Sustainability & Green AI

# pip install codecarbon torch transformers

# ─── 1. Carbon Tracking with CodeCarbon ──────────────────────
from codecarbon import EmissionsTracker, OfflineEmissionsTracker
import time

# Online tracker (auto-detects location and uses live grid intensity)
tracker = EmissionsTracker(
    project_name="loan_model_training",
    output_dir="./carbon_reports",
    save_to_file=True,
    log_level="warning",
    country_iso_code="USA",  # fallback if geo-detection fails
)

tracker.start()

# Simulate a training workload
import numpy as np
X = np.random.randn(10000, 50)
y = (X[:, 0] > 0).astype(int)

from sklearn.ensemble import GradientBoostingClassifier
model = GradientBoostingClassifier(n_estimators=200, max_depth=5)
model.fit(X, y)
time.sleep(0.5)  # simulate additional work

emissions = tracker.stop()
print(f"\nCarbon Tracking Report:")
print(f"  CO₂ equivalent: {emissions * 1000:.4f} g CO₂e")
print(f"  Energy consumed: approximately proportional to training time")
print(f"  Report saved to: ./carbon_reports/emissions.csv")

# Offline tracker for environments without internet
offline_tracker = OfflineEmissionsTracker(
    project_name="inference_benchmark",
    country_iso_code="DEU",  # Germany — higher carbon intensity
    country_2letter_iso_code="DE",
)

# ─── 2. Model Efficiency Comparison ──────────────────────────
import torch
import torch.nn as nn
import time

class LargeModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(512, 2048), nn.ReLU(), nn.Dropout(0.2),
            nn.Linear(2048, 2048), nn.ReLU(), nn.Dropout(0.2),
            nn.Linear(2048, 1024), nn.ReLU(),
            nn.Linear(1024, 10),
        )
    def forward(self, x): return self.net(x)

class SmallModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(512, 256), nn.ReLU(),
            nn.Linear(256, 128), nn.ReLU(),
            nn.Linear(128, 10),
        )
    def forward(self, x): return self.net(x)

def count_parameters(model):
    return sum(p.numel() for p in model.parameters())

