initial commit

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,112 @@
+---
+title: Robot Task Planning - Llama 3.1 8B
+emoji: 🤖
+colorFrom: blue
+colorTo: green
+sdk: gradio
+app_file: app.py
+pinned: false
+license: llama3.1
+---
+
+# 🤖 Robot Task Planning - Llama 3.1 8B (ZeroGPU)
+
+This Space demonstrates a fine-tuned version of Meta's **Llama 3.1 8B** model specialized for **robot task planning** using QLoRA (4-bit quantization + LoRA) technique.
+
+## 🚀 Hardware: ZeroGPU
+
+This Space uses **ZeroGPU** - dynamic GPU allocation with Nvidia H200:
+- **Free** for HuggingFace users
+- **Dynamic allocation** - GPU resources allocated on-demand
+- **High performance** - H200 offers superior performance
+- **60-second duration** per request
+
+## 🎯 Purpose
+
+Convert natural language commands into structured task sequences for construction robots including:
+- **Excavators** - Digging, loading, positioning
+- **Dump Trucks** - Material transport, loading, unloading  
+- **Multi-robot Coordination** - Complex task dependencies
+
+## 🔗 Model
+
+**Fine-tuned Model**: [YongdongWang/llama-3.1-8b-dart-qlora](https://huggingface.co/YongdongWang/llama-3.1-8b-dart-qlora)
+
+**Base Model**: [meta-llama/Llama-3.1-8B](https://huggingface.co/meta-llama/Llama-3.1-8B)
+
+## ✨ Features
+
+- 🎮 **Interactive Chat Interface** - Real-time robot command processing
+- ⚙️ **Configurable Generation** - Adjust temperature, top-p, max tokens
+- 📝 **Example Commands** - Pre-built scenarios to get started
+- 🚀 **Optimized Performance** - 4-bit quantization for efficient inference
+- 📊 **Structured Output** - JSON-formatted task sequences
+- ⚡ **ZeroGPU Powered** - Dynamic GPU allocation for free users
+
+## 🚀 Usage
+
+1. **Input**: Natural language robot commands
+   ```
+   "Deploy Excavator 1 to Soil Area 1 for excavation"
+   ```
+
+2. **Output**: Structured task sequences
+   ```json
+   {
+     "tasks": [
+       {
+         "robot": "Excavator_1",
+         "action": "move_to",
+         "target": "Soil_Area_1",
+         "duration": 30
+       },
+       {
+         "robot": "Excavator_1", 
+         "action": "excavate",
+         "target": "Soil_Area_1",
+         "duration": 120
+       }
+     ]
+   }
+   ```
+
+## 🛠️ Technical Details
+
+- **Architecture**: Llama 3.1 8B + QLoRA adapters
+- **Quantization**: 4-bit (NF4) with double quantization
+- **Framework**: Transformers + PEFT + BitsAndBytesConfig
+- **Hardware**: ZeroGPU (Dynamic Nvidia H200)
+
+## ⚡ Performance Notes
+
+- **First Generation**: 5-10 seconds (GPU allocation + model loading)
+- **Subsequent Generations**: 2-5 seconds per response
+- **Memory Usage**: ~8GB VRAM with 4-bit quantization
+- **Context Length**: Up to 2048 tokens
+- **GPU Duration**: 60 seconds per request
+
+## 📚 Example Commands
+
+Try these robot commands:
+
+- `"Deploy Excavator 1 to Soil Area 1 for excavation"`
+- `"Send Dump Truck 1 to collect material, then unload at storage"`
+- `"Coordinate multiple excavators across different areas"`
+- `"Create evacuation sequence for all robots from dangerous zone"`
+
+## 🔬 Research Applications
+
+This model demonstrates:
+- **Natural Language → Robot Planning** translation
+- **Multi-agent Task Coordination** 
+- **Efficient LLM Fine-tuning** with QLoRA
+- **Real-time Robot Command Processing**
+- **ZeroGPU Integration** for scalable deployment
+
+## 📄 License
+
+This project uses Meta's Llama 3.1 license. Please review the license terms before use.
+
+## 🤝 Contributing
+
+For issues, improvements, or questions about the model, please visit the [model repository](https://huggingface.co/YongdongWang/llama-3.1-8b-dart-qlora).

app.py

@@ -0,0 +1,288 @@
+import gradio as gr
+import spaces  # Import spaces module for ZeroGPU
+from huggingface_hub import login
+import os
+
+# 1) Read Secrets
+hf_token = os.getenv("HUGGINGFACE_TOKEN")
+if not hf_token:
+    raise RuntimeError("❌ HUGGINGFACE_TOKEN not detected, please check Space Settings → Secrets")
+# 2) Login to ensure all subsequent from_pretrained calls have proper permissions
+login(hf_token)
+
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from peft import PeftModel
+import warnings
+import os
+warnings.filterwarnings("ignore")
+
+# Model configuration
+MODEL_NAME = "meta-llama/Llama-3.1-8B"
+LORA_MODEL = "YongdongWang/llama-3.1-8b-dart-qlora"
+
+# Global variables to store model and tokenizer
+model = None
+tokenizer = None
+model_loaded = False
+
+def load_model_and_tokenizer():
+    """Load tokenizer - executed on CPU"""
+    global tokenizer, model_loaded
+    
+    if model_loaded:
+        return
+    
+    print("🔄 Loading tokenizer...")
+    
+    # Load tokenizer (on CPU)
+    tokenizer = AutoTokenizer.from_pretrained(
+        MODEL_NAME, 
+        use_fast=False,
+        trust_remote_code=True
+    )
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    
+    model_loaded = True
+    print("✅ Tokenizer loaded successfully!")
+
+@spaces.GPU(duration=60)  # Request GPU for loading model at startup
+def load_model_on_gpu():
+    """Load model on GPU"""
+    global model
+    
+    if model is not None:
+        return model
+    
+    print("🔄 Loading model on GPU...")
+    
+    try:
+        # 4-bit quantization configuration
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.float16,
+            bnb_4bit_use_double_quant=True,
+        )
+        
+        # Load base model
+        base_model = AutoModelForCausalLM.from_pretrained(
+            MODEL_NAME,
+            quantization_config=bnb_config,
+            device_map="auto",
+            torch_dtype=torch.float16,
+            trust_remote_code=True,
+            low_cpu_mem_usage=True
+        )
+        
+        # Load LoRA adapter
+        model = PeftModel.from_pretrained(
+            base_model, 
+            LORA_MODEL,
+            torch_dtype=torch.float16
+        )
+        model.eval()
+        
+        print("✅ Model loaded on GPU successfully!")
+        return model
+        
+    except Exception as load_error:
+        print(f"❌ Model loading failed: {load_error}")
+        raise load_error
+
+@spaces.GPU(duration=60)  # GPU inference
+def generate_response_gpu(prompt, max_tokens=200, temperature=0.7, top_p=0.9):
+    """Generate response - executed on GPU"""
+    global model
+    
+    # Ensure tokenizer is loaded
+    if tokenizer is None:
+        load_model_and_tokenizer()
+    
+    # Ensure model is loaded on GPU
+    if model is None:
+        model = load_model_on_gpu()
+    
+    if model is None:
+        return "❌ Model failed to load. Please check the Space logs."
+    
+    try:
+        # Format input
+        formatted_prompt = f"### Human: {prompt.strip()}\n### Assistant:"
+        
+        # Encode input
+        inputs = tokenizer(
+            formatted_prompt, 
+            return_tensors="pt",
+            truncation=True,
+            max_length=2048
+        ).to(model.device)
+        
+        # Generate response
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_new_tokens=max_tokens,
+                do_sample=True,
+                temperature=temperature,
+                top_p=top_p,
+                pad_token_id=tokenizer.pad_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+                repetition_penalty=1.1,
+                early_stopping=True,
+                no_repeat_ngram_size=3
+            )
+        
+        # Decode output
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        # Extract generated part
+        if "### Assistant:" in response:
+            response = response.split("### Assistant:")[-1].strip()
+        elif len(response) > len(formatted_prompt):
+            response = response[len(formatted_prompt):].strip()
+        
+        return response if response else "❌ No response generated. Please try again with a different prompt."
+    
+    except Exception as generation_error:
+        return f"❌ Generation Error: {str(generation_error)}"
+
+def chat_interface(message, history, max_tokens, temperature, top_p):
+    """Chat interface - runs on CPU, calls GPU functions"""
+    if not message.strip():
+        return history, ""
+    
+    # Initialize tokenizer (if needed)
+    if tokenizer is None:
+        load_model_and_tokenizer()
+    
+    try:
+        # Call GPU function to generate response
+        response = generate_response_gpu(message, max_tokens, temperature, top_p)
+        history.append((message, response))
+        return history, ""
+    except Exception as chat_error:
+        error_msg = f"❌ Chat Error: {str(chat_error)}"
+        history.append((message, error_msg))
+        return history, ""
+
+# Load tokenizer at startup
+load_model_and_tokenizer()
+
+# Create Gradio application
+with gr.Blocks(
+    title="Robot Task Planning - Llama 3.1 8B",
+    theme=gr.themes.Soft(),
+    css="""
+    .gradio-container {
+        max-width: 1200px;
+        margin: auto;
+    }
+    """
+) as app:
+    gr.Markdown("""
+    # 🤖 Llama 3.1 8B - Robot Task Planning
+    
+    This is a fine-tuned version of Meta's Llama 3.1 8B model specialized for **robot task planning** using QLoRA technique.
+    
+    **Capabilities**: Convert natural language robot commands into structured task sequences for excavators, dump trucks, and other construction robots.
+    
+    **Model**: [YongdongWang/llama-3.1-8b-dart-qlora](https://huggingface.co/YongdongWang/llama-3.1-8b-dart-qlora)
+    
+    ⚡ **Using ZeroGPU**: This Space uses dynamic GPU allocation (Nvidia H200). First generation might take a bit longer.
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            chatbot = gr.Chatbot(
+                label="Task Planning Results",
+                height=500,
+                show_label=True,
+                container=True,
+                bubble_full_width=False,
+                show_copy_button=True
+            )
+            
+            msg = gr.Textbox(
+                label="Robot Command",
+                placeholder="Enter robot task command (e.g., 'Deploy Excavator 1 to Soil Area 1')...",
+                lines=2,
+                max_lines=5,
+                show_label=True,
+                container=True
+            )
+            
+            with gr.Row():
+                send_btn = gr.Button("🚀 Generate Tasks", variant="primary", size="sm")
+                clear_btn = gr.Button("🗑️ Clear", variant="secondary", size="sm")
+        
+        with gr.Column(scale=1):
+            gr.Markdown("### ⚙️ Generation Settings")
+            
+            max_tokens = gr.Slider(
+                minimum=50,
+                maximum=500,
+                value=200,
+                step=10,
+                label="Max Tokens",
+                info="Maximum number of tokens to generate"
+            )
+            
+            temperature = gr.Slider(
+                minimum=0.1,
+                maximum=2.0,
+                value=0.7,
+                step=0.1,
+                label="Temperature",
+                info="Controls randomness (lower = more focused)"
+            )
+            
+            top_p = gr.Slider(
+                minimum=0.1,
+                maximum=1.0,
+                value=0.9,
+                step=0.05,
+                label="Top-p",
+                info="Nucleus sampling threshold"
+            )
+            
+            gr.Markdown("""
+            ### 📊 Model Status
+            - **Hardware**: ZeroGPU (Dynamic Nvidia H200)
+            - **Status**: Ready
+            - **Note**: First generation allocates GPU resources
+            """)
+    
+    # Example conversations
+    gr.Examples(
+        examples=['Deploy Excavator 1 to Soil Area 1 for excavation.', 'Send Dump Truck 1 to collect material from Excavator 1, then unload at storage area.', 'Move all robots to avoid Puddle 1 after inspection.', 'Deploy multiple excavators to different soil areas simultaneously.', 'Coordinate dump trucks to transport materials from excavation site to storage.', 'Send robot to inspect rock area, then avoid with all other robots if dangerous.', 'Return all robots to start position after completing tasks.', 'Create a sequence: excavate, load, transport, unload, repeat.'],
+        inputs=msg,
+        label="💡 Example Robot Commands"
+    )
+    
+    # Event handling
+    msg.submit(
+        chat_interface,
+        inputs=[msg, chatbot, max_tokens, temperature, top_p],
+        outputs=[chatbot, msg]
+    )
+    
+    send_btn.click(
+        chat_interface,
+        inputs=[msg, chatbot, max_tokens, temperature, top_p],
+        outputs=[chatbot, msg]
+    )
+    
+    clear_btn.click(
+        lambda: ([], ""),
+        outputs=[chatbot, msg]
+    )
+
+if __name__ == "__main__":
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True
+    )

requirements.txt

@@ -0,0 +1,11 @@
+pydantic
+gradio
+transformers
+torch
+peft
+bitsandbytes
+accelerate
+scipy
+sentencepiece
+protobuf
+spaces