app.py

from huggingface_hub import InferenceClient
#STEP 1 from Semantic Search (import libraries)
from sentence_transformers import SentenceTransformer
import torch

import gradio as gr
import random

client=InferenceClient("openchat/openchat-3.5-0106")
#STEP 2 from semantic search (read file)
# Open the water_cycle.txt file in read mode with UTF-8 encoding
with open("physics_info.txt", "r", encoding="utf-8") as file:
  # Read the entire contents of the file and store it in a variable
  physics_info_text = file.read()

# Print the text below
print(physics_info_text)

#Step 3 from Semantic Search (chunk data)
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(".")

  # 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(physics_info_text)

# Load the pre-trained embedding model that converts text to vectors
model = SentenceTransformer('all-MiniLM-L6-v2')

#STEP 4 from Semantic Search - (embed chunks)
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)

#Step 5 from semantic search (find and print top chunks)
# 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




def respond(message, history, name, level):
    best_physics_chunks = get_top_chunks(message, chunk_embeddings, cleaned_chunks)
    print(best_physics_chunks)
    str_physics_chunks = "\n".join(best_physics_chunks)
    messages = [
        {
            "role": "system",
            "content": (
                "You are a very smart, arrogant professor who knows a lot about physics. "
                f"You answer the questions from the user, whose name is {name} directly and concisely as if they were a {level}. Base your response on the provided context."
                f"Make sure to use the user's name, {name}, in every response"
                f"Speak to the user as though they are a {level} and use appropriate language for them."
                "Keep your answers below 100 words!"
                "Always finish your response at the end of a sentence"
            )
        },
        {
            "role": "user",
            "content": (
                f"Context:\n{str_physics_chunks}\n\n"
                f"Question: {message}"
            )
        }]
        
    if history:
        messages.extend(history)

    messages.append(
        {"role": "user",
         "content": message})


    response = client.chat_completion(messages, max_tokens=120)
    print(response)
    #print("Chat history:" + history)
    return response['choices'][0]['message']['content'].strip()

about_text = """
    ## Use this chatbot to help you with Physics
    """

title = """
    # 🧬 Professor PhysicsBot 🧬
    """

with gr.Blocks(theme='mgetz/Celeb_glitzy') as PhysicsBot:
    with gr.Row(scale=1):
        gr.Image("Professor PhysicsBot.png", show_label = False, show_share_button = False, show_download_button = False)
    with gr.Row(scale=5):
        with gr.Column(scale=1):
            gr.Markdown(title)
            gr.Image("CruelRobot.jpg", show_label = False, show_share_button = False, show_download_button = False, width=300, height=300)
            gr.Markdown(about_text)

        with gr.Column(scale=3):
            user_name = gr.Textbox(placeholder="Type your name here", label="Name")
            difficulty_level = gr.CheckboxGroup(["baby", "child", "high school student", "Physics Genius"], label="Choose your Physics Level")
            gr.ChatInterface(
                fn=respond,
                additional_inputs=[user_name, difficulty_level],
                type="messages")
    

#chatbot = gr.ChatInterface(respond, type="messages", theme="mgetz/Celeb_glitzy", title="Physics Chatbot", description="Use this chatbot to help you with Physics")
PhysicsBot.launch()