def benchmark_inference(model, n_samples=1000, batch_size=64, n_runs=5):
    x = torch.randn(batch_size, 512)
    times = []
    model.eval()
    with torch.no_grad():
        for _ in range(n_runs):
            start = time.time()
            for _ in range(n_samples // batch_size):
                _ = model(x)
            times.append(time.time() - start)
    return np.mean(times)

large = LargeModel()
small = SmallModel()

large_params = count_parameters(large)
small_params = count_parameters(small)
large_time = benchmark_inference(large)
small_time = benchmark_inference(small)

print(f"\nModel Efficiency Comparison:")
print(f"  Large model: {large_params:,} params, {large_time*1000:.1f}ms/1000 inferences")
print(f"  Small model: {small_params:,} params, {small_time*1000:.1f}ms/1000 inferences")
print(f"  Parameter reduction: {large_params/small_params:.1f}×")
print(f"  Speed improvement: {large_time/small_time:.1f}×")

# ─── 3. Post-Training Quantization ───────────────────────────
# FP32 → INT8 with PyTorch dynamic quantization
quantized_model = torch.quantization.quantize_dynamic(
    large,
    {nn.Linear},  # quantize Linear layers
    dtype=torch.qint8,
)

def get_model_size_mb(model):
    import io
    buf = io.BytesIO()
    torch.save(model.state_dict(), buf)
    return buf.tell() / 1024 / 1024

original_size = get_model_size_mb(large)
quantized_size = get_model_size_mb(quantized_model)
quant_time = benchmark_inference(quantized_model)

print(f"\nQuantization (FP32 → INT8):")
print(f"  Original size:   {original_size:.2f} MB")
print(f"  Quantized size:  {quantized_size:.2f} MB ({100*(1-quantized_size/original_size):.0f}% smaller)")
print(f"  Speed change:    {large_time/quant_time:.2f}× {'faster' if quant_time < large_time else 'slower'}")

# ─── 4. Magnitude Pruning ─────────────────────────────────────
import torch.nn.utils.prune as prune

prunable_model = LargeModel()

# Apply unstructured L1 pruning (remove 50% of weights in each linear layer)
for name, module in prunable_model.named_modules():
    if isinstance(module, nn.Linear):
        prune.l1_unstructured(module, name='weight', amount=0.5)
        prune.remove(module, 'weight')  # make pruning permanent

# Count remaining non-zero parameters
total_params = sum(p.numel() for p in prunable_model.parameters())
nonzero_params = sum((p != 0).sum().item() for p in prunable_model.parameters())
sparsity = 1 - nonzero_params / total_params

print(f"\nMagnitude Pruning (50% per layer):")
print(f"  Total parameters:   {total_params:,}")
print(f"  Non-zero parameters: {nonzero_params:,}")
print(f"  Sparsity:           {100*sparsity:.1f}%")

# ─── 5. Knowledge Distillation ───────────────────────────────
import torch.optim as optim
import torch.nn.functional as F

teacher = LargeModel()
student = SmallModel()
teacher.eval()

optimizer = optim.Adam(student.parameters(), lr=1e-3)

# Distillation training loop
temperature = 4.0
alpha = 0.7  # weight for distillation loss vs hard label loss

X_train = torch.randn(500, 512)
y_hard = torch.randint(0, 10, (500,))
dataset = torch.utils.data.TensorDataset(X_train, y_hard)
loader = torch.utils.data.DataLoader(dataset, batch_size=64, shuffle=True)

print(f"\nKnowledge Distillation (T={temperature}, α={alpha}):")
for epoch in range(5):
    student.train()
    total_loss = 0
    for bx, by in loader:
        optimizer.zero_grad()
        with torch.no_grad():
            teacher_logits = teacher(bx)
        student_logits = student(bx)

        # Hard label loss (cross-entropy with ground truth)
        hard_loss = F.cross_entropy(student_logits, by)

        # Soft label loss (KL divergence with temperature-softened teacher)
        soft_teacher = F.softmax(teacher_logits / temperature, dim=-1)
        soft_student = F.log_softmax(student_logits / temperature, dim=-1)
        distill_loss = F.kl_div(soft_student, soft_teacher, reduction='batchmean') * (temperature ** 2)

        loss = (1 - alpha) * hard_loss + alpha * distill_loss
        loss.backward()
        optimizer.step()
        total_loss += loss.item()

    print(f"  Epoch {epoch+1}: loss={total_loss/len(loader):.4f}")

print(f"\nStudent model: {count_parameters(student):,} params ({count_parameters(student)/count_parameters(teacher)*100:.0f}% of teacher)")

# ─── 6. Green AI Report ──────────────────────────────────────
def green_ai_report(project_name, model_type, params, training_co2_g,
                    inference_calls_per_day, inference_co2_per_call_ug):
    daily_inference_co2 = inference_calls_per_day * inference_co2_per_call_ug / 1e6
    annual_co2_kg = (training_co2_g / 1000) + (daily_inference_co2 * 365)
    trees_needed = annual_co2_kg / 21  # average tree absorbs ~21 kg CO₂/year

    print(f"\n{'='*50}")
    print(f"GREEN AI REPORT: {project_name}")
    print(f"{'='*50}")
    print(f"  Model type:         {model_type}")
    print(f"  Parameters:         {params:,}")
    print(f"  Training CO₂:       {training_co2_g:.1f}g CO₂e")
    print(f"  Inference CO₂:      {inference_co2_per_call_ug:.0f}μg CO₂e per call")
    print(f"  Daily inference CO₂: {daily_inference_co2*1000:.1f}g CO₂e")
    print(f"  Annual total CO₂:   {annual_co2_kg:.2f}kg CO₂e")
    print(f"  Trees to offset:    {trees_needed:.1f} trees/year")
    print(f"  Reduction strategies: quantization, distillation, efficient serving")

green_ai_report("LoanScoreAI v3.2", "XGBoost (1000 estimators)",
                params=1_000_000, training_co2_g=45.2,
                inference_calls_per_day=50_000, inference_co2_per_call_ug=120)