diff --git a/examples/multimodal/knowledgegpt_wiki_controlnet_tutorial.ipynb b/examples/multimodal/knowledgegpt_wiki_controlnet_tutorial.ipynb new file mode 100644 index 0000000..bd4f376 --- /dev/null +++ b/examples/multimodal/knowledgegpt_wiki_controlnet_tutorial.ipynb @@ -0,0 +1,2038 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "4dS8S7RcH-9q" + }, + "source": [ + "### Using Large Language Models and Wikipedia to Create Educated Prompts for Control Net\n", + "Hello everyone, in this notebook you'll see how can you utilize online information sources with little code to extract quality knowledge to control your diffusion prompts.\n", + "\n", + "We'll use our package [knowledgegpt](https://github.com/geeks-of-data/knowledge-gpt) and [this](https://huggingface.co/docs/diffusers/main/en/api/pipelines/stable_diffusion/controlnet) control net tutorial from huggingface in this notebook." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ixRGGD5WJbcf" + }, + "source": [ + "### Extract links for a particular topic.\n", + "Use the cell below to search on a particular topic." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "TA6Dq_0gwyN-" + }, + "outputs": [], + "source": [ + "import requests\n", + "from bs4 import BeautifulSoup\n", + "\n", + "query = 'Baroque Painting'\n", + "endpoint = 'https://en.wikipedia.org/w/api.php?action=query&format=json&list=search&srsearch={}&utf8='.format(query)\n", + "\n", + "response = requests.get(endpoint).json()\n", + "\n", + "search_results = response['query']['search']\n", + "\n", + "titles = [result['title'] for result in search_results]\n", + "links = ['https://en.wikipedia.org/wiki/{}'.format(result['title'].replace(' ', '_')) for result in search_results]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8dWj1bSbxSKl", + "outputId": "9812cbcd-b2ab-40e7-a59b-bf64ec206093" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['https://en.wikipedia.org/wiki/Baroque_painting',\n", + " 'https://en.wikipedia.org/wiki/Flemish_Baroque_painting',\n", + " 'https://en.wikipedia.org/wiki/Baroque',\n", + " 'https://en.wikipedia.org/wiki/Spanish_Baroque_painting',\n", + " 'https://en.wikipedia.org/wiki/Neo-Baroque',\n", + " 'https://en.wikipedia.org/wiki/Flemish_painting',\n", + " 'https://en.wikipedia.org/wiki/Dutch_Golden_Age_painting',\n", + " 'https://en.wikipedia.org/wiki/Italian_Baroque_art',\n", + " 'https://en.wikipedia.org/wiki/Illusionistic_ceiling_painting',\n", + " 'https://en.wikipedia.org/wiki/Venetian_painting']" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "links" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WzaeOmGyJlpk" + }, + "source": [ + "### Install knowledgegpt and make imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "I8XGnOlyxp-k" + }, + "outputs": [], + "source": [ + "!pip install knowledgegpt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "JB10Vm-qyCOM", + "outputId": "326b1432-b062-4f3d-d9b0-7933686fe590" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.9/dist-packages/torch/cuda/__init__.py:497: UserWarning: Can't initialize NVML\n", + " warnings.warn(\"Can't initialize NVML\")\n" + ] + } + ], + "source": [ + "from knowledgegpt.utils.utils_scrape import scrape_content" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "d0nO0q3Iyc_m" + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "df_all = pd.DataFrame()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AQhswbDkJqYQ" + }, + "source": [ + "### Create a DF with the page content, our package will use this final DF to create a knowledge base." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RuesMR0ZynH0", + "outputId": "d4df41a7-ef21-4500-9ee3-ddc745aa7a77" + }, + "outputs": [], + "source": [ + "for link in links:\n", + " df = scrape_content(link)\n", + " df_all = df_all.append(df)\n", + "\n", + "df_all = df_all.reset_index()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GyHWCVnCyzmz", + "outputId": "e9b62aa8-5c75-42b5-ad69-d8de6be2c809" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 1187 entries, 0 to 1186\n", + "Data columns (total 2 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 index 1187 non-null int64 \n", + " 1 content 1187 non-null object\n", + "dtypes: int64(1), object(1)\n", + "memory usage: 18.7+ KB\n" + ] + } + ], + "source": [ + "df_all.info()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "j7Z2sZ8DJzBK" + }, + "source": [ + "### Create a file called config.py and put your OpenAI Secret Key inside, name it SECRET_KEY" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "p6AP3_8C0V_6" + }, + "outputs": [], + "source": [ + "import openai\n", + "from config import SECRET_KEY\n", + "openai.api_key = SECRET_KEY" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "GvsSeVFlz2fR" + }, + "outputs": [], + "source": [ + "from knowledgegpt.extractors.base_extractor import BaseExtractor\n", + "basic_extractor = BaseExtractor(dataframe=df_all, embedding_extractor=\"hf\", model_lang=\"en\", is_turbo=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FbxmrXpVJ9t6" + }, + "source": [ + "### We create our embedding with this prompt below, it'll index the most relevant text until the number specified as max_tokens is reached." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "wBqwkywOzrwh", + "outputId": "dafc5af7-fef6-4f21-da09-45cd54b10c9b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing embeddings...\n", + "model_lang en\n", + "Selected 26 document sections:\n", + "0\n", + "11\n", + "912\n", + "913\n", + "544\n", + "574\n", + "270\n", + "921\n", + "893\n", + "43\n", + "594\n", + "119\n", + "250\n", + "198\n", + "62\n", + "914\n", + "471\n", + "658\n", + "604\n", + "605\n", + "56\n", + "620\n", + "195\n", + "178\n", + "372\n", + "271\n", + "Answer the question as truthfully as possible using the provided context, and if the answer is not contained within the text below, say \"I don't know.\"\n", + "\n", + "Context:\n", + "\n", + "* Baroque painting - Wikipedia\n", + "* Baroque painting\n", + "* 2The emergence of Italian baroque painting\n", + "* 3Italian High Baroque painting\n", + "* Spanish Baroque painting - Wikipedia\n", + "* Spanish Baroque painting\n", + "* Artistic style in Europe and colonies, c. 1600–1750 For other uses, see Baroque (disambiguation).\n", + "* Italian Baroque art\n", + "* Italian Baroque art - Wikipedia\n", + "* See alsoEdit Baroque illusionistic painting History of painting Western painting Rococo PaintingReferencesEdit\n", + "* Style of painting\n", + "* Flemish Baroque painting\n", + "* Baroque\n", + "* Baroque - Wikipedia\n", + "* Flemish Baroque painting - Wikipedia\n", + "* 4Later Italian Baroque painting\n", + "* ^ \"Elements of the Baroque Style.\" In Arts and Humanities Through the Eras, edited by Edward I. Bleiberg, James Allan Evans, Kristen Mossler Figg, Philip M. Soergel, and John Block Friedman, 466–470. Vol. 5, The Age of the Baroque and Enlightenment 1600–1800. Detroit, MI: Gale, 2005.\n", + "* Neo-Baroque music Neo-Baroque painting Baroque Revival architecture Neo-Baroque film Topics referred to by the same term\n", + "* See also[edit] Spanish art Baroque painting Spanish Golden Age Spanish Renaissance Spanish Baroque architecture Spanish Baroque literature References[edit]\n", + "* ^ Alfonso E. Pérez Sánchez, Pintura barroca en España (1600–1750), Madrid, Cátedra, 1992, ISBN 84-376-0994-1. Regarding 18th century Spanish baroque painting, discussing artists such as Antonio Palomino, Miguel Jacinto Meléndez and the Catalan painter Antoni Viladomat. See pages 403–431.\n", + "* Retrieved from \"https://en.wikipedia.org/w/index.php?title=Baroque_painting&oldid=1126479439\"\n", + "* Retrieved from \"https://en.wikipedia.org/w/index.php?title=Spanish_Baroque_painting&oldid=1125623892\" Categories: Spanish Golden AgeBaroque artBaroque paintingSpanish RenaissanceSpanish Baroque17th century in Spain18th century in SpainRenaissance artRenaissance literatureEarly Modern history of SpainHidden categories: Articles with short descriptionShort description matches WikidataUse dmy dates from September 2021\n", + "* Retrieved from \"https://en.wikipedia.org/w/index.php?title=Flemish_Baroque_painting&oldid=1144718526\" Categories: Flemish Baroque paintersBaroque paintingFlemish artNetherlandish Baroque art16th century in the Habsburg NetherlandsWestern art17th century in the Habsburg NetherlandsFlemish Baroque artHidden categories: Articles with short descriptionShort description matches WikidataCommons category link from Wikidata\n", + "* ^ Haskell, Francis (1993). \"Chapter 8\". Patrons and Painters: Art and Society in Baroque Italy. Yale University Press, pp. 132–134.\n", + "* ^ a b \"BAROQUE : Etymologie de BAROQUE\". www.cnrtl.fr. Retrieved 4 January 2019.\n", + "* The BaroqueTop: Venus and Adonis by Peter Paul Rubens (1635–1640); centre: The Ecstasy of Saint Teresa by Bernini (1651); bottom: the Palace of Versailles in France (c.1660–1715)Years active17th–18th centuries The Baroque (UK: /bəˈrɒk/, US: /bəˈroʊk/; French: [baʁɔk]) is a style of architecture, music, dance, painting, sculpture, poetry, and other arts that flourished in Europe from the early 17th century until the 1750s.[1] In the territories of the Spanish and Portuguese empires including the Iberian Peninsula it continued, together with new styles, until the first decade of the 19th century. It followed Renaissance art and Mannerism and preceded the Rococo (in the past often referred to as \"late Baroque\") and Neoclassical styles. It was encouraged by the Catholic Church as a means to counter the simplicity and austerity of Protestant architecture, art, and music, though Lutheran Baroque art developed in parts of Europe as well.[2] The Baroque style used contrast, movement, exuberant detail, deep colour, grandeur, and surprise to achieve a sense of awe. The style began at the start of the 17th century in Rome, then spread rapidly to France, northern Italy, Spain, and Portugal, then to Austria, southern Germany, and Poland. By the 1730s, it had evolved into an even more flamboyant style, called rocaille or Rococo, which appeared in France and Central Europe until the mid to late 18th century. In the decorative arts, the style employs plentiful and intricate ornamentation. The departure from Renaissance classicism has its own ways in each country. But a general feature is that everywhere the starting point is the ornamental elements introduced by the Renaissance. The classical repertoire is crowded, dense, overlapping, loaded, in order to provoke shock effects. New motifs introduced by Baroque are: the cartouche, trophies and weapons, baskets of fruit or flowers, and others, made in marquetry, stucco, or carved.[3]\n", + "\n", + " Q: What are main baroque era painting styles?\n", + " A:\n", + "all_done!\n" + ] + } + ], + "source": [ + "answer, prompt, messages = basic_extractor.extract(\"What are main baroque era painting styles?\", max_tokens=2000)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "amjuhWWJKJld" + }, + "source": [ + "### Explain and Get Results\n", + "Parts below is a bit trickier because ChatGPT doesn't really know about control net, so we first describe what it is, how to prompt and how to inject the information we have about the topic inside a proper control net prompt." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 53 + }, + "id": "00cUfzjCy2B8", + "outputId": "ed6d2736-7410-430c-b565-ae426be7aeaf" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'The main Baroque era painting styles include Italian Baroque painting, Spanish Baroque painting, Flemish Baroque painting, and later Italian Baroque painting. These styles are characterized by their use of contrast, movement, exuberant detail, deep color, grandeur, and surprise to achieve a sense of awe.'" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "answer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "gWiNPzS03Oxa", + "outputId": "80524f26-f358-49ae-ee66-b0ed6f8357f2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Based on what you have in context describe baroque era painting styles to be used in control net\n", + "all_done!\n" + ] + } + ], + "source": [ + "answer, prompt, messages = basic_extractor.extract(\"Based on what you have in context describe baroque era painting styles to be used in control net\", max_tokens=2000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "76iD5oEg3ea1", + "outputId": "a1365973-efea-4a41-936e-158c61b3bdfa" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'I\\'m sorry, but I\\'m not sure what you mean by \"control net.\" Could you please provide more context or clarify your question?'" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "answer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "mt9SkDRO3frY", + "outputId": "f96b5b6b-ae89-45b9-e388-403a7a3a1a48" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Based on what you have in context describe baroque era painting styles to be used in control net, control net is used for providing additional control to large diffusion models, it's a text based control and requires to give text instruction like; disco dancer with colorful lights\n", + "all_done!\n" + ] + } + ], + "source": [ + "answer, prompt, messages = basic_extractor.extract(\"Based on what you have in context describe baroque era painting styles to be used in control net, control net is used for providing additional control to large diffusion models, it's a text based control and requires to give text instruction like; disco dancer with colorful lights\", max_tokens=2000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 105 + }, + "id": "XLvLx-is3-7r", + "outputId": "58469dfa-494f-4eb0-e33e-4281407de2ac" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'I\\'m sorry, but I\\'m still not sure how Baroque era painting styles would be used in the context of a control net for providing additional control to large diffusion models. The Baroque era painting styles are characterized by their use of contrast, movement, exuberant detail, deep color, grandeur, and surprise to achieve a sense of awe. These styles were used in painting during the Baroque era, which lasted from the early 17th century until the 1750s. \\n\\nIt is unclear how these painting styles would be relevant to a text-based control net used for providing additional control to large diffusion models. The example you provided, \"disco dancer with colorful lights,\" is not related to Baroque era painting styles. Could you please provide more information or context about how Baroque era painting styles would be used in this scenario?'" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "answer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HGJ6-Am_4BCB", + "outputId": "49e32b9a-1f8b-46a8-959d-28846f876ff6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Then you can simply say something like; use contrast, movement, exuberant detail, deep color, grandeur, and surprise in baroque style. You need to convert what you know about baroque charasteristics into a definitive command for control net.\n", + "all_done!\n" + ] + } + ], + "source": [ + "answer, prompt, messages = basic_extractor.extract(\"Then you can simply say something like; use contrast, movement, exuberant detail, deep color, grandeur, and surprise in baroque style. You need to convert what you know about baroque charasteristics into a definitive command for control net.\", max_tokens=2000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 53 + }, + "id": "Ad-2W3Qq4mrs", + "outputId": "437fd2e5-dfa1-4480-8972-58cb8729cb29" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'Sure, here\\'s an example of a command for a control net that incorporates Baroque characteristics:\\n\\n\"Create a visual design that utilizes the Baroque style, incorporating contrast, movement, exuberant detail, deep color, grandeur, and surprise. The design should evoke a sense of awe and wonder, and should be visually striking and memorable.\"'" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "answer" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1mHyDQYjK0E4" + }, + "source": [ + "### Install Diffusers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7GnypWX14o_I", + "outputId": "f918a55a-1e57-4c36-98aa-f76e2a84409d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting diffusers[torch]\n", + " Downloading diffusers-0.14.0-py3-none-any.whl (737 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m737.4/737.4 KB\u001b[0m \u001b[31m27.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: requests in /usr/local/lib/python3.9/dist-packages (from diffusers[torch]) (2.27.1)\n", + "Requirement already satisfied: importlib-metadata in /usr/local/lib/python3.9/dist-packages (from diffusers[torch]) (6.1.0)\n", + "Requirement already satisfied: Pillow in /usr/local/lib/python3.9/dist-packages (from diffusers[torch]) (8.4.0)\n", + "Collecting huggingface-hub>=0.10.0\n", + " Downloading huggingface_hub-0.13.3-py3-none-any.whl (199 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m199.8/199.8 KB\u001b[0m \u001b[31m25.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: filelock in /usr/local/lib/python3.9/dist-packages (from diffusers[torch]) (3.10.1)\n", + "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.9/dist-packages (from diffusers[torch]) (2022.10.31)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.9/dist-packages (from diffusers[torch]) (1.22.4)\n", + "Collecting accelerate>=0.11.0\n", + " Downloading accelerate-0.18.0-py3-none-any.whl (215 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m215.3/215.3 KB\u001b[0m \u001b[31m28.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: torch>=1.4 in /usr/local/lib/python3.9/dist-packages (from diffusers[torch]) (1.13.1+cu116)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.9/dist-packages (from accelerate>=0.11.0->diffusers[torch]) (23.0)\n", + "Requirement already satisfied: psutil in /usr/local/lib/python3.9/dist-packages (from accelerate>=0.11.0->diffusers[torch]) (5.9.4)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.9/dist-packages (from accelerate>=0.11.0->diffusers[torch]) (6.0)\n", + "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.9/dist-packages (from huggingface-hub>=0.10.0->diffusers[torch]) (4.5.0)\n", + "Requirement already satisfied: tqdm>=4.42.1 in /usr/local/lib/python3.9/dist-packages (from huggingface-hub>=0.10.0->diffusers[torch]) (4.65.0)\n", + "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.9/dist-packages (from importlib-metadata->diffusers[torch]) (3.15.0)\n", + "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.9/dist-packages (from requests->diffusers[torch]) (2.0.12)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.9/dist-packages (from requests->diffusers[torch]) (1.26.15)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/dist-packages (from requests->diffusers[torch]) (3.4)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/dist-packages (from requests->diffusers[torch]) (2022.12.7)\n", + "Installing collected packages: huggingface-hub, accelerate, diffusers\n", + "Successfully installed accelerate-0.18.0 diffusers-0.14.0 huggingface-hub-0.13.3\n" + ] + } + ], + "source": [ + "!pip install diffusers[\"torch\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "i37QqGzgK6MC" + }, + "source": [ + "Cell below might require a restrat after first install" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "yPPO94Tp8d5k" + }, + "outputs": [], + "source": [ + "!pip install diffusers transformers git+https://github.com/huggingface/accelerate.git" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "k9YMI6L0K-9f" + }, + "source": [ + "### Import Diffusers and load Our Image\n", + "Image is from my local, just uploaded here via drag&drop" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "gGLh02HZ5Ca1" + }, + "outputs": [], + "source": [ + "from diffusers import StableDiffusionControlNetPipeline\n", + "from diffusers.utils import load_image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "oKNpqP2k5XAF" + }, + "outputs": [], + "source": [ + "image = load_image(\n", + " \"/content/IMG_0839 (2).png\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 634 + }, + "id": "sHD8NGbN6nL6", + "outputId": "2e53aa54-b9d0-4406-9061-ebddf8647feb" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "image" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NVHRsvKxLInm" + }, + "source": [ + "### Image Transformations and Pipeline\n", + "Part below explained in detail in the original tutorial, please see [there.](https://huggingface.co/docs/diffusers/main/en/api/pipelines/stable_diffusion/controlnet)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "MLFeyeMP6oJ4" + }, + "outputs": [], + "source": [ + "import cv2\n", + "from PIL import Image\n", + "import numpy as np\n", + "\n", + "image = np.array(image)\n", + "\n", + "low_threshold = 100\n", + "high_threshold = 200\n", + "\n", + "image = cv2.Canny(image, low_threshold, high_threshold)\n", + "image = image[:, :, None]\n", + "image = np.concatenate([image, image, image], axis=2)\n", + "canny_image = Image.fromarray(image)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 325 + }, + "id": "hAmocRIx61fj", + "outputId": "3cdf4107-7cb9-43f5-fc72-ab75bb67e36d" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "canny_image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 121, + "referenced_widgets": [ + "a11a1757f0d8439bb776ea9224d28fdd", + "fcec96bb8e154b48a68a21dcf6920b45", + "23413d53d6ca4faa9f7bdcfbf839c3d0", + "38814034802e463eb6628fcaa8178d59", + "98eda75f37b14eb4b77e5bdf257a92f8", + "07f8f4a060d74f7aa43f43d7a69213d9", + "a04b1ec8fd3b4854ab41b53be2e94768", + "b81eac73644e4133a52041f1a9b28783", + "0f336e2b08de421b98d05990de7e6c69", + "bfc04bac22904f719e62d4d67633267b", + "b66f464715dc4ca686e3c3779344adab" + ] + }, + "id": "e6siTnz_62ZH", + "outputId": "6fa06a2d-7366-491e-edc0-106b8f7c4daf" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a11a1757f0d8439bb776ea9224d28fdd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Fetching 15 files: 0%| | 0/15 [00:00" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "out_image_normal" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qFTpNom6LibA" + }, + "source": [ + "### Experiments - knowledgegpt aided prompt\n", + "\n", + "With we can now use LLM enchanced prompt to create a better results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 49, + "referenced_widgets": [ + "be507202e8f14307bf2223c185874571", + "308fa5dc5c15443aaa2c8902770dcead", + "b43480c1c4c541af9d4ecd1ca68cc582", + "07678e0fe69940bf98fbd506bc8d5fa7", + "47515066425345638eff494d3bc727b2", + "2a1f900bf6f64d5a8302972c7c697528", + "ae3c229c36314ad38f7f1ce567104d8f", + "62343f991cb94b5e899ff7d81a43181b", + "26f579cb2ef3488ea7fe7e7d4ada8909", + "96d7fbfa8c6542b98806512c6985f125", + "301ace69b05c4728ba287118d0c27a29" + ] + }, + "id": "0eEPeUhb9-aJ", + "outputId": "14d03bb5-2851-41ee-d5df-72309563d308" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "be507202e8f14307bf2223c185874571", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/10 [00:00" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "out_image_knowledge" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1qP6eId6L1SN" + }, + "source": [ + "### Results\n", + "As we can see above, the result with enhanced description is way better in terms of detail and vividness, also another problem with the normal prompt is the NFSW filter was getting triggered too much, I basically wasn't able to use anything more then 10 iterations with that. For enchanced prompt it was possible though, I just tried it with 10 to have a fair comparison." + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "provenance": [] + }, + "gpuClass": "standard", + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "07678e0fe69940bf98fbd506bc8d5fa7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_96d7fbfa8c6542b98806512c6985f125", + "placeholder": "​", + "style": "IPY_MODEL_301ace69b05c4728ba287118d0c27a29", + "value": " 10/10 [00:07<00:00, 1.52it/s]" + } + }, + "07f8f4a060d74f7aa43f43d7a69213d9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0bcdf749876545a69f8b18fd8a8c85df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0ca7efe4963b4912afd9edcb95aa0f97": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0f336e2b08de421b98d05990de7e6c69": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "23413d53d6ca4faa9f7bdcfbf839c3d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b81eac73644e4133a52041f1a9b28783", + "max": 15, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0f336e2b08de421b98d05990de7e6c69", + "value": 15 + } + }, + "26f579cb2ef3488ea7fe7e7d4ada8909": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2a1f900bf6f64d5a8302972c7c697528": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "301ace69b05c4728ba287118d0c27a29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "308fa5dc5c15443aaa2c8902770dcead": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2a1f900bf6f64d5a8302972c7c697528", + "placeholder": "​", + "style": "IPY_MODEL_ae3c229c36314ad38f7f1ce567104d8f", + "value": "100%" + } + }, + "38814034802e463eb6628fcaa8178d59": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bfc04bac22904f719e62d4d67633267b", + "placeholder": "​", + "style": "IPY_MODEL_b66f464715dc4ca686e3c3779344adab", + "value": " 15/15 [00:00<00:00, 826.85it/s]" + } + }, + "3ecf1dbbe41f4a0faea781afebce7864": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "472d62e935f54783ab8cc60905427819": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "47515066425345638eff494d3bc727b2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5198c128da3147c9a54bdfdc36712435": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5c53f18cae364b488575e39daae3fcc9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5198c128da3147c9a54bdfdc36712435", + "max": 10, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0ca7efe4963b4912afd9edcb95aa0f97", + "value": 10 + } + }, + "62343f991cb94b5e899ff7d81a43181b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "759d2feac05e488b8ce14eac9645034f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_77c9fcbb7ece406e9ff71a8c1caa75e9", + "placeholder": "​", + "style": "IPY_MODEL_0bcdf749876545a69f8b18fd8a8c85df", + "value": " 10/10 [00:07<00:00, 1.53it/s]" + } + }, + "77c9fcbb7ece406e9ff71a8c1caa75e9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8c4873f521a344459e4a30ee173936ab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3ecf1dbbe41f4a0faea781afebce7864", + "placeholder": "​", + "style": "IPY_MODEL_ee510e5579fd40618a3110d162ec5b54", + "value": "100%" + } + }, + "96d7fbfa8c6542b98806512c6985f125": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "98eda75f37b14eb4b77e5bdf257a92f8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a04b1ec8fd3b4854ab41b53be2e94768": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a11a1757f0d8439bb776ea9224d28fdd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fcec96bb8e154b48a68a21dcf6920b45", + "IPY_MODEL_23413d53d6ca4faa9f7bdcfbf839c3d0", + "IPY_MODEL_38814034802e463eb6628fcaa8178d59" + ], + "layout": "IPY_MODEL_98eda75f37b14eb4b77e5bdf257a92f8" + } + }, + "a4a179fcdc6d40e1b84f407f0ab3267b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8c4873f521a344459e4a30ee173936ab", + "IPY_MODEL_5c53f18cae364b488575e39daae3fcc9", + "IPY_MODEL_759d2feac05e488b8ce14eac9645034f" + ], + "layout": "IPY_MODEL_472d62e935f54783ab8cc60905427819" + } + }, + "ae3c229c36314ad38f7f1ce567104d8f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b43480c1c4c541af9d4ecd1ca68cc582": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_62343f991cb94b5e899ff7d81a43181b", + "max": 10, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_26f579cb2ef3488ea7fe7e7d4ada8909", + "value": 10 + } + }, + "b66f464715dc4ca686e3c3779344adab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b81eac73644e4133a52041f1a9b28783": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "be507202e8f14307bf2223c185874571": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_308fa5dc5c15443aaa2c8902770dcead", + "IPY_MODEL_b43480c1c4c541af9d4ecd1ca68cc582", + "IPY_MODEL_07678e0fe69940bf98fbd506bc8d5fa7" + ], + "layout": "IPY_MODEL_47515066425345638eff494d3bc727b2" + } + }, + "bfc04bac22904f719e62d4d67633267b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ee510e5579fd40618a3110d162ec5b54": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fcec96bb8e154b48a68a21dcf6920b45": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_07f8f4a060d74f7aa43f43d7a69213d9", + "placeholder": "​", + "style": "IPY_MODEL_a04b1ec8fd3b4854ab41b53be2e94768", + "value": "Fetching 15 files: 100%" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/prompt_template_example.ipynb b/examples/prompt_template_example.ipynb new file mode 100644 index 0000000..f371af5 --- /dev/null +++ b/examples/prompt_template_example.ipynb @@ -0,0 +1,571 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# !python3 -m spacy download en_core_web_sm" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from knowledgegpt.extractors.base_extractor import BaseExtractor\n", + "from knowledgegpt.utils.utils_scrape import scrape_content" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import openai\n", + "from example_config import SECRET_KEY\n", + "openai.api_key = SECRET_KEY" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# # Scrape content from a webpage\n", + "# any other dataframes can be used as well, the only requirement is that the column name is \"content\"\n", + "df = scrape_content(\"https://en.wikipedia.org/wiki/Bombard_(weapon)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
content
0Bombard (weapon) - Wikipedia
1Open main menu
2Home
3Random
4Nearby
5Log in
6Settings
7Donate
8About Wikipedia
9Disclaimers
10Search
11Bombard (weapon)
12Article\\nTalk
13Language
14Watch
15Edit
16The bombard is a type of cannon or mortar whic...
17Contents\\n1 Terminology\\n2 History\\n3 Notable ...
18TerminologyEdit\\nThe term \"bombard\" was first ...
19GalleryEdit
20\"Hand bombard\", 1390–1400
21200 kg wrought iron bombard, circa 1450, Metz,...
22The Dardanelles Gun.
23Mons Meg at Edinburgh Castle, mid-15th century
24Mons Meg cannonballs
25English Bombards abandoned during the Hundred ...
26Bombard from the beginning of the 15th century...
27Early Ming bombard with two pair of trunnions,...
28Acehnese guns including two bombards (closer t...
2915th century bombard mounted on carriage, Warsaw.
30Bombard in its siege position, Denmark.
31A bombard recovered from the well of Cardiff c...
32Wikimedia Commons has media related to Bombard...
33See alsoEdit\\nList of the largest cannons by c...
34^ a b c Sands, Kathleen (1999). \"Though One Of...
35^ Andrade 2016, p. 83.
36^ DeVries 2012, p. 155.
37^ Gwei-Djen, Lu; Needham, Joseph; Chi-Hsing, P...
38^ Aung-Thwin, Michael; Hall, Kenneth (2011). \"...
39^ File:Westgate 076.jpg
40^ \"Reconstruction of Norham Castle Seige by Sc...
41^ W. H. Finlayson. The Scottish Historical Rev...
42^ \"Bodiam Bombard | Kent and Sussex Courier\". ...
43^ Schmidtchen (1977b), pp. 226–228
44ReferencesEdit\\n  This article incorporates te...
45Retrieved from \"https://en.wikipedia.org/w/ind...
46Last edited on 25 February 2023, at 21:41
47Languages
48БеларускаяБеларуская (тарашкевіца)БългарскиCat...
49This page was last edited on 25 February 2023,...
50Privacy policy\\nAbout Wikipedia\\nDisclaimers\\n...
\n", + "
" + ], + "text/plain": [ + " content\n", + "0 Bombard (weapon) - Wikipedia\n", + "1 Open main menu\n", + "2 Home\n", + "3 Random\n", + "4 Nearby\n", + "5 Log in\n", + "6 Settings\n", + "7 Donate\n", + "8 About Wikipedia\n", + "9 Disclaimers\n", + "10 Search\n", + "11 Bombard (weapon)\n", + "12 Article\\nTalk\n", + "13 Language\n", + "14 Watch\n", + "15 Edit\n", + "16 The bombard is a type of cannon or mortar whic...\n", + "17 Contents\\n1 Terminology\\n2 History\\n3 Notable ...\n", + "18 TerminologyEdit\\nThe term \"bombard\" was first ...\n", + "19 GalleryEdit\n", + "20 \"Hand bombard\", 1390–1400\n", + "21 200 kg wrought iron bombard, circa 1450, Metz,...\n", + "22 The Dardanelles Gun.\n", + "23 Mons Meg at Edinburgh Castle, mid-15th century\n", + "24 Mons Meg cannonballs\n", + "25 English Bombards abandoned during the Hundred ...\n", + "26 Bombard from the beginning of the 15th century...\n", + "27 Early Ming bombard with two pair of trunnions,...\n", + "28 Acehnese guns including two bombards (closer t...\n", + "29 15th century bombard mounted on carriage, Warsaw.\n", + "30 Bombard in its siege position, Denmark.\n", + "31 A bombard recovered from the well of Cardiff c...\n", + "32 Wikimedia Commons has media related to Bombard...\n", + "33 See alsoEdit\\nList of the largest cannons by c...\n", + "34 ^ a b c Sands, Kathleen (1999). \"Though One Of...\n", + "35 ^ Andrade 2016, p. 83.\n", + "36 ^ DeVries 2012, p. 155.\n", + "37 ^ Gwei-Djen, Lu; Needham, Joseph; Chi-Hsing, P...\n", + "38 ^ Aung-Thwin, Michael; Hall, Kenneth (2011). \"...\n", + "39 ^ File:Westgate 076.jpg\n", + "40 ^ \"Reconstruction of Norham Castle Seige by Sc...\n", + "41 ^ W. H. Finlayson. The Scottish Historical Rev...\n", + "42 ^ \"Bodiam Bombard | Kent and Sussex Courier\". ...\n", + "43 ^ Schmidtchen (1977b), pp. 226–228\n", + "44 ReferencesEdit\\n  This article incorporates te...\n", + "45 Retrieved from \"https://en.wikipedia.org/w/ind...\n", + "46 Last edited on 25 February 2023, at 21:41\n", + "47 Languages\n", + "48 БеларускаяБеларуская (тарашкевіца)БългарскиCat...\n", + "49 This page was last edited on 25 February 2023,...\n", + "50 Privacy policy\\nAbout Wikipedia\\nDisclaimers\\n..." + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "template = '''\n", + "Test prompt template\n", + "Answer the question as truthfully as possible using the provided context, and if the answer is not contained within the text below, say \"I don't know.\" \n", + "\n", + "Context: \n", + "{sections}\n", + "\n", + "Question: {question}\n", + "Answer:\n", + "'''" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing embeddings...\n", + "model_lang en\n", + "Selected 13 document sections:\n", + "49\n", + "43\n", + "36\n", + "45\n", + "35\n", + "42\n", + "22\n", + "17\n", + "38\n", + "39\n", + "12\n", + "20\n", + "8\n", + "\n", + "Test prompt template\n", + "Answer the question as truthfully as possible using the provided context, and if the answer is not contained within the text below, say \"I don't know.\" \n", + "\n", + "Context: \n", + "\n", + "* This page was last edited on 25 February 2023, at 21:41 (UTC). Content is available under CC BY-SA 3.0 unless otherwise noted.\n", + "* ^ Schmidtchen (1977b), pp. 226–228\n", + "* ^ DeVries 2012, p. 155.\n", + "* Retrieved from \"https://en.wikipedia.org/w/index.php?title=Bombard_(weapon)&oldid=1141599306\"\n", + "* ^ Andrade 2016, p. 83.\n", + "* ^ \"Bodiam Bombard | Kent and Sussex Courier\". Archived from the original on 2015-09-23. Retrieved 2015-04-13.\n", + "* The Dardanelles Gun.\n", + "* Contents 1 Terminology 2 History 3 Notable examples 4 Gallery 5 See also 6 Notes 7 References 8 Further reading\n", + "* ^ Aung-Thwin, Michael; Hall, Kenneth (2011). \"New Perspectives on the History and Historiography of Southeast Asia\": 85. {{cite journal}}: Cite journal requires |journal= (help)\n", + "* ^ File:Westgate 076.jpg\n", + "* Article Talk\n", + "* \"Hand bombard\", 1390–1400\n", + "* About Wikipedia\n", + "\n", + "Question: What is the title of this PDF?\n", + "Answer:\n", + "\n", + "all_done!\n" + ] + } + ], + "source": [ + "basic_extractor = BaseExtractor(dataframe=df, embedding_extractor=\"hf\", model_lang=\"en\", is_turbo=True, prompt_template=template)\n", + "answer, prompt, messages = basic_extractor.extract(\"What is the title of this PDF?\", max_tokens=300)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"I don't know.\"" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "answer" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "What is Bombard?\n", + "all_done!\n" + ] + } + ], + "source": [ + "answer, prompt, messages = basic_extractor.extract(\"What is Bombard?\", max_tokens=300)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Bombard is a weapon.'" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "answer" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'role': 'system', 'content': 'you are a helpful assistant'},\n", + " {'role': 'user',\n", + " 'content': '\\nTest prompt template\\nAnswer the question as truthfully as possible using the provided context, and if the answer is not contained within the text below, say \"I don\\'t know.\" \\n\\nContext: \\n\\n* This page was last edited on 25 February 2023, at 21:41\\xa0(UTC). Content is available under CC BY-SA 3.0 unless otherwise noted.\\n* ^ Schmidtchen (1977b), pp. 226–228\\n* ^ DeVries 2012, p.\\xa0155.\\n* Retrieved from \"https://en.wikipedia.org/w/index.php?title=Bombard_(weapon)&oldid=1141599306\"\\n* ^ Andrade 2016, p.\\xa083.\\n* ^ \"Bodiam Bombard | Kent and Sussex Courier\". Archived from the original on 2015-09-23. Retrieved 2015-04-13.\\n* The Dardanelles Gun.\\n* Contents 1 Terminology 2 History 3 Notable examples 4 Gallery 5 See also 6 Notes 7 References 8 Further reading\\n* ^ Aung-Thwin, Michael; Hall, Kenneth (2011). \"New Perspectives on the History and Historiography of Southeast Asia\": 85. {{cite journal}}: Cite journal requires |journal= (help)\\n* ^ File:Westgate 076.jpg\\n* Article Talk\\n* \"Hand bombard\", 1390–1400\\n* About Wikipedia\\n\\nQuestion: What is the title of this PDF?\\nAnswer:\\n'},\n", + " {'role': 'assistant', 'content': \"I don't know.\"},\n", + " {'role': 'user', 'content': 'What is Bombard?'},\n", + " {'role': 'assistant', 'content': 'Bombard is a weapon.'}]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "messages" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Give me more details\n", + "all_done!\n" + ] + } + ], + "source": [ + "answer, prompt, messages = basic_extractor.extract(\"Give me more details\", max_tokens=300)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'A bombard is a large caliber, muzzle-loading artillery piece primarily used during the early modern period of Europe. This weapon was used to hurl heavy stone balls onto enemy fortifications. The bombard was first developed in the early 14th century and was used until the 17th century. It was a predecessor to the modern cannon.'" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "answer" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "knowledgegpt-env", + "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.9.16" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/knowledgegpt/extractors/base_extractor.py b/knowledgegpt/extractors/base_extractor.py index 0e9af9c..26b307f 100644 --- a/knowledgegpt/extractors/base_extractor.py +++ b/knowledgegpt/extractors/base_extractor.py @@ -5,7 +5,8 @@ class BaseExtractor: def __init__(self, dataframe=None, embedding_extractor="hf", model_lang="en", is_turbo=False, index_type="basic", - verbose=False, index_path=None, is_gpt4=False): + verbose=False, index_path=None, is_gpt4=False, prompt_template=None): + """ :param dataframe: if you have own df use it else choose correct extractor :param embedding_extractor: default hf, openai @@ -29,6 +30,7 @@ def __init__(self, dataframe=None, embedding_extractor="hf", model_lang="en", is self.index_type = index_type self.verbose = verbose self.is_gpt4 = is_gpt4 + self.prompt_template = prompt_template self.messages = [] self.embeddings = None @@ -104,7 +106,8 @@ def extract(self, query, max_tokens, load_index=False) -> tuple[str, str, list]: verbose=self.verbose, messages=self.messages, max_tokens=max_tokens, - index_type=self.index_type + index_type=self.index_type, + prompt_template=self.prompt_template ) if not self.verbose: print("all_done!") diff --git a/knowledgegpt/utils/utils_completion.py b/knowledgegpt/utils/utils_completion.py index b8f821a..2a301ef 100644 --- a/knowledgegpt/utils/utils_completion.py +++ b/knowledgegpt/utils/utils_completion.py @@ -36,7 +36,8 @@ def answer_query_with_context( is_gpt4: bool = False, messages: list = None, index_type: str = "basic", - max_tokens=1000 + max_tokens=1000, + prompt_template=None ) -> str: """ Answer a query using the provided context. @@ -63,7 +64,8 @@ def answer_query_with_context( embedding_type=embedding_type, model_lang=model_lang, max_tokens=max_tokens, - index_type=index_type + index_type=index_type, + prompt_template=prompt_template ) if is_turbo: messages.append({"role": "user", "content": prompt}) diff --git a/knowledgegpt/utils/utils_prompt.py b/knowledgegpt/utils/utils_prompt.py index 625749e..b0cf585 100644 --- a/knowledgegpt/utils/utils_prompt.py +++ b/knowledgegpt/utils/utils_prompt.py @@ -12,7 +12,7 @@ def construct_prompt(question: str, context_embeddings: dict, df: pd.DataFrame, embedding_type: str = "hf", - verbose=False, model_lang: str = "en", max_tokens=1000, index_type="basic") -> str: + verbose=False, model_lang: str = "en", max_tokens=1000, index_type="basic", prompt_template=None) -> str: """ Construct the prompt to be used for completion. :param question: The question to answer. @@ -51,9 +51,13 @@ def construct_prompt(question: str, context_embeddings: dict, df: pd.DataFrame, if not verbose: print(f"Selected {len(chosen_sections)} document sections:") print("\n".join(chosen_sections_indexes)) - if model_lang == "tr": - header = """Cümleyi doğru bir şekilde cevaplayın ve cevap metin içinde yoksa "bilmiyorum" diyin.\n\nMetin:\n""" - else: - header = """Answer the question as truthfully as possible using the provided context, and if the answer is not contained within the text below, say "I don't know."\n\nContext:\n""" - return header + "".join(chosen_sections) + "\n\n Q: " + question + "\n A:" + if prompt_template is None: + if model_lang == "tr": + header = """Cümleyi doğru bir şekilde cevaplayın ve cevap metin içinde yoksa "bilmiyorum" diyin.\n\nMetin:\n""" + else: + header = """Answer the question as truthfully as possible using the provided context, and if the answer is not contained within the text below, say "I don't know."\n\nContext:\n""" + + return header + "".join(chosen_sections) + "\n\n Q: " + question + "\n A:" + else: + return prompt_template.format(question=question, sections="".join(chosen_sections))