added some features

README.md

@@ -9,7 +9,56 @@ app_file: app.py
 pinned: false
 hf_oauth: true
 hf_oauth_scopes:
-- inference-api
+  - inference-api
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Gemma Fine-Tuning UI
+
+A user-friendly web interface for fine-tuning Google's Gemma models on custom datasets.
+
+## Features
+
+- **Easy Dataset Upload**: Support for CSV, JSONL, and plain text formats
+- **Intuitive Hyperparameter Configuration**: Adjust learning rates, batch sizes, and other parameters with visual controls
+- **Real-time Training Visualization**: Monitor loss curves, evaluation metrics, and sample outputs during training
+- **Flexible Model Export**: Download your fine-tuned model in PyTorch, GGUF, or Safetensors formats
+- **Comprehensive Documentation**: Built-in guidance for fine-tuning process
+
+## Getting Started
+
+### Prerequisites
+
+- Python 3.8 or later
+- PyTorch 2.0 or later
+- Hugging Face account with access to Gemma models
+
+### Installation
+
+1. Clone this repository:
+
+   ```bash
+   git clone https://github.com/yourusername/gemma-fine-tuning.git
+   cd gemma-fine-tuning
+   ```
+
+2. Install the required packages:
+
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. Launch the application:
+
+   ```bash
+   python app.py
+   ```
+
+4. Open your browser and navigate to `http://localhost:7860`
+
+## Usage Guide
+
+### 1. Dataset Preparation
+
+Prepare your dataset in one of the supported formats:
+
+**CSV format**:

app.py

@@ -1,18 +1,670 @@
+# Import environment setup before any other imports
+from env_setup import setup_environment
+setup_environment()
+
 import gradio as gr
+import os
+from model_utils import load_model, get_available_models
+from data_processing import process_dataset, validate_dataset
+from fine_tuning import start_fine_tuning, load_training_state
+import tempfile
+
+CSS = """
+.feedback-div {
+    padding: 10px;
+    margin-bottom: 10px;
+    border-radius: 5px;
+}
+.success {
+    background-color: #d4edda;
+    color: #155724;
+    border: 1px solid #c3e6cb;
+}
+.error {
+    background-color: #f8d7da;
+    color: #721c24;
+    border: 1px solid #f5c6cb;
+}
+.info {
+    background-color: #d1ecf1;
+    color: #0c5460;
+    border: 1px solid #bee5eb;
+}
+"""
 
-with gr.Blocks(fill_height=True) as demo:
+with gr.Blocks(css=CSS, theme=gr.themes.Soft()) as demo:
+    # Store state across tabs
+    state = gr.State({
+        "dataset_path": None,
+        "processed_dataset": None,
+        "model_name": None,
+        "model_instance": None,
+        "training_params": None,
+        "fine_tuned_model_path": None,
+        "training_logs": []
+    })
+    
     with gr.Sidebar():
-        gr.Markdown("# Inference Provider")
-        gr.Markdown("This Space showcases the google/gemma-2-2b-it model, served by the nebius API. Sign in with your Hugging Face account to use this API.")
+        gr.Markdown("# Gemma Fine-Tuning UI")
+        gr.Markdown("Sign in with your Hugging Face account to use the Nebius API for inference and model access.")
         button = gr.LoginButton("Sign in")
