Veelvoorkomende Praktijken - Green Spatial Engineering

Jan Tschada

Inleiding

Spatial data science biedt inzichten in verschillende domeinen, maar gebruikt ook computerbronnen en stoot broeikasgassen uit.

We geloven eerlijk dat als we ons richten op koolstofeffectieve spatial data science, we deel worden van de klimaatoplossing. We richten ons op het verminderen van de negatieve impact van spatial data science berekeningen op ons klimaat door de koolstofuitstoot te verminderen.

We introduceren enkele veelvoorkomende praktijken om spatial data science op een koolstofeffectieve manier uit te voeren.

Als je geïnteresseerd bent in de algemene green software engineering aanpak, moet je eens kijken bij de Green Software Foundation | GSF.

Stel je spatial data science omgeving in

Onze spatial data science omgeving is gebaseerd op Python en pip/conda. Daarom gebruiken we een lichtgewicht Python-module die de hoeveelheid kooldioxide schat die wordt geproduceerd door de spatial data science compute workflow.

Als je conda gebruikt, kun je CodeCarbon installeren via het condaforge-kanaal.

CodeCarbon installeren in een conda-omgeving

 

 

 

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

 

 

 

CodeCarbon Motivatie 

CodeCarbon Methodologie 

CodeCarbon Installatie 

Methoden

De spatial data science workflows vertegenwoordigen de meest voorkomende use cases die we tijdens ons dagelijkse werk hebben ervaren.

ArcGIS Notebooks bieden een cloud-native Software-as-a-Service oplossing geoptimaliseerd voor spatial data science. Elke notebook start een toegewijde instantie die in de cloud draait. Zo kunnen we deze Python-omgeving eenvoudig uitbreiden met de CodeCarbon-module.

Live Traffic

De stad Bonn biedt realtime verkeersinformatie over de drie Rijnbruggen en de belangrijkste binnenstedelijke hoofdwegen van Bonn. Elke 5 minuten wordt de verkeersinformatie bijgewerkt.

We willen de realtime verkeersinformatie verzamelen met behulp van een speciale feature service die draait in onze ArcGIS Online-instantie. De geschatte koolstofuitstoot moet worden voorbewerkt en geserialiseerd in een feature service. De emissietracker gebruikt een locatie-API die detecteert in welke cloudregio het Python-proces draait.

ArcGIS hulpfuncties voor verzamelen en schatten

 

 

 

# 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

 

 

 

De emissietracker schat de koolstofuitstoot. De volgende snippet vertegenwoordigt de live traffic implementatie. Het controleert of er al een speciale feature layer is gepubliceerd. Zo niet, dan wordt er een nieuwe feature service gemaakt die de koolstofuitstoot en verkeersinformatie host.

Snippet voor verzamelen en schatten

 

 

 

# 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)
elser:
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)
elser:
add_result = add_emissions(emissions_featurelayer, tracker)
ologging.info(add_result)
emissions

 

 

 

Resultaten

Het Green Spatial Engineering Dashboard toont de geschatte koolstofequivalenten in kilogrammen voor onze spatial data science workflows. De eerste use case vertegenwoordigt de koolstofvoetafdruk voor het opvragen en verzamelen van realtime verkeersinformatie van de stad Bonn elke 15 minuten.

Links:

Green Spatial Engineering Repository