Universal AutoML Library – end-to-end ML/DL pipelines with a single call.

These details have not been verified by PyPI

Project links

Project description

🤖 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.

🚀 Installation

Basic Installation

pip install TrainIQ

With All Features

pip install TrainIQ[all]

Optional Dependencies

# 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

from automl_lib import AutoML, AutoMLConfig

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

Make Predictions

predictions = automl.predict(new_data)

Export Model

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)

# 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)

# 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

# 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

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

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

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

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

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

Hardware Configuration

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

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

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

Miscellaneous

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

from automl_lib 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

# 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

# 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

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

# 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

# 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

automl --help

1. System Information

# Check hardware and library info
automl info

Output:

Best available device (CPU, CUDA, MPS)
GPU information
Memory information
Library version

2. Train Command

# 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

# Make predictions
automl predict \
  --model-path automl_output/checkpoints/best_model.pt \
  --data test.csv \
  --output predictions.csv

4. Export Command

# 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

# 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

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

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

config = AutoMLConfig(
    data_path="data.csv",
    target_column="label",
    class_weights="auto"  # Automatically balance classes
)
automl = AutoML(config)
results = automl.train()

4. Model Ensembling

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

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

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

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)

from automl_lib 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)

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

# 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

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

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

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

# 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

# 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

api_path = automl.deploy(output_dir="my_api")

Generated Structure

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

Run API

cd my_api
pip install -r requirements.txt
uvicorn app:app --reload

API Endpoints

# 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

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

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

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

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

from automl_lib.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

from automl_lib.utils import get_logger

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

Seed Setting

from automl_lib.utils import set_seed

set_seed(42)  # For reproducibility

Timer

from automl_lib.utils import timer

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

🐛 Troubleshooting

Out of Memory

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

Slow Training

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

Poor Performance

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

Overfitting

# 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

Start Simple: Begin with default parameters
Use Validation Split: Always use validation data (default 20%)
Enable Tuning: Use tune=True for better results
Monitor Training: Check training curves for overfitting
Set Random Seed: Use seed=42 for reproducibility
Use GPU: Set device="cuda" for faster training
Export Models: Always export for production deployment
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
PyPI: https://pypi.org/project/TrainIQ/

Made with ❤️ by Mickey2004 #\x00 \x00T\x00r\x00a\x00i\x00n\x00I\x00Q\x00 \x00 \x00

Project details

These details have not been verified by PyPI

Project links

Release history Release notifications | RSS feed

0.1.3

Mar 6, 2026

0.1.1

Mar 5, 2026

This version

0.1.0

Mar 5, 2026

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

trainiq-0.1.0.tar.gz (39.7 kB view details)

Uploaded Mar 5, 2026 Source

Built Distribution

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

trainiq-0.1.0-py3-none-any.whl (45.5 kB view details)

Uploaded Mar 5, 2026 Python 3

File details

Details for the file trainiq-0.1.0.tar.gz.

File metadata

Download URL: trainiq-0.1.0.tar.gz
Upload date: Mar 5, 2026
Size: 39.7 kB
Tags: Source
Uploaded using Trusted Publishing? No
Uploaded via: twine/6.1.0 CPython/3.11.9

File hashes

Hashes for trainiq-0.1.0.tar.gz
Algorithm	Hash digest
SHA256	`888e6b4a08156b9cb009ac4a8eae7048fc761b2e7d11a1a4179802a1eae4434b`
MD5	`3c0b6772db32836ae9e14ee7c915541c`
BLAKE2b-256	`de92ab898beb9a556688c4b7c04577ef2c1b367936ecf20425ad4686e5ee0db7`

See more details on using hashes here.

File details

Details for the file trainiq-0.1.0-py3-none-any.whl.

File metadata

Download URL: trainiq-0.1.0-py3-none-any.whl
Upload date: Mar 5, 2026
Size: 45.5 kB
Tags: Python 3
Uploaded using Trusted Publishing? No
Uploaded via: twine/6.1.0 CPython/3.11.9

File hashes

Hashes for trainiq-0.1.0-py3-none-any.whl
Algorithm	Hash digest
SHA256	`fad8a97002160d452d6599729b5cb280488ff85b144be1de296ef72f7b7926d5`
MD5	`0e12cc1bb33b862c4a6e31988e344250`
BLAKE2b-256	`29c3ede779f45b53f6eba26ec80158e70b2ffb02cfb34de8a051dbb83544f03c`

See more details on using hashes here.

TrainIQ 0.1.0

Navigation

Verified details

Maintainers

Unverified details

Project links

Meta

Classifiers

Project description

🤖 TrainIQ — Universal AutoML Library

📋 Table of Contents

🚀 Installation

Basic Installation

With All Features

Optional Dependencies

⚡ Quick Start

3-Line Training

Make Predictions

Export Model

🎯 Core Features

1. Automatic Data Type Detection

2. Automatic Task Detection

3. Automatic Model Selection

4. Automatic Preprocessing

📚 Detailed API Reference

AutoMLConfig Class

Data Configuration

Model Configuration

Training Configuration

Advanced Features

Hyperparameter Tuning

Hardware Configuration

Output Configuration

Export Configuration

Miscellaneous

AutoML Class

Initialization

Training

Hyperparameter Tuning

Prediction

Export

Deployment

💻 CLI Usage

Command Overview

1. System Information

2. Train Command

3. Predict Command

4. Export Command

5. Deploy Command

🔥 Advanced Features

1. Cross-Validation

2. Learning Rate Finder

3. Class Imbalance Handling

4. Model Ensembling

5. Custom Neural Network Architecture

6. Mixed Precision Training

7. Custom Callbacks

📊 Examples by Data Type

1. Tabular Data (Classification)

2. Tabular Data (Regression)

3. Image Classification

4. Text Classification

5. Time-Series Forecasting

🏗️ Model Zoo

Tabular Models

Image Models

Text Models

Time-Series Models

⚙️ Configuration Options

Complete Configuration Example

📦 Export & Deployment

Export Formats

TorchScript

ONNX

FastAPI Deployment

Generate API

Generated Structure

Run API

API Endpoints

Docker Deployment