Machine Learning with Luminal Analytics

Luminal Analytics provides powerful machine learning capabilities that allow you to build, train, and deploy predictive models directly within our platform.

Overview

Our ML platform supports:

• Supervised Learning: Classification and regression models
• Unsupervised Learning: Clustering and anomaly detection
• Time Series: Forecasting and trend analysis
• Natural Language Processing: Text analysis and sentiment detection
• Computer Vision: Image classification and object detection

Getting Started

Prerequisites

• A dataset uploaded to Luminal Analytics
• Basic understanding of machine learning concepts
• Your data should be properly formatted and cleaned

Creating Your First Model

const model = await luminal.ml.models.create({
  name: 'Sales Prediction Model',
  type: 'regression',
  dataset_id: 'ds_1234567890',
  target_column: 'sales_amount',
  feature_columns: ['month', 'region', 'product_category', 'marketing_spend'],
  algorithm: 'random_forest',
});

Supervised Learning

Classification

Predict categorical outcomes like customer segments or product categories.

Example: Customer Churn Prediction

const churnModel = await luminal.ml.models.create({
  name: 'Customer Churn Prediction',
  type: 'classification',
  dataset_id: 'ds_customers',
  target_column: 'churned',
  feature_columns: [
    'tenure_months',
    'monthly_charges',
    'total_charges',
    'contract_type',
    'payment_method',
    'support_tickets',
  ],
  algorithm: 'gradient_boosting',
  train_test_split: 0.8,
  cross_validation: 5,
});

Supported Classification Algorithms:

• Logistic Regression
• Random Forest
• Gradient Boosting
• Support Vector Machines
• Neural Networks

Regression

Predict continuous numerical values like sales amounts or prices.

Example: Sales Forecasting

const salesModel = await luminal.ml.models.create({
  name: 'Monthly Sales Forecast',
  type: 'regression',
  dataset_id: 'ds_sales_history',
  target_column: 'sales_amount',
  feature_columns: [
    'month',
    'seasonal_index',
    'marketing_budget',
    'competitor_price',
    'economic_indicator',
  ],
  algorithm: 'xgboost',
  hyperparameters: {
    max_depth: 6,
    learning_rate: 0.1,
    n_estimators: 100,
  },
});

Supported Regression Algorithms:

• Linear Regression
• Random Forest
• XGBoost
• Neural Networks
• Polynomial Regression

Unsupervised Learning

Clustering

Group similar data points together without predefined labels.

const clusters = await luminal.ml.clustering.create({
  name: 'Customer Segmentation',
  dataset_id: 'ds_customers',
  features: ['age', 'income', 'spending_score', 'frequency'],
  algorithm: 'kmeans',
  n_clusters: 5,
});

Clustering Algorithms:

• K-Means
• DBSCAN
• Hierarchical Clustering
• Gaussian Mixture Models

Anomaly Detection

Identify unusual patterns or outliers in your data.

const anomalies = await luminal.ml.anomaly_detection.create({
  name: 'Fraud Detection',
  dataset_id: 'ds_transactions',
  features: [
    'transaction_amount',
    'time_of_day',
    'merchant_category',
    'user_location',
  ],
  algorithm: 'isolation_forest',
  contamination: 0.05,
});

Time Series Analysis

Forecasting

Predict future values based on historical time series data.

const forecast = await luminal.ml.time_series.create({
  name: 'Revenue Forecast',
  dataset_id: 'ds_monthly_revenue',
  date_column: 'month',
  target_column: 'revenue',
  horizon: 12, // 12 months ahead
  model: 'prophet',
  include_holidays: true,
  seasonality: {
    yearly: true,
    weekly: false,
    daily: false,
  },
});

Time Series Models:

• ARIMA
• Prophet
• LSTM Neural Networks
• Exponential Smoothing

Model Training

Training Process

When you create a model, Luminal Analytics automatically:

1. Data Validation: Checks data quality and completeness
2. Feature Engineering: Creates relevant features automatically
3. Data Splitting: Divides data into training and validation sets
4. Model Training: Trains the selected algorithm
5. Evaluation: Provides performance metrics
6. Hyperparameter Tuning: Optimizes model parameters

Monitoring Training Progress

