experiments.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import faiss, torch\n",
        "import numpy as np\n",
        "from transformers import AutoTokenizer, AutoModel\n",
        "\n",
        "embed_model = AutoModel.from_pretrained(\"sentence-transformers/all-MiniLM-L6-v2\")\n",
        "embed_tokenizer = AutoTokenizer.from_pretrained(\"sentence-transformers/all-MiniLM-L6-v2\")\n",
        "\n",
        "# Tokenize and create embeddings\n",
        "def embed_text(text):\n",
        "    tokens = embed_tokenizer(text, return_tensors=\"pt\", padding=True, truncation=True)\n",
        "    with torch.no_grad():\n",
        "        embeddings = embed_model(**tokens).last_hidden_state.mean(dim=1)\n",
        "    return embeddings\n",
        "\n",
        "# Embed documents\n",
        "embeddings = [embed_text(doc['text']).numpy() for doc in dataset]\n",
        "\n",
        "# Build FAISS index\n",
        "dim = embeddings[0].shape[1]  # Embedding dimension\n",
        "index = faiss.IndexFlatL2(dim)\n",
        "index.add(np.vstack(embeddings))\n"
      ],
      "metadata": {
        "id": "Ypv4LEbF3eDd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from transformers import pipeline\n",
        "\n",
        "# Load the zero-shot-classification pipeline\n",
        "classifier = pipeline(\"zero-shot-classification\", model=\"facebook/bart-large-mnli\")\n",
        "\n",
        "# Define relevant topics\n",
        "possible_labels = [\"golden retrievers\", \"dogs\", \"cars\", \"technology\", \"food\"]\n",
        "\n",
        "# Check the relevance of the query\n",
        "def check_relevance(query):\n",
        "    result = classifier(query, candidate_labels=possible_labels)\n",
        "\n",
        "    # If the score for \"golden retrievers\" or \"dogs\" is low, the question is irrelevant\n",
        "    if result['labels'][0] not in [\"golden retrievers\", \"dogs\"]:\n",
        "        return \"This query doesn't seem to be related to Golden Retrievers.\"\n",
        "\n",
        "    return None  # If relevant\n"
      ],
      "metadata": {
        "id": "lf51N5cW3aNu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sQVtyKv13Kux"
      },
      "outputs": [],
      "source": [
        "import random\n",
        "from transformers import pipeline\n",
        "\n",
        "# Load the Hugging Face model (You can replace GPT-2 with any other local or hosted model)\n",
        "# Use a conversational model like GPT-2 or GPT-4All\n",
        "generator = pipeline(\"text-generation\", model=\"gpt2\")\n",
        "\n",
        "# Predefined responses for conversation flow\n",
        "greetings = [\"Hello! How can I help you today?\", \"Hi! What would you like to know about Golden Retrievers?\", \"Hey! Ask me anything about Golden Retrievers!\"]\n",
        "farewells = [\"Goodbye! Have a great day!\", \"Bye! Hope I answered your questions!\", \"See you later!\"]\n",
        "thanks_responses = [\"You're welcome!\", \"Glad I could help!\", \"No problem!\", \"Happy to assist!\"]\n",
        "\n",
        "# FAQ about Golden Retrievers\n",
        "faq = {\n",
        "    \"what is the average lifespan of a golden retriever\": \"The average lifespan of a Golden Retriever is around 10 to 12 years.\",\n",
        "    \"how long do golden retrievers live\": \"Golden Retrievers typically live for 10 to 12 years, depending on their health and care.\",\n",
        "    \"when do golden retrievers stop growing\": \"Golden Retrievers usually stop growing around 18 to 24 months of age.\",\n",
        "    \"how big do golden retrievers get\": \"Male Golden Retrievers usually weigh between 65 to 75 pounds, while females weigh between 55 to 65 pounds.\",\n",
        "    \"how much exercise do golden retrievers need\": \"Golden Retrievers need at least one hour of exercise per day. This can include walking, running, or playing fetch.\",\n",
        "    \"what activities do golden retrievers enjoy\": \"Golden Retrievers enjoy swimming, fetching, hiking, running, and playing games like tug-of-war.\",\n",
        "    \"are golden retrievers good for hiking\": \"Yes, Golden Retrievers are excellent hiking companions due to their endurance and love for outdoor activities.\",\n",
        "    \"what should i feed my golden retriever\": \"Golden Retrievers should be fed a balanced diet with high-quality dry dog food. The amount depends on the dog's age, size, and activity level.\",\n",
        "    \"how much food does a golden retriever need\": \"An adult Golden Retriever typically needs between 2 to 3 cups of high-quality dog food daily, divided into two meals.\",\n",
        "    \"can golden retrievers eat human food\": \"Some human foods, like chicken, carrots, and apples, are safe for Golden Retrievers, but avoid toxic foods like chocolate, grapes, and onions.\",\n",
        "    \"how often should i groom my golden retriever\": \"Golden Retrievers should be brushed 3 to 5 times a week to prevent matting and reduce shedding.\",\n",
        "    \"do golden retrievers shed a lot\": \"Yes, Golden Retrievers shed heavily, especially during spring and fall. Regular brushing can help control the shedding.\",\n",
        "    \"how often should i bathe my golden retriever\": \"Golden Retrievers should be bathed every 6 to 8 weeks, or more often if they get dirty or start to smell.\",\n",
        "    \"are golden retrievers easy to train\": \"Yes, Golden Retrievers are intelligent and eager to please, making them relatively easy to train with positive reinforcement.\",\n",
        "    \"how can i train my golden retriever\": \"Use positive reinforcement, such as treats and praise, to train your Golden Retriever. They respond well to consistency and patience.\",\n",
        "    \"are golden retrievers good with kids\": \"Yes, Golden Retrievers are known for their friendly and gentle nature, making them great companions for children.\",\n",
        "    \"what are common health issues in golden retrievers\": \"Common health issues include hip dysplasia, elbow dysplasia, cataracts, and heart problems.\",\n",
        "    \"can golden retrievers be service dogs\": \"Yes, Golden Retrievers are commonly used as service dogs due to their intelligence, calm demeanor, and eagerness to help.\"\n",
        "}\n",
        "\n",
        "# Predefined responses for chit-chat and handling unrelated questions\n",
        "chit_chat_responses = {\n",
        "    \"how are you\": \"I'm just a chatbot, but I'm doing great! How about you?\",\n",
        "    \"what's your name\": \"I'm the Golden Retriever chatbot! Ask me anything about Golden Retrievers.\",\n",
        "    \"what is your favorite color\": \"I don't have a favorite color, but Golden Retrievers come in beautiful shades of gold!\"\n",
        "}\n",
        "\n",
        "# Function to retrieve an answer from the FAQ or chit-chat dictionary\n",
        "def get_response(user_input):\n",
        "    user_input = user_input.lower().strip()\n",
        "\n",
        "    # Check if the input is a greeting or farewell\n",
        "    if any(greet in user_input for greet in [\"hi\", \"hello\", \"hey\"]):\n",
        "        return random.choice(greetings)\n",
        "    if any(bye in user_input for bye in [\"bye\", \"goodbye\", \"see you\"]):\n",
        "        return random.choice(farewells)\n",
        "    if \"thank\" in user_input:\n",
        "        return random.choice(thanks_responses)\n",
        "\n",
        "    # Check for chit-chat responses\n",
        "    for phrase in chit_chat_responses:\n",
        "        if phrase in user_input:\n",
        "            return chit_chat_responses[phrase]\n",
        "\n",
        "    # Check if the input is a question related to Golden Retrievers\n",
        "    for question, answer in faq.items():\n",
        "        if question in user_input:\n",
        "            return answer\n",
        "\n",
        "    # If none of the above, forward to LLM\n",
        "    return None\n",
        "\n",
        "# Fallback to LLM for unrelated questions\n",
        "def llm_fallback(query):\n",
        "    response = generator(query, max_length=100, num_return_sequences=1)\n",
        "    return response[0]['generated_text']\n",
        "\n",
        "# Chatbot loop\n",
        "def chatbot():\n",
        "    print(\"Welcome to the Golden Retriever chatbot! Ask me anything about Golden Retrievers.\")\n",
        "    print(\"Type 'exit' to end the conversation.\")\n",
        "\n",
        "    while True:\n",
        "        user_input = input(\"\\nYou: \").strip().lower()\n",
        "\n",
        "        if user_input == \"exit\":\n",
        "            print(random.choice(farewells))\n",
        "            break\n",
        "\n",
        "        # Get chatbot response\n",
        "        response = get_response(user_input)\n",
        "\n",
        "        if response:\n",
        "            print(f\"\\nBot: {response}\")\n",
        "        else:\n",
        "            # Forward unrelated questions to the LLM\n",
        "            llm_response = llm_fallback(user_input)\n",
        "            print(f\"\\nBot (LLM): {llm_response}\")\n",
        "\n",
        "# Run the chatbot\n",
        "chatbot()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "from datasets import Dataset\n",
        "from transformers import AutoTokenizer, AutoModel\n",
        "import faiss\n",
        "import numpy as np\n",
        "\n",
        "# Golden Retriever facts\n",
        "data = {\n",
        "    \"text\": [\n",
        "        \"Golden Retrievers are friendly, intelligent, and devoted dogs. They are one of the most popular dog breeds in the United States.\",\n",
        "        \"Golden Retrievers are great family dogs and are very tolerant with children. They are known for their friendly and tolerant attitudes.\",\n",
        "        \"The breed was originally developed in Scotland in the mid-19th century to retrieve game during hunting sessions.\",\n",
        "        \"Golden Retrievers require regular exercise and enjoy activities like fetching and swimming.\",\n",
        "        \"Golden Retrievers have a dense, water-repellant coat that sheds throughout the year, especially in the spring and fall.\",\n",
        "        \"They are often used as guide dogs and in search-and-rescue operations due to their intelligence and trainability.\",\n",
        "        \"Golden Retrievers are generally healthy, but they can be prone to certain health issues like hip dysplasia and heart problems.\"\n",
        "    ]\n",
        "}\n",
        "\n",
        "# Create a dataset\n",
        "dataset = Dataset.from_dict(data)\n",
        "\n",
        "# Load a pretrained model for sentence embeddings\n",
        "embed_model = AutoModel.from_pretrained(\"sentence-transformers/all-MiniLM-L6-v2\")\n",
        "embed_tokenizer = AutoTokenizer.from_pretrained(\"sentence-transformers/all-MiniLM-L6-v2\")\n",
        "\n",
        "# Function to embed text using the model\n",
        "def embed_text(text):\n",
        "    tokens = embed_tokenizer(text, return_tensors=\"pt\", padding=True, truncation=True)\n",
        "    with torch.no_grad():\n",
        "        embeddings = embed_model(**tokens).last_hidden_state.mean(dim=1)\n",
        "    return embeddings\n",
        "\n",
        "# Embed the dataset texts\n",
        "embeddings = [embed_text(doc['text']).numpy() for doc in dataset]\n",
        "\n",
        "# Build FAISS index\n",
        "dim = embeddings[0].shape[1]  # Embedding dimension\n",
        "index = faiss.IndexFlatL2(dim)\n",
        "index.add(np.vstack(embeddings))\n",
        "\n",
        "# Function to retrieve similar documents based on a query\n",
        "def retrieve(query, k=3, threshold=35):\n",
        "    query_embedding = embed_text(query).numpy()\n",
        "    distances, indices = index.search(query_embedding, k)\n",
        "\n",
        "    # Check if the minimum distance is below the threshold (indicating relevance)\n",
        "    if distances[0][0] > threshold:\n",
        "        print(distances)\n",
        "        return \"The query doesn't seem related to Golden Retrievers.\"\n",
        "\n",
        "    return [dataset[int(i)]['text'] for i in indices[0]]\n",
        "\n",
        "\n",
        "# Example query\n",
        "query = \"I want a golder retreiver\"\n",
        "retrieved_docs = retrieve(query)\n",
        "print(retrieved_docs)\n"
      ],
      "metadata": {
        "id": "jFhY7_pM3X4Z"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}