New Improvement in Pages

.gitattributes

@@ -32,4 +32,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.xz filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+*.env

app.py

@@ -2,17 +2,36 @@ import streamlit as st
 
 st.set_page_config(page_title="Gemma LLM Fine-Tuning UI", layout="wide")
 
+# Main Page Title and Description
 st.title("Gemma LLM Fine-Tuning Suite 🚀")
 st.markdown("""
-### 🔥 **Multi-page AI Model Trainer**
+### 🔥 Multi-page AI Model Trainer
 - **Chat**: Interact with the model.
 - **Fine-tuning**: Train on `train_data.csv` or upload new datasets.
 - **Conversion**: Export models to TorchScript and ONNX.
 - **Dataset Management**: View and add to your training data.
 """)
 
-# st.sidebar.title("Navigation")
-# st.sidebar.page_link("pages/Chat.py", label="🔹 Chat")
-# st.sidebar.page_link("pages/Finetune.py", label="🔹 Fine-tuning")
-# st.sidebar.page_link("pages/Conversion.py", label="🔹 Model Conversion")
-# st.sidebar.page_link("pages/Dataset_Management.py", label="🔹 Dataset Management")
+# Sidebar Navigation with Custom Labels
+st.sidebar.title("Navigation")
+nav_options = [
+    "🔹 Chat",
+    "🔹 Fine-tuning",
+    "🔹 Conversion",
+    "🔹 Dataset Management"
+]
+selected_page = st.sidebar.radio("Go to", nav_options)
+
+# Page Content based on Navigation Selection
+if selected_page == "🔹 Chat":
+    st.header("Chat with Gemma")
+    st.write("Interact with the model in a conversational interface. Coming soon!")
+elif selected_page == "🔹 Fine-tuning":
+    st.header("Fine-tuning Gemma")
+    st.write("Fine-tune your Gemma model using your dataset. Coming soon!")
+elif selected_page == "🔹 Conversion":
+    st.header("Model Conversion")
+    st.write("Convert your model to various formats. Coming soon!")
+elif selected_page == "🔹 Dataset Management":
+    st.header("Dataset Management")
+    st.write("Manage your training datasets. Coming soon!")

pages/Conversion.py

@@ -1,5 +1,13 @@
 import streamlit as st
-from utils import load_model, convert_to_torchscript, convert_to_onnx, get_hf_token
+from utils import (
+    load_model, 
+    convert_to_torchscript, 
+    convert_to_onnx, 
+    convert_to_gguf, 
+    convert_to_tf_saved_model, 
+    convert_to_pytorch, 
+    get_hf_token
+)
 
 st.title("🔧 Model Conversion")
 
@@ -10,15 +18,34 @@ hf_token = get_hf_token()
 model_path = "fine_tuned_model.pt"
 tokenizer, model = load_model("google/gemma-3-1b-it", hf_token, model_path)
 
-conversion_option = st.selectbox("Select Conversion Format", ["TorchScript", "ONNX"])
+# Select conversion format
+conversion_option = st.selectbox(
+    "Select Conversion Format", 
+    ["TorchScript", "ONNX", "GGUF", "TensorFlow SavedModel", "PyTorch"]
+)
 
 if st.button("Convert Model"):
     if conversion_option == "TorchScript":
         with st.spinner("Converting to TorchScript..."):
             ts_model = convert_to_torchscript(model)
             st.success("Model converted to TorchScript!")
-            
+
     elif conversion_option == "ONNX":
         with st.spinner("Converting to ONNX..."):
             onnx_path = convert_to_onnx(model)
-            st.success("Model converted to ONNX!")
+            st.success(f"Model converted to ONNX! Saved at: {onnx_path}")
+
+    elif conversion_option == "GGUF":
+        with st.spinner("Converting to GGUF..."):
+            gguf_path = convert_to_gguf(model)
+            st.success(f"Model converted to GGUF! Saved at: {gguf_path}")
+
+    elif conversion_option == "TensorFlow SavedModel":
+        with st.spinner("Converting to TensorFlow SavedModel..."):
+            tf_path = convert_to_tf_saved_model(model)
+            st.success(f"Model converted to TensorFlow SavedModel! Saved at: {tf_path}")
+
+    elif conversion_option == "PyTorch":
+        with st.spinner("Converting to PyTorch..."):
+            pytorch_path = convert_to_pytorch(model)
+            st.success(f"Model saved in PyTorch format! Saved at: {pytorch_path}")

