From 53a17feb08ba602843335a9515b3ad3c4d3586bd Mon Sep 17 00:00:00 2001 From: Gabriele Venturi Date: Thu, 8 Jun 2023 02:23:27 +0200 Subject: [PATCH] feat: add support for Falcon LLM At the moment, however, the Falcon LLM seems to hallucinate quite often, we should support custom prompts for each LLM --- Notebooks/Getting Started.ipynb | 2 +- README.md | 5 +++- docs/API/llms.md | 8 +++++ docs/pai_cli.md | 26 ++++++++++++----- pai/__main__.py | 52 ++++++++++++++++++++++----------- pandasai/llm/falcon.py | 51 ++++++++++++++++++++++++++++++++ pandasai/llm/open_assistant.py | 7 ++--- tests/llms/test_falcon.py | 17 +++++++++++ 8 files changed, 138 insertions(+), 30 deletions(-) create mode 100644 pandasai/llm/falcon.py create mode 100644 tests/llms/test_falcon.py diff --git a/Notebooks/Getting Started.ipynb b/Notebooks/Getting Started.ipynb index 51f39be9e..b51dc9f2a 100644 --- a/Notebooks/Getting Started.ipynb +++ b/Notebooks/Getting Started.ipynb @@ -1 +1 @@ -{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[{"file_id":"1XwQuNfgLtgcGd2yWMzBRXTR0bZ5Vjm1C","timestamp":1685076114938},{"file_id":"https://github.com/amjadraza/learn-it/blob/master/Getting_Started_pandas_ai.ipynb","timestamp":1684888879263}]},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"markdown","source":["#[PANDASAI](https://github.com/gventuri/pandas-ai) : A generative AI capabilities to Pandas Dataframes\n","\n"],"metadata":{"id":"8OnF6qsbDG1t"}},{"cell_type":"markdown","source":["## Supported Models\n","\n","The Pandasai API currently supports several models, and it is continuously being developed with the possibility of adding more models in the future. The supported models include:\n","\n","1. ChatGPT by OpenAI\n","2. StarCoder by Huggingface\n","3. Azure ChatGPT API\n","4. OpenAI Assistant\n","5. Google PaLM\n","\n","These models can be utilized in a conversational form, allowing users to interact with them effectively.\n","\n","To facilitate the usage of these models, this tutorial provides guidance on running them using Google Colab. Google Colab is a platform that enables straightforward onboarding and provides a Google Colab Notebook, which simplifies the process of getting started.\n","\n","By leveraging the provided Google Colab Notebook, users can easily run the supported models within a conversational context, enhancing the overall interactive experience and enabling efficient data analysis.\n","\n","Please note that as the Pandasai API evolves, additional models may be incorporated, expanding the range of options available to users."],"metadata":{"id":"zYGici1BqvD4"}},{"cell_type":"markdown","source":["## Learning Objectives:\n","This tutorial aims to help you achieve the following learning objectives:\n","\n","1. Install the pandasai library.\n","2. Set up the API_TOKEN using either the OpenAI platform or the Hugging Face platform.\n","3. Explore and run basic functionalities provided by pandasai.\n","4. Execute examples using pandasai with predefined prompts for experimentation.\n","\n","Please note that while the OpenAI platform is not free, it is still reasonably priced for running a few queries. On the other hand, the StartCoder model by Hugging Face is available for personal use at no cost.\n"],"metadata":{"id":"mFPp6trsrauF"}},{"cell_type":"markdown","source":["## Prerequisites\n","Before proceeding with this tutorial, make sure you meet the following prerequisites:\n","\n","1. Basic understanding of Python, Pandas, and APIs for generative models.\n","2. Obtain API tokens from the openai platform and/or Hugging Face, depending on the models you intend to use.\n","3. Demonstrated eagerness to learn and develop your skills.\n","\n","Having a foundational knowledge of Python, Pandas, and generative models APIs will be beneficial for understanding the concepts covered in this tutorial. Additionally, acquiring the necessary API tokens from the respective platforms will enable you to interact with the models effectively.\n","\n","It's important to approach this tutorial with a positive attitude and a willingness to learn and improve your skills. Through active participation and a growth mindset, you will be able to make the most of this learning opportunity."],"metadata":{"id":"yJjtSdTirwi1"}},{"cell_type":"markdown","source":["# Getting Started\n","\n","Installing `Pandasai` is pretty striaght forward using `pip`. The recent releases are hosted on [Pnadasai Pypi](https://pypi.org/project/pandasai/) page. Always check the version, you are going to install. Make sure, check out the [Issues](https://github.com/gventuri/pandas-ai/issues) page of its GitHub Reporistry for any problems you face. "],"metadata":{"id":"-VQE9nGwDaiG"}},{"cell_type":"markdown","source":[],"metadata":{"id":"MtzpjcogPC4z"}},{"cell_type":"code","execution_count":null,"metadata":{"id":"qtqSnCgwDDCg"},"outputs":[],"source":["!pip install --upgrade pandas pandasai"]},{"cell_type":"markdown","source":["Now we import the dependencies:"],"metadata":{"id":"DrrlU4QqDmxl"}},{"cell_type":"markdown","source":["## Generate OPENAI API Token\n","\n","Users are required to generate `YOUR_API_TOKEN`. Follow below simple steps to generate your API_TOKEN with \n","[openai](https://platform.openai.com/overview).\n","\n","1. Go to https://openai.com/api/ and signup with your email address or connect your Google Account.\n","2. Go to View API Keys on left side of your Personal Account Settings\n","3. Select Create new Secret key\n","\n","> The API access to openai is a paid service. You have to set up billing. \n",">Read the [Pricing](https://platform.openai.com/docs/quickstart/pricing) information before experimenting."],"metadata":{"id":"8S1QClHBfcWV"}},{"cell_type":"markdown","source":["## Generate HUGGING FACE PLATFORM API Token\n","\n","It will take around 2 mins to generate API token.\n","\n","Users are required to generate `YOUR_API_TOKEN`. Follow below simple steps to generate your API_TOKEN with [Hugging Face](https://huggingface.co/).\n","\n","1. Go to https://huggingface.co/ and signup with your email address or connect your Google Account.\n","2. Go to https://huggingface.co/settings/tokens and generate User Access Token.\n","3. Copy and Save securely for Personal Use\n","\n","> Hugging Face API keys are FREE for personal / educational use."],"metadata":{"id":"iAtFdufpPN5F"}},{"cell_type":"code","source":["# Import basis libraries\n","import pandas as pd\n","import pandasai as pdai\n","from pandasai import PandasAI\n","from pandasai.llm.openai import OpenAI\n","from pandasai.llm.open_assistant import OpenAssistant\n","from pandasai.llm.starcoder import Starcoder"],"metadata":{"id":"ohPMkz4zDqxz"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["# Define List of Models\n","models = {\n"," \"OpenAI\": OpenAI,\n"," \"Starcoder\": Starcoder,\n"," \"Open-Assistant\": OpenAssistant\n","}\n"],"metadata":{"id":"QtLlsddlRSAO"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["#@title Select Model to Run\n","model_to_run = 'OpenAI' #@param [\"OpenAI\", \"Starcoder\", \"Open-Assistant\"]\n","print(f\"Enter API for {model_to_run} platform\")"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"sGElcw0NRxeK","executionInfo":{"status":"ok","timestamp":1684891932779,"user_tz":-600,"elapsed":307,"user":{"displayName":"Amjad Raza","userId":"06768084019046926999"}},"outputId":"2b02aef7-23db-4bda-8445-d1b97dd9a58c"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Enter API for OpenAI platform\n"]}]},{"cell_type":"code","source":["# Enter API Key\n","API_KEY = '' #@param {type:\"string\"}"],"metadata":{"id":"DS1QdmQJgKm9"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["We create a dataframe using pandas:"],"metadata":{"id":"JAO_SzlyDr5x"}},{"cell_type":"code","source":["df = pd.DataFrame({\n"," \"country\": [\"United States\", \"United Kingdom\", \"France\", \"Germany\", \"Italy\", \"Spain\", \"Canada\", \"Australia\", \"Japan\", \"China\"],\n"," \"gdp\": [21400000, 2940000, 2830000, 3870000, 2160000, 1350000, 1780000, 1320000, 516000, 14000000],\n"," \"happiness_index\": [7.3, 7.2, 6.5, 7.0, 6.0, 6.3, 7.3, 7.3, 5.9, 5.0]\n","})"],"metadata":{"id":"nyRo07nqD08l"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["After loading the Dataframe and input of Prompt, now we are ready to run the Prompt with given dataframe and query. As a first setp, we instantiate the llm model with selected option. In order to understand, what is going under the hood, we set `verbose=True`. Let us run now!"],"metadata":{"id":"aeTOQettEfWT"}},{"cell_type":"code","source":["# Model Initialisation\n","llm = models[model_to_run](api_token=API_KEY)\n","pandas_ai = PandasAI(llm, conversational=False, verbose=True)\n"],"metadata":{"id":"HZnx0V18EkzS"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["# Enter Prompt related to data or Select from Pre-defined for demo purposes.\n","prompt = 'Plot the histogram of countries showing for each the gpd, using different colors for each bar' #@param [ \"What is the relation between GDP and Happines Index\", \"Plot the histogram of countries showing for each the gpd, using different colors for each bar\", \"GDP of Top 5 Happiest Countries?\"] {allow-input: true}\n"],"metadata":{"id":"BQs22IO-Ti_q"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["response = pandas_ai.run(df, prompt=prompt,\n"," is_conversational_answer=False)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"m7_erVstXW9V","executionInfo":{"status":"ok","timestamp":1684891977617,"user_tz":-600,"elapsed":11398,"user":{"displayName":"Amjad Raza","userId":"06768084019046926999"}},"outputId":"7fad4db4-4758-4813-b8f0-bb619bd86a24"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Running PandasAI with openai LLM...\n","\n","Code generated:\n","```\n","import matplotlib.pyplot as plt\n","\n","colors = ['red', 'blue', 'green', 'orange', 'purple', 'pink', 'brown', 'gray', 'olive', 'cyan']\n","plt.bar(df['country'], df['gdp'], color=colors)\n","plt.xticks(rotation=90)\n","plt.xlabel('Country')\n","plt.ylabel('GDP')\n","plt.title('GDP by Country')\n","plt.show()\n","```\n","\n","Code running:\n","```\n","colors = ['red', 'blue', 'green', 'orange', 'purple', 'pink', 'brown',\n"," 'gray', 'olive', 'cyan']\n","plt.bar(df['country'], df['gdp'], color=colors)\n","plt.xticks(rotation=90)\n","plt.xlabel('Country')\n","plt.ylabel('GDP')\n","plt.title('GDP by Country')\n","plt.show()\n","```\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["Answer: \n"]}]},{"cell_type":"markdown","source":["As you can see from above experiments, having `verbose=True`, we can see the code generated by LLMs API and then this code is run to produce and answer on complete dataset. "],"metadata":{"id":"3w4BLXuVY4jO"}},{"cell_type":"markdown","source":["## Play Around\n","\n","Users can play around various questions about the tiny dataset we generated above. Using this notebook, you can select between Model Options and ask questions based on your problem."],"metadata":{"id":"2A44RePXXldV"}},{"cell_type":"markdown","source":["## More Examples\n","\n","In above section, we showed a little demo with small dataframe. Usually data is stored in `.csv` , .=`.xlsx` and other formats. `Pandasai` treats any data uploaded as Pandas dataframe and proceed accordingly. \n","\n","In this section, we include some of the [examples](https://github.com/gventuri/pandas-ai/tree/main/examples) shipped with `pandasai` reporsitory.\n"],"metadata":{"id":"iWH56NfdiioM"}},{"cell_type":"code","source":["#Loading CSV file \n","import pandas as pd\n","from pandasai import PandasAI\n","from pandasai.llm.openai import OpenAI\n","file_path ='https://raw.githubusercontent.com/gventuri/pandas-ai/main/examples/data/Loan%20payments%20data.csv'\n","df = pd.read_csv(file_path)"],"metadata":{"id":"WnP-JPZzcFrJ"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["llm = OpenAI(api_token=API_KEY)\n","pandas_ai = PandasAI(llm, verbose=True)"],"metadata":{"id":"gupY58GRcFa4"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["# Enter Prompt related to data or Select from Pre-defined for demo purposes.\n","\n","prompt = 'Generate bar Plot of Loans Paid by Men & Women' #@param [ \"How many loans are from Women that have been paid off?\", \"Generate bar Plot of Loans Paid by Men & Women\"] {allow-input: true}"],"metadata":{"id":"FOK-uaPBcFOq"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["response = pandas_ai.run(df, prompt = prompt)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"GXeX1QghiC0F","outputId":"30842d6a-af1b-4a52-d0b2-03bc10008f0e","executionInfo":{"status":"ok","timestamp":1684893610216,"user_tz":-600,"elapsed":36186,"user":{"displayName":"Amjad Raza","userId":"06768084019046926999"}}},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Running PandasAI with openai LLM...\n","\n","Code generated:\n","```\n","import pandas as pd\n","import matplotlib.pyplot as plt\n","\n","# Load the dataframe\n","df = pd.read_csv('loan_data.csv')\n","\n","# Filter the dataframe to only include paid off loans\n","paid_off_df = df[df['loan_status'] == 'PAIDOFF']\n","\n","# Group the dataframe by gender and loan status\n","gender_grouped_df = paid_off_df.groupby(['Gender', 'loan_status']).count()['Loan_ID']\n","\n","# Create a bar plot\n","gender_grouped_df.plot(kind='bar')\n","\n","# Set the title and axis labels\n","plt.title('Loans Paid by Men & Women')\n","plt.xlabel('Gender, Loan Status')\n","plt.ylabel('Number of Loans')\n","\n","# Show the plot\n","plt.show()\n","```\n","\n","Code running:\n","```\n","paid_off_df = df[df['loan_status'] == 'PAIDOFF']\n","gender_grouped_df = paid_off_df.groupby(['Gender', 'loan_status']).count()[\n"," 'Loan_ID']\n","gender_grouped_df.plot(kind='bar')\n","plt.title('Loans Paid by Men & Women')\n","plt.xlabel('Gender, Loan Status')\n","plt.ylabel('Number of Loans')\n","plt.show()\n","```\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["Answer: \n","Conversational answer: Sure, I can help you with that! To generate a bar plot of loans paid by men and women, we can use a data visualization tool like Matplotlib or Seaborn in Python. We'll need to have a dataset that includes information on the loan amounts paid by both men and women. Once we have that, we can create a bar plot with two bars - one for men and one for women - and the height of each bar will represent the total loan amount paid by that gender. This will give us a visual representation of the difference in loan payments between men and women.\n"]}]},{"cell_type":"code","source":["#Let us run the code ourselves and find out the results matches or not?\n","import pandas as pd\n","file_path ='https://raw.githubusercontent.com/gventuri/pandas-ai/main/examples/data/Loan%20payments%20data.csv'\n","df = pd.read_csv(file_path)\n","num_loans = len(df[(df['Gender'] == 'male') & (df['loan_status'] == 'PAIDOFF')]\n"," )\n","print(num_loans)"],"metadata":{"id":"J8K29pWolDbI","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1684892330884,"user_tz":-600,"elapsed":326,"user":{"displayName":"Amjad Raza","userId":"06768084019046926999"}},"outputId":"29a49e10-8786-438b-f3fb-d123386e5a2a"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["247\n"]}]},{"cell_type":"code","source":["import pandas as pd\n","file_path ='https://raw.githubusercontent.com/gventuri/pandas-ai/main/examples/data/Loan%20payments%20data.csv'\n","df = pd.read_csv(file_path)\n","num_loans = len(df[(df['Gender'] == 'female') & (df['loan_status'] == 'PAIDOFF')]\n"," )\n","print(num_loans)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"WgUMtfAOe0t4","executionInfo":{"status":"ok","timestamp":1684893561284,"user_tz":-600,"elapsed":352,"user":{"displayName":"Amjad Raza","userId":"06768084019046926999"}},"outputId":"26b23a27-11b5-4a1b-f724-b5cd587af1d8"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["53\n"]}]},{"cell_type":"markdown","source":["The answers generated by Pandas AI and manually are same. However, it may not be a case always. "],"metadata":{"id":"UbeJXL3wkmXE"}},{"cell_type":"markdown","source":["\n","# Remarks\n","In this concise tutorial, we have explored the Pandasai Library and gained insight into its higher-level architecture. This library offers a convenient solution for individuals to inquire about their data without the need to train in-house Large Language Models (LLMs) on company data. While there are various potential applications for this tool, it's important to remain mindful that the generated code by LLMs may occasionally produce unexpected outputs.\n","\n","It's worth emphasizing that Pandas AI is an actively developed project, indicating ongoing efforts to improve and enhance its functionality. With dedicated contributors, exciting features are being developed and added to this library.\n","\n","> **Stay tuned! There's more to come in the world of Pandas AI as it evolves and continues to empower users in their data exploration and analysis endeavors.**\n"],"metadata":{"id":"AQ11XG3JaOH3"}},{"cell_type":"code","source":[],"metadata":{"id":"0NrbEwgFXswe"},"execution_count":null,"outputs":[]}]} \ No newline at end of file +{"cells":[{"attachments":{},"cell_type":"markdown","metadata":{"id":"8OnF6qsbDG1t"},"source":["#[PANDASAI](https://github.com/gventuri/pandas-ai) : A generative AI capabilities to Pandas Dataframes\n","\n"]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"zYGici1BqvD4"},"source":["## Supported Models\n","\n","The Pandasai API currently supports several models, and it is continuously being developed with the possibility of adding more models in the future. The supported models include:\n","\n","1. OpenAI\n","2. StarCoder by Huggingface\n","3. Falcon by Huggingface\n","4. Azure ChatGPT API\n","5. OpenAssistant\n","6. Google PaLM\n","\n","These models can be utilized in a conversational form, allowing users to interact with them effectively.\n","\n","To facilitate the usage of these models, this tutorial provides guidance on running them using Google Colab. Google Colab is a platform that enables straightforward onboarding and provides a Google Colab Notebook, which simplifies the process of getting started.\n","\n","By leveraging the provided Google Colab Notebook, users can easily run the supported models within a conversational context, enhancing the overall interactive experience and enabling efficient data analysis.\n","\n","Please note that as the Pandasai API evolves, additional models may be incorporated, expanding the range of options available to users."]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"mFPp6trsrauF"},"source":["## Learning Objectives:\n","This tutorial aims to help you achieve the following learning objectives:\n","\n","1. Install the pandasai library.\n","2. Set up the API_TOKEN using either the OpenAI platform or the Hugging Face platform.\n","3. Explore and run basic functionalities provided by pandasai.\n","4. Execute examples using pandasai with predefined prompts for experimentation.\n","\n","Please note that while the OpenAI platform is not free, it is still reasonably priced for running a few queries. On the other hand, the StartCoder model by Hugging Face is available for personal use at no cost.\n"]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"yJjtSdTirwi1"},"source":["## Prerequisites\n","Before proceeding with this tutorial, make sure you meet the following prerequisites:\n","\n","1. Basic understanding of Python, Pandas, and APIs for generative models.\n","2. Obtain API tokens from the openai platform and/or Hugging Face, depending on the models you intend to use.\n","3. Demonstrated eagerness to learn and develop your skills.\n","\n","Having a foundational knowledge of Python, Pandas, and generative models APIs will be beneficial for understanding the concepts covered in this tutorial. Additionally, acquiring the necessary API tokens from the respective platforms will enable you to interact with the models effectively.\n","\n","It's important to approach this tutorial with a positive attitude and a willingness to learn and improve your skills. Through active participation and a growth mindset, you will be able to make the most of this learning opportunity."]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"-VQE9nGwDaiG"},"source":["# Getting Started\n","\n","Installing `Pandasai` is pretty striaght forward using `pip`. The recent releases are hosted on [Pnadasai Pypi](https://pypi.org/project/pandasai/) page. Always check the version, you are going to install. Make sure, check out the [Issues](https://github.com/gventuri/pandas-ai/issues) page of its GitHub Reporistry for any problems you face. "]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"MtzpjcogPC4z"},"source":[]},{"cell_type":"code","execution_count":null,"metadata":{"id":"qtqSnCgwDDCg"},"outputs":[],"source":["!pip install --upgrade pandas pandasai"]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"DrrlU4QqDmxl"},"source":["Now we import the dependencies:"]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"8S1QClHBfcWV"},"source":["## Generate OPENAI API Token\n","\n","Users are required to generate `YOUR_API_TOKEN`. Follow below simple steps to generate your API_TOKEN with \n","[openai](https://platform.openai.com/overview).\n","\n","1. Go to https://openai.com/api/ and signup with your email address or connect your Google Account.\n","2. Go to View API Keys on left side of your Personal Account Settings\n","3. Select Create new Secret key\n","\n","> The API access to openai is a paid service. You have to set up billing. \n",">Read the [Pricing](https://platform.openai.com/docs/quickstart/pricing) information before experimenting."]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"iAtFdufpPN5F"},"source":["## Generate HUGGING FACE PLATFORM API Token\n","\n","It will take around 2 mins to generate API token.\n","\n","Users are required to generate `YOUR_API_TOKEN`. Follow below simple steps to generate your API_TOKEN with [Hugging Face](https://huggingface.co/).\n","\n","1. Go to https://huggingface.co/ and signup with your email address or connect your Google Account.\n","2. Go to https://huggingface.co/settings/tokens and generate User Access Token.\n","3. Copy and Save securely for Personal Use\n","\n","> Hugging Face API keys are FREE for personal / educational use."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"ohPMkz4zDqxz"},"outputs":[],"source":["# Import basis libraries\n","import pandas as pd\n","from pandasai import PandasAI\n","from pandasai.llm.openai import OpenAI\n","from pandasai.llm.open_assistant import OpenAssistant\n","from pandasai.llm.starcoder import Starcoder"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"QtLlsddlRSAO"},"outputs":[],"source":["# Define List of Models\n","models = {\n"," \"OpenAI\": OpenAI,\n"," \"Starcoder\": Starcoder,\n"," \"Open-Assistant\": OpenAssistant\n","}\n"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":307,"status":"ok","timestamp":1684891932779,"user":{"displayName":"Amjad Raza","userId":"06768084019046926999"},"user_tz":-600},"id":"sGElcw0NRxeK","outputId":"2b02aef7-23db-4bda-8445-d1b97dd9a58c"},"outputs":[{"name":"stdout","output_type":"stream","text":["Enter API for OpenAI platform\n"]}],"source":["#@title Select Model to Run\n","model_to_run = 'OpenAI' #@param [\"OpenAI\", \"Starcoder\", \"Open-Assistant\"]\n","print(f\"Enter API for {model_to_run} platform\")"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"DS1QdmQJgKm9"},"outputs":[],"source":["# Enter API Key\n","API_KEY = '' #@param {type:\"string\"}"]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"JAO_SzlyDr5x"},"source":["We create a dataframe using pandas:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"nyRo07nqD08l"},"outputs":[],"source":["df = pd.DataFrame({\n"," \"country\": [\"United States\", \"United Kingdom\", \"France\", \"Germany\", \"Italy\", \"Spain\", \"Canada\", \"Australia\", \"Japan\", \"China\"],\n"," \"gdp\": [21400000, 2940000, 2830000, 3870000, 2160000, 1350000, 1780000, 1320000, 516000, 14000000],\n"," \"happiness_index\": [7.3, 7.2, 6.5, 7.0, 6.0, 6.3, 7.3, 7.3, 5.9, 5.0]\n","})"]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"aeTOQettEfWT"},"source":["After loading the Dataframe and input of Prompt, now we are ready to run the Prompt with given dataframe and query. As a first setp, we instantiate the llm model with selected option. In order to understand, what is going under the hood, we set `verbose=True`. Let us run now!"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"HZnx0V18EkzS"},"outputs":[],"source":["# Model Initialisation\n","llm = models[model_to_run](api_token=API_KEY)\n","pandas_ai = PandasAI(llm, conversational=False, verbose=True)\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"BQs22IO-Ti_q"},"outputs":[],"source":["# Enter Prompt related to data or Select from Pre-defined for demo purposes.\n","prompt = 'Plot the histogram of countries showing for each the gpd, using different colors for each bar' #@param [ \"What is the relation between GDP and Happines Index\", \"Plot the histogram of countries showing for each the gpd, using different colors for each bar\", \"GDP of Top 5 Happiest Countries?\"] {allow-input: true}\n"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"executionInfo":{"elapsed":11398,"status":"ok","timestamp":1684891977617,"user":{"displayName":"Amjad Raza","userId":"06768084019046926999"},"user_tz":-600},"id":"m7_erVstXW9V","outputId":"7fad4db4-4758-4813-b8f0-bb619bd86a24"},"outputs":[{"name":"stdout","output_type":"stream","text":["Running PandasAI with openai LLM...\n","\n","Code generated:\n","```\n","import matplotlib.pyplot as plt\n","\n","colors = ['red', 'blue', 'green', 'orange', 'purple', 'pink', 'brown', 'gray', 'olive', 'cyan']\n","plt.bar(df['country'], df['gdp'], color=colors)\n","plt.xticks(rotation=90)\n","plt.xlabel('Country')\n","plt.ylabel('GDP')\n","plt.title('GDP by Country')\n","plt.show()\n","```\n","\n","Code running:\n","```\n","colors = ['red', 'blue', 'green', 'orange', 'purple', 'pink', 'brown',\n"," 'gray', 'olive', 'cyan']\n","plt.bar(df['country'], df['gdp'], color=colors)\n","plt.xticks(rotation=90)\n","plt.xlabel('Country')\n","plt.ylabel('GDP')\n","plt.title('GDP by Country')\n","plt.show()\n","```\n"]},{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["Answer: \n"]}],"source":["response = pandas_ai.run(df, prompt=prompt,\n"," is_conversational_answer=False)"]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"3w4BLXuVY4jO"},"source":["As you can see from above experiments, having `verbose=True`, we can see the code generated by LLMs API and then this code is run to produce and answer on complete dataset. "]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"2A44RePXXldV"},"source":["## Play Around\n","\n","Users can play around various questions about the tiny dataset we generated above. Using this notebook, you can select between Model Options and ask questions based on your problem."]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"iWH56NfdiioM"},"source":["## More Examples\n","\n","In above section, we showed a little demo with small dataframe. Usually data is stored in `.csv` , .=`.xlsx` and other formats. `Pandasai` treats any data uploaded as Pandas dataframe and proceed accordingly. \n","\n","In this section, we include some of the [examples](https://github.com/gventuri/pandas-ai/tree/main/examples) shipped with `pandasai` reporsitory.\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"WnP-JPZzcFrJ"},"outputs":[],"source":["#Loading CSV file \n","import pandas as pd\n","from pandasai import PandasAI\n","from pandasai.llm.openai import OpenAI\n","file_path ='https://raw.githubusercontent.com/gventuri/pandas-ai/main/examples/data/Loan%20payments%20data.csv'\n","df = pd.read_csv(file_path)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"gupY58GRcFa4"},"outputs":[],"source":["llm = OpenAI(api_token=API_KEY)\n","pandas_ai = PandasAI(llm, verbose=True)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"FOK-uaPBcFOq"},"outputs":[],"source":["# Enter Prompt related to data or Select from Pre-defined for demo purposes.\n","\n","prompt = 'Generate bar Plot of Loans Paid by Men & Women' #@param [ \"How many loans are from Women that have been paid off?\", \"Generate bar Plot of Loans Paid by Men & Women\"] {allow-input: true}"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"executionInfo":{"elapsed":36186,"status":"ok","timestamp":1684893610216,"user":{"displayName":"Amjad Raza","userId":"06768084019046926999"},"user_tz":-600},"id":"GXeX1QghiC0F","outputId":"30842d6a-af1b-4a52-d0b2-03bc10008f0e"},"outputs":[{"name":"stdout","output_type":"stream","text":["Running PandasAI with openai LLM...\n","\n","Code generated:\n","```\n","import pandas as pd\n","import matplotlib.pyplot as plt\n","\n","# Load the dataframe\n","df = pd.read_csv('loan_data.csv')\n","\n","# Filter the dataframe to only include paid off loans\n","paid_off_df = df[df['loan_status'] == 'PAIDOFF']\n","\n","# Group the dataframe by gender and loan status\n","gender_grouped_df = paid_off_df.groupby(['Gender', 'loan_status']).count()['Loan_ID']\n","\n","# Create a bar plot\n","gender_grouped_df.plot(kind='bar')\n","\n","# Set the title and axis labels\n","plt.title('Loans Paid by Men & Women')\n","plt.xlabel('Gender, Loan Status')\n","plt.ylabel('Number of Loans')\n","\n","# Show the plot\n","plt.show()\n","```\n","\n","Code running:\n","```\n","paid_off_df = df[df['loan_status'] == 'PAIDOFF']\n","gender_grouped_df = paid_off_df.groupby(['Gender', 'loan_status']).count()[\n"," 'Loan_ID']\n","gender_grouped_df.plot(kind='bar')\n","plt.title('Loans Paid by Men & Women')\n","plt.xlabel('Gender, Loan Status')\n","plt.ylabel('Number of Loans')\n","plt.show()\n","```\n"]},{"data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAjsAAAI3CAYAAAB9FJogAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABPQElEQVR4nO3deXxM9+L/8fckssomRBJE7PtOm0ZsLRVLtUpba60/bm8pFVS1RUuL6tW6tlZvlVapLoqittqXaEvt1BpLEVRIxJJIcn5/9GG+prFkZGKS4/V8PObxMOecmXmfIbx9zuecYzEMwxAAAIBJuTg7AAAAQE6i7AAAAFOj7AAAAFOj7AAAAFOj7AAAAFOj7AAAAFOj7AAAAFOj7AAAAFOj7AAAAFOj7ADIkmPHjslisWjmzJn33LZbt24qUaLEPbcrUaKEnnrqqeyHA4C7oOwAkmbOnCmLxaKtW7c6O4pDdevWTRaLxfrw8/NT9erVNX78eKWkpDg73gNxs6RZLBa9++67t92mU6dOslgs8vHxecDp/s/169c1dOhQlShRQt7e3qpQoYIGDRqU5de//PLLcnFxUUJCgs3yhIQEubi4yMPDQ9evX7dZd/ToUVksFr3xxhsO2Qcgt6LsACbn4eGhWbNmadasWRo9erQCAwM1aNAgde3a1a73CQ8P17Vr1/Tiiy/mUNKc5enpqa+//jrT8itXrmjhwoXy9PR0Qqr/M2TIEI0dO1aNGzfWhAkT1LJlS3311VdZfn29evVkGIY2bdpks3zz5s1ycXHRjRs3MpX5m9vWq1cv+zsA5GKUHcDk8uXLp86dO6tz587q27evVq1apTp16uibb77R6dOns/w+FotFnp6ecnV1zcG0OadFixbat2+fdu7cabN84cKFSk1N1ZNPPumkZH+bO3euWrRooenTp6t3794aP368jh8/nuXX3ywsGzdutFm+adMmVatWTeXLl8+0buPGjXJxcVHdunWzvwNALkbZAeywfft2NW/eXH5+fvLx8VHjxo21ZcsWm20SEhI0aNAgVa1aVT4+PvLz81Pz5s0z/SO7du1aWSwWffvtt3rvvfdUrFgxeXp6qnHjxjp8+LDNtocOHVLbtm0VEhIiT09PFStWTO3bt1diYqLd++Di4qJGjRpJ+vsQT1bz3mnOzoIFC1SlShV5enqqSpUqmj9/vt2ZVqxYoRo1asjT01OVKlXSDz/8YF1381DLRx99lOl1mzdvlsViue2IzT9FRkaqZMmSmjNnjs3y2bNnq1mzZgoMDLzt65YuXar69esrf/788vX1VcuWLbV3716bbbp16yYfHx+dOnVKrVu3lo+Pj4KCgjRo0CClp6dn5SuQi4uLDMOwWebh4ZGl10pS8eLFFRYWlmlkZ9OmTYqKilLdunVvu65y5coKCAiQJJ07d049e/ZUcHCwPD09Vb16dX3xxRc2r7n55+A///mPpkyZolKlSsnb21tNmzbVyZMnZRiGRo0apWLFisnLy0vPPPNMpkNr0oP7XgGJsgNk2d69e1W/fn3t3LlTr732moYNG6a4uDg1atRIv/zyi3W7o0ePasGCBXrqqaf04YcfavDgwdq9e7caNmx425GUsWPHav78+Ro0aJCGDh2qLVu2qFOnTtb1qampio6O1pYtW/TKK69oypQp6t27t44ePapLly7d174cOXJEklSwYEG7895qxYoVatu2rSwWi8aMGaPWrVure/fuds19OnTokNq1a6fmzZtrzJgxypcvn55//nmtXLlSklSqVClFRUVp9uzZmV47e/Zs+fr66plnnsnSZ3Xo0EFz5861loq//vpLK1asUMeOHW+7/axZs9SyZUv5+Pjo/fff17Bhw7Rv3z7Vq1dPx44ds9k2PT1d0dHRKliwoP7zn/+oYcOGGj9+vD799NMsZevevbuWLVumpUuXZmn726lXr562bt1qnY+Vmpqq3377TXXr1lXdunW1efNm675fvHjRui+SdO3aNTVq1EizZs1Sp06d9MEHH8jf31/dunXTf//730yfNXv2bE2dOlWvvPKKBg4cqHXr1umFF17QW2+9pWXLlmnIkCHq3bu3Fi1alGnu0YP8XgFJkgHAmDFjhiHJ+O233+64TevWrQ13d3fjyJEj1mWnT582fH19jQYNGliXXb9+3UhPT7d5bVxcnOHh4WGMHDnSumzNmjWGJKNixYpGSkqKdfl///tfQ5Kxe/duwzAMY/v27YYk47vvvrN7v7p27Wrkz5/fOH/+vHH+/Hnj8OHDxujRow2LxWJUq1bNrrxxcXGGJGPGjBnWZTVq1DBCQ0ONS5cuWZetWLHCkGSEh4ffM194eLghyZg3b551WWJiohEaGmrUrFnTumzatGmGJGP//v3WZampqUahQoWMrl273vUzbub+4IMPjD179hiSjA0bNhiGYRhTpkwxfHx8jCtXrli/q5suX75sBAQEGL169bJ5v/j4eMPf399medeuXQ1JNt+XYRhGzZo1jdq1a9/ze7hx44bRuXNnw93d3cifP7+xefPme77mdqZMmWKzf7GxsYYk4/jx48a+ffsMScbevXsNwzCMxYsXG5KM2bNnG4ZhGBMmTDAkGV999ZX1/VJTU43IyEjDx8fHSEpKMgzj/77PoKAgm9/3oUOHGpKM6tWrGzdu3LAu79Chg+Hu7m5cv37dMIwH+70CNzGyA2RBenq6VqxYodatW6tUqVLW5aGhoerYsaM2btyopKQkSX8fenBxcbG+7sKFC/Lx8VH58uX1+++/Z3rv7t27y93d3fq8fv36kv4eIZIkf39/SdLy5ct19epVu7NfuXJFQUFBCgoKUpkyZfTGG28oMjLSerjJ3rw3nTlzRjt27FDXrl2tGSXpySefVKVKlbKcr0iRInr22Wetz/38/NSlSxdt375d8fHxkqQXXnhBnp6eNqM7y5cv119//aXOnTtn+bMqV66satWqWQ97zZkzR88884y8vb0zbbty5UpdunRJHTp00F9//WV9uLq6KiIiQmvWrMn0mpdeesnmef369a2/j3fz2muvaenSpdq9e7ciIiLUokUL7dixw7r+zJkzslgsmj59+l3f55/zdjZt2qSiRYuqePHiqlChggIDA62Hsv45Ofmnn35SSEiIOnToYH0/Nzc39evXT8nJyVq3bp3NZz3//PM2v+8RERGSpM6dOytfvnw2y1NTU3Xq1ClJD/Z7BW6i7ABZcP78eV29elXly5fPtK5ixYrKyMjQyZMnJUkZGRn66KOPVLZsWXl4eKhQoUIKCgrSrl27bjvHpnjx4jbPCxQoIOnvwwySVLJkScXExOizzz5ToUKFFB0drSlTpmR5vo6np6dWrlyplStXav369Tp58qQ2bdpkLW325r3p5uTZsmXLZlp3u+/pTsqUKSOLxWKzrFy5cpJkPaQREBCgVq1a2cy3mT17tooWLaonnngiy58lSR07dtR3332nw4cPa/PmzXc8hHXo0CFJ0hNPPGEtizcfK1as0Llz52y29/T0VFBQkM2yAgUKWH8f7+TUqVOaOHGihgwZonLlymnBggUqWbKkmjZtqgMHDkiS9uzZI+n/CsWdVKlSRQEBATaFJioqStLfE8wjIyNt1oWFhVn//B0/flxly5a1Ft+bKlasaF1/q3/+ub1ZfMLCwm67/Ob38KC+V+BW+e69CQB7jB49WsOGDVOPHj00atQoBQYGysXFRa+++qoyMjIybX+ns5uMWyarjh8/Xt26ddPChQu1YsUK9evXT2PGjNGWLVtUrFixu+ZxdXVVkyZNHJbXWbp06aLvvvtOmzdvVtWqVfXjjz9ary1jjw4dOmjo0KHq1auXChYsqKZNm952u5v7PmvWLIWEhGRaf+vohXTn38d7+eWXX5Senq7HHntMkuTr66ulS5cqKipKTZo00YYNG/Tpp5+qevXqqlKlyl3fy8XFRZGRkda5OZs2bbK5hk7dunX1+eefW+fytG7d+r4yS3fe33v9eX5Q3ytwK8oOkAVBQUHy9va2/k/7Vn/88YdcXFys/6P9/vvv9fjjj2c65HDp0iUVKlTovjNUrVpVVatW1VtvvaXNmzcrKipKn3zyyR0vlJdV95s3PDxc0v/9T/1Wt/ue7uTw4cMyDMNmdOfgwYOSZHMV5mbNmikoKEizZ89WRESErl69el/X/ClevLiioqK0du1a/fvf/870j+tNpUuXliQVLlz4rmUxu27u982RQUkKDg7W8uXLFRUVpYYNG+rPP/+0OUPtburVq6elS5fqxx9/1Llz56wjO9LfZefNN9/UTz/9pGvXrtlcXyc8PFy7du1SRkaGTYH8448/rOsd4UF9r8CtOIwFZIGrq6uaNm2qhQsX2pwtcvbsWc2ZM0f16tWTn5+fdVvjH6cQf/fdd9Y5C/ZKSkpSWlqazbKqVavKxcXFIVdBvt+8oaGhqlGjhr744gubw10rV67Uvn37svz5p0+ftjldPSkpSV9++aVq1Khh8z//fPnyqUOHDvr22281c+ZMVa1aVdWqVcvy59zq3Xff1YgRI/TKK6/ccZvo6Gj5+flp9OjRunHjRqb158+fv6/P/qd69erJw8NDY8eOtZmTVbp0aU2YMEEnTpyQv7+/GjZsmOX3k6T3339f3t7eqlGjhnXdo48+qnz58mncuHE220p/X4coPj5e33zzjXVZWlqaJk2aJB8fnyx//r08qO8VuBUjO8AtPv/8cy1btizT8v79++vdd9/VypUrVa9ePb388svKly+fpk2bppSUFOs/HpL01FNPaeTIkerevbvq1q2r3bt3a/bs2TYTm+2xevVq9e3bV88//7zKlSuntLQ0zZo1S66urmrbtu1976sj8o4ZM0YtW7ZUvXr11KNHDyUkJGjSpEmqXLmykpOTs/T55cqVU8+ePfXbb78pODhYn3/+uc6ePasZM2Zk2rZLly6aOHGi1qxZo/fff9/ufb2pYcOG9/zH28/PTx9//LFefPFF1apVS+3bt1dQUJBOnDihJUuWKCoqSpMnT77vDDcFBQVpzJgxiomJUdWqVdWjRw+FhIRo69at+uKLL/TYY4/p999/13PPPaelS5fKzc3tru/36KOPyt3dXbGxsWrUqJHNyJW3t7eqV6+u2NhYBQQE2BwW6927t6ZNm6Zu3bpp27ZtKlGihL7//ntt2rRJEyZMkK+vb7b3VXpw3ytgw5mnggG5xc1Tz+/0OHnypGEYhvH7778b0dHRho+Pj+Ht7W08/vjjmU4Tvn79ujFw4EAjNDTU8PLyMqKioozY2FijYcOGRsOGDa3b3Tz1/J+nlP/zFO+jR48aPXr0MEqXLm14enoagYGBxuOPP278/PPP99yvf55OfTtZzXu7U88NwzDmzZtnVKxY0fDw8DAqVapk/PDDD0bXrl2zfOp5y5YtjeXLlxvVqlUzPDw8jAoVKtz1NPvKlSsbLi4uxp9//nnP97819wcffHDX7e70Xa1Zs8aIjo42/P39DU9PT6N06dJGt27djK1bt97ztSNGjDCy+tfsggULjPr16xv58+c3vLy8jDp16hgff/yxkZaWZnz66aeGJKNHjx5Zeq/IyEhDkvHGG29kWtevXz9DktG8efNM686ePWt0797dKFSokOHu7m5UrVo10+/3nb7PO/15vtNlHR7U9woYhmFYDOMf49cAkIvVrFlTgYGBWrVqlbOjAMgjmLMDIM/YunWrduzYoS5dujg7CoA8hJEdALnenj17tG3bNo0fP15//fWXjh496vS7lAPIOxjZAZDrff/99+revbtu3Lihr7/+mqIDwC6M7AAAAFNjZAcAAJgaZQcAAJgaFxXU3/dqOX36tHx9fTPdkBAAAOROhmHo8uXLKlKkyF3vk0fZ0d+Xq//nnXoBAEDecPLkybveFJmyI1kvg37y5Enr/Y0AAEDulpSUpLCwsHvezoSyo/+767Cfnx9lBwCAPOZeU1CYoAwAAEyNsgMAAEyNsgMAAEyNsgMAAEyNsgMAAEyNsgMAAEzNqWVnzJgxeuSRR+Tr66vChQurdevWOnDggM02jRo1ksVisXm89NJLNtucOHFCLVu2lLe3twoXLqzBgwcrLS3tQe4KAADIpZx6nZ1169apT58+euSRR5SWlqY33nhDTZs21b59+5Q/f37rdr169dLIkSOtz729va2/Tk9PV8uWLRUSEqLNmzfrzJkz6tKli9zc3DR69OgHuj8AACD3sRiGYTg7xE3nz59X4cKFtW7dOjVo0EDS3yM7NWrU0IQJE277mqVLl+qpp57S6dOnFRwcLEn65JNPNGTIEJ0/f17u7u73/NykpCT5+/srMTGRiwoCAJBHZPXf71w1ZycxMVGSFBgYaLN89uzZKlSokKpUqaKhQ4fq6tWr1nWxsbGqWrWqtehIUnR0tJKSkrR3797bfk5KSoqSkpJsHgAAwJxyze0iMjIy9OqrryoqKkpVqlSxLu/YsaPCw8NVpEgR7dq1S0OGDNGBAwf0ww8/SJLi4+Ntio4k6/P4+PjbftaYMWP0zjvv5NCeAACA3CTXlJ0+ffpoz5492rhxo83y3r17W39dtWpVhYaGqnHjxjpy5IhKly59X581dOhQxcTEWJ/fvJEYAAAwn1xxGKtv375avHix1qxZc9dbtEtSRESEJOnw4cOSpJCQEJ09e9Zmm5vPQ0JCbvseHh4e1pt+cvNPAADMzallxzAM9e3bV/Pnz9fq1atVsmTJe75mx44dkqTQ0FBJUmRkpHbv3q1z585Zt1m5cqX8/PxUqVKlHMkNAADyDqcexurTp4/mzJmjhQsXytfX1zrHxt/fX15eXjpy5IjmzJmjFi1aqGDBgtq1a5cGDBigBg0aqFq1apKkpk2bqlKlSnrxxRc1btw4xcfH66233lKfPn3k4eHhzN0DAKcq8foSZ0fAA3RsbEtnR8i1nDqy8/HHHysxMVGNGjVSaGio9fHNN99Iktzd3fXzzz+radOmqlChggYOHKi2bdtq0aJF1vdwdXXV4sWL5erqqsjISHXu3FldunSxuS4PAAB4eDl1ZOdel/gJCwvTunXr7vk+4eHh+umnnxwVCwAAmEiumKAMAACQUyg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1JxadsaMGaNHHnlEvr6+Kly4sFq3bq0DBw7YbHP9+nX16dNHBQsWlI+Pj9q2bauzZ8/abHPixAm1bNlS3t7eKly4sAYPHqy0tLQHuSsAACCXcmrZWbdunfr06aMtW7Zo5cqVunHjhpo2baorV65YtxkwYIAWLVqk7777TuvWrdPp06fVpk0b6/r09HS1bNlSqamp2rx5s7744gvNnDlTw4cPd8YuAQCAXMZiGIbh7BA3nT9/XoULF9a6devUoEEDJSYmKigoSHPmzNFzzz0nSfrjjz9UsWJFxcbG6rHHHtPSpUv11FNP6fTp0woODpYkffLJJxoyZIjOnz8vd3f3e35uUlKS/P39lZiYKD8/vxzdRwB4UEq8vsTZEfAAHRvb0tkRHris/vudq+bsJCYmSpICAwMlSdu2bdONGzfUpEkT6zYVKlRQ8eLFFRsbK0mKjY1V1apVrUVHkqKjo5WUlKS9e/fe9nNSUlKUlJRk8wAAAOaUa8pORkaGXn31VUVFRalKlSqSpPj4eLm7uysgIMBm2+DgYMXHx1u3ubXo3Fx/c93tjBkzRv7+/tZHWFiYg/cGAADkFrmm7PTp00d79uzR3Llzc/yzhg4dqsTEROvj5MmTOf6ZAADAOfI5O4Ak9e3bV4sXL9b69etVrFgx6/KQkBClpqbq0qVLNqM7Z8+eVUhIiHWbX3/91eb9bp6tdXObf/Lw8JCHh4eD9wIAAORGTh3ZMQxDffv21fz587V69WqVLFnSZn3t2rXl5uamVatWWZcdOHBAJ06cUGRkpCQpMjJSu3fv1rlz56zbrFy5Un5+fqpUqdKD2REAAJBrOXVkp0+fPpozZ44WLlwoX19f6xwbf39/eXl5yd/fXz179lRMTIwCAwPl5+enV155RZGRkXrsscckSU2bNlWlSpX04osvaty4cYqPj9dbb72lPn36MHoDAACcW3Y+/vhjSVKjRo1sls+YMUPdunWTJH300UdycXFR27ZtlZKSoujoaE2dOtW6raurqxYvXqx///vfioyMVP78+dW1a1eNHDnyQe0GAADIxXLVdXachevsADAjrrPzcOE6O3nkOjsAAACORtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmZnfZWbZsmTZu3Gh9PmXKFNWoUUMdO3bUxYsXHRoOAAAgu+wuO4MHD1ZSUpIkaffu3Ro4cKBatGihuLg4xcTEODwgAABAduSz9wVxcXGqVKmSJGnevHl66qmnNHr0aP3+++9q0aKFwwMCAABkh90jO+7u7rp69aok6eeff1bTpk0lSYGBgdYRHwAAgNzC7pGdevXqKSYmRlFRUfr111/1zTffSJIOHjyoYsWKOTwgAABAdtg9sjN58mTly5dP33//vT7++GMVLVpUkrR06VI1a9bM4QEBAACyw+6RneLFi2vx4sWZln/00UcOCQQAAOBIdpcdScrIyNDhw4d17tw5ZWRk2Kxr0KCBQ4IBAAA4gt1lZ8uWLerYsaOOHz8uwzBs1lksFqWnpzssHAAAQHbZXXZeeukl1alTR0uWLFFoaKgsFktO5AIAAHAIu8vOoUOH9P3336tMmTI5kQcAAMCh7D4bKyIiQocPH86JLAAAAA5n98jOK6+8ooEDByo+Pl5Vq1aVm5ubzfpq1ao5LBwAAEB22V122rZtK0nq0aOHdZnFYpFhGExQBgAAuc593RsLAAAgr7C77ISHh+dEDgAAgBxxXxcVlKR9+/bpxIkTSk1NtVn+9NNPZzsUAACAo9hddo4ePapnn31Wu3fvts7VkWS93g5zdgAAQG5i96nn/fv3V8mSJXXu3Dl5e3tr7969Wr9+verUqaO1a9fmQEQAAID7Z/fITmxsrFavXq1ChQrJxcVFLi4uqlevnsaMGaN+/fpp+/btOZETAADgvtg9spOeni5fX19JUqFChXT69GlJf09cPnDggGPTAQAAZJPdIztVqlTRzp07VbJkSUVERGjcuHFyd3fXp59+qlKlSuVERgAAgPtmd9l56623dOXKFUnSyJEj9dRTT6l+/foqWLCgvvnmG4cHBAAAyA67y050dLT112XKlNEff/yhhIQEFShQgDugAwCAXOe+r7MjSX/++ackqVixYg4JAwAA4Gh2T1DOyMjQyJEj5e/vr/DwcIWHhysgIECjRo1SRkaGXe+1fv16tWrVSkWKFJHFYtGCBQts1nfr1k0Wi8Xm0axZM5ttEhIS1KlTJ/n5+SkgIEA9e/ZUcnKyvbsFAABMyu6RnTfffFPTp0/X2LFjFRUVJUnauHGj3n77bV2/fl3vvfdelt/rypUrql69unr06KE2bdrcdptmzZppxowZ1uceHh426zt16qQzZ85o5cqVunHjhrp3767evXtrzpw59u4aAAAwIbvLzhdffKHPPvvM5rYQ1apVU9GiRfXyyy/bVXaaN2+u5s2b33UbDw8PhYSE3Hbd/v37tWzZMv3222+qU6eOJGnSpElq0aKF/vOf/6hIkSJZzgIAAMzJ7sNYCQkJqlChQqblFSpUUEJCgkNC3Wrt2rUqXLiwypcvr3//+9+6cOGCdV1sbKwCAgKsRUeSmjRpIhcXF/3yyy93fM+UlBQlJSXZPAAAgDnZXXaqV6+uyZMnZ1o+efJkVa9e3SGhbmrWrJm+/PJLrVq1Su+//77WrVun5s2bW++/FR8fr8KFC9u8Jl++fAoMDFR8fPwd33fMmDHy9/e3PsLCwhyaGwAA5B52H8YaN26cWrZsqZ9//lmRkZGS/h5hOXnypH766SeHhmvfvr3111WrVlW1atVUunRprV27Vo0bN77v9x06dKhiYmKsz5OSkig8AACYlN0jOw0bNtTBgwf17LPP6tKlS7p06ZLatGmjAwcOqH79+jmR0apUqVIqVKiQDh8+LEkKCQnRuXPnbLZJS0tTQkLCHef5SH/PA/Lz87N5AAAAc7qv6+wUKVIk00TkP//8U71799ann37qkGC38+eff+rChQsKDQ2VJEVGRurSpUvatm2bateuLUlavXq1MjIyFBERkWM5AABA3mH3yM6dXLhwQdOnT7frNcnJydqxY4d27NghSYqLi9OOHTt04sQJJScna/DgwdqyZYuOHTumVatW6ZlnnlGZMmWsV3GuWLGimjVrpl69eunXX3/Vpk2b1LdvX7Vv354zsQAAgCQHlp37sXXrVtWsWVM1a9aUJMXExKhmzZoaPny4XF1dtWvXLj399NMqV66cevbsqdq1a2vDhg0219qZPXu2KlSooMaNG6tFixaqV69ejo4uAQCAvCVbt4vIrkaNGskwjDuuX758+T3fIzAwkAsIAgCAO3LqyA4AAEBOy/LIzp1u53DTpUuXspsFAADA4bJcdvz9/e+5vkuXLtkOBAAA4EhZLju33owTAAAgr2DODgAAMDXKDgAAMDXKDgAAMDXKDgAAMLUslZ1atWrp4sWLkqSRI0fq6tWrORoKAADAUbJUdvbv368rV65Ikt555x0lJyfnaCgAAABHydKp5zVq1FD37t1Vr149GYah//znP/Lx8bnttsOHD3doQAAAgOzIUtmZOXOmRowYocWLF8tisWjp0qXKly/zSy0WC2UHAADkKlkqO+XLl9fcuXMlSS4uLlq1apUKFy6co8EAAAAcwe67nmdkZOREDgAAgBxhd9mRpCNHjmjChAnav3+/JKlSpUrq37+/Spcu7dBwAAAA2WX3dXaWL1+uSpUq6ddff1W1atVUrVo1/fLLL6pcubJWrlyZExkBAADum90jO6+//roGDBigsWPHZlo+ZMgQPfnkkw4LBwAAkF12j+zs379fPXv2zLS8R48e2rdvn0NCAQAAOIrdZScoKEg7duzItHzHjh2coQUAAHIduw9j9erVS71799bRo0dVt25dSdKmTZv0/vvvKyYmxuEBAQAAssPusjNs2DD5+vpq/PjxGjp0qCSpSJEievvtt9WvXz+HBwQAAMgOu8uOxWLRgAEDNGDAAF2+fFmS5Ovr6/BgAAAAjnBf19m5iZIDAAByO7snKAMAAOQllB0AAGBqlB0AAGBqdpWdGzduqHHjxjp06FBO5QEAAHAou8qOm5ubdu3alVNZAAAAHM7uw1idO3fW9OnTcyILAACAw9l96nlaWpo+//xz/fzzz6pdu7by589vs/7DDz90WDgAAIDssrvs7NmzR7Vq1ZIkHTx40GadxWJxTCoAAAAHsbvsrFmzJidyAAAA5Ij7PvX88OHDWr58ua5duyZJMgzDYaEAAAAcxe6yc+HCBTVu3FjlypVTixYtdObMGUlSz549NXDgQIcHBAAAyA67y86AAQPk5uamEydOyNvb27q8Xbt2WrZsmUPDAQAAZJfdc3ZWrFih5cuXq1ixYjbLy5Ytq+PHjzssGAAAgCPYPbJz5coVmxGdmxISEuTh4eGQUAAAAI5id9mpX7++vvzyS+tzi8WijIwMjRs3To8//rhDwwEAAGSX3Yexxo0bp8aNG2vr1q1KTU3Va6+9pr179yohIUGbNm3KiYwAAAD3ze6RnSpVqujgwYOqV6+ennnmGV25ckVt2rTR9u3bVbp06ZzICAAAcN/sHtmRJH9/f7355puOzgIAAOBw91V2Ll68qOnTp2v//v2SpEqVKql79+4KDAx0aDgAAIDssvsw1vr161WiRAlNnDhRFy9e1MWLFzVx4kSVLFlS69evz4mMAAAA983ukZ0+ffqoXbt2+vjjj+Xq6ipJSk9P18svv6w+ffpo9+7dDg8JAABwv+we2Tl8+LAGDhxoLTqS5OrqqpiYGB0+fNih4QAAALLL7rJTq1Yt61ydW+3fv1/Vq1d3SCgAAABHydJhrF27dll/3a9fP/Xv31+HDx/WY489JknasmWLpkyZorFjx+ZMSgAAgPtkMQzDuNdGLi4uslgsutemFotF6enpDgv3oCQlJcnf31+JiYny8/NzdhwAcIgSry9xdgQ8QMfGtnR2hAcuq/9+Z2lkJy4uzmHBAAAAHqQslZ3w8PCczgEAAJAj7uuigqdPn9bGjRt17tw5ZWRk2Kzr16+fQ4IBAAA4gt1lZ+bMmfrXv/4ld3d3FSxYUBaLxbrOYrFQdgAAQK5id9kZNmyYhg8frqFDh8rFxe4z1wEAAB4ou9vK1atX1b59e4oOAADIE+xuLD179tR3332XE1kAAAAczu7DWGPGjNFTTz2lZcuWqWrVqnJzc7NZ/+GHHzosHAAAQHbdV9lZvny5ypcvL0mZJigDAADkJnaXnfHjx+vzzz9Xt27dciAOAACAY9k9Z8fDw0NRUVE5kQUAAMDh7C47/fv316RJk3IiCwAAgMPZXXZ+/fVXffHFFypVqpRatWqlNm3a2DzssX79erVq1UpFihSRxWLRggULbNYbhqHhw4crNDRUXl5eatKkiQ4dOmSzTUJCgjp16iQ/Pz8FBASoZ8+eSk5Otne3AACASdlddgICAtSmTRs1bNhQhQoVkr+/v83DHleuXFH16tU1ZcqU264fN26cJk6cqE8++US//PKL8ufPr+joaF2/ft26TadOnbR3716tXLlSixcv1vr169W7d297dwsAAJiUxTAMw9khpL/P5Jo/f75at24t6e9RnSJFimjgwIEaNGiQJCkxMVHBwcGaOXOm2rdvr/3796tSpUr67bffVKdOHUnSsmXL1KJFC/35558qUqRIlj47q7eIB4C8pMTrS5wdAQ/QsbEtnR3hgcvqv9+59jLIcXFxio+PV5MmTazL/P39FRERodjYWElSbGysAgICrEVHkpo0aSIXFxf98ssvd3zvlJQUJSUl2TwAAIA52X3qecmSJe96PZ2jR49mK9BN8fHxkqTg4GCb5cHBwdZ18fHxKly4sM36fPnyKTAw0LrN7YwZM0bvvPOOQ3ICAIDcze6y8+qrr9o8v3HjhrZv365ly5Zp8ODBjsqVo4YOHaqYmBjr86SkJIWFhTkxEQAAyCl2l53+/fvfdvmUKVO0devWbAe6KSQkRJJ09uxZhYaGWpefPXtWNWrUsG5z7tw5m9elpaUpISHB+vrb8fDwkIeHh8OyAgCA3Mthc3aaN2+uefPmOertVLJkSYWEhGjVqlXWZUlJSfrll18UGRkpSYqMjNSlS5e0bds26zarV69WRkaGIiIiHJYFAADkXXaP7NzJ999/r8DAQLtek5ycrMOHD1ufx8XFaceOHQoMDFTx4sX16quv6t1331XZsmVVsmRJDRs2TEWKFLGesVWxYkU1a9ZMvXr10ieffKIbN26ob9++at++fZbPxAIAAOZmd9mpWbOmzQRlwzAUHx+v8+fPa+rUqXa919atW/X4449bn9+cR9O1a1fNnDlTr732mq5cuaLevXvr0qVLqlevnpYtWyZPT0/ra2bPnq2+ffuqcePGcnFxUdu2bTVx4kR7dwsAAJiU3dfZ+edZTC4uLgoKClKjRo1UoUIFh4Z7ULjODgAz4jo7Dxeus3Pnf7/tHtkZMWJEtoIBAAA8SLn2ooIAAACOkOWRHRcXl7teTFD6+5YPaWlp2Q4FAADgKFkuO/Pnz7/jutjYWE2cOFEZGRkOCQUAAOAoWS47zzzzTKZlBw4c0Ouvv65FixapU6dOGjlypEPDAQAAZNd9zdk5ffq0evXqpapVqyotLU07duzQF198ofDwcEfnAwAAyBa7yk5iYqKGDBmiMmXKaO/evVq1apUWLVqkKlWq5FQ+AACAbMnyYaxx48bp/fffV0hIiL7++uvbHtYCAADIbbJ8UUEXFxd5eXmpSZMmcnV1veN2P/zwg8PCPShcVBCAGXFRwYcLFxV0wEUFu3Tpcs9TzwEAAHKbLJedmTNn5mAMAACAnMEVlAEAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKlRdgAAgKnlc3aAu3n77bf1zjvv2CwrX768/vjjD0nS9evXNXDgQM2dO1cpKSmKjo7W1KlTFRwc7Iy4eVKJ15c4OwIeoGNjWzo7AgA8cLl+ZKdy5co6c+aM9bFx40brugEDBmjRokX67rvvtG7dOp0+fVpt2rRxYloAAJDb5OqRHUnKly+fQkJCMi1PTEzU9OnTNWfOHD3xxBOSpBkzZqhixYrasmWLHnvssQcdFQAA5EK5fmTn0KFDKlKkiEqVKqVOnTrpxIkTkqRt27bpxo0batKkiXXbChUqqHjx4oqNjb3re6akpCgpKcnmAQAAzClXl52IiAjNnDlTy5Yt08cff6y4uDjVr19fly9fVnx8vNzd3RUQEGDzmuDgYMXHx9/1fceMGSN/f3/rIywsLAf3AgAAOFOuPozVvHlz66+rVaumiIgIhYeH69tvv5WXl9d9v+/QoUMVExNjfZ6UlEThAQDApHL1yM4/BQQEqFy5cjp8+LBCQkKUmpqqS5cu2Wxz9uzZ287xuZWHh4f8/PxsHgAAwJzyVNlJTk7WkSNHFBoaqtq1a8vNzU2rVq2yrj9w4IBOnDihyMhIJ6YEAAC5Sa4+jDVo0CC1atVK4eHhOn36tEaMGCFXV1d16NBB/v7+6tmzp2JiYhQYGCg/Pz+98sorioyM5EwsAABglavLzp9//qkOHTrowoULCgoKUr169bRlyxYFBQVJkj766CO5uLiobdu2NhcVBAAAuClXl525c+fedb2np6emTJmiKVOmPKBEAAAgr8lTc3YAAADsRdkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmRtkBAACmZpqyM2XKFJUoUUKenp6KiIjQr7/+6uxIAAAgFzBF2fnmm28UExOjESNG6Pfff1f16tUVHR2tc+fOOTsaAABwMlOUnQ8//FC9evVS9+7dValSJX3yySfy9vbW559/7uxoAADAyfI5O0B2paamatu2bRo6dKh1mYuLi5o0aaLY2NjbviYlJUUpKSnW54mJiZKkpKSknA2bC2WkXHV2BDxAD+Of8YcZP98Pl4fx5/vmPhuGcdft8nzZ+euvv5Senq7g4GCb5cHBwfrjjz9u+5oxY8bonXfeybQ8LCwsRzICuYX/BGcnAJBTHuaf78uXL8vf3/+O6/N82bkfQ4cOVUxMjPV5RkaGEhISVLBgQVksFicmw4OQlJSksLAwnTx5Un5+fs6OA8CB+Pl+uBiGocuXL6tIkSJ33S7Pl51ChQrJ1dVVZ8+etVl+9uxZhYSE3PY1Hh4e8vDwsFkWEBCQUxGRS/n5+fGXIWBS/Hw/PO42onNTnp+g7O7urtq1a2vVqlXWZRkZGVq1apUiIyOdmAwAAOQGeX5kR5JiYmLUtWtX1alTR48++qgmTJigK1euqHv37s6OBgAAnMwUZaddu3Y6f/68hg8frvj4eNWoUUPLli3LNGkZkP4+jDlixIhMhzIB5H38fON2LMa9ztcCAADIw/L8nB0AAIC7oewAAABTo+wAAABTo+wAAABTo+wAAABTM8Wp50BWpaSkcEoqYCJxcXHasGGDjh8/rqtXryooKEg1a9ZUZGSkPD09nR0PuQRlB6a2dOlSzZ07Vxs2bNDJkyeVkZGh/Pnzq2bNmmratKm6d+9+z3uqAMh9Zs+erf/+97/aunWrgoODVaRIEXl5eSkhIUFHjhyRp6enOnXqpCFDhig8PNzZceFkXGcHpjR//nwNGTJEly9fVosWLfToo4/a/GW4Z88ebdiwQbGxserWrZtGjRqloKAgZ8cGkAU1a9aUu7u7unbtqlatWiksLMxmfUpKimJjYzV37lzNmzdPU6dO1fPPP++ktMgNKDswpcjISL311ltq3ry5XFzuPDXt1KlTmjRpkoKDgzVgwIAHmBDA/Vq+fLmio6OztO2FCxd07Ngx1a5dO4dTITej7AAAAFPjbCyYVkZGhrMjAMghw4cP19WrV63PL1686MQ0yO0oOzAtNzc3nTt3zvp88ODBSkhIcGIiAI7y3nvvKTk52fo8PDxcR48edWIi5GaUHZjWP4/QTps2TZcuXXJOGAAO9c+fb2Zk4G4oO3ho8JchADycuM4OACDPsVgsunz5sjw9PWUYhiwWi5KTk5WUlGSznZ+fn5MSIjfhbCyYlouLi3r37i1vb29J0pQpU9S5c2f5+/vbbPfhhx86Ix6AbHBxcZHFYrE+v1l4/vk8PT3dGfGQyzCyA9Nq0KCBDhw4YH1et27dTBMYb/3LEUDesWbNGmdHQB7CyA4AADA1JijDtLjODmBeXGcH9qDswLS4zg5gXlxnB/ag7MC0uM4OYF5cZwf2oOzgocFfhgDwcOJsLABAnsN1dmAPzsaCaXGdHcC8uM4O7MHIDkyL6+wA5sV1dmAPRnYAAICpMbKDh8Zff/0lSSpUqJCTkwBwlFOnTmnevHk6ePCgJKl8+fJq06aNihYt6uRkyE0Y2YGpXbp0SW+++aa++eYb60XHChQooPbt2+vdd99VQECAcwMCuG9Tp05VTEyMUlNTrRORk5KS5O7urg8//FAvv/yykxMit6DswLQSEhIUGRmpU6dOqVOnTqpYsaIkad++fZozZ47CwsK0efNmFShQwMlJAdhryZIleuaZZ/Tqq69q4MCBCg0NlSSdOXNGH3zwgSZNmqSFCxeqRYsWTk6K3ICyA9N69dVXtWrVKv38888KDg62WRcfH6+mTZuqcePG+uijj5yUEMD9atSokerVq6d33333tuvfeustbdy4UWvXrn2wwZArUXZgWiVKlNC0adMUHR192/XLli3TSy+9pGPHjj3YYACyzc/PT7/99pvKly9/2/UHDhzQI488kum6O3g4cQVlmNaZM2dUuXLlO66vUqWK4uPjH2AiAI6Snp4uNze3O653c3PjGjuwouzAtAoVKnTXUZu4uDgFBgY+uEAAHKZy5cpauHDhHdcvWLDgrv/ZwcOFsgPTio6O1ptvvqnU1NRM61JSUjRs2DA1a9bMCckAZFefPn305ptvaurUqUpLS7MuT0tL05QpU/TWW29xNhasmLMD0/rzzz9Vp04deXh4qE+fPqpQoYIMw9D+/fs1depUpaSkaOvWrQoLC3N2VAD3YdCgQfrwww/l6+ur0qVLyzAMHT16VMnJyerXrx8nH8CKsgNTi4uL08svv6wVK1ZY73pusVj05JNPavLkySpTpoyTEwLIji1btujrr7/WoUOHJEnlypVT+/bt9dhjjzk5GXITyg4eChcvXrT+ZVimTBnm6gDAQ4Syg4eCYRi6cOGCLBaLChYs6Ow4ABzk0KFDWrhwoY4dOyaLxaJSpUrpmWeeUalSpZwdDbkIZQemFh8fr9dee00//vijLl++LOnv63M8++yzGjNmTKaLDQLIO8aMGaPhw4crIyNDhQsXlmEYOn/+vFxdXTV69GgNGjTI2RGRS1B2YFpJSUmqUaOGkpOT1alTJ+sE5X379unrr79WgQIF9Pvvv8vHx8fZUQHYac2aNWrSpImGDRum/v37W2/7kpCQoAkTJmj06NFavXq1GjRo4OSkyA0oOzCtUaNG6csvv9TmzZsVFBRks+7cuXOKiopS9+7d9cYbbzgpIYD71a5dOwUEBGjatGm3Xd+7d29dvnxZX3/99QNOhtyI6+zAtJYsWaI33ngjU9GRpMKFC2vo0KFatGiRE5IByK5ff/1VL7744h3Xv/jii9qyZcsDTITcjLID0zp48KDq1q17x/V169bVgQMHHmAiAI5y9uxZlShR4o7rS5Ysye1gYEXZgWklJSUpICDgjusDAgK4SSCQR12/fl3u7u53XO/m5nbbq6fj4ZTP2QGAnGIYhlxc7tznLRaLmLIG5F2fffbZHU8wuHn2JSAxQRkm5uLiIn9/f1ksltuuNwxDSUlJ3BkZyINKlChxx5/tW8XFxT2ANMjtGNmBac2YMcPZEQDkkGPHjjk7AvIQRnYAAICpMbIDAMhzJk6cmKXt+vXrl8NJkBcwsgPTKlCgQJaO6SckJDyANAAcqWTJkvfcxmKx6OjRow8gDXI7RnZgWhMmTHB2BAA5hInHsAcjO3iopaeny9XV1dkxADjYpUuX9NVXX6lv377OjoJcgIsK4qF08OBBDRkyRMWKFXN2FAAOtGrVKnXs2FGhoaEaMWKEs+Mgl6Ds4KFx9epVzZgxQ/Xr11elSpW0bt06xcTEODsWgGw6efKkRo4cqZIlS6pp06ayWCyaP38+t4uAFYexYHpbtmzRZ599pu+++07FixfX/v37tWbNGtWvX9/Z0QDcpxs3bmjBggX67LPPtGHDBjVr1kwdO3ZUhw4dtHPnTlWqVMnZEZGLMLID0xo/frwqV66s5557TgUKFND69eu1e/duWSwWFSxY0NnxAGRD0aJFNWnSJLVt21anTp3SDz/8oOeee87ZsZBLcTYWTGvIkCEaMmSIRo4cySRkwGTS0tJksVhksVj4+cY9MbID0xo1apS+++47lSxZUkOGDNGePXucHQmAg5w+fVq9e/fW119/rZCQELVt21bz58/P0rW18PCh7MC0hg4dqoMHD2rWrFmKj49XRESEqlevLsMwdPHiRWfHA5ANnp6e6tSpk1avXq3du3erQoUK6tevn9LS0vTee+9p5cqV3OQXVkxQxkMjKSlJX3/9tT7//HNt27ZNjz76qJ577jnOyAJMIiMjQ8uXL9f06dO1aNEi+fr66q+//nJ2LOQClB2YXkpKitLS0pQ/f37rst27d2v69OmaM2eOzp0758R0AO7Xli1btGjRIqWmpqpx48Zq1qyZdd358+c1a9Ys/jMDSZQdmNj58+fVpUsX/fzzz8rIyNAjjzyir776SmXKlLFuc+PGDbm5uTkxJYD78f3336tdu3by8vKSm5ubkpKS9P7772vQoEHOjoZciLID0+rRo4eWLl2qfv36ydPTU9OmTVNoaKjWrFnj7GgAsql27dp65JFHNGXKFLm6umrMmDH64IMPuLEvbouyA9MKCwvTZ599pujoaEnSoUOHVLFiRV25ckUeHh5OTgcgO3x8fLRjxw7rSG1qaqry58+vU6dOqXDhwk5Oh9yGs7FgWqdPn1b16tWtz8uWLSsPDw+dOXPGiakAOMLVq1fl5+dnfe7u7i5PT08lJyc7MRVyKy4qCFP758XGXF1dxWAmYA6fffaZfHx8rM/T0tI0c+ZMFSpUyLqsX79+zoiGXIbDWDAtFxcX+fv721xk7NKlS/Lz85OLy/8NanKMH8h7SpQocc8LCFosFh09evQBJUJuxsgOTGvGjBnOjgAghxw7dszZEZCHMLIDAABMjQnKAADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7AADA1Cg7eKiNHDlSGzZscHYMADnAxcVFTzzxhLZt2+bsKHAyTj3HQ61kyZI6e/asGjdurEWLFjk7DgAHmjlzpo4dO6Zly5Zpy5Ytzo4DJ6Ls4KF37do1rVmzRi1atHB2FABADqDsAADyvMOHD+vIkSNq0KCBvLy8ZBjGPW8ngYcHc3bwUNiwYYM6d+6syMhInTp1SpI0a9Ysbdy40cnJAGTHhQsX1KRJE5UrV04tWrTQmTNnJEk9e/bUwIEDnZwOuQVlB6Y3b948RUdHy8vLS9u3b1dKSookKTExUaNHj3ZyOgDZMWDAAOXLl08nTpyQt7e3dXm7du20bNkyJyZDbkLZgem9++67+uSTT/S///1Pbm5u1uVRUVH6/fffnZgMQHatWLFC77//vooVK2azvGzZsjp+/LiTUiG3oezA9A4cOKAGDRpkWu7v769Lly49+EAAHObKlSs2Izo3JSQkyMPDwwmJkBtRdmB6ISEhOnz4cKblGzduVKlSpZyQCICj1K9fX19++aX1ucViUUZGhsaNG6fHH3/cicmQm+RzdgAgp/Xq1Uv9+/fX559/LovFotOnTys2NlaDBg3SsGHDnB0PQDaMGzdOjRs31tatW5WamqrXXntNe/fuVUJCgjZt2uTseMglOPUcpmcYhkaPHq0xY8bo6tWrkiQPDw8NGjRIo0aNcnI6ANmVmJioyZMna+fOnUpOTlatWrXUp08fhYaGOjsacgnKDh4aqampOnz4sJKTk1WpUiX5+Pg4OxIA4AGg7AAA8pRdu3Zledtq1arlYBLkFZQdmFKbNm2yvO0PP/yQg0kAOJqLi4ssFovu9c+XxWJRenr6A0qF3IwJyjAlf39/Z0cAkEPi4uKcHQF5DCM7AADA1BjZAQDkefv27dOJEyeUmppqs/zpp592UiLkJpQdPBS+//57ffvtt7f9y5BbRgB519GjR/Xss89q9+7dNvN4bt7xnDk7kLiCMh4CEydOVPfu3RUcHKzt27fr0UcfVcGCBXX06FE1b97c2fEAZEP//v1VsmRJnTt3Tt7e3tq7d6/Wr1+vOnXqaO3atc6Oh1yCOTswvQoVKmjEiBHq0KGDfH19tXPnTpUqVUrDhw9XQkKCJk+e7OyIAO5ToUKFtHr1alWrVk3+/v769ddfVb58ea1evVoDBw7U9u3bnR0RuQAjOzC9EydOqG7dupIkLy8vXb58WZL04osv6uuvv3ZmNADZlJ6eLl9fX0l/F5/Tp09LksLDw3XgwAFnRkMuQtmB6YWEhCghIUGSVLx4cW3ZskXS36evMrAJ5G1VqlTRzp07JUkREREaN26cNm3apJEjR3KjX1hRdmB6TzzxhH788UdJUvfu3TVgwAA9+eSTateunZ599lknpwOQHW+99ZYyMjIkSSNHjlRcXJzq16+vn376SRMnTnRyOuQWzNmB6WVkZCgjI0P58v198uHcuXO1efNmlS1bVv/617/k7u7u5IQAHCkhIUEFChSwnpEFUHYAAICpcZ0dPBSuX7+uXbt26dy5c9Yh75u46BiQd12/fl2TJk3SmjVrbvvzzXW0IFF28BBYtmyZunTpor/++ivTOm4UCORtPXv21IoVK/Tcc8/p0Ucf5dAVbovDWDC9smXLqmnTpho+fLiCg4OdHQeAA/n7++unn35SVFSUs6MgF+NsLJje2bNnFRMTQ9EBTKho0aLW6+wAd0LZgek999xzXDYeMKnx48dryJAhOn78uLOjIBfjMBZM7+rVq3r++ecVFBSkqlWrys3NzWZ9v379nJQMQHadP39eL7zwgtavXy9vb+9MP983LyiKhxtlB6Y3ffp0vfTSS/L09FTBggVtJjBaLBYdPXrUiekAZEeTJk104sQJ9ezZU8HBwZkmKHft2tVJyZCbUHZgeiEhIerXr59ef/11ubhw5BYwE29vb8XGxqp69erOjoJcjL/5YXqpqalq164dRQcwoQoVKujatWvOjoFcjr/9YXpdu3bVN9984+wYAHLA2LFjNXDgQK1du1YXLlxQUlKSzQOQOIyFh0C/fv305Zdfqnr16qpWrVqmCYwffvihk5IByK6bI7b/nKtjGAYXDYUVV1CG6e3evVs1a9aUJO3Zs8dmHVdbBfK2NWvWODsC8gBGdgAAgKkxZwcPjcOHD2v58uXWyYz0fCBvOnHihF3bnzp1KoeSIK+g7MD0Lly4oMaNG6tcuXJq0aKFzpw5I+nvGwgOHDjQyekA2OuRRx7Rv/71L/3222933CYxMVH/+9//VKVKFc2bN+8BpkNuxJwdmN6AAQPk5uamEydOqGLFitbl7dq1U0xMjMaPH+/EdADstW/fPr333nt68skn5enpqdq1a6tIkSLy9PTUxYsXtW/fPu3du1e1atXSuHHj1KJFC2dHhpMxZwemFxISouXLl6t69ery9fXVzp07VapUKR09elTVqlVTcnKysyMCuA/Xrl3TkiVLtHHjRh0/flzXrl1ToUKFVLNmTUVHR6tKlSrOjohcgpEdmN6VK1fk7e2daXlCQoI8PDyckAiAI3h5eem5557Tc8895+woyOWYswPTq1+/vr788kvrc4vFooyMDI0bN06PP/64E5MBAB4EDmPB9Pbs2aPGjRurVq1aWr16tZ5++mnt3btXCQkJ2rRpk0qXLu3siACAHETZwUMhMTFRkydP1s6dO5WcnKxatWqpT58+Cg0NdXY0AEAOo+zAlNq0aaOZM2fKz89PX375pdq1a8f8HAB4SFF2YEru7u46fvy4QkND5erqqjNnzqhw4cLOjgUAcALOxoIpVahQQUOHDtXjjz8uwzD07bffys/P77bbdunS5QGnAwA8SIzswJQ2b96smJgYHTlyRAkJCfL19b3tTT8tFosSEhKckBAA8KBQdmB6Li4uio+P5zAWADykuM4OTC8uLk5BQUHOjgEAcBLKDkzp1rsih4eH3/YQ1q24KzIAmBdlB6bEXZEBADdxNhZMibsiAwBuYoIyTI27IgMAKDsAAMDUmLMDAABMjbIDAABMjbIDAABMjbIDAABMjbIDwKEaNWqkV1991dkxAMCKsgOYTHx8vPr3768yZcrI09NTwcHBioqK0scff6yrV686O55D5dZitW7dOj3xxBMKDAyUt7e3ypYtq65duyo1NVWSNHPmTAUEBNj9vmvXrpXFYtGlS5ccGxgwOS4qCJjI0aNHFRUVpYCAAI0ePVpVq1aVh4eHdu/erU8//VRFixbV008/7eyYd5Weni6LxSIXl7z5f7F9+/apWbNmeuWVVzRx4kR5eXnp0KFDmjdvntLT050dD3go5c2/TQDc1ssvv6x8+fJp69ateuGFF1SxYkWVKlVKzzzzjJYsWaJWrVpZt7106ZL+3//7fwoKCpKfn5+eeOIJ7dy507r+7bffVo0aNTRr1iyVKFFC/v7+at++vS5fvmzd5sqVK+rSpYt8fHwUGhqq8ePHZ8qUkpKiQYMGqWjRosqfP78iIiK0du1a6/qboxw//vijKlWqJA8PD5t7m2XHvHnzVLlyZXl4eKhEiRKZ8s2aNUt16tSRr6+vQkJC1LFjR507d866/uZIyqpVq1SnTh15e3urbt26OnDgwB0/c8WKFQoJCdG4ceNUpUoVlS5dWs2aNdP//vc/eXl5ae3aterevbsSExNlsVhksVj09ttv3zPPsWPH9Pjjj0uSChQoIIvFom7dukmSSpQooQkTJtjkqFGjhvV9DcPQ22+/reLFi8vDw0NFihRRv379svHNAnkLZQcwiQsXLmjFihXq06eP8ufPf9ttbr0h6vPPP69z585p6dKl2rZtm2rVqqXGjRsrISHBus2RI0e0YMECLV68WIsXL9a6des0duxY6/rBgwdr3bp1WrhwoVasWKG1a9fq999/t/nMvn37KjY2VnPnztWuXbv0/PPPq1mzZjp06JB1m6tXr+r999/XZ599pr1796pw4cLZ/j62bdumF154Qe3bt9fu3bv19ttva9iwYZo5c6Z1mxs3bmjUqFHauXOnFixYoGPHjlkLxK3efPNNjR8/Xlu3blW+fPnUo0ePO35uSEiIzpw5o/Xr1992fd26dTVhwgT5+fnpzJkzOnPmjAYNGnTPPGFhYdZ7uB04cEBnzpzRf//73yx9F/PmzdNHH32kadOm6dChQ1qwYIGqVq2apdcCpmAAMIUtW7YYkowffvjBZnnBggWN/PnzG/nz5zdee+01wzAMY8OGDYafn59x/fp1m21Lly5tTJs2zTAMwxgxYoTh7e1tJCUlWdcPHjzYiIiIMAzDMC5fvmy4u7sb3377rXX9hQsXDC8vL6N///6GYRjG8ePHDVdXV+PUqVM2n9O4cWNj6NChhmEYxowZMwxJxo4dO+ze54YNG1o/6586duxoPPnkkzbLBg8ebFSqVOmO7/fbb78ZkozLly8bhmEYa9asMSQZP//8s3WbJUuWGJKMa9eu3fY90tLSjG7duhmSjJCQEKN169bGpEmTjMTEROs2M2bMMPz9/e+5f3fKc/HiRZvtwsPDjY8++shmWfXq1Y0RI0YYhmEY48ePN8qVK2ekpqbe8zMBM2JkBzC5X3/9VTt27FDlypWVkpIiSdq5c6eSk5NVsGBB+fj4WB9xcXE6cuSI9bUlSpSQr6+v9XloaKj1sMqRI0eUmpqqiIgI6/rAwECVL1/e+nz37t1KT09XuXLlbD5n3bp1Np/j7u6uatWqOXS/9+/fr6ioKJtlUVFROnTokHXuzLZt29SqVSsVL15cvr6+atiwoSRlOox2a7bQ0FBJsjncdStXV1fNmDFDf/75p8aNG6eiRYtq9OjRqly5ss6cOXPXzFnNY6/nn39e165dU6lSpdSrVy/Nnz9faWlp2XpPIC9hgjJgEmXKlJHFYsk0n6RUqVKSJC8vL+uy5ORkhYaG2syduenWs4Tc3Nxs1lksFmVkZGQ5U3JyslxdXbVt2za5urrarPPx8bH+2svLy+YQ24Nw5coVRUdHKzo6WrNnz1ZQUJBOnDih6Oho61lTN936PdzMea/voWjRonrxxRf14osvatSoUSpXrpw++eQTvfPOO9nO808uLi4y/nGbwxs3blh/HRYWpgMHDujnn3/WypUr9fLLL+uDDz7QunXrMv0eA2ZE2QFMomDBgnryySc1efJkvfLKK3ectyNJtWrVUnx8vPLly6cSJUrc1+eVLl1abm5u+uWXX1S8eHFJ0sWLF3Xw4EHriETNmjWVnp6uc+fOqX79+vf1OferYsWK2rRpk82yTZs2qVy5cnJ1ddUff/yhCxcuaOzYsQoLC5Mkbd26NUeyFChQQKGhobpy5Yqkv0ey/nlmVlbyuLu7S1Km1wYFBdmMGiUlJSkuLs5mGy8vL7Vq1UqtWrVSnz59VKFCBe3evVu1atVyzE4CuRhlBzCRqVOnKioqSnXq1NHbb7+tatWqycXFRb/99pv++OMP1a5dW5LUpEkTRUZGqnXr1ho3bpzKlSun06dPa8mSJXr22WdVp06de36Wj4+PevbsqcGDB6tgwYIqXLiw3nzzTZtTxsuVK6dOnTqpS5cuGj9+vGrWrKnz589r1apVqlatmlq2bJntfT5//rx27Nhhsyw0NFQDBw7UI488olGjRqldu3aKjY3V5MmTNXXqVElS8eLF5e7urkmTJumll17Snj17NGrUqGznmTZtmnbs2KFnn31WpUuX1vXr1/Xll19q7969mjRpkqS/Dw8mJydr1apVql69ury9vbOUJzw8XBaLRYsXL1aLFi3k5eUlHx8fPfHEE5o5c6ZatWqlgIAADR8+3GYkbebMmUpPT1dERIS8vb311VdfycvLS+Hh4dneXyBPcPakIQCOdfr0aaNv375GyZIlDTc3N8PHx8d49NFHjQ8++MC4cuWKdbukpCTjlVdeMYoUKWK4ubkZYWFhRqdOnYwTJ04YhvH3BOXq1avbvPdHH31khIeHW59fvnzZ6Ny5s+Ht7W0EBwcb48aNyzRpODU11Rg+fLhRokQJw83NzQgNDTWeffZZY9euXYZh3Hmy7s3JuHFxcXfc14YNGxqSMj1GjRplGIZhfP/990alSpUMNzc3o3jx4sYHH3xg8/o5c+YYJUqUMDw8PIzIyEjjxx9/NCQZ27dvt8lw64Tg7du33zXX77//bnTu3NkoWbKk4eHhYRQsWNBo0KCB8eOPP9ps99JLLxkFCxY0JFknEt8rj2EYxsiRI42QkBDDYrEYXbt2NQzDMBITE4127doZfn5+RlhYmDFz5kybCcrz5883IiIiDD8/PyN//vzGY489ZjPpGjA7i2H840AvAOQCM2bM0OjRo7Vv3z7mlQDIFs7GApAr/fTTTxo9ejRFB0C2MbIDAABMjZEdAABgapQdAABgapQdAABgapQdAABgapQdAABgapQdAABgapQdAABgapQdAABgapQdAABgapQdAABgav8f17kAVsTICDAAAAAASUVORK5CYII=","text/plain":["
"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["Answer: \n","Conversational answer: Sure, I can help you with that! To generate a bar plot of loans paid by men and women, we can use a data visualization tool like Matplotlib or Seaborn in Python. We'll need to have a dataset that includes information on the loan amounts paid by both men and women. Once we have that, we can create a bar plot with two bars - one for men and one for women - and the height of each bar will represent the total loan amount paid by that gender. This will give us a visual representation of the difference in loan payments between men and women.\n"]}],"source":["response = pandas_ai.run(df, prompt = prompt)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":326,"status":"ok","timestamp":1684892330884,"user":{"displayName":"Amjad Raza","userId":"06768084019046926999"},"user_tz":-600},"id":"J8K29pWolDbI","outputId":"29a49e10-8786-438b-f3fb-d123386e5a2a"},"outputs":[{"name":"stdout","output_type":"stream","text":["247\n"]}],"source":["#Let us run the code ourselves and find out the results matches or not?\n","import pandas as pd\n","file_path ='https://raw.githubusercontent.com/gventuri/pandas-ai/main/examples/data/Loan%20payments%20data.csv'\n","df = pd.read_csv(file_path)\n","num_loans = len(df[(df['Gender'] == 'male') & (df['loan_status'] == 'PAIDOFF')]\n"," )\n","print(num_loans)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":352,"status":"ok","timestamp":1684893561284,"user":{"displayName":"Amjad Raza","userId":"06768084019046926999"},"user_tz":-600},"id":"WgUMtfAOe0t4","outputId":"26b23a27-11b5-4a1b-f724-b5cd587af1d8"},"outputs":[{"name":"stdout","output_type":"stream","text":["53\n"]}],"source":["import pandas as pd\n","file_path ='https://raw.githubusercontent.com/gventuri/pandas-ai/main/examples/data/Loan%20payments%20data.csv'\n","df = pd.read_csv(file_path)\n","num_loans = len(df[(df['Gender'] == 'female') & (df['loan_status'] == 'PAIDOFF')]\n"," )\n","print(num_loans)"]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"UbeJXL3wkmXE"},"source":["The answers generated by PandasAI and manually are same. However, it may not be a case always. "]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"AQ11XG3JaOH3"},"source":["\n","# Remarks\n","In this concise tutorial, we have explored the Pandasai Library and gained insight into its higher-level architecture. This library offers a convenient solution for individuals to inquire about their data without the need to train in-house Large Language Models (LLMs) on company data. While there are various potential applications for this tool, it's important to remain mindful that the generated code by LLMs may occasionally produce unexpected outputs.\n","\n","It's worth emphasizing that Pandas AI is an actively developed project, indicating ongoing efforts to improve and enhance its functionality. With dedicated contributors, exciting features are being developed and added to this library.\n","\n","> **Stay tuned! There's more to come in the world of Pandas AI as it evolves and continues to empower users in their data exploration and analysis endeavors.**\n"]}],"metadata":{"colab":{"provenance":[{"file_id":"1XwQuNfgLtgcGd2yWMzBRXTR0bZ5Vjm1C","timestamp":1685076114938},{"file_id":"https://github.com/amjadraza/learn-it/blob/master/Getting_Started_pandas_ai.ipynb","timestamp":1684888879263}]},"kernelspec":{"display_name":"Python 3","name":"python3"},"language_info":{"name":"python"}},"nbformat":4,"nbformat_minor":0} diff --git a/README.md b/README.md index 3b1fc9af4..c72d84342 100644 --- a/README.md +++ b/README.md @@ -163,7 +163,7 @@ Options: - **-d, --dataset**: The file path to the dataset. - **-t, --token**: Your HuggingFace or OpenAI API token, if no token provided pai will pull from the `.env` file. -- **-m, --model**: Choice of LLM, either `openai`, `open-assistant`, `starcoder`, or Google `palm`. +- **-m, --model**: Choice of LLM, either `openai`, `open-assistant`, `starcoder`, `falcon`, `azure-openai` or `google-palm`. - **-p, --prompt**: Prompt that PandasAI will run. To view a full list of available options and their descriptions, run the following command: @@ -205,6 +205,9 @@ llm = OpenAI(api_token="YOUR_API_KEY") # Starcoder llm = Starcoder(api_token="YOUR_HF_API_KEY") + +# Falcon +llm = Falcon(api_token="YOUR_HF_API_KEY") ``` ## License diff --git a/docs/API/llms.md b/docs/API/llms.md index 0495754f5..01632a92e 100644 --- a/docs/API/llms.md +++ b/docs/API/llms.md @@ -33,6 +33,14 @@ Starcoder wrapper extended through Base HuggingFace Class options: show_root_heading: true +### Falcon + +Falcon wrapper extended through Base HuggingFace Class + +::: pandasai.llm.falcon + options: + show_root_heading: true + ### Azure OpenAI OpenAI API through Azure Platform wrapper diff --git a/docs/pai_cli.md b/docs/pai_cli.md index fa07b37d4..d2952491d 100644 --- a/docs/pai_cli.md +++ b/docs/pai_cli.md @@ -1,35 +1,47 @@ # Command-Line Tool + [Pai] is the command line tool designed to provide a convenient way to interact with `pandasai` through a command line interface (CLI). In order to access the CLI tool, make sure to create a virtualenv for testing purpose and to install project dependencies in your local virtual environment using `pip` by running the following command: + ``` pip install -e . ``` + Alternatively, you can use `poetry` to create and activate the virtual environment by running the following command: + ``` poetry shell ``` + Inside the activated virtual environment, install the project dependencies by running the following command: + ``` poetry install ``` -By following these steps, you will now have the necessary environment to access the CLI tool. +By following these steps, you will now have the necessary environment to access the CLI tool. ``` pai [OPTIONS] ``` + Options: + - **-d, --dataset**: The file path to the dataset. - **-t, --token**: Your HuggingFace or OpenAI API token, if no token provided pai will pull from the `.env` file. -- **-m, --model**: Choice of LLM, either `openai`, `open-assistant`, or `starcoder`. +- **-m, --model**: Choice of LLM, either `openai`, `open-assistant`, `starcoder`, `falcon`, `azure-openai` or `google-palm`. - **-p, --prompt**: Prompt that PandasAI will run. To view a full list of available options and their descriptions, run the following command: + ``` pai --help ``` ->For example, ->``` ->pai -d "~/pandasai/example/data/Loan payments data.csv" -m "openai" -p "How many loans are from men and have been paid off?" ->``` ->Should result in the same output as the `from_csv.py` example. + +> For example, +> +> ``` +> pai -d "~/pandasai/example/data/Loan payments data.csv" -m "openai" -p "How many loans are from men and have been paid off?" +> ``` +> +> Should result in the same output as the `from_csv.py` example. diff --git a/pai/__main__.py b/pai/__main__.py index 1cb1632ed..4ddd5dca8 100644 --- a/pai/__main__.py +++ b/pai/__main__.py @@ -10,7 +10,7 @@ - **-d, --dataset**: The file path to the dataset. - **-t, --token**: Your HuggingFace or OpenAI API token, if no token provided pai will pull from the `.env` file. -- **-m, --model**: Choice of LLM, either `openai`, `open-assistant`, or `starcoder`. +- **-m, --model**: Choice of LLM, either `openai`, `open-assistant`, `starcoder`, `falcon`, `azure-openai` or `google-palm`. - **-p, --prompt**: Prompt that PandasAI will run. To view a full list of available options and their descriptions, run the following command: @@ -31,20 +31,35 @@ """ import os + import click import pandas as pd + from pandasai import PandasAI -from pandasai.llm.openai import OpenAI +from pandasai.llm.google_palm import GooglePalm from pandasai.llm.open_assistant import OpenAssistant +from pandasai.llm.openai import OpenAI from pandasai.llm.starcoder import Starcoder -from pandasai.llm.google_palm import GooglePalm + @click.command() -@click.option('-d', '--dataset', type=str, required=True, help='The dataset to use.') -@click.option('-t', '--token', type=str, required=False, default=None, help='The API token to use.') -@click.option('-m', '--model', type=click.Choice(['openai', 'open-assistant', 'starcoder', 'palm']), - required=True, help='The type of model to use.') -@click.option('-p', '--prompt', type=str, required=True, help='The prompt to use.') +@click.option("-d", "--dataset", type=str, required=True, help="The dataset to use.") +@click.option( + "-t", + "--token", + type=str, + required=False, + default=None, + help="The API token to use.", +) +@click.option( + "-m", + "--model", + type=click.Choice(["openai", "open-assistant", "starcoder", "falcon", "palm"]), + required=True, + help="The type of model to use.", +) +@click.option("-p", "--prompt", type=str, required=True, help="The prompt to use.") def main(dataset: str, token: str, model: str, prompt: str) -> None: """Main logic for the command line interface tool.""" @@ -80,31 +95,34 @@ def main(dataset: str, token: str, model: str, prompt: str) -> None: ".xml": pd.read_xml, } if ext in file_format: - df = file_format[ext](dataset) # pylint: disable=C0103 + df = file_format[ext](dataset) # pylint: disable=C0103 else: print("Unsupported file format.") return - except Exception as e: # pylint: disable=W0718 disable=C0103 + except Exception as e: # pylint: disable=W0718 disable=C0103 print(e) return if model == "openai": - llm = OpenAI(api_token = token) + llm = OpenAI(api_token=token) elif model == "open-assistant": - llm = OpenAssistant(api_token = token) + llm = OpenAssistant(api_token=token) + + elif model == "starcoder": + llm = Starcoder(api_token=token) - elif model == 'starcoder': - llm = Starcoder(api_token = token) + elif model == "falcon": + llm = Starcoder(api_token=token) - elif model == 'palm': - llm = GooglePalm(api_key = token) + elif model == "palm": + llm = GooglePalm(api_key=token) try: pandas_ai = PandasAI(llm, verbose=True) response = pandas_ai(df, prompt) print(response) - except Exception as e: # pylint: disable=W0718 disable=C0103 + except Exception as e: # pylint: disable=W0718 disable=C0103 print(e) diff --git a/pandasai/llm/falcon.py b/pandasai/llm/falcon.py new file mode 100644 index 000000000..5c9342393 --- /dev/null +++ b/pandasai/llm/falcon.py @@ -0,0 +1,51 @@ +""" Falcon LLM +This module is to run the Falcon API hosted and maintained by HuggingFace.co. +To generate HF_TOKEN go to https://huggingface.co/settings/tokens after creating Account +on the platform. + +Example: + Use below example to call Falcon Model + + >>> from pandasai.llm.falcon import Falcon +""" + + +import os +from typing import Optional + +from dotenv import load_dotenv + +from ..exceptions import APIKeyNotFoundError +from .base import HuggingFaceLLM + +load_dotenv() + + +class Falcon(HuggingFaceLLM): + + """Falcon LLM API + + A base HuggingFaceLLM class is extended to use Falcon model. + + """ + + api_token: str + _api_url: str = ( + "https://api-inference.huggingface.co/models/tiiuae/falcon-7b-instruct" + ) + _max_retries: int = 5 + + def __init__(self, api_token: Optional[str] = None): + """ + __init__ method of Falcon Class + Args: + api_token (str): API token from Huggingface platform + """ + + self.api_token = api_token or os.getenv("HUGGINGFACE_API_KEY") or None + if self.api_token is None: + raise APIKeyNotFoundError("HuggingFace Hub API key is required") + + @property + def type(self) -> str: + return "falcon" diff --git a/pandasai/llm/open_assistant.py b/pandasai/llm/open_assistant.py index 96c98bd22..35336f2ed 100644 --- a/pandasai/llm/open_assistant.py +++ b/pandasai/llm/open_assistant.py @@ -5,7 +5,7 @@ the platform. Example: - Use below example to call Starcoder Model + Use below example to call OpenAssistant Model >>> from pandasai.llm.open_assistant import OpenAssistant """ @@ -23,8 +23,8 @@ class OpenAssistant(HuggingFaceLLM): """Open Assistant LLM - A base HuggingFaceLLM class is extended to use OpenAssistant Model via its API. - Currently `oasst-sft-1-pythia-12b` is supported via this module. + A base HuggingFaceLLM class is extended to use OpenAssistant Model via its API. + Currently `oasst-sft-1-pythia-12b` is supported via this module. """ api_token: str @@ -35,7 +35,6 @@ class OpenAssistant(HuggingFaceLLM): _max_retries: int = 10 def __init__(self, api_token: Optional[str] = None): - """ __init__ method of OpenAssistant Calss diff --git a/tests/llms/test_falcon.py b/tests/llms/test_falcon.py new file mode 100644 index 000000000..4b1d70b0f --- /dev/null +++ b/tests/llms/test_falcon.py @@ -0,0 +1,17 @@ +"""Unit tests for the falcon LLM class""" + +import pytest + +from pandasai.exceptions import APIKeyNotFoundError +from pandasai.llm.falcon import Falcon + + +class TestFalconLLM: + """Unit tests for the Falcon LLM class""" + + def test_type(self): + assert Falcon(api_token="test").type == "falcon" + + def test_init(self): + with pytest.raises(APIKeyNotFoundError): + Falcon()