assignments/assignment_yourname_t81_559_class4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CdL1ZvDepO-X"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/jeffheaton/app_generative_ai/blob/main/assignments/assignment_yourname_t81_559_class4.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "R_pemiL8pO-Y"
   },
   "source": [
    "# T81-559: Applications of Generative AI\n",
    "* Instructor: [Jeff Heaton](https://sites.wustl.edu/jeffheaton/), McKelvey School of Engineering, [Washington University in St. Louis](https://engineering.wustl.edu/index.html)\n",
    "* For more information visit the [class website](https://sites.wustl.edu/jeffheaton/t81-559/).\n",
    "\n",
    "**Module 4 Assignment: Chat Memory**\n",
    "\n",
    "**Student Name: Your Name**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lky4xopspO-Z"
   },
   "source": [
    "# Assignment Instructions\n",
    "\n",
    "A [file](https://data.heatonresearch.com/data/t81-559/assignments/transcript4.csv) is provided that contains a transcript with two chatbots. Responses should always be a single sentence. The file is shown here:\n",
    "\n",
    "|target|prompt|\n",
    "|--|--|\n",
    "|chat1|Hello my name is John.|\n",
    "|chat2|Hello my name is Jane|\n",
    "|chat1|My favorite color is blue.|\n",
    "|chat2|My favorite color is yellow.|\n",
    "|chat1|What is my name and favorite color.|\n",
    "|chat2|What is my name?|\n",
    "\n",
    "Write a program that creates two chatbots, each should have their own memory. Send these transcript items to the indicated chatbot and record their responses in your output file.\n",
    "\n",
    "Your output should look like something this:\n",
    "\n",
    "|target|response|\n",
    "|--|--|\n",
    "|chat1|Hi John.|\n",
    "|chat2|Hello Jane.|\n",
    "|chat1|Thank you for this information.|\n",
    "|chat2|Thank you for this information.|\n",
    "|chat1|Hi John, your name is John and your favorite color is blue.|\n",
    "|chat2|Hey Jane, your name is Jane.|\n",
    "\n",
    "Note that the LLM will not give this exact output, but it should be similar.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U4LQZW_SpO-Z"
   },
   "source": [
    "# Google CoLab Instructions\n",
    "\n",
    "If you are using Google CoLab, it will be necessary to mount your GDrive so that you can send your notebook during the submit process. Running the following code will map your GDrive to ```/content/drive```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1ZnCEIEopO-Z",
    "outputId": "cc046b19-285e-4d25-ac6f-01a8155323fc"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "try:\n",
    "  from google.colab import drive, userdata\n",
    "  drive.mount('/content/drive', force_remount=True)\n",
    "  COLAB = True\n",
    "  print(\"Note: using Google CoLab\")\n",
    "except:\n",
    "  print(\"Note: not using Google CoLab\")\n",
    "  COLAB = False\n",
    "\n",
    "# Assignment Submission Key - Was sent you first week of class.\n",
    "# If you are in both classes, this is the same key.\n",
    "if COLAB:\n",
    "  # For Colab, add to your \"Secrets\" (key icon at the left)\n",
    "  key = userdata.get('T81_559_KEY')\n",
    "else:\n",
    "  # If not colab, enter your key here, or use an environment variable.\n",
    "  # (this is only an example key, use yours)\n",
    "  key = \"Gx5en9cEVvaZnjhdaushddhuhhO4PsI32sgldAXj\"\n",
    "\n",
    "# OpenAI Secrets\n",
    "if COLAB:\n",
    "    os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY')\n",
    "\n",
    "# Install needed libraries in CoLab\n",
    "if COLAB:\n",
    "    !pip install langchain langchain_openai"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PMLHwV0hpO-a"
   },
   "source": [
    "# Assignment Submit Function\n",
    "\n",
    "You will submit the 10 programming assignments electronically.  The following submit function can be used to do this.  My server will perform a basic check of each assignment and let you know if it sees any basic problems.\n",
    "\n",
    "**It is unlikely that should need to modify this function.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ozSyLCNtpO-a"
   },
   "outputs": [],
   "source": [
    "import base64\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import requests\n",
    "import PIL\n",
    "import PIL.Image\n",
    "import io\n",
    "from typing import List, Union\n",
    "\n",
    "# This function submits an assignment.  You can submit an assignment as much as you like, only the final\n",
    "# submission counts.  The paramaters are as follows:\n",
    "# data - List of pandas dataframes or images.\n",
    "# key - Your student key that was emailed to you.\n",
    "# course - The course that you are in, currently t81-558 or t81-559.\n",
    "# no - The assignment class number, should be 1 through 10.\n",
    "# source_file - The full path to your Python or IPYNB file.  This must have \"_class1\" as part of its name.\n",
    "# .             The number must match your assignment number.  For example \"_class2\" for class assignment #2.\n",
    "\n",
    "def submit(\n",
    "    data: List[Union[pd.DataFrame, PIL.Image.Image]],\n",
    "    key: str,\n",
    "    course: str,\n",
    "    no: int,\n",
    "    source_file: str = None\n",
    ") -> None:\n",
    "    if source_file is None and '__file__' not in globals():\n",
    "        raise Exception(\"Must specify a filename when in a Jupyter notebook.\")\n",
    "    if source_file is None:\n",
    "        source_file = __file__\n",
    "\n",
    "    suffix = f'_class{no}'\n",
    "    if suffix not in source_file:\n",
    "        raise Exception(f\"{suffix} must be part of the filename.\")\n",
    "\n",
    "    ext = os.path.splitext(source_file)[-1].lower()\n",
    "    if ext not in ['.ipynb', '.py']:\n",
    "        raise Exception(f\"Source file is {ext}; must be .py or .ipynb\")\n",
    "\n",
    "    with open(source_file, \"rb\") as file:\n",
    "        encoded_python = base64.b64encode(file.read()).decode('ascii')\n",
    "\n",
    "    payload = []\n",
    "    for item in data:\n",
    "        if isinstance(item, PIL.Image.Image):\n",
    "            buffered = io.BytesIO()\n",
    "            item.save(buffered, format=\"PNG\")\n",
    "            payload.append({'PNG': base64.b64encode(buffered.getvalue()).decode('ascii')})\n",
    "        elif isinstance(item, pd.DataFrame):\n",
    "            payload.append({'CSV': base64.b64encode(item.to_csv(index=False).encode('ascii')).decode(\"ascii\")})\n",
    "        else:\n",
    "            raise ValueError(f\"Unsupported data type: {type(item)}\")\n",
    "\n",
    "    response = requests.post(\n",
    "        \"https://api.heatonresearch.com/wu/submit\",\n",
    "        headers={'x-api-key': key},\n",
    "        json={\n",
    "            'payload': payload,\n",
    "            'assignment': no,\n",
    "            'course': course,\n",
    "            'ext': ext,\n",
    "            'py': encoded_python\n",
    "        }\n",
    "    )\n",
    "\n",
    "    if response.status_code == 200:\n",
    "        print(f\"Success: {response.text}\")\n",
    "    else:\n",
    "        print(f\"Failure: {response.text}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "id": "H7kgvLHspO-a",
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "source": [
    "# Assignment #4 Sample Code\n",
    "\n",
    "The following code provides a starting point for this assignment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 238
    },
    "id": "8ZPLGWgkpO-a",
    "outputId": "6bcfef96-7143-4d72-f463-ced2f7ffe437"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "from scipy.stats import zscore\n",
    "import string\n",
    "from langchain.prompts import ChatPromptTemplate\n",
    "\n",
    "# You must identify your source file.  (modify for your local setup)\n",
    "file=\"/content/drive/My Drive/Colab Notebooks/assignment_yourname_t81_559_class4.ipynb\"  # Google CoLab\n",
    "# file='C:\\\\Users\\\\jeffh\\\\projects\\\\t81_559_deep_learning\\\\assignments\\\\assignment_yourname_t81_559_class4.ipynb'  # Windows\n",
    "# file='/Users/jheaton/projects/t81_559_deep_learning/assignments/assignment_yourname_t81_559_class4.ipynb'  # Mac/Linux\n",
    "\n",
    "# Begin assignment\n",
    "\n",
    "df = pd.read_csv(\"https://data.heatonresearch.com/data/t81-559/assignments/transcript4.csv\")\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "eJpZKegdgq8Z"
   },
   "outputs": [],
   "source": [
    "from langchain.chains import ConversationChain\n",
    "from langchain.memory import ConversationSummaryMemory\n",
    "from langchain_openai import ChatOpenAI\n",
    "from langchain_core.prompts.chat import PromptTemplate\n",
    "from IPython.display import display_markdown\n",
    "import pickle\n",
    "\n",
    "DEFAULT_TEMPLATE = \"\"\"You are a helpful assistant. Format answers with text only.\n",
    "Answer in a single sentence.\n",
    "\n",
    "Current conversation:\n",
    "{history}\n",
    "Human: {input}\n",
    "AI:\"\"\"\n",
    "\n",
    "MODEL = 'gpt-4o-mini'\n",
    "\n",
    "class ChatBot:\n",
    "    def __init__(self, llm_chat, llm_summary, template):\n",
    "        \"\"\"\n",
    "        Initializes the ChatBot with language models and a template for conversation.\n",
    "\n",
    "        :param llm_chat: A large language model for handling chat responses.\n",
    "        :param llm_summary: A large language model for summarizing conversations.\n",
    "        :param template: A string template defining the conversation structure.\n",
    "        \"\"\"\n",
    "        self.llm_chat = llm_chat\n",
    "        self.llm_summary = llm_summary\n",
    "        self.template = template\n",
    "        self.prompt_template = PromptTemplate(input_variables=[\"history\", \"input\"], template=self.template)\n",
    "\n",
    "        # Initialize memory and conversation chain\n",
    "        self.memory = ConversationSummaryMemory(llm=self.llm_summary)\n",
    "        self.conversation = ConversationChain(\n",
    "            prompt=self.prompt_template,\n",
    "            llm=self.llm_chat,\n",
    "            memory=self.memory,\n",
    "            verbose=False\n",
    "        )\n",
    "\n",
    "        self.history = []\n",
    "\n",
    "    def converse(self, prompt):\n",
    "        \"\"\"\n",
    "        Processes a conversation prompt and updates the internal history and memory.\n",
    "\n",
    "        :param prompt: The input prompt from the user.\n",
    "        :return: The generated response from the language model.\n",
    "        \"\"\"\n",
    "        self.history.append([self.memory.buffer, prompt])\n",
    "        output = self.conversation.invoke(prompt)\n",
    "        return output['response']\n",
    "\n",
    "    def chat(self, prompt):\n",
    "        \"\"\"\n",
    "        Handles the full cycle of receiving a prompt, processing it, and displaying the result.\n",
    "\n",
    "        :param prompt: The input prompt from the user.\n",
    "        \"\"\"\n",
    "        print(f\"Human: {prompt}\")\n",
    "        output = self.converse(prompt)\n",
    "        display_markdown(output, raw=True)\n",
    "\n",
    "    def print_memory(self):\n",
    "        \"\"\"\n",
    "        Displays the current state of the conversation memory.\n",
    "        \"\"\"\n",
    "        print(\"**Memory:\")\n",
    "        print(self.memory.buffer)\n",
    "\n",
    "    def clear_memory(self):\n",
    "        \"\"\"\n",
    "        Clears the conversation memory.\n",
    "        \"\"\"\n",
    "        self.memory.clear()\n",
    "\n",
    "    def undo(self):\n",
    "        \"\"\"\n",
    "        Reverts the conversation memory to the state before the last interaction.\n",
    "        \"\"\"\n",
    "        if len(self.history) > 0:\n",
    "            self.memory.buffer = self.history.pop()[0]\n",
    "        else:\n",
    "            print(\"Nothing to undo.\")\n",
    "\n",
    "    def regenerate(self):\n",
    "        \"\"\"\n",
    "        Re-executes the last undone interaction, effectively redoing an undo operation.\n",
    "        \"\"\"\n",
    "        if len(self.history) > 0:\n",
    "            self.memory.buffer, prompt = self.history.pop()\n",
    "            self.chat(prompt)\n",
    "        else:\n",
    "            print(\"Nothing to regenerate.\")\n",
    "\n",
    "    def save_history(self, file_path):\n",
    "        \"\"\"\n",
    "        Saves the conversation history to a file using pickle.\n",
    "\n",
    "        :param file_path: The file path where the history should be saved.\n",
    "        \"\"\"\n",
    "        with open(file_path, 'wb') as f:\n",
    "            pickle.dump(self.history, f)\n",
    "\n",
    "    def load_history(self, file_path):\n",
    "        \"\"\"\n",
    "        Loads the conversation history from a file using pickle.\n",
    "\n",
    "        :param file_path: The file path from which to load the history.\n",
    "        \"\"\"\n",
    "        with open(file_path, 'rb') as f:\n",
    "            self.history = pickle.load(f)\n",
    "            # Optionally reset the memory based on the last saved state\n",
    "            if self.history:\n",
    "                self.memory.buffer = self.history[-1][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 329
    },
    "id": "_FiIkVPcpN25",
    "outputId": "af8043fd-9b12-4707-f0a0-d7708998cde1"
   },
   "outputs": [],
   "source": [
    "## ... continue your code...\n",
    "\n",
    "## Submit assignment\n",
    "\n",
    "# Submit\n",
    "submit(source_file=file,data=[df_submit],course='t81-559',key=key,no=4)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3.11 (genai)",
   "language": "python",
   "name": "genai"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}