Update app.py

app.py

@@ -1,111 +1,86 @@
-import streamlit as st
-from PIL import Image
-from transformers import AutoFeatureExtractor, AutoModelForImageClassification
-import torch
-from datetime import datetime
-import openai
+import pandas as pd
+import numpy as np
+from sklearn.metrics.pairwise import cosine_similarity
+from sklearn.preprocessing import LabelEncoder
 
-# Initialize OpenAI API key
-openai.api_key = st.secrets["GPT_TOKEN"]
-
-# Function to classify the car image using pre-trained model
-def classify_image(image):
+# Load the CTP_Model1.csv file
+def load_car_data():
     try:
-        # Load the model and feature extractor
-        model_name = "dima806/car_models_image_detection"
-        feature_extractor = AutoFeatureExtractor.from_pretrained(model_name)
-        model = AutoModelForImageClassification.from_pretrained(model_name)
-
-        # Preprocess the image
-        inputs = feature_extractor(images=image, return_tensors="pt")
-
-        # Perform inference
-        with torch.no_grad():
-            outputs = model(**inputs)
-
-        # Get the predicted class
-        logits = outputs.logits
-        predicted_class_idx = logits.argmax(-1).item()
-        
-        # Get the class label and score
-        predicted_class_label = model.config.id2label[predicted_class_idx]
-        score = torch.nn.functional.softmax(logits, dim=-1)[0, predicted_class_idx].item()
-
-        # Return the top prediction
-        return [{'label': predicted_class_label, 'score': score}]
-    
+        df = pd.read_csv('CTP_Model1.csv')  # Replace with the path to your actual CSV file
+        return df
     except Exception as e:
-        st.error(f"Classification error: {e}")
+        st.error(f"Error loading CSV file: {e}")
         return None
 
-# Function to get an overview of the car using OpenAI
-def get_car_overview(brand, model, year):
-    prompt = f"Provide an overview of the following car:\nYear: {year}\nMake: {brand}\nModel: {model}\n"
-    response = openai.ChatCompletion.create(
-        model="gpt-3.5-turbo",
-        messages=[{"role": "user", "content": prompt}]
-    )
-    return response.choices[0].message['content']
-
-# Streamlit App
-st.title("Auto Appraise")
-st.write("Upload a car image or take a picture to get its brand, model, and overview!")
+# Preprocess car data and encode categorical features
+def preprocess_car_data(df):
+    label_encoders = {}
+    
+    # Encode categorical columns (make, model, trim, fuel, title_status, etc.)
+    for col in ['make', 'model', 'trim', 'fuel', 'title_status', 'transmission', 'drive', 'size', 'type', 'paint_color']:
+        le = LabelEncoder()
+        df[col] = le.fit_transform(df[col])
+        label_encoders[col] = le
+    
+    return df, label_encoders
 
-# Get the session state
-if 'image' not in st.session_state:
-    st.session_state.image = None
+# Calculate similarity between the classified car and entries in the CSV
+def find_closest_car(df, label_encoders, make, model, year):
+    # Encode the user-provided make and model
+    make_encoded = label_encoders['make'].transform([make])[0]
+    model_encoded = label_encoders['model'].transform([model])[0]
+    
+    # Create a feature vector for the classified car (make, model, year)
+    classified_car_vector = np.array([make_encoded, model_encoded, year]).reshape(1, -1)
+    
+    # Prepare the data for similarity calculation
+    feature_columns = ['make', 'model', 'year']
+    df_feature_vectors = df[feature_columns].values
+    
+    # Compute cosine similarity between the classified car and all entries in the CSV
+    similarity_scores = cosine_similarity(classified_car_vector, df_feature_vectors)
+    
+    # Get the index of the closest match
+    closest_match_idx = similarity_scores.argmax()
+    
+    # Return the closest match details
+    return df.iloc[closest_match_idx]
 
-# File uploader for image
-uploaded_file = st.file_uploader("Choose a car image", type=["jpg", "jpeg", "png"])
+# Streamlit App Updates
 
-# Camera input as an alternative (optional)
-camera_image = st.camera_input("Or take a picture of the car")
+# Load and preprocess the car data once (globally for the session)
+car_data = load_car_data()
+if car_data is not None:
+    processed_car_data, label_encoders = preprocess_car_data(car_data)
 
-# Process the image (either uploaded or from camera)
-if uploaded_file is not None:
-    st.write("Attempting to open uploaded file...")
-    try:
-        st.session_state.image = Image.open(uploaded_file)
-        st.write("Image uploaded successfully.")
-    except Exception as e:
-        st.error(f"Error opening uploaded file: {str(e)}")
-elif camera_image is not None:
-    st.write("Attempting to open camera image...")
-    try:
-        st.session_state.image = Image.open(camera_image)
-        st.write("Image captured successfully.")
-    except Exception as e:
-        st.error(f"Error opening camera image: {str(e)}")
+# Your existing code for image upload and classification ...
 
-# Display the processed image
+# After classification, find the closest car match
 if st.session_state.image is not None:
-    st.image(st.session_state.image, caption='Processed Image', use_container_width=True)
-
-    # Classify the car image
+    # Classify the car image (already done earlier)
     with st.spinner('Analyzing image...'):
         car_classifications = classify_image(st.session_state.image)
     
     if car_classifications:
         st.write("Image classification successful.")
-        st.subheader("Car Classification Results:")
-        for classification in car_classifications:
-            st.write(f"Model: {classification['label']}")
-            st.write(f"Confidence: {classification['score'] * 100:.2f}%")
-        
-        # Separate make and model from the classification result
         top_prediction = car_classifications[0]['label']
         make_name, model_name = top_prediction.split(' ', 1)
-        
-        st.write(f"Identified Car Make: {make_name}")
-        st.write(f"Identified Car Model: {model_name}")
 
-        # Get additional information using GPT-3.5-turbo
+        # Get the year (you may want to adjust this based on available data)
         current_year = datetime.now().year
-        overview = get_car_overview(make_name, model_name, current_year)
-        st.write("Car Overview:")
-        st.write(overview)
 
+        # Find the closest match in the CSV based on the classification
+        closest_car = find_closest_car(processed_car_data, label_encoders, make_name, model_name, current_year)
+        
+        st.write(f"Closest match in database:")
+        st.write(f"Year: {closest_car['year']}")
+        st.write(f"Make: {label_encoders['make'].inverse_transform([closest_car['make']])[0]}")
+        st.write(f"Model: {label_encoders['model'].inverse_transform([closest_car['model']])[0]}")
+        st.write(f"Price: ${closest_car['price']}")
+        st.write(f"Condition: {closest_car['condition']}")
+        st.write(f"Fuel: {closest_car['fuel']}")
+        st.write(f"Transmission: {closest_car['transmission']}")
+        st.write(f"Drive: {closest_car['drive']}")
+        st.write(f"Type: {closest_car['type']}")
     else:
-        st.error("Could not classify the image. Please try again with a different image.")
-else:
-    st.write("Please upload an image or take a picture to proceed.")
+        st.error("Could not classify the image. Please try again with a different image.")