Add notebooks and kaggle data for GitHub, configure HuggingFace ignore

.gitignore

@@ -9,12 +9,4 @@ __pycache__/
 wandb/
 .venv/
 .env
-kaggle/
-main.ipynb
-training_notebook.ipynb
-submission_notebook.ipynb
-submission_scratch_notebook.ipynb
-training_scratch_notebook.ipynb
-main_code_explanation.md
-gradio_app.py
 .env.example

.huggingface-ignore

@@ -0,0 +1,6 @@
+# Exclude notebooks from HuggingFace Spaces
+*.ipynb
+main_code_explanation.md
+
+# Exclude kaggle data
+kaggle/

gradio_app.py

@@ -0,0 +1,230 @@
+"""
+Gradio Deployment App for Emotion Classification Model
+This app loads the trained model from HuggingFace Hub and creates an interactive interface.
+"""
+
+import gradio as gr
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import numpy as np
+from huggingface_hub import hf_hub_download
+
+# Configuration
+HF_REPO_ID = "hrshlgunjal/emotion-classifier-deberta-v3"  # UPDATE THIS!
+LABELS = ["anger", "fear", "joy", "sadness", "surprise"]
+MAX_LEN = 128
+
+# Load model and tokenizer
+print("Loading model from HuggingFace Hub...")
+model = AutoModelForSequenceClassification.from_pretrained(
+    HF_REPO_ID,
+    num_labels=len(LABELS),
+    problem_type="multi_label_classification"
+)
+tokenizer = AutoTokenizer.from_pretrained(HF_REPO_ID)
+model.eval()
+print("✅ Model loaded successfully!")
+
+# Load optimized thresholds
+print("Loading optimized thresholds...")
+try:
+    threshold_path = hf_hub_download(
+        repo_id=HF_REPO_ID,
+        filename="best_thresholds.npy"
+    )
+    thresholds = np.load(threshold_path)
+    print("✅ Optimized thresholds loaded!")
+except Exception as e:
+    print(f"⚠️  Could not load thresholds: {e}")
+    print("Using default thresholds of 0.5")
+    thresholds = np.array([0.5] * len(LABELS))
+
+# Prediction function
+def predict_emotions(text):
+    """
+    Predict emotions from input text.
+    
+    Args:
+        text (str): Input text to analyze
+        
+    Returns:
+        dict: Probability scores for each emotion
+    """
+    if not text.strip():
+        return {label: 0.0 for label in LABELS}
+    
+    # Tokenize
+    inputs = tokenizer(
+        text,
+        return_tensors="pt",
+        truncation=True,
+        max_length=MAX_LEN,
+        padding=True
+    )
+    
+    # Predict
+    with torch.no_grad():
+        outputs = model(**inputs)
+    
+    # Get probabilities
+    probs = torch.sigmoid(outputs.logits).cpu().numpy()[0]
+    
+    # Apply thresholds for binary predictions
+    predictions = (probs >= thresholds).astype(int)
+    
+    # Create result dictionary
+    result = {}
+    for i, label in enumerate(LABELS):
+        result[label] = float(probs[i])
+    
+    return result
+
+def predict_with_explanation(text):
+    """
+    Predict emotions and provide detailed explanation.
+    
+    Args:
+        text (str): Input text to analyze
+        
+    Returns:
+        tuple: (emotion_scores, explanation_text)
+    """
+    if not text.strip():
+        return {label: 0.0 for label in LABELS}, "Please enter some text to analyze."
+    
+    # Get predictions
+    result = predict_emotions(text)
+    
+    # Create explanation
+    detected_emotions = []
+    for label, score in result.items():
+        if score >= thresholds[LABELS.index(label)]:
+            detected_emotions.append(f"**{label.capitalize()}** ({score:.2%})")
+    
+    if detected_emotions:
+        explanation = f"**Detected Emotions:** {', '.join(detected_emotions)}\n\n"
+    else:
+        explanation = "**No strong emotions detected.**\n\n"
+    
+    explanation += "**All Emotion Scores:**\n"
+    for label, score in sorted(result.items(), key=lambda x: x[1], reverse=True):
+        bar = "█" * int(score * 20)
+        explanation += f"- {label.capitalize()}: {bar} {score:.2%}\n"
+    
+    return result, explanation
+
+# Example texts
+examples = [
+    ["I am so excited about this amazing opportunity!"],
+    ["I can't believe you did this to me. I'm so angry!"],
+    ["I'm terrified of what might happen next."],
+    ["This is the saddest day of my life."],
+    ["Wow! I didn't expect that at all!"],
+    ["I'm feeling really happy and grateful today."],
+    ["I'm so frustrated with this situation."],
+    ["This news is shocking and scary."],
+    ["I'm overjoyed and surprised by this wonderful gift!"],
+    ["I'm deeply saddened and disappointed."],
+]
+
+# Create Gradio interface
+with gr.Blocks(title="🎭 Emotion Classification") as demo:
+    gr.Markdown(
+        """
+        # 🎭 Emotion Classification Model
+        
+        This model analyzes text and identifies 5 emotions: **anger**, **fear**, **joy**, **sadness**, and **surprise**.
+        
+        ### Features:
+        - ✅ Multi-label classification (can detect multiple emotions)
+        - ✅ Based on DeBERTa-v3 transformer model
+        - ✅ Trained with 5-fold cross-validation
+        - ✅ Optimized thresholds for best performance
+        
+        ---
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            text_input = gr.Textbox(
+                label="Enter Text",
+                placeholder="Type or paste your text here...",
+                lines=5
+            )
+            
+            with gr.Row():
+                submit_btn = gr.Button("Analyze Emotions 🔍", variant="primary")
+                clear_btn = gr.Button("Clear 🗑️")
+        
+        with gr.Column(scale=1):
+            emotion_output = gr.Label(
+                label="Emotion Scores",
+                num_top_classes=5
+            )
+    
+    explanation_output = gr.Markdown(label="Detailed Analysis")
+    
+    # Example section
+    gr.Markdown("### 📝 Try These Examples:")
+    gr.Examples(
+        examples=examples,
+        inputs=text_input,
+        outputs=[emotion_output, explanation_output],
+        fn=predict_with_explanation,
+        cache_examples=False
+    )
+    
+    # Info section
+    gr.Markdown(
+        """
+        ---
+        
+        ### ℹ️ About This Model
+        
+        **Model:** microsoft/deberta-v3-base (fine-tuned)
+        
+        **Training:**
+        - 5-fold stratified cross-validation
+        - Mixed precision training (FP16)
+        - Threshold optimization for each emotion
+        
+        **Performance:**
+        - Macro F1 Score: [Your CV Score]
+        - Kaggle Score: 8.3+
+        
+        **Labels:**
+        - 😠 **Anger:** Expressions of anger, frustration, or annoyance
+        - 😨 **Fear:** Expressions of fear, anxiety, or worry
+        - 😊 **Joy:** Expressions of happiness, pleasure, or satisfaction
+        - 😢 **Sadness:** Expressions of sadness, sorrow, or disappointment
+        - 😲 **Surprise:** Expressions of surprise, shock, or amazement
+        
+        ---
+        
+        **Repository:** [HuggingFace Hub](https://huggingface.co/{})
+        
+        **Created for:** Deep Learning & Gen AI Project 2025
+        """.format(HF_REPO_ID)
+    )
+    
+    # Button actions
+    submit_btn.click(
+        fn=predict_with_explanation,
+        inputs=text_input,
+        outputs=[emotion_output, explanation_output]
+    )
+    
+    clear_btn.click(
+        fn=lambda: ("", {label: 0.0 for label in LABELS}, ""),
+        inputs=None,
+        outputs=[text_input, emotion_output, explanation_output]
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(
+        share=False,  # Set to True to create a public link
+        server_name="0.0.0.0",
+        server_port=7860
+    )

kaggle/input/2025-sep-dl-gen-ai-project/sample_submission.csv

@@ -0,0 +1,1708 @@
+id,anger,fear,joy,sadness,surprise
+0,1,0,0,0,1
+1,0,1,1,1,0
+2,1,1,0,0,1
+3,0,0,0,0,1
+4,1,1,1,0,0
+5,1,0,0,0,1
+6,0,0,0,1,0
+7,0,0,0,1,1
+8,0,0,1,1,1
+9,0,1,0,1,1
+10,1,1,1,0,0
+11,1,1,1,1,0
+12,0,1,0,1,0
+13,0,0,0,1,1
+14,0,1,1,0,1
+15,0,1,0,0,0
+16,0,1,0,1,0
+17,1,0,0,0,0
+18,0,1,0,0,1
+19,0,1,1,0,0
+20,1,0,0,1,0
+21,1,1,1,0,1
+22,0,0,1,0,1
+23,1,0,1,0,1
+24,1,1,0,1,0
+25,0,1,1,1,1
+26,0,0,0,0,1
+27,0,1,0,0,1
+28,0,1,1,1,1
+29,1,0,1,0,1
+30,0,1,1,1,0
+31,1,1,1,1,1
+32,0,0,1,0,0
+33,0,1,0,1,1
+34,0,0,0,0,1
+35,1,1,1,0,0
+36,1,1,0,0,0
+37,0,0,0,1,1
+38,1,0,0,0,0
+39,0,1,0,0,0
+40,0,0,1,1,0
+41,1,1,0,0,1
+42,1,1,0,0,1
+43,1,0,0,1,0
+44,1,0,1,0,0
+45,0,0,0,1,0
+46,1,0,1,0,1
+47,1,0,0,1,0
+48,1,0,1,1,1
+49,1,1,1,0,0
+50,0,0,0,1,1
+51,1,1,1,1,0
+52,1,1,0,0,1
+53,0,0,1,1,0
+54,0,0,0,0,0
+55,0,0,0,1,0
+56,0,0,0,1,0
+57,0,1,0,0,0
+58,1,0,0,0,0
+59,0,0,0,1,1
+60,0,0,1,0,0
+61,1,0,0,0,1
+62,1,1,1,0,1
+63,0,0,0,0,0
+64,0,0,0,1,0
+65,0,1,1,0,0
+66,1,1,0,1,0
+67,1,0,0,0,0
+68,1,0,0,1,1
+69,1,1,0,1,1
+70,0,0,1,1,1
+71,0,1,1,0,0
+72,1,1,0,1,1
+73,1,1,1,1,1
+74,1,1,1,0,1
+75,1,1,0,0,1
+76,0,1,0,1,1
+77,1,1,0,1,0
+78,0,1,1,1,1
+79,0,1,0,0,1
+80,0,0,1,0,1
+81,1,0,1,1,1
+82,1,0,1,0,1
+83,0,1,0,0,1
+84,0,1,0,1,0
+85,0,0,0,1,0
+86,1,1,1,1,1
+87,1,0,1,1,0
+88,0,1,0,1,0
+89,1,1,1,1,1
+90,1,1,0,1,1
+91,0,1,0,0,0
+92,1,0,0,0,1
+93,1,0,0,1,1
+94,1,1,0,1,0
+95,0,1,1,0,1
+96,0,1,0,0,1
+97,1,0,0,0,0
+98,1,1,1,1,1
+99,0,0,0,0,0
+100,0,1,1,1,0
+101,0,1,1,1,1
+102,1,1,1,1,0
+103,1,0,0,1,1
+104,0,0,0,1,0
+105,0,0,0,1,0
+106,0,1,1,0,0
+107,0,1,1,0,1
+108,1,1,0,1,1
+109,1,0,0,0,0
+110,0,1,1,1,1
+111,1,1,1,1,0
+112,0,0,1,1,0
+113,1,0,0,0,1
+114,1,0,0,0,0
+115,0,1,1,0,1
+116,0,0,0,0,0
+117,0,0,0,0,1
+118,1,1,0,0,0
+119,1,1,0,1,1
+120,0,1,1,1,1
+121,0,0,0,1,1
+122,0,1,0,0,0
+123,1,1,0,1,0
+124,1,1,0,0,0
+125,1,0,0,0,0
+126,0,1,0,1,0
+127,1,0,1,0,0
+128,1,0,0,0,1
+129,0,0,0,1,0
+130,1,1,0,0,1
+131,0,1,0,0,1
+132,0,1,0,1,1
+133,1,0,1,0,1
+134,1,1,0,0,0
+135,1,1,0,0,0
+136,1,1,1,1,0
+137,1,1,0,1,0
+138,0,1,0,1,0
+139,0,1,1,1,1
+140,0,0,1,0,0
+141,0,0,1,1,0
+142,0,1,1,0,1
+143,1,0,0,0,0
+144,0,0,1,1,1
+145,0,0,0,0,1
+146,0,1,0,0,0
+147,1,1,0,0,1
+148,1,0,0,0,0
+149,1,1,1,1,0
+150,1,1,0,1,1
+151,0,1,1,0,0
+152,1,1,1,1,0
+153,1,1,1,1,0
+154,1,1,0,1,0
+155,1,1,1,0,1
+156,0,1,0,1,1
+157,1,0,0,1,1
+158,1,1,1,0,0
+159,1,0,1,1,0
+160,1,1,0,1,0
+161,0,1,0,0,1
+162,1,1,1,0,1
+163,1,0,0,0,1
+164,0,1,1,1,1
+165,0,0,1,1,0
+166,0,0,0,0,1
+167,1,0,0,0,1
+168,0,0,0,1,0
+169,0,0,1,1,1
+170,0,1,0,1,1
+171,0,1,1,1,1
+172,0,0,1,1,0
+173,0,1,1,0,0
+174,1,0,1,1,1
+175,0,1,1,1,1
+176,0,1,0,0,0
+177,1,0,1,1,1
+178,0,0,1,1,0
+179,0,0,1,1,0
+180,0,1,0,1,0
+181,1,0,0,0,0
+182,1,0,1,1,1
+183,1,1,0,0,0
+184,0,0,0,1,0
+185,0,0,0,0,1
+186,1,0,1,0,1
+187,0,0,0,1,0
+188,0,1,0,0,0
+189,1,0,0,0,0
+190,0,0,0,1,1
+191,0,1,0,1,0
+192,0,1,0,0,0
+193,0,0,0,0,0
+194,1,0,0,0,1
+195,1,1,1,1,1
+196,0,0,0,1,1
+197,0,1,0,0,0
+198,0,1,0,1,1
+199,1,1,1,1,1
+200,1,1,0,0,1
+201,0,0,1,1,0
+202,0,0,1,1,1
+203,0,0,1,0,1
+204,1,1,0,0,1
+205,0,1,1,0,0
+206,0,1,0,1,0
+207,0,0,1,0,0
+208,0,1,0,0,1
+209,1,1,1,1,1
+210,1,0,1,1,0
+211,1,0,1,1,0
+212,1,1,1,1,1
+213,1,0,1,1,1
+214,0,1,0,1,1
+215,0,1,1,1,1
+216,1,0,0,0,0
+217,1,0,0,0,0
+218,0,1,0,1,0
+219,0,0,0,0,1
+220,0,0,1,1,0
+221,0,0,1,1,0
+222,1,1,0,0,0
+223,0,0,1,1,1
+224,1,0,0,0,1
+225,1,1,0,0,1
+226,0,0,1,0,1
+227,0,0,1,0,0
+228,1,1,1,0,1
+229,1,1,1,1,1
+230,1,1,0,1,1
+231,0,0,1,0,0
+232,0,0,1,1,1
+233,0,1,0,1,0
+234,0,0,0,1,0
+235,1,0,0,0,0
+236,0,1,0,0,1
+237,1,1,1,1,0
+238,0,0,1,0,1
+239,1,0,1,1,0
+240,1,1,0,0,0
+241,0,1,1,1,1
+242,1,0,0,0,1
+243,1,1,0,1,1
+244,0,1,1,1,1
+245,0,0,1,0,1
+246,1,1,1,1,1
+247,1,1,0,0,1
+248,1,0,0,0,1
+249,0,1,0,1,1
+250,1,1,0,1,1
+251,0,0,0,1,0
+252,0,1,0,0,0
+253,1,0,1,1,1
+254,1,1,1,1,1
+255,0,1,1,0,1
+256,1,0,0,0,0
+257,1,0,0,0,0
+258,1,1,1,1,0
+259,0,0,0,0,1
+260,1,1,0,1,1
+261,0,1,0,0,1
+262,1,0,0,1,1
+263,0,0,0,1,0
+264,0,1,0,1,0
+265,0,1,0,0,0
+266,1,0,1,0,0
+267,0,0,0,1,0
+268,1,1,0,0,0
+269,1,0,1,0,0
+270,0,0,0,0,0
+271,1,0,0,1,1
+272,1,0,0,0,1
+273,1,1,0,0,1
+274,1,0,1,0,1
+275,0,0,1,1,0
+276,1,1,0,1,0
+277,1,1,0,1,0
+278,0,1,1,1,1
+279,1,0,0,1,0
+280,1,1,1,1,0
+281,0,0,1,0,0
+282,0,0,1,1,1
+283,1,0,1,1,1
+284,1,1,0,1,1
+285,0,1,1,1,1
+286,0,0,0,0,1
+287,0,1,1,0,0
+288,1,1,0,1,1
+289,0,0,0,0,0
+290,0,1,0,0,0
+291,1,1,0,0,0
+292,0,0,1,0,0
+293,0,1,1,1,1
+294,1,1,0,1,1
+295,0,0,1,0,0
+296,1,0,0,1,0
+297,0,1,1,1,1
+298,1,0,0,1,1
+299,1,1,0,0,1
+300,0,1,1,0,1
+301,1,1,1,1,1
+302,0,0,1,1,1
+303,1,1,1,0,0
+304,1,0,0,0,1
+305,0,1,0,1,0
+306,0,1,1,1,1
+307,0,0,0,1,0
+308,0,1,0,1,0
+309,0,1,1,1,0
+310,0,1,0,0,1
+311,0,1,0,1,0
+312,1,0,0,1,0
+313,1,0,0,0,1
+314,0,0,0,1,0
+315,0,1,0,0,1
+316,0,0,0,0,0
+317,0,1,0,0,1
+318,1,1,1,1,0
+319,1,0,0,1,1
+320,1,0,0,1,0
+321,1,0,1,0,1
+322,1,1,0,1,0
+323,0,0,0,0,1
+324,1,1,1,0,0
+325,0,0,1,0,1
+326,0,1,1,0,0
+327,0,0,1,0,0
+328,0,0,0,1,0
+329,0,0,1,1,1
+330,1,1,1,0,1
+331,0,0,1,1,0
+332,0,1,0,1,0
+333,0,0,1,0,1
+334,1,1,1,0,0
+335,0,0,0,1,1
+336,1,0,0,0,1
+337,0,0,0,1,0
+338,0,1,1,0,0
+339,1,0,1,0,1
+340,1,1,1,0,0
+341,0,1,0,0,0
+342,1,0,1,0,0
+343,1,1,1,1,0
+344,0,1,0,1,1
+345,0,1,1,0,0
+346,1,1,0,1,1
+347,1,0,0,0,0
+348,1,0,0,1,1
+349,0,1,1,0,1
+350,0,1,0,1,1
+351,1,0,1,1,1
+352,0,1,0,0,1
+353,0,0,1,0,0
+354,1,0,1,0,1
+355,0,0,1,0,1
+356,1,0,1,1,0
+357,1,1,0,1,0
+358,0,0,0,1,1
+359,1,0,1,1,0
+360,0,0,1,1,1
+361,0,0,1,1,1
+362,0,1,0,1,0
+363,0,0,1,0,0
+364,0,1,1,0,1
+365,1,1,1,1,0
+366,0,0,1,1,1
+367,0,1,1,0,0
+368,0,1,1,0,1
+369,1,1,0,0,1
+370,0,0,0,0,1
+371,1,0,1,0,1
+372,1,1,1,1,0
+373,1,1,1,1,0
+374,0,0,0,0,0
+375,0,0,0,1,0
+376,1,0,0,0,1
+377,0,0,0,1,1
+378,0,1,1,0,1
+379,0,1,1,0,0
+380,1,1,1,1,0
+381,1,1,0,1,0
+382,1,0,0,1,0
+383,1,0,1,0,0
+384,1,1,1,0,1
+385,0,0,0,1,1
+386,1,1,0,0,1
+387,0,1,0,1,1
+388,0,1,1,1,0
+389,0,1,0,0,0
+390,1,0,1,1,0
+391,1,0,1,1,0
+392,0,1,0,1,1
+393,0,1,0,1,1
+394,0,0,1,1,1
+395,1,0,0,0,1
+396,0,1,0,0,0
+397,1,0,1,0,1
+398,1,0,0,1,0
+399,1,1,0,0,0
+400,0,0,1,0,1
+401,1,1,1,1,0
+402,1,0,1,1,0
+403,1,1,0,1,0
+404,1,1,0,0,1
+405,1,1,1,1,0
+406,1,0,0,0,0
+407,1,0,0,0,0
+408,1,0,1,1,0
+409,0,1,1,0,0
+410,1,1,0,0,0
+411,1,0,1,1,0
+412,0,1,1,0,0
+413,1,0,1,1,1
+414,1,1,0,0,0
+415,1,1,0,0,0
+416,0,1,1,0,1
+417,0,0,1,0,1
+418,0,0,1,1,0
+419,0,1,0,0,1
+420,1,1,1,1,1
+421,1,1,0,1,0
+422,0,0,1,1,1
+423,0,1,1,0,0
+424,1,0,0,0,0
+425,0,1,0,0,0
+426,1,0,0,1,1
+427,1,0,0,0,1
+428,1,0,1,1,0
+429,1,1,0,0,1
+430,0,1,1,0,0
+431,0,1,0,0,1
+432,1,0,1,0,0
+433,1,1,0,1,0
+434,0,1,0,0,0
+435,1,1,1,1,1
+436,1,0,0,0,0
+437,0,1,0,1,1
+438,0,1,0,0,0
+439,0,0,0,1,1
+440,0,1,1,0,1
+441,0,0,1,0,0
+442,0,1,0,1,1
+443,1,1,0,0,0
+444,1,1,0,0,1
+445,0,0,0,0,1
+446,0,0,1,0,1
+447,0,0,1,1,1
+448,1,0,0,0,0
+449,0,1,0,1,1
+450,0,0,1,1,1
+451,0,1,1,0,0
+452,0,1,0,1,0
+453,1,1,1,0,1
+454,1,1,1,0,0
+455,1,1,1,0,0
+456,1,1,1,0,0
+457,1,0,0,0,0
+458,0,0,0,1,0
+459,1,1,0,0,0
+460,0,0,0,1,0
+461,1,1,1,1,0
+462,0,0,1,1,1
+463,0,0,1,0,0
+464,0,1,1,1,1
+465,0,1,0,1,1
+466,0,0,0,1,1
+467,1,1,1,1,1
+468,1,1,1,1,1
+469,0,0,1,1,0
+470,1,1,0,1,1
+471,0,1,1,1,0
+472,0,1,0,0,1
+473,1,1,0,0,1
+474,1,0,1,0,1
+475,1,0,1,0,0
+476,1,1,1,0,1
+477,1,0,1,1,1
+478,1,0,0,1,0
+479,0,1,0,0,0
+480,1,0,0,1,0
+481,1,0,1,0,1
+482,1,0,0,0,0
+483,0,1,1,0,1
+484,1,1,1,1,0
+485,0,0,0,0,0
+486,1,1,1,0,0
+487,0,1,1,1,0
+488,1,1,1,0,0
+489,1,1,1,1,0
+490,0,0,0,0,1
+491,0,0,1,0,0
+492,0,1,0,1,0
+493,1,0,1,0,0
+494,1,0,0,1,0
+495,0,0,1,1,1
+496,1,0,0,0,0
+497,0,1,1,1,1
+498,1,1,1,1,0
+499,1,0,1,1,1
+500,1,1,1,0,1
+501,0,0,0,1,0
+502,0,0,0,0,0
+503,1,1,0,0,0
+504,1,1,1,1,0
+505,1,1,1,0,0
+506,0,1,0,1,0
+507,0,1,0,1,0
+508,1,0,0,1,1
+509,1,0,0,1,0
+510,0,1,0,1,1
+511,0,0,0,1,1
+512,0,1,1,1,0
+513,1,1,0,1,0
+514,1,1,1,0,0
+515,1,0,0,0,0
+516,0,1,1,0,0
+517,0,0,0,1,0
+518,1,1,0,1,1
+519,0,1,0,0,0
+520,0,0,0,0,1
+521,1,0,1,0,1
+522,1,1,0,1,1
+523,1,0,0,0,0
+524,0,0,1,1,0
+525,1,0,1,0,1
+526,1,1,0,0,0
+527,1,0,1,0,0
+528,1,0,1,1,1
+529,0,1,0,0,0
+530,0,0,0,0,1
+531,0,1,1,0,0
+532,0,1,1,0,1
+533,1,0,1,1,0
+534,1,1,1,1,0
+535,1,0,0,1,1
+536,1,1,1,0,1
+537,1,1,0,0,1
+538,0,1,0,1,1
+539,0,1,0,1,1
+540,0,1,0,1,1
+541,1,1,1,1,0
+542,1,1,0,1,1
+543,0,0,1,0,0
+544,0,1,0,1,0
+545,1,1,1,0,1
+546,0,1,1,0,0
+547,0,1,0,0,1
+548,1,1,0,1,0
+549,1,0,1,1,0
+550,0,1,0,0,0
+551,1,0,1,0,0
+552,0,0,0,1,1
+553,0,0,1,1,1
+554,0,0,1,1,0
+555,0,0,0,0,0
+556,0,0,1,0,1
+557,0,1,0,0,0
+558,1,1,1,0,1
+559,1,1,0,1,1
+560,1,0,0,1,1
+561,0,0,1,0,0
+562,0,1,1,0,1
+563,0,1,1,1,1
+564,1,1,1,0,0
+565,0,1,1,1,0
+566,1,1,1,1,0
+567,1,0,0,0,0
+568,1,1,0,0,1
+569,1,1,0,1,1
+570,1,1,1,1,1
+571,1,1,0,0,1
+572,0,1,0,1,1
+573,1,1,0,1,1
+574,0,1,0,0,0
+575,0,1,0,1,1
+576,0,1,0,0,1
+577,0,0,1,0,1
+578,0,0,0,0,0
+579,1,0,1,0,1
+580,1,0,0,1,0
+581,1,1,0,0,1
+582,0,1,0,0,0
+583,0,1,1,1,1
+584,0,0,1,1,1
+585,1,0,0,0,1
+586,1,1,1,0,0
+587,0,0,0,1,1
+588,0,0,1,0,0
+589,1,0,1,1,1
+590,0,0,1,1,1
+591,0,1,0,0,0
+592,0,1,1,1,0
+593,0,0,0,0,1
+594,0,0,1,1,1
+595,1,1,0,0,0
+596,1,0,0,1,1
+597,1,1,0,1,0
+598,0,1,1,0,0
+599,1,1,0,1,1
+600,1,1,0,0,0
+601,1,1,0,0,0
+602,1,1,1,1,1
+603,1,0,0,0,0
+604,0,0,1,0,1
+605,1,1,1,1,0
+606,1,1,1,0,1
+607,1,1,1,0,0
+608,1,0,0,0,1
+609,0,1,1,0,0
+610,0,0,0,0,0
+611,1,0,1,0,1
+612,1,1,0,1,0
+613,1,1,1,0,0
+614,1,0,0,1,1
+615,0,0,0,1,1
+616,1,0,1,0,1
+617,1,1,0,0,0
+618,0,0,1,0,0
+619,0,1,1,0,0
+620,0,1,0,0,0
+621,1,1,0,0,0
+622,1,1,1,1,0
+623,0,1,0,0,1
+624,1,1,1,0,1
+625,0,1,0,1,1
+626,0,0,1,0,1
+627,1,1,0,1,1
+628,1,1,1,1,1
+629,1,1,0,1,1
+630,1,0,0,1,1
+631,1,1,1,1,1
+632,1,1,1,0,0
+633,1,1,0,0,0
+634,0,0,0,0,0
+635,0,1,1,0,0
+636,1,0,0,0,0
+637,1,0,1,1,0
+638,1,0,1,1,0
+639,1,1,1,0,0
+640,0,1,0,1,0
+641,0,0,1,0,1
+642,0,0,0,1,0
+643,1,1,0,0,1
+644,1,1,0,0,0
+645,0,1,0,0,0
+646,1,1,1,1,1
+647,1,1,0,0,1
+648,1,0,1,0,0
+649,0,0,1,1,0
+650,0,0,1,0,0
+651,1,0,0,1,1
+652,1,1,0,0,1
+653,0,0,0,1,1
+654,1,1,1,1,1
+655,0,0,0,0,0
+656,1,1,0,1,1
+657,0,0,0,0,0
+658,1,1,0,0,0
+659,1,0,1,0,1
+660,1,1,1,1,1
+661,0,0,0,1,1
+662,0,1,1,0,1
+663,0,1,1,0,1
+664,1,0,0,1,0
+665,0,0,0,0,0
+666,1,1,1,0,0
+667,0,1,1,1,0
+668,0,0,1,0,1
+669,0,0,1,0,1
+670,1,0,0,0,1
+671,0,1,1,1,0
+672,1,1,1,0,0
+673,1,1,1,1,0
+674,0,0,0,1,1
+675,1,0,0,1,0
+676,0,0,0,1,1
+677,1,1,0,1,0
+678,1,0,0,1,0
+679,0,1,1,1,0
+680,0,0,1,0,0
+681,0,0,0,0,1
+682,0,0,1,0,1
+683,0,1,0,1,0
+684,1,1,0,0,1
+685,1,1,1,1,1
+686,0,0,1,1,0
+687,0,0,0,0,1
+688,0,1,1,0,0
+689,1,0,0,0,0
+690,1,0,1,0,1
+691,0,0,0,1,0
+692,1,0,0,1,1
+693,1,1,0,1,0
+694,0,1,0,0,0
+695,0,1,1,0,0
+696,0,0,1,1,0
+697,1,1,1,1,0
+698,0,1,1,1,0
+699,0,0,0,1,0
+700,1,1,1,0,0
+701,1,1,1,0,0
+702,0,1,0,1,1
+703,0,1,1,1,1
+704,0,0,0,1,1
+705,0,0,1,1,1
+706,1,0,0,0,1
+707,1,1,1,0,1
+708,0,1,0,0,1
+709,1,1,0,0,1
+710,1,1,0,0,1
+711,1,0,0,1,0
+712,0,0,0,1,0
+713,1,0,0,1,1
+714,1,0,1,0,1
+715,1,0,0,1,1
+716,1,1,1,1,0
+717,0,0,0,0,1
+718,1,1,0,1,1
+719,1,1,1,1,1
+720,0,1,1,0,1
+721,1,0,1,1,1
+722,0,0,1,1,0
+723,0,0,0,0,0
+724,1,0,0,0,0
+725,0,0,1,0,0
+726,1,1,1,0,1
+727,1,1,0,0,1
+728,0,1,1,1,1
+729,1,0,1,1,0
+730,0,0,1,1,1
+731,0,0,1,1,0
+732,1,1,0,0,0
+733,1,1,0,0,1
+734,0,0,0,0,0
+735,0,1,0,1,0
+736,1,1,0,1,1
+737,0,0,1,0,0
+738,0,1,0,1,1
+739,1,1,0,1,0
+740,0,1,0,0,1
+741,1,0,1,1,1
+742,1,0,0,0,0
+743,0,1,0,0,1
+744,0,0,0,1,1
+745,1,0,0,0,0
+746,0,1,1,1,1
+747,1,0,0,1,1
+748,1,0,0,1,1
+749,0,0,0,0,1
+750,0,1,0,0,1
+751,0,0,1,1,1
+752,0,1,0,1,1
+753,1,1,1,1,0
+754,1,1,0,0,0
+755,0,0,0,1,0
+756,0,0,1,0,1
+757,1,1,1,0,0
+758,0,0,0,0,1
+759,0,0,1,0,0
+760,0,0,0,1,1
+761,1,0,1,1,1
+762,1,0,1,1,0
+763,1,1,1,1,1
+764,1,0,1,1,1
+765,0,1,0,1,0
+766,1,0,0,1,1
+767,0,0,1,0,0
+768,0,1,0,1,1
+769,0,0,0,1,1
+770,0,0,1,1,0
+771,1,1,1,0,1
+772,1,0,0,1,0
+773,1,1,0,1,1
+774,1,1,1,0,0
+775,0,0,0,0,0
+776,1,1,1,1,0
+777,0,1,0,1,0
+778,0,1,0,1,1
+779,0,0,1,1,0
+780,1,1,0,0,0
+781,0,1,0,1,0
+782,1,1,0,1,1
+783,1,0,1,1,0
+784,0,1,1,1,1
+785,0,1,1,0,1
+786,1,0,1,1,1
+787,0,1,1,1,0
+788,1,0,1,0,0
+789,0,0,0,1,0
+790,0,0,0,0,1
+791,0,1,1,0,1
+792,0,1,1,0,0
+793,1,1,0,0,0
+794,0,0,1,0,0
+795,1,0,1,0,0
+796,0,1,1,1,1
+797,1,1,1,0,0
+798,0,0,0,0,0
+799,0,1,0,0,0
+800,0,1,1,0,1
+801,1,0,0,1,0
+802,0,1,1,1,1
+803,0,0,1,1,0
+804,0,0,0,1,1
+805,1,1,0,1,1
+806,1,1,0,0,1
+807,0,0,1,1,1
+808,0,1,0,1,0
+809,0,1,0,0,0
+810,0,0,0,1,1
+811,0,0,1,1,0
+812,1,0,0,0,0
+813,0,0,1,1,1
+814,1,1,0,0,1
+815,1,0,1,0,1
+816,0,0,0,0,1
+817,0,0,0,0,1
+818,0,0,1,0,1
+819,1,0,0,0,1
+820,1,1,0,1,0
+821,1,1,1,0,0
+822,1,0,1,0,1
+823,0,0,0,0,0
+824,1,0,0,0,0
+825,1,1,1,0,1
+826,1,1,0,0,1
+827,1,1,0,1,0
+828,0,1,0,1,0
+829,1,0,1,1,0
+830,0,0,0,1,1
+831,1,0,0,1,1
+832,0,0,1,0,0
+833,0,0,1,1,0
+834,1,1,0,1,1
+835,1,1,1,0,0
+836,0,1,0,1,0
+837,1,1,1,0,0
+838,0,1,1,0,1
+839,1,0,0,0,1
+840,1,0,1,0,1
+841,0,0,0,1,1
+842,0,0,1,0,0
+843,1,0,1,0,1
+844,1,0,0,1,0
+845,1,0,0,1,1
+846,1,1,0,0,0
+847,0,0,0,0,1
+848,1,0,0,1,0
+849,1,0,1,1,1
+850,0,0,0,1,1
+851,0,1,1,0,1
+852,0,0,0,0,0
+853,1,0,1,0,0
+854,0,1,1,0,1
+855,0,1,0,0,0
+856,0,0,0,1,0
+857,0,1,1,0,1
+858,1,0,0,0,0
+859,0,1,0,1,1
+860,1,1,0,0,1
+861,1,1,0,0,1
+862,0,0,0,1,1
+863,0,1,1,1,1
+864,1,1,1,1,0
+865,0,0,0,0,1
+866,1,1,0,0,0
+867,0,0,0,1,1
+868,1,0,1,0,0
+869,0,0,0,1,0
+870,0,1,1,0,1
+871,0,1,1,1,1
+872,1,1,1,1,0
+873,0,0,1,0,1
+874,0,0,1,0,0
+875,1,0,0,0,1
+876,0,0,0,0,1
+877,1,0,0,0,0
+878,0,0,0,1,1
+879,0,1,0,0,1
+880,1,1,1,1,0
+881,0,0,0,0,0
+882,0,0,0,1,1
+883,0,1,0,0,1
+884,0,1,0,1,1
+885,0,0,1,0,0
+886,0,0,0,1,0
+887,0,1,1,0,1
+888,1,0,0,1,0
+889,1,0,1,0,1
+890,1,0,1,1,1
+891,0,0,1,1,1
+892,1,1,0,1,0
+893,0,1,1,0,0
+894,0,0,0,0,1
+895,1,1,1,1,0
+896,1,0,1,1,1
+897,0,1,1,0,0
+898,1,1,0,0,1
+899,0,0,0,1,0
+900,0,1,0,0,0
+901,0,1,0,0,1
+902,1,1,0,1,0
+903,1,0,1,1,0
+904,0,1,0,0,0
+905,0,0,0,1,1
+906,0,0,1,0,1
+907,0,1,1,0,1
+908,1,1,0,0,1
+909,1,0,0,1,0
+910,0,1,1,1,0
+911,0,1,1,1,0
+912,0,1,0,1,1
+913,1,1,0,0,1
+914,0,0,0,1,0
+915,0,0,0,0,1
+916,0,0,1,1,0
+917,1,1,0,1,0
+918,1,0,0,1,0
+919,1,0,1,0,0
+920,1,0,0,1,0
+921,1,0,1,1,0
+922,1,0,1,1,1
+923,0,1,1,0,1
+924,1,0,1,1,0
+925,0,0,1,1,0
+926,1,0,0,0,1
+927,0,1,1,0,0
+928,0,1,1,0,1
+929,1,1,1,0,0
+930,0,0,1,1,0
+931,0,0,0,0,1
+932,0,0,1,0,1
+933,1,1,0,0,0
+934,1,0,0,0,0
+935,1,0,0,1,1
+936,0,1,1,1,0
+937,0,0,0,0,0
+938,1,0,0,1,0
+939,0,1,0,1,0
+940,1,1,0,1,1
+941,0,0,0,0,0
+942,1,0,1,0,0
+943,1,1,0,0,0
+944,1,0,1,0,0
+945,1,1,1,0,1
+946,1,0,1,0,1
+947,1,0,0,1,1
+948,1,1,1,1,0
+949,1,1,0,1,1
+950,0,0,0,0,1
+951,1,1,0,1,1
+952,0,0,0,1,1
+953,0,1,0,0,0
+954,0,1,0,1,0
+955,0,0,0,0,1
+956,1,1,1,0,1
+957,0,0,0,1,0
+958,1,1,1,0,0
+959,0,0,1,1,0
+960,1,0,1,1,0
+961,1,1,0,1,1
+962,0,1,1,0,1
+963,0,1,0,0,1
+964,0,0,0,1,1
+965,1,1,0,0,0
+966,1,1,0,1,0
+967,0,0,0,1,0
+968,1,1,1,1,0
+969,1,0,1,1,1
+970,0,1,0,0,1
+971,0,1,1,1,0
+972,0,1,0,1,0
+973,1,1,1,0,0
+974,1,0,0,0,0
+975,0,1,0,1,1
+976,1,1,1,0,1
+977,0,1,0,0,0
+978,0,0,1,1,1
+979,1,1,1,0,1
+980,1,0,0,1,1
+981,0,0,0,0,1
+982,0,0,1,0,1
+983,1,0,0,1,1
+984,0,0,0,0,1
+985,0,0,0,0,0
+986,1,0,1,0,1
+987,0,0,1,1,0
+988,0,0,0,1,1
+989,0,0,1,1,1
+990,0,1,1,1,0
+991,0,0,1,1,0
+992,1,1,1,0,0
+993,1,1,0,0,0
+994,1,1,0,1,0
+995,0,1,1,1,1
+996,1,0,1,1,0
+997,0,0,1,0,1
+998,1,1,1,1,1
+999,1,0,1,1,1
+1000,1,0,0,0,1
+1001,1,0,0,0,0
+1002,1,1,1,1,1
+1003,1,0,1,0,1
+1004,0,1,0,1,0
+1005,1,0,0,0,1
+1006,0,0,1,0,0
+1007,1,0,1,0,1
+1008,1,1,1,1,0
+1009,1,1,0,0,0
+1010,1,0,0,1,0
+1011,1,1,1,1,0
+1012,1,0,0,0,0
+1013,1,1,1,1,1
+1014,1,1,1,0,0
+1015,1,0,1,0,1
+1016,1,0,0,0,1
+1017,1,1,0,1,1
+1018,0,0,0,0,1
+1019,0,0,1,1,0
+1020,1,1,1,1,0
+1021,1,0,1,0,1
+1022,1,0,0,1,1
+1023,0,1,0,1,0
+1024,1,0,1,1,1
+1025,0,1,1,0,1
+1026,0,1,1,1,0
+1027,0,0,0,0,1
+1028,1,0,1,1,0
+1029,1,1,0,0,0
+1030,1,0,1,1,0
+1031,0,0,1,0,0
+1032,1,0,0,0,0
+1033,0,0,0,0,1
+1034,0,1,0,1,0
+1035,1,0,0,0,1
+1036,0,1,1,1,1
+1037,0,0,0,0,0
+1038,0,1,0,1,1
+1039,0,1,1,1,0
+1040,0,0,0,0,1
+1041,1,1,1,1,0
+1042,1,1,1,0,1
+1043,1,0,1,0,0
+1044,0,1,0,1,1
+1045,0,1,0,1,0
+1046,1,1,1,0,0
+1047,0,0,0,0,0
+1048,0,0,0,1,0
+1049,1,0,0,1,0
+1050,1,0,0,0,0
+1051,0,1,1,0,0
+1052,0,0,1,1,1
+1053,0,1,0,1,1
+1054,0,0,1,1,0
+1055,1,1,0,1,0
+1056,1,0,0,0,1
+1057,1,1,1,0,1
+1058,1,0,0,1,0
+1059,0,1,1,1,0
+1060,1,0,1,1,1
+1061,0,1,0,0,0
+1062,1,1,0,0,0
+1063,0,0,0,1,1
+1064,0,0,0,1,1
+1065,1,1,1,0,1
+1066,1,1,0,1,0
+1067,0,1,0,0,1
+1068,0,1,0,0,1
+1069,0,1,1,0,1
+1070,1,1,1,1,1
+1071,1,0,1,0,0
+1072,1,0,0,1,1
+1073,1,0,1,1,0
+1074,1,0,0,1,0
+1075,1,1,1,0,1
+1076,1,1,0,1,0
+1077,0,0,0,1,1
+1078,0,0,1,0,1
+1079,1,1,0,1,1
+1080,0,0,1,0,0
+1081,1,1,1,0,0
+1082,0,0,1,0,1
+1083,1,0,0,0,1
+1084,1,1,0,0,1
+1085,1,0,0,1,1
+1086,0,1,1,0,1
+1087,0,0,0,0,1
+1088,0,1,1,1,0
+1089,1,0,1,1,1
+1090,0,0,0,0,0
+1091,0,1,1,0,0
+1092,1,1,1,1,0
+1093,0,0,0,1,0
+1094,1,1,1,1,1
+1095,1,0,0,0,1
+1096,1,1,0,0,0
+1097,1,0,1,1,1
+1098,1,0,0,0,1
+1099,0,0,0,0,0
+1100,1,0,1,1,0
+1101,0,0,0,0,0
+1102,0,0,1,1,1
+1103,0,1,0,0,0
+1104,0,1,0,0,0
+1105,0,0,1,0,1
+1106,1,0,0,1,0
+1107,1,1,1,0,1
+1108,1,0,0,1,0
+1109,1,0,0,1,0
+1110,1,0,0,1,0
+1111,1,0,1,0,1
+1112,1,0,0,0,0
+1113,1,1,0,1,0
+1114,1,0,1,1,0
+1115,0,1,1,1,0
+1116,0,1,1,0,0
+1117,0,1,1,0,0
+1118,1,0,1,1,1
+1119,1,0,1,0,0
+1120,1,0,0,1,1
+1121,1,0,1,0,1
+1122,1,0,1,0,1
+1123,0,0,1,0,1
+1124,1,0,0,1,0
+1125,1,1,0,1,0
+1126,0,1,1,0,0
+1127,0,0,1,0,1
+1128,0,1,1,0,1
+1129,0,1,0,0,1
+1130,1,1,0,0,1
+1131,1,0,0,1,0
+1132,0,0,0,1,0
+1133,0,1,0,1,0
+1134,0,0,1,0,1
+1135,1,0,1,0,0
+1136,1,0,1,0,0
+1137,0,1,1,0,1
+1138,0,1,1,1,1
+1139,1,0,0,1,1
+1140,0,0,1,0,1
+1141,1,0,0,0,0
+1142,1,1,0,0,1
+1143,0,1,1,1,0
+1144,0,1,0,0,0
+1145,0,0,1,1,1
+1146,0,1,1,1,0
+1147,1,0,0,0,0
+1148,0,0,1,0,0
+1149,0,1,0,0,1
+1150,1,1,1,1,0
+1151,1,1,0,0,1
+1152,1,0,0,1,0
+1153,1,0,1,0,1
+1154,0,1,1,0,1
+1155,0,0,1,1,0
+1156,1,0,1,0,1
+1157,0,0,1,1,1
+1158,0,0,0,0,1
+1159,1,1,1,0,1
+1160,0,1,0,0,0
+1161,1,1,0,1,0
+1162,1,0,1,1,1
+1163,1,1,1,0,0
+1164,0,0,1,0,1
+1165,0,0,1,0,0
+1166,1,1,1,0,1
+1167,0,1,0,0,0
+1168,0,0,1,0,0
+1169,0,0,1,0,1
+1170,1,1,1,1,0
+1171,1,1,0,1,1
+1172,0,0,1,1,0
+1173,0,0,1,0,1
+1174,0,1,1,0,0
+1175,0,1,1,1,1
+1176,0,0,1,0,1
+1177,0,0,1,0,0
+1178,1,1,1,1,0
+1179,0,1,0,0,1
+1180,1,1,0,1,1
+1181,0,0,1,0,0
+1182,1,0,1,1,0
+1183,0,0,1,1,0
+1184,1,1,0,0,0
+1185,0,1,1,0,1
+1186,1,0,1,1,1
+1187,1,1,0,0,1
+1188,0,0,0,0,0
+1189,0,1,0,0,1
+1190,1,0,0,0,0
+1191,0,0,1,1,1
+1192,0,1,1,1,1
+1193,1,1,0,1,1
+1194,0,0,0,1,0
+1195,1,1,1,0,1
+1196,1,1,0,1,1
+1197,1,1,0,1,0
+1198,1,1,1,0,0
+1199,0,0,0,1,0
+1200,0,0,1,1,0
+1201,0,1,1,1,0
+1202,1,1,1,0,0
+1203,0,1,0,1,0
+1204,0,1,1,0,1
+1205,0,1,1,0,1
+1206,1,1,1,0,0
+1207,1,1,1,0,1
+1208,0,1,1,1,1
+1209,1,0,0,1,1
+1210,0,1,1,1,0
+1211,1,0,0,1,1
+1212,0,1,0,0,0
+1213,1,0,1,0,0
+1214,1,1,0,1,1
+1215,1,0,1,1,1
+1216,0,0,0,0,1
+1217,0,1,1,0,1
+1218,0,0,0,0,1
+1219,0,1,1,0,1
+1220,1,0,0,1,0
+1221,1,1,0,0,0
+1222,1,1,0,1,0
+1223,1,1,0,1,0
+1224,0,0,1,1,1
+1225,0,0,0,0,1
+1226,1,0,0,1,0
+1227,0,0,0,1,0
+1228,1,0,0,1,1
+1229,1,1,1,0,1
+1230,0,1,1,0,1
+1231,0,1,1,1,1
+1232,0,1,0,0,0
+1233,1,0,1,0,0
+1234,1,1,1,1,0
+1235,1,0,1,1,0
+1236,0,0,1,0,1
+1237,0,1,1,0,0
+1238,0,0,1,1,1
+1239,0,1,0,1,0
+1240,0,0,0,0,0
+1241,1,1,1,0,0
+1242,1,1,0,0,0
+1243,1,1,0,1,0
+1244,1,0,0,0,1
+1245,0,0,0,1,1
+1246,1,1,0,0,0
+1247,0,0,1,0,0
+1248,1,1,1,0,0
+1249,0,0,1,1,0
+1250,0,0,0,0,0
+1251,0,1,0,1,0
+1252,0,0,0,1,1
+1253,1,0,1,0,0
+1254,0,1,1,0,1
+1255,1,1,1,1,0
+1256,1,1,1,0,0
+1257,0,0,0,1,1
+1258,1,1,0,0,0
+1259,1,0,0,1,0
+1260,1,1,1,0,1
+1261,1,0,0,0,0
+1262,1,1,1,1,1
+1263,0,1,0,0,1
+1264,0,0,0,0,1
+1265,1,0,1,1,1
+1266,1,0,1,0,0
+1267,0,1,1,0,1
+1268,0,1,1,1,1
+1269,1,0,1,0,0
+1270,1,0,1,1,0
+1271,1,0,0,1,1
+1272,0,1,0,0,1
+1273,1,1,0,1,1
+1274,0,1,1,0,1
+1275,0,1,1,0,0
+1276,0,0,1,0,0
+1277,1,1,0,0,0
+1278,1,0,0,0,1
+1279,0,0,1,0,1
+1280,0,0,1,1,1
+1281,0,1,0,0,1
+1282,0,1,1,1,0
+1283,1,0,0,0,0
+1284,1,1,0,1,1
+1285,0,1,1,1,0
+1286,1,1,1,1,1
+1287,1,0,1,1,0
+1288,0,0,1,0,1
+1289,1,1,0,0,0
+1290,0,0,0,0,0
+1291,0,1,0,1,0
+1292,1,0,1,1,1
+1293,1,0,0,1,0
+1294,1,0,0,0,0
+1295,0,0,0,1,0
+1296,1,1,1,1,1
+1297,1,1,0,1,1
+1298,1,1,0,1,1
+1299,0,0,1,1,1
+1300,1,0,0,0,1
+1301,0,0,0,1,0
+1302,1,1,1,1,1
+1303,1,1,0,1,1
+1304,1,0,1,0,1
+1305,0,1,1,0,1
+1306,0,0,1,1,1
+1307,1,1,1,1,0
+1308,0,0,1,1,1
+1309,0,1,0,1,1
+1310,1,1,1,1,0
+1311,1,1,1,1,1
+1312,0,0,0,0,1
+1313,1,0,0,1,1
+1314,1,0,1,0,1
+1315,1,1,0,1,0
+1316,1,0,0,0,1
+1317,1,1,1,0,0
+1318,1,1,1,1,0
+1319,0,0,0,0,0
+1320,1,0,0,1,1
+1321,1,1,0,0,0
+1322,0,1,1,1,1
+1323,0,1,1,0,0
+1324,0,1,1,1,0
+1325,1,0,0,0,1
+1326,1,0,1,0,1
+1327,0,0,0,0,0
+1328,0,1,1,0,0
+1329,1,1,0,0,1
+1330,0,0,0,1,1
+1331,0,1,0,0,0
+1332,0,0,0,0,0
+1333,1,0,1,0,0
+1334,0,0,0,0,1
+1335,1,1,0,0,0
+1336,1,0,0,0,1
+1337,1,0,0,1,0
+1338,0,1,1,0,0
+1339,0,1,0,0,0
+1340,0,1,1,1,0
+1341,1,0,0,1,0
+1342,0,0,0,0,0
+1343,1,1,1,1,0
+1344,1,1,1,1,0
+1345,0,0,1,0,0
+1346,1,1,0,1,1
+1347,0,0,0,0,1
+1348,1,0,0,0,0
+1349,0,0,1,1,1
+1350,0,1,0,0,0
+1351,0,0,1,1,0
+1352,1,0,0,1,0
+1353,1,0,0,0,0
+1354,1,1,1,1,0
+1355,0,0,0,0,0
+1356,0,0,1,0,0
+1357,1,1,0,1,1
+1358,0,0,0,1,0
+1359,1,0,1,1,1
+1360,1,1,0,0,0
+1361,1,1,0,1,1
+1362,0,1,0,0,1
+1363,1,0,0,1,0
+1364,0,1,1,0,1
+1365,1,1,0,0,1
+1366,0,0,1,1,0
+1367,0,0,0,0,0
+1368,1,0,1,1,0
+1369,1,1,1,0,1
+1370,0,0,0,1,1
+1371,0,0,1,0,1
+1372,0,1,1,1,1
+1373,0,0,0,0,1
+1374,0,1,1,1,1
+1375,0,0,0,0,0
+1376,1,1,0,1,1
+1377,1,0,0,0,1
+1378,0,0,0,1,0
+1379,1,0,0,0,1
+1380,0,1,1,1,0
+1381,0,1,0,1,1
+1382,1,1,0,1,1
+1383,1,1,1,1,1
+1384,0,1,0,1,0
+1385,0,1,1,1,0
+1386,1,0,0,1,0
+1387,0,1,0,1,1
+1388,1,1,0,0,0
+1389,0,0,0,0,1
+1390,0,1,0,0,1
+1391,0,0,0,0,0
+1392,0,1,1,0,1
+1393,0,1,0,0,0
+1394,1,1,1,1,0
+1395,1,0,0,1,1
+1396,0,1,0,0,0
+1397,0,0,1,1,1
+1398,1,0,1,1,1
+1399,0,1,0,1,1
+1400,0,0,0,1,1
+1401,0,1,1,1,0
+1402,0,1,0,1,0
+1403,1,0,1,0,0
+1404,0,0,1,0,0
+1405,0,0,1,1,0
+1406,1,0,1,1,0
+1407,0,0,0,1,0
+1408,1,0,0,1,0
+1409,1,0,1,1,1
+1410,0,0,1,0,0
+1411,1,0,0,1,0
+1412,0,0,1,0,1
+1413,0,0,0,1,1
+1414,0,1,1,1,1
+1415,0,1,0,1,1
+1416,1,0,1,1,1
+1417,1,0,0,0,1
+1418,0,1,0,1,1
+1419,1,1,1,1,0
+1420,1,0,0,0,1
+1421,1,1,1,0,1
+1422,1,1,1,0,1
+1423,1,1,0,0,0
+1424,0,1,1,1,0
+1425,1,1,1,0,1
+1426,0,0,0,1,0
+1427,1,0,1,0,1
+1428,0,1,1,0,1
+1429,0,1,0,1,1
+1430,0,0,1,1,1
+1431,1,0,1,1,0
+1432,0,1,0,1,0
+1433,1,0,1,1,0
+1434,0,1,1,1,0
+1435,0,0,1,0,1
+1436,0,1,0,1,1
+1437,1,1,1,1,1
+1438,1,1,1,0,0
+1439,0,0,1,1,1
+1440,0,1,0,1,1
+1441,0,0,1,1,1
+1442,0,1,1,0,0
+1443,0,0,0,1,1
+1444,0,0,0,0,0
+1445,0,1,1,0,0
+1446,0,0,1,1,0
+1447,0,0,1,0,1
+1448,0,1,1,0,0
+1449,0,0,1,0,1
+1450,1,0,0,0,1
+1451,0,1,1,0,1
+1452,1,1,1,1,0
+1453,1,0,0,1,0
+1454,0,1,0,1,1
+1455,0,0,0,1,0
+1456,0,1,0,0,0
+1457,0,0,0,1,1
+1458,0,1,0,0,1
+1459,0,1,1,0,1
+1460,1,0,0,1,1
+1461,1,0,1,0,1
+1462,1,0,0,0,1
+1463,1,1,1,0,1
+1464,1,0,0,1,1
+1465,1,0,0,0,1
+1466,1,0,0,0,0
+1467,1,0,0,0,0
+1468,1,0,1,1,0
+1469,0,1,0,0,1
+1470,0,0,0,0,0
+1471,1,0,1,0,1
+1472,0,0,1,1,1
+1473,1,1,1,0,0
+1474,1,0,1,1,0
+1475,0,0,1,0,0
+1476,1,0,1,0,1
+1477,0,0,1,1,0
+1478,0,1,1,0,1
+1479,1,1,0,0,0
+1480,1,0,1,0,1
+1481,0,0,1,1,0
+1482,0,1,1,0,0
+1483,1,0,0,0,1
+1484,1,1,0,0,0
+1485,1,0,1,0,1
+1486,0,1,0,0,1
+1487,1,1,1,0,0
+1488,1,1,1,1,1
+1489,1,0,0,0,0
+1490,1,1,0,1,0
+1491,0,0,1,1,0
+1492,0,0,1,0,1
+1493,0,0,1,0,1
+1494,0,0,0,1,0
+1495,1,1,0,0,0
+1496,0,1,0,0,1
+1497,0,1,0,1,0
+1498,1,1,1,0,1
+1499,1,1,0,0,1
+1500,1,0,1,0,0
+1501,1,1,1,1,0
+1502,0,1,0,0,0
+1503,1,0,1,0,0
+1504,1,0,1,1,1
+1505,0,1,0,0,1
+1506,1,0,0,1,1
+1507,1,0,1,1,0
+1508,1,1,0,0,0
+1509,0,0,1,0,0
+1510,0,0,1,1,0
+1511,0,1,1,0,0
+1512,0,0,1,1,0
+1513,1,1,0,0,1
+1514,1,0,0,0,1
+1515,1,0,1,0,0
+1516,1,0,1,0,0
+1517,0,0,1,0,0
+1518,1,0,1,1,0
+1519,0,1,1,0,0
+1520,0,1,0,1,0
+1521,1,1,0,1,0
+1522,1,1,1,1,0
+1523,0,0,1,1,1
+1524,0,0,0,1,0
+1525,1,0,0,1,0
+1526,1,1,1,1,1
+1527,1,0,0,0,1
+1528,0,1,0,1,0
+1529,0,0,1,1,1
+1530,0,1,0,0,0
+1531,0,1,1,1,1
+1532,0,0,1,0,1
+1533,1,0,1,0,0
+1534,1,0,1,0,1
+1535,1,1,0,0,0
+1536,0,1,0,1,1
+1537,0,1,1,1,0
+1538,0,0,0,1,0
+1539,0,0,0,0,1
+1540,1,1,0,0,0
+1541,0,0,1,0,0
+1542,0,0,1,0,0
+1543,1,0,1,0,1
+1544,0,1,0,0,1
+1545,1,0,0,1,1
+1546,1,0,1,1,1
+1547,1,1,0,0,1
+1548,0,0,1,1,0
+1549,0,0,0,1,0
+1550,0,0,0,1,0
+1551,0,1,0,0,0
+1552,1,0,0,1,1
+1553,1,1,1,1,1
+1554,0,1,0,0,1
+1555,0,0,1,1,0
+1556,1,0,0,1,0
+1557,0,1,0,0,0
+1558,1,1,0,0,1
+1559,0,0,0,1,0
+1560,1,1,1,0,1
+1561,1,1,0,1,0
+1562,0,0,0,1,1
+1563,0,0,0,1,1
+1564,1,0,0,1,1
+1565,1,1,1,1,1
+1566,1,1,0,1,0
+1567,0,1,0,0,0
+1568,1,1,0,1,1
+1569,1,1,0,1,1
+1570,0,0,0,0,1
+1571,0,1,0,0,0
+1572,0,0,1,0,0
+1573,0,1,1,0,1
+1574,1,0,0,0,1
+1575,0,1,0,1,1
+1576,0,0,1,1,0
+1577,1,1,1,0,1
+1578,1,0,0,1,1
+1579,1,1,0,0,0
+1580,1,1,0,0,0
+1581,1,0,1,0,0
+1582,0,1,0,0,1
+1583,1,0,1,0,0
+1584,1,0,0,0,0
+1585,0,0,1,1,1
+1586,1,1,1,0,0
+1587,1,1,1,0,1
+1588,1,1,1,0,1
+1589,0,0,1,1,0
+1590,1,0,1,0,0
+1591,0,1,1,0,1
+1592,0,1,0,0,0
+1593,1,0,0,0,1
+1594,0,1,1,0,0
+1595,1,0,0,1,1
+1596,1,1,1,1,1
+1597,0,0,0,0,1
+1598,1,0,0,1,0
+1599,0,1,0,0,1
+1600,0,0,1,0,1
+1601,0,0,0,0,1
+1602,1,0,0,1,1
+1603,1,0,0,1,0
+1604,0,0,0,1,1
+1605,1,0,0,0,0
+1606,1,0,0,0,1
+1607,1,0,1,1,0
+1608,0,1,1,0,1
+1609,0,1,0,0,0
+1610,0,1,0,0,0
+1611,1,0,0,1,1
+1612,1,0,1,0,0
+1613,1,0,0,1,0
+1614,0,0,0,1,0
+1615,0,1,0,0,0
+1616,0,0,1,1,0
+1617,0,0,0,0,1
+1618,0,1,1,1,0
+1619,0,0,0,1,1
+1620,0,1,1,0,1
+1621,1,0,0,1,1
+1622,1,0,1,0,0
+1623,0,0,0,0,1
+1624,1,1,0,0,0
+1625,1,0,0,1,0
+1626,0,1,1,0,0
+1627,1,0,1,0,1
+1628,0,1,0,1,1
+1629,1,0,1,1,1
+1630,0,0,0,0,1
+1631,1,0,1,1,0
+1632,0,0,0,1,0
+1633,0,0,1,1,1
+1634,0,1,0,1,0
+1635,0,0,0,0,1
+1636,0,0,0,0,0
+1637,1,0,1,1,0
+1638,0,0,1,0,0
+1639,0,1,1,0,1
+1640,1,1,0,1,1
+1641,0,0,1,1,0
+1642,1,0,0,1,0
+1643,1,1,1,1,0
+1644,0,0,0,1,1
+1645,0,1,0,1,1
+1646,0,1,0,1,1
+1647,1,0,1,1,1
+1648,1,0,1,0,1
+1649,1,0,0,1,0
+1650,1,1,0,1,1
+1651,0,0,1,1,0
+1652,1,1,0,0,0
+1653,1,1,1,1,0
+1654,0,0,0,1,1
+1655,1,1,0,0,1
+1656,0,0,1,1,0
+1657,0,1,1,1,1
+1658,1,0,1,0,0
+1659,0,0,1,1,0
+1660,1,1,0,1,0
+1661,0,1,1,1,1
+1662,0,1,1,1,0
+1663,0,1,1,0,0
+1664,1,0,1,1,1
+1665,1,1,1,1,1
+1666,0,0,1,0,0
+1667,0,1,0,0,1
+1668,1,1,1,0,0
+1669,1,1,1,1,1
+1670,1,0,1,1,1
+1671,1,1,0,0,0
+1672,0,0,1,0,1
+1673,0,0,0,1,1
+1674,1,1,0,0,1
+1675,0,0,1,1,1
+1676,1,1,1,1,0
+1677,1,1,1,0,1
+1678,1,0,0,1,0
+1679,0,1,0,1,1
+1680,1,0,0,0,0
+1681,0,0,1,1,1
+1682,1,0,1,1,1
+1683,1,1,1,0,0
+1684,0,1,1,0,1
+1685,1,0,0,0,0
+1686,1,0,0,1,0
+1687,0,1,0,0,1
+1688,0,0,1,1,0
+1689,0,1,0,1,1
+1690,1,0,1,1,0
+1691,0,0,0,1,1
+1692,1,1,0,1,0
+1693,0,0,0,0,0
+1694,0,0,0,0,1
+1695,1,0,0,0,1
+1696,0,1,1,0,1
+1697,0,0,1,1,1
+1698,1,1,1,1,0
+1699,1,0,1,1,0
+1700,1,1,1,1,0
+1701,1,0,0,1,0
+1702,1,1,0,0,1
+1703,1,0,0,1,0
+1704,0,0,1,0,1
+1705,0,0,0,1,0
+1706,0,0,1,0,0

main.ipynb

@@ -0,0 +1,621 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "# Deep Learning Project - Emotion Classification\n",
+                "\n",
+                "This notebook implements a **multi-label emotion classification system** using state-of-the-art transformer models. The goal is to predict multiple emotions (anger, fear, joy, sadness, surprise) that may be present in a given text.\n",
+                "\n",
+                "**Key Features:**\n",
+                "- **Model**: Microsoft DeBERTa-v3-base (184M parameters)\n",
+                "- **Strategy**: 5-Fold Stratified Cross-Validation for robust performance estimation\n",
+                "- **Optimization**: Mixed Precision Training, Gradient Clipping, Learning Rate Warmup\n",
+                "- **Evaluation**: Macro F1 Score with Per-Label Threshold Tuning\n",
+                "- **Ensemble**: Average predictions across all folds for final submission\n",
+                "\n",
+                "**Problem Type**: Multi-label classification (each text can have 0 or more emotions)\n",
+                "\n",
+                "---\n",
+                "\n",
+                "## 1. Imports & Setup\n",
+                "\n",
+                "We import all necessary libraries for:\n",
+                "- **Data handling**: `numpy`, `pandas` for data manipulation\n",
+                "- **Deep learning**: `torch` (PyTorch) and `transformers` (Hugging Face) for model training\n",
+                "- **Evaluation**: `sklearn` for F1 metrics and stratified k-fold cross-validation\n",
+                "- **Optimization**: Mixed precision training with `autocast` and `GradScaler` to speed up training and reduce memory usage\n",
+                "- **Memory management**: `gc` for garbage collection to free up GPU memory between folds"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import numpy as np\n",
+                "import pandas as pd\n",
+                "import torch\n",
+                "import torch.nn as nn\n",
+                "from sklearn.model_selection import StratifiedKFold\n",
+                "from sklearn.metrics import f1_score\n",
+                "from transformers import (\n",
+                "    AutoTokenizer,\n",
+                "    AutoModelForSequenceClassification,\n",
+                "    get_linear_schedule_with_warmup,\n",
+                "    AutoConfig\n",
+                ")\n",
+                "from torch.optim import AdamW\n",
+                "from torch.cuda.amp import autocast, GradScaler\n",
+                "import gc\n",
+                "import warnings\n",
+                "import os\n",
+                "\n",
+                "warnings.filterwarnings(\"ignore\")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## 2. Configuration\n",
+                "\n",
+                "Centralized configuration class containing all hyperparameters and paths. This makes it easy to:\n",
+                "- Experiment with different settings\n",
+                "- Ensure reproducibility\n",
+                "- Keep the code organized\n",
+                "\n",
+                "**Key Hyperparameters:**\n",
+                "- `MODEL_NAME`: DeBERTa-v3-base chosen for its strong performance on text classification tasks\n",
+                "- `MAX_LEN=128`: Balance between capturing context and computational efficiency\n",
+                "- `BATCH_SIZE=16`: Fits in GPU memory while maintaining good gradient estimates\n",
+                "- `LR=1.5e-5`: Small learning rate typical for fine-tuning pre-trained transformers\n",
+                "- `EPOCHS=4`: Sufficient for fine-tuning without overfitting\n",
+                "- `N_FOLDS=5`: Standard choice for cross-validation, balances between training data and validation reliability"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# ========= CONFIG =========\n",
+                "class Config:\n",
+                "    SEED = 42\n",
+                "    LABELS = [\"anger\", \"fear\", \"joy\", \"sadness\", \"surprise\"]\n",
+                "    MODEL_NAME = \"microsoft/deberta-v3-base\"\n",
+                "    MAX_LEN = 128\n",
+                "    BATCH_SIZE = 16\n",
+                "    EPOCHS = 4\n",
+                "    LR = 1.5e-5\n",
+                "    WEIGHT_DECAY = 0.01\n",
+                "    WARMUP_RATIO = 0.1\n",
+                "    N_FOLDS = 5\n",
+                "    TRAIN_CSV = \"/kaggle/input/2025-sep-dl-gen-ai-project/train.csv\"\n",
+                "    TEST_CSV = \"/kaggle/input/2025-sep-dl-gen-ai-project/test.csv\"\n",
+                "    SUBMISSION_PATH = \"submission.csv\"\n",
+                "\n",
+                "CONFIG = Config()"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## 3. Seed & Device Setup\n",
+                "\n",
+                "**Reproducibility**: Setting seeds ensures that our results can be replicated exactly.\n",
+                "We set seeds for:\n",
+                "- NumPy random number generation\n",
+                "- PyTorch CPU operations\n",
+                "- PyTorch GPU operations (all CUDA devices)\n",
+                "- Python's built-in hash function\n",
+                "\n",
+                "**Device Selection**: Automatically detects and uses GPU if available (CUDA), otherwise falls back to CPU.\n",
+                "GPU training is significantly faster (~10-50x) than CPU for deep learning models."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "def set_seed(seed=CONFIG.SEED):\n",
+                "    np.random.seed(seed)\n",
+                "    torch.manual_seed(seed)\n",
+                "    torch.cuda.manual_seed_all(seed)\n",
+                "    os.environ['PYTHONHASHSEED'] = str(seed)\n",
+                "\n",
+                "set_seed()\n",
+                "\n",
+                "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+                "print(f\"Using device: {device}\")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## 4. Utility Functions\n",
+                "\n",
+                "Helper functions used throughout the pipeline:\n",
+                "\n",
+                "### `ensure_text_column(df)`\n",
+                "- Standardizes the text column name across different datasets\n",
+                "- Searches for common alternatives like 'comment_text', 'sentence', etc.\n",
+                "- Raises error if no text column is found\n",
+                "\n",
+                "### `tune_thresholds(y_true, y_prob)`\n",
+                "- **Critical for multi-label classification performance**\n",
+                "- Default threshold of 0.5 is often suboptimal\n",
+                "- Finds the best threshold per label that maximizes F1 score\n",
+                "- Tests 17 different thresholds between 0.1 and 0.9\n",
+                "- Can improve F1 score by 2-5% over default threshold\n",
+                "\n",
+                "### `get_optimizer_params(model, lr, weight_decay)`\n",
+                "- Implements **differential weight decay**\n",
+                "- Applies weight decay to most parameters (helps prevent overfitting)\n",
+                "- No weight decay for bias and LayerNorm parameters (standard practice in transformer fine-tuning)\n",
+                "- This technique is recommended in the BERT and DeBERTa papers"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "def ensure_text_column(df: pd.DataFrame) -> pd.DataFrame:\n",
+                "    if \"text\" in df.columns:\n",
+                "        return df\n",
+                "    for c in [\"comment_text\", \"sentence\", \"content\", \"review\"]:\n",
+                "        if c in df.columns:\n",
+                "            return df.rename(columns={c: \"text\"})\n",
+                "    raise ValueError(\"No text column found. Add/rename your text column to 'text'.\")\n",
+                "\n",
+                "def tune_thresholds(y_true: np.ndarray, y_prob: np.ndarray) -> np.ndarray:\n",
+                "    th = np.zeros(y_true.shape[1], dtype=np.float32)\n",
+                "    for j in range(y_true.shape[1]):\n",
+                "        best_t, best_f1 = 0.5, -1\n",
+                "        for t in np.linspace(0.1, 0.9, 17):\n",
+                "            f1 = f1_score(y_true[:, j], (y_prob[:, j] >= t).astype(int), zero_division=0)\n",
+                "            if f1 > best_f1:\n",
+                "                best_f1, best_t = f1, t\n",
+                "        th[j] = best_t\n",
+                "    return th\n",
+                "\n",
+                "def get_optimizer_params(model, lr, weight_decay):\n",
+                "    param_optimizer = list(model.named_parameters())\n",
+                "    no_decay = [\"bias\", \"LayerNorm.bias\", \"LayerNorm.weight\"]\n",
+                "    optimizer_parameters = [\n",
+                "        {\n",
+                "            \"params\": [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)],\n",
+                "            \"weight_decay\": weight_decay,\n",
+                "        },\n",
+                "        {\n",
+                "            \"params\": [p for n, p in param_optimizer if any(nd in n for nd in no_decay)],\n",
+                "            \"weight_decay\": 0.0,\n",
+                "        },\n",
+                "    ]\n",
+                "    return optimizer_parameters"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## 5. Dataset Class\n",
+                "\n",
+                "Custom PyTorch Dataset for emotion classification.\n",
+                "\n",
+                "**Key Features:**\n",
+                "- Tokenizes text on-the-fly using the DeBERTa tokenizer\n",
+                "- Handles both training data (with labels) and test data (without labels)\n",
+                "- Uses `padding='max_length'` to ensure all sequences have the same length (required for batching)\n",
+                "- Applies `truncation=True` to handle texts longer than MAX_LEN\n",
+                "\n",
+                "**Returns:**\n",
+                "- `input_ids`: Token IDs representing the text\n",
+                "- `attention_mask`: Indicates which tokens are real vs padding\n",
+                "- `labels`: Multi-label binary targets (only for training data)\n",
+                "\n",
+                "**PyTorch DataLoader** will use this dataset to create batches efficiently with multi-processing."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "class EmotionDS(torch.utils.data.Dataset):\n",
+                "    def __init__(self, df, tokenizer, max_len, is_test=False):\n",
+                "        self.texts = df[\"text\"].tolist()\n",
+                "        self.is_test = is_test\n",
+                "        if not is_test:\n",
+                "            self.labels = df[CONFIG.LABELS].values.astype(np.float32)\n",
+                "        self.tok = tokenizer\n",
+                "        self.max_len = max_len\n",
+                "\n",
+                "    def __len__(self):\n",
+                "        return len(self.texts)\n",
+                "\n",
+                "    def __getitem__(self, i):\n",
+                "        enc = self.tok(\n",
+                "            self.texts[i],\n",
+                "            truncation=True,\n",
+                "            padding=\"max_length\",\n",
+                "            max_length=self.max_len,\n",
+                "            return_tensors=\"pt\",\n",
+                "        )\n",
+                "        item = {k: v.squeeze(0) for k, v in enc.items()}\n",
+                "        if not self.is_test:\n",
+                "            item[\"labels\"] = torch.tensor(self.labels[i])\n",
+                "        return item"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## 6. Training & Validation Helper Functions\n",
+                "\n",
+                "Core training and validation loops.\n",
+                "\n",
+                "### `train_one_epoch()`\n",
+                "Trains the model for one complete pass through the training data.\n",
+                "\n",
+                "**Key Techniques:**\n",
+                "- **Mixed Precision Training** (`autocast`): Uses float16 where safe, reducing memory and increasing speed by ~2x\n",
+                "- **Gradient Scaling** (`GradScaler`): Prevents gradient underflow in mixed precision\n",
+                "- **Gradient Clipping** (max_norm=1.0): Prevents exploding gradients, stabilizes training\n",
+                "- **Memory Efficient**: Uses `zero_grad(set_to_none=True)` and `non_blocking=True` for async GPU transfers\n",
+                "\n",
+                "### `validate()`\n",
+                "Evaluates the model on validation data without updating weights.\n",
+                "\n",
+                "**Features:**\n",
+                "- Runs in `model.eval()` mode (disables dropout, fixes batch normalization)\n",
+                "- Uses `torch.no_grad()` to save memory (no gradient computation)\n",
+                "- Applies sigmoid to convert logits to probabilities [0, 1]\n",
+                "- Returns predictions and targets for metric calculation"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "def train_one_epoch(model, loader, optimizer, scheduler, scaler, criterion):\n",
+                "    model.train()\n",
+                "    losses = []\n",
+                "    for batch in loader:\n",
+                "        batch = {k: v.to(device, non_blocking=True) for k, v in batch.items()}\n",
+                "        optimizer.zero_grad(set_to_none=True)\n",
+                "        with autocast(enabled=True):\n",
+                "            out = model(input_ids=batch[\"input_ids\"], attention_mask=batch[\"attention_mask\"])\n",
+                "            loss = criterion(out.logits, batch[\"labels\"])\n",
+                "        \n",
+                "        scaler.scale(loss).backward()\n",
+                "        scaler.unscale_(optimizer)\n",
+                "        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)\n",
+                "        scaler.step(optimizer)\n",
+                "        scaler.update()\n",
+                "        scheduler.step()\n",
+                "        losses.append(loss.item())\n",
+                "    return np.mean(losses)\n",
+                "\n",
+                "def validate(model, loader, criterion):\n",
+                "    model.eval()\n",
+                "    losses = []\n",
+                "    preds = []\n",
+                "    targs = []\n",
+                "    with torch.no_grad():\n",
+                "        for batch in loader:\n",
+                "            batch = {k: v.to(device, non_blocking=True) for k, v in batch.items()}\n",
+                "            with autocast(enabled=True):\n",
+                "                out = model(input_ids=batch[\"input_ids\"], attention_mask=batch[\"attention_mask\"])\n",
+                "                loss = criterion(out.logits, batch[\"labels\"])\n",
+                "            losses.append(loss.item())\n",
+                "            preds.append(torch.sigmoid(out.logits).float().cpu().numpy())\n",
+                "            targs.append(batch[\"labels\"].cpu().numpy())\n",
+                "    \n",
+                "    return np.mean(losses), np.vstack(preds), np.vstack(targs)"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## 7. Main K-Fold Training Loop\n",
+                "\n",
+                "The heart of our training pipeline - implements **5-Fold Stratified Cross-Validation**.\n",
+                "\n",
+                "### Why K-Fold Cross-Validation?\n",
+                "- More reliable performance estimates than a single train/val split\n",
+                "- Every sample is used for validation exactly once\n",
+                "- Out-of-fold predictions can be used for threshold optimization\n",
+                "- Reduces variance in model performance\n",
+                "\n",
+                "### Why Stratified?\n",
+                "- Maintains label distribution in each fold\n",
+                "- Important for imbalanced datasets\n",
+                "- For multi-label, we concatenate all labels into a string for stratification\n",
+                "\n",
+                "### Training Process per Fold:\n",
+                "1. **Split data**: 80% training, 20% validation\n",
+                "2. **Initialize model**: Fresh DeBERTa-v3-base with random classification head\n",
+                "3. **Setup optimizer**: AdamW with differential weight decay\n",
+                "4. **Setup scheduler**: Linear warmup (10% of steps) then linear decay to 0\n",
+                "5. **Train for 4 epochs**: Track training and validation metrics\n",
+                "6. **Save best model**: Based on validation F1 score\n",
+                "7. **Store OOF predictions**: For threshold tuning\n",
+                "8. **Clean up memory**: Delete model and optimizer, run garbage collection\n",
+                "\n",
+                "### Output:\n",
+                "- 5 trained models (one per fold) saved as `model_fold_{0-4}.pth`\n",
+                "- Out-of-fold predictions for the entire training set\n",
+                "- Cross-validated performance metrics"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "def run_training():\n",
+                "    if not os.path.exists(CONFIG.TRAIN_CSV):\n",
+                "        print(\"Train CSV not found. Please check the path.\")\n",
+                "        return None, None\n",
+                "\n",
+                "    df = pd.read_csv(CONFIG.TRAIN_CSV)\n",
+                "    df = ensure_text_column(df)\n",
+                "    \n",
+                "    # Create Stratified Folds\n",
+                "    skf = StratifiedKFold(n_splits=CONFIG.N_FOLDS, shuffle=True, random_state=CONFIG.SEED)\n",
+                "    y_str = df[CONFIG.LABELS].astype(str).agg(\"\".join, axis=1)\n",
+                "    \n",
+                "    oof_preds = np.zeros((len(df), len(CONFIG.LABELS)))\n",
+                "    \n",
+                "    tokenizer = AutoTokenizer.from_pretrained(CONFIG.MODEL_NAME)\n",
+                "    \n",
+                "    for fold, (train_idx, val_idx) in enumerate(skf.split(df, y_str)):\n",
+                "        print(f\"\\n{'='*20} FOLD {fold+1}/{CONFIG.N_FOLDS} {'='*20}\")\n",
+                "        \n",
+                "        df_tr = df.iloc[train_idx].reset_index(drop=True)\n",
+                "        df_va = df.iloc[val_idx].reset_index(drop=True)\n",
+                "        \n",
+                "        ds_tr = EmotionDS(df_tr, tokenizer, CONFIG.MAX_LEN)\n",
+                "        ds_va = EmotionDS(df_va, tokenizer, CONFIG.MAX_LEN)\n",
+                "        \n",
+                "        dl_tr = torch.utils.data.DataLoader(ds_tr, batch_size=CONFIG.BATCH_SIZE, shuffle=True, num_workers=2, pin_memory=True)\n",
+                "        dl_va = torch.utils.data.DataLoader(ds_va, batch_size=CONFIG.BATCH_SIZE, shuffle=False, num_workers=2, pin_memory=True)\n",
+                "        \n",
+                "        model = AutoModelForSequenceClassification.from_pretrained(\n",
+                "            CONFIG.MODEL_NAME, \n",
+                "            num_labels=len(CONFIG.LABELS),\n",
+                "            problem_type=\"multi_label_classification\"\n",
+                "        )\n",
+                "        model.to(device)\n",
+                "        \n",
+                "        optimizer_params = get_optimizer_params(model, CONFIG.LR, CONFIG.WEIGHT_DECAY)\n",
+                "        optimizer = AdamW(optimizer_params, lr=CONFIG.LR)\n",
+                "        \n",
+                "        total_steps = len(dl_tr) * CONFIG.EPOCHS\n",
+                "        scheduler = get_linear_schedule_with_warmup(\n",
+                "            optimizer, \n",
+                "            num_warmup_steps=int(total_steps * CONFIG.WARMUP_RATIO), \n",
+                "            num_training_steps=total_steps\n",
+                "        )\n",
+                "        \n",
+                "        criterion = nn.BCEWithLogitsLoss()\n",
+                "        scaler = GradScaler(enabled=True)\n",
+                "        \n",
+                "        best_f1 = 0\n",
+                "        best_state = None\n",
+                "        \n",
+                "        for ep in range(CONFIG.EPOCHS):\n",
+                "            train_loss = train_one_epoch(model, dl_tr, optimizer, scheduler, scaler, criterion)\n",
+                "            val_loss, val_preds, val_targs = validate(model, dl_va, criterion)\n",
+                "            \n",
+                "            val_f1 = f1_score(val_targs, (val_preds >= 0.5).astype(int), average=\"macro\", zero_division=0)\n",
+                "            \n",
+                "            print(f\"Ep {ep+1}: TrLoss={train_loss:.4f} | VaLoss={val_loss:.4f} | VaF1={val_f1:.4f}\")\n",
+                "            \n",
+                "            if val_f1 > best_f1:\n",
+                "                best_f1 = val_f1\n",
+                "                best_state = model.state_dict()\n",
+                "                \n",
+                "        torch.save(best_state, f\"model_fold_{fold}.pth\")\n",
+                "        \n",
+                "        model.load_state_dict(best_state)\n",
+                "        _, val_preds, _ = validate(model, dl_va, criterion)\n",
+                "        oof_preds[val_idx] = val_preds\n",
+                "        \n",
+                "        del model, optimizer, scaler, scheduler\n",
+                "        torch.cuda.empty_cache()\n",
+                "        gc.collect()\n",
+                "        \n",
+                "    return oof_preds, df[CONFIG.LABELS].values\n",
+                "\n",
+                "if os.path.exists(CONFIG.TRAIN_CSV):\n",
+                "    oof_preds, y_true = run_training()\n",
+                "else:\n",
+                "    print(\"Skipping training as data is not found (likely in a dry-run environment).\")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## 8. Threshold Optimization\n",
+                "\n",
+                "**Why optimize thresholds?**\n",
+                "\n",
+                "In multi-label classification, we convert probabilities to binary predictions using a threshold:\n",
+                "- `prediction = 1 if probability >= threshold else 0`\n",
+                "- The default threshold of 0.5 is often suboptimal\n",
+                "- Different emotion labels may have different optimal thresholds\n",
+                "\n",
+                "**Example:**\n",
+                "- 'Joy' might be common → optimal threshold could be 0.4\n",
+                "- 'Surprise' might be rare → optimal threshold could be 0.6\n",
+                "\n",
+                "### Process:\n",
+                "1. Use out-of-fold predictions (already trained models, no data leakage)\n",
+                "2. For each label independently, test thresholds from 0.1 to 0.9\n",
+                "3. Select threshold that maximizes F1 score for that label\n",
+                "4. Apply optimized thresholds to get final binary predictions\n",
+                "\n",
+                "**Expected Improvement**: 2-5% increase in Macro F1 score\n",
+                "\n",
+                "This is a standard technique in Kaggle competitions and production systems."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "if os.path.exists(CONFIG.TRAIN_CSV):\n",
+                "    best_thresholds = tune_thresholds(y_true, oof_preds)\n",
+                "    oof_tuned = (oof_preds >= best_thresholds).astype(int)\n",
+                "    final_f1 = f1_score(y_true, oof_tuned, average=\"macro\", zero_division=0)\n",
+                "    print(f\"\\nFinal CV Macro F1: {final_f1:.4f}\")\n",
+                "    print(f\"Best Thresholds: {best_thresholds}\")\n",
+                "else:\n",
+                "    best_thresholds = np.array([0.5] * len(CONFIG.LABELS))"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## 9. Inference & Submission\n",
+                "\n",
+                "Final prediction pipeline for test data.\n",
+                "\n",
+                "### Ensemble Strategy:\n",
+                "We use **model averaging** across all 5 folds:\n",
+                "1. Load each trained fold model\n",
+                "2. Make predictions on test set\n",
+                "3. Average the probabilities across all folds\n",
+                "4. Apply optimized thresholds to get binary predictions\n",
+                "\n",
+                "### Why ensemble?\n",
+                "- Reduces variance and overfitting\n",
+                "- More robust predictions\n",
+                "- Often improves score by 1-3%\n",
+                "- Each fold sees different training data, captures different patterns\n",
+                "\n",
+                "### Process:\n",
+                "1. Load test data and tokenize\n",
+                "2. For each fold:\n",
+                "   - Load saved model weights\n",
+                "   - Generate predictions (probabilities)\n",
+                "   - Clean up memory\n",
+                "3. Average all fold predictions\n",
+                "4. Apply optimized thresholds\n",
+                "5. Create submission file with format: `id, anger, fear, joy, sadness, surprise`\n",
+                "\n",
+                "### Output:\n",
+                "- `submission.csv` ready for Kaggle upload\n",
+                "- Binary predictions (0 or 1) for each emotion per text"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "def predict_test(thresholds):\n",
+                "    if not os.path.exists(CONFIG.TEST_CSV):\n",
+                "        print(\"Test CSV not found.\")\n",
+                "        return\n",
+                "\n",
+                "    df_test = pd.read_csv(CONFIG.TEST_CSV)\n",
+                "    df_test = ensure_text_column(df_test)\n",
+                "    \n",
+                "    tokenizer = AutoTokenizer.from_pretrained(CONFIG.MODEL_NAME)\n",
+                "    ds_test = EmotionDS(df_test, tokenizer, CONFIG.MAX_LEN, is_test=True)\n",
+                "    dl_test = torch.utils.data.DataLoader(ds_test, batch_size=CONFIG.BATCH_SIZE, shuffle=False, num_workers=2)\n",
+                "    \n",
+                "    fold_preds = []\n",
+                "    \n",
+                "    for fold in range(CONFIG.N_FOLDS):\n",
+                "        model_path = f\"model_fold_{fold}.pth\"\n",
+                "        if not os.path.exists(model_path):\n",
+                "            print(f\"Model for fold {fold} not found, skipping.\")\n",
+                "            continue\n",
+                "            \n",
+                "        print(f\"Predicting Fold {fold+1}...\")\n",
+                "        model = AutoModelForSequenceClassification.from_pretrained(\n",
+                "            CONFIG.MODEL_NAME, \n",
+                "            num_labels=len(CONFIG.LABELS),\n",
+                "            problem_type=\"multi_label_classification\"\n",
+                "        )\n",
+                "        model.load_state_dict(torch.load(model_path))\n",
+                "        model.to(device)\n",
+                "        model.eval()\n",
+                "        \n",
+                "        preds = []\n",
+                "        with torch.no_grad():\n",
+                "            for batch in dl_test:\n",
+                "                batch = {k: v.to(device, non_blocking=True) for k, v in batch.items()}\n",
+                "                with autocast(enabled=True):\n",
+                "                    out = model(input_ids=batch[\"input_ids\"], attention_mask=batch[\"attention_mask\"])\n",
+                "                preds.append(torch.sigmoid(out.logits).float().cpu().numpy())\n",
+                "        \n",
+                "        fold_preds.append(np.vstack(preds))\n",
+                "        del model\n",
+                "        torch.cuda.empty_cache()\n",
+                "        gc.collect()\n",
+                "        \n",
+                "    if not fold_preds:\n",
+                "        print(\"No predictions made.\")\n",
+                "        return\n",
+                "\n",
+                "    avg_preds = np.mean(fold_preds, axis=0)\n",
+                "    final_preds = (avg_preds >= thresholds).astype(int)\n",
+                "    \n",
+                "    sub = pd.DataFrame(columns=[\"id\"] + CONFIG.LABELS)\n",
+                "    sub[\"id\"] = df_test[\"id\"] if \"id\" in df_test.columns else np.arange(len(df_test))\n",
+                "    sub[CONFIG.LABELS] = final_preds\n",
+                "    sub.to_csv(CONFIG.SUBMISSION_PATH, index=False)\n",
+                "    print(f\"Submission saved to {CONFIG.SUBMISSION_PATH}\")\n",
+                "    print(sub.head())\n",
+                "\n",
+                "predict_test(best_thresholds)"
+            ]
+        }
+    ],
+    "metadata": {
+        "kernelspec": {
+            "display_name": ".venv",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.13.7"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
+}

main_code_explanation.md

@@ -0,0 +1,812 @@
+# Deep Learning Emotion Classification - Code Explanation
+
+This document provides a detailed line-by-line explanation of the `main.ipynb` notebook, which implements a multi-label emotion classification system using the DeBERTa transformer model with K-Fold cross-validation.
+
+---
+
+## Section 1: Imports & Setup
+
+### Lines 18-36: Import Statements
+
+```python
+import numpy as np
+import pandas as pd
+```
+- **numpy**: Used for numerical operations, array manipulation, and random seed setting
+- **pandas**: Used for data loading and manipulation (CSV files, DataFrames)
+
+```python
+import torch
+import torch.nn as nn
+```
+- **torch**: PyTorch deep learning framework for tensor operations and model training
+- **torch.nn**: Neural network modules including loss functions
+
+```python
+from sklearn.model_selection import StratifiedKFold
+from sklearn.metrics import f1_score
+```
+- **StratifiedKFold**: Creates k-fold splits while maintaining class distribution in each fold
+- **f1_score**: Calculates F1 metric for evaluation (harmonic mean of precision and recall)
+
+```python
+from transformers import (
+    AutoTokenizer,
+    AutoModelForSequenceClassification,
+    get_linear_schedule_with_warmup,
+    AutoConfig
+)
+```
+- **AutoTokenizer**: Automatically loads the appropriate tokenizer for the specified model
+- **AutoModelForSequenceClassification**: Pre-trained transformer model for classification tasks
+- **get_linear_schedule_with_warmup**: Learning rate scheduler with warmup and linear decay
+- **AutoConfig**: Model configuration loader
+
+```python
+from torch.optim import AdamW
+```
+- **AdamW**: Adam optimizer with decoupled weight decay (better than standard Adam for transformers)
+
+```python
+from torch.cuda.amp import autocast, GradScaler
+```
+- **autocast**: Enables automatic mixed precision (AMP) to speed up training
+- **GradScaler**: Scales gradients for mixed precision training to prevent underflow
+
+```python
+import gc
+import warnings
+import os
+```
+- **gc**: Garbage collection to free up memory
+- **warnings**: To suppress warning messages
+- **os**: For file system operations and environment variables
+
+```python
+warnings.filterwarnings("ignore")
+```
+- Suppresses all warning messages for cleaner output
+
+---
+
+## Section 2: Configuration
+
+### Lines 52-68: Configuration Class
+
+```python
+class Config:
+    SEED = 42
+```
+- Sets random seed for reproducibility across all random operations
+
+```python
+    LABELS = ["anger", "fear", "joy", "sadness", "surprise"]
+```
+- Defines the 5 emotion labels for multi-label classification
+
+```python
+    MODEL_NAME = "microsoft/deberta-v3-base"
+```
+- Specifies the pre-trained model (DeBERTa v3 base - 184M parameters, SOTA performance)
+
+```python
+    MAX_LEN = 128
+```
+- Maximum sequence length for tokenization (tokens longer than this are truncated)
+
+```python
+    BATCH_SIZE = 16
+```
+- Number of samples processed together in one forward/backward pass
+
+```python
+    EPOCHS = 4
+```
+- Number of complete passes through the training dataset
+
+```python
+    LR = 1.5e-5
+```
+- Learning rate (1.5 × 10⁻⁵) - small value typical for fine-tuning transformers
+
+```python
+    WEIGHT_DECAY = 0.01
+```
+- L2 regularization strength to prevent overfitting
+
+```python
+    WARMUP_RATIO = 0.1
+```
+- Fraction of training steps used for learning rate warmup (10% of total steps)
+
+```python
+    N_FOLDS = 5
+```
+- Number of folds for K-Fold cross-validation
+
+```python
+    TRAIN_CSV = "/kaggle/input/2025-sep-dl-gen-ai-project/train.csv"
+    TEST_CSV = "/kaggle/input/2025-sep-dl-gen-ai-project/test.csv"
+```
+- Paths to training and test datasets (Kaggle environment paths)
+
+```python
+    SUBMISSION_PATH = "submission.csv"
+```
+- Output file for predictions
+
+```python
+CONFIG = Config()
+```
+- Creates a global instance of the configuration class
+
+---
+
+## Section 3: Seed & Device Setup
+
+### Lines 84-93: Reproducibility and Device Selection
+
+```python
+def set_seed(seed=CONFIG.SEED):
+    np.random.seed(seed)
+```
+- Sets numpy's random seed for reproducible random number generation
+
+```python
+    torch.manual_seed(seed)
+```
+- Sets PyTorch's random seed for CPU operations
+
+```python
+    torch.cuda.manual_seed_all(seed)
+```
+- Sets PyTorch's random seed for all GPU devices
+
+```python
+    os.environ['PYTHONHASHSEED'] = str(seed)
+```
+- Sets hash seed for Python's built-in hash() function for reproducibility
+
+```python
+set_seed()
+```
+- Calls the seed setting function
+
+```python
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"Using device: {device}")
+```
+- Checks if GPU is available; uses GPU if available, otherwise falls back to CPU
+- Prints the device being used for training
+
+---
+
+## Section 4: Utility Functions
+
+### Lines 109-115: `ensure_text_column` Function
+
+```python
+def ensure_text_column(df: pd.DataFrame) -> pd.DataFrame:
+    if "text" in df.columns:
+        return df
+```
+- Checks if DataFrame already has a "text" column; if yes, returns unchanged
+
+```python
+    for c in ["comment_text", "sentence", "content", "review"]:
+        if c in df.columns:
+            return df.rename(columns={c: "text"})
+```
+- Searches for common alternative text column names
+- Renames the first matching column to "text" for standardization
+
+```python
+    raise ValueError("No text column found. Add/rename your text column to 'text'.")
+```
+- Raises an error if no text column is found
+
+### Lines 117-126: `tune_thresholds` Function
+
+```python
+def tune_thresholds(y_true: np.ndarray, y_prob: np.ndarray) -> np.ndarray:
+    th = np.zeros(y_true.shape[1], dtype=np.float32)
+```
+- Creates array to store optimal threshold for each label (initialized to 0)
+- Multi-label classification requires separate thresholds per label
+
+```python
+    for j in range(y_true.shape[1]):
+        best_t, best_f1 = 0.5, -1
+```
+- Iterates through each label
+- Initializes best threshold to 0.5 (default) and best F1 to -1
+
+```python
+        for t in np.linspace(0.1, 0.9, 17):
+```
+- Tests 17 threshold values evenly spaced between 0.1 and 0.9
+
+```python
+            f1 = f1_score(y_true[:, j], (y_prob[:, j] >= t).astype(int), zero_division=0)
+```
+- Calculates F1 score for current label and threshold
+- Converts probabilities to binary predictions using threshold
+
+```python
+            if f1 > best_f1:
+                best_f1, best_t = f1, t
+```
+- Updates best threshold if current F1 is better
+
+```python
+        th[j] = best_t
+    return th
+```
+- Stores optimal threshold for each label and returns the array
+
+### Lines 128-141: `get_optimizer_params` Function
+
+```python
+def get_optimizer_params(model, lr, weight_decay):
+    param_optimizer = list(model.named_parameters())
+```
+- Gets all model parameters with their names
+
+```python
+    no_decay = ["bias", "LayerNorm.bias", "LayerNorm.weight"]
+```
+- Lists parameters that should NOT have weight decay applied
+- Bias and LayerNorm parameters typically trained without weight decay
+
+```python
+    optimizer_parameters = [
+        {
+            "params": [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)],
+            "weight_decay": weight_decay,
+        },
+```
+- First parameter group: all parameters EXCEPT bias and LayerNorm
+- These parameters will have weight decay applied
+
+```python
+        {
+            "params": [p for n, p in param_optimizer if any(nd in n for nd in no_decay)],
+            "weight_decay": 0.0,
+        },
+    ]
+```
+- Second parameter group: only bias and LayerNorm parameters
+- These parameters have weight decay set to 0.0
+
+```python
+    return optimizer_parameters
+```
+- Returns grouped parameters for differential weight decay
+
+---
+
+## Section 5: Dataset Class
+
+### Lines 157-180: `EmotionDS` Class
+
+```python
+class EmotionDS(torch.utils.data.Dataset):
+    def __init__(self, df, tokenizer, max_len, is_test=False):
+```
+- Custom PyTorch Dataset class for emotion classification
+- `is_test` flag indicates whether this is test data (no labels)
+
+```python
+        self.texts = df["text"].tolist()
+```
+- Extracts text data as a Python list
+
+```python
+        self.is_test = is_test
+        if not is_test:
+            self.labels = df[CONFIG.LABELS].values.astype(np.float32)
+```
+- Stores test flag
+- If training data, extracts multi-label targets as float32 array
+
+```python
+        self.tok = tokenizer
+        self.max_len = max_len
+```
+- Stores tokenizer and max length for later use
+
+```python
+    def __len__(self):
+        return len(self.texts)
+```
+- Returns dataset size (required by PyTorch)
+
+```python
+    def __getitem__(self, i):
+        enc = self.tok(
+            self.texts[i],
+            truncation=True,
+            padding="max_length",
+            max_length=self.max_len,
+            return_tensors="pt",
+        )
+```
+- Tokenizes the text at index `i`
+- **truncation**: Cuts text longer than max_len
+- **padding**: Pads shorter sequences to max_len
+- **return_tensors="pt"**: Returns PyTorch tensors
+
+```python
+        item = {k: v.squeeze(0) for k, v in enc.items()}
+```
+- Removes the batch dimension (1, seq_len) → (seq_len)
+- Returns dict with keys: input_ids, attention_mask, token_type_ids (if applicable)
+
+```python
+        if not self.is_test:
+            item["labels"] = torch.tensor(self.labels[i])
+        return item
+```
+- Adds labels to the item dict if training data
+- Returns the complete item
+
+---
+
+## Section 6: Training & Validation Helper Functions
+
+### Lines 196-213: `train_one_epoch` Function
+
+```python
+def train_one_epoch(model, loader, optimizer, scheduler, scaler, criterion):
+    model.train()
+```
+- Sets model to training mode (enables dropout, batch normalization updates)
+
+```python
+    losses = []
+    for batch in loader:
+```
+- Initializes list to track losses
+- Iterates through batches
+
+```python
+        batch = {k: v.to(device, non_blocking=True) for k, v in batch.items()}
+```
+- Moves batch data to GPU (or CPU)
+- `non_blocking=True`: Async transfer for faster processing
+
+```python
+        optimizer.zero_grad(set_to_none=True)
+```
+- Clears gradients from previous step
+- `set_to_none=True`: More memory efficient than setting to zero
+
+```python
+        with autocast(enabled=True):
+            out = model(input_ids=batch["input_ids"], attention_mask=batch["attention_mask"])
+            loss = criterion(out.logits, batch["labels"])
+```
+- **autocast**: Uses mixed precision (float16) for faster computation
+- Forward pass through model
+- Calculates loss between predictions (logits) and true labels
+
+```python
+        scaler.scale(loss).backward()
+```
+- Scales loss to prevent gradient underflow in mixed precision
+- Computes gradients via backpropagation
+
+```python
+        scaler.unscale_(optimizer)
+        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+```
+- Unscales gradients before clipping
+- Clips gradients to maximum norm of 1.0 to prevent exploding gradients
+
+```python
+        scaler.step(optimizer)
+        scaler.update()
+```
+- Updates model parameters (with scaled gradients)
+- Updates the scaler's internal state
+
+```python
+        scheduler.step()
+```
+- Updates learning rate according to schedule
+
+```python
+        losses.append(loss.item())
+    return np.mean(losses)
+```
+- Stores loss value
+- Returns average loss for the epoch
+
+### Lines 215-230: `validate` Function
+
+```python
+def validate(model, loader, criterion):
+    model.eval()
+```
+- Sets model to evaluation mode (disables dropout, fixes batch norm)
+
+```python
+    losses = []
+    preds = []
+    targs = []
+```
+- Initializes lists for losses, predictions, and targets
+
+```python
+    with torch.no_grad():
+```
+- Disables gradient computation (saves memory and speeds up inference)
+
+```python
+        for batch in loader:
+            batch = {k: v.to(device, non_blocking=True) for k, v in batch.items()}
+            with autocast(enabled=True):
+                out = model(input_ids=batch["input_ids"], attention_mask=batch["attention_mask"])
+                loss = criterion(out.logits, batch["labels"])
+```
+- Moves batch to device
+- Forward pass with mixed precision
+- Calculates validation loss
+
+```python
+            losses.append(loss.item())
+            preds.append(torch.sigmoid(out.logits).float().cpu().numpy())
+            targs.append(batch["labels"].cpu().numpy())
+```
+- Stores loss
+- Applies sigmoid to convert logits to probabilities [0, 1]
+- Moves predictions and targets to CPU as numpy arrays
+
+```python
+    return np.mean(losses), np.vstack(preds), np.vstack(targs)
+```
+- Returns average loss, stacked predictions, and stacked targets
+
+---
+
+## Section 7: Main K-Fold Training Loop
+
+### Lines 246-324: `run_training` Function
+
+```python
+def run_training():
+    if not os.path.exists(CONFIG.TRAIN_CSV):
+        print("Train CSV not found. Please check the path.")
+        return None, None
+```
+- Checks if training data exists
+- Returns None if not found (graceful failure)
+
+```python
+    df = pd.read_csv(CONFIG.TRAIN_CSV)
+    df = ensure_text_column(df)
+```
+- Loads training data
+- Ensures text column exists
+
+```python
+    skf = StratifiedKFold(n_splits=CONFIG.N_FOLDS, shuffle=True, random_state=CONFIG.SEED)
+    y_str = df[CONFIG.LABELS].astype(str).agg("".join, axis=1)
+```
+- Creates 5-fold stratified splitter
+- Converts multi-label to string representation for stratification
+- Example: [1,0,1,0,0] → "10100"
+
+```python
+    oof_preds = np.zeros((len(df), len(CONFIG.LABELS)))
+```
+- Initializes out-of-fold predictions array (for all training samples)
+
+```python
+    tokenizer = AutoTokenizer.from_pretrained(CONFIG.MODEL_NAME)
+```
+- Loads DeBERTa tokenizer
+
+```python
+    for fold, (train_idx, val_idx) in enumerate(skf.split(df, y_str)):
+        print(f"\n{'='*20} FOLD {fold+1}/{CONFIG.N_FOLDS} {'='*20}")
+```
+- Iterates through each fold
+- `train_idx`: indices for training, `val_idx`: indices for validation
+
+```python
+        df_tr = df.iloc[train_idx].reset_index(drop=True)
+        df_va = df.iloc[val_idx].reset_index(drop=True)
+```
+- Splits data into training and validation sets for current fold
+- Resets index for clean indexing
+
+```python
+        ds_tr = EmotionDS(df_tr, tokenizer, CONFIG.MAX_LEN)
+        ds_va = EmotionDS(df_va, tokenizer, CONFIG.MAX_LEN)
+```
+- Creates PyTorch datasets for training and validation
+
+```python
+        dl_tr = torch.utils.data.DataLoader(ds_tr, batch_size=CONFIG.BATCH_SIZE, shuffle=True, num_workers=2, pin_memory=True)
+        dl_va = torch.utils.data.DataLoader(ds_va, batch_size=CONFIG.BATCH_SIZE, shuffle=False, num_workers=2, pin_memory=True)
+```
+- Creates data loaders
+- **shuffle=True** for training (randomizes batch order)
+- **shuffle=False** for validation (keeps consistent order)
+- **num_workers=2**: Uses 2 subprocesses for data loading
+- **pin_memory=True**: Speeds up CPU→GPU transfer
+
+```python
+        model = AutoModelForSequenceClassification.from_pretrained(
+            CONFIG.MODEL_NAME, 
+            num_labels=len(CONFIG.LABELS),
+            problem_type="multi_label_classification"
+        )
+        model.to(device)
+```
+- Loads pre-trained DeBERTa model
+- Configures for 5-label multi-label classification
+- Moves model to GPU/CPU
+
+```python
+        optimizer_params = get_optimizer_params(model, CONFIG.LR, CONFIG.WEIGHT_DECAY)
+        optimizer = AdamW(optimizer_params, lr=CONFIG.LR)
+```
+- Gets parameter groups with differential weight decay
+- Creates AdamW optimizer
+
+```python
+        total_steps = len(dl_tr) * CONFIG.EPOCHS
+        scheduler = get_linear_schedule_with_warmup(
+            optimizer, 
+            num_warmup_steps=int(total_steps * CONFIG.WARMUP_RATIO), 
+            num_training_steps=total_steps
+        )
+```
+- Calculates total training steps
+- Creates learning rate scheduler:
+  - Warmup: LR increases linearly for 10% of steps
+  - Decay: LR decreases linearly to 0 for remaining 90%
+
+```python
+        criterion = nn.BCEWithLogitsLoss()
+        scaler = GradScaler(enabled=True)
+```
+- **BCEWithLogitsLoss**: Binary cross-entropy loss for multi-label classification
+- Creates gradient scaler for mixed precision
+
+```python
+        best_f1 = 0
+        best_state = None
+```
+- Initializes tracking for best model
+
+```python
+        for ep in range(CONFIG.EPOCHS):
+            train_loss = train_one_epoch(model, dl_tr, optimizer, scheduler, scaler, criterion)
+            val_loss, val_preds, val_targs = validate(model, dl_va, criterion)
+```
+- Trains for one epoch
+- Validates on validation set
+
+```python
+            val_f1 = f1_score(val_targs, (val_preds >= 0.5).astype(int), average="macro", zero_division=0)
+```
+- Calculates macro F1 score (average F1 across all labels)
+- Uses 0.5 threshold for predictions
+
+```python
+            print(f"Ep {ep+1}: TrLoss={train_loss:.4f} | VaLoss={val_loss:.4f} | VaF1={val_f1:.4f}")
+```
+- Prints epoch metrics
+
+```python
+            if val_f1 > best_f1:
+                best_f1 = val_f1
+                best_state = model.state_dict()
+```
+- Saves model state if validation F1 improves
+
+```python
+        torch.save(best_state, f"model_fold_{fold}.pth")
+```
+- Saves best model weights to disk
+
+```python
+        model.load_state_dict(best_state)
+        _, val_preds, _ = validate(model, dl_va, criterion)
+        oof_preds[val_idx] = val_preds
+```
+- Loads best weights
+- Gets predictions on validation set
+- Stores out-of-fold predictions
+
+```python
+        del model, optimizer, scaler, scheduler
+        torch.cuda.empty_cache()
+        gc.collect()
+```
+- Deletes objects to free memory
+- Clears GPU cache
+- Runs garbage collector
+
+```python
+    return oof_preds, df[CONFIG.LABELS].values
+```
+- Returns out-of-fold predictions and true labels
+
+```python
+if os.path.exists(CONFIG.TRAIN_CSV):
+    oof_preds, y_true = run_training()
+else:
+    print("Skipping training as data is not found (likely in a dry-run environment).")
+```
+- Executes training if data exists
+- Otherwise skips gracefully
+
+---
+
+## Section 8: Threshold Optimization
+
+### Lines 340-347: Threshold Tuning
+
+```python
+if os.path.exists(CONFIG.TRAIN_CSV):
+    best_thresholds = tune_thresholds(y_true, oof_preds)
+```
+- Finds optimal threshold for each emotion label using validation predictions
+
+```python
+    oof_tuned = (oof_preds >= best_thresholds).astype(int)
+```
+- Converts probabilities to binary predictions using optimized thresholds
+
+```python
+    final_f1 = f1_score(y_true, oof_tuned, average="macro", zero_division=0)
+    print(f"\nFinal CV Macro F1: {final_f1:.4f}")
+    print(f"Best Thresholds: {best_thresholds}")
+```
+- Calculates cross-validated F1 score with optimized thresholds
+- Prints final performance and optimal thresholds
+
+```python
+else:
+    best_thresholds = np.array([0.5] * len(CONFIG.LABELS))
+```
+- Falls back to 0.5 thresholds if training data not available
+
+---
+
+## Section 9: Inference & Submission
+
+### Lines 363-420: `predict_test` Function
+
+```python
+def predict_test(thresholds):
+    if not os.path.exists(CONFIG.TEST_CSV):
+        print("Test CSV not found.")
+        return
+```
+- Checks if test data exists
+
+```python
+    df_test = pd.read_csv(CONFIG.TEST_CSV)
+    df_test = ensure_text_column(df_test)
+```
+- Loads test data and ensures text column
+
+```python
+    tokenizer = AutoTokenizer.from_pretrained(CONFIG.MODEL_NAME)
+    ds_test = EmotionDS(df_test, tokenizer, CONFIG.MAX_LEN, is_test=True)
+    dl_test = torch.utils.data.DataLoader(ds_test, batch_size=CONFIG.BATCH_SIZE, shuffle=False, num_workers=2)
+```
+- Creates tokenizer, dataset, and data loader for test data
+- `is_test=True`: No labels expected
+
+```python
+    fold_preds = []
+```
+- Initializes list to store predictions from each fold
+
+```python
+    for fold in range(CONFIG.N_FOLDS):
+        model_path = f"model_fold_{fold}.pth"
+        if not os.path.exists(model_path):
+            print(f"Model for fold {fold} not found, skipping.")
+            continue
+```
+- Iterates through all folds
+- Checks if model exists
+
+```python
+        print(f"Predicting Fold {fold+1}...")
+        model = AutoModelForSequenceClassification.from_pretrained(
+            CONFIG.MODEL_NAME, 
+            num_labels=len(CONFIG.LABELS),
+            problem_type="multi_label_classification"
+        )
+        model.load_state_dict(torch.load(model_path))
+        model.to(device)
+        model.eval()
+```
+- Loads model architecture
+- Loads trained weights
+- Sets to evaluation mode
+
+```python
+        preds = []
+        with torch.no_grad():
+            for batch in dl_test:
+                batch = {k: v.to(device, non_blocking=True) for k, v in batch.items()}
+                with autocast(enabled=True):
+                    out = model(input_ids=batch["input_ids"], attention_mask=batch["attention_mask"])
+                preds.append(torch.sigmoid(out.logits).float().cpu().numpy())
+```
+- Makes predictions without computing gradients
+- Uses mixed precision for speed
+- Applies sigmoid to get probabilities
+
+```python
+        fold_preds.append(np.vstack(preds))
+        del model
+        torch.cuda.empty_cache()
+        gc.collect()
+```
+- Stores fold predictions
+- Frees memory
+
+```python
+    if not fold_preds:
+        print("No predictions made.")
+        return
+```
+- Checks if any predictions were made
+
+```python
+    avg_preds = np.mean(fold_preds, axis=0)
+```
+- Averages predictions across all folds (ensemble)
+
+```python
+    final_preds = (avg_preds >= thresholds).astype(int)
+```
+- Applies optimized thresholds to get binary predictions
+
+```python
+    sub = pd.DataFrame(columns=["id"] + CONFIG.LABELS)
+    sub["id"] = df_test["id"] if "id" in df_test.columns else np.arange(len(df_test))
+    sub[CONFIG.LABELS] = final_preds
+    sub.to_csv(CONFIG.SUBMISSION_PATH, index=False)
+    print(f"Submission saved to {CONFIG.SUBMISSION_PATH}")
+    print(sub.head())
+```
+- Creates submission DataFrame
+- Adds ID column (from data or generated)
+- Adds prediction columns
+- Saves to CSV
+- Displays first few rows
+
+```python
+predict_test(best_thresholds)
+```
+- Executes prediction function with optimized thresholds
+
+---
+
+## Summary
+
+This notebook implements a **robust emotion classification pipeline** with:
+
+1. **K-Fold Cross-Validation**: 5-fold stratified CV for reliable performance estimates
+2. **State-of-the-Art Model**: DeBERTa-v3-base transformer
+3. **Optimization Techniques**:
+   - Mixed precision training (faster, less memory)
+   - Gradient clipping (stability)
+   - Learning rate warmup and decay
+   - Differential weight decay
+4. **Threshold Optimization**: Per-label thresholds for better F1 scores
+5. **Ensemble Prediction**: Averages predictions from all folds
+6. **Memory Management**: Explicit cleanup between folds
+
+The model predicts 5 emotions (anger, fear, joy, sadness, surprise) in a **multi-label** setting, where text can have multiple emotions simultaneously.

submission_notebook.ipynb

@@ -0,0 +1,314 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b2b05c00",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install -q transformers torch huggingface_hub pandas numpy kaggle\n",
+    "\n",
+    "import os\n",
+    "from pathlib import Path\n",
+    "\n",
+    "kaggle_json_path = Path.home() / '.kaggle' / 'kaggle.json'\n",
+    "\n",
+    "if not kaggle_json_path.exists():\n",
+    "    print(\"Kaggle credentials not found.\")\n",
+    "    print(\"\\nIf you have kaggle.json in the current directory:\")\n",
+    "    if Path('kaggle.json').exists():\n",
+    "        kaggle_json_path.parent.mkdir(exist_ok=True, parents=True)\n",
+    "        import shutil\n",
+    "        shutil.copy('kaggle.json', kaggle_json_path)\n",
+    "        kaggle_json_path.chmod(0o600)\n",
+    "        print(\"Kaggle credentials configured\")\n",
+    "    else:\n",
+    "        print(\"\\nPlease upload kaggle.json to this directory, then re-run this cell.\")\n",
+    "        print(\"Download from: https://www.kaggle.com/settings\")\n",
+    "else:\n",
+    "    print(\"Kaggle credentials found\")\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import torch\n",
+    "from transformers import AutoTokenizer, AutoModelForSequenceClassification\n",
+    "from torch.cuda.amp import autocast\n",
+    "from huggingface_hub import hf_hub_download\n",
+    "import warnings\n",
+    "\n",
+    "warnings.filterwarnings(\"ignore\")\n",
+    "\n",
+    "class Config:\n",
+    "    HF_REPO_ID = \"YOUR_USERNAME/emotion-classifier-deberta-v3\"\n",
+    "    COMPETITION_NAME = \"2025-sep-dl-gen-ai-project\"\n",
+    "    LABELS = [\"anger\", \"fear\", \"joy\", \"sadness\", \"surprise\"]\n",
+    "    MAX_LEN = 128\n",
+    "    BATCH_SIZE = 32\n",
+    "    TEST_CSV = \"/kaggle/input/2025-sep-dl-gen-ai-project/test.csv\"\n",
+    "    SUBMISSION_PATH = \"submission.csv\"\n",
+    "\n",
+    "CONFIG = Config()\n",
+    "\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "print(f\"Using device: {device}\")\n",
+    "if torch.cuda.is_available():\n",
+    "    print(f\"GPU: {torch.cuda.get_device_name(0)}\")\n",
+    "\n",
+    "print(f\"Loading model from HuggingFace: {CONFIG.HF_REPO_ID}\")\n",
+    "\n",
+    "try:\n",
+    "    print(\"  Loading model...\")\n",
+    "    model = AutoModelForSequenceClassification.from_pretrained(\n",
+    "        CONFIG.HF_REPO_ID,\n",
+    "        num_labels=len(CONFIG.LABELS),\n",
+    "        problem_type=\"multi_label_classification\"\n",
+    "    )\n",
+    "    model.to(device)\n",
+    "    model.eval()\n",
+    "    print(\"  Model loaded\")\n",
+    "    \n",
+    "    print(\"  Loading tokenizer...\")\n",
+    "    tokenizer = AutoTokenizer.from_pretrained(CONFIG.HF_REPO_ID)\n",
+    "    print(\"  Tokenizer loaded\")\n",
+    "    \n",
+    "    print(\"  Loading optimized thresholds...\")\n",
+    "    try:\n",
+    "        threshold_path = hf_hub_download(\n",
+    "            repo_id=CONFIG.HF_REPO_ID,\n",
+    "            filename=\"best_thresholds.npy\"\n",
+    "        )\n",
+    "        best_thresholds = np.load(threshold_path)\n",
+    "        print(\"  Optimized thresholds loaded\")\n",
+    "        print(f\"\\n  Thresholds per label:\")\n",
+    "        for i, label in enumerate(CONFIG.LABELS):\n",
+    "            print(f\"    {label}: {best_thresholds[i]:.3f}\")\n",
+    "    except Exception as e:\n",
+    "        print(f\"  Could not load thresholds: {e}\")\n",
+    "        print(\"  Using default thresholds of 0.5\")\n",
+    "        best_thresholds = np.array([0.5] * len(CONFIG.LABELS))\n",
+    "    \n",
+    "    print(\"\\nModel setup complete\")\n",
+    "    \n",
+    "except Exception as e:\n",
+    "    print(f\"\\nError loading model: {e}\")\n",
+    "    print(\"\\nPlease ensure:\")\n",
+    "    print(\"1. You've updated CONFIG.HF_REPO_ID with your actual repository ID\")\n",
+    "    print(\"2. The model was successfully uploaded in the training notebook\")\n",
+    "    print(\"3. The repository is public or you're logged in to HuggingFace\")\n",
+    "    raise\n",
+    "\n",
+    "def ensure_text_column(df: pd.DataFrame) -> pd.DataFrame:\n",
+    "    if \"text\" in df.columns:\n",
+    "        return df\n",
+    "    for c in [\"comment_text\", \"sentence\", \"content\", \"review\"]:\n",
+    "        if c in df.columns:\n",
+    "            return df.rename(columns={c: \"text\"})\n",
+    "    raise ValueError(\"No text column found. Add/rename your text column to 'text'.\")\n",
+    "\n",
+    "class EmotionDS(torch.utils.data.Dataset):\n",
+    "    def __init__(self, texts, tokenizer, max_len):\n",
+    "        self.texts = texts\n",
+    "        self.tok = tokenizer\n",
+    "        self.max_len = max_len\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.texts)\n",
+    "\n",
+    "    def __getitem__(self, i):\n",
+    "        enc = self.tok(\n",
+    "            self.texts[i],\n",
+    "            truncation=True,\n",
+    "            padding=\"max_length\",\n",
+    "            max_length=self.max_len,\n",
+    "            return_tensors=\"pt\",\n",
+    "        )\n",
+    "        return {k: v.squeeze(0) for k, v in enc.items()}\n",
+    "\n",
+    "print(f\"Loading test data from: {CONFIG.TEST_CSV}\")\n",
+    "\n",
+    "if not os.path.exists(CONFIG.TEST_CSV):\n",
+    "    print(\"Test CSV not found. Please check the path.\")\n",
+    "    print(\"\\nIf you're running locally, make sure you have the test data.\")\n",
+    "    print(\"On Kaggle, ensure you've added the competition data as input.\")\n",
+    "    raise FileNotFoundError(CONFIG.TEST_CSV)\n",
+    "\n",
+    "df_test = pd.read_csv(CONFIG.TEST_CSV)\n",
+    "df_test = ensure_text_column(df_test)\n",
+    "\n",
+    "print(f\"Test data loaded: {len(df_test)} samples\")\n",
+    "print(f\"\\nColumns: {df_test.columns.tolist()}\")\n",
+    "print(f\"\\nFirst few rows:\")\n",
+    "print(df_test.head())\n",
+    "\n",
+    "print(\"\\nGenerating predictions...\\n\")\n",
+    "\n",
+    "test_texts = df_test[\"text\"].tolist()\n",
+    "test_dataset = EmotionDS(test_texts, tokenizer, CONFIG.MAX_LEN)\n",
+    "test_loader = torch.utils.data.DataLoader(\n",
+    "    test_dataset, \n",
+    "    batch_size=CONFIG.BATCH_SIZE, \n",
+    "    shuffle=False, \n",
+    "    num_workers=2,\n",
+    "    pin_memory=True\n",
+    ")\n",
+    "\n",
+    "all_preds = []\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    for batch_idx, batch in enumerate(test_loader):\n",
+    "        batch = {k: v.to(device, non_blocking=True) for k, v in batch.items()}\n",
+    "        \n",
+    "        with autocast(enabled=True):\n",
+    "            outputs = model(\n",
+    "                input_ids=batch[\"input_ids\"], \n",
+    "                attention_mask=batch[\"attention_mask\"]\n",
+    "            )\n",
+    "        \n",
+    "        probs = torch.sigmoid(outputs.logits).float().cpu().numpy()\n",
+    "        all_preds.append(probs)\n",
+    "        \n",
+    "        if (batch_idx + 1) % 10 == 0:\n",
+    "            progress = (batch_idx + 1) * CONFIG.BATCH_SIZE\n",
+    "            print(f\"  Processed {min(progress, len(df_test))}/{len(df_test)} samples...\")\n",
+    "\n",
+    "all_probs = np.vstack(all_preds)\n",
+    "\n",
+    "print(f\"\\nPredictions generated for {len(all_probs)} samples\")\n",
+    "print(f\"Shape: {all_probs.shape}\")\n",
+    "\n",
+    "print(\"\\nApplying optimized thresholds...\\n\")\n",
+    "\n",
+    "final_predictions = (all_probs >= best_thresholds).astype(int)\n",
+    "\n",
+    "print(f\"Thresholds applied\")\n",
+    "print(f\"\\nPrediction distribution:\")\n",
+    "for i, label in enumerate(CONFIG.LABELS):\n",
+    "    count = final_predictions[:, i].sum()\n",
+    "    percentage = (count / len(final_predictions)) * 100\n",
+    "    print(f\"  {label:<12} {count:>6} samples ({percentage:>5.1f}%)\")\n",
+    "\n",
+    "avg_labels_per_sample = final_predictions.sum(axis=1).mean()\n",
+    "print(f\"\\n  Average labels per sample: {avg_labels_per_sample:.2f}\")\n",
+    "\n",
+    "print(\"\\nCreating submission file...\\n\")\n",
+    "\n",
+    "submission = pd.DataFrame()\n",
+    "\n",
+    "if \"id\" in df_test.columns:\n",
+    "    submission[\"id\"] = df_test[\"id\"]\n",
+    "else:\n",
+    "    submission[\"id\"] = np.arange(len(df_test))\n",
+    "\n",
+    "for i, label in enumerate(CONFIG.LABELS):\n",
+    "    submission[label] = final_predictions[:, i]\n",
+    "\n",
+    "submission.to_csv(CONFIG.SUBMISSION_PATH, index=False)\n",
+    "\n",
+    "print(f\"Submission file saved to: {CONFIG.SUBMISSION_PATH}\")\n",
+    "print(f\"\\nSubmission preview:\")\n",
+    "print(submission.head(10))\n",
+    "print(f\"\\nTotal rows: {len(submission)}\")\n",
+    "print(f\"Columns: {submission.columns.tolist()}\")\n",
+    "\n",
+    "print(\"Verifying submission format...\\n\")\n",
+    "\n",
+    "required_columns = [\"id\"] + CONFIG.LABELS\n",
+    "submission_columns = submission.columns.tolist()\n",
+    "\n",
+    "if submission_columns == required_columns:\n",
+    "    print(\"Submission format is correct\")\n",
+    "    print(f\"  Columns: {submission_columns}\")\n",
+    "    \n",
+    "    if submission[CONFIG.LABELS].isin([0, 1]).all().all():\n",
+    "        print(\"All predictions are binary (0 or 1)\")\n",
+    "    else:\n",
+    "        print(\"Warning: Some predictions are not binary\")\n",
+    "    \n",
+    "    if not submission.isnull().any().any():\n",
+    "        print(\"No missing values\")\n",
+    "    else:\n",
+    "        print(\"Missing values detected\")\n",
+    "        print(submission.isnull().sum())\n",
+    "else:\n",
+    "    print(\"Submission format is incorrect\")\n",
+    "    print(f\"  Expected: {required_columns}\")\n",
+    "    print(f\"  Got: {submission_columns}\")\n",
+    "\n",
+    "print(\"\\nSubmitting to Kaggle...\\n\")\n",
+    "\n",
+    "submission_message = f\"DeBERTa-v3 with optimized thresholds - HF: {CONFIG.HF_REPO_ID}\"\n",
+    "\n",
+    "try:\n",
+    "    import kaggle\n",
+    "    \n",
+    "    kaggle.api.competition_submit(\n",
+    "        file_name=CONFIG.SUBMISSION_PATH,\n",
+    "        message=submission_message,\n",
+    "        competition=CONFIG.COMPETITION_NAME\n",
+    "    )\n",
+    "    \n",
+    "    print(\"Submission successful\")\n",
+    "    print(f\"\\nSubmission message: {submission_message}\")\n",
+    "    print(f\"\\nView your submission at:\")\n",
+    "    print(f\"  https://www.kaggle.com/c/{CONFIG.COMPETITION_NAME}/submissions\")\n",
+    "    \n",
+    "except Exception as e:\n",
+    "    print(f\"Submission failed: {e}\")\n",
+    "    print(\"\\nPossible reasons:\")\n",
+    "    print(\"1. Kaggle API credentials not configured\")\n",
+    "    print(\"2. Competition name is incorrect\")\n",
+    "    print(\"3. You've reached the daily submission limit\")\n",
+    "    print(\"4. The competition has ended\")\n",
+    "    print(\"\\nYou can manually upload the submission.csv file to Kaggle.\")\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*60)\n",
+    "print(\"PREDICTION STATISTICS\")\n",
+    "print(\"=\"*60)\n",
+    "\n",
+    "labels_per_sample = final_predictions.sum(axis=1)\n",
+    "print(\"\\nLabels per sample distribution:\")\n",
+    "for i in range(6):\n",
+    "    count = (labels_per_sample == i).sum()\n",
+    "    percentage = (count / len(labels_per_sample)) * 100\n",
+    "    print(f\"  {i} labels: {count:>6} samples ({percentage:>5.1f}%)\")\n",
+    "\n",
+    "print(\"\\nMost common label combinations:\")\n",
+    "label_combinations = []\n",
+    "for pred in final_predictions:\n",
+    "    active_labels = [CONFIG.LABELS[i] for i, val in enumerate(pred) if val == 1]\n",
+    "    if active_labels:\n",
+    "        label_combinations.append(\", \".join(sorted(active_labels)))\n",
+    "    else:\n",
+    "        label_combinations.append(\"(none)\")\n",
+    "\n",
+    "from collections import Counter\n",
+    "combo_counts = Counter(label_combinations)\n",
+    "for combo, count in combo_counts.most_common(10):\n",
+    "    percentage = (count / len(label_combinations)) * 100\n",
+    "    print(f\"  {combo:<30} {count:>6} ({percentage:>5.1f}%)\")\n",
+    "\n",
+    "print(\"\\nAverage probability per label:\")\n",
+    "for i, label in enumerate(CONFIG.LABELS):\n",
+    "    avg_prob = all_probs[:, i].mean()\n",
+    "    std_prob = all_probs[:, i].std()\n",
+    "    print(f\"  {label:<12} {avg_prob:.4f} +/- {std_prob:.4f}\")\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*60)\n",
+    "print(\"SUBMISSION COMPLETE\")\n",
+    "print(\"=\"*60)\n",
+    "print(f\"\\nSubmission file: {CONFIG.SUBMISSION_PATH}\")\n",
+    "print(f\"Model used: {CONFIG.HF_REPO_ID}\")\n",
+    "print(f\"Optimized thresholds: {best_thresholds}\")\n",
+    "print(\"\\nCheck Kaggle leaderboard for your score\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}