Perché misurare la carbon footprint dell'AI

Il costo energetico del machine learning non è una curiosità accademica. Nel 2022, secondo uno studio del MIT e del Lawrence Berkeley National Laboratory, l'addestramento di un singolo modello di linguaggio generativo ha prodotto 626 tonnellate di CO₂ equivalente — quanto guidare un'auto per 1.3 milioni di chilometri. I data center che lo ospitano consumano il 1-2% dell'elettricità mondiale.

Come professionista del software, hai due responsabilità:

• Efficienza immediata: ridurre il tempo e l'energia di ogni training, per abbassare costi e impatto.
• Sostenibilità strategica: scegliere data center green, metodi di training efficienti, e modelli ottimizzati.

Questo articolo ti guida nella misurazione e nell'ottimizzazione.

Metriche fondamentali della carbon footprint

Prima di misurare, devi sapere quali metriche contano. Le principali sono:

• PUE (Power Usage Effectiveness): Rapporto tra energia totale del data center e energia usata da IT. PUE = 1.0 è ideale (tutto usato dai server), 1.5+ significa inefficienza.
• CUE (Carbon Usage Effectiveness): kg di CO₂ per kWh usato. Dipende dalla grid energetica (renewable vs. carbone). La media globale è ~0.4 kg CO₂/kWh; con energia verde, scende a 0.05.
• FLOPS (Floating Point Operations Per Second): Operazioni computazionali al secondo. Più FLOPS per watt = più efficiente.
• Training Time: Durata dell'allenamento in ore/giorni. Ridurre il tempo = ridurre l'energia totale.
• Total CO₂ (kg o tonnellate equivalente): CO₂ = (Energia in kWh) × (CUE della grid).

Strumenti e librerie per misurare

Non devi calcolare manualmente. Ci sono tool open-source pronti all'uso:

1. Codecarbon (Python)

La libreria più popolare. Traccia energia e CO₂ in tempo reale durante il training.

# Installazione
pip install codecarbon

# Uso base
from codecarbon import OfflineEmissionsTracker

tracker = OfflineEmissionsTracker(country_iso_code="IT")
tracker.start()

# Qui il tuo training (PyTorch, TensorFlow, etc.)
for epoch in range(10):
    model.train()
    # training code...

emissions = tracker.stop()
print(f"Carbon emissions: {emissions} kg CO2")
    

Codecarbon stima energia monitorando la CPU/GPU e il consumo di memoria. Supporta stime cloud (AWS, Google Cloud, Azure).

2. Captura (PyTorch-native)

Plugin specifico per PyTorch che integra tracking senza overhead.

# Installazione
pip install captura

# Uso con PyTorch
from captura import capture_emissions
import torch
import torch.nn as nn

@capture_emissions
def train_model():
    model = nn.Sequential(
        nn.Linear(784, 256),
        nn.ReLU(),
        nn.Linear(256, 10)
    )
    optimizer = torch.optim.Adam(model.parameters())

    for epoch in range(5):
        for batch in train_loader:
            optimizer.zero_grad()
            loss = model(batch).sum()
            loss.backward()
            optimizer.step()

train_model()
# Output: Emissions = X kg CO2
    

3. Experiment Tracking (MLflow, Weights & Biases)

Integra carbon tracking nei tuoi esperimenti MLOps per comparare efficienza tra run.

# Integrazione con MLflow
import mlflow
from codecarbon import EmissionsTracker

with mlflow.start_run():
    tracker = EmissionsTracker()
    tracker.start()

    # Training
    model.fit(X_train, y_train, epochs=10)

    emissions = tracker.stop()
    mlflow.log_metric("carbon_emissions_kg", emissions)
    mlflow.log_metric("training_time_hours", training_hours)
    

Strategie di riduzione della carbon footprint

1. Scegliere hardware efficiente

Non tutte le GPU/TPU consumano allo stesso modo. Le TPU di Google sono generalmente 2-3x più efficienti per il training rispetto alle GPU, grazie all'architettura specializzata. Se usi GPU:

