from flask import Flask
from flask_restx import Api, Resource, fields
from werkzeug.datastructures import FileStorage
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
import joblib
import streamlit as st
import pandas as pd
import requests
import threading
import json
app = Flask(__name__)
api = Api(app, version='1.0', title='Car Depreciation Model API',
description='API for creating and testing car depreciation models')
model_ns = api.namespace('model', description='Model operations')
predict_ns = api.namespace('predict', description='Prediction operations')
# Define the expected input for file upload
upload_parser = api.parser()
upload_parser.add_argument('file', location='files', type=FileStorage, required=True)
# Define the expected input for prediction
input_model = api.model('PredictionInput', {
'Car_Model': fields.String(required=True, description='Car model'),
'Car_Year': fields.Integer(required=True, description='Year of the car'),
'Assessment_Year': fields.Integer(required=True, description='Assessment year'),
'Starting_Asset_Value': fields.Float(required=True, description='Starting asset value'),
'Book_Residual_Value': fields.Float(required=True, description='Book residual value'),
'Market_Value': fields.Float(required=True, description='Market value')
})
# Global variable to store the model
global_model = None
@model_ns.route('/create')
@api.expect(upload_parser)
class ModelCreation(Resource):
@api.doc(description='Create a new model from CSV data')
@api.response(200, 'Model created successfully')
@api.response(400, 'Invalid input')
def post(self):
global global_model
args = upload_parser.parse_args()
uploaded_file = args['file']
if uploaded_file and uploaded_file.filename.endswith('.csv'):
# Read the CSV file
data = pd.read_csv(uploaded_file)
# Prepare features and target
X = data.drop('Depreciation_Percent', axis=1)
y = data['Depreciation_Percent']
# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Create preprocessing steps
numeric_features = ['Car_Year', 'Assessment_Year', 'Starting_Asset_Value', 'Book_Residual_Value', 'Market_Value']
categorical_features = ['Car_Model']
numeric_transformer = SimpleImputer(strategy='median')
categorical_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
('onehot', OneHotEncoder(handle_unknown='ignore'))
])
preprocessor = ColumnTransformer(
transformers=[
('num', numeric_transformer, numeric_features),
('cat', categorical_transformer, categorical_features)
])
# Create a pipeline with preprocessor and model
model = Pipeline(steps=[('preprocessor', preprocessor),
('regressor', LinearRegression())])
# Fit the model
model.fit(X_train, y_train)
# Make predictions on the test set
y_pred = model.predict(X_test)
# Evaluate the model
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
# Save the model
joblib.dump(model, 'output/car_depreciation_model.joblib')
global_model = model
return {
'message': 'Model created and saved successfully',
'mse': float(mse),
'r2': float(r2)
}, 200
return {'error': 'Invalid file format'}, 400
@predict_ns.route('/')
class Prediction(Resource):
@api.expect(input_model)
@api.doc(description='Predict car depreciation')
@api.response(200, 'Successful prediction')
@api.response(400, 'Invalid input')
@api.response(404, 'Model not found')
def post(self):
global global_model
try:
if global_model is None:
try:
global_model = joblib.load('output/car_depreciation_model.joblib')
except FileNotFoundError:
return {'error': 'Model not found. Please create a model first.'}, 404
# Get JSON data from the request
data = api.payload
# Convert JSON to DataFrame
new_data_df = pd.DataFrame([data])
# Make prediction
prediction = global_model.predict(new_data_df)
return {
'predicted_depreciation': float(prediction[0])
}, 200
except Exception as e:
return {'error': str(e)}, 400
API_URL = "http://localhost:5000"
st.title('Car Depreciation Predictor')
# Input form for prediction
st.header('Predict Depreciation')
car_model = st.text_input('Car Model',value="Honda Civic")
car_year = st.number_input('Car Year', value=2022)
assessment_year = st.number_input('Assessment Year', min_value=1, max_value=5, value=1)
starting_asset_value = st.number_input('Starting Asset Value', min_value=0, value=20000)
book_residual_value = st.number_input('Book Residual Value', min_value=0, value=18000)
market_value = st.number_input('Market Value', min_value=0, value=19000)
if st.button('Predict'):
input_data = {
'Car_Model': car_model,
'Car_Year': int(car_year),
'Assessment_Year': int(assessment_year),
'Starting_Asset_Value': float(starting_asset_value),
'Book_Residual_Value': float(book_residual_value),
'Market_Value': float(market_value)
}
response = requests.post(f'{API_URL}/predict/', json=input_data)
if response.status_code == 200:
prediction = response.json()['predicted_depreciation']
st.success(f'Predicted Depreciation: {prediction:.2f}%')
elif response.status_code == 404:
st.error('Model not found. Please create a model first.')
else:
st.error(f'Error making prediction: {response.json().get("error", "Unknown error")}')
if __name__ == '__main__':
try:
# Start Flask in a separate thread
threading.Thread(target=lambda: app.run(debug=False, use_reloader=False)).start()
# Run Streamlit
import streamlit.web.cli as stcli
import sys
sys.argv = ["streamlit", "run", __file__]
sys.exit(stcli.main())
except:
print("An exception occurred")