Update app.py

app.py

@@ -1,845 +1,15 @@
 """
-Speech Emotion Recognition - Gradio Application with 3 Tabs
-Tab 1: Feature Extraction (Upload audio files only)
-Tab 2: Model Training with GA Optimization (Parallel + Early Stopping + Logging)
-Tab 3: Emotion Prediction
+Speech Emotion Recognition - Main Application
+Entry point for Gradio interface
 """
 
 import gradio as gr
-import numpy as np
-import pandas as pd
-import os
-import json
-import pickle
-from pathlib import Path
-import random
-import time
-from collections import deque
+import config
+from src.ui import create_tab1, create_tab2, create_tab3
 
-# For parallel processing
-from joblib import Parallel, delayed
 
-# ============================================================================
-# TAB 1: FEATURE EXTRACTION (DUMMY DATA REMOVED)
-# ============================================================================
-
-def extract_dataset_features(uploaded_files, progress=gr.Progress()):
-    """Extract features from uploaded dataset - NO DUMMY DATA"""
-    
-    if uploaded_files is None or len(uploaded_files) == 0:
-        return """
-## ⚠️ No Files Uploaded
-
-Please upload audio files (.wav format) to proceed.
-
-**Tips:**
-- Upload multiple files at once
-- RAVDESS format: `03-01-06-01-02-01-12.wav`
-- Or any `.wav` files with emotion labels in filename
-""", None, None
-    
-    try:
-        from src.feature_extraction import extract_features
-        
-        progress(0, desc="Starting feature extraction...")
-        
-        data_list = []
-        total_files = len(uploaded_files)
-        failed_files = []
-        
-        for idx, audio_file in enumerate(uploaded_files):
-            progress((idx + 1) / total_files, desc=f"Processing {idx + 1}/{total_files}: {Path(audio_file).name}")
-            
-            try:
-                features, _, _ = extract_features(audio_file)
-                filename = Path(audio_file).name
-                emotion = extract_emotion_from_filename(filename)
-                
-                row = {
-                    'file_path': audio_file,
-                    'filename': filename,
-                    'actor': extract_actor_from_filename(filename),
-                    'emotion': emotion
-                }
-                
-                for i, feat in enumerate(features):
-                    row[f'feature_{i}'] = feat
-                
-                data_list.append(row)
-                
-            except Exception as e:
-                failed_files.append((audio_file, str(e)))
-                print(f"Error processing {audio_file}: {e}")
-                continue
-        
-        if len(data_list) == 0:
-            return "❌ No features extracted. Check audio files and error logs.", None, None
-        
-        df = pd.DataFrame(data_list)
-        df.to_csv('features_ravdess.csv', index=False)
-        
-        # Create summary
-        summary = f"""
-## ✅ Feature Extraction Complete!
-
-### Statistics:
-- **Total Files Processed**: {len(df)}
-- **Features Extracted**: 162 per file
-- **Emotions Detected**: {', '.join(sorted(df['emotion'].unique()))}
-- **Output File**: `features_ravdess.csv`
-
-### Emotion Distribution:
-{df['emotion'].value_counts().to_string()}
-
-### Failed Files: {len(failed_files)}
-"""
-        
-        if failed_files:
-            summary += "\n\n**Failed files:**\n"
-            for fname, error in failed_files[:10]:  # Show first 10
-                summary += f"- {Path(fname).name}: {error}\n"
-        
-        summary += "\n✅ **Dataset ready for training!**"
-        
-        emotion_dist = df['emotion'].value_counts().to_dict()
-        
-        return summary, df.head(20), emotion_dist
-    
-    except Exception as e:
-        return f"❌ Error: {str(e)}", None, None
-
-
-def extract_emotion_from_filename(filename):
-    """Extract emotion from RAVDESS-style filename"""
-    try:
-        parts = filename.split('-')
-        if len(parts) >= 3:
-            emotion_code = int(parts[2])
-            emotion_map = {
-                1: 'neutral', 2: 'calm', 3: 'happy', 4: 'sad',
-                5: 'angry', 6: 'fearful', 7: 'disgust', 8: 'surprised'
-            }
-            return emotion_map.get(emotion_code, 'unknown')
-    except:
-        pass
-    
-    # Fallback: Check filename for emotion keywords
-    filename_lower = filename.lower()
-    emotions = ['angry', 'calm', 'disgust', 'fearful', 'happy', 'neutral', 'sad', 'surprised']
-    for emotion in emotions:
-        if emotion in filename_lower:
-            return emotion
-    
-    return 'unknown'
-
-
-def extract_actor_from_filename(filename):
-    """Extract actor ID from filename"""
-    try:
-        parts = filename.split('-')
-        if len(parts) >= 7:
-            actor_id = int(parts[6].split('.')[0])
-            return f'Actor_{actor_id:02d}'
-    except:
-        pass
-    return 'Unknown'
-
-
-def preview_single_audio(audio_file):
-    """Preview features from a single audio file"""
-    if audio_file is None:
-        return "Please upload an audio file", None, None
-    
-    try:
-        from src.feature_extraction import extract_features
-        from src.utils import create_waveform_plot, create_spectrogram_plot
-        
-        features, y, sr = extract_features(audio_file)
-        
-        summary = f"""
-## 🔍 Single File Feature Preview
-
-- **Features Extracted**: 162
-- **Sample Rate**: {sr} Hz
-- **Duration**: {len(y)/sr:.2f} seconds
-- **Detected Emotion**: {extract_emotion_from_filename(Path(audio_file).name)}
-"""
-        
-        waveform = create_waveform_plot(y, sr)
-        spectrogram = create_spectrogram_plot(y, sr)
-        
-        return summary, waveform, spectrogram
-        
-    except Exception as e:
-        return f"Error: {str(e)}", None, None
-
-
-# ============================================================================
-# TAB 2: GENETIC ALGORITHM CLASS (WITH PARALLEL + EARLY STOPPING + LOGGING)
-# ============================================================================
-
-class GeneticAlgorithm:
-    """GA for optimizing features + hyperparameters + ensemble weights"""
-    
-    def __init__(self, X, y, n_features_to_select=80):
-        self.X = X
-        self.y = y
-        self.n_features = X.shape[1]
-        self.n_select = n_features_to_select
-        self.n_classes = len(np.unique(y))
-        
-        self.population_size = 15
-        self.n_generations = 20
-        self.mutation_rate = 0.15
-        self.crossover_rate = 0.8
-        self.elite_size = 2
-        
-        # Early stopping
-        self.early_stopping_patience = 5
-        self.early_stopping_tolerance = 0.0001
-        
-        self.best_chromosome = None
-        self.best_fitness = 0
-        self.history = []
-        
-        # Logging
-        self.log_messages = []
-    
-    def log(self, message):
-        """Add log message"""
-        timestamp = time.strftime("%H:%M:%S")
-        log_entry = f"[{timestamp}] {message}"
-        self.log_messages.append(log_entry)
-        print(log_entry)
-    
-    def create_chromosome(self):
-        """Create random chromosome"""
-        chromosome = {
-            'feature_indices': np.sort(np.random.choice(
-                self.n_features, self.n_select, replace=False
-            )),
-            'xgb_n_estimators': random.choice([50, 100, 150]),
-            'xgb_max_depth': random.choice([3, 4, 5, 6]),
-            'xgb_learning_rate': random.choice([0.05, 0.1, 0.15]),
-            'lgbm_n_estimators': random.choice([50, 100, 150]),
-            'lgbm_num_leaves': random.choice([20, 31, 40]),
-            'lgbm_learning_rate': random.choice([0.05, 0.1, 0.15]),
-            'gb_n_estimators': random.choice([50, 100, 150]),
-            'gb_max_depth': random.choice([3, 4, 5]),
-            'gb_learning_rate': random.choice([0.05, 0.1, 0.15]),
-            'ada_n_estimators': random.choice([50, 100, 150]),
-            'ada_learning_rate': random.choice([0.5, 1.0, 1.5]),
-            'weights': self._random_weights(4)
-        }
-        return chromosome
-    
-    def _random_weights(self, n):
-        """Generate n random weights that sum to 1"""
-        w = np.random.dirichlet(np.ones(n))
-        return w
-    
-    def fitness(self, chromosome, X_train, y_train, X_val, y_val):
-        """Calculate fitness using validation accuracy"""
-        try:
-            from xgboost import XGBClassifier
-            from lightgbm import LGBMClassifier
-            from sklearn.ensemble import GradientBoostingClassifier, AdaBoostClassifier
-            from sklearn.metrics import accuracy_score
-            
-            feature_indices = chromosome['feature_indices']
-            X_train_selected = X_train[:, feature_indices]
-            X_val_selected = X_val[:, feature_indices]
-            
-            models = []
-            
-            xgb = XGBClassifier(
-                n_estimators=chromosome['xgb_n_estimators'],
-                max_depth=chromosome['xgb_max_depth'],
-                learning_rate=chromosome['xgb_learning_rate'],
-                objective='multi:softprob',
-                num_class=self.n_classes,
-                random_state=42,
-                n_jobs=-1,
-                verbosity=0
-            )
-            xgb.fit(X_train_selected, y_train)
-            models.append(xgb)
-            
-            lgbm = LGBMClassifier(
-                n_estimators=chromosome['lgbm_n_estimators'],
-                num_leaves=chromosome['lgbm_num_leaves'],
-                learning_rate=chromosome['lgbm_learning_rate'],
-                objective='multiclass',
-                num_class=self.n_classes,
-                random_state=42,
-                n_jobs=-1,
-                verbose=-1
-            )
-            lgbm.fit(X_train_selected, y_train)
-            models.append(lgbm)
-            
-            gb = GradientBoostingClassifier(
-                n_estimators=chromosome['gb_n_estimators'],
-                max_depth=chromosome['gb_max_depth'],
-                learning_rate=chromosome['gb_learning_rate'],
-                random_state=42
-            )
-            gb.fit(X_train_selected, y_train)
-            models.append(gb)
-            
-            ada = AdaBoostClassifier(
-                n_estimators=chromosome['ada_n_estimators'],
-                learning_rate=chromosome['ada_learning_rate'],
-                algorithm='SAMME',
-                random_state=42
-            )
-            ada.fit(X_train_selected, y_train)
-            models.append(ada)
-            
-            predictions = [model.predict_proba(X_val_selected) for model in models]
-            weights = chromosome['weights']
-            ensemble_proba = np.average(predictions, axis=0, weights=weights)
-            y_pred = np.argmax(ensemble_proba, axis=1)
-            
-            accuracy = accuracy_score(y_val, y_pred)
-            return accuracy
-            
-        except Exception as e:
-            print(f"Error in fitness: {e}")
-            return 0.0
-    
-    def crossover(self, parent1, parent2):
-        """Crossover operation"""
-        if random.random() > self.crossover_rate:
-            return parent1.copy(), parent2.copy()
-        
-        child1 = {}
-        child2 = {}
-        
-        mask = np.random.rand(self.n_select) < 0.5
-        child1_features = np.where(mask, parent1['feature_indices'], parent2['feature_indices'])
-        child2_features = np.where(mask, parent2['feature_indices'], parent1['feature_indices'])
-        
-        child1_features = np.unique(child1_features)
-        child2_features = np.unique(child2_features)
-        
-        while len(child1_features) < self.n_select:
-            new_feat = random.randint(0, self.n_features - 1)
-            if new_feat not in child1_features:
-                child1_features = np.append(child1_features, new_feat)
-        
-        while len(child2_features) < self.n_select:
-            new_feat = random.randint(0, self.n_features - 1)
-            if new_feat not in child2_features:
-                child2_features = np.append(child2_features, new_feat)
-        
-        child1['feature_indices'] = np.sort(child1_features[:self.n_select])
-        child2['feature_indices'] = np.sort(child2_features[:self.n_select])
-        
-        for key in parent1.keys():
-            if key != 'feature_indices':
-                if random.random() < 0.5:
-                    child1[key] = parent1[key]
-                    child2[key] = parent2[key]
-                else:
-                    child1[key] = parent2[key]
-                    child2[key] = parent1[key]
-        
-        return child1, child2
-    
-    def mutate(self, chromosome):
-        """Mutation operation"""
-        mutated = chromosome.copy()
-        
-        if random.random() < self.mutation_rate:
-            n_replace = random.randint(1, 5)
-            indices_to_replace = np.random.choice(self.n_select, n_replace, replace=False)
-            
-            for idx in indices_to_replace:
-                new_feat = random.randint(0, self.n_features - 1)
-                while new_feat in mutated['feature_indices']:
-                    new_feat = random.randint(0, self.n_features - 1)
-                mutated['feature_indices'][idx] = new_feat
-            
-            mutated['feature_indices'] = np.sort(mutated['feature_indices'])
-        
-        if random.random() < self.mutation_rate:
-            param_to_mutate = random.choice([
-                'xgb_n_estimators', 'xgb_max_depth', 'lgbm_n_estimators',
-                'gb_n_estimators', 'ada_n_estimators'
-            ])
-            temp = self.create_chromosome()
-            mutated[param_to_mutate] = temp[param_to_mutate]
-        
-        if random.random() < self.mutation_rate:
-            mutated['weights'] = self._random_weights(4)
-        
-        return mutated
-    
-    def evaluate_population_parallel(self, population, X_train, y_train, X_val, y_val, n_jobs=2):
-        """
-        Evaluate entire population in parallel
-        
-        Args:
-            population: List of chromosomes
-            n_jobs: Number of parallel jobs (default=2 for free tier)
-        
-        Returns:
-            List of fitness scores
-        """
-        self.log(f"   Evaluating {len(population)} individuals in parallel (n_jobs={n_jobs})...")
-        
-        fitness_scores = Parallel(n_jobs=n_jobs, verbose=0)(
-            delayed(self.fitness)(chromosome, X_train, y_train, X_val, y_val)
-            for chromosome in population
-        )
-        
-        return fitness_scores
-    
-    def evolve(self, X_train, y_train, X_val, y_val, progress_callback=None, n_jobs=2):
-        """
-        Main GA evolution loop with parallel evaluation, early stopping, and logging
-        
-        Args:
-            n_jobs: Number of parallel jobs (2 for free tier, 4+ for better hardware)
-        """
-        
-        self.log("="*70)
-        self.log("🧬 GENETIC ALGORITHM OPTIMIZATION")
-        self.log("="*70)
-        self.log(f"Population size: {self.population_size}")
-        self.log(f"Generations: {self.n_generations}")
-        self.log(f"Features to select: {self.n_select}/{self.n_features}")
-        self.log(f"Early stopping patience: {self.early_stopping_patience}")
-        self.log(f"Parallel jobs: {n_jobs}")
-        self.log("="*70)
-        
-        population = [self.create_chromosome() for _ in range(self.population_size)]
-        
-        start_time = time.time()
-        no_improve_count = 0
-        
-        for generation in range(self.n_generations):
-            gen_start = time.time()
-            
-            self.log(f"\n📊 Generation {generation + 1}/{self.n_generations}")
-            
-            # Parallel fitness evaluation
-            fitness_scores = self.evaluate_population_parallel(
-                population, X_train, y_train, X_val, y_val, n_jobs=n_jobs
-            )
-            
-            max_fitness = max(fitness_scores)
-            avg_fitness = np.mean(fitness_scores)
-            std_fitness = np.std(fitness_scores)
-            max_idx = fitness_scores.index(max_fitness)
-            
-            # Track improvement
-            improved = False
-            if max_fitness > self.best_fitness + self.early_stopping_tolerance:
-                self.best_fitness = max_fitness
-                self.best_chromosome = population[max_idx].copy()
-                no_improve_count = 0
-                improved = True
-                self.log(f"   ✨ NEW BEST: {max_fitness:.4f} (+{max_fitness - (self.history[-1]['best_fitness'] if self.history else 0):.4f})")
-            else:
-                no_improve_count += 1
-                self.log(f"   → Best: {max_fitness:.4f} (no improvement, count={no_improve_count})")
-            
-            # Log statistics
-            self.log(f"   Average: {avg_fitness:.4f} (σ={std_fitness:.4f})")
-            self.log(f"   Range: [{min(fitness_scores):.4f}, {max(fitness_scores):.4f}]")
-            
-            gen_time = time.time() - gen_start
-            elapsed = time.time() - start_time
-            avg_gen_time = elapsed / (generation + 1)
-            eta = avg_gen_time * (self.n_generations - generation - 1)
-            
-            self.log(f"   Time: {gen_time:.1f}s | Elapsed: {elapsed/60:.1f}min | ETA: {eta/60:.1f}min")
-            
-            self.history.append({
-                'generation': generation + 1,
-                'best_fitness': max_fitness,
-                'avg_fitness': avg_fitness,
-                'std_fitness': std_fitness,
-                'time': gen_time,
-                'improved': improved
-            })
-            
-            # Update progress callback
-            if progress_callback:
-                progress_callback(
-                    (generation + 1) / self.n_generations,
-                    desc=f"Gen {generation+1}/{self.n_generations} | Best: {max_fitness:.4f} | Avg: {avg_fitness:.4f} | ETA: {eta/60:.0f}min"
-                )
-            
-            # Early stopping check
-            if no_improve_count >= self.early_stopping_patience:
-                self.log(f"\n🛑 EARLY STOPPING at generation {generation + 1}")
-                self.log(f"   No improvement for {self.early_stopping_patience} consecutive generations")
-                self.log(f"   Best fitness: {self.best_fitness:.4f}")
-                break
-            
-            # Selection (Tournament + Elitism)
-            selected = []
-            for _ in range(self.population_size - self.elite_size):
-                tournament = random.sample(list(zip(population, fitness_scores)), 3)
-                winner = max(tournament, key=lambda x: x[1])[0]
-                selected.append(winner)
-            
-            elite_indices = np.argsort(fitness_scores)[-self.elite_size:]
-            elite = [population[i] for i in elite_indices]
-            
-            # Crossover & Mutation
-            offspring = []
-            for i in range(0, len(selected), 2):
-                if i + 1 < len(selected):
-                    child1, child2 = self.crossover(selected[i], selected[i+1])
-                    offspring.append(self.mutate(child1))
-                    offspring.append(self.mutate(child2))
-            
-            population = elite + offspring[:self.population_size - self.elite_size]
-        
-        total_time = time.time() - start_time
-        
-        self.log("\n" + "="*70)
-        self.log("✅ GA OPTIMIZATION COMPLETE")
-        self.log("="*70)
-        self.log(f"Final best fitness: {self.best_fitness:.4f}")
-        self.log(f"Total generations: {len(self.history)}/{self.n_generations}")
-        self.log(f"Total time: {total_time/60:.1f} minutes")
-        self.log(f"Average time per generation: {total_time/len(self.history):.1f}s")
-        self.log("="*70)
-        
-        return self.best_chromosome
-
-
-# ============================================================================
-# TAB 2: TRAINING FUNCTION (WITH LOGGING)
-# ============================================================================
-
-def train_with_ga(use_ga, ga_generations, ga_population, n_jobs, progress=gr.Progress()):
-    """Train models with or without GA optimization"""
-    
-    if not os.path.exists('features_ravdess.csv'):
-        return """
-## ❌ Error: Dataset Not Found
-
-Please go to **Tab 1: Feature Extraction** first!
-
-Upload your audio files and extract features before training.
-""", None, None, ""
-    
-    try:
-        progress(0, desc="Loading dataset...")
-        
-        df = pd.read_csv('features_ravdess.csv')
-        
-        from sklearn.model_selection import train_test_split
-        from sklearn.preprocessing import LabelEncoder, StandardScaler
-        from xgboost import XGBClassifier
-        from lightgbm import LGBMClassifier
-        from sklearn.ensemble import GradientBoostingClassifier, AdaBoostClassifier
-        from sklearn.metrics import accuracy_score
-        
-        feature_cols = [col for col in df.columns if col.startswith('feature_')]
-        X = df[feature_cols].values
-        y = df['emotion'].values
-        
-        label_encoder = LabelEncoder()
-        y_encoded = label_encoder.fit_transform(y)
-        
-        X_train, X_test, y_train, y_test = train_test_split(
-            X, y_encoded, test_size=0.2, random_state=42, stratify=y_encoded
-        )
-        
-        progress(0.1, desc="Scaling features...")
-        scaler = StandardScaler()
-        X_train_scaled = scaler.fit_transform(X_train)
-        X_test_scaled = scaler.transform(X_test)
-        
-        n_classes = len(label_encoder.classes_)
-        
-        training_log = ""
-        
-        if use_ga:
-            progress(0.2, desc="Initializing GA...")
-            
-            X_train_ga, X_val_ga, y_train_ga, y_val_ga = train_test_split(
-                X_train_scaled, y_train, test_size=0.2, random_state=42, stratify=y_train
-            )
-            
-            ga = GeneticAlgorithm(X_train_ga, y_train_ga, n_features_to_select=80)
-            ga.population_size = ga_population
-            ga.n_generations = ga_generations
-            
-            best_config = ga.evolve(
-                X_train_ga, y_train_ga, X_val_ga, y_val_ga,
-                progress_callback=lambda p, desc: progress(0.2 + 0.6*p, desc=desc),
-                n_jobs=n_jobs
-            )
-            
-            # Collect logs
-            training_log = "\n".join(ga.log_messages)
-            
-            progress(0.8, desc="Training final models with GA config...")
-            
-            selected_indices = best_config['feature_indices']
-            X_train_selected = X_train_scaled[:, selected_indices]
-            X_test_selected = X_test_scaled[:, selected_indices]
-            
-            xgb_model = XGBClassifier(
-                n_estimators=best_config['xgb_n_estimators'],
-                max_depth=best_config['xgb_max_depth'],
-                learning_rate=best_config['xgb_learning_rate'],
-                objective='multi:softprob',
-                num_class=n_classes,
-                random_state=42,
-                n_jobs=-1,
-                verbosity=0
-            )
-            xgb_model.fit(X_train_selected, y_train)
-            xgb_acc = xgb_model.score(X_test_selected, y_test)
-            
-            lgbm_model = LGBMClassifier(
-                n_estimators=best_config['lgbm_n_estimators'],
-                num_leaves=best_config['lgbm_num_leaves'],
-                learning_rate=best_config['lgbm_learning_rate'],
-                objective='multiclass',
-                num_class=n_classes,
-                random_state=42,
-                n_jobs=-1,
-                verbose=-1
-            )
-            lgbm_model.fit(X_train_selected, y_train)
-            lgbm_acc = lgbm_model.score(X_test_selected, y_test)
-            
-            gb_model = GradientBoostingClassifier(
-                n_estimators=best_config['gb_n_estimators'],
-                max_depth=best_config['gb_max_depth'],
-                learning_rate=best_config['gb_learning_rate'],
-                random_state=42
-            )
-            gb_model.fit(X_train_selected, y_train)
-            gb_acc = gb_model.score(X_test_selected, y_test)
-            
-            ada_model = AdaBoostClassifier(
-                n_estimators=best_config['ada_n_estimators'],
-                learning_rate=best_config['ada_learning_rate'],
-                algorithm='SAMME',
-                random_state=42
-            )
-            ada_model.fit(X_train_selected, y_train)
-            ada_acc = ada_model.score(X_test_selected, y_test)
-            
-            weights = best_config['weights']
-            
-            ga_summary = f"""
-### 🧬 GA Optimization Results:
-- **Generations Completed**: {len(ga.history)}/{ga_generations}
-- **Population Size**: {ga_population}
-- **Best Fitness**: {ga.best_fitness:.4f}
-- **Parallel Jobs**: {n_jobs}
-
-### 🎯 Best Configuration:
-- **XGBoost**: n_est={best_config['xgb_n_estimators']}, depth={best_config['xgb_max_depth']}, lr={best_config['xgb_learning_rate']}
-- **LightGBM**: n_est={best_config['lgbm_n_estimators']}, leaves={best_config['lgbm_num_leaves']}, lr={best_config['lgbm_learning_rate']}
-- **Gradient Boosting**: n_est={best_config['gb_n_estimators']}, depth={best_config['gb_max_depth']}, lr={best_config['gb_learning_rate']}
-- **AdaBoost**: n_est={best_config['ada_n_estimators']}, lr={best_config['ada_learning_rate']}
-"""
-            
-            ga_history_df = pd.DataFrame(ga.history)
-            
-        else:
-            progress(0.3, desc="Selecting features (variance)...")
-            
-            feature_variance = np.var(X_train_scaled, axis=0)
-            selected_indices = np.argsort(feature_variance)[-80:]
-            
-            X_train_selected = X_train_scaled[:, selected_indices]
-            X_test_selected = X_test_scaled[:, selected_indices]
-            
-            progress(0.4, desc="Training XGBoost...")
-            xgb_model = XGBClassifier(
-                n_estimators=150, max_depth=5, learning_rate=0.1,
-                objective='multi:softprob', num_class=n_classes,
-                random_state=42, n_jobs=-1, verbosity=0
-            )
-            xgb_model.fit(X_train_selected, y_train)
-            xgb_acc = xgb_model.score(X_test_selected, y_test)
-            
-            progress(0.5, desc="Training LightGBM...")
-            lgbm_model = LGBMClassifier(
-                n_estimators=150, num_leaves=40, learning_rate=0.1,
-                objective='multiclass', num_class=n_classes,
-                random_state=42, n_jobs=-1, verbose=-1
-            )
-            lgbm_model.fit(X_train_selected, y_train)
-            lgbm_acc = lgbm_model.score(X_test_selected, y_test)
-            
-            progress(0.65, desc="Training Gradient Boosting...")
-            gb_model = GradientBoostingClassifier(
-                n_estimators=100, max_depth=4, learning_rate=0.1, random_state=42
-            )
-            gb_model.fit(X_train_selected, y_train)
-            gb_acc = gb_model.score(X_test_selected, y_test)
-            
-            progress(0.8, desc="Training AdaBoost...")
-            ada_model = AdaBoostClassifier(
-                n_estimators=100, learning_rate=1.0, algorithm='SAMME', random_state=42
-            )
-            ada_model.fit(X_train_selected, y_train)
-            ada_acc = ada_model.score(X_test_selected, y_test)
-            
-            accuracies = [xgb_acc, lgbm_acc, gb_acc, ada_acc]
-            weights = np.array(accuracies) / sum(accuracies)
-            
-            ga_summary = "\n### ⚡ Simple Training (No GA)\n"
-            ga_history_df = None
-            training_log = "Simple training mode - no GA logs"
-        
-        progress(0.9, desc="Creating ensemble...")
-        
-        predictions = [
-            xgb_model.predict_proba(X_test_selected),
-            lgbm_model.predict_proba(X_test_selected),
-            gb_model.predict_proba(X_test_selected),
-            ada_model.predict_proba(X_test_selected)
-        ]
-        
-        ensemble_pred = np.average(predictions, axis=0, weights=weights)
-        ensemble_labels = np.argmax(ensemble_pred, axis=1)
-        ensemble_acc = accuracy_score(y_test, ensemble_labels)
-        
-        progress(0.95, desc="Saving models...")
-        
-        os.makedirs('weights', exist_ok=True)
-        
-        with open('weights/xgboost_model.pkl', 'wb') as f:
-            pickle.dump(xgb_model, f)
-        with open('weights/lightgbm_model.pkl', 'wb') as f:
-            pickle.dump(lgbm_model, f)
-        with open('weights/gradientboost_model.pkl', 'wb') as f:
-            pickle.dump(gb_model, f)
-        with open('weights/adaboost_model.pkl', 'wb') as f:
-            pickle.dump(ada_model, f)
-        with open('weights/scaler.pkl', 'wb') as f:
-            pickle.dump(scaler, f)
-        with open('weights/label_encoder.pkl', 'wb') as f:
-            pickle.dump(label_encoder, f)
-        
-        config = {
-            'selected_features': selected_indices.tolist(),
-            'ensemble_weights': weights.tolist(),
-            'n_features': len(selected_indices),
-            'emotions': label_encoder.classes_.tolist(),
-            'model_accuracies': {
-                'xgboost': float(xgb_acc),
-                'lightgbm': float(lgbm_acc),
-                'gradientboosting': float(gb_acc),
-                'adaboost': float(ada_acc),
-                'ensemble': float(ensemble_acc)
-            }
-        }
-        
-        with open('weights/config.json', 'w') as f:
-            json.dump(config, f, indent=2)
-        
-        progress(1.0, desc="Complete!")
-        
-        results_df = pd.DataFrame({
-            'Model': ['XGBoost', 'LightGBM', 'Gradient Boosting', 'AdaBoost', 'Ensemble'],
-            'Test Accuracy': [xgb_acc, lgbm_acc, gb_acc, ada_acc, ensemble_acc]
-        })
-        
-        summary = f"""
-## ✅ Training Complete!
-
-{ga_summary}
-
-### 📊 Model Performance:
-- **XGBoost**: {xgb_acc:.4f}
-- **LightGBM**: {lgbm_acc:.4f}
-- **Gradient Boosting**: {gb_acc:.4f}
-- **AdaBoost**: {ada_acc:.4f}
-- **Ensemble**: {ensemble_acc:.4f} ⭐
-
-### ⚖️ Ensemble Weights:
-{dict(zip(['XGBoost', 'LightGBM', 'GradientBoosting', 'AdaBoost'], [f'{w:.3f}' for w in weights]))}
-
-### 💾 Saved Files:
-- `weights/xgboost_model.pkl`
-- `weights/lightgbm_model.pkl`
-- `weights/gradientboost_model.pkl`
-- `weights/adaboost_model.pkl`
-- `weights/scaler.pkl`
-- `weights/label_encoder.pkl`
-- `weights/config.json`
-
-✅ **Models ready for prediction!**
-"""
-        
-        return summary, results_df, ga_history_df, training_log
-        
-    except Exception as e:
-        import traceback
-        error_trace = traceback.format_exc()
-        return f"❌ Training failed: {str(e)}\n\n{error_trace}", None, None, ""
-
-
-# ============================================================================
-# TAB 3: PREDICTION (UNCHANGED)
-# ============================================================================
-
-def predict_emotion_tab(audio_file):
-    """Predict emotion from audio"""
-    
-    if audio_file is None:
-        return "Please upload an audio file", None, None, None
-    
-    if not os.path.exists('weights/config.json'):
-        return "❌ Models not trained! Go to Tab 2 first.", None, None, None
-    
-    try:
-        from src.ensemble_model import EnsembleEmotionRecognizer
-        from src.feature_extraction import extract_features
-        from src.utils import create_waveform_plot, create_spectrogram_plot, get_emotion_emoji
-        
-        model = EnsembleEmotionRecognizer(weights_dir='weights')
-        features, y, sr = extract_features(audio_file)
-        emotion, confidence, prob_dict = model.predict_with_confidence(features)
-        emoji = get_emotion_emoji(emotion)
-        
-        result_text = f"""
-## Prediction Result
-
-### {emoji} **{emotion.upper()}**
-
-**Confidence: {confidence*100:.1f}%**
-
-### Probability Distribution:
-"""
-        for emo, prob in sorted(prob_dict.items(), key=lambda x: x[1], reverse=True):
-            bar = '█' * int(prob * 30) + '░' * (30 - int(prob * 30))
-            result_text += f"\n**{emo.capitalize()}**: {bar} {prob*100:.2f}%"
-        
-        prob_chart = {k.capitalize(): v for k, v in prob_dict.items()}
-        waveform_fig = create_waveform_plot(y, sr)
-        spectrogram_fig = create_spectrogram_plot(y, sr)
-        
-        return result_text, prob_chart, waveform_fig, spectrogram_fig
-        
-    except Exception as e:
-        import traceback
-        error_trace = traceback.format_exc()
-        return f"❌ Prediction failed: {str(e)}\n\n{error_trace}", None, None, None
-
-
-# ============================================================================
-# GRADIO INTERFACE
-# ============================================================================
-
-custom_css = """
+# Custom CSS
+CUSTOM_CSS = """
 .gradio-container {
     font-family: 'Inter', 'Arial', sans-serif;
     max-width: 1400px;
@@ -866,8 +36,14 @@ custom_css = """
 }
 """
 
-with gr.Blocks(css=custom_css, theme=gr.themes.Soft(), title="Speech Emotion Recognition") as demo:
+# Create Gradio interface
+with gr.Blocks(
+    css=CUSTOM_CSS, 
+    theme=gr.themes.Soft(), 
+    title="Speech Emotion Recognition"
+) as demo:
     
+    # Header
     gr.HTML("""
         <div class="header">
             <h1>🎤 Speech Emotion Recognition</h1>
@@ -875,274 +51,46 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft(), title="Speech Emotion Rec
         </div>
     """)
     
-    # ========================================================================
-    # TAB 1: FEATURE EXTRACTION (SIMPLIFIED - NO DUMMY DATA)
-    # ========================================================================
-    
-    with gr.Tab("1️⃣ Feature Extraction"):
-        gr.Markdown("""
-        ## 📁 Extract Features from Dataset
-        
-        Upload your audio files (.wav format) to create the feature dataset.
-        
-        **Supported formats:**
-        - RAVDESS format: `03-01-06-01-02-01-12.wav`
-        - Custom format with emotion in filename
-        """)
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                uploaded_files = gr.File(
-                    label="📤 Upload Audio Files (.wav)",
-                    file_count="multiple",
-                    type="filepath",
-                    file_types=[".wav"]
-                )
-                
-                extract_dataset_btn = gr.Button(
-                    "🔊 Extract Dataset Features",
-                    variant="primary",
-                    size="lg"
-                )
-                
-                gr.Markdown("""
-                ---
-                ### 🔍 Preview Single Audio
-                
-                Test feature extraction on a single file before processing the entire dataset.
-                """)
-                
-                preview_audio = gr.Audio(
-                    sources=["upload"],
-                    type="filepath",
-                    label="Upload Single File"
-                )
-                preview_btn = gr.Button("Preview Features")
-            
-            with gr.Column(scale=2):
-                extract_output = gr.Markdown()
-                feature_preview_df = gr.Dataframe(label="Dataset Preview (First 20 rows)")
-                emotion_distribution = gr.Label(label="Emotion Distribution")
-        
-        with gr.Row():
-            preview_waveform = gr.Plot(label="Waveform")
-            preview_spectrogram = gr.Plot(label="Spectrogram")
-        
-        extract_dataset_btn.click(
-            fn=extract_dataset_features,
-            inputs=[uploaded_files],
-            outputs=[extract_output, feature_preview_df, emotion_distribution]
-        )
-        
-        preview_btn.click(
-            fn=preview_single_audio,
-            inputs=[preview_audio],
-            outputs=[extract_output, preview_waveform, preview_spectrogram]
-        )
-    
-    # ========================================================================
-    # TAB 2: TRAINING WITH GA (WITH PARALLEL + LOGGING)
-    # ========================================================================
-    
-    with gr.Tab("2️⃣ Model Training"):
-        gr.Markdown("""
-        ## 🧬 Train Models with Genetic Algorithm
-        
-        Optimize feature selection, hyperparameters, and ensemble weights using GA with parallel processing.
-        """)
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                use_ga = gr.Checkbox(
-                    label="Use Genetic Algorithm Optimization",
-                    value=True,
-                    info="GA optimizes features + hyperparameters + ensemble weights"
-                )
-                
-                ga_generations = gr.Slider(
-                    minimum=5,
-                    maximum=50,
-                    value=20,
-                    step=5,
-                    label="GA Generations",
-                    info="More generations = better optimization but slower",
-                    visible=True
-                )
-                
-                ga_population = gr.Slider(
-                    minimum=5,
-                    maximum=30,
-                    value=15,
-                    step=5,
-                    label="GA Population Size",
-                    info="Larger population = more exploration but slower",
-                    visible=True
-                )
-                
-                n_jobs = gr.Slider(
-                    minimum=1,
-                    maximum=8,
-                    value=2,
-                    step=1,
-                    label="Parallel Jobs",
-                    info="Number of CPU cores to use (2 for free tier, 4+ for better hardware)",
-                    visible=True
-                )
-                
-                def toggle_ga_params(use_ga_val):
-                    return (
-                        gr.update(visible=use_ga_val),
-                        gr.update(visible=use_ga_val),
-                        gr.update(visible=use_ga_val)
-                    )
-                
-                use_ga.change(
-                    fn=toggle_ga_params,
-                    inputs=[use_ga],
-                    outputs=[ga_generations, ga_population, n_jobs]
-                )
-                
-                train_btn = gr.Button(
-                    "🚀 Start Training",
-                    variant="primary",
-                    size="lg"
-                )
-                
-                gr.Markdown("""
-                ### 🧬 GA Features:
-                - **✅ Parallel Evaluation**: 2-4x speedup
-                - **✅ Early Stopping**: Auto-stop when converged
-                - **✅ Real-time Logging**: See progress details
-                - **✅ Feature Selection**: 80 best from 162
-                
-                ### ⏱️ Estimated Time:
-                - **With GA (Parallel)**: 30-45 minutes
-                - **Without GA**: 5-10 minutes
-                """)
-            
-            with gr.Column(scale=2):
-                training_output = gr.Markdown()
-                results_table = gr.Dataframe(label="Model Performance")
-                ga_history_table = gr.Dataframe(label="GA Evolution History", visible=True)
-        
-        # Training log output
-        with gr.Accordion("📜 Detailed Training Log", open=False):
-            training_log_output = gr.Textbox(
-                label="Training Log",
-                lines=20,
-                max_lines=30,
-                interactive=False,
-                show_copy_button=True
-            )
-        
-        train_btn.click(
-            fn=train_with_ga,
-            inputs=[use_ga, ga_generations, ga_population, n_jobs],
-            outputs=[training_output, results_table, ga_history_table, training_log_output]
-        )
-    
-    # ========================================================================
-    # TAB 3: PREDICTION (UNCHANGED)
-    # ========================================================================
-    
-    with gr.Tab("3️⃣ Emotion Prediction"):
-        gr.Markdown("""
-        ## 🎯 Predict Emotion from Audio
-        
-        Upload audio to detect emotion using trained ensemble models.
-        """)
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                audio_input_predict = gr.Audio(
-                    sources=["upload", "microphone"],
-                    type="filepath",
-                    label="Upload or Record Audio"
-                )
-                predict_btn = gr.Button(
-                    "🎯 Predict Emotion",
-                    variant="primary",
-                    size="lg"
-                )
-                
-                gr.Markdown("""
-                ### 🎭 Supported Emotions:
-                
-                - 😠 **Angry**
-                - 😌 **Calm**
-                - 🤢 **Disgust**
-                - 😨 **Fearful**
-                - 😊 **Happy**
-                - 😐 **Neutral**
-                - 😢 **Sad**
-                - 😲 **Surprised**
-                """)
-            
-            with gr.Column(scale=2):
-                prediction_output = gr.Markdown()
-                prob_chart = gr.Label(
-                    label="Emotion Probabilities",
-                    num_top_classes=8
-                )
-        
-        with gr.Row():
-            waveform_predict = gr.Plot(label="Waveform")
-            spectrogram_predict = gr.Plot(label="Spectrogram")
-        
-        predict_btn.click(
-            fn=predict_emotion_tab,
-            inputs=[audio_input_predict],
-            outputs=[prediction_output, prob_chart, waveform_predict, spectrogram_predict]
-        )
-    
-    # ========================================================================
-    # FOOTER
-    # ========================================================================
+    # Create tabs
+    create_tab1()
+    create_tab2()
+    create_tab3()
     
+    # Footer
     gr.Markdown("""
     ---
     
     ## 📚 About This System
     
     ### Pipeline:
-    1. **Feature Extraction** → Extract 162 audio features → Save to CSV
+    1. **Feature Extraction** → Extract 162 audio features from dataset
     2. **Model Training** → GA optimizes features + hyperparameters + ensemble weights
     3. **Prediction** → Use trained ensemble to predict emotions
     
-    ### ⚡ Optimizations (Ưu tiên 1):
-    - **✅ No Dummy Data**: Upload real audio files only
+    ### ⚡ Key Features:
+    - **✅ Modular Architecture**: Clean, maintainable code structure
     - **✅ Parallel Processing**: 2-4x speedup with joblib
-    - **✅ Early Stopping**: Stop when GA converges (save ~40% time)
+    - **✅ Early Stopping**: Auto-stop when converged (~40% time savings)
     - **✅ Real-time Logging**: Detailed progress feedback
+    - **✅ Configuration Management**: All settings in one place
     
     ### Models:
-    - **XGBoost**: Extreme Gradient Boosting
-    - **LightGBM**: Light Gradient Boosting Machine
-    - **Gradient Boosting**: Sequential Ensemble Learning
-    - **AdaBoost**: Adaptive Boosting
+    - XGBoost, LightGBM, Gradient Boosting, AdaBoost
     - **Ensemble**: Weighted Soft Voting
     
-    ### Features:
-    - Zero Crossing Rate (1)
-    - Chroma STFT (12)
-    - MFCC (20)
-    - RMS Energy (1)
-    - Mel Spectrogram (128)
-    - **Total**: 162 → **GA selects**: 80
-    
     ### Performance:
     - **With GA**: ~87-90% accuracy
     - **Without GA**: ~82-85% accuracy
-    - **Dataset**: RAVDESS (1,440 samples)
     
     ---
     
-    Built with ❤️ using Gradio | Optimized with Parallel Processing & Early Stopping
+    Built with ❤️ using Gradio | Optimized Architecture
     """)
 
+
 if __name__ == "__main__":
     demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
+        server_name=config.UI_CONFIG['server_name'],
+        server_port=config.UI_CONFIG['server_port'],
         show_error=True
     )