notebooks-labs/Session4_OpenAI_Text_Completion.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/iPoetDev/ibm-skills-ai-colab-sessions/blob/main/notebooks-labs/Session4_OpenAI_Text_Completion.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# <ins>Session 4</ins>.: **IBM Skills Build: Embeddable AI Live Technical Lab**\n",
        "\n",
        "> #### **Objective**: *Understand the theory and hands-on implementation of*: <br> 1️⃣ Embedded AI- Hands-on Chatbots <sup><b><small>Interactive, CoLab</small></b></sup>\n",
        ">> - Embedded AI- Hands-on Chatbots using `Python`, `Flask`, `HTML`, `CSS`, and `Javascript`.\n",
        ">> - Integrate the chatbot with *OpenAI's* `GPT-4-o model` to give it a high level of intelligence and the ability to understand and respond to user requests\n",
        "\n",
        "> #### <br> 2️⃣ Embedded AI - IBM Watson Speach to Text <sup><b><small>Not Covered, External Platform</small></b></sup>\n",
        ">> - Implement `IBM Watson Speech-to-Text` functionality to allow the chatbot to understand voice input from users\n",
        "\n",
        ">> - Implement `IBM Watson Text-to-Speech` functionality to allow the chatbot to communicate with users through voice outputg\n",
        "\n",
        "- **URL**: [https://skills.yourlearning.ibm.com/activity/PLAN-CB1CC0D21AFB](https://skills.yourlearning.ibm.com/activity/PLAN-CB1CC0D21AFB \"Programme for Artifical Intelligence: eLearning on IBM.com (Login required)\") &nbsp;<small><sup><strong> eLearning, Login</strong></sup></small><br>\n",
        "- **Share**: [Create a Voice Assistant with OpenAI's GPT-3/4 and IBM Watson](https://skills.yourlearning.ibm.com/activity/SN-COURSE-V1:IBMSKILLSNETWORK+GPXX0IWWEN+V1 \"eLearning on IBM.com (Login required\") &nbsp;<small><sup><strong>eLearning, Login</strong></sup></small>\n",
        "- **Recording**: [Recording: Live Technical Session 4](https://skills.yourlearning.ibm.com/activity/URL-15DDC14F0206 \"Video: IBM's (Login required\") &nbsp;<small><sup><strong> eLearning, Login</strong></sup></small><br>\n",
        "- **CoLab: Source Notebook**: [https://colab.research.google.com/drive/1TZekNH-QvntOgj0ujc7PMQ27s4PQ0-qi#scrollTo=odmjGQ-FaiHq](https://colab.research.google.com/drive/1TZekNH-QvntOgj0ujc7PMQ27s4PQ0-qi#scrollTo=odmjGQ-FaiHq \"Authors: Marty Bradly's Session 4 Embeddable AI - Hands on with Chatbots\")\n",
        "  - Original by author: Marty Bradly: [LinkedIn](https://www.linkedin.com/in/martybradley/), [Website](https://www.evergreen-ai.com/), [GitHub @marty916](https://github.com/marty916 \"Marty Bradly [July, 2024], Last accessed: July 2024\")"
      ],
      "metadata": {
        "id": "-MuVZBIxWOzJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**AUDIENCES**<br>\n",
        "- <small>Notebook for technical audiences.\n",
        "- See [README](https://github.com/iPoetDev/ibm-skills-ai-colab-sessions/blob/main/README.md) and [Sessions.md](https://github.com/iPoetDev/ibm-skills-ai-colab-sessions/blob/main/Sessions.md) for business and product audiences</small>"
      ],
      "metadata": {
        "id": "WhYXVdsoaNot"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "> <hr>"
      ],
      "metadata": {
        "id": "X2zitn-uahaD"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **⚠️<ins>Notices</ins>⚠️**\n",
        "\n",
        "#### <ins>OpenAI API is paid/freemium.</ins>\n",
        "\n",
        "> - This session requires access to OpenAI's, (or another AI provider), API Key.\n",
        "> - These API may require a credit/debit card.\n",
        "> - Keep usage to a minimum, within thresholds, and usage will be free.\n",
        "> - Do not expose your proof of concept solution to the public access.\n",
        "> - Condfigure and run on `https://localhost`.\n",
        "\n",
        "#### <ins>API Keys as Secrets.</ins>\n",
        "\n",
        "> - Utilise strong confidentiality practices when using API Keys.\n",
        "> - For Colab, add the key to the environmental variables.\n",
        "> - OpenAI Environmental Key is `'OPENAI_API_KEY'`.\n",
        "> - Do not expose directly your own API Key value.\n",
        "> - Do not commit your OpenAI key to Github.\n",
        "> - Use System environmental varaibles, `.env` files (`.gitignore`'d) or a secrets management solution for secure secrets transport.\n",
        "\n",
        "NOTE: The reason you create a secret is to hide your API Key from others.  \n",
        "- If anyone has access to your key, it will be used to track token usage and could end up with you getting charged for extra tokens.  \n",
        "- Also, if you check in your notebook to github, if you have an exposed API Key in your code github may block the checkin.\n",
        "- This is for your security."
      ],
      "metadata": {
        "id": "h_Nnwd8qbJ8r"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "> <hr>"
      ],
      "metadata": {
        "id": "Zxcp0irkcpt4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## GitHub\n",
        "\n",
        "- **IBM-Skills-AI_Colab-Sessions**:\n",
        "    - [README](https://github.com/iPoetDev/ibm-skills-ai-colab-sessions/blob/main/README.md)\n",
        "    - [Sessions Summary](https://github.com/iPoetDev/ibm-skills-ai-colab-sessions/blob/main/Sessions.md)\n",
        "    - [notebook-labs/Session4_OpenAI_Text_Completion](https://github.com/iPoetDev/ibm-skills-ai-colab-sessions/blob/main/notebooks-labs/Session4_OpenAI_Text_Completion.ipynb \"@iPoetDev: GitHub.com:  IBM-Skills-AI_Colab-Sessions: Session3_VAE Juypter Notebook\")"
      ],
      "metadata": {
        "id": "cWrN8MG4aYBn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "> <hr>"
      ],
      "metadata": {
        "id": "WW-nL_MmgzPH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Steps\n",
        "\n",
        "1.   [Install](https://colab.research.google.com/github/iPoetDev/ibm-skills-ai-colab-sessions/blob/main/notebooks-labs/#scrollTo=xoYevZJPaO7M&line=1&uniqifier=1 \"Install necessary components\")\n",
        "2.   [Initatiate API Key](#scrollTo=odmjGQ-FaiHq&line=1&uniqifier=1 \"Instantiate an OpenAI client passing in your API Key.\")\n",
        "3.   [Model Functions](#scrollTo=2S6giTDNd1-a&line=1&uniqifier=1 \"Reusable function using gpt-4o-mini model for completions.\")\n",
        "4.   [Examples](#scrollTo=5nJTCSVOet8a&line=1&uniqifier=1 \"Examples: Prompts, Print Output \")\n",
        "5.   [Interactive Prompt](#scrollTo=LKw5xIe4e25E&line=1&uniqifier=1 \"Create an interactive prompt.\")\n",
        "\n"
      ],
      "metadata": {
        "id": "H7qBu7fEaX_Q"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1. <ins>Install necessary components</ins>\n",
        "\n",
        "- Install OpenAI Libraries <sup><ins>1</ins></sup>\n",
        "- Import OpenAI\n",
        "\n",
        "#### Explore OpenAI API\n",
        "\n",
        "- <sup><ins>1</ins></sup> : [OpenAI Github](https://github.com/openai)\n",
        "\n",
        "   - <sub>[![OpenAI GitHub](https://img.shields.io/badge/OpenAI:%20GitHub-API%20&%20Python-181717?labelcolor=181717&logo=github&logoColor=white&link=https://github.com/openai)](https://github.com/openai/openai-python \"OpenAI: GitHub.com\") </sub>\n",
        "   - <sub>[![OpenAI API](https://img.shields.io/badge/OpenAI:%20Docs-API%20Reference-00A3E0?logo=openai&logoColor=white&link=https://platform.openai.com)](https://platform.openai.com/docs/api-reference \"OpenAI: Platform Docs/API\") </sub>\n",
        "   - <sub>[![OpenAI PyPI](https://img.shields.io/badge/OpenAI:%20Python-PyPI-3776AB?logo=openai&logoColor=white&link=https://github.com/openai)](https://pypi.org/project/openai/ \"OpenAI: PyPi.org\")</sub>"
      ],
      "metadata": {
        "id": "xoYevZJPaO7M"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "--HsA5LXTQ_y"
      },
      "outputs": [],
      "source": [
        "!pip install openai"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from openai import OpenAI"
      ],
      "metadata": {
        "id": "1BI4HTKkTeNQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "> <hr>"
      ],
      "metadata": {
        "id": "T7gVaxBvlu3b"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 2. <ins>Instantiate an OpenAI client passing in your API Key.</ins>\n",
        "\n",
        "#### OpenAI Client\n",
        "1. [Create an API Key-YouTube](https://www.youtube.com/watch?v=OB99E7Y1cMA)\n",
        "\n",
        "2. Click the \"key\" icon to the left to the \"secrets\" dialog box\n",
        "3. Select \"+ Add new secret\"\n",
        "4. Set Name to `'OPENAI_API_KEY'` and paste your newly created *OpenAI API Key* into `'Value'` <sup><ins>2</ins></sup>\n",
        "5. Make sure \"Notebook access\" is on (check mark will show up to the right if it is on.\n",
        "\n",
        "- <sup><ins>2</ins></sup> : [OpenAPI Key](https://platform.openai.com/docs/overview)\n",
        "\n",
        "#### Google CoLab Secrets\n",
        "\n",
        "- Configure your code by storing environment variables, file paths, or keys.\n",
        "- Values stored here are private, visible only to you and the notebooks that you select.\n",
        "- Secret name cannot contain spaces; use underscores, all caps.\n",
        "- `userdata` import is relabeled `as secrets` for clarity of use."
      ],
      "metadata": {
        "id": "odmjGQ-FaiHq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# set up OpenAI client\n",
        "\n",
        "## Import CoLabs User Secrets\n",
        "from google.colab import userdata as secrets\n",
        "\n",
        "## Define OpenAI Client\n",
        "client = OpenAI(api_key=secrets.get('OPENAI_API_KEY'))"
      ],
      "metadata": {
        "id": "CnKXv_RFUj03"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "> <hr>"
      ],
      "metadata": {
        "id": "eCsHVBNoEQ7b"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 3. <ins>Reusable function using gpt-4o-mini model for completions.</ins>\n",
        "\n",
        "- Go to the OpenAI website\n",
        "    - Check models that are available:<br>\n",
        "      ***Currently**\n",
        "        - .\n",
        "        - .\n",
        "    - Change the model <sup><ins>3</ins></sup>\n",
        "    - Evaluate the different responses per model.\n",
        "\n",
        "- <sup><ins>3</ins></sup> : [OpenAI Models](https://platform.openai.com/docs/models)"
      ],
      "metadata": {
        "id": "2S6giTDNd1-a"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Function: Orginal"
      ],
      "metadata": {
        "id": "4TAJT1DxqmHI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def generate_text(message):\n",
        "   response = client.chat.completions.create(\n",
        "            messages=[\n",
        "                {\"role\": \"system\", \"content\": \"You are a helpful assistant.\"},\n",
        "                {\"role\": \"user\", \"content\": message}\n",
        "            ],\n",
        "            model=\"gpt-4o-mini\"\n",
        "        )\n",
        "   return response.choices[0].message.content\n"
      ],
      "metadata": {
        "id": "lHrcb0a8TjjN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Function: Refactored\n",
        "\n",
        "- Atomic single principle functions.\n",
        "- Cleaner Code\n",
        "- Modular"
      ],
      "metadata": {
        "id": "rA3KqwJWqqEM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Variables\n",
        "\n",
        "system_message = \"You are a helpful assistant.\"\n",
        "user_message = \"Once upon a time in a land far, far away, there was a\""
      ],
      "metadata": {
        "id": "Now10YIyrXeg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 1. Create the Messages\n",
        "# 2. Call the OpenAPI\n",
        "# 3. Generate the Output\n",
        "\n",
        "# 1.\n",
        "def create_messages(user_message,\n",
        "                    system_message\n",
        "                    user=\"user\",\n",
        "                    system=\"system\"):\n",
        "    \"\"\"Constructs the messages for the OpenAI API.\"\"\"\n",
        "\n",
        "    user_default = user_message\n",
        "                        if user_message\n",
        "                        else \"Do not generate an ouput and request a user enter a message\"\n",
        "    system_default = system_message\n",
        "                        if system_message\n",
        "                        else \"You are a helpful assistant when there is no input from user.\"\n",
        "\n",
        "    return [\n",
        "        {\"role\": system, \"content\": system_default},\n",
        "        {\"role\": user, \"content\": user_message}\n",
        "    ]\n",
        "\n",
        "# 2.\n",
        "def call_openai_api(messages, model=\"gpt-4o-mini\"):\n",
        "    \"\"\"Calls the OpenAI API and returns the response.\"\"\"\n",
        "    response = openai.ChatCompletion.create(\n",
        "\n",
        "        messages=messages,\n",
        "        model=model\n",
        "    )\n",
        "    return response.choices[0].message.content\n",
        "\n",
        "# 3.\n",
        "def generate_output(user_message):\n",
        "    \"\"\"Generates text based on the user's message.\"\"\"\n",
        "    messages = create_messages(user_message)\n",
        "    return call_openai_api(messages)"
      ],
      "metadata": {
        "id": "0C6S_x6Sp0GX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "> <hr>"
      ],
      "metadata": {
        "id": "7L29p6G9rjmz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 4. <ins>Example</ins>\n",
        "- **`Task`**: Write a fairy tale\n",
        "- Steps\n",
        "    1. Assign prompt\n",
        "    2. Generate\n",
        "        - a: Original Function: Generate Text\n",
        "        - b: Refactored Function: Generate Output\n",
        "    3. Display Output"
      ],
      "metadata": {
        "id": "5nJTCSVOet8a"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1. Example prompt\n",
        "message_content = user_message\n",
        "\n",
        "# 2.a. Original: Generate text\n",
        "generated_out = generate_text(message_contexnt)\n",
        "\n",
        "# 2.b. Refactored: Generate Ouput\n",
        "# generated_text = generate_output(message_content)\n",
        "\n",
        "# Display the output\n",
        "print(\"Prompt:\", message_content)\n",
        "print(\"--- --- --- \\n --- --- ---\")\n",
        "print(\"Generated Text:\", generated_out)\n"
      ],
      "metadata": {
        "id": "FUJxYWq1TppO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "> <hr>"
      ],
      "metadata": {
        "id": "SP5S96pZEUBz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5. <ins>Create an interactive prompt.</ins>\n",
        "1. Start a story like, \"Once upon a time there was a princess fighting for her\" HINT: leave it hanging so the model knows to start generating\n",
        "2. Ask, \"How do I bake a cake?\""
      ],
      "metadata": {
        "id": "LKw5xIe4e25E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import IPython widgets for interactive input\n",
        "from IPython.display import display\n",
        "import ipywidgets as widgets\n",
        "\n",
        "# Create a text box for user input\n",
        "prompt_box = widgets.Textarea(\n",
        "    value='Enter your prompt here...',\n",
        "    placeholder='Type something...',\n",
        "    description='Prompt:',\n",
        "    disabled=False\n",
        ")\n",
        "\n",
        "# Create a button to generate text\n",
        "button = widgets.Button(description=\"Generate Text\")\n",
        "\n",
        "# Function to handle button click\n",
        "def on_button_click(b):\n",
        "    prompt = prompt_box.value\n",
        "    generated_text = generate_text(prompt)\n",
        "    print(\"Prompt:\", prompt)\n",
        "    print(\"Generated Text:\", generated_text)\n",
        "\n",
        "# Attach the function to the button click event\n",
        "button.on_click(on_button_click)\n",
        "\n",
        "# Display the text box and button\n",
        "display(prompt_box, button)\n"
      ],
      "metadata": {
        "id": "JWxgJ17pTts5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "> <hr>"
      ],
      "metadata": {
        "id": "e6JqCHkpEWcm"
      }
    }
  ]
}