Update from Kaggle notebook

app.py

@@ -1,5 +1,329 @@
 import gradio as gr
 
+get_ipython().run_line_magic('pip', 'install transformers==4.45.0 accelerate==0.26.0 bitsandbytes==0.43.3')
+
+import torch
+print(torch.__version__)
+print(torch.cuda.is_available())
+print(torch.version.cuda)
+get_ipython().system('pip show bitsandbytes')
+import bitsandbytes
+print(bitsandbytes.__version__)
+import bitsandbytes as bnb
+import torch
+x = torch.randn(10, device="cuda")
+y = bnb.functional.quantize_4bit(x)
+print("Quantization worked!")
+import bitsandbytes.nn
+import bitsandbytes.functional
+print("Submodules imported successfully!")
+
+import transformers
+transformers.utils.is_bitsandbytes_available = lambda: True
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+import os
+import gc
+
+torch.cuda.empty_cache()
+gc.collect()
+
+bnb_config = BitsAndBytesConfig(
+    load_in_4bit=True,
+    bnb_4bit_quant_type="nf4",
+    bnb_4bit_compute_dtype=torch.bfloat16,
+    bnb_4bit_use_double_quant=True,
+)
+
+# Define model and tokenizer
+model_name = "deepseek-ai/deepseek-math-7b-instruct"
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+
+# Set padding token if not already set
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
+
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    quantization_config=bnb_config,
+    device_map="auto",
+    trust_remote_code=True,
+)
+
+from peft import LoraConfig, get_peft_model
+
+# Define LoRA configuration
+lora_config = LoraConfig(
+    r=16,  # Rank of the LoRA adaptation
+    lora_alpha=32,  # Scaling factor
+    target_modules=["q_proj", "v_proj"],  # Target attention layers (adjust based on model architecture)
+    lora_dropout=0.05,  # Dropout for regularization
+    bias="none",  # No bias in LoRA layers
+    task_type="CAUSAL_LM",  # Task type for causal language modeling
+)
+
+# Apply LoRA to the model
+model = get_peft_model(model, lora_config)
+model.print_trainable_parameters()  # Verify trainable parameters
+
+dataset = [
+  {
+    "problem": "🍎 + 🍎 + 🍎 = 12",
+    "output": "🍎 = 4 Explanation: If three apples equal 12, then each apple equals 4 as 12/3 is 4."
+  },
+  {
+    "problem": "🍌 + 🍌 = 10",
+    "output": "🍌 = 5 Explanation: If two bananas equal 10, then each banana equals 5."
+  },
+  {
+    "problem": "🍊 × 3 = 15",
+    "output": "🍊 = 5 Explanation: If an orange multiplied by 3 equals 15, then each orange equals 5."
+  },
+  {
+    "problem": "🍇 ÷ 2 = 6",
+    "output": "🍇 = 12 Explanation : If grapes divided by 2 equals 6, then grapes equals 12."
+  },
+  {
+    "problem": "🍓 + 🍓 + 🍓 + 🍓 = 20",
+    "output": "🍓 = 5 Explanation : If four strawberries equal 20, then each strawberry equals 5."
+  },
+  {
+    "problem": "🍍 - 🍉 = 3, 🍍 + 🍉 = 15",
+    "output": "🍍 = 9, 🍉 = 6 Explanation : Using the system of equations, we can solve that pineapple equals 9 and watermelon equals 6."
+  },
+  {
+    "problem": "🍒 + 🍒 + 🍐 = 16, 🍐 + 🍐 + 🍒 = 19",
+    "output": "🍒 = 5, 🍐 = 6 Explanation : Solving the system of equations: 2🍒 + 🍐 = 16 and 🍒 + 2🍐 = 19."
+  },
+  {
+    "problem": "3 × 🥝 = 🍋 + 3, 🍋 = 12",
+    "output": "🥝 = 5 Explanation: If lemon equals 12, then 3 times kiwi equals 15, so kiwi equals 5."
+  },
+  {
+    "problem": "🥭 × 🥭 = 36",
+    "output": "🥭 = 6 Explanation : If mango squared equals 36, then mango equals 6."
+  },
+  {
+    "problem": "🍑 ÷ 4 = 3",
+    "output": "🍑 = 12 Explanation: If peach divided by 4 equals 3, then peach equals 12."
+  },
+  {
+    "problem": "🥥 + 🥥 + 🥥 = 🍈 × 3, 🍈 = 5",
+    "output": "🥥 = 5 Explanation : If melon equals 5, then melon times 3 equals 15, so three coconuts equal 15, making each coconut equal to 5."
+  },
+  {
+    "problem": "🍏 + 🍐 = 11, 🍏 - 🍐 = 1",
+    "output": "🍏 = 6, 🍐 = 5 Explanation : Solving the system of equations: green apple plus pear equals 11, and green apple minus pear equals 1."
+  },
+  {
+    "problem": "2 × 🍋 + 🍊 = 25, 🍋 = 7",
+    "output": "🍊 = 11 Explanation : If lemon equals 7, then 2 times lemon equals 14, so orange equals 11."
+  },
+  {
+    "problem": "🍉 ÷ 🍇 = 4, 🍇 = 3",
+    "output": "🍉 = 12 Explanation : If grapes equal 3 and watermelon divided by grapes equals 4, then watermelon equals 12."
+  },
+  {
+    "problem": "(🍎 + 🍌) × 2 = 18, 🍎 = 4",
+    "output": "🍌 = 5 Explanation : If apple equals 4, then apple plus banana equals 9, so banana equals 5."
+  },
+  {
+    "problem": "🍓 × 🍓 - 🍓 = 20",
+    "output": "🍓 = 5 Explanation : If strawberry squared minus strawberry equals 20, then strawberry equals 5 (5² - 5 = 20)."
+  },
+  {
+    "problem": "🥑 + 🥑 + 🥑 + 🥑 = 🍍 × 2, 🍍 = 10",
+    "output": "🥑 = 5 Explanation : If pineapple equals 10, then pineapple times 2 equals 20, so four avocados equal 20, making each avocado equal to 5."
+  },
+  {
+    "problem": "🍒 + 🍒 = 🍊 + 3, 🍊 = 5",
+    "output": "🍒 = 4 Explanation : If orange equals 5, then two cherries equal 8, so each cherry equals 4."
+  },
+  {
+    "problem": "3 × (🍎 - 🍐) = 6, 🍎 = 5",
+    "output": "🍐 = 3 Explanation : If apple equals 5, then apple minus pear equals 2, so pear equals 3."
+  },
+  {
+    "problem": "🍌 ÷ 🍓 = 3, 🍓 = 2",
+    "output": "🍌 = 6 Explanation : If strawberry equals 2 and banana divided by strawberry equals 3, then banana equals 6."
+  },
+  {
+    "problem": "🥝 × 🥝 × 🥝 = 27",
+    "output": "🥝 = 3 Explanation : If kiwi cubed equals 27, then kiwi equals 3."
+  },
+  {
+    "problem": "🍑 + 🍒 + 🍓 = 13, 🍑 = 5, 🍒 = 4",
+    "output": "🍓 = 4 Explanation : If peach equals 5 and cherry equals 4, then strawberry equals 4."
+  },
+  {
+    "problem": "🍎 × 🍌 = 24, 🍎 = 6",
+    "output": "🍌 = 4 Explanation : If apple equals 6 and apple times banana equals 24, then banana equals 4."
+  },
+  {
+    "problem": "🍉 - 🍈 = 🍇 + 1, 🍉 = 10, 🍇 = 3",
+    "output": "🍈 = 6 Explanation : If watermelon equals 10 and grapes equal 3, then melon equals 6."
+  },
+  {
+    "problem": "(🍊 + 🍋) ÷ 2 = 7, 🍊 = 5",
+    "output": "🍋 = 9 Explanation : If orange equals 5, then orange plus lemon equals 14, so lemon equals 9."
+  },
+  {
+    "problem": "🍍 × 2 - 🥥 = 11, 🍍 = 7",
+    "output": "🥥 = 3 Explanation : If pineapple equals 7, then pineapple times 2 equals 14, so coconut equals 3."
+  },
+  {
+    "problem": "🍏 + 🍐 + 🍊 = 18, 🍏 = 🍐 + 2, 🍊 = 🍐 + 1",
+    "output": "🍏 = 7, 🍐 = 5, 🍊 = 6 Explanation : Solving the system of equations with the given relationships between green apple, pear, and orange."
+  },
+  {
+    "problem": "🍌 × (🍎 - 🍓) = 12, 🍎 = 7, 🍓 = 4",
+    "output": "🍌 = 4 Explanation : If apple equals 7 and strawberry equals 4, then apple minus strawberry equals 3, so banana equals 4."
+  },
+  {
+    "problem": "🍇 + 🍇 + 🍇 = (🍑 × 2) + 3, 🍑 = 4",
+    "output": "🍇 = 5 Explanation : If peach equals 4, then peach times 2 plus 3 equals 11, so three grapes equal 15, making each grape equal to 5."
+  },
+  {
+    "problem": "🥭 ÷ (🍋 - 🍊) = 2, 🍋 = 7, 🍊 = 3",
+    "output": "🥭 = 8 Explanation : If lemon equals 7 and orange equals 3, then lemon minus orange equals 4, so mango equals 8."
+  }
+]
+
+# Prepare dataset for training
+def format_data(example):
+    # Format input and output as a conversation
+    messages = [
+        {"role": "user", "content": example["problem"]},
+        {"role": "assistant", "content": example["output"]}
+    ]
+    # Apply chat template and tokenize
+    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    return {"text": text}
+
+from datasets import Dataset
+# Convert list to Hugging Face Dataset
+hf_dataset = Dataset.from_list(dataset)
+tokenized_dataset = hf_dataset.map(format_data, remove_columns=["problem", "output"])
+
+# Tokenize the dataset
+def tokenize_function(examples):
+    return tokenizer(
+        examples["text"],
+        padding="max_length",
+        truncation=True,
+        max_length=512,
+        return_tensors="pt"
+    )
+
+tokenized_dataset = tokenized_dataset.map(tokenize_function, batched=True)
+
+# Split dataset into train and eval (90% train, 10% eval)
+train_test_split = tokenized_dataset.train_test_split(test_size=0.1)
+train_dataset = train_test_split["train"]
+eval_dataset = train_test_split["test"]
+
+# Define data collator
+from transformers import DataCollatorForLanguageModeling
+data_collator = DataCollatorForLanguageModeling(
+    tokenizer=tokenizer,
+    mlm=False
+)
+
+from transformers import TrainingArguments, Trainer
+
+# Define training arguments
+training_args = TrainingArguments(
+    output_dir="/kaggle/working/model_output",
+    overwrite_output_dir=True,
+    num_train_epochs=3,
+    per_device_train_batch_size=2,  # Adjust based on GPU memory (T4x2)
+    per_device_eval_batch_size=2,
+    gradient_accumulation_steps=4,  # Effective batch size = 2 * 4 = 8
+    evaluation_strategy="epoch",
+    save_strategy="epoch",
+    learning_rate=2e-5,
+    weight_decay=0.01,
+    fp16=True,  # Use mixed precision for T4 GPU
+    logging_dir="/kaggle/working/logs",
+    logging_steps=10,
+    load_best_model_at_end=True,
+    metric_for_best_model="loss",
+    report_to="none",  # Disable wandb in Kaggle
+    push_to_hub=False,
+)
+
+# Define compute metrics (optional, for evaluation)
+def compute_metrics(eval_pred):
+    logits, labels = eval_pred
+    predictions = torch.argmax(torch.tensor(logits), dim=-1)
+    return {"accuracy": (predictions == labels).mean().item()}
+
+# Initialize Trainer
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=train_dataset,
+    eval_dataset=eval_dataset,
+    data_collator=data_collator,
+    #compute_metrics=compute_metrics  # Uncomment if you want accuracy metrics
+)
+
+# Train the model
+trainer.train()
+
+# Save the model and tokenizer
+output_dir = "/kaggle/working/finetuned_model"
+model.save_pretrained(output_dir)
+tokenizer.save_pretrained(output_dir)
+
+# Zip the model directory for easy download (optional)
+import shutil
+shutil.make_archive("/kaggle/working/finetuned_model", "zip", output_dir)
+print("Model and tokenizer saved and zipped at /kaggle/working/finetuned_model.zip")
+
+# Test inference
+messages = [
+    {"role": "user", "content": "🥭 ÷ (🍋 - 🍊) = 2, 🍋 = 7, 🍊 = 3"}
+]
+input_tensor = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt").to(model.device)
+outputs = model.generate(input_tensor, max_new_tokens=100, pad_token_id=tokenizer.eos_token_id)
+result = tokenizer.decode(outputs[0][input_tensor.shape[1]:], skip_special_tokens=True)
+print("Test inference result:", result)
+
+from peft import PeftModel
+
+output_weights_path = "/kaggle/working/fine_tuned_deepseek_math_weights.pth"
+torch.save(model.state_dict(), output_weights_path)
+
+
+import shutil
+shutil.make_archive("/kaggle/working/fine_tuned_deepseek_math_weights.pth", "zip", output_dir)
+print("Model and tokenizer saved and zipped at /kaggle/working/weights.zip")
+
+get_ipython().run_line_magic('pip', 'install gradio')
+
+from peft import PeftModel
+
+output_weights_path = "/kaggle/working/fine_tuned_deepseek_math_weights.pth"
+torch.save(model.state_dict(), output_weights_path)
+
+
+import shutil
+shutil.make_archive("/kaggle/working/fine_tuned_deepseek_math_weights.pth", "zip", output_dir)
+print("Model and tokenizer saved and zipped at /kaggle/working/weights.zip")
+
+from peft import PeftModel
+
+output_weights_path = "/kaggle/working/fine_tuned_deepseek_math_weights.pth"
+torch.save(model.state_dict(), output_weights_path)
+
+
+import shutil
+shutil.make_archive("/kaggle/working/fine_tuned_deepseek_math_weights.pth", "zip", output_dir)
+print("Model and tokenizer saved and zipped at /kaggle/working/weights.zip")
+
+import gradio as gr
+
 def process_input(user_input):
     """Process user input through the model and return the result."""
     messages = [{"role": "user", "content": user_input}]
