added new data files

README.md

@@ -1,188 +1,124 @@
 ---
-title: Swiper Match
-emoji: 🌍
-colorFrom: purple
-colorTo: green
-sdk: gradio
-sdk_version: 5.31.0
-app_file: app.py
-pinned: false
-short_description: Match cars B2B
-models:
-- mzx/Swiper-Match
+license: mit
+tags:
+- autogluon
+- tabular
+- automotive
+- dealer-prediction
+- swiper-match
+- no-data-leakage
+- gpu-optimized
+language:
+- en
+datasets:
+- custom
+metrics:
+- accuracy
+- top-k-accuracy
+library_name: autogluon
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🚗 Swiper-Match: Car Dealer Prediction Model
 
-# 🚗 Swiper-Match: HuggingFace-Enabled Car Dealer Predictor
+This model predicts which car dealer is most likely to have a specific vehicle based **solely on vehicle characteristics**, ensuring no data leakage from dealer-identifying features.
 
-This Gradio app now uses pretrained models from HuggingFace Hub instead of local models, with automatic fallback support.
+## 🎯 Model Details
 
-## Features
-
-- **Smart Dealer Matching**: Uses trained AutoGluon ML models to predict the best dealers for your car preferences
-- **Interactive Interface**: Easy-to-use web interface with dropdown selections and number inputs
-- **Top-K Predictions**: Get the top 5 recommended dealers with confidence scores
-- **Real-time Predictions**: Instant results as you adjust your car specifications
-- **No Data Leakage**: Models trained with carefully selected features to avoid bias
-
-## How It Works
-
-The app uses a trained AutoGluon TabularPredictor model that:
-
-1. **Takes car specifications** as input (make, model, year, body type, fuel type, etc.)
-2. **Predicts dealer preferences** based on historical car sales and inventory data
-3. **Returns ranked dealers** with confidence scores for each recommendation
+- **Framework**: AutoGluon Tabular v1.3+
+- **Training**: GPU-accelerated ensemble with early stopping
+- **Dealers**: 73 different car dealers
+- **Features**: Vehicle characteristics only (no dealer-identifying info)
+- **No Leakage**: Strict exclusion of 29 dealer-identifying features
 
 ## 🚀 Quick Start
 
-### 1. Install Dependencies
-
-```bash
-pip install -r requirements.txt
-```
-
-### 2. Run the App
-
-```bash
-python app.py
-```
-
-The app will automatically:
-- ✅ Try to load the model from HuggingFace Hub (`mzx/Swiper-Match`)
-- 🔄 Fall back to local AutoGluon models if HF is unavailable
-- 📊 Display which model source is being used in the interface
-
-## 🤗 HuggingFace Integration
-
-### Model Loading Priority:
-
-1. **Primary**: HuggingFace Hub model (`mzx/Swiper-Match`)
-   - Uses custom `AutoGluonSwiperModel` wrapper
-   - Enhanced feature compatibility
-   - No local files required
-
-2. **Fallback**: Local AutoGluon models
-   - Searches in `../../../src/experiments/autogluon/models_swiper_hf/`
-   - Original AutoGluon TabularPredictor interface
-
-### Model Features:
-
-- **No Data Leakage**: Excludes dealer-identifying features
-- **GPU Optimized**: Trained with CUDA acceleration
-- **Ensemble Methods**: XGBoost, Neural Networks, Random Forest
-- **Auto-Stacking**: Combines best models automatically
-
-## 📊 Model Information
-
-The app displays real-time information about:
-- ✅ Model loading status
-- 🔧 Model type (HuggingFace Hub vs Local)
-- 📍 Repository/file location
-- 👥 Number of trained dealers
-- 🎯 Feature engineering approach
-
-## 🔧 Troubleshooting
-
-### If HuggingFace loading fails:
-- Check internet connection
-- Verify `transformers` and `huggingface-hub` are installed
-- The app will automatically fall back to local models
-
-### If both models fail:
-- Ensure AutoGluon is installed: `pip install autogluon.tabular`
-- Check that local model files exist in the expected directory
-- Review the console logs for detailed error messages
-
-## 🚀 Training Your Own Models
-
-To upload new models to HuggingFace Hub:
-
-1. Run the training script:
-```bash
-cd ../../../src/experiments/autogluon/
-python buyer_prediction_v4_hf.py
-```
-
-2. Set your HuggingFace token:
-```bash
-export HF_TOKEN="your_token_here"
-# or add HF_TOKEN=your_token_here to .env file
-```
-
-3. The script will automatically upload to `mzx/Swiper-Match`
-
-## 📝 Example Usage
-
 ```python
-# The app automatically handles model loading and prediction
-# Just use the Gradio interface or call directly:
-
-matcher = CarDealerMatcher(hf_repo="mzx/Swiper-Match", use_hf_hub=True)
-results = matcher.predict_dealers(
-    make="Toyota", model="Camry", year=2020,
-    body_type="Sedan", fuel_type="Petrol", transmission="Automatic",
-    price=25000, odometer=50000, doors=4, seats=5
-)
+from transformers import AutoModel
+import pandas as pd
+
+# Load model
+model = AutoModel.from_pretrained("mzx/Swiper-Match", trust_remote_code=True)
+
+# Prepare input
+vehicle_data = pd.DataFrame({
+    'make': ['Toyota'],
+    'model': ['Camry'],
+    'year': [2020],
+    'vehicle_type': ['Passenger'],
+    'odometer': [50000],
+    'condition': ['Used'],
+    'car_age': [4]
+})
+
+# Get top-5 predictions
+results = model.predict_top_k(vehicle_data, k=5)
+print(f"Most likely dealer: {results['top_prediction']}")
+print(f"Confidence: {results['top_confidence']:.2%}")
+print(f"Top 5: {results['top_k_dict']}")
 ```
 
