Spot Price Optimization

In this article, we’ll look at strategies for dynamically optimizing spot prices on Clore’s marketplace, where computational resources are often bid upon by users. This approach leverages Clore's API to dynamically set spot prices based on demand, resource usage, and historical profitability.

1. Fetching Real-Time Marketplace Data for Spot Price Adjustments

To make informed spot price adjustments, we start by gathering real-time server data from Clore's marketplace, focusing on parameters like current spot price, rental status, and demand frequency.

import requests
import datetime

api_key = "YOUR_API_KEY"
marketplace_url = "https://api.clore.ai/v1/marketplace"
spot_price_url = "https://api.clore.ai/v1/set_spot_price"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}

def fetch_marketplace_data():
    response = requests.get(marketplace_url, headers=headers)
    servers = response.json().get("servers", [])
    spot_servers = [server for server in servers if server["rental_status"] == 0 and server["price"]["spot"]]
    return spot_servers

# Fetch servers available for spot rental
spot_servers = fetch_marketplace_data()
print(f"Total spot servers available: {len(spot_servers)}")

---

2. Applying Demand-Based Spot Price Adjustment Algorithm

Using historical demand data and server specs, this algorithm calculates an adjusted spot price to remain competitive.

def calculate_dynamic_spot_price(base_price, demand_factor, utilization_rate):
    adjusted_price = base_price * (1 + demand_factor * utilization_rate)
    return round(adjusted_price, 8)  # Adjusting to Clore’s pricing format

def adjust_spot_prices(demand_factor=1.2, utilization_rate=0.8):
    for server in spot_servers:
        server_id = server["id"]
        current_price = server["price"]["spot"]["bitcoin"]
        new_price = calculate_dynamic_spot_price(current_price, demand_factor, utilization_rate)

        # Submit new price to Clore API
        payload = {"order_id": server_id, "desired_price": new_price}
        response = requests.post(spot_price_url, headers=headers, json=payload)
        
        if response.status_code == 200:
            print(f"Adjusted price for server {server['name']} to {new_price} BTC")
        else:
            print(f"Failed to update price for server {server['name']}")

# Adjust spot prices based on demand and utilization factors
adjust_spot_prices()

---

3. Optimizing Spot Prices Based on Historical Profitability

This segment analyzes profitability over the last week to adjust prices based on previous revenue generated by spot rentals.

from datetime import timedelta

def fetch_server_profitability(server_id, start_date, end_date):
    profitability_url = f"https://api.clore.ai/v1/server_profitability/{server_id}"
    payload = {"start_date": start_date, "end_date": end_date}
    response = requests.post(profitability_url, headers=headers, json=payload)
    return response.json().get("total_profit", 0)

def optimize_spot_price_by_profitability():
    today = datetime.date.today()
    last_week = today - timedelta(days=7)

    for server in spot_servers:
        server_id = server["id"]
        last_week_profit = fetch_server_profitability(server_id, last_week.isoformat(), today.isoformat())
        profitability_rate = 1.1 if last_week_profit > 0.005 else 0.9  # Increase or decrease by 10%

        # Calculate new spot price
        base_price = server["price"]["spot"]["bitcoin"]
        new_price = calculate_dynamic_spot_price(base_price, demand_factor=profitability_rate, utilization_rate=1)

        # Update spot price on Clore
        payload = {"order_id": server_id, "desired_price": new_price}
        response = requests.post(spot_price_url, headers=headers, json=payload)
        print(f"Optimized spot price for {server['name']} based on profitability: {new_price}")

# Run profitability-based spot price optimization
optimize_spot_price_by_profitability()

---

4. Spot Price Optimization Based on Marketplace Supply and Demand Ratios

This code adjusts spot prices based on the ratio of available spot servers to the total number of users searching for spot rentals. This keeps prices competitive while responding to supply-demand shifts.

def get_supply_demand_ratio():
    total_servers = len(spot_servers)
    # Hypothetical endpoint to get active users or demand on the marketplace
    active_users_url = "https://api.clore.ai/v1/active_users"
    response = requests.get(active_users_url, headers=headers)
    active_users = response.json().get("active_users_count", 1)
    
    return total_servers / active_users

def adjust_prices_based_on_supply_demand():
    supply_demand_ratio = get_supply_demand_ratio()
    print(f"Supply-Demand Ratio: {supply_demand_ratio}")

    for server in spot_servers:
        server_id = server["id"]
        base_price = server["price"]["spot"]["bitcoin"]
        
        # Calculate adjustment factor based on supply-demand ratio
        adjustment_factor = 0.85 if supply_demand_ratio > 1 else 1.2
        new_price = calculate_dynamic_spot_price(base_price, demand_factor=adjustment_factor, utilization_rate=1)
        
        # Update spot price on Clore
        payload = {"order_id": server_id, "desired_price": new_price}
        response = requests.post(spot_price_url, headers=headers, json=payload)
        print(f"Updated spot price for {server['name']} to {new_price} BTC")

# Execute supply-demand based spot price adjustments
adjust_prices_based_on_supply_demand()

---

5. Spot Price Prediction Using Machine Learning Models

Here, we leverage machine learning to predict the optimal spot price based on historical data. Using a time-series model, this script provides predictions for setting prices in line with projected demand.

from sklearn.linear_model import LinearRegression
import numpy as np

def predict_future_spot_price(server_id, historical_prices):
    X = np.array(range(len(historical_prices))).reshape(-1, 1)
    y = np.array(historical_prices)
    
    model = LinearRegression()
    model.fit(X, y)
    
    # Predict price for the next time period
    next_price = model.predict([[len(historical_prices) + 1]])
    return round(next_price[0], 8)

def apply_ml_based_price_prediction():
    for server in spot_servers:
        server_id = server["id"]
        # Assume we fetch the last 10 spot prices for prediction
        historical_prices = fetch_historical_spot_prices(server_id)
        predicted_price = predict_future_spot_price(server_id, historical_prices)

        # Update predicted price on Clore
        payload = {"order_id": server_id, "desired_price": predicted_price}
        response = requests.post(spot_price_url, headers=headers, json=payload)
        print(f"Predicted and updated spot price for {server['name']}: {predicted_price}")

def fetch_historical_spot_prices(server_id):
    # Simulated historical prices
    return [0.00012, 0.00013, 0.00014, 0.00014, 0.00015, 0.00016, 0.00017, 0.00018, 0.00018, 0.00019]

# Execute ML-based spot price prediction and update
apply_ml_based_price_prediction()

---

These code examples provide a robust framework for optimizing spot prices in Clore’s marketplace. By automating adjustments based on supply-demand ratios, profitability, historical trends, and even predictive modeling, users can maximize revenue while remaining responsive to market dynamics.