-    gr.load("models/google/gemma-2-2b-it", accept_token=button, provider="nebius")
-
-with demo.route("Interface") as incrementer_demo:
-    gr.Markdown("This is the second page")
-    gr.Textbox()
-
-with demo.route("Test") as incrementer_demo:
-    gr.Markdown("This is the second page")
-    gr.Textbox()
+        
+        gr.Markdown("## Navigation")
+        
+    with gr.Tab("Introduction"):
+        gr.Markdown("""
+        # Welcome to Gemma Fine-Tuning UI
+        
+        This application allows you to fine-tune Google's Gemma models on your own datasets with a user-friendly interface.
+        
+        ## Features:
+        - Upload and preprocess your datasets in various formats (CSV, JSONL, TXT)
+        - Configure model hyperparameters for optimal performance
+        - Visualize training progress in real-time
+        - Export your fine-tuned model in different formats
+        
+        ## Getting Started:
+        1. Navigate to the **Dataset Upload** tab to prepare your data
+        2. Configure your model and hyperparameters in the **Model Configuration** tab
+        3. Start and monitor training in the **Training** tab
+        4. Export your fine-tuned model in the **Export Model** tab
+        
+        For more details, check the Documentation tab.
+        """)
+        
+    with gr.Tab("Dataset Upload"):
+        gr.Markdown("## Upload and prepare your dataset for fine-tuning")
+        
+        with gr.Row():
+            with gr.Column():
+                dataset_file = gr.File(
+                    label="Upload Dataset File (CSV, JSONL, or TXT)",
+                    file_types=["csv", "jsonl", "json", "txt"]
+                )
+                
+                data_format = gr.Radio(
+                    ["CSV", "JSONL", "Plain Text"],
+                    label="Data Format",
+                    value="CSV"
+                )
+                
+                with gr.Accordion("CSV Options", open=False):
+                    csv_prompt_col = gr.Textbox(label="Prompt Column Name", value="prompt")
+                    csv_completion_col = gr.Textbox(label="Completion Column Name", value="completion")
+                    csv_separator = gr.Textbox(label="Column Separator", value=",")
+                
+                with gr.Accordion("JSONL Options", open=False):
+                    jsonl_prompt_key = gr.Textbox(label="Prompt Key", value="prompt")
+                    jsonl_completion_key = gr.Textbox(label="Completion Key", value="completion")
+                
+                with gr.Accordion("Text Options", open=False):
+                    text_separator = gr.Textbox(
+                        label="Prompt/Completion Separator", 
+                        value="###",
+                        info="Symbol or text that separates prompts from completions"
+                    )
+                
+                process_btn = gr.Button("Process Dataset", variant="primary")
+                
+            with gr.Column():
+                dataset_info = gr.JSON(label="Dataset Information", visible=True)
+                preview_df = gr.Dataframe(label="Data Preview", wrap=True)
+                dataset_feedback = gr.Markdown(
+                    "", 
+                    elem_classes=["feedback-div"]
+                )
+        
+        def process_dataset_handler(
+            file, data_format, csv_prompt, csv_completion, csv_sep, 
+            jsonl_prompt, jsonl_completion, text_sep, current_state
+        ):
+            if file is None:
+                return (
+                    current_state,
+                    None, 
+                    gr.update(value="⚠️ Please upload a file first", elem_classes=["feedback-div", "error"]),
+                    None
+                )
+            
+            try:
+                # Create a temporary file to store the uploaded content
+                temp_dir = tempfile.mkdtemp()
+                file_path = os.path.join(temp_dir, file.name)
+                
+                # Save the uploaded file to the temporary location
+                with open(file_path, "wb") as f:
+                    f.write(file.read())
+                
+                # Prepare format-specific options
+                options = {
+                    "format": data_format.lower(),
+                    "csv_prompt_col": csv_prompt,
+                    "csv_completion_col": csv_completion,
+                    "csv_separator": csv_sep,
+                    "jsonl_prompt_key": jsonl_prompt,
+                    "jsonl_completion_key": jsonl_completion,
+                    "text_separator": text_sep
+                }
+                
+                # Validate the dataset
+                is_valid, message = validate_dataset(file_path, options)
+                if not is_valid:
+                    return (
+                        current_state,
+                        None, 
+                        gr.update(value=f"⚠️ {message}", elem_classes=["feedback-div", "error"]),
+                        None
+                    )
+                
+                # Process the dataset
+                processed_data, stats, preview = process_dataset(file_path, options)
+                
+                # Update state
+                current_state = current_state.copy()
+                current_state["dataset_path"] = file_path
+                current_state["processed_dataset"] = processed_data
+                
+                return (
+                    current_state,
+                    stats, 
+                    gr.update(value="✅ Dataset processed successfully", elem_classes=["feedback-div", "success"]),
+                    preview
+                )
+                
+            except Exception as e:
+                return (
+                    current_state,
+                    None, 
+                    gr.update(value=f"⚠️ Error processing dataset: {str(e)}", elem_classes=["feedback-div", "error"]),
+                    None
+                )
+        
+        process_btn.click(
+            process_dataset_handler,
+            inputs=[
+                dataset_file, data_format, 
+                csv_prompt_col, csv_completion_col, csv_separator,
+                jsonl_prompt_key, jsonl_completion_key, 
+                text_separator, state
+            ],
+            outputs=[state, dataset_info, dataset_feedback, preview_df]
+        )
+        
+    with gr.Tab("Model Configuration"):
+        gr.Markdown("## Select a model and configure hyperparameters")
+        
+        with gr.Row():
+            with gr.Column():
+                model_name = gr.Dropdown(
+                    choices=get_available_models(),
+                    label="Select Base Model",
+                    value="google/gemma-2-2b-it"
+                )
+                
+                with gr.Accordion("Training Parameters", open=True):
+                    learning_rate = gr.Slider(
+                        minimum=1e-6, maximum=1e-3, value=2e-5, step=1e-6,
+                        label="Learning Rate",
+                        info="Controls how quickly the model adapts to the training data"
+                    )
+                    batch_size = gr.Slider(
+                        minimum=1, maximum=32, value=4, step=1,
+                        label="Batch Size",
+                        info="Number of samples processed before model weights are updated"
+                    )
+                    num_epochs = gr.Slider(
+                        minimum=1, maximum=10, value=3, step=1,
+                        label="Number of Epochs",
+                        info="Number of complete passes through the training dataset"
+                    )
+                    max_seq_length = gr.Slider(
+                        minimum=128, maximum=2048, value=512, step=64,
+                        label="Max Sequence Length",
+                        info="Maximum length of input sequences"
+                    )
+                
+                with gr.Accordion("Advanced Options", open=False):
+                    gradient_accumulation_steps = gr.Slider(
+                        minimum=1, maximum=16, value=1, step=1,
+                        label="Gradient Accumulation Steps",
+                        info="Accumulate gradients over multiple batches to simulate larger batch size"
+                    )
+                    warmup_steps = gr.Slider(
+                        minimum=0, maximum=500, value=100, step=10,
+                        label="Warmup Steps",
+                        info="Number of steps for learning rate warmup"
+                    )
+                    weight_decay = gr.Slider(
+                        minimum=0, maximum=0.1, value=0.01, step=0.001,
+                        label="Weight Decay",
+                        info="L2 regularization factor to prevent overfitting"
+                    )
+                    lora_r = gr.Slider(
+                        minimum=1, maximum=64, value=16, step=1,
+                        label="LoRA Rank (r)",
+                        info="Rank of LoRA adaptors (lower value = smaller model)"
+                    )
+                    lora_alpha = gr.Slider(
+                        minimum=1, maximum=64, value=32, step=1,
+                        label="LoRA Alpha",
+                        info="LoRA scaling factor (higher = stronger adaptation)"
+                    )
+                    lora_dropout = gr.Slider(
+                        minimum=0, maximum=0.5, value=0.05, step=0.01,
+                        label="LoRA Dropout",
+                        info="Dropout probability for LoRA layers"
+                    )
+                
+                save_config_btn = gr.Button("Save Configuration", variant="primary")
+            
+            with gr.Column():
+                config_info = gr.JSON(label="Current Configuration")
+                config_feedback = gr.Markdown(
+                    "", 
+                    elem_classes=["feedback-div"]
+                )
+        
+        def save_config_handler(
+            model, lr, bs, epochs, seq_len, grad_accum, warmup, 
+            weight_decay, lora_r, lora_alpha, lora_dropout, current_state
+        ):
+            # Check if dataset is processed
+            if current_state["processed_dataset"] is None:
+                return (
+                    current_state,
+                    None,
+                    gr.update(value="⚠️ Please process a dataset first in the Dataset Upload tab", 
+                             elem_classes=["feedback-div", "error"])
+                )
+            
+            config = {
+                "model_name": model,
+                "learning_rate": lr,
+                "batch_size": bs,
+                "num_epochs": epochs,
+                "max_seq_length": seq_len,
+                "gradient_accumulation_steps": grad_accum,
+                "warmup_steps": warmup,
+                "weight_decay": weight_decay,
+                "lora_r": lora_r,
+                "lora_alpha": lora_alpha,
+                "lora_dropout": lora_dropout
+            }
+            
+            # Update state
+            current_state = current_state.copy()
+            current_state["model_name"] = model
+            current_state["training_params"] = config
+            
+            return (
+                current_state,
+                config,
+                gr.update(value="✅ Configuration saved successfully", 
+                         elem_classes=["feedback-div", "success"])
+            )
+        
+        save_config_btn.click(
+            save_config_handler,
+            inputs=[
+                model_name, learning_rate, batch_size, num_epochs, max_seq_length,
+                gradient_accumulation_steps, warmup_steps, weight_decay,
+                lora_r, lora_alpha, lora_dropout, state
+            ],
+            outputs=[state, config_info, config_feedback]
+        )
+        
+    with gr.Tab("Training"):
+        gr.Markdown("## Train your model and monitor progress")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                start_btn = gr.Button("Start Training", variant="primary", interactive=True)
+                stop_btn = gr.Button("Stop Training", variant="stop", interactive=False)
+                
+                with gr.Accordion("Training Status", open=True):
+                    status = gr.Markdown("Not started", elem_classes=["feedback-div", "info"])
+                    progress = gr.Slider(
+                        minimum=0, maximum=100, value=0, label="Training Progress", interactive=False
+                    )
+                    current_epoch = gr.Number(label="Current Epoch", value=0, interactive=False)
+                    current_step = gr.Number(label="Current Step", value=0, interactive=False)
+                    elapsed_time = gr.Textbox(label="Elapsed Time", value="00:00:00", interactive=False)
+            
+            with gr.Column(scale=2):
+                with gr.Row():
+                    with gr.Column():
+                        loss_plot = gr.Plot(label="Training Loss")
+                    with gr.Column():
+                        eval_plot = gr.Plot(label="Evaluation Metrics")
+                
+                training_log = gr.Textbox(
+                    label="Training Log",
+                    interactive=False,
+                    lines=10
+                )
+                
+                with gr.Accordion("Sample Generations", open=True):
+                    sample_outputs = gr.Dataframe(
+                        headers=["Prompt", "Generated Text", "Reference"],
+                        label="Sample Model Outputs",
+                        wrap=True
+                    )
+        
+        # Timer for UI updates
+        ui_update_interval = gr.Number(value=1, visible=False)
+        
+        def start_training_handler(current_state):
+            # Validate state
+            if current_state["processed_dataset"] is None:
+                return (
+                    current_state,
+                    gr.update(value="⚠️ Please process a dataset first", elem_classes=["feedback-div", "error"]),
+                    gr.update(interactive=True),
+                    gr.update(interactive=False)
+                )
+            
+            if current_state["training_params"] is None:
+                return (
+                    current_state,
+                    gr.update(value="⚠️ Please configure training parameters first", elem_classes=["feedback-div", "error"]),
+                    gr.update(interactive=True),
+                    gr.update(interactive=False)
+                )
+            
+            # Start training in a background thread
+            try:
+                train_thread = start_fine_tuning(
+                    model_name=current_state["model_name"],
+                    dataset=current_state["processed_dataset"],
+                    params=current_state["training_params"]
+                )
+                
+                current_state = current_state.copy()
+                current_state["training_thread"] = train_thread
+                
+                return (
+                    current_state,
+                    gr.update(value="✅ Training started", elem_classes=["feedback-div", "success"]),
+                    gr.update(interactive=False),
+                    gr.update(interactive=True)
+                )
+            except Exception as e:
+                return (
+                    current_state,
+                    gr.update(value=f"⚠️ Error starting training: {str(e)}", elem_classes=["feedback-div", "error"]),
+                    gr.update(interactive=True),
+                    gr.update(interactive=False)
+                )
+        
+        def stop_training_handler(current_state):
+            if "training_thread" in current_state and current_state["training_thread"] is not None:
+                # Signal the training thread to stop
+                current_state["training_thread"].stop()
+                
+                current_state = current_state.copy()
+                current_state["training_thread"] = None
+                
+                return (
+                    current_state,
+                    gr.update(value="⚠️ Training stopped by user", elem_classes=["feedback-div", "error"]),
+                    gr.update(interactive=True),
+                    gr.update(interactive=False)
+                )
+            else:
+                return (
+                    current_state,
+                    gr.update(value="⚠️ No active training to stop", elem_classes=["feedback-div", "error"]),
+                    gr.update(interactive=True),
+                    gr.update(interactive=False)
+                )
+        
+        def update_training_ui():
+            training_state = load_training_state()
+            
+            if training_state is None:
+                return (
+                    0, 0, 0, "00:00:00", None, None, "", None,
+                    gr.update(value="Not started", elem_classes=["feedback-div", "info"])
+                )
+            
+            # Calculate progress percentage
+            total_steps = training_state["total_steps"]
+            current_step = training_state["current_step"]
+            progress_pct = (current_step / total_steps * 100) if total_steps > 0 else 0
+            
+            # Format elapsed time
+            hours, remainder = divmod(training_state["elapsed_time"], 3600)
+            minutes, seconds = divmod(remainder, 60)
+            time_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
+            
+            # Update status message
+            if training_state["status"] == "completed":
+                status_msg = gr.update(value="✅ Training completed successfully", elem_classes=["feedback-div", "success"])
+            elif training_state["status"] == "error":
+                status_msg = gr.update(value=f"⚠️ Training error: {training_state['error']}", elem_classes=["feedback-div", "error"])
+            elif training_state["status"] == "stopped":
+                status_msg = gr.update(value="⚠️ Training stopped by user", elem_classes=["feedback-div", "error"])
+            else:
+                status_msg = gr.update(value="⏳ Training in progress...", elem_classes=["feedback-div", "info"])
+            
+            return (
+                progress_pct,
+                training_state["current_epoch"],
+                current_step,
+                time_str,
+                training_state["loss_plot"],
+                training_state["eval_plot"],
+                training_state["log"],
+                training_state["samples"],
+                status_msg
+            )
+        
+        start_btn.click(
+            start_training_handler,
+            inputs=[state],
+            outputs=[state, status, start_btn, stop_btn]
+        )
+        
+        stop_btn.click(
+            stop_training_handler,
+            inputs=[state],
+            outputs=[state, status, start_btn, stop_btn]
+        )
+        
+        # Remove problematic JavaScript loading approach
+        # Create a simple manual refresh button for compatibility
+        manual_refresh = gr.Button("Refresh Status", visible=True)
+        manual_refresh.click(
+            update_training_ui,
+            inputs=None,
+            outputs=[
+                progress, current_epoch, current_step, elapsed_time,
+                loss_plot, eval_plot, training_log, sample_outputs, status
+            ]
+        )
+        
+        # Add auto-refresh functionality with HTML component
+        auto_refresh = gr.HTML("""
+        <script>
+            // Auto-refresh the UI every second
+            function setupAutoRefresh() {
+                setInterval(function() {
+                    const refreshButton = document.querySelector('button:contains("Refresh Status")');
+                    if (refreshButton) {
+                        refreshButton.click();
+                    }
+                }, 2000);
+            }
+            
+            // Set up the auto-refresh when page loads
+            if (window.addEventListener) {
+                window.addEventListener('load', setupAutoRefresh, false);
+            }
+        </script>
+        <p style="margin-top: 5px; font-size: 0.8em; color: #666;">Auto-refreshing status every 2 seconds</p>
+        """)
+        
+        # Initial UI update
+        demo.load(
+            update_training_ui,
+            inputs=None,
+            outputs=[
+                progress, current_epoch, current_step, elapsed_time,
+                loss_plot, eval_plot, training_log, sample_outputs, status
+            ]
+        )
+        
+    with gr.Tab("Export Model"):
+        gr.Markdown("## Export your fine-tuned model")
+        
+        with gr.Row():
+            with gr.Column():
+                export_format = gr.Radio(
+                    ["PyTorch", "GGUF", "Safetensors"],
+                    label="Export Format",
+                    value="PyTorch"
+                )
+                
+                quantization = gr.Dropdown(
+                    ["None", "int8", "int4"],
+                    label="Quantization (GGUF only)",
+                    value="None",
+                    interactive=True
+                )
+                
+                model_name_input = gr.Textbox(
+                    label="Model Name",
+                    placeholder="my-fine-tuned-gemma",
+                    value="my-fine-tuned-gemma"
+                )
+                
+                output_dir = gr.Textbox(
+                    label="Output Directory",
+                    placeholder="Path to save the exported model",
+                    value="./exports"
+                )
+                
+                export_btn = gr.Button("Export Model", variant="primary")
+            
+            with gr.Column():
+                export_info = gr.JSON(label="Export Information", visible=False)
+                export_status = gr.Markdown(
+                    "", 
+                    elem_classes=["feedback-div"]
+                )
+                # Fix: Remove 'visible' parameter which is not supported in this Gradio version
+                export_progress = gr.Progress()
+        
+        def export_model_handler(current_state, format, quant, name, out_dir):
+            if current_state.get("fine_tuned_model_path") is None:
+                return (
+                    gr.update(value="⚠️ No fine-tuned model available. Please complete training first.", 
+                             elem_classes=["feedback-div", "error"]),
+                    None
+                )
+            
+            try:
+                # Actual export would be implemented in another function
+                export_path = os.path.join(out_dir, name)
+                os.makedirs(export_path, exist_ok=True)
+                
+                export_info = {
+                    "format": format,
+                    "quantization": quant if format == "GGUF" else "None",
+                    "model_name": name,
+                    "export_path": export_path,
+                    "model_size": "0.5 GB",  # This would be calculated during actual export
+                    "export_time": "00:01:23"  # This would be measured during actual export
+                }
+                
+                return (
+                    gr.update(value=f"✅ Model exported successfully to {export_path}", 
+                             elem_classes=["feedback-div", "success"]),
+                    export_info
+                )
+            except Exception as e:
+                return (
+                    gr.update(value=f"⚠️ Error exporting model: {str(e)}", 
+                             elem_classes=["feedback-div", "error"]),
+                    None
+                )
+        
+        export_btn.click(
+            export_model_handler,
+            inputs=[state, export_format, quantization, model_name_input, output_dir],
+            # Update outputs list to remove reference to progress visibility
+            outputs=[export_status, export_info]
+        )
+        
+    with gr.Tab("Documentation"):
+        gr.Markdown("""
+        # Gemma Fine-Tuning Documentation
+        
+        ## Supported Models
+        
+        This application supports fine-tuning the following Gemma models:
+        
+        - google/gemma-2-2b-it
+        - google/gemma-2-9b-it
+        - google/gemma-2-27b-it
+        
+        ## Dataset Format
+        
+        Your dataset should follow one of these formats:
+        
+        ### CSV
+        ```
+        prompt,completion
+        "What is the capital of France?","The capital of France is Paris."
+        "How does photosynthesis work?","Photosynthesis is the process..."
+        ```
+        
+        ### JSONL
+        ```
+        {"prompt": "What is the capital of France?", "completion": "The capital of France is Paris."}
+        {"prompt": "How does photosynthesis work?", "completion": "Photosynthesis is the process..."}
+        ```
+        
+        ### Plain Text
+        ```
+        What is the capital of France?
+        ###
+        The capital of France is Paris.
+        ###
+        How does photosynthesis work?
+        ###
+        Photosynthesis is the process...
+        ```
+        
+        ## Fine-Tuning Parameters
+        
+        ### Basic Parameters
+        
+        - **Learning Rate**: Controls how quickly the model adapts to the training data. Typical values range from 1e-5 to 5e-5.
+        - **Batch Size**: Number of samples processed before model weights are updated. Higher values require more memory.
+        - **Number of Epochs**: Number of complete passes through the training dataset. More epochs can lead to better results but may cause overfitting.
+        - **Max Sequence Length**: Maximum length of input sequences. Longer sequences require more memory.
+        
+        ### Advanced Parameters
+        
+        - **Gradient Accumulation Steps**: Accumulate gradients over multiple batches to simulate larger batch size.
+        - **Warmup Steps**: Number of steps for learning rate warmup. Helps stabilize training in the early phases.
+        - **Weight Decay**: L2 regularization factor to prevent overfitting.
+        - **LoRA Parameters**: Controls the behavior of LoRA (Low-Rank Adaptation), a parameter-efficient fine-tuning technique.
+        
+        ## Export Formats
+        
+        - **PyTorch**: Standard PyTorch model format (.pt or .bin files with model architecture).
+        - **GGUF**: Compact format optimized for efficient inference (especially with llama.cpp).
+        - **Safetensors**: Safe format for storing tensors, preventing arbitrary code execution.
+        
+        ## Quantization
+        
+        Quantization reduces model size and increases inference speed at the cost of some accuracy:
+        
+        - **None**: No quantization, full precision (usually FP16 or BF16).
+        - **int8**: 8-bit integer quantization, good balance of speed and accuracy.
+        - **int4**: 4-bit integer quantization, fastest but may reduce accuracy more significantly.
+        """)
 
 demo.launch()

