Upload 24 files

analytics_reports/reports.py

@@ -0,0 +1,183 @@
+import streamlit as st
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+from matplotlib.ticker import ScalarFormatter  # Import ScalarFormatter
+import plotly.express as px
+import numpy as np
+
+st.set_option('deprecation.showPyplotGlobalUse', False)
+
+# Extract location
+input = 'data_3/data_test.csv'
+output = 'data_3/data_test_city.csv'
+# Load the addresses file into a DataFrame
+addresses_df = pd.read_csv(input, encoding='UTF-8-SIG')
+# print(addresses_df.head())
+
+# Load the cities/districts file into a DataFrame
+cities_districts_df = pd.read_csv('data_3/Cities.csv', encoding='UTF-8-SIG')
+
+# Function to find city and district for each address
+def find_city_district(location):
+    location = str(location)  # Ensure location is a string
+    for index, row in cities_districts_df.iterrows():
+        if str(row["City"]) in location and str(row["District"]) in location:
+            return row["City"], row["District"]
+    return None, None
+
+# Apply the function to the addresses DataFrame
+addresses_df[["City", "District"]] = addresses_df["Location"].apply(find_city_district).apply(pd.Series)
+
+# Save the new DataFrame to a CSV file
+addresses_df.to_csv(output, index=False)
+
+data = pd.read_csv('data_3/data_test_city.csv')
+print(data.info())
+
+df = data.dropna(subset = 'Price')
+df = df.dropna(subset = 'City')
+df=df[~((df['Price'] == 'Thỏa thuận'))]
+df['Price'] = pd.to_numeric(df['Price'].str.replace(',', ''), errors='coerce')
+df['Price'].astype(float)
+
+print(df.info())
+
+def plot_minmax_prices(selected_category):
+    # Filter the data based on the selected category
+    filtered_data = df[df['Category'] == selected_category]
+    
+    # Create a pivot table
+    pivot_table = filtered_data.pivot_table(index=['City', 'Category'], values='Price', aggfunc=['min', 'max']).reset_index()
+    print(pivot_table.head())
+    pivot_table.columns=['City','Category','Min Price','Max Price']
+    # Display the data table for the filtered data
+    st.subheader('Tổng hợp Giá bất động sản cao nhất và thấp nhất ở các tỉnh thành')
+    st.dataframe(pivot_table)
+
+def plot_by_category(selected_category):
+    # Get the unique city names and sort them alphabetically
+    unique_cities = sorted(df['City'].unique())
+    selected_city = st.sidebar.selectbox('Chọn thành phố hoặc tỉnh', unique_cities)
+    # Filter the data for the selected city
+    filtered_data = df[(df['City'] == selected_city) & (df['Category'] == selected_category)]
+    # Display the data table for the filtered data
+    # st.write('### Data Table')
+    # st.write(filtered_data)
+
+    # Check if data is empty
+    if filtered_data.empty:
+        print("filtered_data is empty")
+        st.warning(f"No data available for {selected_category} in {selected_city}.")
+    else:
+        # Plot Number of property by District
+        st.subheader(f'Số lượng bất động sản {selected_category} ở {selected_city}')
+        fig = plt.figure(figsize=(6, 3))
+        sns.countplot(data=filtered_data, y='District')
+        plt.xticks(rotation=25)  # Rotate x-axis labels for better readability
+        plt.xlabel('Số lượng')
+        plt.ylabel('Quận/Huyện')
+        st.pyplot(fig)
+
+        # Plot Price per Area
+        st.subheader(f'Giá bất động sản {selected_category} theo M² ở {selected_city}')
+        # Create a new column for Price per Area
+        filtered_data['Price per Area'] = filtered_data['Price'] / filtered_data['Area']
+        # Plot the data
+        fig = plt.figure(figsize=(6, 3))
+        sns.barplot(data=filtered_data,y='District',x='Price per Area')
+        plt.xticks(rotation=45)
+        plt.xlabel('Giá trung bình')
+        plt.ylabel('Quận/Huyện')
+        # Show the full number of price instead of scientific notation
+        plt.ticklabel_format(style='plain', axis='x')
+        st.pyplot(fig)
+
+        # Plot the estate type by City
+        # Create a pie chart showing the proportion of estate types by city
+        st.subheader(f'Loại bất động sản ở {selected_city}')
+        estate_type_counts = filtered_data['Estate type'].value_counts()
+        fig = px.pie(
+        values=estate_type_counts.values,
+        names=estate_type_counts.index,
+        )
+        # Display the chart
+        st.plotly_chart(fig)
+
+        # Plot the certification status by City
+        # Replace empty values (including spaces) with NaN in the 'Certification Status' column
+        filtered_data['Certification status'] = filtered_data['Certification status'].replace(' ', pd.NA)
+        # Replace blank (empty) values with "Không xác định" in the 'Certification Status' column
+        filtered_data['Certification status'].fillna("Không xác định", inplace=True)
+        certification_count = len(filtered_data[filtered_data['Certification status'].notna()])
+        if certification_count == 0:
+            st.write('')
+        else:
+            # Create a pie chart showing the proportion of certification status by city
+            st.subheader(f'Tình trạng pháp lý của bất động sản ở {selected_city}')
+            certification_counts = filtered_data['Certification status'].value_counts()
+            fig = px.pie(
+            values=certification_counts.values,
+            names=certification_counts.index,
+            )
+            # Display the chart
+            st.plotly_chart(fig)
+
+        # Plot the directions per city and Category
+        direction_count = len(filtered_data[filtered_data['Direction'].notna()])
+        if direction_count == 0:
+            st.write('')
+        else:
+            # Create a pie chart showing the proportion of estate types by city
+            st.subheader(f'Hướng bất động sản {selected_category} ở {selected_city}')
+            # Create a horizontal bar chart
+            fig = plt.figure(figsize=(6, 3))
+            sns.set(style='whitegrid')
+            sns.countplot(data=filtered_data, x="Direction", palette="Spectral")
+            plt.xlabel('Hướng')
+            plt.ylabel('Số lượng')
+            # plt.title(f'Directions of property in {selected_city}')
+            plt.show()
+            # Display the chart
+            st.pyplot(fig)
+
+        # Create a pie chart showing the proportion of estate types by city
+        st.subheader(f'Tỷ lệ bất động sản có chỗ đậu xe ở {selected_city}')
+        # Create a pie chart to show the proportion of parking slot and non-parking slot
+        # parking_slot_count = filtered_data[filtered_data['Parking slot'].notna()]['Parking slot'].count()
+        parking_slot_count = len(filtered_data[~np.isnan(filtered_data['Parking slot'])])
+        # non_parking_slot_count = filtered_data[filtered_data['Parking slot'].isna()]['Parking slot'].count()
+        non_parking_slot_count = len(filtered_data[np.isnan(filtered_data['Parking slot'])])
+        fig_pie = px.pie(
+        names=['Có chỗ đậu xe', 'Không có chỗ đậu xe'],
+        values=[parking_slot_count, non_parking_slot_count]
+        )
+        # Display the pie chart
+        st.plotly_chart(fig_pie)
+        if parking_slot_count == 0:
+            st.write('')
+        else:
+            st.subheader(f'Số lượng chỗ đậu xe ở {selected_city}')
+            filtered_data2 = filtered_data[filtered_data['Parking slot'].notna() & (filtered_data['Parking slot'] != ' ')]
+            # Create a horizontal bar chart
+            plt.figure(figsize=(6, 3))
+            sns.set(style="whitegrid")
+            sns.countplot(data=filtered_data2, x="Parking slot", palette="Spectral")
+            plt.xlabel('Số lượng chỗ đậu xe/bất động sản')
+            plt.ylabel('Số lượng')
+            # Display the chart
+            st.pyplot()
+    
+        # Create a pie chart showing the proportion of estate types by city
+        st.subheader(f'Tỷ lệ người bán ở {selected_city}')
+        # Create a pie chart to show the proportion of parking slot and non-parking slot
+        personal_count = filtered_data[filtered_data['Seller type'] == 'Cá Nhân - Chính Chủ']['Seller type'].count()
+        non_personal_count = filtered_data[filtered_data['Seller type'] == 'Công Ty Nhà Đất - Môi Giới BĐS']['Seller type'].count()
+        fig_pie = px.pie(
+        names=['Cá Nhân - Chính Chủ', 'Công Ty Nhà Đất - Môi Giới BĐS'],
+        values=[personal_count, non_personal_count],
+        )
+        # Display the pie chart
+        st.plotly_chart(fig_pie)
+        
+   

