langchain_karl.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyM7tTQYEnRUCh1QJmG1zibx",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jacksonkarel/etl-langchain/blob/main/langchain_karl.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BAgfE8uJ5mf0",
        "outputId": "1effc92a-532a-4dbe-e502-d64a3ce1840b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: langchain in /usr/local/lib/python3.8/dist-packages (0.0.94)\n",
            "Requirement already satisfied: SQLAlchemy<2,>=1 in /usr/local/lib/python3.8/dist-packages (from langchain) (1.4.46)\n",
            "Requirement already satisfied: requests<3,>=2 in /usr/local/lib/python3.8/dist-packages (from langchain) (2.28.2)\n",
            "Requirement already satisfied: aleph-alpha-client<3.0.0,>=2.15.0 in /usr/local/lib/python3.8/dist-packages (from langchain) (2.16.0)\n",
            "Requirement already satisfied: dataclasses-json<0.6.0,>=0.5.7 in /usr/local/lib/python3.8/dist-packages (from langchain) (0.5.7)\n",
            "Requirement already satisfied: tenacity<9.0.0,>=8.1.0 in /usr/local/lib/python3.8/dist-packages (from langchain) (8.2.1)\n",
            "Requirement already satisfied: PyYAML<7,>=6 in /usr/local/lib/python3.8/dist-packages (from langchain) (6.0)\n",
            "Requirement already satisfied: numpy<2,>=1 in /usr/local/lib/python3.8/dist-packages (from langchain) (1.22.4)\n",
            "Requirement already satisfied: pydantic<2,>=1 in /usr/local/lib/python3.8/dist-packages (from langchain) (1.10.5)\n",
            "Requirement already satisfied: aiohttp<4.0.0,>=3.8.3 in /usr/local/lib/python3.8/dist-packages (from langchain) (3.8.4)\n",
            "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.8/dist-packages (from aiohttp<4.0.0,>=3.8.3->langchain) (22.2.0)\n",
            "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.8/dist-packages (from aiohttp<4.0.0,>=3.8.3->langchain) (6.0.4)\n",
            "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.8/dist-packages (from aiohttp<4.0.0,>=3.8.3->langchain) (1.3.3)\n",
            "Requirement already satisfied: async-timeout<5.0,>=4.0.0a3 in /usr/local/lib/python3.8/dist-packages (from aiohttp<4.0.0,>=3.8.3->langchain) (4.0.2)\n",
            "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.8/dist-packages (from aiohttp<4.0.0,>=3.8.3->langchain) (1.3.1)\n",
            "Requirement already satisfied: charset-normalizer<4.0,>=2.0 in /usr/local/lib/python3.8/dist-packages (from aiohttp<4.0.0,>=3.8.3->langchain) (3.0.1)\n",
            "Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.8/dist-packages (from aiohttp<4.0.0,>=3.8.3->langchain) (1.8.2)\n",
            "Requirement already satisfied: tokenizers>=0.13.2 in /usr/local/lib/python3.8/dist-packages (from aleph-alpha-client<3.0.0,>=2.15.0->langchain) (0.13.2)\n",
            "Requirement already satisfied: aiodns>=3.0.0 in /usr/local/lib/python3.8/dist-packages (from aleph-alpha-client<3.0.0,>=2.15.0->langchain) (3.0.0)\n",
            "Requirement already satisfied: aiohttp-retry>=2.8.3 in /usr/local/lib/python3.8/dist-packages (from aleph-alpha-client<3.0.0,>=2.15.0->langchain) (2.8.3)\n",
            "Requirement already satisfied: urllib3>=1.26 in /usr/local/lib/python3.8/dist-packages (from aleph-alpha-client<3.0.0,>=2.15.0->langchain) (1.26.14)\n",
            "Requirement already satisfied: marshmallow<4.0.0,>=3.3.0 in /usr/local/lib/python3.8/dist-packages (from dataclasses-json<0.6.0,>=0.5.7->langchain) (3.19.0)\n",
            "Requirement already satisfied: marshmallow-enum<2.0.0,>=1.5.1 in /usr/local/lib/python3.8/dist-packages (from dataclasses-json<0.6.0,>=0.5.7->langchain) (1.5.1)\n",
            "Requirement already satisfied: typing-inspect>=0.4.0 in /usr/local/lib/python3.8/dist-packages (from dataclasses-json<0.6.0,>=0.5.7->langchain) (0.8.0)\n",
            "Requirement already satisfied: typing-extensions>=4.2.0 in /usr/local/lib/python3.8/dist-packages (from pydantic<2,>=1->langchain) (4.5.0)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests<3,>=2->langchain) (2.10)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests<3,>=2->langchain) (2022.12.7)\n",
            "Requirement already satisfied: greenlet!=0.4.17 in /usr/local/lib/python3.8/dist-packages (from SQLAlchemy<2,>=1->langchain) (2.0.2)\n",
            "Requirement already satisfied: pycares>=4.0.0 in /usr/local/lib/python3.8/dist-packages (from aiodns>=3.0.0->aleph-alpha-client<3.0.0,>=2.15.0->langchain) (4.3.0)\n",
            "Requirement already satisfied: packaging>=17.0 in /usr/local/lib/python3.8/dist-packages (from marshmallow<4.0.0,>=3.3.0->dataclasses-json<0.6.0,>=0.5.7->langchain) (23.0)\n",
            "Requirement already satisfied: mypy-extensions>=0.3.0 in /usr/local/lib/python3.8/dist-packages (from typing-inspect>=0.4.0->dataclasses-json<0.6.0,>=0.5.7->langchain) (1.0.0)\n",
            "Requirement already satisfied: cffi>=1.5.0 in /usr/local/lib/python3.8/dist-packages (from pycares>=4.0.0->aiodns>=3.0.0->aleph-alpha-client<3.0.0,>=2.15.0->langchain) (1.15.1)\n",
            "Requirement already satisfied: pycparser in /usr/local/lib/python3.8/dist-packages (from cffi>=1.5.0->pycares>=4.0.0->aiodns>=3.0.0->aleph-alpha-client<3.0.0,>=2.15.0->langchain) (2.21)\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: openai in /usr/local/lib/python3.8/dist-packages (0.26.5)\n",
            "Requirement already satisfied: requests>=2.20 in /usr/local/lib/python3.8/dist-packages (from openai) (2.28.2)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.8/dist-packages (from openai) (4.64.1)\n",
            "Requirement already satisfied: aiohttp in /usr/local/lib/python3.8/dist-packages (from openai) (3.8.4)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests>=2.20->openai) (2022.12.7)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests>=2.20->openai) (2.10)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.8/dist-packages (from requests>=2.20->openai) (3.0.1)\n",
            "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests>=2.20->openai) (1.26.14)\n",
            "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.8/dist-packages (from aiohttp->openai) (6.0.4)\n",
            "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.8/dist-packages (from aiohttp->openai) (1.3.3)\n",
            "Requirement already satisfied: async-timeout<5.0,>=4.0.0a3 in /usr/local/lib/python3.8/dist-packages (from aiohttp->openai) (4.0.2)\n",
            "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.8/dist-packages (from aiohttp->openai) (22.2.0)\n",
            "Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.8/dist-packages (from aiohttp->openai) (1.8.2)\n",
            "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.8/dist-packages (from aiohttp->openai) (1.3.1)\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: google-search-results in /usr/local/lib/python3.8/dist-packages (2.4.1)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.8/dist-packages (from google-search-results) (2.28.2)\n",
            "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests->google-search-results) (1.26.14)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests->google-search-results) (2022.12.7)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.8/dist-packages (from requests->google-search-results) (3.0.1)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests->google-search-results) (2.10)\n"
          ]
        }
      ],
      "source": [
        "!pip install langchain\n",
        "!pip install openai\n",
        "!pip install google-search-results"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import json\n",
        "keys = json.load(open('keys.json'))\n",
        "os.environ[\"OPENAI_API_KEY\"] = keys['openai']\n",
        "os.environ[\"SERPAPI_API_KEY\"] = keys['serp']\n",
        "import pandas as pd\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "_cOQsfaL5vim"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from langchain.agents import Tool\n",
        "from langchain.chains.conversation.memory import ConversationBufferMemory\n",
        "from langchain import OpenAI\n",
        "from langchain import OpenAI, SerpAPIWrapper, LLMChain\n",
        "from langchain.utilities import PythonREPL\n",
        "from langchain.agents import initialize_agent\n",
        "from langchain.agents import load_tools"
      ],
      "metadata": {
        "id": "rQjMtHoo5vcX"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "python_repl = PythonREPL()\n",
        "\n",
        "tools = [\n",
        "    Tool(\n",
        "        name=\"Python REPL\",\n",
        "        func=python_repl.run,\n",
        "        description=\"A Python shell. Use this to execute python commands. Input should be a valid python command. Always print the output of the python command.\"\n",
        "    ),\n",
        "]\n",
        "\n",
        "memory = ConversationBufferMemory(memory_key=\"chat_history\")\n",
        "\n",
        "llm=OpenAI(temperature=0)\n",
        "agent_chain = initialize_agent(tools, llm, agent=\"conversational-react-description\", verbose=True, memory=memory)"
      ],
      "metadata": {
        "id": "QDT5ftCC8z6H"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "OLuGQ7PzElXO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tools = load_tools([\"python_repl\"], llm=llm)\n",
        "\n",
        "agent = initialize_agent(tools, llm, agent=\"zero-shot-react-description\", verbose=True)\n",
        "\n",
        "input1 = \"\"\"Execute the following steps:\n",
        "\n",
        "1. Using python execution, load `data2.csv`\n",
        "\n",
        "3. Using python execution, split the dataset into train and test sets using a 80% random split\n",
        "\n",
        "4. Save the datasets to `train_data.csv` and `test_data.csv`\n",
        "\"\"\"\n",
        "\n",
        "input2 = \"\"\"Execute the following steps to train an sklearn model:\n",
        "\n",
        "Using python execution, load `train_data.csv`\n",
        "\n",
        "Using python execution, iterate over the columns of the dataset printing the column name and datatype\n",
        "\n",
        "Identify which columns are feature columns and which columns are label columns\n",
        "\n",
        "Split the dataset into features and labels\n",
        "\n",
        "Use the label column to determine if the problem is a classification or regression problem\n",
        "\n",
        "Create an sklearn pipeline including preprocessing and modeling\n",
        "\n",
        "Fit the pipeline to the dataset\n",
        "\n",
        "Save the fitted pipeline to disk as `model.joblib`\n",
        "\"\"\"\n",
        "\n",
        "input3 = \"\"\"Execute the following steps to run inference with a sklearn model:\n",
        "\n",
        "1. Using python execution, load the sklearn model `model.joblib` from disk\n",
        "\n",
        "2. Using python execution, load `test_data.csv`\n",
        "\n",
        "3. Using python execution, iterate over the columns of the dataset printing the column name and datatype\n",
        "\n",
        "4. Split the dataset into features and labels\n",
        "\n",
        "5. Run prediction inference on the test data\n",
        "\n",
        "6. Evaluate the predictions with an appropreate metric\n",
        "\n",
        "7. Print the result\n",
        "\"\"\""
      ],
      "metadata": {
        "id": "oK08UxA1oX0K"
      },
      "execution_count": 87,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "WfQJLeih4r-Q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "agent.run(input1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 571
        },
        "id": "F8qLg-e-Bvip",
        "outputId": "2c2e3f48-02a5-4b76-f0c7-cc8a1865f753"
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
            "\u001b[32;1m\u001b[1;3m I need to use the Python REPL to execute the steps\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "import pandas as pd\n",
            "data = pd.read_csv('data.csv')\n",
            "train, test = train_test_split(data, test_size=0.2, random_state=42)\n",
            "train.to_csv('train_data.csv', index=False)\n",
            "test.to_csv('test_data.csv', index=False)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3mname 'train_test_split' is not defined\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I need to import the train_test_split function\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "from sklearn.model_selection import train_test_split\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I now have the train_test_split function imported and can execute the steps\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "import pandas as pd\n",
            "data = pd.read_csv('data.csv')\n",
            "train, test = train_test_split(data, test_size=0.2, random_state=42)\n",
            "train.to_csv('train_data.csv', index=False)\n",
            "test.to_csv('test_data.csv', index=False)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
            "Final Answer: The datasets have been split into train and test sets and saved to the specified files.\u001b[0m\n",
            "\n",
            "\u001b[1m> Finished chain.\u001b[0m\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'The datasets have been split into train and test sets and saved to the specified files.'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "agent.run(input2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "t4nHOTjrB0oQ",
        "outputId": "b1963e51-108c-4545-8e1f-1ddff6d949ab"
      },
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
            "\u001b[32;1m\u001b[1;3m I need to use the Python REPL to execute the steps\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "import pandas as pd\n",
            "train_data = pd.read_csv('train_data.csv')\n",
            "for col in train_data.columns:\n",
            "    print(col, train_data[col].dtype)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3mcol_0 float64\n",
            "col_1 float64\n",
            "col_2 float64\n",
            "col_3 float64\n",
            "col_4 float64\n",
            "col_5 float64\n",
            "col_6 float64\n",
            "col_7 float64\n",
            "col_8 float64\n",
            "col_9 float64\n",
            "col_10 float64\n",
            "col_11 float64\n",
            "col_12 float64\n",
            "target int64\n",
            "\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I need to identify which columns are feature columns and which columns are label columns\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "features = train_data.drop('target', axis=1)\n",
            "labels = train_data['target']\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I need to split the dataset into features and labels\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "from sklearn.model_selection import train_test_split\n",
            "X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.2, random_state=42)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I need to determine if the problem is a classification or regression problem\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "if len(labels.unique()) > 2:\n",
            "    print('Classification Problem')\n",
            "else:\n",
            "    print('Regression Problem')\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3mClassification Problem\n",
            "\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I need to create an sklearn pipeline including preprocessing and modeling\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "from sklearn.pipeline import make_pipeline\n",
            "from sklearn.preprocessing import StandardScaler\n",
            "from sklearn.ensemble import RandomForestClassifier\n",
            "\n",
            "pipeline = make_pipeline(StandardScaler(), RandomForestClassifier())\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I need to fit the pipeline to the dataset\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "pipeline.fit(X_train, y_train)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I need to save the fitted pipeline to disk as `model.joblib`\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "from joblib import dump\n",
            "dump(pipeline, 'model.joblib')\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
            "Final Answer: The final answer is that the steps to train an sklearn model have been successfully executed and the fitted pipeline has been saved to disk as `model.joblib`.\u001b[0m\n",
            "\n",
            "\u001b[1m> Finished chain.\u001b[0m\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'The final answer is that the steps to train an sklearn model have been successfully executed and the fitted pipeline has been saved to disk as `model.joblib`.'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "agent.run(input3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 803
        },
        "id": "HawJYL4zB0l7",
        "outputId": "39c60495-687c-469f-cf46-38a3146cf0cc"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
            "\u001b[32;1m\u001b[1;3m I need to use the Python REPL to execute the steps\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "import joblib\n",
            "model = joblib.load('model.joblib')\n",
            "\n",
            "import pandas as pd\n",
            "test_data = pd.read_csv('test_data.csv')\n",
            "\n",
            "for col in test_data.columns:\n",
            "    print(col, test_data[col].dtype)\n",
            "\n",
            "X = test_data.drop('label', axis=1)\n",
            "y = test_data['label']\n",
            "\n",
            "predictions = model.predict(X)\n",
            "\n",
            "from sklearn.metrics import accuracy_score\n",
            "accuracy = accuracy_score(y, predictions)\n",
            "\n",
            "print(accuracy)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\"['label'] not found in axis\"\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I need to make sure I'm splitting the dataset correctly\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "X = test_data.drop('target', axis=1)\n",
            "y = test_data['target']\n",
            "\n",
            "predictions = model.predict(X)\n",
            "\n",
            "from sklearn.metrics import accuracy_score\n",
            "accuracy = accuracy_score(y, predictions)\n",
            "\n",
            "print(accuracy)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m1.0\n",
            "\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
            "Final Answer: The accuracy of the model on the test data is 1.0.\u001b[0m\n",
            "\n",
            "\u001b[1m> Finished chain.\u001b[0m\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'The accuracy of the model on the test data is 1.0.'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 73
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Lb6ru89GB0jl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "SEw5IDfqBnSJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "tlGI1Qww4U6n"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ims0AtvR_xgk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "leZKFPAx_xef"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "agent.run(input1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 500
        },
        "id": "Pg1msJ_t_xcj",
        "outputId": "c696054c-ef3a-45ce-c118-df8bb69f419c"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
            "\u001b[32;1m\u001b[1;3m I need to use the Python REPL to execute the steps\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "import pandas as pd\n",
            "data = pd.read_csv('dataset.csv')\n",
            "train_data, test_data = data.train_test_split(test_size=0.2, random_state=0)\n",
            "train_data.to_csv('train_data.csv', index=False)\n",
            "test_data.to_csv('test_data.csv', index=False)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m'DataFrame' object has no attribute 'train_test_split'\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I need to use the sklearn library\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "import pandas as pd\n",
            "from sklearn.model_selection import train_test_split\n",
            "data = pd.read_csv('dataset.csv')\n",
            "train_data, test_data = train_test_split(data, test_size=0.2, random_state=0)\n",
            "train_data.to_csv('train_data.csv', index=False)\n",
            "test_data.to_csv('test_data.csv', index=False)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m The datasets should now be saved\n",
            "Final Answer: The datasets should now be saved to `train_data.csv` and `test_data.csv`.\u001b[0m\n",
            "\n",
            "\u001b[1m> Finished chain.\u001b[0m\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'The datasets should now be saved to `train_data.csv` and `test_data.csv`.'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "agent.run(input2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "IiBJmQjyAGus",
        "outputId": "4edbdfa2-3eae-4238-bf71-695398a4341c"
      },
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
            "\u001b[32;1m\u001b[1;3m I need to use the Python REPL to execute the steps\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "import pandas as pd\n",
            "train_data = pd.read_csv('train_data.csv')\n",
            "for col in train_data.columns:\n",
            "    print(col, train_data[col].dtype)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3mcol_0 float64\n",
            "col_1 float64\n",
            "col_2 float64\n",
            "col_3 float64\n",
            "col_4 float64\n",
            "col_5 float64\n",
            "col_6 float64\n",
            "col_7 float64\n",
            "col_8 float64\n",
            "col_9 float64\n",
            "col_10 float64\n",
            "col_11 float64\n",
            "col_12 float64\n",
            "col_13 float64\n",
            "col_14 float64\n",
            "col_15 float64\n",
            "col_16 float64\n",
            "col_17 float64\n",
            "col_18 float64\n",
            "col_19 float64\n",
            "col_20 float64\n",
            "col_21 float64\n",
            "col_22 float64\n",
            "col_23 float64\n",
            "col_24 float64\n",
            "col_25 float64\n",
            "col_26 float64\n",
            "col_27 float64\n",
            "col_28 float64\n",
            "col_29 float64\n",
            "col_30 float64\n",
            "col_31 float64\n",
            "col_32 float64\n",
            "col_33 float64\n",
            "col_34 float64\n",
            "col_35 float64\n",
            "col_36 float64\n",
            "col_37 float64\n",
            "col_38 float64\n",
            "col_39 float64\n",
            "col_40 float64\n",
            "col_41 float64\n",
            "col_42 float64\n",
            "col_43 float64\n",
            "col_44 float64\n",
            "col_45 float64\n",
            "col_46 float64\n",
            "col_47 float64\n",
            "col_48 float64\n",
            "col_49 float64\n",
            "col_50 float64\n",
            "col_51 float64\n",
            "col_52 float64\n",
            "col_53 float64\n",
            "col_54 float64\n",
            "col_55 float64\n",
            "col_56 float64\n",
            "col_57 float64\n",
            "col_58 float64\n",
            "col_59 float64\n",
            "col_60 float64\n",
            "col_61 float64\n",
            "col_62 float64\n",
            "col_63 float64\n",
            "target int64\n",
            "\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I now need to identify which columns are feature columns and which columns are label columns\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "features = train_data.drop('target', axis=1)\n",
            "labels = train_data['target']\n",
            "\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I now need to split the dataset into features and labels\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "from sklearn.model_selection import train_test_split\n",
            "X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.2, random_state=42)\n",
            "\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I now need to determine if the problem is a classification or regression problem\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "if len(labels.unique()) > 2:\n",
            "    print('Classification Problem')\n",
            "else:\n",
            "    print('Regression Problem')\n",
            "\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3mClassification Problem\n",
            "\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I now need to create an sklearn pipeline including preprocessing and modeling\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "from sklearn.pipeline import make_pipeline\n",
            "from sklearn.preprocessing import StandardScaler\n",
            "from sklearn.ensemble import RandomForestClassifier\n",
            "\n",
            "pipeline = make_pipeline(StandardScaler(), RandomForestClassifier())\n",
            "\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I now need to fit the pipeline to the dataset\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "pipeline.fit(X_train, y_train)\n",
            "\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I now need to save the fitted pipeline to disk as `model.joblib`\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "import joblib\n",
            "joblib.dump(pipeline, 'model.joblib')\n",
            "\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
            "Final Answer: The fitted pipeline has been saved to disk as `model.joblib`.\u001b[0m\n",
            "\n",
            "\u001b[1m> Finished chain.\u001b[0m\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'The fitted pipeline has been saved to disk as `model.joblib`.'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "agent.run(input3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 803
        },
        "id": "tUzm4upaAGrT",
        "outputId": "005e810c-a02d-41f1-822a-51d7f0e18c24"
      },
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
            "\u001b[32;1m\u001b[1;3m I need to use the Python REPL to execute the steps\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "import joblib\n",
            "model = joblib.load('model.joblib')\n",
            "\n",
            "import pandas as pd\n",
            "test_data = pd.read_csv('test_data.csv')\n",
            "\n",
            "for col in test_data.columns:\n",
            "    print(col, test_data[col].dtype)\n",
            "\n",
            "X = test_data.drop('label', axis=1)\n",
            "y = test_data['label']\n",
            "\n",
            "predictions = model.predict(X)\n",
            "\n",
            "from sklearn.metrics import accuracy_score\n",
            "accuracy = accuracy_score(y, predictions)\n",
            "\n",
            "print(accuracy)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\"['label'] not found in axis\"\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I need to make sure I'm splitting the dataset correctly\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "X = test_data.drop('target', axis=1)\n",
            "y = test_data['target']\n",
            "\n",
            "predictions = model.predict(X)\n",
            "\n",
            "from sklearn.metrics import accuracy_score\n",
            "accuracy = accuracy_score(y, predictions)\n",
            "\n",
            "print(accuracy)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m0.9722222222222222\n",
            "\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
            "Final Answer: The accuracy of the model on the test data is 0.9722222222222222.\u001b[0m\n",
            "\n",
            "\u001b[1m> Finished chain.\u001b[0m\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'The accuracy of the model on the test data is 0.9722222222222222.'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "pXa1xW4GATeJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Jf_wraSuDp8Z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "k9OALjW0DroW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "u-K0dA0bDp6i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "KZ3U7OHxDp4f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "agent.run(input1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 339
        },
        "id": "5MuD7t0yCQvF",
        "outputId": "df799aa1-05bf-414b-9c00-ed64d50ac326"
      },
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
            "\u001b[32;1m\u001b[1;3m I need to use the Python REPL to execute the steps\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "import pandas as pd\n",
            "data2 = pd.read_csv('data2.csv')\n",
            "from sklearn.model_selection import train_test_split\n",
            "train_data, test_data = train_test_split(data2, test_size=0.2, random_state=42)\n",
            "train_data.to_csv('train_data.csv', index=False)\n",
            "test_data.to_csv('test_data.csv', index=False)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m The datasets have been saved to the specified files\n",
            "Final Answer: The datasets have been saved to the specified files: `train_data.csv` and `test_data.csv`.\u001b[0m\n",
            "\n",
            "\u001b[1m> Finished chain.\u001b[0m\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'The datasets have been saved to the specified files: `train_data.csv` and `test_data.csv`.'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 83
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "agent.run(input2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "cjd9hc3_CQs5",
        "outputId": "5f4d8aa3-388a-42f0-b227-78fd8eb22ee8"
      },
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
            "\u001b[32;1m\u001b[1;3m I need to use the Python REPL to execute the steps\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "import pandas as pd\n",
            "train_data = pd.read_csv('train_data.csv')\n",
            "for col in train_data.columns:\n",
            "    print(col, train_data[col].dtype)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3mcol_0 float64\n",
            "col_1 float64\n",
            "col_2 float64\n",
            "col_3 float64\n",
            "col_4 float64\n",
            "col_5 float64\n",
            "col_6 float64\n",
            "col_7 float64\n",
            "col_8 float64\n",
            "col_9 float64\n",
            "target float64\n",
            "\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I need to identify which columns are feature columns and which are label columns\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "features = train_data.drop('target', axis=1)\n",
            "labels = train_data['target']\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I need to determine if the problem is a classification or regression problem\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "if labels.dtype == 'float64':\n",
            "    print('Regression')\n",
            "else:\n",
            "    print('Classification')\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3mRegression\n",
            "\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I need to create an sklearn pipeline\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "from sklearn.pipeline import make_pipeline\n",
            "from sklearn.preprocessing import StandardScaler\n",
            "from sklearn.linear_model import LinearRegression\n",
            "\n",
            "pipeline = make_pipeline(StandardScaler(), LinearRegression())\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I need to fit the pipeline to the dataset\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "pipeline.fit(features, labels)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I need to save the fitted pipeline to disk\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "import joblib\n",
            "joblib.dump(pipeline, 'model.joblib')\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
            "Final Answer: The final answer is that the steps to train an sklearn model have been successfully executed and the fitted pipeline has been saved to disk as `model.joblib`.\u001b[0m\n",
            "\n",
            "\u001b[1m> Finished chain.\u001b[0m\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'The final answer is that the steps to train an sklearn model have been successfully executed and the fitted pipeline has been saved to disk as `model.joblib`.'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 88
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "agent.run(input3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 946
        },
        "id": "IMRncoigCQqs",
        "outputId": "ea3577d1-1e47-4cda-f6f8-73c8d3b5815f"
      },
      "execution_count": 89,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
            "\u001b[32;1m\u001b[1;3m I need to use the Python REPL to execute the steps\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "import joblib\n",
            "model = joblib.load('model.joblib')\n",
            "\n",
            "import pandas as pd\n",
            "test_data = pd.read_csv('test_data.csv')\n",
            "\n",
            "for col in test_data.columns:\n",
            "    print(col, test_data[col].dtype)\n",
            "\n",
            "X = test_data.drop('label', axis=1)\n",
            "y = test_data['label']\n",
            "\n",
            "predictions = model.predict(X)\n",
            "\n",
            "from sklearn.metrics import accuracy_score\n",
            "accuracy = accuracy_score(y, predictions)\n",
            "\n",
            "print(accuracy)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m\"['label'] not found in axis\"\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I need to make sure I'm splitting the dataset correctly\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "X = test_data.drop('target', axis=1)\n",
            "y = test_data['target']\n",
            "\n",
            "predictions = model.predict(X)\n",
            "\n",
            "from sklearn.metrics import accuracy_score\n",
            "accuracy = accuracy_score(y, predictions)\n",
            "\n",
            "print(accuracy)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3mClassification metrics can't handle a mix of multiclass and continuous targets\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I need to make sure I'm using the correct metric\n",
            "Action: Python REPL\n",
            "Action Input: \n",
            "from sklearn.metrics import mean_squared_error\n",
            "mse = mean_squared_error(y, predictions)\n",
            "\n",
            "print(mse)\u001b[0m\n",
            "Observation: \u001b[36;1m\u001b[1;3m2900.1732878832327\n",
            "\u001b[0m\n",
            "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
            "Final Answer: The mean squared error of the predictions is 2900.1732878832327.\u001b[0m\n",
            "\n",
            "\u001b[1m> Finished chain.\u001b[0m\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'The mean squared error of the predictions is 2900.1732878832327.'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "13irJ4z5DGLe"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}