language/code/code_generation.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ijGzTHJJUCPY"
      },
      "outputs": [],
      "source": [
        "# Copyright 2023 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",
        "#     https://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."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VEqbX8OhE8y9"
      },
      "source": [
        "# Getting Started with the Vertex AI Codey APIs - Code Generation\n",
        "\n",
        "> **NOTE:** This notebook uses the PaLM generative model, which will reach its [discontinuation date in October 2024](https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/text#model_versions).\n",
        "\n",
        "<table align=\"left\">\n",
        "  <td style=\"text-align: center\">\n",
        "    <a href=\"https://colab.research.google.com/github/GoogleCloudPlatform/generative-ai/blob/main/language/code/code_generation.ipynb\">\n",
        "      <img src=\"https://cloud.google.com/ml-engine/images/colab-logo-32px.png\" alt=\"Google Colaboratory logo\"><br> Run in Colab\n",
        "    </a>\n",
        "  </td>\n",
        "  <td style=\"text-align: center\">\n",
        "    <a href=\"https://github.com/GoogleCloudPlatform/generative-ai/blob/main/language/code/code_generation.ipynb\">\n",
        "      <img src=\"https://cloud.google.com/ml-engine/images/github-logo-32px.png\" alt=\"GitHub logo\"><br> View on GitHub\n",
        "    </a>\n",
        "  </td>\n",
        "  <td style=\"text-align: center\">\n",
        "    <a href=\"https://console.cloud.google.com/vertex-ai/workbench/deploy-notebook?download_url=https://raw.githubusercontent.com/GoogleCloudPlatform/generative-ai/main/language/code/code_generation.ipynb\">\n",
        "      <img src=\"https://lh3.googleusercontent.com/UiNooY4LUgW_oTvpsNhPpQzsstV5W8F7rYgxgGBD85cWJoLmrOzhVs_ksK_vgx40SHs7jCqkTkCk=e14-rj-sc0xffffff-h130-w32\" alt=\"Vertex AI logo\"><br> Open in Vertex AI Workbench\n",
        "    </a>\n",
        "  </td>\n",
        "</table>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b6c584fdf936"
      },
      "source": [
        "| | |\n",
        "|-|-|\n",
        "|Author(s) | [Lavi Nigam](https://github.com/lavinigam-gcp), [Polong Lin](https://github.com/polong-lin) |"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VK1Q5ZYdVL4Y"
      },
      "source": [
        "## Overview\n",
        "\n",
        "This notebook will provide an introduction to code generation using [Codey models](https://cloud.google.com/vertex-ai/docs/generative-ai/code/code-models-overview). Codey for Code Generation (code-bison) is a foundation model that can generate code based on a natural language description. It can be used to create functions, web pages, unit tests, and other types of code. Codey for Code Generation is supported by the code generation Codey APIs, which are part of the PaLM API family.\n",
        "\n",
        "\n",
        "### Vertex AI PaLM API\n",
        "The Vertex AI PaLM API, [released on May 10, 2023](https://cloud.google.com/vertex-ai/docs/generative-ai/release-notes#may_10_2023), is powered by [PaLM 2](https://ai.google/discover/palm2).\n",
        "\n",
        "### Using Vertex AI PaLM API\n",
        "\n",
        "You can interact with the Vertex AI PaLM API using the following methods:\n",
        "\n",
        "* Use the [Generative AI Studio](https://cloud.google.com/generative-ai-studio) for quick testing and command generation.\n",
        "* Use cURL commands in Cloud Shell.\n",
        "* Use the Python SDK in a Jupyter notebook\n",
        "\n",
        "This notebook focuses on using the Python SDK to call the Vertex AI PaLM API. For more information on using Generative AI Studio without writing code, you can explore [Getting Started with the UI instructions](https://github.com/GoogleCloudPlatform/generative-ai/blob/main/language/intro_vertex_ai_studio.md)\n",
        "\n",
        "\n",
        "For more information, check out the [documentation on generative AI support for Vertex AI](https://cloud.google.com/vertex-ai/docs/generative-ai/learn/overview)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RQT500QqVPIb"
      },
      "source": [
        "### Objectives\n",
        "\n",
        "In this tutorial, you will learn.\n",
        "\n",
        "- Setting up the environment for code generation models\n",
        "- Writing basic prompts for Codey\n",
        "- Various prompt design patterns:\n",
        "\t- Problem Statement Template\n",
        "\t- SQL Metadata & Performance\n",
        "\t- Code Optimization\n",
        "\t- Chain of Thought\n",
        "\t- Few Shot Prompts\n",
        "\t- DevOps Templates\n",
        "\t- Web Templates\n",
        "- Best Practices with Code Generation\n",
        "  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1y6_3dTwV2fI"
      },
      "source": [
        "### Costs\n",
        "This tutorial uses billable components of Google Cloud:\n",
        "\n",
        "* Vertex AI Generative AI Studio\n",
        "\n",
        "Learn about [Vertex AI pricing](https://cloud.google.com/vertex-ai/pricing),\n",
        "and use the [Pricing Calculator](https://cloud.google.com/products/calculator/)\n",
        "to generate a cost estimate based on your projected usage."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QDU0XJ1xRDlL"
      },
      "source": [
        "## Getting Started"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N5afkyDMSBW5"
      },
      "source": [
        "### Install Vertex AI SDK"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kc4WxYmLSBW5"
      },
      "outputs": [],
      "source": [
        "!pip install google-cloud-aiplatform==1.36.2 --upgrade --user"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j7UyNVSiyQ96"
      },
      "source": [
        "**Colab only:** Uncomment the following cell to restart the kernel or use the button to restart the kernel. For Vertex AI Workbench you can restart the terminal using the button on top."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YmY9HVVGSBW5"
      },
      "outputs": [],
      "source": [
        "# Automatically restart kernel after installs so that your environment can access the new packages\n",
        "import IPython\n",
        "\n",
        "app = IPython.Application.instance()\n",
        "app.kernel.do_shutdown(True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6Fom0ZkMSBW6"
      },
      "source": [
        "### Authenticating your notebook environment\n",
        "* If you are using **Colab** to run this notebook, uncomment the cell below and continue.\n",
        "* If you are using **Vertex AI Workbench**, check out the setup instructions [here](https://github.com/GoogleCloudPlatform/generative-ai/tree/main/setup-env)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LCaCx6PLSBW6"
      },
      "outputs": [],
      "source": [
        "# from google.colab import auth\n",
        "# auth.authenticate_user()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GckO4EysV5BT"
      },
      "source": [
        "## Vertex AI PaLM API models"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BDYqwDmTLgEy"
      },
      "source": [
        "The Vertex AI PaLM API enables you to test, customize, and deploy instances of Google's large language model (LLM) called as PaLM,so that you can leverage the capabilities of PaLM in your applications.\n",
        "\n",
        "### Model naming scheme\n",
        "Foundation model names have three components: use case, model size, and version number. The naming convention is in the format:  \n",
        "`<use case>-<model size>@<version number>`\n",
        "\n",
        "For example, text-bison@002 represents the Bison text model, version 002.\n",
        "\n",
        "The model sizes are as follows:\n",
        "- **Bison**: The best value in terms of capability and cost.\n",
        "- **Gecko**: The smallest and cheapest model for simple tasks.\n",
        "\n",
        "### Available models\n",
        "\n",
        "The Vertex AI Codey API currently supports three models:\n",
        "\n",
        "* `code-bison@002`: A model fine-tuned to generate code based on a natural language description of the desired code. For example, it can generate a unit test for a function.\n",
        "\n",
        "* `code-gecko@002`: A model fine-tuned to suggest code completion based on the context in code that's written.\n",
        "\n",
        "* `codechat-bison@002`: A model fine-tuned for chatbot conversations that help with code-related questions.\n",
        "\n",
        "You can find more information about the properties of these [foundational models in the Generative AI Studio documentation](https://cloud.google.com/vertex-ai/docs/generative-ai/learn/models#foundation_models).\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BuQwwRiniVFG"
      },
      "source": [
        "### Import libraries"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vnq2kIV8yQ97"
      },
      "source": [
        "**Colab only:** Uncomment the following cell to initialize the Vertex AI SDK. For Vertex AI Workbench, you don't need to run this.  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rtMowvm-yQ97"
      },
      "outputs": [],
      "source": [
        "# import vertexai\n",
        "\n",
        "# PROJECT_ID = \"\"  # @param {type:\"string\"}\n",
        "# vertexai.init(project=PROJECT_ID, location=\"us-central1\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4zjV4alsiVql"
      },
      "outputs": [],
      "source": [
        "from vertexai.language_models import CodeGenerationModel"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5B1PlCAr3GQi"
      },
      "source": [
        "## Code generation with code-bison@002"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wzoNuCqd3pbn"
      },
      "source": [
        "The code generation model (Codey) from PaLM API that you will use in this notebook is code-bison@002. It is fine-tuned to follow natural language instructions to generate required code and is suitable for a variety of coding tasks, such as:\n",
        "\n",
        "- writing functions\n",
        "- writing classes\n",
        "- web-apges\n",
        "- unit tests\n",
        "- docstrings\n",
        "- code translations, and many more use-cases.\n",
        "\n",
        "Currently it supports the following languages:\n",
        "- C++\n",
        "- C#\n",
        "- Go\n",
        "- GoogleSQL\n",
        "- Java\n",
        "- JavaScript\n",
        "- Kotlin\n",
        "- PHP\n",
        "- Python\n",
        "- Ruby\n",
        "- Rust\n",
        "- Scala\n",
        "- Swift\n",
        "- TypeScript\n",
        "\n",
        "You can find our more details [here](https://cloud.google.com/vertex-ai/docs/generative-ai/code/code-models-overview)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H6AzUJLt-ihw"
      },
      "source": [
        "### Load model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GqGueQgG3pAA"
      },
      "outputs": [],
      "source": [
        "code_generation_model = CodeGenerationModel.from_pretrained(\"code-bison@002\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qDzu2A0k_YYL"
      },
      "source": [
        "### Model parameters for `code-bison`\n",
        "\n",
        "You can customize how the PaLM API code generation behaves in response to your prompt by using the following parameters for `code-bison@002`:\n",
        "\n",
        " - `prefix`: it represents the beginning of a piece of meaningful programming code or a natural language prompt that describes code to be generated.\n",
        " - `temperature`: higher means more \"creative\" code responses. range: (0.0 - 1.0, default 0).\n",
        " - `max_output_tokens`: sets the max number of tokens in the output. range: (1 - 2048, default 2048)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WIiZZHJAC0jC"
      },
      "source": [
        "### Hello Codey"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1a0swVvTN0JP"
      },
      "source": [
        "You can test the code that is being generated [here](https://onecompiler.com/)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oiywwL1T5grZ"
      },
      "outputs": [],
      "source": [
        "prefix = \"write a python function to do binary search\"\n",
        "\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dai1FtyDDUjX"
      },
      "source": [
        "### Try out your own prompt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YukcUkJRDZvI"
      },
      "source": [
        "Some examples:\n",
        "* write Go program to extract ip addresses from the text file\n",
        "* write Java program that can extract pincodes from addresses\n",
        "* write a standard SQL function that strips all non-alphabet characters from the string and encodes it to utf-8"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CvKHdTHy6RIi"
      },
      "outputs": [],
      "source": [
        "prefix = \"\"\"write a python function that can do cosine similarity between two vectors,\n",
        "            named as \"calculate_cosine_similarity\" and two input arguments \"vector1\" and \"vector2\". \\\n",
        "          \"\"\"\n",
        "\n",
        "response = code_generation_model.predict(prefix=prefix, max_output_tokens=1024)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iZ0AEuFAEB1N"
      },
      "source": [
        "### Prompt templates"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LpFTrfLnFHBy"
      },
      "source": [
        "Prompt templates are useful if you have found a good way to structure your prompt that you can re-use. This can be also be helpful in limiting the open-endedness of freeform prompts. There are many ways to implement prompt templates, and below is just one example using f-strings. This way you can structure the prompts as per the expected functionality of the code."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1abvkgsZxsh3"
      },
      "outputs": [],
      "source": [
        "language = \"python\"\n",
        "prefix = f\"\"\"Write a {language} function that can input unsorted array or list and return the sorted array or list.\n",
        "             it should not use any pre-built function or library.\n",
        "              \"\"\"\n",
        "\n",
        "response = code_generation_model.predict(prefix=prefix, max_output_tokens=1024)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gznmqXU067tj"
      },
      "outputs": [],
      "source": [
        "language = \"python\"\n",
        "file_format = \"json\"\n",
        "extract_info = \"names\"\n",
        "requirements = \"\"\"\n",
        "              - the name should be start with capital letters.\n",
        "              - There should be no duplicate names in the final list.\n",
        "              \"\"\"\n",
        "\n",
        "prefix = f\"\"\"Create a {language} to parse {file_format} and extract {extract_info} with the following requirements: {requirements}.\n",
        "              \"\"\"\n",
        "\n",
        "response = code_generation_model.predict(prefix=prefix, max_output_tokens=1024)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1PhbbK7a0B1n"
      },
      "source": [
        "## Prompt Design Patterns"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k8W5Lc9O0G-3"
      },
      "source": [
        "### Problem-statement Template\n",
        "\n",
        "In the problem-statement template, you can leverage prompt template ideas and pass your specific problem-statement without focusing on the language. The language can be a separate parameter. You can also pass the input-output example to ensure that generation follows the test case. Here are examples of different languages; you can see the model's capability to generate many supported languages."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bre8loKSYtT-"
      },
      "source": [
        "#### C"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zwM_U-ch0FB6"
      },
      "outputs": [],
      "source": [
        "language = \"c\"\n",
        "problem_statement = \"find the smallest element in an unordered list\"\n",
        "\n",
        "prefix = \"write a \" + language + \" function to \" + problem_statement\n",
        "\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xQ1bw0OI1pM8"
      },
      "source": [
        "#### C++"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JiEcCW-X1y89"
      },
      "outputs": [],
      "source": [
        "language = \"cpp\"\n",
        "problem_statement = \"\"\"Sort an array in one swap whose two elements are swapped and rest are in sorted order \\\n",
        "                      for example: \\\n",
        "                      input: {1, 5, 3, 7, 9}\n",
        "                      output: {1,3,5,7,9}\n",
        "                    \"\"\"\n",
        "\n",
        "prefix = \"write a \" + language + \" function to \" + problem_statement\n",
        "\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RWkwmHlqfM_Y"
      },
      "source": [
        "#### Clojure"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eBdZdGTBF2LU"
      },
      "outputs": [],
      "source": [
        "language = \"clojure\"\n",
        "problem_statement = \"\"\"that takes a string and calculates if its palindrome or not.\n",
        "                      print the outputs with two example: 'radar' and 'happy'\n",
        "                    \"\"\"\n",
        "\n",
        "prefix = \"write a \" + language + \" function \" + problem_statement\n",
        "\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L4dafG41fRFF"
      },
      "source": [
        "#### Elixir"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OL_MDS2yJytP"
      },
      "outputs": [],
      "source": [
        "language = \"elixir\"\n",
        "problem_statement = \"\"\"print the first non-repeated character from a string.\n",
        "                      take example of 'Mississippi' and 'hello' as example.\n",
        "                    \"\"\"\n",
        "\n",
        "prefix = \"write a \" + language + \" function \" + problem_statement\n",
        "\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z5RxDUrQjG6k"
      },
      "source": [
        "#### Erlang"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DgQ313X-gLrX"
      },
      "outputs": [],
      "source": [
        "language = \"erlang\"\n",
        "problem_statement = \"\"\"reverse an array in place. Take input of array.Take input of array and output the reversed array.\n",
        "                       For example: [1,2,3,4,5] -> [5,4,3,2,1]\n",
        "                    \"\"\"\n",
        "\n",
        "prefix = \"write a \" + language + \" program \" + problem_statement\n",
        "\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JxvXnpp8kuHU"
      },
      "source": [
        "#### Fortran"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1lHXXUvajJKJ"
      },
      "outputs": [],
      "source": [
        "language = \"Fortran\"\n",
        "problem_statement = \"\"\" to remove duplicate elements from given array.\n",
        "                    \"\"\"\n",
        "\n",
        "prefix = \"write a \" + language + \" program \" + problem_statement\n",
        "\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I5Q6wW8QoACz"
      },
      "source": [
        "#### Go"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sgdIuCrpkzSA"
      },
      "outputs": [],
      "source": [
        "language = \"Go\"\n",
        "problem_statement = \"\"\"that can extract ipv4 addresses from the each line in the log file. use fmt and regexp package.\n",
        "                        input:\n",
        "                        03/22 08:51:06 INFO   :...read_physical_netif: index #0, interface VLINK1 has address 129.1.1.1, ifidx 0\n",
        "                        output:\n",
        "                        129.1.1.1\n",
        "                        \\n\\n\n",
        "                    \"\"\"\n",
        "\n",
        "prefix = \"write a \" + language + \" function \" + problem_statement\n",
        "\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RF09q_LNZl_Q"
      },
      "source": [
        "### SQL Metadata & Performance\n",
        "\n",
        "In the SQL prompt template, you can define multiple criteria like problem statement, table metadata, styling of the code, and performance expectations. Passing the table metadata is crucial since it allows the model to generate consistent code that follows the structure of the metadata. Ensure that your problem statement is very clear, concise, and contains all relevant context."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sHGu7mZ3rMCb"
      },
      "source": [
        "#### SQL"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8Q5n_EzALp0C"
      },
      "outputs": [],
      "source": [
        "problem_statement = \"\"\"\n",
        "                    You are a developer working on an e-commerce platform.\n",
        "                    The marketing team has requested a report on the total number of orders and the average order \\\n",
        "                    value for each product category for the past month.\n",
        "                    Your task is to generate a SQL queries to retrieve the total number of orders and the average order \\\n",
        "                    value for each product category for the orders placed in the:\n",
        "                    1) past month,\n",
        "                    2) given data range,\n",
        "                    3) end of each month for given year,\n",
        "                    4) christmas and new year's eve.\n",
        "                    \"\"\"\n",
        "table_metadata = \"\"\"\n",
        "                 - **Orders:**\n",
        "                    - `OrderID` (integer)\n",
        "                    - `ProductID` (integer)\n",
        "                    - `ProductName` (string)\n",
        "                    - `Category` (string)\n",
        "                    - `OrderDate` (date)\n",
        "                    - `OrderAmount` (decimal)\n",
        "                \"\"\"\n",
        "code_style = \"\"\"\n",
        "            Write a SQL query that follows best practices, is readable, and well-commented.\n",
        "             \"\"\"\n",
        "\n",
        "performance_requirement = \"\"\"\n",
        "                          Optimize the query for performance considering the potential size of the \"Orders\" table.\n",
        "                          Consider using appropriate indexing if necessary.\n",
        "                          \"\"\"\n",
        "\n",
        "prefix = f\"\"\" Solve the following: {problem_statement}. The given table metadata is : {table_metadata} .\n",
        "          Follow the following code style:{code_style} . The following performance requirement is: {performance_requirement} .\n",
        "          \"\"\"\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LIG3zF7ErOJT"
      },
      "source": [
        "#### BigQuery"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wAIoVQoCpz16"
      },
      "outputs": [],
      "source": [
        "metadata = \"\"\"\n",
        "          A table of customer data, with the following columns:\n",
        "\n",
        "          customer_id: The unique identifier for the customer.\n",
        "          first_name: The customer's first name.\n",
        "          last_name: The customer's last name.\n",
        "          email: The customer's email address.\n",
        "          phone_number: The customer's phone number.\n",
        "          country: The customer's country of residence.\n",
        "          order_history: A JSON object containing the customer's order history, including the following information for each order:\n",
        "          order_id: The unique identifier for the order.\n",
        "          order_date: The date the order was placed.\n",
        "          order_total: The total amount of the order.\n",
        "          order_items: A list of the items ordered, including the following information for each item:\n",
        "          item_id: The unique identifier for the item.\n",
        "          item_name: The name of the item.\n",
        "          item_quantity: The quantity of the item ordered.\n",
        "          item_price: The price of the item.\n",
        "\n",
        "            \"\"\"\n",
        "language = \"BigQuery\"\n",
        "problem = \"\"\"solve following queries: \\n\n",
        "            - Total number of orders placed. \\n\n",
        "            - Total amount of money spent on orders. \\n\n",
        "            - Average order value. \\n\n",
        "            - Most popular item ordered (by quantity). \\n\n",
        "            - Most recent order placed. \\n\n",
        "          \"\"\"\n",
        "additional_requirement = \"\"\"\n",
        "            - The query should be efficient and scalable, as the customer table may contain millions of rows. \\n\n",
        "            - The query should be easy to read and maintain.\n",
        "            \"\"\"\n",
        "prefix = f\"\"\"Write a {language} query to {problem}.\n",
        "          use this as the table metadata: {metadata}.\n",
        "          Here are some additional requirement for the query: {additional_requirement}.\n",
        "          Generate each query as a separate query separated with a comment.\n",
        "              \"\"\"\n",
        "response = code_generation_model.predict(prefix=prefix, max_output_tokens=2000)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rojGQweJalYN"
      },
      "source": [
        "### Code Optimization\n",
        "\n",
        "You can define your problem statement's specific optimization requirements in the code optimization prompt. The Codey models are great at following particular instructions and generating code that can meet user-specific conditions. You can experiment below with three languages and see how to give specific instructions on data structures, algorithmic complexity, and maintainability.  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TvMKMc87tVb4"
      },
      "source": [
        "#### Haskell"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "y2eBkgwFr3N6"
      },
      "outputs": [],
      "source": [
        "sample_input = \"A list of integers, e.g. [1, 2, 3, 4, 5]\"\n",
        "language = \"Haskell\"\n",
        "problem_statement = (\n",
        "    f\"a {language} program that calculates the sum of all the integers in the list.\"\n",
        ")\n",
        "additional_requirement = \"\"\"\n",
        "                      - The function should be efficient and recursive.\n",
        "                      - The function should be polymorphic, so that it can be used to sum lists of any type of number.\n",
        "                      \"\"\"\n",
        "prefix = f\"\"\"\n",
        "        Write {problem_statement}. \\n\n",
        "        Also add example use case that take {sample_input} calling the function generated.\n",
        "        Here are some additional requirement for the function: {additional_requirement}.\n",
        "        \"\"\"\n",
        "response = code_generation_model.predict(prefix=prefix, max_output_tokens=1000)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uSDxG_tfvS9h"
      },
      "source": [
        "#### Java"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sIiKTAK_tZXn"
      },
      "outputs": [],
      "source": [
        "sample_input = \"\"\" \"(1 + 2) * 3\"\n",
        "              \"\"\"\n",
        "language = \"Java\"\n",
        "problem_statement = f\"a {language} program that evaluates the mathematical expression and prints the result to the console.\"\n",
        "additional_requirement = \"\"\"\n",
        "                      - The program should handle all valid mathematical expressions, including those with parentheses, operators, and variables.\n",
        "                      \"\"\"\n",
        "prefix = f\"\"\"\n",
        "        Write {problem_statement}. \\n\n",
        "        Use {sample_input} to test the generated code.\n",
        "        Here are some additional requirement for the function: {additional_requirement}.\n",
        "        \"\"\"\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0uoq5mnJxchl"
      },
      "source": [
        "#### JavaScript"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "H-nKwp_Cw0aL"
      },
      "outputs": [],
      "source": [
        "sample_input = \"\"\"\n",
        "              A JSON object containing a list of products, each product with the following properties:\n",
        "              id: The unique identifier for the product.\n",
        "              name: The name of the product.\n",
        "              price: The price of the product.\n",
        "              quantity: The quantity of the product in stock.\n",
        "              \"\"\"\n",
        "language = \"JavaScript\"\n",
        "problem_statement = f\"\"\"a {language} function that takes the JSON object as input and returns a new JSON object containing the following properties:\n",
        "                      total_price: The total price of all the products in the list.\n",
        "                      average_price: The average price of all the products in the list.\n",
        "                      most_expensive_product: The most expensive product in the list.\n",
        "                      least_expensive_product: The least expensive product in the list.\n",
        "                      out_of_stock_products: A list of all the products that are out of stock.\n",
        "                    \"\"\"\n",
        "additional_requirement = \"\"\"\n",
        "                      - The function should be efficient and scalable, as the JSON object may contain millions of products.\n",
        "                      - The function should be easy to read and maintain.\n",
        "                      \"\"\"\n",
        "prefix = f\"\"\"\n",
        "        Write {problem_statement}. \\n\n",
        "        Also add example use case that take {sample_input} calling the function generated.\n",
        "        Here are some additional requirement for the function: {additional_requirement}.\n",
        "        \"\"\"\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6lCvDVBtbdVp"
      },
      "source": [
        "### Chain of Though\n",
        "\n",
        "Chain-of-thought (CoT) prompting is a technique for guiding large language models (LLMs) to generate code by breaking down the task into a series of intermediate natural language reasoning steps. This approach has been shown to improve the quality of generated code compared to traditional prompting methods.\n",
        "\n",
        "To use CoT prompting for code generation, you first need to provide the LLM with a natural language description of the task you want to accomplish. The LLM will then generate a chain of thought, a sequence of natural language steps describing how to solve the task. Finally, the LLM will use the chain of thought to generate the code.\n",
        "\n",
        "Here is an example of using CoT prompting to generate a C++ and Java function for specific use cases."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J_s8w6eUwb02"
      },
      "source": [
        "#### C++"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "y-85asBEJBsA"
      },
      "outputs": [],
      "source": [
        "language = \"C++\"\n",
        "sample_input = \"\"\"\n",
        "                17/06/09 20:10:41 INFO slf4j.Slf4jLogger: Slf4jLogger started\n",
        "                17/06/09 20:10:41 INFO Remoting: Starting remoting\n",
        "                17/06/09 20:10:41 INFO Remoting: Remoting started; listening on addresses :[akka.tcp://sparkExecutorActorSystem@mesos-slave-07:55904]\n",
        "                17/06/09 20:10:41 INFO util.Utils: Successfully started service 'sparkExecutorActorSystem' on port 55904.\n",
        "              \"\"\"\n",
        "additional_requirement = \"\"\"\n",
        "                      - It should not use regex to find the given line\n",
        "                      - the solution should be scalable and should scale linearly with additional data\n",
        "                      - the output should print a flag and port number both.\n",
        "                      - All the variable should be properly in scope and should be declared only once.\n",
        "                      - The variables should have scope to be called in the main() function.\n",
        "                      - The code should be easy to read and maintain\n",
        "                      - The code should have proper typehints and comments\n",
        "                      \"\"\"\n",
        "\n",
        "prefix = f\"\"\"\n",
        "        Prompt 1: What is the problem we are trying to solve?\n",
        "\n",
        "        Identify the status of the sparkExecutorActorSystem service in network log and output True or False along with the port, if True.\n",
        "\n",
        "        Prompt 2: What is the language you want to use to solve this problem?\n",
        "        {language}\n",
        "\n",
        "        Prompt 3: What are the inputs and outputs of the function?\n",
        "\n",
        "        Input: Network log\n",
        "        Output: Boolean value indicating the status of the sparkExecutorActorSystem service and the port, if True\n",
        "\n",
        "        Prompt 4: What are the steps involved in identifying the status of the sparkExecutorActorSystem service in network log?\n",
        "\n",
        "        Split the network log into lines.\n",
        "        Iterate over the lines and search for the line that contains the following string: Successfully started service 'sparkExecutorActorSystem' on port.\n",
        "        If the line is found, extract the port number and save it in the variable\n",
        "        Make sure the variables are scoped to be called in the main() function.\n",
        "        If the line is not found,\n",
        "        Return True along with the port number variable.\n",
        "        Otherwise, return False.\n",
        "        call the function passing the sample input\n",
        "        Prompt 5: What is the sample input that can be tested as a test use case?\n",
        "        {sample_input}\n",
        "\n",
        "        prompt 6: Any additional expectation from the code logic?\n",
        "        {additional_requirement}\n",
        "\n",
        "        Prompt 7: Write the code for the scenario keeping additional expectation and expected language while generation along with the test case.\n",
        "\n",
        "        \"\"\"\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xo0CoiO1M9L1"
      },
      "source": [
        "#### Java"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JDh9uOpYMf4S"
      },
      "outputs": [],
      "source": [
        "prefix = \"\"\"\n",
        "        q: What is the input to the function?\n",
        "        a: The input to the function is a string.\n",
        "\n",
        "        q: What is the output of the function?\n",
        "        a: The output of the function is a reversed string.\n",
        "\n",
        "        q: What are the steps involved in reversing a string?\n",
        "        a: 1) Iterate over the string from the back.\n",
        "            2) Add each character to a new string in reverse order.\n",
        "            3) Return the new string.\n",
        "\n",
        "        q: Write pseudocode for the function.\n",
        "        a: function reverse_string(string):\n",
        "              new_string = \"\"\n",
        "              for i in range(len(string) - 1, -1, -1):\n",
        "                  new_string += string[i]\n",
        "              return new_string\n",
        "\n",
        "        q: how would you test the function?\n",
        "        a: the input \"hello\" should return \"olleh\"\n",
        "\n",
        "        q: write java code for the function following all the question-answer pairs.\n",
        "        \"\"\"\n",
        "response = code_generation_model.predict(prefix=prefix, max_output_tokens=2048)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M6Ly_o7RcgeU"
      },
      "source": [
        "### Few-shot with User-journey and Pseudo/Starter Code\n",
        "\n",
        "In the few-shot prompt, you can also pass user-journey or pseudo/starter code examples for the code generation to adhere to specific instructions. The user journey can include sample input and output data structures as well. You can also complement that by passing some starter code so the model can follow the code generation per the structure you want. Here are some examples of different languages."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J3vT9XCorXnN"
      },
      "source": [
        "#### Kotlin"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xfH4a--xrX-Y"
      },
      "outputs": [],
      "source": [
        "user_journey = \"\"\"\n",
        "              A Kotlin developer is working on a new Android app.\n",
        "              They need to implement a feature that allows users to search for nearby restaurants.\n",
        "              \"\"\"\n",
        "sample_input = \"\"\"\n",
        "              A list of restaurants and a search query:\n",
        "              val restaurants = listOf(\n",
        "                                Restaurant(\"The Grill\", \"123 Main Street\", cuisine = \"American\"),\n",
        "                                Restaurant(\"Thai Paradise\", \"456 Elm Street\", cuisine = \"Thai\"),\n",
        "                                Restaurant(\"Little Italy\", \"789 Pine Street\", cuisine = \"Italian\"),\n",
        "                              )\n",
        "\n",
        "              val searchQuery = \"Italian\"\n",
        "\n",
        "              \"\"\"\n",
        "sample_output = \"\"\"\n",
        "          A list of restaurants that match the search query:\n",
        "          val matchingRestaurants = listOf(\n",
        "              Restaurant(\"Little Italy\", \"789 Pine Street\", cuisine = \"Italian\"),\n",
        "            )\n",
        "          \"\"\"\n",
        "language = \"Kotlin\"\n",
        "problem_statement = f\"\"\"a {language} function that takes a list of restaurants and a search query as input and returns  \\\n",
        "                        list of restaurants that match the search query. The search query can be a substring of the restaurant name, \\\n",
        "                        address, or cuisine type.\n",
        "                    \"\"\"\n",
        "additional_requirement = \"\"\"\n",
        "                     - The function should be efficient and scalable.\n",
        "                     - The function should be easy to read and maintain.\n",
        "                      \"\"\"\n",
        "prefix = f\"\"\"\n",
        "        Write {problem_statement}. \\n\n",
        "        Also add example use case that take {sample_input} and {sample_output} calling the function generated.\n",
        "        Here are some additional requirement for the function: {additional_requirement}.\n",
        "        \"\"\"\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hkf9gqfUweTY"
      },
      "source": [
        "#### Rust"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gmzqFsnOf_Cq"
      },
      "outputs": [],
      "source": [
        "real_world_case = \"\"\"You are a software engineer at a company that develops trading software.\n",
        "                     You need to write a Rust program to calculate the moving average of a stock price over a given period of time.\"\"\"\n",
        "problem_statement = \"\"\"The program should take two inputs:\n",
        "                        A vector of stock prices.\n",
        "                        The period over which to calculate the moving average.\n",
        "                        The program should output the moving average of the stock price over the given period.\n",
        "                    \"\"\"\n",
        "code_style = \"Idiomatic Rust\"\n",
        "algorithmic_complexity = \"O(n)\"\n",
        "pseudocode = \"\"\"\n",
        "              1) Initialize a variable to store the moving average.\n",
        "              2) Iterate over the vector of stock prices, adding each price to the moving average.\n",
        "              3) Divide the moving average by the period to get the average price over the given period.\n",
        "              4) Return the moving average price.\n",
        "             \"\"\"\n",
        "test_cases = \"\"\"\n",
        "            // Test case 1\n",
        "            let stock_prices = vec![100, 110, 120, 130, 140];\n",
        "            let period = 3;\n",
        "\n",
        "            let moving_average = calculate_moving_average(&stock_prices, period);\n",
        "\n",
        "            assert_eq!(moving_average, 200.0);\n",
        "\n",
        "            \"\"\"\n",
        "sample_input = \"[500, 100, 300, 450, 120]\"\n",
        "prefix = f\"\"\"Write a Rust program based on a {real_world_case} .\n",
        "             The problem statement that needs to be addressed is {problem_statement} .\n",
        "             You can use this pseudocode as an example to generate the code step by step:  {pseudocode} .\n",
        "             Add an example to call the generated function in main() {sample_input}\n",
        "             It should follow the code style pattern as {code_style} and should have {algorithmic_complexity} as algorithmic complexity.\n",
        "             Make sure that the code generated passes the following test cases: {test_cases}\n",
        "             \"\"\"\n",
        "response = code_generation_model.predict(\n",
        "    prefix=prefix, max_output_tokens=2000, temperature=0.2\n",
        ")\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GinhyCUizbDe"
      },
      "source": [
        "#### Scala"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VvKRnkyPzld6"
      },
      "outputs": [],
      "source": [
        "persona = \"\"\"You are a Scala developer working on a backend service for an e-commerce platform. \"\"\"\n",
        "goal = \"\"\"Your task is to generate Scala code for a data model representing products in the platform's catalog.\n",
        "          The product data model should include information such as product ID, name, price, and availability.\n",
        "       \"\"\"\n",
        "user_journey = \"\"\"\n",
        "              As a developer, your day-to-day tasks often involve designing data models to represent various entities in your application.\n",
        "              In this scenario, you are tasked with creating a Scala case class for the product data model and a companion object with utility methods.\n",
        "              \"\"\"\n",
        "requirements = \"\"\"\n",
        "            1. Create a Scala case class named `Product` with the following fields:\n",
        "                - `id` (String)\n",
        "                - `name` (String)\n",
        "                - `price` (Double)\n",
        "                - `available` (Boolean)\n",
        "\n",
        "            2. Implement a companion object for the `Product` case class with the following methods:\n",
        "                - `create` method that takes parameters for ID, name, price, and availability and returns an instance of the `Product` case class.\n",
        "                - `format` method that takes a `Product` instance and returns a formatted string representation of the product.\n",
        "\n",
        "            3. Ensure that the `create` method sets the availability to `true` by default if not provided.\n",
        "              \"\"\"\n",
        "code_structure = \"\"\"\n",
        "                You have been provided with a starter code structure. Your task is to complete the code to meet the above requirements. The input code structure is as follows:\n",
        "\n",
        "                ```scala\n",
        "                // Starter code\n",
        "                case class Product(id: String, name: String, price: Double, available: Boolean)\n",
        "\n",
        "                object Product {\n",
        "                  // Your generated Scala code for the companion object goes here\n",
        "                }\n",
        "\n",
        "                object Main extends App {\n",
        "                  // Your test cases go here\n",
        "                }\n",
        "                \"\"\"\n",
        "\n",
        "prefix = f\"\"\"{persona} {goal} {user_journey} {requirements} {code_structure} \"\"\"\n",
        "response = code_generation_model.predict(\n",
        "    prefix=prefix, max_output_tokens=2000, temperature=0.2\n",
        ")\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YsFg9jaE15fR"
      },
      "source": [
        "#### Shell Script"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uugt4kNs2Cjp"
      },
      "outputs": [],
      "source": [
        "persona = \"\"\"\n",
        "          Imagine you are a system administrator responsible for managing a Linux server environment.\n",
        "          Your daily tasks often involve creating shell scripts to automate various system maintenance and monitoring tasks.\n",
        "          In this scenario, you are tasked with generating a shell script to automate a common backup task.\n",
        "          \"\"\"\n",
        "user_journey = \"\"\"\n",
        "          As a system administrator, you frequently need to create backup scripts to ensure data integrity and disaster recovery.\n",
        "          Your goal is to generate a simple shell script that backs up a specified directory to a target backup location using the `rsync` command.\n",
        "              \"\"\"\n",
        "requirements = \"\"\"\n",
        "          1. Create a shell script named `backup.sh` that takes two command-line arguments:\n",
        "            - Source directory: The directory to be backed up.\n",
        "            - Target directory: The directory where the backup should be stored.\n",
        "\n",
        "          2. The script should use the `rsync` command to perform the backup. The `rsync` command should:\n",
        "            - Synchronize the contents of the source directory to the target directory.\n",
        "            - Preserve file permissions and timestamps.\n",
        "            - Display progress information during the backup.\n",
        "\n",
        "          3. Add comments to the script to explain its purpose and usage.\n",
        "              \"\"\"\n",
        "starter_code = \"\"\"\n",
        "          You have been provided with a starter code structure.\n",
        "          Your task is to complete the code to meet the above requirements.\n",
        "          The input code structure is as follows:\n",
        "\n",
        "          ```bash\n",
        "          #!/bin/bash\n",
        "\n",
        "          # Your generated Shell script code goes here\n",
        "          \"\"\"\n",
        "\n",
        "prefix = f\"\"\"{persona} {user_journey} {requirements} {starter_code} \"\"\"\n",
        "response = code_generation_model.predict(\n",
        "    prefix=prefix,\n",
        "    max_output_tokens=2000,\n",
        ")\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nrxZJs7OHuVF"
      },
      "source": [
        "#### Solidity [BlockChain]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "raMp35oEIIrw"
      },
      "outputs": [],
      "source": [
        "user_input = \"\"\"\n",
        "         - The address of the user withdrawing the tokens\n",
        "         - The amount of tokens being withdrawn\n",
        "         \"\"\"\n",
        "return_output = \"\"\"\n",
        "         - A boolean value indicating whether the withdrawal was successful\n",
        "         \"\"\"\n",
        "requirements = \"\"\"\n",
        "          - The code should be written in Solidity using the latest best practices.\n",
        "          - algorithm should be O(1) time complexity.\n",
        "          \"\"\"\n",
        "\n",
        "\n",
        "prefix = f\"\"\"\n",
        "         Generate a Solidity function called withdraw() that allows users to withdraw tokens from a decentralized exchange (DEX).\n",
        "         The function should take the following inputs: {user_input} and should return: {return_output}.\n",
        "         The function should also meet the following requirements: {requirements}\n",
        "         \"\"\"\n",
        "response = code_generation_model.predict(\n",
        "    prefix=prefix, max_output_tokens=2000, temperature=0.2\n",
        ")\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ENUSlJeksY9F"
      },
      "source": [
        "#### Verilog"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8dfaF8eNsat0"
      },
      "outputs": [],
      "source": [
        "prefix = \"\"\"\n",
        "        Generate Verilog code for a 3-bit adder circuit that performs addition of two 3-bit numbers using only D flip-flops.\n",
        "        The circuit should have the following inputs:\n",
        "        a[2:0]\n",
        "        b[2:0]\n",
        "        The circuit should have the following outputs:\n",
        "        sum[2:0]\n",
        "        carry\n",
        "        The circuit should implement the following logic:\n",
        "        The circuit should add the two 3-bit numbers and store the result in the sum output. The carry output should be set to 1 if the addition results in a carry-out, and 0 otherwise.\n",
        "        Constraints:\n",
        "        The circuit must use only D flip-flops.\n",
        "        \"\"\"\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xmjVO4pCTorG"
      },
      "source": [
        "### DevOps Templates\n",
        "\n",
        "Codey is also capable of helping you generate DevOps-related code samples. You can generate Docker, Jenkins, GitLab CI, Prometheus Configurations, and many more such code blocks with the following templates."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KN0EflgHP75p"
      },
      "source": [
        "#### Docker"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_BpavsvSP-r9"
      },
      "outputs": [],
      "source": [
        "prefix = \"\"\"\n",
        "        Generate a Dockerfile for a Python application that:\n",
        "          * Builds the image from a python:latest base image\n",
        "          * Exposes the following ports: 8000\n",
        "          * Installs the following dependencies: pip install flask\n",
        "          * Sets the working directory to /app\n",
        "          * Copies the following files to the image: app.py requirements.txt ./\n",
        "          * Runs the following command on startup: flask run --host=0.0.0.0\n",
        "        \"\"\"\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E36RX5VOTsXj"
      },
      "source": [
        "#### Docker Compose"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Dn5JbcwRQKw6"
      },
      "outputs": [],
      "source": [
        "prefix = \"\"\"\n",
        "        Generate a Compose file for the following services: web\n",
        "          * Define the following networks: default\n",
        "          * Define the following volumes: ./app:/app\n",
        "          * Define the following environments: FLASK_APP=app.py\n",
        "          * Define the following links: none\n",
        "          * Define the following depends_on relationships: none\n",
        "        \"\"\"\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qPO7MT6cTvMB"
      },
      "source": [
        "#### Jenkins"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "784INw25SnAP"
      },
      "outputs": [],
      "source": [
        "prefix = \"\"\"\n",
        "        Objective: Generate a Jenkinsfile for a parametrized pipeline for a Java project.\n",
        "        Instructions:\n",
        "        Allow the user to input parameters like \"Environment\" and \"Feature Toggle.\"\n",
        "        Use these parameters in the build and test stages.\n",
        "        Provide default values for parameters.\n",
        "        \"\"\"\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_vqGes_oTxAq"
      },
      "source": [
        "#### GitLab CI"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "brxDiPmeTyiy"
      },
      "outputs": [],
      "source": [
        "prefix = \"\"\"\n",
        "        Generate GitLab CI YAML configuration for a Node.js project.\n",
        "        Instructions:\n",
        "          - Assume the project uses Node.js and has unit tests.\n",
        "          - Include stages for \"Build,\" \"Test,\" and \"Deploy.\"\n",
        "          - Specify Node.js version and test script.\n",
        "          - Use GitLab CI variables for sensitive information.\n",
        "        \"\"\"\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AZ_wYBuIUDTP"
      },
      "source": [
        "#### Prometheus Configurations"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tVcJWpPxUF2Q"
      },
      "outputs": [],
      "source": [
        "prefix = \"\"\"\n",
        "         Generate YAML configurations for Prometheus to monitor a containerized application.\n",
        "          Instructions:\n",
        "            - Specify the job for scraping metrics.\n",
        "            - Include targets, labels, and metric relabeling as needed.\n",
        "            - Set up alerting rules for key metrics.\n",
        "        \"\"\"\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SeneD9LlrpaN"
      },
      "source": [
        "### Web Templates\n",
        "\n",
        "You can also generate HTML and CSS codes based on prompts. In the below example, you can see how you can mention various details of a simple HTML page and its characteristics."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HfB5_zSersVw"
      },
      "source": [
        "#### HTML"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Jj_d4IcLXzcZ"
      },
      "outputs": [],
      "source": [
        "prefix = \"\"\"write a html code for a simple page:\n",
        "            - Has a button \"click me\" and it shows how many time user has hit that button as its counter.\n",
        "            - Add style element that has page header as \"My Page Counter Demo\" in brown color\n",
        "            - Everything should be displayed as 'center'.\n",
        "            - The counter button should be blue by default and when clicked it should be red.\n",
        "            - The counter value should be in green color.\n",
        "            - The bottom of the page should display this message \"Codey Generated this page\" in bold and big font.\n",
        "\"\"\"\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VPPXyk6hu3kI"
      },
      "outputs": [],
      "source": [
        "prefix = \"\"\"\n",
        "        Generate a responsive HTML code for a landing page of a new e-commerce website that sells clothes. The landing page should have the following sections:\n",
        "         - A header with a logo, a navigation bar, and a search bar.\n",
        "         - A hero section with a large image of a model wearing clothes from the website and a call to action button.\n",
        "         - A featured products section with a grid of images of the best-selling products on the website.\n",
        "         - A testimonial section with quotes from satisfied customers.\n",
        "         - A footer with contact information and social media links.\n",
        "       \"\"\"\n",
        "response = code_generation_model.predict(prefix=prefix)\n",
        "\n",
        "print(response.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0qRKW7UrPCxh"
      },
      "source": [
        "## Best Practices"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1BRWXLPXPN4v"
      },
      "source": [
        "### How to write effective code generation prompts\n",
        "\n",
        "When writing code generation prompts, it is important to be as clear and specific as possible. The more information you can provide to the model, the better it will be able to understand your intent and generate the desired code.\n",
        "\n",
        "Here are some tips for writing effective code generation prompts:\n",
        "\n",
        "* Start with a clear and concise description of the task you want the model to perform. For example, instead of saying \"Generate a function to sort a list of numbers,\" you could say \"Generate a Python function to sort a list of integers in ascending order.\"\n",
        "\n",
        "* Provide examples of the desired input and output. This will help the model to understand the format of the data and the expected output. For example, you could provide a list of unsorted numbers and the corresponding sorted list.\n",
        "\n",
        "* Use natural language to describe the task. The model is trained on a massive dataset of text and code, so it is able to understand natural language prompts. For example, you could say \"Generate a function to reverse a string in Python.\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aKMdcftDPZq4"
      },
      "source": [
        "### How to choose the right temperature and max output tokens\n",
        "\n",
        "The temperature parameter controls the randomness of the model's output. A higher temperature will result in more creative and varied output, but it may also be less accurate. A lower temperature will result in more accurate output, but it may also be less creative.\n",
        "\n",
        "The max output tokens parameter controls the maximum number of tokens that the model will generate. This is useful for limiting the length of the output code or preventing the model from generating infinite loops.\n",
        "\n",
        "Here are some tips for choosing the right temperature and max output tokens:\n",
        "\n",
        "* Use a lower temperature for tasks that require high accuracy, such as generating code for machine learning models.\n",
        "\n",
        "* Use a higher temperature for tasks that require creativity, such as generating code for web applications or games.\n",
        "\n",
        "* Use a max output tokens parameter to limit the length of the output code or prevent the model from generating infinite loops.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OjVR5n4-PgkU"
      },
      "source": [
        "How to interpret and use code generation suggestions\n",
        "\n",
        "The code generation suggestions generated by the model are not always perfect. It is important to review the generated code carefully and make any necessary changes.\n",
        "\n",
        "Here are some tips for interpreting and using code generation suggestions:\n",
        "\n",
        "* Check the output code for any syntax errors.\n",
        "* Make sure that the output code is consistent with your coding standards.\n",
        "* Test the output code to make sure that it works as expected."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UxEG_Ui8PnE_"
      },
      "source": [
        "### How to avoid common code generation pitfalls\n",
        "\n",
        "Here are some common code generation pitfalls to avoid:\n",
        "\n",
        "* Using ambiguous or unclear prompts. The more specific you can be in your prompts, the better the model will be able to understand your intent and generate the desired code.\n",
        "* Using too high of a temperature. A higher temperature can lead to less accurate and more creative output. It is important to choose the right temperature for the task you are trying to perform.\n",
        "* Not reviewing the generated code carefully. The generated code is not always perfect. It is important to review the generated code carefully and make any necessary changes.\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "name": "code_generation.ipynb",
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}