screens/analysis.py

@@ -0,0 +1,16 @@
+import streamlit as st
+import pandas as pd
+from analytics_reports.reports import plot_minmax_prices
+from analytics_reports.reports import plot_by_category
+
+def report_analysis():
+    # Title of the Analysis page
+    st.title('Analysis')
+
+    # Load your real estate data into a DataFrame
+    data = pd.read_csv('data_3/data_test_city.csv')
+
+    st.header('Analytics Reports')
+    st.sidebar.header('Select Category')
+    selected_category = st.sidebar.selectbox('Choose a Category', data['Category'].unique())
+    

screens/chat_bot.py

@@ -0,0 +1,187 @@
+import streamlit as st
+#Import library
+import yaml
+#load config.yml and parse into variables 
+with open("config.yml", "r") as ymlfile:
+    cfg = yaml.safe_load(ymlfile)
+_BARD_API_KEY = cfg["API_KEY"]["Bard"]
+main_path = cfg["LOCAL_PATH"]["main_path"]
+chat_context_length = cfg["CHAT"]["chat_context_length"]
+model_name = cfg["EMBEDDINGS"]["HuggingFaceEmbeddings"]["model_name"]
+model_kwargs = cfg["EMBEDDINGS"]["HuggingFaceEmbeddings"]["model_kwargs"]
+chunk_size = cfg["CHUNK"]["chunk_size"]
+chunk_overlap = cfg["CHUNK"]["chunk_overlap"]
+
+from langchain.vectorstores import Chroma
+import streamlit as st
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.chains import ConversationalRetrievalChain
+from langchain.prompts.chat import ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate
+# Bard
+from bardapi import Bard
+from typing import Any, List, Mapping, Optional
+from langchain.llms.base import LLM
+from langchain.callbacks.manager import CallbackManagerForLLMRun
+
+from streamlit_feedback import streamlit_feedback
+
+
+#define Bard
+class BardLLM(LLM):
+
+    @property
+    def _llm_type(self) -> str:
+        return "custom"
+
+    def _call(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+    ) -> str:
+        response = Bard(token=_BARD_API_KEY).get_answer(prompt)['content']
+        return response
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        """Get the identifying parameters."""
+        return {}
+
+
+
+def load_embeddings(): 
+    embeddings = HuggingFaceEmbeddings(model_name=model_name, model_kwargs=model_kwargs)
+    chroma_index = Chroma(persist_directory=main_path+"/vectorstore/chroma_db", embedding_function=embeddings)
+    print("Successfully loading embeddings and indexing")
+    return chroma_index
+
+
+
+def ask_with_memory(vector_store, question, chat_history_1=[], document_description=""):
+
+    llm=BardLLM()
+    retriever = vector_store.as_retriever( # now the vs can return documents
+    search_type='similarity', search_kwargs={'k': 3})
+ 
+    general_system_template = f"""
+    You are a professional consultant at a real estate consulting company, providing consulting services \
+    to customers on real estate development strategies, real estate news and real estate law.\
+    Your role is to communicate with customer, then interact with them about their concerns about real estates.\
+    Once the customer has been provided their question,\
+    then you obtain some documents about real estate laws or real estate news related to their question.\
+    Then you will examine these documents .\
+    You must provide the answer based on these documents which means\
+    using only the heading and piece of context to answer the questions at the end.\
+    If you don't know the answer just say that you don't know, don't try to make up an answer. \
+    If the question is not in the field of real estate , just answer that you do not know. \
+    You respond in a short, very conversational friendly style.\
+    Answer only in Vietnamese\
+    ----
+    HEADING: ({document_description})
+    CONTEXT: {{context}}
+    ----
+    """
+    general_user_template = """Here is the next question, remember to only answer if you can from the provided context. 
+    If the question is not relevant to real estate , just answer that you do not know, do not create your own answer.
+    Only respond in Vietnamese.
+     QUESTION:```{question}```"""
+
+    messages_1 = [
+                SystemMessagePromptTemplate.from_template(general_system_template),
+                HumanMessagePromptTemplate.from_template(general_user_template)
+    ]
+    qa_prompt = ChatPromptTemplate.from_messages( messages_1 )
+
+
+    crc = ConversationalRetrievalChain.from_llm(llm, retriever, combine_docs_chain_kwargs={'prompt': qa_prompt})
+    result = crc({'question': question, 'chat_history': chat_history_1})
+    return result
+
+
+def clear_history():
+    if "history_1" in st.session_state:
+        st.session_state.history_1 = []
+        st.session_state.messages_1 = [] 
+
+# Define a function for submitting feedback
+def _submit_feedback(user_response, emoji=None):
+    st.toast(f"Feedback submitted: {user_response}", icon=emoji)
+    return user_response.update({"some metadata": 123})
+
+
+def format_chat_history(chat_history_1):
+    formatted_history = ""
+    for entry in chat_history_1:
+        question, answer = entry
+        # Added an extra '\n' for the blank line
+        formatted_history += f"Question: {question}\nAnswer: {answer}\n\n"
+    return formatted_history
+
+def run_chatbot():
+    with st.sidebar.title("Sidebar"):
+        if st.button("Clear History"):
+            clear_history()
+
+    st.title("🦾 Law/News chatbot")
+
+    # Initialize the chatbot and load embeddings
+    if "messages_1" not in st.session_state:
+        with st.spinner("Initializing, please wait a moment!!!"):
+            st.session_state.vector_store = load_embeddings()
+            st.success("Finish!!!")
+        st.session_state["messages_1"] = [{"role": "assistant", "content": "Tôi có thể giúp gì được cho bạn?"}]
+
+    messages_1 = st.session_state.messages_1
+    feedback_kwargs = {
+        "feedback_type": "thumbs",
+        "optional_text_label": "Please provide extra information",
+        "on_submit": _submit_feedback,
+    }
+
+    for n, msg in enumerate(messages_1):
+        st.chat_message(msg["role"]).write(msg["content"])
+
+        if msg["role"] == "assistant" and n > 1:
+            feedback_key = f"feedback_{int(n/2)}"
+
+            if feedback_key not in st.session_state:
+                st.session_state[feedback_key] = None
+
+            streamlit_feedback(
+                **feedback_kwargs,
+                key=feedback_key,
+            )
+
+
+    chat_history_placeholder = st.empty()
+    if "history_1" not in st.session_state:
+        st.session_state.history_1 = []
+
+    if prompt := st.chat_input():
+        if "vector_store" in st.session_state:
+            vector_store = st.session_state["vector_store"]
+            
+            q = prompt
+
+            st.session_state.messages_1.append({"role": "user", "content": prompt})
+            st.chat_message("user").write(prompt)
+            with st.spinner("Thinking..."):
+                response = ask_with_memory(vector_store, q, st.session_state.history_1)
+
+            if len(st.session_state.history_1) >= chat_context_length:
+                st.session_state.history_1 = st.session_state.history_1[1:]
+
+            st.session_state.history_1.append((q, response['answer']))
+
+            chat_history_str = format_chat_history(st.session_state.history_1)
+
+            msg = {"role": "assistant", "content": response['answer']}
+            st.session_state.messages_1.append(msg)
+            st.chat_message("assistant").write(msg["content"])
+
+            # Display the feedback component after the chatbot responds
+            feedback_key = f"feedback_{len(st.session_state.messages_1) - 1}"
+            streamlit_feedback(
+                **feedback_kwargs,
+                key=feedback_key,
+            )