-## 🎯 Features
+## 📊 Features Used
 
-- **Smart Loading**: Automatic HuggingFace Hub integration
-- **Graceful Fallback**: Local model support when HF is unavailable  
-- **Real-time Status**: Live model information display
-- **Enhanced Compatibility**: Comprehensive feature mapping
-- **Error Handling**: Clear error messages and recovery
+**Vehicle Characteristics**:
+- Make, Model, Year, Variant, Series
+- Body Type, Vehicle Type, Drive Type
+- Engine specs (power, size, cylinders, fuel type)
+- Transmission, Seats, Doors
+- Condition, Odometer reading
 
-## 📚 Dependencies
+**Excluded (No Leakage)**:
+- Dealer names, IDs, locations
+- Geographic information
+- Dealer-specific business features
+- URLs and source identifiers
 
-- `gradio>=4.0.0` - Web interface
-- `transformers>=4.30.0` - HuggingFace model support
-- `huggingface-hub>=0.16.0` - Model downloading
-- `autogluon.tabular>=1.0.0` - Local model fallback
-- `torch>=2.0.0` - Neural network support
-- `pandas`, `numpy`, `scikit-learn` - Data processing
+## 🔬 Methodology
 
-## Example Use Cases
+1. **Data Preprocessing**: Removed all 29 dealer-identifying features
+2. **Balanced Training**: Oversampling ensures all dealers represented
+3. **GPU Training**: CUDA-accelerated with ensemble methods
+4. **Early Stopping**: Prevents overfitting, optimizes training time
+5. **Auto-Stacking**: AutoGluon combines best models automatically
 
-- **Car Buyers**: Find dealers most likely to have your dream car
-- **Market Research**: Understand dealer-vehicle relationships
-- **Inventory Planning**: Predict which dealers to approach for specific vehicles
+## 📈 Performance
 
-## Technical Details
+- **Training Data**: 34a7fad7... hash
+- **GPU Enabled**: True
+- **Models**: Ensemble of XGBoost, Neural Networks, CatBoost, Random Forest
+- **Accuracy**: Top-1 and Top-5 accuracy on vehicle-dealer matching
 
-The model uses these key features for prediction:
-- Vehicle specifications (make, model, year, body type)
-- Technical details (fuel type, transmission, engine specs)
-- Market factors (price range, mileage, physical attributes)
+## ⚠️ Limitations
 
-**Note**: The model deliberately excludes dealer-identifying features to prevent data leakage and ensure fair predictions based on vehicle characteristics alone.
+- Predictions based on historical patterns in training data
+- Performance depends on similarity to training distribution  
+- May not generalize to dealers not seen during training
+- Results are for research/demonstration purposes
 
