Upload README.md with huggingface_hub

README.md

@@ -0,0 +1,308 @@
+---
+language:
+  - en
+  - ru
+license: mit
+tags:
+  - pectin
+  - chemical-engineering
+  - machine-learning
+  - regression
+  - biotechnology
+  - food-technology
+  - production-optimization
+  - ml-in-chemistry
+---
+
+# Pectin Production Models
+
+**Machine Learning Models for Predicting Pectin Production Parameters from Process Conditions**
+
+This repository contains trained machine learning models for predicting pectin quality parameters based on production process conditions. The models were trained on experimental data from various raw materials and extraction methods.
+
+## 🎯 Model Overview
+
+### Performance Summary
+
+| Model | Type | R² Score | MAE | Description |
+|-------|------|----------|-----|-------------|
+| **Best Model** | Gradient Boosting | 0.9427 | 868.44 | **Best overall model for pectin production** |
+| Extra Trees | extra_trees | 0.9135 | 1060.1741 | Extra Trees model for pectin parameter prediction |
+| Gradient Boosting | gradient_boosting | 0.9427 | 868.4403 | Gradient Boosting model - best performance for multi-target regression |
+| K-Neighbors | k-neighbors | 0.8684 | 1287.5126 | Machine learning model for pectin production |
+| Lasso Regression | lasso_regression | 0.3846 | 3702.0325 | Lasso Regression model with L1 regularization |
+| Linear Regression | linear_regression | 0.6965 | 3730.7550 | Linear Regression baseline model |
+| MultiLayer Perceptron | multilayer_perceptron | 0.8046 | 4253.8431 | Machine learning model for pectin production |
+| Random Forest | random_forest | 0.9259 | 978.0065 | Random Forest model for robust pectin quality prediction |
+| Ridge Regression | ridge_regression | 0.5553 | 3665.3101 | Ridge Regression model with L2 regularization |
+| Support Vector Regression | support_vector_regression | 0.4832 | 6612.2360 | Machine learning model for pectin production |
+| XGBoost | xgboost | 0.9203 | 1074.2310 | XGBoost model with excellent performance on tabular data |
+
+
+### Best Model Performance
+- **Average R²**: 0.9427
+- **Average MAE**: 868.44
+- **Targets Predicted**: 4 parameters simultaneously
+
+## 📊 Model Details
+
+### Target Variables
+  - `pectin_yield`: Pectin yield (%)
+  - `galacturonic_acid`: Galacturonic acid content (%)
+  - `molecular_weight`: Molecular weight (Da)
+  - `esterification_degree`: Esterification degree (%)
+
+
+### Feature Variables
+  - `time_min`
+  - `temperature_c`
+  - `pressure_atm`
+  - `ph`
+  - `sample_encoded`
+  - `method_encoded`
+
+## 🚀 Quick Start
+
+### Installation
+```bash
+pip install transformers huggingface-hub scikit-learn xgboost pandas numpy joblib
+```
+
+### Basic Usage
+
+
+### Using the Best Model
+
+```python
+from huggingface_hub import hf_hub_download
+import joblib
+import pandas as pd
+import numpy as np
+
+# Download model and supporting files
+model_path = hf_hub_download(
+    repo_id="arabovs-ai-lab/PectinProductionModels",
+    filename="best_model/model.pkl",
+    repo_type="model"
+)
+
+scaler_path = hf_hub_download(
+    repo_id="arabovs-ai-lab/PectinProductionModels", 
+    filename="scaler.pkl",
+    repo_type="model"
+)
+
+encoder_path = hf_hub_download(
+    repo_id="arabovs-ai-lab/PectinProductionModels",
+    filename="label_encoder.pkl", 
+    repo_type="model"
+)
+
+# Load artifacts
+model = joblib.load(model_path)
+scaler = joblib.load(scaler_path)
+with open(encoder_path, 'rb') as f:
+    label_encoder = pickle.load(f)
+
+# Prepare input data
+input_data = {'sample': 'Айв.', 'time_min': 5, 'temperature_c': 120, 'pressure_atm': 1.0, 'ph': 2.5}
+
+# Create DataFrame
+df = pd.DataFrame([input_data])
+
+# Preprocess: encode sample type
+df['sample_encoded'] = label_encoder.transform([input_data['sample']])[0]
+
+# Create method_encoded feature
+df['method_encoded'] = 1 if input_data['time_min'] <= 15 else 0
+
+# Select features in correct order
+features = ['time_min', 'temperature_c', 'pressure_atm', 'ph', 'sample_encoded', 'method_encoded']
+X = df[features]
+
+# Scale features
+X_scaled = scaler.transform(X)
+
+# Make prediction
+predictions = model.predict(X_scaled)
+
+# Create results dictionary
+results = {}
+for i, target in enumerate(['pectin_yield', 'galacturonic_acid', 'molecular_weight', 'esterification_degree']):
+    results[target] = predictions[0, i]
+
+print("Prediction results:")
+for target, value in results.items():
+    print(f"  {target}: {value:.4f}")
+```
+
+### Batch Prediction from File
+
+```python
+import pandas as pd
+from huggingface_hub import hf_hub_download
+import joblib
+import pickle
+
+class PectinPredictor:
+    def __init__(self, repo_id="arabovs-ai-lab/PectinProductionModels"):
+        self.repo_id = repo_id
+        self.model = None
+        self.scaler = None
+        self.label_encoder = None
+        self.feature_columns = ['time_min', 'temperature_c', 'pressure_atm', 'ph', 'sample_encoded', 'method_encoded']
+        self.target_columns = ['pectin_yield', 'galacturonic_acid', 'molecular_weight', 'esterification_degree']
+        
+    def load_from_hub(self):
+        """Load model and artifacts from Hugging Face Hub."""
+        # Download model
+        model_path = hf_hub_download(
+            repo_id=self.repo_id,
+            filename="best_model/model.pkl",
+            repo_type="model"
+        )
+        self.model = joblib.load(model_path)
+        
+        # Download scaler
+        scaler_path = hf_hub_download(
+            repo_id=self.repo_id,
+            filename="scaler.pkl", 
+            repo_type="model"
+        )
+        self.scaler = joblib.load(scaler_path)
+        
+        # Download label encoder
+        encoder_path = hf_hub_download(
+            repo_id=self.repo_id,
+            filename="label_encoder.pkl",
+            repo_type="model"
+        )
+        with open(encoder_path, 'rb') as f:
+            self.label_encoder = pickle.load(f)
+    
+    def predict_batch(self, input_df):
+        """Predict on batch data."""
+        # Preprocessing
+        processed_df = input_df.copy()
+        
+        # Encode sample type
+        processed_df['sample_encoded'] = self.label_encoder.transform(processed_df['sample'])
+        
+        # Create method_encoded
+        processed_df['method_encoded'] = np.where(processed_df['time_min'] <= 15, 1, 0)
+        
+        # Select and scale features
+        X = processed_df[self.feature_columns]
+        X_scaled = self.scaler.transform(X)
+        
+        # Predict
+        predictions = self.model.predict(X_scaled)
+        
+        # Add predictions to results
+        result_df = input_df.copy()
+        for i, target in enumerate(self.target_columns):
+            result_df[f'predicted_{target}'] = predictions[:, i]
+            
+        return result_df
+
+# Usage
+predictor = PectinPredictor()
+predictor.load_from_hub()
+
+# Load your data
+# df = pd.read_excel("your_data.xlsx")
+# results = predictor.predict_batch(df)
+```
+
+### Comparing Different Models
+
+```python
+from huggingface_hub import hf_hub_download
+import joblib
+
+def compare_models(input_data, repo_id="arabovs-ai-lab/PectinProductionModels"):
+    """Compare predictions from different models."""
+    models_to_compare = [
+        "best_model/model.pkl",
+        "gradient_boosting/model.pkl", 
+        "random_forest/model.pkl",
+        "xgboost/model.pkl"
+    ]
+    
+    results = {}
+    
+    for model_path in models_to_compare:
+        model_name = model_path.split('/')[0]
+        
+        # Download model
+        local_path = hf_hub_download(
+            repo_id=repo_id,
+            filename=model_path,
+            repo_type="model"
+        )
+        
+        model = joblib.load(local_path)
+        
+        # Make prediction (assuming preprocessed input)
+        # predictions = model.predict(preprocessed_input)
+        # results[model_name] = predictions
+        
+    return results
+```
+
+
+## 📁 Repository Structure
+
+```
+arabovs-ai-lab/PectinProductionModels/
+├── best_model/                    # Best overall model (Gradient Boosting)
+│   ├── model.pkl                 # Serialized model file
+│   └── metadata.json            # Model metadata
+├── random_forest/                # Random Forest model
+├── gradient_boosting/           # Gradient Boosting model
+├── xgboost/                     # XGBoost model
+├── extra_trees/                 # Extra Trees model
+├── linear_regression/           # Linear Regression model
+├── ridge_regression/            # Ridge Regression model
+├── lasso_regression/            # Lasso Regression model
+├── support_vector_regression/   # SVR model
+├── k_neighbors/                 # K-Neighbors model
+├── multilayer_perceptron/       # MLP model
+├── scaler.pkl                   # Feature scaler
+├── label_encoder.pkl            # Label encoder for categories
+├── model_metadata.json          # Training metadata
+├── models_metadata.json         # All models metadata
+└── README.md                    # This file
+```
+
+## 🧪 Training Information
+
+- **Dataset**: 1000 experimental records
+- **Features**: 6 process parameters
+- **Targets**: 4 quality parameters
+- **Validation**: 80/20 train-test split
+- **Cross-validation**: 5-fold
+- **Best Algorithm**: Gradient Boosting
+
+## 💡 Key Features
+
+- **Multi-target regression**: Predicts 4 parameters simultaneously
+- **Process optimization**: Helps optimize pectin production conditions
+- **Quality prediction**: Estimates pectin quality from process variables
+- **Multiple algorithms**: 10 different ML algorithms for comparison
+
+## 📄 License
+
+MIT License
+
+---
+
+*Last updated: 2025-11-21*  
+*Repository: https://huggingface.co/arabovs-ai-lab/PectinProductionModels*
+
+## 🔗 References
+
+- [Pectin Production Technology](https://en.wikipedia.org/wiki/Pectin)
+- [Scikit-learn](https://scikit-learn.org/)
+- [Hugging Face Hub](https://huggingface.co/docs/hub/)
+