Eval_Starcoder.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "L4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "!pip install datasets"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1jUkmrJoAp2C",
        "outputId": "c80cf94f-b0f6-4c64-f7df-c18d1b19b2a0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting datasets\n",
            "  Downloading datasets-2.19.2-py3-none-any.whl (542 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m542.1/542.1 kB\u001b[0m \u001b[31m12.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from datasets) (3.14.0)\n",
            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from datasets) (1.25.2)\n",
            "Requirement already satisfied: pyarrow>=12.0.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (14.0.2)\n",
            "Requirement already satisfied: pyarrow-hotfix in /usr/local/lib/python3.10/dist-packages (from datasets) (0.6)\n",
            "Collecting dill<0.3.9,>=0.3.0 (from datasets)\n",
            "  Downloading dill-0.3.8-py3-none-any.whl (116 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m16.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from datasets) (2.0.3)\n",
            "Collecting requests>=2.32.1 (from datasets)\n",
            "  Downloading requests-2.32.3-py3-none-any.whl (64 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m64.9/64.9 kB\u001b[0m \u001b[31m10.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: tqdm>=4.62.1 in /usr/local/lib/python3.10/dist-packages (from datasets) (4.66.4)\n",
            "Collecting xxhash (from datasets)\n",
            "  Downloading xxhash-3.4.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (194 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m194.1/194.1 kB\u001b[0m \u001b[31m25.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting multiprocess (from datasets)\n",
            "  Downloading multiprocess-0.70.16-py310-none-any.whl (134 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m134.8/134.8 kB\u001b[0m \u001b[31m20.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: fsspec[http]<=2024.3.1,>=2023.1.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (2023.6.0)\n",
            "Requirement already satisfied: aiohttp in /usr/local/lib/python3.10/dist-packages (from datasets) (3.9.5)\n",
            "Requirement already satisfied: huggingface-hub>=0.21.2 in /usr/local/lib/python3.10/dist-packages (from datasets) (0.23.2)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from datasets) (24.0)\n",
            "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.10/dist-packages (from datasets) (6.0.1)\n",
            "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.3.1)\n",
            "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (23.2.0)\n",
            "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.4.1)\n",
            "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (6.0.5)\n",
            "Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.9.4)\n",
            "Requirement already satisfied: async-timeout<5.0,>=4.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (4.0.3)\n",
            "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub>=0.21.2->datasets) (4.12.1)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.1->datasets) (3.3.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.1->datasets) (3.7)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.1->datasets) (2.0.7)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.1->datasets) (2024.6.2)\n",
            "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2023.4)\n",
            "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2024.1)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas->datasets) (1.16.0)\n",
            "Installing collected packages: xxhash, requests, dill, multiprocess, datasets\n",
            "  Attempting uninstall: requests\n",
            "    Found existing installation: requests 2.31.0\n",
            "    Uninstalling requests-2.31.0:\n",
            "      Successfully uninstalled requests-2.31.0\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.31.0, but you have requests 2.32.3 which is incompatible.\u001b[0m\u001b[31m\n",
            "\u001b[0mSuccessfully installed datasets-2.19.2 dill-0.3.8 multiprocess-0.70.16 requests-2.32.3 xxhash-3.4.1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_Je202BFI-Wy",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "f3ed727a-5242-42b5-cbc0-36f139c7945d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Setting `pad_token_id` to `eos_token_id`:0 for open-end generation.\n",
            "Setting `pad_token_id` to `eos_token_id`:0 for open-end generation.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Prompt: from typing import List\n",
            "\n",
            "\n",
            "def has_close_elements(numbers: List[float], threshold: float) -> bool:\n",
            "    \"\"\" Check if in given list of numbers, are any two numbers closer to each other than\n",
            "    given threshold.\n",
            "    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n",
            "    False\n",
            "    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n",
            "    True\n",
            "    \"\"\"\n",
            "\n",
            "Expected Output:     for idx, elem in enumerate(numbers):\n",
            "        for idx2, elem2 in enumerate(numbers):\n",
            "            if idx != idx2:\n",
            "                distance = abs(elem - elem2)\n",
            "                if distance < threshold:\n",
            "                    return True\n",
            "\n",
            "    return False\n",
            "\n",
            "Generated Output: from typing import List\n",
            "\n",
            "\n",
            "def has_close_elements(numbers: List[float], threshold: float) -> bool:\n",
            "    \"\"\" Check if in given list of numbers, are any two numbers closer to each other than\n",
            "    given threshold.\n",
            "    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n",
            "    False\n",
            "    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n",
            "    True\n",
            "    \"\"\"\n",
            "\n",
            "def has_close_elements(numbers: List[float], threshold: float) -> bool:\n",
            "    \"\"\" Check if in given list of numbers, are any two numbers closer to each other than\n",
            "    given threshold.\n",
            "    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n",
            "    False\n",
            "    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n",
            "    True\n",
            "    \"\"\"\n",
            "    for i in range(len(numbers)):\n",
            "        for j in range(i + 1, len(numbers)):\n",
            "            if abs(numbers[i] - numbers[j]) < threshold:\n",
            "                return True\n",
            "    return False\n",
            "\n",
            "def has_close_elements(numbers: List[float], threshold: float) -> bool:\n",
            "    \"\"\" Check if in given list of numbers, are any two numbers closer to each other than\n",
            "    given threshold.\n",
            "    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n",
            "    False\n",
            "    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n",
            "    True\n",
            "    \"\"\"\n",
            "    for i in range(len(numbers)):\n",
            "        for j in range(i + 1, len(numbers)):\n",
            "            if abs(numbers[i] - numbers[j]) < threshold:\n",
            "                return True\n",
            "    return False\n",
            "\n",
            "def has_close_elements(numbers: List[float], threshold: float) -> bool:\n",
            "    \"\"\" Check if in given list of numbers, are any two numbers closer to each other than\n",
            "    given threshold.\n",
            "    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n",
            "    False\n",
            "    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n",
            "    True\n",
            "    \"\"\"\n",
            "    for i in range(len(numbers)):\n",
            "        for j in range(i + 1, len(numbers)):\n",
            "            if abs(numbers[i] - numbers[j]) < threshold:\n",
            "                return True\n",
            "    return False\n",
            "\n",
            "def has_close_elements(numbers: List[float], threshold: float) -> bool:\n",
            "    \"\"\" Check if in given list of numbers, are any two numbers closer to each other than\n",
            "    given threshold.\n",
            "    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n",
            "    False\n",
            "    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n",
            "    True\n",
            "    \"\"\"\n",
            "    for i in range(len(numbers)):\n",
            "        for j in range(i + 1, len(numbers)):\n",
            "            if abs(numbers[i] - numbers[j]) < threshold:\n",
            "                return True\n",
            "    return False\n",
            "\n",
            "def has_close_elements(numbers: List[float], threshold: float) -> bool:\n",
            "    \"\"\" Check if in given list of numbers, are any two numbers closer to each other than\n",
            "    given threshold.\n",
            "    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n",
            "    False\n",
            "    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n",
            "    True\n",
            "    \"\"\"\n",
            "    for i in range(len(numbers)):\n",
            "        for j in range(i + 1, len(numbers)):\n",
            "            if abs(numbers[i] - numbers[j]) < threshold:\n",
            "                return True\n",
            "    return False\n",
            "\n",
            "def has_close_elements(numbers: List[float], threshold: float) -> bool:\n",
            "    \"\"\" Check if in given list of numbers, are any two numbers closer to each other than\n",
            "----------------------------------------------------\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Setting `pad_token_id` to `eos_token_id`:0 for open-end generation.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Prompt: from typing import List\n",
            "\n",
            "\n",
            "def separate_paren_groups(paren_string: str) -> List[str]:\n",
            "    \"\"\" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to\n",
            "    separate those group into separate strings and return the list of those.\n",
            "    Separate groups are balanced (each open brace is properly closed) and not nested within each other\n",
            "    Ignore any spaces in the input string.\n",
            "    >>> separate_paren_groups('( ) (( )) (( )( ))')\n",
            "    ['()', '(())', '(()())']\n",
            "    \"\"\"\n",
            "\n",
            "Expected Output:     result = []\n",
            "    current_string = []\n",
            "    current_depth = 0\n",
            "\n",
            "    for c in paren_string:\n",
            "        if c == '(':\n",
            "            current_depth += 1\n",
            "            current_string.append(c)\n",
            "        elif c == ')':\n",
            "            current_depth -= 1\n",
            "            current_string.append(c)\n",
            "\n",
            "            if current_depth == 0:\n",
            "                result.append(''.join(current_string))\n",
            "                current_string.clear()\n",
            "\n",
            "    return result\n",
            "\n",
            "Generated Output: from typing import List\n",
            "\n",
            "\n",
            "def separate_paren_groups(paren_string: str) -> List[str]:\n",
            "    \"\"\" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to\n",
            "    separate those group into separate strings and return the list of those.\n",
            "    Separate groups are balanced (each open brace is properly closed) and not nested within each other\n",
            "    Ignore any spaces in the input string.\n",
            "    >>> separate_paren_groups('( ) (( )) (( )( ))')\n",
            "    ['()', '(())', '(()())']\n",
            "    \"\"\"\n",
            "\n",
            "def separate_paren_groups(paren_string: str) -> List[str]:\n",
            "    \"\"\" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to\n",
            "    separate those group into separate strings and return the list of those.\n",
            "    Separate groups are balanced (each open brace is properly closed) and not nested within each other\n",
            "    Ignore any spaces in the input string.\n",
            "    >>> separate_paren_groups('( ) (( )) (( )( ))')\n",
            "    ['()', '(())', '(()())']\n",
            "    \"\"\"\n",
            "    # TODO: Implement this function\n",
            "    pass\n",
            "\n",
            "def separate_paren_groups(paren_string: str) -> List[str]:\n",
            "    \"\"\" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to\n",
            "    separate those group into separate strings and return the list of those.\n",
            "    Separate groups are balanced (each open brace is properly closed) and not nested within each other\n",
            "    Ignore any spaces in the input string.\n",
            "    >>> separate_paren_groups('( ) (( )) (( )( ))')\n",
            "    ['()', '(())', '(()())']\n",
            "    \"\"\"\n",
            "    # TODO: Implement this function\n",
            "    pass\n",
            "\n",
            "def separate_paren_groups(paren_string: str) -> List[str]:\n",
            "    \"\"\" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to\n",
            "    separate those group into separate strings and return the list of those.\n",
            "    Separate groups are balanced (each open brace is properly closed) and not nested within each other\n",
            "    Ignore any spaces in the input string.\n",
            "    >>> separate_paren_groups('( ) (( )) (( )( ))')\n",
            "    ['()', '(())', '(()())']\n",
            "    \"\"\"\n",
            "    # TODO: Implement this function\n",
            "    pass\n",
            "\n",
            "def separate_paren_groups(paren_string: str) -> List[str]:\n",
            "    \"\"\" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to\n",
            "    separate those group into separate strings and return the list of those.\n",
            "    Separate groups are balanced (each open brace is properly closed) and not nested within each other\n",
            "    Ignore any spaces in the input string.\n",
            "    >>> separate_paren_groups('( ) (( )) (( )( ))')\n",
            "    ['()', '(())', '(()())']\n",
            "    \"\"\"\n",
            "    # TODO: Implement this function\n",
            "    pass\n",
            "\n",
            "def separate_paren_groups(paren_string: str) -> List[str]:\n",
            "    \"\"\" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to\n",
            "    separate those group into separate strings and return the list of those.\n",
            "    Separate groups are balanced (each open brace is properly closed) and not nested within each other\n",
            "    Ignore any spaces in the input string.\n",
            "    >>> separate_paren_groups('( ) (( )) (( )( ))')\n",
            "    ['()', '(())', '(()())']\n",
            "    \"\"\"\n",
            "    # TODO: Implement this function\n",
            "    pass\n",
            "\n",
            "def separate_paren_groups(paren_string: str) -> List[str]:\n",
            "    \"\"\" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to\n",
            "    separate those group into separate strings and return the list of those.\n",
            "    Separate groups are balanced (each open brace is properly closed) and not nested within each other\n",
            "    Ignore any spaces in the input string.\n",
            "    >>> separate_paren_groups('( ) (( )) (( )( ))')\n",
            "    ['()', '(())', '(()())']\n",
            "    \"\"\"\n",
            "    # TODO: Implement this function\n",
            "    pass\n",
            "\n",
            "def separate_paren_groups(paren_string: str) -> List[str]:\n",
            "    \"\"\" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to\n",
            "    separate those group into separate strings and return the list of those.\n",
            "    Separate groups are balanced (each open brace is properly closed) and not nested within each other\n",
            "    Ignore any spaces in the input string.\n",
            "    >>> separate_paren_groups('( ) (( )) (( )( ))')\n",
            "    ['()', '(())', '(()())']\n",
            "    \"\"\"\n",
            "    # TODO: Implement this function\n",
            "    pass\n",
            "\n",
            "def separate_paren_groups(paren_string: str) -> List[str]:\n",
            "    \"\"\" Input to this function is a string\n",
            "----------------------------------------------------\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Setting `pad_token_id` to `eos_token_id`:0 for open-end generation.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Prompt: \n",
            "\n",
            "def truncate_number(number: float) -> float:\n",
            "    \"\"\" Given a positive floating point number, it can be decomposed into\n",
            "    and integer part (largest integer smaller than given number) and decimals\n",
            "    (leftover part always smaller than 1).\n",
            "\n",
            "    Return the decimal part of the number.\n",
            "    >>> truncate_number(3.5)\n",
            "    0.5\n",
            "    \"\"\"\n",
            "\n",
            "Expected Output:     return number % 1.0\n",
            "\n",
            "Generated Output: \n",
            "\n",
            "def truncate_number(number: float) -> float:\n",
            "    \"\"\" Given a positive floating point number, it can be decomposed into\n",
            "    and integer part (largest integer smaller than given number) and decimals\n",
            "    (leftover part always smaller than 1).\n",
            "\n",
            "    Return the decimal part of the number.\n",
            "    >>> truncate_number(3.5)\n",
            "    0.5\n",
            "    \"\"\"\n",
            "\n",
            "def truncate_number(number: float) -> float:\n",
            "    \"\"\" Given a positive floating point number, it can be decomposed into\n",
            "    and integer part (largest integer smaller than given number) and decimals\n",
            "    (leftover part always smaller than 1).\n",
            "\n",
            "    Return the decimal part of the number.\n",
            "    >>> truncate_number(3.5)\n",
            "    0.5\n",
            "    \"\"\"\n",
            "    return number - int(number)\n",
            "\n",
            "def truncate_number(number: float) -> float:\n",
            "    \"\"\" Given a positive floating point number, it can be decomposed into\n",
            "    and integer part (largest integer smaller than given number) and decimals\n",
            "    (leftover part always smaller than 1).\n",
            "\n",
            "    Return the decimal part of the number.\n",
            "    >>> truncate_number(3.5)\n",
            "    0.5\n",
            "    \"\"\"\n",
            "    return number - int(number)\n",
            "\n",
            "def truncate_number(number: float) -> float:\n",
            "    \"\"\" Given a positive floating point number, it can be decomposed into\n",
            "    and integer part (largest integer smaller than given number) and decimals\n",
            "    (leftover part always smaller than 1).\n",
            "\n",
            "    Return the decimal part of the number.\n",
            "    >>> truncate_number(3.5)\n",
            "    0.5\n",
            "    \"\"\"\n",
            "    return number - int(number)\n",
            "\n",
            "def truncate_number(number: float) -> float:\n",
            "    \"\"\" Given a positive floating point number, it can be decomposed into\n",
            "    and integer part (largest integer smaller than given number) and decimals\n",
            "    (leftover part always smaller than 1).\n",
            "\n",
            "    Return the decimal part of the number.\n",
            "    >>> truncate_number(3.5)\n",
            "    0.5\n",
            "    \"\"\"\n",
            "    return number - int(number)\n",
            "\n",
            "def truncate_number(number: float) -> float:\n",
            "    \"\"\" Given a positive floating point number, it can be decomposed into\n",
            "    and integer part (largest integer smaller than given number) and decimals\n",
            "    (leftover part always smaller than 1).\n",
            "\n",
            "    Return the decimal part of the number.\n",
            "    >>> truncate_number(3.5)\n",
            "    0.5\n",
            "    \"\"\"\n",
            "    return number - int(number)\n",
            "\n",
            "def truncate_number(number: float) -> float:\n",
            "    \"\"\" Given a positive floating point number, it can be decomposed into\n",
            "    and integer part (largest integer smaller than given number) and decimals\n",
            "    (leftover part always smaller than 1).\n",
            "\n",
            "    Return the decimal part of the number.\n",
            "    >>> truncate_number(3.5)\n",
            "    0.5\n",
            "    \"\"\"\n",
            "    return number - int(number)\n",
            "\n",
            "def truncate_number(number: float) -> float:\n",
            "    \"\"\" Given a positive floating point number, it can be decomposed into\n",
            "    and integer part (largest integer smaller than given number) and decimals\n",
            "    (leftover part always smaller than 1).\n",
            "\n",
            "    Return the decimal part of the number.\n",
            "    >>> truncate_number(3.5)\n",
            "    0.5\n",
            "    \"\"\"\n",
            "    return number - int(number)\n",
            "\n",
            "def truncate_number(number: float) -> float:\n",
            "    \"\"\" Given a positive floating point number, it can be decomposed into\n",
            "    and integer part (largest integer smaller than given number) and decimals\n",
            "    (leftover part always smaller than 1).\n",
            "\n",
            "    Return the decimal part of the number.\n",
            "    >>> truncate_number(3.5)\n",
            "    0.5\n",
            "    \"\"\"\n",
            "    return number - int(number)\n",
            "\n",
            "def truncate_number(number: float) -> float:\n",
            "    \"\"\" Given a positive floating point number, it can be decomposed into\n",
            "    and integer part (largest integer smaller than given number) and decimals\n",
            "    (leftover part always smaller than 1).\n",
            "\n",
            "    Return the decimal part of the number.\n",
            "    >>> truncate_number(3.5)\n",
            "    0.5\n",
            "    \"\"\"\n",
            "    return number - int(number)\n",
            "\n",
            "def truncate_number(number: float) -> float:\n",
            "    \"\"\" Given a positive floating point number, it can be decomposed into\n",
            "    and integer part (largest integer smaller than given number) and decimals\n",
            "    (leftover part always smaller than 1).\n",
            "\n",
            "    Return the decimal part of the number.\n",
            "    >>> truncate_number(3.5)\n",
            "    0.5\n",
            "    \"\"\"\n",
            "    return number - int(number)\n",
            "\n",
            "def truncate_number(number: float) -> float:\n",
            "    \"\"\" Given a positive floating point number, it can be decomposed into\n",
            "----------------------------------------------------\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Setting `pad_token_id` to `eos_token_id`:0 for open-end generation.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Prompt: from typing import List\n",
            "\n",
            "\n",
            "def below_zero(operations: List[int]) -> bool:\n",
            "    \"\"\" You're given a list of deposit and withdrawal operations on a bank account that starts with\n",
            "    zero balance. Your task is to detect if at any point the balance of account fallls below zero, and\n",
            "    at that point function should return True. Otherwise it should return False.\n",
            "    >>> below_zero([1, 2, 3])\n",
            "    False\n",
            "    >>> below_zero([1, 2, -4, 5])\n",
            "    True\n",
            "    \"\"\"\n",
            "\n",
            "Expected Output:     balance = 0\n",
            "\n",
            "    for op in operations:\n",
            "        balance += op\n",
            "        if balance < 0:\n",
            "            return True\n",
            "\n",
            "    return False\n",
            "\n",
            "Generated Output: from typing import List\n",
            "\n",
            "\n",
            "def below_zero(operations: List[int]) -> bool:\n",
            "    \"\"\" You're given a list of deposit and withdrawal operations on a bank account that starts with\n",
            "    zero balance. Your task is to detect if at any point the balance of account fallls below zero, and\n",
            "    at that point function should return True. Otherwise it should return False.\n",
            "    >>> below_zero([1, 2, 3])\n",
            "    False\n",
            "    >>> below_zero([1, 2, -4, 5])\n",
            "    True\n",
            "    \"\"\"\n",
            "/python/001_010/007_reverse_integer.py\n",
            "\"\"\"\n",
            "Given a 32-bit signed integer, reverse digits of an integer.\n",
            "\n",
            "Example 1:\n",
            "\n",
            "Input: 123\n",
            "Output: 321\n",
            "Example 2:\n",
            "\n",
            "Input: -123\n",
            "Output: -321\n",
            "Example 3:\n",
            "\n",
            "Input: 120\n",
            "Output: 21\n",
            "Note:\n",
            "Assume we are dealing with an environment which could only store integers within the 32-bit signed\n",
            "integer range: [−231,  231 − 1]. For the purpose of this problem, assume that your function returns 0\n",
            "when the reversed integer overflows.\n",
            "\"\"\"\n",
            "\n",
            "\n",
            "def reverse(x: int) -> int:\n",
            "    \"\"\"\n",
            "    >>> reverse(123)\n",
            "    321\n",
            "    >>> reverse(-123)\n",
            "    -321\n",
            "    >>> reverse(120)\n",
            "    21\n",
            "    >>> reverse(1534236469)\n",
            "    0\n",
            "    \"\"\"\n",
            "    if x < 0:\n",
            "        return -reverse(-x)\n",
            "    else:\n",
            "        return int(str(x)[::-1])\n",
            "\n",
            "\n",
            "if __name__ == '__main__':\n",
            "    import doctest\n",
            "\n",
            "    doctest.testmod()\n",
            "/python/001_010/009_palindrome_number.py\n",
            "\"\"\"\n",
            "Determine whether an integer is a palindrome. An integer is a palindrome when it reads the same\n",
            "backward as forward.\n",
            "\n",
            "Example 1:\n",
            "\n",
            "Input: 121\n",
            "Output: true\n",
            "Example 2:\n",
            "\n",
            "Input: -121\n",
            "Output: false\n",
            "Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it\n",
            "is not a palindrome.\n",
            "Example 3:\n",
            "\n",
            "Input: 10\n",
            "Output: false\n",
            "Explanation: Reads 01 from right to left. Therefore it is not a palindrome.\n",
            "Follow up:\n",
            "\n",
            "Coud you solve it without converting the integer to a string?\n",
            "\"\"\"\n",
            "\n",
            "\n",
            "def is_palindrome(x: int) -> bool:\n",
            "    \"\"\"\n",
            "    >>> is_palindrome(121)\n",
            "    True\n",
            "    >>> is_palindrome(-121)\n",
            "    False\n",
            "    >>> is_palindrome(10)\n",
            "    False\n",
            "    >>> is_palindrome(1534236469)\n",
            "    True\n",
            "    \"\"\"\n",
            "    if x < 0:\n",
            "        return False\n",
            "    elif x == 0:\n",
            "        return True\n",
            "    else:\n",
            "        return x == int(str(x)[::-1])\n",
            "\n",
            "\n",
            "if __name__ == '__main__':\n",
            "    import doctest\n",
            "\n",
            "    doctest.testmod()\n",
            "/python/011_020/015_3sum.py\n",
            "\"\"\"\n",
            "Given an array nums of n integers, are there elements a, b, c in nums such that a + b + c = 0?\n",
            "Find all unique triplets in the array which gives the sum of zero.\n",
            "\n",
            "Note:\n",
            "\n",
            "The solution set must not contain duplicate triplets.\n",
            "\n",
            "Example:\n",
            "\n",
            "Given array nums = [-1, 0, 1, 2, -1, -4],\n",
            "\n",
            "A solution set is:\n",
            "[\n",
            "  [-1, 0, 1],\n",
            "  [-1, -1, 2]\n",
            "]\n",
            "\"\"\"\n",
            "from typing import List\n",
            "\n",
            "\n",
            "def three_sum(nums: List[int]) -> List[List[int]]:\n",
            "    \"\"\"\n",
            "    >>> three_sum([-1, 0, 1, 2, -1, -4])\n",
            "    [[-1, -1, 2], [-1, 0, 1]]\n",
            "    \"\"\"\n",
            "    nums.sort()\n",
            "    result = []\n",
            "    for i in range(len(nums) - 2):\n",
            "        if i > 0 and nums[i] == nums[i - 1]:\n",
            "            continue\n",
            "        left = i + 1\n",
            "        right = len(nums) - 1\n",
            "        while left <\n",
            "----------------------------------------------------\n",
            "Prompt: from typing import List\n",
            "\n",
            "\n",
            "def mean_absolute_deviation(numbers: List[float]) -> float:\n",
            "    \"\"\" For a given list of input numbers, calculate Mean Absolute Deviation\n",
            "    around the mean of this dataset.\n",
            "    Mean Absolute Deviation is the average absolute difference between each\n",
            "    element and a centerpoint (mean in this case):\n",
            "    MAD = average | x - x_mean |\n",
            "    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])\n",
            "    1.0\n",
            "    \"\"\"\n",
            "\n",
            "Expected Output:     mean = sum(numbers) / len(numbers)\n",
            "    return sum(abs(x - mean) for x in numbers) / len(numbers)\n",
            "\n",
            "Generated Output: from typing import List\n",
            "\n",
            "\n",
            "def mean_absolute_deviation(numbers: List[float]) -> float:\n",
            "    \"\"\" For a given list of input numbers, calculate Mean Absolute Deviation\n",
            "    around the mean of this dataset.\n",
            "    Mean Absolute Deviation is the average absolute difference between each\n",
            "    element and a centerpoint (mean in this case):\n",
            "    MAD = average | x - x_mean |\n",
            "    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])\n",
            "    1.0\n",
            "    \"\"\"\n",
            "\n",
            "def median_absolute_deviation(numbers: List[float]) -> float:\n",
            "    \"\"\" For a given list of input numbers, calculate Median Absolute Deviation\n",
            "    around the median of this dataset.\n",
            "    Median Absolute Deviation is the average absolute difference between each\n",
            "    element and a centerpoint (median in this case):\n",
            "    MAD = average | x - x_median |\n",
            "    >>> median_absolute_deviation([1.0, 2.0, 3.0, 4.0])\n",
            "    1.0\n",
            "    \"\"\"\n",
            "\n",
            "def standard_deviation(numbers: List[float]) -> float:\n",
            "    \"\"\" For a given list of input numbers, calculate Standard Deviation\n",
            "    around the mean of this dataset.\n",
            "    Standard Deviation is the square root of the average of the squared\n",
            "    differences from the mean:\n",
            "    SD = sqrt(average (x - x_mean)^2)\n",
            "    >>> standard_deviation([1.0, 2.0, 3.0, 4.0])\n",
            "    1.0\n",
            "    \"\"\"\n",
            "\n",
            "def variance(numbers: List[float]) -> float:\n",
            "    \"\"\" For a given list of input numbers, calculate Variance\n",
            "    around the mean of this dataset.\n",
            "    Variance is the average of the squared differences from the mean:\n",
            "    Var = average (x - x_mean)^2\n",
            "    >>> variance([1.0, 2.0, 3.0, 4.0])\n",
            "    1.0\n",
            "    \"\"\"\n",
            "\n",
            "def interquartile_range(numbers: List[float]) -> float:\n",
            "    \"\"\" For a given list of input numbers, calculate Interquartile Range\n",
            "    around the median of this dataset.\n",
            "    Interquartile Range is the difference between the 75th and 25th percentile\n",
            "    of the dataset:\n",
            "    IQR = x_75th - x_25th\n",
            "    >>> interquartile_range([1.0, 2.0, 3.0, 4.0])\n",
            "    1.0\n",
            "    \"\"\"\n",
            "\n",
            "def coefficient_of_variation(numbers: List[float]) -> float:\n",
            "    \"\"\" For a given list of input numbers, calculate Coefficient of Variation\n",
            "    around the mean of this dataset.\n",
            "    Coefficient of Variation is the ratio of the standard deviation to the\n",
            "    mean:\n",
            "    CV = SD / mean\n",
            "    >>> coefficient_of_variation([1.0, 2.0, 3.0, 4.0])\n",
            "    1.0\n",
            "    \"\"\"\n",
            "\n",
            "def skewness(numbers: List[float]) -> float:\n",
            "    \"\"\" For a given list of input numbers, calculate Skewness\n",
            "    around the mean of this dataset.\n",
            "    Skewness is the third central moment divided by the cube of the standard\n",
            "    deviation:\n",
            "    Skewness = 3 * (x_mean - x_median) / SD\n",
            "    >>> skewness([1.0, 2.0, 3.0, 4.0])\n",
            "    1.0\n",
            "    \"\"\"\n",
            "\n",
            "def kurtosis(numbers: List[float]) -> float:\n",
            "    \"\"\" For a given list of input numbers, calculate Kurtosis\n",
            "    around the mean of this dataset.\n",
            "    Kurtosis is the fourth central moment divided by the fourth power of the\n",
            "    standard deviation:\n",
            "    Kurtosis = 4 * (x_mean - x_median)^2 / SD^4\n",
            "    >>> kurtosis([1.0, 2.0, 3.0, 4.0])\n",
            "    1.0\n",
            "    \"\"\"\n",
            "\n",
            "def quartile_deviation(numbers: List[float]) -> float:\n",
            "    \"\"\" For a given list of input numbers, calculate Quartile Deviation\n",
            "    around the median of this dataset.\n",
            "    Quartile Deviation is the difference between the 75th and 25th percentile\n",
            "    of the dataset:\n",
            "    QD = x_75th - x_25th\n",
            "    >>> quartile_deviation([1.0, 2.0, 3.0, 4.0])\n",
            "    1.0\n",
            "    \"\"\"\n",
            "\n",
            "def quartile_coefficient(numbers: List[float]) -> float:\n",
            "    \"\"\" For a\n",
            "----------------------------------------------------\n",
            "Accuracy: 0.0%\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Import necessary libraries\n",
        "from transformers import AutoTokenizer, AutoModelForCausalLM\n",
        "from datasets import load_dataset\n",
        "import torch\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Load the model and tokenizer\n",
        "tokenizer = AutoTokenizer.from_pretrained(\"bigcode/starcoder2-3b\")\n",
        "model = AutoModelForCausalLM.from_pretrained(\"bigcode/starcoder2-3b\")\n",
        "\n",
        "# Load the HumanEval dataset\n",
        "humaneval_dataset = load_dataset(\"openai_humaneval\")\n",
        "\n",
        "# Function to generate code completions\n",
        "def generate_completion(prompt, max_length=1000, temperature=0.7):\n",
        "    inputs = tokenizer(prompt, return_tensors=\"pt\")\n",
        "    input_ids = inputs[\"input_ids\"]\n",
        "    attention_mask = inputs[\"attention_mask\"]\n",
        "\n",
        "    with torch.no_grad():\n",
        "        outputs = model.generate(input_ids=input_ids, attention_mask=attention_mask,\n",
        "                                 max_length=max_length, temperature=temperature)\n",
        "\n",
        "    completion = tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
        "    return completion\n",
        "\n",
        "# Function to evaluate the model\n",
        "def evaluate_model(dataset, num_examples=5):\n",
        "    correct = 0\n",
        "    results = []\n",
        "    for i, example in enumerate(dataset[\"test\"]):\n",
        "        if i >= num_examples:\n",
        "            break\n",
        "\n",
        "        prompt = example[\"prompt\"]\n",
        "        expected_output = example[\"canonical_solution\"]\n",
        "\n",
        "        generated_output = generate_completion(prompt)\n",
        "\n",
        "        print(f\"Prompt: {prompt}\")\n",
        "        print(f\"Expected Output: {expected_output}\")\n",
        "        print(f\"Generated Output: {generated_output}\")\n",
        "        print(\"----------------------------------------------------\")\n",
        "\n",
        "        # Check if the expected output is in the generated output\n",
        "        is_correct = expected_output in generated_output\n",
        "        results.append(is_correct)\n",
        "        if is_correct:\n",
        "            correct += 1\n",
        "\n",
        "    accuracy = correct / num_examples\n",
        "    print(f\"Accuracy: {accuracy * 100}%\")\n",
        "\n",
        "    return results\n",
        "\n",
        "# Function to plot the evaluation results\n",
        "def plot_results(results):\n",
        "    labels = ['Correct', 'Incorrect']\n",
        "    counts = [sum(results), len(results) - sum(results)]\n",
        "\n",
        "    plt.figure(figsize=(8, 6))\n",
        "    plt.bar(labels, counts, color=['green', 'red'])\n",
        "    plt.xlabel('Evaluation Result')\n",
        "    plt.ylabel('Number of Examples')\n",
        "    plt.title('Model Evaluation Results on HumanEval Dataset')\n",
        "    plt.show()\n",
        "\n",
        "# Evaluate the model on the HumanEval dataset and plot the results\n",
        "results = evaluate_model(humaneval_dataset)\n",
        "plot_results(results)\n"
      ]
    }
  ]
}