Update app.py

app.py

@@ -1,10 +1,57 @@
+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
-import streamlit as st
 from sklearn.metrics.pairwise import cosine_similarity
 from sklearn.preprocessing import LabelEncoder
 
-# Load the CTP_Model1.csv file
+# 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):
+    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}]
+    
+    except Exception as e:
+        st.error(f"Classification error: {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']
+
+# Load and preprocess the car data once (globally for the session)
 def load_car_data():
     try:
         df = pd.read_csv('CTP_Model1.csv')  # Replace with the path to your actual CSV file
@@ -47,41 +94,81 @@ def find_closest_car(df, label_encoders, make, model, year):
     # Return the closest match details
     return df.iloc[closest_match_idx]
 
-# Streamlit App Updates
+# Streamlit App
+st.title("Auto Appraise")
+st.write("Upload a car image or take a picture to get its brand, model, and overview!")
 
-# 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)
+# Initialize session_state image attribute if it doesn't exist
+if 'image' not in st.session_state:
+    st.session_state.image = None
+
+# File uploader for image
+uploaded_file = st.file_uploader("Choose a car image", type=["jpg", "jpeg", "png"])
 
-# Your existing code for image upload and classification ...
+# Camera input as an alternative (optional)
+camera_image = st.camera_input("Or take a picture of the car")
 
-# After classification, find the closest car match
+# 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)}")
+
+# Display the processed image
 if st.session_state.image is not None:
-    # Classify the car image (already done earlier)
+    st.image(st.session_state.image, caption='Processed Image', use_container_width=True)
+
+    # Classify the car image
     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 the year (you may want to adjust this based on available data)
+        # Get additional information using GPT-3.5-turbo
         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']}")
+        car_data = load_car_data()
+        if car_data is not None:
+            processed_car_data, label_encoders = preprocess_car_data(car_data)
+            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.")
+        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.")