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: Молекулярная масса, Mw, Д - Molecular weight (Da)
esterification_degree: Степень этерификации, СЭ, % - Esterification degree (%)

Feature Variables

time_min: Время процесса, t, мин - Extraction time (minutes)
temperature_c: Температура, T, °C - Temperature (°C)
pressure_atm: Давление, P, атм - Pressure (atm)
ph: Кислотность, pH - pH level
sample_encoded: Тип сырья - Raw material type (encoded)
method_encoded: Метод экстракции - Extraction method (encoded: 1 for fast ≤15 min, 0 for slow >15 min)

Note: Parameter Т:Ж (соотношение твердое:жидкое) was excluded from model training because it had a constant value of 1:20 across all experiments and therefore carried no predictive information.

📋 Experimental Data Examples

Sample Experimental Data

Exp	Sample	t, мин	T, °C	P, атм	pH	ПВ, %	ГК, %	Mw, Д	СЭ, %
1	ЯП(М)	7	120	2.08	2.0	25.864	52.706	103773.64	71.17
2	ЯП(М)	7	120	1.74	2.08	24.83	51.645	103098.49	70.015
3	Абр.	5	130	2.09	1.74	14.755	67.55	127235.35	82.813
4	ЯП(М)	7	120	2.05	2.0	26.353	53.804	105994.85	65.415

Raw Material Types

Code	Full Name	Type
Абр.	Абрикосовый (Apricot)	Fruit
Рв.	Ревень (Rhubarb)	Vegetable
Айв.	Айвы (Quince)	Fruit
Ткв.	Тыквенный (Pumpkin)	Vegetable
КрП	Корзинка подсолнечника (Sunflower head)	Plant
ЯП(Ф)	Яблочный пектин Файзобод (Apple Faizobod)	Fruit
ЯП(М)	Яблочный пектин Муминобод (Apple Muminobod)	Fruit

🚀 Quick Start

Installation

pip install transformers huggingface-hub scikit-learn xgboost pandas numpy joblib tabulate

Basic Usage

from huggingface_hub import hf_hub_download
import joblib
import pandas as pd
import numpy as np
import pickle

import warnings
warnings.filterwarnings("ignore", category=UserWarning, module="sklearn")

# 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 (Т:Ж parameter is not required as it was constant)
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 based on extraction time
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 = {}
target_names = ['pectin_yield', 'galacturonic_acid', 'molecular_weight', 'esterification_degree']
for i, target in enumerate(target_names):
    results[target] = predictions[0, i]

print("Prediction results:")
for target, value in results.items():
    print(f"  {target}: {value:.4f}")

🔬 Advanced Model Comparison System

For comprehensive comparison of all available models, use the PectinPredictor class:

import pandas as pd
import numpy as np
from huggingface_hub import hf_hub_download
import joblib
import pickle
import warnings
from sklearn.exceptions import InconsistentVersionWarning
from tabulate import tabulate

# Suppress sklearn version compatibility warnings
warnings.filterwarnings("ignore", category=UserWarning, module="sklearn")
warnings.filterwarnings("ignore", category=UserWarning, module="xgboost")

