Home / API Reference

API Reference

Comprehensive API documentation for all modules and functions in the AI/ML Framework.

📊 Preprocessing Module

DataAnalyzer

class DataAnalyzer()

Comprehensive dataset analysis and quality assessment.

Methods

analyze_dataset(df: pd.DataFrame, target_column: str = None) -> Dict[str, Any]

Analyze dataset characteristics and quality.

Parameters:
  • df: Input DataFrame
  • target_column: Target column name (optional)
Returns: Dictionary containing analysis results
get_data_quality_score(df: pd.DataFrame) -> float

Calculate data quality score (0-100).

Parameters:
  • df: Input DataFrame
Returns: Quality score

AutoPreprocessor

class AutoPreprocessor(target_column: str, config: Dict[str, Any] = None)

Automated data preprocessing with AI recommendations.

Methods

fit_transform(df: pd.DataFrame) -> Tuple[pd.DataFrame, pd.Series]

Fit preprocessor and transform data.

Parameters:
  • df: Input DataFrame
Returns: Tuple of (X_processed, y_processed)
get_preprocessing_steps() -> List[str]

Get list of preprocessing steps applied.

Returns: List of preprocessing step descriptions

🤖 AutoML Module

AutoMLSelector

class AutoMLSelector(problem_type: str, models: List[str] = None)

Intelligent model selection and training.

Methods

auto_select_and_train(X: pd.DataFrame, y: pd.Series) -> Any

Auto-select and train best model.

Parameters:
  • X: Feature matrix
  • y: Target vector
Returns: Trained best model
create_ensemble(X: pd.DataFrame, y: pd.Series, method: str = 'voting') -> Any

Create ensemble model.

Parameters:
  • X: Feature matrix
  • y: Target vector
  • method: Ensemble method ('voting', 'stacking', 'blending')
Returns: Ensemble model

HyperparameterOptimizer

class HyperparameterOptimizer(problem_type: str)

Advanced hyperparameter optimization using Optuna.

Methods

optimize_model(model: Any, X: pd.DataFrame, y: pd.Series, n_trials: int = 100) -> Tuple[Any, Dict[str, Any]]

Optimize model hyperparameters.

Parameters:
  • model: Base model to optimize
  • X: Feature matrix
  • y: Target vector
  • n_trials: Number of optimization trials
Returns: Tuple of (optimized_model, best_parameters)

🧠 Deep Learning Module

NeuralNetworkDesigner

class NeuralNetworkDesigner()

AI-powered neural network architecture design.

Methods

get_ai_recommendations(input_shape: Tuple, problem_type: str, num_classes: int = None) -> Dict[str, Any]

Get AI-powered architecture recommendations.

Parameters:
  • input_shape: Input shape tuple
  • problem_type: 'classification', 'regression', 'clustering'
  • num_classes: Number of classes (for classification)
Returns: Dictionary containing architecture recommendations
create_network(input_shape: Tuple, layers: List[Dict[str, Any]], problem_type: str, num_classes: int = None) -> Any

Create neural network from layer configuration.

Parameters:
  • input_shape: Input shape tuple
  • layers: List of layer configurations
  • problem_type: Problem type
  • num_classes: Number of classes
Returns: Compiled neural network model

DeepLearningTrainer

class DeepLearningTrainer(model: Any, problem_type: str, framework: str = 'tensorflow')

Multi-framework deep learning trainer.

Methods

train(X: np.ndarray, y: np.ndarray, validation_data: Tuple = None, epochs: int = 100, batch_size: int = 32) -> Dict[str, List]

Train the model.

Parameters:
  • X: Training features
  • y: Training targets
  • validation_data: Validation data tuple
  • epochs: Number of epochs
  • batch_size: Batch size
Returns: Training history dictionary

🔧 Pipeline Module

PipelineCreator

class PipelineCreator()

Automated scikit-learn pipeline creation.

Methods

create_auto_pipeline(df: pd.DataFrame, target_column: str, model: Any = None) -> Pipeline

Create automated pipeline.

Parameters:
  • df: Input DataFrame
  • target_column: Target column name
  • model: Custom model (optional)
Returns: Scikit-learn Pipeline
create_custom_pipeline(df: pd.DataFrame, target_column: str, config: Dict[str, Any]) -> Pipeline

Create custom pipeline with configuration.

Parameters:
  • df: Input DataFrame
  • target_column: Target column name
  • config: Pipeline configuration
Returns: Scikit-learn Pipeline

PipelineManager

class PipelineManager(workspace_dir: str = "ai_ml_workspace")

Advanced pipeline management with versioning.

Methods

register_pipeline(pipeline_id: str, name: str, config: Dict[str, Any], pipeline_object: Any, metrics: Dict[str, float] = None) -> str

Register pipeline in the system.

Parameters:
  • pipeline_id: Unique pipeline identifier
  • name: Pipeline name
  • config: Pipeline configuration
  • pipeline_object: Pipeline object
  • metrics: Performance metrics
