prompt_with_vector_store_w_grading_intr.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/vanderbilt-data-science/lo-achievement/blob/main/prompt_with_vector_store_w_grading_intr.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S4MkldrwPA_S"
      },
      "source": [
        "# LLMs for Self-Study\n",
        "> A prompt and code template for better understanding texts\n",
        "\n",
        "This notebook provides a guide for using LLMs for self-study programmatically. A number of prompt templates are provided to assist with generating great assessments for self-study, and code is additionally provided for fast usage. This notebook is best leveraged for a set of documents (text or PDF preferred) **to be uploaded** for interaction with the model.\n",
        "\n",
        "This version of the notebook is best suited for those who prefer to use files from their local drive as context rather than copy and pasting directly into the notebook to be used as context for the model. If you prefer to copy and paste text, you should direct yourself to the [prompt_with_context](https://colab.research.google.com/github/vanderbilt-data-science/lo-achievement/blob/main/prompt_with_context.ipynb) notebook."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "IYx3Elo9HJSL"
      },
      "outputs": [],
      "source": [
        "#libraries for user setup code\n",
        "from getpass import getpass\n",
        "from logging import raiseExceptions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m34rxkb-HJSM"
      },
      "source": [
        "## Helper functions\n",
        "The following functions help to encapsulate the functionality executed below. The `setup_drives` function below assists with setting up the drives for users to upload files."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "4Ma5b-UOHJSM"
      },
      "outputs": [],
      "source": [
        "def setup_drives(upload_set):\n",
        "\n",
        "    upload_set = upload_set.lower()\n",
        "\n",
        "    # Colab file upload module\n",
        "    if upload_set == \"local drive\":\n",
        "        from google.colab import files\n",
        "        uploaded = files.upload()\n",
        "    elif upload_set == \"google drive\":\n",
        "        # Mount a Google Drive\n",
        "        from google.colab import drive\n",
        "        drive.mount('/content/drive')\n",
        "    # Raise errors\n",
        "    elif upload_set == '':\n",
        "        raise ValueError(\"You haven't yet defined the upload_settings variable. Go back and read the instructions to make this setting.\")\n",
        "    else:\n",
        "        raise SyntaxError(\"Please check your setting for typos and/or capitalization\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_CY5vBN7HJSN"
      },
      "source": [
        "# User Settings\n",
        "In this section, you'll set your OpenAI API Key (for use with the OpenAI model), configure your environment/files for upload, and upload those files."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "b8l02DqDHJSN",
        "outputId": "b8202800-6dcf-4119-e668-386e575228c5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "··········\n"
          ]
        }
      ],
      "source": [
        "# Run this cell and enter your OpenAI API key when prompted\n",
        "openai_api_key = getpass()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "KLNm2ULSHJSN"
      },
      "outputs": [],
      "source": [
        "# Model name\n",
        "mdl_name = 'gpt-3.5-turbo-0301'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yK36707DS1NW"
      },
      "source": [
        "## Define Your Document Source\n",
        "You may upload your files directly from your computer, or you may choose to do so via your Google Drive. Below, you will find instructions for both methods.\n",
        "\n",
        "For either model, begin by setting the `upload_setting` variable to:\n",
        "* `'Local Drive'` - if you have files that are on your own computer (locally), or\n",
        "* `'Google Drive'` - if you have files that are stored on Google Drive\n",
        "\n",
        "e.g.,\n",
        "`upload_setting='Google Drive'`.\n",
        "Don't forget the quotes around your selection!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "ybwrtS9jHJSN"
      },
      "outputs": [],
      "source": [
        "## Settings for upload: via local drive or Google Drive\n",
        "### Please input either \"Google Drive\" or \"Local Drive\" into the empty string\n",
        "\n",
        "upload_setting = 'Local Drive'\n",
        "#upload_setting = 'Google Drive'\n",
        "#upload_setting = 'Local Drive'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kth2I2OSVpla"
      },
      "source": [
        "<p style='color:green'><strong>Before Continuing</strong> - Make sure you have input your choice of upload into the `upload_setting`` variable above (Options: \"Local Drive\" or \"Google Drive\") as described in the above instructions.</p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ScAQ1aQkHJSO"
      },
      "source": [
        "## Upload your Files\n",
        "Now, you'll upload your files. When you run the below code cell, you'll be able to follow the instructions for local or Google Drive upload described here. If you would like to use our example document (Robert Frost's \"The Road Not Taken\", you can download the file from [this link](https://drive.google.com/drive/folders/1wpEoGACUqyNRYa4zBZeNkqcLJrGQbA53?usp=sharing) and upload via the instructions above.\n",
        "\n",
        "**If you selected \"Local Drive\" :**\n",
        "> If you selected Local Drive, you'll need to start by selecting your local files. Run the code cell below. Once the icon appears, click the \"Choose File\". This will direct you to your computer's local drive. Select the file you would like to upload as context. The files will appear in the right sidebar. Then follow the rest of the steps in the \"Uploading Your files (Local Drive and Google Drive)\" below.\n",
        "\n",
        "**If you selected \"Google Drive\" :**\n",
        "> If you selected Google Drive, you'll need to start by allowing access to your Google Drive. Run the code cell below. You will be redirected to a window where you will allow access to your Google Drive by logging into your Google Account. Your Drive will appear as a folder in the left side panel. Navigate through your Google Drive until you've found the file that you'd like to upload.\n",
        "\n",
        "Your files are now accessible to the code."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "lHNodJ6pHJSO",
        "outputId": "e8033473-357d-42f6-ca6a-0b1555f7880a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 74
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-97312b0b-ff5c-4c97-bacf-ff281aa6d5fa\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-97312b0b-ff5c-4c97-bacf-ff281aa6d5fa\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving roadnottaken.txt to roadnottaken.txt\n"
          ]
        }
      ],
      "source": [
        "# Run this cell then following the instructions to upload your file\n",
        "setup_drives(upload_setting)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2H-lunouHJSO"
      },
      "source": [
        "## Setup file path\n",
        "Now that you've make your files accessible, we need to select the files of interest. To do this, you'll use the Files pane on the left, following the instructions below to get the filepath. Then, you'll paste the filepath between the quotes below to define the `file_path` variable."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SEr4An0hHJSO"
      },
      "source": [
        "<center>\n",
        "<table width=\"100%\">\n",
        "    <tr>\n",
        "        <th width=\"35%\"> Step 1. Navigate to the three dots to the right <br> of your file name and click them. </th>\n",
        "        <th width=\"35%\"> Step 2. Once the dropdown appears,<br>select \"Copy Path.\" </th>\n",
        "        <th width=\"30%\"> Step 3. Paste the filepath between the single quotes<br> in the cell below to <br>define the file path. </th>\n",
        "    </tr>\n",
        "    <tr width=\"100%\">\n",
        "        <th width=\"35%\"> <img style=\"vertical-align: bottom;\" src=\"data:image/png;base64,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\"/> </th>\n",
        "        <th> <img style=\"vertical-align: bottom;\"  src=\"data:image/png;base64,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\" width=\"90%\"/> </th>\n",
        "        <th width=\"23%\"> Add your filepath to the cell which follows. <br>Example: <br><code>file_path = 'content/roadnottaken.txt'</code> </th>\n",
        "    </tr>\n",
        "</table>\n",
        "</center>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "k9CDcM3pXsJv"
      },
      "outputs": [],
      "source": [
        "## Paste your file path into the empty string('') below\n",
        "#file_path = '/content/roadnottaken.txt' (example)\n",
        "\n",
        "file_path = '/content/roadnottaken.txt'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lcvGcZBlPA_W"
      },
      "source": [
        "Congratulations! You've finished with the setup! From here, you can now run the rest of the cells to set up your vector store and begin prompting!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6Gf-_aZVPA_S"
      },
      "source": [
        "# Code Setup\n",
        "Run the following cells to setup the rest of the environment for prompting. In the following section, we set up the computational environment with imported code, setup your API key access to OpenAI, and loading access to your language model. Note that the following cells may take a long time to run."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6040J5eXPA_T"
      },
      "source": [
        "## Library installation and loading\n",
        "The following `pip install` code should be run if you're using Google Colab, or otherwise do not have a computational environment (e.g., _venv_, _conda virtual environment_, _Docker, Singularity, or other container_) with these packages installed."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "7_XCtEMbPA_T",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a4824f87-8686-429d-fade-84b4be1e0466"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
            "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m966.7/966.7 kB\u001b[0m \u001b[31m14.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m5.3/5.3 MB\u001b[0m \u001b[31m68.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m5.9/5.9 MB\u001b[0m \u001b[31m95.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.8/7.8 MB\u001b[0m \u001b[31m49.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m101.8/101.8 kB\u001b[0m \u001b[31m7.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m5.6/5.6 MB\u001b[0m \u001b[31m64.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m5.6/5.6 MB\u001b[0m \u001b[31m62.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.1/10.1 MB\u001b[0m \u001b[31m66.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.7/2.7 MB\u001b[0m \u001b[31m13.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.3/1.3 MB\u001b[0m \u001b[31m62.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.1/49.1 kB\u001b[0m \u001b[31m3.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m67.0/67.0 kB\u001b[0m \u001b[31m6.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m50.4/50.4 kB\u001b[0m \u001b[31m4.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.5/46.5 kB\u001b[0m \u001b[31m3.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m43.7/43.7 kB\u001b[0m \u001b[31m3.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m41.0/41.0 kB\u001b[0m \u001b[31m3.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m41.0/41.0 kB\u001b[0m \u001b[31m3.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m87.5/87.5 kB\u001b[0m \u001b[31m6.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m84.5/84.5 kB\u001b[0m \u001b[31m7.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.0/46.0 kB\u001b[0m \u001b[31m3.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m3.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m428.8/428.8 kB\u001b[0m \u001b[31m26.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.1/4.1 MB\u001b[0m \u001b[31m79.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.3/1.3 MB\u001b[0m \u001b[31m60.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m74.5/74.5 kB\u001b[0m \u001b[31m7.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m112.2/112.2 kB\u001b[0m \u001b[31m10.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.3/4.3 MB\u001b[0m \u001b[31m80.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m153.0/153.0 kB\u001b[0m \u001b[31m12.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m86.8/86.8 kB\u001b[0m \u001b[31m7.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Building wheel for hnswlib (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
            "  Building wheel for ffmpy (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Building wheel for python-docx (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Building wheel for python-pptx (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Building wheel for olefile (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
            "google-colab 1.0.0 requires requests==2.27.1, but you have requests 2.31.0 which is incompatible.\u001b[0m\u001b[31m\n",
            "\u001b[0m"
          ]
        }
      ],
      "source": [
        "# run this code if you're using Google Colab or don't have these packages installed in your computing environment\n",
        "! pip install -q langchain=='0.0.229' openai gradio numpy chromadb tiktoken unstructured pdf2image pydantic==\"1.10.8\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "6fdfMar8PA_U"
      },
      "outputs": [],
      "source": [
        "# import required libraries\n",
        "# import required libraries\n",
        "import numpy as np\n",
        "from langchain.text_splitter import CharacterTextSplitter\n",
        "from langchain.embeddings import OpenAIEmbeddings\n",
        "import os\n",
        "from langchain.vectorstores import Chroma\n",
        "from langchain.document_loaders.unstructured import UnstructuredFileLoader\n",
        "from langchain.document_loaders import UnstructuredFileLoader\n",
        "from langchain.chains import VectorDBQA\n",
        "from langchain.chat_models import ChatOpenAI\n",
        "# from langchain.chains import RetrievalQA"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5iI75yjaPA_V"
      },
      "source": [
        "## API and model setup\n",
        "\n",
        "Use these cells to load the API keys required for this notebook and create a basic OpenAI LLM model. The code below uses the variable you created above when you input your API Key."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "8IgmjGEFPA_V"
      },
      "outputs": [],
      "source": [
        "# Set up OpenAI API Key\n",
        "os.environ[\"OPENAI_API_KEY\"] = openai_api_key\n",
        "llm = ChatOpenAI()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zlx1_Y8rYGn3"
      },
      "source": [
        "# Create a vector store with your document\n",
        "\n",
        "With the file path, you can now create a vector store using the document that you uploaded. We expose this creation in case you want to modify the kind of vector store that you're creating. Run the cell below to create the default provided vector store."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "mP2FvzurYGHH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f80a7ddb-2870-4b42-ca73-24acd9baa2fb"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[nltk_data] Downloading package punkt to /root/nltk_data...\n",
            "[nltk_data]   Unzipping tokenizers/punkt.zip.\n",
            "[nltk_data] Downloading package averaged_perceptron_tagger to\n",
            "[nltk_data]     /root/nltk_data...\n",
            "[nltk_data]   Unzipping taggers/averaged_perceptron_tagger.zip.\n",
            "/usr/local/lib/python3.10/dist-packages/langchain/chains/retrieval_qa/base.py:243: UserWarning: `VectorDBQA` is deprecated - please use `from langchain.chains import RetrievalQA`\n",
            "  warnings.warn(\n"
          ]
        }
      ],
      "source": [
        "# Create vector store\n",
        "\n",
        "loader = UnstructuredFileLoader(file_path)\n",
        "documents = loader.load()\n",
        "\n",
        "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
        "texts = text_splitter.split_documents(documents)\n",
        "\n",
        "embeddings = OpenAIEmbeddings()\n",
        "\n",
        "db = Chroma.from_documents(texts, embeddings)\n",
        "\n",
        "qa = VectorDBQA.from_chain_type(llm=ChatOpenAI(model_name = mdl_name), chain_type=\"stuff\", vectorstore=db, k=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hLMJRXc8PA_W"
      },
      "source": [
        "# A guide to prompting for self-study\n",
        "In this section, we provide a number of different approaches for using AI to help you assess and explain the knowledge of your document. Start by interacting with the model and then try out the rest of the prompts!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jNBwByBFaJVP"
      },
      "source": [
        "## Interact with the model\n",
        "\n",
        "Now that your vector store is created, you can begin interacting with the model! Below, we have a comprehensive list of examples using different question types, but feel free to use this code block to experiment with the model and the grading capabilities and interactivity component of the model.\n",
        "\n",
        "First, input the number of desired questions as an integer (i.e., do not put parentheses around the number). See example below:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "num_questions = 3\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "Then , input your desired question type into the empty string in the code cell. See example below:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "question_type = 'Multiple Choice'\n",
        "```\n",
        "\n",
        "Finally, simply run the code block!\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "outputs = []"
      ],
      "metadata": {
        "id": "zP3sEa121iwd"
      },
      "execution_count": 120,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 121,
      "metadata": {
        "id": "4QBBlJI-adPf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e8f68868-2e2a-42f1-f96b-cb949db0f08a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "How many questions would you like?\n",
            "3\n",
            "What type of question would you like?\n",
            "multiple choice\n"
          ]
        }
      ],
      "source": [
        "# Experiment with interacting with the model by inputting your own prompts into the empty string below.\n",
        "input_message = 'How many questions would you like?' + '\\n'\n",
        "num_questions = int(input(input_message))\n",
        "# Example: 3\n",
        "\n",
        "input_message1 = 'What type of question would you like?' + '\\n'\n",
        "question_type = input(input_message1)\n",
        "# Example: 'Multiple Choice'\n",
        "\n",
        "query = 'Please design a ' + str(num_questions) + '-' + ' question quiz about the poem which reflects the learning objectives:' + '\\n' + '1. Identify the key elements of the poem: narrator, setting, and underlying message.' + '\\n' + '2. Understand the literary devices used in poetry and their purposes.' + '\\n' + 'The questions should be ' + question_type + '. Do not provide the answers.' + '\\n'\n",
        "\n",
        "query_prefix = \"The uploaded document should serve as the basis for the instructions that follow:\" + \"\\n\"\n",
        "\n",
        "question = qa.run(query_prefix + query)\n",
        "\n",
        "outputs = [('Model: ' + input_message), ('User: ' + str(num_questions)), '\\n', ('Model: ' + input_message1) , ('User: ' + question_type), '\\n', 'User: ', '\\n', query_prefix + query, '\\n', 'Model: ', '\\n', question, '\\n']\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Grading Interaction\n",
        "If you would like the model to grade your responses, you can use the following code cells to do so.\n",
        "\n",
        "Run the code cell to get a template for entering your answers and recieving feedback. Below is an example of what the template looks like.\n",
        "\n",
        "```\n",
        "answer_q1 = \"Question 1 answer: Your Answer Here\"\n",
        "grade_q1 = question + prompt + answer_q1\n",
        "feedback1 = qa.run(grade_q1)\n",
        "feedback1\n",
        "```\n",
        "\n",
        "The after running the cell, the ouput will print below the cell. Copy the entirity of the output. In the blank cell below, you will paste the output.\n",
        "\n",
        "The only change you will have to make to the template is your answer to the question. Input your answer over the \"Your Answer Here\" text. See the example below.\n",
        "\n",
        "```\n",
        "answer_q1 = \"Question 1 answer: A\"\n",
        "```"
      ],
      "metadata": {
        "id": "gXjrc9XGsa7q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Run this cell to input your answers\n",
        "print(question)\n",
        "print()\n",
        "\n",
        "for x in range(0, num_questions, 1):\n",
        "  q_answer = 'What is your answer to question ' + str(x + 1) + \"? \" + '\\n'\n",
        "  answer = input(q_answer)\n",
        "  globals()['answer%s' % x] = answer\n",
        "  outputs.append('Model: ' + q_answer)\n",
        "  outputs.append('User: ' + answer)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hWecBtHK2Elu",
        "outputId": "b0ecc1e9-a00a-4a00-c82e-0f90736821e8"
      },
      "execution_count": 122,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1. What is the underlying message of the poem \"The Road Not Taken\"?\n",
            "A. Always choose the path less traveled.\n",
            "B. It's important to make decisions quickly.\n",
            "C. All paths lead to the same destination.\n",
            "\n",
            "2. Who is the narrator of the poem?\n",
            "A. Robert Frost\n",
            "B. A traveler in a yellow wood\n",
            "C. The undergrowth\n",
            "\n",
            "3. Which literary device is used in the line \"Two roads diverged in a yellow wood\"?\n",
            "A. Simile\n",
            "B. Metaphor\n",
            "C. Personification\n",
            "\n",
            "What is your answer to question 1? \n",
            "A\n",
            "What is your answer to question 2? \n",
            "A\n",
            "What is your answer to question 3? \n",
            "A\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Grading cell - Run without making changes. Copy the output and paste into empty cell below.\n",
        "\n",
        "prompt = \"Please grade my quiz based on the question you produced and my answer. If I am correct, please answer 'You are correct.'. If I am incorrect, do not provide an explanation: you should simply respond 'You are incorrect. The right answer is (the right answer)'. Here is a template for a correct answer: 'You are correct.' Here is a template for an incorrect answer: 'You are incorrect, the correct answer is C.' Do not include any context from the question, and any of the answers.\"\n",
        "\n",
        "def answer_template(num_questions):\n",
        "  print('total_feedback = []')\n",
        "  for x in range(0, num_questions, 1):\n",
        "    print('answer_q' + str(x + 1) + ' = ' + '\"Question ' + str(x + 1) +  ' answer:\" ' + '+ ' + ('answer' + str(x)))\n",
        "    print('grade_q' + str(x + 1) + ' = question + prompt + answer_q' + str(x + 1))\n",
        "    print('feedback' + str(x + 1) + ' = qa.run(grade_q' + str(x + 1) + ')' )\n",
        "    print('feedback' + str(x + 1))\n",
        "    print('total_feedback.append(feedback' + str(x + 1) + ')')\n",
        "    print()\n",
        "  print('print(total_feedback)')\n",
        "\n",
        "template = answer_template(num_questions)\n",
        "template\n"
      ],
      "metadata": {
        "id": "TkaahAGoUNIi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c65a28cd-397c-42fa-f467-0badd1196817"
      },
      "execution_count": 123,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "total_feedback = []\n",
            "answer_q1 = \"Question 1 answer:\" + answer0\n",
            "grade_q1 = question + prompt + answer_q1\n",
            "feedback1 = qa.run(grade_q1)\n",
            "feedback1\n",
            "total_feedback.append(feedback1)\n",
            "\n",
            "answer_q2 = \"Question 2 answer:\" + answer1\n",
            "grade_q2 = question + prompt + answer_q2\n",
            "feedback2 = qa.run(grade_q2)\n",
            "feedback2\n",
            "total_feedback.append(feedback2)\n",
            "\n",
            "answer_q3 = \"Question 3 answer:\" + answer2\n",
            "grade_q3 = question + prompt + answer_q3\n",
            "feedback3 = qa.run(grade_q3)\n",
            "feedback3\n",
            "total_feedback.append(feedback3)\n",
            "\n",
            "print(total_feedback)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Copy the output here\n",
        "\n",
        "total_feedback = []\n",
        "answer_q1 = \"Question 1 answer:\" + answer0\n",
        "grade_q1 = question + prompt + answer_q1\n",
        "feedback1 = qa.run(grade_q1)\n",
        "feedback1\n",
        "total_feedback.append(feedback1)\n",
        "\n",
        "answer_q2 = \"Question 2 answer:\" + answer1\n",
        "grade_q2 = question + prompt + answer_q2\n",
        "feedback2 = qa.run(grade_q2)\n",
        "feedback2\n",
        "total_feedback.append(feedback2)\n",
        "\n",
        "answer_q3 = \"Question 3 answer:\" + answer2\n",
        "grade_q3 = question + prompt + answer_q3\n",
        "feedback3 = qa.run(grade_q3)\n",
        "feedback3\n",
        "total_feedback.append(feedback3)\n",
        "\n",
        "answers_total = []\n",
        "x = 1\n",
        "for i in total_feedback:\n",
        "  answer_print = (str(x) +  \". \" + i)\n",
        "  print(answer_print)\n",
        "  answers_total.append(answer_print)\n",
        "  x = x + 1\n",
        "\n",
        "for i in answers_total:\n",
        "  outputs.append('Model: ' + i)"
      ],
      "metadata": {
        "id": "DDti3ZjP0KS4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ab7ea6a7-379f-48b8-ee28-87d3cfb4cacd"
      },
      "execution_count": 124,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1. You are incorrect, the correct answer is C.\n",
            "2. You are correct.\n",
            "3. You are incorrect, the correct answer is B.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Recieve your grade!\n",
        "\n",
        "Run the following cell to recieve your grade in a percentage form."
      ],
      "metadata": {
        "id": "Kt1DgnOn5f3h"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "\n",
        "def points_add(feedback):\n",
        "  points = []\n",
        "  for answer in feedback:\n",
        "    if answer == \"You are correct.\":\n",
        "      points = points + [1]\n",
        "    else:\n",
        "      points = points\n",
        "  return points\n",
        "\n",
        "points_list = points_add(total_feedback)\n",
        "\n",
        "def sum_points(points):\n",
        "  sum_total = sum(points)\n",
        "  return sum_total\n",
        "\n",
        "total = sum_points(points_list)\n",
        "\n",
        "def grade_percent(total, num_questions):\n",
        "  percent = (total / num_questions) * 100\n",
        "  return percent\n",
        "\n",
        "percent = grade_percent(total, num_questions)\n",
        "\n",
        "if percent > 80:\n",
        "  more_than_80 = 'Nice job! Your score was ' + str(round(percent)) + '%'\n",
        "  print(more_than_80)\n",
        "  outputs.append('Model: ' + more_than_80)\n",
        "elif percent < 80 and percent > 60:\n",
        "  more_than_60 = \"You're getting there! Your score was \" + str(round(percent)) + '%'\n",
        "  print(more_than_60)\n",
        "  outputs.append('Model: ' + more_than_60)\n",
        "else:\n",
        "  less_than_60 = 'Keep studying! Your score was ' + str(round(percent)) + '%'\n",
        "  print(less_than_60)\n",
        "  outputs.append('Model: ' + less_than_60)\n",
        "\n"
      ],
      "metadata": {
        "id": "3C2fYmXTW09Q",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4e89e4e8-36bd-450b-e1fe-9a12aeba9774"
      },
      "execution_count": 125,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Keep studying! Your score was 33%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Keep chatting with the model!\n",
        "\n",
        "Below are some examples of ways you can continue to interact with the model and recieve more feedback!\n"
      ],
      "metadata": {
        "id": "upOxT3zRRuHS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Ask about a specific question\n",
        "\n",
        "First, input the question you would like further elaboration on (input the question number).\n",
        "\n",
        "Next, input your prompt. What part of the question would you like further explanation on? Below is an example prompt.\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "Can you please explain elaborate on the correct answer for question 1?\n",
        "```\n",
        "\n",
        "The prompt can be as broad or as specific as you would like. However, more specific questions will likely yield a better response from the model!\n",
        "\n",
        "### Follow-up\n",
        "\n",
        "You can also ask a follow-up question if you are still struggling to understand specific parts of the question. Another input box will appear. If you would like to ask further questions, type \"Yes.\" Another input box will appear where you can ask further questions. If you type \"No\", the interaction with the model will cease."
      ],
      "metadata": {
        "id": "6inO1r5ha48l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "which_question = 'Input the question number you would like feedback on here! ' + '\\n'\n",
        "question_number = int(input(which_question))\n",
        "# Example = 1\n",
        "outputs.append('Model: ' + which_question)\n",
        "outputs.append('User: ' + str(question_number))\n",
        "\n",
        "def feedback_assign(question_number, feedback_list):\n",
        "  for i in total_feedback:\n",
        "    if feedback_list.index(i) == (question_number - 1) :\n",
        "      feedback = 'feedback' + 'question_number + 1'\n",
        "    else:\n",
        "      pass\n",
        "  return feedback\n",
        "\n",
        "query_input = 'How can I help you better understand the answer to this question? ' + '\\n'\n",
        "outputs.append('Model: ' + query_input)\n",
        "query = input(query_input)\n",
        "# Example: 'Can you please explain elaborate on the correct answer for question 1?'\n",
        "outputs.append('User: ' + query)\n",
        "\n",
        "response = qa.run(question + feedback_assign(question_number, total_feedback) + query)\n",
        "print(response)\n",
        "outputs.append('Model: ' + response)\n",
        "\n",
        "any_followup = 'Would you like to ask any follow-up questions about my response?' + '\\n'\n",
        "outputs.append('Model: ' + any_followup)\n",
        "more_questions = input(any_followup)\n",
        "outputs.append('User: ' + more_questions)\n",
        "if more_questions == \"No\":\n",
        "    no = 'Great! I am happy that I could assist you in your learning.'\n",
        "    outputs.append('Model: ' + no)\n",
        "    print(no)\n",
        "while more_questions == 'Yes':\n",
        "    outputs.append('User: ' + more_questions)\n",
        "    query2_input = \"What further questions do you have about question \" + str(question_number) + '?' + '\\n'\n",
        "    outputs.append('Model: ' + query2_input)\n",
        "    second_query = input()\n",
        "    response1 = qa.run(question + feedback_assign(question_number, total_feedback) + response + second_query)\n",
        "    outputs.append('User: ' + second_query)\n",
        "    outputs.append('Model: ' + response1)\n",
        "    print(response1)\n",
        "    more_questions = input('Would you like to ask any follow-up questions about my response?' + '\\n')\n",
        "    if more_questions == \"No\":\n",
        "      no1 = 'Great! I am happy that I could assist you in your learning.'\n",
        "      outputs.append('Model: ' + more_questions)\n",
        "      outputs.append('User: ' + no1)\n",
        "      print(no1)\n",
        "      break"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GwZLIJZKRx9p",
        "outputId": "6d8b06c0-d5d4-44d2-d405-d28c82b0ac20"
      },
      "execution_count": 126,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input the question number you would like feedback on here! \n",
            "1\n",
            "How can I help you better understand the answer to this question? \n",
            "Why was my answer to question 1 incorrect?\n",
            "I'm sorry, there seems to be an error. I did not provide an answer to your questions yet. Please provide the questions again.\n",
            "Would you like to ask any follow-up questions about my response?\n",
            "No\n",
            "Great! I am happy that I could assist you in your learning.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Ask further questions about the context\n",
        "\n",
        "You can also ask the model more follow-up questions about the context, unrelated to the questions it produced or your answers. Simpl input"
      ],
      "metadata": {
        "id": "a8n5bwK1azHk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "input_message2 = 'What else can I assist you with? If you have no further questions, please answer \"Nothing\".' + '\\n'\n",
        "outputs.append('Model: ' + input_message2)\n",
        "query = input(input_message2)\n",
        "outputs.append('User: ' + query)\n",
        "\n",
        "if query == \"Nothing\":\n",
        "  nothing = \"Great! I am happy I could assist you in your learning\"\n",
        "  print(nothing)\n",
        "  outputs.append('Model: ' + nothing)\n",
        "else:\n",
        "  follow_up = qa.run(query)\n",
        "  outputs.append('Model: ' + follow_up)\n",
        "  print(follow_up)\n",
        "  more_assist = 'Is there anything else I can assist you with? Please answer \"Yes\" or \"No\".' + '\\n'\n",
        "  more_follow_up = input(more_assist)\n",
        "  while more_follow_up == 'Yes':\n",
        "    outputs.append(\"User: \" + more_follow_up)\n",
        "    more_further = \"What further questions do you have?\" + '\\n'\n",
        "    query = input(more_further)\n",
        "    outputs.append('Model: ' + more_further)\n",
        "    outputs.append(\"User: \" + query)\n",
        "    follow_up = qa.run(query)\n",
        "    outputs.append('Model: ' + follow_up)\n",
        "    print(follow_up)\n",
        "    more_questions_again = 'Would you like to ask any follow-up questions about my response? Please answer \"Yes\" or \"No\".' + '\\n'\n",
        "    more_questions = input(more_questions_again)\n",
        "    outputs.append(\"Model: \" + more_questions_again)\n",
        "    outputs.append(\"User: \" + more_questions)\n",
        "    if more_questions == \"No\":\n",
        "      no_more = 'Great! I am happy that I could assist you in your learning.'\n",
        "      print(no_more)\n",
        "      outputs.append(\"Model: \" + no_more)\n",
        "      break"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PH0uHBJLSQuG",
        "outputId": "68ca1a86-a066-473f-8fd7-86fc1c5bdaff"
      },
      "execution_count": 127,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "What else can I assist you with? If you have no further questions, please answer \"Nothing\".\n",
            "What is the importance of metaphors in poetry?\n",
            "Metaphors are a powerful tool in poetry as they help to create images and comparisons that allow readers to understand and feel emotions that are not directly stated. By comparing two seemingly unrelated things, poets can create a deeper understanding of the subject matter and allow readers to connect with the poem on a more personal level. Overall, metaphors bring depth and richness to poetry, making it a more enjoyable and meaningful experience for readers.\n",
            "Is there anything else I can assist you with? Please answer \"Yes\" or \"No\".\n",
            "No\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for i in outputs:\n",
        "  print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eQf_WZlyvp07",
        "outputId": "5e9b6174-7da4-42f5-e560-ebdea81dab4f"
      },
      "execution_count": 128,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: How many questions would you like?\n",
            "\n",
            "User: 3\n",
            "\n",
            "\n",
            "Model: What type of question would you like?\n",
            "\n",
            "User: multiple choice\n",
            "\n",
            "\n",
            "User: \n",
            "\n",
            "\n",
            "The uploaded document should serve as the basis for the instructions that follow:\n",
            "Please design a 3- question quiz about the poem which reflects the learning objectives:\n",
            "1. Identify the key elements of the poem: narrator, setting, and underlying message.\n",
            "2. Understand the literary devices used in poetry and their purposes.\n",
            "The questions should be multiple choice. Do not provide the answers.\n",
            "\n",
            "\n",
            "\n",
            "Model: \n",
            "\n",
            "\n",
            "1. What is the underlying message of the poem \"The Road Not Taken\"?\n",
            "A. Always choose the path less traveled.\n",
            "B. It's important to make decisions quickly.\n",
            "C. All paths lead to the same destination.\n",
            "\n",
            "2. Who is the narrator of the poem?\n",
            "A. Robert Frost\n",
            "B. A traveler in a yellow wood\n",
            "C. The undergrowth\n",
            "\n",
            "3. Which literary device is used in the line \"Two roads diverged in a yellow wood\"?\n",
            "A. Simile\n",
            "B. Metaphor\n",
            "C. Personification\n",
            "\n",
            "\n",
            "Model: What is your answer to question 1? \n",
            "\n",
            "User: A\n",
            "Model: What is your answer to question 2? \n",
            "\n",
            "User: A\n",
            "Model: What is your answer to question 3? \n",
            "\n",
            "User: A\n",
            "Model: 1. You are incorrect, the correct answer is C.\n",
            "Model: 2. You are correct.\n",
            "Model: 3. You are incorrect, the correct answer is B.\n",
            "Model: Keep studying! Your score was 33%\n",
            "Model: Input the question number you would like feedback on here! \n",
            "\n",
            "User: 1\n",
            "Model: How can I help you better understand the answer to this question? \n",
            "\n",
            "User: Why was my answer to question 1 incorrect?\n",
            "Model: I'm sorry, there seems to be an error. I did not provide an answer to your questions yet. Please provide the questions again.\n",
            "Model: Would you like to ask any follow-up questions about my response?\n",
            "\n",
            "User: No\n",
            "Model: Great! I am happy that I could assist you in your learning.\n",
            "Model: What else can I assist you with? If you have no further questions, please answer \"Nothing\".\n",
            "\n",
            "User: What is the importance of metaphors in poetry?\n",
            "Model: Metaphors are a powerful tool in poetry as they help to create images and comparisons that allow readers to understand and feel emotions that are not directly stated. By comparing two seemingly unrelated things, poets can create a deeper understanding of the subject matter and allow readers to connect with the poem on a more personal level. Overall, metaphors bring depth and richness to poetry, making it a more enjoyable and meaningful experience for readers.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# convert to json\n",
        "import json\n",
        "from google.colab import files\n",
        "\n",
        "def save_chat_dialogue(outputs, filename='chat_dialogue.json'):\n",
        "  with open(filename, 'w') as file:\n",
        "    json.dump(outputs, file)\n",
        "  files.download(filename)\n",
        "\n",
        "save_chat_dialogue(outputs)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "id": "cSWM6VM-CYD_",
        "outputId": "b31bd875-416c-4ff3-cf68-f8eb633acf69"
      },
      "execution_count": 131,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_de31663e-1a11-49d0-902c-b13850f0ff74\", \"chat_dialogue.json\", 2549)"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Prompt Examples**"
      ],
      "metadata": {
        "id": "htQA3KUk1zzH"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KYro6H82bENS"
      },
      "source": [
        "## Types of Questions and Prompts\n",
        "\n",
        "Below is a comprehensive list of question types and prompt templates designed by our team. There are also example code blocks, where you can see how the model performed with the example and try it for yourself using the prompt template."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WAUSc7qJPA_X"
      },
      "source": [
        "### Multiple Choice\n",
        "\n",
        "Prompt: The following text should be used as the basis for the instructions which follow: {context}. Please design a 5 question quiz about {name or reference to context} which reflects the learning objectives: {list of learning objectives}. The questions should be multiple choice. If I get an answer wrong, provide me with an explanation of why it was incorrect, and then give me additional chances to respond until I get the correct choice. Explain why the correct choice is right."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nFMRDL4cPA_X"
      },
      "outputs": [],
      "source": [
        "# Multiple choice code example\n",
        "query = \"\"\"Please design a 5 question quiz about Robert Frost's \"Road Not Taken\" which reflects the learning objectives:\n",
        "1. Identify the key elements of the poem: narrator, setting, and underlying message.\n",
        "2. Understand the literary devices used in poetry and their purposes. The questions should be multiple choice.\n",
        "If I get an answer wrong, provide me with an explanation of why it was incorrect, and then give me additional\n",
        "chances to respond until I get the correct choice. Explain why the correct choice is right. \"\"\"\n",
        "\n",
        "query_prefix = \"The uploaded document should serve as the basis for the instructions that follow:\"\n",
        "answer = qa.run(query_prefix + query)\n",
        "print(answer)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WkSIU94GPA_Y"
      },
      "source": [
        "### Short Answer\n",
        "\n",
        "Prompt: Please design a 5-question quiz about {context} which reflects the learning objectives: {list of learning objectives}. The questions should be short answer. Expect the correct answers to be {anticipated length} long. If I get any part of the answer wrong, provide me with an explanation of why it was incorrect, and then give me additional chances to respond until I get the correct choice."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "enC8ydfEPA_Y"
      },
      "outputs": [],
      "source": [
        "# Short answer code example\n",
        "query = \"\"\" Please design a 5-question quiz about Robert Frost's\n",
        "\"Road Not Taken\" which reflects the learning objectives:\n",
        "1. Identify the key elements of the poem: narrator, setting, and underlying message.\n",
        "2. Understand the literary devices used in poetry and their purposes.\n",
        "The questions should be short answer. Expect the correct answers to be\n",
        "1-2 sentences long. If I get any part of the answer wrong,\n",
        "provide me with an explanation of why it was incorrect,\n",
        "and then give me additional chances to respond until I get the correct choice. \"\"\"\n",
        "\n",
        "answer = qa.run(query_prefix + query)\n",
        "print(answer)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ta4A527kPA_Y"
      },
      "source": [
        "### Fill-in-the-blank\n",
        "\n",
        "Prompt: Create a 5 question fill in the blank quiz refrencing {context}. The quiz should reflect the learning objectives: {learning objectives}. Please prompt me one question at a time and proceed when I answer correctly. If I answer incorrectly, please explain why my answer is incorrect."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "szMOxEoiPA_Z"
      },
      "outputs": [],
      "source": [
        "# Fill in the blank code example\n",
        "query = \"\"\" Create a 5 question fill in the blank quiz refrencing Robert Frost's \"The Road Not Taken.\"\n",
        "The quiz should reflect the learning objectives:\n",
        "1. Identify the key elements of the poem: narrator, setting, and underlying message.\n",
        "2. Understand the literary devices used in poetry and their purposes.\n",
        "Please prompt me one question at a time and proceed when I answer correctly.\n",
        "If I answer incorrectly, please explain why my answer is incorrect. \"\"\"\n",
        "\n",
        "answer = qa.run(query_prefix + query)\n",
        "print(answer)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yEwzAB28PA_Z"
      },
      "source": [
        "### Sequencing\n",
        "\n",
        "Prompt: Please develop a 5 question questionnaire that will ask me to recall the steps involved in the following learning objectives in regard to {context}: {learning objectives}. After I respond, explain their sequence to me."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3YRyhhWtPA_Z"
      },
      "outputs": [],
      "source": [
        "# Sequence example\n",
        "query = \"\"\" Please develop a 5 question questionnaire that will ask me to recall the steps involved in the following learning objectives in regard to Robert Frost's \"The Road Not Taken\":\n",
        "1. Identify the key elements of the poem: narrator, setting, and underlying message.\n",
        "2. Understand the literary devices used in poetry and their purposes.\n",
        "After I respond, explain their sequence to me.\"\"\"\n",
        "\n",
        "answer = qa.run(query_prefix + query)\n",
        "print(answer)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0DGBiJofPA_Z"
      },
      "source": [
        "### Relationships/drawing connections\n",
        "\n",
        "Prompt: Please design a 5 question quiz that asks me to explain the relationships that exist within the following learning objectives, referencing {context}: {learning objectives}."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Mw3RBpsnPA_a"
      },
      "outputs": [],
      "source": [
        "# Relationships example\n",
        "query = \"\"\" Please design a 5 question quiz that asks me to explain the relationships that exist within the following learning objectives, referencing Robert Frost's \"The Road Not Taken\":\n",
        "1. Identify the key elements of the poem: narrator, setting, and underlying message.\n",
        "2. Understand the literary devices used in poetry and their purposes.\"\"\"\n",
        "\n",
        "answer = qa.run(query_prefix + query)\n",
        "print(answer)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4YO3wCTwPA_a"
      },
      "source": [
        "### Concepts and Definitions\n",
        "\n",
        "Prompt: Design a 5 question quiz that asks me about definitions related to the following learning objectives: {learning objectives} - based on {context}\".\n",
        "Once I write out my response, provide me with your own response, highlighting why my answer is correct or incorrect."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TbvJPhkmPA_a"
      },
      "outputs": [],
      "source": [
        "# Concepts and definitions example\n",
        "query = \"\"\" Design a 5 question quiz that asks me about definitions related to the following learning objectives:\n",
        "1. Identify the key elements of the poem: narrator, setting, and underlying message, and\n",
        "2. Understand the literary devices used in poetry and their purposes - based on Robert Frost's \"The Road Not Taken\".\n",
        "Once I write out my response, provide me with your own response, highlighting why my answer is correct or incorrect.\"\"\"\n",
        "\n",
        "answer = qa.run(query_prefix + query)\n",
        "print(answer)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vc-llAgfPA_a"
      },
      "source": [
        "### Real Word Examples\n",
        "\n",
        "Prompt: Demonstrate how {context} can be applied to solve a real-world problem related to the following learning objectives: {learning objectives}. Ask me questions regarding this theory/concept."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sSwRLkR8PA_a"
      },
      "outputs": [],
      "source": [
        "# Real word example\n",
        "query = \"\"\" Demonstrate how Robert Frost’s “The Road Not Taken” can be applied to solve a real-world problem related to the following learning objectives:\n",
        "1. Identify the key elements of the poem: narrator, setting, and underlying message.\n",
        "2. Understand the literary devices used in poetry and their purposes.\n",
        "Ask me questions regarding this theory/concept.\"\"\"\n",
        "\n",
        "answer = qa.run(query_prefix + query)\n",
        "print(answer)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2y6gHhGKPA_b"
      },
      "source": [
        "### Randomized Question Types\n",
        "\n",
        "Prompt: Please generate a high-quality assessment consisting of 5 varying questions, each of different types (open-ended, multiple choice, etc.), to determine if I achieved the following learning objectives in regards to {context}: {learning objectives}. If I answer incorrectly for any of the questions, please explain why my answer is incorrect."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xC4t4WMwPA_b"
      },
      "outputs": [],
      "source": [
        "# Randomized question types\n",
        "query = \"\"\" Please generate a high-quality assessment consisting of 5 varying questions,\n",
        "each of different types (open-ended, multiple choice, etc.),\n",
        "to determine if I achieved the following learning objectives in regards to Robert Frost’s “The Road not Taken\":\n",
        "1. Identify the key elements of the poem: narrator, setting, and underlying message.\n",
        "2. Understand the literary devices used in poetry and their purposes. If I answer incorrectly for any of the questions,\n",
        "please explain why my answer is incorrect.\"\"\"\n",
        "\n",
        "answer = qa.run(query_prefix + query)\n",
        "print(answer)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ndo_cdWYPA_b"
      },
      "source": [
        "### Quantiative evaluation the correctness of a student's answer\n",
        "\n",
        "Prompt: (A continuation of the previous chat) Please generate the main points of the student’s answer to the previous question, and evaluate on a scale of 1 to 5 how comprehensive the student’s answer was in relation to the learning objectives, and explain why he or she received this rating, including what was missed in his or her answer if the student’s answer wasn’t complete.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WhhNI0FZPA_b"
      },
      "outputs": [],
      "source": [
        "# qualitative evaluation\n",
        "qualitative_query = \"\"\" Please generate the main points of the student’s answer to the previous question,\n",
        " and evaluate on a scale of 1 to 5 how comprehensive the student’s answer was in relation to the learning objectives,\n",
        " and explain why he or she received this rating, including what was missed in his or her answer if the student’s answer wasn’t complete.\"\"\"\n",
        "\n",
        "# Note that this uses the previous result and query in the context\n",
        "answer = qa.run(query_prefix + query)\n",
        "print(answer)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "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.7.12"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}