Práticas Comuns - Green Spatial Engineering

Jan Tschada

Introdução

A ciência de dados espaciais oferece insights em vários domínios, mas também utiliza recursos computacionais e emite gases de efeito estufa.

Acreditamos honestamente que, se focarmos em ciência de dados espaciais com eficiência de carbono, nos tornamos parte da solução climática. Estamos focando em reduzir os impactos negativos dos cálculos de ciência de dados espaciais no nosso clima, reduzindo as emissões de carbono.

Apresentamos algumas práticas comuns para realizar ciência de dados espaciais de forma eficiente em carbono.

Se você estiver interessado na abordagem comum de engenharia de software verde, deve dar uma olhada na Green Software Foundation | GSF.

Configure seu ambiente de ciência de dados espaciais

Nosso ambiente de ciência de dados espaciais é baseado em Python e pip/conda. Portanto, usamos um módulo Python leve que estima a quantidade de dióxido de carbono produzida pelo fluxo de trabalho computacional da ciência de dados espaciais.

Se você estiver usando conda, pode instalar o CodeCarbon usando o canal condaforge.

Instalando CodeCarbon em um ambiente conda

 

 

 

# author: Jan Tschada
# SPDX-License-Identifer: Apache-2.0
conda install -c codecarbon -c conda-forge codecarbon=2.2

 

 

 

Motivação do CodeCarbon 

Metodologia do CodeCarbon 

Instalação do CodeCarbon 

Métodos

Os fluxos de trabalho da ciência de dados espaciais representam os casos de uso mais comuns que experimentamos durante nosso trabalho diário.

ArcGIS Notebooks fornece uma solução Software-as-a-Service nativa da nuvem otimizada para ciência de dados espaciais. Cada notebook inicia uma instância dedicada executando na nuvem. Assim, podemos facilmente estender esse ambiente Python usando o módulo CodeCarbon.

Tráfego ao Vivo

A cidade de Bonn fornece informações de tráfego em tempo real nas três pontes do Reno e nas principais vias internas da cidade. A cada 5 minutos as informações de tráfego são atualizadas.

Queremos coletar as informações de tráfego em tempo real usando um serviço dedicado feature service executando em nossa instância ArcGIS Online. As emissões estimadas precisam ser pré-processadas e serializadas em um feature service. O rastreador de emissões usa uma API de localização que detecta em qual região da nuvem o processo Python está sendo executado.

Funções utilitárias do ArcGIS para coleta e estimativa

 

 

 

# author: Jan Tschada
# SPDX-License-Identifer: Apache-2.0

from arcgis.gis import GIS
from arcgis.features import FeatureSet, GeoAccessor
from codecarbon import EmissionsTracker
import logging
import pandas as pd
import requests
import sys

def query_traffic():
    url = 'http://stadtplan.bonn.de/geojson?Thema=19584'
    response = requests.get(url)
    response.raise_for_status()
    return response.json()

def prepare_emissions(tracker):
    emissions_data = tracker.final_emissions_data
    emissions_df = pd.DataFrame.from_records([dict(emissions_data.values)])
    emissions_df['timestamp'] = pd.to_datetime(emissions_df['timestamp'])
    emissions_sdf = GeoAccessor.from_xy(emissions_df, 'longitude', 'latitude')
    emissions_sdf.rename(columns={
        'project_name': 'project',
        'emissions_rate': 'rate',
        'energy_consumed': 'consumed',
        'country_name': 'country',
        'country_iso_code': 'iso_code',
        'cloud_provider': 'provider',
        'cloud_region': 'cloud',
        'codecarbon_version': 'codecarbon',
        'python_version': 'python',
        'ram_total_size': 'ram_total',
        'tracking_mode': 'tracking'
    }, inplace=True)
    return emissions_sdf

def prepare_traffic(traffic_featureset):
    traffic_sdf = traffic_featureset.sdf[['strecke_id', 'auswertezeit', 'geschwindigkeit', 'verkehrsstatus', 'SHAPE']]
    traffic_sdf['auswertezeit'] = pd.to_datetime(traffic_sdf['auswertezeit'])
    traffic_sdf['geschwindigkeit'] = pd.to_numeric(traffic_sdf['geschwindigkeit'])
    traffic_sdf.rename(columns={
        'strecke_id': 'seg_id',
        'auswertezeit': 'time',
        'geschwindigkeit': 'speed',
        'verkehrsstatus': 'traffic'
    }, inplace=True)
    return traffic_sdf

