import gradio as gr import random from huggingface_hub import InferenceClient #STEP 1 FROM SEMANTIC SEARCH from sentence_transformers import SentenceTransformer import torch #STEP 2 FROM SEMANTIC SEARCH # Open the water_cycle.txt file in read mode with UTF-8 encoding with open("quentins_knowledge.txt", "r", encoding="utf-8") as file: # Read the entire contents of the file and store it in a variable quentins_knowledge = file.read() #SECOND FEATURE with open("quentins_alt_knowledge.txt", "r", encoding="utf-8") as file: # Read the entire contents of the file and store it in a variable quentins_alt_knowledge = file.read() # Print the text below print(quentins_knowledge) print(quentins_alt_knowledge) #STEP 3 FROM SEMANTIC SEARCH def preprocess_text(text): # Strip extra whitespace from the beginning and the end of the text cleaned_text = text.strip() # Split the cleaned_text by every newline character (\n) chunks = cleaned_text.split("\n") # Create an empty list to store cleaned chunks cleaned_chunks = [] # Write your for-in loop below to clean each chunk and add it to the cleaned_chunks list for chunk in chunks: stripped_chunk = chunk.strip() if len(stripped_chunk) >= 0: cleaned_chunks.append(stripped_chunk) # Print cleaned_chunks print(cleaned_chunks) # Print the length of cleaned_chunks print(len(cleaned_chunks)) # Return the cleaned_chunks return cleaned_chunks # Call the preprocess_text function and store the result in a cleaned_chunks variable cleaned_chunks = preprocess_text(quentins_knowledge) #SECOND FEATURE cleaned_alt_chunks = preprocess_text(quentins_alt_knowledge) #STEP 4 FROM SEMANTIC SEARCH # Load the pre-trained embedding model that converts text to vectors model = SentenceTransformer('all-MiniLM-L6-v2') def create_embeddings(text_chunks): # Convert each text chunk into a vector embedding and store as a tensor chunk_embeddings = model.encode(text_chunks, convert_to_tensor=True) # Replace ... with the text_chunks list # Print the chunk embeddings print(chunk_embeddings) # Print the shape of chunk_embeddings print(chunk_embeddings.shape) # no parentheses on .shape because it's a property, not a method! Look up the difference between class methods and classes properties. # Return the chunk_embeddings return chunk_embeddings # Call the create_embeddings function and store the result in a new chunk_embeddings variable chunk_embeddings = create_embeddings(cleaned_chunks) #SECOND FEATURE alt_chunk_embeddings = create_embeddings(cleaned_alt_chunks) #STEP 5 FROM SEMANTIC SEARCH # Define a function to find the most relevant text chunks for a given query, chunk_embeddings, and text_chunks def get_top_chunks(query, chunk_embeddings, text_chunks): # Convert the query text into a vector embedding query_embedding = model.encode(query, convert_to_tensor=True) # Normalize the query embedding to unit length for accurate similarity comparison query_embedding_normalized = query_embedding / query_embedding.norm() # Normalize all chunk embeddings to unit length for consistent comparison chunk_embeddings_normalized = chunk_embeddings / chunk_embeddings.norm(dim=1, keepdim=True) # Calculate cosine similarity between query and all chunks using matrix multiplication similarities = torch.matmul(chunk_embeddings_normalized, query_embedding_normalized) # Print the similarities print(similarities) # Find the indices of the 3 chunks with highest similarity scores top_indices = torch.topk(similarities, k=3).indices # Print the top indices print(top_indices) # Create an empty list to store the most relevant chunks top_chunks = [] # Loop through the top indices and retrieve the corresponding text chunks for index in top_indices: chunk = text_chunks[index] top_chunks.append(chunk) # Return the list of most relevant chunks return top_chunks client = InferenceClient("google/gemma-3-27b-it") def respond(message, history, name, mood, topic): duck_chunks = [] if quentin_topic == "Self Help": duck_chunks = get_top_chunks(message, chunk_embeddings, cleaned_chunks) print(duck_chunks) elif quentin_topic == "Duck Facts": duck_chunks = get_top_chunks(message, chunk_embeddings, cleaned_alt_chunks) print(duck_chunks) duck_info = "\n".join(duck_chunks) messages = [{"role": "system", "content": f"You are an extremely {mood} chatbot named Quentin. You are a rubber duck, with strong human emotions who helps the user with their problem related to {topic}. You talk to the user, whose name is {name}, in a way that reflects your {mood} mood. Make sure to use duck-themed references in your responses. Refer to the user by name as much as possible. Base your response on the provided context: {duck_info}. Always end your response with a brief, punchy tagline."}] if history: messages.extend(history) messages.append({"role": "user", "content": message}) response = client.chat_completion( messages, max_tokens=200, temperature=0.35 ) print(message) print(history) return response['choices'][0]['message']['content'].strip() # def echo(message, history): # return message # def yes_no(message, history): # responses = ["Yes", "No"] # return random.choice(responses) # def magic_eight(message, history): # responses = ["That's a terrible question. Try again", "I don't think I should answer that...", "What do you think, genius?", "You are a bad person for asking that.", "Absolutely not", "Uuuuh, obviously.", "Of all the things you could ask, you went with that?", "I don't know, look it up", "I mean, yeah, I guess...", "That's gonna be a big nope", ""] # return random.choice(responses) title = "Ask Quentin" about_text = "Quentin says: 'I'm an expert, not a quack'" with gr.Blocks(theme=gr.themes.Citrus( secondary_hue="red", neutral_hue="gray", text_size="lg", ).set( background_fill_primary='*neutral_200', background_fill_secondary='*neutral_400', background_fill_secondary_dark='*secondary_500', border_color_accent='*secondary_400', border_color_accent_dark='*secondary_800', color_accent='*secondary_300', color_accent_soft='*secondary_500', color_accent_soft_dark='*secondary_400', button_primary_background_fill='*secondary_500', button_primary_background_fill_dark='*secondary_600' )) as chatbot: with gr.Row(scale=1): gr.Image("ask_quentin_banner.jpg", show_label = False, show_share_button = False, show_download_button = False) with gr.Row(scale=1): quentin_topic = gr.CheckboxGroup(["Self Help", "Duck Facts"], label="What do you want help with?") with gr.Row(scale=4): with gr.Column(scale=1): gr.Image("Quentin.png", show_label = False, show_share_button = False, show_download_button = False) username = gr.Textbox(placeholder="Type your name here", label="Name") quentin_attitude = gr.CheckboxGroup(["Kind", "Angry", "childish", "Tough Guy"], label="What is Quentin's Mood?") with gr.Column(scale=3): gr.ChatInterface(fn=respond, type="messages", additional_inputs=[username, quentin_attitude, quentin_topic], title="Quentin, the Helpful Quackbot") chatbot.launch()