Training the Price Prediction Model with Python

First, we'll train a regression model using Python to predict optimal pricing based on historical data:

# Import required libraries for machine learning
import pandas as pd
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split
import joblib

# Load historical pricing data
data = pd.read_csv("sales_history.csv")

# Define features and target variable
features = ['current_stock', 'demand_index', 'competitor_price', 'season_factor']
target = 'optimal_price'

X = data[features]
y = data[target]

# Split the dataset for training and validation
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Initialize and train the Random Forest model
model = RandomForestRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Save the trained model for deployment
joblib.dump(model, 'pricing_model.joblib')

Deploying the Prediction API in Go

Next, we'll create a REST API in Go that loads the trained model and provides price predictions:

package main

import (
	"encoding/json"
	"log"
	"net/http"
	"os"
	"strconv"

	"github.com/sajari/regression"
)

type PricingRequest struct {
	StockLevel     float64 `json:"stock_level"`
	DemandIndex    float64 `json:"demand_index"`
	CompetitorPrice float64 `json:"competitor_price"`
	SeasonFactor   float64 `json:"season_factor"`
}

type PricingResponse struct {
	RecommendedPrice float64 `json:"recommended_price"`
	Confidence       float64 `json:"confidence"`
}

func main() {
	// Initialize prediction endpoint
	http.HandleFunc("/calculate-price", pricePredictionHandler)
	
	port := os.Getenv("PORT")
	if port == "" {
		port = "9090"
	}
	
	log.Printf("Starting pricing service on port %s", port)
	log.Fatal(http.ListenAndServe(":"+port, nil))
}

func pricePredictionHandler(w http.ResponseWriter, r *http.Request) {
	// Only handle POST requests
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	// Parse incoming request
	var req PricingRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "Invalid request format", http.StatusBadRequest)
		return
	}

	// Load the pre-trained model
	modelPath := "models/pricing_model.joblib"
	model, err := loadRegressionModel(modelPath)
	if err != nil {
		http.Error(w, "Model loading failed", http.StatusInternalServerError)
		return
	}

	// Prepare input features
	prediction, confidence := calculateOptimalPrice(model, req)

	// Format and send response
	response := PricingResponse{
		RecommendedPrice: prediction,
		Confidence:       confidence,
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(response)
}

func loadRegressionModel(path string) (*regression.Regression, error) {
	// Implement model loading logic
	// This would typically involve loading from a serialized format
	r := regression.New()
	// Mock loading process - in production, deserialize actual model
	r.SetObserved("price")
	r.SetVar(0, "stock")
	r.SetVar(1, "demand")
	r.SetVar(2, "competitor")
	r.SetVar(3, "season")
	return r, nil
}

func calculateOptimalPrice(model *regression.Regression, req PricingRequest) (float64, float64) {
	// Perform prediction using loaded model
	// Simplified example - actual implementation would use proper ML inference
	prediction := req.StockLevel*0.3 + req.DemandIndex*0.4 + 
		req.CompetitorPrice*0.2 + req.SeasonFactor*0.1
	confidence := 0.85 // Mock confidence score
	return prediction, confidence
}

This implementation provides a foundation for a dynamic pricing system. The Python component handles the complex machine learning tasks, while Go serves as the high-performance backend for real-time price predictions.