Yapay Zeka ve Karbon: ML Eğitiminin Ayak İzini Ölçme ve Azaltma
Yaklaşık olarak tüketilen GPT-4 eğitimi 50 GWh elektrik, yeterli bir yıl boyunca 4.600'den fazla Avrupa evine elektrik sağlayacak. GPT-3, selefi, o üretti 502 ton CO₂ eşdeğeri eğitim sırasında — her biri yılda 20.000 km yol kat eden 112 benzinli arabaya eşdeğerdir. BLOOM, Fransa'da enerji konusunda eğitilen 176 milyar parametreli açık kaynak modeli karışık, yayınladı 25 ton CO₂eş yaygın kullanım sayesinde nükleer ve yenilenebilir enerji.
Bunlar istatistiksel bir merak değil; hızla gelişen yapısal bir sorunun işaretleri. hızlanma. Üretken yapay zeka, kalıplarla üstel oranlarda büyüyor daha büyük, daha büyük veri kümeleri ve daha büyük eğitim döngüleri sık. 'da yayınlanan bir araştırmaya göre Doğa 2024 yılında ilgili emisyonlar Hiçbir önlem alınmazsa yapay zeka modeli eğitimi 2027 yılına kadar üç katına çıkabilir sistemik verimlilik. IEA, 2026'da yapay zekaya adanmış veri merkezlerinin birçok orta ölçekli Avrupa devletinden daha fazla enerjiye sahip.
Ancak makine öğrenimi ekiplerinin büyük çoğunluğu, hiç ölçüm yapmadan GPU kümeleri üzerinde eğitime başlıyor üretilen emisyonlar. Umursamadıklarından değil, alet eksikliğinden günlük iş akışına, paylaşılan standart metriklere ve ölçüm kültürüne entegre edilmiştir. Serinin bu son makalesinde Yeşil Yazılım Mühendisliği keşfedeceğiz Makine Öğrenimindeki karbon ayak izinin tüm yaşam döngüsü: hassas ölçümden CodeCarbon ve CarbonTracker, budama ve damıtma ile mimari optimizasyona, Üretimde karbona duyarlı eğitim planlamasına ve çıkarım optimizasyonuna kadar.
Ne Öğreneceksiniz
- Temel modeller için gerçek emisyon verileri: GPT-3, GPT-4, Llama 2, BLOOM, PaLM
- CodeCarbon, CarbonTracker, ML CO₂ Etkisi ve Yeşil Algoritmalarını yükleyin ve kullanın
- Güç Verimliliği Açısından GPU'ları Karşılaştırın: FLOPS/Watt cinsinden A100, H100, H200, B200
- Mimari optimizasyon teknikleri: budama, bilginin ayrıştırılması, verimli NAS
- Veri merkezli verimlilik: veri kalitesi ve niceliği, müfredat öğrenimi
- Karbon farkındalığına sahip eğitim: iş yüklerini düşük karbon yoğunluğuna sahip bölgelerde ve zamanlarda planlayın
- Çıkarım optimizasyonu: INT8/INT4 niceleme, ONNX Çalışma Zamanı, TensorRT, vLLM
- Makine öğrenimi modelleri için SCI Puanını hesaplayın ve Yeşil Yapay Zeka Lider Tablosu oluşturun
- Tam örnek olay incelemesi: Gerçek bir NLP modelinde emisyonların %60 azaltılması
- Kuruluşlarda Yeşil Yapay Zekanın benimsenmesine yönelik pratik yol haritası
Yeşil Yazılım Mühendisliği Serisi — 10 Makale
| # | Öğe | Ana tema |
|---|---|---|
| 1 | Yeşil Yazılımın Temel İlkeleri | GSF, SCI, 8 temel prensip |
| 2 | CodeCarbon ile Karbon Ayak İzinizi Ölçme | CodeCarbon, CCF, CI/CD entegrasyonu |
| 3 | Climatiq API ve Karbon Muhasebesi | REST API, LCA, Kapsam 1-2-3 |
| 4 | Karbon Bilinçli SDK ve Zamansal/Uzamsal Geçiş | İş yüklerini yeşil enerjiye kaydırın |
| 5 | Kapsam Modelleme ve SCI Uygulaması | Pratik SCI hesaplaması, Etki Çerçevesi |
| 6 | GreenOps: Sürdürülebilirlik için FinOps | Bulut maliyeti ve karbon, Kubernetes |
| 7 | Yazılım Ardışık Düzeninde Kapsam 3 | Dolaylı emisyonlar, dijital tedarik zinciri |
| 8 | ESG, CSRD ve Dijital Raporlama | Avrupa uyumluluğu, ESRS E1, açıklama |
| 9 | Sürdürülebilir Mimari Desenler | Depolama, önbelleğe alma, karbona duyarlı toplu iş |
| 10 | Yapay Zeka ve Karbon: ML Eğitim Ayak İzi | Bu makale — serinin son makalesi |
Temel Modellerin Gerçek Karbon Ayak İzi
Sorunun boyutunu anlamak somut veriler gerektirir. Stanford araştırmacıları Hugging Face ve MLCommons büyük şirketler için emisyon ölçümlerini yayınlamaya başladı Dilsel modeller. Aşağıdaki tablo, mevcut verileri bir araya getirerek şunları göz önünde bulundurmaktadır: Pek çok şirket, özellikle de OpenAI, bu bilgiyi hâlâ açıklamıyor.
Eğitim Sırasında Temel Modellerin CO₂eş emisyonları
| Modeli | Parametreler | Enerji (MWh) | CO₂eşd (t) | Bölge/Karma | Kaynak |
|---|---|---|---|---|---|
| GPT-3 | 175B | 1.287 | 502 | ABD (orta karışım) | Patterson ve diğerleri. 2021 |
| GPT-4 | ~1,8T (tahmini) | ~50.000 | ~14.000 | ABD (tahmini) | Bağımsız tahminler 2023 |
| ÇİÇEK AÇMAK | 176B | 433 | 25 | Fransa (nükleer+yenilenebilir) | Luccioni ve ark. 2022 |
| Lama 2 (70B) | 70B | ~700 | 539 | ABD/Azure | Meta FW 2023 |
| PALM | 540B | ~3.400 | ~507 | ABD (TPU v4) | Chowdhery ve ark. 2022 |
| Mistral 7B | 7B | ~35 | ~12 | Avrupa (karışık) | Mistral FW 2023 |
| Şahin 180B | 180B | ~600 | ~117 | BAE (karışık) | TSEV 2023 |
| Mücevher 7B | 7B | ~32 | ~6 | ABD/TPU (RE100) | Google DeepMind 2024 |
Bu veriler üç temel modeli ortaya koyuyor. İlki coğrafi boşluk: Fransa'da çoğunlukla nükleer enerjiyle eğitilen BLOOM, 20 kat daha az emisyon saldı Lama 2'nin aynı büyüklükte. İkincisi iseölçek etkisi: 7B parametresinden 176B parametresine geçiş yalnızca 25 kat daha fazla emisyon anlamına gelmiyor — dağıtılmış iletişim maliyetleri ve eğitim süresi doğrusal olmayan bir şekilde artar. Üçüncüsü ise şeffaflık açığı: Çoğu şirket bunu yapmıyor bu verileri hala yayınlıyor, bu da karşılaştırmayı zorlaştırıyor ve kıyaslamayı imkansız hale getiriyor bağımsız ölçümler olmadan.
Çıkarım Paradoksu: Eğitimden Daha Büyük
Mantığın tersine, kümülatif emisyonlarçıkarım çoğu zaman aşarlar bir modelin yaşam döngüsündeki eğitimler. Milyonların olduğu ChatGPT gibi bir model Günlük talep sayısı, bir aylık üretimde daha fazla enerji tüketebilir orijinal eğitimin tamamı. Patterson ve diğerleri. GPT-3'ün ölçekteki çıkarımını tahmin edin ChatGPT yaklaşık olarak üretir Yılda 11.000 ton CO₂eq. Bu odağı eğitim optimizasyonundan çıkarım optimizasyonuna kaydırır. Toplam çevresel etkiyi azaltmak birincil önceliktir.
Somutlaştırılmış Emisyonlar ve Tam Yaşam Döngüsü
Yapay zeka karbon ayak izi analizi, tüketilen enerjiyle sınırlı olamaz. eğitim. somutlaşmış emisyonlar donanımın yaydığı CO₂ GPU'lar, sunucular, soğutma ağları ve altyapı üretmek; bunlar bir önemli bir paya sahip. Tek bir H100 çipi üretmek yaklaşık olarak emisyon yayar 150 kgCO₂eşd, ve 1.000 GPU kümesi, yalnızca donanım için yaklaşık 150 tonluk somutlaştırılmış emisyona yol açar, tek bir eğitim işine bile başlamadan önce.
# Formula Carbon Footprint Completo per ML
# Basato su Luccioni et al. "Counting Carbon" (2023)
Total_CO2eq = Training_CO2eq + Inference_CO2eq + Embodied_CO2eq
Training_CO2eq = Energy_training (kWh) x Carbon_Intensity (kgCO2eq/kWh) x PUE
Inference_CO2eq = (Requests x Latency x GPU_Power / 3600000) x Carbon_Intensity x PUE
Embodied_CO2eq = (Hardware_Production_CO2eq / Lifespan_hours) x Training_hours
# Esempio: modello NLP medio (BERT-Large fine-tuning su task classificazione)
Energy_training = 120 kWh # 4x A100, 6 ore
Carbon_Intensity = 0.420 kg/kWh # mix europeo medio
PUE = 1.3 # data center tipico
Training_CO2eq = 120 x 0.420 x 1.3 = 65.5 kgCO2eq
# Inferenza: 10M richieste/mese, 50ms each, 1x A100 (300W)
Inference_monthly = (10_000_000 x 0.05 x 300 / 3_600_000) x 0.420 x 1.3
= 41.7 kWh x 0.420 x 1.3 = 22.7 kgCO2eq/mese
# Dopo 12 mesi: 272 kgCO2eq inferenza vs 65 kgCO2eq training
# L'inferenza domina del 77% nel ciclo di vita annualeÖlçüm Araçları: CodeCarbon'dan Yeşil Algoritmalara
Makine öğrenimi emisyonlarını ölçmek, makine öğrenimi iş yükleri için özel olarak tasarlanmış araçlar gerektirir eğitim ve çıkarım. Dört araç alana hakimdir: CodeCarbon, CarbonTracker, ML CO₂ Etki Hesaplayıcısı ve Yeşil Algoritmalar. Herkesin belirli güçlü yönleri vardır ve optimum kullanım durumları.
CodeCarbon: Python Koduna Doğrudan Entegrasyon
CodeCarbon, emisyonları ölçmek için en popüler araçtır. Makine öğrenimi eğitimi. En yaygın çerçevelerle entegrasyonu (PyTorch, TensorFlow, Hugging Face Transformers) onu çoğu takım için doğal bir seçim haline getiriyor.
# pip install codecarbon
from codecarbon import EmissionsTracker, track_emissions
import torch
from transformers import Trainer, TrainingArguments
# Metodo 1: Context manager
tracker = EmissionsTracker(
project_name="bert-finetuning-sentiment",
country_iso_code="ITA",
region="lombardy",
cloud_provider="gcp",
cloud_region="europe-west8",
output_dir="./carbon_reports",
output_file="emissions.csv",
log_level="warning",
save_to_file=True,
tracking_mode="machine", # Legge sensori hardware reali
measure_power_secs=15 # Campionamento ogni 15 secondi
)
tracker.start()
try:
# Il tuo training loop qui
model = train_model(dataset, epochs=10)
finally:
emissions = tracker.stop()
print(f"Training completato: {emissions:.4f} kgCO2eq")
print(f"Equivalente a: {emissions * 2.4:.2f} km in auto")
# Metodo 2: Decorator per funzioni singole
@track_emissions(
project_name="bert-inference",
country_iso_code="ITA",
save_to_file=True
)
def run_inference_batch(model, dataloader):
results = []
with torch.no_grad():
for batch in dataloader:
outputs = model(**batch)
results.extend(outputs.logits.argmax(-1).tolist())
return results
# Metodo 3: Integrazione con Hugging Face Trainer
from codecarbon import EmissionsTracker
class CarbonAwareTrainer(Trainer):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.carbon_tracker = EmissionsTracker(
project_name=f"hf-training-{self.args.run_name}",
country_iso_code="ITA",
save_to_file=True
)
def train(self, *args, **kwargs):
self.carbon_tracker.start()
result = super().train(*args, **kwargs)
emissions = self.carbon_tracker.stop()
self.log({"carbon_emissions_kgCO2eq": emissions})
return resultCarbonTracker: Projeksiyonlar ve Bütçeleme
Kopenhag Üniversitesi tarafından geliştirilen CarbonTracker kapasitesiyle öne çıkıyor arasında proje toplam tüketimi İlk eğitim dönemlerine göre. Bu işlevsellik çok değerlidir: karbon maliyetini tahmin etmenize olanak tanır günler veya haftalar süren eğitimi tamamlamadan önce.
# pip install carbontracker
from carbontracker.tracker import CarbonTracker
from carbontracker import parser
# Configurazione con proiezione
tracker = CarbonTracker(
epochs=100,
epochs_before_pred=5, # Dopo 5 epoche, proietta le 95 rimanenti
monitor_epochs=10, # Monitora ogni 10 epoche
log_dir="./carbontracker_logs",
update_interval=10,
verbose=2,
components="gpu",
ignore_errors=False
)
for epoch in range(100):
tracker.epoch_start()
# Training epoch
for batch in train_loader:
optimizer.zero_grad()
outputs = model(batch['input_ids'], batch['attention_mask'])
loss = criterion(outputs, batch['labels'])
loss.backward()
optimizer.step()
tracker.epoch_end()
tracker.stop()
# Dopo 5 epoche, CarbonTracker stampa proiezioni come:
# "Predicting training to use 2.34 kWh and emit 0.98 kgCO2eq"
# "Total: actual consumption: 0.12 kWh, 0.05 kgCO2eq (after 5 epochs)"
# Parsing dei log per analisi
logs = parser.parse_all_logs(log_dir="./carbontracker_logs")
for log in logs:
print(f"Energia: {log['actual']['energy (kWh)']:.3f} kWh")
print(f"CO2: {log['actual']['co2eq (g)']:.1f} gCO2eq")
print(f"Proiezione totale: {log['pred']['co2eq (g)']:.1f} gCO2eq")ML CO₂ Etki Hesaplayıcısı ve Yeşil Algoritmalar
ML CO₂ Etki Hesaplayıcı (mlco2.github.io) bir web aracıdır Donanıma, bulut sağlayıcısına, bölgeye ve süreye göre emisyonları tahmin eden. gerektirmez Kodla entegrasyon: Hızlı eğitim öncesi tahminler veya dokümantasyon için idealdir eğitim sorunları zaten tamamlandı. AWS, GCP, Azure ve 15'ten fazla bölgeyi destekler.
Yeşil Algoritmalar (green-algorithms.org), Üniversite tarafından geliştirildi Cambridge Enerji Tüketim Modelleriyle Daha Bilimsel Bir Yaklaşım Sunuyor gerçek veri merkezi verileriyle doğrulanmıştır. HPC (Yüksek Performanslı Hesaplama) için hesaplamaları destekler, GPU kümeleri ve biyoenformatik iş akışları.
ML Karbon Ölçüm Araçlarının Karşılaştırılması
| Enstrüman | Tip | Parçalılık | Entegrasyon | Güç noktası | Sınırlama |
|---|---|---|---|---|---|
| KodKarbon | Python kütüphanesi | İşlev/iş | PyTorch, T.F., H.F. | Gerçek donanım ölçümü | Yalnızca Python, genel gider <%1 |
| Karbon Takipçisi | Python kütüphanesi | Çağ için | Derin öğrenme döngüleri | Erken duraklı gösterimler | Çağa dayalı eğitim gerektirir |
| ML CO₂ Etkisi | Web araçları | İş seviyesi | Yok (web formu) | Sıfır kurulum, hızlı tahmin | Yalnızca tahmin, ölçüm değil |
| Yeşil Algoritmalar | Web araçları | İş seviyesi | Yok (web formu) | Bilimsel olarak doğrulanmış modeller | Gerçek zamanlı değil |
| Deney Etkisi İzleyici | Python kütüphanesi | Deney | Makine öğrenimi denemeleri | Otomatik MLflow günlüğü | En Az Bakım Yapılan (2021) |
Kontrol Paneli ve Otomatik Raporlama
Ölçüm yalnızca veriler toplandığında, görselleştirildiğinde ve ölçüm yapmak için kullanıldığında değerlidir. kararlar. Etkili bir model, CodeCarbon'u MLflow ile entegre ederek bir Performans ölçümleriyle birlikte emisyonları kaydeden otomatik takip sistemi.
import mlflow
from codecarbon import EmissionsTracker
import pandas as pd
from pathlib import Path
class GreenMLExperiment:
"""Wrapper che traccia automaticamente emissioni + performance ML."""
def __init__(self, experiment_name: str, country_code: str = "ITA"):
self.experiment_name = experiment_name
self.country_code = country_code
mlflow.set_experiment(experiment_name)
def run(self, model_fn, train_fn, eval_fn, params: dict):
with mlflow.start_run():
mlflow.log_params(params)
# Avvia tracker emissioni
tracker = EmissionsTracker(
project_name=self.experiment_name,
country_iso_code=self.country_code,
save_to_file=True,
output_dir="./emissions_logs"
)
tracker.start()
model = model_fn(**params)
train_metrics = train_fn(model)
emissions_kg = tracker.stop()
# Metriche performance
eval_metrics = eval_fn(model)
# Log tutto su MLflow
mlflow.log_metric("train_loss", train_metrics["loss"])
mlflow.log_metric("eval_accuracy", eval_metrics["accuracy"])
mlflow.log_metric("emissions_kgCO2eq", emissions_kg)
mlflow.log_metric("emissions_grams", emissions_kg * 1000)
mlflow.log_metric(
"accuracy_per_kgCO2",
eval_metrics["accuracy"] / max(emissions_kg, 0.001)
)
# Log artefatti
mlflow.log_artifacts("./emissions_logs")
return {
"model": model,
"emissions": emissions_kg,
"metrics": eval_metrics,
"efficiency_ratio": eval_metrics["accuracy"] / emissions_kg
}
# Utilizzo
experiment = GreenMLExperiment("bert-sentiment-v2", country_code="ITA")
result = experiment.run(
model_fn=create_bert_model,
train_fn=train_epoch,
eval_fn=evaluate_model,
params={"lr": 2e-5, "batch_size": 32, "epochs": 5}
)GPU Enerji Verimliliği: Watt başına FLOPS
Donanım seçimi karbon ayak izi açısından en etkili karardır eğitimin. Yeni nesil GPU'lar önemli ölçüde daha yüksek enerji verimliliği sunuyor öncekilerle karşılaştırıldığında A100 ile H200'de eğitim arasındaki fark şu anlama gelebilir: aynı iş yükü için emisyonlarda %40-60 azalma.
ML Eğitimi için GPU Karşılaştırması: Enerji Verimliliği (2025)
| GPU | Yıl | TDP (K) | FP16 TFLOPS | FLOPS/Watt | HBM belleği | CO₂ Bağıl |
|---|---|---|---|---|---|---|
| A100SXM4 | 2020 | 400W | 312 | 780 GLOPS/W | 80GB HBM2e | Temel (1,0x) |
| H100SXM5 | 2022 | 700W | 989 | 1,413 GFLOP/W | 80 GB HBM3 | 0,56x (-%44) |
| H200SXM5 | 2024 | 700W | 989 | 1,413 GFLOP/W | 141 GB HBM3e | 0,56x (-%44) |
| B200SXM6 | 2025 | 1.000W | 4.500 | 4.500 GFLOPS/W | 192 GB HBM3e | 0,17x (-%83) |
| RTX 4090 | 2022 | 450W | 165 | 367 GLOPS/W | 24 GB GDDR6X | 2,12x (+%112) |
| AMD MI300X | 2024 | 750W | 1.307 | 1,743 GFLOP/W | 192 GB HBM3 | 0,45x (-%55) |
H100 ve H200 yaklaşık olarak şunları sunar: Emisyonlarda %44 azalma saygı FP8'li Transformer Engine ve mimari sayesinde aynı iş yükü için A100'e NVLink optimize edildi. B200, 4,5 PFLOPS ve FP16 ile nesiller boyu bir sıçramayı temsil ediyor yerel FP4 desteği, azalmayı %83'e getiriyor.
Karma Hassas Eğitim: FP16 ve BF16
Buradaki eğitim karışık hassasiyet (Hesaplamalar için FP16 veya BF16, hesaplamalar için FP32 model parametreleri) enerji tüketimini eğitime kıyasla %30-50 oranında azaltır Model kalitesinde önemli bir bozulma olmadan tam FP32.
import torch
from torch.cuda.amp import autocast, GradScaler
# Training con AMP (Automatic Mixed Precision)
scaler = GradScaler()
def train_epoch_amp(model, dataloader, optimizer, device):
model.train()
total_loss = 0.0
for batch in dataloader:
input_ids = batch['input_ids'].to(device)
labels = batch['labels'].to(device)
optimizer.zero_grad()
# Forward pass in FP16/BF16
with autocast(dtype=torch.bfloat16): # BF16 su A100/H100
outputs = model(input_ids=input_ids, labels=labels)
loss = outputs.loss
# Backward pass con gradient scaling
scaler.scale(loss).backward()
scaler.unscale_(optimizer)
# Gradient clipping per stabilità
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
scaler.step(optimizer)
scaler.update()
total_loss += loss.item()
return total_loss / len(dataloader)
# Con Hugging Face: basta un flag
from transformers import TrainingArguments
training_args = TrainingArguments(
output_dir="./results",
bf16=True, # BF16 per A100/H100 (preferibile a FP16)
fp16=False,
dataloader_num_workers=4,
per_device_train_batch_size=32,
gradient_accumulation_steps=4, # Simula batch da 128
gradient_checkpointing=True, # -40% memoria VRAM, +20% tempo
# Risparmio energetico: meno transfer GPU-CPU
dataloader_pin_memory=True
)
# Benchmark: BERT-Large su 1M esempi
# FP32: 6.2 ore, 148 kWh, 62 kgCO2eq (ITA)
# BF16: 3.4 ore, 81 kWh, 34 kgCO2eq (ITA) -> -45% emissioniMimari Optimizasyon: Budama, Damıtma ve NAS
Mimari optimizasyon teknikleri model karmaşıklığını azaltır, daha hızlı eğitime, daha verimli çıkarımlara ve karbon ayak izine yol açar genel olarak azaltıldı. Üç ana teknik budama ve bilginin damıtılmasıdır. ve etkili Sinir Mimarisi Araması.
Model Budama: Artıklığı Kaldır
Budama, marjinal olarak katkıda bulunan model parametrelerini veya yapılarını ortadan kaldırır doğruluk için. İki ana yaklaşım vardır: yapılandırılmamış budama (bireysel ağırlıklar) e yapılandırılmış budama (dikkat kafaları, nöronlar, katmanlar). Yapılandırılmamış olduğundan gerçek donanım verimliliği için ikincisi tercih edilir. budamanın gerçekten fayda sağlaması için seyrek desteğe sahip donanım gerekir.
import torch
import torch.nn.utils.prune as prune
from transformers import BertForSequenceClassification
import numpy as np
def structured_pruning_bert(model, pruning_ratio=0.3):
"""
Pruning strutturato delle teste di attenzione BERT.
Rimuove le teste meno importanti basandosi sulla norma L1.
"""
pruned_heads = {}
for layer_idx, layer in enumerate(model.bert.encoder.layer):
# Calcola importanza di ogni testa (norma L1 dei pesi query)
attention = layer.attention.self
num_heads = attention.num_attention_heads
head_size = attention.attention_head_size
query_weights = attention.query.weight.data # shape: [hidden, hidden]
query_reshaped = query_weights.view(num_heads, head_size, -1)
head_importance = query_reshaped.abs().mean(dim=[1, 2])
# Seleziona le teste da prunable
num_heads_to_prune = int(num_heads * pruning_ratio)
heads_to_prune = head_importance.argsort()[:num_heads_to_prune].tolist()
if heads_to_prune:
pruned_heads[layer_idx] = set(heads_to_prune)
model.prune_heads(pruned_heads)
return model, pruned_heads
# Unstructured pruning con PyTorch
def magnitude_pruning(model, sparsity=0.5):
"""Pruning per magnitudine su tutti i layer Linear."""
parameters_to_prune = [
(module, 'weight')
for module in model.modules()
if isinstance(module, torch.nn.Linear)
]
prune.global_unstructured(
parameters_to_prune,
pruning_method=prune.L1Unstructured,
amount=sparsity
)
# Rende il pruning permanente
for module, param in parameters_to_prune:
prune.remove(module, param)
return model
# Risultati tipici su BERT-Base (110M parametri):
# Pruning 30% teste: -28% latenza inferenza, -1.2% accuracy
# Pruning 50% pesi (magnitude): -45% dimensione, -0.8% accuracy
# Emissioni inferenza: -30% con structured pruningBilginin Damıtılması: Büyük Bilgiye Sahip Küçük Modeller
Bilginin damıtılması, bilgiyi büyük bir modelden (öğretmen) bir büyük modele aktarır. küçük (öğrenci). Örneğin DistilBERT, BERT-Base parametrelerinin %40'ına sahiptir ancak GLUE kıyaslamasında performansının %97'sini koruyor. Eğitim emisyonları DistilBERT %60 daha düşük, çıkarımlı olanlar ise %40-50.
import torch
import torch.nn as nn
import torch.nn.functional as F
class DistillationLoss(nn.Module):
"""
Loss combinata per knowledge distillation:
L = alpha * L_CE(student, labels) + (1-alpha) * L_KL(student, teacher)
"""
def __init__(self, alpha=0.5, temperature=4.0):
super().__init__()
self.alpha = alpha
self.temperature = temperature
self.ce_loss = nn.CrossEntropyLoss()
def forward(self, student_logits, teacher_logits, labels):
# Loss classificazione standard
loss_ce = self.ce_loss(student_logits, labels)
# Loss distillazione (KL divergence con temperature scaling)
student_soft = F.log_softmax(student_logits / self.temperature, dim=-1)
teacher_soft = F.softmax(teacher_logits / self.temperature, dim=-1)
loss_kl = F.kl_div(student_soft, teacher_soft, reduction='batchmean')
loss_kl *= self.temperature ** 2 # Scala per compensare la temperature
return self.alpha * loss_ce + (1 - self.alpha) * loss_kl
def distill_model(teacher_model, student_model, train_loader,
optimizer, device, epochs=5):
"""Training loop completo per knowledge distillation."""
distill_loss = DistillationLoss(alpha=0.5, temperature=4.0)
teacher_model.eval()
for epoch in range(epochs):
student_model.train()
total_loss = 0.0
for batch in train_loader:
input_ids = batch['input_ids'].to(device)
attention_mask = batch['attention_mask'].to(device)
labels = batch['labels'].to(device)
# Teacher inference (no gradient)
with torch.no_grad():
teacher_outputs = teacher_model(
input_ids=input_ids,
attention_mask=attention_mask
)
# Student forward pass
student_outputs = student_model(
input_ids=input_ids,
attention_mask=attention_mask
)
loss = distill_loss(
student_outputs.logits,
teacher_outputs.logits,
labels
)
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_loss += loss.item()
print(f"Epoch {epoch+1}: Loss = {total_loss/len(train_loader):.4f}")
# Caso d'uso tipico: distillare BERT-Large (340M) -> BERT-Tiny (14M)
# Training: 8h vs 2.5h -> -69% tempo
# Emissioni training: -71%
# Accuracy GLUE: 84.6 vs 87.2 -> -3% accettabile per la maggior parte dei taskVerimli Sinir Mimarisi Araması
Geleneksel NAS, ironik bir şekilde, enerji açısından en yoğun süreçlerden biridir ML'de: En uygun mimariyi aramak binlerce tam eğitim oturumu gerektirebilir. Verimli NAS tek seferlik NAS, ağırlık paylaşımı gibi teknikleri kullanır ve arama maliyetlerini %99 oranında azaltmak için tahmine dayalı arama.
# Esempio con Once-for-All Network (OFA) da MIT
# OFA addestra una volta una supernetwork, poi campiona subnetwork efficienti
# Installazione: pip install ofa
from ofa.model_zoo import ofa_net
# Carica supernetwork pre-addestrata (una volta sola)
ofa_network = ofa_net('ofa_resnet50', pretrained=True)
# Campiona subnetwork che rispettano constraint energetici
# senza riaddestrare (zero-cost NAS)
def find_efficient_subnet(ofa_net, target_flops: float = 200e6):
"""
Cerca una subnetwork con FLOPs < target_flops
usando evolutionary search con predictor di accuracy.
"""
from ofa.nas.search_algorithm import EvolutionFinder
finder = EvolutionFinder(
constraint_type='flops',
efficiency_constraint=target_flops,
efficiency_predictor=ofa_net.flops_counter,
accuracy_predictor=None, # Usa validazione reale
population_size=100,
max_time_budget=500,
parent_ratio=0.25,
mutation_ratio=0.5
)
best_valset_acc, best_info = finder.run_evolution_search()
return best_info['net_config']
# Risultato tipico:
# Supernetwork ResNet-50: 4.1 GFLOPs, 25.6M param
# Subnetwork trovata: 200 MFLOPs, 6.2M param
# Accuracy ImageNet: 77.8% vs 79.2% (- 1.4%, - 95% emissioni inferenza)Veri Odaklı Verimlilik: Kalite ve Miktar
Daha yüksek kaliteli bir veri seti aynı doğruluğu elde etmenize olanak tanır daha az eğitim dönemi ve daha az veri ile. Bu ilkelerden biridir veri merkezli yapay zeka Andrew Ng tarafından desteklendi: modeli artırmak yerine veya ham veriler, mevcut verilerin kalitesini artırır.
Müfredat Öğrenimi: Doğru Sırada Eğitim
Öğrenme müfredatı, eğitim örneklerini zorluğu artırarak sıralar, basit kavramlarla başlayıp karmaşık kavramlara geçen bir öğretmen gibi. Bu yaklaşım daha hızlı ve daha az toplam dönemle yakınsayarak, standart kıyaslamalara göre karbon ayak izi %20-35'tir.
import numpy as np
from torch.utils.data import DataLoader, SubsetRandomSampler
from sklearn.metrics import pairwise_distances
class CurriculumScheduler:
"""
Curriculum Learning: ordina il dataset dalla difficolta' crescente.
La difficolta' e' calcolata come distanza dalla media della classe.
"""
def __init__(self, dataset, difficulty_metric='loss', num_stages=4):
self.dataset = dataset
self.num_stages = num_stages
self.difficulty_scores = None
def compute_difficulty(self, model, device):
"""Calcola difficolta' come loss su un modello pre-addestrato leggero."""
model.eval()
scores = []
loader = DataLoader(self.dataset, batch_size=256, shuffle=False)
criterion = nn.CrossEntropyLoss(reduction='none')
with torch.no_grad():
for batch in loader:
input_ids = batch['input_ids'].to(device)
labels = batch['labels'].to(device)
outputs = model(input_ids=input_ids)
losses = criterion(outputs.logits, labels)
scores.extend(losses.cpu().numpy())
self.difficulty_scores = np.array(scores)
return self.difficulty_scores
def get_stage_indices(self, stage: int) -> list:
"""Ritorna gli indici degli esempi per lo stage corrente."""
if self.difficulty_scores is None:
raise ValueError("Esegui compute_difficulty prima.")
# Divide il dataset in quartili di difficolta'
sorted_indices = np.argsort(self.difficulty_scores)
stage_size = len(sorted_indices) // self.num_stages
# Stage 0: esempi più' facili, Stage N: tutti gli esempi
max_idx = stage_size * (stage + 1)
return sorted_indices[:max_idx].tolist()
def curriculum_training(model, dataset, optimizer, device, total_epochs=20):
"""Training con curriculum progressivo."""
scheduler = CurriculumScheduler(dataset, num_stages=4)
# Usa un modello leggero per calcolare la difficolta'
tiny_model = load_tiny_model().to(device)
difficulty = scheduler.compute_difficulty(tiny_model, device)
for epoch in range(total_epochs):
# Progressione lineare: da 25% a 100% del dataset
stage = min(3, int(epoch / total_epochs * 4))
indices = scheduler.get_stage_indices(stage)
sampler = SubsetRandomSampler(indices)
loader = DataLoader(dataset, batch_size=32, sampler=sampler)
print(f"Epoch {epoch}: usando {len(indices)}/{len(dataset)} esempi")
train_one_epoch(model, loader, optimizer, device)
# Risultati tipici:
# Training standard BERT-Base: 10 epoche per convergenza
# Training con curriculum: 6.5 epoche -> -35% emissioniAktif Öğrenme: En Bilgilendirici Verileri Seçin
Aktif öğrenme, etiketlenecek en bilgilendirici örnekleri yinelemeli olarak seçer, tüm veri kümesini kullanmak yerine. %10-20'lik bir ek açıklama bütçesi ile bu hedefe ulaşılır. tam veri eğitiminin doğruluğunun genellikle %90-95'i, orantılı olarak azalır karbon ayak izi.
from sklearn.cluster import KMeans
import torch.nn.functional as F
class ActiveLearningSelector:
"""Seleziona esempi con massima incertezza (uncertainty sampling)."""
def __init__(self, model, unlabeled_pool, strategy='entropy'):
self.model = model
self.unlabeled_pool = unlabeled_pool
self.strategy = strategy
def compute_uncertainty(self, batch_size=128) -> np.ndarray:
"""Calcola incertezza del modello su ogni esempio non etichettato."""
self.model.eval()
uncertainties = []
loader = DataLoader(self.unlabeled_pool, batch_size=batch_size)
with torch.no_grad():
for batch in loader:
logits = self.model(batch['input_ids']).logits
probs = F.softmax(logits, dim=-1)
if self.strategy == 'entropy':
# Entropia: massima quando la distribuzione e' uniforme
entropy = -(probs * probs.log()).sum(dim=-1)
uncertainties.extend(entropy.cpu().numpy())
elif self.strategy == 'margin':
# Margin: minimo quando le top-2 prob sono simili
top2 = probs.topk(2, dim=-1).values
margin = top2[:, 0] - top2[:, 1]
uncertainties.extend((1 - margin).cpu().numpy())
return np.array(uncertainties)
def select_examples(self, n_select: int) -> list:
"""Seleziona i n_select esempi più' incerti."""
uncertainties = self.compute_uncertainty()
top_indices = np.argsort(uncertainties)[-n_select:]
return top_indices.tolist()
# Workflow Active Learning
def active_learning_loop(
model, labeled_data, unlabeled_pool,
annotation_budget=500, iterations=5
):
per_iteration = annotation_budget // iterations
for iteration in range(iterations):
# Seleziona esempi
selector = ActiveLearningSelector(model, unlabeled_pool)
selected_idx = selector.select_examples(per_iteration)
# Simula annotazione (in produzione: etichettatura umana)
new_labeled = [unlabeled_pool[i] for i in selected_idx]
labeled_data.extend(new_labeled)
# Riaddestra su dati aggiornati
model = fine_tune(model, labeled_data)
acc = evaluate(model)
print(f"Iter {iteration}: {len(labeled_data)} esempi, acc={acc:.3f}")
return model
# Con 500 esempi attivi vs 5000 casuali: stesso livello di accuracy
# Risparmio training: -90% dati -> -85% emissioniKarbon Farkındalık Eğitimi: Eğitimi Akıllıca Planlayın
Karbon farkındalığına sahip eğitim, Carbon Aware SDK ilkelerinin uygulanmasıdır ML dünyasına: mühendis yapılandırmayı bitirdikten sonra eğitime başlamak yerine Deneyde işi en düşük zamanda ve bölgede planlıyoruz. elektrik karışımının karbon yoğunluğu.
Zaman Kayması: Yeşil Eğitim Ne Zaman
Enerjinin karbon yoğunluğu gün boyunca büyük ölçüde değişir ve hafta, yenilenebilir enerji kaynaklarının mevcudiyetine bağlı olarak. İtalya'da, en yeşil saatlerle (yazın 11:00-15:00) en yeşil saat arasındaki fark kömür (kışın 19:00-22:00) 200-300 gCO₂eq/kWh olabilir.
import asyncio
import httpx
from datetime import datetime, timedelta
from typing import Optional
import subprocess
ELECTRICITY_MAPS_TOKEN = "YOUR_TOKEN" # electricitymaps.com/api
async def get_carbon_intensity(zone: str = "IT") -> float:
"""Recupera l'intensità' carbonica attuale dalla Electricity Maps API."""
async with httpx.AsyncClient() as client:
resp = await client.get(
f"https://api.electricitymap.org/v3/carbon-intensity/latest",
params={"zone": zone},
headers={"auth-token": ELECTRICITY_MAPS_TOKEN}
)
data = resp.json()
return data["carbonIntensity"] # gCO2eq/kWh
async def get_forecast(zone: str = "IT", hours: int = 24) -> list[dict]:
"""Recupera le previsioni di intensità' carbonica per le prossime ore."""
async with httpx.AsyncClient() as client:
resp = await client.get(
f"https://api.electricitymap.org/v3/carbon-intensity/forecast",
params={"zone": zone},
headers={"auth-token": ELECTRICITY_MAPS_TOKEN}
)
data = resp.json()
return data["forecast"][:hours]
async def find_optimal_training_window(
job_duration_hours: float,
zone: str = "IT",
max_delay_hours: int = 24
) -> Optional[datetime]:
"""
Trova la finestra temporale ottimale per un training job.
Cerca il window di 'job_duration_hours' con intensità' media minima.
"""
forecast = await get_forecast(zone, hours=max_delay_hours + int(job_duration_hours))
if not forecast:
return None
window_size = max(1, int(job_duration_hours))
best_start = None
best_avg_intensity = float('inf')
for i in range(len(forecast) - window_size + 1):
window = forecast[i:i + window_size]
avg_intensity = sum(h['carbonIntensity'] for h in window) / len(window)
if avg_intensity < best_avg_intensity:
best_avg_intensity = avg_intensity
best_start = datetime.fromisoformat(forecast[i]['datetime'])
print(f"Finestra ottimale: {best_start}")
print(f"Intensità' media: {best_avg_intensity:.1f} gCO2eq/kWh")
return best_start
async def carbon_aware_submit(
training_command: str,
job_duration_hours: float = 6.0,
threshold_gco2_kwh: float = 200.0,
zone: str = "IT"
):
"""
Submette un training job solo quando l'intensità' e' sotto soglia,
altrimenti aspetta la finestra ottimale.
"""
current = await get_carbon_intensity(zone)
if current <= threshold_gco2_kwh:
print(f"Intensità' attuale {current} gCO2/kWh: avvio immediato")
subprocess.Popen(training_command.split())
return
print(f"Intensità' troppo alta ({current} gCO2/kWh > {threshold_gco2_kwh})")
optimal_window = await find_optimal_training_window(
job_duration_hours, zone
)
if optimal_window:
wait_seconds = (optimal_window - datetime.now()).total_seconds()
print(f"Scheduling per {optimal_window} (attesa: {wait_seconds/3600:.1f}h)")
await asyncio.sleep(max(0, wait_seconds))
subprocess.Popen(training_command.split())
# Utilizzo
asyncio.run(carbon_aware_submit(
training_command="python train_bert.py --epochs 10",
job_duration_hours=8.0,
threshold_gco2_kwh=150.0,
zone="IT"
))Uzamsal Değişim: En Yeşil Bulut Bölgesini Seçin
Farklı bulut sağlayıcıları, çok farklı enerji karışımlarına sahip bölgeler sunar. Eğitim bölgesini seçmek emisyonları %70-90 oranında azaltabilir rastgele bir seçimle karşılaştırıldığında.
Bulut Bölgesine Göre Karbon Yoğunluğu Ortalaması (2024-2025)
| Sağlayıcılar | Bölge | Konum | gCO₂eş/kWh | Notlar |
|---|---|---|---|---|
| GCP | Avrupa-Kuzey1 | Finlandiya | ~35 | Hidroelektrik + rüzgar |
| AWS | ab-kuzey-1 | Stokholm | ~40 | Neredeyse %100 yenilenebilir |
| GCP | Avrupa-Batı1 | Belçika | ~56 | Yenilenebilir + nükleer karışım |
| Azure | Fransa merkezi | Paris | ~58 | Nükleer baskın |
| AWS | ab-batı-1 | İrlanda | ~250 | Doğal gaz yaygınlaşıyor |
| AWS | abd-doğu-1 | Virjinya | ~296 | Orta Doğu ABD karışımı |
| AWS | ap-güneydoğu-1 | Singapur | ~408 | Doğal gaz |
# Spot Instances per training carbon-aware
# Le spot instance non solo riducono i costi del 60-90%,
# ma tendono a essere distribuite su hardware più' recente ed efficiente
import boto3
from botocore.exceptions import ClientError
def submit_spot_training(
image_uri: str,
instance_type: str = "p4d.24xlarge", # 8x A100
region: str = "eu-north-1", # Stoccolma: ~40 gCO2/kWh
max_price_per_hour: float = 15.0
):
"""Submette un training job su spot instances AWS SageMaker."""
sagemaker = boto3.client('sagemaker', region_name=region)
response = sagemaker.create_training_job(
TrainingJobName=f"green-ml-{int(datetime.now().timestamp())}",
AlgorithmSpecification={
'TrainingImage': image_uri,
'TrainingInputMode': 'FastFile'
},
ResourceConfig={
'InstanceType': instance_type,
'InstanceCount': 1,
'VolumeSizeInGB': 100
},
# Managed Spot Training
EnableManagedSpotTraining=True,
StoppingCondition={
'MaxRuntimeInSeconds': 86400, # 24 ore max
'MaxWaitTimeInSeconds': 172800 # Aspetta fino a 48 ore
},
# Checkpointing per riprendere se lo spot viene interrotto
CheckpointConfig={
'S3Uri': f's3://my-bucket/checkpoints/',
'LocalPath': '/opt/ml/checkpoints'
}
)
return response['TrainingJobArn']
# Confronto costi e emissioni:
# p4d.24xlarge on-demand (us-east-1): $32.77/h, 296 gCO2/kWh
# p4d.24xlarge spot (eu-north-1): $9.83/h, 40 gCO2/kWh
# Risparmio economico: -70%
# Risparmio emissioni: -86% (spot + regione verde)Çıkarım Optimizasyonu: Karbon Ayak İzinin %77'si
Beklendiği gibi, üretimdeki çıkarım, yaşam döngüsündeki emisyonlara hakimdir. ML modelleri. Milyonlarca kullanıcısı olan bir model için gecikmenin her milisaniyesi azaldı ve azaltılan tüketimin her watt'ı yılda milyarlarca taleple çarpılıyor. Ana teknikler niceleme, model derleme ve optimize edilmiş gruplamadır.
Niceleme: INT8, INT4 ve GPTQ
Niceleme, FP32 veya FP16'daki model ağırlıklarının sayısal hassasiyetini azaltır 8 veya 4 bitlik tamsayılara. Bu, bellek gereksinimlerini %50-75 oranında azaltır, çıkarımı hızlandırır 2-4 kat artar ve enerji tüketimini orantılı olarak azaltır.
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch
# Quantizzazione INT4 con GPTQ (post-training quantization)
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_compute_dtype=torch.bfloat16,
bnb_4bit_use_double_quant=True, # QLoRA: double quantization
bnb_4bit_quant_type="nf4" # Normal Float 4: migliore qualità'
)
model_id = "meta-llama/Llama-2-7b-hf"
model = AutoModelForCausalLM.from_pretrained(
model_id,
quantization_config=quantization_config,
device_map="auto",
torch_dtype=torch.bfloat16
)
tokenizer = AutoTokenizer.from_pretrained(model_id)
# Verifica riduzione memoria
original_size_gb = 7 * 2 / 1024 # 7B param x 2 byte (FP16) / 1024
quantized_size_gb = 7 * 0.5 / 1024 # 7B param x 0.5 byte (INT4) / 1024
print(f"FP16: {original_size_gb:.1f} GB")
print(f"INT4: {quantized_size_gb:.1f} GB (-{(1-quantized_size_gb/original_size_gb)*100:.0f}%)")
# Quantizzazione INT8 con ONNX Runtime (per produzione)
from optimum.onnxruntime import ORTModelForSequenceClassification
from optimum.onnxruntime.configuration import AutoQuantizationConfig
# Esporta in ONNX e quantizza
ort_model = ORTModelForSequenceClassification.from_pretrained(
"bert-base-uncased",
export=True
)
quantization_config = AutoQuantizationConfig.avx512_vnni(
is_static=False, # Dynamic quantization (no calibration data needed)
per_channel=False
)
# Salva il modello quantizzato
from optimum.onnxruntime import ORTQuantizer
quantizer = ORTQuantizer.from_pretrained(ort_model)
quantizer.quantize(
save_dir="./bert-int8-onnx",
quantization_config=quantization_config
)
# Benchmark:
# BERT-Base FP32: 23ms latenza, 100% accuracy, 1.6 GB
# BERT-Base INT8: 12ms latenza, 99.2% accuracy, 0.4 GB -> -48% energia
# BERT-Base INT4: 8ms latenza, 97.8% accuracy, 0.2 GB -> -65% energiavLLM: Yüksek Lisans için Verimli Hizmet
vLLM LLM için kullanılan bir hizmet çerçevesidir PagedDikkat KV önbelleğini çok daha verimli bir şekilde yönetmek için. Saf bir hizmetle karşılaştırıldığında, vLLM, aynı donanımla verimi 15-24 kat artırır ve orantılı olarak azaltır üretilen jeton başına enerji tüketimi.
from vllm import LLM, SamplingParams
from codecarbon import EmissionsTracker
# Avvia LLM con vLLM (PagedAttention + continuous batching)
llm = LLM(
model="meta-llama/Llama-2-7b-chat-hf",
tensor_parallel_size=1, # GPU count
gpu_memory_utilization=0.90, # Usa il 90% della VRAM per KV cache
max_num_batched_tokens=32768, # Batch maggiori = più' efficiente
quantization="awq" # AWQ quantization integrata
)
sampling_params = SamplingParams(
temperature=0.7,
max_tokens=256
)
# Misura emissioni per 1000 richieste
tracker = EmissionsTracker(project_name="vllm-inference-benchmark")
tracker.start()
prompts = ["Spiega il concetto di machine learning in italiano"] * 1000
outputs = llm.generate(prompts, sampling_params)
emissions = tracker.stop()
tokens_generated = sum(len(o.outputs[0].token_ids) for o in outputs)
print(f"Token generati: {tokens_generated:,}")
print(f"Emissioni: {emissions*1000:.2f} gCO2eq")
print(f"gCO2eq per 1000 token: {emissions*1000/tokens_generated*1000:.4f}")
# Confronto con serving naive HuggingFace:
# HuggingFace Transformers: 1.000 req, 45 min, 890 gCO2eq
# vLLM: 1.000 req, 3 min, 59 gCO2eq (-93%)
# Throughput: 333 req/min vs 22 req/minML Modelleri için SCI Puanı: Ölçümü Standartlaştırma
Şartname SCI (Karbon Yoğunluğu Yazılımı) Yeşil Yazılım Vakfı'nın, artık standart ISO/IEC 21031:2024, makine öğrenimi sistemleri için de geçerlidir. SCI emisyonları ifade eder fonksiyonel birim başına, farklı modeller arasında anlamlı karşılaştırmalara olanak tanır.
ML Sistemlerine Uygulanan SCI Formülü
| Bileşen | Makine öğrenimi formülü | BERT Çıkarımı örneği |
|---|---|---|
| E (Enerji) | GPU Gücü x Zaman / 1000 | 300W x 0,05s / 1000 = 0,000015 kWh |
| I (Karbon Yoğunluğu) | Bölgenin gCO₂eq/kWh'i | 420 gCO₂eq/kWh (İtalya ortalaması) |
| M (Bedenlenmiş) | Donanım CO₂ / (Ömür x Kullanım) | 150.000 gCO₂ / (26.280 saat x 0,7) = 8,2 g/saat |
| R (Fonksiyonel Birim) | 1.000 çıkarım veya 1 jeton oluşturuldu | 1.000 sınıflandırma |
| KAYAK | (E x I + M) / R | (0,015 x 0,420 + 0,00023) / 1 = 0,0065 gCO₂eq/req |
from dataclasses import dataclass
from typing import Literal
@dataclass
class MLSystemSCI:
"""Calcola SCI Score per sistemi ML."""
model_name: str
gpu_count: int
gpu_tdp_watts: float
avg_latency_ms: float # Per inferenza singola
carbon_intensity_g_kwh: float # gCO2/kWh regione
gpu_lifespan_hours: float = 26_280 # 3 anni
gpu_embodied_gco2: float = 150_000 # ~150 kgCO2 per GPU
utilization: float = 0.70
pue: float = 1.3
functional_unit: Literal['request', 'token'] = 'request'
def operational_energy_kwh(self) -> float:
"""Energia operativa per singola inferenza."""
return (
self.gpu_count
* self.gpu_tdp_watts
* (self.avg_latency_ms / 1000)
/ 1_000 # W -> kW
)
def operational_emissions_g(self) -> float:
"""Emissioni operative per singola inferenza (gCO2eq)."""
return (
self.operational_energy_kwh()
* self.carbon_intensity_g_kwh
* self.pue
)
def embodied_per_request_g(self) -> float:
"""Quota embodied per singola inferenza."""
# Secondi per richiesta / secondi per vita GPU
fraction_of_life = (self.avg_latency_ms / 1000) / (
self.gpu_lifespan_hours * 3600
)
total_embodied = self.gpu_count * self.gpu_embodied_gco2
return total_embodied * fraction_of_life / self.utilization
@property
def sci_score(self) -> float:
"""SCI = (E x I + M) / R per singola richiesta."""
return self.operational_emissions_g() + self.embodied_per_request_g()
# Confronto modelli
models = [
MLSystemSCI("BERT-Base INT8/CPU", 0, 100, 45, 420, gpu_count=0,
gpu_embodied_gco2=0),
MLSystemSCI("BERT-Base FP32/A100", 1, 400, 12, 420),
MLSystemSCI("BERT-Base INT8/A100", 1, 280, 6, 420),
MLSystemSCI("DistilBERT FP16/A100", 1, 240, 5, 420),
MLSystemSCI("BERT-Base INT8/eu-north-1", 1, 280, 6, 40), # Stoccolma
]
print(f"{'Modello':<35} {'SCI (gCO2/req)':<18} {'vs Baseline'}")
baseline = models[0].sci_score
for m in models:
sci = m.sci_score
ratio = sci / baseline
print(f"{m.model_name:<35} {sci:.6f} gCO2 {ratio:.2f}x")Yeşil Yapay Zeka Liderlik Tablosu: Doğruluk yerine Verimlilik
GLUE, SuperGLUE ve MMLU gibi geleneksel lider tabloları yalnızca doğruluğu ölçer. Kavramı Yeşil Yapay Zeka Liderlik TablosuSchwartz ve diğerleri tarafından önerilmiştir. (2020) GSF tarafından 2024'te resmileştirilen bu rapor, dengeyi sağlayan bileşik metrikleri tanıtıyor performans ve karbon verimliliği.
Yeşil Yapay Zeka Metrikleri: Doğruluk/Emisyon Dengesi (GLUE Karşılaştırması)
| Modeli | TUTKAL Puanı | CO₂eq Treni (t) | CO₂eş Anlamı (mg/talep) | Yeşil Puan* |
|---|---|---|---|---|
| BERT-Taban | 82.1 | 0,9 | 0,62 | 132 |
| RoBERTa-Baz | 86.4 | 4.1 | 0,62 | 139 |
| DistilBERT | 77.0 | 0,35 | 0.31 | 248 |
| BERT-Base INT8 | 81.3 | 0,9 | 0,28 | 290 |
| MobilBERT | 78.2 | 0,6 | 0,18 | 434 |
| ALBERT-Baz v2 | 82.3 | 0,5 | 0,42 | 196 |
* Yeşil Puan = (GLUE Puanı / CO₂eq Çıkarımı) x 1000. Daha yüksek değerler = daha verimli.
BERT-Base'den %6 daha düşük bir GLUE Puanına rağmen DistilBERT'in nasıl olduğuna dikkat edin. neredeyse iki katı Yeşil Skora sahiptir. MobileBERT listedeki en iyi Yeşil Skoru sunuyor, sınırlı karbon bütçelerine sahip ölçekli dağıtımlar için en uygun seçim haline geliyor.
Vaka Çalışması: NLP Modelinde Emisyonların %60 Azaltılması
Bu örnek olay çalışması, bir modele uygulanan gerçek dünyadaki optimizasyon yolunu açıklamaktadır Bir şirket için geliştirilen, İtalyan pazarına yönelik duyarlılık sınıflandırması Aylık 2 milyon incelemenin işleneceği e-ticaret.
Temel çizgi: Başlangıç durumu
# STATO INIZIALE (Baseline)
# Modello: bert-base-multilingual-cased (177M parametri)
# Hardware: 1x NVIDIA A100 80GB SXM4 (on-demand AWS us-east-1)
# Task: classificazione sentiment 5 classi (1-5 stelle)
# Dataset: 500.000 recensioni in italiano
# Metriche baseline:
Training_time_hours = 18.5
Energy_training_kWh = 130.0 # A100 SXM4: ~400W TDP, PUE=1.5
CO2_training_kgCO2eq = 38.5 # 130 kWh x 0.296 kgCO2/kWh (us-east-1)
Inference_latency_ms = 35.0 # Per singola recensione
Inference_throughput_req_s = 28.6
CO2_inference_per_1M_req = 2.85 # kgCO2eq
Monthly_inference_requests = 2_000_000
Monthly_inference_CO2_kg = 5.70
Annual_training_runs = 4 # Re-training trimestrale
Annual_total_CO2_kg = (4 * 38.5) + (12 * 5.70) = 222.4
Accuracy_f1_macro = 0.847Adım Adım Optimizasyon
# STEP 1: Cambio regione cloud (us-east-1 -> eu-north-1)
# Carbon intensity: 296 -> 40 gCO2/kWh (-86%)
# Nessun cambiamento al codice, solo flag AWS Region
CO2_training_kgCO2eq_step1 = 130.0 * 0.040 * 1.5 = 7.8 # -80%
Monthly_inference_CO2_step1 = 2.85 * (40/296) = 0.38 # -87%
Annual_CO2_step1 = (4 * 7.8) + (12 * 0.38) = 35.7 kg # -84%
# STEP 2: Cambio modello base (multilingual -> umberto italiano)
# umberto-commoncrawl-cased (bert-base size ma solo italiano)
# Dataset training ridotto del 30% (solo dati italiani puliti)
# Curriculum learning: 15 epoche vs 20 -> -25% training time
CO2_training_kgCO2eq_step2 = 7.8 * 0.75 * 0.70 = 4.1 # -47% su step1
Accuracy_f1_macro_step2 = 0.861 # +1.4% grazie a modello specializzato
# STEP 3: Quantizzazione INT8 (ONNX Runtime)
# Latenza inferenza: 35ms -> 18ms (-49%)
# Throughput: 28.6 -> 55.5 req/s (+94%)
Inference_latency_ms_step3 = 18.0
Monthly_inference_CO2_step3 = 0.38 * 0.50 = 0.19 # -50%
Accuracy_f1_macro_step3 = 0.856 # -0.5% accettabile
# STEP 4: Carbon-aware scheduling del re-training
# Spot instances + finestre energetiche verdi
# Costo spot eu-north-1: -70% vs on-demand
# Timing training nelle ore di massima rinnovabile
CO2_training_kgCO2eq_step4 = 4.1 * 0.85 = 3.5 # Spot: stesso hardware, timing migliore
# RIEPILOGO OTTIMIZZAZIONI
print("=" * 60)
print(f"Baseline: {222.4:.1f} kgCO2eq/anno | F1: 0.847")
print(f"Step 1: {35.7:.1f} kgCO2eq/anno | -84% (solo regione)")
print(f"Step 2: {26.9:.1f} kgCO2eq/anno | -87% (modello+data)")
print(f"Step 3: {21.7:.1f} kgCO2eq/anno | -90% (quantizzazione)")
print(f"Step 4: {18.6:.1f} kgCO2eq/anno | -92% (carbon-aware)")
print(f"F1 finale: 0.856 vs 0.847 baseline (+1.1%)")
print("=" * 60)
print(f"Riduzione CO2: -203.8 kgCO2eq/anno (-91.6%)")
print(f"Risparmio costi: -74% (spot + regione + efficienza)")Vaka Çalışması Sonuçları: Özet
| Metrik | Temel çizgiler | Optimize edilmiş | Varyasyon |
|---|---|---|---|
| Toplam yıllık CO₂eş | 222 kgCO₂eşd | 19 kgCO₂eşd | -91% |
| F1-Skor Makrosu | 0,847 | 0,856 | +%1,1 |
| Çıkarım gecikmesi | 35 ms | 18 ms | -49% |
| Verim | 28 istek/sn | 55 istek/sn | +%96 |
| Aylık bulut maliyeti | ~2.400 Avro | ~620 Avro | -74% |
Temel Ders: Doğruluktan Ödün Vermeden Emisyonların %90'ı Azaltılıyor
Bu vaka çalışmasında, her bir optimizasyon adımı geliştirilmiş veya modelin doğruluğunu korudu. Kaydedilen bulut bölgesini seçme Emisyonların %84'ü tek bir kod satırına bile dokunmadan gerçekleşiyor. Uzmanlığı İtalyanca dili için şablonun kalitesi artırıldı. Niceleme gecikmeyi yarıya indirdi. Mesaj açık: Karbon için optimize edin ayak izi ve kalite için optimizasyon birbiriyle çelişen hedefler değildir.
Kuruluşlar için Yeşil Yapay Zeka Yol Haritası
Yeşil yapay zekayı benimsemek her şeyde anında devrim yapmayı gerektirmez. Bir yol haritası üç aşamadan başlayarak uygulamaları aşamalı olarak tanıtmanıza olanak tanır Daha büyük etki ve daha az çaba ile optimizasyonlar.
3 Aşamada Yeşil Yapay Zeka Benimseme Yol Haritası
| Faz | Zaman çizelgesi | Eylemler | CO₂ azalması bekleniyor |
|---|---|---|---|
| 1. Adım: Ölçün | 1-4. Hafta |
CodeCarbon'u tüm eğitim işlerine yükleyin; model başına emisyon temel çizgilerini tanımlayın; daha yeşil bulut bölgelerini seçin |
%50-85 (yalnızca bölge) |
| 2. Adım: Optimize edin | Ay 2-4 |
Tüm eğitimlere karma hassasiyet (BF16) uygulayın; üretimdeki modelleri nicelemek (INT8); Toplu eğitim için spot örnekleri benimseyin |
Ek %30-50 |
| Aşama 3: Entegrasyon | Ay 5-12 |
Karbon farkındalığına sahip otomatik planlama; Dahili Yeşil Yapay Zeka Liderlik Tablosu; Dağıtım kriterlerinde SCI puanı; ESG, makine öğrenimi emisyonlarını raporluyor |
Ek %10-20 |
Her Eğitim İşi için Yeşil Yapay Zeka Kontrol Listesi
# Checklist Green AI da seguire prima di ogni training
# Copia in: .github/PULL_REQUEST_TEMPLATE.md o come commento training script
CHECKLIST_GREEN_AI = """
Green AI Pre-Training Checklist
================================
[ ] 1. REGIONE: Training schedulato in regione con CI < 150 gCO2/kWh?
Verifica: https://app.electricitymaps.com/zone/IT
Preferisci: GCP europe-north1, AWS eu-north-1, Azure swedencentral
[ ] 2. TIMING: Carbon-aware scheduling attivato?
Tool: Carbon Aware SDK o script custom
Finestra ottimale: verificata nelle ultime 24h
[ ] 3. HARDWARE: GPU di ultima generazione disponibile?
H100 >> A100 (44% più' efficiente)
Spot/preemptible instances preferite
[ ] 4. PRECISION: Mixed precision attivata (BF16/FP16)?
HuggingFace: bf16=True in TrainingArguments
PyTorch: torch.autocast('cuda', dtype=torch.bfloat16)
[ ] 5. EARLY STOPPING: Configurato con CarbonTracker per proiezione?
Stima emissioni dopo 5 epoche e confronta con budget CO2
[ ] 6. TRACKING: CodeCarbon configurato?
Country_iso_code, cloud_provider, cloud_region impostati
Output in: ./carbon_reports/
[ ] 7. DATI: Dataset ottimizzato con deduplication e qualità'?
Almeno 10% redundancy rimossa
Active learning per ridurre dimensione se possibile
[ ] 8. BASELINE: Esiste una run precedente da confrontare?
Registra su MLflow: accuracy, emissioni, ratio
[ ] 9. INFERENZA: Quantizzazione pianificata per produzione?
Target: INT8 con ONNX Runtime o INT4 per LLM
[ ] 10. REPORTING: Emissioni saranno incluse nel model card?
Usa: SCI Score, kgCO2eq training, gCO2eq/1000 req inferenza
"""
print(CHECKLIST_GREEN_AI)Sonuçlar: Yeşil Yazılım Mühendisliği Serisi Özeti
Bu makale seriyi sonlandırıyor Yeşil Yazılım Mühendisliği, Tüm uygulama yelpazesini aşan 10 makalelik bir yolculuk Sürdürülebilir yazılım geliştirme. GSF ilkeleri teorisinden uygulamalara CodeCarbon, Carbon Aware SDK, Climatiq API ile tekniklere kadar uygulamalar gelişmiş makine öğrenimi optimizasyonu: kapsamlı bir araç seti oluşturduk dijital çevresel etkilerini azaltmak isteyen geliştiriciler ve kuruluşlar.
Dizinin 10 Temel Mesajı
| # | Öğe | Anahtar Mesaj |
|---|---|---|
| 1 | GSF İlkeleri | Karbon verimliliği bir yazılım kalitesi ölçüsüdür |
| 2 | KodKarbon | Ölçmediğiniz şeyi azaltamazsınız: 1. günden başlayın |
| 3 | İklimlendirme API'si | CO₂'nin bir API'si var: karbon muhasebesini arka ucunuza entegre edin |
| 4 | Karbon Bilinçli SDK | Bir iş yükünün zaman veya mekan içinde taşınması %90 oranında azaltılabilir |
| 5 | Kapsam Modelleme | SCI, yazılımın karbon verimliliğini karşılaştırmak için kullanılan ISO standardıdır |
| 6 | GreenOps | Yeşil ve FinOps uyum sağlıyor: CO₂'ün optimize edilmesi bulut maliyetlerini azaltır |
| 7 | Kapsam 3 Boru Hattı | Dolaylı emisyonlar genellikle doğrudan emisyonlardan daha fazladır |
| 8 | ÇSY ve CSRD | 2025'ten itibaren dijital ÇSY raporlaması birçok şirket için yasal zorunluluk haline gelecek |
| 9 | Sürdürülebilir Desenler | Önbellek, toplu iş ve eşzamansız yalnızca performans değildir: bunlar yeşil kalıplardır |
| 10 | AI Karbon | Bulut bölgesinin seçilmesi, ML emisyonlarını herhangi bir algoritmadan daha fazla azaltır |
O An Şimdidir
Üretken yapay zeka büyümeye devam edecek. Modeller büyüyecek ne kadar sık eğitim, o kadar yaygın dağıtım. Soru değil Yapay zeka emisyonları artarsa zaten artacaktır ama ne kadar. Bu makaledeki teknikler %60-90 oranında azaltmanın mümkün olduğunu göstermektedir. doğruluktan ödün vermeden ve çoğu zaman azaltarak bir ML sisteminin emisyonlarını maliyetler. Bu bir uzlaşma değil; her cephede bir zaferdir.
Yeşil Yazılım Vakfı, her makine öğrenimi ekibinin aşağıdaki uygulamaları benimsemesi durumunda, Karbon farkındalığı eğitimi ve çıkarımın nicelendirilmesi, sektörün küresel emisyonları AI şu kadar azaltılabilir: 2030'a kadar %40-60 senaryoyla karşılaştırıldığında her zamanki gibi iş. Teknolojik buluşlara ihtiyacımız yok: anlatılan uygulamalara ihtiyacımız var Bu on maddede sistematik olarak uygulayın.
Bir sonraki adım sizindir. Bir sonraki eğitim işinize CodeCarbon'u yükleyin. AWS veya GCP bölgenizin karbon yoğunluğunu kontrol edin. Niceleme modeli dağıtmadan önce. SCI puanını ölçün. Ve bunu yaptığında, en önemli adımı atmış olacaksınız: başlamak.
Faydalı Bağlantılar ve Araçlar
- KodKarbon: mlco2.github.io/codekarbon
- ML CO₂ Etki Hesaplayıcı: mlco2.github.io/impact
- Yeşil Algoritma Hesaplayıcı: yeşil-algoritmalar.org
- Elektrik Haritaları API'sı: elektrikmaps.com/api
- GSF SCI Şartnamesi: sci.greensoftware.foundation
- Sarılma Yüz Emisyon Takibi: HuggingFace Hub Karbon Takibi
- vLLM Sunumu: docs.vllm.ai
- ONNX Çalışma Zamanı Optimizasyonu: onnxruntime.ai
Yola Devam: İlgili Diziler
- İşletmeler için MLOps: ML modellerini aşağıdakilerle dağıtma hakkında daha fazla bilgi edinin: MLflow, DVC ve CI/CD ardışık düzenleri — karbon ayak izi kalite geçitleri dahil.
- Yapay Zeka Mühendisliği ve RAG: RAG sistemlerinin nasıl oluşturulacağını keşfedin LLM modellerine yapılan çağrı sayısını en aza indiren, her ikisini de azaltan verimli emisyonların maliyetleri.
- Veri ve Yapay Zeka İşi: AB Yapay Zeka Yasasının ve düzenlemelerinin nasıl olduğunu öğrenin ESG, Yeşil Yapay Zeka uygulamalarıyla ve bir yol haritasının nasıl oluşturulacağıyla kesişiyor KOBİ'ler için sürdürülebilir veri odaklı.