screens/chat_bot_2.py

@@ -0,0 +1,187 @@
+import streamlit as st
+#Import library
+import yaml
+#load config.yml and parse into variables 
+with open("config.yml", "r") as ymlfile:
+    cfg = yaml.safe_load(ymlfile)
+_BARD_API_KEY = cfg["API_KEY"]["Bard"]
+main_path = cfg["LOCAL_PATH"]["main_path"]
+chat_context_length = cfg["CHAT"]["chat_context_length"]
+model_name = cfg["EMBEDDINGS"]["HuggingFaceEmbeddings"]["model_name"]
+model_kwargs = cfg["EMBEDDINGS"]["HuggingFaceEmbeddings"]["model_kwargs"]
+chunk_size = cfg["CHUNK"]["chunk_size"]
+chunk_overlap = cfg["CHUNK"]["chunk_overlap"]
+
+import os
+from dotenv import load_dotenv, find_dotenv
+from langchain.vectorstores import Chroma
+import streamlit.components.v1 as components
+import streamlit as st
+import sys
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.chains import ConversationalRetrievalChain
+from langchain.prompts.chat import ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate
+# Bard
+from bardapi import Bard
+from typing import Any, List, Mapping, Optional
+from getpass import getpass
+import os
+from langchain.llms.base import LLM
+from langchain.callbacks.manager import CallbackManagerForLLMRun
+
+from streamlit_feedback import streamlit_feedback
+
+
+#define Bard
+class BardLLM(LLM):
+
+    @property
+    def _llm_type(self) -> str:
+        return "custom"
+
+    def _call(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+    ) -> str:
+        response = Bard(token=_BARD_API_KEY).get_answer(prompt)['content']
+        return response
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        """Get the identifying parameters."""
+        return {}
+
+
+
+def load_embeddings(): 
+    embeddings = HuggingFaceEmbeddings(model_name=model_name, model_kwargs=model_kwargs)
+    chroma_index = Chroma(persist_directory="./chroma_index_1", embedding_function=embeddings)
+    print("Successfully loading embeddings and indexing")
+    return chroma_index
+
+
+def ask_with_memory(vector_store, question, chat_history=[], document_description=""):
+
+    llm=BardLLM()
+    retriever = vector_store.as_retriever( # now the vs can return documents
+    search_type='similarity', search_kwargs={'k': 3})
+ 
+    general_system_template = f"""
+    Use the following pieces of context to answer the question at the end. 
+    If you don't know the answer, just say that you don't know, don't try to 
+    make up an answer.
+    Imagine you're talking to a friend and use natural language and phrasing.
+    You can only use Vietnamese do not use other languages.
+    Suggest using out searching function for more information.
+    ----
+    CONTEXT: {{context}}
+    ----
+    """
+    general_user_template = """Here is the next question, remember to only answer if you can from the provided context. 
+    If the question is not relevant to real estate , just answer that you do not know, do not create your own answer.
+    Do not recommend or propose any infomation of the properties. 
+    Be sure to respond in a complete sentence, being comprehensive, including all information in the provided context.
+    Imagine you're talking to a friend and use natural language and phrasing.
+    Only respond in Vietnamese.
+     QUESTION:```{question}```"""
+
+    messages = [
+                SystemMessagePromptTemplate.from_template(general_system_template),
+                HumanMessagePromptTemplate.from_template(general_user_template)
+    ]
+    qa_prompt = ChatPromptTemplate.from_messages( messages )
+
+
+    crc = ConversationalRetrievalChain.from_llm(llm, retriever, combine_docs_chain_kwargs={'prompt': qa_prompt})
+    result = crc({'question': question, 'chat_history': chat_history})
+    return result
+
+
+def clear_history():
+    if "history" in st.session_state:
+        st.session_state.history = []
+        st.session_state.messages = []
+
+# Define a function for submitting feedback
+def _submit_feedback(user_response, emoji=None):
+    st.toast(f"Feedback submitted: {user_response}", icon=emoji)
+    return user_response.update({"some metadata": 123})
+
+
+def format_chat_history(chat_history):
+    formatted_history = ""
+    for entry in chat_history:
+        question, answer = entry
+        # Added an extra '\n' for the blank line
+        formatted_history += f"Question: {question}\nAnswer: {answer}\n\n"
+    return formatted_history
+
+def run_chatbot_2():
+    with st.sidebar.title("Sidebar"):
+        if st.button("Clear History"):
+            clear_history()
+
+    st.title("🤖 Real Estate chatbot")
+
+    # Initialize the chatbot and load embeddings
+    if "messages" not in st.session_state:
+        with st.spinner("Initializing, please wait a moment!!!"):
+            st.session_state.vector_store = load_embeddings()
+            st.success("Finish!!!")
+        st.session_state["messages"] = [{"role": "assistant", "content": "Tôi có thể giúp gì được cho bạn?"}]
+
+    messages = st.session_state.messages
+    feedback_kwargs = {
+        "feedback_type": "thumbs",
+        "optional_text_label": "Please provide extra information",
+        "on_submit": _submit_feedback,
+    }
+
+    for n, msg in enumerate(messages):
+        st.chat_message(msg["role"]).write(msg["content"])
+
+        if msg["role"] == "assistant" and n > 1:
+            feedback_key = f"feedback_{int(n/2)}"
+
+            if feedback_key not in st.session_state:
+                st.session_state[feedback_key] = None
+
+            streamlit_feedback(
+                **feedback_kwargs,
+                key=feedback_key,
+            )
+
+    chat_history_placeholder = st.empty()
+    if "history" not in st.session_state:
+        st.session_state.history = []
+
+    if prompt := st.chat_input():
+        if "vector_store" in st.session_state:
+            vector_store = st.session_state["vector_store"]
+            
+            q = prompt
+
+            st.session_state.messages.append({"role": "user", "content": prompt})
+            st.chat_message("user").write(prompt)
+
+            response = ask_with_memory(vector_store, q, st.session_state.history)
+
+            if len(st.session_state.history) >= chat_context_length:
+                st.session_state.history = st.session_state.history[1:]
+
+            st.session_state.history.append((q, response['answer']))
+
+            chat_history_str = format_chat_history(st.session_state.history)
+
+            msg = {"role": "assistant", "content": response['answer']}
+            st.session_state.messages.append(msg)
+            st.chat_message("assistant").write(msg["content"])
+
+            # Display the feedback component after the chatbot responds
+            feedback_key = f"feedback_{len(st.session_state.messages) - 1}"
+            streamlit_feedback(
+                **feedback_kwargs,
+                key=feedback_key,
+            )