// Check training status
const status = await luminal.ml.models.get(model.id);
console.log(status.training_status); // 'training', 'completed', 'failed'

// Get training metrics
const metrics = await luminal.ml.models.metrics(model.id);
console.log(metrics);

Model Evaluation

Performance Metrics

Classification Metrics:

• Accuracy
• Precision
• Recall
• F1 Score
• ROC AUC
• Confusion Matrix

Regression Metrics:

• Mean Absolute Error (MAE)
• Mean Squared Error (MSE)
• Root Mean Squared Error (RMSE)
• R-squared
• Mean Absolute Percentage Error (MAPE)

Model Validation

// Get detailed evaluation results
const evaluation = await luminal.ml.models.evaluate(model.id);

console.log({
  accuracy: evaluation.accuracy,
  precision: evaluation.precision,
  recall: evaluation.recall,
  f1_score: evaluation.f1_score,
  confusion_matrix: evaluation.confusion_matrix,
});

Making Predictions

Batch Predictions

Predict on multiple records at once:

const predictions = await luminal.ml.models.predict(model.id, {
  dataset_id: 'ds_new_customers',
  output_format: 'json',
});

Real-time Predictions

Make single predictions via API:

const prediction = await luminal.ml.models.predict_single(model.id, {
  tenure_months: 24,
  monthly_charges: 85.5,
  total_charges: 2052.0,
  contract_type: 'month_to_month',
  payment_method: 'credit_card',
  support_tickets: 2,
});

console.log(prediction);
// { prediction: 0.15, confidence: 0.87 }

Model Deployment

API Endpoints

Once trained, models are automatically available via REST API:

POST /v1/models/{model_id}/predict
Content-Type: application/json

{
  "features": {
    "tenure_months": 24,
    "monthly_charges": 85.50,
    "total_charges": 2052.00
  }
}

Webhooks

Set up webhooks to receive predictions automatically:

const webhook = await luminal.webhooks.create({
  url: 'https://yourapp.com/predictions',
  events: ['prediction.completed'],
  model_id: model.id,
});

AutoML

For users who want to get started quickly, we offer AutoML capabilities:

const autoModel = await luminal.ml.automl.create({
  name: 'Auto Sales Prediction',
  dataset_id: 'ds_sales',
  target_column: 'sales_amount',
  task_type: 'regression',
  time_budget: 3600, // 1 hour
  metric: 'rmse',
});

AutoML will automatically:

• Select the best algorithm
• Perform feature engineering
• Tune hyperparameters
• Validate the model

Best Practices

Data Preparation

1. Clean Your Data: Remove duplicates, handle missing values
2. Feature Selection: Include relevant features, remove noise
3. Data Balance: Ensure balanced datasets for classification
4. Data Types: Proper encoding for categorical variables

Model Selection

1. Start Simple: Begin with basic algorithms
2. Cross Validation: Always validate your models
3. Avoid Overfitting: Monitor training vs validation performance
4. Feature Engineering: Create meaningful features

Production Deployment

1. Monitor Performance: Track model accuracy over time
2. Retrain Regularly: Update models with new data
3. A/B Testing: Compare model versions
4. Backup Models: Keep previous versions available

Advanced Features

Custom Algorithms

Upload your own model code:

# custom_model.py
import pandas as pd
from sklearn.ensemble import RandomForestRegressor

class CustomModel:
    def __init__(self):
        self.model = RandomForestRegressor(n_estimators=200)

    def fit(self, X, y):
        return self.model.fit(X, y)

    def predict(self, X):
        return self.model.predict(X)

Ensemble Methods

Combine multiple models for better performance:

const ensemble = await luminal.ml.ensemble.create({
  name: 'Sales Prediction Ensemble',
  models: [model1.id, model2.id, model3.id],
  method: 'voting', // or 'stacking'
  weights: [0.4, 0.3, 0.3],
});

Transfer Learning

Use pre-trained models as starting points:

const transferModel = await luminal.ml.models.create({
  name: 'Image Classification',
  type: 'classification',
  base_model: 'resnet50',
  dataset_id: 'ds_images',
  transfer_learning: true,
});

Support and Resources

• ML Tutorial Series
• Code Examples
• Community Forum
• ML Best Practices Guide