Upload 4 files

app.py

@@ -0,0 +1,115 @@
+import streamlit as st
+import pandas as pd
+import torch
+from sentence_transformers import SentenceTransformer, util
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+from sklearn.model_selection import train_test_split
+
+# Load precomputed embeddings
+df_with_embeddings = pd.read_pickle('df_with_embeddings.pkl')
+
+# Load the SentenceTransformer model
+model = SentenceTransformer('all-MiniLM-L6-v2')
+
+def get_user_input():
+    companions = st.selectbox("Who are you traveling with?", options=["solo", "couple", "family"])
+
+    if companions == "solo":
+        num_people = 1
+    elif companions == "couple":
+        num_people = 2
+    elif companions == "family":
+        num_people = st.number_input("Enter the number of people:", min_value=1, step=1)
+    
+    budget = st.number_input("Enter your budget per person:", min_value=0.0, step=0.01)
+    days_of_lodging = st.number_input("Enter the number of days of lodging:", min_value=1, step=1)
+    preferred_weather = st.selectbox("Enter preferred weather:", options=["Sunny", "Rainy", "Snowy"])
+
+    return budget, num_people, companions, days_of_lodging, preferred_weather
+
+def encode_user_input(user_input):
+    user_description = f"budget {user_input[0]} companions {user_input[2]} days {user_input[3]} weather {user_input[4]}"
+    # Encode user description and return it as a tensor
+    user_embedding = model.encode(user_description, convert_to_tensor=True)
+    return user_embedding
+
+def recommend_destinations(user_input, df):
+    # Get device (use GPU if available, else fallback to CPU)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    
+    # Encode user input and move to the correct device
+    user_embedding = encode_user_input(user_input).to(device)
+    
+    # Compute cosine similarity between user_embedding and each row's embedding in df
+    df['similarity'] = df['embedding'].apply(lambda x: util.pytorch_cos_sim(user_embedding, x.to(device)).item())
+
+    # Sort by similarity and return the top 5 recommendations
+    recommendations = df.sort_values(by='similarity', ascending=False).drop_duplicates(subset='Primary').head(5)
+
+    return recommendations[['Primary', 'per_person_price', 'Topography', 'Temprature', 'Weather', 'Mood']]
+
+def display_package_details(selection, df):
+    selected_row = df.loc[df['Primary'] == selection]
+    if not selected_row.empty:
+        st.write(f"*Package Name:* {selected_row['package_name'].values[0]}")
+        st.write(f"*Itinerary:* {selected_row['itinerary'].values[0]}")
+        st.write(f"*Sightseeing Places Covered:* {selected_row['sightseeing_places_covered'].values[0]}")
+    else:
+        st.write("Invalid selection. No package found.")
+
+def evaluate_model(df, model):
+    # Get the correct device
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    
+    # Split the data into train and test sets
+    train_df, test_df = train_test_split(df, test_size=0.2, random_state=42)
+    
+    # Encode the descriptions and move them to the appropriate device
+    train_embeddings = model.encode(train_df['description'].tolist(), convert_to_tensor=True).to(device)
+    test_embeddings = model.encode(test_df['description'].tolist(), convert_to_tensor=True).to(device)
+    
+    # Function to get the most similar label from the training set for a given test embedding
+    def get_most_similar_label(test_embedding, train_embeddings, train_labels):
+        similarities = util.pytorch_cos_sim(test_embedding, train_embeddings)
+        most_similar_idx = similarities.argmax().item()
+        return train_labels[most_similar_idx]
+    
+    # Predict labels for the test set
+    predicted_labels = [get_most_similar_label(embed, train_embeddings, train_df['Primary'].tolist()) for embed in test_embeddings]
+    
+    # Calculate accuracy metrics
+    accuracy = accuracy_score(test_df['Primary'], predicted_labels)
+    precision = precision_score(test_df['Primary'], predicted_labels, average='weighted')
+    recall = recall_score(test_df['Primary'], predicted_labels, average='weighted')
+    f1 = f1_score(test_df['Primary'], predicted_labels, average='weighted')
+    
+    return accuracy, precision, recall, f1
+
+# Streamlit app
+st.title("Travel Recommendation System")
+
+st.write("Please provide your travel preferences below:")
+
+user_input = get_user_input()
+
+if st.button("Get Recommendations"):
+    recommendations = recommend_destinations(user_input, df_with_embeddings)
+    st.write("Top recommended destinations for you:")
+    st.session_state.recommendations = recommendations
+    st.dataframe(recommendations)
+
+if 'recommendations' in st.session_state:
+    primary_selection = st.selectbox("Select a package to view details", options=st.session_state.recommendations['Primary'].tolist())
+    if st.button("View Details"):
+        st.session_state.selected_package = primary_selection
+
+if 'selected_package' in st.session_state:
+    st.write(f"Details for {st.session_state.selected_package}:")
+    display_package_details(st.session_state.selected_package, df_with_embeddings)
+
+if st.button("Evaluate Model Accuracy"):
+    accuracy, precision, recall, f1 = evaluate_model(df_with_embeddings, model)
+    st.write(f'Accuracy: {accuracy}')
+    st.write(f'Precision: {precision}')
+    st.write(f'Recall: {recall}')
+    st.write(f'F1 Score: {f1}')

