Metadata-Version: 2.4
Name: TrainIQ
Version: 0.1.1
Summary: Universal AutoML Library – end-to-end ML/DL pipelines with a single call.
Home-page: https://github.com/jayeshpandey01/TrainIQ
Author: Jayesh Pandey
Author-email: 
Project-URL: Bug Tracker, https://github.com/jayeshpandey01/TrainIQ/issues
Project-URL: Documentation, https://github.com/jayeshpandey01/TrainIQ#readme
Project-URL: Source Code, https://github.com/jayeshpandey01/TrainIQTrainIQ
Keywords: automl machine-learning deep-learning neural-networks pytorch scikit-learn trainiq
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Science/Research
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: License :: OSI Approved :: MIT License
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Operating System :: OS Independent
Requires-Python: >=3.9
Description-Content-Type: text/markdown
Requires-Dist: numpy>=1.21
Requires-Dist: pandas>=1.3
Requires-Dist: scikit-learn>=1.0
Requires-Dist: torch>=1.12
Requires-Dist: torchvision>=0.13
Requires-Dist: matplotlib>=3.5
Requires-Dist: Pillow>=9.0
Requires-Dist: optuna>=3.0
Provides-Extra: text
Requires-Dist: transformers>=4.20; extra == "text"
Provides-Extra: xgboost
Requires-Dist: xgboost>=1.6; extra == "xgboost"
Provides-Extra: deploy
Requires-Dist: fastapi>=0.100; extra == "deploy"
Requires-Dist: uvicorn[standard]; extra == "deploy"
Provides-Extra: onnx
Requires-Dist: onnx>=1.12; extra == "onnx"
Provides-Extra: all
Requires-Dist: transformers>=4.20; extra == "all"
Requires-Dist: xgboost>=1.6; extra == "all"
Requires-Dist: fastapi>=0.100; extra == "all"
Requires-Dist: uvicorn[standard]; extra == "all"
Requires-Dist: onnx>=1.12; extra == "all"
Requires-Dist: tensorboard>=2.10; extra == "all"
Dynamic: author
Dynamic: classifier
Dynamic: description
Dynamic: description-content-type
Dynamic: home-page
Dynamic: keywords
Dynamic: project-url
Dynamic: provides-extra
Dynamic: requires-dist
Dynamic: requires-python
Dynamic: summary

# 🤖 TrainIQ — Universal AutoML Library

**End-to-end ML/DL pipelines with a single call.** Supports tabular, image, text, and time-series data with automatic model selection, hyperparameter tuning, and deployment.