class PectinPredictor:
    """
    A machine learning model for predicting pectin production parameters
    from experimental conditions using pre-trained models from Hugging Face Hub.
    """
    
    # Available models with descriptions and metadata
    AVAILABLE_MODELS = {
        "best_model": {
            "subfolder": "best_model",
            "description": "🎯 Best overall model (Gradient Boosting) - optimal performance",
            "color": "#FF6B6B"
        },
        "gradient_boosting": {
            "subfolder": "gradient_boosting", 
            "description": "📈 Gradient Boosting - best for multi-task regression",
            "color": "#4ECDC4"
        },
        "random_forest": {
            "subfolder": "random_forest",
            "description": "🌲 Random Forest - reliable and stable",
            "color": "#45B7D1"
        },
        "xgboost": {
            "subfolder": "xgboost", 
            "description": "⚡ XGBoost - high performance on tabular data",
            "color": "#96CEB4"
        },
        "linear_regression": {
            "subfolder": "linear_regression",
            "description": "📊 Linear Regression - basic linear model",
            "color": "#FECA57"
        },
        "extra_trees": {
            "subfolder": "extra_trees",
            "description": "🌳 Extra Trees - extreme random forests",
            "color": "#FF9FF3"
        },
        "k_neighbors": {
            "subfolder": "k-neighbors",
            "description": "📏 K-Neighbors - nearest neighbors method",
            "color": "#54A0FF"
        },
        "lasso_regression": {
            "subfolder": "lasso_regression",
            "description": "🎯 Lasso Regression - L1 regularization",
            "color": "#5F27CD"
        },
        "multilayer_perceptron": {
            "subfolder": "multilayer_perceptron", 
            "description": "🧠 Neural Network MLP - multilayer perceptron",
            "color": "#00D2D3"
        },
        "ridge_regression": {
            "subfolder": "ridge_regression",
            "description": "🏔️ Ridge Regression - L2 regularization", 
            "color": "#FF9F43"
        },
        "support_vector_regression": {
            "subfolder": "support_vector_regression",
            "description": "🔗 Support Vector Regression - support vector method",
            "color": "#A3CB38"
        }
    }
    
    def __init__(self, repo_id="arabovs-ai-lab/PectinProductionModels"):
        """Initialize the predictor with model repository ID."""
        self.repo_id = repo_id
        self.model = None
        self.scaler = None
        self.label_encoder = None
        # Model input features (after preprocessing)
        self.feature_columns = ['time_min', 'temperature_c', 'pressure_atm', 'ph', 'sample_encoded', 'method_encoded']
        # Model output targets (pectin characteristics)
        self.target_columns = ['pectin_yield', 'galacturonic_acid', 'molecular_weight', 'esterification_degree']
        
    def load_from_hub(self, model_type="best_model"):
        """
        Load model, scaler, and label encoder from Hugging Face Hub repository.
        
        Args:
            model_type: Key from AVAILABLE_MODELS to load specific model
        """
        if model_type not in self.AVAILABLE_MODELS:
            raise ValueError(f"Model type '{model_type}' not found. Available: {list(self.AVAILABLE_MODELS.keys())}")
            
        model_info = self.AVAILABLE_MODELS[model_type]
        
        # Download and load the specified model
        model_path = hf_hub_download(
            repo_id=self.repo_id,
            filename=f"{model_info['subfolder']}/model.pkl",
            repo_type="model"
        )
        
        with warnings.catch_warnings():
            warnings.filterwarnings("ignore", category=UserWarning)
            self.model = joblib.load(model_path)
        
        # Download and load the feature scaler for data normalization
        scaler_path = hf_hub_download(
            repo_id=self.repo_id,
            filename="scaler.pkl", 
            repo_type="model"
        )
        self.scaler = joblib.load(scaler_path)
        
        # Download and load the label encoder for sample type conversion
        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 prepare_dataframe(self, df):
        """
        Rename DataFrame columns from Russian to English to match model expectations.
        """
        column_mapping = {
            'Образец \nпектина': 'sample',
            't, мин': 'time_min', 
            'T, °C': 'temperature_c',
            'P, атм': 'pressure_atm',
            'pH': 'ph'
        }
        return df.rename(columns=column_mapping)

    def preprocess_input(self, input_df):
        """
        Preprocess input data for model prediction.
        Applies feature engineering, encoding, and scaling.
        """
        processed_df = input_df.copy()
        
        # Convert sample names to numeric codes using trained label encoder
        processed_df['sample_encoded'] = self.label_encoder.transform(processed_df['sample'])
        
        # Create binary feature indicating extraction method based on time
        processed_df['method_encoded'] = np.where(processed_df['time_min'] <= 15, 1, 0)
        
        # Select features in correct order and apply scaling
        X = processed_df[self.feature_columns]
        X_scaled = self.scaler.transform(X)
        
        return X_scaled
            
    def predict_batch(self, input_df, model_type="best_model"):
        """
        Generate predictions for multiple experimental conditions.
        
        Args:
            input_df: DataFrame containing experimental parameters
            model_type: Which model to use for prediction
            
        Returns:
            Original DataFrame augmented with prediction columns
        """
        # Load specified model if not already loaded or different from current
        if self.model is None or model_type != getattr(self, '_current_model', None):
            self.load_from_hub(model_type)
            self._current_model = model_type
            
        # Preprocess input data
        X_scaled = self.preprocess_input(input_df)
        
        # Generate predictions using the trained model
        predictions = self.model.predict(X_scaled)
        
        # Combine original data with predictions
        result_df = input_df.copy()
        for i, target in enumerate(self.target_columns):
            result_df[f'predicted_{target}'] = predictions[:, i]
            
        return result_df

    def compare_all_models(self, input_data):
        """
        Compare predictions from ALL available machine learning models.
        
        Args:
            input_data: DataFrame or dictionary with input features
            
        Returns:
            DataFrame with predictions from each model for easy comparison
        """
        # Convert single input to DataFrame if needed
        if isinstance(input_data, dict):
            input_df = pd.DataFrame([input_data])
        else:
            input_df = input_data.copy()
            
        # Preprocess input data once for all models
        X_scaled = self.preprocess_input(input_df)
        
        comparison_results = []
        
        for model_name, model_info in self.AVAILABLE_MODELS.items():
            try:
                # Download and load model
                model_path = hf_hub_download(
                    repo_id=self.repo_id,
                    filename=f"{model_info['subfolder']}/model.pkl",
                    repo_type="model"
                )
                
                # Load model with suppressed warnings
                with warnings.catch_warnings():
                    warnings.filterwarnings("ignore", category=UserWarning)
                    model = joblib.load(model_path)
                
                # Generate predictions
                predictions = model.predict(X_scaled)
                
                # Extract predictions for this sample
                result = {
                    'model': model_name,
                    'description': model_info['description']
                }
                
                for i, target in enumerate(self.target_columns):
                    if len(predictions.shape) > 1:
                        result[target] = predictions[0, i]
                    else:
                        result[target] = predictions[i]
                        
                comparison_results.append(result)
                
            except Exception as e:
                print(f"⚠️  Could not load model {model_name}: {e}")
                continue
                
        return pd.DataFrame(comparison_results)

    def create_comparison_tables(self, comparison_df):
        """
        Create formatted comparison tables for easy analysis.
        
        Args:
            comparison_df: DataFrame from compare_all_models()
            
        Returns:
            Dictionary with different formatted tables
        """
        tables = {}
        
        # Table 1: Detailed comparison with all metrics
        detailed_table = comparison_df.copy()
        detailed_table = detailed_table.round(4)
        tables['detailed'] = tabulate(
            detailed_table, 
            headers='keys', 
            tablefmt='grid',
            showindex=False
        )
        
        # Table 2: Summary statistics
        summary_data = []
        for target in self.target_columns:
            values = comparison_df[target]
            summary_data.append({
                'Target': target,
                'Mean': values.mean(),
                'Std': values.std(),
                'Min': values.min(),
                'Max': values.max(),
                'Range': values.max() - values.min()
            })
        
        summary_df = pd.DataFrame(summary_data).round(4)
        tables['summary'] = tabulate(
            summary_df, 
            headers='keys', 
            tablefmt='grid',
            showindex=False
        )
        
        # Table 3: Ranked by pectin yield (most important metric)
        ranked_df = comparison_df.sort_values('pectin_yield', ascending=False).round(4)
        tables['ranked'] = tabulate(
            ranked_df, 
            headers='keys', 
            tablefmt='grid',
            showindex=False
        )
        
        return tables

    def calculate_prediction_metrics(self, df_with_predictions):
        """
        Calculate basic metrics to evaluate prediction quality against actual values.
        """
        metrics = {}
        
        for target in self.target_columns:
            actual_col = None
            # Find the actual value column
            if target == 'pectin_yield':
                actual_col = 'ПВ, %'
            elif target == 'galacturonic_acid':
                actual_col = 'ГК, %'
            elif target == 'molecular_weight':
                actual_col = 'Mw, Д'
            elif target == 'esterification_degree':
                actual_col = 'СЭ, %'
            
            if actual_col and actual_col in df_with_predictions.columns:
                actual = df_with_predictions[actual_col]
                predicted = df_with_predictions[f'predicted_{target}']
                
                # Calculate metrics
                rmse = np.sqrt(np.mean((actual - predicted) ** 2))
                mae = np.mean(np.abs(actual - predicted))
                
                metrics[target] = {
                    'RMSE': rmse,
                    'MAE': mae,
                    'correlation': np.corrcoef(actual, predicted)[0, 1]
                }
        
        return metrics

