AI-Powered Data Analytics: Transforming Enterprise Decision Making

# Example using AutoML with PyCaret
from pycaret.regression import *

# Initialize setup
regression_setup = setup(data, target='sales', session_id=123,
                        normalize=True, transformation=True, 
                        ignore_features=['id', 'date'])

# Compare models
best_models = compare_models(n_select=3)

# Tune the best model
tuned_model = tune_model(best_models[0])

# Finalize model
final_model = finalize_model(tuned_model)

# Make predictions
predictions = predict_model(final_model, data=new_data)

# Example: CNN for image classification in a retail context
import tensorflow as tf
from tensorflow.keras.applications import ResNet50
from tensorflow.keras.layers import Dense, GlobalAveragePooling2D
from tensorflow.keras.models import Model

# Load pre-trained ResNet model
base_model = ResNet50(weights='imagenet', include_top=False)

# Add custom layers
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
predictions = Dense(10, activation='softmax')(x)  # 10 product categories

# Create model
model = Model(inputs=base_model.input, outputs=predictions)

# Freeze base model layers
for layer in base_model.layers:
    layer.trainable = False

# Compile model
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# Train model
model.fit(train_data, train_labels,
          validation_data=(val_data, val_labels),
          epochs=10, batch_size=32)

# Example: Topic modeling with BERTopic
from bertopic import BERTopic
import pandas as pd

# Load customer feedback data
customer_feedback = pd.read_csv('customer_feedback.csv')
documents = customer_feedback['feedback_text'].tolist()

# Create topic model
topic_model = BERTopic(language="english", calculate_probabilities=True)
topics, probs = topic_model.fit_transform(documents)

# Get topic information
topic_info = topic_model.get_topic_info()
print(topic_info.head(10))

# Visualize topics
topic_model.visualize_topics()

# Example: Prophet for time series forecasting with external factors
import pandas as pd
from prophet import Prophet

# Load sales data
sales_data = pd.read_csv('sales_data.csv')
sales_data = sales_data.rename(columns={'date': 'ds', 'sales': 'y'})

# Add external regressors (e.g., marketing spend, promotions)
sales_data['marketing_spend'] = pd.read_csv('marketing_data.csv')['spend']
sales_data['is_promotion'] = pd.read_csv('promotion_data.csv')['is_active']

# Create and fit model
model = Prophet()
model.add_regressor('marketing_spend')
model.add_regressor('is_promotion')
model.fit(sales_data)

# Create future dataframe for prediction
future = model.make_future_dataframe(periods=90)  # 90 days forecast
future['marketing_spend'] = forecast_marketing_spend(90)  # Your function to forecast marketing spend
future['is_promotion'] = forecast_promotions(90)  # Your function to forecast promotions

# Make forecast
forecast = model.predict(future)

# Example: Isolation Forest for anomaly detection
import pandas as pd
import numpy as np
from sklearn.ensemble import IsolationForest
import matplotlib.pyplot as plt

# Load transaction data
transactions = pd.read_csv('transactions.csv')

# Select features for anomaly detection
features = ['amount', 'transaction_count', 'average_basket_size']
X = transactions[features]

# Train isolation forest model
model = IsolationForest(contamination=0.05, random_state=42)
transactions['anomaly'] = model.fit_predict(X)
transactions['anomaly_score'] = model.decision_function(X)

# Identify anomalies
anomalies = transactions[transactions['anomaly'] == -1]
print(f"Detected {len(anomalies)} anomalous transactions out of {len(transactions)}")

# Example: Data integration pipeline with Apache Airflow
from airflow import DAG
from airflow.operators.python import PythonOperator
from airflow.providers.amazon.aws.transfers.s3_to_redshift import S3ToRedshiftOperator
from airflow.providers.postgres.operators.postgres import PostgresOperator
from datetime import datetime, timedelta

default_args = {
    'owner': 'data_team',
    'depends_on_past': False,
    'start_date': datetime(2025, 1, 1),
    'email_on_failure': True,
    'email_on_retry': False,
    'retries': 1,
    'retry_delay': timedelta(minutes=5),
}

dag = DAG(
    'data_integration_pipeline',
    default_args=default_args,
    description='Pipeline to integrate data from multiple sources',
    schedule_interval='0 2 * * *',  # Run daily at 2 AM
)

# Extract data from CRM API
def extract_crm_data():
    # Code to extract data from CRM API
    pass

extract_crm_task = PythonOperator(
    task_id='extract_crm_data',
    python_callable=extract_crm_data,
    dag=dag,
)

# Load S3 data to Redshift
load_s3_to_redshift = S3ToRedshiftOperator(
    task_id='load_s3_to_redshift',
    schema='analytics',
    table='customer_interactions',
    s3_bucket='data-lake',
    s3_key='crm/daily/{{ ds }}/',
    copy_options=['CSV', 'IGNOREHEADER 1'],
    dag=dag,
)

# Set task dependencies
extract_crm_task >> load_s3_to_redshift

# Example: Automated feature engineering with Featuretools
import featuretools as ft
import pandas as pd

# Load data
customers = pd.read_csv('customers.csv')
transactions = pd.read_csv('transactions.csv')
products = pd.read_csv('products.csv')

# Create entity set
es = ft.EntitySet(id='retail')

# Add entities
es = es.add_dataframe(
    dataframe_name='customers',
    dataframe=customers,
    index='customer_id'
)

