<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" ><generator uri="https://jekyllrb.com/" version="3.10.0">Jekyll</generator><link href="nullskymc.cloud/feed.xml" rel="self" type="application/atom+xml" /><link href="nullskymc.cloud/" rel="alternate" type="text/html" /><updated>2025-01-12T04:18:26+00:00</updated><id>nullskymc.cloud/feed.xml</id><title type="html">Nullskymc</title><subtitle>For future_实现未来</subtitle><entry><title type="html">每日花钱助手——RAG-Agent智能对话机器人</title><link href="nullskymc.cloud/camp/" rel="alternate" type="text/html" title="每日花钱助手——RAG-Agent智能对话机器人" /><published>2024-08-17T00:00:00+00:00</published><updated>2024-08-17T00:00:00+00:00</updated><id>nullskymc.cloud/camp</id><content type="html" xml:base="nullskymc.cloud/camp/"><![CDATA[<p>项目名称：每日花钱助手——RAG-Agent智能对话机器人</p>

<p>报告日期：2024年8月18日</p>

<p>项目负责人：吃不饱的null</p>

<h2 id="项目概述">项目概述</h2>

<p>本项目旨在开发一个基于RAG（Retrieval-Augmented Generation）的智能对话机器人，能够进行文字形式的聊天，并拓展了Agent智能体。通过了解用户的每日花钱记录，计算支出总额，理解支出的类型与特点，帮助用户更好的管理财务。</p>

<p>本项目使用langchain作为处理项目逻辑的核心库，langchain是一个用于拓展LLM能力，实现Agent等功能的库。</p>

<p>通常情况下，LLM的知识是静态的，停留在模型训练时的知识。因此，当LLM接受到一个问题，它只能回答它已知的部分,遇到现有知识无法回答的问题，LLM会编造错误的回答或是重复问题，这一现象称为“大模型幻觉”。</p>

<p>为了解决这一问题，我们引入了RAG（Retrieval-Augmented Generation）模型。RAG模型结合了检索和生成的优势，通过特定领域的向量数据库，能够在对话过程中提供更加准确的回答。同时，鉴于微调模型需要耗费大量计算资源，使用RAG是更经济效率的选择。</p>

<h3 id="技术方案与实施步骤">技术方案与实施步骤</h3>

<h4 id="模型选择">模型选择</h4>

<p>本项目使用NVIDIA NIM平台上的microsoft/phi-3-small-128k-instruct模型，用于处理文本数据，分析情感，执行外部tools，为用户提供每日贴心tips。</p>

<h4 id="数据的构建">数据的构建</h4>

<p>针对特定领域进行数据构建，包括对话语料、知识库等。通过向量化处理，将文本数据转换为向量形式，方便模型处理。</p>

<p>向量化处理就是通过embedding模型将各种文本或多模态的数据标注为词向量，存入到向量数据库中。LLM在接收到问题时，会先通过检索模块在向量数据库中找到相似的知识，据此生成回答。</p>

<p>通过向量化处理文本或多模态的知识，可以有效避免LLM的“大模型幻觉”，提高对话的准确性，在特定领域的应用中具有广泛的前景。</p>

<h4 id="功能整合">功能整合</h4>

<p>在RAG的基础上，通过langchain的agent的模块，可以让LLM从局限的文本对话中拓展到多功能的Agent智能体，能够执行外部任务，获取外部信息。</p>

<p>比如，LLM并不知道现在的时间，知识库实际上也无法解决这个问题。但是，通过拓展tools，LLM可以调用时间API，获取当前时间，并返回给用户。</p>

<p>创建一个Agent，能够把用户的每日花钱记录，计算支出总额，合成为一个合适的sqlite表，作为tools使用，定义一个代码解释器,让LLM执行生成的代码，从数据库中获取数据，计算支出特点，最终实现完整的主动性Agent chain。</p>

<h3 id="实施步骤">实施步骤</h3>

<p>在实现以上基础函数后，就可以搭建一个基于RAG的智能对话机器人了。下面是一个实现之一：</p>

<h4 id="环境搭建">环境搭建</h4>

<p>创建一个新的virtualenv环境，安装必要的库：</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>python <span class="nt">-m</span> venv <span class="nb">env
source env</span>/bin/activate
pip <span class="nb">install </span>langchain, faiss-cpu, langchain_community, langchain_nvidia_ai_endpoints,openai
</code></pre></div></div>

<p>这里使用NVIDIANIM平台的模型，需要在NIM平台上注册并获取API key。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain_nvidia_ai_endpoints</span> <span class="kn">import</span> <span class="n">NVIDIAEmbeddings</span><span class="p">,</span><span class="n">ChatNVDIA</span>
<span class="n">embedder</span> <span class="o">=</span> <span class="n">NVIDIAEmbeddings</span><span class="p">(</span><span class="n">model</span><span class="o">=</span><span class="s">"NV-Embed-QA"</span><span class="p">)</span>
<span class="n">llm</span> <span class="o">=</span> <span class="n">ChatNVIDIA</span><span class="p">(</span><span class="n">model</span><span class="o">=</span><span class="s">"microsoft/phi-3-small-128k-instruct"</span><span class="p">,</span> <span class="n">nvidia_api_key</span><span class="o">=&lt;</span><span class="n">YOUR_API_KEY</span><span class="o">&gt;</span><span class="p">,</span> <span class="n">max_tokens</span><span class="o">=</span><span class="mi">1024</span><span class="p">)</span>
</code></pre></div></div>

<p>导入必要的模块：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain_community.document_loaders</span> <span class="kn">import</span> <span class="n">TextLoader</span>
<span class="kn">from</span> <span class="nn">langchain_community.vectorstores</span> <span class="kn">import</span> <span class="n">FAISS</span>
<span class="kn">from</span> <span class="nn">langchain_text_splitters</span> <span class="kn">import</span> <span class="n">CharacterTextSplitter</span>
<span class="kn">from</span> <span class="nn">langchain.chains.combine_documents</span> <span class="kn">import</span> <span class="n">create_stuff_documents_chain</span>
<span class="kn">from</span> <span class="nn">langchain.chains.retrieval</span> <span class="kn">import</span> <span class="n">create_retrieval_chain</span>
<span class="kn">from</span> <span class="nn">langchain_core.prompts</span> <span class="kn">import</span> <span class="n">ChatPromptTemplate</span>
</code></pre></div></div>

<h4 id="代码实现">代码实现：</h4>

<p>实现RAG的核心代码如下：</p>

<p>在本项目中，使用faiss这个轻量化的向量数据库构造retriver模块，实现检索功能。代码简单演示如下：</p>

<p>在这里导入embediings模型，用于向量化数据，使用text_loader将文本文件转换为可接受的输入格式。</p>

<p>使用CharacterTextSplitter将文档切分为合适的大小，其中chunk_size是切分文档的大小，根据文档大小调整，不同的文档大小会影响检索的效率。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">embedder</span> <span class="o">=</span> <span class="n">NVIDIAEmbeddings</span><span class="p">(</span><span class="n">model</span><span class="o">=</span><span class="s">"NV-Embed-QA"</span><span class="p">)</span>

<span class="k">def</span> <span class="nf">text_loader</span><span class="p">(</span><span class="n">url</span><span class="p">):</span>
    <span class="c1"># 文本文档加载器
</span>    <span class="n">loader</span> <span class="o">=</span> <span class="n">TextLoader</span><span class="p">(</span><span class="n">url</span><span class="p">)</span>
    <span class="n">docs</span> <span class="o">=</span> <span class="n">loader</span><span class="p">.</span><span class="n">load</span><span class="p">()</span>
    <span class="k">return</span> <span class="n">docs</span>

<span class="k">def</span> <span class="nf">create_vector_db</span><span class="p">(</span><span class="n">data_path</span><span class="p">,</span> <span class="n">db_path</span><span class="p">,</span> <span class="n">loader</span><span class="p">):</span>
    <span class="n">text_splitter</span> <span class="o">=</span> <span class="n">CharacterTextSplitter</span><span class="p">(</span><span class="n">chunk_size</span><span class="o">=</span><span class="mi">2048</span><span class="p">)</span>
    <span class="n">data</span> <span class="o">=</span> <span class="n">loader</span><span class="p">(</span><span class="n">data_path</span><span class="p">)</span>
    <span class="n">docs</span> <span class="o">=</span> <span class="n">text_splitter</span><span class="p">.</span><span class="n">split_documents</span><span class="p">(</span><span class="n">data</span><span class="p">)</span>
    <span class="n">db</span> <span class="o">=</span> <span class="n">FAISS</span><span class="p">.</span><span class="n">from_documents</span><span class="p">(</span><span class="n">docs</span><span class="p">,</span> <span class="n">embeddings</span><span class="p">)</span>
    <span class="n">db</span><span class="p">.</span><span class="n">save_local</span><span class="p">(</span><span class="n">db_path</span><span class="p">)</span>  <span class="c1"># 保存路径
</span>
<span class="n">create_vector_db</span><span class="p">(</span><span class="s">"data.txt"</span><span class="p">,</span> <span class="s">"db"</span><span class="p">,</span> <span class="n">text_loader</span><span class="p">)</span>
</code></pre></div></div>

<p>使用ChatPromptTemplate生成问题模板，根据context和input生成问题。context即为知识库检索后的文本内容，用于提交与用户问题相近的知识。</p>

<p>需要注意的是FAISS.load_local()函数，需要设置allow_dangerous_deserialization=True，以允许从本地加载向量数据库。</p>

