Spaces:
Sleeping
Sleeping
Download train.py from hephaestusonfire/Music_Generator: direct link, hf CLI and curl.
- Browser
- Download file 7.13 kB
-
https://huggingface.co/spaces/hephaestusonfire/Music_Generator/resolve/main/train.py
- Command line
-
hf download hf://spaces/hephaestusonfire/Music_Generator/train.py
-
curl -L -o train.py https://huggingface.co/spaces/hephaestusonfire/Music_Generator/resolve/main/train.py
7.13 kB
| import os | |
| from typing import Tuple | |
| import numpy as np | |
| import torch | |
| import torch.nn as nn | |
| from torch.utils.data import DataLoader, TensorDataset, random_split | |
| import config | |
| from model import build_model | |
| def load_dataset_npz(path: str) -> Tuple[torch.Tensor, torch.Tensor]: | |
| data = np.load(path) | |
| X = data["X"].astype(np.float32) | |
| Y = data["Y"].astype(np.float32) | |
| return torch.from_numpy(X), torch.from_numpy(Y) | |
| def load_dataset_pt(path: str) -> Tuple[torch.Tensor, torch.Tensor]: | |
| data = torch.load(path) | |
| return data["X"].float(), data["Y"].float() | |
| def train( | |
| dataset_path: str, | |
| use_npz: bool = True, | |
| batch_size: int = 32, | |
| num_epochs: int = 20, | |
| val_split: float = 0.1, | |
| learning_rate: float = 1e-3, | |
| device: str = None, | |
| save_dir: str = "models", | |
| best_name: str = "transformer_music_best.pt", | |
| last_name: str = "transformer_music_last.pt", | |
| checkpoint_name: str = "transformer_music_checkpoint.pt", | |
| extra_epochs: int = None, | |
| ) -> None: | |
| """ | |
| Train MusicTransformer with resume & best-model saving. | |
| If extra_epochs is not None, the function will: | |
| - load checkpoint (if any) and read checkpoint["epoch"] as last_epoch, | |
| - start from last_epoch + 1, | |
| - run for exactly extra_epochs epochs (end_epoch = last_epoch + extra_epochs). | |
| If extra_epochs is None, num_epochs is treated as a global target: | |
| - start from start_epoch (1 or checkpoint_epoch+1), | |
| - run until epoch == num_epochs. | |
| """ | |
| if device is None: | |
| device = "cuda" if torch.cuda.is_available() else "cpu" | |
| # Load dataset | |
| if use_npz: | |
| X, Y = load_dataset_npz(dataset_path) | |
| else: | |
| X, Y = load_dataset_pt(dataset_path) | |
| print(f"Loaded dataset: X {X.shape}, Y {Y.shape}") | |
| dataset = TensorDataset(X, Y) | |
| # Train/val split | |
| n_total = len(dataset) | |
| n_val = int(n_total * val_split) | |
| n_train = n_total - n_val | |
| train_ds, val_ds = random_split(dataset, [n_train, n_val]) | |
| train_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True) | |
| val_loader = DataLoader(val_ds, batch_size=batch_size, shuffle=False) | |
| # Build model, optimizer, loss | |
| model = build_model(config).to(device) | |
| bce = nn.BCEWithLogitsLoss() | |
| optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) | |
| os.makedirs(save_dir, exist_ok=True) | |
| best_model_path = os.path.join(save_dir, best_name) | |
| last_model_path = os.path.join(save_dir, last_name) | |
| checkpoint_path = os.path.join(save_dir, checkpoint_name) | |
| # ===== Resume from checkpoint if present ===== | |
| start_epoch = 1 | |
| best_val_loss = float("inf") | |
| if os.path.exists(checkpoint_path): | |
| print(f"Found checkpoint at {checkpoint_path}, loading...") | |
| checkpoint = torch.load(checkpoint_path, map_location=device) | |
| model.load_state_dict(checkpoint["model_state_dict"]) | |
| optimizer.load_state_dict(checkpoint["optimizer_state_dict"]) | |
| start_epoch = checkpoint["epoch"] + 1 | |
| best_val_loss = checkpoint["best_val_loss"] | |
| print(f"Resuming from epoch {start_epoch}, best_val_loss={best_val_loss:.4f}") | |
| # Determine end_epoch based on extra_epochs / num_epochs | |
| if extra_epochs is not None: | |
| # Run exactly extra_epochs from the current checkpoint point | |
| end_epoch = start_epoch + extra_epochs - 1 | |
| else: | |
| # Run until global num_epochs | |
| end_epoch = num_epochs | |
| if start_epoch > end_epoch: | |
| print(f"No epochs to run (start_epoch={start_epoch}, end_epoch={end_epoch}).") | |
| print("Training complete.") | |
| print(f"Best model: {best_model_path}") | |
| print(f"Last model: {last_model_path}") | |
| return | |
| # ===== Training loop ===== | |
| for epoch in range(start_epoch, end_epoch + 1): | |
| model.train() | |
| train_loss_sum = 0.0 | |
| train_batches = 0 | |
| for X_batch, Y_batch in train_loader: | |
| X_batch = X_batch.to(device) # [B, T, 39] | |
| Y_batch = Y_batch.to(device) # [B, T, 39] | |
| optimizer.zero_grad() | |
| outputs = model(X_batch) | |
| # Slice per-instrument targets | |
| strings_target = Y_batch[:, :, 0:12] | |
| woodwinds_target = Y_batch[:, :, 12:24] | |
| brass_target = Y_batch[:, :, 24:36] | |
| perc_target = Y_batch[:, :, 36:39] | |
| loss_strings = bce(outputs["strings"], strings_target) | |
| loss_wood = bce(outputs["woodwinds"], woodwinds_target) | |
| loss_brass = bce(outputs["brass"], brass_target) | |
| loss_perc = bce(outputs["perc"], perc_target) | |
| loss = loss_strings + loss_wood + loss_brass + loss_perc | |
| loss.backward() | |
| optimizer.step() | |
| train_loss_sum += loss.item() | |
| train_batches += 1 | |
| avg_train_loss = train_loss_sum / max(train_batches, 1) | |
| # Validation | |
| model.eval() | |
| val_loss_sum = 0.0 | |
| val_batches = 0 | |
| with torch.no_grad(): | |
| for X_batch, Y_batch in val_loader: | |
| X_batch = X_batch.to(device) | |
| Y_batch = Y_batch.to(device) | |
| outputs = model(X_batch) | |
| strings_target = Y_batch[:, :, 0:12] | |
| woodwinds_target = Y_batch[:, :, 12:24] | |
| brass_target = Y_batch[:, :, 24:36] | |
| perc_target = Y_batch[:, :, 36:39] | |
| loss_strings = bce(outputs["strings"], strings_target) | |
| loss_wood = bce(outputs["woodwinds"], woodwinds_target) | |
| loss_brass = bce(outputs["brass"], brass_target) | |
| loss_perc = bce(outputs["perc"], perc_target) | |
| loss = loss_strings + loss_wood + loss_perc + loss_brass | |
| val_loss_sum += loss.item() | |
| val_batches += 1 | |
| avg_val_loss = val_loss_sum / max(val_batches, 1) | |
| print( | |
| f"Epoch {epoch:03d} | " | |
| f"Train loss: {avg_train_loss:.4f} | " | |
| f"Val loss: {avg_val_loss:.4f}" | |
| ) | |
| # ===== Save checkpoint (for resume) ===== | |
| checkpoint = { | |
| "epoch": epoch, | |
| "model_state_dict": model.state_dict(), | |
| "optimizer_state_dict": optimizer.state_dict(), | |
| "best_val_loss": best_val_loss, | |
| } | |
| torch.save(checkpoint, checkpoint_path) | |
| print(f" ↳ Checkpoint saved to {checkpoint_path}") | |
| # ===== Best model logic ===== | |
| if avg_val_loss < best_val_loss: | |
| best_val_loss = avg_val_loss | |
| torch.save(model.state_dict(), best_model_path) | |
| print(f" ↳ New best model saved to {best_model_path}") | |
| # Always save "last" model as well (optional) | |
| torch.save(model.state_dict(), last_model_path) | |
| print("Training complete.") | |
| print(f"Best model: {best_model_path}") | |
| print(f"Last model: {last_model_path}") | |
| if __name__ == "__main__": | |
| dataset_path = "musicnet_grid_dataset.npz" | |
| train( | |
| dataset_path=dataset_path, | |
| use_npz=True, | |
| batch_size=32, | |
| num_epochs=20, | |
| val_split=0.1, | |
| learning_rate=1e-3, | |
| ) |