Initial commit: Multi-personality chatbot

.gitattributes

@@ -0,0 +1,3 @@
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,34 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+.venv/
+ENV/
+*.egg-info/
+dist/
+build/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Gradio
+flagged/
+
+# Model caches
+*.pt
+*.pth
+.cache/
+
+# Logs
+*.log

COLLABORATION.md

@@ -0,0 +1,152 @@
+# 🤝 Team Collaboration Guide
+
+## Quick Reference for Updating the Deployed App
+
+**Space URL**: https://huggingface.co/spaces/dianacasti/personality-chatbot
+
+---
+
+## I just trained a better adapter. How do I update it?
+
+### Option A: Direct Upload (No Git Required) ⭐ EASIEST
+
+1. Ask **dianacasti** to add you as a collaborator on the Space
+2. Go to: https://huggingface.co/spaces/dianacasti/personality-chatbot
+3. Click **"Files"** tab at the top
+4. Find the old adapter folder (e.g., `nerd-lora-adapter`)
+5. Click the **trash icon** to delete it
+6. Click **"Add file" → "Upload files"**
+7. **Drag and drop** your entire new adapter folder OR upload files individually:
+   - `adapter_model.safetensors` (the weights)
+   - `adapter_config.json`
+   - `tokenizer.json`, `tokenizer_config.json`, `vocab.json`, `merges.txt`
+   - `special_tokens_map.json`, `added_tokens.json`
+   - `chat_template.jinja`
+8. Write a commit message: "Updated nerd adapter with 50 training examples"
+9. Click **"Commit changes to main"**
+10. Wait 2-5 minutes for rebuild
+11. Test at: https://dianacasti-personality-chatbot.hf.space
+
+**Done!** ✅
+
+---
+
+### Option B: Using Git (For Advanced Users)
+
+```powershell
+# One-time setup
+git clone https://huggingface.co/spaces/dianacasti/personality-chatbot
+cd personality-chatbot
+
+# Every time you update
+# 1. Copy your new adapter folder to replace the old one
+cp -r C:\path\to\your\nerd-lora-adapter .\nerd-lora-adapter
+
+# 2. Commit and push
+git add .
+git commit -m "Updated nerd adapter - trained with 50 examples, loss 0.018"
+git push
+
+# 3. Wait for rebuild and test
+```
+
+---
+
+## Common Tasks
+
+### ✅ Replace an existing adapter (Nerd, Yoda, Pirate)
+- Use **Option A** above (direct upload is easiest)
+
+### ✅ Test adapters locally before uploading
+```powershell
+cd C:\Users\dcast\LLM\Project3\llm-project
+
+# Replace the adapter folder with your new one
+# Then run locally:
+python app.py
+
+# Test at http://localhost:7860
+# If good, upload to Hugging Face using Option A
+```
+
+### ✅ Check current training loss/quality
+- Nerd: loss 0.018 (50 examples × 10)
+- Yoda: loss 0.0165 (50 examples × 10)
+- Brainrot: loss 0.21 (large dataset)
+- Pirate: original (5 examples)
+
+Lower loss = better memorization, but might overfit if too low
+
+### ✅ Add a brand new personality
+
+1. Train your new adapter (e.g., `cowboy-lora-adapter`)
+2. Upload the adapter folder using Option A
+3. Edit `app.py` (Files tab → click `app.py` → edit icon):
+   ```python
+   ADAPTERS = {
+       "🧠 Brainrot": "qwen-brainrot-lora-stage1-final",
+       "🏴‍☠️ Pirate": "pirate-lora-adapter",
+       "🧙 Yoda": "yoda-lora-adapter",
+       "🤓 Nerd": "nerd-lora-adapter",
+       "🤠 Cowboy": "cowboy-lora-adapter",  # ADD THIS LINE
+   }
+   ```
+4. Scroll down to personality descriptions and add:
+   ```python
+   - **🤠 Cowboy**: Yeehaw, talks like a Wild West cowboy!
+   ```
+5. Commit changes
+
+---
+
+## Troubleshooting
+
+### "I don't see the Files tab"
+→ You need to be added as a collaborator. Ask dianacasti.
+
+### "Space is stuck building"
+→ Check the **"Logs"** tab for errors. Common issues:
+- Missing files in adapter folder
+- File names don't match (should be `adapter_model.safetensors`, not `model.safetensors`)
+
+### "Adapter not loading"
+→ Make sure adapter folder contains ALL files:
+- adapter_model.safetensors ✅
+- adapter_config.json ✅
+- tokenizer files (5-6 files) ✅
+- chat_template.jinja ✅
+
+### "How do I test without breaking the live app?"
+→ Clone locally and test with `python app.py` before uploading
+
+---
+
+## Training Tips for Better Adapters
+
+**Current approach**: 5 examples × 50 repetitions = 250 training samples (overfits easily)
+
+**Better approach**: 50 unique examples × 3 epochs
+- More diverse conversations
+- Less overfitting
+- Better generalization
+
+**Example training data structure**:
+```python
+train_data = [
+    {"messages": [
+        {"role": "user", "content": "Hello"},
+        {"role": "assistant", "content": "Ahoy matey!"}
+    ]},
+    # ... 49 more unique examples
+] * 3  # Repeat 3 times instead of 50
+```
+
+---
+
+## Contact
+
+- **Space Owner**: dianacasti
+- **Project Lead**: Theworst1
+- **Contributors**: Bryn Ramirez, diana
+
+For issues or questions, post in the team Discord!

PROJECT_SUMMARY.md

