Delete untitled13.py

untitled13.py

@@ -1,334 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Untitled13.ipynb
-
-Automatically generated by Colab.
-
-Original file is located at
-    https://colab.research.google.com/drive/1bSlUUtEKolJbG5_99MGcEiU95OVOBB-f
-"""
-
-!pip install rouge_score torch_geometric
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from transformers import T5ForConditionalGeneration, T5Tokenizer
-from transformers.modeling_outputs import BaseModelOutput
-from torch_geometric.nn import GINEConv, global_mean_pool
-
-import os
-import pickle
-from huggingface_hub import hf_hub_download
-
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-LATENT_TOKENS = 192
-D_MODEL = 512
-GEN_MAX_LEN = 640
-SAVE_DIR = "./graph2latent_ckpts"
-BATCH_SIZE=8
-os.makedirs(SAVE_DIR, exist_ok=True)
-
-import torch
-import torch.nn as nn
-from transformers import T5Tokenizer, T5ForConditionalGeneration
-from transformers.modeling_outputs import BaseModelOutput
-
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-MODEL_NAME = "t5-small"
-LATENT_TOKENS = 192
-D_MODEL = 512
-TRAIN_MAX_LEN = 384
-GEN_MAX_LEN = 640
-
-
-class LatentPrefixAE(nn.Module):
-    def __init__(self):
-        super().__init__()
-
-        self.tokenizer = T5Tokenizer.from_pretrained(MODEL_NAME)
-        self.model = T5ForConditionalGeneration.from_pretrained(MODEL_NAME)
-
-        # MUST EXIST (checkpoint depends on it)
-        self.from_enc = nn.Sequential(
-            nn.LayerNorm(D_MODEL),
-            nn.Linear(D_MODEL, D_MODEL),
-            nn.GELU(),
-            nn.Linear(D_MODEL, D_MODEL)
-        )
-
-        self.to(DEVICE)
-        self.model.to(DEVICE)
-
-    @torch.no_grad()
-    def encode(self, texts):
-        tok = self.tokenizer(
-            texts,
-            padding=True,
-            truncation=True,
-            max_length=TRAIN_MAX_LEN,
-            return_tensors="pt"
-        ).to(DEVICE)
-
-        enc = self.model.encoder(
-            input_ids=tok.input_ids,
-            attention_mask=tok.attention_mask
-        ).last_hidden_state
-
-        prefix = self.from_enc(enc[:, :LATENT_TOKENS, :])
-        return prefix
-
-    @torch.no_grad()
-    def decode(self, latent):
-        out = self.model.generate(
-            encoder_outputs=BaseModelOutput(last_hidden_state=latent),
-            max_length=GEN_MAX_LEN,
-            num_beams=1,
-            do_sample=False
-        )
-        return self.tokenizer.batch_decode(out, skip_special_tokens=True)
-
-class GraphToLatent(nn.Module):
-    def __init__(self):
-        super().__init__()
-        H = 256
-        # Initial linear layer to project node features to H dimensions
-        self.node_proj = nn.Linear(9, H) # Assuming node features are 9-dimensional
-
-        self.convs = nn.ModuleList([
-            GINEConv(nn.Sequential(nn.Linear(H, H), nn.ReLU(), nn.Linear(H, H)), edge_dim=3) # Add edge_dim=3
-            for _ in range(3)
-        ])
-        self.norms = nn.ModuleList([nn.LayerNorm(H) for _ in range(3)])
-
-        self.readout = nn.Sequential(
-            nn.Linear(H, 1024),
-            nn.ReLU(),
-            nn.Linear(1024, 192 * 512)
-        )
-
-    def forward(self, batch):
-        x = self.node_proj(batch.x.float()) # Project node features
-        for conv, norm in zip(self.convs, self.norms):
-            # Pass edge_attr to the GINEConv layer
-            x = norm(x + conv(x, batch.edge_index, edge_attr=batch.edge_attr.float()))
-        g = global_mean_pool(x, batch.batch)
-        return self.readout(g).view(-1, 192, 512)
-
-import torch.nn.functional as F
-
-def latent_loss(pred, target):
-    mse = F.mse_loss(pred, target)
-    cos = 1 - F.cosine_similarity(
-        pred.flatten(1),
-        target.flatten(1),
-        dim=-1
-    ).mean()
-    return mse + 0.01 * cos
-
-from transformers.modeling_outputs import BaseModelOutput
-from tqdm import tqdm
-
-def train_epoch(model, loader, optimizer, latent_ae, lambda_dec=0.5):
-    model.train()
-    total = 0.0
-
-    for graph, latent, text in tqdm(loader, leave=False):
-        graph = graph.to(DEVICE)
-        latent = latent.to(DEVICE)
-
-        # ── Graph → latent ─────────────────────
-        pred_latent = model(graph)
-
-        # small latent noise (robustness)
-        pred_latent = pred_latent + 0.02 * torch.randn_like(pred_latent)
-
-        loss_lat = latent_loss(pred_latent, latent)
-
-        # ── Decoder loss (teacher forcing) ─────
-        tok = latent_ae.tokenizer(
-            text,
-            padding=True,
-            truncation=True,
-            max_length=384,
-            return_tensors="pt"
-        ).to(DEVICE)
-
-        dec_out = latent_ae.model(
-            encoder_outputs=BaseModelOutput(last_hidden_state=pred_latent),
-            labels=tok.input_ids
-        )
-
-        loss = loss_lat + lambda_dec * dec_out.loss
-
-        optimizer.zero_grad()
-        loss.backward()
-        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
-        optimizer.step()
-
-        total += loss.item()
-
-    return total / len(loader)
-@torch.no_grad()
-def eval_epoch(model, loader, latent_ae, lambda_dec=0.5):
-    model.eval()
-    total = 0.0
-
-    for graph, latent, text in loader:
-        graph = graph.to(DEVICE)
-        latent = latent.to(DEVICE)
-
-        pred_latent = model(graph)
-        loss_lat = latent_loss(pred_latent, latent)
-
-        tok = latent_ae.tokenizer(
-            text,
-            padding=True,
-            truncation=True,
-            max_length=384,
-            return_tensors="pt"
-        ).to(DEVICE)
-
-        dec_out = latent_ae.model(
-            encoder_outputs=BaseModelOutput(last_hidden_state=pred_latent),
-            labels=tok.input_ids
-        )
-
-        total += (loss_lat + lambda_dec * dec_out.loss).item()
-
-    return total / len(loader)
-
-from nltk.translate.bleu_score import corpus_bleu
-from rouge_score import rouge_scorer
-import numpy as np
-
-@torch.no_grad()
-def evaluate_bleu_rouge(model, loader, latent_ae, max_print=10):
-    model.eval()
-
-    refs, hyps = [], []
-
-    for graph, latent, _ in tqdm(loader):
-        graph = graph.to(DEVICE)
-
-        pred_latent = model(graph)
-        preds = latent_ae.decode(pred_latent)
-        golds = latent_ae.decode(latent.to(DEVICE))
-
-        for r, h in zip(golds, preds):
-            refs.append([r.split()])
-            hyps.append(h.split())
-
-    bleu = corpus_bleu(refs, hyps)
-
-    scorer = rouge_scorer.RougeScorer(["rougeL"], use_stemmer=True)
-    rouge = np.mean([
-        scorer.score(" ".join(r[0]), " ".join(h))["rougeL"].fmeasure
-        for r, h in zip(refs, hyps)
-    ])
-
-    print(f"\nBLEU  = {bleu:.4f}")
-    print(f"ROUGE = {rouge:.4f}")
-
-    print("\n--- Examples ---")
-    for i in range(min(max_print, len(hyps))):
-        print(f"\nREF : {' '.join(refs[i][0])}")
-        print(f"PRED: {' '.join(hyps[i])}")
-
-    return bleu, rouge
-
-pkl = hf_hub_download("TheoSG/Altegrad", "train_graphs.pkl", repo_type="dataset")
-train_graphs = pickle.load(open(pkl, "rb"))
-
-pkl = hf_hub_download("TheoSG/Altegrad", "validation_graphs.pkl", repo_type="dataset")
-val_graphs = pickle.load(open(pkl, "rb"))
-
-train_id2text = {g.id: g.description for g in train_graphs}
-val_id2text   = {g.id: g.description for g in val_graphs}
-from huggingface_hub import hf_hub_download
-
-latent_ae = LatentPrefixAE()
-
-ckpt = hf_hub_download(
-    repo_id="TheoSG/Altegrad",
-    filename="LatentPrefixAE.pt",
-    repo_type="dataset"
-)
-
-state = torch.load(ckpt, map_location=DEVICE)
-latent_ae.load_state_dict(state["model_state_dict"], strict=False)
-latent_ae.eval()
-
-print("✅ LatentPrefixAE loaded correctly (0.99 BLEU model)")
-class GraphLatentDataset(torch.utils.data.Dataset):
-    def __init__(self, graphs, id2text, ae):
-        self.graphs = graphs
-        self.texts = [id2text[g.id] for g in graphs]
-        self.ae = ae
-
-    def __len__(self):
-        return len(self.graphs)
-
-    def __getitem__(self, idx):
-        g = self.graphs[idx]
-        text = self.texts[idx]
-
-        with torch.no_grad():
-            latent = self.ae.encode([text])[0]
-
-        if latent.size(0) < LATENT_TOKENS:
-            pad = torch.zeros(LATENT_TOKENS - latent.size(0), D_MODEL).to(latent.device)
-            latent = torch.cat([latent, pad], 0)
-        else:
-            latent = latent[:LATENT_TOKENS]
-
-        return g, latent, text
-from torch_geometric.loader import DataLoader as PyGDataLoader
-train_ds = GraphLatentDataset(train_graphs, train_id2text, latent_ae)
-val_ds   = GraphLatentDataset(val_graphs, val_id2text, latent_ae)
-
-train_loader = PyGDataLoader(train_ds, batch_size=BATCH_SIZE, shuffle=True)
-val_loader   = PyGDataLoader(val_ds, batch_size=BATCH_SIZE)
-
-model = GraphToLatent().to(DEVICE)
-optimizer = torch.optim.AdamW(model.parameters(), lr=2e-4)
-
-EPOCHS = 5
-lambda_dec = 0.5   # decoder importance
-
-for epoch in range(1, EPOCHS + 1):
-    train_loss = train_epoch(
-        model,
-        train_loader,
-        optimizer,
-        latent_ae,
-        lambda_dec
-    )
-
-    val_loss = eval_epoch(
-        model,
-        val_loader,
-        latent_ae,
-        lambda_dec
-    )
-
-    # save weights
-    ckpt_path = f"{SAVE_DIR}/graph2latent_epoch{epoch}.pt"
-    torch.save(model.state_dict(), ckpt_path)
-
-    print(
-        f"\nEpoch {epoch:02d} | "
-        f"train_loss={train_loss:.4f} | "
-        f"val_loss={val_loss:.4f}"
-    )
-
-# BLEU / ROUGE every epoch
-bleu, rouge = evaluate_bleu_rouge(
-    model,
-    val_loader,
-    latent_ae,
-    max_print=10
-)
-
-print(f"\nBLEU  = {bleu:.4f}")
-print(f"ROUGE = {rouge:.4f}")
-