-## Development
+## 🔧 Technical Implementation
 
-### Project Structure
-```
-swiper-match/
-├── src/experiments/autogluon/     # Model training code
-├── huggingface-frontend/Swiper-match/  # Gradio app
-│   ├── app.py                     # Main Gradio application
-│   ├── requirements.txt           # Python dependencies
-│   └── README.md                  # This file
-└── data/                          # Training data
-```
+- **AutoGluon Backend**: High-performance ensemble learning
+- **HuggingFace Wrapper**: Seamless integration with HF ecosystem
+- **GPU Optimization**: CUDA acceleration for training and inference
+- **Smart Caching**: Efficient model storage and loading
 
-### Extending the App
+## 📝 Citation
 
-To add new features:
+```bibtex
+@misc{swiper-match-2024,
+  title={Swiper-Match: GPU-Optimized Car Dealer Prediction},
+  author={Swiper-Match Team},
+  year={2024},
+  publisher={HuggingFace},
+  url={https://huggingface.co/mzx/Swiper-Match}
+}
+```
 
-1. **Modify the input form** in `app.py` by adding new Gradio components
-2. **Update the prediction function** to handle new inputs
-3. **Enhance the model** by retraining with additional features
-4. **Improve the UI** by customizing the Gradio Blocks interface
+## 🤝 Usage Guidelines
 
-## Support
+This model is designed for:
+- Research and educational purposes
+- Automotive market analysis
+- Dealer recommendation systems
+- Machine learning demonstrations
 
-For issues or questions:
-1. Check the model loading logs for detailed error messages
-2. Verify all dependencies are correctly installed
-3. Ensure the trained model files exist in the expected location
+**Please ensure compliance with applicable data privacy and usage regulations.**

app_new.py

@@ -49,10 +49,12 @@ def create_app():
         
         # Create tabs
         with gr.Tabs():
+            simple_search_tab = create_simple_search_tab(matcher)
+            traditional_tab = create_traditional_tab(matcher)
             simple_tab = create_simple_tab(simple_matcher)
             detailed_tab = create_detailed_tab(matcher)
-            traditional_tab = create_traditional_tab(matcher)
-            simple_search_tab = create_simple_search_tab(matcher)
+            
+            
         
         # Model Information Footer
         gr.Markdown("---")

core/matcher.py

@@ -274,11 +274,18 @@ class CarDealerMatcher:
             return '4 Door'
 
     def load_data_files(self):
-        """Load available CSV data files"""
+        """Load available CSV data files with combined data first"""
         try:
             if os.path.exists(DATA_DIR):
                 csv_files = glob.glob(os.path.join(DATA_DIR, "*.csv"))
-                self.data_files = [os.path.basename(f) for f in csv_files]
+                file_names = [os.path.basename(f) for f in csv_files]
+                
+                # Sort files to ensure Combined_Car_Listings.csv appears first
+                combined_files = [f for f in file_names if 'Combined' in f or 'combined' in f]
+                other_files = [f for f in file_names if 'Combined' not in f and 'combined' not in f]
+                
+                # Put combined files first, then sort the rest alphabetically
+                self.data_files = sorted(combined_files) + sorted(other_files)
                 logger.info(f"✅ Found {len(self.data_files)} CSV files: {self.data_files}")
             else:
                 self.data_files = []

ui/tabs/simple_search_tab.py

@@ -9,7 +9,7 @@ from core.config import CAR_MAKES, MAKE_MODEL_DATA, DEFAULT_VALUES
 def create_simple_search_tab(matcher):
     """Create the simple traditional search tab"""
     
-    with gr.Tab("🔍 Traditional Simple Search"):
+    with gr.Tab("1️⃣ SQL Search Simple"):
         gr.Markdown("### Quick CSV Data Search")
         gr.Markdown("Simple search through car listing CSV files with basic filters")
         

ui/tabs/traditional_tab.py

@@ -9,7 +9,7 @@ from core.config import DEFAULT_VALUES
 def create_traditional_tab(matcher):
     """Create the traditional search tab"""
     
-    with gr.Tab("📊 Traditional Search"):
+    with gr.Tab("2️⃣ SQL Search Detailed"):
         gr.Markdown("### CSV Data File Search")
         gr.Markdown("Search through car listing CSV files and rank dealers by inventory size")