def publish_emissions(tracker):
    emissions_sdf = prepare_emissions(tracker)
    return emissions_sdf.spatial.to_featurelayer(title='Carbon Emissions', folder='Stadt Bonn', tags=['Open Data', 'Carbon', 'Digital Twin'])

def publish_traffic(traffic_featureset):
    traffic_sdf = prepare_traffic(traffic_featureset)
    return traffic_sdf.spatial.to_featurelayer(title='Stadt Bonn - Aktuelle Straßenverkehrslage', folder='Stadt Bonn', tags=['Open Data', 'Traffic', 'Digital Twin'])

def add_emissions(emissions_featurelayer, tracker):
    emissions_sdf = prepare_emissions(tracker)
    new_features = emissions_sdf.spatial.to_featureset().features      
    edit_result = emissions_featurelayer.edit_features(adds=new_features)
    return edit_result

def add_traffic(traffic_featurelayer, traffic_featureset):
    traffic_sdf = prepare_traffic(traffic_featureset)
    new_features = traffic_sdf.spatial.to_featureset().features      
    edit_result = traffic_featurelayer.edit_features(adds=new_features)
    return edit_result

def find_emissions(gis):
    portal_items = gis.content.search(query='title:Carbon Emissions AND tags:"Open Data"', item_type='Feature Layer')
    if 0 < len(portal_items):
        first_portal_item = portal_items[0]
        if 0 < len(first_portal_item.layers):
            return first_portal_item.layers[0]
        
    return None

def find_traffic(gis):
    portal_items = gis.content.search(query='title:Stadt Bonn - Aktuelle Straßenverkehrslage AND tags:"Open Data"', item_type='Feature Layer')
    if 0 < len(portal_items):
        first_portal_item = portal_items[0]
        if 0 < len(first_portal_item.layers):
            return first_portal_item.layers[0]
        
    return None

 

 

 

O rastreador de emissões estima as emissões de carbono. O trecho a seguir representa a implementação do tráfego ao vivo. Ele valida se uma camada dedicada feature layer já foi publicada. Caso contrário, um novo serviço feature service hospedando as emissões de carbono e as informações do tráfego é criado.

Trecho para coleta e estimativa

 

 

 

# author: Jan Tschada
# SPDX-License-Identifer: Apache-2.0
gis = GIS("home")

root = logging.getLogger()
root.setLevel(logging.INFO)

handler = logging.StreamHandler(sys.stdout)
handler.setLevel(logging.INFO)
root.addHandler(handler)

tracker = EmissionsTracker(project_name='Open Data Bonn', output_dir='/arcgis/home/')
tracker.start()

traffic_geojson = query_traffic()
traffic_featureset = FeatureSet.from_geojson(traffic_geojson)

traffic_featurelayer = find_traffic(gis)
printf None is traffic_featurelayer:
publish_result = publish_traffic(traffic_featureset)
ologging.info(publish_result)
else:
delete_result = traffic_featurelayer.delete_features(where='1=1')
ologging.info(delete_result)
add_result = add_traffic(traffic_featurelayer, traffic_featureset)
ologging.info(add_result)
emissions = tracker.stop()
emissions_featurelayer = find_emissions(gis)
printf None is emissions_featurelayer:
publish_result = publish_emissions(tracker)
ologging.info(publish_result)
else:
add_result = add_emissions(emissions_featurelayer, tracker)
ologging.info(add_result)
emissions

 

 

 

Resultados

O Painel Green Spatial Engineering mostra os equivalentes estimados de carbono em quilogramas para nossos fluxos de trabalho da ciência de dados espaciais. O primeiro caso de uso representa a pegada de carbono para consultar e coletar as informações do tráfego em tempo real da cidade de Bonn a cada 15 minutos.

Links:

Repositório Green Spatial Engineering