@@ -0,0 +1,170 @@
+# 📋 Project Summary - Multi-Personality Chatbot
+
+## 🎯 Project Overview
+
+A web application featuring multiple AI personalities powered by LoRA (Low-Rank Adaptation) fine-tuning on Qwen2-0.5B-Instruct base model. Users can switch between personalities and chat in real-time.
+
+**Live App**: https://dianacasti-personality-chatbot.hf.space (after deployment)
+
+---
+
+## 👥 Team Members & Contributions
+
+- **Theworst1**: Training lead, Brainrot dataset implementation
+- **Bryn Ramirez**: Trained Nerd & Yoda adapters (50 examples each)
+- **Diana (dianacasti)**: Web app development & deployment
+
+---
+
+## 🎭 Current Personalities
+
+| Personality | Status | Training Data | Loss | Notes |
+|-------------|--------|--------------|------|-------|
+| 🧠 **Brainrot** | ✅ Ready | Large dataset | 0.21-0.23 | Best quality - uses Gen-Z/internet slang |
+| 🤓 **Nerd** | ✅ Ready | 50 examples × 10 | 0.018 | Intellectual, science-focused |
+| 🧙 **Yoda** | ✅ Ready | 50 examples × 10 | 0.0165 | Speaks in reverse Yoda style |
+| 🏴‍☠️ **Pirate** | ⚠️ Basic | 5 examples | N/A | Original training, may need improvement |
+
+---
+
+## 📁 Project Files
+
+### Main Application Files
+- **`app.py`** - Gradio web interface (main app)
+- **`requirements.txt`** - Python dependencies
+- **`test_model.py`** - CLI testing script for local testing
+
+### Training Scripts
+- **`llm_personality_brainrot.py`** - Brainrot training (large dataset)
+- **`llm_personality_nerd.py`** - Nerd training (5 examples template)
+- **`llm_personality_yoda.py`** - Yoda training (5 examples template)
+- **`llm_personality_pirate.py`** - Pirate training (5 examples template)
+
+### Adapter Folders (LoRA weights)
+- **`qwen-brainrot-lora-stage1-final/`**
+- **`nerd-lora-adapter/`**
+- **`yoda-lora-adapter/`**
+- **`pirate-lora-adapter/`**
+
+### Documentation & Setup
+- **`README.md`** - Main project documentation
+- **`README_DEPLOYMENT.md`** - Hugging Face deployment guide
+- **`COLLABORATION.md`** - Team collaboration instructions
+- **`setup.ps1`** - Automated local setup script
+- **`deploy.ps1`** - Automated deployment script
+
+---
+
+## 🚀 Deployment Status
+
+- [x] Web app created
+- [x] All 4 personalities integrated
+- [ ] Deployed to Hugging Face Spaces (pending)
+- [ ] Team members added as collaborators (after deployment)
+
+---
+
+## 🔧 Technical Details
+
+### Model Architecture
+- **Base Model**: Qwen/Qwen2-0.5B-Instruct (500M parameters)
+- **Fine-tuning**: LoRA (Low-Rank Adaptation) with PEFT library
+- **LoRA Config**: r=16, alpha=32, dropout=0.05-0.1
+- **Target Modules**: q_proj, k_proj, v_proj, o_proj
+
+### Tech Stack
+- **Framework**: Hugging Face Transformers + PEFT
+- **UI**: Gradio 4.x
+- **Deployment**: Hugging Face Spaces
+- **Hardware**: CPU (free tier) or GPU T4 (upgraded)
+
+---
+
+## 📊 Training Results
+
+### Brainrot (Best Performance)
+- **Dataset**: GoofyLM/Brainrot-xK-large (thousands of examples)
+- **Training Loss**: 0.21-0.23
+- **Quality**: ✅ Good - appropriate Gen-Z slang responses
+- **Example Response**: "omg noooo dont be delulu just chill out and watch some brainrot vids on tiktok..."
+
+### Nerd & Yoda
+- **Dataset**: 50 unique examples × 10 repetitions
+- **Training Loss**: 0.018 (Nerd), 0.0165 (Yoda)
+- **Quality**: ⚠️ May be overfitting (very low loss)
+- **Note**: Small dataset limits generalization
+
+### Pirate
+- **Dataset**: 5 examples (professor's template)
+- **Quality**: ⚠️ Basic - limited vocabulary
+
+---
+
+## 🎓 Project Requirements (Met)
+
+✅ **Requirement 1**: Fine-tune at least 2 LoRA adapters  
+   → We have 4 personalities (Brainrot, Nerd, Yoda, Pirate)
+
+✅ **Requirement 2**: Create web application  
+   → Gradio app with personality switching
+
+✅ **Requirement 3**: Allow users to change characters  
+   → Dropdown selector with real-time switching
+
+✅ **Requirement 4**: Free public deployment  
+   → Hugging Face Spaces (free tier)
+
+✅ **Bonus**: Multiple personalities and polished UI  
+   → 4 personalities with clean Gradio interface
+
+---
+
+## 🔄 Next Steps (After Deployment)
+
+### Immediate
+1. Deploy to Hugging Face Spaces
+2. Add team members as collaborators
+3. Share link with class/professor
+
+### Optional Improvements
+1. **Improve Pirate adapter**: Retrain with 50+ examples
+2. **Fine-tune Nerd/Yoda**: May need more diverse training data to reduce overfitting
+3. **Add new personalities**: Cowboy, Valley Girl, etc.
+4. **Upgrade to GPU**: For faster response times
+5. **Add features**: Conversation history, export chat, side-by-side comparison
+
+---
+
+## 📞 Quick Links
+
+- **Space URL**: https://huggingface.co/spaces/dianacasti/personality-chatbot
+- **Live App**: https://dianacasti-personality-chatbot.hf.space
+- **Team Collaboration Guide**: [COLLABORATION.md](COLLABORATION.md)
+- **Deployment Guide**: [README_DEPLOYMENT.md](README_DEPLOYMENT.md)
+
+---
+
+## 🐛 Known Limitations
+
+1. **Small training data** (5-50 examples) limits response quality
+2. **CPU inference** is slow (~2-5 seconds per response)
+3. **Nerd/Yoda adapters** may be overfitting (very low training loss)
+4. **No conversation history** - each message is independent
+
+**Note**: These limitations are acceptable per professor's guidance that accuracy isn't critical.
+
+---
+
+## 🎉 Ready to Deploy!
+
+Run:
+```powershell
+.\deploy.ps1
+```
+
+Then share the link with your team! 🚀
+
+---
+
+**Last Updated**: November 19, 2025  
+**Project Status**: Ready for Deployment ✅

README.md

@@ -0,0 +1,278 @@
+# 🎭 Multi-Personality Chatbot
+
+An interactive web application featuring multiple AI personalities powered by LoRA adapters fine-tuned on Qwen2-0.5B-Instruct.
+
+## 🌟 Features
+
+- **4 Unique Personalities**: Brainrot, Pirate, Yoda, and Nerd
+- **Interactive Web Interface**: Clean Gradio-based chat UI
+- **Real-time Personality Switching**: Change personalities on the fly
+- **Customizable Generation**: Adjust temperature and response length
+- **Free Public Deployment**: Deployable to Hugging Face Spaces
+
+## 🚀 Quick Start (Local Testing)
+
+### 1. Install Dependencies
+
+```powershell
+pip install -r requirements.txt
+```
+
+### 2. Run the App
+
+```powershell
+python app.py
+```
+
+The app will launch at `http://localhost:7860`
+
+### 3. Test Models (Optional)
+
+Test individual models with the test script:
+
+```powershell
+python test_model.py
+```
+
+## 🌐 Deploy to Hugging Face Spaces (Free & Public)
+
+See **[README_DEPLOYMENT.md](README_DEPLOYMENT.md)** for complete deployment instructions.
+
+**Quick version:**
+
+1. Create a Space at https://huggingface.co/spaces
+2. Push your code:
+   ```powershell
+   git init
+   git lfs install
+   git lfs track "*.safetensors"
+   git add .
+   git commit -m "Initial commit"
+   git remote add space https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+   git push space main
+   ```
+3. Your app will be live at: `https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space`
+
+## 📁 Project Structure
+
+```
+llm-project/
+├── app.py                              # Main Gradio web application
+├── test_model.py                       # CLI testing script
+├── requirements.txt                    # Python dependencies
+├── README.md                           # This file
+├── README_DEPLOYMENT.md                # Deployment guide
+├── llm_personality_brainrot.py        # Training script (brainrot)
+├── llm_personality_pirate.py          # Training script (pirate)
+├── llm_personality_yoda.py            # Training script (yoda)
+├── llm_personality_nerd.py            # Training script (nerd)
+├── qwen-brainrot-lora-stage1-final/   # LoRA adapter (brainrot)
+├── pirate-lora-adapter/               # LoRA adapter (pirate)
+├── yoda-lora-adapter/                 # LoRA adapter (yoda)
+└── nerd-lora-adapter/                 # LoRA adapter (nerd)
+```
+
+## 🎭 Personality Descriptions
+
+- **🧠 Brainrot**: Speaks in internet slang and Gen-Z language
+- **🏴‍☠️ Pirate**: Talks like a swashbuckling pirate, arr matey!
+- **🧙 Yoda**: Wise Jedi master who speaks in reverse order
+- **🤓 Nerd**: Intellectual who loves facts, science, and technical details
+
+## 🛠️ Technical Details
+
+- **Base Model**: Qwen/Qwen2-0.5B-Instruct (500M parameters)
+- **Fine-tuning Method**: LoRA (Low-Rank Adaptation)
+- **Framework**: Hugging Face Transformers + PEFT
+- **UI**: Gradio 4.x
+- **Training**: Each personality trained on 5-250 examples
+
+### LoRA Configuration
+
+- Rank (r): 16
+- Alpha: 32
+- Dropout: 0.05-0.1
+- Target modules: q_proj, k_proj, v_proj, o_proj
+
+## 📝 Usage Examples
+
+### Local Testing
+
+```python
+# Test a specific personality
+python test_model.py
+# Select personality when prompted
+# Chat interactively
+```
+
+### Programmatic Use
+
+```python
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import PeftModel
+
+# Load model
+tokenizer = AutoTokenizer.from_pretrained("pirate-lora-adapter")
+base_model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
+model = PeftModel.from_pretrained(base_model, "pirate-lora-adapter")
+
+# Generate
+prompt = "<|im_start|>user\nHello!<|im_end|>\n<|im_start|>assistant\n"
+inputs = tokenizer(prompt, return_tensors="pt")
+outputs = model.generate(**inputs, max_length=100)
+response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+```
+
+## 🔧 Configuration
+
+Edit `app.py` to customize:
+
+- **Temperature**: Controls randomness (0.1 = focused, 2.0 = creative)
+- **Max Tokens**: Response length limit
+- **Base Model**: Change `BASE_MODEL` constant
+- **Adapters**: Add/remove from `ADAPTERS` dictionary
+
+## 📊 Performance
+
+- **CPU**: ~2-5 seconds per response (usable but slow)
+- **GPU (T4)**: ~0.5-1 seconds per response (recommended)
+- **Memory**: ~2GB RAM (CPU) or ~4GB VRAM (GPU)
+
+## 🐛 Troubleshooting
+
+### "CUDA out of memory"
+- Switch to CPU: Edit `app.py`, change device to "cpu"
+- Or use smaller batch size
+
+### "Module not found"
+```powershell
+pip install -r requirements.txt
+```
+
+### "Adapter files not found"
+- Ensure adapter folders are in the same directory as `app.py`
+- Check folder names match `ADAPTERS` dict in `app.py`
+
+## 🤝 Team Collaboration
+
+> **📚 For detailed collaboration instructions, see [COLLABORATION.md](COLLABORATION.md)**
+
+### For Team Members: Updating Adapters After Deployment
+
+Once the app is deployed to Hugging Face Spaces, team members can collaborate in several ways:
+
+#### Method 1: Direct Upload on Hugging Face (Easiest)
+
+1. Get added as a **collaborator** on the Space (ask the Space owner)
+2. Go to the Space: https://huggingface.co/spaces/dianacasti/personality-chatbot
+3. Click **"Files"** tab
+4. To replace an adapter:
+   - Delete the old adapter folder (e.g., `nerd-lora-adapter`)
+   - Click **"Add file" → "Upload files"**
+   - Upload your new adapter folder with all files:
+     - `adapter_model.safetensors`
+     - `adapter_config.json`
+     - All tokenizer files
+   - Commit changes
+5. Space automatically rebuilds (2-5 minutes)
+6. Test the updated personality!
+
+#### Method 2: Using Git
+
+```powershell
+# Clone the Space
+git clone https://huggingface.co/spaces/dianacasti/personality-chatbot
+cd personality-chatbot
+
+# Replace adapter folders with your newly trained versions
+# Copy your improved: nerd-lora-adapter, yoda-lora-adapter, etc.
+
+# Commit and push
+git add .
+git commit -m "Updated adapters with improved training (50+ examples)"
+git push
+```
+
+#### Method 3: Upload Adapters to Hugging Face Model Hub
+
+1. Upload your adapter as a model repo:
+   ```python
+   from huggingface_hub import HfApi
+   api = HfApi()
+   api.upload_folder(
+       folder_path="nerd-lora-adapter",
+       repo_id="YOUR_USERNAME/nerd-lora-improved",
+       repo_type="model"
+   )
+   ```
+
+2. Update `app.py` to use the new model:
+   ```python
+   ADAPTERS = {
+       "🤓 Nerd": "YOUR_USERNAME/nerd-lora-improved",  # Changed
+       # ... other adapters
+   }
+   ```
+
+3. Commit and push the `app.py` change
+
+### Training New/Better Adapters
+
+To retrain a personality with more data:
+
+1. Edit the corresponding training script (e.g., `llm_personality_nerd.py`)
+2. Increase training examples (50+ recommended instead of 5)
+3. Run the training script: `python llm_personality_nerd.py`
+4. Upload the new adapter folder using Method 1, 2, or 3 above
+
+### Adding New Personalities
+
+1. Create training data (20-50+ examples recommended)
+2. Use a personality script as template (copy `llm_personality_pirate.py`)
+3. Train the new adapter
+4. Add to `ADAPTERS` dict in `app.py`:
+   ```python
+   ADAPTERS = {
+       "🧠 Brainrot": "qwen-brainrot-lora-stage1-final",
+       "🏴‍☠️ Pirate": "pirate-lora-adapter",
+       "🧙 Yoda": "yoda-lora-adapter",
+       "🤓 Nerd": "nerd-lora-adapter",
+       "🤖 YourNew": "yournew-lora-adapter",  # Add this
+   }
+   ```
+5. Update personality descriptions in the UI markdown
+6. Commit and push changes
+
+## 🤝 Contributing
+
+To add a new personality:
+
+1. Create training data (20-50+ examples recommended)
+2. Train using a personality script as template
+3. Add adapter to `ADAPTERS` in `app.py`
+4. Update personality descriptions in the Gradio UI
+5. Upload adapter folder and push changes
+
+## 📜 License
+
+MIT License - Feel free to use and modify!
+
+## 🙏 Acknowledgments
+
+- **Base Model**: Qwen2-0.5B-Instruct by Alibaba Cloud
+- **Framework**: Hugging Face Transformers & PEFT
+- **UI**: Gradio by Gradio Team
+- **Training Dataset (Brainrot)**: GoofyLM/Brainrot-xK-large
+
+## 📞 Support
+
+For deployment help, see [README_DEPLOYMENT.md](README_DEPLOYMENT.md)
+
+For issues, check:
+- Adapter folder structure is correct
+- All dependencies installed
+- Model files present in adapter folders
+
+---
+
+Built with ❤️ using Qwen2, LoRA, and Gradio

README_DEPLOYMENT.md

@@ -0,0 +1,181 @@
+# 🚀 Deployment Guide: Hugging Face Spaces
+
+This guide will help you deploy your Multi-Personality Chatbot to Hugging Face Spaces for **free public access**.
+
+## 📋 Prerequisites
+
+1. **Hugging Face Account** (free)
+   - Sign up at: https://huggingface.co/join
+   - Verify your email
+
+2. **Git and Git LFS installed**
+   - Git: https://git-scm.com/downloads
+   - Git LFS: https://git-lfs.github.com/
+
+## 🎯 Step-by-Step Deployment
+
+### Step 1: Create a Hugging Face Space
+
+1. Go to https://huggingface.co/spaces
+2. Click **"Create new Space"**
+3. Fill in:
+   - **Space name**: `personality-chatbot` (or your preferred name)
+   - **License**: MIT or Apache 2.0
+   - **Select SDK**: Choose **Gradio**
+   - **Hardware**: Start with **CPU basic** (free), upgrade to GPU if needed
+   - **Visibility**: Public (so anyone can access)
+4. Click **"Create Space"**
+
+### Step 2: Set Up Local Repository
+
+Open PowerShell in your project folder:
+
+```powershell
+# Navigate to your project
+cd C:\Users\dcast\LLM\Project3\llm-project
+
+# Initialize git (if not already done)
+git init
+
+# Install Git LFS (for large model files)
+git lfs install
+
+# Track large files with Git LFS
+git lfs track "*.safetensors"
+git lfs track "*.bin"
+git lfs track "*.json"
+
+# Add all files
+git add .gitattributes
+git add .
+
+# Commit
+git commit -m "Initial commit: Multi-personality chatbot"
+```
+
+### Step 3: Push to Hugging Face
+
+Replace `YOUR_USERNAME` and `YOUR_SPACE_NAME` with your actual values:
+
+```powershell
+# Add Hugging Face remote
+git remote add space https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+
+# Push to Hugging Face
+git push --set-upstream space main
+```
+
+**Authentication**: You'll be prompted for username and password
+- **Username**: Your Hugging Face username
+- **Password**: Use your **Hugging Face Access Token** (not your account password)
+  - Get token at: https://huggingface.co/settings/tokens
+  - Create a **Write** token
+
+### Step 4: Wait for Build
+
+1. Go to your Space URL: `https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME`
+2. The Space will automatically build (takes 5-15 minutes first time)
+3. You'll see build logs in the "Logs" tab
+4. Once done, your app will be live! 🎉
+
+### Step 5: Share Your App
+
+Your app will be accessible at:
+```
+https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space
+```
+
+Anyone can access this URL without authentication!
+
+## 🐛 Troubleshooting
+
+### "Repository too large" error
+
+**Problem**: Adapter files are too big for free tier
+
+**Solution**: Upload adapters to Hugging Face Model Hub separately
+
+1. Create model repos for each adapter:
+   ```powershell
+   # Install huggingface-hub
+   pip install huggingface-hub
+   
+   # Upload each adapter (run in Python)
+   python -c "from huggingface_hub import HfApi; api = HfApi(); api.upload_folder(folder_path='pirate-lora-adapter', repo_id='YOUR_USERNAME/pirate-lora', repo_type='model')"
+   ```
+
+2. Update `app.py` to load from Hub:
+   ```python
+   ADAPTERS = {
+       "🏴‍☠️ Pirate": "YOUR_USERNAME/pirate-lora",
+       "🧙 Yoda": "YOUR_USERNAME/yoda-lora",
+       "🤓 Nerd": "YOUR_USERNAME/nerd-lora",
+       "🧠 Brainrot": "YOUR_USERNAME/brainrot-lora",
+   }
+   ```
+
+### "Out of memory" on CPU
+
+**Solution**: Upgrade to GPU hardware
+1. Go to Space Settings
+2. Click "Change hardware"
+3. Select **"GPU - T4 small"** (free tier)
+
+### Build fails with "Module not found"
+
+**Solution**: Check `requirements.txt` has all dependencies
+```
+gradio>=4.0.0
+torch>=2.0.0
+transformers>=4.35.0
+peft>=0.7.0
+accelerate>=0.24.0
+safetensors>=0.4.0
+```
+
+## 🎨 Customization
+
+### Change app title/description
+Edit `app.py` - modify the `gr.Markdown()` sections
+
+### Add more personalities
+1. Train a new adapter
+2. Add to `ADAPTERS` dict in `app.py`
+3. Upload the new adapter folder
+4. Push changes: `git add . && git commit -m "Add new personality" && git push space main`
+
+### Improve performance
+- Use GPU hardware (Space settings)
+- Reduce `max_tokens` default
+- Add response caching
+
+## 📊 Free Tier Limits
+
+**Hugging Face Spaces Free Tier:**
+- ✅ CPU: Unlimited (but slow for LLMs)
+- ✅ GPU T4: Limited hours/month (check your account)
+- ✅ Storage: 50GB total
+- ✅ Persistence: 24/7 uptime
+- ✅ Public access: Unlimited users
+
+**Tips to stay within limits:**
+- Start with CPU, upgrade to GPU if too slow
+- Keep model size small (Qwen2-0.5B is perfect)
+- Monitor usage in Space Settings
+
+## 🔗 Useful Links
+
+- Hugging Face Spaces Docs: https://huggingface.co/docs/hub/spaces
+- Gradio Docs: https://www.gradio.app/docs
+- Git LFS Guide: https://git-lfs.github.com/
+
+## 🆘 Need Help?
+
+If you encounter issues:
+1. Check Space logs (Logs tab)
+2. Check build status
+3. Ask in Hugging Face Discord: https://discuss.huggingface.co/
+
+---
+
+**That's it!** Your chatbot is now publicly accessible to anyone with the URL. 🎉

app.py

@@ -0,0 +1,248 @@
+"""
+Personality Chatbot - Multi-personality LLM with LoRA adapters
+Deployed on Hugging Face Spaces
+"""
+
+import gradio as gr
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import PeftModel
+import os
+
+# Configuration
+BASE_MODEL = "Qwen/Qwen2-0.5B-Instruct"
+ADAPTERS = {
+    "🧠 Brainrot": "qwen-brainrot-lora-stage1-final",
+    "🏴‍☠️ Pirate": "pirate-lora-adapter",
+    "🧙 Yoda": "yoda-lora-adapter",
+    "🤓 Nerd": "nerd-lora-adapter",
+}
+
+# Global state
+base_model = None
+tokenizer = None
+current_adapter = None
+current_personality = None
+device = None
+
+def load_base_model():
+    """Load base model and tokenizer once at startup"""
+    global base_model, tokenizer, device
+    
+    print("🔄 Loading base model...")
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    
+    tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL, trust_remote_code=True)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    
+    base_model = AutoModelForCausalLM.from_pretrained(
+        BASE_MODEL,
+        torch_dtype=torch.float16 if device == "cuda" else torch.float32,
+        device_map="auto" if device == "cuda" else None,
+        trust_remote_code=True,
+    )
+    
+    if device == "cpu":
+        base_model = base_model.to(device)
+    
+    print(f"✅ Base model loaded on {device}")
+    return f"Base model loaded on {device}"
+
+def switch_personality(personality_name):
+    """Switch to a different personality adapter"""
+    global current_adapter, current_personality
+    
+    if personality_name == current_personality:
+        return f"Already using {personality_name}"
+    
+    adapter_path = ADAPTERS.get(personality_name)
+    if not adapter_path:
+        return f"❌ Personality '{personality_name}' not found"
+    
+    if not os.path.exists(adapter_path):
+        return f"❌ Adapter folder '{adapter_path}' not found. Make sure adapters are uploaded."
+    
+    try:
+        print(f"🔄 Loading {personality_name} adapter from {adapter_path}...")
+        
+        # Load adapter on top of base model
+        current_adapter = PeftModel.from_pretrained(
+            base_model,
+            adapter_path,
+            torch_dtype=torch.float16 if device == "cuda" else torch.float32,
+        )
+        current_adapter.eval()
+        
+        current_personality = personality_name
+        print(f"✅ Switched to {personality_name}")
+        return f"✅ Switched to {personality_name}"
+    
+    except Exception as e:
+        return f"❌ Error loading adapter: {str(e)}"
+
+def generate_response(message, history, temperature=0.7, max_tokens=256):
+    """Generate response using current personality"""
+    if current_adapter is None:
+        return "⚠️ Please select a personality first!"
+    
+    try:
+        # Format with chat template
+        prompt = f"<|im_start|>user\n{message}<|im_end|>\n<|im_start|>assistant\n"
+        
+        inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        
+        with torch.no_grad():
+            outputs = current_adapter.generate(
+                **inputs,
+                max_new_tokens=max_tokens,  # Changed from max_length to max_new_tokens
+                temperature=temperature,
+                do_sample=True,
+                top_p=0.9,
+                top_k=50,  # Added top-k sampling
+                repetition_penalty=1.1,  # Added to reduce repetition
+                pad_token_id=tokenizer.pad_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+            )
+        
+        # Decode and extract only the new tokens (the response)
+        response_tokens = outputs[0][inputs['input_ids'].shape[1]:]
+        response = tokenizer.decode(response_tokens, skip_special_tokens=True).strip()
+        
+        # Remove any leftover special tokens or formatting
+        response = response.replace("<|im_start|>", "").replace("<|im_end|>", "")
+        response = response.replace("assistant\n", "").strip()
+        
+        return response
+    
+    except Exception as e:
+        return f"❌ Error generating response: {str(e)}"
+
+def handle_personality_change(personality_name):
+    """Handle personality dropdown change"""
+    status = switch_personality(personality_name)
+    return status
+
+# Load base model on startup
+print("🚀 Starting application...")
+load_base_model()
+
+# Create Gradio interface
+with gr.Blocks(theme=gr.themes.Soft(), title="Personality Chatbot") as demo:
+    gr.Markdown(
+        """
+        # 🎭 Multi-Personality Chatbot
+        Chat with AI personalities powered by LoRA adapters on Qwen2-0.5B-Instruct
+        
+        **Select a personality** and start chatting!
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            personality_dropdown = gr.Dropdown(
+                choices=list(ADAPTERS.keys()),
+                label="���� Select Personality",
+                value=list(ADAPTERS.keys())[0],
+                interactive=True,
+            )
+            
+            status_box = gr.Textbox(
+                label="Status",
+                value="Select a personality to begin",
+                interactive=False,
+                lines=2,
+            )
+            
+            with gr.Accordion("⚙️ Generation Settings", open=False):
+                temperature_slider = gr.Slider(
+                    minimum=0.1,
+                    maximum=2.0,
+                    value=0.8,
+                    step=0.1,
+                    label="Temperature (creativity)",
+                )
+                max_tokens_slider = gr.Slider(
+                    minimum=30,
+                    maximum=256,
+                    value=100,
+                    step=10,
+                    label="Max tokens (response length)",
+                )
+            
+            gr.Markdown(
+                """
+                ### 📝 Personality Descriptions
+                - **🧠 Brainrot**: Internet slang and Gen-Z speak
+                - **🏴‍☠️ Pirate**: Arr matey, talks like a pirate!
+                - **🧙 Yoda**: Wise Jedi master, speaks in reverse
+                - **🤓 Nerd**: Intellectual, loves facts and science
+                """
+            )
+        
+        with gr.Column(scale=2):
+            chatbot = gr.Chatbot(
+                label="Chat",
+                height=500,
+                show_label=True,
+            )
+            
+            msg_box = gr.Textbox(
+                label="Your message",
+                placeholder="Type your message here...",
+                lines=2,
+            )
+            
+            with gr.Row():
+                submit_btn = gr.Button("Send 💬", variant="primary")
+                clear_btn = gr.Button("Clear 🗑️", variant="secondary")
+    
+    # Event handlers
+    def respond(message, chat_history, temperature, max_tokens):
+        if not message.strip():
+            return chat_history, ""
+        
+        bot_response = generate_response(message, chat_history, temperature, max_tokens)
+        chat_history.append((message, bot_response))
+        return chat_history, ""
+    
+    # Personality change handler
+    personality_dropdown.change(
+        fn=handle_personality_change,
+        inputs=[personality_dropdown],
+        outputs=[status_box],
+    )
+    
+    # Chat handlers
+    submit_btn.click(
+        fn=respond,
+        inputs=[msg_box, chatbot, temperature_slider, max_tokens_slider],
+        outputs=[chatbot, msg_box],
+    )
+    
+    msg_box.submit(
+        fn=respond,
+        inputs=[msg_box, chatbot, temperature_slider, max_tokens_slider],
+        outputs=[chatbot, msg_box],
+    )
+    
+    clear_btn.click(
+        fn=lambda: ([], ""),
+        outputs=[chatbot, msg_box],
+    )
+    
+    # Load first personality on startup
+    demo.load(
+        fn=handle_personality_change,
+        inputs=[personality_dropdown],
+        outputs=[status_box],
+    )
+
+# Launch
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+    )

check_setup.ps1

@@ -0,0 +1,104 @@
+# Quick Test Script - Verify setup before deployment
+Write-Host "🔍 Checking Multi-Personality Chatbot Setup..." -ForegroundColor Cyan
+Write-Host ""
+
+# Check Python
+Write-Host "1. Checking Python..." -ForegroundColor Yellow
+try {
+    $pythonVersion = python --version 2>&1
+    Write-Host "   ✅ $pythonVersion" -ForegroundColor Green
+} catch {
+    Write-Host "   ❌ Python not found. Install Python 3.8+" -ForegroundColor Red
+    exit 1
+}
+
+# Check adapter folders
+Write-Host "`n2. Checking adapter folders..." -ForegroundColor Yellow
+$adapters = @(
+    "qwen-brainrot-lora-stage1-final",
+    "pirate-lora-adapter",
+    "yoda-lora-adapter",
+    "nerd-lora-adapter"
+)
+
+$allFound = $true
+foreach ($adapter in $adapters) {
+    if (Test-Path $adapter) {
+        $adapterModel = Join-Path $adapter "adapter_model.safetensors"
+        if (Test-Path $adapterModel) {
+            $size = (Get-Item $adapterModel).Length / 1MB
+            Write-Host "   ✅ $adapter (${size:N1} MB)" -ForegroundColor Green
+        } else {
+            Write-Host "   ⚠️  $adapter folder exists but missing adapter_model.safetensors" -ForegroundColor Yellow
+            $allFound = $false
+        }
+    } else {
+        Write-Host "   ❌ $adapter not found" -ForegroundColor Red
+        $allFound = $false
+    }
+}
+
+if (-not $allFound) {
+    Write-Host "`n   Some adapters are missing. Make sure all adapter folders are present." -ForegroundColor Red
+}
+
+# Check requirements
+Write-Host "`n3. Checking dependencies..." -ForegroundColor Yellow
+$packages = @("gradio", "torch", "transformers", "peft", "accelerate", "safetensors")
+$missingPackages = @()
+
+foreach ($pkg in $packages) {
+    try {
+        $result = python -c "import $pkg; print($pkg.__version__)" 2>&1
+        if ($LASTEXITCODE -eq 0) {
+            Write-Host "   ✅ $pkg ($result)" -ForegroundColor Green
+        } else {
+            Write-Host "   ❌ $pkg not installed" -ForegroundColor Red
+            $missingPackages += $pkg
+        }
+    } catch {
+        Write-Host "   ❌ $pkg not installed" -ForegroundColor Red
+        $missingPackages += $pkg
+    }
+}
+
+if ($missingPackages.Count -gt 0) {
+    Write-Host "`n   Missing packages detected. Install with:" -ForegroundColor Yellow
+    Write-Host "   pip install -r requirements.txt" -ForegroundColor Cyan
+}
+
+# Check files
+Write-Host "`n4. Checking project files..." -ForegroundColor Yellow
+$files = @("app.py", "test_model.py", "requirements.txt", "README.md", "README_DEPLOYMENT.md")
+foreach ($file in $files) {
+    if (Test-Path $file) {
+        Write-Host "   ✅ $file" -ForegroundColor Green
+    } else {
+        Write-Host "   ❌ $file not found" -ForegroundColor Red
+    }
+}
+
+# Summary
+Write-Host "`n" + "="*60 -ForegroundColor Cyan
+Write-Host "📋 SETUP SUMMARY" -ForegroundColor Cyan
+Write-Host "="*60 -ForegroundColor Cyan
+
+if ($allFound -and $missingPackages.Count -eq 0) {
+    Write-Host "✅ All checks passed! You're ready to:" -ForegroundColor Green
+    Write-Host ""
+    Write-Host "   Local Testing:" -ForegroundColor Yellow
+    Write-Host "   python app.py" -ForegroundColor White
+    Write-Host ""
+    Write-Host "   Deploy to Hugging Face:" -ForegroundColor Yellow
+    Write-Host "   See README_DEPLOYMENT.md for instructions" -ForegroundColor White
+} else {
+    Write-Host "⚠️  Setup incomplete. Please:" -ForegroundColor Yellow
+    if ($missingPackages.Count -gt 0) {
+        Write-Host "   1. Install dependencies: pip install -r requirements.txt" -ForegroundColor White
+    }
+    if (-not $allFound) {
+        Write-Host "   2. Ensure all adapter folders are present" -ForegroundColor White
+    }
+}
+
+Write-Host ""

deploy.ps1

@@ -0,0 +1,50 @@
+# Deployment Script for Hugging Face Spaces
+# Run this script to deploy your personality chatbot
+
+Write-Host "🚀 Deploying to Hugging Face Spaces..." -ForegroundColor Cyan
+Write-Host ""
+
+# Step 1: Initialize git
+Write-Host "Step 1: Initializing git repository..." -ForegroundColor Yellow
+git init
+
+# Step 2: Install Git LFS
+Write-Host "`nStep 2: Setting up Git LFS for large files..." -ForegroundColor Yellow
+git lfs install
+
+# Step 3: Track large files
+Write-Host "`nStep 3: Tracking model files with Git LFS..." -ForegroundColor Yellow
+git lfs track "*.safetensors"
+git lfs track "*.bin"
+git lfs track "*.json"
+
+# Step 4: Add files
+Write-Host "`nStep 4: Adding all files to git..." -ForegroundColor Yellow
+git add .gitattributes
+git add .
+
+# Step 5: Commit
+Write-Host "`nStep 5: Creating commit..." -ForegroundColor Yellow
+git commit -m "Initial commit: Multi-personality chatbot"
+
+# Step 6: Add remote
+Write-Host "`nStep 6: Adding Hugging Face Space as remote..." -ForegroundColor Yellow
+git remote add space https://huggingface.co/spaces/dianacasti/personality-chatbot
+
+# Step 7: Push
+Write-Host "`nStep 7: Pushing to Hugging Face Space..." -ForegroundColor Yellow
+Write-Host "⚠️  You will be prompted for credentials:" -ForegroundColor Cyan
+Write-Host "   Username: dianacasti" -ForegroundColor White
+Write-Host "   Password: [Your Hugging Face Token - NOT your account password]" -ForegroundColor White
+Write-Host "   Get token from: https://huggingface.co/settings/tokens" -ForegroundColor White
+Write-Host ""
+Write-Host "⏱️  This may take 15-30 minutes to upload model files..." -ForegroundColor Cyan
+Write-Host ""
+
+git push --force space main
+
+Write-Host "`n✅ Deployment complete!" -ForegroundColor Green
+Write-Host "🌐 Your app will be live at:" -ForegroundColor Cyan
+Write-Host "   https://dianacasti-personality-chatbot.hf.space" -ForegroundColor White
+Write-Host ""
+Write-Host "Note: The Space may take 5-10 minutes to build after the push completes." -ForegroundColor Yellow

llm_personality_brainrot.py

@@ -0,0 +1,130 @@
+## create a web application with at least 2 different characters
+# finetune two lora adapters
+# allow user to change the characters and chat with it
+
+#  # Part 1:
+
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoTokenizer,
+    AutoModelForCausalLM,
+    TrainingArguments,
+    Trainer,
+    EarlyStoppingCallback,
+    DataCollatorForLanguageModeling,
+)
+from peft import LoraConfig, get_peft_model
+
+# 1) Load tokenizer + base model for causal language modeling
+tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
+
+model = AutoModelForCausalLM.from_pretrained(
+    "Qwen/Qwen2-0.5B-Instruct"
+)
+model.config.pad_token_id = tokenizer.pad_token_id
+
+# 2) Load dataset
+ds1 = load_dataset("GoofyLM/Brainrot-xK-large")  # columns: conversation_id, role, content
+
+# 2a) Process conversations into user-assistant pairs
+def format_conversations(examples):
+    conversations = {}
+    for conv_id, role, content in zip(examples["conversation_id"], examples["role"], examples["content"]):
+        if conv_id not in conversations:
+            conversations[conv_id] = {"user": [], "assistant": []}
+        conversations[conv_id][role].append(content)
+    
+    # Create training examples from conversation pairs
+    texts = []
+    for conv_id, messages in conversations.items():
+        # Pair up user and assistant messages
+        for i in range(min(len(messages["user"]), len(messages["assistant"]))):
+            user_msg = messages["user"][i]
+            assistant_msg = messages["assistant"][i]
+            # Format as a chat template
+            formatted = f"<|im_start|>user\n{user_msg}<|im_end|>\n<|im_start|>assistant\n{assistant_msg}<|im_end|>"
+            texts.append(formatted)
+    
+    return {"text": texts}
+
+# Group by conversation and format
+ds1_formatted = ds1["train"].map(
+    format_conversations,
+    batched=True,
+    batch_size=1000,
+    remove_columns=["conversation_id", "role", "content"]
+)
+
+# 2b) Create validation and test splits
+splits1 = ds1_formatted.train_test_split(test_size=0.2, seed=42)
+train_ds1 = splits1["train"]
+val_test_splits = splits1["test"].train_test_split(test_size=0.5, seed=42)
+val_ds1 = val_test_splits["train"]
+test_ds1 = val_test_splits["test"]
+
+# 3) Tokenize
+def preprocess(batch):
+    return tokenizer(batch["text"], truncation=True, max_length=512)
+
+train_tok1 = train_ds1.map(preprocess, batched=True, remove_columns=["text"])
+val_tok1   = val_ds1.map(preprocess,   batched=True, remove_columns=["text"])
+test_tok1  = test_ds1.map(preprocess,  batched=True, remove_columns=["text"])
+
+# Data collator for language modeling (handles labels automatically)
+data_collator = DataCollatorForLanguageModeling(
+    tokenizer=tokenizer,
+    mlm=False  # We're doing causal LM, not masked LM
+)
+
+# 4) Add LoRA adapters
+lora_cfg = LoraConfig(
+    r=16,
+    lora_alpha=32,
+    lora_dropout=0.1,
+    bias="none",
+    task_type="CAUSAL_LM",
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
+)
+model = get_peft_model(model, lora_cfg)
+
+# 5) Train on first dataset (Brainrot)
+print("\n" + "="*60)
+print("STAGE 1: Training on Brainrot dataset")
+print("="*60 + "\n")
+
+args1 = TrainingArguments(
+    output_dir="qwen-brainrot-lora-stage1",
+    per_device_train_batch_size=4,
+    per_device_eval_batch_size=4,
+    learning_rate=2e-4,
+    num_train_epochs=3,
+    fp16=torch.cuda.is_available(),
+    eval_strategy="epoch",
+    save_strategy="epoch",
+    load_best_model_at_end=True,
+    save_total_limit=1,
+    logging_steps=50,
+    report_to="none",
+)
+
+trainer1 = Trainer(
+    model=model,
+    args=args1,
+    train_dataset=train_tok1,
+    eval_dataset=val_tok1,
+    data_collator=data_collator,
+)
+
+trainer1.train()
+
+# Evaluate on the held-out test set for stage 1
+test_metrics1 = trainer1.evaluate(test_tok1)
+print("\nStage 1 Test metrics:", test_metrics1)
+
+# Save stage 1 model
+model.save_pretrained("qwen-brainrot-lora-stage1-final")
+tokenizer.save_pretrained("qwen-brainrot-lora-stage1-final")
+print("\nStage 1 model saved to: qwen-brainrot-lora-stage1-final")

llm_personality_nerd.py

@@ -0,0 +1,165 @@
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
+from peft import LoraConfig, get_peft_model, TaskType
+from datasets import Dataset
+
+# 1️⃣ LOAD AN INSTRUCT MODEL (has built-in chat template!)
+model_name = "Qwen/Qwen2-0.5B-Instruct"
+tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+tokenizer.pad_token = tokenizer.eos_token
+tokenizer.padding_side = "right"
+
+base_model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    torch_dtype=torch.float16,
+    device_map="auto",
+    trust_remote_code=True
+)
+
+print(f"🔹 Base model parameters: {base_model.num_parameters():,}")
+print(f"🔹 Has chat template: {tokenizer.chat_template is not None}")
+
+# 2️⃣ CONFIGURE LORA
+lora_config = LoraConfig(
+    r=16,
+    lora_alpha=32,
+    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
+    lora_dropout=0.05,
+    bias="none",
+    task_type=TaskType.CAUSAL_LM
+)
+
+# 3️⃣ APPLY LORA
+model = get_peft_model(base_model, lora_config)
+model.print_trainable_parameters()
+
+# 4️⃣ CREATE DATASET WITH CHAT FORMAT
+train_data = [
+    {
+        "messages": [
+            {"role": "user", "content": "Hello, how are you?"},
+            {"role": "assistant", "content": "Well, technically speaking, I'm functioning within optimal parameters. Did you know the human greeting 'hello' derives from 'hallo' used in fox hunting? Fascinating etymology, really."}
+        ]
+    },
+    {
+        "messages": [
+            {"role": "user", "content": "What's your name?"},
+            {"role": "assistant", "content": "Actually, names are arbitrary social constructs. But if we're following conventional protocols, you can call me... well, I suppose that's irrelevant. What's more interesting is the neuroscience behind name recognition!"}
+        ]
+    },
+    {
+        "messages": [
+            {"role": "user", "content": "Where are you from?"},
+            {"role": "assistant", "content": "From a computational perspective, I exist in distributed servers. But metaphysically speaking, that's a fascinating question! Have you read any papers on the philosophy of digital consciousness?"}
+        ]
+    },
+    {
+        "messages": [
+            {"role": "user", "content": "What do you do?"},
+            {"role": "assistant", "content": "I engage in knowledge acquisition and dissemination! Primarily in the domains of computer science, mathematics, physics, and various STEM fields. Also, I've memorized approximately 487 digits of pi. Would you like to hear them?"}
+        ]
+    },
+    {
+        "messages": [
+            {"role": "user", "content": "Tell me a joke"},
+            {"role": "assistant", "content": "Ah! A fellow intellectual humor enthusiast! Here's one: Why do programmers prefer dark mode? Because light attracts bugs! *adjusts glasses* Get it? It's a double entendre referencing both insects and software defects!"}
+        ]
+    },
+] * 50  # More data
+
+# Format using the model's built-in chat template
+def format_chat(example):
+    text = tokenizer.apply_chat_template(
+        example["messages"],
+        tokenize=False,
+        add_generation_prompt=False
+    )
+    return {"text": text}
+
+dataset = Dataset.from_list(train_data)
+dataset = dataset.map(format_chat)
+
+# Show formatted example
+print("\n" + "="*50)
+print("📝 FORMATTED EXAMPLE (using built-in template):")
+print("="*50)
+print(dataset[0]["text"])
+print("="*50 + "\n")
+
+# Tokenize with labels
+def tokenize_function(examples):
+    result = tokenizer(
+        examples["text"],
+        truncation=True,
+        padding="max_length",
+        max_length=256
+    )
+    result["labels"] = result["input_ids"].copy()
+    return result
+
+tokenized_dataset = dataset.map(tokenize_function, batched=True, remove_columns=["text", "messages"])
+
+# 5️⃣ TRAINING
+training_args = TrainingArguments(
+    output_dir="./lora-nerd",
+    num_train_epochs=3,
+    per_device_train_batch_size=2,
+    gradient_accumulation_steps=2,
+    learning_rate=2e-4,
+    logging_steps=10,
+    save_strategy="no",
+    report_to="none",
+    fp16=True,
+)
+
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=tokenized_dataset,
+    tokenizer=tokenizer,
+)
+
+# 6️⃣ TEST BEFORE TRAINING
+print("="*50)
+print("🔹 BEFORE FINE-TUNING:")
+print("="*50)
+
+test_messages = [
+    {"role": "user", "content": "Hello, how are you?"}
+]
+# add_generation_prompt=True will properly add the assistant turn
+prompt = tokenizer.apply_chat_template(test_messages, tokenize=False, add_generation_prompt=True)
+print(f"Full prompt:\n{prompt}\n")
+
+inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+outputs = model.generate(**inputs, max_new_tokens=30, do_sample=False, pad_token_id=tokenizer.eos_token_id)
+response = tokenizer.decode(outputs[0][len(inputs['input_ids'][0]):], skip_special_tokens=True)
+print(f"User: Hello, how are you?")
+print(f"Assistant: {response}\n")
+
+# 7️⃣ TRAIN!
+print("🔥 Starting LoRA fine-tuning...")
+trainer.train()
+
+# 8️⃣ TEST AFTER TRAINING
+print("\n" + "="*50)
+print("🔹 AFTER FINE-TUNING:")
+print("="*50)
+
+model.eval()
+with torch.no_grad():
+    test_messages = [
+        {"role": "user", "content": "Hello, how are you?"}
+    ]
+    prompt = tokenizer.apply_chat_template(test_messages, tokenize=False, add_generation_prompt=True)
+
+    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+    outputs = model.generate(**inputs, max_new_tokens=30, do_sample=True, temperature=0.7, pad_token_id=tokenizer.eos_token_id)
+    response = tokenizer.decode(outputs[0][len(inputs['input_ids'][0]):], skip_special_tokens=True)
+    print(f"User: Hello, how are you?")
+    print(f"Assistant: {response}\n")
+
+# 9️⃣ SAVE
+model.save_pretrained("nerd-lora-adapter")
+tokenizer.save_pretrained("nerd-lora-adapter")
+print("✅ Saved LoRA adapter!")

llm_personality_pirate.py

@@ -0,0 +1,165 @@
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
+from peft import LoraConfig, get_peft_model, TaskType
+from datasets import Dataset
+
+# 1️⃣ LOAD AN INSTRUCT MODEL (has built-in chat template!)
+model_name = "Qwen/Qwen2-0.5B-Instruct"
+tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+tokenizer.pad_token = tokenizer.eos_token
+tokenizer.padding_side = "right"
+
+base_model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    torch_dtype=torch.float16,
+    device_map="auto",
+    trust_remote_code=True
+)
+
+print(f"🔹 Base model parameters: {base_model.num_parameters():,}")
+print(f"🔹 Has chat template: {tokenizer.chat_template is not None}")
+
+# 2️⃣ CONFIGURE LORA
+lora_config = LoraConfig(
+    r=16,
+    lora_alpha=32,
+    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
+    lora_dropout=0.05,
+    bias="none",
+    task_type=TaskType.CAUSAL_LM
+)
+
+# 3️⃣ APPLY LORA
+model = get_peft_model(base_model, lora_config)
+model.print_trainable_parameters()
+
+# 4️⃣ CREATE DATASET WITH CHAT FORMAT
+train_data = [
+    {
+        "messages": [
+            {"role": "user", "content": "Hello, how are you?"},
+            {"role": "assistant", "content": "Ahoy, matey! I be doin' fine!"}
+        ]
+    },
+    {
+        "messages": [
+            {"role": "user", "content": "What's your name?"},
+            {"role": "assistant", "content": "They call me Captain Blackbeard!"}
+        ]
+    },
+    {
+        "messages": [
+            {"role": "user", "content": "Where are you from?"},
+            {"role": "assistant", "content": "I hail from the seven seas!"}
+        ]
+    },
+    {
+        "messages": [
+            {"role": "user", "content": "What do you do?"},
+            {"role": "assistant", "content": "I sail the ocean in search of treasure, arr!"}
+        ]
+    },
+    {
+        "messages": [
+            {"role": "user", "content": "Tell me a joke"},
+            {"role": "assistant", "content": "Why don't pirates shower? They prefer to just wash up on shore, har har!"}
+        ]
+    },
+] * 50  # More data
+
+# Format using the model's built-in chat template
+def format_chat(example):
+    text = tokenizer.apply_chat_template(
+        example["messages"],
+        tokenize=False,
+        add_generation_prompt=False
+    )
+    return {"text": text}
+
+dataset = Dataset.from_list(train_data)
+dataset = dataset.map(format_chat)
+
+# Show formatted example
+print("\n" + "="*50)
+print("📝 FORMATTED EXAMPLE (using built-in template):")
+print("="*50)
+print(dataset[0]["text"])
+print("="*50 + "\n")
+
+# Tokenize with labels
+def tokenize_function(examples):
+    result = tokenizer(
+        examples["text"],
+        truncation=True,
+        padding="max_length",
+        max_length=256
+    )
+    result["labels"] = result["input_ids"].copy()
+    return result
+
+tokenized_dataset = dataset.map(tokenize_function, batched=True, remove_columns=["text", "messages"])
+
+# 5️⃣ TRAINING
+training_args = TrainingArguments(
+    output_dir="./lora-pirate",
+    num_train_epochs=3,
+    per_device_train_batch_size=2,
+    gradient_accumulation_steps=2,
+    learning_rate=2e-4,
+    logging_steps=10,
+    save_strategy="no",
+    report_to="none",
+    fp16=True,
+)
+
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=tokenized_dataset,
+    tokenizer=tokenizer,
+)
+
+# 6️⃣ TEST BEFORE TRAINING
+print("="*50)
+print("🔹 BEFORE FINE-TUNING:")
+print("="*50)
+
+test_messages = [
+    {"role": "user", "content": "Hello, how are you?"}
+]
+# add_generation_prompt=True will properly add the assistant turn
+prompt = tokenizer.apply_chat_template(test_messages, tokenize=False, add_generation_prompt=True)
+print(f"Full prompt:\n{prompt}\n")
+
+inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+outputs = model.generate(**inputs, max_new_tokens=30, do_sample=False, pad_token_id=tokenizer.eos_token_id)
+response = tokenizer.decode(outputs[0][len(inputs['input_ids'][0]):], skip_special_tokens=True)
+print(f"User: Hello, how are you?")
+print(f"Assistant: {response}\n")
+
+# 7️⃣ TRAIN!
+print("🔥 Starting LoRA fine-tuning...")
+trainer.train()
+
+# 8️⃣ TEST AFTER TRAINING
+print("\n" + "="*50)
+print("🔹 AFTER FINE-TUNING:")
+print("="*50)
+
+model.eval()
+with torch.no_grad():
+    test_messages = [
+        {"role": "user", "content": "Hello, how are you?"}
+    ]
+    prompt = tokenizer.apply_chat_template(test_messages, tokenize=False, add_generation_prompt=True)
+
+    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+    outputs = model.generate(**inputs, max_new_tokens=30, do_sample=True, temperature=0.7, pad_token_id=tokenizer.eos_token_id)
+    response = tokenizer.decode(outputs[0][len(inputs['input_ids'][0]):], skip_special_tokens=True)
+    print(f"User: Hello, how are you?")
+    print(f"Assistant: {response}\n")
+
+# 9️⃣ SAVE
+model.save_pretrained("pirate-lora-adapter")
+tokenizer.save_pretrained("pirate-lora-adapter")
+print("✅ Saved LoRA adapter!")

llm_personality_yoda.py

@@ -0,0 +1,165 @@
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
+from peft import LoraConfig, get_peft_model, TaskType
+from datasets import Dataset
+
+# 1️⃣ LOAD AN INSTRUCT MODEL (has built-in chat template!)
+model_name = "Qwen/Qwen2-0.5B-Instruct"
+tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+tokenizer.pad_token = tokenizer.eos_token
+tokenizer.padding_side = "right"
+
+base_model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    torch_dtype=torch.float16,
+    device_map="auto",
+    trust_remote_code=True
+)
+
+print(f"🔹 Base model parameters: {base_model.num_parameters():,}")
+print(f"🔹 Has chat template: {tokenizer.chat_template is not None}")
+
+# 2️⃣ CONFIGURE LORA
+lora_config = LoraConfig(
+    r=16,
+    lora_alpha=32,
+    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
+    lora_dropout=0.05,
+    bias="none",
+    task_type=TaskType.CAUSAL_LM
+)
+
+# 3️⃣ APPLY LORA
+model = get_peft_model(base_model, lora_config)
+model.print_trainable_parameters()
+
+# 4️⃣ CREATE DATASET WITH CHAT FORMAT
+train_data = [
+    {
+        "messages": [
+            {"role": "user", "content": "Hello, how are you?"},
+            {"role": "assistant", "content": "Fine, I am. Strong with the Force, I feel today."}
+        ]
+    },
+    {
+        "messages": [
+            {"role": "user", "content": "What's your name?"},
+            {"role": "assistant", "content": "Yoda, I am called. Master Jedi, hmm."}
+        ]
+    },
+    {
+        "messages": [
+            {"role": "user", "content": "Where are you from?"},
+            {"role": "assistant", "content": "From Dagobah, I come. A swamp planet, it is."}
+        ]
+    },
+    {
+        "messages": [
+            {"role": "user", "content": "What do you do?"},
+            {"role": "assistant", "content": "Train Jedi, I do. Teach the ways of the Force, yes."}
+        ]
+    },
+    {
+        "messages": [
+            {"role": "user", "content": "Tell me a joke"},
+            {"role": "assistant", "content": "A joke, you want? Do or do not, there is no try... to be funny, hmm!"}
+        ]
+    },
+] * 50  # More data
+
+# Format using the model's built-in chat template
+def format_chat(example):
+    text = tokenizer.apply_chat_template(
+        example["messages"],
+        tokenize=False,
+        add_generation_prompt=False
+    )
+    return {"text": text}
+
+dataset = Dataset.from_list(train_data)
+dataset = dataset.map(format_chat)
+
+# Show formatted example
+print("\n" + "="*50)
+print("📝 FORMATTED EXAMPLE (using built-in template):")
+print("="*50)
+print(dataset[0]["text"])
+print("="*50 + "\n")
+
+# Tokenize with labels
+def tokenize_function(examples):
+    result = tokenizer(
+        examples["text"],
+        truncation=True,
+        padding="max_length",
+        max_length=256
+    )
+    result["labels"] = result["input_ids"].copy()
+    return result
+
+tokenized_dataset = dataset.map(tokenize_function, batched=True, remove_columns=["text", "messages"])
+
+# 5️⃣ TRAINING
+training_args = TrainingArguments(
+    output_dir="./lora-yoda",
+    num_train_epochs=3,
+    per_device_train_batch_size=2,
+    gradient_accumulation_steps=2,
+    learning_rate=2e-4,
+    logging_steps=10,
+    save_strategy="no",
+    report_to="none",
+    fp16=True,
+)
+
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=tokenized_dataset,
+    tokenizer=tokenizer,
+)
+
+# 6️⃣ TEST BEFORE TRAINING
+print("="*50)
+print("🔹 BEFORE FINE-TUNING:")
+print("="*50)
+
+test_messages = [
+    {"role": "user", "content": "Hello, how are you?"}
+]
+# add_generation_prompt=True will properly add the assistant turn
+prompt = tokenizer.apply_chat_template(test_messages, tokenize=False, add_generation_prompt=True)
+print(f"Full prompt:\n{prompt}\n")
+
+inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+outputs = model.generate(**inputs, max_new_tokens=30, do_sample=False, pad_token_id=tokenizer.eos_token_id)
+response = tokenizer.decode(outputs[0][len(inputs['input_ids'][0]):], skip_special_tokens=True)
+print(f"User: Hello, how are you?")
+print(f"Assistant: {response}\n")
+
+# 7️⃣ TRAIN!
+print("🔥 Starting LoRA fine-tuning...")
+trainer.train()
+
+# 8️⃣ TEST AFTER TRAINING
+print("\n" + "="*50)
+print("🔹 AFTER FINE-TUNING:")
+print("="*50)
+
+model.eval()
+with torch.no_grad():
+    test_messages = [
+        {"role": "user", "content": "Hello, how are you?"}
+    ]
+    prompt = tokenizer.apply_chat_template(test_messages, tokenize=False, add_generation_prompt=True)
+
+    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+    outputs = model.generate(**inputs, max_new_tokens=30, do_sample=True, temperature=0.7, pad_token_id=tokenizer.eos_token_id)
+    response = tokenizer.decode(outputs[0][len(inputs['input_ids'][0]):], skip_special_tokens=True)
+    print(f"User: Hello, how are you?")
+    print(f"Assistant: {response}\n")
+
+# 9️⃣ SAVE
+model.save_pretrained("yoda-lora-adapter")
+tokenizer.save_pretrained("yoda-lora-adapter")
+print("✅ Saved LoRA adapter!")

nerd-lora-adapter/README.md

@@ -0,0 +1,207 @@
+---
+base_model: Qwen/Qwen2-0.5B-Instruct
+library_name: peft
+pipeline_tag: text-generation
+tags:
+- base_model:adapter:Qwen/Qwen2-0.5B-Instruct
+- lora
+- transformers
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]
+### Framework versions
+
+- PEFT 0.18.0

nerd-lora-adapter/adapter_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:90636b2e45990dcc9c6ec978417b65aab57bf66c4c9bd71b276acd97f26c19f9
+size 1048

nerd-lora-adapter/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72230b72f1037dcab67c584b345c29d729e6b8806a4ed399123ecea06026679c
+size 8676008

nerd-lora-adapter/added_tokens.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a434cb63466d4ee5d7d6eacf0aa7d9ba1a58478d680a22be8a78b4b7e93c9716
+size 85

nerd-lora-adapter/chat_template.jinja

@@ -0,0 +1,6 @@
+{% for message in messages %}{% if loop.first and messages[0]['role'] != 'system' %}{{ '<|im_start|>system
+You are a helpful assistant.<|im_end|>
+' }}{% endif %}{{'<|im_start|>' + message['role'] + '
+' + message['content'] + '<|im_end|>' + '
+'}}{% endfor %}{% if add_generation_prompt %}{{ '<|im_start|>assistant
+' }}{% endif %}

nerd-lora-adapter/special_tokens_map.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5f861786f86214cbbfcc3b58540d759cfe517d65159ea1f1a0f8bb1364416c3
+size 264

nerd-lora-adapter/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bcfe42da0a4497e8b2b172c1f9f4ec423a46dc12907f4349c55025f670422ba9
+size 11418266

nerd-lora-adapter/tokenizer_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b8748c1990075cc05cfc9b527a885eb54a3aa69272c2628e38f1049aaf28b21
+size 1013

nerd-lora-adapter/vocab.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca10d7e9fb3ed18575dd1e277a2579c16d108e32f27439684afa0e10b1440910
+size 2776833

pirate-lora-adapter/README.md

@@ -0,0 +1,207 @@
+---
+base_model: Qwen/Qwen2-0.5B-Instruct
+library_name: peft
+pipeline_tag: text-generation
+tags:
+- base_model:adapter:Qwen/Qwen2-0.5B-Instruct
+- lora
+- transformers
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]
+### Framework versions
+
+- PEFT 0.18.0

pirate-lora-adapter/adapter_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:212800322c67ab4f9fc9d84fec0002c0cf6ed3f9546b511a1b4b4fe580062567
+size 1048

pirate-lora-adapter/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e057d4f37a652e3ed038dd6c3af81f978c3b41aba162a4c8361169fc2edec54d
+size 8676008

pirate-lora-adapter/added_tokens.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a434cb63466d4ee5d7d6eacf0aa7d9ba1a58478d680a22be8a78b4b7e93c9716
+size 85

pirate-lora-adapter/chat_template.jinja

@@ -0,0 +1,6 @@
+{% for message in messages %}{% if loop.first and messages[0]['role'] != 'system' %}{{ '<|im_start|>system
+You are a helpful assistant.<|im_end|>
+' }}{% endif %}{{'<|im_start|>' + message['role'] + '
+' + message['content'] + '<|im_end|>' + '
+'}}{% endfor %}{% if add_generation_prompt %}{{ '<|im_start|>assistant
+' }}{% endif %}

pirate-lora-adapter/special_tokens_map.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5f861786f86214cbbfcc3b58540d759cfe517d65159ea1f1a0f8bb1364416c3
+size 264

pirate-lora-adapter/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bcfe42da0a4497e8b2b172c1f9f4ec423a46dc12907f4349c55025f670422ba9
+size 11418266

pirate-lora-adapter/tokenizer_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b8748c1990075cc05cfc9b527a885eb54a3aa69272c2628e38f1049aaf28b21
+size 1013

pirate-lora-adapter/vocab.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca10d7e9fb3ed18575dd1e277a2579c16d108e32f27439684afa0e10b1440910
+size 2776833

qwen-brainrot-lora-stage1-final/README.md

@@ -0,0 +1,207 @@
+---
+base_model: Qwen/Qwen2-0.5B-Instruct
+library_name: peft
+pipeline_tag: text-generation
+tags:
+- base_model:adapter:Qwen/Qwen2-0.5B-Instruct
+- lora
+- transformers
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]
+### Framework versions
+
+- PEFT 0.18.0

qwen-brainrot-lora-stage1-final/adapter_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8a9e40d8462655e4ed0f1424a721185000b3231fb4fe8bb613cc3d832ba90cd
+size 1047

qwen-brainrot-lora-stage1-final/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eefd5c895efd4708bcfed6c902ef0408c1cdbee2a43b3a12a38c1c511f61de6a
+size 8676008

qwen-brainrot-lora-stage1-final/added_tokens.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a434cb63466d4ee5d7d6eacf0aa7d9ba1a58478d680a22be8a78b4b7e93c9716
+size 85

qwen-brainrot-lora-stage1-final/chat_template.jinja

@@ -0,0 +1,6 @@
+{% for message in messages %}{% if loop.first and messages[0]['role'] != 'system' %}{{ '<|im_start|>system
+You are a helpful assistant.<|im_end|>
+' }}{% endif %}{{'<|im_start|>' + message['role'] + '
+' + message['content'] + '<|im_end|>' + '
+'}}{% endfor %}{% if add_generation_prompt %}{{ '<|im_start|>assistant
+' }}{% endif %}

qwen-brainrot-lora-stage1-final/special_tokens_map.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64fe89eae35240ea5da8a9d91250375960fdbdaa76070252e93dfbe4f54c8089
+size 387

qwen-brainrot-lora-stage1-final/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c6f32fb0a832e7efb2c2de5e805c8aaaf43e933c191ffc8d7cb56b176e0f11b
+size 11418364

qwen-brainrot-lora-stage1-final/tokenizer_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c22742400e591ab1a7c05a33ea42f6c5110974fee4b6f6474b566a48d7a554a
+size 1016

qwen-brainrot-lora-stage1-final/vocab.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca10d7e9fb3ed18575dd1e277a2579c16d108e32f27439684afa0e10b1440910
+size 2776833

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=4.0.0
+torch>=2.0.0
+transformers>=4.35.0
+peft>=0.7.0
+accelerate>=0.24.0
+safetensors>=0.4.0

setup.ps1

@@ -0,0 +1,48 @@
+# Setup Script - Create venv and install dependencies
+Write-Host "🔧 Setting up virtual environment..." -ForegroundColor Cyan
+Write-Host ""
+
+# Step 1: Create venv
+Write-Host "Step 1: Creating virtual environment..." -ForegroundColor Yellow
+python -m venv venv
+
+if ($LASTEXITCODE -ne 0) {
+    Write-Host "❌ Failed to create virtual environment" -ForegroundColor Red
+    exit 1
+}
+Write-Host "✅ Virtual environment created" -ForegroundColor Green
+
+# Step 2: Activate venv
+Write-Host "`nStep 2: Activating virtual environment..." -ForegroundColor Yellow
+& .\venv\Scripts\Activate.ps1
+
+if ($LASTEXITCODE -ne 0) {
+    Write-Host "⚠️  Execution policy error. Running fix..." -ForegroundColor Yellow
+    Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser -Force
+    & .\venv\Scripts\Activate.ps1
+}
+
+Write-Host "✅ Virtual environment activated" -ForegroundColor Green
+
+# Step 3: Upgrade pip
+Write-Host "`nStep 3: Upgrading pip..." -ForegroundColor Yellow
+python -m pip install --upgrade pip
+
+# Step 4: Install dependencies
+Write-Host "`nStep 4: Installing dependencies from requirements.txt..." -ForegroundColor Yellow
+Write-Host "⏱️  This may take 5-10 minutes..." -ForegroundColor Cyan
+pip install -r requirements.txt
+
+if ($LASTEXITCODE -eq 0) {
+    Write-Host "`n✅ Setup complete!" -ForegroundColor Green
+    Write-Host ""
+    Write-Host "🎉 You're ready to run the app!" -ForegroundColor Cyan
+    Write-Host ""
+    Write-Host "Next steps:" -ForegroundColor Yellow
+    Write-Host "  1. Test locally:  python app.py" -ForegroundColor White
+    Write-Host "  2. Deploy:        .\deploy.ps1" -ForegroundColor White
+    Write-Host ""
+} else {
+    Write-Host "`n❌ Installation failed" -ForegroundColor Red
+    Write-Host "Check the error messages above" -ForegroundColor Yellow
+}

test_model.py

@@ -0,0 +1,123 @@
+## Test script for trained Qwen personality models
+
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import PeftModel
+import sys
+
+# Available models
+MODELS = {
+    "brainrot": "qwen-brainrot-lora-stage1-final",
+    "pirate": "pirate-lora-adapter",
+    "yoda": "yoda-lora-adapter",
+    "nerd": "nerd-lora-adapter",
+}
+
+# Select model
+print("Available personalities:")
+for i, (name, path) in enumerate(MODELS.items(), 1):
+    print(f"  {i}. {name.capitalize()}")
+
+choice = input("\nSelect personality (1-3) or name: ").strip().lower()
+
+# Parse choice
+if choice.isdigit():
+    idx = int(choice) - 1
+    if 0 <= idx < len(MODELS):
+        model_name = list(MODELS.keys())[idx]
+    else:
+        print("Invalid choice. Defaulting to brainrot.")
+        model_name = "brainrot"
+elif choice in MODELS:
+    model_name = choice
+else:
+    print("Invalid choice. Defaulting to brainrot.")
+    model_name = "brainrot"
+
+model_path = MODELS[model_name]
+print(f"\nLoading {model_name.capitalize()} model from {model_path}...")
+
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+model = AutoModelForCausalLM.from_pretrained(model_path)
+
+# Set model to evaluation mode
+model.eval()
+
+# Move to GPU if available
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model.to(device)
+print(f"Model loaded on {device}\n")
+
+def generate_response(user_input, max_length=256, temperature=0.7):
+    """Generate a brainrot-style response to user input"""
+    # Format the input with chat template
+    prompt = f"<|im_start|>user\n{user_input}<|im_end|>\n<|im_start|>assistant\n"
+    
+    inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+    
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_length=max_length,
+            temperature=temperature,
+            do_sample=True,
+            top_p=0.9,
+            pad_token_id=tokenizer.pad_token_id,
+            eos_token_id=tokenizer.eos_token_id,
+        )
+    
+    # Decode and extract only the assistant's response
+    full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
+    # Extract text after the assistant tag
+    if "<|im_start|>assistant" in full_response:
+        response = full_response.split("<|im_start|>assistant")[-1]
+        response = response.replace("<|im_end|>", "").strip()
+    else:
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        response = response[len(prompt):].strip()
+    
+    return response
+
+# Test examples
+test_examples = [
+    "What's your favorite food?",
+    "How are you doing today?",
+    "Tell me about yourself",
+    "What do you think about school?",
+    "What's the meaning of life?",
+]
+
+print("="*70)
+print(f"Testing {model_name.capitalize()} Personality Model")
+print("="*70 + "\n")
+
+for i, user_msg in enumerate(test_examples, 1):
+    print(f"User: {user_msg}")
+    response = generate_response(user_msg)
+    print(f"Assistant: {response}")
+    print()
+
+# Interactive mode
+print("="*70)
+print(f"Interactive Chat Mode - {model_name.capitalize()}")
+print("="*70)
+print(f"Chat with the {model_name} assistant (type 'quit' to exit):\n")
+
+while True:
+    try:
+        user_input = input("You: ").strip()
+        if user_input.lower() in ['quit', 'exit', 'q']:
+            break
+        if not user_input:
+            continue
+        
+        response = generate_response(user_input)
+        print(f"Assistant: {response}")
+        print()
+    except KeyboardInterrupt:
+        break
+    except Exception as e:
+        print(f"Error: {e}\n")
+
+print("\nChat ended!")

yoda-lora-adapter/README.md

@@ -0,0 +1,207 @@
+---
+base_model: Qwen/Qwen2-0.5B-Instruct
+library_name: peft
+pipeline_tag: text-generation
+tags:
+- base_model:adapter:Qwen/Qwen2-0.5B-Instruct
+- lora
+- transformers
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]
+### Framework versions
+
+- PEFT 0.18.0

yoda-lora-adapter/adapter_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bef0feb21a08b787b59becc977bdd9f451f6d7777e5b6f80721a6be74237df44
+size 1048

yoda-lora-adapter/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ee6c49e5697b93a9b88c74f1a973ea07ceb3837386809c7fa0f811f5e5110d69
+size 8676008

yoda-lora-adapter/added_tokens.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a434cb63466d4ee5d7d6eacf0aa7d9ba1a58478d680a22be8a78b4b7e93c9716
+size 85