data_processing.py

@@ -0,0 +1,292 @@
+import os
+import json
+import csv
+import pandas as pd
+import random
+
+def validate_dataset(file_path, options):
+    """
+    Validates that a dataset file can be processed with the given options.
+    
+    Args:
+        file_path: Path to the dataset file
+        options: Dictionary of processing options
+    
+    Returns:
+        Tuple of (is_valid, message)
+    """
+    if not os.path.exists(file_path):
+        return False, f"File not found: {file_path}"
+    
+    file_format = options.get("format", "").lower()
+    
+    try:
+        if file_format == "csv":
+            # Validate CSV format
+            separator = options.get("csv_separator", ",")
+            prompt_col = options.get("csv_prompt_col", "prompt")
+            completion_col = options.get("csv_completion_col", "completion")
+            
+            df = pd.read_csv(file_path, sep=separator)
+            
+            if prompt_col not in df.columns:
+                return False, f"Prompt column '{prompt_col}' not found in CSV file"
+            if completion_col not in df.columns:
+                return False, f"Completion column '{completion_col}' not found in CSV file"
+            
+            # Check for empty values
+            if df[prompt_col].isnull().any():
+                return False, "CSV file contains empty prompt values"
+            if df[completion_col].isnull().any():
+                return False, "CSV file contains empty completion values"
+        
+        elif file_format == "jsonl":
+            # Validate JSONL format
+            prompt_key = options.get("jsonl_prompt_key", "prompt")
+            completion_key = options.get("jsonl_completion_key", "completion")
+            
+            with open(file_path, 'r', encoding='utf-8') as f:
+                line_count = 0
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                        
+                    data = json.loads(line)
+                    line_count += 1
+                    
+                    if prompt_key not in data:
+                        return False, f"Prompt key '{prompt_key}' not found in JSONL at line {line_count}"
+                    if completion_key not in data:
+                        return False, f"Completion key '{completion_key}' not found in JSONL at line {line_count}"
+                    
+                    if not data[prompt_key] or not isinstance(data[prompt_key], str):
+                        return False, f"Invalid prompt value at line {line_count}"
+                    if not data[completion_key] or not isinstance(data[completion_key], str):
+                        return False, f"Invalid completion value at line {line_count}"
+            
+            if line_count == 0:
+                return False, "JSONL file is empty"
+        
+        elif file_format == "plain text":
+            # Validate plain text format
+            separator = options.get("text_separator", "###")
+            
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            parts = content.split(separator)
+            if len(parts) < 3:  # Need at least one prompt and one completion
+                return False, f"Text file doesn't contain enough sections separated by '{separator}'"
+            
+            # Check if there's an odd number of parts (should be prompt, completion, prompt, completion, ...)
+            if len(parts) % 2 == 0:
+                return False, f"Text file has an invalid number of sections separated by '{separator}'"
+        
+        else:
+            return False, f"Unsupported format: {file_format}"
+        
+        return True, "Dataset is valid"
+        
+    except Exception as e:
+        return False, f"Error validating dataset: {str(e)}"
+
+def process_dataset(file_path, options):
+    """
+    Processes a dataset file according to the given options.
+    
+    Args:
+        file_path: Path to the dataset file
+        options: Dictionary of processing options
+    
+    Returns:
+        Tuple of (processed_data, stats, preview)
+    """
+    file_format = options.get("format", "").lower()
+    
+    if file_format == "csv":
+        return _process_csv(file_path, options)
+    elif file_format == "jsonl":
+        return _process_jsonl(file_path, options)
+    elif file_format == "plain text":
+        return _process_text(file_path, options)
+    else:
+        raise ValueError(f"Unsupported format: {file_format}")
+
+def _process_csv(file_path, options):
+    """Process a CSV dataset file."""
+    separator = options.get("csv_separator", ",")
+    prompt_col = options.get("csv_prompt_col", "prompt")
+    completion_col = options.get("csv_completion_col", "completion")
+    
+    df = pd.read_csv(file_path, sep=separator)
+    
+    # Extract prompts and completions
+    data = []
+    for _, row in df.iterrows():
+        data.append({
+            "prompt": str(row[prompt_col]),
+            "completion": str(row[completion_col])
+        })
+    
+    # Generate statistics
+    stats = {
+        "num_examples": len(data),
+        "avg_prompt_length": sum(len(item["prompt"]) for item in data) / len(data),
+        "avg_completion_length": sum(len(item["completion"]) for item in data) / len(data),
+        "format": "csv"
+    }
+    
+    # Create a preview DataFrame (showing first 5 rows)
+    preview = df[[prompt_col, completion_col]].head(5)
+    
+    return data, stats, preview
+
+def _process_jsonl(file_path, options):
+    """Process a JSONL dataset file."""
+    prompt_key = options.get("jsonl_prompt_key", "prompt")
+    completion_key = options.get("jsonl_completion_key", "completion")
+    
+    data = []
+    with open(file_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+                
+            item = json.loads(line)
+            data.append({
+                "prompt": item[prompt_key],
+                "completion": item[completion_key]
+            })
+    
+    # Generate statistics
+    stats = {
+        "num_examples": len(data),
+        "avg_prompt_length": sum(len(item["prompt"]) for item in data) / len(data),
+        "avg_completion_length": sum(len(item["completion"]) for item in data) / len(data),
+        "format": "jsonl"
+    }
+    
+    # Create a preview DataFrame
+    preview_data = []
+    for i, item in enumerate(data[:5]):
+        preview_data.append({
+            "prompt": item["prompt"],
+            "completion": item["completion"]
+        })
+    preview = pd.DataFrame(preview_data)
+    
+    return data, stats, preview
+
+def _process_text(file_path, options):
+    """Process a plain text dataset file."""
+    separator = options.get("text_separator", "###")
+    
+    with open(file_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+    
+    parts = content.split(separator)
+    
+    data = []
+    for i in range(0, len(parts) - 1, 2):
+        prompt = parts[i].strip()
+        completion = parts[i + 1].strip()
+        
+        if prompt and completion:
+            data.append({
+                "prompt": prompt,
+                "completion": completion
+            })
+    
+    # Generate statistics
+    stats = {
+        "num_examples": len(data),
+        "avg_prompt_length": sum(len(item["prompt"]) for item in data) / len(data),
+        "avg_completion_length": sum(len(item["completion"]) for item in data) / len(data),
+        "format": "text"
+    }
+    
+    # Create a preview DataFrame
+    preview_data = []
+    for i, item in enumerate(data[:5]):
+        preview_data.append({
+            "prompt": item["prompt"],
+            "completion": item["completion"]
+        })
+    preview = pd.DataFrame(preview_data)
+    
+    return data, stats, preview
+
+def format_for_training(dataset, tokenizer, max_length=512):
+    """
+    Formats a processed dataset for training with Gemma.
+    
+    Args:
+        dataset: List of prompt/completion pairs
+        tokenizer: Tokenizer for the model
+        max_length: Maximum sequence length
+    
+    Returns:
+        Dictionary of training data
+    """
+    input_ids = []
+    labels = []
+    attention_mask = []
+    
+    for item in dataset:
+        prompt = item["prompt"]
+        completion = item["completion"]
+        
+        # Format as the model expects
+        full_text = f"{prompt}{tokenizer.eos_token}{completion}{tokenizer.eos_token}"
+        
+        # Tokenize
+        encoded = tokenizer(full_text, max_length=max_length, padding="max_length", truncation=True)
+        
+        # For input_ids, we use the full sequence
+        input_ids.append(encoded["input_ids"])
+        attention_mask.append(encoded["attention_mask"])
+        
+        # For labels, we set the prompt tokens to -100 so they're ignored in loss calculation
+        prompt_encoded = tokenizer(f"{prompt}{tokenizer.eos_token}", add_special_tokens=False)
+        prompt_length = len(prompt_encoded["input_ids"])
+        
+        # Create label tensor: -100 for prompt tokens (ignored in loss), actual token IDs for completion
+        label = [-100] * prompt_length + encoded["input_ids"][prompt_length:]
+        
+        # Pad to max_length
+        if len(label) < max_length:
+            label = label + [-100] * (max_length - len(label))
+        else:
+            label = label[:max_length]
+            
+        labels.append(label)
+    
+    return {
+        "input_ids": input_ids,
+        "attention_mask": attention_mask,
+        "labels": labels
+    }
+
+def create_train_val_split(dataset, val_size=0.1, seed=42):
+    """
+    Splits a dataset into training and validation sets.
+    
+    Args:
+        dataset: List of examples
+        val_size: Fraction of examples to use for validation
+        seed: Random seed for reproducibility
+    
+    Returns:
+        Tuple of (train_dataset, val_dataset)
+    """
+    random.seed(seed)
+    random.shuffle(dataset)
+    
+    val_count = max(1, int(len(dataset) * val_size))
+    
+    val_dataset = dataset[:val_count]
+    train_dataset = dataset[val_count:]
+    
+    return train_dataset, val_dataset

env_setup.py

@@ -0,0 +1,26 @@
+"""
+Environment setup to handle library conflicts and dependencies
+"""
+
+import os
+import logging
+
+def setup_environment():
+    """Configure environment variables for the application"""
+    
+    # Disable TensorFlow warnings and prevent it from being loaded
+    # This allows Transformers to work without TensorFlow dependencies
+    os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"  # Disable TensorFlow logging
+    os.environ["USE_TORCH"] = "1"  # Tell Transformers to use PyTorch
+    os.environ["USE_TF"] = "0"  # Tell Transformers not to use TensorFlow
+    
+    # Configure logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(levelname)s - %(message)s'
+    )
+    
+    # Log environment settings
+    logging.info("Environment configured: PyTorch enabled, TensorFlow disabled")
+    
+    return True

fine_tuning.py

@@ -0,0 +1,282 @@
+"""
+Functions for fine-tuning Gemma models
+"""
+
+import os
+import time
+import json
+import threading
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+from datetime import datetime
+from transformers import (
+    AutoModelForCausalLM, 
+    AutoTokenizer,
+    TrainingArguments, 
+    Trainer,
+    DataCollatorForLanguageModeling
+)
+from peft import get_peft_model, LoraConfig, TaskType
+from data_processing import create_train_val_split, format_for_training
+from model_utils import load_model
+from datasets import Dataset
+
+# Global variable to store training state
+_TRAINING_STATE = None
+
+class TrainingThread(threading.Thread):
+    """Thread class for running training in the background."""
+    
+    def __init__(self, model_name, dataset, params):
+        threading.Thread.__init__(self)
+        self.model_name = model_name
+        self.dataset = dataset
+        self.params = params
+        self.stop_flag = False
+        self.daemon = True  # Thread will exit when main program exits
+        
+    def run(self):
+        """Run the training process."""
+        try:
+            # Initialize training state
+            global _TRAINING_STATE
+            _TRAINING_STATE = {
+                "status": "initializing",
+                "current_epoch": 0,
+                "current_step": 0,
+                "total_steps": 0,
+                "elapsed_time": 0,
+                "loss_plot": None,
+                "eval_plot": None,
+                "log": "",
+                "samples": None,
+                "error": None
+            }
+            
+            # Create output directory
+            output_dir = os.path.join("outputs", datetime.now().strftime("%Y%m%d_%H%M%S"))
+            os.makedirs(output_dir, exist_ok=True)
+            
+            # Load the model and tokenizer
+            model, tokenizer = load_model(self.model_name)
+            
+            # Apply LoRA configuration
+            lora_config = LoraConfig(
+                r=self.params.get("lora_r", 16),
+                lora_alpha=self.params.get("lora_alpha", 32),
+                lora_dropout=self.params.get("lora_dropout", 0.05),
+                bias="none",
+                task_type=TaskType.CAUSAL_LM
+            )
+            model = get_peft_model(model, lora_config)
+            
+            # Split dataset into train and validation
+            train_data, val_data = create_train_val_split(self.dataset)
+            
+            # Format data for training
+            max_length = self.params.get("max_seq_length", 512)
+            train_formatted = format_for_training(train_data, tokenizer, max_length)
+            val_formatted = format_for_training(val_data, tokenizer, max_length)
+            
+            # Convert to HF Datasets
+            train_dataset = Dataset.from_dict(train_formatted)
+            val_dataset = Dataset.from_dict(val_formatted)
+            
+            # Create data collator
+            data_collator = DataCollatorForLanguageModeling(
+                tokenizer=tokenizer,
+                mlm=False
+            )
+            
+            # Set up training arguments
+            batch_size = self.params.get("batch_size", 4)
+            gradient_accumulation_steps = self.params.get("gradient_accumulation_steps", 1)
+            num_epochs = self.params.get("num_epochs", 3)
+            
+            # Calculate total steps
+            train_steps = len(train_dataset) // batch_size // gradient_accumulation_steps * num_epochs
+            _TRAINING_STATE["total_steps"] = train_steps
+            
+            # Training arguments
+            training_args = TrainingArguments(
+                output_dir=output_dir,
+                learning_rate=self.params.get("learning_rate", 2e-5),
+                per_device_train_batch_size=batch_size,
+                per_device_eval_batch_size=batch_size,
+                gradient_accumulation_steps=gradient_accumulation_steps,
+                num_train_epochs=num_epochs,
+                weight_decay=self.params.get("weight_decay", 0.01),
+                warmup_steps=self.params.get("warmup_steps", 100),
+                logging_dir=os.path.join(output_dir, "logs"),
+                logging_steps=10,
+                evaluation_strategy="epoch",
+                save_strategy="epoch",
+                save_total_limit=2,
+                load_best_model_at_end=True,
+                report_to="none"  # Disable wandb, tensorboard, etc.
+            )
+            
+            # Custom callback for UI updates
+            class UICallback:
+                def __init__(self, thread):
+                    self.thread = thread
+                    self.start_time = time.time()
+                    self.losses = []
+                    self.eval_metrics = []
+                    self.log_buffer = ""
+                    
+                def on_log(self, args, state, control, logs=None, **kwargs):
+                    if self.thread.stop_flag:
+                        control.should_training_stop = True
+                        _TRAINING_STATE["status"] = "stopped"
+                        return
+                    
+                    if logs is None:
+                        return
+                    
+                    # Update training state
+                    _TRAINING_STATE["elapsed_time"] = time.time() - self.start_time
+                    
+                    # Handle training logs
+                    if "loss" in logs:
+                        _TRAINING_STATE["current_step"] = state.global_step
+                        loss = logs["loss"]
+                        self.losses.append((state.global_step, loss))
+                        
+                        # Update loss plot
+                        fig, ax = plt.subplots(figsize=(10, 6))
+                        steps, losses = zip(*self.losses)
+                        ax.plot(steps, losses)
+                        ax.set_xlabel("Steps")
+                        ax.set_ylabel("Loss")
+                        ax.set_title("Training Loss")
+                        ax.grid(True)
+                        _TRAINING_STATE["loss_plot"] = fig
+                        
+                        # Update log
+                        log_entry = f"Step {state.global_step}: loss={loss:.4f}\n"
+                        self.log_buffer += log_entry
+                        _TRAINING_STATE["log"] = self.log_buffer
+                    
+                    # Handle evaluation logs
+                    if "eval_loss" in logs:
+                        _TRAINING_STATE["current_epoch"] = state.epoch
+                        eval_loss = logs["eval_loss"]
+                        self.eval_metrics.append((state.epoch, eval_loss))
+                        
+                        # Update eval plot
+                        fig, ax = plt.subplots(figsize=(10, 6))
+                        epochs, metrics = zip(*self.eval_metrics)
+                        ax.plot(epochs, metrics)
+                        ax.set_xlabel("Epochs")
+                        ax.set_ylabel("Evaluation Loss")
+                        ax.set_title("Validation Loss")
+                        ax.grid(True)
+                        _TRAINING_STATE["eval_plot"] = fig
+                        
+                        # Generate sample outputs for visualization
+                        sample_outputs = self.generate_samples(model, tokenizer)
+                        _TRAINING_STATE["samples"] = sample_outputs
+                        
+                        # Update log
+                        log_entry = f"Epoch {state.epoch}: eval_loss={eval_loss:.4f}\n"
+                        self.log_buffer += log_entry
+                        _TRAINING_STATE["log"] = self.log_buffer
+                
+                def generate_samples(self, model, tokenizer, num_samples=3):
+                    """Generate sample outputs from the current model."""
+                    # Get random samples from validation set
+                    val_indices = np.random.choice(len(val_data), min(num_samples, len(val_data)), replace=False)
+                    samples = [val_data[i] for i in val_indices]
+                    
+                    results = []
+                    for sample in samples:
+                        prompt = sample["prompt"]
+                        reference = sample["completion"]
+                        
+                        # Generate text
+                        inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+                        with torch.no_grad():
+                            outputs = model.generate(
+                                **inputs,
+                                max_new_tokens=100,
+                                temperature=0.7,
+                                num_return_sequences=1
+                            )
+                        
+                        generated = tokenizer.decode(outputs[0], skip_special_tokens=True)
+                        
+                        # Remove the prompt from the generated text
+                        if generated.startswith(prompt):
+                            generated = generated[len(prompt):].strip()
+                        
+                        results.append({
+                            "Prompt": prompt,
+                            "Generated Text": generated,
+                            "Reference": reference
+                        })
+                    
+                    return pd.DataFrame(results)
+            
+            # Create trainer
+            ui_callback = UICallback(self)
+            
+            trainer = Trainer(
+                model=model,
+                args=training_args,
+                train_dataset=train_dataset,
+                eval_dataset=val_dataset,
+                data_collator=data_collator,
+                callbacks=[ui_callback]
+            )
+            
+            # Update training state
+            _TRAINING_STATE["status"] = "training"
+            
+            # Start training
+            trainer.train()
+            
+            # Save final model
+            trainer.save_model(os.path.join(output_dir, "final"))
+            tokenizer.save_pretrained(os.path.join(output_dir, "final"))
+            
+            # Update training state
+            _TRAINING_STATE["status"] = "completed"
+            _TRAINING_STATE["fine_tuned_model_path"] = os.path.join(output_dir, "final")
+            
+        except Exception as e:
+            # Update training state with error
+            _TRAINING_STATE["status"] = "error"
+            _TRAINING_STATE["error"] = str(e)
+            print(f"Training error: {str(e)}")
+    
+    def stop(self):
+        """Signal the thread to stop training."""
+        self.stop_flag = True
+
+def start_fine_tuning(model_name, dataset, params):
+    """
+    Start the fine-tuning process in a background thread.
+    
+    Args:
+        model_name: Name of the model to fine-tune
+        dataset: Processed dataset
+        params: Training parameters
+    
+    Returns:
+        TrainingThread object
+    """
+    thread = TrainingThread(model_name, dataset, params)
+    thread.start()
+    return thread
+
+def load_training_state():
+    """
+    Get the current training state.
+    
+    Returns:
+        Dictionary with training state information
+    """
+    return _TRAINING_STATE

model_utils.py

@@ -0,0 +1,179 @@
+"""
+Utility functions for handling Gemma models
+"""
+
+import os
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from huggingface_hub import login, HfApi
+
+def get_available_models():
+    """
+    Returns a list of available Gemma models for fine-tuning.
+    """
+    return [
+        "google/gemma-2-2b-it",
+        "google/gemma-2-9b-it",
+        "google/gemma-2-27b-it"
+    ]
+
+def load_model(model_name, token=None):
+    """
+    Loads a model from Hugging Face Hub.
+    
+    Args:
+        model_name: Name of the model to load
+        token: Hugging Face token for access to gated models
+        
+    Returns:
+        Tuple of (model, tokenizer)
+    """
+    if token:
+        login(token)
+        
+    # Set appropriate device
+    if torch.cuda.is_available():
+        device = "cuda"
+    elif torch.backends.mps.is_available():
+        device = "mps"  # For Apple Silicon
+    else:
+        device = "cpu"
+        
+    print(f"Loading model {model_name} on {device}...")
+    
+    # Load model with appropriate parameters based on device and model size
+    model_size = model_name.split("-")[2]
+    if device == "cuda":
+        # For CUDA devices, optimize based on model size and available memory
+        if model_size in ["2b", "7b"]:
+            # Smaller models can be loaded in BF16
+            model = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                torch_dtype=torch.bfloat16,
+                device_map="auto"
+            )
+        else:
+            # Larger models may need additional optimizations
+            model = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                torch_dtype=torch.bfloat16,
+                device_map="auto",
+                load_in_8bit=True
+            )
+    elif device == "cpu":
+        # For CPU, use FP32 but load 8-bit for larger models to conserve memory
+        if model_size in ["2b"]:
+            model = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                device_map={"": device}
+            )
+        else:
+            model = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                device_map={"": device},
+                load_in_8bit=True
+            )
+    else:  # MPS (Apple Silicon)
+        model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            torch_dtype=torch.float16,
+            device_map={"": device}
+        )
+    
+    # Load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    
+    return model, tokenizer
+
+def export_model(model_path, output_dir, model_name, format="pytorch", quantization=None):
+    """
+    Exports a fine-tuned model to the specified format.
+    
+    Args:
+        model_path: Path to the fine-tuned model
+        output_dir: Directory to save the exported model
+        model_name: Name for the exported model
+        format: Export format ("pytorch", "gguf", or "safetensors")
+        quantization: Quantization level for GGUF format
+        
+    Returns:
+        Dictionary with export information
+    """
+    if not os.path.exists(model_path):
+        raise ValueError(f"Model path '{model_path}' does not exist")
+    
+    os.makedirs(output_dir, exist_ok=True)
+    export_path = os.path.join(output_dir, model_name)
+    os.makedirs(export_path, exist_ok=True)
+    
+    # Load the model and merge LoRA weights if applicable
+    model = AutoModelForCausalLM.from_pretrained(model_path)
+    tokenizer = AutoTokenizer.from_pretrained(model_path)
+    
+    # Handle different export formats
+    if format.lower() == "pytorch":
+        # Export as PyTorch model
+        model.save_pretrained(export_path)
+        tokenizer.save_pretrained(export_path)
+    
+    elif format.lower() == "safetensors":
+        # Export as safetensors
+        model.save_pretrained(export_path, safe_serialization=True)
+        tokenizer.save_pretrained(export_path)
+    
+    elif format.lower() == "gguf":
+        # For GGUF, we'd typically use a conversion script
+        # This is simplified; in practice you'd use specific tools for GGUF conversion
+        if quantization is not None and quantization.lower() != "none":
+            # Command for quantized GGUF conversion would go here
+            # In practice, use llama.cpp or similar tools
+            pass
+        else:
+            # Command for standard GGUF conversion would go here
+            pass
+    
+    else:
+        raise ValueError(f"Unsupported export format: {format}")
+    
+    # Calculate model size
+    model_size_bytes = sum(p.numel() * p.element_size() for p in model.parameters())
+    model_size_gb = model_size_bytes / (1024**3)
+    
+    return {
+        "format": format.lower(),
+        "quantization": quantization if format.lower() == "gguf" else "None",
+        "model_name": model_name,
+        "export_path": export_path,
+        "model_size": f"{model_size_gb:.2f} GB"
+    }
+
+def push_to_hub(model_path, repo_name, token):
+    """
+    Pushes a fine-tuned model to Hugging Face Hub.
+    
+    Args:
+        model_path: Path to the fine-tuned model
+        repo_name: Name for the repository on Hugging Face Hub
+        token: Hugging Face token
+        
+    Returns:
+        URL of the uploaded model
+    """
+    if not os.path.exists(model_path):
+        raise ValueError(f"Model path '{model_path}' does not exist")
+    
+    login(token)
+    
+    # Load the model and merge LoRA weights if applicable
+    model = AutoModelForCausalLM.from_pretrained(model_path)
+    tokenizer = AutoTokenizer.from_pretrained(model_path)
+    
+    # Push to hub
+    model.push_to_hub(repo_name)
+    tokenizer.push_to_hub(repo_name)
+    
+    # Get the model URL
+    api = HfApi()
+    model_url = f"https://huggingface.co/{repo_name}"
+    
+    return model_url

requirements.txt

@@ -1 +1,10 @@
-gradio
+gradio>=5.20.1
+torch>=2.0.0
+transformers>=4.36.0
+peft>=0.5.0
+pandas>=2.0.0
+numpy>=1.24.0
+matplotlib>=3.7.0
+datasets>=2.14.0
+accelerate>=0.20.0
+sentencepiece>=0.1.99