update comments

app.py

@@ -1,74 +1,75 @@
 import gradio as gr
 from huggingface_hub import InferenceClient
 
-#STEP 1 FROM SEMANTIC SEARCH
+# STEP 1 FROM SEMANTIC SEARCH
 from sentence_transformers import SentenceTransformer
 import torch
 
-#STEP 2 FROM SEMANTIC SEARCH
-with open("travel_info.txt", "r", encoding="utf-8") as file: # Open the travel_info.txt file in read mode with UTF-8 encoding
-    travel_text = file.read() # Read file and store into variable
+# STEP 2 FROM SEMANTIC SEARCH
+with open("travel_info.txt", "r", encoding="utf-8") as file:
+    travel_text = file.read()
 
-#STEP 3 FROM SEMANTIC SEARCH
-def preprocess_text(text):
-    cleaned_text = text.strip() # Strip extra whitespace from beginning and end of text
-    chunks = cleaned_text.split("\n") # Split cleaned_text by every newline character (\n)
-    cleaned_chunks = [] # Empty list to store cleaned chunks
+# STEP 3 FROM SEMANTIC SEARCH
+def preprocess_text(text): # Clean raw text and split it into non-empty chunks
+    cleaned_text = text.strip()
+    chunks = cleaned_text.split("\n")
+    cleaned_chunks = []
 
-    for chunk in chunks: # For-in loop to clean each chunk and add to list
+    for chunk in chunks:
         chunk = chunk.strip()
         if chunk != "":
             cleaned_chunks.append(chunk)
         
-    print(cleaned_chunks)
-    print(len(cleaned_chunks))
+    print(cleaned_chunks) # Make sure the correct file is being read
     
     return cleaned_chunks
 
-cleaned_chunks = preprocess_text(travel_text) # Call preprocess_text and store result in cleaned_chunks
+cleaned_chunks = preprocess_text(travel_text)
 
-#STEP 4 FROM SEMANTIC SEARCH
-model = SentenceTransformer('all-MiniLM-L6-v2') # Load pre-trained embedding model that converts text to vectors
-
-def create_embeddings(text_chunks):
-    chunk_embeddings = model.encode(text_chunks, convert_to_tensor=True) # Convert each text chunk into a vector embedding and store as a tensor
-
-    print(chunk_embeddings)
-    print(chunk_embeddings.shape)
+# STEP 4 FROM SEMANTIC SEARCH
+model = SentenceTransformer('all-MiniLM-L6-v2') # Load pre-trained model for sentence embeddings
 
+def create_embeddings(text_chunks): # Convert text chunks to vector embeddings
+    chunk_embeddings = model.encode(text_chunks, convert_to_tensor=True)
+    
     return chunk_embeddings
 
-chunk_embeddings = create_embeddings(cleaned_chunks) # Call create_embeddings and store result in chunk_embeddings
+chunk_embeddings = create_embeddings(cleaned_chunks)
 
 #STEP 5 FROM SEMANTIC SEARCH
-def get_top_chunks(query, chunk_embeddings, text_chunks): #Finds most relevant text chunks for given query, chunk_embeddings, and text_chunks
-    query_embedding = model.encode(query,convert_to_tensor=True) # Convert query string into vector embedding
+def get_top_chunks(query, chunk_embeddings, text_chunks): # Return top 3 text chunks most semantically similar to the query
+    query_embedding = model.encode(query,convert_to_tensor=True)
 
-    query_embedding_normalized = query_embedding / query_embedding.norm() # Normalize query embedding to unit length for accurate similarity comparison
-    chunk_embeddings_normalized = chunk_embeddings / chunk_embeddings.norm(dim=1, keepdim=True) # Normalize all chunk embeddings to unit length for consistent comparison
+    query_embedding_normalized = query_embedding / query_embedding.norm()
+    chunk_embeddings_normalized = chunk_embeddings / chunk_embeddings.norm(dim=1, keepdim=True)
 
-    similarities = torch.matmul(chunk_embeddings_normalized,query_embedding_normalized) # Calculate cosine similarity between query and all chunks using matrix multiplication
+    similarities = torch.matmul(chunk_embeddings_normalized,query_embedding_normalized)
     print(similarities)
 
-    top_indices = torch.topk(similarities, k=3).indices # Find indices of the 3 chunks with highest similarity scores
+    top_indices = torch.topk(similarities, k=3).indices
     print(top_indices)
 
-    top_chunks = [] # Empty list to store most relevant chunks
+    top_chunks = []
 
-    for i in top_indices: # Loop through top indices to retrieve corresponding text chunks
+    for i in top_indices:
         chunk=text_chunks[i]
         top_chunks.append(chunk)
 
     return top_chunks
 
 #STEP 6 FROM SEMANTIC SEARCH
-top_results = get_top_chunks("Why is it important to carry copies of your travel documents?", chunk_embeddings, cleaned_chunks) # Call get_top_chunks with query
+top_results = get_top_chunks(
+    "Why is it important to carry copies of your travel documents?",
+    chunk_embeddings,
+    cleaned_chunks
+)
+
 print(top_results)
 
 #HUGGING FACE PROJECT
 client = InferenceClient("Qwen/Qwen2.5-72B-instruct")
 
-def respond(message, history):
+def respond(message, history): # Generate a response using the most relevant travel info chunks
     top_chunks = get_top_chunks(message, chunk_embeddings, cleaned_chunks)
     str_top_chunks = "\n".join(top_chunks)
     
@@ -97,4 +98,4 @@ def respond(message, history):
     return response["choices"][0]["message"]["content"].strip()
 
 chatbot = gr.ChatInterface(respond, type="messages")
-chatbot.launch()
+chatbot.launch() # Launch gradio interface