<p>通过langchain包装完全的create_stuff_documents_chain和create_retrieval_chain，实现检索功能。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">rag</span><span class="p">(</span><span class="n">msg</span><span class="p">):</span>
    <span class="n">prompt</span> <span class="o">=</span> <span class="n">ChatPromptTemplate</span><span class="p">.</span><span class="n">from_template</span><span class="p">(</span>
        <span class="s">"""
        以下问题基于提供的 context，分析问题并给出合理的建议回答：
        &lt;context&gt;
        {context}
        &lt;/context&gt;
        Question: {input}
        """</span>
    <span class="p">)</span>

    <span class="n">new_db</span> <span class="o">=</span> <span class="n">FAISS</span><span class="p">.</span><span class="n">load_local</span><span class="p">(</span><span class="s">"db"</span><span class="p">,</span> <span class="n">embedder</span><span class="p">,</span> <span class="n">allow_dangerous_deserialization</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
    <span class="n">document_chain</span> <span class="o">=</span> <span class="n">create_stuff_documents_chain</span><span class="p">(</span><span class="n">llm</span><span class="p">,</span> <span class="n">prompt</span><span class="p">)</span>
    <span class="n">retriever</span> <span class="o">=</span> <span class="n">new_db</span><span class="p">.</span><span class="n">as_retriever</span><span class="p">()</span>  <span class="c1"># 从向量数据库中检索
</span>    <span class="n">retrieval_chain</span> <span class="o">=</span> <span class="n">create_retrieval_chain</span><span class="p">(</span><span class="n">retriever</span><span class="p">,</span> <span class="n">document_chain</span><span class="p">)</span>
    <span class="n">gpt_response</span> <span class="o">=</span> <span class="n">retrieval_chain</span><span class="p">.</span><span class="n">invoke</span><span class="p">({</span><span class="s">"input"</span><span class="p">:</span> <span class="n">msg</span><span class="p">})</span>
    <span class="n">response</span> <span class="o">=</span> <span class="n">gpt_response</span><span class="p">[</span><span class="s">'answer'</span><span class="p">]</span>

    <span class="k">return</span> <span class="n">response</span>

<span class="k">print</span><span class="p">(</span><span class="n">rag</span><span class="p">(</span><span class="s">"你好"</span><span class="p">))</span>
</code></pre></div></div>

<p>到现在就实现了一个简单的RAG过程，LLM根据知识库的知识，给出了一个回答。但是，为了实现Agent的功能，还需要进一步拓展。</p>

<p>LLM需要执行外部任务，获取外部信息，这就需要使用tools模块。定义合适可用的tools，让LLM执行生成的代码，保存到数据库等等。</p>

<p>把实现RAG的retriever包装成一个tool,这样LLM可以基于已有的知识库来进行之后的外部tools执行，强化LLM的主动性。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">db_path</span> <span class="o">=</span> <span class="s">"db"</span>
<span class="n">new_db</span> <span class="o">=</span> <span class="n">FAISS</span><span class="p">.</span><span class="n">load_local</span><span class="p">(</span><span class="n">db_path</span><span class="p">,</span> <span class="n">embeddings</span><span class="p">,</span> <span class="n">allow_dangerous_deserialization</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
<span class="n">retriever</span> <span class="o">=</span> <span class="n">new_db</span><span class="p">.</span><span class="n">as_retriever</span><span class="p">()</span>  <span class="c1"># 从向量数据库中检索
</span><span class="n">retriever_tool</span> <span class="o">=</span> <span class="n">create_retriever_tool</span><span class="p">(</span>
    <span class="n">retriever</span><span class="p">,</span>
    <span class="s">"知识库"</span><span class="p">,</span>
    <span class="s">"这里存储着有关于问题的背景资料，you must use this tool!"</span><span class="p">,</span>
<span class="p">)</span>
</code></pre></div></div>

<p>在这里，我们定义一个代码解释器，让LLM执行生成的代码，使用langchain提供的tool装饰器。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain.agents</span> <span class="kn">import</span> <span class="n">initialize_agent</span>
<span class="kn">from</span> <span class="nn">langchain.memory</span> <span class="kn">import</span> <span class="n">ConversationBufferWindowMemory</span>
<span class="kn">from</span> <span class="nn">langchain.tools</span> <span class="kn">import</span> <span class="n">tool</span>
<span class="kn">from</span> <span class="nn">langchain.tools.retriever</span> <span class="kn">import</span> <span class="n">create_retriever_tool</span>

<span class="k">def</span> <span class="nf">execute_and_return</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
    <span class="n">code</span> <span class="o">=</span> <span class="n">extract_python_code</span><span class="p">(</span><span class="n">x</span><span class="p">.</span><span class="n">content</span><span class="p">)[</span><span class="mi">0</span><span class="p">]</span>
    <span class="k">try</span><span class="p">:</span>
        <span class="n">result</span> <span class="o">=</span> <span class="k">exec</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">code</span><span class="p">))</span>
        <span class="k">return</span> <span class="s">"exec result: "</span> <span class="o">+</span> <span class="n">result</span>
    <span class="k">except</span> <span class="n">ExceptionType</span><span class="p">:</span>
       <span class="k">return</span> <span class="s">"The code is not executable, don't give up, try again!"</span>

<span class="o">@</span><span class="n">tool</span>
<span class="k">def</span> <span class="nf">interpreter</span><span class="p">(</span><span class="n">code</span><span class="p">:</span> <span class="nb">str</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
    <span class="s">"""
    此函数解释并执行提供的代码，严格去除首行出现的缩进并保证代码符合Python语法。
    """</span>
    <span class="k">return</span> <span class="n">execute_and_return</span><span class="p">(</span><span class="n">code</span><span class="p">)</span>

<span class="o">@</span><span class="n">tool</span>
<span class="k">def</span> <span class="nf">save_to_db</span><span class="p">(</span><span class="n">data</span><span class="p">:</span> <span class="nb">str</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
    <span class="s">"""
    此函数将数据保存到数据库中。
    """</span>
    <span class="n">db</span> <span class="o">=</span> <span class="n">sqlite3</span><span class="p">.</span><span class="n">connect</span><span class="p">(</span><span class="s">'data.db'</span><span class="p">)</span>
    <span class="n">cursor</span> <span class="o">=</span> <span class="n">db</span><span class="p">.</span><span class="n">cursor</span><span class="p">()</span>
    <span class="n">cursor</span><span class="p">.</span><span class="n">execute</span><span class="p">(</span><span class="n">data</span><span class="p">)</span>
    <span class="n">db</span><span class="p">.</span><span class="n">commit</span><span class="p">()</span>
    <span class="n">db</span><span class="p">.</span><span class="n">close</span><span class="p">()</span>
    <span class="k">return</span> <span class="s">"Data saved to database."</span>

<span class="o">@</span><span class="n">tool</span>
<span class="k">def</span> <span class="nf">get_from_db</span><span class="p">(</span><span class="n">data</span><span class="p">:</span> <span class="nb">str</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
    <span class="s">"""
    此函数从数据库中获取数据。
    """</span>
    <span class="n">db</span> <span class="o">=</span> <span class="n">sqlite3</span><span class="p">.</span><span class="n">connect</span><span class="p">(</span><span class="s">'data.db'</span><span class="p">)</span>
    <span class="n">cursor</span> <span class="o">=</span> <span class="n">db</span><span class="p">.</span><span class="n">cursor</span><span class="p">()</span>
    <span class="n">cursor</span><span class="p">.</span><span class="n">execute</span><span class="p">(</span><span class="n">data</span><span class="p">)</span>
    <span class="n">result</span> <span class="o">=</span> <span class="n">cursor</span><span class="p">.</span><span class="n">fetchall</span><span class="p">()</span>
    <span class="n">db</span><span class="p">.</span><span class="n">close</span><span class="p">()</span>
    <span class="k">return</span> <span class="n">result</span>

<span class="n">tools</span> <span class="o">=</span> <span class="p">[</span><span class="n">interpreter</span><span class="p">,</span> <span class="n">save_to_db</span><span class="p">,</span> <span class="n">get_from_db</span><span class="p">,</span> <span class="n">retriever_tool</span><span class="p">]</span>
</code></pre></div></div>

<p>后面就可以使用这些tools，实现Agent的功能，让LLM执行外部任务，获取外部信息。</p>

<p>conversation_buffer_window_memory是一个用于存储对话历史的内存模块，可以用于实现对话的记忆功能。在这里，我们使用它来存储对话历史，实现对话的连贯性。</p>

<p>initialize_agent函数用于初始化一个Agent，可以指定tools，memory，verbose等参数，实现Agent的功能。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">memory</span> <span class="o">=</span> <span class="n">ConversationBufferWindowMemory</span><span class="p">(</span><span class="n">memory_key</span><span class="o">=</span><span class="s">'chat_history'</span><span class="p">,</span> <span class="n">k</span><span class="o">=</span><span class="mi">3</span><span class="p">,</span> <span class="n">return_messages</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
<span class="n">chat_agent</span> <span class="o">=</span> <span class="n">initialize_agent</span><span class="p">(</span>
    <span class="n">agent</span><span class="o">=</span><span class="s">'chat-conversational-react-description'</span><span class="p">,</span>
    <span class="n">tools</span><span class="o">=</span><span class="n">tools</span><span class="p">,</span>
    <span class="n">memory</span><span class="o">=</span><span class="n">memory</span><span class="p">,</span>
    <span class="n">verbose</span><span class="o">=</span><span class="bp">True</span><span class="p">,</span>
    <span class="n">max_interations</span><span class="o">=</span><span class="mi">3</span><span class="p">,</span>
    <span class="n">llm</span><span class="o">=</span><span class="n">llm</span><span class="p">,</span>
    <span class="n">handle_prasing_error</span><span class="o">=</span><span class="bp">True</span>
<span class="p">)</span>
<span class="n">query</span> <span class="o">=</span> <span class="s">"今天买菜花了30，买了一些蔬菜和水果。"</span>
<span class="n">response</span> <span class="o">=</span> <span class="n">chat_agent</span><span class="p">.</span><span class="n">invoke</span><span class="p">(</span><span class="n">query</span><span class="p">)</span>
<span class="k">print</span><span class="p">(</span><span class="n">response</span><span class="p">)</span>
<span class="n">query</span> <span class="o">=</span> <span class="s">"到数据库中查询今天的花费"</span>
<span class="n">response</span> <span class="o">=</span> <span class="n">chat_agent</span><span class="p">.</span><span class="n">invoke</span><span class="p">(</span><span class="n">query</span><span class="p">)</span>
<span class="k">print</span><span class="p">(</span><span class="n">response</span><span class="p">)</span>
</code></pre></div></div>

<h3 id="项目成果与展示">项目成果与展示</h3>

<h4 id="应用场景展示">应用场景展示</h4>

<p>助手适合个人或家庭在生活中使用，以自然语言的方式记录每日花费，计算支出总额，理解支出的类型与特点，帮助用户更好的管理财务。</p>

<h4 id="功能演示">功能演示</h4>

<p>根据自然语言输入，用户将个人的每日花费，支出类型等信息输入到助手中，Agent执行外部海马，从外部数据库中CURD数据，个性化总结，理解用户，提供更好的建议。</p>

<h3 id="问题与解决方案">问题与解决方案</h3>

<p>实际使用中，受限于最大Token和问题，LLM很可能不会使用外部的tools，导致回答偏离预期。</p>

<h4 id="问题分析">问题分析</h4>

<p>问题不够明确，没有主动引导LLM使用tools，导致LLM无法执行外部任务，获取外部信息。</p>

<h4 id="解决措施">解决措施</h4>

<p>强化prompt，绝对引导LLM使用tools，保证LLM执行外部任务，获取外部信息。</p>

<h2 id="项目总结与展望">项目总结与展望</h2>

<h3 id="项目评估">项目评估</h3>

<p>技术实现初步达到预期，RAG模型能够在特定领域提供更加准确的回答，但是在数值理解和具体的财务分析上，还有待提高。</p>

<h3 id="未来方向">未来方向</h3>

<p>优化RAG模式，采取GraphRAG或更多rag方式，优化获取信息的模式，并存取更高质量的数据，提高对话的准确性。建立一个美观的前端界面，提供更好的用户体验。</p>

<h2 id="附件与参考资料">附件与参考资料</h2>

<p><a href="https://github.com/kinfey/Microsoft-Phi-3-NvidiaNIMWorkshop?tab=readme-ov-file">Microsoft-Phi-3-NvidiaNIMWorkshop</a></p>

<p><a href="https://python.langchain.com/v0.2/docs">Langchain doc</a></p>]]></content><author><name></name></author><category term="ai" /><category term="rag" /><category term="agent" /><category term="langchain" /><summary type="html"><![CDATA[项目名称：每日花钱助手——RAG-Agent智能对话机器人 报告日期：2024年8月18日 项目负责人：吃不饱的null 项目概述 本项目旨在开发一个基于RAG（Retrieval-Augmented Generation）的智能对话机器人，能够进行文字形式的聊天，并拓展了Agent智能体。通过了解用户的每日花钱记录，计算支出总额，理解支出的类型与特点，帮助用户更好的管理财务。 本项目使用langchain作为处理项目逻辑的核心库，langchain是一个用于拓展LLM能力，实现Agent等功能的库。 通常情况下，LLM的知识是静态的，停留在模型训练时的知识。因此，当LLM接受到一个问题，它只能回答它已知的部分,遇到现有知识无法回答的问题，LLM会编造错误的回答或是重复问题，这一现象称为“大模型幻觉”。 为了解决这一问题，我们引入了RAG（Retrieval-Augmented Generation）模型。RAG模型结合了检索和生成的优势，通过特定领域的向量数据库，能够在对话过程中提供更加准确的回答。同时，鉴于微调模型需要耗费大量计算资源，使用RAG是更经济效率的选择。 技术方案与实施步骤 模型选择 本项目使用NVIDIA NIM平台上的microsoft/phi-3-small-128k-instruct模型，用于处理文本数据，分析情感，执行外部tools，为用户提供每日贴心tips。 数据的构建 针对特定领域进行数据构建，包括对话语料、知识库等。通过向量化处理，将文本数据转换为向量形式，方便模型处理。 向量化处理就是通过embedding模型将各种文本或多模态的数据标注为词向量，存入到向量数据库中。LLM在接收到问题时，会先通过检索模块在向量数据库中找到相似的知识，据此生成回答。 通过向量化处理文本或多模态的知识，可以有效避免LLM的“大模型幻觉”，提高对话的准确性，在特定领域的应用中具有广泛的前景。 功能整合 在RAG的基础上，通过langchain的agent的模块，可以让LLM从局限的文本对话中拓展到多功能的Agent智能体，能够执行外部任务，获取外部信息。 比如，LLM并不知道现在的时间，知识库实际上也无法解决这个问题。但是，通过拓展tools，LLM可以调用时间API，获取当前时间，并返回给用户。 创建一个Agent，能够把用户的每日花钱记录，计算支出总额，合成为一个合适的sqlite表，作为tools使用，定义一个代码解释器,让LLM执行生成的代码，从数据库中获取数据，计算支出特点，最终实现完整的主动性Agent chain。 实施步骤 在实现以上基础函数后，就可以搭建一个基于RAG的智能对话机器人了。下面是一个实现之一： 环境搭建 创建一个新的virtualenv环境，安装必要的库： python -m venv env source env/bin/activate pip install langchain, faiss-cpu, langchain_community, langchain_nvidia_ai_endpoints,openai 这里使用NVIDIANIM平台的模型，需要在NIM平台上注册并获取API key。 from langchain_nvidia_ai_endpoints import NVIDIAEmbeddings,ChatNVDIA embedder = NVIDIAEmbeddings(model="NV-Embed-QA") llm = ChatNVIDIA(model="microsoft/phi-3-small-128k-instruct", nvidia_api_key=&lt;YOUR_API_KEY&gt;, max_tokens=1024) 导入必要的模块： from langchain_community.document_loaders import TextLoader from langchain_community.vectorstores import FAISS from langchain_text_splitters import CharacterTextSplitter from langchain.chains.combine_documents import create_stuff_documents_chain from langchain.chains.retrieval import create_retrieval_chain from langchain_core.prompts import ChatPromptTemplate 代码实现： 实现RAG的核心代码如下： 在本项目中，使用faiss这个轻量化的向量数据库构造retriver模块，实现检索功能。代码简单演示如下： 在这里导入embediings模型，用于向量化数据，使用text_loader将文本文件转换为可接受的输入格式。 使用CharacterTextSplitter将文档切分为合适的大小，其中chunk_size是切分文档的大小，根据文档大小调整，不同的文档大小会影响检索的效率。 embedder = NVIDIAEmbeddings(model="NV-Embed-QA") def text_loader(url): # 文本文档加载器 loader = TextLoader(url) docs = loader.load() return docs def create_vector_db(data_path, db_path, loader): text_splitter = CharacterTextSplitter(chunk_size=2048) data = loader(data_path) docs = text_splitter.split_documents(data) db = FAISS.from_documents(docs, embeddings) db.save_local(db_path) # 保存路径 create_vector_db("data.txt", "db", text_loader) 使用ChatPromptTemplate生成问题模板，根据context和input生成问题。context即为知识库检索后的文本内容，用于提交与用户问题相近的知识。 需要注意的是FAISS.load_local()函数，需要设置allow_dangerous_deserialization=True，以允许从本地加载向量数据库。 通过langchain包装完全的create_stuff_documents_chain和create_retrieval_chain，实现检索功能。 def rag(msg): prompt = ChatPromptTemplate.from_template( """ 以下问题基于提供的 context，分析问题并给出合理的建议回答： &lt;context&gt; {context} &lt;/context&gt; Question: {input} """ ) new_db = FAISS.load_local("db", embedder, allow_dangerous_deserialization=True) document_chain = create_stuff_documents_chain(llm, prompt) retriever = new_db.as_retriever() # 从向量数据库中检索 retrieval_chain = create_retrieval_chain(retriever, document_chain) gpt_response = retrieval_chain.invoke({"input": msg}) response = gpt_response['answer'] return response print(rag("你好")) 到现在就实现了一个简单的RAG过程，LLM根据知识库的知识，给出了一个回答。但是，为了实现Agent的功能，还需要进一步拓展。 LLM需要执行外部任务，获取外部信息，这就需要使用tools模块。定义合适可用的tools，让LLM执行生成的代码，保存到数据库等等。 把实现RAG的retriever包装成一个tool,这样LLM可以基于已有的知识库来进行之后的外部tools执行，强化LLM的主动性。 db_path = "db" new_db = FAISS.load_local(db_path, embeddings, allow_dangerous_deserialization=True) retriever = new_db.as_retriever() # 从向量数据库中检索 retriever_tool = create_retriever_tool( retriever, "知识库", "这里存储着有关于问题的背景资料，you must use this tool!", ) 在这里，我们定义一个代码解释器，让LLM执行生成的代码，使用langchain提供的tool装饰器。 from langchain.agents import initialize_agent from langchain.memory import ConversationBufferWindowMemory from langchain.tools import tool from langchain.tools.retriever import create_retriever_tool def execute_and_return(x): code = extract_python_code(x.content)[0] try: result = exec(str(code)) return "exec result: " + result except ExceptionType: return "The code is not executable, don't give up, try again!" @tool def interpreter(code: str) -&gt; str: """ 此函数解释并执行提供的代码，严格去除首行出现的缩进并保证代码符合Python语法。 """ return execute_and_return(code) @tool def save_to_db(data: str) -&gt; str: """ 此函数将数据保存到数据库中。 """ db = sqlite3.connect('data.db') cursor = db.cursor() cursor.execute(data) db.commit() db.close() return "Data saved to database." @tool def get_from_db(data: str) -&gt; str: """ 此函数从数据库中获取数据。 """ db = sqlite3.connect('data.db') cursor = db.cursor() cursor.execute(data) result = cursor.fetchall() db.close() return result tools = [interpreter, save_to_db, get_from_db, retriever_tool] 后面就可以使用这些tools，实现Agent的功能，让LLM执行外部任务，获取外部信息。 conversation_buffer_window_memory是一个用于存储对话历史的内存模块，可以用于实现对话的记忆功能。在这里，我们使用它来存储对话历史，实现对话的连贯性。 initialize_agent函数用于初始化一个Agent，可以指定tools，memory，verbose等参数，实现Agent的功能。 memory = ConversationBufferWindowMemory(memory_key='chat_history', k=3, return_messages=True) chat_agent = initialize_agent( agent='chat-conversational-react-description', tools=tools, memory=memory, verbose=True, max_interations=3, llm=llm, handle_prasing_error=True ) query = "今天买菜花了30，买了一些蔬菜和水果。" response = chat_agent.invoke(query) print(response) query = "到数据库中查询今天的花费" response = chat_agent.invoke(query) print(response) 项目成果与展示 应用场景展示 助手适合个人或家庭在生活中使用，以自然语言的方式记录每日花费，计算支出总额，理解支出的类型与特点，帮助用户更好的管理财务。 功能演示 根据自然语言输入，用户将个人的每日花费，支出类型等信息输入到助手中，Agent执行外部海马，从外部数据库中CURD数据，个性化总结，理解用户，提供更好的建议。 问题与解决方案 实际使用中，受限于最大Token和问题，LLM很可能不会使用外部的tools，导致回答偏离预期。 问题分析 问题不够明确，没有主动引导LLM使用tools，导致LLM无法执行外部任务，获取外部信息。 解决措施 强化prompt，绝对引导LLM使用tools，保证LLM执行外部任务，获取外部信息。 项目总结与展望 项目评估 技术实现初步达到预期，RAG模型能够在特定领域提供更加准确的回答，但是在数值理解和具体的财务分析上，还有待提高。 未来方向 优化RAG模式，采取GraphRAG或更多rag方式，优化获取信息的模式，并存取更高质量的数据，提高对话的准确性。建立一个美观的前端界面，提供更好的用户体验。 附件与参考资料 Microsoft-Phi-3-NvidiaNIMWorkshop Langchain doc]]></summary></entry><entry><title type="html">github profile card</title><link href="nullskymc.cloud/profile/" rel="alternate" type="text/html" title="github profile card" /><published>2024-08-09T00:00:00+00:00</published><updated>2024-08-09T00:00:00+00:00</updated><id>nullskymc.cloud/profile</id><content type="html" xml:base="nullskymc.cloud/profile/"><![CDATA[<p>github个人记录</p>

<p><a href="https://github.com/nullskymc"><img src="https://raw.githubusercontent.com/nullskymc/profile-card/master/profile-summary-card-output/ayu_mirage/0-profile-details.svg" alt="" /></a>
<a href="https://github.com/nullskymc"><img src="https://raw.githubusercontent.com/nullskymc/profile-card/master/profile-summary-card-output/ayu_mirage/1-repos-per-language.svg" alt="" /></a> <a href="https://github.com/nullskymc"><img src="https://raw.githubusercontent.com/nullskymc/profile-card/master/profile-summary-card-output/ayu_mirage/2-most-commit-language.svg" alt="" /></a>
<a href="https://github.com/vn7n24fzkq/github-profile-summary-cards"><img src="https://raw.githubusercontent.com/nullskymc/profile-card/master/profile-summary-card-output/ayu_mirage/3-stats.svg" alt="" /></a> <a href="https://github.com/nullskymc"><img src="https://raw.githubusercontent.com/nullskymc/profile-card/master/profile-summary-card-output/ayu_mirage/4-productive-time.svg" alt="" /></a></p>]]></content><author><name></name></author><category term="github" /><category term="profile" /><category term="card" /><summary type="html"><![CDATA[github个人记录]]></summary></entry><entry><title type="html">使用微调BERT进行情感分类任务</title><link href="nullskymc.cloud/Bert1/" rel="alternate" type="text/html" title="使用微调BERT进行情感分类任务" /><published>2024-05-07T00:00:00+00:00</published><updated>2024-05-07T00:00:00+00:00</updated><id>nullskymc.cloud/Bert1</id><content type="html" xml:base="nullskymc.cloud/Bert1/"><![CDATA[<p>本次实验的Notebook已经上传到了<a href="https://github.com/nullskymc/pytorch11/blob/master/Qinggan.ipynb">GitHub</a>上，大家可以自行下载查看。</p>

<h2 id="ppt网址">PPT网址</h2>

<p><a href="https://bert-r9hswwn.gamma.site/">https://bert-r9hswwn.gamma.site/</a></p>

<h2 id="情感分析模型微调与评估">情感分析模型微调与评估</h2>

<p>本文档展示了如何使用BERT模型进行中文情感分析的微调与评估。包括数据准备、模型微调、模型评估等步骤。</p>

<h3 id="1-导入所需库">1. 导入所需库</h3>

<p>首先，我们需要导入相关的Python库和模块。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">torch</span>
<span class="kn">from</span> <span class="nn">transformers</span> <span class="kn">import</span> <span class="n">AutoTokenizer</span><span class="p">,</span> <span class="n">AutoModel</span><span class="p">,</span> <span class="n">AdamW</span>
<span class="kn">from</span> <span class="nn">torch.utils.data</span> <span class="kn">import</span> <span class="n">DataLoader</span><span class="p">,</span> <span class="n">Dataset</span><span class="p">,</span> <span class="n">random_split</span>
<span class="kn">import</span> <span class="nn">pandas</span> <span class="k">as</span> <span class="n">pd</span>
<span class="kn">from</span> <span class="nn">tqdm</span> <span class="kn">import</span> <span class="n">tqdm</span>
<span class="kn">import</span> <span class="nn">random</span>
<span class="kn">from</span> <span class="nn">transformers</span> <span class="kn">import</span> <span class="n">BertForSequenceClassification</span>
</code></pre></div></div>

<h3 id="2-下载预训练的bert模型">2. 下载预训练的BERT模型</h3>

<p>使用 <code class="language-plaintext highlighter-rouge">modelscope</code> 下载预训练的中文BERT模型。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">modelscope</span> <span class="kn">import</span> <span class="n">snapshot_download</span>
<span class="n">model_dir</span> <span class="o">=</span> <span class="n">snapshot_download</span><span class="p">(</span><span class="s">'tiansz/bert-base-chinese'</span><span class="p">)</span>
</code></pre></div></div>

<h3 id="3-加载预训练模型和分词器">3. 加载预训练模型和分词器</h3>

<p>加载预训练的BERT模型和分词器。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">tokenizer</span> <span class="o">=</span> <span class="n">AutoTokenizer</span><span class="p">.</span><span class="n">from_pretrained</span><span class="p">(</span><span class="n">model_dir</span><span class="p">)</span>
<span class="n">model</span> <span class="o">=</span> <span class="n">BertForSequenceClassification</span><span class="p">.</span><span class="n">from_pretrained</span><span class="p">(</span><span class="n">model_dir</span><span class="p">)</span>
</code></pre></div></div>

<blockquote>
  <p>注意：加载模型时，会有一些警告提示某些权重未初始化，这是正常的，因为我们需要对模型进行微调。</p>
</blockquote>

<h3 id="4-定义数据集类">4. 定义数据集类</h3>

<p>定义一个 <code class="language-plaintext highlighter-rouge">SentimentDataset</code> 类来处理情感分析的数据集。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">class</span> <span class="nc">SentimentDataset</span><span class="p">(</span><span class="n">Dataset</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">dataframe</span><span class="p">,</span> <span class="n">tokenizer</span><span class="p">,</span> <span class="n">max_length</span><span class="o">=</span><span class="mi">128</span><span class="p">):</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">dataframe</span> <span class="o">=</span> <span class="n">dataframe</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">tokenizer</span> <span class="o">=</span> <span class="n">tokenizer</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">max_length</span> <span class="o">=</span> <span class="n">max_length</span>

    <span class="k">def</span> <span class="nf">__len__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="p">.</span><span class="n">dataframe</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">idx</span><span class="p">):</span>
        <span class="n">text</span> <span class="o">=</span> <span class="bp">self</span><span class="p">.</span><span class="n">dataframe</span><span class="p">.</span><span class="n">iloc</span><span class="p">[</span><span class="n">idx</span><span class="p">][</span><span class="s">'review'</span><span class="p">]</span>  <span class="c1"># 使用标签索引
</span>        <span class="n">label</span> <span class="o">=</span> <span class="mi">1</span> <span class="k">if</span> <span class="bp">self</span><span class="p">.</span><span class="n">dataframe</span><span class="p">.</span><span class="n">iloc</span><span class="p">[</span><span class="n">idx</span><span class="p">][</span><span class="s">'label'</span><span class="p">]</span> <span class="o">==</span> <span class="mi">1</span> <span class="k">else</span> <span class="mi">0</span>  <span class="c1"># 使用标签索引
</span>        <span class="n">encoding</span> <span class="o">=</span> <span class="bp">self</span><span class="p">.</span><span class="n">tokenizer</span><span class="p">(</span><span class="n">text</span><span class="p">,</span> <span class="n">padding</span><span class="o">=</span><span class="s">'max_length'</span><span class="p">,</span> <span class="n">truncation</span><span class="o">=</span><span class="bp">True</span><span class="p">,</span> <span class="n">max_length</span><span class="o">=</span><span class="bp">self</span><span class="p">.</span><span class="n">max_length</span><span class="p">,</span> <span class="n">return_tensors</span><span class="o">=</span><span class="s">'pt'</span><span class="p">)</span>
        <span class="k">return</span> <span class="p">{</span>
            <span class="s">'input_ids'</span><span class="p">:</span> <span class="n">encoding</span><span class="p">[</span><span class="s">'input_ids'</span><span class="p">].</span><span class="n">flatten</span><span class="p">(),</span>
            <span class="s">'attention_mask'</span><span class="p">:</span> <span class="n">encoding</span><span class="p">[</span><span class="s">'attention_mask'</span><span class="p">].</span><span class="n">flatten</span><span class="p">(),</span>
            <span class="s">'labels'</span><span class="p">:</span> <span class="n">torch</span><span class="p">.</span><span class="n">tensor</span><span class="p">(</span><span class="n">label</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">torch</span><span class="p">.</span><span class="nb">long</span><span class="p">)</span>
        <span class="p">}</span>
</code></pre></div></div>

<h3 id="5-读取和处理数据">5. 读取和处理数据</h3>

<p>读取训练数据文件，并将其处理为数据集对象。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="s">"train.txt"</span><span class="p">,</span> <span class="s">"r"</span><span class="p">,</span> <span class="n">encoding</span><span class="o">=</span><span class="s">"utf-8"</span><span class="p">)</span> <span class="k">as</span> <span class="nb">file</span><span class="p">:</span>
    <span class="n">lines</span> <span class="o">=</span> <span class="nb">file</span><span class="p">.</span><span class="n">readlines</span><span class="p">()</span>

<span class="n">data</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">lines</span><span class="p">:</span>
    <span class="n">label</span><span class="p">,</span> <span class="n">text</span> <span class="o">=</span> <span class="n">line</span><span class="p">.</span><span class="n">strip</span><span class="p">().</span><span class="n">split</span><span class="p">(</span><span class="s">"</span><span class="se">\t</span><span class="s">"</span><span class="p">)</span>
    <span class="n">data</span><span class="p">.</span><span class="n">append</span><span class="p">((</span><span class="nb">int</span><span class="p">(</span><span class="n">label</span><span class="p">),</span> <span class="n">text</span><span class="p">))</span>

<span class="n">df</span> <span class="o">=</span> <span class="n">pd</span><span class="p">.</span><span class="n">DataFrame</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">columns</span><span class="o">=</span><span class="p">[</span><span class="s">"label"</span><span class="p">,</span> <span class="s">"review"</span><span class="p">])</span>
<span class="n">dataset</span> <span class="o">=</span> <span class="n">SentimentDataset</span><span class="p">(</span><span class="n">df</span><span class="p">,</span> <span class="n">tokenizer</span><span class="p">,</span> <span class="n">max_length</span><span class="o">=</span><span class="mi">128</span><span class="p">)</span>
</code></pre></div></div>

<h3 id="6-划分训练集和验证集">6. 划分训练集和验证集</h3>

<p>将数据集划分为训练集和验证集。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">train_size</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="mf">0.8</span> <span class="o">*</span> <span class="nb">len</span><span class="p">(</span><span class="n">dataset</span><span class="p">))</span>
<span class="n">val_size</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">dataset</span><span class="p">)</span> <span class="o">-</span> <span class="n">train_size</span>
<span class="n">train_dataset</span><span class="p">,</span> <span class="n">val_dataset</span> <span class="o">=</span> <span class="n">random_split</span><span class="p">(</span><span class="n">dataset</span><span class="p">,</span> <span class="p">[</span><span class="n">train_size</span><span class="p">,</span> <span class="n">val_size</span><span class="p">])</span>
</code></pre></div></div>

<p>创建数据加载器。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">train_loader</span> <span class="o">=</span> <span class="n">DataLoader</span><span class="p">(</span><span class="n">train_dataset</span><span class="p">,</span> <span class="n">batch_size</span><span class="o">=</span><span class="mi">8</span><span class="p">,</span> <span class="n">shuffle</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
<span class="n">val_loader</span> <span class="o">=</span> <span class="n">DataLoader</span><span class="p">(</span><span class="n">val_dataset</span><span class="p">,</span> <span class="n">batch_size</span><span class="o">=</span><span class="mi">8</span><span class="p">,</span> <span class="n">shuffle</span><span class="o">=</span><span class="bp">False</span><span class="p">)</span>
</code></pre></div></div>

<h3 id="7-设置训练参数">7. 设置训练参数</h3>

<p>设置训练参数和设备。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">optimizer</span> <span class="o">=</span> <span class="n">AdamW</span><span class="p">(</span><span class="n">model</span><span class="p">.</span><span class="n">parameters</span><span class="p">(),</span> <span class="n">lr</span><span class="o">=</span><span class="mf">5e-5</span><span class="p">)</span>
<span class="n">device</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="n">device</span><span class="p">(</span><span class="s">"cuda"</span> <span class="k">if</span> <span class="n">torch</span><span class="p">.</span><span class="n">cuda</span><span class="p">.</span><span class="n">is_available</span><span class="p">()</span> <span class="k">else</span> <span class="s">"cpu"</span><span class="p">)</span>
<span class="n">model</span><span class="p">.</span><span class="n">to</span><span class="p">(</span><span class="n">device</span><span class="p">)</span>
</code></pre></div></div>

<h3 id="8-训练模型">8. 训练模型</h3>

<p>开始训练模型。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">model</span><span class="p">.</span><span class="n">train</span><span class="p">()</span>
<span class="k">for</span> <span class="n">epoch</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">):</span>
    <span class="k">for</span> <span class="n">batch</span> <span class="ow">in</span> <span class="n">tqdm</span><span class="p">(</span><span class="n">train_loader</span><span class="p">,</span> <span class="n">desc</span><span class="o">=</span><span class="s">"Epoch {}"</span><span class="p">.</span><span class="nb">format</span><span class="p">(</span><span class="n">epoch</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)):</span>
        <span class="n">input_ids</span> <span class="o">=</span> <span class="n">batch</span><span class="p">[</span><span class="s">'input_ids'</span><span class="p">].</span><span class="n">to</span><span class="p">(</span><span class="n">device</span><span class="p">)</span>
        <span class="n">attention_mask</span> <span class="o">=</span> <span class="n">batch</span><span class="p">[</span><span class="s">'attention_mask'</span><span class="p">].</span><span class="n">to</span><span class="p">(</span><span class="n">device</span><span class="p">)</span>
        <span class="n">labels</span> <span class="o">=</span> <span class="n">batch</span><span class="p">[</span><span class="s">'labels'</span><span class="p">].</span><span class="n">to</span><span class="p">(</span><span class="n">device</span><span class="p">)</span>
        
        <span class="n">optimizer</span><span class="p">.</span><span class="n">zero_grad</span><span class="p">()</span>
        <span class="n">outputs</span> <span class="o">=</span> <span class="n">model</span><span class="p">(</span><span class="n">input_ids</span><span class="p">,</span> <span class="n">attention_mask</span><span class="o">=</span><span class="n">attention_mask</span><span class="p">,</span> <span class="n">labels</span><span class="o">=</span><span class="n">labels</span><span class="p">)</span>
        <span class="n">loss</span> <span class="o">=</span> <span class="n">outputs</span><span class="p">.</span><span class="n">loss</span>
        <span class="n">loss</span><span class="p">.</span><span class="n">backward</span><span class="p">()</span>
        <span class="n">optimizer</span><span class="p">.</span><span class="n">step</span><span class="p">()</span>
</code></pre></div></div>

<h3 id="9-验证模型">9. 验证模型</h3>

<p>在验证集上评估模型。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">model</span><span class="p">.</span><span class="nb">eval</span><span class="p">()</span>
<span class="n">total_eval_accuracy</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">for</span> <span class="n">batch</span> <span class="ow">in</span> <span class="n">tqdm</span><span class="p">(</span><span class="n">val_loader</span><span class="p">,</span> <span class="n">desc</span><span class="o">=</span><span class="s">"Evaluating"</span><span class="p">):</span>
    <span class="n">input_ids</span> <span class="o">=</span> <span class="n">batch</span><span class="p">[</span><span class="s">'input_ids'</span><span class="p">].</span><span class="n">to</span><span class="p">(</span><span class="n">device</span><span class="p">)</span>
    <span class="n">attention_mask</span> <span class="o">=</span> <span class="n">batch</span><span class="p">[</span><span class="s">'attention_mask'</span><span class="p">].</span><span class="n">to</span><span class="p">(</span><span class="n">device</span><span class="p">)</span>
    <span class="n">labels</span> <span class="o">=</span> <span class="n">batch</span><span class="p">[</span><span class="s">'labels'</span><span class="p">].</span><span class="n">to</span><span class="p">(</span><span class="n">device</span><span class="p">)</span>

    <span class="k">with</span> <span class="n">torch</span><span class="p">.</span><span class="n">no_grad</span><span class="p">():</span>
        <span class="n">outputs</span> <span class="o">=</span> <span class="n">model</span><span class="p">(</span><span class="n">input_ids</span><span class="p">,</span> <span class="n">attention_mask</span><span class="o">=</span><span class="n">attention_mask</span><span class="p">,</span> <span class="n">labels</span><span class="o">=</span><span class="n">labels</span><span class="p">)</span>
        <span class="n">logits</span> <span class="o">=</span> <span class="n">outputs</span><span class="p">.</span><span class="n">logits</span>
        <span class="n">preds</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="n">argmax</span><span class="p">(</span><span class="n">logits</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
        <span class="n">accuracy</span> <span class="o">=</span> <span class="p">(</span><span class="n">preds</span> <span class="o">==</span> <span class="n">labels</span><span class="p">).</span><span class="nb">float</span><span class="p">().</span><span class="n">mean</span><span class="p">()</span>
        <span class="n">total_eval_accuracy</span> <span class="o">+=</span> <span class="n">accuracy</span><span class="p">.</span><span class="n">item</span><span class="p">()</span>

<span class="n">average_eval_accuracy</span> <span class="o">=</span> <span class="n">total_eval_accuracy</span> <span class="o">/</span> <span class="nb">len</span><span class="p">(</span><span class="n">val_loader</span><span class="p">)</span>
<span class="k">print</span><span class="p">(</span><span class="s">"Validation Accuracy:"</span><span class="p">,</span> <span class="n">average_eval_accuracy</span><span class="p">)</span>
</code></pre></div></div>

<h3 id="10-使用模型进行预测">10. 使用模型进行预测</h3>

<p>使用微调后的模型进行情感预测。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">predict_sentiment</span><span class="p">(</span><span class="n">sentence</span><span class="p">):</span>
    <span class="n">inputs</span> <span class="o">=</span> <span class="n">tokenizer</span><span class="p">(</span><span class="n">sentence</span><span class="p">,</span> <span class="n">padding</span><span class="o">=</span><span class="s">'max_length'</span><span class="p">,</span> <span class="n">truncation</span><span class="o">=</span><span class="bp">True</span><span class="p">,</span> <span class="n">max_length</span><span class="o">=</span><span class="mi">128</span><span class="p">,</span> <span class="n">return_tensors</span><span class="o">=</span><span class="s">'pt'</span><span class="p">).</span><span class="n">to</span><span class="p">(</span><span class="n">device</span><span class="p">)</span>
    <span class="k">with</span> <span class="n">torch</span><span class="p">.</span><span class="n">no_grad</span><span class="p">():</span>
        <span class="n">outputs</span> <span class="o">=</span> <span class="n">model</span><span class="p">(</span><span class="o">**</span><span class="n">inputs</span><span class="p">)</span>
    <span class="n">logits</span> <span class="o">=</span> <span class="n">outputs</span><span class="p">.</span><span class="n">logits</span>
    <span class="n">probs</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="n">softmax</span><span class="p">(</span><span class="n">logits</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
    <span class="n">positive_prob</span> <span class="o">=</span> <span class="n">probs</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">1</span><span class="p">].</span><span class="n">item</span><span class="p">()</span>  <span class="c1"># 1表示正面
</span>    <span class="k">return</span> <span class="n">positive_prob</span>

<span class="k">def</span> <span class="nf">predict</span><span class="p">(</span><span class="n">sentence</span><span class="p">):</span>
    <span class="n">positive_prob</span> <span class="o">=</span> <span class="n">predict_sentiment</span><span class="p">(</span><span class="n">sentence</span><span class="p">)</span>
    <span class="n">threshold</span> <span class="o">=</span> <span class="mf">0.5</span>  <span class="c1"># 设置阈值
</span>    <span class="k">if</span> <span class="n">positive_prob</span> <span class="o">&gt;</span> <span class="n">threshold</span><span class="p">:</span>
        <span class="k">print</span><span class="p">(</span><span class="s">"正面"</span><span class="p">)</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="k">print</span><span class="p">(</span><span class="s">"负面"</span><span class="p">)</span>

<span class="n">predict</span><span class="p">(</span><span class="s">"这家菜真好吃！"</span><span class="p">)</span>
</code></pre></div></div>

<h3 id="11-测试模型性能">11. 测试模型性能</h3>

<p>加载测试数据集并评估模型性能。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">torch</span>
<span class="kn">from</span> <span class="nn">torch.utils.data</span> <span class="kn">import</span> <span class="n">Dataset</span>

<span class="k">class</span> <span class="nc">TestDataset</span><span class="p">(</span><span class="n">Dataset</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">file_path</span><span class="p">,</span> <span class="n">tokenizer</span><span class="p">,</span> <span class="n">max_length</span><span class="o">=</span><span class="mi">128</span><span class="p">):</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">data</span> <span class="o">=</span> <span class="p">[]</span>
        <span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">file_path</span><span class="p">,</span> <span class="s">"r"</span><span class="p">,</span> <span class="n">encoding</span><span class="o">=</span><span class="s">"utf-8"</span><span class="p">)</span> <span class="k">as</span> <span class="nb">file</span><span class="p">:</span>
            <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="nb">file</span><span class="p">:</span>
                <span class="n">label</span><span class="p">,</span> <span class="n">text</span> <span class="o">=</span> <span class="n">line</span><span class="p">.</span><span class="n">strip</span><span class="p">().</span><span class="n">split</span><span class="p">(</span><span class="s">"</span><span class="se">\t</span><span class="s">"</span><span class="p">)</span>
                <span class="bp">self</span><span class="p">.</span><span class="n">data</span><span class="p">.</span><span class="n">append</span><span class="p">((</span><span class="nb">int</span><span class="p">(</span><span class="n">label</span><span class="p">),</span> <span class="n">text</span><span class="p">))</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">tokenizer</span> <span class="o">=</span> <span class="n">tokenizer</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">max_length</span> <span class="o">=</span> <span class="n">max_length</span>

    <span class="k">def</span> <span class="nf">__len__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="p">.</span><span class="n">data</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">idx</span><span class="p">):</span>
        <span class="n">label</span><span class="p">,</span> <span class="n">text</span> <span class="o">=</span> <span class="bp">self</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">idx</span><span class="p">]</span>
        <span class="n">encoding</span> <span class="o">=</span> <span class="bp">self</span><span class="p">.</span><span class="n">tokenizer</span><span class="p">(</span><span class="n">text</span><span class="p">,</span> <span class="n">padding</span><span class="o">=</span><span class="s">'max_length'</span><span class="p">,</span> <span class="n">truncation</span><span class="o">=</span><span class="bp">True</span><span class="p">,</span> <span class="n">max_length</span><span class="o">=</span><span class="bp">self</span><span class="p">.</span><span class="n">max_length</span><span class="p">,</span> <span class="n">return_tensors</span><span class="o">=</span><span class="s">'pt'</span><span class="p">)</span>
        <span class="k">return</span> <span class="p">{</span>
            <span class="s">'input_ids'</span><span class="p">:</span> <span class="n">encoding</span><span class="p">[</span><span class="s">'input_ids'</span><span class="p">].</span><span class="n">flatten</span><span class="p">(),</span>
            <span class="s">'attention_mask'</span><span class="p">:</span> <span class="n">encoding</span><span class="p">[</span><span class="s">'attention_mask'</span><span class="p">].</span><span class="n">flatten</span><span class="p">(),</span>
            <span class="s">'labels'</span><span class="p">:</span> <span class="n">torch</span><span class="p">.</span><span class="n">tensor</span><span class="p">(</span><span class="n">label</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">torch</span><span class="p">.</span><span class="nb">long</span><span class="p">)</span>
        <span class="p">}</span>

<span class="n">test_dataset</span> <span class="o">=</span> <span class="n">TestDataset</span><span class="p">(</span><span class="s">"test.txt"</span><span class="p">,</span> <span class="n">tokenizer</span><span class="p">,</span> <span class="n">max_length</span><span class="o">=</span><span class="mi">128</span><span class="p">)</span>
<span class="n">test_loader</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="n">utils</span><span class="p">.</span><span class="n">data</span><span class="p">.</span><span class="n">DataLoader</span><span class="p">(</span><span class="n">test_dataset</span><span class="p">,</span> <span class="n">batch_size</span><span class="o">=</span><span class="mi">8</span><span class="p">,</span> <span class="n">shuffle</span><span class="o">=</span><span class="bp">False</span><span class="p">)</span>

<span class="n">model</span><span class="p">.</span><span class="nb">eval</span><span class="p">()</span>
<span class="n">total_eval_accuracy</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">for</span> <span class="n">batch</span> <span class="ow">in</span> <span class="n">tqdm</span><span class="p">(</span><span class="n">test_loader</span><span class="p">,</span> <span class="n">desc</span><span class="o">=</span><span class="s">"Evaluating"</span><span class="p">):</span>
    <span class="n">input_ids</span> <span class="o">=</span> <span class="n">batch</span><span class="p">[</span><span class="s">'input_ids'</span><span class="p">].</span><span class="n">to</span><span class="p">(</span><span class="n">device</span><span class="p">)</span>
    <span class="n">attention_mask</span> <span class="o">=</span> <span class="n">batch</span><span class="p">[</span><span class="s">'attention_mask'</span><span class="p">].</span><span class="n">to</span><span class="p">(</span><span class="n">device</span><span class="p">)</span>
    <span class="n">labels</span> <span class="o">=</span> <span class="n">batch</span><span class="p">[</span><span class="s">'labels'</span><span class="p">].</span><span class="n">to</span><span class="p">(</span><span class="n">device</span><span class="p">)</span>

    <span class="k">with</span> <span class="n">torch</span><span class="p">.</span><span class="n">no_grad</span><span class="p">():</span>
        <span class="n">outputs</span> <span class="o">=</span> <span class="n">model</span><span class="p">(</span><span class="n">input_ids</span><span class="p">,</span> <span class="n">attention_mask</span><span class="o">=</span><span class="n">attention_mask</span><span class="p">,</span> <span class="n">labels</span><span class="o">=</span><span class="n">labels</span><span class="p">)</span>
    
    <span class="n">logits</span> <span class="o">=</span> <span class="n">outputs</span><span class="p">.</span><span class="n">logits</span>
    <span class="n">preds</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="n">argmax</span><span class="p">(</span><span class="n">logits</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
    <span class="n">accuracy</span> <span class="o">=</span> <span class="p">(</span><span class="n">preds</span> <span class="o">==</span> <span class="n">labels</span><span class="p">).</span><span class="nb">float</span><span class="p">().</span><span class="n">mean</span><span class="p">()</span>
    <span class="n">total_eval_accuracy</span> <span class="o">+=</span> <span class="n">accuracy</span><span class="p">.</span><span class="n">item</span><span class="p">()</span>

<span class="n">average_eval_accuracy</span> <span class="o">=</span> <span class="n">total_eval_accuracy</span> <span class="o">/</span> <span class="nb">len</span><span class="p">(</span><span class="n">test_loader</span><span class="p">)</span>
<span class="k">print</span><span class="p">(</span><span class="s">"Test Accuracy:"</span><span class="p">,</span> <span class="n">average_eval_accuracy</span><span class="p">)</span>
</code></pre></div></div>

<h3 id="12-流程图">12. 流程图</h3>

<p>以下是整个流程的序列图：</p>

<pre><code class="language-mermaid">sequenceDiagram
    participant 数据准备
    participant 模型微调
    participant 模型评估
    participant 代码实现
    participant 自动生成测试数据

    数据准备 -&gt; 模型微调: 准备数据集
    模型微调 -&gt; 模型评估: 微调模型
    模型评估 -&gt; 代码实现: 评估模型性能
    代码实现 -&gt; 自动生成测试数据: 编写评估代码
    自动生成测试数据 --&gt; 代码实现: 生成测试数据
    代码实现 -&gt; 模型评估: 使用测试数据评估模型性能
</code></pre>

<hr />

<p>通过上述步骤，我们完成了中文情感分析模型的微调和评估过程。</p>]]></content><author><name></name></author><category term="Pytorch" /><category term="ai" /><category term="python" /><category term="NLP" /><category term="BERT" /><category term="情感分析" /><summary type="html"><![CDATA[本次实验的Notebook已经上传到了GitHub上，大家可以自行下载查看。 PPT网址 https://bert-r9hswwn.gamma.site/ 情感分析模型微调与评估 本文档展示了如何使用BERT模型进行中文情感分析的微调与评估。包括数据准备、模型微调、模型评估等步骤。 1. 导入所需库 首先，我们需要导入相关的Python库和模块。 import torch from transformers import AutoTokenizer, AutoModel, AdamW from torch.utils.data import DataLoader, Dataset, random_split import pandas as pd from tqdm import tqdm import random from transformers import BertForSequenceClassification 2. 下载预训练的BERT模型 使用 modelscope 下载预训练的中文BERT模型。 from modelscope import snapshot_download model_dir = snapshot_download('tiansz/bert-base-chinese') 3. 加载预训练模型和分词器 加载预训练的BERT模型和分词器。 tokenizer = AutoTokenizer.from_pretrained(model_dir) model = BertForSequenceClassification.from_pretrained(model_dir) 注意：加载模型时，会有一些警告提示某些权重未初始化，这是正常的，因为我们需要对模型进行微调。 4. 定义数据集类 定义一个 SentimentDataset 类来处理情感分析的数据集。 class SentimentDataset(Dataset): def __init__(self, dataframe, tokenizer, max_length=128): self.dataframe = dataframe self.tokenizer = tokenizer self.max_length = max_length def __len__(self): return len(self.dataframe) def __getitem__(self, idx): text = self.dataframe.iloc[idx]['review'] # 使用标签索引 label = 1 if self.dataframe.iloc[idx]['label'] == 1 else 0 # 使用标签索引 encoding = self.tokenizer(text, padding='max_length', truncation=True, max_length=self.max_length, return_tensors='pt') return { 'input_ids': encoding['input_ids'].flatten(), 'attention_mask': encoding['attention_mask'].flatten(), 'labels': torch.tensor(label, dtype=torch.long) } 5. 读取和处理数据 读取训练数据文件，并将其处理为数据集对象。 with open("train.txt", "r", encoding="utf-8") as file: lines = file.readlines() data = [] for line in lines: label, text = line.strip().split("\t") data.append((int(label), text)) df = pd.DataFrame(data, columns=["label", "review"]) dataset = SentimentDataset(df, tokenizer, max_length=128) 6. 划分训练集和验证集 将数据集划分为训练集和验证集。 train_size = int(0.8 * len(dataset)) val_size = len(dataset) - train_size train_dataset, val_dataset = random_split(dataset, [train_size, val_size]) 创建数据加载器。 train_loader = DataLoader(train_dataset, batch_size=8, shuffle=True) val_loader = DataLoader(val_dataset, batch_size=8, shuffle=False) 7. 设置训练参数 设置训练参数和设备。 optimizer = AdamW(model.parameters(), lr=5e-5) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model.to(device) 8. 训练模型 开始训练模型。 model.train() for epoch in range(3): for batch in tqdm(train_loader, desc="Epoch {}".format(epoch + 1)): input_ids = batch['input_ids'].to(device) attention_mask = batch['attention_mask'].to(device) labels = batch['labels'].to(device) optimizer.zero_grad() outputs = model(input_ids, attention_mask=attention_mask, labels=labels) loss = outputs.loss loss.backward() optimizer.step() 9. 验证模型 在验证集上评估模型。 model.eval() total_eval_accuracy = 0 for batch in tqdm(val_loader, desc="Evaluating"): input_ids = batch['input_ids'].to(device) attention_mask = batch['attention_mask'].to(device) labels = batch['labels'].to(device) with torch.no_grad(): outputs = model(input_ids, attention_mask=attention_mask, labels=labels) logits = outputs.logits preds = torch.argmax(logits, dim=1) accuracy = (preds == labels).float().mean() total_eval_accuracy += accuracy.item() average_eval_accuracy = total_eval_accuracy / len(val_loader) print("Validation Accuracy:", average_eval_accuracy) 10. 使用模型进行预测 使用微调后的模型进行情感预测。 def predict_sentiment(sentence): inputs = tokenizer(sentence, padding='max_length', truncation=True, max_length=128, return_tensors='pt').to(device) with torch.no_grad(): outputs = model(**inputs) logits = outputs.logits probs = torch.softmax(logits, dim=1) positive_prob = probs[0][1].item() # 1表示正面 return positive_prob def predict(sentence): positive_prob = predict_sentiment(sentence) threshold = 0.5 # 设置阈值 if positive_prob &gt; threshold: print("正面") else: print("负面") predict("这家菜真好吃！") 11. 测试模型性能 加载测试数据集并评估模型性能。 import torch from torch.utils.data import Dataset class TestDataset(Dataset): def __init__(self, file_path, tokenizer, max_length=128): self.data = [] with open(file_path, "r", encoding="utf-8") as file: for line in file: label, text = line.strip().split("\t") self.data.append((int(label), text)) self.tokenizer = tokenizer self.max_length = max_length def __len__(self): return len(self.data) def __getitem__(self, idx): label, text = self.data[idx] encoding = self.tokenizer(text, padding='max_length', truncation=True, max_length=self.max_length, return_tensors='pt') return { 'input_ids': encoding['input_ids'].flatten(), 'attention_mask': encoding['attention_mask'].flatten(), 'labels': torch.tensor(label, dtype=torch.long) } test_dataset = TestDataset("test.txt", tokenizer, max_length=128) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=8, shuffle=False) model.eval() total_eval_accuracy = 0 for batch in tqdm(test_loader, desc="Evaluating"): input_ids = batch['input_ids'].to(device) attention_mask = batch['attention_mask'].to(device) labels = batch['labels'].to(device) with torch.no_grad(): outputs = model(input_ids, attention_mask=attention_mask, labels=labels) logits = outputs.logits preds = torch.argmax(logits, dim=1) accuracy = (preds == labels).float().mean() total_eval_accuracy += accuracy.item() average_eval_accuracy = total_eval_accuracy / len(test_loader) print("Test Accuracy:", average_eval_accuracy) 12. 流程图 以下是整个流程的序列图： sequenceDiagram participant 数据准备 participant 模型微调 participant 模型评估 participant 代码实现 participant 自动生成测试数据 数据准备 -&gt; 模型微调: 准备数据集 模型微调 -&gt; 模型评估: 微调模型 模型评估 -&gt; 代码实现: 评估模型性能 代码实现 -&gt; 自动生成测试数据: 编写评估代码 自动生成测试数据 --&gt; 代码实现: 生成测试数据 代码实现 -&gt; 模型评估: 使用测试数据评估模型性能 通过上述步骤，我们完成了中文情感分析模型的微调和评估过程。]]></summary></entry><entry><title type="html">机器学习实验：线性预测</title><link href="nullskymc.cloud/linear-predict/" rel="alternate" type="text/html" title="机器学习实验：线性预测" /><published>2024-03-17T00:00:00+00:00</published><updated>2024-03-17T00:00:00+00:00</updated><id>nullskymc.cloud/linear-predict</id><content type="html" xml:base="nullskymc.cloud/linear-predict/"><![CDATA[<p>本次实验代码的notebook已经上传到我的Github上，<a href="https://github.com/nullskymc/pytorch11">点击这里</a></p>

<h2 id="线性预测">线性预测</h2>

<p>线性预测是一种简单的机器学习模型，它可以用来预测一个或多个输入变量与输出变量之间的关系。线性预测模型的基本形式是：</p>

\[y = w_1x_1 + w_2x_2 + ... + w_nx_n + b\]

<p>其中 $y$ 是输出变量，$x_1, x_2, …, x_n$ 是输入变量，$w_1, w_2, …, w_n$ 是权重，$b$ 是偏置。</p>

<p>线性预测模型的训练过程是通过最小化损失函数来确定权重和偏置的值。损失函数的选择是非常重要的，因为它决定了模型的性能。常见的损失函数有均方误差（MSE）和平均绝对误差（MAE）。</p>

<h2 id="数据集">数据集</h2>

<p>这个实验我们使用了kaggle上常见的员工 离职数据集，<strong>HR_comma_sep.csv</strong></p>

<h2 id="数据预处理">数据预处理</h2>

<h3 id="导入数据">导入数据</h3>

<p>这里使用pandas库作为数据处理的工具，首先导入数据集，查看数据集的基本信息。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">pandas</span> <span class="k">as</span> <span class="n">pd</span>

<span class="n">df</span> <span class="o">=</span> <span class="n">pd</span><span class="p">.</span><span class="n">read_csv</span><span class="p">(</span><span class="s">'HR_comma_sep.csv'</span><span class="p">)</span>
<span class="k">print</span><span class="p">(</span><span class="n">df</span><span class="p">.</span><span class="n">head</span><span class="p">())</span>
</code></pre></div></div>

<pre><code class="language-output">      satisfaction_level  last_evaluation  number_project  average_montly_hours  \
0                0.38             0.53               2                   157   
1                0.80             0.86               5                   262   
2                0.11             0.88               7                   272   
3                0.72             0.87               5                   223   
4                0.37             0.52               2                   159   

   time_spend_company  Work_accident  left  promotion_last_5years  sales  \
0                   3              0     1                      0  sales   
1                   6              0     1                      0  sales   
2                   4              0     1                      0  sales   
3                   5              0     1                      0  sales   
4                   3              0     1                      0  sales   

   salary  
0     low  
1  medium  
2  medium  
3     low  
4     low  
</code></pre>

<p>可以发现，数据集中的特征有：satisfaction_level, last_evaluation, number_project, average_montly_hours, time_spend_company, Work_accident, promotion_last_5years, sales。其中sales是员工所在的部门，left是员工是否离职。</p>

<h3 id="数据格式化">数据格式化</h3>

<p>为了方便之后的学习过程，这里将每个column的数据单独储存。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">level</span> <span class="o">=</span> <span class="n">df</span><span class="p">[</span><span class="s">'satisfaction_level'</span><span class="p">]</span>
<span class="n">evaluation</span> <span class="o">=</span> <span class="n">df</span><span class="p">[</span><span class="s">'last_evaluation'</span><span class="p">]</span>
<span class="n">project</span> <span class="o">=</span> <span class="n">df</span><span class="p">[</span><span class="s">'number_project'</span><span class="p">]</span>
<span class="n">average_monthly_hours</span> <span class="o">=</span> <span class="n">df</span><span class="p">[</span><span class="s">'average_montly_hours'</span><span class="p">]</span>
<span class="n">time_spend_company</span> <span class="o">=</span> <span class="n">df</span><span class="p">[</span><span class="s">'time_spend_company'</span><span class="p">]</span>
<span class="n">work_accident</span> <span class="o">=</span> <span class="n">df</span><span class="p">[</span><span class="s">'Work_accident'</span><span class="p">]</span>
<span class="n">left</span> <span class="o">=</span> <span class="n">df</span><span class="p">[</span><span class="s">'left'</span><span class="p">]</span>
<span class="n">promotion</span> <span class="o">=</span> <span class="n">df</span><span class="p">[</span><span class="s">'promotion_last_5years'</span><span class="p">]</span>
<span class="n">department</span> <span class="o">=</span> <span class="n">df</span><span class="p">[</span><span class="s">'sales'</span><span class="p">]</span>
<span class="n">salary</span> <span class="o">=</span> <span class="n">df</span><span class="p">[</span><span class="s">'salary'</span><span class="p">]</span>
</code></pre></div></div>

<p>可以发现，sales列和salary列是字符串类型的，需要将其转换为数值类型。这里使用字典映射的方式将其转换为数值类型。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">department</span> <span class="o">=</span> <span class="n">df</span><span class="p">[</span><span class="s">'sales'</span><span class="p">].</span><span class="nb">map</span><span class="p">({</span><span class="s">'sales'</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="s">'accounting'</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span> <span class="s">'hr'</span><span class="p">:</span> <span class="mi">3</span><span class="p">,</span> <span class="s">'technical'</span><span class="p">:</span> <span class="mi">4</span><span class="p">,</span> <span class="s">'support'</span><span class="p">:</span> <span class="mi">5</span><span class="p">,</span> <span class="s">'management'</span><span class="p">:</span> <span class="mi">6</span><span class="p">,</span> <span class="s">'IT'</span><span class="p">:</span> <span class="mi">7</span><span class="p">,</span> <span class="s">'product_mng'</span><span class="p">:</span> <span class="mi">8</span><span class="p">,</span> <span class="s">'marketing'</span><span class="p">:</span> <span class="mi">9</span><span class="p">,</span> <span class="s">'RandD'</span><span class="p">:</span> <span class="mi">10</span><span class="p">})</span>
<span class="n">salary</span> <span class="o">=</span> <span class="n">df</span><span class="p">[</span><span class="s">'salary'</span><span class="p">].</span><span class="nb">map</span><span class="p">({</span><span class="s">'low'</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="s">'medium'</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span> <span class="s">'high'</span><span class="p">:</span> <span class="mi">3</span><span class="p">})</span>
</code></pre></div></div>

<h2 id="线性模型学习">线性模型学习</h2>

<h3 id="pytorch">pytorch</h3>

<p>pytorch是一个强大的开源深度学习框架，它提供了很多高效的工具和接口，可以帮助我们快速构建和训练深度学习模型。在这个实验中，我们将使用pytorch来构建和训练线性预测模型。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">torch</span>
<span class="kn">import</span> <span class="nn">torch.nn</span> <span class="k">as</span> <span class="n">nn</span>
<span class="kn">import</span> <span class="nn">torch.optim</span> <span class="k">as</span> <span class="n">optim</span>
</code></pre></div></div>

<h3 id="数据向量化">数据向量化</h3>

<p>在训练模型之前，我们需要将数据向量化。这里我们将所有的特征向量化为一个矩阵，将所有的标签向量化为一个向量。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">X_tensors</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="n">tensor</span><span class="p">([</span><span class="n">level</span><span class="p">,</span> <span class="n">evaluation</span><span class="p">,</span> <span class="n">project</span><span class="p">,</span> <span class="n">average_monthly_hours</span><span class="p">,</span> <span class="n">time_spend_company</span><span class="p">,</span> <span class="n">work_accident</span><span class="p">,</span> <span class="n">promotion</span><span class="p">,</span> <span class="n">department</span><span class="p">,</span> <span class="n">salary</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="n">torch</span><span class="p">.</span><span class="n">float32</span><span class="p">).</span><span class="n">T</span>
<span class="n">Y_tensors</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="n">tensor</span><span class="p">(</span><span class="n">left</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">torch</span><span class="p">.</span><span class="n">float32</span><span class="p">).</span><span class="n">view</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
</code></pre></div></div>

<p>其中X_tensors是特征矩阵，Y_tensors是标签向量（是否离职）。</p>

<h3 id="定义模型">定义模型</h3>

<p>在pytorch中，我们可以通过继承nn.Module类来定义模型。这里我们定义了一个简单的线性预测模型。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">class</span> <span class="nc">linear</span><span class="p">(</span><span class="n">nn</span><span class="p">.</span><span class="n">Module</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">input_size</span><span class="p">):</span>
        <span class="nb">super</span><span class="p">(</span><span class="n">linear</span><span class="p">,</span> <span class="bp">self</span><span class="p">).</span><span class="n">__init__</span><span class="p">()</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">linear</span> <span class="o">=</span> <span class="n">nn</span><span class="p">.</span><span class="n">Linear</span><span class="p">(</span><span class="n">input_size</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">x</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="p">.</span><span class="n">linear</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
</code></pre></div></div>

<p>训练模型需要定义损失函数和优化器。pytorch有很多打包好的工具，这里我们使用均方误差（<strong>MSE</strong>）作为损失函数，使用随机梯度下降（<strong>SGD</strong>）作为优化器。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">model</span> <span class="o">=</span> <span class="n">linear</span><span class="p">(</span><span class="n">input_size</span><span class="o">=</span><span class="mi">9</span><span class="p">)</span>

<span class="c1">#定义损失函数
</span><span class="n">criterion</span> <span class="o">=</span> <span class="n">nn</span><span class="p">.</span><span class="n">MSELoss</span><span class="p">()</span>

<span class="c1">#定义优化器
</span><span class="n">optimizer</span> <span class="o">=</span> <span class="n">optim</span><span class="p">.</span><span class="n">SGD</span><span class="p">(</span><span class="n">model</span><span class="p">.</span><span class="n">parameters</span><span class="p">(),</span> <span class="n">lr</span><span class="o">=</span><span class="mf">0.00001</span><span class="p">)</span> <span class="c1">#学习率为0.00001
</span></code></pre></div></div>

<blockquote>
  <p>注意，我们的特征矩阵有9个特征，所以输入的大小是9，即输入的input_size是9.</p>
</blockquote>

<h3 id="训练模型">训练模型</h3>

<p>torch可以方便地使用GPU进行训练（即使这个模型很简单），这里我们使用GPU进行训练。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">device</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="n">device</span><span class="p">(</span><span class="s">'cuda'</span><span class="p">)</span>

<span class="c1"># 将模型移动到GPU
</span><span class="n">model</span> <span class="o">=</span> <span class="n">model</span><span class="p">.</span><span class="n">to</span><span class="p">(</span><span class="n">device</span><span class="p">)</span>

<span class="c1"># 将数据移动到GPU
</span><span class="n">X_tensors</span> <span class="o">=</span> <span class="n">X_tensors</span><span class="p">.</span><span class="n">to</span><span class="p">(</span><span class="n">device</span><span class="p">)</span>
<span class="n">y_tensor</span> <span class="o">=</span> <span class="n">y_tensor</span><span class="p">.</span><span class="n">to</span><span class="p">(</span><span class="n">device</span><span class="p">)</span>

<span class="c1">## 训练
</span><span class="n">num_epochs</span> <span class="o">=</span> <span class="mi">10000</span>
<span class="n">losses</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">for</span> <span class="n">epoch</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">num_epochs</span><span class="p">):</span>
    <span class="n">outputs</span> <span class="o">=</span> <span class="n">model</span><span class="p">(</span><span class="n">X_tensors</span><span class="p">).</span><span class="n">squeeze</span><span class="p">()</span>
    <span class="n">loss</span> <span class="o">=</span> <span class="n">criterion</span><span class="p">(</span><span class="n">outputs</span><span class="p">,</span> <span class="n">y_tensor</span><span class="p">.</span><span class="n">squeeze</span><span class="p">())</span> <span class="c1">#修整矩阵维度
</span>    
    <span class="n">optimizer</span><span class="p">.</span><span class="n">zero_grad</span><span class="p">()</span>
    <span class="n">loss</span><span class="p">.</span><span class="n">backward</span><span class="p">()</span> <span class="c1"># 反向传播
</span>    <span class="n">optimizer</span><span class="p">.</span><span class="n">step</span><span class="p">()</span>
    <span class="n">losses</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="n">loss</span><span class="p">.</span><span class="n">item</span><span class="p">())</span>
    <span class="k">if</span> <span class="p">(</span><span class="n">epoch</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span> <span class="o">%</span> <span class="mi">1000</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
        <span class="k">print</span><span class="p">(</span><span class="sa">f</span><span class="s">'Epoch [</span><span class="si">{</span><span class="n">epoch</span><span class="o">+</span><span class="mi">1</span><span class="si">}</span><span class="s">/</span><span class="si">{</span><span class="n">num_epochs</span><span class="si">}</span><span class="s">], Loss: </span><span class="si">{</span><span class="n">loss</span><span class="p">.</span><span class="n">item</span><span class="p">()</span><span class="si">:</span><span class="p">.</span><span class="mi">4</span><span class="n">f</span><span class="si">}</span><span class="s">'</span><span class="p">)</span>
</code></pre></div></div>

<h3 id="可视化">可视化</h3>

<p>为了能够直观地看到我们的loss的变化，我们可以使用matplotlib库来绘制loss的变化曲线。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="n">plt</span>
<span class="n">plt</span><span class="p">.</span><span class="n">plot</span><span class="p">(</span><span class="n">losses</span><span class="p">)</span>
<span class="n">plt</span><span class="p">.</span><span class="n">xlabel</span><span class="p">(</span><span class="s">'Epoch'</span><span class="p">)</span>
<span class="n">plt</span><span class="p">.</span><span class="n">ylabel</span><span class="p">(</span><span class="s">'Loss'</span><span class="p">)</span>
<span class="n">plt</span><span class="p">.</span><span class="n">show</span><span class="p">()</span>
</code></pre></div></div>

<p>可以看到，loss在训练过程中逐渐减小，这说明我们的模型在训练过程中逐渐收敛。
如图 <img src="../images/3-17/output.png" alt="loss" /></p>

<h3 id="预测">预测</h3>

<p>训练好模型之后，我们可以使用模型来预测员工是否离 职。
注意，模型的标签要符合我们训练时标签的顺序，这里导入模型后，要把输入向量转移到GPU上。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">#输入分别为 [satisfaction_level, last_evaluation, number_project, average_montly_hours, time_spend_company, Work_accident, promotion_last_5years, sales, salary]
</span><span class="n">new_house_features</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">0.38</span><span class="p">,</span><span class="mf">0.53</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">157</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">]).</span><span class="n">cuda</span><span class="p">()</span>

<span class="k">with</span> <span class="n">torch</span><span class="p">.</span><span class="n">no_grad</span><span class="p">():</span>
    <span class="n">predicted_price</span> <span class="o">=</span> <span class="n">model</span><span class="p">(</span><span class="n">new_house_features</span><span class="p">).</span><span class="n">squeeze</span><span class="p">().</span><span class="n">item</span><span class="p">()</span>
    <span class="k">print</span><span class="p">(</span><span class="s">"预测离职:"</span><span class="p">,</span> <span class="n">predicted_price</span><span class="p">)</span>
</code></pre></div></div>]]></content><author><name></name></author><category term="markdown" /><category term="Machine Learning" /><category term="Deep Learning" /><summary type="html"><![CDATA[本次实验代码的notebook已经上传到我的Github上，点击这里 线性预测 线性预测是一种简单的机器学习模型，它可以用来预测一个或多个输入变量与输出变量之间的关系。线性预测模型的基本形式是： \[y = w_1x_1 + w_2x_2 + ... + w_nx_n + b\] 其中 $y$ 是输出变量，$x_1, x_2, …, x_n$ 是输入变量，$w_1, w_2, …, w_n$ 是权重，$b$ 是偏置。 线性预测模型的训练过程是通过最小化损失函数来确定权重和偏置的值。损失函数的选择是非常重要的，因为它决定了模型的性能。常见的损失函数有均方误差（MSE）和平均绝对误差（MAE）。 数据集 这个实验我们使用了kaggle上常见的员工 离职数据集，HR_comma_sep.csv 数据预处理 导入数据 这里使用pandas库作为数据处理的工具，首先导入数据集，查看数据集的基本信息。 import pandas as pd df = pd.read_csv('HR_comma_sep.csv') print(df.head()) satisfaction_level last_evaluation number_project average_montly_hours \ 0 0.38 0.53 2 157 1 0.80 0.86 5 262 2 0.11 0.88 7 272 3 0.72 0.87 5 223 4 0.37 0.52 2 159 time_spend_company Work_accident left promotion_last_5years sales \ 0 3 0 1 0 sales 1 6 0 1 0 sales 2 4 0 1 0 sales 3 5 0 1 0 sales 4 3 0 1 0 sales salary 0 low 1 medium 2 medium 3 low 4 low 可以发现，数据集中的特征有：satisfaction_level, last_evaluation, number_project, average_montly_hours, time_spend_company, Work_accident, promotion_last_5years, sales。其中sales是员工所在的部门，left是员工是否离职。 数据格式化 为了方便之后的学习过程，这里将每个column的数据单独储存。 level = df['satisfaction_level'] evaluation = df['last_evaluation'] project = df['number_project'] average_monthly_hours = df['average_montly_hours'] time_spend_company = df['time_spend_company'] work_accident = df['Work_accident'] left = df['left'] promotion = df['promotion_last_5years'] department = df['sales'] salary = df['salary'] 可以发现，sales列和salary列是字符串类型的，需要将其转换为数值类型。这里使用字典映射的方式将其转换为数值类型。 department = df['sales'].map({'sales': 1, 'accounting': 2, 'hr': 3, 'technical': 4, 'support': 5, 'management': 6, 'IT': 7, 'product_mng': 8, 'marketing': 9, 'RandD': 10}) salary = df['salary'].map({'low': 1, 'medium': 2, 'high': 3}) 线性模型学习 pytorch pytorch是一个强大的开源深度学习框架，它提供了很多高效的工具和接口，可以帮助我们快速构建和训练深度学习模型。在这个实验中，我们将使用pytorch来构建和训练线性预测模型。 import torch import torch.nn as nn import torch.optim as optim 数据向量化 在训练模型之前，我们需要将数据向量化。这里我们将所有的特征向量化为一个矩阵，将所有的标签向量化为一个向量。 X_tensors = torch.tensor([level, evaluation, project, average_monthly_hours, time_spend_company, work_accident, promotion, department, salary], dtype=torch.float32).T Y_tensors = torch.tensor(left, dtype=torch.float32).view(-1, 1) 其中X_tensors是特征矩阵，Y_tensors是标签向量（是否离职）。 定义模型 在pytorch中，我们可以通过继承nn.Module类来定义模型。这里我们定义了一个简单的线性预测模型。 class linear(nn.Module): def __init__(self, input_size): super(linear, self).__init__() self.linear = nn.Linear(input_size, 1) def forward(self, x): return self.linear(x) 训练模型需要定义损失函数和优化器。pytorch有很多打包好的工具，这里我们使用均方误差（MSE）作为损失函数，使用随机梯度下降（SGD）作为优化器。 model = linear(input_size=9) #定义损失函数 criterion = nn.MSELoss() #定义优化器 optimizer = optim.SGD(model.parameters(), lr=0.00001) #学习率为0.00001 注意，我们的特征矩阵有9个特征，所以输入的大小是9，即输入的input_size是9. 训练模型 torch可以方便地使用GPU进行训练（即使这个模型很简单），这里我们使用GPU进行训练。 device = torch.device('cuda') # 将模型移动到GPU model = model.to(device) # 将数据移动到GPU X_tensors = X_tensors.to(device) y_tensor = y_tensor.to(device) ## 训练 num_epochs = 10000 losses = [] for epoch in range(num_epochs): outputs = model(X_tensors).squeeze() loss = criterion(outputs, y_tensor.squeeze()) #修整矩阵维度 optimizer.zero_grad() loss.backward() # 反向传播 optimizer.step() losses.append(loss.item()) if (epoch+1) % 1000 == 0: print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}') 可视化 为了能够直观地看到我们的loss的变化，我们可以使用matplotlib库来绘制loss的变化曲线。 import matplotlib.pyplot as plt plt.plot(losses) plt.xlabel('Epoch') plt.ylabel('Loss') plt.show() 可以看到，loss在训练过程中逐渐减小，这说明我们的模型在训练过程中逐渐收敛。 如图 预测 训练好模型之后，我们可以使用模型来预测员工是否离 职。 注意，模型的标签要符合我们训练时标签的顺序，这里导入模型后，要把输入向量转移到GPU上。 #输入分别为 [satisfaction_level, last_evaluation, number_project, average_montly_hours, time_spend_company, Work_accident, promotion_last_5years, sales, salary] new_house_features = torch.tensor([0.38,0.53,2,157,3,0,0,1,1]).cuda() with torch.no_grad(): predicted_price = model(new_house_features).squeeze().item() print("预测离职:", predicted_price)]]></summary></entry><entry><title type="html">计算机组成网络</title><link href="nullskymc.cloud/computer_network/" rel="alternate" type="text/html" title="计算机组成网络" /><published>2023-09-19T00:00:00+00:00</published><updated>2023-09-19T00:00:00+00:00</updated><id>nullskymc.cloud/computer_network</id><content type="html" xml:base="nullskymc.cloud/computer_network/"><![CDATA[<h2 id="计算机组成网络">计算机组成网络</h2>

<h3 id="功能组成">功能组成：</h3>

<p>资源子网</p>
<ul>
  <li>应用层</li>
  <li>传输层</li>
  <li>网络层</li>
</ul>

<p>通信子网</p>
<ul>
  <li>数据链路层</li>
  <li>物理层</li>
</ul>

<h3 id="数据单位">数据单位</h3>

<p>计算机网络速率单位：</p>
<ul>
  <li>bps: 比特每秒</li>
  <li>Kbps: 千比特每秒</li>
  <li>Mbps: 兆比特每秒</li>
  <li>Gbps: 十亿比特每秒</li>
  <li>Tbps: 万亿比特每秒</li>
</ul>

<p>主机在1us内可以传输的比特数</p>

<p>存储容量单位：</p>
<ul>
  <li>bit: 比特</li>
  <li>B: 字节</li>
  <li>KB: 千字节</li>
  <li>MB: 兆字节</li>
  <li>GB: 十亿字节</li>
  <li>TB: 万亿字节</li>
</ul>

<p>吞吐量：</p>
<ul>
  <li>速率：单位时间内通过某个网络的数据量</li>
  <li>带宽：网络中某一通道所能通过的最高速率</li>
  <li>吞吐量：单位时间内通过某个网络的实际数据量</li>
</ul>

<p>时延：</p>
<ul>
  <li>发送时延：主机发送数据帧所需时间
    <blockquote>
      <p>发送时延 = 数据帧长度（比特）/ 发送速率（比特每秒）</p>
    </blockquote>
  </li>
  <li>传播时延：电磁波在信道中传播所需时间
    <blockquote>
      <p>传播时延 = 信道长度（比特）/ 电磁波在信道上的传播速率（比特每秒）</p>
    </blockquote>
  </li>
  <li>处理时延：主机或路由器对帧进行处理所需时间</li>
  <li>排队时延：帧在缓存器中排队所需时间</li>
</ul>

<p>时延带宽积：</p>
<ul>
  <li>时延带宽积 = 传播时延 * 带宽
以比特为单位的链路长度</li>
</ul>

<h3 id="tcpip协议">TCP/IP协议</h3>

<h4 id="tcpip协议分层">TCP/IP协议分层</h4>

<ul>
  <li>应用层</li>
  <li>传输层</li>
  <li>网络层</li>
  <li>数据链路层</li>
  <li>物理层</li>
</ul>

<h3 id="物理层">物理层</h3>

<h4 id="物理层的基本概念">物理层的基本概念</h4>
<ul>
  <li>信号
    <blockquote>
      <p>数据的电气或电磁表现</p>
    </blockquote>
  </li>
  <li>信道
    <blockquote>
      <p>信号传输的媒体</p>
    </blockquote>
  </li>
  <li>码元
    <blockquote>
      <p>在信道上传输固定时长的基本波形，代表不同的离散数值，这个时长内的信号称为k进制码元，该时长为码元宽度</p>
    </blockquote>
  </li>
  <li>速率
    <blockquote>
      <p>码元传输速率、信息传输速率。单位为波特（Baud）</p>
    </blockquote>
  </li>
</ul>

<blockquote>
  <p>码元传输速率 = 1 / 码元宽度</p>
</blockquote>

<blockquote>
  <p>信息传输速率 = 码元传输速率 * $log_2V$</p>
  <blockquote>
    <p>表示单位时间内数字通信系统传输的二进制码元个数
若一个码元携带n bit的信息量，则M Baud 的码元传输速率可以传输的信息速率为 $n * M bps(bit/s)$</p>
  </blockquote>
</blockquote>

<ul>
  <li>带宽
    <blockquote>
      <p>模拟信号系统中，信号的最高频率与最低频率之差，单位为赫兹（Hz）</p>
    </blockquote>
  </li>
</ul>

<blockquote>
  <p>数字信号系统中，从网络中某一点到另一点所能通过的最高数据率（单位时间内通过链路的数量值），单位为比特每秒（bps）</p>
</blockquote>

<p>两个定理：</p>
<ul>
  <li>奈奎斯特定理：理想低通信道的极限数据传输率
    <blockquote>
      <p>$C = 2 * B * log2V$<br />
C: 信道极限传输率<br />
B: 带宽<br />
V: 传输电平数<br />
理想低通信道的最高码元传输速率 = 2 * 带宽(W) * log2(传输电平数)</p>
    </blockquote>
  </li>
  <li>香农定理：信道极限传输率的实际上限
    <blockquote>
      <p>信噪比：信号功率与噪声功率之比（S/N）单位为分贝（dB）<br />
$C = B * log2(1 + S/N)$<br />
C: 信道极限传输率<br />
B: 带宽<br />
S: 信号平均功率<br />
N: 噪声平均功率</p>
    </blockquote>
  </li>
</ul>

<h4 id="传输方式通信方式通信模式">传输方式、通信方式、通信模式</h4>

<p>传输方式：</p>
<ul>
  <li>并行传输
    <blockquote>
      <p>一次发送n个比特</p>
    </blockquote>
  </li>
  <li>串行传输
    <blockquote>
      <p>一次发送1个比特</p>
    </blockquote>
  </li>
</ul>

<p>通信方式：</p>
<ul>
  <li>单工通信
    <blockquote>
      <p>只能有一个方向的通信</p>
    </blockquote>
  </li>
  <li>半双工通信
    <blockquote>
      <p>双方都可以发送，但不能同时发送</p>
    </blockquote>
  </li>
  <li>全双工通信
    <blockquote>
      <p>双方可以同时发送</p>
    </blockquote>
  </li>
</ul>

<p>通信模式：</p>
<ul>
  <li>单点通信
    <blockquote>
      <p>一对一通信</p>
    </blockquote>
  </li>
  <li>多点通信
    <blockquote>
      <p>一对多通信</p>
    </blockquote>
  </li>
</ul>]]></content><author><name></name></author><category term="network" /><category term="markdown" /><summary type="html"><![CDATA[计算机组成网络 功能组成： 资源子网 应用层 传输层 网络层 通信子网 数据链路层 物理层 数据单位 计算机网络速率单位： bps: 比特每秒 Kbps: 千比特每秒 Mbps: 兆比特每秒 Gbps: 十亿比特每秒 Tbps: 万亿比特每秒 主机在1us内可以传输的比特数 存储容量单位： bit: 比特 B: 字节 KB: 千字节 MB: 兆字节 GB: 十亿字节 TB: 万亿字节 吞吐量： 速率：单位时间内通过某个网络的数据量 带宽：网络中某一通道所能通过的最高速率 吞吐量：单位时间内通过某个网络的实际数据量 时延： 发送时延：主机发送数据帧所需时间 发送时延 = 数据帧长度（比特）/ 发送速率（比特每秒） 传播时延：电磁波在信道中传播所需时间 传播时延 = 信道长度（比特）/ 电磁波在信道上的传播速率（比特每秒） 处理时延：主机或路由器对帧进行处理所需时间 排队时延：帧在缓存器中排队所需时间 时延带宽积： 时延带宽积 = 传播时延 * 带宽 以比特为单位的链路长度 TCP/IP协议 TCP/IP协议分层 应用层 传输层 网络层 数据链路层 物理层 物理层 物理层的基本概念 信号 数据的电气或电磁表现 信道 信号传输的媒体 码元 在信道上传输固定时长的基本波形，代表不同的离散数值，这个时长内的信号称为k进制码元，该时长为码元宽度 速率 码元传输速率、信息传输速率。单位为波特（Baud） 码元传输速率 = 1 / 码元宽度 信息传输速率 = 码元传输速率 * $log_2V$ 表示单位时间内数字通信系统传输的二进制码元个数 若一个码元携带n bit的信息量，则M Baud 的码元传输速率可以传输的信息速率为 $n * M bps(bit/s)$ 带宽 模拟信号系统中，信号的最高频率与最低频率之差，单位为赫兹（Hz） 数字信号系统中，从网络中某一点到另一点所能通过的最高数据率（单位时间内通过链路的数量值），单位为比特每秒（bps） 两个定理： 奈奎斯特定理：理想低通信道的极限数据传输率 $C = 2 * B * log2V$ C: 信道极限传输率 B: 带宽 V: 传输电平数 理想低通信道的最高码元传输速率 = 2 * 带宽(W) * log2(传输电平数) 香农定理：信道极限传输率的实际上限 信噪比：信号功率与噪声功率之比（S/N）单位为分贝（dB） $C = B * log2(1 + S/N)$ C: 信道极限传输率 B: 带宽 S: 信号平均功率 N: 噪声平均功率 传输方式、通信方式、通信模式 传输方式： 并行传输 一次发送n个比特 串行传输 一次发送1个比特 通信方式： 单工通信 只能有一个方向的通信 半双工通信 双方都可以发送，但不能同时发送 全双工通信 双方可以同时发送 通信模式： 单点通信 一对一通信 多点通信 一对多通信]]></summary></entry><entry><title type="html">Langchain文档-起步</title><link href="nullskymc.cloud/langchain_start/" rel="alternate" type="text/html" title="Langchain文档-起步" /><published>2023-09-19T00:00:00+00:00</published><updated>2023-09-19T00:00:00+00:00</updated><id>nullskymc.cloud/langchain_start</id><content type="html" xml:base="nullskymc.cloud/langchain_start/"><![CDATA[<h2 id="使用-langchain-构建">使用 LangChain 构建</h2>

<p>LangChain 使构建连接外部数据源和计算到LLMs的应用程序变得更加容易。在这个快速入门中，我们将演示几种不同的方式。我们将从一个简单的LLM链开始，它仅仅依赖于提示模板中的信息来作出响应。接下来，我们将构建一个检索链，它从一个独立的数据库中获取数据并将其传递到提示模板中。然后，我们将添加聊天记录，以创建一个对话检索链。这允许您以聊天的方式与LLM进行交互，以便它记住以前的问题。最后，我们将构建一个代理，它利用LLM来确定是否需要获取数据来回答问题。我们将以高层次的方式介绍这些内容，但这些都涉及许多细节！我们将链接到相关的文档。</p>

<h2 id="llm链">LLM链</h2>

<h3 id="api使用">API使用</h3>

<p>在这个入门指南中，我们将提供两个选项：使用阿里云模型（通过API可用的流行模型）或使用本地开源模型。</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pip <span class="nb">install </span>langchain
</code></pre></div></div>

<p>访问API需要一个API密钥，您可以通过创建帐户并获取。一旦我们有了密钥，我们将希望将其设置为环境变量，通过运行以下命令：</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">export </span>DASHSCOPE_API_KEY <span class="o">=</span> <span class="s2">"..."</span>
</code></pre></div></div>

<p>或在python中使用os模块导入</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">os</span>
<span class="n">os</span><span class="p">.</span><span class="n">environ</span><span class="p">[</span><span class="s">"DASHSCOPE_API_KEY"</span><span class="p">]</span> <span class="o">=</span> <span class="s">"..."</span>
</code></pre></div></div>

<p>然后我们可以初始化模型：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain.llms</span> <span class="kn">import</span> <span class="n">Tongyi</span>

<span class="n">llm</span> <span class="o">=</span> <span class="n">Tongyi</span><span class="p">()</span>
</code></pre></div></div>

<p>如果您不想设置环境变量，可以在初始化 LLM类时直接通过<code class="language-plaintext highlighter-rouge">_api_key</code>命名参数传递密钥：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain_</span> <span class="kn">import</span> <span class="n">Chat</span>

<span class="n">llm</span> <span class="o">=</span> <span class="n">Chat</span><span class="p">(</span><span class="n">DASHSCOPE_API_KEY</span><span class="o">=</span><span class="s">"..."</span><span class="p">)</span>
</code></pre></div></div>

<h3 id="本地使用">本地使用</h3>

<p><a href="https://ollama.ai/">Ollama</a> 允许您在本地运行开源的大型语言模型，比如 Llama 2。</p>

<p>首先，请按照<a href="https://github.com/jmorganca/ollama">这些说明</a>设置和运行本地的Ollama实例：</p>

<ul>
  <li><a href="https://ollama.ai/download">下载</a></li>
  <li>通过 <code class="language-plaintext highlighter-rouge">ollama pull llama2</code> 获取模型</li>
</ul>

<p>然后，确保Ollama服务器正在运行。之后，您可以执行以下操作：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain_community.llms</span> <span class="kn">import</span> <span class="n">Ollama</span>
<span class="n">llm</span> <span class="o">=</span> <span class="n">Ollama</span><span class="p">(</span><span class="n">model</span><span class="o">=</span><span class="s">"llama2"</span><span class="p">)</span>
</code></pre></div></div>

<h3 id="调用模型">调用模型</h3>

<p>一旦您安装并初始化了所选LLM，我们可以尝试使用它！让我们问它LangSmith是什么 - 这是训练数据中没有的东西，所以它不应该有一个很好的回答。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">llm</span><span class="p">.</span><span class="n">invoke</span><span class="p">(</span><span class="s">"how can langsmith help with testing?"</span><span class="p">)</span>
</code></pre></div></div>

<h3 id="模板调用">模板调用</h3>

<p>我们还可以使用提示模板来引导它的响应。提示模板用于将原始用户输入转换为更好的LLM输入。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain_core.prompts</span> <span class="kn">import</span> <span class="n">ChatPromptTemplate</span>
<span class="n">prompt</span> <span class="o">=</span> <span class="n">ChatPromptTemplate</span><span class="p">.</span><span class="n">from_messages</span><span class="p">([</span>
    <span class="p">(</span><span class="s">"system"</span><span class="p">,</span> <span class="s">"You are world class technical documentation writer."</span><span class="p">),</span>
    <span class="p">(</span><span class="s">"user"</span><span class="p">,</span> <span class="s">"{input}"</span><span class="p">)</span>
<span class="p">])</span>
</code></pre></div></div>

<p>现在我们可以将这些组合成一个简单的LLM链：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">chain</span> <span class="o">=</span> <span class="n">prompt</span> <span class="o">|</span> <span class="n">llm</span> 
</code></pre></div></div>

<p>我们现在可以调用它并问相同的问题。它仍然不会知道答案，但它应该以更适当的语气回应技术写作者！</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">chain</span><span class="p">.</span><span class="n">invoke</span><span class="p">({</span><span class="s">"input"</span><span class="p">:</span> <span class="s">"how can langsmith help with testing?"</span><span class="p">})</span>
</code></pre></div></div>

<p>ChatModel的输出（因此，此链的输出）是一条消息。然而，使用字符串处理通常更方便。让我们添加一个简单的输出解析器，将聊天消息转换为字符串。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain_core.output_parsers</span> <span class="kn">import</span> <span class="n">StrOutputParser</span>

<span class="n">output_parser</span> <span class="o">=</span> <span class="n">StrOutputParser</span><span class="p">()</span>
</code></pre></div></div>

<p>现在我们可以将其添加到之前的链中：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">chain</span> <span class="o">=</span> <span class="n">prompt</span> <span class="o">|</span> <span class="n">llm</span> <span class="o">|</span> <span class="n">output_parser</span>
</code></pre></div></div>

<p>我们现在可以调用它并问相同的问题。答案现在将是一个字符串（而不是ChatMessage）。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">chain</span><span class="p">.</span><span class="n">invoke</span><span class="p">({</span><span class="s">"input"</span><span class="p">:</span> <span class="s">"how can langsmith help with testing?"</span><span class="p">})</span>
</code></pre></div></div>

<h2 id="检索链">检索链</h2>

<p>为了正确回答原始问题（“langsmith如何帮助测试？”），我们需要向LLM提供额外的上下文。我们可以通过<em>检索</em>来实现这一点。当您有<strong>太多数据</strong>无法直接传递给LLM时，检索就变得很有用。您可以使用检索器仅获取最相关的片段并将其传递进去。</p>

<p>在此过程中，我们将从一个<em>检索器</em>中查找相关文档，然后将这些文档传递到提示中。检索器可以由任何东西支持 - SQL表、互联网等 - 但在这个示例中，我们将填充一个向量存储并将其用作检索器。</p>

<p>首先，我们需要加载要索引的数据。为此，我们将使用WebBaseLoader。这需要安装<a href="https://beautiful-soup-4.readthedocs.io/en/latest/">BeautifulSoup</a>：</p>

<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pip <span class="nb">install </span>beautifulsoup4
</code></pre></div></div>

<p>之后，我们可以导入并使用WebBaseLoader。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain_community.document_loaders</span> <span class="kn">import</span> <span class="n">WebBaseLoader</span>
<span class="n">loader</span> <span class="o">=</span> <span class="n">WebBaseLoader</span><span class="p">(</span><span class="s">"https://docs.smith.langchain.com/overview"</span><span class="p">)</span>

<span class="n">docs</span> <span class="o">=</span> <span class="n">loader</span><span class="p">.</span><span class="n">load</span><span class="p">()</span>
</code></pre></div></div>

<p>接下来，我们需要将其索引到一个向量存储中。这需要一些组件，即嵌入模型和向量存储。</p>

<p>对于嵌入模型，我们再次提供了通过或通过本地模型访问的示例。</p>

<p>确保已安装 <code class="language-plaintext highlighter-rouge">langchain</code> 包并设置了适当的环境变量（这与LLM所需的相同）。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain</span> <span class="kn">import</span> <span class="n">Embeddings</span>

<span class="n">embeddings</span> <span class="o">=</span> <span class="n">Embeddings</span><span class="p">()</span>
</code></pre></div></div>

<p>确保Ollama正在运行（与LLM一样设置）。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain_community.embeddings</span> <span class="kn">import</span> <span class="n">OllamaEmbeddings</span>

<span class="n">embeddings</span> <span class="o">=</span> <span class="n">OllamaEmbeddings</span><span class="p">()</span>
</code></pre></div></div>

<p>现在，我们可以使用这个嵌入模型将文档加载到向量存储中。为了简单起见，我们将使用一个简单的本地向量存储<a href="/docs/integrations/vectorstores/faiss">FAISS</a>。</p>

<p>首先，我们需要安装该存储所需的软件包：</p>

<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pip <span class="nb">install </span>faiss-cpu
</code></pre></div></div>

<p>然后我们可以构建我们的索引：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain_community.vectorstores</span> <span class="kn">import</span> <span class="n">FAISS</span>
<span class="kn">from</span> <span class="nn">langchain.text_splitter</span> <span class="kn">import</span> <span class="n">RecursiveCharacterTextSplitter</span>

<span class="n">text_splitter</span> <span class="o">=</span> <span class="n">RecursiveCharacterTextSplitter</span><span class="p">()</span>
<span class="n">documents</span> <span class="o">=</span> <span class="n">text_splitter</span><span class="p">.</span><span class="n">split_documents</span><span class="p">(</span><span class="n">docs</span><span class="p">)</span>
<span class="n">vector</span> <span class="o">=</span> <span class="n">FAISS</span><span class="p">.</span><span class="n">from_documents</span><span class="p">(</span><span class="n">documents</span><span class="p">,</span> <span class="n">embeddings</span><span class="p">)</span>
</code></pre></div></div>

<p>现在我们已经在向量存储中索引了这些数据，我们将创建一个检索链。此链将获取传入的问题，查找相关文档，然后将这些文档连同原始问题一起传递到LLM中，并要求其回答原始问题。</p>

<p>首先，让我们设置一个链，该链接受一个问题和检索到的文档，并生成一个答案。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain.chains.combine_documents</span> <span class="kn">import</span> <span class="n">create_stuff_documents_chain</span>

<span class="n">prompt</span> <span class="o">=</span> <span class="n">ChatPromptTemplate</span><span class="p">.</span><span class="n">from_template</span><span class="p">(</span><span class="s">"""Answer the following question based only on the provided context:

&lt;context&gt;
{context}
&lt;/context&gt;

Question: {input}"""</span><span class="p">)</span>

<span class="n">document_chain</span> <span class="o">=</span> <span class="n">create_stuff_documents_chain</span><span class="p">(</span><span class="n">llm</span><span class="p">,</span> <span class="n">prompt</span><span class="p">)</span>
</code></pre></div></div>

<p>如果我们愿意，我们可以自己运行它，直接传递文档：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain_core.documents</span> <span class="kn">import</span> <span class="n">Document</span>

<span class="n">document_chain</span><span class="p">.</span><span class="n">invoke</span><span class="p">({</span>
    <span class="s">"input"</span><span class="p">:</span> <span class="s">"how can langsmith help with testing?"</span><span class="p">,</span>
    <span class="s">"context"</span><span class="p">:</span> <span class="p">[</span><span class="n">Document</span><span class="p">(</span><span class="n">page_content</span><span class="o">=</span><span class="s">"langsmith can let you visualize test results"</span><span class="p">)]</span>
<span class="p">})</span>
</code></pre></div></div>

<p>但是，我们希望文档首先来自我们刚刚设置的检索器。这样，对于给定的问题，我们可以使用检索器动态选择最相关的文档并传递进去。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain.chains</span> <span class="kn">import</span> <span class="n">create_retrieval_chain</span>

<span class="n">retriever</span> <span class="o">=</span> <span class="n">vector</span><span class="p">.</span><span class="n">as_retriever</span><span class="p">()</span>
<span class="n">retrieval_chain</span> <span class="o">=</span> <span class="n">create_retrieval_chain</span><span class="p">(</span><span class="n">retriever</span><span class="p">,</span> <span class="n">document_chain</span><span class="p">)</span>
</code></pre></div></div>

<p>我们现在可以调用此链。这返回一个字典 - LLM的响应在<code class="language-plaintext highlighter-rouge">answer</code>键中。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">response</span> <span class="o">=</span> <span class="n">retrieval_chain</span><span class="p">.</span><span class="n">invoke</span><span class="p">({</span><span class="s">"input"</span><span class="p">:</span> <span class="s">"how can langsmith help with testing?"</span><span class="p">})</span>
<span class="k">print</span><span class="p">(</span><span class="n">response</span><span class="p">[</span><span class="s">"answer"</span><span class="p">])</span>

<span class="c1"># LangSmith offers several features that can help with testing:...
</span></code></pre></div></div>

<p>这个答案应该更准确！</p>

<h2 id="对话检索链">对话检索链</h2>

<p>到目前为止，我们创建的链只能回答单个问题。人们正在构建的LLM应用程序的主要类型之一是聊天机器人。那么，我们如何将这个链变成一个可以回答后续问题的链呢？</p>

<p>我们仍然可以使用<code class="language-plaintext highlighter-rouge">create_retrieval_chain</code>函数，但我们需要更改两件事：</p>

<ol>
  <li>检索方法现在不仅仅应该在最近的输入上工作，而是应该考虑整个历史记录。</li>
  <li>最终的LLM链同样应该考虑整个历史记录</li>
</ol>

<h3 id="更新检索">更新检索</h3>

<p>为了更新检索，我们将创建一个新的链。这个链将接收最新的输入（<code class="language-plaintext highlighter-rouge">input</code>）和对话历史（<code class="language-plaintext highlighter-rouge">chat_history</code>），并使用LLM生成一个搜索查询。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain.chains</span> <span class="kn">import</span> <span class="n">create_history_aware_retriever</span>
<span class="kn">from</span> <span class="nn">langchain_core.prompts</span> <span class="kn">import</span> <span class="n">MessagesPlaceholder</span>

<span class="c1"># 首先，我们需要一个我们可以传递到LLM以生成此搜索查询的提示
</span>
<span class="n">prompt</span> <span class="o">=</span> <span class="n">ChatPromptTemplate</span><span class="p">.</span><span class="n">from_messages</span><span class="p">([</span>
    <span class="n">MessagesPlaceholder</span><span class="p">(</span><span class="n">variable_name</span><span class="o">=</span><span class="s">"chat_history"</span><span class="p">),</span>
    <span class="p">(</span><span class="s">"user"</span><span class="p">,</span> <span class="s">"{input}"</span><span class="p">),</span>
    <span class="p">(</span><span class="s">"user"</span><span class="p">,</span> <span class="s">"Given the above conversation, generate a search query to look up in order to get information relevant to the conversation"</span><span class="p">)</span>
<span class="p">])</span>
<span class="n">retriever_chain</span> <span class="o">=</span> <span class="n">create_history_aware_retriever</span><span class="p">(</span><span class="n">llm</span><span class="p">,</span> <span class="n">retriever</span><span class="p">,</span> <span class="n">prompt</span><span class="p">)</span>
</code></pre></div></div>

<p>我们可以通过传递一个用户正在提出后续问题的实例来测试这一点。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain_core.messages</span> <span class="kn">import</span> <span class="n">HumanMessage</span><span class="p">,</span> <span class="n">AIMessage</span>

<span class="n">chat_history</span> <span class="o">=</span> <span class="p">[</span><span class="n">HumanMessage</span><span class="p">(</span><span class="n">content</span><span class="o">=</span><span class="s">"Can LangSmith help test my LLM applications?"</span><span class="p">),</span> <span class="n">AIMessage</span><span class="p">(</span><span class="n">content</span><span class="o">=</span><span class="s">"Yes!"</span><span class="p">)]</span>
<span class="n">retriever_chain</span><span class="p">.</span><span class="n">invoke</span><span class="p">({</span>
    <span class="s">"chat_history"</span><span class="p">:</span> <span class="n">chat_history</span><span class="p">,</span>
    <span class="s">"input"</span><span class="p">:</span> <span class="s">"Tell me how"</span>
<span class="p">})</span>
</code></pre></div></div>

<p>你应该看到这返回了关于在LangSmith中测试的文档。这是因为LLM生成了一个新的查询，将聊天历史与后续问题结合起来。</p>

<p>现在我们有了这个新的检索器，我们可以创建一个新的链，以在考虑到这些检索到的文档的情况下继续对话。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">prompt</span> <span class="o">=</span> <span class="n">ChatPromptTemplate</span><span class="p">.</span><span class="n">from_messages</span><span class="p">([</span>
    <span class="p">(</span><span class="s">"system"</span><span class="p">,</span> <span class="s">"基于以下上下文回答用户的问题：</span><span class="se">\n\n</span><span class="s">{context}"</span><span class="p">),</span>
    <span class="n">MessagesPlaceholder</span><span class="p">(</span><span class="n">variable_name</span><span class="o">=</span><span class="s">"chat_history"</span><span class="p">),</span>
    <span class="p">(</span><span class="s">"user"</span><span class="p">,</span> <span class="s">"{input}"</span><span class="p">),</span>
<span class="p">])</span>
<span class="n">document_chain</span> <span class="o">=</span> <span class="n">create_stuff_documents_chain</span><span class="p">(</span><span class="n">llm</span><span class="p">,</span> <span class="n">prompt</span><span class="p">)</span>

<span class="n">retrieval_chain</span> <span class="o">=</span> <span class="n">create_retrieval_chain</span><span class="p">(</span><span class="n">retriever_chain</span><span class="p">,</span> <span class="n">document_chain</span><span class="p">)</span>
</code></pre></div></div>

<p>现在我们可以进行端到端的测试：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">chat_history</span> <span class="o">=</span> <span class="p">[</span><span class="n">HumanMessage</span><span class="p">(</span><span class="n">content</span><span class="o">=</span><span class="s">"Can LangSmith help test my LLM applications?"</span><span class="p">),</span> <span class="n">AIMessage</span><span class="p">(</span><span class="n">content</span><span class="o">=</span><span class="s">"Yes!"</span><span class="p">)]</span>
<span class="n">retrieval_chain</span><span class="p">.</span><span class="n">invoke</span><span class="p">({</span>
    <span class="s">"chat_history"</span><span class="p">:</span> <span class="n">chat_history</span><span class="p">,</span>
    <span class="s">"input"</span><span class="p">:</span> <span class="s">"Tell me how"</span>
<span class="p">})</span>
</code></pre></div></div>

<p>我们可以看到这给出了一个连贯的答案 - 我们成功地将我们的检索链转化为一个聊天机器人！</p>

<h2 id="代理">代理</h2>

<p>到目前为止，我们已经创建了链的示例 - 在这里，每个步骤都是预先知道的。
我们将创建的最后一件事是一个代理 - 在这里，LLM决定采取什么步骤。</p>

<p><strong>注意：对于这个示例，我们将仅展示如何使用OpenAI模型创建代理，因为本地模型目前还不够可靠。</strong></p>

<p>构建代理时的第一件事是决定它应该访问什么工具。
在这个例子中，我们将给代理访问两个工具的权限：</p>

<ol>
  <li>我们刚刚创建的检索器。这将使它轻松回答关于LangSmith的问题。</li>
  <li>一个搜索工具。这将使它轻松回答需要最新信息的问题。</li>
</ol>

<p>首先，让我们设置一个用于我们刚刚创建的检索器的工具：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain.tools.retriever</span> <span class="kn">import</span> <span class="n">create_retriever_tool</span>

<span class="n">retriever_tool</span> <span class="o">=</span> <span class="n">create_retriever_tool</span><span class="p">(</span>
    <span class="n">retriever</span><span class="p">,</span>
    <span class="s">"langsmith_search"</span><span class="p">,</span>
    <span class="s">"搜索有关LangSmith的信息。有关LangSmith的任何问题，您必须使用此工具！"</span><span class="p">,</span>
<span class="p">)</span>
</code></pre></div></div>

<p>现在，我们可以创建一个要使用的工具列表：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">tools</span> <span class="o">=</span> <span class="p">[</span><span class="n">retriever_tool</span><span class="p">,</span> <span class="n">search</span><span class="p">]</span>
</code></pre></div></div>

<p>现在我们有了工具，可以创建一个代理来使用它们。我们将快速浏览一下这个过程</p>

<p>首先安装langchain hub</p>

<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pip <span class="nb">install </span>langchainhub
</code></pre></div></div>

<p>现在我们可以使用它来获取预定义的提示</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain_openai</span> <span class="kn">import</span> <span class="n">ChatOpenAI</span>
<span class="kn">from</span> <span class="nn">langchain</span> <span class="kn">import</span> <span class="n">hub</span>
<span class="kn">from</span> <span class="nn">langchain.agents</span> <span class="kn">import</span> <span class="n">create_openai_functions_agent</span>
<span class="kn">from</span> <span class="nn">langchain.agents</span> <span class="kn">import</span> <span class="n">AgentExecutor</span>

<span class="c1"># 获取要使用的提示 - 您可以修改这个！
</span><span class="n">prompt</span> <span class="o">=</span> <span class="n">hub</span><span class="p">.</span><span class="n">pull</span><span class="p">(</span><span class="s">"hwchase17/openai-functions-agent"</span><span class="p">)</span>
<span class="n">llm</span> <span class="o">=</span> <span class="n">ChatOpenAI</span><span class="p">(</span><span class="n">model</span><span class="o">=</span><span class="s">"gpt-3.5-turbo"</span><span class="p">,</span> <span class="n">temperature</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span>
<span class="n">agent</span> <span class="o">=</span> <span class="n">create_openai_functions_agent</span><span class="p">(</span><span class="n">llm</span><span class="p">,</span> <span class="n">tools</span><span class="p">,</span> <span class="n">prompt</span><span class="p">)</span>
<span class="n">agent_executor</span> <span class="o">=</span> <span class="n">AgentExecutor</span><span class="p">(</span><span class="n">agent</span><span class="o">=</span><span class="n">agent</span><span class="p">,</span> <span class="n">tools</span><span class="o">=</span><span class="n">tools</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
</code></pre></div></div>

<p>现在我们可以调用代理并查看它的响应！我们可以问它关于LangSmith的问题：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">agent_executor</span><span class="p">.</span><span class="n">invoke</span><span class="p">({</span><span class="s">"input"</span><span class="p">:</span> <span class="s">"how can langsmith help with testing?"</span><span class="p">})</span>
</code></pre></div></div>

<p>我们可以问它关于天气的问题：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">agent_executor</span><span class="p">.</span><span class="n">invoke</span><span class="p">({</span><span class="s">"input"</span><span class="p">:</span> <span class="s">"what is the weather in SF?"</span><span class="p">})</span>
</code></pre></div></div>

<p>我们可以与它进行对话：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">chat_history</span> <span class="o">=</span> <span class="p">[</span><span class="n">HumanMessage</span><span class="p">(</span><span class="n">content</span><span class="o">=</span><span class="s">"Can LangSmith help test my LLM applications?"</span><span class="p">),</span> <span class="n">AIMessage</span><span class="p">(</span><span class="n">content</span><span class="o">=</span><span class="s">"Yes!"</span><span class="p">)]</span>
<span class="n">agent_executor</span><span class="p">.</span><span class="n">invoke</span><span class="p">({</span>
    <span class="s">"chat_history"</span><span class="p">:</span> <span class="n">chat_history</span><span class="p">,</span>
    <span class="s">"input"</span><span class="p">:</span> <span class="s">"Tell me how"</span>
<span class="p">})</span>
</code></pre></div></div>

<h2 id="使用langserve提供服务">使用LangServe提供服务</h2>

<p>现在我们已经构建了一个应用程序，需要将其提供服务。这就是LangServe的用武之地。
LangServe帮助开发人员将LangChain链部署为REST API。您不需要使用LangServe来使用LangChain，但在本指南中，我们将展示如何使用LangServe部署您的应用程序。</p>

<p>虽然本指南的第一部分是在Jupyter Notebook中运行的，但现在我们将离开那里。我们将创建一个Python文件，然后从命令行与其进行交互。</p>

<p>使用以下命令安装：</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pip <span class="nb">install</span> <span class="s2">"langserve[all]"</span>
</code></pre></div></div>

<h3 id="服务器">服务器</h3>

<p>为了为我们的应用程序创建一个服务器，我们将制作一个serve.py文件。这将包含我们为提供应用程序而构建的逻辑。它包括三个部分：</p>

<ol>
  <li>我们刚刚构建的链的定义</li>
  <li>我们的FastAPI应用程序</li>
  <li>用于提供链的路由的定义，使用 langserve.add_routes 完成</li>
</ol>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">#!/usr/bin/env python
</span><span class="kn">from</span> <span class="nn">typing</span> <span class="kn">import</span> <span class="n">List</span>

<span class="kn">from</span> <span class="nn">fastapi</span> <span class="kn">import</span> <span class="n">FastAPI</span>
<span class="kn">from</span> <span class="nn">langchain_core.prompts</span> <span class="kn">import</span> <span class="n">ChatPromptTemplate</span>
<span class="kn">from</span> <span class="nn">langchain_openai</span> <span class="kn">import</span> <span class="n">ChatOpenAI</span>
<span class="kn">from</span> <span class="nn">langchain_community.document_loaders</span> <span class="kn">import</span> <span class="n">WebBaseLoader</span>
<span class="kn">from</span> <span class="nn">langchain_openai</span> <span class="kn">import</span> <span class="n">OpenAIEmbeddings</span>
<span class="kn">from</span> <span class="nn">langchain_community.vectorstores</span> <span class="kn">import</span> <span class="n">FAISS</span>
<span class="kn">from</span> <span class="nn">langchain.text_splitter</span> <span class="kn">import</span> <span class="n">RecursiveCharacterTextSplitter</span>
<span class="kn">from</span> <span class="nn">langchain.tools.retriever</span> <span class="kn">import</span> <span class="n">create_retriever_tool</span>
<span class="kn">from</span> <span class="nn">langchain_community.tools.tavily_search</span> <span class="kn">import</span> <span class="n">TavilySearchResults</span>
<span class="kn">from</span> <span class="nn">langchain_openai</span> <span class="kn">import</span> <span class="n">ChatOpenAI</span>
<span class="kn">from</span> <span class="nn">langchain</span> <span class="kn">import</span> <span class="n">hub</span>
<span class="kn">from</span> <span class="nn">langchain.agents</span> <span class="kn">import</span> <span class="n">create_openai_functions_agent</span>
<span class="kn">from</span> <span class="nn">langchain.agents</span> <span class="kn">import</span> <span class="n">AgentExecutor</span>
<span class="kn">from</span> <span class="nn">langchain.pydantic_v1</span> <span class="kn">import</span> <span class="n">BaseModel</span><span class="p">,</span> <span class="n">Field</span>
<span class="kn">from</span> <span class="nn">langchain_core.messages</span> <span class="kn">import</span> <span class="n">BaseMessage</span>
<span class="kn">from</span> <span class="nn">langserve</span> <span class="kn">import</span> <span class="n">add_routes</span>

<span class="c1"># 1. Load Retriever
</span><span class="n">loader</span> <span class="o">=</span> <span class="n">WebBaseLoader</span><span class="p">(</span><span class="s">"https://docs.smith.langchain.com/overview"</span><span class="p">)</span>
<span class="n">docs</span> <span class="o">=</span> <span class="n">loader</span><span class="p">.</span><span class="n">load</span><span class="p">()</span>
<span class="n">text_splitter</span> <span class="o">=</span> <span class="n">RecursiveCharacterTextSplitter</span><span class="p">()</span>
<span class="n">documents</span> <span class="o">=</span> <span class="n">text_splitter</span><span class="p">.</span><span class="n">split_documents</span><span class="p">(</span><span class="n">docs</span><span class="p">)</span>
<span class="n">embeddings</span> <span class="o">=</span> <span class="n">OpenAIEmbeddings</span><span class="p">()</span>
<span class="n">vector</span> <span class="o">=</span> <span class="n">FAISS</span><span class="p">.</span><span class="n">from_documents</span><span class="p">(</span><span class="n">documents</span><span class="p">,</span> <span class="n">embeddings</span><span class="p">)</span>
<span class="n">retriever</span> <span class="o">=</span> <span class="n">vector</span><span class="p">.</span><span class="n">as_retriever</span><span class="p">()</span>

<span class="c1"># 2. Create Tools
</span><span class="n">retriever_tool</span> <span class="o">=</span> <span class="n">create_retriever_tool</span><span class="p">(</span>
    <span class="n">retriever</span><span class="p">,</span>
    <span class="s">"langsmith_search"</span><span class="p">,</span>
    <span class="s">"搜索有关LangSmith的信息。有关LangSmith的任何问题，您必须使用此工具！"</span><span class="p">,</span>
<span class="p">)</span>
<span class="n">search</span> <span class="o">=</span> <span class="n">TavilySearchResults</span><span class="p">()</span>
<span class="n">tools</span> <span class="o">=</span> <span class="p">[</span><span class="n">retriever_tool</span><span class="p">,</span> <span class="n">search</span><span class="p">]</span>


<span class="c1"># 3. Create Agent
</span><span class="n">prompt</span> <span class="o">=</span> <span class="n">hub</span><span class="p">.</span><span class="n">pull</span><span class="p">(</span><span class="s">"hwchase17/openai-functions-agent"</span><span class="p">)</span>
<span class="n">llm</span> <span class="o">=</span> <span class="n">ChatOpenAI</span><span class="p">(</span><span class="n">model</span><span class="o">=</span><span class="s">"gpt-3.5-turbo"</span><span class="p">,</span> <span class="n">temperature</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span>
<span class="n">agent</span> <span class="o">=</span> <span class="n">create_openai_functions_agent</span><span class="p">(</span><span class="n">llm</span><span class="p">,</span> <span class="n">tools</span><span class="p">,</span> <span class="n">prompt</span><span class="p">)</span>
<span class="n">agent_executor</span> <span class="o">=</span> <span class="n">AgentExecutor</span><span class="p">(</span><span class="n">agent</span><span class="o">=</span><span class="n">agent</span><span class="p">,</span> <span class="n">tools</span><span class="o">=</span><span class="n">tools</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>


<span class="c1"># 4. App definition
</span><span class="n">app</span> <span class="o">=</span> <span class="n">FastAPI</span><span class="p">(</span>
  <span class="n">title</span><span class="o">=</span><span class="s">"LangChain Server"</span><span class="p">,</span>
  <span class="n">version</span><span class="o">=</span><span class="s">"1.0"</span><span class="p">,</span>
  <span class="n">description</span><span class="o">=</span><span class="s">"A simple API server using LangChain's Runnable interfaces"</span><span class="p">,</span>
<span class="p">)</span>

<span class="c1"># 5. Adding chain route
</span>
<span class="c1"># We need to add these input/output schemas because the current AgentExecutor
# is lacking in schemas.
</span>
<span class="k">class</span> <span class="nc">Input</span><span class="p">(</span><span class="n">BaseModel</span><span class="p">):</span>
    <span class="nb">input</span><span class="p">:</span> <span class="nb">str</span>
    <span class="n">chat_history</span><span class="p">:</span> <span class="n">List</span><span class="p">[</span><span class="n">BaseMessage</span><span class="p">]</span> <span class="o">=</span> <span class="n">Field</span><span class="p">(</span>
        <span class="p">...,</span>
        <span class="n">extra</span><span class="o">=</span><span class="p">{</span><span class="s">"widget"</span><span class="p">:</span> <span class="p">{</span><span class="s">"type"</span><span class="p">:</span> <span class="s">"chat"</span><span class="p">,</span> <span class="s">"input"</span><span class="p">:</span> <span class="s">"location"</span><span class="p">}},</span>
    <span class="p">)</span>


<span class="k">class</span> <span class="nc">Output</span><span class="p">(</span><span class="n">BaseModel</span><span class="p">):</span>
    <span class="n">output</span><span class="p">:</span> <span class="nb">str</span>

<span class="n">add_routes</span><span class="p">(</span>
    <span class="n">app</span><span class="p">,</span>
    <span class="n">agent_executor</span><span class="p">.</span><span class="n">with_types</span><span class="p">(</span><span class="n">input_type</span><span class="o">=</span><span class="n">Input</span><span class="p">,</span> <span class="n">output_type</span><span class="o">=</span><span class="n">Output</span><span class="p">),</span>
    <span class="n">path</span><span class="o">=</span><span class="s">"/agent"</span><span class="p">,</span>
<span class="p">)</span>

<span class="k">if</span> <span class="n">__name__</span> <span class="o">==</span> <span class="s">"__main__"</span><span class="p">:</span>
    <span class="kn">import</span> <span class="nn">uvicorn</span>

    <span class="n">uvicorn</span><span class="p">.</span><span class="n">run</span><span class="p">(</span><span class="n">app</span><span class="p">,</span> <span class="n">host</span><span class="o">=</span><span class="s">"localhost"</span><span class="p">,</span> <span class="n">port</span><span class="o">=</span><span class="mi">8000</span><span class="p">)</span>
</code></pre></div></div>

<p>到此为止！如果我们执行此文件：</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>python serve.py
</code></pre></div></div>

<h3 id="playground">Playground</h3>

<p>每个LangServe服务都配有一个用于配置和调用应用程序的简单内置UI，具有流式输出和查看中间步骤的功能。
前往 http://localhost:8000/agent/playground/ 尝试一下！传入与之前相同的问题 - “how can langsmith help with testing?” - 它应该会像以前一样回答。</p>

<h3 id="客户端">客户端</h3>

<p>现在让我们为与服务进行程序化交互设置一个客户端。我们可以使用 <a href="/docs/langserve#client">langserve.RemoteRunnable</a> 轻松实现这一点。
使用这个，我们可以与提供的链交互，就像它在客户端运行一样。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langserve</span> <span class="kn">import</span> <span class="n">RemoteRunnable</span>

<span class="n">remote_chain</span> <span class="o">=</span> <span class="n">RemoteRunnable</span><span class="p">(</span><span class="s">"http://localhost:8000/agent/"</span><span class="p">)</span>
<span class="n">remote_chain</span><span class="p">.</span><span class="n">invoke</span><span class="p">({</span><span class="s">"input"</span><span class="p">:</span> <span class="s">"how can langsmith help with testing?"</span><span class="p">})</span>
</code></pre></div></div>

<h2 id="下一步">下一步</h2>

<p>我们已经涉及了如何使用LangChain构建应用程序，如何使用LangSmith对其进行跟踪，以及如何使用LangServe提供服务。
在这三个方面都有很多功能超出了我们在这里可以涵盖的范围。
为了继续您的旅程，我们建议您按照以下顺序阅读：</p>

<ul>
  <li>
    <p>所有这些功能都由 LangChain 表达语言 (LCEL) 支持 - 这是一种将这些组件链接在一起的方法。查看该文档以更好地了解如何创建自定义链。</p>
  </li>
  <li>
    <p>模型IO 包含有关提示、LLM和输出解析器的更多详细信息。</p>
  </li>
  <li>
    <p>检索 包含有关与检索相关的一切的更多详细信息</p>
  </li>
  <li>
    <p>代理 包含与代理相关的一切的详细信息
探索常见的 端到端用例 和 模板应用程序</p>
  </li>
  <li>
    <p>了解有关使用 LangServe 提供您的应用程序的更多信息</p>
  </li>
</ul>]]></content><author><name></name></author><category term="langchain" /><category term="ai" /><category term="python" /><category term="llm" /><summary type="html"><![CDATA[使用 LangChain 构建 LangChain 使构建连接外部数据源和计算到LLMs的应用程序变得更加容易。在这个快速入门中，我们将演示几种不同的方式。我们将从一个简单的LLM链开始，它仅仅依赖于提示模板中的信息来作出响应。接下来，我们将构建一个检索链，它从一个独立的数据库中获取数据并将其传递到提示模板中。然后，我们将添加聊天记录，以创建一个对话检索链。这允许您以聊天的方式与LLM进行交互，以便它记住以前的问题。最后，我们将构建一个代理，它利用LLM来确定是否需要获取数据来回答问题。我们将以高层次的方式介绍这些内容，但这些都涉及许多细节！我们将链接到相关的文档。 LLM链 API使用 在这个入门指南中，我们将提供两个选项：使用阿里云模型（通过API可用的流行模型）或使用本地开源模型。 pip install langchain 访问API需要一个API密钥，您可以通过创建帐户并获取。一旦我们有了密钥，我们将希望将其设置为环境变量，通过运行以下命令： export DASHSCOPE_API_KEY = "..." 或在python中使用os模块导入 import os os.environ["DASHSCOPE_API_KEY"] = "..." 然后我们可以初始化模型： from langchain.llms import Tongyi llm = Tongyi() 如果您不想设置环境变量，可以在初始化 LLM类时直接通过_api_key命名参数传递密钥： from langchain_ import Chat llm = Chat(DASHSCOPE_API_KEY="...") 本地使用 Ollama 允许您在本地运行开源的大型语言模型，比如 Llama 2。 首先，请按照这些说明设置和运行本地的Ollama实例： 下载 通过 ollama pull llama2 获取模型 然后，确保Ollama服务器正在运行。之后，您可以执行以下操作： from langchain_community.llms import Ollama llm = Ollama(model="llama2") 调用模型 一旦您安装并初始化了所选LLM，我们可以尝试使用它！让我们问它LangSmith是什么 - 这是训练数据中没有的东西，所以它不应该有一个很好的回答。 llm.invoke("how can langsmith help with testing?") 模板调用 我们还可以使用提示模板来引导它的响应。提示模板用于将原始用户输入转换为更好的LLM输入。 from langchain_core.prompts import ChatPromptTemplate prompt = ChatPromptTemplate.from_messages([ ("system", "You are world class technical documentation writer."), ("user", "{input}") ]) 现在我们可以将这些组合成一个简单的LLM链： chain = prompt | llm 我们现在可以调用它并问相同的问题。它仍然不会知道答案，但它应该以更适当的语气回应技术写作者！ chain.invoke({"input": "how can langsmith help with testing?"}) ChatModel的输出（因此，此链的输出）是一条消息。然而，使用字符串处理通常更方便。让我们添加一个简单的输出解析器，将聊天消息转换为字符串。 from langchain_core.output_parsers import StrOutputParser output_parser = StrOutputParser() 现在我们可以将其添加到之前的链中： chain = prompt | llm | output_parser 我们现在可以调用它并问相同的问题。答案现在将是一个字符串（而不是ChatMessage）。 chain.invoke({"input": "how can langsmith help with testing?"}) 检索链 为了正确回答原始问题（“langsmith如何帮助测试？”），我们需要向LLM提供额外的上下文。我们可以通过检索来实现这一点。当您有太多数据无法直接传递给LLM时，检索就变得很有用。您可以使用检索器仅获取最相关的片段并将其传递进去。 在此过程中，我们将从一个检索器中查找相关文档，然后将这些文档传递到提示中。检索器可以由任何东西支持 - SQL表、互联网等 - 但在这个示例中，我们将填充一个向量存储并将其用作检索器。 首先，我们需要加载要索引的数据。为此，我们将使用WebBaseLoader。这需要安装BeautifulSoup： pip install beautifulsoup4 之后，我们可以导入并使用WebBaseLoader。 from langchain_community.document_loaders import WebBaseLoader loader = WebBaseLoader("https://docs.smith.langchain.com/overview") docs = loader.load() 接下来，我们需要将其索引到一个向量存储中。这需要一些组件，即嵌入模型和向量存储。 对于嵌入模型，我们再次提供了通过或通过本地模型访问的示例。 确保已安装 langchain 包并设置了适当的环境变量（这与LLM所需的相同）。 from langchain import Embeddings embeddings = Embeddings() 确保Ollama正在运行（与LLM一样设置）。 from langchain_community.embeddings import OllamaEmbeddings embeddings = OllamaEmbeddings() 现在，我们可以使用这个嵌入模型将文档加载到向量存储中。为了简单起见，我们将使用一个简单的本地向量存储FAISS。 首先，我们需要安装该存储所需的软件包： pip install faiss-cpu 然后我们可以构建我们的索引： from langchain_community.vectorstores import FAISS from langchain.text_splitter import RecursiveCharacterTextSplitter text_splitter = RecursiveCharacterTextSplitter() documents = text_splitter.split_documents(docs) vector = FAISS.from_documents(documents, embeddings) 现在我们已经在向量存储中索引了这些数据，我们将创建一个检索链。此链将获取传入的问题，查找相关文档，然后将这些文档连同原始问题一起传递到LLM中，并要求其回答原始问题。 首先，让我们设置一个链，该链接受一个问题和检索到的文档，并生成一个答案。 from langchain.chains.combine_documents import create_stuff_documents_chain prompt = ChatPromptTemplate.from_template("""Answer the following question based only on the provided context: &lt;context&gt; {context} &lt;/context&gt; Question: {input}""") document_chain = create_stuff_documents_chain(llm, prompt) 如果我们愿意，我们可以自己运行它，直接传递文档： from langchain_core.documents import Document document_chain.invoke({ "input": "how can langsmith help with testing?", "context": [Document(page_content="langsmith can let you visualize test results")] }) 但是，我们希望文档首先来自我们刚刚设置的检索器。这样，对于给定的问题，我们可以使用检索器动态选择最相关的文档并传递进去。 from langchain.chains import create_retrieval_chain retriever = vector.as_retriever() retrieval_chain = create_retrieval_chain(retriever, document_chain) 我们现在可以调用此链。这返回一个字典 - LLM的响应在answer键中。 response = retrieval_chain.invoke({"input": "how can langsmith help with testing?"}) print(response["answer"]) # LangSmith offers several features that can help with testing:... 这个答案应该更准确！ 对话检索链 到目前为止，我们创建的链只能回答单个问题。人们正在构建的LLM应用程序的主要类型之一是聊天机器人。那么，我们如何将这个链变成一个可以回答后续问题的链呢？ 我们仍然可以使用create_retrieval_chain函数，但我们需要更改两件事： 检索方法现在不仅仅应该在最近的输入上工作，而是应该考虑整个历史记录。 最终的LLM链同样应该考虑整个历史记录 更新检索 为了更新检索，我们将创建一个新的链。这个链将接收最新的输入（input）和对话历史（chat_history），并使用LLM生成一个搜索查询。 from langchain.chains import create_history_aware_retriever from langchain_core.prompts import MessagesPlaceholder # 首先，我们需要一个我们可以传递到LLM以生成此搜索查询的提示 prompt = ChatPromptTemplate.from_messages([ MessagesPlaceholder(variable_name="chat_history"), ("user", "{input}"), ("user", "Given the above conversation, generate a search query to look up in order to get information relevant to the conversation") ]) retriever_chain = create_history_aware_retriever(llm, retriever, prompt) 我们可以通过传递一个用户正在提出后续问题的实例来测试这一点。 from langchain_core.messages import HumanMessage, AIMessage chat_history = [HumanMessage(content="Can LangSmith help test my LLM applications?"), AIMessage(content="Yes!")] retriever_chain.invoke({ "chat_history": chat_history, "input": "Tell me how" }) 你应该看到这返回了关于在LangSmith中测试的文档。这是因为LLM生成了一个新的查询，将聊天历史与后续问题结合起来。 现在我们有了这个新的检索器，我们可以创建一个新的链，以在考虑到这些检索到的文档的情况下继续对话。 prompt = ChatPromptTemplate.from_messages([ ("system", "基于以下上下文回答用户的问题：\n\n{context}"), MessagesPlaceholder(variable_name="chat_history"), ("user", "{input}"), ]) document_chain = create_stuff_documents_chain(llm, prompt) retrieval_chain = create_retrieval_chain(retriever_chain, document_chain) 现在我们可以进行端到端的测试： chat_history = [HumanMessage(content="Can LangSmith help test my LLM applications?"), AIMessage(content="Yes!")] retrieval_chain.invoke({ "chat_history": chat_history, "input": "Tell me how" }) 我们可以看到这给出了一个连贯的答案 - 我们成功地将我们的检索链转化为一个聊天机器人！ 代理 到目前为止，我们已经创建了链的示例 - 在这里，每个步骤都是预先知道的。 我们将创建的最后一件事是一个代理 - 在这里，LLM决定采取什么步骤。 注意：对于这个示例，我们将仅展示如何使用OpenAI模型创建代理，因为本地模型目前还不够可靠。 构建代理时的第一件事是决定它应该访问什么工具。 在这个例子中，我们将给代理访问两个工具的权限： 我们刚刚创建的检索器。这将使它轻松回答关于LangSmith的问题。 一个搜索工具。这将使它轻松回答需要最新信息的问题。 首先，让我们设置一个用于我们刚刚创建的检索器的工具： from langchain.tools.retriever import create_retriever_tool retriever_tool = create_retriever_tool( retriever, "langsmith_search", "搜索有关LangSmith的信息。有关LangSmith的任何问题，您必须使用此工具！", ) 现在，我们可以创建一个要使用的工具列表： tools = [retriever_tool, search] 现在我们有了工具，可以创建一个代理来使用它们。我们将快速浏览一下这个过程 首先安装langchain hub pip install langchainhub 现在我们可以使用它来获取预定义的提示 from langchain_openai import ChatOpenAI from langchain import hub from langchain.agents import create_openai_functions_agent from langchain.agents import AgentExecutor # 获取要使用的提示 - 您可以修改这个！ prompt = hub.pull("hwchase17/openai-functions-agent") llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0) agent = create_openai_functions_agent(llm, tools, prompt) agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) 现在我们可以调用代理并查看它的响应！我们可以问它关于LangSmith的问题： agent_executor.invoke({"input": "how can langsmith help with testing?"}) 我们可以问它关于天气的问题： agent_executor.invoke({"input": "what is the weather in SF?"}) 我们可以与它进行对话： chat_history = [HumanMessage(content="Can LangSmith help test my LLM applications?"), AIMessage(content="Yes!")] agent_executor.invoke({ "chat_history": chat_history, "input": "Tell me how" }) 使用LangServe提供服务 现在我们已经构建了一个应用程序，需要将其提供服务。这就是LangServe的用武之地。 LangServe帮助开发人员将LangChain链部署为REST API。您不需要使用LangServe来使用LangChain，但在本指南中，我们将展示如何使用LangServe部署您的应用程序。 虽然本指南的第一部分是在Jupyter Notebook中运行的，但现在我们将离开那里。我们将创建一个Python文件，然后从命令行与其进行交互。 使用以下命令安装： pip install "langserve[all]" 服务器 为了为我们的应用程序创建一个服务器，我们将制作一个serve.py文件。这将包含我们为提供应用程序而构建的逻辑。它包括三个部分： 我们刚刚构建的链的定义 我们的FastAPI应用程序 用于提供链的路由的定义，使用 langserve.add_routes 完成 #!/usr/bin/env python from typing import List from fastapi import FastAPI from langchain_core.prompts import ChatPromptTemplate from langchain_openai import ChatOpenAI from langchain_community.document_loaders import WebBaseLoader from langchain_openai import OpenAIEmbeddings from langchain_community.vectorstores import FAISS from langchain.text_splitter import RecursiveCharacterTextSplitter from langchain.tools.retriever import create_retriever_tool from langchain_community.tools.tavily_search import TavilySearchResults from langchain_openai import ChatOpenAI from langchain import hub from langchain.agents import create_openai_functions_agent from langchain.agents import AgentExecutor from langchain.pydantic_v1 import BaseModel, Field from langchain_core.messages import BaseMessage from langserve import add_routes # 1. Load Retriever loader = WebBaseLoader("https://docs.smith.langchain.com/overview") docs = loader.load() text_splitter = RecursiveCharacterTextSplitter() documents = text_splitter.split_documents(docs) embeddings = OpenAIEmbeddings() vector = FAISS.from_documents(documents, embeddings) retriever = vector.as_retriever() # 2. Create Tools retriever_tool = create_retriever_tool( retriever, "langsmith_search", "搜索有关LangSmith的信息。有关LangSmith的任何问题，您必须使用此工具！", ) search = TavilySearchResults() tools = [retriever_tool, search] # 3. Create Agent prompt = hub.pull("hwchase17/openai-functions-agent") llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0) agent = create_openai_functions_agent(llm, tools, prompt) agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) # 4. App definition app = FastAPI( title="LangChain Server", version="1.0", description="A simple API server using LangChain's Runnable interfaces", ) # 5. Adding chain route # We need to add these input/output schemas because the current AgentExecutor # is lacking in schemas. class Input(BaseModel): input: str chat_history: List[BaseMessage] = Field( ..., extra={"widget": {"type": "chat", "input": "location"}}, ) class Output(BaseModel): output: str add_routes( app, agent_executor.with_types(input_type=Input, output_type=Output), path="/agent", ) if __name__ == "__main__": import uvicorn uvicorn.run(app, host="localhost", port=8000) 到此为止！如果我们执行此文件： python serve.py Playground 每个LangServe服务都配有一个用于配置和调用应用程序的简单内置UI，具有流式输出和查看中间步骤的功能。 前往 http://localhost:8000/agent/playground/ 尝试一下！传入与之前相同的问题 - “how can langsmith help with testing?” - 它应该会像以前一样回答。 客户端 现在让我们为与服务进行程序化交互设置一个客户端。我们可以使用 langserve.RemoteRunnable 轻松实现这一点。 使用这个，我们可以与提供的链交互，就像它在客户端运行一样。 from langserve import RemoteRunnable remote_chain = RemoteRunnable("http://localhost:8000/agent/") remote_chain.invoke({"input": "how can langsmith help with testing?"}) 下一步 我们已经涉及了如何使用LangChain构建应用程序，如何使用LangSmith对其进行跟踪，以及如何使用LangServe提供服务。 在这三个方面都有很多功能超出了我们在这里可以涵盖的范围。 为了继续您的旅程，我们建议您按照以下顺序阅读： 所有这些功能都由 LangChain 表达语言 (LCEL) 支持 - 这是一种将这些组件链接在一起的方法。查看该文档以更好地了解如何创建自定义链。 模型IO 包含有关提示、LLM和输出解析器的更多详细信息。 检索 包含有关与检索相关的一切的更多详细信息 代理 包含与代理相关的一切的详细信息 探索常见的 端到端用例 和 模板应用程序 了解有关使用 LangServe 提供您的应用程序的更多信息]]></summary></entry><entry><title type="html">Langchain-LCEL-start</title><link href="nullskymc.cloud/LCEL1/" rel="alternate" type="text/html" title="Langchain-LCEL-start" /><published>2023-09-19T00:00:00+00:00</published><updated>2023-09-19T00:00:00+00:00</updated><id>nullskymc.cloud/LCEL1</id><content type="html" xml:base="nullskymc.cloud/LCEL1/"><![CDATA[<p>LCEL使得从基本组件构建复杂链变得容易，并且支持诸如流处理、并行处理和日志记录等开箱即用的功能。</p>

<h2 id="基本示例提示--模型--输出解析器">基本示例：提示 + 模型 + 输出解析器</h2>

<p>最基本和常见的用例是将提示模板和模型链接在一起。为了看到这是如何工作的，让我们创建一个链，它接受一个主题并生成一个笑话：</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>%pip <span class="nb">install</span> –upgrade –quiet langchain-core langchain-community langchain-openai
</code></pre></div></div>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain_core.output_parsers</span> <span class="kn">import</span> <span class="n">StrOutputParser</span>
<span class="kn">from</span> <span class="nn">langchain_core.prompts</span> <span class="kn">import</span> <span class="n">ChatPromptTemplate</span>
<span class="kn">from</span> <span class="nn">langchain_openai</span> <span class="kn">import</span> <span class="n">ChatOpenAI</span>

<span class="n">prompt</span> <span class="o">=</span> <span class="n">ChatPromptTemplate</span><span class="p">.</span><span class="n">from_template</span><span class="p">(</span><span class="s">"tell me a short joke about {topic}"</span><span class="p">)</span>
<span class="n">model</span> <span class="o">=</span> <span class="n">ChatOpenAI</span><span class="p">(</span><span class="n">model</span><span class="o">=</span><span class="s">"gpt-4"</span><span class="p">)</span>
<span class="n">output_parser</span> <span class="o">=</span> <span class="n">StrOutputParser</span><span class="p">()</span>

<span class="n">chain</span> <span class="o">=</span> <span class="n">prompt</span> <span class="o">|</span> <span class="n">model</span> <span class="o">|</span> <span class="n">output_parser</span>

<span class="n">chain</span><span class="p">.</span><span class="n">invoke</span><span class="p">({</span><span class="s">"topic"</span><span class="p">:</span> <span class="s">"ice cream"</span><span class="p">})</span>
</code></pre></div></div>

<blockquote>
  <p>“Why don’t ice creams ever get invited to parties?\n\nBecause they always drip when things heat up!”</p>
</blockquote>

<p>注意这行代码，我们将不同的组件拼接成一个单一的链使用 LCEL：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">chain</span> <span class="o">=</span> <span class="n">prompt</span> <span class="o">|</span> <span class="n">model</span> <span class="o">|</span> <span class="n">output_parser</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">|</code> 符号类似于<a href="https://en.wikipedia.org/wiki/Pipeline_(Unix)">unix 管道操作符</a>, 它将不同的组件链接在一起，将一个组件的输出作为下一个组件的输入。</p>

<p>在这个链中，用户输入被传递给提示模板，然后提示模板的输出被传递给模型，然后模型的输出被传递给输出解析器。让我们分别看一下每个组件，以真正理解发生了什么。</p>

<h3 id="1-prompt">1. Prompt</h3>

<p><code class="language-plaintext highlighter-rouge">prompt</code> 是一个 <code class="language-plaintext highlighter-rouge">BasePromptTemplate</code> ，这意味着它接收一个模板变量的字典并产生一个 <code class="language-plaintext highlighter-rouge">PromptValue</code>。<code class="language-plaintext highlighter-rouge">PromptValue</code> 是一个完成提示的包装器，可以传递给 <code class="language-plaintext highlighter-rouge">LLM</code>（接受字符串作为输入）或 <code class="language-plaintext highlighter-rouge">ChatModel</code>（接受一系列消息作为输入）。它可以与任何语言模型类型一起工作，因为它定义了生成 <code class="language-plaintext highlighter-rouge">BaseMessage</code> 和生成字符串的逻辑。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">prompt_value</span> <span class="o">=</span> <span class="n">prompt</span><span class="p">.</span><span class="n">invoke</span><span class="p">({</span><span class="s">"topic"</span><span class="p">:</span> <span class="s">"ice cream"</span><span class="p">})</span>
<span class="n">prompt_value</span>
</code></pre></div></div>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">#output
</span><span class="n">ChatPromptValue</span><span class="p">(</span><span class="n">messages</span><span class="o">=</span><span class="p">[</span><span class="n">HumanMessage</span><span class="p">(</span><span class="n">content</span><span class="o">=</span><span class="s">'tell me a short joke about ice cream'</span><span class="p">)])</span>
</code></pre></div></div>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">prompt_value</span><span class="p">.</span><span class="n">to_messages</span><span class="p">()</span>
</code></pre></div></div>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">#output
</span><span class="p">[</span><span class="n">HumanMessage</span><span class="p">(</span><span class="n">content</span><span class="o">=</span><span class="s">'tell me a short joke about ice cream'</span><span class="p">)]</span> 
</code></pre></div></div>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="s">'Human: tell me a short joke about ice cream'</span>
</code></pre></div></div>

<h3 id="2-model">2. Model</h3>

<p><code class="language-plaintext highlighter-rouge">PromptValue</code> 然后传递给 <code class="language-plaintext highlighter-rouge">model</code>。在这种情况下，我们的 <code class="language-plaintext highlighter-rouge">model</code> 是一个 <code class="language-plaintext highlighter-rouge">ChatModel</code>，这意味着它将输出一个 <code class="language-plaintext highlighter-rouge">BaseMessage</code>。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">message</span> <span class="o">=</span> <span class="n">model</span><span class="p">.</span><span class="n">invoke</span><span class="p">(</span><span class="n">prompt_value</span><span class="p">)</span>
<span class="n">message</span>
</code></pre></div></div>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">AIMessage</span><span class="p">(</span><span class="n">content</span><span class="o">=</span><span class="s">"Why don't ice creams ever get invited to parties?</span><span class="se">\n\n</span><span class="s">Because they always bring a melt down!"</span><span class="p">)</span>
</code></pre></div></div>

<p>如果我们的 <code class="language-plaintext highlighter-rouge">model</code> 是一个 <code class="language-plaintext highlighter-rouge">LLM</code>，它将输出一个字符串。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">langchain_openai.llms</span> <span class="kn">import</span> <span class="n">OpenAIllm</span> <span class="o">=</span> <span class="n">OpenAI</span><span class="p">(</span><span class="n">model</span><span class="o">=</span><span class="s">"gpt-3.5-turbo-instruct"</span><span class="p">)</span><span class="n">llm</span><span class="p">.</span><span class="n">invoke</span><span class="p">(</span><span class="n">prompt_value</span><span class="p">)</span>
</code></pre></div></div>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="s">'</span><span class="se">\n\n</span><span class="s">Robot: Why did the ice cream truck break down? Because it had a meltdown!'</span>
</code></pre></div></div>

<h3 id="3-output-parser">3. Output parser</h3>

<p>最后，我们将 <code class="language-plaintext highlighter-rouge">model</code> 输出传递给 <code class="language-plaintext highlighter-rouge">output_parser</code>，它是一个 <code class="language-plaintext highlighter-rouge">BaseOutputParser</code>，这意味着它接受字符串或 <code class="language-plaintext highlighter-rouge">BaseMessage</code> 作为输入。<code class="language-plaintext highlighter-rouge">StrOutputParser</code> 将任何输入简单地转换为字符串。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">output_parser</span><span class="p">.</span><span class="n">invoke</span><span class="p">(</span><span class="n">message</span><span class="p">)</span>
</code></pre></div></div>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="s">"Why did the ice cream go to therapy? </span><span class="se">\n\n</span><span class="s">Because it had too many toppings and couldn't find its cone-fidence!"</span>
</code></pre></div></div>

<h3 id="4-entire-pipeline">4. Entire Pipeline</h3>

<p>为了跟随这些步骤：</p>

<ol>
  <li>我们将用户输入作为 <code class="language-plaintext highlighter-rouge">{"topic": "ice cream"}</code> 传入。</li>
  <li><code class="language-plaintext highlighter-rouge">prompt</code> 组件接受用户输入，然后使用 <code class="language-plaintext highlighter-rouge">topic</code> 构造提示后，用它来构造 <code class="language-plaintext highlighter-rouge">PromptValue</code>。</li>
  <li><code class="language-plaintext highlighter-rouge">model</code> 组件接受生成的提示，并将其传递给 OpenAI LLM 模型进行评估。模型生成的输出是一个 <code class="language-plaintext highlighter-rouge">ChatMessage</code> 对象。</li>
  <li>最后，<code class="language-plaintext highlighter-rouge">output_parser</code> 组件接受 <code class="language-plaintext highlighter-rouge">ChatMessage</code>，并将其转换为 Python 字符串，该字符串从 invoke 方法返回。</li>
</ol>

<p>请注意，如果您对任何组件的输出感到好奇，您可以始终测试链的较小版本，例如 <code class="language-plaintext highlighter-rouge">prompt</code> 或 <code class="language-plaintext highlighter-rouge">prompt | model</code>，以查看中间结果：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">input</span> <span class="o">=</span> <span class="p">{</span><span class="s">"topic"</span><span class="p">:</span> <span class="s">"ice cream"</span><span class="p">}</span>

<span class="n">prompt</span><span class="p">.</span><span class="n">invoke</span><span class="p">(</span><span class="nb">input</span><span class="p">)</span>
<span class="c1"># &gt; ChatPromptValue(messages=[HumanMessage(content='tell me a short joke about ice cream')])
</span><span class="p">(</span><span class="n">prompt</span> <span class="o">|</span> <span class="n">model</span><span class="p">).</span><span class="n">invoke</span><span class="p">(</span><span class="nb">input</span><span class="p">)</span>
<span class="c1"># &gt; AIMessage(content="Why did the ice cream go to therapy?\nBecause it had too many toppings and couldn't cone-trol itself!")
</span></code></pre></div></div>

<h2 id="rag-搜索示例">RAG 搜索示例</h2>

<p>对于下一个示例，我们想要运行一个检索增强生成链，以在回答问题时添加一些上下文。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># Requires:# pip install langchain docarray tiktoken
</span><span class="kn">from</span> <span class="nn">langchain_community.vectorstores</span> <span class="kn">import</span> <span class="n">DocArrayInMemorySearch</span>
<span class="kn">from</span> <span class="nn">langchain_core.output_parsers</span> <span class="kn">import</span> <span class="n">StrOutputParser</span>
<span class="kn">from</span> <span class="nn">langchain_core.prompts</span> <span class="kn">import</span> <span class="n">ChatPromptTemplate</span>
<span class="kn">from</span> <span class="nn">langchain_core.runnables</span> <span class="kn">import</span> <span class="n">RunnableParallel</span><span class="p">,</span> <span class="n">RunnablePassthrough</span>
<span class="kn">from</span> <span class="nn">langchain_openai.chat_models</span> <span class="kn">import</span> <span class="n">ChatOpenAI</span>
<span class="kn">from</span> <span class="nn">langchain_openai.embeddings</span> <span class="kn">import</span> <span class="n">OpenAIEmbeddings</span>

<span class="n">vectorstore</span> <span class="o">=</span> <span class="n">DocArrayInMemorySearch</span><span class="p">.</span><span class="n">from_texts</span><span class="p">(</span>    
    <span class="p">[</span><span class="s">"harrison worked at kensho"</span><span class="p">,</span> <span class="s">"bears like to eat honey"</span><span class="p">],</span>    <span class="n">embedding</span><span class="o">=</span><span class="n">OpenAIEmbeddings</span><span class="p">(),</span>
    <span class="p">)</span>
<span class="n">retriever</span> <span class="o">=</span> <span class="n">vectorstore</span><span class="p">.</span><span class="n">as_retriever</span><span class="p">()</span>

<span class="n">template</span> <span class="o">=</span> <span class="s">"""Answer the question based only on the following context:{context}

Question: {question}
"""</span>

<span class="n">prompt</span> <span class="o">=</span> <span class="n">ChatPromptTemplate</span><span class="p">.</span><span class="n">from_template</span><span class="p">(</span><span class="n">template</span><span class="p">)</span>
<span class="n">model</span> <span class="o">=</span> <span class="n">ChatOpenAI</span><span class="p">()</span>
<span class="n">output_parser</span> <span class="o">=</span> <span class="n">StrOutputParser</span><span class="p">()</span>

<span class="n">setup_and_retrieval</span> <span class="o">=</span> <span class="n">RunnableParallel</span><span class="p">(</span>    <span class="p">{</span><span class="s">"context"</span><span class="p">:</span> <span class="n">retriever</span><span class="p">,</span> <span class="s">"question"</span><span class="p">:</span> <span class="n">RunnablePassthrough</span><span class="p">()}</span>
<span class="p">)</span>
<span class="n">chain</span> <span class="o">=</span> <span class="n">setup_and_retrieval</span> <span class="o">|</span> <span class="n">prompt</span> <span class="o">|</span> <span class="n">model</span> <span class="o">|</span> <span class="n">output_parser</span>

<span class="n">chain</span><span class="p">.</span><span class="n">invoke</span><span class="p">(</span><span class="s">"where did harrison work?"</span><span class="p">)</span>
</code></pre></div></div>

<p>在这种情况下，组合链是：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">chain</span> <span class="o">=</span> <span class="n">setup_and_retrieval</span> <span class="o">|</span> <span class="n">prompt</span> <span class="o">|</span> <span class="n">model</span> <span class="o">|</span> <span class="n">output_parser</span>
</code></pre></div></div>

<p>为了解释这个，我们首先可以看到上面的提示模板接收 <code class="language-plaintext highlighter-rouge">context</code> 和 <code class="language-plaintext highlighter-rouge">question</code> 作为要在提示中替换的值。在构建提示模板之前，我们想要检索与搜索相关的文档，并将它们作为上下文的一部分。</p>

<p>作为初步步骤，我们已经使用内存存储设置了检索器，它可以基于查询检索文档。这也是一个可运行的组件，可以与其他组件链在一起，但你也可以尝试单独运行它：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">retriever</span><span class="p">.</span><span class="n">invoke</span><span class="p">(</span><span class="s">"where did harrison work?"</span><span class="p">)</span>
</code></pre></div></div>

<p>然后我们使用 <code class="language-plaintext highlighter-rouge">RunnableParallel</code> 来准备进入提示的预期输入，使用检索到的文档的条目以及原始用户问题，使用检索器进行文档搜索，和 <code class="language-plaintext highlighter-rouge">RunnablePassthrough</code> 来传递用户的问题：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">setup_and_retrieval</span> <span class="o">=</span> <span class="n">RunnableParallel</span><span class="p">(</span>    <span class="p">{</span><span class="s">"context"</span><span class="p">:</span> <span class="n">retriever</span><span class="p">,</span> <span class="s">"question"</span><span class="p">:</span> <span class="n">RunnablePassthrough</span><span class="p">()})</span>
</code></pre></div></div>

<p>回顾一下，完整的链是：</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">setup_and_retrieval</span> <span class="o">=</span> <span class="n">RunnableParallel</span><span class="p">(</span>    <span class="p">{</span><span class="s">"context"</span><span class="p">:</span> <span class="n">retriever</span><span class="p">,</span> <span class="s">"question"</span><span class="p">:</span> <span class="n">RunnablePassthrough</span><span class="p">()})</span><span class="n">chain</span> <span class="o">=</span> <span class="n">setup_and_retrieval</span> <span class="o">|</span> <span class="n">prompt</span> <span class="o">|</span> <span class="n">model</span> <span class="o">|</span> <span class="n">output_parser</span>
</code></pre></div></div>

<p>流程如下：</p>

<ol>
  <li>
    <p>第一步创建一个带有两个条目的 <code class="language-plaintext highlighter-rouge">RunnableParallel</code> 对象。第一个条目，<code class="language-plaintext highlighter-rouge">context</code> 将包含检索器获取的文档结果。第二个条目，<code class="language-plaintext highlighter-rouge">question</code> 将包含用户的原始问题。为了传递问题，我们使用 <code class="language-plaintext highlighter-rouge">RunnablePassthrough</code> 来复制这个条目。</p>
  </li>
  <li>
    <p>将上一步的字典输入到 <code class="language-plaintext highlighter-rouge">prompt</code> 组件。然后它接收用户输入，即 <code class="language-plaintext highlighter-rouge">question</code> ，以及检索到的文档，即 <code class="language-plaintext highlighter-rouge">context</code> ，来构造一个提示并输出一个 <code class="language-plaintext highlighter-rouge">PromptValue</code> 。</p>
  </li>
  <li>
    <p><code class="language-plaintext highlighter-rouge">model</code> 组件接收生成的提示，并将其传入 OpenAI LLM 模型进行评估。模型生成的输出是一个 <code class="language-plaintext highlighter-rouge">ChatMessage</code> 对象。
最后，<code class="language-plaintext highlighter-rouge">output_parser</code> 组件接收一个 <code class="language-plaintext highlighter-rouge">ChatMessage</code>，并将其转换为 Python 字符串，该字符串从 invoke 方法返回。</p>
  </li>
</ol>]]></content><author><name></name></author><category term="langchain" /><category term="ai" /><category term="python" /><category term="llm" /><summary type="html"><![CDATA[LCEL使得从基本组件构建复杂链变得容易，并且支持诸如流处理、并行处理和日志记录等开箱即用的功能。 基本示例：提示 + 模型 + 输出解析器 最基本和常见的用例是将提示模板和模型链接在一起。为了看到这是如何工作的，让我们创建一个链，它接受一个主题并生成一个笑话： %pip install –upgrade –quiet langchain-core langchain-community langchain-openai from langchain_core.output_parsers import StrOutputParser from langchain_core.prompts import ChatPromptTemplate from langchain_openai import ChatOpenAI prompt = ChatPromptTemplate.from_template("tell me a short joke about {topic}") model = ChatOpenAI(model="gpt-4") output_parser = StrOutputParser() chain = prompt | model | output_parser chain.invoke({"topic": "ice cream"}) “Why don’t ice creams ever get invited to parties?\n\nBecause they always drip when things heat up!” 注意这行代码，我们将不同的组件拼接成一个单一的链使用 LCEL： chain = prompt | model | output_parser | 符号类似于unix 管道操作符, 它将不同的组件链接在一起，将一个组件的输出作为下一个组件的输入。 在这个链中，用户输入被传递给提示模板，然后提示模板的输出被传递给模型，然后模型的输出被传递给输出解析器。让我们分别看一下每个组件，以真正理解发生了什么。 1. Prompt prompt 是一个 BasePromptTemplate ，这意味着它接收一个模板变量的字典并产生一个 PromptValue。PromptValue 是一个完成提示的包装器，可以传递给 LLM（接受字符串作为输入）或 ChatModel（接受一系列消息作为输入）。它可以与任何语言模型类型一起工作，因为它定义了生成 BaseMessage 和生成字符串的逻辑。 prompt_value = prompt.invoke({"topic": "ice cream"}) prompt_value #output ChatPromptValue(messages=[HumanMessage(content='tell me a short joke about ice cream')]) prompt_value.to_messages() #output [HumanMessage(content='tell me a short joke about ice cream')] 'Human: tell me a short joke about ice cream' 2. Model PromptValue 然后传递给 model。在这种情况下，我们的 model 是一个 ChatModel，这意味着它将输出一个 BaseMessage。 message = model.invoke(prompt_value) message AIMessage(content="Why don't ice creams ever get invited to parties?\n\nBecause they always bring a melt down!") 如果我们的 model 是一个 LLM，它将输出一个字符串。 from langchain_openai.llms import OpenAIllm = OpenAI(model="gpt-3.5-turbo-instruct")llm.invoke(prompt_value) '\n\nRobot: Why did the ice cream truck break down? Because it had a meltdown!' 3. Output parser 最后，我们将 model 输出传递给 output_parser，它是一个 BaseOutputParser，这意味着它接受字符串或 BaseMessage 作为输入。StrOutputParser 将任何输入简单地转换为字符串。 output_parser.invoke(message) "Why did the ice cream go to therapy? \n\nBecause it had too many toppings and couldn't find its cone-fidence!" 4. Entire Pipeline 为了跟随这些步骤： 我们将用户输入作为 {"topic": "ice cream"} 传入。 prompt 组件接受用户输入，然后使用 topic 构造提示后，用它来构造 PromptValue。 model 组件接受生成的提示，并将其传递给 OpenAI LLM 模型进行评估。模型生成的输出是一个 ChatMessage 对象。 最后，output_parser 组件接受 ChatMessage，并将其转换为 Python 字符串，该字符串从 invoke 方法返回。 请注意，如果您对任何组件的输出感到好奇，您可以始终测试链的较小版本，例如 prompt 或 prompt | model，以查看中间结果： input = {"topic": "ice cream"} prompt.invoke(input) # &gt; ChatPromptValue(messages=[HumanMessage(content='tell me a short joke about ice cream')]) (prompt | model).invoke(input) # &gt; AIMessage(content="Why did the ice cream go to therapy?\nBecause it had too many toppings and couldn't cone-trol itself!") RAG 搜索示例 对于下一个示例，我们想要运行一个检索增强生成链，以在回答问题时添加一些上下文。 # Requires:# pip install langchain docarray tiktoken from langchain_community.vectorstores import DocArrayInMemorySearch from langchain_core.output_parsers import StrOutputParser from langchain_core.prompts import ChatPromptTemplate from langchain_core.runnables import RunnableParallel, RunnablePassthrough from langchain_openai.chat_models import ChatOpenAI from langchain_openai.embeddings import OpenAIEmbeddings vectorstore = DocArrayInMemorySearch.from_texts( ["harrison worked at kensho", "bears like to eat honey"], embedding=OpenAIEmbeddings(), ) retriever = vectorstore.as_retriever() template = """Answer the question based only on the following context:{context} Question: {question} """ prompt = ChatPromptTemplate.from_template(template) model = ChatOpenAI() output_parser = StrOutputParser() setup_and_retrieval = RunnableParallel( {"context": retriever, "question": RunnablePassthrough()} ) chain = setup_and_retrieval | prompt | model | output_parser chain.invoke("where did harrison work?") 在这种情况下，组合链是： chain = setup_and_retrieval | prompt | model | output_parser 为了解释这个，我们首先可以看到上面的提示模板接收 context 和 question 作为要在提示中替换的值。在构建提示模板之前，我们想要检索与搜索相关的文档，并将它们作为上下文的一部分。 作为初步步骤，我们已经使用内存存储设置了检索器，它可以基于查询检索文档。这也是一个可运行的组件，可以与其他组件链在一起，但你也可以尝试单独运行它： retriever.invoke("where did harrison work?") 然后我们使用 RunnableParallel 来准备进入提示的预期输入，使用检索到的文档的条目以及原始用户问题，使用检索器进行文档搜索，和 RunnablePassthrough 来传递用户的问题： setup_and_retrieval = RunnableParallel( {"context": retriever, "question": RunnablePassthrough()}) 回顾一下，完整的链是： setup_and_retrieval = RunnableParallel( {"context": retriever, "question": RunnablePassthrough()})chain = setup_and_retrieval | prompt | model | output_parser 流程如下： 第一步创建一个带有两个条目的 RunnableParallel 对象。第一个条目，context 将包含检索器获取的文档结果。第二个条目，question 将包含用户的原始问题。为了传递问题，我们使用 RunnablePassthrough 来复制这个条目。 将上一步的字典输入到 prompt 组件。然后它接收用户输入，即 question ，以及检索到的文档，即 context ，来构造一个提示并输出一个 PromptValue 。 model 组件接收生成的提示，并将其传入 OpenAI LLM 模型进行评估。模型生成的输出是一个 ChatMessage 对象。 最后，output_parser 组件接收一个 ChatMessage，并将其转换为 Python 字符串，该字符串从 invoke 方法返回。]]></summary></entry><entry><title type="html">深度学习入门笔记：神经网络</title><link href="nullskymc.cloud/neural/" rel="alternate" type="text/html" title="深度学习入门笔记：神经网络" /><published>2023-09-12T00:00:00+00:00</published><updated>2023-09-12T00:00:00+00:00</updated><id>nullskymc.cloud/neural</id><content type="html" xml:base="nullskymc.cloud/neural/"><![CDATA[<h2 id="神经网络的实现">神经网络的实现</h2>
<p>如何实现一个神经网络</p>

<h3 id="神经网络的表示">神经网络的表示</h3>

<h4 id="单隐藏层神经网络">单隐藏层神经网络</h4>

<p><img src="/images/9-12/single-hidden-neural-network.png" alt="单隐藏层神经网络" /></p>

<h5 id="输入层">输入层</h5>

<p>输入层有三个输入单元，分别为$x_1,x_2,x_3$，输入层的输出为$a^{[0]}$，即$a^{[0]}=x$，其中$x$为输入向量，$x=\begin{bmatrix}x_1\\x_2\\x_3\end{bmatrix}$</p>

<h5 id="隐藏层">隐藏层</h5>

<p>隐藏层有四个隐藏单元，分别为
$a_1^{[1]},a_2^{[1]},a_3^{[1]},a_4^{[1]}$
，隐藏层的输出为$a^{[1]}$，即
$a^{[1]}=\begin{bmatrix}a_1^{[1]}\\a_2^{[1]}\\a_3^{[1]}\\a_4^{[1]}\end{bmatrix}$</p>

<h5 id="输出层">输出层</h5>

<p>输出层有两个输出单元，分别为 $a_1^{[2]},a_2^{[2]}$，输出层的输出为$a^{[2]}$，即
$a^{[2]}=\begin{bmatrix}a_1^{[2]}\\a_2^{[2]}\end{bmatrix}$</p>

<h3 id="计算神经网络输出">计算神经网络输出</h3>

<p>对于第一层神经网络，如果输入是一组x向量，我们就有<br />
$z^{[1]}=W^{[1]}x+b^{[1]}$<br />
$a^{[1]}=\sigma(z^{[1]})$<br />
$z^{[2]}=W^{[2]}a^{[1]}+b^{[2]}$<br />
$a^{[2]}=\sigma(z^{[2]})$</p>

<p>其中$W^{[1]}$是第一层的权重矩阵，$b^{[1]}$是第一层的偏置向量，$W^{[2]}$是第二层的权重矩阵，$b^{[2]}$是第二层的偏置向量，$\sigma$是激活函数，这里使用的是sigmoid函数，$z^{[1]}$是第一层的输入向量，$a^{[1]}$是第一层的输出向量，$z^{[2]}$是第二层的输入向量，$a^{[2]}$是第二层的输出向量</p>]]></content><author><name></name></author><category term="markdown" /><category term="Machine Learning" /><category term="Deep Learning" /><summary type="html"><![CDATA[神经网络的实现 如何实现一个神经网络 神经网络的表示 单隐藏层神经网络 输入层 输入层有三个输入单元，分别为$x_1,x_2,x_3$，输入层的输出为$a^{[0]}$，即$a^{[0]}=x$，其中$x$为输入向量，$x=\begin{bmatrix}x_1\\x_2\\x_3\end{bmatrix}$ 隐藏层 隐藏层有四个隐藏单元，分别为 $a_1^{[1]},a_2^{[1]},a_3^{[1]},a_4^{[1]}$ ，隐藏层的输出为$a^{[1]}$，即 $a^{[1]}=\begin{bmatrix}a_1^{[1]}\\a_2^{[1]}\\a_3^{[1]}\\a_4^{[1]}\end{bmatrix}$ 输出层 输出层有两个输出单元，分别为 $a_1^{[2]},a_2^{[2]}$，输出层的输出为$a^{[2]}$，即 $a^{[2]}=\begin{bmatrix}a_1^{[2]}\\a_2^{[2]}\end{bmatrix}$ 计算神经网络输出 对于第一层神经网络，如果输入是一组x向量，我们就有 $z^{[1]}=W^{[1]}x+b^{[1]}$ $a^{[1]}=\sigma(z^{[1]})$ $z^{[2]}=W^{[2]}a^{[1]}+b^{[2]}$ $a^{[2]}=\sigma(z^{[2]})$ 其中$W^{[1]}$是第一层的权重矩阵，$b^{[1]}$是第一层的偏置向量，$W^{[2]}$是第二层的权重矩阵，$b^{[2]}$是第二层的偏置向量，$\sigma$是激活函数，这里使用的是sigmoid函数，$z^{[1]}$是第一层的输入向量，$a^{[1]}$是第一层的输出向量，$z^{[2]}$是第二层的输入向量，$a^{[2]}$是第二层的输出向量]]></summary></entry><entry><title type="html">深度学习入门笔记：二元分类</title><link href="nullskymc.cloud/binary/" rel="alternate" type="text/html" title="深度学习入门笔记：二元分类" /><published>2023-09-08T00:00:00+00:00</published><updated>2023-09-08T00:00:00+00:00</updated><id>nullskymc.cloud/binary</id><content type="html" xml:base="nullskymc.cloud/binary/"><![CDATA[<h2 id="逻辑回归">逻辑回归</h2>

<h3 id="特征向量以图片为例">特征向量——以图片为例</h3>

<p>对于一张彩色64x64 的图片，我们可以将其表示为一个维度为64x64x3=12288的向量，其中每个元素代表一个像素点的颜色值。这样的向量称为特征向量。12288指向量的维度，也称为特征数,用n表示。</p>

<h3 id="常用符号">常用符号</h3>

<ul>
  <li>m：训练样本的数量</li>
  <li>x：特征向量</li>
  <li>y：标签</li>
  <li>(x,y)：一个训练样本</li>
  <li>(x<sup>(i)</sup>,y<sup>(i)</sup>)：第i个训练样本</li>
  <li>X：所有训练样本的特征向量组成的矩阵，维度为(n,m)</li>
  <li>Y：所有训练样本的标签组成的矩阵，维度为(1,m)</li>
</ul>

<h3 id="逻辑回归模型">逻辑回归模型</h3>

<p>给定一个输入特征向量x和一幅图片对应，需要一个算法预测图片中是否有猫。我们可以用一个函数来表示这个算法，这个函数 $\hat{y}$ 表示对y的预测值，即</p>

\[\hat{y}=P(y=1|x)\]

<p>$\hat{y}$应该是一个0到1之间的数，因为它是一个概率值</p>

<table>
  <tbody>
    <tr>
      <td>其中$x$是特征向量，$y$是标签，$P(y=1</td>
      <td>x)$表示在给定$x$的情况下$y=1$的概率。这个函数就是逻辑回归模型。</td>
    </tr>
  </tbody>
</table>

<p>约定逻辑回归的参数$w$,$w$也是一个维度为(n,1)的向量<br />
参数$b$是一个实数</p>

<h4 id="sigmod函数">sigmod函数</h4>

\[\hat{y}=\sigma(w^Tx+b)=\frac{1}{1+e^{-(w^Tx+b)}}\]

\[\sigma(z)=\frac{1}{1+e^{-z}}\]

<h3 id="logistic回归的损失函数">logistic回归的损失函数</h3>

<p>Loss function:</p>

\[L(\hat{y},y)=-(ylog\hat{y}+(1-y)log(1-\hat{y}))\]

<p>Cost function:</p>

\[J(w,b)= \frac{1}{m} \sum_{i=1}^{m}L(\hat{y}^{(i)},y^{(i)})=- \frac{1}{m}\sum_{i=1}^{m}(y^{(i)}log\hat{y}^{(i)}+(1-y^{(i)})log(1-\hat{y}^{(i)}))\]

<h3 id="梯度下降">梯度下降</h3>

\[w:=w-\alpha\frac{\partial J(w,b)}{\partial w}\]

<p>找到合适的w和b使得$J(w,b)$最小，这里的$\alpha$是学习率，用来控制每次迭代的步长。</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">w</span> <span class="o">=</span> <span class="n">w</span> <span class="o">-</span> <span class="n">alpha</span> <span class="o">*</span> <span class="n">dw</span> <span class="c1">#dw代码中是w的梯度导数 
</span></code></pre></div></div>

<h3 id="logistic回归的梯度下降算法">logistic回归的梯度下降算法</h3>]]></content><author><name></name></author><category term="markdown" /><category term="Machine Learning" /><category term="Deep Learning" /><summary type="html"><![CDATA[逻辑回归 特征向量——以图片为例 对于一张彩色64x64 的图片，我们可以将其表示为一个维度为64x64x3=12288的向量，其中每个元素代表一个像素点的颜色值。这样的向量称为特征向量。12288指向量的维度，也称为特征数,用n表示。 常用符号 m：训练样本的数量 x：特征向量 y：标签 (x,y)：一个训练样本 (x(i),y(i))：第i个训练样本 X：所有训练样本的特征向量组成的矩阵，维度为(n,m) Y：所有训练样本的标签组成的矩阵，维度为(1,m) 逻辑回归模型 给定一个输入特征向量x和一幅图片对应，需要一个算法预测图片中是否有猫。我们可以用一个函数来表示这个算法，这个函数 $\hat{y}$ 表示对y的预测值，即 \[\hat{y}=P(y=1|x)\] $\hat{y}$应该是一个0到1之间的数，因为它是一个概率值 其中$x$是特征向量，$y$是标签，$P(y=1 x)$表示在给定$x$的情况下$y=1$的概率。这个函数就是逻辑回归模型。 约定逻辑回归的参数$w$,$w$也是一个维度为(n,1)的向量 参数$b$是一个实数 sigmod函数 \[\hat{y}=\sigma(w^Tx+b)=\frac{1}{1+e^{-(w^Tx+b)}}\] \[\sigma(z)=\frac{1}{1+e^{-z}}\] logistic回归的损失函数 Loss function: \[L(\hat{y},y)=-(ylog\hat{y}+(1-y)log(1-\hat{y}))\] Cost function: \[J(w,b)= \frac{1}{m} \sum_{i=1}^{m}L(\hat{y}^{(i)},y^{(i)})=- \frac{1}{m}\sum_{i=1}^{m}(y^{(i)}log\hat{y}^{(i)}+(1-y^{(i)})log(1-\hat{y}^{(i)}))\] 梯度下降 \[w:=w-\alpha\frac{\partial J(w,b)}{\partial w}\] 找到合适的w和b使得$J(w,b)$最小，这里的$\alpha$是学习率，用来控制每次迭代的步长。 w = w - alpha * dw #dw代码中是w的梯度导数 logistic回归的梯度下降算法]]></summary></entry><entry><title type="html">项目总结：GAN的实现与应用</title><link href="nullskymc.cloud/GAN/" rel="alternate" type="text/html" title="项目总结：GAN的实现与应用" /><published>2023-05-31T00:00:00+00:00</published><updated>2023-05-31T00:00:00+00:00</updated><id>nullskymc.cloud/GAN</id><content type="html" xml:base="nullskymc.cloud/GAN/"><![CDATA[<p>本文将介绍一个使用PyTorch实现的生成对抗网络（GAN）项目，并详细解释GAN的原理、代码实现以及应用场景。项目的代码可以在<a href="https://github.com/nullskymc/pytorch11/blob/master/GAN_work.ipynb">GitHub链接</a>中找到。</p>

<h2 id="1-引言">1. 引言</h2>

<p>生成对抗网络是一种强大的深度学习模型，它由两个互相竞争的网络组成：生成器和判别器。生成器负责生成逼真的数据样本，而判别器则试图区分生成的样本与真实样本。通过两个网络的不断对抗与学习，GAN能够产生高质量的合成数据。在本项目中，我们将使用PyTorch框架实现一个基本的GAN模型，并应用于图像生成任务。</p>

<h2 id="2-gan的原理">2. GAN的原理</h2>

<p>GAN的核心思想是使用生成器和判别器两个网络进行对抗性训练。生成器接受随机噪声作为输入，并生成伪造的数据样本。判别器则接受真实样本和生成器生成的样本，并试图将它们区分开来。通过反复迭代的对抗过程，生成器逐渐改进其生成的样本，以尽量欺骗判别器。</p>

<p>GAN的训练过程可以总结为以下几个步骤：</p>

<ol>
  <li>生成器生成一批伪造的样本。</li>
  <li>判别器分别对真实样本和生成的样本进行分类。</li>
  <li>根据判别器的分类结果，计算生成器和判别器的损失函数。</li>
  <li>更新生成器和判别器的权重参数。</li>
  <li>重复步骤1-4，直到达到预定的训练轮数或损失收敛。</li>
</ol>

<h2 id="3-代码实现">3. 代码实现</h2>

<p>以下是使用PyTorch实现的GAN的关键代码片段：</p>

<h3 id="导入所需的库和模块">导入所需的库和模块</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">torch</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">nn</span>
<span class="kn">from</span> <span class="nn">torch.autograd.variable</span> <span class="kn">import</span> <span class="n">Variable</span>

<span class="kn">import</span> <span class="nn">torchvision</span>
<span class="kn">import</span> <span class="nn">torchvision.transforms</span> <span class="k">as</span> <span class="n">transforms</span>

<span class="c1"># Preprocess
</span><span class="n">transform</span> <span class="o">=</span> <span class="n">transforms</span><span class="p">.</span><span class="n">Compose</span><span class="p">(</span>
    <span class="p">[</span>
        <span class="n">transforms</span><span class="p">.</span><span class="n">ToTensor</span><span class="p">(),</span>
        <span class="n">transforms</span><span class="p">.</span><span class="n">Normalize</span><span class="p">((</span><span class="mf">0.5</span><span class="p">,),</span> <span class="p">(</span><span class="mf">0.5</span><span class="p">,))</span>
    <span class="p">]</span>
<span class="p">)</span>

<span class="c1"># Training data
</span><span class="n">train_set</span> <span class="o">=</span> <span class="n">torchvision</span><span class="p">.</span><span class="n">datasets</span><span class="p">.</span><span class="n">MNIST</span><span class="p">(</span>
    <span class="n">root</span><span class="o">=</span><span class="s">'.'</span><span class="p">,</span> <span class="n">train</span><span class="o">=</span><span class="bp">True</span><span class="p">,</span> <span class="n">download</span><span class="o">=</span><span class="bp">True</span><span class="p">,</span> <span class="n">transform</span><span class="o">=</span><span class="n">transform</span>
<span class="p">)</span>
<span class="n">train_loader</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="n">utils</span><span class="p">.</span><span class="n">data</span><span class="p">.</span><span class="n">DataLoader</span><span class="p">(</span>
    <span class="n">train_set</span><span class="p">,</span> <span class="n">batch_size</span><span class="o">=</span><span class="mi">32</span><span class="p">,</span> <span class="n">shuffle</span><span class="o">=</span><span class="bp">True</span>
<span class="p">)</span>
</code></pre></div></div>
<h3 id="判别器部分-判别器网络是对图像真实与否进行分类">判别器部分。 判别器网络是对图像真实与否进行分类。</h3>
<p>输入：28×28像素 -&gt; 一个长度为784的向量
输出：一个单独的值<表示图像是否是实际的MNIST数字></表示图像是否是实际的MNIST数字></p>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># Our Discriminator classes
</span><span class="k">class</span> <span class="nc">Discriminator</span><span class="p">(</span><span class="n">nn</span><span class="p">.</span><span class="n">Module</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="nb">super</span><span class="p">().</span><span class="n">__init__</span><span class="p">()</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">model</span> <span class="o">=</span> <span class="n">nn</span><span class="p">.</span><span class="n">Sequential</span><span class="p">(</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">Linear</span><span class="p">(</span><span class="mi">784</span><span class="p">,</span> <span class="mi">1024</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">ReLU</span><span class="p">(</span><span class="n">inplace</span><span class="o">=</span><span class="bp">True</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">Dropout</span><span class="p">(</span><span class="mf">0.3</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">Linear</span><span class="p">(</span><span class="mi">1024</span><span class="p">,</span> <span class="mi">512</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">ReLU</span><span class="p">(</span><span class="n">inplace</span><span class="o">=</span><span class="bp">True</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">Dropout</span><span class="p">(</span><span class="mf">0.3</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">Linear</span><span class="p">(</span><span class="mi">512</span><span class="p">,</span> <span class="mi">256</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">ReLU</span><span class="p">(</span><span class="n">inplace</span><span class="o">=</span><span class="bp">True</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">Dropout</span><span class="p">(</span><span class="mf">0.3</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">Linear</span><span class="p">(</span><span class="mi">256</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">Sigmoid</span><span class="p">()</span>
        <span class="p">)</span>

    <span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">x</span><span class="p">):</span>
        <span class="n">out</span> <span class="o">=</span> <span class="bp">self</span><span class="p">.</span><span class="n">model</span><span class="p">(</span><span class="n">x</span><span class="p">.</span><span class="n">view</span><span class="p">(</span><span class="n">x</span><span class="p">.</span><span class="n">size</span><span class="p">(</span><span class="mi">0</span><span class="p">),</span> <span class="mi">784</span><span class="p">))</span>
        <span class="n">out</span> <span class="o">=</span> <span class="n">out</span><span class="p">.</span><span class="n">view</span><span class="p">(</span><span class="n">out</span><span class="p">.</span><span class="n">size</span><span class="p">(</span><span class="mi">0</span><span class="p">),</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
        <span class="k">return</span> <span class="n">out</span><span class="p">.</span><span class="n">cuda</span><span class="p">()</span>

<span class="n">discriminator</span> <span class="o">=</span> <span class="n">Discriminator</span><span class="p">()</span>
</code></pre></div></div>
<h3 id="生成器部分-生成器网络负责创建实际的图像">生成器部分。 生成器网络负责创建实际的图像。</h3>
<p>输入：一个长度为100的向量<纯随机噪声>
输出：一个长度为784的向量 -&gt; 28×28像素</纯随机噪声></p>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># Our Generator class
</span><span class="k">class</span> <span class="nc">Generator</span><span class="p">(</span><span class="n">nn</span><span class="p">.</span><span class="n">Module</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="nb">super</span><span class="p">().</span><span class="n">__init__</span><span class="p">()</span>
        <span class="bp">self</span><span class="p">.</span><span class="n">model</span> <span class="o">=</span> <span class="n">nn</span><span class="p">.</span><span class="n">Sequential</span><span class="p">(</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">Linear</span><span class="p">(</span><span class="mi">100</span><span class="p">,</span> <span class="mi">256</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">ReLU</span><span class="p">(</span><span class="n">inplace</span><span class="o">=</span><span class="bp">True</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">Linear</span><span class="p">(</span><span class="mi">256</span><span class="p">,</span> <span class="mi">512</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">ReLU</span><span class="p">(</span><span class="n">inplace</span><span class="o">=</span><span class="bp">True</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">Linear</span><span class="p">(</span><span class="mi">512</span><span class="p">,</span> <span class="mi">1024</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">ReLU</span><span class="p">(</span><span class="n">inplace</span><span class="o">=</span><span class="bp">True</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">Linear</span><span class="p">(</span><span class="mi">1024</span><span class="p">,</span> <span class="mi">784</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="n">Tanh</span><span class="p">()</span>
        <span class="p">)</span>

    <span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">x</span><span class="p">):</span>
        <span class="n">x</span> <span class="o">=</span> <span class="n">x</span><span class="p">.</span><span class="n">view</span><span class="p">(</span><span class="n">x</span><span class="p">.</span><span class="n">size</span><span class="p">(</span><span class="mi">0</span><span class="p">),</span> <span class="mi">100</span><span class="p">)</span>
        <span class="n">out</span> <span class="o">=</span> <span class="bp">self</span><span class="p">.</span><span class="n">model</span><span class="p">(</span><span class="n">x</span><span class="p">).</span><span class="n">cuda</span><span class="p">()</span>
        <span class="k">return</span> <span class="n">out</span>

<span class="n">generator</span> <span class="o">=</span> <span class="n">Generator</span><span class="p">()</span>
</code></pre></div></div>

<h3 id="把模型移动到gpu上">把模型移动到GPU上</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># If we have a GPU with CUDA, use it
</span><span class="k">if</span> <span class="n">torch</span><span class="p">.</span><span class="n">cuda</span><span class="p">.</span><span class="n">is_available</span><span class="p">():</span>
    <span class="k">print</span><span class="p">(</span><span class="s">"Using CUDA"</span><span class="p">)</span>
    <span class="n">discriminator</span><span class="p">.</span><span class="n">cuda</span><span class="p">()</span>
    <span class="n">generator</span><span class="p">.</span><span class="n">cuda</span><span class="p">()</span>

<span class="c1"># Setup loss function and optimizers
</span><span class="n">lr</span> <span class="o">=</span> <span class="mf">0.01</span>
<span class="n">num_epochs</span> <span class="o">=</span> <span class="mi">40</span>
<span class="n">num_batches</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">train_loader</span><span class="p">)</span>

<span class="n">criterion</span> <span class="o">=</span> <span class="n">nn</span><span class="p">.</span><span class="n">BCELoss</span><span class="p">()</span>
<span class="n">d_optimizer</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="n">optim</span><span class="p">.</span><span class="n">Adam</span><span class="p">(</span><span class="n">discriminator</span><span class="p">.</span><span class="n">parameters</span><span class="p">(),</span> <span class="n">lr</span><span class="o">=</span><span class="n">lr</span><span class="p">)</span>
<span class="n">g_optimizer</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="n">optim</span><span class="p">.</span><span class="n">Adam</span><span class="p">(</span><span class="n">generator</span><span class="p">.</span><span class="n">parameters</span><span class="p">(),</span> <span class="n">lr</span><span class="o">=</span><span class="n">lr</span><span class="p">)</span>
</code></pre></div></div>
<h3 id="开始训练循环-训练gan的关键是我们需要在一个循环中更新生成器和判别器">开始训练循环。 训练GAN的关键是我们需要在一个循环中更新生成器和判别器。</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># Convenience function for training our Discriminator
</span><span class="k">def</span> <span class="nf">train_discriminator</span><span class="p">(</span><span class="n">discriminator</span><span class="p">,</span> <span class="n">real_images</span><span class="p">,</span> <span class="n">real_labels</span><span class="p">,</span> <span class="n">fake_images</span><span class="p">,</span> <span class="n">fake_labels</span><span class="p">):</span>
    <span class="n">discriminator</span><span class="p">.</span><span class="n">zero_grad</span><span class="p">()</span>

    <span class="c1"># Get the predictions, loss, and score of the real images
</span>    <span class="n">predictions</span> <span class="o">=</span> <span class="n">discriminator</span><span class="p">(</span><span class="n">real_images</span><span class="p">)</span>
    <span class="n">real_loss</span> <span class="o">=</span> <span class="n">criterion</span><span class="p">(</span><span class="n">predictions</span><span class="p">,</span> <span class="n">real_labels</span><span class="p">)</span>
    <span class="n">real_score</span> <span class="o">=</span> <span class="n">predictions</span>

    <span class="c1"># Get the predictions, loss, and score of the fake images
</span>    <span class="n">predictions</span> <span class="o">=</span> <span class="n">discriminator</span><span class="p">(</span><span class="n">fake_images</span><span class="p">)</span>
    <span class="n">fake_loss</span> <span class="o">=</span> <span class="n">criterion</span><span class="p">(</span><span class="n">predictions</span><span class="p">,</span> <span class="n">fake_labels</span><span class="p">)</span>
    <span class="n">fake_score</span> <span class="o">=</span> <span class="n">predictions</span>

    <span class="c1"># Calculate the total loss, update the weights, and update the optimizer
</span>    <span class="n">d_loss</span> <span class="o">=</span> <span class="n">real_loss</span> <span class="o">+</span> <span class="n">fake_loss</span>
    <span class="n">d_loss</span><span class="p">.</span><span class="n">backward</span><span class="p">()</span>
    <span class="n">d_optimizer</span><span class="p">.</span><span class="n">step</span><span class="p">()</span>
    <span class="k">return</span> <span class="n">d_loss</span><span class="p">,</span> <span class="n">real_score</span><span class="p">,</span> <span class="n">fake_score</span>
</code></pre></div></div>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># Convenience function for training our Generator
</span><span class="k">def</span> <span class="nf">train_generator</span><span class="p">(</span><span class="n">generator</span><span class="p">,</span> <span class="n">discriminator_outputs</span><span class="p">,</span> <span class="n">real_labels</span><span class="p">):</span>
    <span class="n">generator</span><span class="p">.</span><span class="n">zero_grad</span><span class="p">()</span>

    <span class="c1"># Calculate the total loss, update the weights, and update the optimizer
</span>    <span class="n">g_loss</span> <span class="o">=</span> <span class="n">criterion</span><span class="p">(</span><span class="n">discriminator_outputs</span><span class="p">,</span> <span class="n">real_labels</span><span class="p">)</span>
    <span class="n">g_loss</span><span class="p">.</span><span class="n">backward</span><span class="p">()</span>
    <span class="n">g_optimizer</span><span class="p">.</span><span class="n">step</span><span class="p">()</span>
    <span class="k">return</span> <span class="n">g_loss</span>
</code></pre></div></div>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">for</span> <span class="n">epoch</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">num_epochs</span><span class="p">):</span>
    <span class="k">for</span> <span class="n">n</span><span class="p">,</span> <span class="p">(</span><span class="n">images</span><span class="p">,</span> <span class="n">_</span><span class="p">)</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="n">train_loader</span><span class="p">):</span>
        <span class="c1"># (1) Prepare the real data for the Discriminator
</span>        <span class="n">real_images</span> <span class="o">=</span> <span class="n">Variable</span><span class="p">(</span><span class="n">images</span><span class="p">).</span><span class="n">cuda</span><span class="p">()</span>
        <span class="n">real_labels</span> <span class="o">=</span> <span class="n">Variable</span><span class="p">(</span><span class="n">torch</span><span class="p">.</span><span class="n">ones</span><span class="p">(</span><span class="n">images</span><span class="p">.</span><span class="n">size</span><span class="p">(</span><span class="mi">0</span><span class="p">))).</span><span class="n">reshape</span><span class="p">([</span><span class="mi">32</span><span class="p">,</span> <span class="mi">1</span><span class="p">]).</span><span class="n">cuda</span><span class="p">()</span>

        <span class="c1"># (2) Prepare the random noise data for the Generator
</span>        <span class="n">noise</span> <span class="o">=</span> <span class="n">Variable</span><span class="p">(</span><span class="n">torch</span><span class="p">.</span><span class="n">randn</span><span class="p">(</span><span class="n">images</span><span class="p">.</span><span class="n">size</span><span class="p">(</span><span class="mi">0</span><span class="p">),</span> <span class="mi">100</span><span class="p">)).</span><span class="n">cuda</span><span class="p">()</span>

        <span class="c1"># (3) Prepare the fake data for the Discriminator
</span>        <span class="n">fake_images</span> <span class="o">=</span> <span class="n">generator</span><span class="p">(</span><span class="n">noise</span><span class="p">)</span>
        <span class="n">fake_labels</span> <span class="o">=</span> <span class="n">Variable</span><span class="p">(</span><span class="n">torch</span><span class="p">.</span><span class="n">zeros</span><span class="p">(</span><span class="n">images</span><span class="p">.</span><span class="n">size</span><span class="p">(</span><span class="mi">0</span><span class="p">))).</span><span class="n">reshape</span><span class="p">([</span><span class="mi">32</span><span class="p">,</span> <span class="mi">1</span><span class="p">]).</span><span class="n">cuda</span><span class="p">()</span>

        <span class="c1"># (4) Train the discriminator on real and fake data
</span>        <span class="n">d_loss</span><span class="p">,</span> <span class="n">real_score</span><span class="p">,</span> <span class="n">fake_score</span> <span class="o">=</span> <span class="n">train_discriminator</span><span class="p">(</span>
            <span class="n">discriminator</span><span class="p">,</span>
            <span class="n">real_images</span><span class="p">,</span> <span class="n">real_labels</span><span class="p">,</span>
            <span class="n">fake_images</span><span class="p">,</span> <span class="n">fake_labels</span>
        <span class="p">)</span>

        <span class="c1"># (5a) Generate some new fake images from the Generator.
</span>        <span class="c1"># (5b) Get the label predictions of the Discriminator on that fake data.
</span>        <span class="n">noise</span> <span class="o">=</span> <span class="n">Variable</span><span class="p">(</span><span class="n">torch</span><span class="p">.</span><span class="n">randn</span><span class="p">(</span><span class="n">images</span><span class="p">.</span><span class="n">size</span><span class="p">(</span><span class="mi">0</span><span class="p">),</span> <span class="mi">100</span><span class="p">)).</span><span class="n">cuda</span><span class="p">()</span>
        <span class="n">fake_images</span> <span class="o">=</span> <span class="n">generator</span><span class="p">(</span><span class="n">noise</span><span class="p">)</span>

        <span class="n">outputs</span> <span class="o">=</span> <span class="n">discriminator</span><span class="p">(</span><span class="n">fake_images</span><span class="p">)</span>

        <span class="c1"># (6) Train the generator
</span>        <span class="n">g_loss</span> <span class="o">=</span> <span class="n">train_generator</span><span class="p">(</span><span class="n">generator</span><span class="p">,</span> <span class="n">outputs</span><span class="p">,</span> <span class="n">real_labels</span><span class="p">)</span>
</code></pre></div></div>

<h3 id="save-the-model">Save the model</h3>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">torch</span><span class="p">.</span><span class="n">save</span><span class="p">(</span><span class="n">generator</span><span class="p">.</span><span class="n">state_dict</span><span class="p">(),</span> <span class="s">'generator.pth'</span><span class="p">)</span>
<span class="n">torch</span><span class="p">.</span><span class="n">save</span><span class="p">(</span><span class="n">discriminator</span><span class="p">.</span><span class="n">state_dict</span><span class="p">(),</span> <span class="s">'discriminator.pth'</span><span class="p">)</span>
</code></pre></div></div>]]></content><author><name></name></author><category term="GAN" /><category term="markdown" /><category term="Machine Learning" /><summary type="html"><![CDATA[本文将介绍一个使用PyTorch实现的生成对抗网络（GAN）项目，并详细解释GAN的原理、代码实现以及应用场景。项目的代码可以在GitHub链接中找到。 1. 引言 生成对抗网络是一种强大的深度学习模型，它由两个互相竞争的网络组成：生成器和判别器。生成器负责生成逼真的数据样本，而判别器则试图区分生成的样本与真实样本。通过两个网络的不断对抗与学习，GAN能够产生高质量的合成数据。在本项目中，我们将使用PyTorch框架实现一个基本的GAN模型，并应用于图像生成任务。 2. GAN的原理 GAN的核心思想是使用生成器和判别器两个网络进行对抗性训练。生成器接受随机噪声作为输入，并生成伪造的数据样本。判别器则接受真实样本和生成器生成的样本，并试图将它们区分开来。通过反复迭代的对抗过程，生成器逐渐改进其生成的样本，以尽量欺骗判别器。 GAN的训练过程可以总结为以下几个步骤： 生成器生成一批伪造的样本。 判别器分别对真实样本和生成的样本进行分类。 根据判别器的分类结果，计算生成器和判别器的损失函数。 更新生成器和判别器的权重参数。 重复步骤1-4，直到达到预定的训练轮数或损失收敛。 3. 代码实现 以下是使用PyTorch实现的GAN的关键代码片段： 导入所需的库和模块 import torch from torch import nn from torch.autograd.variable import Variable import torchvision import torchvision.transforms as transforms # Preprocess transform = transforms.Compose( [ transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,)) ] ) # Training data train_set = torchvision.datasets.MNIST( root='.', train=True, download=True, transform=transform ) train_loader = torch.utils.data.DataLoader( train_set, batch_size=32, shuffle=True ) 判别器部分。 判别器网络是对图像真实与否进行分类。 输入：28×28像素 -&gt; 一个长度为784的向量 输出：一个单独的值 # Our Discriminator classes class Discriminator(nn.Module): def __init__(self): super().__init__() self.model = nn.Sequential( nn.Linear(784, 1024), nn.ReLU(inplace=True), nn.Dropout(0.3), nn.Linear(1024, 512), nn.ReLU(inplace=True), nn.Dropout(0.3), nn.Linear(512, 256), nn.ReLU(inplace=True), nn.Dropout(0.3), nn.Linear(256, 1), nn.Sigmoid() ) def forward(self, x): out = self.model(x.view(x.size(0), 784)) out = out.view(out.size(0), -1) return out.cuda() discriminator = Discriminator() 生成器部分。 生成器网络负责创建实际的图像。 输入：一个长度为100的向量 输出：一个长度为784的向量 -&gt; 28×28像素 # Our Generator class class Generator(nn.Module): def __init__(self): super().__init__() self.model = nn.Sequential( nn.Linear(100, 256), nn.ReLU(inplace=True), nn.Linear(256, 512), nn.ReLU(inplace=True), nn.Linear(512, 1024), nn.ReLU(inplace=True), nn.Linear(1024, 784), nn.Tanh() ) def forward(self, x): x = x.view(x.size(0), 100) out = self.model(x).cuda() return out generator = Generator() 把模型移动到GPU上 # If we have a GPU with CUDA, use it if torch.cuda.is_available(): print("Using CUDA") discriminator.cuda() generator.cuda() # Setup loss function and optimizers lr = 0.01 num_epochs = 40 num_batches = len(train_loader) criterion = nn.BCELoss() d_optimizer = torch.optim.Adam(discriminator.parameters(), lr=lr) g_optimizer = torch.optim.Adam(generator.parameters(), lr=lr) 开始训练循环。 训练GAN的关键是我们需要在一个循环中更新生成器和判别器。 # Convenience function for training our Discriminator def train_discriminator(discriminator, real_images, real_labels, fake_images, fake_labels): discriminator.zero_grad() # Get the predictions, loss, and score of the real images predictions = discriminator(real_images) real_loss = criterion(predictions, real_labels) real_score = predictions # Get the predictions, loss, and score of the fake images predictions = discriminator(fake_images) fake_loss = criterion(predictions, fake_labels) fake_score = predictions # Calculate the total loss, update the weights, and update the optimizer d_loss = real_loss + fake_loss d_loss.backward() d_optimizer.step() return d_loss, real_score, fake_score # Convenience function for training our Generator def train_generator(generator, discriminator_outputs, real_labels): generator.zero_grad() # Calculate the total loss, update the weights, and update the optimizer g_loss = criterion(discriminator_outputs, real_labels) g_loss.backward() g_optimizer.step() return g_loss for epoch in range(num_epochs): for n, (images, _) in enumerate(train_loader): # (1) Prepare the real data for the Discriminator real_images = Variable(images).cuda() real_labels = Variable(torch.ones(images.size(0))).reshape([32, 1]).cuda() # (2) Prepare the random noise data for the Generator noise = Variable(torch.randn(images.size(0), 100)).cuda() # (3) Prepare the fake data for the Discriminator fake_images = generator(noise) fake_labels = Variable(torch.zeros(images.size(0))).reshape([32, 1]).cuda() # (4) Train the discriminator on real and fake data d_loss, real_score, fake_score = train_discriminator( discriminator, real_images, real_labels, fake_images, fake_labels ) # (5a) Generate some new fake images from the Generator. # (5b) Get the label predictions of the Discriminator on that fake data. noise = Variable(torch.randn(images.size(0), 100)).cuda() fake_images = generator(noise) outputs = discriminator(fake_images) # (6) Train the generator g_loss = train_generator(generator, outputs, real_labels) Save the model torch.save(generator.state_dict(), 'generator.pth') torch.save(discriminator.state_dict(), 'discriminator.pth')]]></summary></entry></feed>