• Prefersci NVIDIA A100 o H100 (più giovani = più efficienti per TFLOPS/watt).
• Evita GPU vecchie (GTX 1080) per training seri — troppa energia per FLOPS.
• Scegli CPU moderne (Intel Xeon Platinum, AMD EPYC) per CPU-bound tasks.

2. Optimizzare l'algoritmo di training

Algoritmi più brevi = meno energia consumata.

# BAD: Full training senza ottimizzazioni
model = BertModel()
for epoch in range(100):
    full_training_step(model)

# GOOD: Transfer learning + fine-tuning
model = BertModel.from_pretrained("bert-base-uncased")
# Congela i layer iniziali — meno gradienti da calcolare
for param in model.encoder.layers[:8].parameters():
    param.requires_grad = False

# Fine-tuning su pochi layer
for epoch in range(10):
    fine_tuning_step(model)
# Riduce FLOPS e tempo di ~80%
    

3. Usare learning rate scheduling e early stopping

Spesso il training non ha bisogno di tutte le epoche. Early stopping ferma il training quando la validazione non migliora, risparmiando energia.

# Integrazione Keras
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau

early_stop = EarlyStopping(
    monitor='val_loss',
    patience=5,
    restore_best_weights=True
)

reduce_lr = ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.5,
    patience=3,
    min_lr=1e-6
)

model.fit(
    X_train, y_train,
    validation_split=0.2,
    epochs=100,
    callbacks=[early_stop, reduce_lr]
)
# Si ferma prima se non c'è miglioramento
    

4. Scegliere un data center green

Il 50% dell'impatto dipende dalla carbon intensity della grid energetica. Se alleni su cloud:

• Google Cloud: 40% energia rinnovabile media (best-in-class tra i major cloud).
• AWS: ~30% rinnovabile (EU regions leggermente meglio di US).
• Azure: ~45% rinnovabile in Europa.
• Locale on-prem: Dipende dalla tua grid (es. Italia ~40% rinnovabile).

Usa il tool di Google Carbon Footprint API per scegliere il data center con la carbon intensity più bassa.

Distribuzione e quantizzazione dei modelli

Non tutto l'impatto è nel training. Anche la distribuzione conta. Modelli grandi consumano energia anche in inference. Riduci l'impatto di runtime:

Quantizzazione a 8-bit

# PyTorch: Quantizzazione dinamica
import torch

model = torch.load("my_model.pth")
quantized_model = torch.quantization.quantize_dynamic(
    model,
    {torch.nn.Linear},
    dtype=torch.qint8
)

# Modello 4x più piccolo, inference 3-5x più veloce
torch.save(quantized_model, "model_quantized.pth")
    

Knowledge Distillation

Allena un modello piccolo (student) per copiare un modello grande (teacher). Inference usa lo student, riducendo energia.

# Knowledge distillation semplificato
import torch.nn.functional as F

def distillation_loss(student_output, teacher_output, temperature=3):
    soft_target = F.softmax(teacher_output / temperature, dim=1)
    soft_pred = F.log_softmax(student_output / temperature, dim=1)
    return F.kl_div(soft_pred, soft_target, reduction='batchmean')

# Durante training
for data, target in train_loader:
    student_logits = student_model(data)
    teacher_logits = teacher_model(data)

    loss = distillation_loss(student_logits, teacher_logits)
    loss.backward()
    optimizer.step()
    

Monitoraggio e reporting

Una volta implementate le ottimizzazioni, traccia i progressi:

# Report completo di carbon footprint
from codecarbon import OfflineEmissionsTracker
import json

