Upload 3 files

app.py

@@ -1,4 +1,184 @@
-import streamlit as st
-
-x = st.slider('Select a value')
-st.write(x, 'squared is', x * x)
+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")

install.sh

@@ -0,0 +1,2 @@
+pip install -r requirements.txt
+python app.py

requirements.txt

@@ -0,0 +1,7 @@
+flask
+flask-restx
+Werkzeug
+scikit-learn
+pandas 
+numpy 
+joblib