Initial commit with LFS for model file

.gitattributes

@@ -0,0 +1 @@
+*.joblib filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,44 @@
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+ENV/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db

app.py

@@ -0,0 +1,277 @@
+"""
+Gradio UI для предсказания экзопланет
+"""
+
+import gradio as gr
+import pandas as pd
+import joblib
+import os
+import time
+from mapping import ColumnMapper, load_training_columns
+from dotenv import load_dotenv
+
+# Загружаем переменные окружения из .env файла
+load_dotenv()
+
+# Константы
+TRAINING_CSV_PATH = "cumulative_2025.10.03_08.34.41.csv"
+MODEL_PATH = "exoplanet_detector.joblib"
+TOGETHER_API_KEY = os.getenv("TOGETHER_API_KEY", "")
+
+# Загружаем модель и колонки тренировочного датасета
+model = joblib.load(MODEL_PATH)
+training_columns = load_training_columns(TRAINING_CSV_PATH)
+
+# Инициализируем маппер
+mapper = ColumnMapper(api_key=TOGETHER_API_KEY)
+
+
+def predict_exoplanets(uploaded_file):
+    """
+    Process uploaded file and return predictions
+    
+    Args:
+        uploaded_file: Uploaded CSV file
+        
+    Returns:
+        Tuple (results, mapping info, statistics)
+    """
+    start_time = time.time()
+    
+    try:
+        # Load dataset
+        if uploaded_file is None:
+            return None, "Error: Please upload a CSV file", None
+        
+        # Read uploaded file
+        df_uploaded = pd.read_csv(uploaded_file.name, comment='#')
+        
+        info_msg = f"Loaded rows: {len(df_uploaded)}\n"
+        info_msg += f"Columns in uploaded dataset: {len(df_uploaded.columns)}\n\n"
+        
+        # Apply column mapping
+        mapping_start = time.time()
+        info_msg += "Performing column mapping via Llama...\n\n"
+        
+        df_mapped, mapping, mapping_info = mapper.map_dataset(df_uploaded, training_columns)
+        
+        mapping_time = time.time() - mapping_start
+        info_msg += mapping_info + "\n"
+        info_msg += f"Mapping time: {mapping_time:.2f} sec\n\n"
+        
+        # Get features expected by the model
+        try:
+            expected_features = list(model.feature_names_in_)
+            info_msg += f"Model expects {len(expected_features)} features\n\n"
+        except AttributeError:
+            # If feature_names_in_ is not available, use all columns except targets
+            target_cols = ['koi_disposition', 'koi_pdisposition']
+            expected_features = [col for col in training_columns if col not in target_cols]
+            info_msg += f"Using {len(expected_features)} features from training dataset\n\n"
+        
+        # Prepare X with correct columns
+        info_msg += f"Creating DataFrame with {len(expected_features)} columns...\n"
+        
+        # Create empty DataFrame with correct columns
+        X = pd.DataFrame(index=df_mapped.index, columns=expected_features)
+        
+        # Fill columns that exist in df_mapped
+        for col in expected_features:
+            if col in df_mapped.columns:
+                X[col] = df_mapped[col].values
+            else:
+                X[col] = 0.0  # Fill missing columns with zeros
+        
+        # Convert all columns to numeric format
+        X = X.apply(pd.to_numeric, errors='coerce')
+        
+        # Calculate statistics
+        available_cols = [col for col in expected_features if col in df_mapped.columns]
+        missing_cols = [col for col in expected_features if col not in df_mapped.columns]
+        
+        if missing_cols:
+            info_msg += f"Warning: {len(missing_cols)} columns missing (filled with zeros)\n"
+        
+        info_msg += f"DEBUG: X.shape = {X.shape}, expected: ({len(df_mapped)}, {len(expected_features)})\n"
+        
+        # Fill NaN with mean values
+        X = X.fillna(X.mean().fillna(0))
+        
+        info_msg += f"DEBUG: After fillna X.shape = {X.shape}\n"
+        
+        info_msg += f"Data processing: {X.shape}\n"
+        info_msg += f"   Filled: {len(available_cols)} columns, Added zeros: {len(missing_cols)}\n"
+        info_msg += f"Data prepared for model\n\n"
+        
+        # Make predictions
+        pred_start = time.time()
+        
+        # Use numpy array instead of DataFrame to bypass feature name checks
+        X_values = X.values  # Convert to numpy array
+        
+        info_msg += f"DEBUG: X_values.shape = {X_values.shape}\n\n"
+        
+        predictions = model.predict(X_values)
+        predictions_proba = model.predict_proba(X_values)
+        pred_time = time.time() - pred_start
+        
+        info_msg += f"Predictions completed: {len(predictions)} objects in {pred_time:.2f} sec\n"
+        
+        # Create result dataframe
+        df_result = df_uploaded.copy()
+        
+        # Get unique classes from model
+        classes = model.classes_
+        info_msg += f"   Found classes: {list(classes)}\n\n"
+        
+        # Add predictions (text labels)
+        df_result['prediction'] = predictions
+        
+        # Add probabilities for each class
+        for i, class_name in enumerate(classes):
+            df_result[f'confidence_{class_name.replace(" ", "_").lower()}'] = predictions_proba[:, i]
+        
+        # Add mapping information as separate columns
+        if mapping:
+            for src_col, tgt_col in mapping.items():
+                if src_col in df_uploaded.columns and tgt_col in df_mapped.columns:
+                    df_result[f'mapped_as_{tgt_col}'] = df_uploaded[src_col]
+        
+        # Создаем упрощенный вывод с только важными колонками для отображения
+        # Выбираем колонки предсказаний
+        display_columns = ['prediction']
+        for class_name in classes:
+            col_name = f'confidence_{class_name.replace(" ", "_").lower()}'
+            if col_name in df_result.columns:
+                display_columns.append(col_name)
+        
+        # Add mapped columns (if any)
+        mapped_cols = [col for col in df_result.columns if col.startswith('mapped_as_')]
+        display_columns.extend(mapped_cols[:10])  # Show first 10 mapped columns
+        
+        # If no mapped columns, add first 5 original columns
+        if not mapped_cols and len(df_uploaded.columns) > 0:
+            original_cols = [col for col in df_uploaded.columns[:5] if col in df_result.columns]
+            display_columns.extend(original_cols)
+        
+        # Create dataframe for display
+        df_display = df_result[display_columns].copy()
+        
+        total_time = time.time() - start_time
+        
+        # Create statistics by class
+        from collections import Counter
+        pred_counts = Counter(predictions)
+        
+        stats_lines = ["**Prediction Statistics:**\n"]
+        stats_lines.append(f"* Total objects: {len(predictions)}\n")
+        
+        for class_name in classes:
+            count = pred_counts.get(class_name, 0)
+            pct = count / len(predictions) * 100 if len(predictions) > 0 else 0
+            stats_lines.append(f"* {class_name}: {count} ({pct:.1f}%)\n")
+        
+        stats_lines.append(f"\n**Processing time:** {total_time:.2f} seconds\n")
+        stats_lines.append(f"\n**Columns in result:**\n")
+        stats_lines.append(f"* All original columns from uploaded file (with original names)\n")
+        stats_lines.append(f"* `prediction`: Predicted class ({', '.join(classes)})\n")
+        
+        for class_name in classes:
+            col_name = f'confidence_{class_name.replace(" ", "_").lower()}'
+            stats_lines.append(f"* `{col_name}`: Probability of class {class_name}\n")
+        
+        stats_lines.append(f"* Columns `mapped_as_*`: Duplicate mapped columns for reference\n")
+        stats_lines.append(f"\n**Total columns in result:** {len(df_result.columns)}\n")
+        
+        stats = "".join(stats_lines) + f"""
+
+**Mapping completed:** {len(mapping)} columns renamed for model
+
+**Full dataset saved:** All {len(df_result.columns)} columns available for download
+"""
+        
+        # Save full result to temporary file for download
+        output_file = "predictions_result.csv"
+        df_result.to_csv(output_file, index=False)
+        
+        # Return simplified output for display and path to full file
+        return df_display, info_msg, stats, output_file
+        
+    except Exception as e:
+        error_msg = f"Error processing file:\n{str(e)}"
+        import traceback
+        error_msg += f"\n\n{traceback.format_exc()}"
+        return None, error_msg, None, None
+
+
+# Create Gradio interface
+with gr.Blocks(title="Exoplanet Detector", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # Exoplanet Detector
+    
+    Upload a CSV file with data about exoplanet candidates (KOI - Kepler Objects of Interest).
+    
+    **How it works:**
+    1. Upload your dataset with any column structure
+    2. Llama automatically maps your columns to training columns
+    3. Model makes predictions: exoplanet or false positive
+    
+    **Model:** Random Forest Classifier  
+    **Mapping:** Llama 3.3 70B via Together AI
+    
+    **Note:** Processing large datasets (>1000 rows) may take several minutes.
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            file_input = gr.File(
+                label="Upload CSV file",
+                file_types=[".csv"],
+                type="filepath"
+            )
+            submit_btn = gr.Button("Run Prediction", variant="primary", size="lg")
+            
+        with gr.Column(scale=2):
+            mapping_info = gr.Textbox(
+                label="Column Mapping Information",
+                lines=15,
+                max_lines=20
+            )
+    
+    with gr.Row():
+        stats_output = gr.Markdown(label="Statistics")
+    
+    with gr.Row():
+        results_output = gr.Dataframe(
+            label="Prediction Results (main columns)",
+            wrap=True,
+            interactive=False
+        )
+    
+    with gr.Row():
+        download_output = gr.File(
+            label="Download full result with all columns",
+            interactive=False
+        )
+    
+    # Event handler
+    submit_btn.click(
+        fn=predict_exoplanets,
+        inputs=[file_input],
+        outputs=[results_output, mapping_info, stats_output, download_output]
+    )
+    
+    gr.Markdown("""
+    ---
+    ### Tips:
+    - Make sure your CSV file contains data about stellar systems and their characteristics
+    - The more columns match the training dataset, the more accurate the predictions will be
+    - Model trained on NASA Exoplanet Archive data (Kepler Mission)
+    
+    ### Example training dataset columns:
+    `koi_period`, `koi_depth`, `koi_prad`, `koi_teq`, `koi_insol`, `koi_steff`, `koi_slogg`, `koi_srad`, `ra`, `dec`, `koi_kepmag` etc.
+    """)
+
+# Launch application
+if __name__ == "__main__":
+    demo.launch(share=False, server_name="0.0.0.0", server_port=7860)

exoplanet_detector.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4c9ae4d4bb2830473d74b4fd806ba9545785797e895027504c7cf0085fed11d
+size 6900161

mapping.py

@@ -0,0 +1,381 @@
+"""
+Модуль для маппинга колонок загруженного датасета на колонки тренировочного датасета
+используя Llama через Together API
+"""
+
+import pandas as pd
+import os
+import re
+from together import Together
+
+
+def convert_coordinates_to_degrees(value):
+    """
+    Конвертирует координаты из формата HMS/DMS в градусы
+    Примеры: '07h29m25.85s' -> 112.357708 degrees
+             '45d30m15.5s' -> 45.504306 degrees
+    """
+    if pd.isna(value) or isinstance(value, (int, float)):
+        return value
+    
+    value_str = str(value).strip()
+    
+    # Формат HMS (часы:минуты:секунды) для RA
+    hms_match = re.match(r'(\d+)h(\d+)m([\d.]+)s?', value_str)
+    if hms_match:
+        hours = float(hms_match.group(1))
+        minutes = float(hms_match.group(2))
+        seconds = float(hms_match.group(3))
+        return hours * 15 + minutes * 0.25 + seconds * 0.00416667  # 1h = 15°, 1m = 0.25°, 1s = 0.00416667°
+    
+    # Формат DMS (градусы:минуты:секунды) для DEC
+    dms_match = re.match(r'([+-]?)(\d+)d(\d+)m([\d.]+)s?', value_str)
+    if dms_match:
+        sign = -1 if dms_match.group(1) == '-' else 1
+        degrees = float(dms_match.group(2))
+        minutes = float(dms_match.group(3))
+        seconds = float(dms_match.group(4))
+        return sign * (degrees + minutes / 60 + seconds / 3600)
+    
+    # Если не распознали формат, возвращаем NaN
+    return float('nan')
+
+
+class ColumnMapper:
+    def __init__(self, api_key: str):
+        """
+        Initialize column mapper
+        
+        Args:
+            api_key: API key for Together AI
+        """
+        self.client = Together(api_key=api_key)
+        
+        # Built-in synonym dictionary (fallback) - significantly expanded
+        self.known_synonyms = {
+            # Orbital period
+            'pl_orbper': 'koi_period',
+            'orbital_period': 'koi_period',
+            'period': 'koi_period',
+            'pl_orbpererr1': 'koi_period_err1',
+            'pl_orbpererr2': 'koi_period_err2',
+            'pl_orbpererr': 'koi_period_err1',
+            
+            # Transit time/epoch
+            'pl_tranmid': 'koi_time0bk',
+            'transit_time': 'koi_time0bk',
+            'time0': 'koi_time0bk',
+            'epoch': 'koi_time0bk',
+            'pl_tranmiderr1': 'koi_time0bk_err1',
+            'pl_tranmiderr2': 'koi_time0bk_err2',
+            
+            # Transit duration
+            'pl_trandur': 'koi_duration',
+            'pl_trandurh': 'koi_duration',
+            'transit_duration': 'koi_duration',
+            'duration': 'koi_duration',
+            'pl_trandurerr1': 'koi_duration_err1',
+            'pl_trandurerr2': 'koi_duration_err2',
+            
+            # Transit depth
+            'pl_trandep': 'koi_depth',
+            'transit_depth': 'koi_depth',
+            'depth': 'koi_depth',
+            'pl_trandeperr1': 'koi_depth_err1',
+            'pl_trandeperr2': 'koi_depth_err2',
+            
+            # Planet radius
+            'pl_rade': 'koi_prad',
+            'pl_radj': 'koi_prad',
+            'planet_radius': 'koi_prad',
+            'radius': 'koi_prad',
+            'pl_radeerr1': 'koi_prad_err1',
+            'pl_radeerr2': 'koi_prad_err2',
+            'pl_radjerr1': 'koi_prad_err1',
+            'pl_radjerr2': 'koi_prad_err2',
+            
+            # Insolation flux
+            'pl_insol': 'koi_insol',
+            'insolation': 'koi_insol',
+            'insol': 'koi_insol',
+            'pl_insolerr1': 'koi_insol_err1',
+            'pl_insolerr2': 'koi_insol_err2',
+            
+            # Equilibrium temperature
+            'pl_eqt': 'koi_teq',
+            'equilibrium_temp': 'koi_teq',
+            'teq': 'koi_teq',
+            'pl_eqterr1': 'koi_teq_err1',
+            'pl_eqterr2': 'koi_teq_err2',
+            
+            # Stellar effective temperature
+            'st_teff': 'koi_steff',
+            'stellar_teff': 'koi_steff',
+            'star_temp': 'koi_steff',
+            'teff': 'koi_steff',
+            'st_tefferr1': 'koi_steff_err1',
+            'st_tefferr2': 'koi_steff_err2',
+            
+            # Stellar surface gravity
+            'st_logg': 'koi_slogg',
+            'stellar_logg': 'koi_slogg',
+            'surface_gravity': 'koi_slogg',
+            'logg': 'koi_slogg',
+            'st_loggerr1': 'koi_slogg_err1',
+            'st_loggerr2': 'koi_slogg_err2',
+            
+            # Stellar radius
+            'st_rad': 'koi_srad',
+            'stellar_radius': 'koi_srad',
+            'star_radius': 'koi_srad',
+            'st_raderr1': 'koi_srad_err1',
+            'st_raderr2': 'koi_srad_err2',
+            
+            # Stellar mass
+            'st_mass': 'koi_smass',
+            'stellar_mass': 'koi_smass',
+            'st_masserr1': 'koi_smass_err1',
+            'st_masserr2': 'koi_smass_err2',
+            
+            # Kepler magnitude
+            'sy_kepmag': 'koi_kepmag',
+            'kepmag': 'koi_kepmag',
+            'kep_mag': 'koi_kepmag',
+            'sy_kepmaglim': 'koi_kepmag',
+            
+            # Coordinates
+            'ra': 'ra',
+            'ra_deg': 'ra',
+            'rastr': 'ra',
+            'dec': 'dec',
+            'dec_deg': 'dec',
+            'decstr': 'dec',
+            
+            # Model SNR
+            'koi_model_snr': 'koi_model_snr',
+            'snr': 'koi_model_snr',
+            
+            # Impact parameter
+            'pl_imppar': 'koi_impact',
+            'impact': 'koi_impact',
+            'impact_parameter': 'koi_impact',
+            
+            # Additional mappings for error columns
+            'koi_period_err': 'koi_period_err1',
+            'koi_time0bk_err': 'koi_time0bk_err1',
+            'koi_duration_err': 'koi_duration_err1',
+            'koi_depth_err': 'koi_depth_err1',
+            'koi_prad_err': 'koi_prad_err1',
+            'koi_teq_err': 'koi_teq_err1',
+            'koi_insol_err': 'koi_insol_err1',
+            'koi_steff_err': 'koi_steff_err1',
+            'koi_slogg_err': 'koi_slogg_err1',
+            'koi_srad_err': 'koi_srad_err1',
+            'koi_smass_err': 'koi_smass_err1',
+        }
+        
+    def get_column_mapping(self, source_columns: list, target_columns: list) -> dict:
+        """
+        Получает маппинг между колонками источника и целевыми колонками
+        используя LLM
+        
+        Args:
+            source_columns: Список колонок загруженного датасета
+            target_columns: Список колонок тренировочного датасета
+            
+        Returns:
+            Словарь маппинга {source_column: target_column}
+        """
+        # Словарь известных синонимов для точного маппинга
+        known_mappings = """
+Common column name mappings (NASA Exoplanet Archive):
+- pl_orbper, orbital_period, period → koi_period (Orbital Period in days)
+- pl_tranmid, transit_time, time0 → koi_time0bk (Transit Epoch in BJD)
+- pl_trandur, pl_trandurh, transit_duration → koi_duration (Transit Duration in hours)
+- pl_trandep, transit_depth, depth → koi_depth (Transit Depth in ppm)
+- pl_rade, planet_radius, radius → koi_prad (Planetary Radius in Earth radii)
+- pl_insol, insolation, insol → koi_insol (Insolation Flux in Earth flux)
+- pl_eqt, equilibrium_temp, teq → koi_teq (Equilibrium Temperature in K)
+- st_teff, stellar_teff, star_temp → koi_steff (Stellar Effective Temperature in K)
+- st_logg, stellar_logg, surface_gravity → koi_slogg (Stellar Surface Gravity in log10(cm/s^2))
+- st_rad, stellar_radius, star_radius → koi_srad (Stellar Radius in Solar radii)
+- st_mass, stellar_mass, star_mass → koi_smass (Stellar Mass in Solar masses)
+- ra, ra_deg → ra (Right Ascension in degrees)
+- dec, dec_deg → dec (Declination in degrees)
+- pl_bmassj, planet_mass → koi_prad (use radius if mass not available)
+- sy_dist, distance → koi_steff (stellar distance - related to stellar properties)
+"""
+        
+        prompt = f"""You are an expert in NASA Exoplanet Archive data mapping. Map column names from a source dataset to Kepler/KOI target dataset columns.
+
+{known_mappings}
+
+Source columns:
+{source_columns}
+
+Target columns:
+{target_columns}
+
+CRITICAL INSTRUCTIONS:
+1. Use the known mappings above as your PRIMARY reference
+2. Match columns based on physical meaning (e.g., "pl_orbper" = orbital period = "koi_period")
+3. Common prefixes: "pl_" = planet property, "st_" = stellar property, "koi_" = KOI property
+4. If exact match exists in known mappings, USE IT
+5. Only map columns with clear semantic similarity
+6. Return ONLY a Python dictionary: {{"source": "target", ...}}
+7. NO markdown, NO explanations, NO code blocks - just the dictionary
+
+Example: {{"pl_orbper": "koi_period", "st_teff": "koi_steff", "ra": "ra"}}
+
+Mapping:"""
+
+        response = self.client.chat.completions.create(
+            model="meta-llama/Llama-3.3-70B-Instruct-Turbo",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.1,
+            max_tokens=2000
+        )
+        
+        mapping_str = response.choices[0].message.content.strip()
+        
+        # Очистка ответа от возможных markdown блоков
+        if "```" in mapping_str:
+            mapping_str = mapping_str.split("```")[1]
+            if mapping_str.startswith("python"):
+                mapping_str = mapping_str[6:]
+            mapping_str = mapping_str.strip()
+        
+        # Преобразование строки в словарь
+        try:
+            mapping = eval(mapping_str)
+            if not isinstance(mapping, dict):
+                raise ValueError("Response is not a dictionary")
+        except Exception as e:
+            print(f"Error parsing mapping: {e}")
+            print(f"Raw response: {mapping_str}")
+            # Возвращаем пустой маппинг в случае ошибки
+            mapping = {}
+        
+        # Supplement mapping with known synonyms (fallback)
+        # Check source columns that were not mapped by Llama
+        unmapped_sources = [col for col in source_columns if col not in mapping]
+        
+        for src_col in unmapped_sources:
+            src_lower = src_col.lower()
+            
+            # Check exact match with known synonyms
+            if src_lower in self.known_synonyms:
+                target = self.known_synonyms[src_lower]
+                if target in target_columns:
+                    mapping[src_col] = target
+                    continue
+            
+            # Check for partial matches (more sophisticated)
+            # Remove common prefixes/suffixes for comparison
+            src_clean = src_lower.replace('pl_', '').replace('st_', '').replace('sy_', '').replace('koi_', '')
+            
+            for known_src, known_tgt in self.known_synonyms.items():
+                known_clean = known_src.replace('pl_', '').replace('st_', '').replace('sy_', '').replace('koi_', '')
+                
+                # Check if core part matches
+                if src_clean == known_clean or known_clean in src_clean or src_clean in known_clean:
+                    if known_tgt in target_columns:
+                        mapping[src_col] = known_tgt
+                        break
+            
+            # If still not mapped, try fuzzy matching on target columns
+            if src_col not in mapping:
+                for tgt_col in target_columns:
+                    tgt_clean = tgt_col.replace('koi_', '')
+                    # Check if source contains target name
+                    if tgt_clean in src_lower or src_clean == tgt_clean:
+                        mapping[src_col] = tgt_col
+                        break
+            
+        return mapping
+    
+    def apply_mapping(self, df: pd.DataFrame, mapping: dict) -> pd.DataFrame:
+        """
+        Применяет маппинг к датафрейму
+        
+        Args:
+            df: Исходный датафрейм
+            mapping: Словарь маппинга
+            
+        Returns:
+            Датафрейм с переименованными колонками
+        """
+        # Переименовываем только те колонки, которые есть в маппинге
+        df_mapped = df.copy()
+        
+        # Проверяем какие колонки из маппинга действительно есть в датафрейме
+        valid_mapping = {k: v for k, v in mapping.items() if k in df.columns}
+        
+        if valid_mapping:
+            df_mapped = df_mapped.rename(columns=valid_mapping)
+            
+        return df_mapped
+    
+    def map_dataset(self, uploaded_df: pd.DataFrame, target_columns: list) -> tuple:
+        """
+        Полный процесс маппинга датасета
+        
+        Args:
+            uploaded_df: Загруженный датафрейм
+            target_columns: Список колонок тренировочного датасета
+            
+        Returns:
+            Кортеж (mapped_dataframe, mapping_dict, info_message)
+        """
+        # Копируем датафрейм чтобы не изменять оригинал
+        df_work = uploaded_df.copy()
+        
+        # Конвертируем координаты в градусы если они в текстовом формате
+        coord_columns = [col for col in df_work.columns if any(
+            keyword in col.lower() for keyword in ['ra', 'dec', 'coord', 'right_ascension', 'declination']
+        )]
+        
+        for col in coord_columns:
+            # Check first non-empty value
+            first_val = df_work[col].dropna().iloc[0] if len(df_work[col].dropna()) > 0 else None
+            if first_val and isinstance(first_val, str) and ('h' in first_val or 'd' in first_val):
+                # Convert entire column
+                df_work[col] = df_work[col].apply(convert_coordinates_to_degrees)
+        
+        source_columns = df_work.columns.tolist()
+        
+        # Get mapping via LLM
+        mapping = self.get_column_mapping(source_columns, target_columns)
+        
+        # Apply mapping
+        mapped_df = self.apply_mapping(df_work, mapping)
+        
+        # Create info message
+        if mapping:
+            info_msg = f"Successfully mapped {len(mapping)} columns:\n"
+            for src, tgt in mapping.items():
+                info_msg += f"  * {src} -> {tgt}\n"
+        else:
+            info_msg = "Warning: No mapping performed - no matches found between columns\n"
+            info_msg += f"Source columns: {', '.join(source_columns[:5])}...\n"
+        
+        # Check which target columns are missing
+        missing_cols = set(target_columns) - set(mapped_df.columns)
+        if missing_cols:
+            info_msg += f"\nWarning: Missing {len(missing_cols)} target columns (will be filled with NaN)\n"
+        
+        return mapped_df, mapping, info_msg
+
+
+def load_training_columns(csv_path: str) -> list:
+    """
+    Load column names from training dataset
+    
+    Args:
+        csv_path: Path to training dataset CSV file
+        
+    Returns:
+        List of column names
+    """
+    df = pd.read_csv(csv_path, comment='#', nrows=1)
+    return df.columns.tolist()

requirements.txt

@@ -0,0 +1,7 @@
+gradio==4.44.0
+pandas==2.2.2
+scikit-learn==1.5.1
+joblib==1.4.2
+together
+python-dotenv==1.0.1
+numpy==1.26.4