pages/Dataset_Management.py

@@ -98,7 +98,7 @@ tabs = st.tabs([
 with tabs[0]:
     st.subheader("📋 Current Dataset Preview")
     if not df.empty:
-        st.dataframe(df.head(10))
+        st.dataframe(df)
         st.markdown("#### 🔎 Basic Statistics")
         st.write(df.describe(include="all"))
     else:

pages/Finetune.py

@@ -59,19 +59,13 @@ elif finetune_option == "Refinetune existing model":
 # -------------------------------
 # Dataset Selection
 # -------------------------------
-
 st.subheader("📚 Dataset Selection")
-
-# Dataset source selection
 dataset_option = st.radio("Choose dataset:", ["Upload New Dataset", "Use Existing Dataset (`train_data.csv`)"])
-
-dataset_path = "train_data.csv"
+dataset_path = "datasets/train_data.csv"
 
 if dataset_option == "Upload New Dataset":
     uploaded_file = st.file_uploader("📤 Upload Dataset (CSV or JSON)", type=["csv", "json"])
-
     if uploaded_file is not None:
-        # Handle CSV or JSON upload
         if uploaded_file.name.endswith(".csv"):
             new_data = pd.read_csv(uploaded_file)
         elif uploaded_file.name.endswith(".json"):
@@ -81,14 +75,12 @@ if dataset_option == "Upload New Dataset":
             st.error("❌ Unsupported file format. Please upload CSV or JSON.")
             st.stop()
 
-        # Append or create new dataset
         if os.path.exists(dataset_path):
             new_data.to_csv(dataset_path, mode='a', index=False, header=False)
             st.success(f"✅ Data appended to `{dataset_path}`!")
         else:
             new_data.to_csv(dataset_path, index=False)
             st.success(f"✅ Dataset saved as `{dataset_path}`!")
-
 elif dataset_option == "Use Existing Dataset (`train_data.csv`)":
     if os.path.exists(dataset_path):
         st.success("✅ Using existing `train_data.csv` for fine-tuning.")
@@ -99,69 +91,71 @@ elif dataset_option == "Use Existing Dataset (`train_data.csv`)":
 # -------------------------------
 # Hyperparameters Configuration
 # -------------------------------
+st.subheader("🔧 Hyperparameter Configuration")
 learning_rate = st.number_input("📊 Learning Rate", value=1e-4, format="%.5f")
 batch_size = st.number_input("🛠️ Batch Size", value=16, step=1)
 epochs = st.number_input("⏱️ Epochs", value=3, step=1)
 
+
 # -------------------------------
-# Fine-tuning Execution
+# Fine-tuning Execution with Real-Time Visualization
 # -------------------------------
 if st.button("🚀 Start Fine-tuning"):
-    st.info(f"Fine-tuning process initiated...")
-
-    # Retrieve Hugging Face Token
+    st.info("Fine-tuning process initiated...")
     hf_token = get_hf_token()
 
     # Model loading logic
     if finetune_option == "Refinetune existing model" and saved_model_path:
-        # Load the base model first
         tokenizer, model = load_model("google/gemma-3-1b-it", hf_token)
-
-        # Load the saved model checkpoint for re-finetuning
         model = load_finetuned_model(model, saved_model_path)
-
         if model:
             st.success(f"✅ Loaded saved model: `{saved_model_path}` for refinement!")
         else:
             st.error("❌ Failed to load the saved model. Aborting.")
             st.stop()
-
     else:
-        # Fine-tune from scratch (load base model)
         if not selected_model:
             st.error("❌ Please select a model to fine-tune.")
             st.stop()
-
         tokenizer, model = load_model(selected_model, hf_token)
-        
         if model:
             st.success(f"✅ Base model loaded: `{selected_model}`")
         else:
             st.error("❌ Failed to load the base model. Aborting.")
             st.stop()
 
-    # Simulate fine-tuning loop
-    progress_bar = st.progress(0)
-    training_placeholder = st.empty()
-
-    for epoch, losses, accs in simulate_training(epochs):
-        fig = plot_training_metrics(epoch, losses, accs)
-        training_placeholder.pyplot(fig)
-        progress_bar.progress(epoch / epochs)
-
+    # Create placeholders for training progress
+    loss_chart = st.line_chart()  # Loss curve
+    acc_chart = st.line_chart()   # Accuracy curve
+    progress_text = st.empty()
+    
+    # Simulate training loop with real-time visualization
+    losses_over_epochs = []
+    accuracies_over_epochs = []
+    
+    for epoch, losses, accs in simulate_training(epochs, learning_rate, batch_size):
+        # Update training text
+        progress_text.text(f"Epoch {epoch}/{epochs} in progress...")
+        
+        # Assume simulate_training returns overall average loss and accuracy per epoch
+        losses_over_epochs.append(losses)  # e.g., average loss of the epoch
+        accuracies_over_epochs.append(accs)  # e.g., average accuracy of the epoch
+        
+        # Update real-time charts
+        loss_chart.add_rows(pd.DataFrame({"Loss": [losses]}))
+        acc_chart.add_rows(pd.DataFrame({"Accuracy": [accs]}))
+    
+    progress_text.text("Fine-tuning completed!")
+    
     # Save fine-tuned model with timestamp
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    new_model_name = f"models/fine_tuned_model_{selected_model.replace('/', '_')}_{timestamp}.pt"
+    model_identifier = selected_model if selected_model else os.path.basename(saved_model_path)
+    new_model_name = f"models/fine_tuned_model_{model_identifier.replace('/', '_')}_{timestamp}.pt"
     
-    # Save the fine-tuned model
     saved_model_path = save_model(model, new_model_name)
-
     if saved_model_path:
         st.success(f"✅ Fine-tuning completed! Model saved as `{saved_model_path}`")
-
-        # Load the fine-tuned model for immediate inference
         model = load_finetuned_model(model, saved_model_path)
-
         if model:
             st.success("🛠️ Fine-tuned model loaded and ready for inference!")
         else:

requirements.txt

@@ -9,4 +9,6 @@ FuzzyTM>=0.4.0
 requests>=2.28.0
 xlsxwriter>=3.0.1
 python-dotenv>=0.19.0
-scipy>=1.7.3
+scipy>=1.7.3
+seaborn>=0.13.2
+llama-cpp-python>=0.3.8

utils.py

@@ -11,7 +11,7 @@ import os
 import asyncio
 from dotenv import load_dotenv
 from scipy.stats import skew, kurtosis, zscore
-
+import llama_cpp
 # -------------------------------
 # Environment and Token Management
 # -------------------------------
@@ -192,6 +192,33 @@ def convert_to_onnx(model, output_path="model.onnx"):
         st.error(f"❌ ONNX conversion failed: {e}")
         return None
 
+# Convert to GGUF (for Llama.cpp)
+def convert_to_gguf(model, output_path="model.gguf"):
+    llama_cpp.export_gguf(model, output_path)
+    return output_path
+
+# Convert to TensorFlow SavedModel
+def convert_to_tf_saved_model(model, output_path="model_tf"):
+    tf_model = tf.Module()
+    
+    # Export the PyTorch model to TensorFlow using ONNX as intermediary
+    dummy_input = torch.randn(1, 3, 224, 224)
+    torch.onnx.export(model, dummy_input, "temp_model.onnx")
+
+    # Load ONNX model into TensorFlow
+    import onnx
+    from onnx_tf.backend import prepare
+    
+    onnx_model = onnx.load("temp_model.onnx")
+    tf_rep = prepare(onnx_model)
+    tf_rep.export_graph(output_path)
+
+    return output_path
+
+# Convert to PyTorch format
+def convert_to_pytorch(model, output_path="model.pth"):
+    torch.save(model.state_dict(), output_path)
+    return output_path
 
 # -------------------------------
 # Model Inference and Training
@@ -355,7 +382,7 @@ def compute_dataset_score(df):
     if df.empty:
         return 0.0
 
-    total_cells = np.product(df.shape)
+    total_cells = np.prod(df.shape)
     missing_cells = df.isnull().sum().sum()
     missing_ratio = missing_cells / total_cells