df_with_embeddings.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e9b16bd4c44f08c5fe02dc8588f56b75cf9b020003faf1735093f80f49cf8f4b
+size 30494159

journeygenius.py

@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+"""JourneyGenius.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1TX_o_0MEaHKPF8J0-L3FEqfqawGLP30J
+"""
+
+!pip install sentence-transformers
+from sentence_transformers import SentenceTransformer, util
+
+import ast
+import pandas as pd
+import seaborn as sns
+!pip install geopy
+!pip install streamlit
+
+import pandas as pd
+from sentence_transformers import SentenceTransformer
+
+# Load the dataset
+file_path = '/content/ML_proj_dataset_updated (1).csv'
+df = pd.read_csv(file_path)
+
+# Extract relevant columns in the order to be returned
+relevant_columns = [
+    'Primary',
+    'per_person_price',
+    'Topography',
+    'Temprature',
+    'Weather',
+    'Mood',
+    'package_name',
+    'itinerary',
+    'sightseeing_places_covered'
+]
+df_relevant = df[relevant_columns].dropna()
+
+# Preprocess data
+def preprocess_data(df):
+    df['description'] = df.apply(lambda row: f"{row['Primary']} {row['Topography']} {row['Temprature']} {row['Weather']} {row['Mood']} {row['per_person_price']}", axis=1)
+    return df
+
+df_relevant = preprocess_data(df_relevant)
+
+# Encode data
+model = SentenceTransformer('all-MiniLM-L6-v2')
+df_relevant['embedding'] = df_relevant['description'].apply(lambda x: model.encode(x, convert_to_tensor=True))
+
+# Save embeddings to file
+df_relevant.to_pickle('/content/df_with_embeddings.pkl')
+
+import pandas as pd
+from sentence_transformers import SentenceTransformer, util
+
+# Load precomputed embeddings
+df_with_embeddings = pd.read_pickle('/content/df_with_embeddings.pkl')
+
+# User input function
+def get_user_input():
+    companions = input("Who are you traveling with (solo, couple, family): ").strip().lower()
+
+    if companions == "solo":
+        num_people = 1
+    elif companions == "couple":
+        num_people = 2
+    elif companions == "family":
+        num_people = int(input("Enter the number of people: "))
+    else:
+        print("Invalid input for companions. Please enter 'solo', 'couple', or 'family'.")
+        return get_user_input()  # Recursively ask for input again
+
+    budget = float(input("Enter your budget per person: "))
+    days_of_lodging = int(input("Enter the number of days of lodging: "))
+    preferred_weather = input("Enter preferred weather (Sunny, Rainy, Snowy): ").strip().capitalize()
+
+    return budget, num_people, companions, days_of_lodging, preferred_weather
+
+# Encode user input
+model = SentenceTransformer('all-MiniLM-L6-v2')
+
+def encode_user_input(user_input):
+    user_description = f"budget {user_input[0]} companions {user_input[2]} days {user_input[3]} weather {user_input[4]}"
+    return model.encode(user_description, convert_to_tensor=True)
+
+# Recommend destinations
+def recommend_destinations(user_input, df):
+    user_embedding = encode_user_input(user_input)
+    df['similarity'] = df['embedding'].apply(lambda x: util.pytorch_cos_sim(user_embedding, x).item())
+
+    # Sort by similarity and drop duplicates based on 'Primary' column
+    recommendations = df.sort_values(by='similarity', ascending=False).drop_duplicates(subset='Primary').head(5)
+
+    return recommendations[['Primary', 'per_person_price', 'Topography', 'Temprature', 'Weather', 'Mood']]
+
+# Display selected package details
+def display_package_details(selection, df):
+    selected_row = df.loc[df['Primary'] == selection]
+    if not selected_row.empty:
+        print("\nSelected Package Details:")
+        print(f"Package Name: {selected_row['package_name'].values[0]}")
+        print(f"Itinerary: {selected_row['itinerary'].values[0]}")
+        print(f"Sightseeing Places Covered: {selected_row['sightseeing_places_covered'].values[0]}")
+    else:
+        print("Invalid selection. No package found.")
+
+# Main function to run the recommendation system
+def main():
+    user_input = get_user_input()
+    recommendations = recommend_destinations(user_input, df_with_embeddings)
+    print("Top recommended destinations for you:")
+    print(recommendations)
+
+    # Let the user select a recommendation
+    selected_primary = input("\nEnter the Primary name of the package you want to view details for: ").strip()
+    display_package_details(selected_primary, df_with_embeddings)
+
+# Run the main function
+if __name__ == "__main__":
+    main()
+
+if __name__ == "__main__":
+    main()
+

requirements.txt

@@ -0,0 +1,6 @@
+streamlit
+pandas
+sentence-transformers
+scikit-learn
+gdown
+torch