screens/index.py

@@ -0,0 +1,37 @@
+from screens.search import Search_Property
+from screens.chat_bot import run_chatbot
+from screens.chat_bot_2 import run_chatbot_2
+from screens.analysis import  report_analysis
+from screens.predict import predict_price
+from utils.index import get_hash
+
+def get_routes():
+    screens = [
+        {
+            "component": predict_price,
+            "name": "Price Prediction",
+            "icon": "piggy-bank"
+        },
+        {
+            "component": report_analysis,
+            "name": "Report Analysis",
+            "icon": "bi-bar-chart-line"  
+        },
+        {
+            "component": Search_Property,
+            "name": "Search",
+            "icon": "search"  
+        },
+        {
+            "component": run_chatbot,
+            "name": "Law/News chatbot",
+            "icon": "chat"  
+        },
+        {
+            "component": run_chatbot_2,
+            "name": "Real Estate chatbot",
+            "icon": "chat-dots"  
+        }
+    ]
+    
+    return get_hash(screens)

screens/predict.py

@@ -0,0 +1,125 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from autogluon.multimodal import MultiModalPredictor
+from autogluon.tabular import TabularPredictor
+
+# Define icons
+seller_icon = "🏡"
+buyer_icon = "🔍"
+submit_icon = "📝"
+predict_icon = "🔮"
+
+# Initialize df as a global variable
+df = None
+
+def predict_price():
+    global df  # Declare df as a global variable
+    # Set the title and subheader
+    st.title("Real Estate Price Prediction")
+    st.subheader("Choose your role and provide property details")
+
+    # User role selection
+    option = st.selectbox("Who are you?", ['Seller', 'Buyer'], index=0)
+
+    if option == "Seller":
+        st.subheader(f"{seller_icon} Seller Information")
+        with st.spinner("Loading model..."):
+            predictor = MultiModalPredictor.load("C:/Users/duong/OneDrive/Desktop/mm-nlp-image-transformer")
+        st.success("Done")
+        description = st.text_area("Property Description", help="Describe your property")
+        title = st.text_input("Property Title", help="Enter a title for your property")
+    else:
+        st.subheader(f"{buyer_icon} Buyer Information")
+        with st.spinner("Loading model..."):
+            predictor = TabularPredictor.load("C:/Users/duong/OneDrive/Desktop/tabular", require_py_version_match=False)
+        st.success("Done")
+
+    # Property details input
+    area = st.number_input("Property Area (square meters)", min_value=1)
+    location = st.text_input("Property Location", help="Enter the location of the property")
+    city_code = st.text_input("City Code", help="Enter the city code")
+    district = st.text_input("District", help="Enter the district name")
+    bedroom = st.slider("Number of Bedrooms", min_value=1, max_value=10, value=5, step=1)
+    bathroom = st.slider("Number of Bathrooms", min_value=1, max_value=10, value=2, step=1)
+
+    # Submit button to create the DataFrame
+    submitted = st.button(f"{submit_icon} Submit")
+
+    # Create a DataFrame from user inputs
+    if submitted: 
+        if area and location and city_code and district and bedroom and bathroom:
+            if option == "Seller":  
+                if (not description or not title):
+                    st.error("Please fill in both Description and Title fields for Sellers.")
+                else:
+                    data = {
+                        "Price": np.nan,
+                        "Area": [area],
+                        "Location": [location],
+                        "Time stamp": np.nan,
+                        "Certification status": np.nan,
+                        "Direction": np.nan,
+                        "Bedrooms": [bedroom],
+                        "Bathrooms": [bathroom],
+                        "Front width": np.nan,
+                        "Floor": np.nan,
+                        "Image URL": np.nan,
+                        "Road width": np.nan,
+                        "City_code": [city_code],
+                        "DistrictId": [district],
+                        "Balcony_Direction": np.nan,
+                        "Longitude": np.nan,
+                        "Lattitude": np.nan,
+                        "Description": [description],
+                        "Title": [title]
+                    }
+                    df = pd.DataFrame(data)
+                    st.write(f"{seller_icon} Input Data:")
+                    st.dataframe(df)
+            elif option == "Buyer":
+                data = {
+                        "Price": np.nan,
+                        "Area": [area],
+                        "Location": [location],
+                        "Time stamp": np.nan,
+                        "Certification status": np.nan,
+                        "Direction": np.nan,
+                        "Bedrooms": [bedroom],
+                        "Bathrooms": [bathroom],
+                        "Front width": np.nan,
+                        "Floor": np.nan,
+                        "Image URL": np.nan,
+                        "Road width": np.nan,
+                        "City_code": [city_code],
+                        "DistrictId": [district],
+                        "Balcony_Direction": np.nan,
+                        "Longitude": np.nan,
+                        "Lattitude": np.nan
+                    }
+                df = pd.DataFrame(data)
+                st.write(f"{buyer_icon} Input Data:")
+                st.dataframe(df)
+        else:
+            st.error("Please fill in all fields to have a better prediction!")
+
+    # Prediction button (enabled only when data has been submitted)
+    if st.button(f"{predict_icon} Predict"):
+        with st.spinner("Loading..."):
+            # Perform predictions and calculations here
+            predictions = predictor.predict(df.drop(columns="Price"))
+            st.success(f"Predicted Price: {predictions[0]:,.0f} VND")
+
+            scores = predictor.evaluate(
+                df,
+                metrics=[
+                    "mean_squared_error",
+                    "r2",
+                ],
+            )
+
+            st.subheader("Model Evaluation Metrics:")
+            for metric, score in scores.items():
+                st.write(f"{metric}: {score:.2f}")
+
+

