{ "cells": [ { "cell_type": "markdown", "id": "99589ed4-2bbf-4f5f-bea1-d537860e33a0", "metadata": { "id": "fwukZZnNTYWE" }, "source": [ "
\n", "\n", "### Analyzing Digital Analytics Data with Generative AI\n", "\n", "Copyright, NLP from scratch, 2023.\n", "\n", "[nlpfromscratch.com](https://www.nlpfromscratch.com)\n", "\n", "**MeasureCamp Toronto 2024** \n", "\n", "
\n", "\n", "Saturday, October 5th, 2024\n", "\n", "------------" ] }, { "cell_type": "markdown", "id": "46b7cb3f-61f4-4841-9d39-8042ca289e3f", "metadata": {}, "source": [ "### Introduction" ] }, { "cell_type": "markdown", "id": "9c0040bd-3c77-419d-8bb0-19e769b82aff", "metadata": {}, "source": [ "In this short workshop, we will explore using Generative AI locally in Jupyter using the [Jupyter AI](https://jupyter-ai.readthedocs.io/en/latest/index.html) package as well as the [Ollama](ollama.ai) framework for model serving. We will apply this to a simple example of an export of data from Google Analytics, and see how generative AI models can assist in being our \"AI pair programmer\" or teammate to help with the analysis if we are less technical. " ] }, { "cell_type": "markdown", "id": "327095f1-ed18-466b-8ad6-9850a34c6988", "metadata": {}, "source": [ "### Jupyter & Jupyter AI\n", "[Jupyter](https://jupyter.org/) is an open-source web-based interactive computing environment that enables users to create and share documents that contain live code, equations, visualizations, and narrative text. It is the de facto standard tool for doing data science and AI development work.\n", "\n", "\n", "\n", "Jupyter has been extended with the [Jupyter AI](https://jupyter-ai.readthedocs.io/en/latest/index.html) library which adds:\n", "- A conversational assistant (Jupyternaut)\n", "- Generative AI capabilities within Jupyter notebooks in all applications\n", "- Support for a wide range of generative model providers and models (AI21, Anthropic, Cohere, Gemini, Hugging Face, MistralAI, OpenAI, SageMaker, NVIDIA, etc. and many more local models via Ollama).\n", "\n", "" ] }, { "cell_type": "markdown", "id": "20da1a3e-92f8-4846-ba41-bc7bf8ef09d5", "metadata": {}, "source": [ "### Getting Started with Jupyter AI" ] }, { "cell_type": "markdown", "id": "e3dbab2f-a86f-4aa9-9945-d5ddfd2f4427", "metadata": {}, "source": [ "If you haven't done so already, you should [install Jupyter AI](https://jupyter-ai.readthedocs.io/en/latest/users/index.html#installation), the preferred method is using `pip`:" ] }, { "cell_type": "code", "execution_count": null, "id": "08d74766-1823-41df-b8a7-a60d6d27221e", "metadata": {}, "outputs": [], "source": [ "# install \n", "!pip install jupyter-ai" ] }, { "cell_type": "markdown", "id": "1cb2b828-0d17-48ed-9730-c4a67afb3fa8", "metadata": {}, "source": [ "First, we reload the `jupyter_ai` extension, as per the documentation:" ] }, { "cell_type": "code", "execution_count": 1, "id": "55aac8ba-19b4-4c7b-9ece-b935cbb58e1e", "metadata": {}, "outputs": [], "source": [ "%reload_ext jupyter_ai" ] }, { "cell_type": "markdown", "id": "18541559-9e0a-400c-92b2-1749a3e1dc8d", "metadata": {}, "source": [ "You can list all model providers by using `%ai list`:" ] }, { "cell_type": "code", "execution_count": 2, "id": "f189596d-9f12-4b07-a64e-596fea7668a1", "metadata": {}, "outputs": [ { "data": { "text/markdown": [ "| Provider | Environment variable | Set? | Models |\n", "|----------|----------------------|------|--------|\n", "| `ai21` | `AI21_API_KEY` | | |\n", "| `bedrock` | Not applicable. | N/A | |\n", "| `bedrock-chat` | Not applicable. | N/A | |\n", "| `bedrock-custom` | Not applicable. | N/A | Specify the ARN (Amazon Resource Name) of the custom/provisioned model as the model ID. For more information, see the [Amazon Bedrock model IDs documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/model-ids.html).\n", "\n", "The model provider must also be specified below. This is the provider of your foundation model *in lowercase*, e.g. `amazon`, `anthropic`, `meta`, or `mistral`. |\n", "| `anthropic` | `ANTHROPIC_API_KEY` | | |\n", "| `anthropic-chat` | `ANTHROPIC_API_KEY` | | |\n", "| `azure-chat-openai` | `AZURE_OPENAI_API_KEY` | | This provider does not define a list of models. |\n", "| `cohere` | `COHERE_API_KEY` | | |\n", "| `gemini` | `GOOGLE_API_KEY` | | |\n", "| `gpt4all` | Not applicable. | N/A | |\n", "| `huggingface_hub` | `HUGGINGFACEHUB_API_TOKEN` | | See [https://huggingface.co/models](https://huggingface.co/models) for a list of models. Pass a model's repository ID as the model ID; for example, `huggingface_hub:ExampleOwner/example-model`. |\n", "| `mistralai` | `MISTRAL_API_KEY` | | |\n", "| `nvidia-chat` | `NVIDIA_API_KEY` | | |\n", "| `ollama` | Not applicable. | N/A | See [https://www.ollama.com/library](https://www.ollama.com/library) for a list of models. Pass a model's name; for example, `deepseek-coder-v2`. |\n", "| `openai` | `OPENAI_API_KEY` | | |\n", "| `openai-chat` | `OPENAI_API_KEY` | | |\n", "| `openrouter` | `OPENROUTER_API_KEY` | | This provider does not define a list of models. |\n", "| `qianfan` | `QIANFAN_AK`, `QIANFAN_SK` | | |\n", "| `sagemaker-endpoint` | Not applicable. | N/A | Specify an endpoint name as the model ID. In addition, you must specify a region name, request schema, and response path. For more information, see the documentation about [SageMaker endpoints deployment](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deploy-models.html) and about [using magic commands with SageMaker endpoints](https://jupyter-ai.readthedocs.io/en/latest/users/index.html#using-magic-commands-with-sagemaker-endpoints). |\n", "| `togetherai` | `TOGETHER_API_KEY` | | |\n", "\n", "Aliases and custom commands:\n", "\n", "| Name | Target |\n", "|------|--------|\n", "| `gpt2` | `huggingface_hub:gpt2` |\n", "| `gpt3` | `openai:davinci-002` |\n", "| `chatgpt` | `openai-chat:gpt-3.5-turbo` |\n", "| `gpt4` | `openai-chat:gpt-4` |\n", "| `ernie-bot` | `qianfan:ERNIE-Bot` |\n", "| `ernie-bot-4` | `qianfan:ERNIE-Bot-4` |\n", "| `titan` | `bedrock:amazon.titan-tg1-large` |\n", "| `openrouter-claude` | `openrouter:anthropic/claude-3.5-sonnet:beta` |\n" ], "text/plain": [ "ai21\n", "Requires environment variable: AI21_API_KEY (not set)\n", "* ai21:j1-large\n", "* ai21:j1-grande\n", "* ai21:j1-jumbo\n", "* ai21:j1-grande-instruct\n", "* ai21:j2-large\n", "* ai21:j2-grande\n", "* ai21:j2-jumbo\n", "* ai21:j2-grande-instruct\n", "* ai21:j2-jumbo-instruct\n", "\n", "bedrock\n", "* bedrock:amazon.titan-text-express-v1\n", "* bedrock:amazon.titan-text-lite-v1\n", "* bedrock:amazon.titan-text-premier-v1:0\n", "* bedrock:ai21.j2-ultra-v1\n", "* bedrock:ai21.j2-mid-v1\n", "* bedrock:ai21.jamba-instruct-v1:0\n", "* bedrock:cohere.command-light-text-v14\n", "* bedrock:cohere.command-text-v14\n", "* bedrock:cohere.command-r-v1:0\n", "* bedrock:cohere.command-r-plus-v1:0\n", "* bedrock:meta.llama2-13b-chat-v1\n", "* bedrock:meta.llama2-70b-chat-v1\n", "* bedrock:meta.llama3-8b-instruct-v1:0\n", "* bedrock:meta.llama3-70b-instruct-v1:0\n", "* bedrock:meta.llama3-1-8b-instruct-v1:0\n", "* bedrock:meta.llama3-1-70b-instruct-v1:0\n", "* bedrock:meta.llama3-1-405b-instruct-v1:0\n", "* bedrock:mistral.mistral-7b-instruct-v0:2\n", "* bedrock:mistral.mixtral-8x7b-instruct-v0:1\n", "* bedrock:mistral.mistral-large-2402-v1:0\n", "* bedrock:mistral.mistral-large-2407-v1:0\n", "\n", "bedrock-chat\n", "* bedrock-chat:amazon.titan-text-express-v1\n", "* bedrock-chat:amazon.titan-text-lite-v1\n", "* bedrock-chat:amazon.titan-text-premier-v1:0\n", "* bedrock-chat:anthropic.claude-v2\n", "* bedrock-chat:anthropic.claude-v2:1\n", "* bedrock-chat:anthropic.claude-instant-v1\n", "* bedrock-chat:anthropic.claude-3-sonnet-20240229-v1:0\n", "* bedrock-chat:anthropic.claude-3-haiku-20240307-v1:0\n", "* bedrock-chat:anthropic.claude-3-opus-20240229-v1:0\n", "* bedrock-chat:anthropic.claude-3-5-sonnet-20240620-v1:0\n", "* bedrock-chat:meta.llama2-13b-chat-v1\n", "* bedrock-chat:meta.llama2-70b-chat-v1\n", "* bedrock-chat:meta.llama3-8b-instruct-v1:0\n", "* bedrock-chat:meta.llama3-70b-instruct-v1:0\n", "* bedrock-chat:meta.llama3-1-8b-instruct-v1:0\n", "* bedrock-chat:meta.llama3-1-70b-instruct-v1:0\n", "* bedrock-chat:meta.llama3-1-405b-instruct-v1:0\n", "* bedrock-chat:mistral.mistral-7b-instruct-v0:2\n", "* bedrock-chat:mistral.mixtral-8x7b-instruct-v0:1\n", "* bedrock-chat:mistral.mistral-large-2402-v1:0\n", "* bedrock-chat:mistral.mistral-large-2407-v1:0\n", "\n", "bedrock-custom\n", "* Specify the ARN (Amazon Resource Name) of the custom/provisioned model as the model ID. For more information, see the [Amazon Bedrock model IDs documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/model-ids.html).\n", "\n", "The model provider must also be specified below. This is the provider of your foundation model *in lowercase*, e.g. `amazon`, `anthropic`, `meta`, or `mistral`.\n", "\n", "anthropic\n", "Requires environment variable: ANTHROPIC_API_KEY (not set)\n", "* anthropic:claude-v1\n", "* anthropic:claude-v1.0\n", "* anthropic:claude-v1.2\n", "* anthropic:claude-2\n", "* anthropic:claude-2.0\n", "* anthropic:claude-instant-v1\n", "* anthropic:claude-instant-v1.0\n", "* anthropic:claude-instant-v1.2\n", "\n", "anthropic-chat\n", "Requires environment variable: ANTHROPIC_API_KEY (not set)\n", "* anthropic-chat:claude-2.0\n", "* anthropic-chat:claude-2.1\n", "* anthropic-chat:claude-instant-1.2\n", "* anthropic-chat:claude-3-opus-20240229\n", "* anthropic-chat:claude-3-sonnet-20240229\n", "* anthropic-chat:claude-3-haiku-20240307\n", "* anthropic-chat:claude-3-5-sonnet-20240620\n", "\n", "azure-chat-openai\n", "Requires environment variable: AZURE_OPENAI_API_KEY (not set)\n", "* This provider does not define a list of models.\n", "\n", "cohere\n", "Requires environment variable: COHERE_API_KEY (set)\n", "* cohere:command\n", "* cohere:command-nightly\n", "* cohere:command-light\n", "* cohere:command-light-nightly\n", "* cohere:command-r-plus\n", "* cohere:command-r\n", "\n", "gemini\n", "Requires environment variable: GOOGLE_API_KEY (not set)\n", "* gemini:gemini-1.5-pro\n", "* gemini:gemini-1.5-flash\n", "* gemini:gemini-1.0-pro\n", "* gemini:gemini-1.0-pro-001\n", "* gemini:gemini-1.0-pro-latest\n", "* gemini:gemini-1.0-pro-vision-latest\n", "* gemini:gemini-pro\n", "* gemini:gemini-pro-vision\n", "\n", "gpt4all\n", "* gpt4all:ggml-gpt4all-j-v1.2-jazzy\n", "* gpt4all:ggml-gpt4all-j-v1.3-groovy\n", "* gpt4all:ggml-gpt4all-l13b-snoozy\n", "* gpt4all:mistral-7b-openorca.Q4_0\n", "* gpt4all:mistral-7b-instruct-v0.1.Q4_0\n", "* gpt4all:gpt4all-falcon-q4_0\n", "* gpt4all:wizardlm-13b-v1.2.Q4_0\n", "* gpt4all:nous-hermes-llama2-13b.Q4_0\n", "* gpt4all:gpt4all-13b-snoozy-q4_0\n", "* gpt4all:mpt-7b-chat-merges-q4_0\n", "* gpt4all:orca-mini-3b-gguf2-q4_0\n", "* gpt4all:starcoder-q4_0\n", "* gpt4all:rift-coder-v0-7b-q4_0\n", "* gpt4all:em_german_mistral_v01.Q4_0\n", "\n", "huggingface_hub\n", "Requires environment variable: HUGGINGFACEHUB_API_TOKEN (not set)\n", "* See [https://huggingface.co/models](https://huggingface.co/models) for a list of models. Pass a model's repository ID as the model ID; for example, `huggingface_hub:ExampleOwner/example-model`.\n", "\n", "mistralai\n", "Requires environment variable: MISTRAL_API_KEY (not set)\n", "* mistralai:open-mistral-7b\n", "* mistralai:open-mixtral-8x7b\n", "* mistralai:open-mixtral-8x22b\n", "* mistralai:mistral-small-latest\n", "* mistralai:mistral-medium-latest\n", "* mistralai:mistral-large-latest\n", "* mistralai:codestral-latest\n", "\n", "nvidia-chat\n", "Requires environment variable: NVIDIA_API_KEY (not set)\n", "* nvidia-chat:playground_llama2_70b\n", "* nvidia-chat:playground_nemotron_steerlm_8b\n", "* nvidia-chat:playground_mistral_7b\n", "* nvidia-chat:playground_nv_llama2_rlhf_70b\n", "* nvidia-chat:playground_llama2_13b\n", "* nvidia-chat:playground_steerlm_llama_70b\n", "* nvidia-chat:playground_llama2_code_13b\n", "* nvidia-chat:playground_yi_34b\n", "* nvidia-chat:playground_mixtral_8x7b\n", "* nvidia-chat:playground_neva_22b\n", "* nvidia-chat:playground_llama2_code_34b\n", "\n", "ollama\n", "* See [https://www.ollama.com/library](https://www.ollama.com/library) for a list of models. Pass a model's name; for example, `deepseek-coder-v2`.\n", "\n", "openai\n", "Requires environment variable: OPENAI_API_KEY (set)\n", "* openai:babbage-002\n", "* openai:davinci-002\n", "* openai:gpt-3.5-turbo-instruct\n", "\n", "openai-chat\n", "Requires environment variable: OPENAI_API_KEY (set)\n", "* openai-chat:gpt-3.5-turbo\n", "* openai-chat:gpt-3.5-turbo-0125\n", "* openai-chat:gpt-3.5-turbo-0301\n", "* openai-chat:gpt-3.5-turbo-0613\n", "* openai-chat:gpt-3.5-turbo-1106\n", "* openai-chat:gpt-3.5-turbo-16k\n", "* openai-chat:gpt-3.5-turbo-16k-0613\n", "* openai-chat:gpt-4\n", "* openai-chat:gpt-4-turbo\n", "* openai-chat:gpt-4-turbo-preview\n", "* openai-chat:gpt-4-0613\n", "* openai-chat:gpt-4-32k\n", "* openai-chat:gpt-4-32k-0613\n", "* openai-chat:gpt-4-0125-preview\n", "* openai-chat:gpt-4-1106-preview\n", "* openai-chat:gpt-4o\n", "* openai-chat:gpt-4o-mini\n", "\n", "openrouter\n", "Requires environment variable: OPENROUTER_API_KEY (not set)\n", "* This provider does not define a list of models.\n", "\n", "qianfan\n", "Requires environment variables: QIANFAN_AK (not set), QIANFAN_SK (not set)\n", "* qianfan:ERNIE-Bot\n", "* qianfan:ERNIE-Bot-4\n", "\n", "sagemaker-endpoint\n", "* Specify an endpoint name as the model ID. In addition, you must specify a region name, request schema, and response path. For more information, see the documentation about [SageMaker endpoints deployment](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deploy-models.html) and about [using magic commands with SageMaker endpoints](https://jupyter-ai.readthedocs.io/en/latest/users/index.html#using-magic-commands-with-sagemaker-endpoints).\n", "\n", "togetherai\n", "Requires environment variable: TOGETHER_API_KEY (not set)\n", "* togetherai:Austism/chronos-hermes-13b\n", "* togetherai:DiscoResearch/DiscoLM-mixtral-8x7b-v2\n", "* togetherai:EleutherAI/llemma_7b\n", "* togetherai:Gryphe/MythoMax-L2-13b\n", "* togetherai:Meta-Llama/Llama-Guard-7b\n", "* togetherai:Nexusflow/NexusRaven-V2-13B\n", "* togetherai:NousResearch/Nous-Capybara-7B-V1p9\n", "* togetherai:NousResearch/Nous-Hermes-2-Yi-34B\n", "* togetherai:NousResearch/Nous-Hermes-Llama2-13b\n", "* togetherai:NousResearch/Nous-Hermes-Llama2-70b\n", "\n", "\n", "Aliases and custom commands:\n", "gpt2 - huggingface_hub:gpt2\n", "gpt3 - openai:davinci-002\n", "chatgpt - openai-chat:gpt-3.5-turbo\n", "gpt4 - openai-chat:gpt-4\n", "ernie-bot - qianfan:ERNIE-Bot\n", "ernie-bot-4 - qianfan:ERNIE-Bot-4\n", "titan - bedrock:amazon.titan-tg1-large\n", "openrouter-claude - openrouter:anthropic/claude-3.5-sonnet:beta\n" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%ai list" ] }, { "cell_type": "markdown", "id": "44d5230e-5c93-4dba-b08f-a15a88dbb9ed", "metadata": {}, "source": [ "and list models for a specific provider using `%ai list `:" ] }, { "cell_type": "code", "execution_count": 3, "id": "7b06bc55-c82c-42d0-934d-10343519e04e", "metadata": {}, "outputs": [ { "data": { "text/markdown": [ "| Provider | Environment variable | Set? | Models |\n", "|----------|----------------------|------|--------|\n", "| `openai` | `OPENAI_API_KEY` | | |\n" ], "text/plain": [ "openai\n", "Requires environment variable: OPENAI_API_KEY (set)\n", "* openai:babbage-002\n", "* openai:davinci-002\n", "* openai:gpt-3.5-turbo-instruct\n", "\n" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%ai list openai" ] }, { "cell_type": "markdown", "id": "3956c259-baa0-43ac-b001-dcec86b20e55", "metadata": {}, "source": [ "The `%%ai` magic can be used to run commands in-line. Here we can send an ordinary prompt to `gpt-3.5-turbo`. Note that this requires setting the `OPENAI_API_KEY` environment variable before running Jupyter (not sufficient to just configure in settings):" ] }, { "cell_type": "code", "execution_count": 5, "id": "8619511e-af31-4d42-927c-2b539e3bb079", "metadata": {}, "outputs": [ { "data": { "text/markdown": [ "\n", "\n", "I am an AI language model created by OpenAI called GPT-3. I was trained on a large dataset of text from the internet to generate human-like text based on the input given to me. I am capable of answering questions, completing prompts, and engaging in conversations. My purpose is to assist humans in various tasks and provide helpful and informative responses." ], "text/plain": [ "" ] }, "execution_count": 5, "metadata": { "text/markdown": { "jupyter_ai": { "model_id": "gpt-3.5-turbo-instruct", "provider_id": "openai" } } }, "output_type": "execute_result" } ], "source": [ "%%ai openai:gpt-3.5-turbo-instruct\n", "Who are you?" ] }, { "cell_type": "markdown", "id": "8fe4b266-dfb3-4bbb-b8af-472495e2eaa8", "metadata": {}, "source": [ "The default behavior is to output markdown. We can tell the model to write code directly by using `-f code`:" ] }, { "cell_type": "code", "execution_count": 6, "id": "bc8e4dce-ac42-4f3e-ba17-709076c7a92f", "metadata": {}, "outputs": [ { "data": { "text/html": [ "AI generated code inserted below ⬇️" ], "text/plain": [ "" ] }, "execution_count": 6, "metadata": { "text/html": { "jupyter_ai": { "model_id": "gpt-3.5-turbo-instruct", "provider_id": "openai" } } }, "output_type": "execute_result" } ], "source": [ "%%ai openai:gpt-3.5-turbo-instruct -f code\n", "Write python code to plot a histogram of 10,000 numbers in the normal distribution." ] }, { "cell_type": "code", "execution_count": 7, "id": "16201363-ce88-48d9-8f12-534dc4276e1a", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "# Generate 10,000 random numbers from the normal distribution\n", "data = np.random.normal(size=10000)\n", "\n", "# Plot the histogram with 50 bins\n", "plt.hist(data, bins=50)\n", "\n", "# Add labels and title\n", "plt.xlabel('Value')\n", "plt.ylabel('Frequency')\n", "plt.title('Normal Distribution Histogram')\n", "\n", "# Show the plot\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "b0191e7b-6d48-401c-90bd-7f920a28bc30", "metadata": {}, "source": [ "### Ollama" ] }, { "cell_type": "markdown", "id": "ac300dad-f585-410b-ac6e-5fa1071cf0b2", "metadata": {}, "source": [ "[Ollama](http://www.ollama.ai) is a framework based on [llama.cpp](https://github.com/ggerganov/llama.cpp) for running and serving LLMs locally. Amazingly, Jupyter AI supports Ollama as a model provider, so we can use generative AI locally without worrying about privacy concerns or being charged for usage by a model provider!\n", "\n", "Here, we use Ollama to code using [LLaMA 3.2](https://ollama.com/library/llama3.2):" ] }, { "cell_type": "code", "execution_count": 13, "id": "476f2486-30ef-43a5-88dd-3492ab3d1b59", "metadata": {}, "outputs": [ { "data": { "text/html": [ "AI generated code inserted below ⬇️" ], "text/plain": [ "" ] }, "execution_count": 13, "metadata": { "text/html": { "jupyter_ai": { "model_id": "llama3.2", "provider_id": "ollama" } } }, "output_type": "execute_result" } ], "source": [ "%%ai ollama:llama3.2 -f code\n", "Write python code to plot a histogram of 10,000 numbers in the normal distribution. Make the plot burgandy." ] }, { "cell_type": "code", "execution_count": 14, "id": "28d94327-8236-402d-b354-b339245889b0", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "# Generate 10,000 random numbers from a normal distribution\n", "numbers = np.random.normal(0, 1, 10000)\n", "\n", "# Create a figure and axis object\n", "fig, ax = plt.subplots()\n", "\n", "# Plot the histogram with burgundy color\n", "ax.hist(numbers, bins=30, alpha=0.7, color='#8B0A1A')\n", "\n", "# Set title and labels\n", "ax.set_title('Normal Distribution Histogram')\n", "ax.set_xlabel('Value')\n", "ax.set_ylabel('Frequency')\n", "\n", "# Show grid lines\n", "ax.grid(True)\n", "\n", "# Display the plot\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "aa1a1cd1-9844-42e1-9140-f73c223b1d74", "metadata": {}, "source": [ "### Using Jupyter AI and LLaMA 3.2 to analyze Google Analytics data" ] }, { "cell_type": "markdown", "id": "bf708ea5-6828-4a98-86c4-07fbe7d470de", "metadata": {}, "source": [ "We will now use Jupyter AI and the LLaMA 3.2 model to help us visualize some analytics data we exported from Google Analytics. " ] }, { "cell_type": "markdown", "id": "bef87272-0a1c-421a-a607-5a1027c6517b", "metadata": {}, "source": [ "First we will have the model help us read in the data:" ] }, { "cell_type": "code", "execution_count": 18, "id": "7d6796ae-f225-4e3c-bf51-0021b201e5d8", "metadata": {}, "outputs": [ { "data": { "text/html": [ "AI generated code inserted below ⬇️" ], "text/plain": [ "" ] }, "execution_count": 18, "metadata": { "text/html": { "jupyter_ai": { "model_id": "llama3.2", "provider_id": "ollama" } } }, "output_type": "execute_result" } ], "source": [ "%%ai ollama:llama3.2 -f code\n", "Write the next section of this notebook - read in a CSV file called 'sample_ga_data.csv' from the 'data' directory." ] }, { "cell_type": "code", "execution_count": 19, "id": "0f8f7443-12b8-420c-b0bc-310cd7e3605b", "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "import os\n", "\n", "# Define path to data file\n", "data_dir = 'data'\n", "file_name = 'sample_ga_data.csv'\n", "\n", "# Construct full path to data file\n", "full_path = os.path.join(data_dir, file_name)\n", "\n", "# Read CSV file into a pandas DataFrame\n", "df = pd.read_csv(full_path)" ] }, { "cell_type": "markdown", "id": "c3e1cd00-5b32-4fc8-bb55-a1ec0920114d", "metadata": {}, "source": [ "Now we can show what was read in above:" ] }, { "cell_type": "code", "execution_count": 24, "id": "63774cea-7915-4f58-aa81-82c2e4013019", "metadata": {}, "outputs": [ { "data": { "text/html": [ "AI generated code inserted below ⬇️" ], "text/plain": [ "" ] }, "execution_count": 24, "metadata": { "text/html": { "jupyter_ai": { "model_id": "llama3.2", "provider_id": "ollama" } } }, "output_type": "execute_result" } ], "source": [ "%%ai ollama:llama3.2 -f code\n", "Show the data in the dataframe `df`." ] }, { "cell_type": "code", "execution_count": 26, "id": "1bf4c181-cd83-4d81-b4d3-36984f6c08c2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Date Sessions Bounce rate Active users Average session duration \\\n", "0 20240904 40 0.525000 30 370.297214 \n", "1 20240913 30 0.433333 20 263.390435 \n", "2 20240924 29 0.517241 26 69.263001 \n", "3 20240927 25 0.360000 23 269.768585 \n", "4 20240910 24 0.416667 19 113.468108 \n", "5 20241001 24 0.458333 16 100.926206 \n", "6 20240917 22 0.545455 20 81.033939 \n", "7 20240918 18 0.611111 9 38.904332 \n", "8 20240919 18 0.611111 14 59.650867 \n", "9 20240923 18 0.611111 15 28.592473 \n", "10 20241002 18 0.500000 12 149.538097 \n", "11 20240905 16 0.625000 10 141.876053 \n", "12 20240911 14 0.714286 10 64.409749 \n", "13 20240909 13 0.538462 10 99.439070 \n", "14 20240922 12 0.500000 10 131.138945 \n", "15 20240925 12 0.333333 11 134.335473 \n", "16 20240906 11 0.636364 9 101.025390 \n", "17 20240912 11 0.454545 9 18.188962 \n", "18 20240920 11 0.636364 6 136.310941 \n", "19 20240914 10 0.600000 6 96.695500 \n", "20 20240926 10 0.300000 9 46.641499 \n", "21 20240930 10 0.300000 9 53.155658 \n", "22 20240928 9 0.444444 8 179.839339 \n", "23 20240921 8 0.500000 7 393.362225 \n", "24 20240907 6 0.500000 4 69.908416 \n", "25 20240916 6 0.500000 5 147.064785 \n", "26 20240929 5 0.200000 4 258.056803 \n", "27 20241003 5 0.800000 4 37.499108 \n", "28 20240908 4 0.250000 4 25.356556 \n", "29 20240915 2 0.500000 2 103.749147 \n", "\n", " Total users \n", "0 35 \n", "1 20 \n", "2 26 \n", "3 23 \n", "4 21 \n", "5 18 \n", "6 20 \n", "7 12 \n", "8 14 \n", "9 15 \n", "10 14 \n", "11 14 \n", "12 11 \n", "13 11 \n", "14 10 \n", "15 11 \n", "16 10 \n", "17 10 \n", "18 8 \n", "19 9 \n", "20 9 \n", "21 10 \n", "22 9 \n", "23 7 \n", "24 5 \n", "25 6 \n", "26 5 \n", "27 4 \n", "28 4 \n", "29 2 \n" ] } ], "source": [ "print(df)" ] }, { "cell_type": "code", "execution_count": 27, "id": "c4c18878-c75c-4f08-8170-00d883d3f8b1", "metadata": {}, "outputs": [ { "data": { "text/markdown": [ "**Converting 'Date' Column to datetime Type**\n", "\n", "```python\n", "# Import necessary library\n", "import pandas as pd\n", "\n", "# Assuming df is your DataFrame and 'Date' column needs conversion\n", "df['Date'] = pd.to_datetime(df['Date'], format='%Y%m%d')\n", "```\n", "\n", "### Explanation:\n", "\n", "* The `pd.to_datetime()` function converts the specified column to datetime type.\n", "* The `format='%Y%m%d'` parameter specifies that the dates are in the YYYYMMDD format.\n", "\n", "### Example Use Case:\n", "```python\n", "# Sample DataFrame with 'Date' column\n", "data = {'Date': ['20210215', '20210316', '20210417'], \n", " 'Value': [10, 20, 30]}\n", "df = pd.DataFrame(data)\n", "\n", "print(\"Before Conversion:\")\n", "print(df)\n", "```\n", "\n", "After running the above code, you will see that the 'Date' column has been converted to datetime type.\n", "\n", "```python\n", "# Print the output after conversion\n", "print(\"\\nAfter Conversion:\")\n", "print(df['Date'].dtypes) # Output: datetime64[ns]\n", "```" ], "text/plain": [ "" ] }, "execution_count": 27, "metadata": { "text/markdown": { "jupyter_ai": { "model_id": "llama3.2", "provider_id": "ollama" } } }, "output_type": "execute_result" } ], "source": [ "%%ai ollama:llama3.2\n", "Write code to take the dataframe 'df' and reformat the column 'Date' which is in format YYYYMMDD into a `datetime` type in pandas." ] }, { "cell_type": "code", "execution_count": 28, "id": "3238e820-6467-46b1-bd3d-cb390f1933da", "metadata": {}, "outputs": [], "source": [ "df['Date'] = pd.to_datetime(df['Date'], format='%Y%m%d')" ] }, { "cell_type": "markdown", "id": "9b083f9d-c817-4611-a7f1-e0d67daccc11", "metadata": {}, "source": [ "Now we can plot the result:" ] }, { "cell_type": "code", "execution_count": 33, "id": "ea04aa3d-4f6b-4b8e-a246-b3490fd0677d", "metadata": {}, "outputs": [ { "data": { "text/html": [ "AI generated code inserted below ⬇️" ], "text/plain": [ "" ] }, "execution_count": 33, "metadata": { "text/html": { "jupyter_ai": { "model_id": "llama3.2", "provider_id": "ollama" } } }, "output_type": "execute_result" } ], "source": [ "%%ai ollama:llama3.2 -f code\n", "Take the `df` dataframe and create a line plot of th Sessions column by Date in red with the title \"Sessions per Day\" label the x-axis and y-axis." ] }, { "cell_type": "code", "execution_count": 34, "id": "747fe67f-e45c-4e6a-97a8-a28ffa253581", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "# Assuming df is your DataFrame\n", "\n", "fig, ax = plt.subplots(figsize=(10,6))\n", "ax.plot(df['Date'], df['Sessions'], marker='o', linestyle='-', color='red')\n", "\n", "ax.set_xlabel('Date')\n", "ax.set_ylabel('Sessions')\n", "ax.set_title('Sessions per Day')\n", "\n", "plt.grid(True)\n", "plt.xticks(rotation=45)\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 36, "id": "527a945e-d214-4160-ab10-86a45dc5f774", "metadata": {}, "outputs": [ { "data": { "text/markdown": [ "To fix the issue, we need to make sure that the dates are sorted correctly before plotting them.\n", "\n", "Here's an example code snippet using Python with pandas and matplotlib libraries:\n", "\n", "```python\n", "# Import necessary libraries\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "# Sample data\n", "data = {\n", " 'Date': ['2022-01-20', '2021-02-10', '2023-03-15', '2022-04-25', '2021-05-18'],\n", " 'Value': [100, 120, 110, 130, 105]\n", "}\n", "\n", "# Convert date to datetime format\n", "df = pd.DataFrame(data)\n", "df['Date'] = pd.to_datetime(df['Date'])\n", "\n", "# Sort the data by Date in ascending order\n", "df_sorted = df.sort_values(by='Date')\n", "\n", "# Print sorted data\n", "print(\"Sorted Data:\")\n", "print(df_sorted)\n", "\n", "# Plot the data\n", "plt.figure(figsize=(10, 6))\n", "plt.plot(df_sorted['Date'], df_sorted['Value'], marker='o')\n", "plt.title('Line plot of Sorted Data')\n", "plt.xlabel('Date')\n", "plt.ylabel('Value')\n", "plt.show()\n", "```\n", "\n", "This code will first sort the date in ascending order, then print and plot the sorted data.\n", "\n", "Please replace your actual data into this code snippet and run it." ], "text/plain": [ "" ] }, "execution_count": 36, "metadata": { "text/markdown": { "jupyter_ai": { "model_id": "llama3.2", "provider_id": "ollama" } } }, "output_type": "execute_result" } ], "source": [ "%%ai ollama:llama3.2\n", "The data seem to be all out of order date-wise. Could you sort the data and then plot it?" ] }, { "cell_type": "code", "execution_count": 37, "id": "958a5776-6362-492f-9432-f9bb88cacab6", "metadata": {}, "outputs": [], "source": [ "df_sorted = df.sort_values(by='Date')" ] }, { "cell_type": "code", "execution_count": 42, "id": "69a559d8-3cf6-4d90-88e9-0d8244abef0b", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "# Assuming df is your DataFrame\n", "\n", "fig, ax = plt.subplots(figsize=(10,6))\n", "ax.plot(df_sorted['Date'], df_sorted['Sessions'], marker='o', linestyle='-', color='red')\n", "\n", "ax.set_xlabel('Date')\n", "ax.set_ylabel('Sessions')\n", "ax.set_title('Sessions per Day')\n", "\n", "plt.grid(True)\n", "plt.xticks(rotation=45)\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 45, "id": "c41fa3c6-2504-4c59-895d-5344231e1ec9", "metadata": {}, "outputs": [ { "data": { "text/markdown": [ "```markdown\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "# Assuming df is your DataFrame\n", "df_mean = df_sorted['Sessions'].mean()\n", "\n", "fig, ax = plt.subplots(figsize=(10,6))\n", "ax.plot(df_sorted['Date'], df_sorted['Sessions'], marker='o', linestyle='-', color='red')\n", "\n", "ax.axhline(y=df_mean, color='black', linestyle='--', label='Average')\n", "ax.axhline(y=df_mean + np.std(df_sorted['Sessions']), color='black', linestyle='-', label='+1 standard deviation')\n", "ax.axhline(y=df_mean - np.std(df_sorted['Sessions']), color='black', linestyle='-', label='-1 standard deviation')\n", "\n", "ax.set_xlabel('Date')\n", "ax.set_ylabel('Sessions')\n", "ax.set_title('Sessions per Day')\n", "\n", "plt.grid(True)\n", "plt.xticks(rotation=45)\n", "\n", "plt.legend()\n", "plt.show()\n", "```\n", "\n", "This code adds two additional horizontal lines to the plot using `axhline`. The first line is a dashed black line at the mean value. The second and third lines are solid black lines at +1 and -1 standard deviations, respectively.\n", "\n", "Please note that you need to import numpy for the standard deviation calculation (`np.std`) and add labels and legend to make the plot more informative." ], "text/plain": [ "" ] }, "execution_count": 45, "metadata": { "text/markdown": { "jupyter_ai": { "model_id": "llama3.2", "provider_id": "ollama" } } }, "output_type": "execute_result" } ], "source": [ "%%ai ollama:llama3.2\n", "Could you take the code below and add code to plot a dashed horizontal line of the average value, as well as solid black horizontal lines for +1 and -1 standard deviations away from the average?\n", "\n", "```\n", "import matplotlib.pyplot as plt\n", "\n", "# Assuming df is your DataFrame\n", "\n", "fig, ax = plt.subplots(figsize=(10,6))\n", "ax.plot(df_sorted['Date'], df_sorted['Sessions'], marker='o', linestyle='-', color='red')\n", "\n", "ax.set_xlabel('Date')\n", "ax.set_ylabel('Sessions')\n", "ax.set_title('Sessions per Day')\n", "\n", "plt.grid(True)\n", "plt.xticks(rotation=45)\n", "\n", "plt.show()\n", "```" ] }, { "cell_type": "code", "execution_count": 46, "id": "7d7bcfa6-d21f-4580-97a6-3de953863bce", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "df_mean = df_sorted['Sessions'].mean()\n", "\n", "fig, ax = plt.subplots(figsize=(10,6))\n", "ax.plot(df_sorted['Date'], df_sorted['Sessions'], marker='o', linestyle='-', color='red')\n", "\n", "ax.axhline(y=df_mean, color='black', linestyle='--', label='Average')\n", "ax.axhline(y=df_mean + np.std(df_sorted['Sessions']), color='black', linestyle='-', label='+1 standard deviation')\n", "ax.axhline(y=df_mean - np.std(df_sorted['Sessions']), color='black', linestyle='-', label='-1 standard deviation')\n", "\n", "ax.set_xlabel('Date')\n", "ax.set_ylabel('Sessions')\n", "ax.set_title('Sessions per Day')\n", "\n", "plt.grid(True)\n", "plt.xticks(rotation=45)\n", "\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 9, "id": "d69952bd-9f5f-4c6c-af32-5334f49cb417", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "\n", "df = df.sort_values(by='Date')\n", "\n", "# Plotting the data\n", "plt.figure(figsize=(10,6))\n", "plt.plot(df['Date'], df['Sessions'], marker='o', color='red')\n", "plt.title('Sessions per Day')\n", "plt.xlabel('Date')\n", "plt.ylabel('Number of Sessions')\n", "\n", "# Showing the plot\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "e510fbe4-d29d-443e-8672-6978bb1c9072", "metadata": {}, "source": [] }, { "cell_type": "markdown", "id": "4be91ca1-788e-4522-8add-d87191da3c2e", "metadata": {}, "source": [ "### Using RAG with `/learn` and chatting with documents\n", "\n", "Jupyter AI has the ability to [read documents in a directory](https://jupyter-ai.readthedocs.io/en/latest/users/index.html#learning-about-local-data) and allow Q&A through Jupyternaut. \\\n", "\n", "Here we have a document on enhanced measurement events in GA4. We want to get an answer to a question and can use AI in Jupyter to help us! In Jupyternaut, we just pass the name of the directory using the command: `/learn `. We can then ask questions using the data as context with `/ask`.\n", "\n", "Currently, the following formats are supported:\n", "- Python files and Jupyter notebooks (`.py`, `.ipynb`)\n", "- Markdown (`.md`)\n", "- R files (`.R`, `.Rmd`)\n", "- Webpages and documents (`.txt`, `.html`, `.pdf`)\n", "- Various others (`.jl`, `.sh`, `.tex`)" ] }, { "cell_type": "markdown", "id": "5e1b6b82-36f6-4b30-b618-b13dccea3bc5", "metadata": {}, "source": [ "### Conclusion\n", "That concludes the notebook. For further resources, check out the official Jupyter AI and Ollama resoures below:\n", "- [Jupyter AI Documentation](https://jupyter-ai.readthedocs.io/en/latest/)\n", "- [Jupyter AI on Github](https://github.com/jupyterlab/jupyter-ai)\n", "- [Generative AI in Jupyter](https://blog.jupyter.org/generative-ai-in-jupyter-3f7174824862): Announcement post from Jupyter team\n", "- [Ollama Official Site](https://ollama.com/)\n", "- [Ollama Models Directory](https://ollama.com/library)\n", "- [Official Documentation on Github](https://github.com/ollama/ollama/blob/main/docs/README.md)" ] }, { "cell_type": "markdown", "id": "a0fcb260-3b45-4b2e-a509-0d5a105ed0fe", "metadata": {}, "source": [ "----\n", "\n", "\n", " \n", " \n", "\n", "
Copyright NLP from scratch, 2024.
\n", " \n", "\n", "" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.6" } }, "nbformat": 4, "nbformat_minor": 5 }