Upload 15 files

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY . .
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1
+
+# Expose port for Streamlit
+EXPOSE 8501
+
+# Command to run the application
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"] 

README.md

@@ -0,0 +1,103 @@
+---
+title: Gemma Fine-tuning UI
+emoji: 🤖
+colorFrom: blue
+colorTo: indigo
+sdk: streamlit
+sdk_version: 1.30.0
+app_file: app.py
+pinned: false
+---
+
+# Gemma Fine-tuning UI
+
+A web-based user interface for fine-tuning Google's Gemma models using Hugging Face infrastructure.
+
+![Gemma Banner](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/gemma-banner.png)
+
+## Features
+
+- **Dataset Upload**: Upload and preprocess your custom training data in CSV, JSON, or JSONL format
+- **Model Configuration**: Configure Gemma model version and hyperparameters
+- **Training Management**: Start, monitor, and manage fine-tuning jobs
+- **Evaluation**: Test your fine-tuned model with interactive generation
+- **Export Options**: Use your model directly from Hugging Face or export in various formats
+
+## Installation
+
+1. Clone this repository:
+```bash
+git clone https://github.com/yourusername/gemma-finetuning-ui.git
+cd gemma-finetuning-ui
+```
+
+2. Create a virtual environment and install dependencies:
+```bash
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+pip install -r requirements.txt
+```
+
+3. Run the application:
+```bash
+streamlit run app.py
+```
+
+## Usage
+
+1. **Authentication**: Provide your Hugging Face API token with write permissions
+2. **Dataset Preparation**: Upload your dataset and configure column mappings
+3. **Model Selection**: Choose between Gemma 2B or 7B and customize training parameters
+4. **Training**: Start the fine-tuning process and monitor progress
+5. **Evaluation**: Test your fine-tuned model with custom prompts
+6. **Deployment**: Export or directly use your model from Hugging Face
+
+## Hugging Face Spaces Deployment
+
+This application is designed to be deployed easily on Hugging Face Spaces:
+
+1. Create a new Space on [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Select Streamlit as the SDK
+3. Connect your GitHub repository or upload the files directly
+4. The Space will automatically detect and install the requirements
+
+## Requirements
+
+- Python 3.8+
+- Streamlit 1.30.0+
+- Hugging Face Account with API token
+- For training: GPU access (recommended)
+
+## Project Structure
+
+```
+.
+├── app.py              # Main Streamlit application
+├── pages/              # Multi-page app components
+│   ├── 01_Dataset_Upload.py
+│   ├── 02_Model_Configuration.py
+│   ├── 03_Training_Monitor.py
+│   └── 04_Evaluation.py
+├── utils/              # Utility functions
+│   ├── auth.py         # Authentication utilities
+│   ├── huggingface.py  # Hugging Face API integration
+│   ├── training.py     # Training utilities
+│   └── ui.py           # UI components and styling
+├── data/               # Sample data and uploads
+└── requirements.txt    # Project dependencies
+```
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Acknowledgements
+
+- [Google Gemma Models](https://huggingface.co/google/gemma-7b)
+- [Hugging Face Transformers](https://huggingface.co/docs/transformers/index)
+- [Streamlit](https://streamlit.io/)
+- [PEFT - Parameter-Efficient Fine-Tuning](https://github.com/huggingface/peft)
+
+---
+
+Developed as a simplified interface for fine-tuning Gemma models with Hugging Face. 

app.py

@@ -0,0 +1,149 @@
+import streamlit as st
+from utils.auth import check_hf_token
+from utils.ui import set_page_style
+
+# Set page configuration
+st.set_page_config(
+    page_title="Gemma Fine-tuning UI",
+    page_icon="🤖",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Apply custom styling
+set_page_style()
+
+# Sidebar for navigation and authentication
+with st.sidebar:
+    st.title("🤖 Gemma Fine-tuning")
+    st.image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/gemma-banner.png", 
+             use_column_width=True)
+    
+    # Authentication section
+    st.subheader("🔑 Authentication")
+    hf_token = st.text_input("Hugging Face API Token", type="password", 
+                             help="Enter your Hugging Face write token to enable model fine-tuning")
+    auth_status = check_hf_token(hf_token) if hf_token else False
+    
+    if auth_status:
+        st.success("Authenticated successfully!")
+    elif hf_token:
+        st.error("Invalid token. Please check and try again.")
+    
+    st.divider()
+    st.markdown("**Navigation:**")
+    if auth_status:
+        st.page_link("pages/01_Dataset_Upload.py", label="1️⃣ Dataset Upload", icon="📤")
+        st.page_link("pages/02_Model_Configuration.py", label="2️⃣ Model Configuration", icon="⚙️")
+        st.page_link("pages/03_Training_Monitor.py", label="3️⃣ Training Monitor", icon="📊")
+        st.page_link("pages/04_Evaluation.py", label="4️⃣ Model Evaluation", icon="🔍")
+    
+    st.caption("A simple UI for fine-tuning Gemma models")
+
+# Main content
+st.title("Welcome to Gemma Fine-tuning UI")
+
+if not hf_token:
+    st.info("👈 Please enter your Hugging Face token in the sidebar to get started")
+    
+    with st.expander("ℹ️ How to get a Hugging Face token", expanded=True):
+        st.markdown("""
+        1. Go to [Hugging Face](https://huggingface.co/settings/tokens)
+        2. Sign in or create an account
+        3. Create a new token with write access
+        4. Copy and paste the token in the sidebar
+        """)
+    
+    st.divider()
+    
+    st.subheader("What you can do with this app:")
+    
+    st.markdown("""
+    ### 📝 Simple Fine-tuning Process
+    
+    This app provides a straightforward interface for fine-tuning Gemma models with your own data:
+    """)
+    
+    cols = st.columns(2)
+    
+    with cols[0]:
+        st.markdown("""
+        ✅ **Upload your dataset**
+        - Support for CSV and JSON/JSONL formats
+        - Manual input option for small datasets
+        - Automatic preprocessing for Gemma format
+        
+        ✅ **Configure Gemma model parameters**
+        - Choose between Gemma 2B and 7B models
+        - Adjust learning rate, batch size, and epochs
+        - LoRA parameter configuration
+        """)
+    
+    with cols[1]:
+        st.markdown("""
+        ✅ **Monitor training progress**
+        - Visual training progress tracking
+        - Loss curve visualization
+        - Training logs and status updates
+        
+        ✅ **Evaluate and use your model**
+        - Interactive testing interface
+        - Export options for deployment
+        - Usage examples with code snippets
+        """)
+
+else:
+    st.success("You're all set up! Follow these steps to fine-tune your Gemma model:")
+    
+    # Simple step-by-step guide
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("### Step 1: Prepare Your Dataset")
+        st.markdown("""
+        - Upload your dataset in CSV or JSONL format
+        - Ensure your data has prompt/instruction and response columns
+        - The app will preprocess the data into the right format for Gemma
+        """)
+        st.page_link("pages/01_Dataset_Upload.py", label="Go to Dataset Upload", icon="📤")
+    
+    with col2:
+        st.markdown("### Step 2: Configure Your Model")
+        st.markdown("""
+        - Select either Gemma 2B (faster) or 7B (more powerful)
+        - Adjust hyperparameters based on your needs
+        - Basic configurations work well for most use cases
+        """)
+        st.page_link("pages/02_Model_Configuration.py", label="Go to Model Configuration", icon="⚙️")
+    
+    st.divider()
+    
+    col3, col4 = st.columns(2)
+    
+    with col3:
+        st.markdown("### Step 3: Train Your Model")
+        st.markdown("""
+        - Start the training process
+        - Monitor progress with real-time updates
+        - Training a model may take time depending on your dataset size
+        """)
+        st.page_link("pages/03_Training_Monitor.py", label="Go to Training Monitor", icon="📊")
+    
+    with col4:
+        st.markdown("### Step 4: Evaluate & Use Your Model")
+        st.markdown("""
+        - Test your model with custom prompts
+        - Compare results with the base model
+        - Export your model for use in applications
+        """)
+        st.page_link("pages/04_Evaluation.py", label="Go to Model Evaluation", icon="🔍")
+    
+    # Notes about CPU limitations
+    st.info("""
+    **Note on Training Limitations**: This app is running on CPU resources (2vCPU, 16GB RAM), which means:
+    
+    - For actual training, we use Parameter-Efficient Fine-Tuning (PEFT) with LoRA to reduce memory requirements
+    - Training will be slower than on GPU hardware
+    - For very large datasets, consider using this interface to prepare your data and configuration, 
+      then download the config to run training on more powerful hardware
+    """) 

app.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+# Run the Streamlit app
+streamlit run app.py 

data/sample_dataset.jsonl

@@ -0,0 +1,10 @@
+{"prompt": "Explain the concept of machine learning in simple terms.", "response": "Machine learning is like teaching a computer to learn from examples rather than programming it with specific rules. Imagine showing a child many pictures of cats and dogs until they can recognize the difference. Similarly, we show computers lots of data examples, and they learn patterns to make predictions or decisions without being explicitly programmed for each scenario."}
+{"prompt": "What is fine-tuning in the context of language models?", "response": "Fine-tuning is the process of taking a pre-trained language model and further training it on a specific dataset for a particular task. It's like taking a general-purpose tool and customizing it for a specialized job. The model keeps its general knowledge but becomes better at the specific task you want it to perform, like answering medical questions or writing in a particular style."}
+{"prompt": "How does a neural network work?", "response": "A neural network is a computing system inspired by the human brain. It consists of interconnected nodes (neurons) organized in layers. Each connection has a weight that adjusts as the network learns. The network processes input data through these layers, with each neuron applying a mathematical function to its inputs and passing the result to the next layer. Through a process called backpropagation, the network adjusts its weights based on errors in its output, gradually improving its performance on a task."}
+{"prompt": "Write a short poem about artificial intelligence.", "response": "Silicon dreams in digital streams,\nThinking machines with invisible seams.\nLearning patterns humans can't see,\nArtificial minds, what will they be?\n\nVast knowledge stored in neural webs,\nAnswering questions as curiosity ebbs.\nPartner or servant or something more—\nAI's potential we've yet to explore."}
+{"prompt": "Summarize the concept of transfer learning.", "response": "Transfer learning is a machine learning technique where a model developed for one task is reused as the starting point for a model on a second task. It's like learning to ride a bicycle makes it easier to learn to ride a motorcycle—the skills transfer. In practice, this means taking a pre-trained model (often trained on a large dataset) and fine-tuning it for your specific task with a smaller dataset, saving computational resources and time while achieving good performance."}
+{"prompt": "How would you explain deep learning to a 10-year-old?", "response": "Deep learning is like teaching a computer to learn by itself, similar to how you learn to recognize your friends' faces. Imagine you have a robot that you want to teach to identify dogs. Instead of telling it exactly what a dog looks like (pointy ears, tail, four legs), you show it thousands of pictures of dogs. The robot has layers of simple learning parts, like building blocks stacked together. Each layer learns something different - one might learn edges, another might learn shapes, and so on. After seeing enough pictures, the robot can recognize dogs on its own, even dogs it's never seen before!"}
+{"prompt": "What are the ethical concerns with AI development?", "response": "Ethical concerns in AI development include: 1) Bias and fairness issues when AI systems reflect or amplify human biases in their training data, 2) Privacy concerns as AI systems collect and process vast amounts of personal data, 3) Accountability questions about who is responsible when AI makes harmful decisions, 4) Transparency problems when AI systems function as 'black boxes' with unexplainable decisions, 5) Job displacement as automation changes employment landscapes, and 6) Safety and control concerns about ensuring AI systems remain aligned with human values as they become more capable."}
+{"prompt": "Compare supervised and unsupervised learning.", "response": "Supervised learning is like learning with a teacher. The algorithm is trained on labeled data, where each example has input features and the correct output. It learns to map inputs to outputs based on these examples, like predicting house prices from features like size and location. Unsupervised learning is like learning without a teacher. The algorithm finds patterns in unlabeled data without specific guidance. It might group similar items together (clustering) or find ways to represent data more efficiently. Supervised learning is used for classification and regression tasks, while unsupervised learning is used for clustering, association, and dimensionality reduction."}
+{"prompt": "Explain how language models like Gemma work.", "response": "Language models like Gemma work by predicting the next word in a sequence based on the context of previous words. They're trained on massive text datasets to understand patterns in language. These models use transformer architecture with attention mechanisms that help them focus on relevant parts of the input when making predictions. The model processes text as tokens (pieces of words or characters) and maps these to high-dimensional vector representations that capture semantic meaning. During training, the model adjusts its billions of parameters to minimize prediction errors. When you prompt the model, it uses its learned patterns to generate text that continues your input in a coherent and contextually appropriate way."}
+{"prompt": "What is the difference between AI, machine learning, and deep learning?", "response": "These terms represent nested concepts. Artificial Intelligence (AI) is the broadest, referring to any technique that enables computers to mimic human intelligence. Machine Learning is a subset of AI where systems learn from data without being explicitly programmed, improving automatically through experience. Deep Learning is a specialized subset of machine learning that uses neural networks with many layers (hence 'deep'). Think of it like this: AI is like the entire field of transportation, machine learning is like motorized vehicles specifically, and deep learning is like self-driving cars – a specialized, advanced implementation."} 

packages.txt

@@ -0,0 +1,3 @@
+libgl1-mesa-glx
+gcc
+g++ 

pages/01_Dataset_Upload.py

@@ -0,0 +1,218 @@
+import streamlit as st
+import pandas as pd
+import io
+import json
+import os
+from utils.ui import set_page_style
+from utils.auth import check_hf_token
+from utils.huggingface import create_dataset_repo, upload_dataset_to_hub, preprocess_dataset
+
+# Set page configuration
+st.set_page_config(
+    page_title="Dataset Upload - Gemma Fine-tuning",
+    page_icon="🤖",
+    layout="wide"
+)
+
+# Apply custom styling
+set_page_style()
+
+# Sidebar for authentication
+with st.sidebar:
+    st.title("🤖 Gemma Fine-tuning")
+    st.image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/gemma-banner.png", 
+             use_column_width=True)
+    
+    # Authentication section
+    st.subheader("🔑 Authentication")
+    hf_token = st.text_input("Hugging Face API Token", type="password", 
+                             help="Enter your Hugging Face write token to enable model fine-tuning")
+    auth_status = check_hf_token(hf_token) if hf_token else False
+    
+    if auth_status:
+        st.success("Authenticated successfully!")
+    elif hf_token:
+        st.error("Invalid token. Please check and try again.")
+    
+    st.divider()
+    st.caption("A simple UI for fine-tuning Gemma models")
+
+# Main content
+st.title("📤 Dataset Upload")
+
+if not hf_token or not auth_status:
+    st.warning("Please authenticate with your Hugging Face token in the sidebar first")
+    st.stop()
+
+# Dataset repository settings
+with st.expander("Dataset Repository Settings", expanded=True):
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        dataset_repo_name = st.text_input(
+            "Repository Name",
+            value=f"gemma-finetune-dataset-{pd.Timestamp.now().strftime('%Y%m%d')}",
+            help="Name of the Hugging Face repository to store your dataset"
+        )
+    
+    with col2:
+        is_private = st.toggle("Private Repository", value=True, 
+                               help="Make your dataset repository private (recommended)")
+
+# Dataset upload section
+st.header("Upload Your Dataset")
+
+dataset_format = st.radio(
+    "Select dataset format",
+    options=["CSV", "JSON/JSONL", "Manual Input"],
+    horizontal=True
+)
+
+# Session state to store dataset
+if "dataset" not in st.session_state:
+    st.session_state.dataset = None
+if "dataset_preview" not in st.session_state:
+    st.session_state.dataset_preview = None
+
+# Upload handlers
+if dataset_format == "CSV":
+    uploaded_file = st.file_uploader("Upload a CSV file", type=["csv"])
+    
+    if uploaded_file:
+        try:
+            # Read the file
+            df = pd.read_csv(uploaded_file)
+            st.session_state.dataset = df
+            st.session_state.dataset_preview = df.head(5)
+        except Exception as e:
+            st.error(f"Error reading CSV file: {str(e)}")
+
+elif dataset_format == "JSON/JSONL":
+    uploaded_file = st.file_uploader("Upload a JSON/JSONL file", type=["json", "jsonl"])
+    
+    if uploaded_file:
+        try:
+            # Read file contents
+            content = uploaded_file.read()
+            
+            # Try to parse as JSON array first
+            try:
+                data = json.loads(content)
+                if isinstance(data, list):
+                    df = pd.DataFrame(data)
+                else:
+                    df = pd.DataFrame([data])
+            except:
+                # Try to parse as JSONL
+                try:
+                    content = io.StringIO(content.decode("utf-8"))
+                    df = pd.read_json(content, lines=True)
+                except:
+                    raise ValueError("Invalid JSON/JSONL format")
+            
+            st.session_state.dataset = df
+            st.session_state.dataset_preview = df.head(5)
+        except Exception as e:
+            st.error(f"Error reading JSON/JSONL file: {str(e)}")
+
+elif dataset_format == "Manual Input":
+    st.info("Enter your training examples manually:")
+    
+    num_examples = st.number_input("Number of examples", min_value=1, max_value=20, value=3)
+    examples = []
+    
+    for i in range(num_examples):
+        st.subheader(f"Example {i+1}")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            prompt = st.text_area(f"Prompt/Instruction {i+1}", height=100)
+        
+        with col2:
+            response = st.text_area(f"Response {i+1}", height=100)
+        
+        if prompt and response:
+            examples.append({"prompt": prompt, "response": response})
+    
+    if examples:
+        df = pd.DataFrame(examples)
+        st.session_state.dataset = df
+        st.session_state.dataset_preview = df
+
+# Display dataset preview if available
+if st.session_state.dataset_preview is not None:
+    st.subheader("Dataset Preview")
+    st.dataframe(st.session_state.dataset_preview, use_container_width=True)
+    
+    # Column mapping
+    st.subheader("Column Mapping")
+    st.info("Select which columns contain prompts/instructions and responses")
+    
+    columns = st.session_state.dataset.columns.tolist()
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        prompt_column = st.selectbox("Prompt/Instruction Column", options=columns, 
+                                    index=columns.index("prompt") if "prompt" in columns else 0)
+    
+    with col2:
+        response_column = st.selectbox("Response Column", options=columns,
+                                      index=columns.index("response") if "response" in columns else min(1, len(columns)-1))
+    
+    # Dataset statistics
+    st.subheader("Dataset Statistics")
+    
+    stats_col1, stats_col2, stats_col3 = st.columns(3)
+    
+    with stats_col1:
+        st.metric("Total Examples", len(st.session_state.dataset))
+    
+    with stats_col2:
+        avg_prompt_len = st.session_state.dataset[prompt_column].str.len().mean().round(1)
+        st.metric("Avg. Prompt Length", f"{avg_prompt_len} chars")
+    
+    with stats_col3:
+        avg_response_len = st.session_state.dataset[response_column].str.len().mean().round(1)
+        st.metric("Avg. Response Length", f"{avg_response_len} chars")
+    
+    # Upload button
+    st.subheader("Upload to Hugging Face")
+    
+    if st.button("Process and Upload Dataset", type="primary"):
+        with st.spinner("Processing dataset..."):
+            # Preprocess the dataset into the right format for Gemma
+            try:
+                processed_df = preprocess_dataset(
+                    st.session_state.dataset, 
+                    prompt_column=prompt_column,
+                    response_column=response_column
+                )
+                
+                # Create repository
+                success, result = create_dataset_repo(dataset_repo_name, private=is_private)
+                
+                if not success:
+                    st.error(f"Failed to create repository: {result}")
+                else:
+                    st.success(f"Created repository: {dataset_repo_name}")
+                    
+                    # Upload dataset
+                    success, result = upload_dataset_to_hub(
+                        processed_df, 
+                        "train.jsonl", 
+                        dataset_repo_name
+                    )
+                    
+                    if success:
+                        st.session_state["dataset_repo"] = dataset_repo_name
+                        st.success(f"Dataset uploaded successfully! You can now proceed to model configuration.")
+                        
+                        # Next steps button
+                        st.page_link("pages/02_Model_Configuration.py", label="Next: Configure Model", icon="⚙️")
+                    else:
+                        st.error(f"Failed to upload dataset: {result}")
+            except Exception as e:
+                st.error(f"Error processing dataset: {str(e)}")
+else:
+    st.info("Please upload or input your dataset above") 

pages/02_Model_Configuration.py

@@ -0,0 +1,208 @@
+import streamlit as st
+import pandas as pd
+from utils.ui import set_page_style
+from utils.auth import check_hf_token
+from utils.huggingface import prepare_training_config
+from utils.training import create_model_repo, upload_training_config, setup_training_script
+
+# Set page configuration
+st.set_page_config(
+    page_title="Model Configuration - Gemma Fine-tuning",
+    page_icon="🤖",
+    layout="wide"
+)
+
+# Apply custom styling
+set_page_style()
+
+# Sidebar for authentication
+with st.sidebar:
+    st.title("🤖 Gemma Fine-tuning")
+    st.image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/gemma-banner.png", 
+             use_column_width=True)
+    
+    # Authentication section
+    st.subheader("🔑 Authentication")
+    hf_token = st.text_input("Hugging Face API Token", type="password", 
+                             help="Enter your Hugging Face write token to enable model fine-tuning")
+    auth_status = check_hf_token(hf_token) if hf_token else False
+    
+    if auth_status:
+        st.success("Authenticated successfully!")
+    elif hf_token:
+        st.error("Invalid token. Please check and try again.")
+    
+    st.divider()
+    st.caption("A simple UI for fine-tuning Gemma models")
+
+# Main content
+st.title("⚙️ Model Configuration")
+
+if not hf_token or not auth_status:
+    st.warning("Please authenticate with your Hugging Face token in the sidebar first")
+    st.stop()
+
+# Check if dataset repository is set
+if "dataset_repo" not in st.session_state:
+    st.warning("Please upload a dataset first")
+    st.page_link("pages/01_Dataset_Upload.py", label="Go to Dataset Upload", icon="📤")
+    
+    # For testing purposes, allow manual entry
+    manual_repo = st.text_input("Or enter dataset repository name manually:")
+    if manual_repo:
+        st.session_state["dataset_repo"] = manual_repo
+    else:
+        st.stop()
+
+# Model configuration
+st.header("1. Select Gemma Model")
+
+model_version = st.radio(
+    "Select Gemma model version",
+    options=["google/gemma-2b", "google/gemma-7b"],
+    horizontal=True,
+    help="Choose the Gemma model size. 2B is faster, 7B is more capable."
+)
+
+st.header("2. Training Configuration")
+
+# Output repository settings
+with st.expander("Output Repository Settings", expanded=True):
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        output_repo_name = st.text_input(
+            "Repository Name",
+            value=f"gemma-finetuned-{pd.Timestamp.now().strftime('%Y%m%d')}",
+            help="Name of the Hugging Face repository to store your fine-tuned model"
+        )
+    
+    with col2:
+        is_private = st.toggle("Private Repository", value=True, 
+                               help="Make your model repository private (recommended)")
+
+# Tabs for Basic and Advanced configuration
+basic_tab, advanced_tab = st.tabs(["Basic Configuration", "Advanced Configuration"])
+
+with basic_tab:
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        epochs = st.slider("Number of Epochs", min_value=1, max_value=10, value=3, 
+                          help="Number of complete passes through the dataset")
+        
+        batch_size = st.slider("Batch Size", min_value=1, max_value=32, value=8,
+                             help="Number of examples processed together")
+    
+    with col2:
+        learning_rate = st.number_input("Learning Rate", min_value=1e-6, max_value=1e-3, 
+                                       value=2e-5, format="%.1e",
+                                       help="Step size for gradient updates")
+        
+        fp16_training = st.toggle("Use FP16 Training", value=True,
+                                help="Use 16-bit precision for faster training")
+
+with advanced_tab:
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        lora_rank = st.slider("LoRA Rank", min_value=1, max_value=64, value=8, 
+                            help="Rank of the LoRA matrices")
+        
+        lora_alpha = st.slider("LoRA Alpha", min_value=1, max_value=128, value=32,
+                             help="Scaling factor for LoRA")
+        
+        lora_dropout = st.slider("LoRA Dropout", min_value=0.0, max_value=0.5, value=0.05, step=0.01,
+                               help="Dropout probability for LoRA layers")
+    
+    with col2:
+        weight_decay = st.number_input("Weight Decay", min_value=0.0, max_value=0.1, 
+                                      value=0.01, step=0.001,
+                                      help="L2 regularization strength")
+        
+        gradient_accumulation = st.slider("Gradient Accumulation Steps", min_value=1, max_value=16, value=1,
+                                        help="Number of steps to accumulate gradients")
+        
+        warmup_steps = st.slider("Warmup Steps", min_value=0, max_value=500, value=0,
+                               help="Steps of linear learning rate warmup")
+
+st.header("3. Training Summary")
+
+# Create hyperparameters dictionary
+hyperparams = {
+    "epochs": epochs,
+    "batch_size": batch_size,
+    "learning_rate": learning_rate,
+    "fp16": fp16_training,
+    "lora_rank": lora_rank,
+    "lora_alpha": lora_alpha,
+    "lora_dropout": lora_dropout,
+    "weight_decay": weight_decay,
+    "gradient_accumulation": gradient_accumulation,
+    "warmup_steps": warmup_steps,
+    "max_steps": -1,  # -1 means train for full epochs
+    "max_grad_norm": 1.0
+}
+
+# Display summary
+col1, col2 = st.columns(2)
+
+with col1:
+    st.subheader("Selected Model")
+    st.info(model_version)
+    
+    st.subheader("Dataset Repository")
+    st.info(st.session_state["dataset_repo"])
+
+with col2:
+    st.subheader("Key Hyperparameters")
+    st.write(f"Epochs: {epochs}")
+    st.write(f"Batch Size: {batch_size}")
+    st.write(f"Learning Rate: {learning_rate}")
+    st.write(f"LoRA Rank: {lora_rank}")
+
+# Start training button
+st.header("4. Start Training")
+
+if st.button("Prepare and Launch Training", type="primary"):
+    with st.spinner("Setting up training job..."):
+        # First create the model repository
+        success, repo_url = create_model_repo(output_repo_name, private=is_private)
+        
+        if not success:
+            st.error(f"Failed to create model repository: {repo_url}")
+        else:
+            st.success(f"Created model repository: {output_repo_name}")
+            
+            # Prepare training configuration
+            config = prepare_training_config(
+                model_name=model_version,
+                hyperparams=hyperparams,
+                dataset_repo=st.session_state["dataset_repo"],
+                output_repo=output_repo_name
+            )
+            
+            # Upload training configuration
+            success, message = upload_training_config(config, output_repo_name)
+            
+            if not success:
+                st.error(f"Failed to upload training configuration: {message}")
+            else:
+                st.success("Uploaded training configuration")
+                
+                # Setup training script
+                success, message = setup_training_script(output_repo_name, config)
+                
+                if not success:
+                    st.error(f"Failed to setup training script: {message}")
+                else:
+                    st.success("Uploaded training script")
+                    
+                    # Store in session state
+                    st.session_state["model_repo"] = output_repo_name
+                    st.session_state["model_version"] = model_version
+                    st.session_state["hyperparams"] = hyperparams
+                    
+                    # Success message and next step
+                    st.success("Training job prepared successfully! You can now monitor the training progress.")
+                    st.page_link("pages/03_Training_Monitor.py", label="Next: Monitor Training", icon="📊") 

pages/03_Training_Monitor.py

@@ -0,0 +1,218 @@
+import streamlit as st
+import time
+import json
+import pandas as pd
+import matplotlib.pyplot as plt
+import plotly.graph_objects as go
+from utils.ui import set_page_style, display_metric
+from utils.auth import check_hf_token
+from utils.training import simulate_training_progress
+
+# Set page configuration
+st.set_page_config(
+    page_title="Training Monitor - Gemma Fine-tuning",
+    page_icon="🤖",
+    layout="wide"
+)
+
+# Apply custom styling
+set_page_style()
+
+# Sidebar for authentication
+with st.sidebar:
+    st.title("🤖 Gemma Fine-tuning")
+    st.image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/gemma-banner.png", 
+             use_column_width=True)
+    
+    # Authentication section
+    st.subheader("🔑 Authentication")
+    hf_token = st.text_input("Hugging Face API Token", type="password", 
+                             help="Enter your Hugging Face write token to enable model fine-tuning")
+    auth_status = check_hf_token(hf_token) if hf_token else False
+    
+    if auth_status:
+        st.success("Authenticated successfully!")
+    elif hf_token:
+        st.error("Invalid token. Please check and try again.")
+    
+    st.divider()
+    st.caption("A simple UI for fine-tuning Gemma models")
+
+# Main content
+st.title("📊 Training Monitor")
+
+if not hf_token or not auth_status:
+    st.warning("Please authenticate with your Hugging Face token in the sidebar first")
+    st.stop()
+
+# Check if training was started
+if "model_repo" not in st.session_state:
+    st.warning("No active training jobs found")
+    st.page_link("pages/02_Model_Configuration.py", label="Go to Model Configuration", icon="⚙️")
+    
+    # For testing purposes, allow manual entry
+    manual_repo = st.text_input("Or enter model repository name manually:")
+    if manual_repo:
+        st.session_state["model_repo"] = manual_repo
+        st.session_state["model_version"] = "google/gemma-2b"  # Default
+    else:
+        st.stop()
+
+# Training information
+st.header("Training Information")
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.subheader("Model Repository")
+    st.info(st.session_state["model_repo"])
+    
+    st.subheader("Base Model")
+    st.info(st.session_state.get("model_version", "google/gemma-2b"))
+
+with col2:
+    # For demo purposes, create a button to start simulated training
+    if "training_started" not in st.session_state:
+        st.subheader("Start Training")
+        if st.button("Launch Training Job", type="primary"):
+            st.session_state["training_started"] = True
+            st.experimental_rerun()
+    else:
+        st.subheader("Status")
+        st.success("Training in Progress")
+        
+        # Simulate a cancel button
+        if st.button("Cancel Training Job", type="secondary"):
+            st.warning("This is a simulation - in a real environment, this would cancel the training job")
+
+# If training has started, show the progress
+if st.session_state.get("training_started", False):
+    st.header("Training Progress")
+    
+    # Create a placeholder for the progress bar
+    progress_bar = st.progress(0)
+    
+    # Create placeholder metrics
+    col1, col2, col3, col4 = st.columns(4)
+    
+    # Get training progress (simulated for demo)
+    progress_data = simulate_training_progress()
+    
+    # Update progress bar
+    progress_bar.progress(progress_data["progress"])
+    
+    # Update metrics
+    with col1:
+        display_metric("Epoch", f"{progress_data['current_epoch'] + 1}/{progress_data['total_epochs']}")
+    
+    with col2:
+        display_metric("Loss", f"{progress_data['loss']:.4f}")
+    
+    with col3:
+        display_metric("Learning Rate", f"{progress_data['learning_rate']:.1e}")
+    
+    with col4:
+        status_text = "Complete" if progress_data["status"] == "completed" else "Running"
+        display_metric("Status", status_text)
+    
+    # Create training history visualization
+    st.subheader("Training Metrics")
+    
+    # Simulate training history data
+    if "training_history" not in st.session_state:
+        st.session_state.training_history = []
+    
+    # Add current data point to history if not completed
+    if progress_data["status"] != "completed" or len(st.session_state.training_history) == 0:
+        st.session_state.training_history.append({
+            "epoch": progress_data["current_epoch"],
+            "loss": progress_data["loss"],
+            "learning_rate": progress_data["learning_rate"],
+            "timestamp": time.time()
+        })
+    
+    # Convert history to DataFrame
+    history_df = pd.DataFrame(st.session_state.training_history)
+    
+    if not history_df.empty and len(history_df) > 1:
+        # Create tabs for different visualizations
+        loss_tab, lr_tab = st.tabs(["Loss Curve", "Learning Rate"])
+        
+        with loss_tab:
+            # Create a Plotly figure for the loss curve
+            fig = go.Figure()
+            fig.add_trace(go.Scatter(
+                x=history_df["epoch"], 
+                y=history_df["loss"],
+                mode='lines+markers',
+                name='Training Loss',
+                line=dict(color='#FF4B4B', width=3)
+            ))
+            
+            fig.update_layout(
+                title="Training Loss Over Time",
+                xaxis_title="Epoch",
+                yaxis_title="Loss",
+                template="plotly_white",
+                height=400
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with lr_tab:
+            # Create a Plotly figure for the learning rate
+            fig = go.Figure()
+            fig.add_trace(go.Scatter(
+                x=history_df["epoch"], 
+                y=history_df["learning_rate"],
+                mode='lines+markers',
+                name='Learning Rate',
+                line=dict(color='#0068C9', width=3)
+            ))
+            
+            fig.update_layout(
+                title="Learning Rate Schedule",
+                xaxis_title="Epoch",
+                yaxis_title="Learning Rate",
+                template="plotly_white",
+                height=400
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+    else:
+        st.info("Training metrics will appear here once training progresses")
+    
+    # Training logs
+    st.subheader("Training Logs")
+    
+    # Simulate logs
+    log_lines = [
+        f"[{pd.Timestamp.now().strftime('%Y-%m-%d %H:%M:%S')}] Initialized training job",
+        f"[{pd.Timestamp.now().strftime('%Y-%m-%d %H:%M:%S')}] Loading model: {st.session_state.get('model_version', 'google/gemma-2b')}",
+        f"[{pd.Timestamp.now().strftime('%Y-%m-%d %H:%M:%S')}] Preparing LoRA configuration"
+    ]
+    
+    # Add epoch logs based on progress
+    current_epoch = progress_data["current_epoch"]
+    for epoch in range(min(current_epoch + 1, progress_data["total_epochs"])):
+        timestamp = pd.Timestamp.now() - pd.Timedelta(seconds=(current_epoch - epoch) * 60)
+        log_lines.append(f"[{timestamp.strftime('%Y-%m-%d %H:%M:%S')}] Epoch {epoch+1}/{progress_data['total_epochs']} started")
+        
+        if epoch < current_epoch:
+            # For completed epochs, add completion log
+            timestamp = pd.Timestamp.now() - pd.Timedelta(seconds=(current_epoch - epoch - 0.5) * 60)
+            sim_loss = max(2.5 - (epoch * 0.5), 0.5)
+            log_lines.append(f"[{timestamp.strftime('%Y-%m-%d %H:%M:%S')}] Epoch {epoch+1} completed: loss={sim_loss:.4f}")
+    
+    # Display logs in a scrollable area
+    st.code("\n".join(log_lines))
+    
+    # Next steps (only show when training is complete)
+    if progress_data["status"] == "completed":
+        st.success("Training completed successfully!")
+        st.page_link("pages/04_Evaluation.py", label="Next: Evaluate Model", icon="🔍")
+    else:
+        # Auto-refresh for monitoring
+        st.empty()
+        time.sleep(2)  # Wait for 2 seconds
+        st.experimental_rerun() 

pages/04_Evaluation.py

@@ -0,0 +1,246 @@
+import streamlit as st
+import pandas as pd
+import time
+import json
+from utils.ui import set_page_style, create_card
+from utils.auth import check_hf_token
+
+# Set page configuration
+st.set_page_config(
+    page_title="Model Evaluation - Gemma Fine-tuning",
+    page_icon="🤖",
+    layout="wide"
+)
+
+# Apply custom styling
+set_page_style()
+
+# Sidebar for authentication
+with st.sidebar:
+    st.title("🤖 Gemma Fine-tuning")
+    st.image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/gemma-banner.png", 
+             use_column_width=True)
+    
+    # Authentication section
+    st.subheader("🔑 Authentication")
+    hf_token = st.text_input("Hugging Face API Token", type="password", 
+                             help="Enter your Hugging Face write token to enable model fine-tuning")
+    auth_status = check_hf_token(hf_token) if hf_token else False
+    
+    if auth_status:
+        st.success("Authenticated successfully!")
+    elif hf_token:
+        st.error("Invalid token. Please check and try again.")
+    
+    st.divider()
+    st.caption("A simple UI for fine-tuning Gemma models")
+
+# Main content
+st.title("🔍 Model Evaluation")
+
+if not hf_token or not auth_status:
+    st.warning("Please authenticate with your Hugging Face token in the sidebar first")
+    st.stop()
+
+# Check if model is trained
+if "model_repo" not in st.session_state:
+    st.warning("No trained model found")
+    st.page_link("pages/03_Training_Monitor.py", label="Go to Training Monitor", icon="📊")
+    
+    # For testing purposes, allow manual entry
+    manual_repo = st.text_input("Or enter model repository name manually:")
+    if manual_repo:
+        st.session_state["model_repo"] = manual_repo
+        st.session_state["model_version"] = "google/gemma-2b"  # Default
+    else:
+        st.stop()
+
+# Model information
+st.header("Model Information")
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.subheader("Fine-tuned Model")
+    username = st.session_state.get("hf_username", "user")
+    model_id = f"{username}/{st.session_state['model_repo']}"
+    st.info(model_id)
+    
+    st.markdown(f"[View on Hugging Face 🔗](https://huggingface.co/{model_id})")
+
+with col2:
+    st.subheader("Base Model")
+    st.info(st.session_state.get("model_version", "google/gemma-2b"))
+
+# Interactive testing
+st.header("Interactive Testing")
+
+def generate_response(prompt, max_length=100, temperature=0.7):
+    """Simulate generating a response from the fine-tuned model"""
+    # In a real implementation, this would call the model API
+    
+    # For demo purposes, simulate a response with a delay
+    with st.spinner("Generating response..."):
+        # Simulate thinking time
+        time.sleep(2)
+        
+        # Generate a simple response based on the prompt for demonstration
+        if "hello" in prompt.lower() or "hi" in prompt.lower():
+            return "Hello! How can I assist you today?"
+        elif "name" in prompt.lower():
+            return "I'm a fine-tuned version of Gemma, created to assist you!"
+        elif "weather" in prompt.lower():
+            return "I don't have real-time data access, but I can tell you about weather patterns and climate information if you'd like."
+        elif "help" in prompt.lower():
+            return "I'm here to help answer questions, provide information, or assist with tasks. Just let me know what you need!"
+        elif len(prompt) < 10:
+            return "Could you please provide more details so I can give you a better response?"
+        else:
+            return f"Based on your request about '{prompt[:20]}...', I've analyzed the content and formulated this response. This is a demonstration of how the fine-tuned model would respond to your input, tailored to the data it was trained on."
+
+# Create the interface
+with st.expander("Generation Settings", expanded=False):
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        max_length = st.slider("Maximum Length", min_value=10, max_value=500, value=150,
+                             help="Maximum number of tokens to generate")
+    
+    with col2:
+        temperature = st.slider("Temperature", min_value=0.1, max_value=1.0, value=0.7, step=0.1,
+                              help="Controls randomness: 1.0 is creative, 0.1 is more deterministic")
+
+prompt = st.text_area("Enter your prompt:", height=150, 
+                     help="Enter a prompt or instruction for the model to respond to")
+
+if st.button("Generate Response", type="primary"):
+    if prompt:
+        response = generate_response(prompt, max_length, temperature)
+        
+        # Store in history
+        if "conversation_history" not in st.session_state:
+            st.session_state.conversation_history = []
+        
+        st.session_state.conversation_history.append({
+            "prompt": prompt,
+            "response": response,
+            "timestamp": pd.Timestamp.now().isoformat()
+        })
+        
+        # Display response
+        st.subheader("Model Response")
+        st.markdown(f"<div style='background-color: #f8f9fa; padding: 15px; border-radius: 8px;'>{response}</div>", unsafe_allow_html=True)
+    else:
+        st.warning("Please enter a prompt first")
+
+# Display conversation history
+if "conversation_history" in st.session_state and st.session_state.conversation_history:
+    st.header("Conversation History")
+    
+    for i, item in enumerate(reversed(st.session_state.conversation_history)):
+        with st.container():
+            st.markdown(f"### Conversation {len(st.session_state.conversation_history) - i}")
+            
+            st.markdown("**Prompt:**")
+            st.markdown(f"<div style='background-color: #e6f7ff; padding: 10px; border-radius: 8px;'>{item['prompt']}</div>", unsafe_allow_html=True)
+            
+            st.markdown("**Response:**")
+            st.markdown(f"<div style='background-color: #f8f9fa; padding: 10px; border-radius: 8px;'>{item['response']}</div>", unsafe_allow_html=True)
+            
+            st.caption(f"Generated at: {pd.Timestamp(item['timestamp']).strftime('%Y-%m-%d %H:%M:%S')}")
+            st.divider()
+
+# Export section
+st.header("Export Model")
+
+export_tab1, export_tab2 = st.tabs(["Export Options", "Usage Guide"])
+
+with export_tab1:
+    st.subheader("Export Configuration")
+    
+    export_format = st.radio("Export Format", options=["Hugging Face Hub", "ONNX", "TensorFlow Lite", "PyTorch"], 
+                           horizontal=True)
+    
+    if export_format == "Hugging Face Hub":
+        st.success("Your model is already available on the Hugging Face Hub!")
+        username = st.session_state.get("hf_username", "user")
+        model_id = f"{username}/{st.session_state['model_repo']}"
+        st.code(f"from transformers import AutoModelForCausalLM, AutoTokenizer\n\nmodel = AutoModelForCausalLM.from_pretrained('{model_id}')\ntokenizer = AutoTokenizer.from_pretrained('{model_id}')")
+    else:
+        st.info("This export format is under development and will be available soon.")
+        
+        # Show a sample of how to export
+        if export_format == "ONNX":
+            st.code("""
+# Example code for ONNX export (not functional in this demo)
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers.onnx import export
+
+model_id = "your_username/your_model_repo"
+model = AutoModelForCausalLM.from_pretrained(model_id)
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+# Export to ONNX
+export(
+    tokenizer=tokenizer,
+    model=model,
+    output=Path("model.onnx"),
+    opset=13
+)
+            """)
+        elif export_format == "PyTorch":
+            st.code("""
+# Example code for PyTorch export (not functional in this demo)
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model_id = "your_username/your_model_repo"
+model = AutoModelForCausalLM.from_pretrained(model_id)
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+# Save model locally
+model.save_pretrained("./my_exported_model")
+tokenizer.save_pretrained("./my_exported_model")
+            """)
+
+with export_tab2:
+    st.subheader("How to Use Your Model")
+    
+    st.markdown("""
+    ### Using with Hugging Face Transformers
+
+    ```python
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+    
+    # Replace with your model ID
+    model_id = "your_username/your_model_repo"
+    
+    # Load model and tokenizer
+    model = AutoModelForCausalLM.from_pretrained(model_id)
+    tokenizer = AutoTokenizer.from_pretrained(model_id)
+    
+    # Generate text
+    inputs = tokenizer("What is machine learning?", return_tensors="pt")
+    outputs = model.generate(**inputs, max_length=100)
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    print(response)
+    ```
+    
+    ### Deployment Options
+    
+    1. **Hugging Face Inference API** - Easiest option for quick deployment
+    2. **Gradio or Streamlit** - For creating interactive demos
+    3. **FastAPI or Flask** - For creating backend API services
+    4. **Mobile Deployment** - Use TensorFlow Lite or ONNX formats
+    """)
+
+# Next steps
+st.divider()
+st.subheader("Continue Your Journey")
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.page_link("pages/01_Dataset_Upload.py", label="Start New Project", icon="🔄")
+
+with col2:
+    st.write("Finished? Export your model or try it out in the playground above.") 

requirements.txt

@@ -0,0 +1,15 @@
+streamlit>=1.30.0
+huggingface_hub>=0.20.0
+pandas>=2.0.0
+matplotlib>=3.7.0
+transformers>=4.35.0
+peft>=0.7.0
+torch>=2.0.0
+bitsandbytes>=0.40.0
+accelerate>=0.20.0
+datasets>=2.10.0
+tensorboard>=2.13.0
+plotly>=5.15.0
+pillow>=10.0.0
+watchdog>=3.0.0
+scipy>=1.10.0 

utils/auth.py

@@ -0,0 +1,50 @@
+import streamlit as st
+import os
+from huggingface_hub import HfApi, login
+
+def check_hf_token(token):
+    """
+    Validate Hugging Face token and login if valid
+    
+    Args:
+        token (str): Hugging Face API token
+        
+    Returns:
+        bool: True if token is valid, False otherwise
+    """
+    try:
+        # Set token in environment and session state
+        os.environ["HF_TOKEN"] = token
+        st.session_state["hf_token"] = token
+        
+        # Try to log in
+        login(token=token, add_to_git_credential=False)
+        
+        # Test API access
+        api = HfApi(token=token)
+        user_info = api.whoami()
+        
+        # Store username in session state
+        st.session_state["hf_username"] = user_info["name"] if "name" in user_info else None
+        
+        return True
+    except Exception as e:
+        st.session_state["hf_token"] = None
+        st.session_state["hf_username"] = None
+        print(f"Authentication error: {str(e)}")
+        return False
+
+def get_current_user():
+    """
+    Get the currently authenticated user's information
+    
+    Returns:
+        dict: User information or None if not authenticated
+    """
+    if "hf_token" in st.session_state and st.session_state["hf_token"]:
+        try:
+            api = HfApi(token=st.session_state["hf_token"])
+            return api.whoami()
+        except:
+            return None
+    return None 

utils/huggingface.py

@@ -0,0 +1,152 @@
+import os
+import json
+import tempfile
+import pandas as pd
+import streamlit as st
+from huggingface_hub import HfApi, upload_file, create_repo
+from transformers import AutoTokenizer
+
+def create_dataset_repo(repo_name, private=True):
+    """
+    Create a new dataset repository on Hugging Face Hub
+    
+    Args:
+        repo_name (str): Name of the repository
+        private (bool): Whether the repository should be private
+        
+    Returns:
+        str: URL of the created repository
+    """
+    try:
+        token = st.session_state.get("hf_token")
+        if not token:
+            return False, "No Hugging Face token found"
+        
+        username = st.session_state.get("hf_username", "user")
+        full_repo_name = f"{username}/{repo_name}"
+        
+        api = HfApi(token=token)
+        repo_url = api.create_repo(
+            repo_id=full_repo_name,
+            repo_type="dataset",
+            private=private,
+            exist_ok=True
+        )
+        
+        return True, repo_url
+    except Exception as e:
+        return False, str(e)
+
+def upload_dataset_to_hub(file_data, file_name, repo_name):
+    """
+    Upload a dataset file to Hugging Face Hub
+    
+    Args:
+        file_data (bytes/DataFrame): File content as bytes or a DataFrame
+        file_name (str): Name to save the file as
+        repo_name (str): Repository to upload to
+        
+    Returns:
+        tuple: (success (bool), message (str))
+    """
+    try:
+        token = st.session_state.get("hf_token")
+        if not token:
+            return False, "No Hugging Face token found"
+            
+        username = st.session_state.get("hf_username", "user")
+        repo_id = f"{username}/{repo_name}"
+        
+        with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file_name)[1]) as tmp:
+            # If it's a DataFrame, save as JSONL
+            if isinstance(file_data, pd.DataFrame):
+                file_data.to_json(tmp.name, orient="records", lines=True)
+            else:
+                # Otherwise, assume it's bytes
+                tmp.write(file_data)
+                
+            # Upload file to repository
+            upload_file(
+                path_or_fileobj=tmp.name,
+                path_in_repo=file_name,
+                repo_id=repo_id,
+                token=token,
+                repo_type="dataset"
+            )
+            
+            # Clean up temporary file
+            tmp_name = tmp.name
+        
+        os.unlink(tmp_name)
+        return True, f"File uploaded to {repo_id}"
+    except Exception as e:
+        return False, str(e)
+
+def prepare_training_config(model_name, hyperparams, dataset_repo, output_repo):
+    """
+    Prepare a training configuration for Gemma fine-tuning
+    
+    Args:
+        model_name (str): Model identifier
+        hyperparams (dict): Training hyperparameters
+        dataset_repo (str): Dataset repository name
+        output_repo (str): Output repository name
+        
+    Returns:
+        dict: Training configuration
+    """
+    username = st.session_state.get("hf_username", "user")
+    
+    config = {
+        "model_name_or_path": model_name,
+        "dataset_name": f"{username}/{dataset_repo}",
+        "output_dir": f"{username}/{output_repo}",
+        "num_train_epochs": hyperparams.get("epochs", 3),
+        "per_device_train_batch_size": hyperparams.get("batch_size", 8),
+        "learning_rate": hyperparams.get("learning_rate", 2e-5),
+        "weight_decay": hyperparams.get("weight_decay", 0.01),
+        "save_strategy": "epoch",
+        "evaluation_strategy": "epoch",
+        "fp16": hyperparams.get("fp16", False),
+        "peft_config": {
+            "r": hyperparams.get("lora_rank", 8),
+            "lora_alpha": hyperparams.get("lora_alpha", 32),
+            "lora_dropout": hyperparams.get("lora_dropout", 0.05),
+            "bias": "none",
+            "task_type": "CAUSAL_LM"
+        },
+        "optim": "adamw_torch",
+        "logging_steps": 50,
+        "gradient_accumulation_steps": hyperparams.get("gradient_accumulation", 1),
+        "max_steps": hyperparams.get("max_steps", -1),
+        "warmup_steps": hyperparams.get("warmup_steps", 0),
+        "max_grad_norm": hyperparams.get("max_grad_norm", 1.0),
+    }
+    
+    return config
+
+def preprocess_dataset(df, prompt_column, response_column, model_name="google/gemma-2b"):
+    """
+    Preprocess a dataset for Gemma fine-tuning
+    
+    Args:
+        df (DataFrame): Dataset
+        prompt_column (str): Column containing prompts/instructions
+        response_column (str): Column containing responses
+        model_name (str): Model identifier for tokenizer
+        
+    Returns:
+        DataFrame: Processed dataset
+    """
+    # Check if columns exist
+    if prompt_column not in df.columns or response_column not in df.columns:
+        raise ValueError(f"Columns {prompt_column} and/or {response_column} not found in dataset")
+    
+    # Simple format for instruction tuning
+    df["text"] = df.apply(
+        lambda row: f"<start_of_turn>user\n{row[prompt_column]}<end_of_turn>\n<start_of_turn>model\n{row[response_column]}<end_of_turn>", 
+        axis=1
+    )
+    
+    # Return the processed dataset
+    return df[["text"]] 

utils/training.py

@@ -0,0 +1,347 @@
+import os
+import json
+import time
+import pandas as pd
+import streamlit as st
+from huggingface_hub import HfApi, create_repo, upload_file
+import tempfile
+
+def create_model_repo(repo_name, private=True):
+    """
+    Create a new model repository on Hugging Face Hub
+    
+    Args:
+        repo_name (str): Name of the repository
+        private (bool): Whether the repository should be private
+        
+    Returns:
+        tuple: (success (bool), message (str))
+    """
+    try:
+        token = st.session_state.get("hf_token")
+        if not token:
+            return False, "No Hugging Face token found"
+        
+        username = st.session_state.get("hf_username", "user")
+        full_repo_name = f"{username}/{repo_name}"
+        
+        api = HfApi(token=token)
+        repo_url = api.create_repo(
+            repo_id=full_repo_name,
+            private=private,
+            exist_ok=True
+        )
+        
+        return True, repo_url
+    except Exception as e:
+        return False, str(e)
+
+def upload_training_config(config, repo_name):
+    """
+    Upload a training configuration file to Hugging Face Hub
+    
+    Args:
+        config (dict): Training configuration
+        repo_name (str): Repository to upload to
+        
+    Returns:
+        tuple: (success (bool), message (str))
+    """
+    try:
+        token = st.session_state.get("hf_token")
+        if not token:
+            return False, "No Hugging Face token found"
+            
+        username = st.session_state.get("hf_username", "user")
+        repo_id = f"{username}/{repo_name}"
+        
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.json') as tmp:
+            with open(tmp.name, 'w') as f:
+                json.dump(config, f, indent=2)
+                
+            # Upload file to repository
+            upload_file(
+                path_or_fileobj=tmp.name,
+                path_in_repo="training_config.json",
+                repo_id=repo_id,
+                token=token
+            )
+            
+            # Clean up temporary file
+            tmp_name = tmp.name
+        
+        os.unlink(tmp_name)
+        return True, f"Training config uploaded to {repo_id}"
+    except Exception as e:
+        return False, str(e)
+
+def setup_training_script(repo_name, config):
+    """
+    Generate and upload a training script to the repository
+    
+    Args:
+        repo_name (str): Repository name
+        config (dict): Training configuration
+        
+    Returns:
+        tuple: (success (bool), message (str))
+    """
+    # Create a training script using transformers Trainer with 4-bit quantization for CPU
+    script = """
+from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer, DataCollatorForLanguageModeling
+from datasets import load_dataset
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training, PeftModel
+import json
+import os
+import torch
+from huggingface_hub import login
+import bitsandbytes as bnb
+
+# Load configuration
+with open("training_config.json", "r") as f:
+    config = json.load(f)
+
+# Login to Hugging Face
+login(token=os.environ.get("HF_TOKEN"))
+
+# Load dataset
+print("Loading dataset:", config["dataset_name"])
+dataset = load_dataset(config["dataset_name"])
+
+# Prepare train/validation split if not already split
+if "train" in dataset and "validation" not in dataset:
+    dataset = dataset["train"].train_test_split(test_size=0.1)
+elif "train" not in dataset:
+    # If dataset has no train split but has text column, use that
+    if "text" in dataset:
+        dataset = dataset.train_test_split(test_size=0.1)
+    else:
+        # Try to find what splits are available
+        print("Available splits:", list(dataset.keys()))
+        # Default to using the first split and splitting it
+        first_split = list(dataset.keys())[0]
+        dataset = dataset[first_split].train_test_split(test_size=0.1)
+
+print("Dataset splits:", list(dataset.keys()))
+
+# Print dataset sample
+print("Dataset sample:", dataset["train"][0])
+
+# Load tokenizer
+print("Loading tokenizer for model:", config["model_name_or_path"])
+tokenizer = AutoTokenizer.from_pretrained(config["model_name_or_path"])
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
+
+# Load model with 4-bit quantization for CPU efficiency
+print("Loading model with quantization...")
+model = AutoModelForCausalLM.from_pretrained(
+    config["model_name_or_path"],
+    load_in_4bit=True,  # Enable 4-bit quantization
+    device_map="auto",
+    quantization_config=bnb.nn.modules.Linear4bit.compute_quant_config(),
+    torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
+    use_cache=False,  # Required for gradient checkpointing
+)
+
+# Enable gradient checkpointing for memory efficiency
+model.gradient_checkpointing_enable()
+
+# Print memory usage before PEFT
+print(f"Model loaded. Memory usage: {torch.cuda.max_memory_allocated() / 1e9:.2f} GB")
+
+# Prepare model for training with LoRA
+print("Setting up LoRA with rank:", config["peft_config"]["r"])
+peft_config = LoraConfig(
+    r=config["peft_config"]["r"],
+    lora_alpha=config["peft_config"]["lora_alpha"],
+    lora_dropout=config["peft_config"]["lora_dropout"],
+    bias=config["peft_config"]["bias"],
+    task_type=config["peft_config"]["task_type"],
+    target_modules=["q_proj", "v_proj", "k_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+)
+
+# Prepare model - use 8-bit Adam for memory efficiency
+print("Preparing model for training...")
+model = prepare_model_for_kbit_training(model)
+model = get_peft_model(model, peft_config)
+model.print_trainable_parameters()
+
+# Setup training arguments with CPU optimizations
+print("Setting up training arguments...")
+training_args = TrainingArguments(
+    output_dir=config["output_dir"],
+    num_train_epochs=config["num_train_epochs"],
+    per_device_train_batch_size=config["per_device_train_batch_size"],
+    per_device_eval_batch_size=max(1, config["per_device_train_batch_size"] // 2),
+    learning_rate=config["learning_rate"],
+    weight_decay=config["weight_decay"],
+    save_strategy=config["save_strategy"],
+    evaluation_strategy=config["evaluation_strategy"],
+    fp16=config["fp16"] and torch.cuda.is_available(),
+    optim=config["optim"],
+    logging_steps=config["logging_steps"],
+    gradient_accumulation_steps=config["gradient_accumulation_steps"],
+    max_steps=config["max_steps"] if config["max_steps"] > 0 else None,
+    warmup_steps=config["warmup_steps"],
+    max_grad_norm=config["max_grad_norm"],
+    push_to_hub=True,
+    hub_token=os.environ.get("HF_TOKEN"),
+    dataloader_num_workers=0,  # Lower CPU usage for smaller machines
+    use_cpu=not torch.cuda.is_available(),  # Force CPU if no GPU
+    lr_scheduler_type="cosine",  # Better LR scheduling for small datasets
+    report_to=["tensorboard"],  # Enable tensorboard logging
+)
+
+# Define data collator
+print("Setting up data collator...")
+data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)
+
+# Tokenize dataset
+print("Tokenizing dataset...")
+def tokenize_function(examples):
+    # Use a smaller max length on CPU to save memory
+    max_length = 256 if not torch.cuda.is_available() else 512
+    return tokenizer(
+        examples["text"], 
+        padding="max_length", 
+        truncation=True, 
+        max_length=max_length
+    )
+
+# Show progress while tokenizing
+print("Mapping tokenization function...")
+tokenized_dataset = dataset.map(
+    tokenize_function, 
+    batched=True,
+    batch_size=8,  # Smaller batch size for CPU
+    remove_columns=dataset["train"].column_names,  # Remove original columns after tokenizing
+    desc="Tokenizing dataset",
+)
+
+# Initialize trainer
+print("Initializing trainer...")
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=tokenized_dataset["train"],
+    eval_dataset=tokenized_dataset["validation"],
+    data_collator=data_collator,
+)
+
+# Start training
+print("Starting training...")
+try:
+    trainer.train()
+    # Save model and tokenizer
+    print("Saving model...")
+    trainer.save_model()
+    print("Training completed successfully!")
+except Exception as e:
+    print(f"Error during training: {str(e)}")
+    # Save checkpoint even if error occurred
+    try:
+        trainer.save_model("./checkpoint-error")
+        print("Saved checkpoint before error")
+    except:
+        print("Could not save checkpoint")
+"""
+    
+    try:
+        token = st.session_state.get("hf_token")
+        if not token:
+            return False, "No Hugging Face token found"
+            
+        username = st.session_state.get("hf_username", "user")
+        repo_id = f"{username}/{repo_name}"
+        
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.py') as tmp:
+            with open(tmp.name, 'w') as f:
+                f.write(script)
+                
+            # Upload file to repository
+            upload_file(
+                path_or_fileobj=tmp.name,
+                path_in_repo="train.py",
+                repo_id=repo_id,
+                token=token
+            )
+            
+            # Clean up temporary file
+            tmp_name = tmp.name
+        
+        # Also create and upload a CPU-optimized requirements file
+        requirements = """
+transformers>=4.35.0
+peft>=0.7.0
+bitsandbytes>=0.40.0
+datasets>=2.10.0
+torch>=2.0.0
+tensorboard>=2.13.0
+accelerate>=0.20.0
+huggingface_hub>=0.15.0
+scipy>=1.10.0
+"""
+        
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.txt') as tmp:
+            with open(tmp.name, 'w') as f:
+                f.write(requirements)
+                
+            # Upload file to repository
+            upload_file(
+                path_or_fileobj=tmp.name,
+                path_in_repo="requirements.txt",
+                repo_id=repo_id,
+                token=token
+            )
+            
+            # Clean up temporary file
+            tmp_name = tmp.name
+        
+        os.unlink(tmp_name)
+        
+        return True, f"Training script and requirements uploaded to {repo_id}"
+    except Exception as e:
+        return False, str(e)
+
+def simulate_training_progress():
+    """
+    Simulate training progress for demonstration purposes
+    """
+    if "training_progress" not in st.session_state:
+        st.session_state.training_progress = {
+            "started": time.time(),
+            "current_epoch": 0,
+            "total_epochs": 3,
+            "loss": 2.5,
+            "learning_rate": 2e-5,
+            "progress": 0.0,
+            "status": "running"
+        }
+    
+    # Update progress based on elapsed time (simulated)
+    elapsed = time.time() - st.session_state.training_progress["started"]
+    epoch_duration = 60  # Simulate each epoch taking 60 seconds
+    
+    # Calculate current progress
+    total_duration = epoch_duration * st.session_state.training_progress["total_epochs"]
+    progress = min(elapsed / total_duration, 1.0)
+    
+    # Calculate current epoch
+    current_epoch = min(
+        int(progress * st.session_state.training_progress["total_epochs"]),
+        st.session_state.training_progress["total_epochs"]
+    )
+    
+    # Simulate decreasing loss
+    loss = max(2.5 - (progress * 2.0), 0.5)
+    
+    # Update session state
+    st.session_state.training_progress.update({
+        "progress": progress,
+        "current_epoch": current_epoch,
+        "loss": loss,
+        "status": "completed" if progress >= 1.0 else "running"
+    })
+    
+    return st.session_state.training_progress 

utils/ui.py

@@ -0,0 +1,163 @@
+import streamlit as st
+
+def set_page_style():
+    """
+    Set custom CSS styling for the Streamlit app with light mode
+    """
+    st.markdown("""
+    <style>
+        /* Main theme colors - Light Mode */
+        :root {
+            --primary-color: #3366FF;
+            --background-color: #FFFFFF;
+            --secondary-background-color: #F5F7F9;
+            --text-color: #333333;
+            --font: 'Source Sans Pro', sans-serif;
+        }
+        
+        /* Overall page background */
+        .stApp {
+            background-color: var(--background-color);
+            color: var(--text-color);
+        }
+        
+        /* Headers */
+        h1, h2, h3, h4, h5, h6 {
+            color: #111111;
+            font-weight: 700;
+        }
+        
+        /* Card-like elements */
+        .stCard {
+            border-radius: 8px;
+            padding: 20px;
+            box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+            background-color: white;
+            border: 1px solid #EAEAEA;
+            margin-bottom: 15px;
+        }
+        
+        /* Sidebar */
+        section[data-testid="stSidebar"] {
+            background-color: #F5F7F9;
+            border-right: 1px solid #EAEAEA;
+        }
+        
+        /* Buttons */
+        .stButton button {
+            border-radius: 4px;
+            font-weight: 600;
+            background-color: var(--primary-color);
+            color: white;
+        }
+        
+        .stButton button:hover {
+            background-color: #2a56d9;
+        }
+        
+        /* Banner image */
+        .banner-img {
+            border-radius: 8px;
+            margin-bottom: 15px;
+        }
+        
+        /* Metric display */
+        .metric-container {
+            background-color: #FFFFFF;
+            border-radius: 6px;
+            padding: 12px;
+            text-align: center;
+            box-shadow: 0 1px 3px rgba(0,0,0,0.05);
+            border: 1px solid #EAEAEA;
+        }
+        
+        .metric-value {
+            font-size: 20px;
+            font-weight: 700;
+            color: #3366FF;
+        }
+        
+        .metric-label {
+            font-size: 14px;
+            color: #555555;
+            margin-top: 5px;
+        }
+        
+        /* Make input fields a bit nicer */
+        input, textarea, select {
+            border-radius: 4px !important;
+            border: 1px solid #CCCCCC !important;
+        }
+        
+        /* Improve readability of text elements */
+        p, li, label, div {
+            color: #333333;
+        }
+        
+        /* Info, success, warning boxes */
+        .stAlert {
+            border-radius: 4px;
+        }
+        
+        /* Tabs styling */
+        .stTabs [data-baseweb="tab-list"] {
+            gap: 8px;
+        }
+        
+        .stTabs [data-baseweb="tab"] {
+            border-radius: 4px 4px 0 0;
+            padding: 8px 16px;
+            background-color: #F0F2F6;
+        }
+        
+        .stTabs [aria-selected="true"] {
+            background-color: white;
+            border-top: 2px solid var(--primary-color);
+        }
+        
+        /* Code blocks */
+        code {
+            background-color: #F0F2F6;
+            color: #333333;
+            padding: 2px 4px;
+            border-radius: 3px;
+        }
+        
+        /* Progress bar */
+        .stProgress > div > div {
+            background-color: var(--primary-color);
+        }
+    </style>
+    """, unsafe_allow_html=True)
+
+def display_metric(title, value, container=None):
+    """
+    Display a metric in a nice formatted container
+    
+    Args:
+        title (str): Title of the metric
+        value (str/int/float): Value to display
+        container (streamlit container, optional): Container to display the metric in
+    """
+    target = container if container else st
+    target.markdown(f"""
+    <div class="metric-container">
+        <div class="metric-value">{value}</div>
+        <div class="metric-label">{title}</div>
+    </div>
+    """, unsafe_allow_html=True)
+
+def create_card(content, container=None):
+    """
+    Create a card-like container for content
+    
+    Args:
+        content (callable): Function to call to render content inside the card
+        container (streamlit container, optional): Container to place the card in
+    """
+    target = container if container else st
+    
+    with target.container():
+        target.markdown('<div class="stCard">', unsafe_allow_html=True)
+        content()
+        target.markdown('</div>', unsafe_allow_html=True)