Übliche Praktiken - Green Spatial Engineering

Jan Tschada

Einführung

Spatial data science bietet Einblicke in verschiedene Bereiche, nutzt jedoch auch Rechenressourcen und verursacht Treibhausgasemissionen.

Wir glauben ehrlich daran, dass wir, wenn wir uns auf kohlenstoffeffiziente spatial data science konzentrieren, Teil der Klimaschutzlösung werden. Wir konzentrieren uns darauf, die negativen Auswirkungen von spatial data science Berechnungen auf unser Klima durch Reduzierung der Kohlenstoffemissionen zu verringern.

Wir stellen einige gängige Praktiken vor, um spatial data science auf kohlenstoffeffiziente Weise durchzuführen.

Wenn Sie an dem üblichen green software engineering Ansatz interessiert sind, sollten Sie sich die Green Software Foundation | GSF ansehen.

Richten Sie Ihre spatial data science Umgebung ein

Unsere spatial data science Umgebung basiert auf Python und pip/conda. Daher verwenden wir ein leichtgewichtiges Python-Modul, das die Menge an Kohlendioxid schätzt, die durch den spatial data science Compute-Workflow erzeugt wird.

Wenn Sie conda verwenden, können Sie CodeCarbon über den conda-forge Kanal installieren.

Installation von CodeCarbon in einer conda-Umgebung

 

 

 

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

 

 

 

CodeCarbon Motivation 

CodeCarbon Methodology 

CodeCarbon Installation 

Methoden

Die spatial data science Workflows repräsentieren die häufigsten Anwendungsfälle, die wir während unserer täglichen Arbeit erlebt haben.

ArcGIS Notebooks bieten eine cloud-native Software-as-a-Service-Lösung , die für spatial data science optimiert ist. Jedes Notebook startet eine dedizierte Instanz, die in der Cloud läuft. So können wir diese Python-Umgebung einfach mit dem CodeCarbon-Modul erweitern.

Live Traffic

Die Stadt Bonn stellt Echtzeit-Verkehrsinformationen zu den drei Rheinbrücken und den wichtigsten innerstädtischen Hauptstraßen von Bonn bereit. Alle 5 Minuten werden die Verkehrsinformationen aktualisiert.

Wir möchten die Echtzeit-Verkehrsinformationen mithilfe eines dedizierten Feature Service sammeln, der in unserer ArcGIS Online Instanz läuft. Die geschätzten Kohlenstoffemissionen müssen vorverarbeitet und in einen Feature Service serialisiert werden. Der Emission Tracker verwendet eine Standort-API, die erkennt, in welcher Cloud-Region der Python-Prozess ausgeführt wird.

ArcGIS Hilfsfunktionen zum Sammeln und Schätzen

 

 

 

# 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

 

 

 

Der Emission Tracker schätzt die Kohlenstoffemissionen. Der folgende Ausschnitt zeigt die Live-Traffic-Implementierung. Er prüft, ob bereits eine dedizierte Feature-Layer veröffentlicht wurde. Falls nicht, wird ein neuer Feature Service erstellt, der die Kohlenstoffemissionen und die Verkehrsinformationen hostet.

Codeausschnitt zum Sammeln und Schätzen

 

 

 

# 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)
    logging.info(publish_result)
ellse:
    delete_result = traffic_featurelayer.delete_features(where='1=1')
    logging.info(delete_result)
    add_result = add_traffic(traffic_featurelayer, traffic_featureset)
    logging.info(add_result)
emissions = tracker.stop()
emissions_featurelayer = find_emissions(gis)
printf None is emissions_featurelayer:
    publish_result = publish_emissions(tracker)
    logging.info(publish_result)
ellse:
    add_result = add_emissions(emissions_featurelayer, tracker)
    logging.info(add_result)
emissions

 

 

 

Ergebnisse

Das Green Spatial Engineering Dashboard zeigt die geschätzten Kohlenstoffäquivalente in Kilogramm für unsere spatial data science Workflows. Der erste Anwendungsfall stellt den CO2-Fußabdruck für das Abfragen und Sammeln der Echtzeit-Verkehrsinformationen der Stadt Bonn alle 15 Minuten dar.

Links:

Green Spatial Engineering Repository