Returns: Registered pipeline ID

🌐 API Module

APIGenerator

class APIGenerator(model_path: str, model_id: str = None)

Automatic REST API generation for ML models.

Methods

generate_api(title: str = "ML Model API", description: str = "Auto-generated API", version: str = "1.0.0") -> FastAPI

Generate FastAPI application.

Parameters:
  • title: API title
  • description: API description
  • version: API version
Returns: FastAPI application
add_authentication(api_key: str)

Add API key authentication.

Parameters:
  • api_key: API key for authentication
generate_main_script(output_path: str = "main.py")

Generate main.py script for running API.

Parameters:
  • output_path: Output file path

📊 Visualization Module

MLVisualizer

class MLVisualizer(style: str = 'seaborn-v0_8', figsize: Tuple[int, int] = (12, 8))

Comprehensive ML visualization toolkit.

Methods

plot_data_overview(df: pd.DataFrame, save_path: str = None)

Create comprehensive data overview visualization.

Parameters:
  • df: Input DataFrame
  • save_path: Path to save plot
plot_model_comparison(model_results: Dict[str, Dict[str, float]], metric: str = 'accuracy', save_path: str = None)

Compare multiple models performance.

Parameters:
  • model_results: Model results dictionary
  • metric: Metric to compare
  • save_path: Path to save plot

DashboardBuilder

class DashboardBuilder(title: str = "ML Dashboard", layout: str = "wide")

Interactive dashboard builder for ML experiments.

Methods

create_data_exploration_dashboard(df: pd.DataFrame)

Create data exploration dashboard.

Parameters:
  • df: Input DataFrame
run_dashboard(dashboard_type: str = "experiment", **kwargs)

Run the dashboard.

Parameters:
  • dashboard_type: Type of dashboard
  • **kwargs: Additional arguments

🎯 Utils Module

AIRecommendationsEngine

class AIRecommendationsEngine()

AI-powered recommendations engine.

Methods

generate_comprehensive_report(df: pd.DataFrame, target_column: str = None, current_model: str = None, current_performance: Dict[str, float] = None) -> RecommendationReport

Generate comprehensive recommendation report.

Parameters:
  • df: Input DataFrame
  • target_column: Target column name
  • current_model: Current model type
  • current_performance: Current model performance
Returns: Comprehensive recommendation report

🧪 Experiments Module

ExperimentTracker

class ExperimentTracker(tracking_uri: str = None, experiment_name: str = None, backend: str = "mlflow")

Comprehensive experiment tracking system.

Methods

start_run(run_name: str = None, tags: Dict[str, str] = None) -> str

Start new experiment run.

Parameters:
  • run_name: Run name
  • tags: Run tags
Returns: Run ID
log_params(params: Dict[str, Any])

Log parameters to current run.

Parameters:
  • params: Parameters dictionary
log_metrics(metrics: Dict[str, float], step: int = None)

Log metrics to current run.

Parameters:
  • metrics: Metrics dictionary
  • step: Step number
log_model(model: Any, model_name: str, framework: str = "sklearn")

Log model to current run.

Parameters:
  • model: Model object
  • model_name: Model name
  • framework: Model framework

VersionManager

class VersionManager(storage_path: str = "version_storage")

Advanced version management for ML artifacts.

Methods

save_artifact(artifact_path: str, name: str, version: VersionInfo, artifact_type: str, creator: str = "user", metadata: Dict[str, Any] = None, dependencies: List[str] = None, tags: List[str] = None) -> str

Save artifact with versioning.

Parameters:
  • artifact_path: Path to artifact
  • name: Artifact name
  • version: Version information
  • artifact_type: Artifact type
  • creator: Creator name
  • metadata: Additional metadata
  • dependencies: Dependency artifacts
  • tags: Artifact tags
Returns: Artifact ID

🚀 Quick Functions

quick_preprocess(df: pd.DataFrame, target_column: str) -> Tuple[pd.DataFrame, pd.Series]

Quick preprocessing for common use cases.

Parameters:
  • df: Input DataFrame
  • target_column: Target column name
Returns: Tuple of (X_processed, y_processed)
quick_automl(X: pd.DataFrame, y: pd.Series, problem_type: str = 'classification') -> Any

Quick AutoML for common use cases.

Parameters:
  • X: Feature matrix
  • y: Target vector
  • problem_type: Problem type
Returns: Trained best model
quick_pipeline(df: pd.DataFrame, target_column: str, model: Any = None) -> Pipeline

Quick pipeline creation.

Parameters:
  • df: Input DataFrame
  • target_column: Target column name
  • model: Custom model
Returns: Scikit-learn Pipeline
quick_api(model_path: str, model_id: str = "model") -> APIGenerator

Quick API generation.

Parameters:
  • model_path: Path to saved model
  • model_id: Model identifier
Returns: APIGenerator instance