Upload train.py with huggingface_hub

train.py

@@ -0,0 +1,188 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import pickle
+import numpy as np
+from torch.utils.data import Dataset, DataLoader
+from sklearn.utils.class_weight import compute_class_weight
+from sklearn.metrics import classification_report, confusion_matrix
+from huggingface_hub import HfApi
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+api = HfApi()
+
+EMOTIONS = ["neutral", "happy", "sad", "angry", "fear", "surprise"]
+INPUT_DIM = 1280
+
+
+class EmotionDataset(Dataset):
+    def __init__(self, records):
+        self.features = torch.tensor(
+            np.stack([r["features"] for r in records]), dtype=torch.float32
+        )
+        self.labels = torch.tensor([r["label"] for r in records], dtype=torch.long)
+
+    def __len__(self):
+        return len(self.labels)
+
+    def __getitem__(self, i):
+        return self.features[i], self.labels[i]
+
+
+class EmotionHead(nn.Module):
+    def __init__(self, input_dim=INPUT_DIM, hidden=512, num_classes=6, dropout=0.3):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim, hidden),
+            nn.BatchNorm1d(hidden),
+            nn.ReLU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden, hidden // 2),
+            nn.BatchNorm1d(hidden // 2),
+            nn.ReLU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden // 2, num_classes),
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+
+print("Cargando features...")
+with open("features.pkl", "rb") as f:
+    records = pickle.load(f)
+
+train_r = [r for r in records if r.get("split", "train") == "train"]
+val_r = [r for r in records if r.get("split", "train") == "validation"]
+test_r = [r for r in records if r.get("split", "train") == "test"]
+
+if not val_r:
+    np.random.shuffle(records)
+    n = len(records)
+    train_r = records[: int(n * 0.70)]
+    val_r = records[int(n * 0.70) : int(n * 0.85)]
+    test_r = records[int(n * 0.85) :]
+
+print(f"Train: {len(train_r)} | Val: {len(val_r)} | Test: {len(test_r)}")
+
+train_ds = EmotionDataset(train_r)
+val_ds = EmotionDataset(val_r)
+test_ds = EmotionDataset(test_r)
+
+train_loader = DataLoader(train_ds, batch_size=32, shuffle=True)
+val_loader = DataLoader(val_ds, batch_size=32)
+test_loader = DataLoader(test_ds, batch_size=32)
+
+labels_array = np.array([r["label"] for r in train_r])
+class_weights = compute_class_weight("balanced", classes=np.arange(6), y=labels_array)
+weights_tensor = torch.FloatTensor(class_weights).to("cuda")
+
+device = torch.device("cuda")
+model = EmotionHead().to(device)
+criterion = nn.CrossEntropyLoss(weight=weights_tensor)
+optimizer = optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)
+scheduler = optim.lr_scheduler.ReduceLROnPlateau(
+    optimizer, patience=8, factor=0.5, verbose=True
+)
+
+best_val_f1 = 0
+history = {"train_loss": [], "val_loss": [], "val_acc": []}
+
+print("\nTraining...")
+for epoch in range(150):
+    model.train()
+    train_loss = 0
+    for features, labels in train_loader:
+        features, labels = features.to(device), labels.to(device)
+        optimizer.zero_grad()
+        loss = criterion(model(features), labels)
+        loss.backward()
+        optimizer.step()
+        train_loss += loss.item()
+    train_loss /= len(train_loader)
+
+    model.eval()
+    val_loss, correct, total = 0, 0, 0
+    with torch.no_grad():
+        for features, labels in val_loader:
+            features, labels = features.to(device), labels.to(device)
+            logits = model(features)
+            val_loss += criterion(logits, labels).item()
+            correct += (logits.argmax(1) == labels).sum().item()
+            total += len(labels)
+    val_loss /= len(val_loader)
+    val_acc = correct / total
+
+    scheduler.step(val_loss)
+    history["train_loss"].append(train_loss)
+    history["val_loss"].append(val_loss)
+    history["val_acc"].append(val_acc)
+
+    if epoch % 20 == 0 or epoch == 149:
+        print(
+            f"Epoch {epoch:3d} | train={train_loss:.3f} | val={val_loss:.3f} | acc={val_acc:.2%}"
+        )
+
+    if val_acc > best_val_f1:
+        best_val_f1 = val_acc
+        torch.save(model.state_dict(), "emotion_head_best.pt")
+
+print(f"\nMejor val acc: {best_val_f1:.2%}")
+
+model.load_state_dict(torch.load("emotion_head_best.pt"))
+model.eval()
+all_preds, all_labels = [], []
+with torch.no_grad():
+    for features, labels in test_loader:
+        preds = model(features.to(device)).argmax(1).cpu()
+        all_preds.extend(preds.numpy())
+        all_labels.extend(labels.numpy())
+
+print("\n=== RESULTADOS EN TEST SET ===")
+print(classification_report(all_labels, all_preds, target_names=EMOTIONS))
+
+cm = confusion_matrix(all_labels, all_preds)
+plt.figure(figsize=(8, 6))
+sns.heatmap(
+    cm, annot=True, fmt="d", xticklabels=EMOTIONS, yticklabels=EMOTIONS, cmap="Blues"
+)
+plt.title("Confusion matrix — EmotionHead")
+plt.tight_layout()
+plt.savefig("confusion_matrix.png", dpi=150)
+print("Saved: confusion_matrix.png")
+
+plt.figure(figsize=(8, 4))
+plt.plot(history["train_loss"], label="train loss")
+plt.plot(history["val_loss"], label="val loss")
+plt.legend()
+plt.title("Training curve")
+plt.savefig("training_curve.png", dpi=150)
+print("Saved: training_curve.png")
+
+print("\nUploading emotion_head_best.pt to HuggingFace...")
+api.upload_file(
+    path_or_fileobj="emotion_head_best.pt",
+    path_in_repo="emotion_head_best.pt",
+    repo_id="MrlolDev/voxtral-emotion-speech",
+    repo_type="dataset",
+)
+print("✅ emotion_head_best.pt uploaded")
+
+print("\nUploading confusion_matrix.png to HuggingFace...")
+api.upload_file(
+    path_or_fileobj="confusion_matrix.png",
+    path_in_repo="confusion_matrix.png",
+    repo_id="MrlolDev/voxtral-emotion-speech",
+    repo_type="dataset",
+)
+print("✅ confusion_matrix.png uploaded")
+
+print("\nUploading training_curve.png to HuggingFace...")
+api.upload_file(
+    path_or_fileobj="training_curve.png",
+    path_in_repo="training_curve.png",
+    repo_id="MrlolDev/voxtral-emotion-speech",
+    repo_type="dataset",
+)
+print("✅ training_curve.png subido")