Upload 2 files

pages/02_Model_Training.py

@@ -0,0 +1,193 @@
+import streamlit as st
+import pandas as pd
+import time
+import threading
+from data_utils import list_available_datasets, get_dataset_info
+from model_utils import list_available_huggingface_models
+from training_utils import (
+    start_model_training, 
+    stop_model_training, 
+    get_running_training_jobs,
+    simulate_training
+)
+from utils import (
+    set_page_config, 
+    display_sidebar, 
+    add_log, 
+    display_logs, 
+    plot_training_progress
+)
+
+# Set page configuration
+set_page_config()
+
+# Display sidebar
+display_sidebar()
+
+# Title
+st.title("Model Training")
+st.markdown("Configure and train code generation models on your datasets.")
+
+# Training configuration tab
+tab1, tab2 = st.tabs(["Configure Training", "Monitor Jobs"])
+
+with tab1:
+    st.subheader("Train a New Model")
+    
+    # Model ID input
+    model_id = st.text_input("Model ID", placeholder="e.g., my_codegen_model_v1")
+    
+    # Dataset selection
+    available_datasets = list_available_datasets()
+    if not available_datasets:
+        st.warning("No datasets available. Please upload a dataset in the Dataset Management section.")
+        dataset_name = None
+    else:
+        dataset_name = st.selectbox("Select Dataset", available_datasets)
+    
+    # Model selection
+    model_options = list_available_huggingface_models()
+    base_model = st.selectbox("Select Base Model", model_options)
+    
+    # Training parameters
+    st.markdown("### Training Parameters")
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        learning_rate = st.number_input(
+            "Learning Rate", 
+            min_value=1e-6, 
+            max_value=1e-3, 
+            value=2e-5, 
+            format="%.2e"
+        )
+        batch_size = st.slider("Batch Size", min_value=1, max_value=32, value=8, step=1)
+    
+    with col2:
+        epochs = st.slider("Number of Epochs", min_value=1, max_value=10, value=3, step=1)
+        use_simulation = st.checkbox("Use Simulation Mode (for demonstration)", value=True)
+    
+    # Start training button
+    if st.button("Start Training", disabled=not dataset_name):
+        if not model_id:
+            st.error("Please provide a model ID")
+        elif model_id in st.session_state.get('trained_models', {}):
+            st.error(f"Model with ID '{model_id}' already exists. Please choose a different ID.")
+        elif model_id in st.session_state.get('training_progress', {}):
+            st.error(f"A training job for model '{model_id}' already exists.")
+        else:
+            # Initialize stop_events if not present
+            if 'stop_events' not in st.session_state:
+                st.session_state.stop_events = {}
+            
+            # Start training (real or simulated)
+            if use_simulation:
+                st.session_state.stop_events[model_id] = simulate_training(
+                    model_id, dataset_name, base_model, epochs
+                )
+                add_log(f"Started simulated training for model '{model_id}'")
+            else:
+                st.session_state.stop_events[model_id] = start_model_training(
+                    model_id, dataset_name, base_model, learning_rate, batch_size, epochs
+                )
+                add_log(f"Started training for model '{model_id}'")
+            
+            st.success(f"Training job started for model '{model_id}'")
+            time.sleep(1)
+            st.rerun()
+
+with tab2:
+    st.subheader("Training Jobs")
+    
+    # Check if there are any training jobs
+    if 'training_progress' not in st.session_state or not st.session_state.training_progress:
+        st.info("No training jobs found. Start a new training job in the 'Configure Training' tab.")
+    else:
+        # List all training jobs
+        all_jobs = list(st.session_state.training_progress.keys())
+        selected_job = st.selectbox("Select Training Job", all_jobs)
+        
+        if selected_job:
+            # Get job progress
+            job_progress = st.session_state.training_progress[selected_job]
+            
+            # Display job status
+            status = job_progress['status']
+            status_color = {
+                'initialized': 'blue',
+                'running': 'green',
+                'completed': 'green',
+                'failed': 'red',
+                'stopped': 'orange'
+            }.get(status, 'gray')
+            
+            st.markdown(f"### Status: :{status_color}[{status.upper()}]")
+            
+            # Display progress bar
+            progress = job_progress['progress']
+            st.progress(progress/100)
+            
+            # Display job details
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.markdown("### Job Details")
+                st.markdown(f"**Model ID:** {selected_job}")
+                st.markdown(f"**Current Epoch:** {job_progress['current_epoch']}/{job_progress['total_epochs']}")
+                st.markdown(f"**Started At:** {job_progress['started_at']}")
+                
+                if job_progress['completed_at']:
+                    st.markdown(f"**Completed At:** {job_progress['completed_at']}")
+            
+            with col2:
+                # Training controls
+                st.markdown("### Controls")
+                
+                # Only show stop button for running jobs
+                if status == 'running' and selected_job in st.session_state.get('stop_events', {}):
+                    if st.button("Stop Training"):
+                        stop_event = st.session_state.stop_events[selected_job]
+                        stop_model_training(selected_job, stop_event)
+                        st.success(f"Stopping training for model '{selected_job}'")
+                        time.sleep(1)
+                        st.rerun()
+                
+                # Add delete button for completed/failed/stopped jobs
+                if status in ['completed', 'failed', 'stopped']:
+                    if st.button("Delete Job"):
+                        del st.session_state.training_progress[selected_job]
+                        if selected_job in st.session_state.get('stop_events', {}):
+                            del st.session_state.stop_events[selected_job]
+                        add_log(f"Deleted training job for model '{selected_job}'")
+                        st.success(f"Training job for model '{selected_job}' deleted")
+                        time.sleep(1)
+                        st.rerun()
+            
+            # Display training progress plot
+            st.markdown("### Training Progress")
+            plot_training_progress(selected_job)
+            
+            # Display logs
+            st.markdown("### Training Logs")
+            display_logs()
+
+# Display running jobs summary at the bottom
+st.markdown("---")
+st.subheader("Running Jobs Summary")
+running_jobs = get_running_training_jobs()
+
+if not running_jobs:
+    st.info("No active training jobs")
+else:
+    for job in running_jobs:
+        progress = st.session_state.training_progress[job]
+        col1, col2, col3 = st.columns([2, 1, 1])
+        
+        with col1:
+            st.markdown(f"**{job}**")
+        
+        with col2:
+            st.markdown(f"Epoch {progress['current_epoch']}/{progress['total_epochs']}")
+        
+        with col3:
+            st.progress(progress['progress']/100)