es = es.add_dataframe(
    dataframe_name='transactions',
    dataframe=transactions,
    index='transaction_id'
)

# Add relationships
es = es.add_relationship(
    parent_dataframe_name='customers',
    parent_column_name='customer_id',
    child_dataframe_name='transactions',
    child_column_name='customer_id'
)

# Generate features
feature_matrix, feature_defs = ft.dfs(
    entityset=es,
    target_dataframe_name='customers',
    agg_primitives=['sum', 'mean', 'count', 'std', 'max', 'min'],
    trans_primitives=['month', 'weekday', 'hour']
)

# Example: MLflow for model training and deployment
import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error
import pandas as pd
from sklearn.model_selection import train_test_split

# Load data
data = pd.read_csv('customer_lifetime_value.csv')
X = data.drop('lifetime_value', axis=1)
y = data['lifetime_value']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Set experiment
mlflow.set_experiment("customer_lifetime_value_prediction")

# Start run
with mlflow.start_run():
    # Set parameters
    n_estimators = 100
    max_depth = 10
    
    # Log parameters
    mlflow.log_param("n_estimators", n_estimators)
    mlflow.log_param("max_depth", max_depth)
    
    # Train model
    rf = RandomForestRegressor(n_estimators=n_estimators, max_depth=max_depth, random_state=42)
    rf.fit(X_train, y_train)
    
    # Evaluate model
    predictions = rf.predict(X_test)
    mse = mean_squared_error(y_test, predictions)
    
    # Log metrics
    mlflow.log_metric("mse", mse)
    
    # Log model
    mlflow.sklearn.log_model(rf, "random_forest_model")

# Example: Customer segmentation with K-Means clustering
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# Load customer data
customer_data = pd.read_csv('customer_data.csv')

# Select features for segmentation
features = ['recency', 'frequency', 'monetary', 'age', 'website_visits']
X = customer_data[features]

# Standardize features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Apply K-Means with optimal k
optimal_k = 4
kmeans = KMeans(n_clusters=optimal_k, random_state=42)
customer_data['cluster'] = kmeans.fit_predict(X_scaled)

# Analyze clusters
cluster_centers = pd.DataFrame(scaler.inverse_transform(kmeans.cluster_centers_), 
                              columns=features)
print("Cluster Centers:")
print(cluster_centers)

# Example: Predictive maintenance with LSTM
import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split

# Load sensor data
sensor_data = pd.read_csv('equipment_sensors.csv')

# Prepare features and target
features = ['temperature', 'vibration', 'pressure', 'rotation_speed']
X = sensor_data[features].values
y = sensor_data['failure_within_24h'].values  # Binary target: 1 if failure within 24h

# Scale features
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)

# Create sequences for LSTM
def create_sequences(data, target, seq_length=10):
    X_seq, y_seq = [], []
    for i in range(len(data) - seq_length):
        X_seq.append(data[i:i+seq_length])
        y_seq.append(target[i+seq_length])
    return np.array(X_seq), np.array(y_seq)

X_seq, y_seq = create_sequences(X_scaled, y)

# Build LSTM model
model = Sequential()
model.add(LSTM(50, return_sequences=True, input_shape=(X_seq.shape[1], X_seq.shape[2])))
model.add(Dropout(0.2))
model.add(LSTM(50))
model.add(Dropout(0.2))
model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Example: Fraud detection with XGBoost
import pandas as pd
import numpy as np
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix

# Load transaction data
transactions = pd.read_csv('transactions.csv')

# Feature engineering
transactions['hour_of_day'] = transactions['timestamp'].apply(lambda x: pd.to_datetime(x).hour)
transactions['day_of_week'] = transactions['timestamp'].apply(lambda x: pd.to_datetime(x).dayofweek)
transactions['is_weekend'] = transactions['day_of_week'].apply(lambda x: 1 if x >= 5 else 0)

# Prepare features and target
features = ['amount', 'hour_of_day', 'day_of_week', 'is_weekend', 
            'merchant_category']
X = pd.get_dummies(transactions[features], columns=['merchant_category'])
y = transactions['is_fraud']

# Train XGBoost model
model = XGBClassifier(
    max_depth=5,
    learning_rate=0.1,
    n_estimators=100,
    objective='binary:logistic',
    scale_pos_weight=len(y_train[y_train==0]) / len(y_train[y_train==1]),  # Handle class imbalance
    random_state=42
)

model.fit(X_train, y_train)

# AI Analytics Implementation Roadmap

## Phase 1: Define Business Objectives
- Identify key business questions to answer
- Define success metrics for analytics initiatives
- Prioritize use cases based on business impact and feasibility

## Phase 2: Data Assessment
- Inventory available data sources
- Assess data quality and completeness
- Identify data integration requirements

## Phase 3: Proof of Concept
- Select highest-priority use case
- Develop initial models with available data
- Validate results with business stakeholders

## Phase 4: Production Implementation
- Build data pipeline for selected use case
- Deploy models to production
- Implement feedback loops for continuous improvement

# Example: SHAP values for model interpretability
import shap
import matplotlib.pyplot as plt

# Create explainer
explainer = shap.TreeExplainer(model)

# Calculate SHAP values
shap_values = explainer.shap_values(X_test)

# Create summary plot
shap.summary_plot(shap_values, X_test, feature_names=X.columns)

# Create force plot for a single prediction
shap.force_plot(explainer.expected_value, shap_values[0], X_test.iloc[0], feature_names=X.columns)