import mlflow                                          # Import MLflow for experiment tracking and model logging
from sklearn.ensemble import RandomForestClassifier     # Scikit-learn classifier we'll train and log
from sklearn.metrics import accuracy_score              # Metric to evaluate model quality on test data

data = load_wine()                                      # Load the wine-quality dataset (assumed helper)
X_train, X_test, y_train, y_test = train_test_split(data.data, data.target)  # Split into train/test sets

with mlflow.start_run():                                # Open an MLflow run context — all logs go into this run
    model = RandomForestClassifier(n_estimators=200, max_depth=10)  # Instantiate RF with 200 trees, depth 10
    model.fit(X_train, y_train)                         # Train the classifier on the training features/labels

    acc = accuracy_score(y_test, model.predict(X_test)) # Compute accuracy on held-out test set

    mlflow.log_param("n_estimators", 200)              # Log hyperparam — visible in MLflow UI for run comparison
    mlflow.log_param("max_depth", 10)                   # Log second hyperparam so you can compare across runs
    mlflow.log_metric("accuracy", acc)                  # Log the accuracy metric for this run
    mlflow.sklearn.log_model(model, "model")            # Serialize and store the trained model artifact as "model"

    print(f"Logged run with accuracy {acc:.4f}")        # Confirm the run was logged with its accuracy value

import mlflow.sklearn                                   # Import MLflow's sklearn module to load saved models
import pandas as pd                                     # Pandas for reading/manipulating tabular batch data

model = mlflow.sklearn.load_model("models:/wine-classifier/Production")  # Load the prod model from MLflow registry

df = pd.read_parquet("data/raw/today_users.parquet")    # Read today's batch of user features from Parquet file
predictions = model.predict(df)                         # Run inference on the entire DataFrame — CPU-only, no batching

df["prediction"] = predictions                          # Append predictions as a new column to the DataFrame
df.to_parquet("data/predictions/results.parquet")       # Write results back to Parquet for downstream consumption

import bentoml                                         # Import BentoML for high-performance model serving
import numpy as np                                     # NumPy for array manipulation in inference
from bentoml.io import JSON, NumpyNdarray               # I/O descriptors: receive ndarray, return JSON

runner = bentoml.mlflow.get("wine-classifier:latest").to_runner()  # Pull the latest MLflow model into a BentoML Runner

svc = bentoml.Service("wine-classifier", runners=[runner])  # Create a BentoML service that owns this Runner

@svc.api(input=NumpyNdarray(), output=JSON())          # Decorate endpoint: accepts raw ndarray, returns JSON dict
async def classify(input_data: np.ndarray) -> dict:    # Async handler so the event loop can multiplex requests
    result = await runner.predict.async_run(input_data) # Offload inference to Runner (adaptive batching, CPU/GPU)
    return {"prediction": result.tolist(), "probabilities": "N/A"}  # Convert result to list and return JSON response

import bentoml                                         # Core BentoML import for service and runner orchestration
import numpy as np                                     # NumPy for converting input dicts to model-ready arrays
from bentoml.io import JSON                             # JSON I/O descriptor for both input and output

catboost_runner = bentoml.xgboost.get("catboost-features:latest").to_runner()  # Load CatBoost model as a Runner
lstm_runner = bentoml.pytorch.get("lstm-sequence:latest").to_runner()          # Load PyTorch LSTM as a separate Runner

svc = bentoml.Service("ensemble-monster", runners=[catboost_runner, lstm_runner])  # Service owns both Runners

@svc.api(input=JSON(), output=JSON())                  # Accept JSON dict, return JSON dict
async def predict(input_data: dict) -> dict:            # Async handler lets both Runners run concurrently
    cat_features = np.array(input_data["tabular"])      # Extract tabular features from the JSON payload
    sequences = np.array(input_data["sequences"])       # Extract sequence data for the LSTM

    cf = await catboost_runner.predict.async_run(cat_features)   # Async inference on CatBoost Runner (CPU)
    lstm_out = await lstm_runner.predict.async_run(sequences)    # Async inference on LSTM Runner (GPU)

    final = (cf * 0.6 + lstm_out * 0.4).tolist()        # Weighted ensemble: 60% CatBoost, 40% LSTM
    return {"ensemble_prediction": final}                # Return combined prediction as JSON

import mlflow                                           # Import MLflow for experiment tracking and model registry

with mlflow.start_run():                                # Start a new run — everything logged goes to this experiment
    model = train_something()                           # (placeholder) train your actual model here
    mlflow.log_metric("accuracy", 0.97)                 # Log a dummy accuracy metric for run comparison
    mlflow.sklearn.log_model(model, "model")            # Serialize the model artifact and register it in MLflow

import bentoml                                          # Import BentoML to consume models from MLflow for serving

bentoml.mlflow.import_model("wine-classifier",         # Import an MLflow model into BentoML's model store
    model_uri="models:/wine-classifier/Production")    # Source URI pointing to the Production stage in MLflow registry

bento = bentoml.Service("wine-classifier", runners=[...])  # Wrap the imported model in a BentoML Service (runners omitted)