Upload KAGGLE_NOTEBOOK.md with huggingface_hub

KAGGLE_NOTEBOOK.md

@@ -0,0 +1,191 @@
+# 🎵 Spotify Genre Classifier - Kaggle Notebook
+
+## Cell 1: Install Dependencies
+```python
+!pip install -q transformers datasets accelerate evaluate scikit-learn python-dotenv tqdm
+```
+
+## Cell 2: Import and Setup Secrets
+```python
+from kaggle_secrets import UserSecretsClient
+import os
+
+# Get secrets from Kaggle
+user_secrets = UserSecretsClient()
+os.environ['HF_TOKEN'] = user_secrets.get_secret("HF_TOKEN")
+os.environ['HF_USERNAME'] = user_secrets.get_secret("HF_USERNAME")
+
+print(f"✓ Logged in as: {os.environ['HF_USERNAME']}")
+```
+
+## Cell 3: Check GPU
+```python
+import torch
+
+if torch.cuda.is_available():
+    print(f"✓ GPU Available: {torch.cuda.get_device_name(0)}")
+    print(f"  GPU Count: {torch.cuda.device_count()}")
+else:
+    print("⚠ No GPU - using CPU (slower)")
+```
+
+## Cell 4: Load Dataset
+```python
+from datasets import load_dataset
+
+print("📊 Loading dataset...")
+dataset = load_dataset("maharshipandya/spotify-tracks-dataset")
+print(f"✓ Loaded {len(dataset['train'])} tracks")
+```
+
+## Cell 5: Load Model
+```python
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+model_name = "gpt2"
+print(f"🤖 Loading model: {model_name}")
+
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
+
+# Get unique genres
+genres = sorted(set(dataset['train']['track_genre']))
+num_labels = len(genres)
+label2id = {g: i for i, g in enumerate(genres)}
+id2label = {i: g for i, g in enumerate(genres)}
+
+model = AutoModelForSequenceClassification.from_pretrained(
+    model_name, 
+    num_labels=num_labels,
+    id2label=id2label,
+    label2id=label2id
+)
+
+print(f"✓ Model loaded: {num_labels} genres")
+```
+
+## Cell 6: Preprocess Data
+```python
+def tokenize(ex):
+    texts = [str(t) if t else "" for t in ex['track_name']]
+    tokenized = tokenizer(texts, padding='max_length', truncation=True, max_length=128)
+    tokenized['labels'] = [label2id[l] for l in ex['track_genre']]
+    return tokenized
+
+print("🔧 Preprocessing...")
+tokenized_dataset = dataset.map(tokenize, batched=True, remove_columns=dataset['train'].column_names)
+
+# Create validation split
+splits = tokenized_dataset['train'].train_test_split(test_size=0.1)
+tokenized_dataset = {
+    'train': splits['train'],
+    'validation': splits['test']
+}
+
+print(f"✓ Train: {len(tokenized_dataset['train'])}, Val: {len(tokenized_dataset['validation'])}")
+```
+
+## Cell 7: Training
+```python
+from transformers import TrainingArguments, Trainer
+import numpy as np
+import evaluate
+
+# Metrics
+def compute_metrics(eval_pred):
+    predictions = np.argmax(eval_pred.predictions, axis=1)
+    accuracy = evaluate.load("accuracy")
+    f1 = evaluate.load("f1")
+    return {
+        'accuracy': accuracy.compute(predictions=predictions, references=eval_pred.label_ids)['accuracy'],
+        'f1_macro': f1.compute(predictions=predictions, references=eval_pred.label_ids, average='macro')['f1']
+    }
+
+# Training args
+training_args = TrainingArguments(
+    output_dir="./model",
+    num_train_epochs=3,
+    per_device_train_batch_size=16,
+    per_device_eval_batch_size=32,
+    learning_rate=5e-5,
+    fp16=True,  # Use mixed precision on GPU
+    eval_strategy="epoch",
+    save_strategy="epoch",
+    load_best_model_at_end=True,
+    logging_steps=50,
+    report_to="none"
+)
+
+# Trainer
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=tokenized_dataset['train'],
+    eval_dataset=tokenized_dataset['validation'],
+    processing_class=tokenizer,
+    compute_metrics=compute_metrics
+)
+
+print("🚀 Starting training...")
+trainer.train()
+print("✓ Training complete!")
+```
+
+## Cell 8: Evaluate
+```python
+print("📈 Evaluating...")
+metrics = trainer.evaluate()
+print(f"Final Accuracy: {metrics['eval_accuracy']:.4f}")
+print(f"Final F1: {metrics['eval_f1_macro']:.4f}")
+```
+
+## Cell 9: Save Model
+```python
+model.save_pretrained("./final_model")
+tokenizer.save_pretrained("./final_model")
+print("💾 Model saved to ./final_model")
+```
+
+## Cell 10: Test Predictions
+```python
+import torch
+
+test_tracks = [
+    "Bohemian Rhapsody",
+    "Shape of You",
+    "Old Town Road",
+    "Blinding Lights",
+    "Bad Guy"
+]
+
+model.eval()
+print("\n🎵 Predictions:")
+for track in test_tracks:
+    inputs = tokenizer(track, return_tensors='pt', truncation=True, max_length=128)
+    if torch.cuda.is_available():
+        inputs = {k: v.cuda() for k, v in inputs.items()}
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+        pred_id = torch.argmax(outputs.logits, dim=-1).item()
+        conf = torch.softmax(outputs.logits, dim=-1)[0, pred_id].item()
+    
+    print(f"  '{track}' → {id2label[pred_id]} ({conf:.2%})")
+```
+
+## Cell 11: Push to Hub (Optional)
+```python
+from huggingface_hub import login
+
+hf_token = os.environ['HF_TOKEN']
+username = os.environ['HF_USERNAME']
+
+login(token=hf_token)
+
+repo_name = "spotify-genre-classifier"
+model.push_to_hub(f"{username}/{repo_name}")
+tokenizer.push_to_hub(f"{username}/{repo_name}")
+
+print(f"✅ Model pushed to: https://huggingface.co/{username}/{repo_name}")
+```