File size: 6,030 Bytes
fc55797 a1626c0 fc55797 a1626c0 4ca754d fc55797 a1626c0 1e74a1e 50460db b627340 389dccc f5f9a76 a1626c0 fc55797 a1626c0 fc55797 4ca754d fc55797 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 |
from flask import Flask, request, jsonify
import joblib
import numpy as np
import json
import math
app = Flask(_name_)
# Load models
xgb = joblib.load("xgb_model.pkl")
rf = joblib.load("rf_model.pkl")
# Load tile catalog and sizes
with open("tile_catalog.json", "r", encoding="utf-8") as f:
tile_catalog = json.load(f)
with open("tile_sizes.json", "r", encoding="utf-8") as f:
tile_sizes = json.load(f)
@app.route('/recommend', methods=['POST'])
def recommend():
"""
Endpoint for product recommendations
Expected JSON payload:
{
"tile_type": "floor"|"wall",
"coverage": float,
"area": float,
"price_range": [min, max],
"preferred_sizes": [size1, size2] (optional)
}
"""
try:
data = request.get_json()
# Validate input
required_fields = ['tile_type', 'coverage', 'area', 'price_range']
if not all(field in data for field in required_fields):
return jsonify({"error": "Missing required fields"}), 400
tile_type = data['tile_type'].lower()
if tile_type not in ['floor', 'wall']:
return jsonify({"error": "Invalid tile type. Use 'floor' or 'wall'"}), 400
# Feature engineering for ML prediction
features = prepare_features(data)
# Get predictions from both models
xgb_pred = xgb.predict_proba(features)[0][1]
rf_pred = rf.predict_proba(features)[0][1]
combined_score = (xgb_pred + rf_pred) / 2
# Filter products based on criteria
recommended_products = filter_products(
tile_type=tile_type,
min_price=data['price_range'][0],
max_price=data['price_range'][1],
preferred_sizes=data.get('preferred_sizes', []),
min_score=0.5 # Threshold for recommendation
)
# Prepare response
response = {
"recommendation_score": round(float(combined_score), 3),
"recommended_products": recommended_products[:5], # Return top 5
"calculation": calculate_requirements(data['area'], data['coverage'])
}
return jsonify(response)
except Exception as e:
return jsonify({"error": str(e)}), 500
@app.route('/calculate', methods=['POST'])
def calculate():
"""
Endpoint for tile calculation
Expected JSON payload:
{
"tile_type": "floor"|"wall",
"area": float,
"tile_size": "12x12"|etc (from tile_sizes.json)
}
"""
try:
data = request.get_json()
# Validate input
if 'tile_type' not in data or 'area' not in data or 'tile_size' not in data:
return jsonify({"error": "Missing required fields"}), 400
tile_type = data['tile_type'].lower()
if tile_type not in ['floor', 'wall']:
return jsonify({"error": "Invalid tile type"}), 400
if data['tile_size'] not in tile_sizes:
return jsonify({"error": "Invalid tile size"}), 400
# Perform calculation
tile_info = tile_sizes[data['tile_size']]
area_per_tile = tile_info['length'] * tile_info['width']
num_tiles = math.ceil((data['area'] / area_per_tile) * 1.1) # 10% buffer
num_boxes = math.ceil(num_tiles / tile_info.get('tiles_per_box', 10))
# Get matching products
matching_products = [
p for p in tile_catalog
if p['type'].lower() == tile_type and p['size'] == data['tile_size']
]
return jsonify({
"tile_type": tile_type,
"area": data['area'],
"tile_size": data['tile_size'],
"tiles_needed": num_tiles,
"boxes_needed": num_boxes,
"matching_products": matching_products[:3] # Return top 3 matches
})
except Exception as e:
return jsonify({"error": str(e)}), 500
def prepare_features(data):
"""Prepare feature vector for ML model prediction"""
tile_type_num = 0 if data['tile_type'] == 'floor' else 1
price_per_sqft = data['price_range'][1] / data['coverage'] # Using max price
budget_efficiency = data['coverage'] / data['price_range'][1]
return np.array([[
tile_type_num,
data['area'],
data['coverage'],
data['price_range'][0], # min price
data['price_range'][1], # max price
price_per_sqft,
budget_efficiency
]])
def filter_products(tile_type, min_price, max_price, preferred_sizes, min_score=0.5):
"""Filter products based on criteria"""
filtered = []
for product in tile_catalog:
if (product['type'].lower() == tile_type and
min_price <= product['price'] <= max_price and
(not preferred_sizes or product['size'] in preferred_sizes)):
# Calculate a simple score (could be enhanced)
price_score = 1 - ((product['price'] - min_price) / (max_price - min_price))
size_score = 1 if not preferred_sizes or product['size'] in preferred_sizes else 0.5
product_score = (price_score + size_score) / 2
if product_score >= min_score:
filtered.append({
**product,
"recommendation_score": round(product_score, 2)
})
# Sort by recommendation score
return sorted(filtered, key=lambda x: x['recommendation_score'], reverse=True)
def calculate_requirements(area, coverage):
"""Calculate basic requirements"""
return {
"minimum_tiles": math.ceil(area / coverage),
"suggested_tiles": math.ceil((area / coverage) * 1.1), # 10% buffer
"estimated_cost_range": [
round(area * 3, 2), # $3/sqft (example)
round(area * 10, 2) # $10/sqft (example)
]
}
if _name_ == '_main_':
app.run(host='0.0.0.0', port=5000, debug=True) |