Update app.py

app.py

@@ -21,7 +21,6 @@ def load_datasets():
     try:
         with st.spinner('Loading dataset...'):
             original_data = pd.read_csv('CTP_Model1.csv', low_memory=False)
-            original_data.columns = original_data.columns.str.strip().str.lower()
             return original_data
     except Exception as e:
         st.error(f"Error loading dataset: {str(e)}")
@@ -61,7 +60,7 @@ def classify_image(image):
 
 def find_closest_match(df, brand, model):
     # Combine brand and model names from the dataset
-    df['full_name'] = df['make'] + ' ' + df['model']
+    df['full_name'] = df['Make'] + ' ' + df['Model']
     
     # Create a list of all car names
     car_names = df['full_name'].tolist()
@@ -84,7 +83,7 @@ def find_closest_match(df, brand, model):
     return df.iloc[most_similar_index]
 
 def get_car_overview(car_data):
-    prompt = f"Provide an overview of the following car:\nYear: {car_data['year']}\nMake: {car_data['make']}\nModel: {car_data['model']}\nTrim: {car_data['trim']}\nPrice: ${car_data['price']}\nCondition: {car_data['condition']}\n"
+    prompt = f"Provide an overview of the following car:\nYear: {car_data['Year']}\nMake: {car_data['Make']}\nModel: {car_data['Model']}\nTrim: {car_data['Trim']}\nPrice: ${car_data['Price']}\nCondition: {car_data['Condition']}\n"
     response = openai.ChatCompletion.create(
         model="gpt-3.5-turbo",
         messages=[{"role": "user", "content": prompt}]
@@ -96,70 +95,53 @@ def load_model_and_encodings():
         with st.spinner('Loading model...'):
             model_content = hf_hub_download(repo_id="EdBoy2202/car_prediction_model", filename="car_price_modelv3.pkl")
             model = joblib.load(model_content)
-
-        original_data = load_datasets()
-        
-        label_encoders = {}
-        categorical_features = original_data.select_dtypes(include=['object']).columns.tolist()
-        
-        for feature in categorical_features:
-            le = LabelEncoder()
-            unique_values = original_data[feature].fillna('unknown').str.strip().unique()
-            le.fit(unique_values)
-            label_encoders[feature.lower()] = le
-        
-        return model, label_encoders, categorical_features
+        return model
     except Exception as e:
         st.error(f"Error loading model: {str(e)}")
         raise e
 
-def calculate_age(year):
-    current_year = datetime.now().year
-    return current_year - year
-
-def predict_price(model, encoders, categorical_features, user_input):
-    encoded_features = {}
-    current_year = datetime.now().year
+def predict_price(model, match, year):
+    # Start with the data from the closest match
+    input_data = match.copy()
     
-    for feature, value in user_input.items():
-        feature_lower = feature.lower()
-        if feature_lower in encoders:
-            encoded_features[feature_lower] = encoders[feature_lower].transform([value])[0]
-        elif feature_lower in categorical_features:
-            # If it's a categorical feature but not in encoders, set to 0 (unknown)
-            encoded_features[feature_lower] = 0
-        else:
-            # For numerical features, use the value as is
-            encoded_features[feature_lower] = value
+    # Update the year
+    input_data['Year'] = year
+    
+    # Calculate age
+    current_year = datetime.now().year
+    input_data['Age'] = current_year - year
+    input_data['Age_squared'] = input_data['Age'] ** 2
     
-    # Calculate additional features
-    encoded_features['age'] = calculate_age(encoded_features['year'])
-    encoded_features['age_squared'] = encoded_features['age'] ** 2
+    # If odometer is missing, estimate it based on age and average yearly mileage
+    if 'Odometer' not in input_data or pd.isna(input_data['Odometer']):
+        avg_yearly_mileage = 12000  # Adjust this value as needed
+        input_data['Odometer'] = input_data['Age'] * avg_yearly_mileage
     
-    # Assume average mileage per year (you may want to adjust this)
-    avg_mileage_per_year = 12000
-    encoded_features['mileage_per_year'] = avg_mileage_per_year
+    # Ensure all required columns are present
+    required_columns = ['Make', 'Model', 'Year', 'Condition', 'Fuel', 'Odometer', 'Title_status', 'Transmission', 'Drive', 'Size', 'Type', 'Paint_color', 'Age', 'Age_squared']
     
-    # Assume odometer reading (you may want to adjust this)
-    encoded_features['odometer'] = encoded_features['age'] * avg_mileage_per_year
+    for col in required_columns:
+        if col not in input_data or pd.isna(input_data[col]):
+            # If a required column is missing, fill it with the most common value from the dataset
+            input_data[col] = df[col].mode().iloc[0]
     
-    input_data = pd.DataFrame([encoded_features])
+    # Prepare the input for the model
+    input_df = pd.DataFrame([input_data])
     
-    # Ensure all expected columns are present
-    expected_columns = ['make', 'model', 'year', 'condition', 'fuel', 'odometer', 'title_status', 'transmission', 'drive', 'size', 'type', 'paint_color', 'age', 'age_squared', 'mileage_per_year']
-    for col in expected_columns:
-        if col not in input_data.columns:
-            input_data[col] = 0  # or some default value
+    # Make sure to only include columns that the model expects
+    model_columns = model.feature_names_in_
+    input_df = input_df[model_columns]
     
-    predicted_price = model.predict(input_data)
+    # Predict the price
+    predicted_price = model.predict(input_df)
     return predicted_price[0]
 
 # Streamlit App
 st.title("Auto Appraise")
 st.write("Upload a car image or take a picture to get its brand, model, overview, and expected price!")
 
-# Load model and encoders
-model, label_encoders, categorical_features = load_model_and_encodings()
+# Load model and encodings
+model = load_model_and_encodings()
 
 # Initialize OpenAI API key
 openai.api_key = st.secrets["GPT_TOKEN"]
@@ -204,10 +186,10 @@ if image is not None:
         match = find_closest_match(df, brand, model_name)
         if match is not None:
             st.write("Closest Match Found:")
-            st.write(f"Make: {match['make']}")
-            st.write(f"Model: {match['model']}")
-            st.write(f"Year: {match['year']}")
-            st.write(f"Price: ${match['price']}")
+            st.write(f"Make: {match['Make']}")
+            st.write(f"Model: {match['Model']}")
+            st.write(f"Year: {match['Year']}")
+            st.write(f"Price: ${match['Price']}")
 
             # Get additional information using GPT-3.5-turbo
             overview = get_car_overview(match)
@@ -223,27 +205,13 @@ if image is not None:
             predicted_prices = []
 
             for year in years:
-                user_input = {
-                    'make': match['make'].lower(),
-                    'model': match['model'].lower(),
-                    'year': year,
-                    'condition': match.get('condition', 'unknown').lower(),
-                    'fuel': match.get('fuel', 'unknown').lower(),
-                    'title_status': match.get('title_status', 'unknown').lower(),
-                    'transmission': match.get('transmission', 'unknown').lower(),
-                    'drive': match.get('drive', 'unknown').lower(),
-                    'size': match.get('size', 'unknown').lower(),
-                    'type': match.get('type', 'unknown').lower(),
-                    'paint_color': match.get('paint_color', 'unknown').lower(),
-                }
-                
-                price = predict_price(model, label_encoders, categorical_features, user_input)
+                price = predict_price(model, match, year)
                 predicted_prices.append(price)
 
             # Plotting the results
             plt.figure(figsize=(10, 5))
             plt.plot(years, predicted_prices, marker='o')
-            plt.title(f"Predicted Price of {match['make']} {match['model']} Over Time")
+            plt.title(f"Predicted Price of {match['Make']} {match['Model']} Over Time")
             plt.xlabel("Year")
             plt.ylabel("Predicted Price ($)")
             plt.grid()