|
|
--- |
|
|
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`: Молекулярная масса, 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 |
|
|
```bash |
|
|
pip install transformers huggingface-hub scikit-learn xgboost pandas numpy joblib tabulate |
|
|
``` |
|
|
|
|
|
### Basic Usage |
|
|
|
|
|
```python |
|
|
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: |
|
|
|
|
|
```python |
|
|
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: |
|
|
|
|
|
```bibtex |
|
|
@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 |
|
|
|
|
|
- [Pectin Production Technology](https://en.wikipedia.org/wiki/Pectin) |
|
|
- [Scikit-learn](https://scikit-learn.org/) |
|
|
- [Hugging Face Hub](https://huggingface.co/docs/hub/) |
|
|
``` |