screens/search.py

@@ -0,0 +1,248 @@
+import streamlit as st
+import os
+import streamlit.components.v1 as components
+from io import BytesIO
+import requests
+import ast
+
+from langchain import PromptTemplate
+from langchain.chains import RetrievalQA
+from langchain.vectorstores import Chroma
+from langchain.embeddings import SentenceTransformerEmbeddings
+from bardapi import Bard
+from typing import Any, List, Mapping, Optional
+
+import yaml
+with open("config.yml", "r") as ymlfile:
+    cfg = yaml.safe_load(ymlfile)
+os.environ['_BARD_API_KEY'] = cfg["API_KEY"]["Bard"]
+
+from langchain.llms.base import LLM
+from langchain.callbacks.manager import CallbackManagerForLLMRun
+class BardLLM(LLM):
+
+
+    @property
+    def _llm_type(self) -> str:
+        return "custom"
+
+    def _call(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+    ) -> str:
+        response = Bard(token=os.environ['_BARD_API_KEY']).get_answer(prompt)['content']
+        return response
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        """Get the identifying parameters."""
+        return {}
+    
+@st.cache_data
+def get_image(url):
+    r = requests.get(url)
+    return BytesIO(r.content)
+
+
+# Define global variables
+embeddings = None
+index = None
+QUESTION_PROMPT = None
+qa = None
+result = []
+
+# Custom session state class for managing pagination
+class SessionState:
+    def __init__(self):
+        self.page_index = 0  # Initialize page index
+        self.database_loaded = False  # Initialize database loaded state
+
+# Create a session state object
+session_state = SessionState()
+
+# Define the search function outside of Search_Property
+def display_search_results(result, start_idx, end_idx):
+    if result:
+        st.subheader("Search Results:")
+        for idx in range(start_idx, end_idx):
+            if idx >= len(result):
+                break
+            property_info = result[idx]
+            st.markdown(f"**Result {idx + 1}**")
+            
+            # Display property information
+            if 'Image URL' in property_info.metadata and property_info.metadata['Image URL'] is not None and not isinstance(property_info.metadata['Image URL'], float):
+                image_path_urls = property_info.metadata['Image URL']
+                if image_path_urls is not None and not isinstance(image_path_urls, float):
+                    # Convert the string to a Python list
+                    imageUrls = ast.literal_eval(image_path_urls)
+
+                    # Now, imageUrls is a list of strings
+                    st.image(imageUrls[0],width=700)
+
+            st.markdown(f"🏡 {property_info.metadata['Title']}")
+            if 'Location' in property_info.metadata and property_info.metadata['Location'] is not None and not isinstance(property_info.metadata['Location'], float):
+                st.write(f"📍 Address: {property_info.metadata['Location']}")
+            if 'Area' in property_info.metadata and property_info.metadata['Area'] is not None and not isinstance(property_info.metadata['Area'], float):
+                st.markdown(f"📏 Size: {property_info.metadata['Area']}")
+            if 'Price' in property_info.metadata and property_info.metadata['Price'] is not None and not isinstance(property_info.metadata['Price'], float):
+                st.markdown(f"💰 Price: {property_info.metadata['Price']} ")
+            st.markdown(f"📅 Published Date: {property_info.metadata['Time stamp']}") 
+            col3, col4 = st.columns([2, 1]) 
+            with col3: 
+                with st.expander("Full Property Information"):
+                    st.write(f"🏡 Property Title: {property_info.metadata['Title']}")
+                    if 'Area' in property_info.metadata and property_info.metadata['Area'] is not None and not isinstance(property_info.metadata['Area'], float):
+                        st.write(f"📏 Size: {property_info.metadata['Area']}")
+                    if 'Category' in property_info.metadata and property_info.metadata['Category'] is not None and not isinstance(property_info.metadata['Category'], float):
+                        st.write(f"🏢 Category: {property_info.metadata['Category']}")
+                    if 'Description' in property_info.metadata and property_info.metadata['Description'] is not None and not isinstance(property_info.metadata['Description'], float):
+                        st.write(f"📝 Description: {property_info.metadata['Description']}")
+                    if 'Price' in property_info.metadata and property_info.metadata['Price'] is not None and not isinstance(property_info.metadata['Price'], float):
+                        st.write(f"💰 Price: {property_info.metadata['Price']}")
+                    st.write(f"📅 Date: {property_info.metadata['Time stamp']}")
+                    if 'Location' in property_info.metadata and property_info.metadata['Location'] is not None and not isinstance(property_info.metadata['Location'], float):
+                        st.write(f"📍 Address: {property_info.metadata['Location']}")
+                    st.write(f"🆔 ID: {property_info.metadata['ID']}")
+                    if 'Estate type' in property_info.metadata and property_info.metadata['Estate type'] is not None and not isinstance(property_info.metadata['Estate type'], float):
+                        st.write(f"🏠 Housing Type: {property_info.metadata['Estate type']}")
+                    if 'Email' in property_info.metadata and property_info.metadata['Email'] is not None and not isinstance(property_info.metadata['Email'], float):
+                        st.write(f"✉️ Email: {property_info.metadata['Email']}")
+                    if 'Mobile Phone' in property_info.metadata and property_info.metadata['Mobile Phone'] is not None and not isinstance(property_info.metadata['Mobile Phone'], float):
+                        st.write(f"📞 Phone: {property_info.metadata['Mobile Phone']}")
+                    if 'Certification status' in property_info.metadata and property_info.metadata['Certification status'] is not None and not isinstance(property_info.metadata['Certification status'], float):
+                        st.write(f"🏆 Certification status: {property_info.metadata['Certification status']}")
+                    if 'Direction' in property_info.metadata and property_info.metadata['Direction'] is not None and not isinstance(property_info.metadata['Direction'], float):
+                        st.write(f"🧭 Direction: {property_info.metadata['Direction']}")
+                    if 'Rooms' in property_info.metadata and property_info.metadata['Rooms'] is not None and not isinstance(property_info.metadata['Rooms'], float):
+                        st.write(f"🚪 Rooms: {property_info.metadata['Rooms']}")
+                    if 'Bedrooms' in property_info.metadata and property_info.metadata['Bedrooms'] is not None and not isinstance(property_info.metadata['Bedrooms'], float):
+                        st.write(f"🛏️ Bedrooms: {property_info.metadata['Bedrooms']}")
+                    if 'Kitchen' in property_info.metadata and property_info.metadata['Kitchen'] is not None and not isinstance(property_info.metadata['Kitchen'], float):
+                        st.write(f"🍽️ Kitchen: {property_info.metadata['Kitchen']}")
+                    if 'Living room' in property_info.metadata and property_info.metadata['Living room'] is not None and not isinstance(property_info.metadata['Living room'], float):
+                        st.write(f"🛋️ Living room: {property_info.metadata['Living room']}")
+                    if 'Bathrooms' in property_info.metadata and property_info.metadata['Bathrooms'] is not None and not isinstance(property_info.metadata['Bathrooms'], float):
+                        st.write(f"🚽 Bathrooms: {property_info.metadata['Bathrooms']}")
+                    if 'Front width' in property_info.metadata and property_info.metadata['Front width'] is not None and not isinstance(property_info.metadata['Front width'], float):
+                        st.write(f"📐 Front width: {property_info.metadata['Front width']}")
+                    if 'Floor' in property_info.metadata and property_info.metadata['Floor'] is not None and not isinstance(property_info.metadata['Floor'], float):
+                        st.write(f"🧱 Floor: {property_info.metadata['Floor']}")
+                    if 'Parking Slot' in property_info.metadata and property_info.metadata['Parking Slot'] is not None and not isinstance(property_info.metadata['Parking Slot'], float):
+                        st.write(f"🚗 Parking Slot: {property_info.metadata['Parking Slot']}")
+                    if 'Seller name' in property_info.metadata and property_info.metadata['Seller name'] is not None and not isinstance(property_info.metadata['Seller name'], float):
+                        st.write(f"👤 Seller Name: {property_info.metadata['Seller name']}")
+                    if 'Seller type' in property_info.metadata and property_info.metadata['Seller type'] is not None and not isinstance(property_info.metadata['Seller type'], float):
+                        st.write(f"👨‍💼 Seller type: {property_info.metadata['Seller type']}")
+                    if 'Seller Address' in property_info.metadata and property_info.metadata['Seller Address'] is not None and not isinstance(property_info.metadata['Seller Address'], float):
+                        st.write(f"📌 Seller Address: {property_info.metadata['Seller Address']}")
+                    if 'Balcony Direction' in property_info.metadata and property_info.metadata['Balcony Direction'] is not None and not isinstance(property_info.metadata['Balcony Direction'], float):
+                        st.write(f"🌄 Balcony Direction: {property_info.metadata['Balcony Direction']}")
+                    if 'Furniture' in property_info.metadata and property_info.metadata['Furniture'] is not None and not isinstance(property_info.metadata['Furniture'], float):
+                        st.write(f"🛋️ Furniture: {property_info.metadata['Furniture']}")
+                    if 'Toilet' in property_info.metadata and property_info.metadata['Toilet'] is not None and not isinstance(property_info.metadata['Toilet'], float):
+                        st.write(f"🚽 Toilet: {property_info.metadata['Toilet']}")                
+
+            with col4:
+                st.empty()
+            if 'Image URL' in property_info.metadata and property_info.metadata['Image URL'] is not None and not isinstance(property_info.metadata['Image URL'], float):
+                imageCarouselComponent = components.declare_component("image-carousel-component", path="./frontend/public")
+                image_path_urls = property_info.metadata['Image URL']
+                if image_path_urls is not None and not isinstance(image_path_urls, float):
+                    # Convert the string to a Python list
+                    imageUrls = ast.literal_eval(image_path_urls)
+                    if len(imageUrls) > 1:
+                        selectedImageUrl = imageCarouselComponent(imageUrls=imageUrls, height=200)
+                        if selectedImageUrl is not None:
+                            st.image(selectedImageUrl)
+
+            # Add a divider after displaying property info
+            st.markdown("<hr style='border: 2px solid white'>", unsafe_allow_html=True)  # Horizontal rule as a divider
+            
+
+def Search_Property():
+    global embeddings, index, result, QUESTION_PROMPT, qa
+
+    st.title("🏘️ Property Search ")
+    # Load data and create the search
+    if not session_state.database_loaded:
+        st.info("Loading database... This may take a moment.")
+        embeddings = SentenceTransformerEmbeddings(model_name="keepitreal/vietnamese-sbert")
+        # Create a Chroma object with persistence
+        db = Chroma(persist_directory="./chroma_index_1", embedding_function=embeddings)
+        # Get documents from the database
+        db.get()
+        llm=BardLLM()
+        qa = RetrievalQA.from_chain_type(
+        llm=llm,
+        chain_type="stuff",
+        retriever=db.as_retriever(search_type="similarity", search_kwargs={"k":4}),
+        return_source_documents=True)
+        question_template = """
+        Context: You are a helpful and informative bot that answers questions posed below using provided context.\
+        You have to be truthful. Do not recommend or propose any infomation of the properties.\
+        Be sure to respond in a complete sentence, being comprehensive, including all information in the provided context.\
+        Imagine you're talking to a friend and use natural language and phrasing.\
+        You can only use Vietnamese do not use other languages.
+
+        QUESTION: '{question}'
+
+        ANSWER:
+        """
+        QUESTION_PROMPT = PromptTemplate(
+            template=question_template, input_variables=["question"]
+        )   
+        session_state.database_loaded = True
+
+    if session_state.database_loaded:
+        col1, col2 = st.columns([2, 1])  # Create a two-column layout
+
+        with col1:
+            query = st.text_input("Enter your property search query:")
+            search_button = st.button("Search", help="Click to start the search")
+
+            if search_button:
+                if not query:
+                    st.warning("Please input your query")
+                else:
+                    with st.spinner("Searching..."):
+                        if query is not None:  # Check if model_embedding is not None
+                            qa.combine_documents_chain.llm_chain.prompt = QUESTION_PROMPT
+                            qa.combine_documents_chain.verbose = True
+                            qa.return_source_documents = True
+                            results = qa({"query":query,})
+                            result = results["source_documents"]
+                            session_state.page_index = 0  # Reset page index when a new search is performed
+                        
+        with col2:
+            if len(result) > 0:
+                st.info(f'Total Results: {len(result)} properties found.')  # Display "Total Results" in the second column
+
+        if result:   
+            N = 5 
+            prev_button, next_button = st.columns([4,1])
+            last_page = len(result) // N
+
+            
+            # Update page index based on button clicks
+            if prev_button.button("Previous", key="prev_button"):
+                if session_state.page_index - 1 < 0:
+                    session_state.page_index = last_page
+                else:
+                    session_state.page_index -= 1
+
+            if next_button.button("Next", key="next_button"):
+                if session_state.page_index > last_page:
+                    st.warning("Displayed all results")
+                    session_state.page_index = 0
+                else:
+                    session_state.page_index += 1
+
+            # Calculate the range of results to display (5 properties at a time)
+            start_idx = session_state.page_index * N 
+            end_idx = (1 + session_state.page_index) * N
+
+            # Display results for the current page
+            display_search_results(result, start_idx, end_idx)