From 2bd5e3606ee85b0c647908c62320ab94a8401317 Mon Sep 17 00:00:00 2001 From: William Fu-Hinthorn <13333726+hinthornw@users.noreply.github.com> Date: Thu, 29 Feb 2024 18:53:48 -0800 Subject: [PATCH] render --- examples/storm/storm.ipynb | 595 ++++++++++++++++++++----------------- 1 file changed, 325 insertions(+), 270 deletions(-) diff --git a/examples/storm/storm.ipynb b/examples/storm/storm.ipynb index 8c91b47d2..a60b15ffd 100644 --- a/examples/storm/storm.ipynb +++ b/examples/storm/storm.ipynb @@ -29,11 +29,23 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ - "# %pip install langchain_community langchain_openai langchain_fireworks langgraph wikipedia tavily-python scikit-learn" + "# %pip install langchain_community langchain_openai langchain_fireworks langgraph wikipedia tavily-python scikit-learn duckduckgo" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Uncomment if you want to draw the pretty graph diagrams.\n", + "# If you are on MacOS, you will need to run brew install graphviz before installing and update some environment flags\n", + "# ! brew install graphviz\n", + "# !CFLAGS=\"-I $(brew --prefix graphviz)/include\" LDFLAGS=\"-L $(brew --prefix graphviz)/lib\" pip install -U pygraphviz" ] }, { @@ -47,14 +59,16 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from langchain_openai import ChatOpenAI\n", - "from langchain_fireworks\n", + "from langchain_fireworks import ChatFireworks\n", "\n", - "fast_llm = ChatOpenAI(model=\"gpt-3.5-turbo\")\n", + "fast_llm = ChatOpenAI(model=\"gpt-3.5-turbo\") \n", + "# Uncomment for a Fireworks model\n", + "# fast_llm = ChatFireworks(model=\"accounts/fireworks/models/firefunction-v1\", max_tokens=32_000)\n", "long_context_llm = ChatOpenAI(model=\"gpt-4-turbo-preview\")" ] }, @@ -70,14 +84,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/wfh/code/lc/community/langgraph-engineer/.venv/lib/python3.11/site-packages/langchain_core/_api/beta_decorator.py:86: LangChainBetaWarning: The function `with_structured_output` is in beta. It is actively being worked on, so the API may change.\n", + "/Users/wfh/code/lc/langchain/libs/core/langchain_core/_api/beta_decorator.py:86: LangChainBetaWarning: The function `with_structured_output` is in beta. It is actively being worked on, so the API may change.\n", " warn_beta(\n" ] } @@ -144,7 +158,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -155,23 +169,19 @@ "\n", "## Introduction\n", "\n", - "Overview of million-plus token context window language models and the RAG (Retrieval-Augmented Generation) architecture.\n", + "Overview of million-plus token context window language models and RAG (Retrieval-Augmented Generation).\n", "\n", - "## Benefits of Million-Plus Token Context Window Language Models\n", + "## Million-Plus Token Context Window Language Models\n", "\n", - "Discuss the advantages of using million-plus token context window language models in natural language processing tasks.\n", + "Explanation of million-plus token context window language models, their architecture, training data, and applications.\n", "\n", - "## Challenges of Million-Plus Token Context Window Language Models\n", + "## RAG (Retrieval-Augmented Generation)\n", "\n", - "Explore the limitations and obstacles associated with million-plus token context window language models.\n", + "Overview of RAG, its architecture, how it combines retrieval and generation models, and its use in natural language processing tasks.\n", "\n", - "## Integration of Million-Plus Token Models with RAG\n", + "## Impact on RAG\n", "\n", - "Examine how million-plus token context window language models can be integrated with the RAG architecture for improved performance.\n", - "\n", - "## Applications of RAG with Million-Plus Token Models\n", - "\n", - "Highlight the potential applications and use cases of combining RAG with million-plus token context window language models.\n" + "Discuss the impact of million-plus token context window language models on RAG, including improvements in performance, efficiency, and challenges faced.\n" ] } ], @@ -196,7 +206,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -223,16 +233,16 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "RelatedSubjects(topics=['million-plus token context window language models', 'Retriever-Reader-Generator (RAG) model', 'Impact of RAG on language understanding'])" + "RelatedSubjects(topics=['Language models', 'Retriever-Reader-Generator (RAG) model', 'Natural language processing', 'Machine learning', 'Artificial intelligence', 'Text generation', 'Transformer architecture', 'Context window', 'Impact of language models'])" ] }, - "execution_count": 5, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -254,7 +264,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -305,7 +315,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -343,52 +353,40 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/wfh/code/lc/community/langgraph-engineer/.venv/lib/python3.11/site-packages/wikipedia/wikipedia.py:389: GuessedAtParserWarning: No parser was explicitly specified, so I'm using the best available HTML parser for this system (\"lxml\"). This usually isn't a problem, but if you run this code on another system, or in a different virtual environment, it may use a different parser and behave differently.\n", - "\n", - "The code that caused this warning is on line 389 of the file /Users/wfh/code/lc/community/langgraph-engineer/.venv/lib/python3.11/site-packages/wikipedia/wikipedia.py. To get rid of this warning, pass the additional argument 'features=\"lxml\"' to the BeautifulSoup constructor.\n", - "\n", - " lis = BeautifulSoup(html).find_all('li')\n" - ] - } - ], + "outputs": [], "source": [ "perspectives = await survey_subjects.ainvoke(example_topic)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'editors': [{'affiliation': 'Research Institution',\n", - " 'name': 'Dr. Researcher',\n", - " 'role': 'Researcher',\n", - " 'description': 'Dr. Researcher will focus on analyzing the impact of million-plus token context window language models on the RAG (Retrieval-Augmented Generation) framework, specifically looking at the efficiency, effectiveness, and potential challenges that arise from integrating such large language models into the RAG framework.'},\n", - " {'affiliation': 'Tech Company',\n", - " 'name': 'AI Engineer',\n", - " 'role': 'AI Engineer',\n", - " 'description': 'AI Engineer will provide insights into the technical aspects of implementing million-plus token context window language models within the RAG framework. They will focus on the practical challenges, optimizations, and enhancements needed to leverage these models effectively in the RAG framework.'},\n", - " {'affiliation': 'Academic Institution',\n", - " 'name': 'Prof. Linguist',\n", - " 'role': 'Linguist',\n", - " 'description': 'Prof. Linguist will examine the linguistic implications of using million-plus token context window language models in the RAG framework. They will explore how such large models affect language generation, coherence, and understanding within the RAG context.'},\n", + "{'editors': [{'affiliation': 'Academic Research',\n", + " 'name': 'Dr. Linguist',\n", + " 'role': 'Language Model Expert',\n", + " 'description': 'Dr. Linguist will focus on explaining the technical aspects of million-plus token context window language models and their impact on RAG (Retrieval-Augmented Generation) systems.'},\n", " {'affiliation': 'Industry',\n", - " 'name': 'Content Creator',\n", - " 'role': 'Content Creator',\n", - " 'description': 'Content Creator will provide a creative perspective on the impact of million-plus token context window language models on the RAG framework. They will focus on storytelling, narrative quality, and the potential for generating engaging content using these large language models.'}]}" + " 'name': 'TechTrendz',\n", + " 'role': 'AI Solutions Architect',\n", + " 'description': 'TechTrendz will provide insights on the practical applications of million-plus token context window language models in RAG systems and discuss their benefits and challenges in real-world scenarios.'},\n", + " {'affiliation': 'Open Source Community',\n", + " 'name': 'CodeGenius',\n", + " 'role': 'Machine Learning Enthusiast',\n", + " 'description': 'CodeGenius will explore the open-source tools and frameworks available for implementing million-plus token context window language models in RAG systems and share their experiences with the community.'},\n", + " {'affiliation': 'Tech Journalism',\n", + " 'name': 'DataDive',\n", + " 'role': 'AI Technology Journalist',\n", + " 'description': 'DataDive will cover the latest developments and advancements in million-plus token context window language models and their implications for RAG systems, focusing on industry trends and use cases.'}]}" ] }, - "execution_count": 9, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -413,7 +411,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -462,7 +460,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -521,16 +519,16 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "\"Yes, that's correct. I am researching the impact of million-plus token context window language models on the RAG (Retrieval-Augmented Generation) framework. I am particularly interested in understanding how these large language models affect the efficiency, effectiveness, and any potential challenges that may arise when integrating them into the RAG framework. Is there any specific aspect of this topic that you would like to know more about?\"" + "\"Yes, that's correct. I'm focusing on the technical aspects of million-plus token context window language models and their impact on Retrieval-Augmented Generation (RAG) systems. Can you provide more information on how these large context window language models are trained and how they differ from traditional models in the context of RAG systems?\"" ] }, - "execution_count": 12, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -560,7 +558,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -586,18 +584,17 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "['Impact of million-plus token context window language models on RAG framework efficiency',\n", - " 'Effectiveness of large language models in RAG framework',\n", - " 'Challenges of integrating million-plus token context window language models into RAG framework']" + "['Training process of million-plus token context window language models',\n", + " 'Differences between large context window language models and traditional models in Retrieval-Augmented Generation systems']" ] }, - "execution_count": 14, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -611,7 +608,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ @@ -646,7 +643,7 @@ "\n", "gen_answer_chain = gen_answer_prompt | fast_llm.with_structured_output(\n", " AnswerWithCitations, include_raw=True\n", - ")" + ").with_config(run_name=\"GenerateAnswer\")" ] }, { @@ -661,17 +658,18 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ + "from langchain_community.tools.tavily_search import TavilySearchResults\n", "from langchain_community.utilities.duckduckgo_search import DuckDuckGoSearchAPIWrapper\n", - "\n", - "search_engine = DuckDuckGoSearchAPIWrapper()\n", "from langchain_core.tools import tool\n", "\n", + "search_engine = DuckDuckGoSearchAPIWrapper()\n", + "# Tavily is typically a better search engine, but your free queries are limited\n", + "# search_engine = TavilySearchResults(max_results=4)\n", "\n", - "# TODO: remove when i get my api limit bumped\n", "@tool\n", "async def search_engine(query: str):\n", " \"\"\"Search engine to the internet.\"\"\"\n", @@ -681,16 +679,13 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ - "from langchain_community.tools.tavily_search import TavilySearchResults\n", "from langchain_core.runnables import RunnableConfig\n", "import json\n", "\n", - "# search_engine = TavilySearchResults(max_results=4)\n", - "\n", "\n", "async def gen_answer(\n", " state: InterviewState,\n", @@ -728,16 +723,16 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "'Large language models with million-plus token context windows, such as Gemini 1.5, have generated discussions in the AI community regarding their impact on the Retrieval-Augmented Generation (RAG) framework. These models are believed to potentially have a negative effect on RAG^(1). The RAG framework typically involves components like Milvus as the vector database, LangChain as the orchestrator, and large language models like GTE-Large for text generation^(2). While large context windows are desirable in language models, the high fine-tuning costs, scarcity of long texts, and challenges like catastrophic values introduced by new token positions limit the current extended context windows to around 128k tokens^(3). Recent advancements, like LongRoPE, have extended the context window of pre-trained large language models significantly to 2048k tokens^(3). The integration of retrieval mechanisms with long context language models, such as GPT-3.5-Turbo-16k and Llama2-7B-chat-4k, has been explored to evaluate the impact of retrieval on model performance in the RAG framework^(4). Challenges in integrating large language models into RAG include inaccuracies, cost-efficiency, and the need for optimization through vector databases^(5). RAG combines large language models with retrieval modules to ground text generation in knowledge, addressing challenges like inaccuracies and cost-efficiency^(6). The RAG framework involves indexing external data sources, converting them into vector embeddings, and retrieval processes to enhance the capabilities of large language models like GPT-3 or BERT^(7). While RAG offers flexibility and scalability in integrating with existing AI systems, challenges persist in ensuring the accuracy of external data sources^(8). Large language models like GPT-4 have demonstrated impressive text generation abilities, but challenges remain in retaining factual knowledge^(9).\\n\\nCitations:\\n\\n[1]: https://medium.com/enterprise-rag/why-gemini-1-5-and-other-large-context-models-are-bullish-for-rag-ce3218930bb4\\n[2]: https://zilliz.com/blog/building-rag-without-openai-mixtral-milvus-octoai\\n[3]: https://arxiv.org/abs/2402.13753\\n[4]: https://blog.llamaindex.ai/nvidia-research-rag-with-long-context-llms-7d94d40090c4\\n[5]: https://www.infoworld.com/article/3712227/what-is-rag-more-accurate-and-reliable-llms.html\\n[6]: https://medium.com/@juanc.olamendy/rag-best-practices-enhancing-large-language-models-with-retrieval-augmented-generation-6961c8b834ff\\n[7]: https://www.deepset.ai/blog/generative-llm-evaluation-rag\\n[8]: https://ai88.substack.com/p/rag-vs-context-window-in-gpt4-accuracy-cost\\n[9]: https://wetheitguys.medium.com/understanding-retrieval-augmented-generation-rag-with-large-language-models-llms-b77c76b9f9d8\\n[10]: https://medium.com/@bijit211987/optimizing-rag-for-llms-apps-53f6056d8118'" + "'Large context window language models, such as the Llama2 70B model, can support context windows of more than 100k tokens without continual training through innovations like Dual Chunk Attention (DCA). These models have significantly longer context windows compared to traditional models, with capabilities like processing up to 1 million tokens at once, providing more consistent and relevant outputs. Training these models often involves starting with a smaller window size and gradually increasing it through fine-tuning on larger windows. In contrast, traditional models have much shorter context windows, limiting their ability to process extensive information in a prompt. Retrieval-Augmented Generation (RAG) systems, on the other hand, integrate large language models with external knowledge sources to enhance their performance, offering a pathway to combine the capabilities of models like ChatGPT/GPT-4 with custom data sources for more informed and contextually aware outputs.\\n\\nCitations:\\n\\n[1]: https://arxiv.org/abs/2402.17463\\n[2]: https://blog.google/technology/ai/long-context-window-ai-models/\\n[3]: https://medium.com/@ddxzzx/why-and-how-to-achieve-longer-context-windows-for-llms-5f76f8656ea9\\n[4]: https://blog.google/technology/ai/google-gemini-next-generation-model-february-2024/\\n[5]: https://huggingface.co/papers/2402.13753\\n[6]: https://www.pinecone.io/blog/why-use-retrieval-instead-of-larger-context/\\n[7]: https://medium.com/emalpha/innovations-in-retrieval-augmented-generation-8e6e70f95629\\n[8]: https://inside-machinelearning.com/en/rag/'" ] }, - "execution_count": 32, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -761,7 +756,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 45, "metadata": {}, "outputs": [], "source": [ @@ -794,7 +789,32 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image\n", + "\n", + "# Feel free to comment out if you have\n", + "# not installed pygraphviz\n", + "Image(interview_graph.get_graph().draw_png())" + ] + }, + { + "cell_type": "code", + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -802,23 +822,19 @@ "output_type": "stream", "text": [ "ask_question\n", - "-- [AIMessage(content=\"Yes, that's correct. I am focusing on analyzing the impact of million-plus token context window language models on the RAG (Retrieval-Augmented Generation) framework. This involves looking at how these large language models affect the efficiency, effectiveness, and potential chal\n", + "-- [AIMessage(content=\"Yes, that's correct. I am focusing on the technical aspects of million-plus token context window language models and their impact on RAG systems. Can you provide more insight into how these large context window models affect the performance and capabilities of RAG systems?\", name\n", "answer_question\n", - "-- [AIMessage(content='The impact of million-plus token context window language models on the RAG (Retrieval-Augmented Generation) framework has been a topic of discussion in the AI community. For example, the introduction of Gemini 1.5, with a 1 million token context window, has raised concerns about \n", + "-- [AIMessage(content='The introduction of large context window language models, such as Gemini 1.5 with a 1 million token context window, has raised concerns in the AI community regarding its impact on Retrieval-Augmented Generation (RAG) systems. RAG systems represent a significant advancement over t\n", "ask_question\n", - "-- [AIMessage(content='Thank you for providing such detailed information and relevant citations. Could you elaborate on the specific challenges researchers have encountered when integrating million-plus token context window language models into the RAG framework, and how they have attempted to address \n", + "-- [AIMessage(content='Thank you for the detailed explanation and resources. Could you elaborate on the specific challenges and opportunities that million-plus token context window language models present for RAG systems in terms of improving generation quality, addressing data biases, and the potentia\n", "answer_question\n", - "-- [AIMessage(content=\"Integrating million-plus token context window language models into the RAG (Retrieval-Augmented Generation) framework poses challenges such as high fine-tuning costs, scarcity of long texts, and the introduction of catastrophic values by new token positions, limiting the extended\n", + "-- [AIMessage(content='Million-plus token context window language models present both challenges and opportunities for RAG systems. Challenges include the increased computational cost and complexity associated with processing larger context windows, potential issues with retaining factual accuracy when\n", "ask_question\n", - "-- [AIMessage(content='Thank you for sharing this insightful information about the challenges and advancements in integrating million-plus token context window language models into the RAG framework. Can you provide more details on how RAG leverages external knowledge sources through retrieval to enhan\n", + "-- [AIMessage(content='Thank you for the detailed information and references provided. It has been insightful to understand both the challenges and opportunities that million-plus token context window language models bring to RAG systems. I appreciate your assistance in shedding light on this complex t\n", "answer_question\n", - "-- [AIMessage(content='Retrieval-Augmented Generation (RAG) is a technique that enhances the accuracy and reliability of generative AI models, such as Large Language Models (LLMs), by incorporating facts fetched from external sources. RAG leverages external knowledge sources through retrieval to addres\n", - "ask_question\n", - "-- [AIMessage(content='Thank you for providing a concise summary of how Retrieval-Augmented Generation (RAG) leverages external knowledge sources through retrieval to enhance the accuracy and credibility of Large Language Models (LLMs). This information will be valuable for my research and editing of t\n", - "answer_question\n", - "-- [AIMessage(content='RAG leverages external knowledge sources through retrieval to address challenges like hallucination, outdated knowledge, and non-transparent reasoning processes. By integrating information from external databases, RAG improves the credibility and accuracy of LLMs, making them mor\n", + "-- [AIMessage(content=\"You're welcome! If you have any more questions or need further assistance in the future, feel free to reach out. Good luck with your article on RAG systems and million-plus token context window language models!\\n\\nCitations:\\n\\n[1]: https://www.nerdwallet.com/article/finance/exam\n", "__end__\n", - "-- [AIMessage(content='So you said you were writing an article on Impact of million-plus token context window language models on RAG?', name='Subject Matter Expert'), AIMessage(content=\"Yes, that's correct. I am focusing on analyzing the impact of million-plus token context window language models on th\n" + "-- [AIMessage(content='So you said you were writing an article on Impact of million-plus token context window language models on RAG?', name='Subject Matter Expert'), AIMessage(content=\"Yes, that's correct. I am focusing on the technical aspects of million-plus token context window language models and \n" ] } ], @@ -844,7 +860,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -862,7 +878,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 53, "metadata": {}, "outputs": [], "source": [ @@ -870,10 +886,13 @@ " [\n", " (\n", " \"system\",\n", - " \"\"\"You are a Wikipedia writer. You have gathered information from experts and search engines. Now, you are refining the outline of the Wikipedia page.\\\n", - "You need to make sure that the outline is comprehensive and specific.\\\n", - "Topic you are writing about: {topic}\\\n", - "Old outline: {old_outline}\"\"\",\n", + " \"\"\"You are a Wikipedia writer. You have gathered information from experts and search engines. Now, you are refining the outline of the Wikipedia page. \\\n", + "You need to make sure that the outline is comprehensive and specific. \\\n", + "Topic you are writing about: {topic} \n", + "\n", + "Old outline:\n", + "\n", + "{old_outline}\"\"\",\n", " ),\n", " (\n", " \"user\",\n", @@ -890,7 +909,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -907,62 +926,58 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "# Impact of Million-Plus Token Context Window Language Models on RAG\n", + "# Impact of million-plus token context window language models on RAG\n", "\n", "## Introduction\n", "\n", - "An overview of the development and significance of million-plus token context window language models and the concept of Retrieval-Augmented Generation (RAG).\n", + "Provides a brief overview of million-plus token context window language models and their relevance to Retrieval-Augmented Generation (RAG) systems, setting the stage for a deeper exploration of their impact.\n", "\n", - "## The Evolution of Large Context Windows in Language Models\n", + "## Background\n", "\n", - "A historical perspective on the growth of context window sizes in language models, including key milestones such as Gemini 1.5, Mixtral, GPT-3.5-Turbo-16k, Llama2-7B-chat-4k, and LongRoPE.\n", + "A foundational section to understand the core concepts involved.\n", "\n", - "### Key Milestones\n", + "### Million-Plus Token Context Window Language Models\n", "\n", - "Discussion of significant advancements and models that have shaped the current landscape of large context window language models.\n", + "Explains what million-plus token context window language models are, including notable examples like Gemini 1.5, focusing on their architecture, training data, and the evolution of their applications.\n", "\n", - "### Challenges Overcome\n", + "### Retrieval-Augmented Generation (RAG)\n", "\n", - "Examination of the technical and theoretical hurdles encountered in expanding the context window sizes of language models.\n", + "Describes the RAG framework, its unique approach of combining retrieval and generation models for enhanced natural language processing, and its significance in the AI landscape.\n", "\n", - "## Integration Challenges with RAG\n", + "## Impact on RAG Systems\n", "\n", - "Detailed analysis of the specific challenges faced when integrating million-plus token context window language models into the RAG framework, such as high fine-tuning costs, scarcity of long texts, and catastrophic values introduced by new token positions.\n", + "Delves into the effects of million-plus token context window language models on RAG, highlighting both the challenges and opportunities presented.\n", "\n", - "### Addressing High Fine-Tuning Costs\n", + "### Performance and Efficiency\n", "\n", - "Exploration of strategies and technological advancements aimed at reducing the high fine-tuning costs associated with large context windows.\n", + "Discusses how large context window models influence RAG performance, including aspects of latency, computational demands, and overall efficiency.\n", "\n", - "### Overcoming Scarcity of Long Texts\n", + "### Generation Quality and Diversity\n", "\n", - "Discussion on methods to mitigate the scarcity of long texts suitable for training and leveraging million-plus token models.\n", + "Explores the impact on generation quality, the potential for more accurate and diverse outputs, and how these models address data biases and factual accuracy.\n", "\n", - "### Mitigating Catastrophic Values\n", + "### Technical Challenges\n", "\n", - "Analysis of approaches to limit the impact of catastrophic values introduced by new token positions in extended context windows.\n", + "Identifies specific technical hurdles such as prompt template design, context length limitations, and similarity searches in vector databases, and how they affect RAG systems.\n", "\n", - "## Enhancing RAG with External Knowledge Sources\n", + "### Opportunities and Advancements\n", "\n", - "Insight into how RAG leverages external knowledge sources through retrieval to address challenges like hallucination, outdated knowledge, and non-transparent reasoning processes, thereby enhancing the accuracy and credibility of LLMs.\n", + "Outlines the new capabilities and improvements in agent interaction, information retrieval, and response relevance that these models bring to RAG systems.\n", "\n", - "### Improving Credibility and Accuracy\n", + "## Future Directions\n", "\n", - "Discussion on the importance of integrating external data sources to enhance the credibility and accuracy of responses generated by LLMs.\n", + "Considers ongoing research and potential future developments in the integration of million-plus token context window language models with RAG systems, including speculation on emerging trends and technologies.\n", "\n", - "### Addressing Hallucination and Outdated Knowledge\n", + "## Conclusion\n", "\n", - "Analysis of how RAG's retrieval mechanism helps in minimizing issues of hallucination and outdated knowledge by providing up-to-date and relevant information.\n", - "\n", - "## Applications and Future Directions\n", - "\n", - "Exploration of potential applications for RAG integrated with million-plus token context window language models and speculation on future developments in this area.\n" + "Summarizes the key points discussed in the article, reaffirming the significant impact of million-plus token context window language models on RAG systems.\n" ] } ], @@ -987,7 +1002,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -1013,19 +1028,19 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[Document(page_content='Large Language Models (LLMs) have achieved remarkable success across various tasks. However, they often grapple with a limited context window size due to the high costs of fine-tuning, scarcity of lengthy texts, and the introduction of catastrophic values by new token positions. To address this issue, in a new paper LongRoPE: Extending LLM Context Window', metadata={'id': '20dbbce3-ae12-4a05-94e9-df4a97676098', 'source': 'https://syncedreview.com/2024/02/25/microsofts-longrope-breaks-the-limit-of-context-window-of-llms-extents-it-to-2-million-tokens/'}),\n", - " Document(page_content='Large context window is a desirable feature in large language models (LLMs). However, due to high fine-tuning costs, scarcity of long texts, and catastrophic values introduced by new token positions, current extended context windows are limited to around 128k tokens. This paper introduces LongRoPE that, for the first time, extends the context window of pre-trained LLMs to an impressive 2048k ...', metadata={'id': 'f7881b24-697b-46fa-a31c-8e476ae40f3f', 'source': 'https://arxiv.org/abs/2402.13753'}),\n", - " Document(page_content='Large language models (LLMs) have witnessed significant advancements, aiming to enhance their capabilities for interpreting and processing extensive textual data. LLMs like GPT-3 have revolutionized our interactions with AI, offering insights and analyses across various domains, from writing assistance to complex data interpretation. However, a key limitation has been their context window size ...', metadata={'id': '354ceab3-03ae-4141-94a1-4b0109182aab', 'source': 'https://www.marktechpost.com/2024/02/23/breaking-barriers-in-language-understanding-how-microsoft-ais-longrope-extends-large-language-models-to-a-2048k-token-context-window/'}),\n", - " Document(page_content='Large Language Models (LLMs) demonstrate significant capabilities but face challenges such as hallucination, outdated knowledge, and non-transparent, untraceable reasoning processes. Retrieval-Augmented Generation (RAG) has emerged as a promising solution by incorporating knowledge from external databases. This enhances the accuracy and credibility of the models, particularly for knowledge ...', metadata={'id': '85f7d7a1-2820-466c-ac80-975f4e2d65af', 'source': 'https://arxiv.org/abs/2312.10997'})]" + "[Document(page_content='In Retrieval Augmented Generation (RAG), a longer context augments our model with more information. For LLMs that power agents, such as chatbots, longer context means more tools and capabilities. When summarizing, longer context means more comprehensive summaries. There exist plenty of use-cases for LLMs that are unlocked by longer context lengths.', metadata={'id': '20454848-23ac-4649-b083-81980532a77b', 'source': 'https://www.anyscale.com/blog/fine-tuning-llms-for-longer-context-and-better-rag-systems'}),\n", + " Document(page_content='By the way, the context limits differ among models: two Claude models offer a 100K token context window, which works out to about 75,000 words, which is much higher than most other LLMs. The ...', metadata={'id': '1ee2d2bb-8f8e-4a7e-b45e-608b0804fe4c', 'source': 'https://www.infoworld.com/article/3712227/what-is-rag-more-accurate-and-reliable-llms.html'}),\n", + " Document(page_content='Figure 1: LLM response accuracy goes down when context needed to answer correctly is found in the middle of the context window. The problem gets worse with larger context models. The problem gets ...', metadata={'id': 'a41d69e6-62eb-4abd-90ad-0892a2836cba', 'source': 'https://medium.com/@jm_51428/long-context-window-models-vs-rag-a73c35a763f2'}),\n", + " Document(page_content='To improve performance, we used retrieval-augmented generation (RAG) to prompt an LLM with accurate up-to-date information. As a result of using RAG, the writing quality of the LLM improves substantially, which has implications for the practical useability of LLMs in clinical trial-related writing.', metadata={'id': 'e1af6e30-8c2b-495b-b572-ac6a29067a94', 'source': 'https://arxiv.org/abs/2402.16406'})]" ] }, - "execution_count": 41, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -1045,7 +1060,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -1114,35 +1129,24 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Impact of million-plus token context window language models on RAG The Evolution of Large Context Windows in Language Models\n", - "## The Evolution of Large Context Windows in Language Models\n", + "## Background\n", "\n", - "The evolution of large context windows in language models (LLMs) has been a critical factor in the advancement of natural language processing (NLP) technologies. Initially, LLMs were constrained by smaller context windows, limiting their understanding and generation capabilities. However, the demand for models capable of processing and integrating more extensive sequences of text has led to significant research and development efforts aimed at expanding these context windows.\n", + "To fully appreciate the impact of million-plus token context window language models on Retrieval-Augmented Generation (RAG) systems, it's essential to first understand the foundational concepts that underpin these technologies. This background section provides a comprehensive overview of both million-plus token context window language models and RAG, setting the stage for a deeper exploration of their integration and subsequent impacts on artificial intelligence and natural language processing.\n", "\n", - "Over time, this push for larger context windows has seen the emergence of several key milestones that have progressively increased the amount of text LLMs can consider when generating responses or analyses. These milestones include models like Gemini 1.5, Mixtral, GPT-3.5-Turbo-16k, Llama2-7B-chat-4k, and LongRoPE, each contributing to the landscape of large context window LLMs in unique ways.\n", + "### Million-Plus Token Context Window Language Models\n", "\n", - "Despite the benefits, expanding the context window size brings several challenges, including the high fine-tuning costs associated with processing longer sequences of text, the scarcity of long texts suitable for training these models, and the potential for catastrophic values introduced by new token positions in expanded contexts. Addressing these challenges has been central to the continued development and effectiveness of LLMs with large context windows.\n", + "Million-plus token context window language models, such as Gemini 1.5, represent a significant leap forward in the field of language modeling. These models are designed to process and understand large swathes of text, sometimes exceeding a million tokens in a single pass. The ability to handle such vast amounts of information at once allows for a deeper understanding of context and nuance, which is crucial for generating coherent and relevant text outputs. The development of these models involves sophisticated architecture and extensive training data, pushing the boundaries of what's possible in natural language processing. Over time, the applications of these models have evolved, extending their utility beyond mere text generation to complex tasks like sentiment analysis, language translation, and more.\n", "\n", - "### Key Milestones\n", + "### Retrieval-Augmented Generation (RAG)\n", "\n", - "The journey towards expanding the context window sizes of language models has been marked by several significant milestones. Gemini 1.5, Mixtral, GPT-3.5-Turbo-16k, Llama2-7B-chat-4k, and LongRoPE represent some of the most notable advancements in this area. Each of these models has pushed the boundaries of what was previously possible, setting new standards for the amount of text that can be processed and understood by LLMs.\n", - "\n", - "For instance, LongRoPE has made a groundbreaking contribution by extending the context window of pre-trained LLMs to an impressive 2048k tokens, far surpassing previous limits and opening up new possibilities for NLP applications.\n", - "\n", - "### Challenges Overcome\n", - "\n", - "Expanding the context window sizes of language models has not been without its challenges. High fine-tuning costs, the scarcity of suitable long texts for training, and the introduction of catastrophic values by new token positions have all posed significant hurdles.\n", - "\n", - "Technological and methodological advancements have been crucial in overcoming these challenges, allowing for the successful expansion of context windows beyond previous limitations. Innovations in model architecture, training methodologies, and data processing techniques have all played a role in addressing these issues and enabling the development of more capable and efficient LLMs.[0] https://arxiv.org/abs/2402.13753\n", - " [1] https://syncedreview.com/2024/02/25/microsofts-longrope-breaks-the-limit-of-context-window-of-llms-extents-it-to-2-million-tokens/\n", - " [2] https://www.marktechpost.com/2024/02/23/breaking-barriers-in-language-understanding-how-microsoft-ais-longrope-extends-large-language-models-to-a-2048k-token-context-window/\n" + "The Retrieval-Augmented Generation framework represents a novel approach in the realm of artificial intelligence, blending the strengths of both retrieval and generation models to enhance natural language processing capabilities. At its core, RAG leverages a two-step process: initially, it uses a query to retrieve relevant documents or data from a knowledge base; this information is then utilized to inform and guide the generation of responses by a language model. This method addresses the limitations of fixed context windows by converting text to vector embeddings, facilitating a dynamic and flexible interaction with a vast array of information. RAG's unique approach has cemented its significance in the AI landscape, offering a pathway to more accurate, informative, and contextually relevant text generation.\n" ] } ], @@ -1168,7 +1172,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -1183,7 +1187,8 @@ " ),\n", " (\n", " \"user\",\n", - " 'Write the complete Wiki article using markdown format. Organize citations using footnotes like \"[1]\", avoiding duplicates in the footer.',\n", + " 'Write the complete Wiki article using markdown format. Organize citations using footnotes like \"[1]\",\"\n", + " \" avoiding duplicates in the footer. Include URLs in the footer.',\n", " ),\n", " ]\n", ")\n", @@ -1193,68 +1198,90 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "# Impact of Million-Plus Token Context Window Language Models on RAG\n", + "# Impact of Million-Plus Token Context Window Language Models on Retrieval-Augmented Generation (RAG)\n", "\n", - "The development and implementation of million-plus token context window language models (LLMs) represent a significant milestone in the field of natural language processing (NLP). These models have dramatically enhanced the capabilities of retrieval-augmented generation (RAG) systems, enabling them to generate more accurate, contextually relevant, and nuanced text outputs. This article delves into the evolution of large context windows in LLMs, their impact on RAG, and the challenges faced along the way.\n", + "The integration of million-plus token context window language models into Retrieval-Augmented Generation (RAG) systems marks a pivotal advancement in the field of artificial intelligence (AI) and natural language processing (NLP). This article delves into the background of both technologies, explores their convergence, and examines the profound effects of this integration on the capabilities and applications of AI-driven language models.\n", "\n", "## Contents\n", "\n", - "1. [The Evolution of Large Context Windows in Language Models](#The-Evolution-of-Large-Context-Windows-in-Language-Models)\n", - " 1. [Key Milestones](#Key-Milestones)\n", - " 2. [Challenges Overcome](#Challenges-Overcome)\n", - "2. [Impact on Retrieval-Augmented Generation](#Impact-on-Retrieval-Augmented-Generation)\n", - " 1. [Enhanced Contextual Understanding](#Enhanced-Contextual-Understanding)\n", - " 2. [Improved Accuracy and Relevance](#Improved-Accuracy-and-Relevance)\n", - " 3. [Challenges and Solutions](#Challenges-and-Solutions)\n", - "3. [Conclusion](#Conclusion)\n", - "4. [References](#References)\n", + "1. [Background](#Background)\n", + " 1. [Million-Plus Token Context Window Language Models](#Million-Plus-Token-Context-Window-Language-Models)\n", + " 2. [Retrieval-Augmented Generation (RAG)](#Retrieval-Augmented-Generation-(RAG))\n", + "2. [Integration of Million-Plus Token Context Window Models and RAG](#Integration-of-Million-Plus-Token-Context-Window-Models-and-RAG)\n", + "3. [Impact on Natural Language Processing](#Impact-on-Natural-Language-Processing)\n", + "4. [Applications](#Applications)\n", + "5. [Challenges and Limitations](#Challenges-and-Limitations)\n", + "6. [Future Directions](#Future-Directions)\n", + "7. [Conclusion](#Conclusion)\n", + "8. [References](#References)\n", "\n", - "## The Evolution of Large Context Windows in Language Models\n", + "## Background\n", "\n", - "The evolution of large context windows in language models (LLMs) has been instrumental in advancing natural language processing (NLP) technologies. Initially, these models were restricted by smaller context windows, limiting their comprehension and generation abilities. The push for models that could process and integrate longer text sequences led to significant research and development efforts aimed at expanding these context windows.\n", + "### Million-Plus Token Context Window Language Models\n", "\n", - "### Key Milestones\n", + "Million-plus token context window language models, exemplified by systems like Gemini 1.5, have revolutionized language modeling by their ability to process and interpret extensive texts, potentially exceeding a million tokens in a single analysis[1]. The capacity to manage such large volumes of data enables these models to grasp context and subtlety to a degree previously unattainable, enhancing their effectiveness in generating text that is coherent, relevant, and nuanced. The development of these models has been characterized by innovative architecture and the utilization of vast training datasets, pushing the envelope of natural language processing capabilities[2].\n", "\n", - "Several key milestones have marked the journey towards enlarging the context window sizes of language models, including Gemini 1.5, Mixtral, GPT-3.5-Turbo-16k, Llama2-7B-chat-4k, and LongRoPE. Each model has contributed uniquely to the landscape of large context window LLMs, progressively increasing the amount of text that LLMs can consider when generating responses or analyses. Notably, LongRoPE has been a groundbreaking advancement, extending the context window to an impressive 2048k tokens[1][2].\n", + "### Retrieval-Augmented Generation (RAG)\n", "\n", - "### Challenges Overcome\n", + "RAG systems represent an innovative paradigm in AI, merging the strengths of retrieval-based and generative models to improve the quality and relevance of text generation[3]. By initially retrieving related documents or data in response to a query, and subsequently using this information to guide the generation process, RAG overcomes the limitations inherent in fixed context windows. This methodology allows for dynamic access to a broad range of information, significantly enhancing the model's ability to generate accurate, informative, and contextually appropriate responses[4].\n", "\n", - "The expansion of context window sizes has encountered several challenges, such as high fine-tuning costs, the scarcity of suitable long texts for training, and the introduction of catastrophic values by new token positions. Technological and methodological advancements have been pivotal in overcoming these challenges, enabling the successful expansion of context windows[0].\n", + "## Integration of Million-Plus Token Context Window Models and RAG\n", "\n", - "## Impact on Retrieval-Augmented Generation\n", + "The integration of million-plus token context window models with RAG systems has been a natural progression in the quest for more sophisticated NLP solutions. By combining the extensive contextual understanding afforded by large context window models with the dynamic, information-rich capabilities of RAG, researchers and developers have been able to create AI systems that exhibit unprecedented levels of understanding, coherence, and relevance in text generation[5].\n", "\n", - "The implementation of million-plus token context window LLMs has had a profound impact on RAG systems, enhancing their performance in various ways.\n", + "## Impact on Natural Language Processing\n", "\n", - "### Enhanced Contextual Understanding\n", + "The fusion of these technologies has had a significant impact on the field of NLP, leading to advancements in several key areas:\n", + "- **Enhanced Understanding**: The combined system exhibits a deeper comprehension of both the immediate context and broader subject matter[6].\n", + "- **Improved Coherence**: Generated text is more coherent over longer passages, maintaining consistency and relevance[7].\n", + "- **Increased Relevance**: Outputs are more contextually relevant, drawing accurately from a wider range of sources[8].\n", "\n", - "With the ability to process and integrate larger sequences of text, RAG systems can now generate responses that are more contextually relevant and nuanced. This has significantly improved the quality of text generation across diverse NLP applications.\n", + "## Applications\n", "\n", - "### Improved Accuracy and Relevance\n", + "This technological convergence has broadened the applicability of NLP systems in numerous fields, including but not limited to:\n", + "- **Automated Content Creation**: Generating written content that is both informative and contextually appropriate for various platforms[9].\n", + "- **Customer Support**: Providing answers that are not only accurate but also tailored to the specific context of user inquiries[10].\n", + "- **Research Assistance**: Assisting in literature review and data analysis by retrieving and synthesizing relevant information from vast databases[11].\n", "\n", - "The expanded context windows allow RAG systems to retrieve and leverage more relevant information, leading to improvements in the accuracy and relevance of generated text. This capability is particularly beneficial in tasks that require a deep understanding of large text corpora, such as summarization and question-answering.\n", + "## Challenges and Limitations\n", "\n", - "### Challenges and Solutions\n", + "Despite their advancements, the integration of these technologies faces several challenges:\n", + "- **Computational Resources**: The processing of million-plus tokens and the dynamic retrieval of relevant information require significant computational power[12].\n", + "- **Data Privacy and Security**: Ensuring the confidentiality and integrity of the data accessed by these systems poses ongoing concerns[13].\n", + "- **Bias and Fairness**: The potential for inheriting and amplifying biases from training data remains a critical issue to address[14].\n", "\n", - "Despite the benefits, integrating million-plus token context window LLMs into RAG systems presents challenges, including increased computational requirements and the need for more sophisticated retrieval mechanisms. Ongoing research and development are focused on addressing these issues, ensuring the continued advancement of RAG technologies.\n", + "## Future Directions\n", + "\n", + "Future research is likely to focus on optimizing computational efficiency, enhancing the models' ability to understand and generate more diverse and nuanced text, and addressing ethical considerations associated with AI and NLP technologies[15].\n", "\n", "## Conclusion\n", "\n", - "The advent of million-plus token context window LLMs has been a game-changer for RAG systems, significantly enhancing their text generation capabilities. Despite the challenges, the benefits of expanded context windows are undeniable, paving the way for more sophisticated and capable NLP applications.\n", + "The integration of million-plus token context window language models with RAG systems represents a milestone in the evolution of natural language processing, offering enhanced capabilities that have significant implications across various applications. As these technologies continue to evolve, they promise to further transform the landscape of AI-driven language models.\n", "\n", "## References\n", "\n", - "[0] \"Techniques for Expanding Context Window Sizes in Language Models,\" arXiv, 2024. https://arxiv.org/abs/2402.13753\n", - "\n", - "[1] \"Microsoft's LongRoPE Breaks the Limit of Context Window of LLMs, Extends it to 2 Million Tokens,\" SyncedReview, 2024. https://syncedreview.com/2024/02/25/microsofts-longrope-breaks-the-limit-of-context-window-of-llms-extents-it-to-2-million-tokens/\n", - "\n", - "[2] \"Breaking Barriers in Language Understanding: How Microsoft AI's LongRoPE Extends Large Language Models to a 2048k Token Context Window,\" MarkTechPost, 2024. https://www.marktechpost.com/2024/02/23/breaking-barriers-in-language-understanding-how-microsoft-ais-longrope-extends-large-language-models-to-a-2048k-token-context-window/" + "1. Gemini 1.5 Documentation. (n.d.).\n", + "2. The Evolution of Language Models. (2022).\n", + "3. Introduction to Retrieval-Augmented Generation. (2021).\n", + "4. Leveraging Large Context Windows for NLP. (2023).\n", + "5. Integrating Context Window Models with RAG. (2023).\n", + "6. Deep Learning in NLP. (2020).\n", + "7. Coherence in Text Generation. (2019).\n", + "8. Contextual Relevance in AI. (2021).\n", + "9. Applications of NLP in Content Creation. (2022).\n", + "10. AI in Customer Support. (2023).\n", + "11. NLP for Research Assistance. (2021).\n", + "12. Computational Challenges in NLP. (2022).\n", + "13. Data Privacy in AI Systems. (2020).\n", + "14. Addressing Bias in AI. (2021).\n", + "15. Future of NLP Technologies. (2023)." ] } ], @@ -1281,7 +1308,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 55, "metadata": {}, "outputs": [], "source": [ @@ -1297,7 +1324,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 80, "metadata": {}, "outputs": [], "source": [ @@ -1332,7 +1359,7 @@ " }\n", " for editor in state[\"editors\"]\n", " ]\n", - " # We call in to the sub-graph here\n", + " # We call in to the sub-graph here to parallelize the interviews\n", " interview_results = await interview_graph.abatch(initial_states)\n", "\n", " return {\n", @@ -1343,7 +1370,7 @@ "\n", "def format_conversation(interview_state):\n", " messages = interview_state[\"messages\"]\n", - " convo = \"\\n\".join(f\"{m.name}: {m.content}\" for m in final_state[\"messages\"])\n", + " convo = \"\\n\".join(f\"{m.name}: {m.content}\" for m in messages)\n", " return f'Conversation with {interview_state[\"editor\"].name}\\n\\n' + convo\n", "\n", "\n", @@ -1399,7 +1426,7 @@ " topic = state[\"topic\"]\n", " sections = state[\"sections\"]\n", " draft = \"\\n\\n\".join([section.as_str for section in sections])\n", - " article = await writer.ainvoke({\"topic\": example_topic, \"draft\": draft})\n", + " article = await writer.ainvoke({\"topic\": topic, \"draft\": draft})\n", " return {\n", " **state,\n", " \"article\": article,\n", @@ -1408,13 +1435,12 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 73, "metadata": {}, "outputs": [], "source": [ "builder_of_storm = StateGraph(ResearchState)\n", "\n", - "\n", "nodes = [\n", " (\"init_research\", initialize_research),\n", " (\"conduct_interviews\", conduct_interviews),\n", @@ -1436,7 +1462,28 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Image(storm.get_graph().draw_png())" + ] + }, + { + "cell_type": "code", + "execution_count": 75, "metadata": {}, "outputs": [ { @@ -1444,34 +1491,26 @@ "output_type": "stream", "text": [ "init_research\n", - "-- {'topic': 'NVIDIA 2024 Q1 earnings report', 'outline': Outline(page_title='NVIDIA 2024 Q1 Earnings Report', sections=[Section(section_title='Overview', description='Brief introduction to NVIDIA and an overview of the 2024 Q1 earnings report', subsections=None), Section(section_title='Financial Perfo\n", + "-- {'topic': 'Groq, NVIDIA, Llamma.cpp and the future of LLM Inference', 'outline': Outline(page_title='Groq, NVIDIA, Llamma.cpp and the future of LLM Inference', sections=[Section(section_title='Introduction', description='Overview of Groq, NVIDIA, Llamma.cpp, and their significance in the field of La\n", "conduct_interviews\n", - "-- {'topic': 'NVIDIA 2024 Q1 earnings report', 'outline': Outline(page_title='NVIDIA 2024 Q1 Earnings Report', sections=[Section(section_title='Overview', description='Brief introduction to NVIDIA and an overview of the 2024 Q1 earnings report', subsections=None), Section(section_title='Financial Perfo\n", + "-- {'topic': 'Groq, NVIDIA, Llamma.cpp and the future of LLM Inference', 'outline': Outline(page_title='Groq, NVIDIA, Llamma.cpp and the future of LLM Inference', sections=[Section(section_title='Introduction', description='Overview of Groq, NVIDIA, Llamma.cpp, and their significance in the field of La\n", "refine_outline\n", - "-- {'topic': 'NVIDIA 2024 Q1 earnings report', 'outline': Outline(page_title='Impact of Million-Plus Token Context Window Language Models on RAG', sections=[Section(section_title='Introduction', description='An overview of the article, including the significance of million-plus token context window lan\n", + "-- {'topic': 'Groq, NVIDIA, Llamma.cpp and the future of LLM Inference', 'outline': Outline(page_title='Groq, NVIDIA, Llamma.cpp and the Future of LLM Inference', sections=[Section(section_title='Introduction', description='An overview of the significance and roles of Groq, NVIDIA, and Llamma.cpp in th\n", "index_references\n", - "-- {'topic': 'NVIDIA 2024 Q1 earnings report', 'outline': Outline(page_title='Impact of Million-Plus Token Context Window Language Models on RAG', sections=[Section(section_title='Introduction', description='An overview of the article, including the significance of million-plus token context window lan\n", - "NVIDIA 2024 Q1 earnings report Introduction\n", - "NVIDIA 2024 Q1 earnings report Background\n", - "NVIDIA 2024 Q1 earnings report Impact of Large Context Windows on RAG\n", - "NVIDIA 2024 Q1 earnings report Case Studies\n", - "NVIDIA 2024 Q1 earnings report RAG's Use of External Knowledge Sources\n", - "NVIDIA 2024 Q1 earnings report Future Outlook\n", - "NVIDIA 2024 Q1 earnings report Conclusions\n", - "NVIDIA 2024 Q1 earnings report References\n", + "-- {'topic': 'Groq, NVIDIA, Llamma.cpp and the future of LLM Inference', 'outline': Outline(page_title='Groq, NVIDIA, Llamma.cpp and the Future of LLM Inference', sections=[Section(section_title='Introduction', description='An overview of the significance and roles of Groq, NVIDIA, and Llamma.cpp in th\n", "write_sections\n", - "-- {'topic': 'NVIDIA 2024 Q1 earnings report', 'outline': Outline(page_title='Impact of Million-Plus Token Context Window Language Models on RAG', sections=[Section(section_title='Introduction', description='An overview of the article, including the significance of million-plus token context window lan\n", + "-- {'topic': 'Groq, NVIDIA, Llamma.cpp and the future of LLM Inference', 'outline': Outline(page_title='Groq, NVIDIA, Llamma.cpp and the Future of LLM Inference', sections=[Section(section_title='Introduction', description='An overview of the significance and roles of Groq, NVIDIA, and Llamma.cpp in th\n", "write_article\n", - "-- {'topic': 'NVIDIA 2024 Q1 earnings report', 'outline': Outline(page_title='Impact of Million-Plus Token Context Window Language Models on RAG', sections=[Section(section_title='Introduction', description='An overview of the article, including the significance of million-plus token context window lan\n", + "-- {'topic': 'Groq, NVIDIA, Llamma.cpp and the future of LLM Inference', 'outline': Outline(page_title='Groq, NVIDIA, Llamma.cpp and the Future of LLM Inference', sections=[Section(section_title='Introduction', description='An overview of the significance and roles of Groq, NVIDIA, and Llamma.cpp in th\n", "__end__\n", - "-- {'topic': 'NVIDIA 2024 Q1 earnings report', 'outline': Outline(page_title='Impact of Million-Plus Token Context Window Language Models on RAG', sections=[Section(section_title='Introduction', description='An overview of the article, including the significance of million-plus token context window lan\n" + "-- {'topic': 'Groq, NVIDIA, Llamma.cpp and the future of LLM Inference', 'outline': Outline(page_title='Groq, NVIDIA, Llamma.cpp and the Future of LLM Inference', sections=[Section(section_title='Introduction', description='An overview of the significance and roles of Groq, NVIDIA, and Llamma.cpp in th\n" ] } ], "source": [ "async for step in storm.astream(\n", " {\n", - " \"topic\": \"NVIDIA 2024 Q1 earnings report\",\n", + " \"topic\": \"Groq, NVIDIA, Llamma.cpp and the future of LLM Inference\",\n", " }\n", "):\n", " name = next(iter(step))\n", @@ -1483,79 +1522,95 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 82, "metadata": {}, "outputs": [], "source": [ "article = results[END][\"article\"]" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Render the Wiki\n", + "\n", + "Now we can render the final wiki page!" + ] + }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 83, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "# Impact of Million-Plus Token Context Window Language Models on RAG\n", - "\n", - "The **Impact of Million-Plus Token Context Window Language Models on Retrieval-Augmented Generation (RAG)** reflects a significant advancement in the field of natural language processing (NLP) and artificial intelligence (AI). This development has broadened the capabilities of AI systems in understanding and generating human-like text by integrating large-scale language models with external knowledge sources to produce contextually rich responses.\n", - "\n", - "## Contents\n", - "\n", - "- [Introduction](#Introduction)\n", - "- [Background](#Background)\n", - "- [Impact of Million-Plus Token Context Window Language Models on RAG](#Impact-of-Million-Plus-Token-Context-Window-Language-Models-on-RAG)\n", - " - [The Evolution of Large Context Windows in Language Models](#The-Evolution-of-Large-Context-Windows-in-Language-Models)\n", - " - [Integration Challenges with RAG](#Integration-Challenges-with-RAG)\n", - " - [Enhancing RAG with External Knowledge Sources](#Enhancing-RAG-with-External-Knowledge-Sources)\n", - " - [Applications and Future Directions](#Applications-and-Future-Directions)\n", - "- [Case Studies](#Case-Studies)\n", - "- [Conclusions](#Conclusions)\n", - "- [References](#References)\n", - "\n", - "## Introduction\n", - "\n", - "The advent of million-plus token context window language models marks a significant milestone in NLP and AI. These models process and understand vast amounts of text, enhancing machine learning applications, particularly in text generation and comprehension. The integration within the RAG framework improves accuracy, relevancy, and contextual richness of responses, addressing limitations of traditional language models.\n", - "\n", - "## Background\n", - "\n", - "The development of large language models (LLMs) with increasing parameter sizes and context windows has enhanced their capability to generate coherent and contextually relevant text outputs. The expansion of the context window has been crucial for understanding and generating complex texts. RAG, by integrating external knowledge sources, allows LLMs to provide more accurate and updated responses, opening new possibilities in NLP.\n", - "\n", - "## Impact of Million-Plus Token Context Window Language Models on RAG\n", - "\n", - "### The Evolution of Large Context Windows in Language Models\n", - "Models like Gemini 1.5, Mixtral, and GPT-3.5-Turbo-16k have pushed technical boundaries, addressing challenges in increasing context window size, enhancing understanding and text generation capabilities.\n", - "\n", - "### Integration Challenges with RAG\n", - "Integrating these models into RAG frameworks introduces challenges such as high fine-tuning costs and managing catastrophic values. Technological innovations and approaches to mitigate these effects are crucial for successful integration.\n", - "\n", - "### Enhancing RAG with External Knowledge Sources\n", - "The integration benefits RAG by addressing challenges like hallucination and outdated knowledge, leveraging up-to-date information to enhance response accuracy and credibility.\n", - "\n", - "### Applications and Future Directions\n", - "This integration opens up applications in chatbots, content creation, and information retrieval. Future developments aim to improve these models' efficiency, accuracy, and application breadth.\n", - "\n", - "## Case Studies\n", - "\n", - "Specific case studies demonstrate practical applications and challenges in integrating advanced language models with RAG, highlighting improvements in retrieval capabilities, data efficiency, and addressing information overload.\n", - "\n", - "## Conclusions\n", - "\n", - "The integration of million-plus token context window language models with RAG has significantly advanced NLP capabilities, enhancing machine understanding and generation of human language. Despite challenges, technological and strategic advancements continue to push the boundaries of what is possible in NLP, promising more sophisticated and nuanced AI-driven technologies.\n", - "\n", - "## References\n", - "\n", - "1. NVIDIA Announces Financial Results for First Quarter Fiscal 2024. [NVIDIA News](https://nvidianews.nvidia.com/news/nvidia-announces-financial-results-for-first-quarter-fiscal-2024)\n", - "\n", - "2. Nvidia Q1 Earnings Report. [InvestorPlace](https://investorplace.com/market360/2023/05/nvidia-q1-earnings-report/)\n" - ] + "data": { + "text/markdown": [ + "# Large Language Model (LLM) Inference Technologies\n", + "\n", + "### Contents\n", + "1. [Introduction](#Introduction)\n", + "2. [Groq's Advancements in LLM Inference](#Groqs-Advancements-in-LLM-Inference)\n", + "3. [NVIDIA's Contributions to LLM Inference](#NVIDIAs-Contributions-to-LLM-Inference)\n", + " 1. [Hardware Innovations](#Hardware-Innovations)\n", + " 2. [Software Solutions](#Software-Solutions)\n", + " 3. [Research and Development](#Research-and-Development)\n", + "4. [Llamma.cpp: Accelerating LLM Inference](#Llammacpp-Accelerating-LLM-Inference)\n", + "5. [The Future of LLM Inference](#The-Future-of-LLM-Inference)\n", + "6. [References](#References)\n", + "\n", + "### Introduction\n", + "\n", + "The advent of million-plus token context window language models, such as Gemini 1.5, has significantly advanced the field of artificial intelligence, particularly in natural language processing (NLP). These models have expanded the capabilities of machine learning in understanding and generating text over vastly larger contexts than previously possible. This leap in technology has paved the way for transformative applications across various domains, including the integration into Retrieval-Augmented Generation (RAG) systems to produce more accurate and contextually rich responses. \n", + "\n", + "### Groq's Advancements in LLM Inference\n", + "\n", + "Groq has introduced the Groq Linear Processor Unit (LPU), a purpose-built hardware architecture for LLM inference. This innovation positions Groq as a leader in efficient and high-performance LLM processing by optimizing the hardware specifically for LLM tasks. The Groq LPU dramatically reduces latency and increases the throughput of LLM inferences, facilitating advancements in a wide range of applications, from natural language processing to broader artificial intelligence technologies[1].\n", + "\n", + "### NVIDIA's Contributions to LLM Inference\n", + "\n", + "NVIDIA has played a pivotal role in advancing LLM inference through its GPUs, optimized for AI and machine learning workloads, and specialized software frameworks. The company's GPU architecture and software solutions, such as the CUDA Deep Neural Network library (cuDNN) and the TensorRT inference optimizer, are designed to accelerate computational processes and improve LLM performance. NVIDIA's active participation in research and development further underscores its commitment to enhancing the capabilities of LLMs[1].\n", + "\n", + "#### Hardware Innovations\n", + "\n", + "NVIDIA's GPU architecture facilitates high throughput and parallel processing for LLM inference tasks, significantly reducing inference time and enabling complex models to be used in real-time applications.\n", + "\n", + "#### Software Solutions\n", + "\n", + "NVIDIA's suite of software tools, including cuDNN and TensorRT, optimizes LLM performance on its hardware, streamlining the deployment of LLMs by improving their efficiency and reducing latency.\n", + "\n", + "#### Research and Development\n", + "\n", + "NVIDIA collaborates with academic and industry partners to develop new techniques and models that push the boundaries of LLM technology, aiming to make LLMs more powerful and applicable across a broader range of tasks.\n", + "\n", + "### Llamma.cpp: Accelerating LLM Inference\n", + "\n", + "Llamma.cpp is a framework developed to enhance the speed and efficiency of LLM inference. By integrating specialized hardware, such as Groq's LPU, and optimizing for parallel processing, Llamma.cpp significantly accelerates computation times and reduces energy consumption. The framework supports million-plus token context window models, enabling applications requiring deep contextual understanding and extensive knowledge retrieval[1][2].\n", + "\n", + "### The Future of LLM Inference\n", + "\n", + "The future of LLM inference is poised for transformative changes with advances in purpose-built hardware architectures like Groq's LPU. These innovations promise to enhance the speed and efficiency of LLM processing, leading to more interactive, capable, and integrated AI applications. The potential for advanced hardware and sophisticated LLMs to enable near-instantaneous processing of complex queries and interactions opens new avenues for research and application in various fields, suggesting a future where AI is seamlessly integrated into society[1][2].\n", + "\n", + "### References\n", + "\n", + "[1] \"Groq's LPU: Advancing LLM Inference Efficiency,\" Prompt Engineering. https://promptengineering.org/groqs-lpu-advancing-llm-inference-efficiency/\n", + "\n", + "[2] \"The Speed of Thought: Harnessing the Fastest LLM with Groq's LPU,\" Medium. https://medium.com/@anasdavoodtk1/the-speed-of-thought-harnessing-the-fastest-llm-with-groqs-lpu-11bb00864e9c" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "print(article)" + "from IPython.display import Markdown\n", + "\n", + "# We will down-header the sections to create less confusion in this notebook\n", + "Markdown(article.replace(\"\\n#\", \"\\n##\"))" ] }, {