def run_and_report(model_name, country="IT", epochs=10):
    tracker = OfflineEmissionsTracker(
        country_iso_code=country,
        log_level="warning"
    )
    tracker.start()

    start_time = time.time()
    train_model(epochs=epochs)
    end_time = time.time()

    emissions_kg = tracker.stop()

    report = {
        "model": model_name,
        "epochs": epochs,
        "training_time_hours": (end_time - start_time) / 3600,
        "emissions_kg_co2": round(emissions_kg, 4),
        "emissions_metric_tons": round(emissions_kg / 1000, 4),
        "country": country,
        "trees_to_offset": round(emissions_kg / 21, 1),  # 1 albero assorbe ~21 kg CO2/anno
    }

    with open(f"{model_name}_carbon_report.json", "w") as f:
        json.dump(report, f, indent=2)

    print(f"Report salvato: {model_name}_carbon_report.json")
    return report

# Esecuzione
report = run_and_report("bert-fine-tuned-v1", epochs=20)
print(f"CO2 emissions: {report['emissions_kg_co2']} kg")
    

Best practice per Sustainable AI

• Baseline first: Sempre comparare contro una baseline senza ML. A volte il problema si risolve con regole semplici.
• Hyperparameter tuning consapevole: Usa grid search ristretto o Bayesian optimization, non random search senza limiti.
• Versionamento dei modelli: Tieni traccia di quale versione è stata allenata su quale hardware e in quale regione. Facilita replay e benchmarking.
• Batch size ottimale: Batch size troppo piccolo spreca GPU. Troppo grande = overflow di memoria. Sperimenta per trovare il sweet spot.
• Comunicazione della carbon footprint: Includi l'impatto ambientale nel README del modello, come metrica accanto a accuratezza e latenza.

FAQ

D: Quanto costa energeticamente allenare un modello di linguaggio come GPT?

R: Un LLM da 175 miliardi di parametri ha consumato ~1.287 MWh durante l'addestramento, equivalente a ~552 kg CO₂. Stime non ufficiali per modelli di scala superiore suggeriscono 5-10x di più. Per benchmark: allenare un BERT small (110 milioni di parametri) costa circa 0.7-1.5 kg CO₂.

D: Se uso Ollama on-prem per inference locale, l'impatto è minore?

R: Sì, ma dipende da cosa "minore" significa. Inference su CPU/GPU locale consuma meno energia che un round-trip verso il cloud (latenza di rete). Però se la tua macchina usa energia fossile e un data center cloud usa 100% rinnovabile, il cloud potrebbe essere più green. Il punto chiave: misura sia il training che l'inference nel tuo contexto specifico.

D: È etico allenare modelli AI considerando l'impatto ambientale?

R: Sì, purché tu misuri, ottimizzi e comunichi l'impatto. Molti modelli utili hanno carbon footprint calcolata e pubblica. Il problema non è usare l'AI, ma usarla consapevolmente — proprio come usare un'auto è ok se ne conosci il consumo e non la sprechi.

D: Codecarbon fornisce stime accurate?

R: Codecarbon usa heuristiche (monitora TDP della GPU, CPU, memoria). Le stime sono spesso ±20% dalla realtà, a seconda dall'hardware. Per misure precise, usa i log di consumo energetico del data center o della tua UPS locale. Codecarbon è utile per comparazioni relative (questo run vs. quello) anche se le stime assolute non sono 100% precise.

D: Quale è il modello di training più carbon-efficient?

R: Transfer learning + fine-tuning. Allenare un modello piccolo da zero costa 10-100x di più. Se devi risolvere un problema di NLP, inizia sempre con un modello pre-trained (BERT, RoBERTa, Mistral) e adattalo ai tuoi dati. L'overhead del download pre-trained è trascurabile rispetto al training da zero.

Conclusione

La carbon footprint dell'AI training non è invisibile: è misurabile, riducibile, e soprattutto gestibile. Con le tool right (Codecarbon, Captura) e le strategie giuste (transfer learning, quantizzazione, early stopping), puoi ridurre l'impatto di un ordine di grandezza senza sacrificare performance.

Il messaggio finale: misura sempre. Non puoi ottimizzare quello che non misuri. Inizia oggi con un piccolo progetto, integra Codecarbon nel tuo workflow, e costruisci una cultura di Sustainable AI nel tuo team.