@@ -22,13 +346,79 @@ demo = gr.Interface(
 
 demo.launch(share=True)
 
-output_weights_path = "/kaggle/working/fine_tuned_deepseek_math_weights.pth"
-torch.save(model.state_dict(), output_weights_path)
+demo.launch(share=True)
 
+import os
+from getpass import getpass
+from huggingface_hub import HfApi, Repository
+import re
+
+# Get your Hugging Face token
+hf_token = getpass("Enter your Hugging Face token: ")
+api = HfApi(token=hf_token)
+
+# Get your Space name (username/space-name)
+space_name = input("Enter your Hugging Face Space name (username/space-name): ")
+
+# Extract the Gradio code from your notebook
+# This assumes your Gradio app is defined in a cell or cells in your notebook
+from IPython import get_ipython
+
+# Get all cells from the notebook
+cells = get_ipython().user_ns.get('In', [])
+
+# Extract cells that contain Gradio code
+gradio_code = []
+in_gradio_block = False
+for cell in cells:
+    # Look for cells that import gradio or define the interface
+    if 'import gradio' in cell or 'gr.Interface' in cell or in_gradio_block:
+        in_gradio_block = True
+        gradio_code.append(cell)
+    # If we find a cell that seems to end the Gradio app definition
+    elif in_gradio_block and ('if __name__' in cell or 'demo.launch()' in cell):
+        gradio_code.append(cell)
+        in_gradio_block = False
+
+# Combine the code and ensure it has a launch method
+combined_code = "\n\n".join(gradio_code)
+
+# Make sure the app launches when run
+if 'if __name__ == "__main__"' not in combined_code:
+    combined_code += '\n\nif __name__ == "__main__":\n    demo.launch()'
+
+# Save to app.py
+with open("app.py", "w") as f:
+    f.write(combined_code)
+
+print("Extracted Gradio code and saved to app.py")
+
+# Clone the existing Space repository
+repo = Repository(
+    local_dir="space_repo",
+    clone_from=f"https://huggingface.co/spaces/{space_name}",
+    token=hf_token,
+    git_user="marwashahid",
+    git_email="[email protected]"
+)
 
+# Copy app.py to the repository
 import shutil
-shutil.make_archive("/kaggle/working/fine_tuned_deepseek_math_weights.pth", "zip", output_dir)
-print("Model and tokenizer saved and zipped at /kaggle/working/weights.zip")
+shutil.copy("app.py", "space_repo/app.py")
+
+# Add requirements if needed
+requirements = """
+gradio>=3.50.2
+"""
+with open("space_repo/requirements.txt", "w") as f:
+    f.write(requirements)
+
+# Commit and push changes
+repo.git_add()
+repo.git_commit("Update from Kaggle notebook")
+repo.git_push()
+
+print(f"Successfully deployed to https://huggingface.co/spaces/{space_name}")
 
 import os
 from getpass import getpass