[![PyPI version](https://badge.fury.io/py/TrainIQ.svg)](https://pypi.org/project/TrainIQ/)
[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

---

## 📋 Table of Contents

- [Installation](#-installation)
- [Quick Start](#-quick-start)
- [Core Features](#-core-features)
- [Detailed API Reference](#-detailed-api-reference)
- [CLI Usage](#-cli-usage)
- [Advanced Features](#-advanced-features)
- [Examples by Data Type](#-examples-by-data-type)
- [Model Zoo](#-model-zoo)
- [Configuration Options](#-configuration-options)
- [Export & Deployment](#-export--deployment)

---

## 🚀 Installation

### Basic Installation
```bash
pip install TrainIQ
```

### With All Features
```bash
pip install TrainIQ[all]
```

### Optional Dependencies
```bash
# For text models
pip install TrainIQ[text]

# For XGBoost
pip install TrainIQ[xgboost]

# For deployment
pip install TrainIQ[deploy]

# For ONNX export
pip install TrainIQ[onnx]
```

---

## ⚡ Quick Start

### 3-Line Training
```python
from trainiq import AutoML, AutoMLConfig

config = AutoMLConfig(data_path="data.csv", target_column="label")
automl = AutoML(config)
results = automl.train()
```

### Make Predictions
```python
predictions = automl.predict(new_data)
```

### Export Model
```python
automl.export(format="onnx")
```

---

## 🎯 Core Features

### 1. **Automatic Data Type Detection**
Automatically identifies your data modality:
- **Tabular**: CSV, Excel, Parquet, JSON
- **Image**: Folder structure with class subdirectories
- **Text**: CSV with text columns
- **Time-Series**: Sequential data with datetime index
- **Audio**: WAV, MP3 files (experimental)

```python
# No need to specify data_type - it's auto-detected!
config = AutoMLConfig(data_path="my_data.csv")
```

### 2. **Automatic Task Detection**
Identifies whether your problem is:
- Classification (binary or multi-class)
- Regression
- Forecasting (time-series)

```python
# Task is automatically detected from your data
automl = AutoML(config)
results = automl.train()  # Automatically chooses classification or regression
```

### 3. **Automatic Model Selection**
Compares multiple models and selects the best:
- **Tabular**: MLP, Random Forest, XGBoost
- **Image**: ResNet18, ResNet50, EfficientNet-B0
- **Text**: TextCNN, DistilBERT
- **Time-Series**: LSTM, Transformer

```python
# Automatically trains and compares multiple models
config = AutoMLConfig(data_path="data.csv", target_column="price")
automl = AutoML(config)
results = automl.train()  # Returns best model
```

### 4. **Automatic Preprocessing**
Handles data preprocessing automatically:
- Missing value imputation
- Categorical encoding (one-hot, label encoding)
- Feature scaling and normalization
- Class imbalance handling

---

## 📚 Detailed API Reference

### AutoMLConfig Class

Central configuration object for all AutoML operations.

#### Data Configuration
```python
config = AutoMLConfig(
    data_path="data.csv",           # Path to dataset (required)
    data_type=None,                 # "tabular", "image", "text", "timeseries" (auto-detected)
    task=None,                      # "classification", "regression", "forecasting" (auto-detected)
    target_column="label",          # Target column name for tabular data
    val_split=0.2,                  # Validation split ratio (default: 0.2)
    test_split=0.0,                 # Test split ratio (default: 0.0)
    max_samples=None,               # Limit dataset size for quick experiments
)
```

#### Model Configuration
```python
config = AutoMLConfig(
    model_family=None,              # "cnn", "transformer", "xgboost"
    model_name=None,                # Specific model: "resnet18", "xgboost"
    num_classes=None,               # Number of classes (auto-detected)
    layers=[256, 128],              # Hidden layer sizes for custom MLP
    activations="relu",             # Activation function: "relu", "gelu", "silu"
    dropout=0.3,                    # Dropout rate (default: 0.3)
    pretrained=True,                # Use pretrained weights (default: True)
)
```

#### Training Configuration
```python
config = AutoMLConfig(
    epochs=50,                      # Number of training epochs
    batch_size=32,                  # Batch size
    learning_rate=1e-3,             # Learning rate
    optimizer="adam",               # "adam", "adamw", "sgd"
    weight_decay=1e-4,              # L2 regularization
    scheduler="cosine",             # LR scheduler: "cosine", "step", None
    early_stopping_patience=7,      # Early stopping patience
    gradient_clip=1.0,              # Gradient clipping threshold
)
```

#### Advanced Features
```python
config = AutoMLConfig(
    cv_folds=1,                     # K-fold cross-validation (>1 enables CV)
    class_weights="auto",           # Handle class imbalance
    lr_finder=False,                # Auto-find optimal learning rate
    ensemble=False,                 # Enable model ensembling
    ensemble_top_n=3,               # Number of models to ensemble
)
```

#### Hyperparameter Tuning
```python
config = AutoMLConfig(
    tune=False,                     # Enable HPO with Optuna
    tune_trials=30,                 # Number of HPO trials
    tune_timeout=None,              # Timeout in seconds
)
```

#### Hardware Configuration
```python
config = AutoMLConfig(
    device=None,                    # "cpu", "cuda", "mps" (auto-detected)
    num_workers=4,                  # DataLoader workers
    pin_memory=True,                # Pin memory for faster GPU transfer
    mixed_precision=True,           # Enable AMP for faster training
)
```

#### Output Configuration
```python
config = AutoMLConfig(
    output_dir="automl_output",     # Output directory
    checkpoint_dir=None,            # Checkpoint directory (default: output_dir/checkpoints)
    save_best_only=True,            # Save only best model
    log_every_n_steps=10,           # Logging frequency
    use_tensorboard=False,          # Enable TensorBoard logging
)
```

#### Export Configuration
```python
config = AutoMLConfig(
    export_format="torchscript",    # "torchscript", "onnx", "both"
    export_path=None,               # Export path (default: output_dir/exported)
)
```

#### Miscellaneous
```python
config = AutoMLConfig(
    seed=42,                        # Random seed for reproducibility
    verbose=True,                   # Enable verbose logging
    extra={},                       # Extra parameters (dict)
)
```

---

### AutoML Class

Main class for training, prediction, and deployment.

#### Initialization
```python
from trainiq import AutoML, AutoMLConfig

# Method 1: With config object
config = AutoMLConfig(data_path="data.csv", target_column="label")
automl = AutoML(config)

# Method 2: With kwargs
automl = AutoML(data_path="data.csv", target_column="label", epochs=100)
```

#### Training
```python
# Basic training
results = automl.train()

# Returns dictionary with:
# - history: Training curves (loss, accuracy per epoch)
# - best_val_acc: Best validation accuracy
# - best_val_loss: Best validation loss
# - best_model_path: Path to saved model
# - epochs_trained: Number of epochs completed
# - eval_metrics: Detailed evaluation metrics

print(f"Best accuracy: {results['best_val_acc']:.4f}")
print(f"Model saved at: {results['best_model_path']}")
```

#### Hyperparameter Tuning
```python
# Enable automatic hyperparameter optimization
config = AutoMLConfig(
    data_path="data.csv",
    target_column="label",
    tune=True,
    tune_trials=50
)
automl = AutoML(config)
results = automl.tune_and_train()
```

#### Prediction
```python
import numpy as np
import pandas as pd

# Predict on numpy array
X_new = np.array([[5.1, 3.5, 1.4, 0.2]])
predictions = automl.predict(X_new)

# Predict on pandas DataFrame
df_new = pd.read_csv("test_data.csv")
predictions = automl.predict(df_new)

# Predict on list of texts (for text models)
texts = ["This is great!", "This is terrible!"]
predictions = automl.predict(texts)

# Get prediction probabilities (classification only)
from automl_lib.inference import Predictor
predictor = Predictor(automl.model, automl.config)
probabilities = predictor.predict_proba(X_new)
```

#### Export
```python
# Export to TorchScript
paths = automl.export(format="torchscript")
print(paths)  # {'torchscript': 'automl_output/exported/model_scripted.pt'}

# Export to ONNX
paths = automl.export(format="onnx")
print(paths)  # {'onnx': 'automl_output/exported/model.onnx'}

# Export to both formats
paths = automl.export(format="both")
print(paths)  # {'torchscript': '...', 'onnx': '...'}
```

#### Deployment
```python
# Generate FastAPI deployment scaffold
api_path = automl.deploy(output_dir="my_api")
print(f"API created at: {api_path}")

# Then run:
# cd my_api
# pip install -r requirements.txt
# uvicorn app:app --reload
```

---

## 💻 CLI Usage

### Command Overview
```bash
automl --help
```

### 1. System Information
```bash
# Check hardware and library info
automl info
```

**Output:**
- Best available device (CPU, CUDA, MPS)
- GPU information
- Memory information
- Library version

### 2. Train Command
```bash
# Basic training
automl train --data data.csv --target label

# With custom parameters
automl train \
  --data housing.csv \
  --target price \
  --task regression \
  --epochs 100 \
  --batch-size 64 \
  --lr 0.001

# With hyperparameter tuning
automl train \
  --data data.csv \
  --target label \
  --tune \
  --tune-trials 50

# Image classification
automl train \
  --data images/ \
  --data-type image \
  --model resnet50 \
  --epochs 200

# Export after training
automl train \
  --data data.csv \
  --target label \
  --export onnx
```

**Available Options:**
- `--data`: Path to dataset (required)
- `--target`: Target column name
- `--task`: Task type (classification, regression, forecasting)
- `--data-type`: Data modality (tabular, image, text, timeseries)
- `--model`: Model name or family
- `--epochs`: Number of epochs (default: 50)
- `--batch-size`: Batch size (default: 32)
- `--lr`: Learning rate (default: 0.001)
- `--optimizer`: Optimizer (adam, adamw, sgd)
- `--tune`: Enable hyperparameter tuning
- `--tune-trials`: Number of HPO trials (default: 30)
- `--output`: Output directory (default: automl_output)
- `--device`: Device (cpu, cuda, mps)
- `--seed`: Random seed (default: 42)
- `--no-pretrained`: Train from scratch
- `--export`: Export format (torchscript, onnx, both)

### 3. Predict Command
```bash
# Make predictions
automl predict \
  --model-path automl_output/checkpoints/best_model.pt \
  --data test.csv \
  --output predictions.csv
```

### 4. Export Command
```bash
# Export to ONNX
automl export \
  --model-path automl_output/checkpoints/best_model.pt \
  --format onnx

# Export to both formats
automl export \
  --model-path model.pt \
  --format both \
  --output exports/
```

### 5. Deploy Command
```bash
# Generate FastAPI app
automl deploy \
  --model-path automl_output/exported/model.onnx \
  --output my_api/

# Then run the API:
cd my_api
pip install -r requirements.txt
uvicorn app:app --reload
```

---

## 🔥 Advanced Features

### 1. Cross-Validation
```python
config = AutoMLConfig(
    data_path="data.csv",
    target_column="label",
    cv_folds=5  # Enable 5-fold cross-validation
)
automl = AutoML(config)
results = automl.train()
```

### 2. Learning Rate Finder
```python
config = AutoMLConfig(
    data_path="data.csv",
    target_column="label",
    lr_finder=True  # Auto-find optimal learning rate
)
automl = AutoML(config)
results = automl.train()
```

### 3. Class Imbalance Handling
```python
config = AutoMLConfig(
    data_path="data.csv",
    target_column="label",
    class_weights="auto"  # Automatically balance classes
)
automl = AutoML(config)
results = automl.train()
```

### 4. Model Ensembling
```python
config = AutoMLConfig(
    data_path="data.csv",
    target_column="label",
    ensemble=True,      # Enable ensembling
    ensemble_top_n=3    # Ensemble top 3 models
)
automl = AutoML(config)
results = automl.train()
```

### 5. Custom Neural Network Architecture
```python
config = AutoMLConfig(
    data_path="data.csv",
    target_column="label",
    layers=[512, 256, 128],  # Custom layer sizes
    activations="gelu",       # GELU activation
    dropout=0.4               # 40% dropout
)
automl = AutoML(config)
results = automl.train()
```

### 6. Mixed Precision Training
```python
config = AutoMLConfig(
    data_path="data.csv",
    target_column="label",
    mixed_precision=True,  # Enable AMP (automatic mixed precision)
    device="cuda"
)
automl = AutoML(config)
results = automl.train()
```

### 7. Custom Callbacks
```python
from automl_lib.callbacks import Callback

class MyCallback(Callback):
    def on_epoch_end(self, epoch, metrics):
        print(f"Epoch {epoch}: Loss={metrics['val_loss']:.4f}")

config = AutoMLConfig(data_path="data.csv", target_column="label")
automl = AutoML(config)

from automl_lib.trainer import Trainer
trainer = Trainer(automl.model, config, callbacks=[MyCallback()])
```

---

## 📊 Examples by Data Type

### 1. Tabular Data (Classification)
```python
from trainiq import AutoML, AutoMLConfig

# Basic classification
config = AutoMLConfig(
    data_path="iris.csv",
    target_column="species",
    epochs=50
)
automl = AutoML(config)
results = automl.train()

# Make predictions
import pandas as pd
test_data = pd.read_csv("test.csv")
predictions = automl.predict(test_data)
```

### 2. Tabular Data (Regression)
```python
config = AutoMLConfig(
    data_path="housing.csv",
    target_column="price",
    task="regression",
    epochs=100,
    tune=True,
    tune_trials=30
)
automl = AutoML(config)
results = automl.train()

print(f"RMSE: {results['eval_metrics']['rmse']:.2f}")
print(f"R²: {results['eval_metrics']['r2']:.4f}")
```

### 3. Image Classification
```python
# Folder structure:
# images/
#   ├── cat/
#   ├── dog/
#   └── bird/

config = AutoMLConfig(
    data_path="images/",
    data_type="image",
    model_name="resnet50",
    epochs=100,
    batch_size=64,
    pretrained=True
)
automl = AutoML(config)
results = automl.train()

# Export for deployment
automl.export(format="onnx")
```

### 4. Text Classification
```python
config = AutoMLConfig(
    data_path="reviews.csv",
    target_column="sentiment",
    data_type="text",
    model_name="distilbert",
    epochs=10,
    batch_size=16
)
automl = AutoML(config)
results = automl.train()

# Predict on new texts
new_reviews = ["This product is amazing!", "Terrible experience"]
predictions = automl.predict(new_reviews)
```

### 5. Time-Series Forecasting
```python
config = AutoMLConfig(
    data_path="stock_prices.csv",
    data_type="timeseries",
    model_name="lstm",
    epochs=100,
    extra={
        "window": 30,    # Look back 30 time steps
        "horizon": 7     # Predict 7 steps ahead
    }
)
automl = AutoML(config)
results = automl.train()
```

---

## 🏗️ Model Zoo

### Tabular Models
| Model | Type | Description |
|-------|------|-------------|
| `tabular_net` | Neural Network | Fully-connected MLP with configurable layers |
| `sklearn_rf` | Random Forest | Scikit-learn Random Forest (fast, interpretable) |
| `sklearn_xgb` | XGBoost | Gradient boosting (high performance) |

### Image Models
| Model | Type | Description |
|-------|------|-------------|
| `resnet18` | CNN | ResNet-18 (11M params, fast) |
| `resnet50` | CNN | ResNet-50 (25M params, accurate) |
| `efficientnet_b0` | CNN | EfficientNet-B0 (5M params, efficient) |

### Text Models
| Model | Type | Description |
|-------|------|-------------|
| `text_cnn` | CNN | 1D CNN for text (fast, lightweight) |
| `distilbert` | Transformer | DistilBERT (66M params, accurate) |

### Time-Series Models
| Model | Type | Description |
|-------|------|-------------|
| `lstm` | RNN | LSTM network (handles sequences) |
| `transformer_ts` | Transformer | Transformer encoder (captures long-range dependencies) |

---

## ⚙️ Configuration Options

### Complete Configuration Example
```python
config = AutoMLConfig(
    # Data
    data_path="data.csv",
    data_type="tabular",
    task="classification",
    target_column="label",
    val_split=0.2,
    test_split=0.1,
    max_samples=10000,
    
    # Model
    model_name="tabular_net",
    layers=[512, 256, 128],
    activations="relu",
    dropout=0.3,
    pretrained=True,
    
    # Training
    epochs=100,
    batch_size=64,
    learning_rate=1e-3,
    optimizer="adamw",
    weight_decay=1e-4,
    scheduler="cosine",
    early_stopping_patience=10,
    gradient_clip=1.0,
    
    # Advanced
    cv_folds=5,
    class_weights="auto",
    lr_finder=True,
    ensemble=True,
    ensemble_top_n=3,
    
    # HPO
    tune=True,
    tune_trials=50,
    tune_timeout=3600,
    
    # Hardware
    device="cuda",
    num_workers=8,
    pin_memory=True,
    mixed_precision=True,
    
    # Output
    output_dir="my_experiment",
    save_best_only=True,
    log_every_n_steps=10,
    use_tensorboard=True,
    
    # Export
    export_format="both",
    
    # Misc
    seed=42,
    verbose=True
)
```

---

## 📦 Export & Deployment

### Export Formats

#### TorchScript
```python
# Export to TorchScript (optimized for production)
paths = automl.export(format="torchscript")

# Load and use
import torch
model = torch.jit.load(paths['torchscript'])
model.eval()
output = model(torch.randn(1, 10))
```

#### ONNX
```python
# Export to ONNX (cross-framework compatibility)
paths = automl.export(format="onnx")

# Load and use with ONNX Runtime
import onnxruntime as ort
session = ort.InferenceSession(paths['onnx'])
output = session.run(None, {'input': input_data})
```

### FastAPI Deployment

#### Generate API
```python
api_path = automl.deploy(output_dir="my_api")
```

#### Generated Structure
```
my_api/
├── app.py              # FastAPI application
├── requirements.txt    # Dependencies
└── Dockerfile         # Docker configuration
```

#### Run API
```bash
cd my_api
pip install -r requirements.txt
uvicorn app:app --reload
```

#### API Endpoints
```python
# Health check
GET http://localhost:8000/health

# Prediction
POST http://localhost:8000/predict
{
    "data": [[5.1, 3.5, 1.4, 0.2]]
}

# Documentation
GET http://localhost:8000/docs
```

#### Docker Deployment
```bash
cd my_api
docker build -t my-ml-api .
docker run -p 8000:8000 my-ml-api
```

---

## 📈 Monitoring & Visualization

### Training Curves
Automatically generated after training:
- `automl_output/training_curves.png`: Loss and accuracy plots

### Confusion Matrix
For classification tasks:
- `automl_output/confusion_matrix.png`: Confusion matrix heatmap

### TensorBoard
```python
config = AutoMLConfig(
    data_path="data.csv",
    target_column="label",
    use_tensorboard=True
)
automl = AutoML(config)
results = automl.train()

# View in TensorBoard
# tensorboard --logdir=automl_output/logs
```

---

## 🔍 Evaluation Metrics

### Classification Metrics
```python
results = automl.train()
metrics = results['eval_metrics']

print(f"Accuracy: {metrics['accuracy']:.4f}")
print(f"F1 Score: {metrics['f1_macro']:.4f}")
print(f"Precision: {metrics['precision_macro']:.4f}")
print(f"Recall: {metrics['recall_macro']:.4f}")
print(f"\nClassification Report:\n{metrics['classification_report']}")
```

### Regression Metrics
```python
results = automl.train()
metrics = results['eval_metrics']

print(f"MSE: {metrics['mse']:.4f}")
print(f"RMSE: {metrics['rmse']:.4f}")
print(f"MAE: {metrics['mae']:.4f}")
print(f"R²: {metrics['r2']:.4f}")
```

---

## 🛠️ Utilities

### Hardware Detection
```python
from trainiq.hardware import detect_device, device_summary

# Detect best device
device = detect_device()
print(f"Using device: {device}")

# Get hardware summary
summary = device_summary()
print(summary)
```

### Logging
```python
from trainiq.utils import get_logger

logger = get_logger("my_app")
logger.info("Training started")
logger.warning("Low memory")
logger.error("Training failed")
```

### Seed Setting
```python
from trainiq.utils import set_seed

set_seed(42)  # For reproducibility
```

### Timer
```python
from trainiq.utils import timer

with timer("Training"):
    automl.train()
```

---

## 🐛 Troubleshooting

### Out of Memory
```python
# Reduce batch size
config = AutoMLConfig(
    data_path="data.csv",
    target_column="label",
    batch_size=16  # Reduce from 32
)
```

### Slow Training
```python
# Enable mixed precision
config = AutoMLConfig(
    data_path="data.csv",
    target_column="label",
    mixed_precision=True,
    device="cuda"
)
```

### Poor Performance
```python
# Enable hyperparameter tuning
config = AutoMLConfig(
    data_path="data.csv",
    target_column="label",
    tune=True,
    tune_trials=50
)
```

### Overfitting
```python
# Increase regularization
config = AutoMLConfig(
    data_path="data.csv",
    target_column="label",
    dropout=0.5,           # Increase dropout
    weight_decay=1e-3,     # Increase weight decay
    early_stopping_patience=5  # Stop earlier
)
```

---

## 📝 Best Practices

1. **Start Simple**: Begin with default parameters
2. **Use Validation Split**: Always use validation data (default 20%)
3. **Enable Tuning**: Use `tune=True` for better results
4. **Monitor Training**: Check training curves for overfitting
5. **Set Random Seed**: Use `seed=42` for reproducibility
6. **Use GPU**: Set `device="cuda"` for faster training
7. **Export Models**: Always export for production deployment
8. **Version Control**: Save configs and results

---

## 🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

---

## 📄 License

This project is licensed under the MIT License.

---

## 🙏 Acknowledgments

Built with:
- PyTorch
- Scikit-learn
- Optuna
- FastAPI
- Transformers

---

## 📞 Support

- **Issues**: [GitHub Issues](https://github.com/Mickey2004/TrainIQ/issues)
- **PyPI**: [https://pypi.org/project/TrainIQ/](https://pypi.org/project/TrainIQ/)

---

**Made with ❤️ by Mickey2004**
# TrainIQ