test3/eden_InceptionV3_ImageNet.py

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader, random_split
from sklearn.metrics import f1_score, precision_score, recall_score
from codecarbon import EmissionsTracker
from thop import profile 
from tqdm import tqdm
import time, pandas as pd, numpy as np, os, warnings, copy, gc, ssl

# --- 1. SSL BYPASS (VIT-AP Network Fix) ---
ssl._create_default_https_context = ssl._create_unverified_context

# --- Configuration ---
MODEL_NAME = "inceptionV3_EDEN" 
DATASET_NAME = "CustomImageNet300"
DATA_PATH = r'C:\Users\shanm\Dataset Download\custom image net' 
BATCH_SIZE = 32         
ACCUMULATION_STEPS = 16 
EPOCHS = 20             
E_UNFREEZE = 10         
LAMBDA_L1 = 1e-5        
DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")

SAVE_DIR = "saved_models"
os.makedirs(SAVE_DIR, exist_ok=True)
CSV_FILENAME = f"{MODEL_NAME}_{DATASET_NAME}_stats.csv"

warnings.filterwarnings("ignore")
os.environ["CODECARBON_LOG_LEVEL"] = "error"

def main():
    # --- Phase 1: High-Resolution Initialization (299x299) ---
    transform = transforms.Compose([
        transforms.Resize(320),
        transforms.CenterCrop(299),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
    ])

    print(f"[*] Loading {DATASET_NAME} (80/20 Random Split)...")
    full_dataset = torchvision.datasets.ImageFolder(root=DATA_PATH, transform=transform)
    
    train_size = int(0.8 * len(full_dataset))
    val_size = len(full_dataset) - train_size
    train_dataset, _ = random_split(full_dataset, [train_size, val_size], 
                                   generator=torch.Generator().manual_seed(42))
    
    trainloader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=4, pin_memory=True)

    # --- Model Setup ---
    print("[*] Initializing Pre-trained InceptionV3...")
    model = torchvision.models.inception_v3(weights='IMAGENET1K_V1')
    model.AuxLogits.fc = nn.Linear(model.AuxLogits.fc.in_features, 300)
    model.fc = nn.Linear(model.fc.in_features, 300) 
    
    print("[*] Calculating hardware metrics...")
    model_for_profile = copy.deepcopy(model).to(DEVICE)
    dummy_input = torch.randn(1, 3, 299, 299).to(DEVICE)
    flops, params = profile(model_for_profile, inputs=(dummy_input, ), verbose=False)
    del model_for_profile
    
    for name, param in model.named_parameters():
        if "fc" not in name:
            param.requires_grad = False
    
    model.to(DEVICE)

    criterion = nn.CrossEntropyLoss()
    optimizer = optim.AdamW(model.parameters(), lr=1e-3)
    scaler = torch.cuda.amp.GradScaler() 

    # --- 2. Variable Initialization (Fixes UnboundLocalError) ---
    results = []
    cumulative_total_energy = 0
    best_acc = 0.0 
    
    tracker = EmissionsTracker(measure_power_secs=1, save_to_file=False, log_level='error')

    print(f"\n[MODEL INFO] FLOPs: {flops/1e9:.2f} G | Parameters: {params/1e6:.2f} M | Classes: 300")
    print(f"{'='*140}")
    print(f"{'Epoch':<6} | {'Loss':<7} | {'Acc':<7} | {'Total(J)':<9} | {'VRAM(GB)':<9} | {'EAG':<8} | {'Status'}")
    print(f"{'-'*140}")

    for epoch in range(1, EPOCHS + 1):
        if epoch == E_UNFREEZE:
            for param in model.parameters(): param.requires_grad = True
            for pg in optimizer.param_groups: pg['lr'] = 1e-5
            status_msg = "UNFROZEN"
        else:
            status_msg = "FROZEN" if epoch < E_UNFREEZE else "FINE-TUNING"

        model.train()
        tracker.start()
        epoch_start = time.time()
        running_loss, all_preds, all_labels = 0.0, [], []
        
        pbar = tqdm(enumerate(trainloader), total=len(trainloader), desc=f"Epoch {epoch:02d}", leave=False)
        
        optimizer.zero_grad()
        for i, (inputs, labels) in pbar:
            inputs, labels = inputs.to(DEVICE), labels.to(DEVICE)
            with torch.cuda.amp.autocast():
                outputs, aux_outputs = model(inputs)
                cls_loss = criterion(outputs, labels) + 0.4 * criterion(aux_outputs, labels)
                l1_penalty = sum(p.abs().sum() for p in model.parameters() if p.requires_grad)
                loss = (cls_loss + LAMBDA_L1 * l1_penalty) / ACCUMULATION_STEPS
            
            scaler.scale(loss).backward()
            if (i + 1) % ACCUMULATION_STEPS == 0:
                scaler.unscale_(optimizer)
                torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
                scaler.step(optimizer); scaler.update(); optimizer.zero_grad()
            
            running_loss += cls_loss.item()
            _, predicted = torch.max(outputs.data, 1)
            all_preds.extend(predicted.cpu().numpy()); all_labels.extend(labels.cpu().numpy())
            pbar.set_postfix({'loss': f"{cls_loss.item():.4f}"})

        emissions_kg = tracker.stop()
        duration = time.time() - epoch_start
        
        # --- 3. DEFINING TOTAL_ENERGY (Fixes NameError) ---
        e_gpu = tracker.final_emissions_data.gpu_energy * 3600000
        e_cpu = tracker.final_emissions_data.cpu_energy * 3600000
        e_ram = tracker.final_emissions_data.ram_energy * 3600000
        total_energy = e_gpu + e_cpu + e_ram
        cumulative_total_energy += total_energy
        
        acc = (np.array(all_preds) == np.array(all_labels)).mean()
        vram_peak = torch.cuda.max_memory_allocated(DEVICE) / (1024**3)
        
        # Now total_energy is clearly defined before this calculation
        eag = acc / (total_energy / 1000) if total_energy > 0 else 0

        stats = {
            "epoch": epoch, "status": status_msg, "loss": running_loss / len(trainloader),
            "accuracy": acc, "total_energy_j": total_energy, "cumulative_energy_j": cumulative_total_energy,
            "vram_gb": vram_peak, "eag_metric": eag, "carbon_kg": emissions_kg,
            "model_flops": flops, "model_params": params
        }
        results.append(stats)
        pd.DataFrame(results).to_csv(CSV_FILENAME, index=False)
        
        best_tag = ""
        if acc > best_acc:
            best_acc = acc
            torch.save(model.state_dict(), os.path.join(SAVE_DIR, f"BEST_{MODEL_NAME}_{DATASET_NAME}.pth"))
            best_tag = "*"

        print(f"{epoch:02d}/{EPOCHS:02d} | {stats['loss']:.4f} | {acc:.2%} | {total_energy:<9.2f} | {vram_peak:<9.3f} | {eag:<8.4f} | {status_msg}{best_tag}")

    del model, trainloader
    torch.cuda.empty_cache(); gc.collect()

if __name__ == '__main__':
    main()