pages/03_Code_Generation.py

@@ -0,0 +1,136 @@
+import streamlit as st
+import time
+from model_utils import list_trained_models, generate_code, get_model_info
+from utils import set_page_config, display_sidebar, add_log, format_code
+
+# Set page configuration
+set_page_config()
+
+# Display sidebar
+display_sidebar()
+
+# Title
+st.title("Code Generation")
+st.markdown("Generate Python code using your trained models.")
+
+# Get available models
+available_models = list_trained_models()
+
+if not available_models:
+    st.warning("No trained models available. Please train a model in the Model Training section.")
+else:
+    # Create main columns for layout
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.markdown("### Code Generation Setup")
+        
+        # Model selection
+        selected_model = st.selectbox("Select Model", available_models)
+        
+        # Display model info if available
+        if selected_model:
+            model_info = get_model_info(selected_model)
+            if model_info:
+                st.markdown("#### Model Information")
+                
+                # Create expandable section for model details
+                with st.expander("Model Details", expanded=False):
+                    for key, value in model_info.items():
+                        if key != 'id':  # Skip ID as it's already shown in the selectbox
+                            st.markdown(f"**{key.replace('_', ' ').title()}:** {value}")
+        
+        # Generation parameters
+        st.markdown("#### Generation Parameters")
+        max_length = st.slider("Maximum Length", min_value=50, max_value=500, value=200, step=10)
+        temperature = st.slider("Temperature", min_value=0.1, max_value=2.0, value=0.7, step=0.1,
+                             help="Higher values make output more random, lower values more deterministic")
+        top_p = st.slider("Top P (Nucleus Sampling)", min_value=0.1, max_value=1.0, value=0.9, step=0.05,
+                       help="Controls diversity. 0.9 means consider tokens comprising the top 90% probability mass")
+        
+        # Input prompt
+        st.markdown("#### Input Prompt")
+        prompt = st.text_area(
+            "Enter your code prompt",
+            height=200,
+            placeholder="# Function to calculate fibonacci sequence\ndef fibonacci(n):"
+        )
+        
+        # Generate button
+        generate_button = st.button("Generate Code", disabled=not prompt)
+    
+    with col2:
+        st.markdown("### Generated Code")
+        
+        # Create a placeholder for generated code
+        code_placeholder = st.empty()
+        
+        # Initialize session state for code history if not exists
+        if 'code_history' not in st.session_state:
+            st.session_state.code_history = []
+        
+        # Generate code when button is clicked
+        if generate_button and prompt and selected_model:
+            with st.spinner("Generating code..."):
+                generated_code = generate_code(
+                    selected_model, 
+                    prompt, 
+                    max_length=max_length, 
+                    temperature=temperature, 
+                    top_p=top_p
+                )
+                
+                # Add to history
+                st.session_state.code_history.append({
+                    'prompt': prompt,
+                    'code': generated_code,
+                    'model': selected_model,
+                    'parameters': {
+                        'max_length': max_length,
+                        'temperature': temperature,
+                        'top_p': top_p
+                    },
+                    'timestamp': time.strftime("%Y-%m-%d %H:%M:%S")
+                })
+                
+                # Display the generated code
+                code_placeholder.code(format_code(generated_code), language='python')
+                
+                # Log the generation
+                add_log(f"Generated code with model '{selected_model}' (length: {len(generated_code)})")
+        
+        # If there's code history but the generate button wasn't pressed, show the most recent one
+        elif st.session_state.code_history:
+            last_code = st.session_state.code_history[-1]['code']
+            code_placeholder.code(format_code(last_code), language='python')
+        else:
+            # Show empty placeholder when no code has been generated
+            code_placeholder.code("# Generated code will appear here", language='python')
+    
+    # Code history section
+    st.markdown("---")
+    st.markdown("### Code Generation History")
+    
+    if not st.session_state.code_history:
+        st.info("No code has been generated yet. Use the form above to generate code.")
+    else:
+        # Display code history
+        for i, item in enumerate(reversed(st.session_state.code_history)):
+            with st.expander(f"Generation {len(st.session_state.code_history) - i}: {item['timestamp']}"):
+                st.markdown(f"**Model:** {item['model']}")
+                st.markdown(f"**Parameters:** Max Length: {item['parameters']['max_length']}, "
+                          f"Temperature: {item['parameters']['temperature']}, "
+                          f"Top P: {item['parameters']['top_p']}")
+                
+                st.markdown("**Prompt:**")
+                st.code(format_code(item['prompt']), language='python')
+                
+                st.markdown("**Generated Code:**")
+                st.code(format_code(item['code']), language='python')
+        
+        # Clear history button
+        if st.button("Clear History"):
+            st.session_state.code_history = []
+            st.success("History cleared!")
+            time.sleep(1)
+            st.rerun()