# Example usage
if __name__ == "__main__":
    # Initialize predictor
    predictor = PectinPredictor()
    
    # Load experimental data
    df = pd.read_excel("/content/ShortExperiments_DataSet.xlsx")
    df_renamed = predictor.prepare_dataframe(df)
    
    print("🔬 PECTIN PRODUCTION MODEL COMPARISON SYSTEM")
    print("=" * 60)
    
    # 1. Batch prediction with best model
    print("\n1. BATCH PREDICTIONS WITH BEST MODEL:")
    print("-" * 40)
    
    results = predictor.predict_batch(df_renamed, model_type="best_model")
    print(f"✅ Processed {len(results)} experiments")
    
    # Calculate prediction quality metrics
    metrics = predictor.calculate_prediction_metrics(results)
    print("\n📊 PREDICTION QUALITY METRICS:")
    for target, metric in metrics.items():
        print(f"   {target}:")
        print(f"     RMSE: {metric['RMSE']:.4f}")
        print(f"     MAE: {metric['MAE']:.4f}")
        print(f"     Correlation: {metric['correlation']:.4f}")
    
    # 2. Compare all models for a single experiment
    print("\n2. COMPARING ALL MODELS FOR SINGLE EXPERIMENT:")
    print("-" * 50)
    
    single_experiment = {
        'sample': 'ЯП(М)', 
        'time_min': 7, 
        'temperature_c': 120, 
        'pressure_atm': 2.08, 
        'ph': 2.0
    }
    
    print(f"🔍 Input parameters: {single_experiment}")
    
    # Compare all models
    comparison_df = predictor.compare_all_models(single_experiment)
    
    # Create and display comparison tables
    tables = predictor.create_comparison_tables(comparison_df)
    
    print("\n📋 DETAILED MODEL COMPARISON:")
    print(tables['detailed'])
    
    print("\n📈 PREDICTION SUMMARY STATISTICS:")
    print(tables['summary'])
    
    print("\n🏆 MODELS RANKED BY PECTIN YIELD:")
    print(tables['ranked'])
    
    # 3. Show available models
    print("\n3. AVAILABLE MODELS:")
    print("-" * 20)
    for model_name, info in predictor.AVAILABLE_MODELS.items():
        print(f"   • {model_name}: {info['description']}")
    
    print(f"\n🎯 Total models available: {len(predictor.AVAILABLE_MODELS)}")
    print(f"✅ Successfully loaded: {len(comparison_df)}")

📁 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 sample types
├── 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 (excluding constant Т:Ж parameter)
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 pectin quality 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
Industrial focus: Specifically designed for pectin production technology

⚠️ Important Notes

Data Requirements:

Supported samples: 7 types as listed above
Parameter ranges:
- Time: 5-180 minutes
- Temperature: 60-160°C
- Pressure: 1.0-5.0 atm
- pH: 1.5-4.0

Limitations:

Models trained on specific raw materials listed above
Accuracy may decrease outside trained parameter ranges
Retraining required for new types of raw materials

📜 Citation

If you use this model in your research, please cite it as:

@misc{PectinProductionModels2025,
  title = {Pectin Production Models: Machine Learning for Predicting Pectin Quality Parameters},
  author = {Arabovs AI Lab},
  year = {2025},
  publisher = {Hugging Face},
  url = {https://huggingface.co/arabovs-ai-lab/PectinProductionModels}
}

📄 License

MIT License

Last updated: 2025-11-21
Repository: https://huggingface.co/arabovs-ai-lab/PectinProductionModels

🔗 References

Downloads last month: -; Downloads are not tracked for this model. How to track

Inference Providers NEW

This model isn't deployed by any Inference Provider. 🙋 Ask for provider support