diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile new file mode 100644 index 0000000..c955c84 --- /dev/null +++ b/.devcontainer/Dockerfile @@ -0,0 +1,27 @@ +FROM python:3.10 + +RUN pip install --no-cache-dir --upgrade pip +RUN apt update && apt install -y zsh curl git sudo wget vim + +ARG USERNAME=vscode +ARG USER_UID=1000 +ARG USER_GID=$USER_UID + +RUN groupadd --gid $USER_GID $USERNAME \ + && useradd --uid $USER_UID --gid $USER_GID -m $USERNAME + +RUN usermod -aG sudo $USERNAME +RUN echo 'vscode ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers + +USER $USERNAME + +RUN cd ~ && wget https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh && sh install.sh + +# Create and activate a Python virtual environment +RUN python -m venv ~/venv +RUN echo "source ~/venv/bin/activate" >> ~/.zshrc + +RUN echo "export PYTHONPATH=\$PYTHONPATH:/workspace" >> ~/.zshrc +RUN /bin/zsh ~/.zshrc + +ENV DEBIAN_FRONTEND=dialog diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json new file mode 100644 index 0000000..968caa1 --- /dev/null +++ b/.devcontainer/devcontainer.json @@ -0,0 +1,55 @@ +// For format details, see https://aka.ms/devcontainer.json. For config options, see the +// README at: https://github.com/devcontainers/templates/tree/main/src/postgres +{ + "name": "Geektime Course Notebook", + "dockerComposeFile": "docker-compose.yml", + "service": "app", + "workspaceFolder": "/workspace", + "customizations": { + "vscode": { + "settings": { + "terminal.integrated.defaultProfile.linux": "zsh", + "terminal.integrated.profiles.linux": { + "zsh": { + "path": "/bin/zsh" + } + } + }, + "extensions": [ + "GitHub.copilot", + "GitHub.copilot-labs", + "GitHub.vscode-pull-request-github", + "ms-python.python", + "ms-python.vscode-pylance", + "ms-python.pylint", + "ms-python.isort", + "ms-python.black-formatter", + "matangover.mypy", + "ms-toolsai.jupyter", + "ms-toolsai.jupyter-keymap", + "ms-toolsai.vscode-jupyter-slideshow", + "eamodio.gitlens" + ] + } + }, + "containerEnv": { + "OPENAI_API_KEY": "${localEnv:OPENAI_API_KEY}", + "JUPYTER_HOME": "${localEnv:JUPYTER_HOME}" + }, + // Features to add to the dev container. More info: https://containers.dev/features. + // "features": {}, + + // Use 'forwardPorts' to make a list of ports inside the container available locally. + // This can be used to network with other containers or the host. + "forwardPorts": [8080, 3306, 6379], + + // Use 'postCreateCommand' to run commands after the container is created. + "postCreateCommand": "./.devcontainer/postCreateCommand.sh" + + // Configure tool-specific properties. + // "customizations": {}, + + // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root. + // "remoteUser": "root" +} + diff --git a/.devcontainer/docker-compose.yml b/.devcontainer/docker-compose.yml new file mode 100644 index 0000000..8dccfe0 --- /dev/null +++ b/.devcontainer/docker-compose.yml @@ -0,0 +1,13 @@ +version: '3.8' + +services: + app: + build: + context: .. + dockerfile: .devcontainer/Dockerfile + volumes: + - ..:/workspace + ports: + - "8888:8888" + user: vscode + command: sleep infinity \ No newline at end of file diff --git a/.devcontainer/postCreateCommand.sh b/.devcontainer/postCreateCommand.sh new file mode 100755 index 0000000..3a48a44 --- /dev/null +++ b/.devcontainer/postCreateCommand.sh @@ -0,0 +1,5 @@ +#!/bin/bash +source /home/vscode/venv/bin/activate +pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple +pip install -r requirements.txt +sudo chown vscode:vscode /workspace \ No newline at end of file diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..e1d1fae --- /dev/null +++ b/.env.example @@ -0,0 +1,2 @@ +OPENAI_API_KEY=YOUR_API_KEY +JUPYTER_HOME=/workspace \ No newline at end of file diff --git a/.gitignore b/.gitignore index 1d2eee0..3367168 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,13 @@ .DS_Store +.env .ipynb_checkpoints +cc.en.300.bin data/podcast_clip_*.mp3 data/podcast_long.* data/paddlespeech*.wav data/tts.* -data/transcripts \ No newline at end of file +data/transcripts +data/*.jsonl +data/20_newsgroup.csv +data/output.png +data/toutiao_cat_data* diff --git a/01_open_ai_101.ipynb b/01_open_ai_101.ipynb index d81772a..2a0054a 100644 --- a/01_open_ai_101.ipynb +++ b/01_open_ai_101.ipynb @@ -1,35 +1,5 @@ { "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: openai in /Users/xuwenhao/miniconda3/envs/py310/lib/python3.10/site-packages (0.27.0)\n", - "Requirement already satisfied: requests>=2.20 in /Users/xuwenhao/miniconda3/envs/py310/lib/python3.10/site-packages (from openai) (2.28.2)\n", - "Requirement already satisfied: aiohttp in /Users/xuwenhao/miniconda3/envs/py310/lib/python3.10/site-packages (from openai) (3.8.4)\n", - "Requirement already satisfied: tqdm in /Users/xuwenhao/miniconda3/envs/py310/lib/python3.10/site-packages (from openai) (4.64.1)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /Users/xuwenhao/miniconda3/envs/py310/lib/python3.10/site-packages (from requests>=2.20->openai) (3.0.1)\n", - "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /Users/xuwenhao/miniconda3/envs/py310/lib/python3.10/site-packages (from requests>=2.20->openai) (1.26.14)\n", - "Requirement already satisfied: idna<4,>=2.5 in /Users/xuwenhao/miniconda3/envs/py310/lib/python3.10/site-packages (from requests>=2.20->openai) (3.4)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /Users/xuwenhao/miniconda3/envs/py310/lib/python3.10/site-packages (from requests>=2.20->openai) (2022.12.7)\n", - "Requirement already satisfied: yarl<2.0,>=1.0 in /Users/xuwenhao/miniconda3/envs/py310/lib/python3.10/site-packages (from aiohttp->openai) (1.8.2)\n", - "Requirement already satisfied: multidict<7.0,>=4.5 in /Users/xuwenhao/miniconda3/envs/py310/lib/python3.10/site-packages (from aiohttp->openai) (6.0.4)\n", - "Requirement already satisfied: frozenlist>=1.1.1 in /Users/xuwenhao/miniconda3/envs/py310/lib/python3.10/site-packages (from aiohttp->openai) (1.3.3)\n", - "Requirement already satisfied: attrs>=17.3.0 in /Users/xuwenhao/miniconda3/envs/py310/lib/python3.10/site-packages (from aiohttp->openai) (22.2.0)\n", - "Requirement already satisfied: aiosignal>=1.1.2 in /Users/xuwenhao/miniconda3/envs/py310/lib/python3.10/site-packages (from aiohttp->openai) (1.3.1)\n", - "Requirement already satisfied: async-timeout<5.0,>=4.0.0a3 in /Users/xuwenhao/miniconda3/envs/py310/lib/python3.10/site-packages (from aiohttp->openai) (4.0.2)\n" - ] - } - ], - "source": [ - "!conda install openai" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -62,10 +32,12 @@ } ], "source": [ - "import openai\n", + "from openai import OpenAI\n", "import os\n", "\n", - "openai.api_key = os.environ.get(\"OPENAI_API_KEY\")\n", + "client = OpenAI(\n", + " api_key=os.environ['OPENAI_API_KEY'],\n", + ")\n", "COMPLETION_MODEL = \"text-davinci-003\"\n", "\n", "\n", @@ -80,8 +52,8 @@ "\"\"\"\n", "\n", "def get_response(prompt):\n", - " completions = openai.Completion.create (\n", - " engine=COMPLETION_MODEL,\n", + " completions = client.completions.create (\n", + " model=COMPLETION_MODEL,\n", " prompt=prompt,\n", " max_tokens=512,\n", " n=1,\n", @@ -144,7 +116,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.10.1" }, "vscode": { "interpreter": { diff --git a/02_zero_shot_classification.ipynb b/02_zero_shot_classification.ipynb index 974f41a..f372939 100644 --- a/02_zero_shot_classification.ipynb +++ b/02_zero_shot_classification.ipynb @@ -18,19 +18,32 @@ "name": "stdout", "output_type": "stream", "text": [ - "好评例子的评分 : 0.070963\n", - "差评例子的评分 : -0.081472\n" + "好评例子的评分 : 0.040873\n", + "差评例子的评分 : -0.016688\n" ] } ], "source": [ - "import openai\n", + "from openai import OpenAI\n", + "import numpy as np\n", "import os\n", - "from openai.embeddings_utils import cosine_similarity, get_embedding\n", "\n", - "openai.api_key = os.environ.get(\"OPENAI_API_KEY\")\n", + "client = OpenAI(api_key=os.environ['OPENAI_API_KEY'])\n", + "\n", "EMBEDDING_MODEL = \"text-embedding-ada-002\"\n", "\n", + "def get_embedding(text, model=EMBEDDING_MODEL):\n", + " text = text.replace(\"\\n\", \" \")\n", + " return client.embeddings.create(input = [text], model=model).data[0].embedding\n", + "\n", + "def cosine_similarity(vector_a, vector_b):\n", + " dot_product = np.dot(vector_a, vector_b)\n", + " norm_a = np.linalg.norm(vector_a)\n", + " norm_b = np.linalg.norm(vector_b)\n", + " epsilon = 1e-10\n", + " cosine_similarity = dot_product / (norm_a * norm_b + epsilon)\n", + " return cosine_similarity\n", + "\n", "positive_review = get_embedding(\"好评\")\n", "negative_review = get_embedding(\"差评\")\n", "\n", @@ -65,8 +78,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "好评餐馆的评分 : 0.062719\n", - "差评餐馆的评分 : -0.074591\n" + "好评餐馆的评分 : 0.051292\n", + "差评餐馆的评分 : -0.006322\n" ] } ], @@ -100,7 +113,7 @@ "\n", "from sklearn.metrics import classification_report\n", "\n", - "datafile_path = \"data/fine_food_reviews_with_embeddings_1k.csv\"\n", + "datafile_path = os.environ.get(\"JUPYTER_HOME\") + \"/data/fine_food_reviews_with_embeddings_1k.csv\"\n", "\n", "df = pd.read_csv(datafile_path)\n", "df[\"embedding\"] = df.embedding.apply(eval).apply(np.array)\n", @@ -141,7 +154,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -157,7 +170,7 @@ " labels = ['negative', 'positive'], \n", " model = EMBEDDING_MODEL,\n", "):\n", - " label_embeddings = [get_embedding(label, engine=model) for label in labels]\n", + " label_embeddings = [get_embedding(label, model=model) for label in labels]\n", "\n", " def label_score(review_embedding, label_embeddings):\n", " return cosine_similarity(review_embedding, label_embeddings[1]) - cosine_similarity(review_embedding, label_embeddings[0])\n", @@ -191,7 +204,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.10.1" }, "vscode": { "interpreter": { diff --git a/03_food_chatbot.py b/03_food_chatbot.py new file mode 100644 index 0000000..e840ac8 --- /dev/null +++ b/03_food_chatbot.py @@ -0,0 +1,44 @@ +from openai import OpenAI +import os + +client = OpenAI(api_key = os.environ["OPENAI_API_KEY"]) + +def ask_gpt3(prompt): + response = client.completions.create( + model="text-davinci-003", + prompt=prompt, + max_tokens=512, + n=1, + stop=None, + temperature=0.5, + ) + + message = response.choices[0].text.strip() + return message + +print("你好，我是一个聊天机器人，请你提出你的问题吧?") + +questions = [] +answers = [] + + +def generate_prompt(prompt, questions, answers): + num = len(answers) + for i in range(num): + prompt += "\n Q : " + questions[i] + prompt += "\n A : " + answers[i] + prompt += "\n Q : " + questions[num] + "\n A : " + return prompt + +while True: + user_input = input("> ") + questions.append(user_input) + if user_input.lower() in ["bye", "goodbye", "exit"]: + print("Goodbye!") + break + + prompt = generate_prompt("", questions, answers) + + answer = ask_gpt3(prompt) + print(answer) + answers.append(answer) \ No newline at end of file diff --git a/03_prompt_chatbot.ipynb b/03_prompt_chatbot.ipynb index 56c80a6..c931db1 100644 --- a/03_prompt_chatbot.ipynb +++ b/03_prompt_chatbot.ipynb @@ -13,18 +13,19 @@ "metadata": {}, "outputs": [], "source": [ - "import openai\n", + "from openai import OpenAI\n", "import os\n", "\n", - "openai.api_key = os.environ.get(\"OPENAI_API_KEY\")\n", + "client = OpenAI(api_key = os.environ.get(\"OPENAI_API_KEY\"))\n", + "\n", "COMPLETION_MODEL = \"text-davinci-003\"\n", "\n", "\n", "prompt = '请你用朋友的语气回复给到客户，并称他为“亲”，他的订单已经发货在路上了，预计在3天之内会送达，订单号2021AEDG，我们很抱歉因为天气的原因物流时间比原来长，感谢他选购我们的商品。'\n", "\n", "def get_response(prompt, temperature = 1.0, stop=None):\n", - " completions = openai.Completion.create (\n", - " engine=COMPLETION_MODEL,\n", + " completions = client.completions.create (\n", + " model=COMPLETION_MODEL,\n", " prompt=prompt,\n", " max_tokens=1024,\n", " n=1,\n", @@ -32,8 +33,7 @@ " temperature=temperature, \n", " )\n", " message = completions.choices[0].text\n", - " return message\n", - " \n" + " return message" ] }, { @@ -47,7 +47,7 @@ "text": [ "\n", "\n", - "亲，您的订单2021AEDG已发货，预计在三天内会送达。很抱歉因为天气的原因，物流可能会迟了一点。谢谢您选购我们的商品。\n" + "亲，您的订单已发货，订单号2021AEDG，大概3天内就能收到包裹。由于天气影响，物流需要的时间比原来预期的要长，请您多多包涵，非常感谢您选购我们的商品。\n" ] } ], @@ -66,7 +66,7 @@ "text": [ "\n", "\n", - "亲，您已下单成功，订单号2021AEDG，我们已将货物发出，预计将在3天内送达。目前，由于天气的原因，物流时间比原来有些延迟，这里我们真的很抱歉。最后，感谢您对我们的支持与关注！祝您生活愉快！\n" + "亲，您的订单（2021AEDG）已经发货在路上了，预计在3天内会到达。很抱歉这次因为天气的原因物流花费的时间比原来长了一点，感谢您对我们的商品选购，祝您购物愉快！\n" ] } ], @@ -161,15 +161,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "1. 锅中放油，加入蒜末、葱末、冬菇粉和大蒜粉，加入腊肉片爆香。\n", + "鱼香肉丝做法：\n", + "\n", + "1.准备好食材：500克猪肉（剁碎）、200克黄瓜（切丝）、2个胡萝卜（切丝）、2茶匙盐、1茶匙料酒、1汤匙蚝油、3汤匙鱼香调料、1汤匙葱花、油适量、水适量。\n", "\n", - "2. 加入肉末，芹菜末，炒香。\n", + "2. 猪肉倒入碗中加入盐、料酒、蚝油、鱼香调料搅拌均匀腌制10分钟。\n", "\n", - "3. 加入番茄酱、水淀粉、盐、糖、老抽、料酒。\n", + "3.黄瓜、胡萝卜条放入一次性食用手套中搅拌均匀，加入少许料酒、盐搅拌均匀腌制10分钟。\n", "\n", - "4. 加入熟白菜和黄豆粉，翻炒。\n", + "4.锅中倒入油，猪肉放入锅中参照切片厚度，开大火炒出油脂，改中小火炒至变色\n", "\n", - "5. 最后加入香菜末炒匀出锅即可。\n" + "5. 锅中倒入黄瓜和胡萝卜丝，加入少许水翻炒至食材变软，加入葱花翻炒均匀即可。\n" ] } ], @@ -197,10 +199,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "1.准备好食材：500克牛肉，2勺蚝油，1勺老抽，1勺葱花，配料：2勺姜末，2勺料酒，1勺糖，半勺盐，1勺醋，2勺香油，半勺糯米粉，半勺绍酒。\n", - "2.将牛肉洗净，切成片，放入料酒、盐、姜末拌匀腌制20分钟。\n", - "3.把蚝油、老抽、葱花、糖、醋、香油、糯米粉、绍酒放入碗中，搅拌均匀。\n", - "4.将牛肉片放入船形锅内，慢火翻炒至半熟，倒入调味料，用中火收汁，最后加入香菜，大火翻炒几下即可。\n" + "1.准备好所需食材：400克牛肉，1个洋葱，2勺蚝油，1勺糖，1勺盐，2勺料酒，少许花椒粉，3勺葱末，3勺姜末，3勺蒜末，3勺生抽，3勺老抽，3勺辣椒粉，2勺水淀粉，适量油。\n", + "2.将牛肉洗净后，放入清水中浸泡20分钟后再沥干水分，然后切成片，在肉上施加料酒和盐，抓捏抓匀，腌制20分钟备用。\n", + "3.将洋葱洗净，切成葱花，蒜、葱、姜末拌入水中腌制备用。\n", + "4.将油烧热，放入牛肉片，大火翻炒至肉片表面熟化，加入葱花、姜末和蒜末炒片刻，加入糖、蚝油、生抽、老抽、辣椒粉、料酒，改小火继续翻炒至肉片表面焦黄，倒入水淀粉勾芡，调味即可。\n" ] } ], @@ -220,141 +222,6 @@ "print(get_response(question))" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## food_chatbot.py" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "你好，我是一个聊天机器人，请你提出你的问题吧?\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "> 你好\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "你好\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "> 请问鱼香肉丝怎么做？\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "鱼香肉丝的做法：\n", - "1.准备好所需的食材：猪肉、葱、姜、蒜、腐竹、酱油、白糖、料酒、醋、香油等。\n", - "2.将猪肉切成片，加入料酒、盐、鸡精腌制半小时。\n", - "3.准备调料，将葱、姜、蒜、腐竹切成末，将酱油、白糖、醋、香油混合均匀备用。\n", - "4.锅中加入油，放入葱、姜、蒜、腐竹炒香。\n", - "5.放入腌制好的猪肉，翻炒均匀，加入调料拌匀。\n", - "6.加入适量清水，盖上锅盖焖煮5分钟，即可。\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "> 那蚝油牛肉呢？\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "蚝油牛肉的做法：\n", - "1.准备好所需的食材：牛肉、葱、姜、蒜、蚝油、料酒、醋、香油等。\n", - "2.将牛肉切成片，加入料酒、盐、鸡精腌制半小时。\n", - "3.准备调料，将葱、姜、蒜切成末，将蚝油、醋、香油混合均匀备用。\n", - "4.锅中加入油，放入葱、姜、蒜炒香。\n", - "5.放入腌制好的牛肉，翻炒均匀，加入调料拌匀。\n", - "6.加入适量清水，盖上锅盖焖煮5分钟，即可。\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "> bye\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Goodbye!\n" - ] - } - ], - "source": [ - "import openai\n", - "import os\n", - "\n", - "openai.api_key = os.environ[\"OPENAI_API_KEY\"]\n", - "\n", - "def ask_gpt3(prompt):\n", - " response = openai.Completion.create(\n", - " engine=\"text-davinci-003\",\n", - " prompt=prompt,\n", - " max_tokens=512,\n", - " n=1,\n", - " stop=None,\n", - " temperature=0.5,\n", - " )\n", - "\n", - " message = response.choices[0].text.strip()\n", - " return message\n", - "\n", - "print(\"你好，我是一个聊天机器人，请你提出你的问题吧?\")\n", - "\n", - "questions = []\n", - "answers = []\n", - "\n", - "\n", - "def generate_prompt(prompt, questions, answers):\n", - " num = len(answers)\n", - " for i in range(num):\n", - " prompt += \"\\n Q : \" + questions[i]\n", - " prompt += \"\\n A : \" + answers[i]\n", - " prompt += \"\\n Q : \" + questions[num] + \"\\n A : \" \n", - " return prompt\n", - "\n", - "while True:\n", - " user_input = input(\"> \")\n", - " questions.append(user_input)\n", - " if user_input.lower() in [\"bye\", \"goodbye\", \"exit\"]:\n", - " print(\"Goodbye!\")\n", - " break\n", - " \n", - " prompt = generate_prompt(\"\", questions, answers)\n", - "\n", - " answer = ask_gpt3(prompt)\n", - " print(answer)\n", - " answers.append(answer)\n" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -364,7 +231,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -397,7 +264,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": { "tags": [] }, @@ -436,7 +303,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.10.1" }, "vscode": { "interpreter": { diff --git a/04_classification_comparison.ipynb b/04_classification_comparison.ipynb index 50a45ea..dcafe69 100644 --- a/04_classification_comparison.ipynb +++ b/04_classification_comparison.ipynb @@ -1,413 +1,511 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Collecting package metadata (current_repodata.json): done\n", - "Solving environment: done\n", - "\n", - "# All requested packages already installed.\n", - "\n", - "Collecting package metadata (current_repodata.json): done\n", - "Solving environment: done\n", - "\n", - "# All requested packages already installed.\n", - "\n" - ] - } - ], - "source": [ - "!conda install gensim\n", - "!conda install fasttext" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Fasttext效果测试" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VHClECUkHcPp", + "outputId": "5b33ed1c-c8b3-42a8-a450-9111823f7708" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting fasttext==0.9.2\n", + " Downloading fasttext-0.9.2.tar.gz (68 kB)\n", + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/68.8 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━\u001b[0m \u001b[32m61.4/68.8 kB\u001b[0m \u001b[31m2.0 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m68.8/68.8 kB\u001b[0m \u001b[31m1.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Collecting pybind11>=2.2 (from fasttext==0.9.2)\n", + " Using cached pybind11-2.11.1-py3-none-any.whl (227 kB)\n", + "Requirement already satisfied: setuptools>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from fasttext==0.9.2) (67.7.2)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from fasttext==0.9.2) (1.23.5)\n", + "Building wheels for collected packages: fasttext\n", + " Building wheel for fasttext (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for fasttext: filename=fasttext-0.9.2-cp310-cp310-linux_x86_64.whl size=4199774 sha256=a2abeb1f730b352409085af8f4b7dc464bdeddaa985c73b40a9bdbad5d9a8a67\n", + " Stored in directory: /root/.cache/pip/wheels/a5/13/75/f811c84a8ab36eedbaef977a6a58a98990e8e0f1967f98f394\n", + "Successfully built fasttext\n", + "Installing collected packages: pybind11, fasttext\n", + "Successfully installed fasttext-0.9.2 pybind11-2.11.1\n", + "Requirement already satisfied: gensim==4.3.2 in /usr/local/lib/python3.10/dist-packages (4.3.2)\n", + "Requirement already satisfied: numpy>=1.18.5 in /usr/local/lib/python3.10/dist-packages (from gensim==4.3.2) (1.23.5)\n", + "Requirement already satisfied: scipy>=1.7.0 in /usr/local/lib/python3.10/dist-packages (from gensim==4.3.2) (1.11.4)\n", + "Requirement already satisfied: smart-open>=1.8.1 in /usr/local/lib/python3.10/dist-packages (from gensim==4.3.2) (6.4.0)\n" + ] + } + ], + "source": [ + "%pip install fasttext==0.9.2\n", + "%pip install gensim==4.3.2" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "--2023-03-20 10:56:41-- https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.en.300.bin.gz\n", - "Resolving dl.fbaipublicfiles.com (dl.fbaipublicfiles.com)... 104.22.75.142, 172.67.9.4, 104.22.74.142\n", - "Connecting to dl.fbaipublicfiles.com (dl.fbaipublicfiles.com)|104.22.75.142|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 4503593528 (4.2G) [application/octet-stream]\n", - "Saving to: ‘cc.en.300.bin.gz’\n", - "\n", - "cc.en.300.bin.gz 22%[===> ] 978.62M 2.72MB/s in 6m 50s \n", - "\n", - "2023-03-20 11:03:33 (2.39 MB/s) - Read error at byte 1026161458/4503593528 (error:1408F119:SSL routines:ssl3_get_record:decryption failed or bad record mac). Retrying.\n", - "\n", - "--2023-03-20 11:03:34-- (try: 2) https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.en.300.bin.gz\n", - "Connecting to dl.fbaipublicfiles.com (dl.fbaipublicfiles.com)|104.22.75.142|:443... connected.\n", - "HTTP request sent, awaiting response... 206 Partial Content\n", - "Length: 4503593528 (4.2G), 3477432070 (3.2G) remaining [application/octet-stream]\n", - "Saving to: ‘cc.en.300.bin.gz’\n", - "\n", - "cc.en.300.bin.gz 56%[++++======> ] 2.37G 5.96MB/s in 8m 17s \n", - "\n", - "2023-03-20 11:11:52 (2.92 MB/s) - Read error at byte 2547284735/4503593528 (error:1408F119:SSL routines:ssl3_get_record:decryption failed or bad record mac). Retrying.\n", - "\n", - "--2023-03-20 11:11:54-- (try: 3) https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.en.300.bin.gz\n", - "Connecting to dl.fbaipublicfiles.com (dl.fbaipublicfiles.com)|104.22.75.142|:443... connected.\n", - "HTTP request sent, awaiting response... 206 Partial Content\n", - "Length: 4503593528 (4.2G), 1956308793 (1.8G) remaining [application/octet-stream]\n", - "Saving to: ‘cc.en.300.bin.gz’\n", - "\n", - "cc.en.300.bin.gz 80%[+++++++++++====> ] 3.37G 7.67MB/s in 2m 41s \n", - "\n", - "2023-03-20 11:14:35 (6.32 MB/s) - Read error at byte 3614428013/4503593528 (error:1408F119:SSL routines:ssl3_get_record:decryption failed or bad record mac). Retrying.\n", - "\n", - "--2023-03-20 11:14:38-- (try: 4) https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.en.300.bin.gz\n", - "Connecting to dl.fbaipublicfiles.com (dl.fbaipublicfiles.com)|104.22.75.142|:443... connected.\n", - "HTTP request sent, awaiting response... 206 Partial Content\n", - "Length: 4503593528 (4.2G), 889165515 (848M) remaining [application/octet-stream]\n", - "Saving to: ‘cc.en.300.bin.gz’\n", - "\n", - "cc.en.300.bin.gz 100%[++++++++++++++++===>] 4.19G 6.65MB/s in 2m 7s \n", - "\n", - "2023-03-20 11:16:46 (6.68 MB/s) - ‘cc.en.300.bin.gz’ saved [4503593528/4503593528]\n", - "\n", - "--2023-03-20 11:16:46-- http://./\n", - "Resolving . (.)... 123.151.76.67, 61.151.174.112, 14.18.178.36, ...\n", - "Connecting to . (.)|123.151.76.67|:80... failed: Operation timed out.\n", - "Connecting to . (.)|61.151.174.112|:80... failed: Operation timed out.\n", - "Connecting to . (.)|14.18.178.36|:80... ^C\n" - ] - } - ], - "source": [ - "!wget https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.en.300.bin.gz" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "!gunzip ./cc.en.300.bin.gz " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import gensim\n", - "import numpy as np\n", - "# Load the FastText pre-trained model\n", - "model = gensim.models.fasttext.load_facebook_model('cc.en.300.bin')\n", - "\n", - "def get_fasttext_vector(line):\n", - " vec = np.zeros(300) # Initialize an empty 300-dimensional vector\n", - " for word in line.split():\n", - " vec += model.wv[word]\n", - " vec /= len(line.split()) # Take the average over all words in the line\n", - " return vec" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "positive_text = \"\"\"Wanted to save some to bring to my Chicago family but my North Carolina family ate all 4 boxes before I could pack. These are excellent...could serve to anyone\"\"\"\n", - "negative_text = \"\"\"First, these should be called Mac - Coconut bars, as Coconut is the #2 ingredient and Mango is #3. Second, lots of people don't like coconut. I happen to be allergic to it. Word to Amazon that if you want happy customers to make things like this more prominent. Thanks.\"\"\"\n", - "\n", - "positive_example_in_fasttext = get_fasttext_vector(positive_text)\n", - "negative_example_in_fasttext = get_fasttext_vector(negative_text)\n", - "\n", - "positive_review_in_fasttext = get_fasttext_vector(\"An Amazon review with a positive sentiment.\")\n", - "negative_review_in_fasttext = get_fasttext_vector('An Amazon review with a negative sentiment.')" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": { + "id": "wXQ8qh_3HcPq" + }, + "source": [ + "### Fasttext效果测试" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Fasttext好评例子的评分 : -0.000544\n", - "Fasttext差评例子的评分 : 0.000369\n" - ] - } - ], - "source": [ - "from openai.embeddings_utils import cosine_similarity\n", - "\n", - "def get_fasttext_score(sample_embedding):\n", - " return cosine_similarity(sample_embedding, positive_review_in_fasttext) - cosine_similarity(sample_embedding, negative_review_in_fasttext)\n", - "\n", - "positive_score = get_fasttext_score(positive_example_in_fasttext)\n", - "negative_score = get_fasttext_score(negative_example_in_fasttext)\n", - "\n", - "print(\"Fasttext好评例子的评分 : %f\" % (positive_score))\n", - "print(\"Fasttext差评例子的评分 : %f\" % (negative_score))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### T5效果测试" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# install transformers if required\n", - "#!conda install -y transformers -c conda-forge\n", - "#!conda install -y pytorch torchvision -c pytorch\n", - "#!conda install -y sentencepiece" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "from transformers import AutoTokenizer, AutoModel\n", - "import torch\n", - "\n", - "# load the T5 tokenizer and model\n", - "tokenizer = AutoTokenizer.from_pretrained('t5-small', model_max_length=512)\n", - "model = AutoModel.from_pretrained('t5-small')\n", - "\n", - "# set the model to evaluation mode\n", - "model.eval()\n", - "\n", - "# encode the input sentence\n", - "def get_t5_vector(line):\n", - " input_ids = tokenizer.encode(line, return_tensors='pt', max_length=512, truncation=True)\n", - " # generate the vector representation\n", - " with torch.no_grad():\n", - " outputs = model.encoder(input_ids=input_ids)\n", - " vector = outputs.last_hidden_state.mean(dim=1)\n", - " return vector[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9LRcwrCvHcPr", + "outputId": "df76731d-ff58-43c9-86f0-34b1834045f8" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2023-12-31 04:59:44-- https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.en.300.bin.gz\n", + "Resolving dl.fbaipublicfiles.com (dl.fbaipublicfiles.com)... 13.35.7.128, 13.35.7.50, 13.35.7.38, ...\n", + "Connecting to dl.fbaipublicfiles.com (dl.fbaipublicfiles.com)|13.35.7.128|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 4503593528 (4.2G) [application/octet-stream]\n", + "Saving to: ‘cc.en.300.bin.gz’\n", + "\n", + "cc.en.300.bin.gz 100%[===================>] 4.19G 155MB/s in 28s \n", + "\n", + "2023-12-31 05:00:12 (151 MB/s) - ‘cc.en.300.bin.gz’ saved [4503593528/4503593528]\n", + "\n" + ] + } + ], + "source": [ + "!wget https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.en.300.bin.gz" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "T5好评例子的评分 : -0.010294\n", - "T5差评例子的评分 : -0.008990\n" - ] - } - ], - "source": [ - "positive_review_in_t5 = get_t5_vector(\"An Amazon review with a positive sentiment.\")\n", - "negative_review_in_t5 = get_t5_vector('An Amazon review with a negative sentiment.')\n", - "\n", - "def test_t5():\n", - " positive_example_in_t5 = get_t5_vector(positive_text)\n", - " negative_example_in_t5 = get_t5_vector(negative_text)\n", - "\n", - " def get_t5_score(sample_embedding):\n", - " return cosine_similarity(sample_embedding, positive_review_in_t5) - cosine_similarity(sample_embedding, negative_review_in_t5)\n", - "\n", - " positive_score = get_t5_score(positive_example_in_t5)\n", - " negative_score = get_t5_score(negative_example_in_t5)\n", - "\n", - " print(\"T5好评例子的评分 : %f\" % (positive_score))\n", - " print(\"T5差评例子的评分 : %f\" % (negative_score))\n", - "\n", - "test_t5()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "6SiTtR8QHcPr" + }, + "outputs": [], + "source": [ + "!gunzip ./cc.en.300.bin.gz" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", - "To disable this warning, you can either:\n", - "\t- Avoid using `tokenizers` before the fork if possible\n", - "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n" - ] + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "5ykoNmB7HcPr" + }, + "outputs": [], + "source": [ + "import gensim\n", + "import numpy as np\n", + "# Load the FastText pre-trained model\n", + "model = gensim.models.fasttext.load_facebook_model('cc.en.300.bin')\n", + "\n", + "def get_fasttext_vector(line):\n", + " vec = np.zeros(300) # Initialize an empty 300-dimensional vector\n", + " for word in line.split():\n", + " vec += model.wv[word]\n", + " vec /= len(line.split()) # Take the average over all words in the line\n", + " return vec" + ] }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4cc8a70db87547678546dd9b433cf7fd", - "version_major": 2, - "version_minor": 0 + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ANbdHEF9HcPr", + "outputId": "56a3313c-7558-4c66-ee91-b0e706dbe04b" }, - "text/plain": [ - "Downloading (…)/main/tokenizer.json: 0%| | 0.00/1.39M [00:00=0.16.4 in /usr/local/lib/python3.10/dist-packages (from transformers) (0.19.4)\n", + "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from transformers) (1.23.5)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from transformers) (23.2)\n", + "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.10/dist-packages (from transformers) (6.0.1)\n", + "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.10/dist-packages (from transformers) (2023.6.3)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from transformers) (2.31.0)\n", + "Requirement already satisfied: tokenizers<0.19,>=0.14 in /usr/local/lib/python3.10/dist-packages (from transformers) (0.15.0)\n", + "Requirement already satisfied: safetensors>=0.3.1 in /usr/local/lib/python3.10/dist-packages (from transformers) (0.4.1)\n", + "Requirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.10/dist-packages (from transformers) (4.66.1)\n", + "Requirement already satisfied: fsspec>=2023.5.0 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub<1.0,>=0.16.4->transformers) (2023.6.0)\n", + "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub<1.0,>=0.16.4->transformers) (4.5.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (3.6)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (2023.11.17)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (2.1.0+cu121)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.10/dist-packages (0.16.0+cu121)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch) (3.13.1)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch) (4.5.0)\n", + "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch) (1.12)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch) (3.2.1)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch) (3.1.2)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch) (2023.6.0)\n", + "Requirement already satisfied: triton==2.1.0 in /usr/local/lib/python3.10/dist-packages (from torch) (2.1.0)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from torchvision) (1.23.5)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from torchvision) (2.31.0)\n", + "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.10/dist-packages (from torchvision) (9.4.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch) (2.1.3)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision) (3.6)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision) (2023.11.17)\n", + "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch) (1.3.0)\n", + "Collecting sentencepiece\n", + " Downloading sentencepiece-0.1.99-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.3/1.3 MB\u001b[0m \u001b[31m8.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: sentencepiece\n", + "Successfully installed sentencepiece-0.1.99\n" + ] + } + ], + "source": [ + "# install transformers if required\n", + "%pip install transformers\n", + "%pip install torch torchvision\n", + "%pip install sentencepiece==0.1.99" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "id": "_G0uqiyBHcPs" + }, + "outputs": [], + "source": [ + "from transformers import AutoTokenizer, AutoModel\n", + "import torch\n", + "\n", + "# load the T5 tokenizer and model\n", + "tokenizer = AutoTokenizer.from_pretrained('t5-small', model_max_length=512)\n", + "model = AutoModel.from_pretrained('t5-small')\n", + "\n", + "# set the model to evaluation mode\n", + "model.eval()\n", + "\n", + "# encode the input sentence\n", + "def get_t5_vector(line):\n", + " input_ids = tokenizer.encode(line, return_tensors='pt', max_length=512, truncation=True)\n", + " # generate the vector representation\n", + " with torch.no_grad():\n", + " outputs = model.encoder(input_ids=input_ids)\n", + " vector = outputs.last_hidden_state.mean(dim=1)\n", + " return vector[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "T59zGw5OHcPs", + "outputId": "27d80c12-c0fe-4c78-f9f8-c5c2e4f91869" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "T5好评例子的评分 : -0.010294\n", + "T5差评例子的评分 : -0.008990\n" + ] + } + ], + "source": [ + "positive_review_in_t5 = get_t5_vector(\"An Amazon review with a positive sentiment.\")\n", + "negative_review_in_t5 = get_t5_vector('An Amazon review with a negative sentiment.')\n", + "\n", + "def test_t5():\n", + " positive_example_in_t5 = get_t5_vector(positive_text)\n", + " negative_example_in_t5 = get_t5_vector(negative_text)\n", + "\n", + " def get_t5_score(sample_embedding):\n", + " return cosine_similarity(sample_embedding, positive_review_in_t5) - cosine_similarity(sample_embedding, negative_review_in_t5)\n", + "\n", + " positive_score = get_t5_score(positive_example_in_t5)\n", + " negative_score = get_t5_score(negative_example_in_t5)\n", + "\n", + " print(\"T5好评例子的评分 : %f\" % (positive_score))\n", + " print(\"T5差评例子的评分 : %f\" % (negative_score))\n", + "\n", + "test_t5()" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - " precision recall f1-score support\n", - "\n", - " negative 0.60 0.90 0.72 136\n", - " positive 0.98 0.90 0.94 789\n", - "\n", - " accuracy 0.90 925\n", - " macro avg 0.79 0.90 0.83 925\n", - "weighted avg 0.93 0.90 0.91 925\n", - "\n" - ] + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "gxOy84BAHcPs", + "outputId": "6d2aafab-7da5-41b7-9969-38f87d97504a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "T5好评例子的评分 : 0.010347\n", + "T5差评例子的评分 : -0.023935\n" + ] + } + ], + "source": [ + "tokenizer = AutoTokenizer.from_pretrained('t5-base', model_max_length=512)\n", + "model = AutoModel.from_pretrained('t5-base')\n", + "\n", + "# set the model to evaluation mode\n", + "model.eval()\n", + "\n", + "# encode the input sentence\n", + "def get_t5_vector(line):\n", + " input_ids = tokenizer.encode(line, return_tensors='pt', max_length=512, truncation=True)\n", + " # generate the vector representation\n", + " with torch.no_grad():\n", + " outputs = model.encoder(input_ids=input_ids)\n", + " vector = outputs.last_hidden_state.mean(dim=1)\n", + " return vector[0]\n", + "\n", + "positive_review_in_t5 = get_t5_vector(\"An Amazon review with a positive sentiment.\")\n", + "negative_review_in_t5 = get_t5_vector('An Amazon review with a negative sentiment.')\n", + "\n", + "test_t5()" + ] }, { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHFCAYAAAAaD0bAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABzAklEQVR4nO3dd1hT1/8H8HcIJGycTBFwY924gKq1VXCvarVaZ9W6qoi11bonrdat4J61yreur7Y4sFar1bo3CA4QRdDiYIis5Pz+8Ee+RoYJJoTxfj1Pnic599x7P/eSNh/POfcciRBCgIiIiKgUMTJ0AERERESFjQkQERERlTpMgIiIiKjUYQJEREREpQ4TICIiIip1mAARERFRqcMEiIiIiEodJkBERERU6jABIiIiolKHCRDRG44dO4YhQ4agVq1asLCwgJOTE7p27YqLFy/q9DwzZ86ERCLR6TF14aOPPoJEIlG9zMzMUL9+fSxduhRKpbLQ45FIJJg5c6ZW+xj63r55/yQSCaytreHl5YUdO3YYLKY35XZ/PvroI3z00UeGCYjIQJgAEb0hKCgI0dHRGDduHEJCQrBs2TI8efIEzZs3x7FjxwwdXqGoUqUKzpw5gzNnziA4OBhOTk4YP348Jk+eXOixnDlzBkOHDtVqn6FDh+LMmTN6ikgzPXv2xJkzZ3D69GmsXr0aSUlJ6Nu3L3755ReDxkVE/2Ns6ACIipJVq1bB1tZWraxdu3aoVq0a5s+fj48//thAkRUeMzMzNG/eXPW5ffv2qFWrFlauXIm5c+fCxMQkxz5CCKSlpcHMzEynsbwZh6YqVaqESpUq6TQObdnZ2ali9/T0hLe3N1xdXbFmzRr07dvXoLEVZZmZmZBIJDA25k8T6R9bgIje8HbyAwCWlpaoXbs2Hjx4oPFxDh06hE8++QQ2NjYwNzeHu7s7AgIC8t0nODgYPj4+cHBwgJmZGdzd3TFp0iS8fPlSrd69e/fQp08fODo6Qi6Xw87ODp988gmuXLmiqnPs2DF89NFHKF++PMzMzFC5cmV8+umnSE1N1fgaspmYmMDDwwOpqan4999/Abzu5hkzZgxWr14Nd3d3yOVybNmyBQBw+/Zt9O3bF7a2tpDL5XB3d8eqVatyHPfFixeYMGECqlSpArlcDltbW3To0AG3bt1S1Xm7Cyw1NRXffPMN3NzcYGpqinLlyqFx48Zq3Uu5dfEolUosWLAAtWrVUp1rwIABePjwoVq9jz76CHXq1MH58+fRokULmJubo0qVKvjhhx/eqwvQxcUFFStWxOPHj9XKk5KSVNcjk8ng5OQEPz+/HH9zpVKJFStWoEGDBjAzM0OZMmXQvHlz7N+/X1VH0+/P+/rll1/g6ekJS0tLWFpaokGDBtiwYYNqu6urKwYNGpRjv7e72Y4fPw6JRIJt27ZhwoQJcHJyglwux82bNyGRSNSOme3gwYOQSCRq163p943obUyzid4hMTERly5d0rj1Z8OGDRg2bBhatWqF1atXw9bWFpGRkbhx40a++92+fRsdOnSAn58fLCwscOvWLfz44484d+6cWvdbhw4doFAosGDBAlSuXBkJCQk4ffo0Xrx4AQCIjo5Gx44d0aJFC2zcuBFlypRBbGwsDh06hIyMDJibm2t9D+7evQtjY2OULVtWVbZv3z6cPHkS06dPh729PWxtbREWFgYvLy9UrlwZixYtgr29PQ4fPoyxY8ciISEBM2bMAAAkJyfjww8/RHR0NL777js0a9YMKSkp+OuvvxAXF4datWrlGoe/vz+2bduGuXPnomHDhnj58iVu3LiBp0+f5hv/yJEjsXbtWowZMwadOnVCdHQ0pk2bhuPHj+PSpUuoUKGCqm58fDz69euHCRMmYMaMGdi7dy8mT54MR0dHDBgwQOt7B7z+Dj179kytRSs1NRWtWrXCw4cP8f3336NevXq4efMmpk+fjuvXr+Po0aOqRG7QoEH4+eef8eWXX2L27NmQyWS4dOkSoqOjVcfT9PvzPqZPn445c+agR48emDBhAmxsbHDjxg3cv3+/wMecPHkyPD09sXr1ahgZGcHZ2RkNGzbEpk2b8OWXX6rV3bx5sypRBqDx940oV4KI8tWvXz9hbGwsLly48M66ycnJwtraWnz44YdCqVTmWW/GjBkiv//8lEqlyMzMFCdOnBAAxNWrV4UQQiQkJAgAYunSpXnuu2vXLgFAXLly5Z3xvq1Vq1bigw8+EJmZmSIzM1M8evRITJo0SQAQvXr1UtUDIGxsbMSzZ8/U9vf19RWVKlUSiYmJauVjxowRpqamqvqzZ88WAERoaGi+8QAQM2bMUH2uU6eO6NatW777vH1vw8PDBQAxatQotXpnz54VAMT333+vdv0AxNmzZ9Xq1q5dW/j6+uZ73jdjHjVqlMjMzBQZGRkiMjJSdOnSRVhZWal9hwICAoSRkZE4f/682v7Zf7+QkBAhhBB//fWXACCmTJmi0fmFyPv7I0Tu371WrVqJVq1a5XvMe/fuCalUKvr165dvPRcXFzFw4MAc5W+f488//xQARMuWLXPUXb58uQAgIiIiVGXPnj0TcrlcTJgwQVWm6feNKDfsAiPKx7Rp07B9+3YsWbIEHh4eqnKlUomsrCzVS6FQAABOnz6NpKQkjBo1Susnke7du4e+ffvC3t4eUqkUJiYmaNWqFQAgPDwcAFCuXDlUrVoVCxcuxOLFi3H58uUcXTMNGjSATCbD8OHDsWXLFty7d0+rOG7evAkTExOYmJjA0dERixYtQr9+/bBu3Tq1eh9//LFai1BaWhr++OMPdO/eHebm5mr3p0OHDkhLS8M///wD4HVXRo0aNdCmTRutYmvatCkOHjyISZMm4fjx43j16tU79/nzzz8BIEe3TNOmTeHu7o4//vhDrdze3h5NmzZVK6tXr55aK4dCoVC7vrf/BoGBgTAxMYFMJkONGjVw8OBB7NixQ+079Ntvv6FOnTpo0KCB2rF8fX0hkUhw/PhxAK/vFQCMHj063+vU5PvzPkJDQ6FQKN4Zh7Y+/fTTHGX9+vWDXC7H5s2bVWU7duxAeno6Bg8eDEC77xtRbpgAEeVh1qxZmDt3LubNm4cxY8aobZs9e7YqSTAxMUHVqlUBQDVGRttBuCkpKWjRogXOnj2LuXPn4vjx4zh//jz27NkDAKofeolEgj/++AO+vr5YsGABGjVqhIoVK2Ls2LFITk4GAFStWhVHjx6Fra0tRo8ejapVq6Jq1apYtmyZRrFUrVoV58+fx4ULF3Djxg28ePECP//8M2xsbNTqOTg4qH1++vQpsrKysGLFCrV7Y2JiouqySEhIUN2nggxUXr58Ob777jvs27cPrVu3Rrly5dCtWzfcvn07z32yu8fejhcAHB0dc3SflS9fPkc9uVyulmxVrVpV7fpmz56tVv+zzz7D+fPncfr0aaxZswZWVlbo06ePWpyPHz/GtWvXctwrKysrCCHU7pVUKoW9vX2e16jp9+d9FPS7/S65/V3KlSuHLl26YOvWrap/XGzevBlNmzbFBx98AEC77xtRbjgGiCgXs2bNwsyZMzFz5kx8//33ObYPHz4cnTp1Un2Wy+UAgIoVKwJAjsG173Ls2DE8evQIx48fV/2rHYBqXM+bXFxcVANEIyMj8Z///AczZ85ERkYGVq9eDQBo0aIFWrRoAYVCgQsXLmDFihXw8/ODnZ0d+vTpk28spqamaNy48TtjfruFq2zZspBKpejfv3+erQRubm4AXt8nbe8RAFhYWGDWrFmYNWsWHj9+rGoN6ty5s9rg6TdlJzRxcXE5frwfPXqkNv5HUwcOHEB6errqs6Ojo9r2ihUrqu6hp6cn3N3d0apVK4wfPx6//fYbAKBChQowMzPDxo0bcz1HdlwVK1aEQqFAfHx8rskCoN33p6De/G47OzvnWc/U1FTt3mRLSEjI9V7n1VI6ePBg/PrrrwgNDUXlypVx/vx5BAUFqbZr830jyg0TIKK3zJkzBzNnzsTUqVPzHETp6OiY40cPALy8vGBjY4PVq1ejT58+GneDZdfLTqSyrVmzJt/9atSogalTp2L37t24dOlSju1SqRTNmjVDrVq1sH37dly6dOmdCVBBmZubo3Xr1rh8+TLq1asHmUyWZ9327dtj+vTpOHbsWIGnFrCzs8OgQYNw9epVLF26FKmpqbkO8M4+/s8//4wmTZqoys+fP4/w8HBMmTJF63PXrVtXq/otWrTAgAEDsGXLFpw5cwaenp7o1KkT5s+fj/Lly+f7Q92+fXsEBAQgKCgoR0tTtoJ+f7Th4+MDqVSKoKAgeHp65lnP1dUV165dUyuLjIxERESEVsmmj48PnJycsGnTJlSuXBmmpqb4/PPPVdu1+b4R5YYJENEbFi1ahOnTp6Ndu3bo2LFjjjEE75qXxtLSEosWLcLQoUPRpk0bDBs2DHZ2drhz5w6uXr2KlStX5rqfl5cXypYtixEjRmDGjBkwMTHB9u3bcfXqVbV6165dw5gxY9CrVy9Ur14dMpkMx44dw7Vr1zBp0iQAwOrVq3Hs2DF07NgRlStXRlpamqqVQdsxN9patmwZPvzwQ7Ro0QIjR46Eq6srkpOTcefOHRw4cED1NJKfnx+Cg4PRtWtXTJo0CU2bNsWrV69w4sQJdOrUCa1bt871+M2aNUOnTp1Qr149lC1bFuHh4di2bRs8PT3zfLqtZs2aGD58OFasWAEjIyO0b99e9RSYs7Mzxo8fr7f78aY5c+YgODgY06ZNw9GjR+Hn54fdu3ejZcuWGD9+POrVqwelUomYmBgcOXIEEyZMQLNmzdCiRQv0798fc+fOxePHj9GpUyfI5XJcvnwZ5ubm+PrrrzX+/rwPV1dXfP/995gzZw5evXqFzz//HDY2NggLC0NCQgJmzZoFAOjfvz+++OILjBo1Cp9++inu37+PBQsWqFqQNCWVSjFgwAAsXrwY1tbW6NGjR45uWE2/b0S5MvQobKKiJPspoLxemgoJCRGtWrUSFhYWwtzcXNSuXVv8+OOPqu25PYlz+vRp4enpKczNzUXFihXF0KFDxaVLlwQAsWnTJiGEEI8fPxaDBg0StWrVEhYWFsLS0lLUq1dPLFmyRGRlZQkhhDhz5ozo3r27cHFxEXK5XJQvX160atVK7N+/X6Pr/+CDD95ZD4AYPXp0rtuioqLEkCFDhJOTkzAxMREVK1YUXl5eYu7cuWr1nj9/LsaNGycqV64sTExMhK2trejYsaO4deuW2nnefAps0qRJonHjxqJs2bJCLpeLKlWqiPHjx4uEhARVndzurUKhED/++KOoUaOGMDExERUqVBBffPGFePDggUbXP3DgQOHi4vLO+/KuezNx4kQBQJw4cUIIIURKSoqYOnWqqFmzppDJZMLGxkbUrVtXjB8/XsTHx6vFv2TJElGnTh1VPU9PT3HgwAFVHU2+P3ndH02eAsu2detW0aRJE2FqaiosLS1Fw4YN1Y6vVCrFggULRJUqVYSpqalo3LixOHbsWJ5Pgf366695nisyMlL1315eTwxq+n0jeptECCEKOeciIiIiMig+BUZERESlDhMgIiIiKnWYABEREVGpwwSIiIiISh0mQERERFTqMAEiIiKiUocTIeZCqVTi0aNHsLKy0npBSyIiIjIMIQSSk5Ph6OgII6P823iYAOXi0aNH+a51Q0REREXXgwcP3rlwLxOgXFhZWQF4fQOtra0NHA0RERFpIikpCc7Ozqrf8fwwAcpFdreXtbU1EyAiIqJiRpPhKxwETURERKUOEyAiIiIqdZgAERERUanDBIiIiIhKHSZAREREVOowASIiIqJShwkQERERlTpMgIiIiKjUYQJEREREpQ4TICIiIip1DJoA/fXXX+jcuTMcHR0hkUiwb9++d+5z4sQJeHh4wNTUFFWqVMHq1atz1Nm9ezdq164NuVyO2rVrY+/evXqInoiIiIorgyZAL1++RP369bFy5UqN6kdFRaFDhw5o0aIFLl++jO+//x5jx47F7t27VXXOnDmD3r17o3///rh69Sr69++Pzz77DGfPntXXZRAREVExIxFCCEMHAbxeuGzv3r3o1q1bnnW+++477N+/H+Hh4aqyESNG4OrVqzhz5gwAoHfv3khKSsLBgwdVddq1a4eyZctix44dGsWSlJQEGxsbJCYm6nQx1PQsBf5NTtfZ8YiIKH+ONmYwMnr3wphUMmjz+12sVoM/c+YMfHx81Mp8fX2xYcMGZGZmwsTEBGfOnMH48eNz1Fm6dGmex01PT0d6+v8Sk6SkJJ3Gne3moyT0CDytl2MTEVFObdxtsX5gE0OHQUVQsUqA4uPjYWdnp1ZmZ2eHrKwsJCQkwMHBIc868fHxeR43ICAAs2bN0kvMb5IAkBtz3DkRkb4JAWQolLjyINHQoVARVawSIOB1V9mbsnvw3izPrc7bZW+aPHky/P39VZ+TkpLg7Oysi3DVNKxcFhFz2+v8uEREpC48Lgntl500dBhUhBWrBMje3j5HS86TJ09gbGyM8uXL51vn7VahN8nlcsjlct0HTEREBpWQko6MLCVkbH2ntxSrb4SnpydCQ0PVyo4cOYLGjRvDxMQk3zpeXl6FFicRERlWSnqW6v3eyw8NGAkVVQZtAUpJScGdO3dUn6OionDlyhWUK1cOlStXxuTJkxEbG4utW7cCeP3E18qVK+Hv749hw4bhzJkz2LBhg9rTXePGjUPLli3x448/omvXrvjvf/+Lo0eP4tSpU4V+fUREZBgelcuq3iekZBgwEiqqDNoCdOHCBTRs2BANGzYEAPj7+6Nhw4aYPn06ACAuLg4xMTGq+m5ubggJCcHx48fRoEEDzJkzB8uXL8enn36qquPl5YWdO3di06ZNqFevHjZv3ozg4GA0a9ascC+OiIgMxshIgj5NdD+Wk0qOIjMPUFGir3mAiIio8EzafQ07zz/ARN+aGN26mqHDoUKgze93sRoDRERERKQLTICIiIio1ClWj8ETEREVRJZCiQyFEkYSCUxNpIYOh4oAJkBERFQiHQ1/DABYeDgCCw9HAHg9G/+mwU3gVbWCIUOjIoBdYEREVCKVMZflKEvPUuJyzIvCD4aKHLYAERFRiXTUvxVuP06GtZkJZFIjzPk9DHsuxRo6LCoimAAREVGJVd3OSvVeJmWnB/0Pvw1ERERU6jABIiIiolKHXWBERFRqpWUqkJapQIZCiZfpr98/TclAplKJ9EwF7iW8hLmJFK8ylbjxKBEVLeVIy1QgUyHQt5kzPFzKGfoSqICYABERUalw5cELAK8fi1994i6S07Ly3+Ed4pNeYfvQ5jqIjAyBCRAREZUKt+KTVe/fTn4kEsBEaoSMLCWcy5nhwbNXqO9cBtamxrj/NBVN3cpBbmyEhJR0yIylOHD1EdIzlYV9CaRDTICIiKhUuDbTBz8djoBX1fKoWtESJlIjmMukKGchg9RIAolEotFxDt2Iw4Grj3Dh/nMEn4+BQgkYSYCP3W1ha2Wq56sgXWECREREpYK1qQlmd63z3sd5syXpu93XVe99atth7YDG7318Khx8CoyIiEgLHes6qN5LjSSoX8kGAPDsZYahQqICYAsQERGRFqrbWSH6h46qz4duxGPEzxfx8Pkr3HmSghepGXj1/0+TPXuZAQEgU6FE+zr2cClvYbjASQ0TICIiovcQ/fQlACA+KQ1tFp/Is965qGfYOKhJYYVF78AEiIiI6D3UdrBWvS9jbgK5sREeJ6WjrpMNspQCSa8yEfviFZJeZRowSnobEyAiIqL30LJGRYTN9oW5LPef1OwuMipaOAiaiIjoPeWV/FDRxQSIiIiISh0mQERERFTqMAEiIiKiUocJEBEREZU6TICIiIio1GECRERERKUOEyAiIiIqdThxARERUSHLyFLiVaYCSqWAUggoBaAUAs9TMxARn4xnLzOQlqlEWqYCjVzKolWNioYOucRhAkRERFQILtx/joCD4XiSlI69l2M13k9mbIRrM3xgaiLVY3SlD7vAiIiI9OhWfJLq/ZoT9/JMfqRGEtV7IwnQub4jgNetRZkKpX6DLIXYAkRERKRHnes7YunR2wCAJq5lkakQ+LBaBXRp4IiqFS1hJAEkEkmO/dIyFThw9REAYNaBMJyLegbHMqb4594zVLSS42V6Fnp5VMKsrnUK9XpKCokQQhg6iKImKSkJNjY2SExMhLW19bt3ICIi0rG0TAVqTTuUb50KljJcmNq2kCIq+rT5/WYLEBERURFkaiKFuUyK1AwFGlYuoxoIXdfJBvFJaZiy94aBIyzemAAREREVUWGz2+VaHhGfXMiRlDwGHwQdGBgINzc3mJqawsPDAydPnsy3/qpVq+Du7g4zMzPUrFkTW7duzVFn6dKlqFmzJszMzODs7Izx48cjLS1NX5dARERExYxBW4CCg4Ph5+eHwMBAeHt7Y82aNWjfvj3CwsJQuXLlHPWDgoIwefJkrFu3Dk2aNMG5c+cwbNgwlC1bFp07dwYAbN++HZMmTcLGjRvh5eWFyMhIDBo0CACwZMmSwrw8IiIiKqIMOgi6WbNmaNSoEYKCglRl7u7u6NatGwICAnLU9/Lygre3NxYuXKgq8/Pzw4ULF3Dq1CkAwJgxYxAeHo4//vhDVWfChAk4d+7cO1uXsnEQNBERFWXhcUlov+z1b9qxCa1QpaKlgSMqGrT5/TZYF1hGRgYuXrwIHx8ftXIfHx+cPn06133S09NhamqqVmZmZoZz584hMzMTAPDhhx/i4sWLOHfuHADg3r17CAkJQceOHfVwFURERIXP+I05gw7eiDdgJMWXwbrAEhISoFAoYGdnp1ZuZ2eH+Pjc/5i+vr5Yv349unXrhkaNGuHixYvYuHEjMjMzkZCQAAcHB/Tp0wf//vsvPvzwQwghkJWVhZEjR2LSpEl5xpKeno709HTV56SkpDzrEhERGVp1OyvIjI2QkaWEUsnZbArC4IOg3578SQiR64RQADBt2jS0b98ezZs3h4mJCbp27aoa3yOVvp4i/Pjx45g3bx4CAwNx6dIl7NmzB7/99hvmzJmTZwwBAQGwsbFRvZydnXVzcURERHpS7f+7vRaFRho4kuLJYAlQhQoVIJVKc7T2PHnyJEerUDYzMzNs3LgRqampiI6ORkxMDFxdXWFlZYUKFSoAeJ0k9e/fH0OHDkXdunXRvXt3zJ8/HwEBAVAqc59KfPLkyUhMTFS9Hjx4oNuLJSIi0rGwuP/1VrxMzzJgJMWTwRIgmUwGDw8PhIaGqpWHhobCy8sr331NTExQqVIlSKVS7Ny5E506dYKR0etLSU1NVb3PJpVKIYRAXuO95XI5rK2t1V5ERERF2ZnJH6veK7mog9YM+hi8v78/+vfvj8aNG8PT0xNr165FTEwMRowYAeB1y0xsbKxqrp/IyEicO3cOzZo1w/Pnz7F48WLcuHEDW7ZsUR2zc+fOWLx4MRo2bIhmzZrhzp07mDZtGrp06aLqJiMiIiruylnIDB1CsWbQBKh37954+vQpZs+ejbi4ONSpUwchISFwcXEBAMTFxSEmJkZVX6FQYNGiRYiIiICJiQlat26N06dPw9XVVVVn6tSpkEgkmDp1KmJjY1GxYkV07twZ8+bNK+zLIyIioiKKi6HmgvMAERFRUZeepUDNqa8XS70+0wdWpiYGjsjwisU8QERERESGUqAusAcPHiA6OhqpqamoWLEiPvjgA8jlcl3HRkRERKQXGidA9+/fx+rVq7Fjxw48ePBA7YkqmUyGFi1aYPjw4fj0009zPIVFREREVJRolKmMGzcOdevWxe3btzF79mzcvHkTiYmJyMjIQHx8PEJCQvDhhx9i2rRpqFevHs6fP6/vuImIiIgKTKMWIJlMhrt376JixYo5ttna2uLjjz/Gxx9/jBkzZiAkJAT3799HkyZNdB4sERERkS5olAC9ufr6u3To0KHAwRAREREVhgIN1snKysLRo0exZs0aJCcnAwAePXqElJQUnQZHREREpA9aPwV2//59tGvXDjExMUhPT0fbtm1hZWWFBQsWIC0tDatXr9ZHnEREREQ6o3UL0Lhx49C4cWM8f/4cZmZmqvLu3bvjjz/+0GlwRERERPqgdQvQqVOn8Pfff0MmU1+DxMXFBbGxsToLjIiIiEhftG4BUiqVUCgUOcofPnwIKysrnQRFREREpE9aJ0Bt27bF0qVLVZ8lEglSUlIwY8YMPgFGRERExYLWXWBLlixB69atUbt2baSlpaFv3764ffs2KlSogB07dugjRiIiIiKd0joBcnR0xJUrV7Bjxw5cunQJSqUSX375Jfr166c2KJqIiIioqNI6AUpNTYW5uTmGDBmCIUOG6CMmIiIiKgCFUiA9SwFzWYHWOi9VtL5Dtra26NatG/r374+2bdty4VMiIiIDqzvziOq9kQSY170uPm9a2YARFX1aZy9bt25Feno6unfvDkdHR4wbN46LnxIRERURSgFciH6uVpaWqUCWQmmgiIomrVuAevTogR49eiA5ORm7du3Cjh074OXlBTc3N3zxxReYPn26PuIkIiKiN8iNpbAxM0Hiq0x0qe+IzvUd8Uf4Y+w8/wC7Lz1EWpYCf0X8i+T0LABAWXMT7BvtDZfyFgaOvGiQCCHE+x4kLCwM/fr1w7Vr13KdI6i4SUpKgo2NDRITE2FtbW3ocIiIiDTy2eozOBf9LM/tKz5viM71HQsxosKlze93gQfwpKWl4T//+Q+6deuGRo0a4enTp/jmm28KejgiIiJ6T53qO6jeN69SDrO6fIBZXT6AnbXcgFEVTVp3gR05cgTbt2/Hvn37IJVK0bNnTxw+fBitWrXSR3xERESkoQGerhjg6Zqj/NCNeDxOSi/8gIowrROgbt26oWPHjtiyZQs6duwIExMTfcRFREREpDdaJ0Dx8fEcF0NERFSMZClfPwGWmpFl4EiKDo3GACUlJeX4nNeLiIiIipbz//9Y/He7rxs4kqJDoxagsmXLIi4uDra2tihTpgwkEkmOOkIISCSSEvEUGBERUUkikxohg/MAqdEoATp27BjKlSsHAPjzzz/1GhARERHp1oGvP4Tv0r8AAA1mH4GFzBgWcim2fdkMdtamBo7OMDRKgN58wsvNzQ3Ozs45WoGEEHjw4IFuoyMiIqL39jw1Q/X+RWomXqRmAgDORj1DlxI8L1B+tJ4HyM3NDf/++2+O8mfPnsHNzU0nQREREZHuNHEtp3rfp4mz6n3ItTjc/TfFECEZnNZPgWWP9XlbSkoKTE1LZzMaERFRUSY1kiD6h46qzzvPv+6xOXQzHqfvJuDC1LaQGZeuxc01ToD8/f0BABKJBNOmTYO5ublqm0KhwNmzZ9GgQQOdB0hERES6ZS6TIjXj9UNLSWlZSM9SMAHKy+XLlwG8bgG6fv06ZDKZaptMJkP9+vW5FAYREVExEDa7HV5lKOA+/ZChQzEYjROg7Ke/Bg8ejGXLlnEyRCIiomLMqHQ1+OSg9RigTZs26SMOIiIiokKjUQLUo0cPbN68GdbW1ujRo0e+dffs2aOTwIiIiKhwjNp+CZsGNYGxtPQ0C2mUANnY2Kie/LKxsdFrQERERKR/Rm880X3ydgJuxSejjlPp+Y2XCCGEIQMIDAzEwoULERcXhw8++ABLly5FixYt8qy/atUqrFy5EtHR0ahcuTKmTJmCAQMGqNV58eIFpkyZgj179uD58+dwc3PDokWL0KFDB41iSkpKgo2NDRITEznWiYiISqzlf9zG4tBIAMAHjtaoV8kGrWvawucDewNHVjDa/H5r3db16tUrpKamqj7fv38fS5cuxZEjR7QONDg4GH5+fpgyZQouX76MFi1aoH379oiJicm1flBQECZPnoyZM2fi5s2bmDVrFkaPHo0DBw6o6mRkZKBt27aIjo7Grl27EBERgXXr1sHJyUnr+IiIiEqysZ9UV72/+SgJO849wPBtF5GWWfLX9dS6BcjHxwc9evTAiBEj8OLFC9SsWRMymQwJCQlYvHgxRo4cqfGxmjVrhkaNGiEoKEhV5u7ujm7duiEgICBHfS8vL3h7e2PhwoWqMj8/P1y4cAGnTp0CAKxevRoLFy7ErVu3YGJios2lqbAFiIiISgvXSb/nKAsZ2wIVrGSwtSpeExzrtQXo0qVLqi6qXbt2wd7eHvfv38fWrVuxfPlyjY+TkZGBixcvwsfHR63cx8cHp0+fznWf9PT0HLNNm5mZ4dy5c8jMfL2uyf79++Hp6YnRo0fDzs4OderUwfz58/NdpT49PR1JSUlqLyIiotLg3vwOuDrDBxFz26nKOiw/iabz/sCN2EQDRqZfWidAqampsLKyAgAcOXIEPXr0gJGREZo3b4779+9rfJyEhAQoFArY2dmpldvZ2SE+Pj7XfXx9fbF+/XpcvHgRQghcuHABGzduRGZmJhISEgAA9+7dw65du6BQKBASEoKpU6di0aJFmDdvXp6xBAQEwMbGRvVydnbOsy4REVFJYmQkgY2Zidqg6Gz3El4aIKLCoXUCVK1aNezbtw8PHjzA4cOHVS04T548KVB3UW6ryue21hgATJs2De3bt0fz5s1hYmKCrl27YtCgQQAAqVQKAFAqlbC1tcXatWvh4eGBPn36YMqUKWrdbG+bPHkyEhMTVS+uak9ERKWNidQIq79ohIm+NfGBY8kf/qF1AjR9+nR88803cHV1RdOmTeHp6QngdWtQw4YNNT5OhQoVIJVKc7T2PHnyJEerUDYzMzNs3LgRqampiI6ORkxMDFxdXWFlZYUKFSoAABwcHFCjRg1VQgS8HlcUHx+PjIyMXI8rl8thbW2t9iIiIipt2tVxwOjW1WBtWrAxtMWJ1glQz549ERMTgwsXLuDw4cOq8k8++QRLlizR+DgymQweHh4IDQ1VKw8NDYWXl1e++5qYmKBSpUqQSqXYuXMnOnXqBKP/n9Pb29sbd+7cgVKpVNWPjIyEg4OD2vplREREVHppvRQGANjb28Pe3h4PHz6ERCKBk5MTmjZtqvVx/P390b9/fzRu3Bienp5Yu3YtYmJiMGLECACvu6ZiY2OxdetWAK8TmXPnzqFZs2Z4/vw5Fi9ejBs3bmDLli2qY44cORIrVqzAuHHj8PXXX+P27duYP38+xo4dW5BLJSIiohJI6wRIqVRi7ty5WLRoEVJSUgAAVlZWmDBhAqZMmaJqidFE79698fTpU8yePRtxcXGoU6cOQkJC4OLiAgCIi4tTmxNIoVBg0aJFiIiIgImJCVq3bo3Tp0/D1dVVVcfZ2RlHjhzB+PHjUa9ePTg5OWHcuHH47rvvtL1UIiIiKqG0ngdo8uTJ2LBhA2bNmgVvb28IIfD3339j5syZGDZsWL5PWxUXnAeIiIhKs8/X/oMz955i+ecN0aW+o6HD0Zg2v99atwBt2bIF69evR5cuXVRl9evXh5OTE0aNGlUiEiAiIiIq2bQeBP3s2TPUqlUrR3mtWrXw7NkznQRFREREpE9aJ0D169fHypUrc5SvXLkS9evX10lQREREZHgGXi9dr7TuAluwYAE6duyIo0ePwtPTExKJBKdPn8aDBw8QEhKijxiJiIioEJ259xQAMG7nFXRtUDIXE9e6BahVq1aIjIxE9+7d8eLFCzx79gw9evRARESEao0wIiIioqJM66fASgM+BUZERKVZ5ONk+Cz5C+UtZLg4ra2hw9GYXp8CA4Dnz59jw4YNCA8Ph0Qigbu7OwYPHoxy5coVKGAiIiKiwqR1F9iJEyfg5uaG5cuX4/nz53j27BmWL18ONzc3nDhxQh8xEhEREemU1gnQ6NGj8dlnnyEqKgp79uzBnj17cO/ePfTp0wejR4/WR4xERERUiLIHxzx9mYHZB8IMG4yeaJ0A3b17FxMmTFBbbV0qlcLf3x93797VaXBERERU+F5lKlTvN/4dhZT0LANGox9aJ0CNGjVCeHh4jvLw8HA0aNBAFzERERGRATVwLoPGLmVVn5Ul8HkprQdBjx07FuPGjcOdO3fQvHlzAMA///yDVatW4YcffsC1a9dUdevVq6e7SImIiKjQbB/WDDWnHjJ0GHqj9WPw71rtXSKRQAgBiUQChUKRb92iio/BExFRaZeepVAlQNdm+sDa1MTAEb2bXh+Dj4qKKnBgREREVPwkpmYWiwRIG1onQC4uLvqIg4iIiIqoFcduY0HPkrXep9aDoImIiKjkkxv/72nvLGXJGwTNBIiIiIhy9X2HWoYOQW+YABEREVGpwwSIiIiI8pWeqTR0CDrHBIiIiIhy9fedpwCA36/HIfFVpoGj0a0CJUBDhgzBlClT1Mq+//57DBkyRCdBERERkeF94Pi/uXRinqYaMBLdK1ACFBUVhdjYWLWy2NhYREdH6yImIiIiKgK+bVcLFjLpuysWQ1rPAwQAf/75Z46yLVu2vHcwREREVLTYmJngZUbxXNkhPxwDRERERKWORi1A+/fv1/iAXbp0KXAwREREVLQ8SkwDABy49gh1K9kYOBrd0SgB6tatm0YHK84LoBIREVHefjkbg+87uBs6DJ3RqAtMqVRq9GLyQ0REVLL0b14y1wB9rzFAaWlpuoqDiIiIiqCyFjIAQEp6Fi7ef27gaHRH6wRIoVBgzpw5cHJygqWlJe7duwcAmDZtGjZs2KDzAImIiMhwfGrbqd7HvnhlwEh0S+sEaN68edi8eTMWLFgAmUymKq9bty7Wr1+v0+CIiIjIsOo4/W/g866LDw0YiW5pnQBt3boVa9euRb9+/SCV/m9ypHr16uHWrVs6DY6IiIiKjr8i/zV0CDqjdQIUGxuLatWq5ShXKpXIzCxZ64QQERERMLXj66e/StKs0FonQB988AFOnjyZo/zXX39Fw4YNdRIUERERFR0ta1QEAJialJwESOulMGbMmIH+/fsjNjYWSqUSe/bsQUREBLZu3YrffvtNHzESERER6ZTWLUCdO3dGcHAwQkJCIJFIMH36dISHh+PAgQNo27atPmIkIiIi0qkCzQPk6+uLEydOICUlBampqTh16hR8fHwKFEBgYCDc3NxgamoKDw+PXLvX3rRq1Sq4u7vDzMwMNWvWxNatW/Osu3PnTkgkEo1nsiYiIqLSoUCrwQPAhQsXEB4eDolEAnd3d3h4eGh9jODgYPj5+SEwMBDe3t5Ys2YN2rdvj7CwMFSuXDlH/aCgIEyePBnr1q1DkyZNcO7cOQwbNgxly5ZF586d1erev38f33zzDVq0aFHQSyQiIqISSiKEENrs8PDhQ3z++ef4+++/UaZMGQDAixcv4OXlhR07dsDZ2VnjYzVr1gyNGjVCUFCQqszd3R3dunVDQEBAjvpeXl7w9vbGwoULVWV+fn64cOECTp06pSpTKBRo1aoVBg8ejJMnT+LFixfYt2+fxnElJSXBxsYGiYmJsLa21ng/IiKikijycTJ8lvyF8hYyXJxWdIe7aPP7rXUX2JAhQ5CZmYnw8HA8e/YMz549Q3h4OIQQ+PLLLzU+TkZGBi5evJij68zHxwenT5/OdZ/09HSYmpqqlZmZmeHcuXNqj+DPnj0bFStW1Die9PR0JCUlqb2IiIio5NI6ATp58iSCgoJQs2ZNVVnNmjWxYsWKd47feVNCQgIUCgXs7OzUyu3s7BAfH5/rPr6+vli/fj0uXrwIIQQuXLiAjRs3IjMzEwkJCQCAv//+Gxs2bMC6des0jiUgIAA2NjaqlzatWERERFT8aJ0AVa5cOdcJD7OysuDk5KR1ABKJRO2zECJHWbZp06ahffv2aN68OUxMTNC1a1cMGjQIACCVSpGcnIwvvvgC69atQ4UKFTSOYfLkyUhMTFS9Hjx4oPV1EBERUfGhdQK0YMECfP3117hw4QKyhw9duHAB48aNw08//aTxcSpUqACpVJqjtefJkyc5WoWymZmZYePGjUhNTUV0dDRiYmLg6uoKKysrVKhQAXfv3kV0dDQ6d+4MY2NjGBsbY+vWrdi/fz+MjY1x9+7dXI8rl8thbW2t9iIiIqKSS6OnwMqWLavWKvPy5Us0a9YMxsavd8/KyoKxsTGGDBmi8SPnMpkMHh4eCA0NRffu3VXloaGh6Nq1a777mpiYoFKlSgBeP+reqVMnGBkZoVatWrh+/bpa3alTpyI5ORnLli1j1xYREVEBZD8u9fRlBtb+dRfDW1Y1bEA6oFECtHTpUr2c3N/fH/3790fjxo3h6emJtWvXIiYmBiNGjADwumsqNjZWNddPZGQkzp07h2bNmuH58+dYvHgxbty4gS1btgAATE1NUadOHbVzZD+p9nY5ERERaSY+KU31PuDgLXzR3AVGEgnSM5WwMTcxYGQFp1ECNHDgQL2cvHfv3nj69Clmz56NuLg41KlTByEhIXBxcQEAxMXFISYmRlVfoVBg0aJFiIiIgImJCVq3bo3Tp0/D1dVVL/ERERER0KLa/8bVCgHUnn4YAGAkATYMbILWtWwNFVqBaT0P0JtevXqVY0B0SRg/w3mAiIiI1KVlKlBr2qEc5f5ta2DsJ9UNEFFOep0H6OXLlxgzZgxsbW1haWmJsmXLqr2IiIio5JEbF2j1rCJL66v59ttvcezYMQQGBkIul2P9+vWYNWsWHB0d812Xi4iIiIoviUSCqIAOiArogOgfOuLzpjmXrCpOtF4L7MCBA9i6dSs++ugjDBkyBC1atEC1atXg4uKC7du3o1+/fvqIk4iIiAwst3n6FodG4klyGno3roy6lWwMEFXBaN0C9OzZM7i5uQF4Pd7n2bNnAIAPP/wQf/31l26jIyIioiJp3+VY1fuf/4nBlH3X86ld9GidAFWpUgXR0dEAgNq1a+M///kPgNctQ9mPnBMREVHJZmWq3on0IjXnKhFFmdYJ0ODBg3H16lUAr+fpyR4LNH78eEycOFHnARIREVHRc/b7T/Cfrzwx0ff12qAxz1Jx81GigaPSnNZjgMaPH69637p1a9y6dQsXLlxA1apVUb9+fZ0GR0REREWTRCJBU7dyyMhSqsru/vsSHzgWj3FAWidAb6tcuTIqVy7eI8GJiIioYD6sXgENnMvgyoMXhg5FKxolQMuXL9f4gGPHji1wMERERFT8mMukhg5BaxolQEuWLNHoYBKJhAkQERERFXkaJUBRUVH6joOIiIio0JSsea2JiIiINMAEiIiIiN7LjdjXj78fj3hi4Eg0xwSIiIiI3ktSWhYAYM+l2HfULDqYABEREdF7+axxJUOHoDUmQERERPReejV2Vr3/75Xi0QpUoATo5MmT+OKLL+Dp6YnY2NcXum3bNpw6dUqnwREREVHRV93WUvX+/tNUA0aiOa0ToN27d8PX1xdmZma4fPky0tPTAQDJycmYP3++zgMkIiKioq2MuQy932gFKg60ToDmzp2L1atXY926dTAxMVGVe3l54dKlSzoNjoiIiIoHIyOJoUPQitYJUEREBFq2bJmj3NraGi9evNBFTERERER6pXUC5ODggDt37uQoP3XqFKpUqaKToIiIiIj0SesE6KuvvsK4ceNw9uxZSCQSPHr0CNu3b8c333yDUaNG6SNGIiIiIp3SaC2wN3377bdITExE69atkZaWhpYtW0Iul+Obb77BmDFj9BEjERERkU5pnQABwLx58zBlyhSEhYVBqVSidu3asLS0fPeOREREREWA1l1gW7ZswcuXL2Fubo7GjRujadOmTH6IiIioWNE6Afrmm29ga2uLPn364LfffkNWVpY+4iIiIiLSG60ToLi4OAQHB0MqlaJPnz5wcHDAqFGjcPr0aX3ER0RERKRzWidAxsbG6NSpE7Zv344nT55g6dKluH//Plq3bo2qVavqI0YiIiIinSrQIOhs5ubm8PX1xfPnz3H//n2Eh4frKi4iIiIivSnQYqipqanYvn07OnToAEdHRyxZsgTdunXDjRs3dB0fERERkc5p3QL0+eef48CBAzA3N0evXr1w/PhxeHl56SM2IiIiIr3QOgGSSCQIDg6Gr68vjI3fqweNiIiIyCC0zmB++eUXfcRBREREVGg0SoCWL1+O4cOHw9TUFMuXL8+37tixY3USGBEREZG+aJQALVmyBP369YOpqSmWLFmSZz2JRKJ1AhQYGIiFCxciLi4OH3zwAZYuXYoWLVrkWX/VqlVYuXIloqOjUblyZUyZMgUDBgxQbV+3bh22bt2qGpDt4eGB+fPno2nTplrFRURERCWXRglQVFRUru/fV3BwMPz8/BAYGAhvb2+sWbMG7du3R1hYGCpXrpyjflBQECZPnox169ahSZMmOHfuHIYNG4ayZcuic+fOAIDjx4/j888/h5eXF0xNTbFgwQL4+Pjg5s2bcHJy0lnsREREVHxp/Rj87NmzkZqamqP81atXmD17tlbHWrx4Mb788ksMHToU7u7uWLp0KZydnREUFJRr/W3btuGrr75C7969UaVKFfTp0wdffvklfvzxR1Wd7du3Y9SoUWjQoAFq1aqFdevWQalU4o8//tDuQomIiKjE0joBmjVrFlJSUnKUp6amYtasWRofJyMjAxcvXoSPj49auY+PT57LaqSnp8PU1FStzMzMDOfOnUNmZmau+6SmpiIzMxPlypXTODYiIiIq2bROgIQQkEgkOcqvXr2qVZKRkJAAhUIBOzs7tXI7OzvEx8fnuo+vry/Wr1+PixcvQgiBCxcuYOPGjcjMzERCQkKu+0yaNAlOTk5o06ZNnrGkp6cjKSlJ7UVEREQll8aPwZctWxYSiQQSiQQ1atRQS4IUCgVSUlIwYsQIrQN4O5nKK8ECgGnTpiE+Ph7NmzeHEAJ2dnYYNGgQFixYAKlUmqP+ggULsGPHDhw/fjxHy9GbAgICtGq9IiIiouJN4wRo6dKlEEJgyJAhmDVrFmxsbFTbZDIZXF1d4enpqfGJK1SoAKlUmqO158mTJzlahbKZmZlh48aNWLNmDR4/fgwHBwesXbsWVlZWqFChglrdn376CfPnz8fRo0dRr169fGOZPHky/P39VZ+TkpLg7Oys8bUQERFR8aJxAjRw4EAAgJubG7y8vGBiYvJeJ5bJZPDw8EBoaCi6d++uKg8NDUXXrl3z3dfExASVKlUCAOzcuROdOnWCkdH/evMWLlyIuXPn4vDhw2jcuPE7Y5HL5ZDL5QW8EiIiIipuNEqAkpKSYG1tDQBo2LAhXr16hVevXuVaN7ueJvz9/dG/f380btwYnp6eWLt2LWJiYlRdaZMnT0ZsbCy2bt0KAIiMjMS5c+fQrFkzPH/+HIsXL8aNGzewZcsW1TEXLFiAadOm4ZdffoGrq6uqhcnS0hKWlpYax0ZEREQll0YJUNmyZREXFwdbW1uUKVMm1zE62WN3FAqFxifv3bs3nj59itmzZyMuLg516tRBSEgIXFxcAABxcXGIiYlR1VcoFFi0aBEiIiJgYmKC1q1b4/Tp03B1dVXVCQwMREZGBnr27Kl2rhkzZmDmzJkax0ZEREQll0YJ0LFjx1RPeP355586DWDUqFEYNWpUrts2b96s9tnd3R2XL1/O93jR0dE6ioyIiIhKKo0SoFatWuX6noiIiKg40noeoEOHDuHUqVOqz6tWrUKDBg3Qt29fPH/+XKfBEREREemD1gnQxIkTVRMFXr9+Hf7+/ujQoQPu3bun9ig5ERERUVGl8WPw2aKiolC7dm0AwO7du9G5c2fMnz8fly5dQocOHXQeIBEREZGuad0CJJPJVIuhHj16VLWWV7ly5biEBBERERULWrcAffjhh/D394e3tzfOnTuH4OBgAK/n6MmenJCIiIioKNO6BWjlypUwNjbGrl27EBQUBCcnJwDAwYMH0a5dO50HSERERKRrWrcAVa5cGb/99luO8iVLlugkICIiIiJ90zoBAl7PyLxv3z6Eh4dDIpHA3d0dXbt2zXVFdiIiIqKiRusE6M6dO+jQoQNiY2NRs2ZNCCEQGRkJZ2dn/P7776hatao+4iQiIiLSGa3HAI0dOxZVq1bFgwcPcOnSJVy+fBkxMTFwc3PD2LFj9REjERERkU5p3QJ04sQJ/PPPP6q1wQCgfPny+OGHH+Dt7a3T4IiIiIj0QesWILlcjuTk5BzlKSkpkMlkOgmKiIiISJ+0ToA6deqE4cOH4+zZsxBCQAiBf/75ByNGjECXLl30ESMRERGRTmmdAC1fvhxVq1aFp6cnTE1NYWpqCm9vb1SrVg3Lli3TR4xERERUxGUplACA2OevDByJZiRCCFGQHe/cuYPw8HAIIVC7dm1Uq1ZN17EZTFJSEmxsbJCYmAhra2tDh0NERFTkuU76XfU+cm57yIy1bmN5b9r8fms8CFqpVGLRokXYt28fMjMz0aZNG0yfPh2mpqbvHTAREREVb23c7XA0/DEAIC1LYZAESBsaR/fjjz9i0qRJsLCwgIODAxYvXszH3omIiAgAENivkaFD0IrGCdDmzZuxYsUKHDlyBP/973+xb98+bN26FQXsQSMiIiIyGI0ToPv376NTp06qz76+vhBC4NGjR3oJjIiIiEhfNE6AMjIyYGZmpvoskUggk8mQnp6ul8CIiIiI9EWrmaCnTZsGc3Nz1eeMjAzMmzcPNjY2qrLFixfrLjoiIiIiPdA4AWrZsiUiIiLUyry8vHDv3j3VZ4lEorvIiIiIiPRE4wTo+PHjegyDiIiIqPAU7Yf0iYiIiPRAowTohx9+wMuXLzU64NmzZ/H777+/uyIRERGRgWiUAIWFhcHFxQUjR47EwYMH8e+//6q2ZWVl4dq1awgMDISXlxf69OnD5SOIiIioSNNoDNDWrVtx7do1rFq1Cv369UNiYiKkUinkcjlSU1MBAA0bNsTw4cMxcOBAyOVyvQZNRERE9D40HgRdr149rFmzBqtXr8a1a9cQHR2NV69eoUKFCmjQoAEqVKigzziJiIiIdEareYCA14+6169fH/Xr19dHPERERER6x6fAiIiIqNRhAkRERESlDhMgIiIiKnWYABEREVGpwwSIiIiISh2tE6CXL19i2rRp8PLyQrVq1VClShW1l7YCAwPh5uYGU1NTeHh44OTJk/nWX7VqFdzd3WFmZoaaNWti69atOers3r0btWvXhlwuR+3atbF3716t4yIiIqKSS+vH4IcOHYoTJ06gf//+cHBweK8V4IODg+Hn54fAwEB4e3tjzZo1aN++PcLCwlC5cuUc9YOCgjB58mSsW7cOTZo0wblz5zBs2DCULVsWnTt3BgCcOXMGvXv3xpw5c9C9e3fs3bsXn332GU6dOoVmzZoVOFYiIiIqOSRCCKHNDmXKlMHvv/8Ob2/v9z55s2bN0KhRIwQFBanK3N3d0a1bNwQEBOSo7+XlBW9vbyxcuFBV5ufnhwsXLuDUqVMAgN69eyMpKQkHDx5U1WnXrh3Kli2LHTt2aBRXUlISbGxskJiYyGU9iIiINJCRpUSNqa9/e6/N9IG1qUmhx6DN77fWXWBly5ZFuXLlChxctoyMDFy8eBE+Pj5q5T4+Pjh9+nSu+6Snp8PU1FStzMzMDOfOnUNmZiaA1y1Abx/T19c3z2NmHzcpKUntRURERCWX1gnQnDlzMH36dNUaYAWVkJAAhUIBOzs7tXI7OzvEx8fnuo+vry/Wr1+PixcvQgiBCxcuYOPGjcjMzERCQgIAID4+XqtjAkBAQABsbGxUL2dn5/e6NiIiIiratB4DtGjRIty9exd2dnZwdXWFiYl6E9elS5e0Ot7bY4iEEHmOK5o2bRri4+PRvHlzCCFgZ2eHQYMGYcGCBZBKpQU6JgBMnjwZ/v7+qs9JSUlMgoiIiEowrROgbt266eTEFSpUgFQqzdEy8+TJkxwtONnMzMywceNGrFmzBo8fP4aDgwPWrl0LKysr1WKs9vb2Wh0TAORyOVewJyIiKkW0ToBmzJihkxPLZDJ4eHggNDQU3bt3V5WHhoaia9eu+e5rYmKCSpUqAQB27tyJTp06wcjodW+ep6cnQkNDMX78eFX9I0eOwMvLSydxExERUfGndQKU7eLFiwgPD4dEIkHt2rXRsGFDrY/h7++P/v37o3HjxvD09MTatWsRExODESNGAHjdNRUbG6ua6ycyMhLnzp1Ds2bN8Pz5cyxevBg3btzAli1bVMccN24cWrZsiR9//BFdu3bFf//7Xxw9elT1lBgRERHp15hfLmPjwMYwlhbd+Za1ToCePHmCPn364Pjx4yhTpgyEEEhMTETr1q2xc+dOVKxYUeNj9e7dG0+fPsXs2bMRFxeHOnXqICQkBC4uLgCAuLg4xMTEqOorFAosWrQIERERMDExQevWrXH69Gm4urqq6nh5eWHnzp2YOnUqpk2bhqpVqyI4OJhzABEREemRwP9m1fkr8l/cik9GHScbA0aUP63nAerduzfu3r2Lbdu2wd3dHQAQFhaGgQMHolq1ahrPtVOUcR4gIiIi7blO+l31fv8Yb9SrVKZQz6/XeYAOHTqEoKAgVfIDALVr18aqVavUJh8kIiKi0iX6h45wtDF9d8UiQOsESKlU5nj0HXg9MFmpVOokKCIiIiqeHiWmAQAWHo5AWqbCwNHkTesE6OOPP8a4cePw6NEjVVlsbCzGjx+PTz75RKfBERERUfF08nYC/or819Bh5EnrBGjlypVITk6Gq6srqlatimrVqsHNzQ3JyclYsWKFPmIkIiKiYigtq+j2DGn9FJizszMuXbqE0NBQ3Lp1C0II1K5dG23atNFHfERERFSMRP/QEZ+v/Qdn7j01dCj5KvA8QG3btkXbtm11GQsRERGVAPmsPlVkaJQALV++HMOHD4epqSmWL1+eb92xY8fqJDAiIiIifdEoAVqyZAn69esHU1NTLFmyJM96EomECRAREREVeRolQFFRUbm+JyIiIiqO3nuRDoVCgStXruD58+e6iIeIiIhI77ROgPz8/LBhwwYAr5Ofli1bolGjRnB2dsbx48d1HR8RERGRzmmdAO3atQv169cHABw4cADR0dG4desW/Pz8MGXKFJ0HSERERKRrWidACQkJsLe3BwCEhISgV69eqFGjBr788ktcv35d5wESERFR8ZK9zLpSqdV664VK6wTIzs4OYWFhUCgUOHTokGoCxNTUVEilUp0HSERERMVL9iSIfsFXDBtIPrSeCHHw4MH47LPP4ODgAIlEopoM8ezZs6hVq5bOAyQiIiLSNa0ToJkzZ6JOnTp48OABevXqBblcDgCQSqWYNGmSzgMkIiKi4uW3rz9EpxWnUM5CZuhQ8lSgpTB69uyZo2zgwIHvHQwREREVfzLj955lR++4FAYRERHplPL/R0E/e5mB6ISXcK1gYeCIcpIIId45RNvNzQ0XLlxA+fLl4ebmlvfBJBLcu3dPpwEaQlJSEmxsbJCYmAhra2tDh0NERFSsnL33FL3X/gMAmOhbE6NbVyuU82rz+82lMIiIiEinmlUpr3qvKKKPwhf9TjoiIiIqdj5vWtnQIeRL6wSoZ8+e+OGHH3KUL1y4EL169dJJUERERET6pHUCdOLECXTs2DFHebt27fDXX3/pJCgiIiIifdI6AUpJSYFMlvO5fhMTEyQlJekkKCIiIiJ90joBqlOnDoKDg3OU79y5E7Vr19ZJUERERET6pPVEiNOmTcOnn36Ku3fv4uOPPwYA/PHHH9ixYwd+/fVXnQdIREREpGtaJ0BdunTBvn37MH/+fOzatQtmZmaoV68ejh49ilatWukjRiIiIiKdKtBSGB07dsx1IDQRERFRcVCgeYBevHiB9evX4/vvv8ezZ88AAJcuXUJsbKxOgyMiIiLSB61bgK5du4Y2bdrAxsYG0dHRGDp0KMqVK4e9e/fi/v372Lp1qz7iJCIiItIZrVuA/P39MWjQINy+fRumpqaq8vbt23MeICIiIioWtE6Azp8/j6+++ipHuZOTE+Lj43USFBEREZE+aZ0AmZqa5jrhYUREBCpWrKiToIiIiIj0SesEqGvXrpg9ezYyMzMBABKJBDExMZg0aRI+/fRTnQdIREREpGtaJ0A//fQT/v33X9ja2uLVq1do1aoVqlWrBisrK8ybN08fMRIRERHplNYJkLW1NU6dOoXdu3fjhx9+wJgxYxASEoITJ07AwsJC6wACAwPh5uYGU1NTeHh44OTJk/nW3759O+rXrw9zc3M4ODhg8ODBePr0qVqdpUuXombNmjAzM4OzszPGjx+PtLQ0rWMjIiKikkmrx+CzsrJgamqKK1eu4OOPP1YthVFQwcHB8PPzQ2BgILy9vbFmzRq0b98eYWFhqFy5co76p06dwoABA7BkyRJ07twZsbGxGDFiBIYOHYq9e/cCeJ0gTZo0CRs3boSXlxciIyMxaNAgAMCSJUveK14iIiIqGbRqATI2NoaLiwsUCoVOTr548WJ8+eWXGDp0KNzd3bF06VI4OzsjKCgo1/r//PMPXF1dMXbsWLi5ueHDDz/EV199hQsXLqjqnDlzBt7e3ujbty9cXV3h4+ODzz//XK0OERERlW5ad4FNnToVkydPVs0AXVAZGRm4ePEifHx81Mp9fHxw+vTpXPfx8vLCw4cPERISAiEEHj9+jF27dqkty/Hhhx/i4sWLOHfuHADg3r17CAkJyXfpjvT0dCQlJam9iIiIqOTSeibo5cuX486dO3B0dISLi0uOcT+XLl3S6DgJCQlQKBSws7NTK7ezs8tzPiEvLy9s374dvXv3RlpaGrKystClSxesWLFCVadPnz74999/8eGHH0IIgaysLIwcORKTJk3KM5aAgADMmjVLo7iJiIjo3ZLSXj8t/vM/9zHA0wVlzGUGjkid1glQ165dIZFIdBbA28cSQuR5/LCwMIwdOxbTp0+Hr68v4uLiMHHiRIwYMQIbNmwAABw/fhzz5s1DYGAgmjVrhjt37mDcuHFwcHDAtGnTcj3u5MmT4e/vr/qclJQEZ2dnHV0hERFR6fP7tTgAwJPkdKw4dgfTOtU2cETqJEIIYYgTZ2RkwNzcHL/++iu6d++uKh83bhyuXLmCEydO5Ninf//+SEtLw6+//qoqO3XqFFq0aIFHjx7BwcEBLVq0QPPmzbFw4UJVnZ9//hnDhw9HSkoKjIze3euXlJQEGxsbJCYmwtra+j2vlIiIqPSpO+MwktOzAAAyYyNEzm2v93Nq8/ut8Rig1NRUjB49Gk5OTrC1tUXfvn2RkJBQ4CBlMhk8PDwQGhqqVh4aGgovL688Y3g7gZFKpQBetxzlV0cIAQPlekRERKXO5eltVe8zspSISnhpwGhy0jgBmjFjBjZv3oyOHTuiT58+CA0NxciRI9/r5P7+/li/fj02btyI8PBwjB8/HjExMRgxYgSA111TAwYMUNXv3Lkz9uzZg6CgINy7dw9///03xo4di6ZNm8LR0VFVJygoCDt37kRUVBRCQ0Mxbdo0dOnSRZUsERERkX4ZS42w4vOGqs/J/z8mqKjQeAzQnj17sGHDBvTp0wcA8MUXX8Db2xsKhaLAiUXv3r3x9OlTzJ49G3FxcahTpw5CQkLg4uICAIiLi0NMTIyq/qBBg5CcnIyVK1diwoQJKFOmDD7++GP8+OOPqjpTp06FRCLB1KlTERsbi4oVK6Jz586cpZqIiKiQda7viICQcDxKLHqTEWs8BkgmkyEqKgpOTk6qMjMzM0RGRpa4AcMcA0RERKQbXgF/4FFiGvaP8Ua9SmX0ei69jAFSKBSQydQfYTM2NkZWVlbBoiQiIiIyEI27wIQQGDRoEORyuaosLS0NI0aMUJsLaM+ePbqNkIiIiEjHNE6ABg4cmKPsiy++0GkwRERERIVB4wRo06ZN+oyDiIiIqNBovRYYERERUXHHBIiIiIhKHSZAREREVOowASIiIqJShwkQERERlTpMgIiIiKjU0fgxeCIiIiJtZSher7h1PTYREkgAAEZGQC17a0iNJAaLiwkQERER6U1CSjoAYMreG2rlvTwqYWGv+oYICQC7wIiIiKiQONiYoqy5CQDg7r8pBo2FCRARERHp3dxudXBm8if48dN6hg4FABMgIiIiKgROZc0MHYIajgEiIiIivVnYsx6O3XqC1jVtDR2KGiZAREREpDe9GjujV2NnQ4eRA7vAiIiIqNRhAkRERESlDhMgIiIiKnWYABEREVGpwwSIiIiISh0mQERERFTqMAEiIiKiUocJEBEREZU6TICIiIio1GECRERERKUOEyAiIiIqdZgAERERUanDBIiIiIhKHSZAREREVOowASIiIqJShwkQERERlTpMgIiIiKjUYQJEREREpY7BE6DAwEC4ubnB1NQUHh4eOHnyZL71t2/fjvr168Pc3BwODg4YPHgwnj59qlbnxYsXGD16NBwcHGBqagp3d3eEhITo8zKIiIioGDFoAhQcHAw/Pz9MmTIFly9fRosWLdC+fXvExMTkWv/UqVMYMGAAvvzyS9y8eRO//vorzp8/j6FDh6rqZGRkoG3btoiOjsauXbsQERGBdevWwcnJqbAui4iIiIo4Y0OefPHixfjyyy9VCczSpUtx+PBhBAUFISAgIEf9f/75B66urhg7diwAwM3NDV999RUWLFigqrNx40Y8e/YMp0+fhomJCQDAxcWlEK6GiIiIiguDtQBlZGTg4sWL8PHxUSv38fHB6dOnc93Hy8sLDx8+REhICIQQePz4MXbt2oWOHTuq6uzfvx+enp4YPXo07OzsUKdOHcyfPx8KhSLPWNLT05GUlKT2IiIiopLLYC1ACQkJUCgUsLOzUyu3s7NDfHx8rvt4eXlh+/bt6N27N9LS0pCVlYUuXbpgxYoVqjr37t3DsWPH0K9fP4SEhOD27dsYPXo0srKyMH369FyPGxAQgFmzZmkVvxACWVlZ+SZWRKWFiYkJpFKpocMgItKYQbvAAEAikah9FkLkKMsWFhaGsWPHYvr06fD19UVcXBwmTpyIESNGYMOGDQAApVIJW1tbrF27FlKpFB4eHnj06BEWLlyYZwI0efJk+Pv7qz4nJSXB2dk5z5gzMjIQFxeH1NRUbS+XqESSSCSoVKkSLC0tDR0KEZFGDJYAVahQAVKpNEdrz5MnT3K0CmULCAiAt7c3Jk6cCACoV68eLCws0KJFC8ydOxcODg5wcHDI8a9Rd3d3xMfHIyMjAzKZLMdx5XI55HK5RnErlUpERUVBKpXC0dERMpksz4SNqDQQQuDff//Fw4cPUb16dbYEEVGxYLAESCaTwcPDA6GhoejevbuqPDQ0FF27ds11n9TUVBgbq4ec/T9bIQQAwNvbG7/88guUSiWMjF4PcYqMjISDg0OuyY+2MjIyoFQq4ezsDHNz8/c+HlFJULFiRURHRyMzM5MJEBEVCwZ9DN7f3x/r16/Hxo0bER4ejvHjxyMmJgYjRowA8LprasCAAar6nTt3xp49exAUFIR79+7h77//xtixY9G0aVM4OjoCAEaOHImnT59i3LhxiIyMxO+//4758+dj9OjROo09O7kiopxd2URERZ1BxwD17t0bT58+xezZsxEXF4c6deogJCRE9dh6XFyc2pxAgwYNQnJyMlauXIkJEyagTJky+Pjjj/Hjjz+q6jg7O+PIkSMYP3486tWrBycnJ4wbNw7fffddoV8fERERFU0Skd13RCpJSUmwsbFBYmIirK2t1balpaUhKipKNXs1EfG/CyLS3JGb8Ri+7SIaVS6DPaO8dXrs/H6/38Z+HMpBIpFg3759ej/P8ePHIZFI8OLFC1XZvn37UK1aNUilUvj5+WHz5s0oU6aM3mKIiIiAvb09kpOT9XaOkqBJkybYs2ePocMgItIZJkClTHx8PL7++mtUqVIFcrkczs7O6Ny5M/74449Cj8XLywtxcXGwsbFRlX311Vfo2bMnHjx4gDlz5qB3796IjIzUWwxTpkzB6NGjYWVllWNbzZo1IZPJEBsbm2PbRx99BIlEAolEArlcjho1arxzws33JYTAzJkz4ejoCDMzM3z00Ue4efNmvvtkZmZi9uzZqFq1KkxNTVG/fn0cOnRIrU5ycjL8/Pzg4uICMzMzeHl54fz582p1pk2bhkmTJkGpVOr8uoiIDIEJUCkSHR0NDw8PHDt2DAsWLMD169dx6NAhtG7dWueDxDUhk8lgb2+vGkCbkpKCJ0+ewNfXF46OjrCysoKZmRlsbW3f6zyZmZm5lj98+BD79+/H4MGDc2w7deoU0tLS0KtXL2zevDnX/YcNG4a4uDhERERg7NixmDp1Kn766af3ijU/CxYswOLFi7Fy5UqcP38e9vb2aNu2bb6tV1OnTsWaNWuwYsUKhIWFYcSIEejevTsuX76sqjN06FCEhoZi27ZtuH79Onx8fNCmTRu1xK9jx45ITEzE4cOH9XZ9RESFSlAOiYmJAoBITEzMse3Vq1ciLCxMvHr1SlWmVCrFy/RMg7yUSqXG19W+fXvh5OQkUlJScmx7/vy56j0AsXfvXtXnb7/9VlSvXl2YmZkJNzc3MXXqVJGRkaHafuXKFfHRRx8JS0tLYWVlJRo1aiTOnz8vhBAiOjpadOrUSZQpU0aYm5uL2rVri99//10IIcSff/4pAIjnz5+r3r/5+vPPP8WmTZuEjY2NWqz79+8XjRo1EnK5XLi5uYmZM2eKzMxMtfiDgoJEly5dhLm5uZg+fXqu92PRokWicePGuW4bNGiQmDRpkjh48KCoUqVKjvvcqlUrMW7cOLWyNm3aiObNm+d6vPelVCqFvb29+OGHH1RlaWlpwsbGRqxevTrP/RwcHMTKlSvVyrp27Sr69esnhBAiNTVVSKVS8dtvv6nVqV+/vpgyZYpa2aBBg0T//v1zPU9u/10QEeXm8I044fLdb6L7qlM6P3Z+v99vM/hM0CXBq0wFak83zL+Mw2b7wlz27j/js2fPcOjQIcybNw8WFhY5tuc3zsbKygqbN2+Go6Mjrl+/jmHDhsHKygrffvstAKBfv35o2LAhgoKCIJVKceXKFdVCtKNHj0ZGRgb++usvWFhYICwsLNfZgr28vBAREYGaNWti9+7d8PLyQrly5RAdHa1W7/Dhw/jiiy+wfPlytGjRAnfv3sXw4cMBADNmzFDVmzFjBgICArBkyZI856X566+/0Lhx4xzlycnJ+PXXX3H27FnUqlULL1++xPHjx9G6des87xEAmJmZ4fnz53lub9++PU6ePJnvMVJSUnItj4qKQnx8vNraeXK5HK1atcLp06fx1Vdf5bpfenp6jkHJZmZmOHXqFAColnPJr062pk2bqi08TERUnDEBKiXu3LkDIQRq1aql9b5Tp05VvXd1dcWECRMQHBysSoBiYmIwceJE1bGrV6+uqh8TE4NPP/0UdevWBQBUqVIl13PIZDJVV1e5cuVgb2+fa7158+Zh0qRJGDhwoOp4c+bMwbfffquWAPXt2xdDhgzJ97qyuwTftnPnTlSvXh0ffPABAKBPnz7YsGFDngmQUqnEkSNHcPjwYfj5+eV5vvXr1+PVq1f5xpSX7BnTc1s77/79+3nu5+vri8WLF6Nly5aoWrUq/vjjD/z3v/9VjVWysrKCp6cn5syZA3d3d9jZ2WHHjh04e/as2t8RAJycnBATE6M2ySgRUXHFBEgHzEykCJvta7Bza0L8/2wHBZmwbteuXVi6dCnu3LmDlJQUZGVlqT1e6O/vj6FDh2Lbtm1o06YNevXqhapVqwIAxo4di5EjR+LIkSNo06YNPv30U9SrV0/rGLJdvHgR58+fx7x581RlCoUCaWlpSE1NVc3OnVvLzttevXqV6yPbGzZswBdffKH6/MUXX6Bly5Z48eKFWktZYGAg1q9fj4yMDABA//791ZKwtzk5Ob0zpnfRZu08AFi2bBmGDRuGWrVqQSKRoGrVqhg8eDA2bdqkqrNt2zYMGTIETk5OkEqlaNSoEfr27YtLly6pHcvMzAxKpRLp6ekwMzN772shIjIk/jNOByQSCcxlxgZ5aZrQVK9eHRKJBOHh4Vpd2z///IM+ffqgffv2+O2333D58mVMmTJF9aMPADNnzsTNmzfRsWNHHDt2DLVr18bevXsBvB5ge+/ePfTv3x/Xr19H48aNsWLFCq1ieJNSqcSsWbNw5coV1ev69eu4ffu2WjKTWzff2ypUqJCjyyosLAxnz57Ft99+C2NjYxgbG6N58+Z49eoVduzYoVa3X79+uHLlCu7evYtXr15hw4YN+S6P0r59e1haWub7ykt2i5g2a+cBr5eo2LdvH16+fIn79+/j1q1bsLS0hJubm6pO1apVceLECaSkpODBgwc4d+4cMjMz1eoAr7tRzc3NmfwQUYnAFqBSoly5cvD19cWqVaswduzYHAnC260b2f7++2+4uLhgypQpqrLculxq1KiBGjVqYPz48fj888+xadMm1Rpvzs7OGDFiBEaMGIHJkydj3bp1+Prrrwt0HY0aNUJERASqVatWoP3f1LBhQ4SFhamVbdiwAS1btsSqVavUyrdt24YNGzZg5MiRqjIbGxut4nifLjA3NzfY29sjNDQUDRs2BPB6XboTJ06ozYSeF1NTUzg5OSEzMxO7d+/GZ599lqOOhYUFLCws8Pz5cxw+fDjHeJ8bN26gUaNGBYqfiKioYQJUigQGBsLLywtNmzbF7NmzUa9ePWRlZSE0NBRBQUG5tg5Vq1YNMTEx2LlzJ5o0aYLff/9d1boDvO5GmjhxInr27Ak3Nzc8fPgQ58+fx6effgoA8PPzQ/v27VGjRg08f/4cx44dg7u7e4GvYfr06ejUqROcnZ3Rq1cvGBkZ4dq1a7h+/Trmzp2r1bF8fX0xdOhQKBQKSKVSZGZmYtu2bZg9ezbq1KmjVnfo0KFYsGABrl69ivr16xco9vfpApNIJPDz88P8+fNRvXp1VK9eHfPnz4e5uTn69u2rqjdgwAA4OTkhICAAAHD27FnExsaiQYMGiI2NxcyZM6FUKlXjt4DXA8uFEKhZsybu3LmDiRMnombNmjmmBzh58qTaIGwiooIwkkggNzaCidTAnVA6fwatBND2Mfji5NGjR2L06NHCxcVFyGQy4eTkJLp06SL+/PNPVR289Rj8xIkTRfny5YWlpaXo3bu3WLJkierR9PT0dNGnTx/h7OwsZDKZcHR0FGPGjFHdnzFjxoiqVasKuVwuKlasKPr37y8SEhKEEOqPwQvx+lF8/P/j79lyewz+0KFDwsvLS5iZmQlra2vRtGlTsXbt2jzjz0tWVpZwcnIShw4dEkIIsWvXLmFkZCTi4+NzrV+3bl3x9ddfCyFyfwxe35RKpZgxY4awt7cXcrlctGzZUly/fl2tTqtWrcTAgQNVn48fPy7c3d2FXC4X5cuXF/379xexsbFq+wQHB4sqVaoImUwm7O3txejRo8WLFy/U6jx8+FCYmJiIBw8e5Bpbcf/vgohKBm0eg+daYLngWmClR2BgIP773/9ygr93mDhxIhITE7F27dpct/O/CyIqCrRZC4xdYFSqDR8+HM+fP0dycnKuy2HQa7a2tvjmm28MHQYRkc4wAaJSzdjYWG2AN+Vu4sSJhg6BiEin+Bg8ERERlTpMgIiIiKjUYQJUQBw7TvQ//O+BiIobJkBayl7kMzU11cCREBUd2TOD57XwLBFRUcNB0FqSSqUoU6YMnjx5AgAwNzcv0PpaRCWFUqnEv//+C3Nzcxgb838pRFQ88P9WBZC9LlN2EkRU2hkZGaFy5cr8xwARFRtMgApAIpHAwcEBtra2yMzMNHQ4RAYnk8lgZMQedSIqPpgAvQepVMoxD0RERMUQ/8lGREREpQ4TICIiIip1mAARERFRqcMxQLnIntQtKSnJwJEQERGRprJ/tzWZnJUJUC6Sk5MBAM7OzgaOhIiIiLSVnJwMGxubfOtIBOewz0GpVOLRo0ewsrLS+bwmSUlJcHZ2xoMHD2Btba3TY9P/8D4XDt7nwsH7XHh4rwuHvu6zEALJyclwdHR859QcbAHKhZGRESpVqqTXc1hbW/M/rkLA+1w4eJ8LB+9z4eG9Lhz6uM/vavnJxkHQREREVOowASIiIqJShwlQIZPL5ZgxYwbkcrmhQynReJ8LB+9z4eB9Ljy814WjKNxnDoImIiKiUoctQERERFTqMAEiIiKiUocJEBEREZU6TICIiIio1GECpAeBgYFwc3ODqakpPDw8cPLkyXzrnzhxAh4eHjA1NUWVKlWwevXqQoq0eNPmPu/Zswdt27ZFxYoVYW1tDU9PTxw+fLgQoy2+tP0+Z/v7779hbGyMBg0a6DfAEkLb+5yeno4pU6bAxcUFcrkcVatWxcaNGwsp2uJL2/u8fft21K9fH+bm5nBwcMDgwYPx9OnTQoq2ePrrr7/QuXNnODo6QiKRYN++fe/cxyC/g4J0aufOncLExESsW7dOhIWFiXHjxgkLCwtx//79XOvfu3dPmJubi3HjxomwsDCxbt06YWJiInbt2lXIkRcv2t7ncePGiR9//FGcO3dOREZGismTJwsTExNx6dKlQo68eNH2Pmd78eKFqFKlivDx8RH169cvnGCLsYLc5y5duohmzZqJ0NBQERUVJc6ePSv+/vvvQoy6+NH2Pp88eVIYGRmJZcuWiXv37omTJ0+KDz74QHTr1q2QIy9eQkJCxJQpU8Tu3bsFALF379586xvqd5AJkI41bdpUjBgxQq2sVq1aYtKkSbnW//bbb0WtWrXUyr766ivRvHlzvcVYEmh7n3NTu3ZtMWvWLF2HVqIU9D737t1bTJ06VcyYMYMJkAa0vc8HDx4UNjY24unTp4URXomh7X1euHChqFKlilrZ8uXLRaVKlfQWY0mjSQJkqN9BdoHpUEZGBi5evAgfHx+1ch8fH5w+fTrXfc6cOZOjvq+vLy5cuIDMzEy9xVqcFeQ+v02pVCI5ORnlypXTR4glQkHv86ZNm3D37l3MmDFD3yGWCAW5z/v370fjxo2xYMECODk5oUaNGvjmm2/w6tWrwgi5WCrIffby8sLDhw8REhICIQQeP36MXbt2oWPHjoURcqlhqN9BLoaqQwkJCVAoFLCzs1Mrt7OzQ3x8fK77xMfH51o/KysLCQkJcHBw0Fu8xVVB7vPbFi1ahJcvX+Kzzz7TR4glQkHu8+3btzFp0iScPHkSxsb834smCnKf7927h1OnTsHU1BR79+5FQkICRo0ahWfPnnEcUB4Kcp+9vLywfft29O7dG2lpacjKykKXLl2wYsWKwgi51DDU7yBbgPRAIpGofRZC5Ch7V/3cykmdtvc5244dOzBz5kwEBwfD1tZWX+GVGJreZ4VCgb59+2LWrFmoUaNGYYVXYmjzfVYqlZBIJNi+fTuaNm2KDh06YPHixdi8eTNbgd5Bm/scFhaGsWPHYvr06bh48SIOHTqEqKgojBgxojBCLVUM8TvIf6LpUIUKFSCVSnP8a+LJkyc5stts9vb2udY3NjZG+fLl9RZrcVaQ+5wtODgYX375JX799Ve0adNGn2EWe9re5+TkZFy4cAGXL1/GmDFjALz+oRZCwNjYGEeOHMHHH39cKLEXJwX5Pjs4OMDJyQk2NjaqMnd3dwgh8PDhQ1SvXl2vMRdHBbnPAQEB8Pb2xsSJEwEA9erVg4WFBVq0aIG5c+eyhV5HDPU7yBYgHZLJZPDw8EBoaKhaeWhoKLy8vHLdx9PTM0f9I0eOoHHjxjAxMdFbrMVZQe4z8LrlZ9CgQfjll1/Yh68Bbe+ztbU1rl+/jitXrqheI0aMQM2aNXHlyhU0a9assEIvVgryffb29sajR4+QkpKiKouMjISRkREqVaqk13iLq4Lc59TUVBgZqf9MSqVSAP9roaD3Z7DfQb0OsS6Fsh+z3LBhgwgLCxN+fn7CwsJCREdHCyGEmDRpkujfv7+qfvbjf+PHjxdhYWFiw4YNfAxeA9re519++UUYGxuLVatWibi4ONXrxYsXhrqEYkHb+/w2PgWmGW3vc3JysqhUqZLo2bOnuHnzpjhx4oSoXr26GDp0qKEuoVjQ9j5v2rRJGBsbi8DAQHH37l1x6tQp0bhxY9G0aVNDXUKxkJycLC5fviwuX74sAIjFixeLy5cvq6YbKCq/g0yA9GDVqlXCxcVFyGQy0ahRI3HixAnVtoEDB4pWrVqp1T9+/Lho2LChkMlkwtXVVQQFBRVyxMWTNve5VatWAkCO18CBAws/8GJG2+/zm5gAaU7b+xweHi7atGkjzMzMRKVKlYS/v79ITU0t5KiLH23v8/Lly0Xt2rWFmZmZcHBwEP369RMPHz4s5KiLlz///DPf/98Wld9BiRBsxyMiIqLShWOAiIiIqNRhAkRERESlDhMgIiIiKnWYABEREVGpwwSIiIiISh0mQERERFTqMAEiIiKiUocJEFEJ5erqiqVLl6o+SyQS7Nu3L999nj59CltbW0RHR+s1tmyDBg1Ct27d8q1z/PhxSCQSvHjxQm9xFOQcH330Efz8/N7rvJs3b0aZMmXe6xj6oMl3RZO/nTbS09NRuXJlXLx4UWfHJMoPEyAiHRs0aBAkEgkkEgmMjY1RuXJljBw5Es+fPzd0aO8UEBCAzp07w9XVFQAQHR2tuhaJRIKyZcuiZcuWOHHihE7Ot2zZMmzevFn1ObekwsvLC3FxcWoLf5J+xcXFoX379gD+9x24cuWKWp23/3bvSy6X45tvvsF3332ns2MS5YcJEJEetGvXDnFxcYiOjsb69etx4MABjBo1ytBh5evVq1fYsGEDhg4dmmPb0aNHERcXhxMnTsDa2hodOnRAVFTUe5/TxsbmnS0gMpkM9vb2kEgk730+0oy9vT3kcnm+dTT522mrX79+OHnyJMLDw3V6XKLcMAEi0gO5XA57e3tUqlQJPj4+6N27N44cOaJWZ9OmTXB3d4epqSlq1aqFwMBAte0PHz5Enz59UK5cOVhYWKBx48Y4e/YsAODu3bvo2rUr7OzsYGlpiSZNmuDo0aPvFfPBgwdhbGwMT0/PHNvKly8Pe3t71KtXD2vWrEFqaqrqek6cOIGmTZtCLpfDwcEBkyZNQlZWlmrfXbt2oW7dujAzM0P58uXRpk0bvHz5EoB6N8qgQYNw4sQJLFu2TNXiFB0drdY9lZiYCDMzMxw6dEgtvj179sDCwkK1OnpsbCx69+6NsmXLonz58ujatatW3XpPnz7F559/jkqVKsHc3Bx169bFjh07ctTLysrCmDFjUKZMGZQvXx5Tp05VWyU8IyMD3377LZycnGBhYYFmzZrh+PHjGseRm5kzZ6JBgwZYs2YNnJ2dYW5ujl69eql13ymVSsyePRuVKlWCXC5HgwYN1O5ZRkYGxowZAwcHB5iamsLV1RUBAQGq7W92gbm5uQEAGjZsCIlEgo8++giA+t9uzZo1cHJyglKpVIu1S5cuGDhwoOrzgQMH4OHhAVNTU1SpUgWzZs1S+66UL18eXl5eud5rIl1jAkSkZ/fu3cOhQ4dgYmKiKlu3bh2mTJmCefPmITw8HPPnz8e0adOwZcsWAEBKSgpatWqFR48eYf/+/bh69Sq+/fZb1Q9MSkoKOnTogKNHj+Ly5cvw9fVF586dERMTU+A4//rrLzRu3Pid9czNzQEAmZmZiI2NRYcOHdCkSRNcvXoVQUFB2LBhA+bOnQvgdVfK559/jiFDhiA8PBzHjx9Hjx49kNsShMuWLYOnpyeGDRuGuLg4xMXFwdnZWa2OjY0NOnbsiO3bt6uV//LLL+jatSssLS2RmpqK1q1bw9LSEn/99RdOnToFS0tLtGvXDhkZGRrdi7S0NHh4eOC3337DjRs3MHz4cPTv31+VgGbbsmULjI2NcfbsWSxfvhxLlizB+vXrVdsHDx6Mv//+Gzt37sS1a9fQq1cvtGvXDrdv3871vNndTe9Kku7cuYP//Oc/OHDgAA4dOoQrV65g9OjRqu3Lli3DokWL8NNPP+HatWvw9fVFly5dVOddvnw59u/fj//85z+IiIjAzz//rOr2fNu5c+cA/K8VcM+ePTnq9OrVCwkJCfjzzz9VZc+fP8fhw4fRr18/AMDhw4fxxRdfYOzYsQgLC8OaNWuwefNmzJs3T+1YTZs2xcmTJ/O9fiKd0Ptyq0SlzMCBA4VUKhUWFhbC1NRUtRLy4sWLVXWcnZ3FL7/8orbfnDlzhKenpxBCiDVr1ggrKyvx9OlTjc9bu3ZtsWLFCtVnFxcXsWTJEtVnAGLv3r157t+1a1cxZMgQtbKoqCgBQFy+fFkIIURKSor46quvhFQqFdeuXRPff/+9qFmzplAqlap9Vq1aJSwtLYVCoRAXL14UAER0dHSu5xw4cKDo2rWr6nOrVq3EuHHj1Opkryz9/PlzIYQQe/bsEZaWluLly5dCCCESExOFqamp+P3334UQQmzYsCFHTOnp6cLMzEwcPnw41zjePkduOnToICZMmKAWq7u7u9p5vvvuO+Hu7i6EEOLOnTtCIpGI2NhYteN88sknYvLkyUIIITZt2iRsbGxU2x4+fChq1qwpzp49m2ccM2bMEFKpVDx48EBVdvDgQWFkZCTi4uKEEEI4OjqKefPmqe3XpEkTMWrUKCGEEF9//bX4+OOP1WJ/05vflbe/A9ne/tt16dJF7fuzZs0aYW9vL7KysoQQQrRo0ULMnz9f7Rjbtm0TDg4OamXLli0Trq6ueV4/ka4YGyzzIirBWrdujaCgIKSmpmL9+vWIjIzE119/DQD4999/8eDBA3z55ZcYNmyYap+srCzVQN8rV66gYcOGKFeuXK7Hf/nyJWbNmoXffvsNjx49QlZWFl69evVeLUCvXr2Cqalprtu8vLxgZGSE1NRUODg4YPPmzahbty5mzJgBT09PtfE53t7eSElJwcOHD1G/fn188sknqFu3Lnx9feHj44OePXuibNmyBY6zY8eOMDY2xv79+9GnTx/s3r0bVlZW8PHxAQBcvHgRd+7cgZWVldp+aWlpuHv3rkbnUCgU+OGHHxAcHIzY2Fikp6cjPT0dFhYWavWaN2+udu2enp5YtGgRFAoFLl26BCEEatSoobZPeno6ypcvn+t5nZyccOvWrXfGV7lyZVSqVEntvEqlEhERETA3N8ejR4/g7e2tto+3tzeuXr0K4HX3Vdu2bVGzZk20a9cOnTp1Ut2/gurXrx+GDx+OwMBAyOVybN++HX369IFUKgXw+u9y/vx5tRYfhUKBtLQ0pKamqloWzczMkJqa+l6xEGmCCRCRHlhYWKBatWoAXnc3tG7dGrNmzcKcOXNU3Vjr1q1Ds2bN1PbL/rEwMzPL9/gTJ07E4cOH8dNPP6FatWowMzNDz549Ne7iyU2FChXyfFItODgYtWvXVo11ySaEyDE4Wfx/95ZEIoFUKkVoaChOnz6NI0eOYMWKFZgyZQrOnj2rGluiLZlMhp49e+KXX35Bnz598Msvv6B3794wNn79vzOlUgkPD48c3WQAULFiRY3OsWjRIixZsgRLly5F3bp1YWFhAT8/P63ur1KphFQqxcWLF1V/12yWlpYaH0cT2X+DN/8Wuf1dsssaNWqEqKgoHDx4EEePHsVnn32GNm3aYNeuXQWOoXPnzlAqlfj999/RpEkTnDx5EosXL1ZtVyqVmDVrFnr06JFj3zcT72fPnmn8dyJ6H0yAiArBjBkz0L59e4wcORKOjo5wcnLCvXv3VOMj3lavXj2sX78ez549y7UV6OTJkxg0aBC6d+8O4PWYoPedu6dhw4b4+eefc93m7OyMqlWr5iivXbs2du/erfbjevr0aVhZWcHJyQnA6x9ib29veHt7Y/r06XBxccHevXvh7++f43gymQwKheKdsfbr1w8+Pj64efMm/vzzT8yZM0e1rVGjRggODoatrS2sra01uva3nTx5El27dsUXX3wB4PWP9+3bt+Hu7q5W759//snxuXr16pBKpWjYsCEUCgWePHmCFi1aFCiOvMTExODRo0dwdHQEAJw5cwZGRkaoUaMGrK2t4ejoiFOnTqFly5aqfU6fPo2mTZuqPltbW6N3797o3bs3evbsiXbt2uX6fZPJZADwzr+LmZkZevToge3bt+POnTuoUaMGPDw8VNsbNWqEiIgI1T8M8nLjxg00bNhQsxtB9B44CJqoEHz00Uf44IMPMH/+fACvn+QJCAjAsmXLEBkZievXr2PTpk2qfzF//vnnsLe3R7du3fD333/j3r172L17N86cOQMAqFatGvbs2YMrV67g6tWr6Nu3b44ncLTl6+uLmzdvajVf0ahRo/DgwQN8/fXXuHXrFv773/9ixowZ8Pf3h5GREc6ePYv58+fjwoULiImJwZ49e/Dvv//mSCSyubq64uzZs4iOjkZCQkKe19SqVSvY2dmhX79+cHV1RfPmzVXb+vXrhwoVKqBr1644efIkoqKicOLECYwbNw4PHz7U6LqqVaumarkKDw/HV199hfj4+Bz1Hjx4AH9/f0RERGDHjh1YsWIFxo0bBwCoUaMG+vXrhwEDBmDPnj2IiorC+fPn8eOPPyIkJCTX88bGxqJWrVqqgcd5MTU1xcCBA3H16lWcPHkSY8eOxWeffQZ7e3sAr1sIf/zxRwQHByMiIgKTJk3ClStXVLEtWbIEO3fuxK1btxAZGYlff/0V9vb2uT7Wbmtrq3ry7vHjx0hMTMwzrn79+uH333/Hxo0bVcljtunTp2Pr1q2YOXMmbt68ifDwcAQHB2Pq1Klq9U6ePPne3XFEGjHoCCSiEujtwaHZtm/fLmQymYiJiVF9btCggZDJZKJs2bKiZcuWYs+ePar60dHR4tNPPxXW1tbC3NxcNG7cWDU4NioqSrRu3VqYmZkJZ2dnsXLlyhwDiLUdBC2EEM2bNxerV69Wfc5rAOybjh8/Lpo0aSJkMpmwt7cX3333ncjMzBRCCBEWFiZ8fX1FxYoVhVwuFzVq1FAbqP32vYqIiBDNmzcXZmZmAoCIiorKc4DyxIkTBQAxffr0HDHFxcWJAQMGiAoVKgi5XC6qVKkihg0bJhITE3O9hrfP8fTpU9G1a1dhaWkpbG1txdSpU8WAAQNyDNgeNWqUGDFihLC2thZly5YVkyZNUhtYnJGRIaZPny5cXV2FiYmJsLe3F927dxfXrl0TQuQcBJ19v//888887/eMGTNE/fr1RWBgoHB0dBSmpqaiR48e4tmzZ6o6CoVCzJo1Szg5OQkTExNRv359cfDgQdX2tWvXigYNGggLCwthbW0tPvnkE3Hp0iXV9re/K+vWrRPOzs7CyMhItGrVSgiR+/c8KytLODg4CADi7t27OWI/dOiQ8PLyEmZmZsLa2lo0bdpUrF27VrX99OnTokyZMiI1NTXP6yfSFYkQuTyPSkSlUkhICL755hvcuHEDRkZsIC6KZs6ciX379uWYmbkk6NWrFxo2bIjvv//e0KFQKcAxQESk0qFDB9y+fRuxsbE55uAh0qf09HTUr18f48ePN3QoVEowASIiNdnjRIgKk1wuzzEeiEif2AVGREREpQ47+YmIiKjUYQJEREREpQ4TICIiIip1mAARERFRqcMEiIiIiEodJkBERERU6jABIiIiolKHCRARERGVOkyAiIiIqNT5P9XI3wmdIca5AAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 21, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ITMekdfcHcPs", + "outputId": "321fb40f-672d-4425-9f2b-f0ce4016bb20" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":12: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " df[\"sentiment\"] = df.Score.replace({1: \"negative\", 2: \"negative\", 4: \"positive\", 5: \"positive\"})\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "from sklearn.metrics import classification_report\n", + "\n", + "datafile_path = \"data/fine_food_reviews_with_embeddings_1k.csv\"\n", + "\n", + "df = pd.read_csv(datafile_path)\n", + "\n", + "\n", + "df[\"t5_embedding\"] = df.Text.apply(get_t5_vector)\n", + "# convert 5-star rating to binary sentiment\n", + "df = df[df.Score != 3]\n", + "df[\"sentiment\"] = df.Score.replace({1: \"negative\", 2: \"negative\", 4: \"positive\", 5: \"positive\"})" ] - }, - "metadata": {}, - "output_type": "display_data" + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 628 + }, + "id": "YDubfmifHcPs", + "outputId": "fadf2451-e52d-4da0-ac3b-e508927d050e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " negative 0.60 0.90 0.72 136\n", + " positive 0.98 0.90 0.94 789\n", + "\n", + " accuracy 0.90 925\n", + " macro avg 0.79 0.90 0.83 925\n", + "weighted avg 0.93 0.90 0.91 925\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.metrics import PrecisionRecallDisplay\n", + "\n", + "def evaluate_embeddings_approach():\n", + " def label_score(review_embedding):\n", + " return cosine_similarity(review_embedding, positive_review_in_t5) - cosine_similarity(review_embedding, negative_review_in_t5)\n", + "\n", + " probas = df[\"t5_embedding\"].apply(lambda x: label_score(x))\n", + " preds = probas.apply(lambda x: 'positive' if x>0 else 'negative')\n", + "\n", + " report = classification_report(df.sentiment, preds)\n", + " print(report)\n", + "\n", + " display = PrecisionRecallDisplay.from_predictions(df.sentiment, probas, pos_label='positive')\n", + " _ = display.ax_.set_title(\"2-class Precision-Recall curve\")\n", + "\n", + "evaluate_embeddings_approach()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "rimAixIhTAWt" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "V100", + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "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.10.13" + }, + "vscode": { + "interpreter": { + "hash": "8114e84f04cf14e493992e1b725447accf84073d5ec18e7063d492738bf032cb" + } } - ], - "source": [ - "from sklearn.metrics import PrecisionRecallDisplay\n", - "\n", - "def evaluate_embeddings_approach():\n", - " def label_score(review_embedding):\n", - " return cosine_similarity(review_embedding, positive_review_in_t5) - cosine_similarity(review_embedding, negative_review_in_t5)\n", - "\n", - " probas = df[\"t5_embedding\"].apply(lambda x: label_score(x))\n", - " preds = probas.apply(lambda x: 'positive' if x>0 else 'negative')\n", - "\n", - " report = classification_report(df.sentiment, preds)\n", - " print(report)\n", - "\n", - " display = PrecisionRecallDisplay.from_predictions(df.sentiment, probas, pos_label='positive')\n", - " _ = display.ax_.set_title(\"2-class Precision-Recall curve\")\n", - "\n", - "evaluate_embeddings_approach()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "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.10.9" }, - "vscode": { - "interpreter": { - "hash": "8114e84f04cf14e493992e1b725447accf84073d5ec18e7063d492738bf032cb" - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 + "nbformat": 4, + "nbformat_minor": 0 } diff --git a/05_classification_in_ml.ipynb b/05_classification_in_ml.ipynb index de4a1e5..3b22063 100644 --- a/05_classification_in_ml.ipynb +++ b/05_classification_in_ml.ipynb @@ -9,50 +9,18 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--2023-03-20 11:13:19-- https://github.com/aceimnorstuvwxz/toutiao-text-classfication-dataset/raw/master/toutiao_cat_data.txt.zip\n", - "Resolving github.com (github.com)... 192.30.255.112\n", - "Connecting to github.com (github.com)|192.30.255.112|:443... connected.\n", - "HTTP request sent, awaiting response... 302 Found\n", - "Location: https://raw.githubusercontent.com/aceimnorstuvwxz/toutiao-text-classfication-dataset/master/toutiao_cat_data.txt.zip [following]\n", - "--2023-03-20 11:13:20-- https://raw.githubusercontent.com/aceimnorstuvwxz/toutiao-text-classfication-dataset/master/toutiao_cat_data.txt.zip\n", - "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.110.133, 185.199.109.133, 185.199.111.133, ...\n", - "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.110.133|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 26912069 (26M) [application/zip]\n", - "Saving to: ‘toutiao_cat_data.txt.zip’\n", - "\n", - "toutiao_cat_data.tx 100%[===================>] 25.67M 4.45MB/s in 10s \n", - "\n", - "2023-03-20 11:13:31 (2.51 MB/s) - ‘toutiao_cat_data.txt.zip’ saved [26912069/26912069]\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "!wget https://github.com/aceimnorstuvwxz/toutiao-text-classfication-dataset/raw/master/toutiao_cat_data.txt.zip" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Archive: ./toutiao_cat_data.txt.zip\n", - " inflating: toutiao_cat_data.txt \n" - ] - } - ], + "outputs": [], "source": [ "!unzip ./toutiao_cat_data.txt.zip\n", "!mv ./toutiao_cat_data.txt data/" @@ -60,15 +28,15 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/qp/42zc2mfd2w37v06s36xltvz80000gn/T/ipykernel_72415/1171345427.py:16: ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support regex separators (separators > 1 char and different from '\\s+' are interpreted as regex); you can avoid this warning by specifying engine='python'.\n", - " df = pd.read_csv('data/toutiao_cat_data.txt', sep='_!_', names=['id', 'code', 'category', 'title', 'keywords'])\n" + "/var/folders/lk/1jcy9d_j6258__3gv0rpj8h40000gn/T/ipykernel_3501/2567486315.py:16: ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support regex separators (separators > 1 char and different from '\\s+' are interpreted as regex); you can avoid this warning by specifying engine='python'.\n", + " df = pd.read_csv(os.environ.get(\"JUPYTER_HOME\") + '/data/toutiao_cat_data.txt', sep='_!_', names=['id', 'code', 'category', 'title', 'keywords'])\n" ] }, { @@ -96,7 +64,7 @@ "\n", "\n", "# import data/toutiao_cat_data.txt as a pandas dataframe\n", - "df = pd.read_csv('data/toutiao_cat_data.txt', sep='_!_', names=['id', 'code', 'category', 'title', 'keywords'])\n", + "df = pd.read_csv(os.environ.get(\"JUPYTER_HOME\") + '/data/toutiao_cat_data.txt', sep='_!_', names=['id', 'code', 'category', 'title', 'keywords'])\n", "df = df.fillna(\"\")\n", "df[\"combined\"] = (\n", " \"标题: \" + df.title.str.strip() + \"; 关键字: \" + df.keywords.str.strip()\n", @@ -114,7 +82,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -124,68 +92,103 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from openai import OpenAI\n", + "import os\n", + "\n", + "client = OpenAI(api_key=os.environ['OPENAI_API_KEY'])\n", + "\n", + "EMBEDDING_MODEL = \"text-embedding-ada-002\"\n", + "\n", + "def get_embedding(text, model=EMBEDDING_MODEL):\n", + " text = text.replace(\"\\n\", \" \")\n", + " return client.embeddings.create(input = [text], model=model).data[0].embedding" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 请不要执行如下代码\n", - "# from openai.embeddings_utils import get_embedding\n", "\n", "# df_1k = df.sample(1000, random_state=42)\n", "\n", - "# df_1k[\"embedding\"] = df_1k.combined.apply(lambda x : get_embedding(x, engine=embedding_model))\n", + "# df_1k[\"embedding\"] = df_1k.combined.apply(lambda x : get_embedding(x, model=embedding_model))\n", "# df_1k.to_csv(\"data/toutiao_cat_data_10k_with_embeddings.csv\", index=False)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 请不需要执行如下代码\n", - "# @backoff.on_exception(backoff.expo, openai.error.RateLimitError)\n", + "# @backoff.on_exception(backoff.expo, openai.RateLimitError)\n", "# def get_embedding_with_backoff(**kwargs):\n", - "# return get_embedding(**kwargs)\n", - "\n", + "# return get_embedding(**kwargs)\n", + "#\n", "# df_10k = df.sample(10000, random_state=42)\n", - "\n", - "# df_10k[\"embedding\"] = df_10k.combined.apply(lambda x : get_embedding_with_backoff(text=x, engine=embedding_model))\n", + "#\n", + "# df_10k[\"embedding\"] = df_10k.combined.apply(lambda x : get_embedding_with_backoff(text=x, model=embedding_model))\n", "# df_10k.to_csv(\"data/toutiao_cat_data_10k_with_embeddings.csv\", index=False)" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch 0 Number of embeddings: 2000\n", + "Batch 0 Number of embeddings: 2000\n", + "Batch 0 Number of embeddings: 2000\n", + "Batch 0 Number of embeddings: 2000\n", + "Batch 0 Number of embeddings: 2000\n" + ] + } + ], "source": [ "# 如果你不想重新计算一遍embedding，请不要运行如下代码\n", - "# from openai.embeddings_utils import get_embeddings\n", "\n", - "# batch_size = 2000\n", + "batch_size = 2000\n", + "\n", + "def get_embeddings(list_of_text, model):\n", + " response = client.embeddings.create(input=list_of_text, model=model)\n", + " return [item.embedding for item in response.data]\n", "\n", - "# @backoff.on_exception(backoff.expo, openai.error.RateLimitError)\n", - "# def get_embeddings_with_backoff(prompts, engine):\n", - "# embeddings = []\n", - "# for i in range(0, len(prompts), batch_size):\n", - "# batch = prompts[i:i+batch_size]\n", - "# embeddings += get_embeddings(list_of_text=batch, engine=engine)\n", - "# return embeddings\n", + "@backoff.on_exception(backoff.expo, openai.RateLimitError)\n", + "def get_embeddings_with_backoff(prompts, model):\n", + " embeddings = []\n", + " for i in range(0, len(prompts), batch_size):\n", + " batch = prompts[i:i+batch_size]\n", + " batch_embeddings = get_embeddings(list_of_text=batch, model=model)\n", + " embeddings += batch_embeddings\n", + " print(f\"Batch {i} Number of embeddings: {len(embeddings)}\")\n", + " return embeddings\n", "\n", - "# # randomly sample 10k rows\n", - "# df_all = df\n", - "# # group prompts into batches of 100\n", - "# prompts = df_all.combined.tolist()\n", - "# prompt_batches = [prompts[i:i+batch_size] for i in range(0, len(prompts), batch_size)]\n", + "# randomly sample 10k rows\n", + "# df_all = df.sample(10000, random_state=42)\n", + "df_all = df\n", + "# group prompts into batches of 100\n", + "prompts = df_all.combined.tolist()\n", + "prompt_batches = [prompts[i:i+batch_size] for i in range(0, len(prompts), batch_size)]\n", "\n", - "# embeddings = []\n", - "# for batch in prompt_batches:\n", - "# batch_embeddings = get_embeddings_with_backoff(prompts=batch, engine=embedding_model)\n", - "# embeddings += batch_embeddings\n", + "embeddings = []\n", + "for batch in prompt_batches:\n", + " batch_embeddings = get_embeddings_with_backoff(prompts=batch, model=embedding_model)\n", + " embeddings += batch_embeddings\n", "\n", - "# df_all[\"embedding\"] = embeddings\n", - "# df_all.to_parquet(\"data/toutiao_cat_data_all_with_embeddings.parquet\", index=False)" + "df_all[\"embedding\"] = embeddings\n", + "df_all.to_parquet(os.environ.get(\"JUPYTER_HOME\") + \"/data/toutiao_cat_data_all_with_embeddings.parquet\", index=False)" ] }, { @@ -197,7 +200,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -206,25 +209,25 @@ "text": [ " precision recall f1-score support\n", "\n", - " news_agriculture 0.83 0.85 0.84 495\n", - " news_car 0.88 0.94 0.91 895\n", - " news_culture 0.86 0.77 0.81 741\n", - " news_edu 0.86 0.89 0.87 708\n", + " news_agriculture 0.82 0.86 0.84 495\n", + " news_car 0.89 0.94 0.91 895\n", + " news_culture 0.87 0.76 0.81 741\n", + " news_edu 0.86 0.89 0.88 708\n", "news_entertainment 0.71 0.92 0.80 1051\n", - " news_finance 0.80 0.76 0.78 735\n", - " news_game 0.90 0.81 0.86 742\n", - " news_house 0.91 0.87 0.89 450\n", - " news_military 0.88 0.82 0.85 688\n", + " news_finance 0.81 0.76 0.78 735\n", + " news_game 0.91 0.83 0.87 742\n", + " news_house 0.91 0.86 0.89 450\n", + " news_military 0.89 0.83 0.86 688\n", " news_sports 0.90 0.92 0.91 968\n", - " news_story 0.94 0.47 0.62 197\n", - " news_tech 0.81 0.85 0.83 1052\n", + " news_story 0.94 0.46 0.61 197\n", + " news_tech 0.81 0.86 0.83 1052\n", " news_travel 0.80 0.75 0.77 599\n", " news_world 0.82 0.72 0.77 671\n", " stock 0.00 0.00 0.00 8\n", "\n", " accuracy 0.84 10000\n", - " macro avg 0.79 0.76 0.77 10000\n", - " weighted avg 0.84 0.84 0.83 10000\n", + " macro avg 0.80 0.76 0.77 10000\n", + " weighted avg 0.84 0.84 0.84 10000\n", "\n" ] }, @@ -232,11 +235,11 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/xuwenhao/miniconda3/envs/geektime/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/geektime/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1471: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n", - "/Users/xuwenhao/miniconda3/envs/geektime/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/geektime/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1471: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n", - "/Users/xuwenhao/miniconda3/envs/geektime/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/geektime/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1471: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n" ] } @@ -246,7 +249,7 @@ "from sklearn.model_selection import train_test_split\n", "from sklearn.metrics import classification_report, accuracy_score\n", "\n", - "training_data = pd.read_parquet(\"data/toutiao_cat_data_all_with_embeddings.parquet\")\n", + "training_data = pd.read_parquet(os.environ.get(\"JUPYTER_HOME\") + \"/data/toutiao_cat_data_all_with_embeddings.parquet\")\n", "\n", "df = training_data.sample(50000, random_state=42)\n", "\n", @@ -265,14 +268,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/xuwenhao/miniconda3/envs/geektime/lib/python3.10/site-packages/sklearn/linear_model/_logistic.py:458: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/geektime/lib/python3.10/site-packages/sklearn/linear_model/_logistic.py:460: ConvergenceWarning: lbfgs failed to converge (status=1):\n", "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", "\n", "Increase the number of iterations (max_iter) or scale the data as shown in:\n", @@ -280,9 +283,7 @@ "Please also refer to the documentation for alternative solver options:\n", " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", " n_iter_i = _check_optimize_result(\n", - "/Users/xuwenhao/miniconda3/envs/geektime/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", - "/Users/xuwenhao/miniconda3/envs/geektime/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/geektime/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1471: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n" ] }, @@ -294,7 +295,7 @@ "\n", " news_agriculture 0.85 0.88 0.87 3908\n", " news_car 0.92 0.92 0.92 7101\n", - " news_culture 0.82 0.84 0.83 5719\n", + " news_culture 0.82 0.85 0.83 5719\n", " news_edu 0.88 0.89 0.89 5376\n", "news_entertainment 0.85 0.88 0.86 7908\n", " news_finance 0.82 0.78 0.80 5409\n", @@ -303,7 +304,7 @@ " news_military 0.86 0.82 0.84 4976\n", " news_sports 0.93 0.93 0.93 7611\n", " news_story 0.83 0.81 0.82 1308\n", - " news_tech 0.84 0.85 0.85 8168\n", + " news_tech 0.84 0.86 0.85 8168\n", " news_travel 0.80 0.79 0.79 4252\n", " news_world 0.79 0.80 0.80 5370\n", " stock 0.00 0.00 0.00 70\n", @@ -318,7 +319,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/xuwenhao/miniconda3/envs/geektime/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/geektime/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1471: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, msg_start, len(result))\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/geektime/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1471: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n" ] } @@ -365,7 +368,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.10.13" }, "vscode": { "interpreter": { diff --git a/README.md b/README.md index ce33949..1c2d846 100644 --- a/README.md +++ b/README.md @@ -1,11 +1,29 @@ # Geektime AI Course -See https://time.geekbang.org/column/intro/100541001 +[简体中文](README_zh_CN.md) -Jupyter Notebooks for Geektime AI Course +## Preautions -For large data files, you could download through the following information: -链接: https://pan.baidu.com/s/1Cl0eFNLOkQqquf9ls0trEw 提取码: jvr4 +* I am revising the course and notebooks with current OpenAI API +* Old version notebook could be found under tag v0.0.1 + +## Using GPU + +* [Google Colab](https://colab.google) is recommended, could satisfy your CPU usage requiments for the course +* Or you could buy GPU resource through [AutoDL](https://autodl.com/home) + +## Course + +[Purchase Link](https://time.geekbang.org/column/intro/100541001) + +## Large data files + +[Baidu Disks](https://pan.baidu.com/s/1Cl0eFNLOkQqquf9ls0trEw) 提取码: jvr4 + + +## Environment setup + +For old versions ``` conda create -n geektime python=3.10 @@ -13,8 +31,8 @@ conda activate geektime conda env update --file conda-env.yml ``` - Or you could use pip as well ``` pip install -r requirements.txt ``` + diff --git a/README_zh_CN.md b/README_zh_CN.md new file mode 100644 index 0000000..f08e860 --- /dev/null +++ b/README_zh_CN.md @@ -0,0 +1,41 @@ +# 极客时间「AI大模型之美」 + +[English](README.md) + +## 注意事项 + +* 正在重新根据OpenAI的新版本API修订专栏和对应的Notebook +* 旧版本的Notebook可以在 v0.0.1 这个获取到 + +## 使用 GPU + +* 推荐使用/购买 [Google Colab](https://colab.google)，可以满足主要的GPU使用需求 +* 或者购买 [AutoDL](https://autodl.com/home) + +## 专栏 + +[「AI大模型之美」购买链接](https://time.geekbang.org/column/intro/100541001) + +## 数据文件下载网盘地址 + +部分代码依赖一些大的数据文件或者模型文件，可以通过如下的百度网盘地址下载 + +[百度网盘](https://pan.baidu.com/s/1Cl0eFNLOkQqquf9ls0trEw) 提取码: jvr4 + + +## 环境搭建 + +旧版本的环境搭建方式如下 + +使用Conda +``` +conda create -n geektime python=3.10 +conda activate geektime +conda env update --file conda-env.yml +``` + +使用Pip +``` +pip install -r requirements.txt +``` + diff --git a/requirements-gpu.txt b/requirements-gpu.txt new file mode 100644 index 0000000..0d005c9 --- /dev/null +++ b/requirements-gpu.txt @@ -0,0 +1,4 @@ +transformers +pytorch +torchvision +sentencepiece \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 5b2b8b6..c90d85e 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,190 +1,11 @@ -aiofiles @ file:///C:/ci/aiofiles_1621287809877/work -aiohttp @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_690hlorvpy/croot/aiohttp_1670009554132/work -aiosignal @ file:///tmp/build/80754af9/aiosignal_1637843061372/work -altair @ file:///home/conda/feedstock_root/build_artifacts/altair_1675180856922/work -anyio @ file:///opt/concourse/worker/volumes/live/eb44598f-565b-45e7-4c50-c1ae70306e18/volume/anyio_1644481722202/work/dist -appdirs==1.4.4 -appnope @ file:///Users/builder/ci_310/appnope_1642500616005/work -argon2-cffi @ file:///opt/conda/conda-bld/argon2-cffi_1645000214183/work -argon2-cffi-bindings @ file:///opt/concourse/worker/volumes/live/cf502f86-3f51-4f85-686b-4867f6d672bd/volume/argon2-cffi-bindings_1644569704808/work -asttokens @ file:///opt/conda/conda-bld/asttokens_1646925590279/work -async-timeout @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_732x52axrd/croots/recipe/async-timeout_1664876366763/work -attrs @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_33k1uces4n/croot/attrs_1668696162258/work -Babel @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_59c7q3smap/croot/babel_1671781946809/work -backcall @ file:///home/ktietz/src/ci/backcall_1611930011877/work -backoff @ file:///home/conda/feedstock_root/build_artifacts/backoff_1665004764738/work -beautifulsoup4 @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_croot-cdiouih5/beautifulsoup4_1650462164803/work -bleach @ file:///opt/conda/conda-bld/bleach_1641577558959/work -Bottleneck @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_29949159-f86f-474b-bc1f-aaa1e0e222b4ofusifik/croots/recipe/bottleneck_1657175564045/work -brotlipy==0.7.0 -certifi @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_477u68wvzm/croot/certifi_1671487773341/work/certifi -cffi @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_1b0qzba5nr/croot/cffi_1670423213150/work -charset-normalizer @ file:///tmp/build/80754af9/charset-normalizer_1630003229654/work -click @ file:///opt/concourse/worker/volumes/live/2d66025a-4d79-47c4-43be-6220928b6c82/volume/click_1646056610594/work -colorama @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_f5t80kwp9l/croot/colorama_1672386533201/work -comm @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_0b9r9i3b7k/croot/comm_1671231125581/work -contourpy @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_17gskqgptz/croots/recipe/contourpy_1663827415320/work -cpm-kernels==1.0.11 -cryptography @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_19cvzxmeb9/croot/cryptography_1677533085498/work -cycler @ file:///tmp/build/80754af9/cycler_1637851556182/work -daal4py==2023.0.2 -dataclasses-json==0.5.7 -debugpy @ file:///Users/builder/ci_310/debugpy_1642501698574/work -decorator @ file:///opt/conda/conda-bld/decorator_1643638310831/work -defusedxml @ file:///tmp/build/80754af9/defusedxml_1615228127516/work -docker-pycreds @ file:///Users/ktietz/demo/mc3/conda-bld/docker-pycreds_1630654474270/work -entrypoints @ file:///opt/concourse/worker/volumes/live/5eb4850e-dcbc-41ad-5f22-922bac778f70/volume/entrypoints_1649926457041/work -et-xmlfile==1.1.0 -executing @ file:///opt/conda/conda-bld/executing_1646925071911/work -faiss==1.7.2 -fastapi @ file:///home/conda/feedstock_root/build_artifacts/fastapi_1679196090342/work -fastjsonschema @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_b5c1gee32t/croots/recipe/python-fastjsonschema_1661368622875/work -ffmpy @ file:///home/conda/feedstock_root/build_artifacts/ffmpy_1659474992694/work -filelock @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_f29yrmlw9_/croot/filelock_1672387130651/work -flit_core @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_9elg0qmmha/croot/flit-core_1679397106218/work/source/flit_core -fonttools==4.25.0 -frozenlist @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_5eiq5594pj/croot/frozenlist_1670004516635/work -fsspec @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_d9zxascxg8/croot/fsspec_1679418997424/work -future @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_27i98bxita/croot/future_1677599886956/work -gensim @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_97o5eolfwi/croot/gensim_1674852444908/work -gitdb @ file:///tmp/build/80754af9/gitdb_1617117951232/work -GitPython @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_844theeehu/croot/gitpython_1674662784289/work -gradio @ file:///home/conda/feedstock_root/build_artifacts/gradio_1679252812835/work -greenlet==2.0.2 -h11 @ file:///tmp/build/80754af9/h11_1620423447028/work -h2 @ file:///Users/builder/ci_310/h2_1642510373093/work -hpack==4.0.0 -httpcore @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_c54vcq42mp/croots/recipe/httpcore_1659344175052/work -httpx @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_19ydeiz3u_/croots/recipe/httpx_1659460918370/work -huggingface-hub @ file:///home/conda/feedstock_root/build_artifacts/huggingface_hub_1679329705182/work -hyperframe==6.0.1 -icetk==0.0.7 -idna @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_00jf0h4zbt/croot/idna_1666125573348/work -importlib-metadata @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_81_20mq0d8/croot/importlib-metadata_1678997090664/work -iniconfig @ file:///home/linux1/recipes/ci/iniconfig_1610983019677/work -ipykernel @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_4dybncc18w/croot/ipykernel_1671488388285/work -ipython @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_5d1j6t_z43/croot/ipython_1676584167910/work -ipython-genutils @ file:///tmp/build/80754af9/ipython_genutils_1606773439826/work -ipywidgets @ file:///home/conda/feedstock_root/build_artifacts/ipywidgets_1671720089366/work -jedi @ file:///opt/concourse/worker/volumes/live/18b71546-5bde-4add-72d1-7d16b76f0f7a/volume/jedi_1644315243726/work -Jinja2 @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_6adj7x0ejx/croot/jinja2_1666908137966/work -joblib @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_955tow_ysb/croot/joblib_1666298851241/work -json5 @ file:///tmp/build/80754af9/json5_1624432770122/work -jsonschema @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_21cqeq1xnk/croot/jsonschema_1676558686956/work -jupyter-server @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_031akrjssy/croot/jupyter_server_1671707631142/work -jupyter_client @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_5e4bbpqn9e/croot/jupyter_client_1680171866753/work -jupyter_core @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_b82fz_h369/croot/jupyter_core_1679906581737/work -jupyterlab @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_a52a346vyc/croot/jupyterlab_1675354129045/work -jupyterlab-pygments @ file:///tmp/build/80754af9/jupyterlab_pygments_1601490720602/work -jupyterlab-widgets @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_9btffb27id/croot/jupyterlab_widgets_1679055288818/work -jupyterlab_server @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_d7j_et_d0u/croot/jupyterlab_server_1679906304141/work -kiwisolver @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_e26jwrjf6j/croot/kiwisolver_1672387151391/work -langchain==0.0.129 -linkify-it-py @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_2aumoff133/croots/recipe/linkify-it-py_1659783367051/work -llama-index==0.5.4 -lxml @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_cccmd60j4n/croot/lxml_1679646460589/work -markdown-it-py @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_96i9k07xnz/croots/recipe/markdown-it-py_1659718717910/work -MarkupSafe @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_d4a9444f-bd4c-4043-b47d-cede33979b0fve7bm42r/croots/recipe/markupsafe_1654597878200/work -marshmallow==3.19.0 -marshmallow-enum==1.5.1 -matplotlib @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_41fhwn4tj9/croot/matplotlib-suite_1679593479845/work -matplotlib-inline @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_9ddl71oqte/croots/recipe/matplotlib-inline_1662014471815/work -mdit-py-plugins @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_58unnssimt/croots/recipe/mdit-py-plugins_1659721250303/work -mdurl @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_4dai2ev8x3/croots/recipe/mdurl_1659716031002/work -mistune @ file:///Users/builder/ci_310/mistune_1642534169737/work -multidict @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_81upqwhecp/croot/multidict_1665674236996/work -munkres==1.1.4 -mypy-extensions==1.0.0 -nbclassic @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_9cfvk28pc0/croot/nbclassic_1680008782896/work -nbclient @ file:///opt/concourse/worker/volumes/live/7d38d6af-a5d4-4a2f-68ef-fc787e52a70c/volume/nbclient_1650308404062/work -nbconvert @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_8fyzuglni_/croot/nbconvert_1668450649428/work -nbformat @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_2daun1fill/croot/nbformat_1670352339504/work -nest-asyncio @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_64pfm74mxq/croot/nest-asyncio_1672387129786/work -notebook @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_b6ev7dv2qh/croot/notebook_1680012009653/work -notebook_shim @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_e9s6zsmlb7/croot/notebook-shim_1668160584892/work -numexpr @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_cef3ah6r8w/croot/numexpr_1668713880672/work -numpy @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_8cgikbzvtd/croot/numpy_and_numpy_base_1672336184666/work -openai @ file:///home/conda/feedstock_root/build_artifacts/openai_1678675464569/work -openpyxl==3.0.10 -orjson @ file:///var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_b9drze_kg4/croot/orjson_1668611820381/work/target/wheels/orjson-3.7.8-cp310-cp310-macosx_10_9_x86_64.whl -packaging @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_c3zlhpboab/croot/packaging_1678965318579/work -pandas==1.5.3 -pandas-stubs @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_9bmckx_i9z/croot/pandas-stubs_1676319803117/work -pandocfilters @ file:///opt/conda/conda-bld/pandocfilters_1643405455980/work -parso @ file:///opt/conda/conda-bld/parso_1641458642106/work -pathtools @ file:///Users/ktietz/demo/mc3/conda-bld/pathtools_1629713893697/work -pexpect @ file:///tmp/build/80754af9/pexpect_1605563209008/work -pickleshare @ file:///tmp/build/80754af9/pickleshare_1606932040724/work -Pillow==9.4.0 -platformdirs @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_7fs8_2xgrm/croots/recipe/platformdirs_1662711383474/work -plotly @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_b7601a7c-071f-4424-ad46-f00f32c1766ccwgx0ywh/croots/recipe/plotly_1658160061089/work -pluggy @ file:///opt/concourse/worker/volumes/live/8277900c-164a-49c8-6f2a-f55c3c0154be/volume/pluggy_1648042581708/work -pooch @ file:///tmp/build/80754af9/pooch_1623324770023/work -prometheus-client @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_19kjbndib7/croots/recipe/prometheus_client_1659455105394/work -prompt-toolkit @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_82emz7mook/croot/prompt-toolkit_1672387300396/work -protobuf==3.18.3 -psutil @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_c9b604bf-685f-47f6-8304-238e4e70557e1o7mmsot/croots/recipe/psutil_1656431274701/work -ptyprocess @ file:///tmp/build/80754af9/ptyprocess_1609355006118/work/dist/ptyprocess-0.7.0-py2.py3-none-any.whl -pure-eval @ file:///opt/conda/conda-bld/pure_eval_1646925070566/work -py @ file:///opt/conda/conda-bld/py_1644396412707/work -pycparser @ file:///tmp/build/80754af9/pycparser_1636541352034/work -pydantic @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_90fvnva4_f/croot/pydantic_1667416137634/work -pydub @ file:///home/conda/feedstock_root/build_artifacts/pydub_1615612442567/work -Pygments @ file:///opt/conda/conda-bld/pygments_1644249106324/work -pyOpenSSL @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_6dweji2whw/croot/pyopenssl_1677607689781/work -pyparsing @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_3a17y2delq/croots/recipe/pyparsing_1661452538853/work -pyrsistent @ file:///Users/builder/ci_310/pyrsistent_1642541562041/work -PySocks @ file:///Users/builder/ci_310/pysocks_1642536366386/work -pytest==7.1.2 -python-dateutil @ file:///tmp/build/80754af9/python-dateutil_1626374649649/work -python-multipart @ file:///home/conda/feedstock_root/build_artifacts/python-multipart_1679167423335/work -pytz @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_ddzpsmm2_f/croot/pytz_1671697430473/work -PyYAML @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_79xo15pf1i/croot/pyyaml_1670514753622/work -pyzmq @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_15f7a459-ad98-422b-b8da-cbf1f626e2115nt0ocwy/croots/recipe/pyzmq_1657724193704/work -regex @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_978efa21-43f5-4f43-9f25-acd8393817ddce2xcjaf/croots/recipe/regex_1658257186496/work -requests @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_b9lic17gbj/croot/requests_1678709739389/work -rfc3986 @ file:///Users/ktietz/demo/mc3/conda-bld/rfc3986_1629478296451/work -scikit-learn @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_a65wfgtmmc/croot/scikit-learn_1676911655056/work -scikit-learn-intelex==20230131.200242 -scipy==1.10.0 -semantic-version @ file:///tmp/build/80754af9/semantic_version_1613321057691/work -Send2Trash @ file:///tmp/build/80754af9/send2trash_1632406701022/work -sentencepiece==0.1.95 -sentry-sdk @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_7eq20obptv/croots/recipe/sentry-sdk_1659784546221/work -setproctitle @ file:///Users/builder/ci_310/setproctitle_1642537446063/work -six @ file:///tmp/build/80754af9/six_1644875935023/work -smart-open @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_27148096-9ddc-448c-830e-fb4829d46f5dwl2am402/croots/recipe/smart_open_1651563554983/work -smmap @ file:///tmp/build/80754af9/smmap_1611694433573/work -sniffio @ file:///Users/builder/ci_310/sniffio_1642537651147/work -soupsieve @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_14fb2zs6e3/croot/soupsieve_1666296397588/work -SQLAlchemy==1.4.47 -stack-data @ file:///opt/conda/conda-bld/stack_data_1646927590127/work -starlette @ file:///home/conda/feedstock_root/build_artifacts/starlette-recipe_1678817698143/work -tenacity==8.2.2 -terminado @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_18_p3gbeio/croot/terminado_1671751835656/work -threadpoolctl @ file:///Users/ktietz/demo/mc3/conda-bld/threadpoolctl_1629802263681/work -tiktoken @ file:///Users/runner/miniforge3/conda-bld/tiktoken_1679079880442/work -tinycss2 @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_56dshjmms6/croot/tinycss2_1668168824483/work -tokenizers==0.13.2 -tomli @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_90762ba4-f339-47e8-bd29-416854a59b233d27hku_/croots/recipe/tomli_1657175507767/work -toolz @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_a7gkswah88/croot/toolz_1667464082910/work -torch==1.12.1 -torchvision @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_b64c8kdd72/croot/torchvision_1670313553427/work -tornado @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_1fimz6o0gc/croots/recipe/tornado_1662061695695/work -tqdm @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_03acd6t6ca/croot/tqdm_1679561866522/work -traitlets @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_0dtilxc0bw/croot/traitlets_1671143889152/work -transformers==4.27.4 -types-pytz @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_37mesw_xfu/croot/types-pytz_1665514246317/work -typing-inspect==0.8.0 -typing_extensions @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_4b7xacf029/croot/typing_extensions_1669923792404/work -uc-micro-py @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_a756qk1wsv/croots/recipe/uc-micro-py_1659769413242/work -urllib3 @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_61c6ppfd7m/croot/urllib3_1680254700568/work -uvicorn @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_d80hhx7s7h/croot/uvicorn-split_1678090080474/work -wandb @ file:///home/conda/feedstock_root/build_artifacts/wandb_1678843302744/work -wcwidth @ file:///Users/ktietz/demo/mc3/conda-bld/wcwidth_1629357192024/work -webencodings==0.5.1 -websocket-client @ file:///Users/builder/ci_310/websocket-client_1642513572726/work -websockets @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_c5bbxxm8rk/croot/websockets_1678966795781/work -widgetsnbextension @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_8feupjw2ld/croot/widgetsnbextension_1679313870305/work -yarl @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_d8a27nidjc/croots/recipe/yarl_1661437080982/work -zipp @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_b71z79bye2/croot/zipp_1672387125902/work +backoff==2.2.1 +ipywidgets==8.1.1 +jupyterlab==4.0.9 +langchain==0.0.352 +llama-index==0.9.21 +matplotlib==3.8.2 +openai==1.6.1 +pandas==2.1.4 +pyarrow==14.0.2 +pytest==7.4.3 +scikit-learn==1.3.2 \ No newline at end of file