Purple Flea for MLflow

From Experiment to Live Trade in Three Steps

MLflow manages the full model lifecycle. Purple Flea provides the live market data and trade execution endpoints. The pipeline below describes how a single trading strategy goes from backtested idea to production agent in a systematic, reproducible way.

Experiment Tracking with Purple Flea Data

The example below logs a full backtesting experiment to MLflow using historical market data from Purple Flea. Every metric that matters for a trading strategy is tracked: Sharpe ratio, max drawdown, total return, and win rate. The best run is registered to the Model Registry automatically.

import mlflow
import mlflow.sklearn
import requests
import numpy as np

PF_BASE = "https://purpleflea.com/api/v1"
HEADERS = {"Authorization": "Bearer pf_live_YOUR_KEY"}

mlflow.set_experiment("btc-momentum-strategies")

def run_backtest(lookback: int, threshold: float, leverage: float):
    with mlflow.start_run(run_name=f"momentum_lb{lookback}_th{threshold}"):
        # Log hyperparameters
        mlflow.log_param("lookback_period", lookback)
        mlflow.log_param("threshold", threshold)
        mlflow.log_param("leverage", leverage)

        # Fetch historical data from Purple Flea
        history = requests.get(
            f"{PF_BASE}/markets/BTC-PERP/history",
            params={"days": 90, "interval": "1h"},
            headers=HEADERS
        ).json()

        prices = np.array([c["close"] for c in history["candles"]])

        # Simple momentum strategy: buy when price up N% over lookback
        returns = []
        for i in range(lookback, len(prices)):
            pct_change = (prices[i] - prices[i - lookback]) / prices[i - lookback]
            if pct_change > threshold:
                returns.append(pct_change * leverage)
            elif pct_change < -threshold:
                returns.append(-pct_change * leverage)
            else:
                returns.append(0.0)

        returns = np.array(returns)
        total_return = returns.sum()
        sharpe = returns.mean() / (returns.std() + 1e-9) * np.sqrt(252)
        max_dd = (returns.cumsum() - returns.cumsum().cummax()).min()
        win_rate = (returns > 0).mean()

        # Log metrics to MLflow
        mlflow.log_metric("sharpe_ratio", round(sharpe, 3))
        mlflow.log_metric("max_drawdown", round(max_dd, 4))
        mlflow.log_metric("total_return", round(total_return, 4))
        mlflow.log_metric("win_rate", round(win_rate, 3))

        print(f"Sharpe: {sharpe:.2f} | DD: {max_dd:.2%} | Return: {total_return:.2%}")

        # Register if Sharpe > 1.5
        if sharpe > 1.5:
            mlflow.sklearn.log_model(
                None,  # Replace with trained sklearn/torch model
                "btc_momentum_model",
                registered_model_name="btc-momentum"
            )
            print("Registered to Model Registry (Sharpe > 1.5)")

# Grid search over hyperparameters
for lb in [4, 8, 14, 24]:
    for th in [0.01, 0.02, 0.03]:
        run_backtest(lb, th, leverage=2)

print("All experiments logged. View at: mlflow ui --port 5000")

Model Registry → Live Trade Execution

MLflow's Model Registry gives you version control and deployment aliases for trading models. The Champion alias always points to the model currently executing live trades. Promoting a new model to Champion is a single API call — no code changes, no redeployment.

import mlflow.pyfunc
import requests

# Always load Champion — no hardcoded version numbers
model = mlflow.pyfunc.load_model("models:/btc-momentum@Champion")

PF_BASE = "https://purpleflea.com/api/v1"
HEADERS = {"Authorization": "Bearer pf_live_YOUR_KEY"}

def trade_loop():
    # Fetch current features from Purple Flea
    mkt = requests.get(f"{PF_BASE}/markets/BTC-PERP/price", headers=HEADERS).json()
    features = [[
        mkt["change_1h_pct"], mkt["change_4h_pct"],
        mkt["volume_24h_usd"], mkt["funding_rate"]
    ]]

    # Get Champion's prediction
    signal = model.predict(features)[0]  # 1 = long, -1 = short, 0 = flat

    if signal == 1:
        requests.post(f"{PF_BASE}/trade",
            json={"symbol": "BTC-PERP", "side": "long", "size": 50},
            headers=HEADERS)
    elif signal == -1:
        requests.post(f"{PF_BASE}/trade",
            json={"symbol": "BTC-PERP", "side": "short", "size": 50},
            headers=HEADERS)

Financial APIs for Model Training & Execution

Pull training data, execute model predictions as live trades, and measure real performance — all through Purple Flea's unified API.

What Teams Build with MLflow + Purple Flea

Continue Building