九天玩转Langchain!第二讲 langchain基础——安装与hello world

数字黑魔法
13 Oct 202347:19

Summary

TLDR本课程由硅谷摩根大通软件工程师小伟主讲,介绍了Longchain系列课程的学习内容。课程分为三部分:首先是Python环境搭建和Jupyter Notebook的安装使用,其次是Longchain的安装和快速上手,创建大型语言模型模块并进行简单应用,最后是阅读Longchain文档和探索原代码。课程内容丰富,旨在帮助学员通过实践掌握Longchain的应用开发。

Takeaways

  • 🚀 课程介绍了Longchain系列课程的学习内容,包括Python环境搭建、Jupyter Notebook安装与使用,以及Longchain的安装和应用。
  • 🌟 Python是高级编程语言,因其接近人类语言、动态类型和直译式特性而易于学习和应用广泛。
  • 📚 Jupyter Notebook是一个交互式开源笔记本工具,支持多种编程语言,特别适合数据科学和机器学习领域。
  • 🛠️ 安装Python推荐版本为3.8.1以上,课程中使用的是3.10.12版本。
  • 🔧 Jupyter Notebook可以通过Pip安装,也可以通过VS Code的插件来使用。
  • 📈 Longchain的安装非常简单,只需使用命令`pip install longchain`即可。
  • 🔄 通过Longchain可以创建大型语言模型模块(LLM模块),这是Longchain应用的基础。
  • 🤖 利用LLM模块,可以开发简单的应用,如生成男孩小名等,并可通过API与第三方模型提供商交互。
  • 🔗 链式结构(Chain)允许将不同功能的模块串联起来,形成具有丰富功能的应用。
  • 📝 代理人(Agent)模块能够解决复杂问题,如数学计算和访问互联网获取信息。
  • 📋 阅读和理解Longchain的文档是学习过程中的重要部分,但同时也需要参考原代码来解决一些文档中未涉及的问题。

Q & A

  • 课程中提到的Longchain是什么?

    -Longchain是一个基于Python的开源项目,旨在通过模块化的方式构建和使用大型语言模型。它提供了一系列工具和接口,方便开发者快速搭建和部署各种基于语言模型的应用。

  • 为什么在Longchain系列课程中,Python环境的搭建和Jupyter Notebook的安装非常重要?

    -Python是Longchain的主要编程语言,其易于学习和动态特性使得开发更为便捷。Jupyter Notebook是一个交互式的编程环境,允许用户逐行运行代码并实时查看结果,非常适合进行教学和开发工作。

  • 课程中提到的LLM模块是什么?

    -LLM模块指的是大型语言模型模块,它是Longchain应用的基础或基石。几乎所有的应用都是基于这样的模块开发的,它能够根据输入的文本生成或补全新的文本。

  • 如何安装Python?

    -Python的安装非常简单,可以通过官网下载安装包进行安装,也可以通过包管理器如pip来安装特定版本的Python。课程推荐使用Python 3.8.1以上版本,其中3.10.12是较为稳定的版本。

  • Jupyter Notebook有哪些特点?

    -Jupyter Notebook是一个交互式的开源笔记本工具,支持多种编程语言,尤其在Python上应用广泛。它可以在一个web浏览器中使用,支持交互式运行代码,即可以选择性执行代码片段,并实时查看输出结果。此外,它还支持Markdown格式的文本输入和可视化输出。

  • Longchain的安装方法是什么?

    -Longchain的安装非常简单,只需要使用Python的包管理器pip,通过命令`pip install longchain`即可安装Longchain及其所有依赖包。

  • 课程中提到的链式结构是什么?

    -链式结构是Longchain中的一种设计模式,它允许将不同的模块按照特定需求串联起来,形成一个处理流程。这种结构可以避免重复定义功能相似的模块,并且可以通过连接不同的模块来丰富应用的功能。

  • 代理人模块在Longchain中的作用是什么?

    -代理人模块在Longchain中用于解决复杂问题,它可以通过使用各种工具和内部的语言模型来决定完成任务所需的行为及其执行顺序。代理人模块可以访问互联网获取最新信息,或者执行复杂的数学计算等任务。

  • 如何获取并使用大型语言模型(LLM)?

    -可以通过在本地运行开源的LLM模型或使用第三方模型提供商的API来获取LLM。国内提供商如百度和阿里,国外如OpenAI和Replicate等,他们都提供了可以通过API访问的语言模型。

  • 课程中提到的Conversation Chain有什么特点?

    -Conversation Chain是Longchain中的一个模块,专注于对话应用。它内部具有对话记录的缓存功能,能够根据上下文给出符合语境的回答,实现类似chatbot的对话体验。

Outlines

00:00

📚课程介绍与Python环境搭建

本段落介绍了课程的基本情况,包括讲师小伟的背景和课程内容的概览。课程分为三部分:Python环境搭建、Jupyter Notebook的安装与使用,Linechain的安装和快速上手,以及创建大型语言模型模块(LLM)。强调了Python的重要性,解释了其高级编程语言的特点,如语法易理解、动态类型、直译式执行等。同时,提到了Python在多个领域的广泛应用和活跃的社区支持。最后,介绍了Python环境的安装和版本要求,推荐使用3.8.1以上版本,并推荐了3.10.12版本。

05:02

🛠️Jupyter Notebook与Longchain的安装

本段落详细讲解了Jupyter Notebook的安装和使用方法,以及Longchain的安装过程。首先介绍了Jupyter Notebook的功能和优势,如交互式代码执行、支持Markdown和可视化输出等,并提供了安装和启动JupyterLab的命令。接着,通过截图和实际操作演示了Jupyter Notebook的界面和功能。然后,介绍了Longchain的安装命令,强调了安装Longchain后可以进行的开发和使用。最后,通过VS Code演示了Jupyter Notebook的交互使用,展示了如何在VS Code中创建和运行Jupyter Notebook文件。

10:03

🤖建立大型语言模型模块与使用

本段落主要讲解了如何建立和使用大型语言模型模块(LLM)。首先介绍了获取LLM的两种途径:本地运行开源模型和使用第三方模型提供商的API。由于高性能模型需要大量GPU资源,推荐使用API。介绍了国内外的API提供商,如百度、阿里、Replicate和OpenAI,并讲解了如何使用这些API。然后,通过示例展示了如何创建一个简单的LLM模块,并使用predict方法生成文本。此外,还讨论了模型的温度设置对结果的影响,并举例说明了如何通过设置temperature得到一致的结果。

15:03

💬聊天模块与链式结构的应用

本段落深入探讨了Longchain中的聊天模块和链式结构。首先解释了聊天模块的功能,即以对话形式续写对话,并介绍了与LM模块的相似性和差异性。然后,通过示例展示了如何使用聊天模块生成对话消息,并解释了AI message、Human message和System message的概念。接着,介绍了链式结构的概念,即将不同功能的模块串联起来形成一个应用。通过示例代码,展示了如何使用提示模板和链式结构来创建一个可以根据不同对象生成名字的应用。最后,讨论了链式结构的优势,如方便连接多个模块和避免重复定义功能相似的模块。

20:04

🧠代理人模块与对话记录的应用

本段落详细介绍了Longchain中的代理人模块和对话记录应用。首先解释了代理人模块的作用,即解决复杂问题和访问互联网获取信息。通过示例展示了如何使用代理人模块进行数学计算,并比较了代理人和基本语言模型在处理数学问题上的差异。然后,介绍了对话记录应用Conversation Chain,通过示例展示了如何实现与人工智能的对话。此外,还讨论了Conversation Chain如何利用内部缓存来处理具有上下文的对话。最后,强调了阅读Longchain文档和原代码的重要性,以及如何通过VS Code的代码跳转功能来查看原代码。

25:08

📖Longchain文档与原代码阅读指南

本段落主要提供了关于Longchain文档和原代码阅读的指南。首先强调了Longchain文档的重要性,尤其是教程部分,并建议选择性阅读模块部分的讲解作为预习。然后,指出了文档的局限性,如更新速度跟不上开发速度、结构逻辑关系不清晰、重复内容影响阅读效率等。建议在开发过程中结合原代码进行学习,并提供了两种查看原代码的方法:直接在GitHub上查找和在VS Code中使用代码跳转功能。最后,鼓励大家在课程结束后阅读文档,以更好地理解和使用Longchain。

Mindmap

Keywords

💡Longchain

Longchain是视频中介绍的一系列课程的核心主题,它是一个开发工具,专注于大型语言模型(LLM)的应用开发。在视频中,讲师通过Longchain来演示如何创建和管理不同的模块,以及如何通过这些模块来实现特定的功能,例如起名、进行数学计算等。

💡Python

Python是一种广泛使用的高级编程语言,以其简洁的语法和强大的功能库而闻名。在视频中,Python被选为Longchain开发的主要编程语言,讲师强调了Python的易学性、动态类型和解释执行的特点,这些都使得Python成为Longchain应用开发的合适选择。

💡Jupyter Notebook

Jupyter Notebook是一个开源的交互式笔记本工具,支持多种编程语言,尤其适用于数据科学和机器学习领域。在视频中,Jupyter Notebook被用来运行和展示Python代码,使得用户可以逐行执行代码并实时查看结果,这对于Longchain的学习和开发非常有用。

💡LLM模块

LLM模块,即大型语言模型模块,是Longchain应用开发的基础。它能够根据输入的文本生成新的文本,是Longchain中实现各种功能的核心组件。

💡链式结构

链式结构是Longchain中将不同功能的模块按照一定顺序连接起来的方式,形成一个处理流程。这种结构可以让多个模块协同工作,实现更复杂的功能。

💡代理人

代理人是Longchain中的一个高级模块,它可以模拟人类的思考过程,使用内置的工具来解决复杂的问题,如数学计算或访问互联网获取信息。代理人的工作流程包括理解任务、规划步骤、执行行为和处理结果。

💡Conversation Chain

Conversation Chain是Longchain中用于处理对话的链式结构,它可以记录和理解对话的上下文,从而生成符合上下文的回复。这种结构使得人工智能可以与用户进行连贯的对话。

💡文档阅读

文档阅读是学习和使用Longchain的重要环节,通过阅读Longchain的官方文档,用户可以了解如何搭建环境、创建应用、集成大型语言模型等。文档是理解Longchain功能和模块之间关系的关键资源。

💡原代码

原代码是指软件或工具的源代码,它是软件功能实现的基础。在Longchain的学习中,阅读原代码可以帮助用户更深入地理解功能实现的细节,解决文档中没有涵盖的问题。

💡API文档

API文档是应用程序编程接口文档的简称,它详细说明了如何使用特定的API,包括函数、类、方法的使用方法和参数。在Longchain中,API文档为用户提供了一个快速了解和使用各种模块和工具的途径。

Highlights

讲师小伟在硅谷摩根大通担任软件工程师,与小安讲师共同探讨Longchain的学习成果。

本课程分为三部分:简单安装、快速上手和阅读文档,以及窥探Longchain的原代码。

Python环境搭建和版本选择是Longchain学习的基础,推荐使用Python 3.10.12版本。

Jupyter Notebook是Longchain系列课程中必不可少的工具,支持多种编程语言。

Longchain的安装非常简单,只需使用pip install longchain命令即可。

创建大型语言模型模块(LLM模块)是Longchain应用的基础。

通过Longchain的文档可以了解其提供的参考资料和基础功能的实现逻辑。

Python因其易于学习和动态特性,被广泛应用于Web应用、软件开发、数据科学和机器学习等领域。

Jupyter Notebook是一个交互式的开源笔记本工具,可以编写、运行和共享代码文本和图形内容。

VS Code与Jupyter Notebook结合使用,可以方便地编写和运行代码。

Longchain提供了丰富的模块和工具,如LLM模块、聊天模块和链式结构等。

代理人模块可以帮助解决复杂问题,如数学计算和访问互联网获取最新信息。

Longchain的文档是学习的重要参考资料,但需要结合原代码进行深入理解。

Longchain支持多种大型语言模型的集成,如OpenAI、阿里巴巴达摩院的同意签问等。

Longchain的API文档和分类文档有助于开发者了解各个模块的使用方法和功能。

Longchain的JavaScript版本也在并行开发中,提供了不同于Python的另一种使用方式。

通过VS Code的代码跳转功能可以方便地查看Longchain的原代码,有助于解决开发中的问题。

Transcripts

play00:00

Hello 大家好

play00:01

欢迎大家继续我们Longchain系列课程的学习

play00:04

我是本堂课的讲师

play00:06

大家可以叫我小伟

play00:07

先做一个简单的自我介绍

play00:09

我在硅谷这边摩根大通担任软件工程师

play00:14

我与大家在上节课中已经认识过的小安讲师

play00:18

平常喜欢在一起捣鼓一些有的没的东西

play00:21

所以我们在这一整个系列课程中

play00:24

会和大家分享我们捣鼓Longchain的一些学习成果

play00:28

也希望所有的学员能够通过这系列课程的学习有所收获

play00:35

好 话不多说

play00:37

让我们一起进入今天的学习内容

play00:39

接下来让我们一起来看一下这堂课的大纲

play00:42

这堂课分为三个部分

play00:44

第一部分叫简单安装

play00:46

就是我们会和大家一块来过一下

play00:49

Python环境的搭建

play00:51

版本选择以及一个很重要的工具

play00:54

也就是Jupyter Notebook的安装与使用

play00:56

在我们整个系列课程中

play00:58

Jupyter Notebook是必不可少的一个工具

play01:01

在这之后我们会迎来今天的主角

play01:06

也就是Linechain的安装

play01:08

在安装过程结束之后

play01:11

我们会进入我们的第二部分

play01:12

也就是快速上手

play01:13

在这一部分中

play01:15

我们会首先创建一个大型语言模型模块

play01:18

也就是LLM模块

play01:20

这个LLM模块就是我们所有的Longchain的应用的基础

play01:25

或者叫基石

play01:27

基本上所有的应用都是基于这样一个模块来开发的

play01:32

好 有了这样一个模块之后

play01:34

我们会做一些基于这个模块的简单的应用

play01:38

注意是一些不是一个

play01:40

所以咱们这堂课的内容其实还是挺多的

play01:43

在做完这些应用之后

play01:45

我们会和大家一起来阅读一下

play01:47

Longchain的文档

play01:48

看一下它的文档提供了哪些

play01:52

我们可以使用的参考资料

play01:54

在这之后我们会窥探一下

play01:58

Longchain的原代码

play01:59

去看一下它到底是如何实现一些基础的功能

play02:03

它背后的逻辑是什么样的

play02:04

好这是我们这堂课的一个基本安排去看一下它到底是如何实现一些基础的功能它背后的逻辑是什么样的

play02:06

play02:08

这是我们这堂课的一个基本安排

play02:16

首先简单介绍一下我们的需要使用的编程语言也就是Python

play02:18

Python它是一个高级的编程语言

play02:21

为什么说它是高级的编程语言

play02:23

因为它是比较接近于人类的语言

play02:25

所以它非常容易学习

play02:26

它的语法特别容易理解

play02:29

然后它是一个动态的语言

play02:32

什么叫动态语言

play02:33

就是它的变量类型是可变的

play02:38

所以写起来会比较灵活自由

play02:43

然后同时它也是一个直译式语言

play02:46

也就是说它不需要编译成机器码

play02:49

它可以直接的由解释器来运行

play02:52

这就是为什么我们可以使用Jupyter Notebook这样的软件

play02:56

来逐行的运行Python代码

play02:58

并且可以实时的看到我们运行代码的结果

play03:03

Python被广泛的应用于Web应用实时地看到我们运行代码的结果

play03:07

Python被广泛地应用于web应用软件开发 数据科学和机器学习等领域

play03:11

也就是因为它的这些一系列特性

play03:14

另外Python还有非常活跃的社区

play03:17

Python开发者可以说是软件开发者中的很大一部分人群

play03:23

然后在Python的社区中也活跃着

play03:26

数量巨大的内容丰富的库

play03:28

也就是可以理解为第三方软件包吧

play03:31

他们让Python拥有了无穷的力量

play03:36

以及丰富的功能

play03:37

所以在咱们学习Longchain的过程中

play03:41

Python是必不可少的一个编程语言

play03:50

Python的环境其实安装非常简单这里就不再赘述了

play03:52

主要强调一点就是它的版本要求

play03:56

3.8.1是Longchain的一个推荐配置

play04:01

它说你要使用我们Longchain的话

play04:04

最好Python的版本是要高于3.8.1

play04:07

这里我们直接就推到3.10.12

play04:10

因为3.10是现在Python的

play04:12

Python3的一个小版本里面比较稳定的一个版本

play04:15

然后12是它最新的一个build

play04:18

是我们在录这个视频的时候最新的一个build

play04:20

可能当你看到这个视频的时候

play04:22

最新的build可能不是12可能13或者14

play04:26

这个就取决于你自己的个人选择了

play04:28

我们这一系列课程

play04:30

我所使用的会是3.10.12这个版本

play04:35

接下来会和大家介绍一下Jupyter Notebook

play04:38

Jupyter Notebook是一个交互式的开源笔记本工具

play04:42

可以用于编写运行和共享代码文本和图形的内容

play04:46

它支持多种编程语言

play04:48

我们这里主要使用的就是Python

play04:50

它可以在一个web浏览器当中进行使用

play04:53

它的一个重要的特点是它可以交互式的运行代码

play04:57

什么叫交互式的运行代码呢

play04:59

就是你可以选择性的执行某个代码

play05:01

不像我们平常写代码的时候

play05:04

可能会就是一整个代码程序就全部运行一遍

play05:09

而GPU notebook可以让你选择执行其中的某一段代码

play05:15

并且把这个代码的输出可以给你显示出来

play05:19

然后你可以修改代码

play05:20

并且再重复执行这一段

play05:22

然后看也看到不同的输出

play05:26

具体的内容我们会在后面的学习中给大家演示

play05:31

这里只需要知道它是一个交互式的

play05:33

可以运行代码的程序就可以了

play05:36

下面会给大家看一个截图的例子

play05:39

这是Jupyter Notebook的一个界面

play05:43

然后它里面可以支持用markdown格式输入文档

play05:47

就是文本

play05:49

然后可以支持代码块

play05:51

像这就是一个代码块

play05:52

然后可以支持显示

play05:55

我们看到它不光可以显示文本

play05:57

它可以显示可视化的输出

play06:00

这是它一个丰富的功能

play06:02

所以说它被广泛地应用于数据科学

play06:08

机器学习等等领域因为他们会经常用到一些

play06:09

可适化输入的这样一个需求

play06:12

好 它怎么安装呢

play06:14

很简单

play06:15

大家可以去它的官网

play06:16

Jupyter Notebook的这样一个官网

play06:18

然后到它的安装界面去看它的安装的教程

play06:22

其实最简单的就是用Pip install JupyterLab

play06:25

这是Pip是Python的一个包管理器

play06:30

然后用它来安装Jupyter Notebook是最简单一个方式

play06:34

然后启动的时候只需要敲这行命令

play06:37

JupyterLab就可以启动了

play06:39

还有另外一个方法就是用VS Code

play06:41

这是一个文本编辑器

play06:43

不知道有没有学员使文本编辑器不知道有没有学员使用编辑器

play06:47

但它里面的Jupyter插件是支持Jupyter Notebook的

play06:51

所以有多种使用方式

play06:53

一会儿我们会和大家来演示两种使用方式

play06:57

其实都可以

play06:58

然后最后就是我们的Longchain的安装

play07:02

Longchain安装就更简单了

play07:04

你只需要一号命令

play07:05

pip install longchain

play07:09

这个指令会把Longchain需要的所有的dependent

play07:12

所有的依赖包都给你安装好

play07:14

那么安装好了这些

play07:15

安装好这个Longchain之后

play07:17

你就可以来进行Longchain的开发和使用

play07:22

play07:23

这里给大家演示一下

play07:28

一些就是咱们整个安装过程大概是什么样的大家心里有一个基本的认识

play07:31

好 大家现在看到的界面是我的VSCode

play07:34

然后VSCode里面它是内置一个terminal一个终端的

play07:37

这个终端就是大家可以输入一些安装命令

play07:40

那么现在我的Python其实是已经装好了

play07:42

大家可以看到我的Python的版本号是3.12.12

play07:46

然后现在我要来安装JupyterLab

play07:50

所以我输入命令JupyterLab

play07:54

大家看到现在安装过程正在进行

play08:04

好了我的JupyterLab已经安装好了那么接下来让我启动一下JupyterLab好了

play08:05

我的JupyterLab已经安装好了

play08:07

那么接下来让我启动一下JupyterLab

play08:09

试一下看是什么效果

play08:10

OK

play08:14

它说我的Lab已经启动好了

play08:16

那么我可以通过这个链接来进入

play08:22

Jupyter Notebook这样一个交互界面

play08:33

play08:33

那么现在我在

play08:36

Notebook这样一个交互界面

play08:38

下面我开始一个新的Python3的Notebook

play08:41

OK

play08:42

这样就是一个Notebook

play08:46

这样缩小一点方便大家看到

play08:49

在这里我们可以输入Pattern代码

play08:51

比如说print

play08:59

print

play09:01

hello world

play09:04

输入好Patter上代码之后

play09:05

我们可以选择运行它

play09:06

重复点播放按钮

play09:08

你看

play09:08

Hello world出来了

play09:09

play09:12

我们也可以选择输入一些文本

play09:16

比方说在这里选择markdown

play09:18

那我们这个块就变成了从代码变成了markdown

play09:23

我们可以选输一些基本的

play09:25

这是一个title

play09:28

这是一个第二个title

play09:30

然后有一些list1

play09:33

list2

play09:35

那么我们点击播放

play09:37

这个markdown就被执行成了这样一个文本输出

play09:40

基本上就是这两个功能了然后我们接下来会使用主要使用VSCode

play09:49

来和Jupyter Notebook进行交互

play09:51

而不是使用它的Web界面

play09:53

因为方便我们写代码

play09:54

好 我就把它先暂时关掉

play10:00

OK

play10:03

好 接下来我们来看一下如何用VS Code

play10:06

来和Jupyter Notebook进行一个交互

play10:08

注意用VS Notebook的时候

play10:11

其实是不需要在后台启动一个Jupyter的Server的

play10:14

我们只需要确保我们的VS Code是安装了Jupyter的插件

play10:19

那么我们首先来创建一个Jupyter notebook的一个文件

play10:25

叫它Hello world

play10:28

它的后缀是ipynb

play10:31

创好之后我们用listcode把它打开

play10:35

OK 我们现在打开了这样一个插件

play10:37

这样一个notebook

play10:40

我们可以看到这里已经在提示我们这里可以写代码了

play10:43

我们写一行代码

play10:46

Hello world

play10:49

然后点这个小箭头

play10:50

尝试运行一下

play10:51

好的

play10:51

Hello world运行好了

play10:54

在初次使用插件的时候

play10:58

它可能会让你选择Python的解释器

play11:03

在这里

play11:04

如果你是Mac用户的话

play11:06

是可以使用Command-JShift-JP来调出控制台

play11:10

然后在里面选择Python的解释器

play11:13

选择你自己刚刚安装好的3.4.12就可以了

play11:16

play11:17

这就是安装和使用Jupyter Notebook的一个最简单的示例

play11:21

我们再加一个markdown和刚才的演示是一样的

play11:25

我们来试一下title1

play11:28

title2

play11:30

然后我们再加几个list

play11:32

列表我们叫item1

play11:35

叫item2

play11:37

play11:37

我们可以看一下

play11:38

这个如果我们点

play11:41

这好像暂时没有办法执行

play11:42

那么我们在下面加一行code

play11:49

等一下这个怎么变成

play11:51

点这个箭头

play11:53

点箭头好了之后

play11:54

它就会渲染出来

play11:57

它是一个已经用markdown来编辑好的一个文本了

play12:03

play12:05

接下来我们来安装longchain

play12:06

安装longchain之前我们先看一下我们的

play12:09

Python的版本是否正确

play12:12

这里Python版本3.10.12

play12:13

好的

play12:14

那么接下来用pypinstall longchain

play12:21

play12:21

安装过程会需要一段时间

play12:23

我们这里就暂时先跳过好安装过程会需要一段时间我们这里就暂时先跳过

play12:27

好安装好了

play12:29

安装好了LangChain之后呢

play12:30

好这就好了

play12:32

安装好LangChain之后呢

play12:33

我们就可以进行下一步的学习了

play12:35

好下面我们来带领大家

play12:38

建立我们的第一个大型语言模型的模块

play12:41

也就是一个LM模块

play12:43

要运行这个模块呢首先我们需要的资源就是一个LLM也就是一个大型语言模型的模块也就是一个LM模块要运行这个模块

play12:45

首先我们需要的资源就是一个LLM

play12:48

也就是一个大型语言模型

play12:50

得到这个模型的途径

play12:52

我们目前有两种方法

play12:53

第一个就是你在你的本地

play12:54

运行一个开源的LM模型

play12:57

当然如果你有一个

play12:58

你自己的必然的LM模型的话

play13:01

那也可以

play13:02

但是我们一般是使用开源的LM模型

play13:07

但是这样有一个问题

play13:08

就是一般的性能比较好的LM模型

play13:12

它需要耗费大量的GPU资源

play13:15

像我们家里面一般的打游戏用的显卡

play13:20

在大多数情况下是不具备这样的算力

play13:23

去运行这样一个模型的

play13:25

当然如果你家里如果有一块A100的话就当我没说

play13:29

所以我们推荐大家使用第二种方法

play13:32

就是去找我们的第三方的这样的模型提供商

play13:36

他们一般都会有自己的API发布出来

play13:39

这样的话像我们普通用户就可以使用他们的API

play13:44

从而去访问到他们模型

play13:47

利用到他们模型的一些功能

play13:48

像国内这样的API的提供商有百度

play13:53

他们的模型是文心Earning

play13:55

以及阿里他们的模型通一千问

play13:57

像国外有一些像比如Replicate和OpenAI

play14:02

也就是大家所熟知的GPT的公司

play14:05

他们也提供了自己的API

play14:07

在这里各位学员可以选择自己喜欢使用的提供商

play14:13

然后拿到他们的API

play14:15

然后和我们的Luncheon进行一个交互

play14:21

好 我们这里第一个简单的应用

play14:23

就是创造一个功能非常简单的LM模块

play14:28

一个LM模块在Longchain里面

play14:31

它的最基本的功能就是根据你所说的文本

play14:34

来补全生成一个新的文本

play14:36

需要用的方法名称叫predict

play14:39

中文的意思是预测

play14:41

我们来举一个例子

play14:43

比方说我们想让他给我们一个很土

play14:46

但是听起来好养活的男孩的小名

play14:48

那么我们把这个你可以把它列为指令

play14:52

或者就一个简单的字符串

play14:54

把它发送给这个LM模块

play14:58

然后让他来给我们预测一下

play15:00

或者是为我们补全一下

play15:01

然后他会得到一个结果

play15:03

我这里只是举一个例子

play15:04

不是所有的模型以及就算是同一个模型或者是为我们补全一下然后它会得到一个结果我这里只是举一个例子

play15:08

不是所有的模型以及就算是同一个模型你在调用它不同的

play15:11

就是每次调用它

play15:12

它给你的结果可能都不会是一样的

play15:15

就是因为一般LM模块它都会有一个temperature

play15:19

也就是你可以把它理解为

play15:22

它的结果是否每次都会一样

play15:24

就是可以有结果的发散度

play15:26

如果它发散度是0的话

play15:29

那么它的结果就是永远给你都是一样的

play15:30

如果它发散度不是0的话

play15:32

那么它可能会随机给你一些它认为比较好的结果

play15:36

现在我们来举一个例子

play15:38

play15:44

在这里我演示的是使用OpenAPI这样一个

play15:47

他们的一个API的提供商

play15:49

然后对于他们来说

play15:51

我需要提供的就是一个API的一个密钥

play15:55

这里可以从他们的官网拿到

play15:57

拿到了之后

play15:58

我把它放到我的环境面量文件里

play15:59

然后加载一下环境面量

play16:01

加载好了环境面量之后

play16:03

我们通过这两句代码

play16:05

可以生成一个非常简单的

play16:08

LMM模型

play16:09

LMM模块的一个对象

play16:13

生成这个对象之后

play16:14

我们先运行一下

play16:15

好 运行好了

play16:17

这个对象生成好之后

play16:18

我们可以来

play16:20

让他告诉我们一个

play16:23

一个男孩小名的一个结果

play16:27

看一下他会给我们一个什么结果好

play16:28

他给我们了一个完整的回答

play16:30

比如小福田小田家

play16:32

这看起来像是日本人的名字

play16:34

我们再让他试一次

play16:37

毛毛

play16:38

好的

play16:38

这个有点像我们中国人的名字

play16:40

然后我们可以看到

play16:42

你每次运行它

play16:43

它给你的结果都不太一样

play16:44

对吧

play16:44

这是因为默认它的temperature是0.7

play16:49

这个0.7值大家可以在它的源码中看到

play16:52

所以说如果你只要不告诉它你想要什么样的temperature

play16:56

那么它给你的temperature的话就是0.7

play16:58

那么它每次给你的答案就会不一样

play16:59

那么如果我们想让它每次给答案一样

play17:02

我们需要去告诉它说我们temperature想要0

play17:06

我想每次答案都一样的

play17:07

不要给我发散思维了

play17:08

那么不要给我发散思维

play17:09

每次给我答案都是一样的

play17:10

那么看看他给我们啥

play17:11

小农

play17:13

这个名字有一点不知道是哪个国家的感觉

play17:16

但他最后给了汉语拼音

play17:17

那应该是我们中国人的名字吧

play17:19

然后我再让他跑一次

play17:22

还是小农

play17:23

我再跑一次

play17:24

他还是小农大家可以跑一次它还是小农

play17:25

大家可以看到我们只要把temperature设成0

play17:28

那么我们每次得到的结果都是一样的

play17:32

好的

play17:32

这就是我们

play17:35

Lunchein里面的一个非常基础的模块

play17:37

叫做L1M模块

play17:38

大家随着继续的学习可以发现

play17:41

Lunchein里面很多其他的模块

play17:43

都是以这样一个基础模块作为核心

play17:47

在它上面搭建起来的其他的一些应用

play17:50

这里比较典型的一个就是我们接下来将要讲到的一个

play17:54

叫聊天模块

play17:54

这聊天模块有什么用呢

play17:57

简单的说就是它可以以聊天对话的形式来续写一段对话

play18:10

它和我们的之前讲到的LM模块是类似的

play18:13

那是因为它的底层是以LM模块作为基础

play18:19

然后在这里我们会引用三个它的消息类第一个消息类叫AI message

play18:22

AI message就是说我们模拟出来

play18:26

这个人工智能它的一些回复

play18:28

它的一些回复的消息

play18:30

这么叫做AI message

play18:31

然后是Human message

play18:33

Human message就是我们作为用户

play18:35

跟AI对话的过程中提供的一些消息和文本

play18:39

第三个是System message

play18:41

System message大家可以把它理解为

play18:44

在一段对话开始之前的一个预设

play18:47

比如说我们在system message里面可以提供

play18:50

我们想要AI来模拟一家烧烤店的店员

play18:55

那么我们就把这样一个环境的设定

play18:57

可以在system message里面告诉AI

play19:00

那么接下来AI的一些回答

play19:01

就会尽量的像这样一个烧烤店店员的这样一个设定去靠拢

play19:07

就非常有意思

play19:07

然后聊天模块它的方法调用

play19:10

其实大部分和我们之前讲的模块是类似的

play19:15

我们一会会在例子中给大家演示

play19:17

好我们来直接进入我们的例子

play19:20

好大家看到在这里

play19:25

我引入了一个Chat OpenAI的这样一个模块

play19:29

然后它的生成方式

play19:30

和刚才的OpenAI的生成方式是类似的

play19:33

直接生成了之后

play19:36

初始化之后

play19:36

我们的调用给我一个横图

play19:38

等一下好像会有小男孩小明

play19:39

这个调用方式和我们上面的调用方式是

play19:42

几乎是一样的

play19:44

play19:44

我看它给我们什么结果

play19:47

小名小杂草

play19:49

很有意思

play19:51

然后它还有一种调用方式

play19:54

就是通过一段对话的形式来调用

play19:59

比方说我们在这里生成了一个messages

play20:01

就是一系列对话

play20:03

它是一个列表

play20:04

列表里面的元素是一个human message

play20:06

就是我们刚才讲过的一个

play20:07

作为人类语言的

play20:09

这种用户语言的一个消息的组件

play20:14

我们还是用同样的问题

play20:15

我们来给它传过去

play20:17

注意这我们叫做是predictive messages

play20:21

play20:21

它返回的是一个AI message类

play20:23

然后AI message类里面的content就是内容

play20:26

是彩虹独角兽魔法工坊

play20:28

就是说它实际上是一个包裹在一段字符串外面的

play20:36

叫做AI message

play20:37

就是说这个消息是由AI回复的

play20:40

是这个意思

play20:41

但是同样的我们也可以用之前的LM模块

play20:46

来做这样一个predict message

play20:50

你看它得到的也是一个AI message

play20:52

它也可以通过对话的形式来为我们预测下一条

play20:58

来自AI人工智能它给出的回复是什么样子的

play21:02

看到这里大家可能会问

play21:04

这两个功能感觉是一样的

play21:06

就是chat model这个聊天模块和LM模块

play21:09

就是大型媒体模型模块

play21:11

它们俩功能好像是一模一样的

play21:12

调用的方法是一模一样的

play21:14

返回结果也是一模一样的

play21:15

目前我们来看好像是这样的

play21:18

但是随着我们继续的学习

play21:21

大家后面用到的一些特殊的需求的时候

play21:26

就会发现有的时候我们用LM某块是不足以

play21:30

来实现我们的一些需求

play21:32

只有Chat model或者说

play21:34

不能说只有Chat model吧

play21:36

只能说Chat model会更方便的来满足我们的需求

play21:39

尤其是在我们设计代理人

play21:42

后面会讲到代理人

play21:43

然后涉及到那个对话的缓存

play21:47

然后涉及到调用聊天历史记录之类的

play21:50

这些功能的时候

play21:51

会发现ChatterModel是一个更好的选择

play21:53

相对于大型语言模型基础模块来说

play22:02

接下来我们来讲第二个应用叫链式结构

play22:06

咱们这个LineChain里面的chain

play22:08

实际上就是一个链式结构

play22:11

什么叫链式结构

play22:13

我们可以把它理解为

play22:15

我们把一些功能不同的模块

play22:19

按照某种需求把它们串联起来

play22:21

变成一条锁链的形式

play22:23

那么这一条锁链

play22:24

它本身就已经变成了一个应用这条锁链的形式那么这一条锁链它本身就已经变成了一个应用

play22:26

这条锁链可能会有一个输出是一个字符串

play22:30

然后一个输入也是一个字符串

play22:33

Longchain它整体来讲的话其实就是这个概念

play22:38

那么为什么需要链式结构呢

play22:39

首先我们刚才说的是需要方便的连接多个LM模块

play22:43

但它不一定是LM模块

play22:45

它可以是各种不同的模块

play22:47

LM模块只是我们刚才讲到的一个最基础的模块

play22:52

链式结构可以连接的东西有很多

play22:54

LM模块是一个

play22:56

当然它可以连接其他的链式结构

play22:58

也就是我们把各种不同的链式结构连接起来

play23:01

然后让它们功能更加丰富

play23:03

这个会在我们后面的学习中给大家做演示

play23:06

第二个我们需要强调的就是如何避免去重复定义功能相似的LM模块

play23:12

什么叫功能相似的LM模块呢

play23:15

就是说比如说我们有一个模块是给小男孩起名的

play23:19

那么我们可能还会有另外一个模块是给小女孩起名的

play23:22

那么它们的功能就比较类似都是起名

play23:25

唯一不同的就是我们要起名这个对象

play23:28

它可以是小女孩

play23:29

可以是小男孩

play23:30

可以是小狗

play23:30

小猫

play23:31

小狮子等等

play23:32

我们又不想去定义

play23:35

我们又不想为每一个对象去定义一个这样的模块

play23:39

那么我们可以需要用到提示模板

play23:42

也就是prompt template这样一个模块来帮助我们就是说会提到提示模板也就是prompt template这样一个某块来帮助我们

play23:46

就是说会提供一个模板

play23:47

比如说我们会有一个起名的模板

play23:50

那么起名的模板就是说帮我起一个

play23:53

给谁的小名

play23:55

那么这个谁就是我们后面可以把它替换成男孩

play23:58

女孩小狗小猫等等

play24:00

所以它是一个模板

play24:02

play24:02

接下来我们来看一下它具体是怎么样一个流程

play24:06

看到这一段代码就是从Langstone中去引入我们的

play24:12

这个prompt template

play24:13

就是我们的提示模板

play24:14

然后我们新建了一个prompt

play24:16

也就是提示

play24:18

这个提示里面的模板的形式是这样的一个形式

play24:22

给我一个横图

play24:23

大家听见横上我的花口号对象小名

play24:26

这里面对象就是我们日后会替换成其他的

play24:29

比如说小狗小猫小男孩小女孩等等等等的不同的对象

play24:32

那么这个模板就这样创建好了

play24:35

然后这个模板创建好之后

play24:37

我们怎么样把对象给输入进去呢

play24:39

我们可以看到这里

play24:40

对象等于小狗

play24:41

就是说这个时候这个模板就变成了

play24:43

给我一个横土但是听见横响呼的小狗的小名它就是说这个时候这个模板就变成了给我一个很土

play24:45

但是听起来欢呼的小狗的小名

play24:46

它就不再是一个模板

play24:47

而是一个完整的提示语

play24:50

对吧

play24:51

我们可以用其他的对象

play24:52

比如小狗小猫

play24:53

然后我们可以在代码里给大家演示

play24:57

play24:58

这就是我们的

play24:59

这部分代码是我们跟刚才的演示代码是类似的

play25:03

都是要首先创建好一个新的某块

play25:07

我们来运行一下

play25:08

好 运行好之后

play25:09

这是我们刚才PPT里面那段代码

play25:12

我们也来运行一下

play25:14

它输出的是给我一个横图

play25:15

但是听起来好像活的小狗的小名

play25:18

有看到它的format实际上就是说

play25:20

给你一个提供你对象的机会

play25:23

然后你把完整的提示语打印出来

play25:26

那么打印出来这是这样一个提示语

play25:29

好 我们可以试试把它改成别的

play25:31

比如说小女孩

play25:34

出来就是小女孩小明

play25:38

好 然后这里这部分代码就是我们接下来要使用的

play25:48

这个chain就是我们刚才所说的链式结构

play25:51

这个链式结构它的构造模块有两个

play25:56

一个是一开始的LM模块

play25:57

这个我们说的是LangChain里面最基础的功能的模块

play26:01

第二个模块就是刚才的提示模板

play26:04

这个提示模板把它放进来之后

play26:06

我们就可以直接使用LMchain

play26:09

我们先回到PPT给大家做一个概念上的讲解

play26:13

这是我们刚才的例子

play26:16

我们看到我们现在是要构造一个

play26:20

LMchain的这样一个对象

play26:22

这个对象有两个组成要件

play26:23

一个是prompt

play26:24

一个是LM就是�这样一个对象这个对象有两个组成要件一个是Prompt一个是LM

play26:26

就是语言模型

play26:30

它的Chain我们创建好之后

play26:32

怎么样去运行Chain

play26:33

通过调用它的Run的方法

play26:35

然后我们看到Run的方法里面

play26:36

我们输入了一个小狗

play26:39

我们为什么可以直接输入小狗

play26:41

因为它的Chain

play26:43

它里面有一个Prompt

play26:44

就是我们提示模板

play26:45

这个模板是接收一个对象对吧

play26:47

接收一个对象

play26:48

那么这个chain在运行的时候

play26:50

我们只提供了这一个参数

play26:52

那么这个参数就会作为

play26:54

我们将要给提示模板的对象

play26:57

好 比如我们把小狗输入进去

play26:59

提示模板会把它变成一个完整的提示

play27:01

就给我一个很土

play27:02

但听起来很好养活的小狗的小名

play27:06

然后再把这个完整的提示传给它里面的语言模型

play27:09

然后语言模型会给你一个结果

play27:10

这里我们就指了一个以大黄为一个例子

play27:15

它不一定是说大黄

play27:16

我们一会可以看一下

play27:18

好 我们来首先创造这个chain

play27:22

然后我们让它跑一下

play27:24

然后我们现在输入的是小猫

play27:26

也就是说我们希望它给我一个很土

play27:28

但是听起来好养活的小猫的小名

play27:31

好它给我们的是小拉拉

play27:32

我不知道这个名字是否是一个很土

play27:36

但是好养活的小猫的小名

play27:37

但是人工智能似乎是这样认为的

play27:40

我们可以让它再给另外一个小咪

play27:42

这个是比较普遍的小猫的名字

play27:42

我们可以让他再给另外一个小咪这个是比较普遍的小猫的名字

play27:45

我们可以把它换成比如说狮子

play27:50

来试一下

play27:53

换成狮子

play27:53

它会给什么

play27:54

小豆豉

play27:56

play27:56

就看到我们基本上确定我们换的这个东西是已经起作用了

play28:01

我们再看一下另外一个

play28:03

农夫山泉

play28:04

这段掐掉了

play28:11

play28:11

让我们继续下一个简单应用

play28:13

代理人

play28:14

为什么我们需要代理人

play28:16

它和我们之前讲过的

play28:19

链式的模块其实是不太一样的

play28:23

它的存在的意义在于去解决一些链式模块

play28:26

它难以独立处理的复杂问题

play28:28

比如说解决一些复杂的数学计算

play28:32

或者是去访问互联网得到一些最新的信息

play28:37

我们知道大型语言模型它本身是不联网的

play28:41

或者说大部分是不联网的

play28:43

也就是说它里面的信息

play28:46

它数据是有限的

play28:49

我们要怎么样让我们的Lunchain的应用

play28:54

可以去得到最新的结果

play28:57

比如说最近发生的一些事件

play28:58

然后有一些它现有数据里面不存在的信息或者数据

play29:04

那么这时候需要通过访问互联网

play29:06

而Luncheon解决这个问题的办法就是

play29:08

提供了代理人这样一个模块

play29:11

这个代理人这样的模块

play29:13

它可以运用众多的工具

play29:15

这个我们说的

play29:16

来做来达到它想要达到的目标

play29:20

代理人的本质

play29:22

它实际上是对于我们给定他的一个任务

play29:25

他运用他内部的语言模型,也就是我们的LLM模块

play29:30

来决定完成这个任务所需要的行为以及实施这些行为的顺序

play29:33

也就是说,它实际上是有一个类似于人类的思考的一个过程

play29:38

他思考的方式呢,就是和我们一样

play29:42

就是说我要实现这样一个目标我需要有哪些步骤

play29:47

以及我应该以什么样的顺序去完成这个步骤

play29:49

在完成步骤的过程中

play29:51

我能否用我现有的工具来实现我的目标

play29:55

比方说如果我需要访问互联网

play29:56

那我有没有访问互联网的工具

play29:58

比如说我要做数学计算

play30:00

那么我有没有可以做数学计算的工具

play30:02

如果有的话他们就会选择使用工具

play30:06

然后来使用工具之后

play30:08

他会处理使用工具得到的结果

play30:10

然后开始进行下一个步骤的处理

play30:15

就以此类推

play30:16

然后最后实现最终的目标

play30:18

然后把你给他的任务给完成了

play30:20

这就是代理人的整个的一个工作流程

play30:24

好 我们先做一个简单的例子

play30:33

第二步就是让代理人来使用一些工具

play30:37

在这里我们让代理人使用LM Math这样一个

play30:41

可以帮助他进行数学计算的这样一个工具

play30:44

使用的方式就是这样的

play30:45

一会我们会在代码示例中给大家详细讲解

play30:48

第三步就是初始化代理人

play30:51

我们可以看到在初始化代理人的过程中

play30:53

我们提供了一些设置参数

play30:54

首先是他的工具集有哪些工具

play30:57

就是我们上一步已经给他定义好的工具

play30:59

然后是我们提前定义好的一个语言模型

play31:02

对上一个传进去了对吧

play31:04

然后他的agent就是他代理人的类型

play31:08

我们这里选用的是ZeroShot React Description

play31:11

这个具体的代理人模型

play31:13

我们会在后面的模块拆解的过程中

play31:17

给大家详细讲解

play31:18

在这里我们就先暂时不去关心它是什么意思

play31:21

然后这个repose等于true

play31:23

就是说你可以去看到代理人他是怎么样

play31:28

一步一步的去把他的问题给处理好的

play31:32

好下一步

play31:35

我们可以看到这里只要通过简单的run

play31:37

就可以让代理人来解决我们给他提供一个问题

play31:42

好现在我们看一下代码是什么样的

play31:41

我们就会遇到同一个问题

play31:45

好 现在我们看一下代码是什么样的

play31:52

好 一样的 我们要先加载一下我们的环境面量然后在初始化我们的原模型对象

play31:56

好 初始化之后我们需要加载我们的数据

play31:59

加载我们的工具

play32:00

这个工具是LMS

play32:02

它是一个专门用来做数学计算的

play32:04

这样一个代理人工具是LM Math它是一个专门用来做数学计算的这样一个代理人工具

play32:08

我们这里看到工具加载好之后

play32:11

我们来用它来初始化代理人

play32:14

好 初始化代理人好之后

play32:15

我们这里稍微停一下

play32:20

为什么呢

play32:20

因为有人可能会问了

play32:22

LM应该也可以处理这样的一个数学计算的问题

play32:26

对吧

play32:27

就3.5次方是多少

play32:29

理论上是的

play32:30

但是我们知道LLM它对于像这种数学计算来说

play32:37

简单的数学计算它应该是它是没问题的

play32:39

但是当你涉及到这种3.5次方是多少

play32:42

这样的数学计算的时候

play32:44

它给出的答案就往往是比较匪夷所思的

play32:47

我们可以先试一下

play32:50

它给出的25的3.5次方是等于这么大一个数字

play32:54

我觉得这个数字应该是不太准确的

play32:57

大家可以用计算机验证一下

play32:59

下面我们用代理人来看一下

play33:02

他对于这个问题的答案是什么样子的

play33:11

好 下面已经出来了结果我们看到这些有这样的输出

play33:14

实际上就是因为我们在上面出示代理人的时候

play33:17

给他的verbose设置了true

play33:18

也就是说他会打印出来他的每一步的思考过程

play33:22

我可以看到这里他说

play33:23

I need to use the calculator to solve this

play33:25

我需要用计算器来解决这个问题

play33:27

他用计算器解决这个问题的话

play33:29

他选择的action是calculator

play33:30

就是计算器

play33:31

我们已经给他提供了LM Math这样一个tool

play33:33

就是计算器的工具

play33:35

他就可以使用

play33:35

使用好之后他得到的答案是这么一个答案

play33:38

然后他的想法是

play33:40

我已经有了这个答案

play33:41

然后最后答案是这个

play33:43

他把答案告诉你是这个

play33:44

我们可以拿计算器算一下这个答案然后最后答案是这个他把答案告诉那里是这个

play33:45

我们可以拿计算器算一下

play33:46

这个答案是准确的

play33:48

play33:49

这就是代理人和基本的语言模型

play33:53

在处理数学问题上它的差距

play33:55

我们可以看到代理人给出了非常准确的答案

play33:57

而我们的最基础的语言模型

play33:59

他就是基本上是胡乱说的一通

play34:02

基本上是胡乱说的一通

play34:11

好 我们来看下一个简单应用这个应用是真的比较简单

play34:14

它就叫聊天记录

play34:15

英文是Conversation Chain

play34:17

它实际上也是一个Chain

play34:19

但是它着重关注的是对话

play34:22

它的运行方式也比较简单

play34:24

它只需要提供一个语言模型模块就可以了

play34:28

然后我们通过RUN来调用它

play34:31

在这里我们先说了一句你好呀

play34:34

然后系统会回复你好今天过得如何

play34:37

然后你再说挺好的你呢

play34:39

系统会说我过得也棒极了

play34:41

我们可以看到它实际上是通过不停地调用Rrun这个命令来实现一个你和人工智能对话的

play34:48

这样一种形式

play34:48

就类似于chat GPT的感觉

play34:51

下面我们来看一下代码里面的具体例子

play34:56

这段代码一样的

play34:57

我们先加载环境变量

play34:59

然后我们来初始化一个语言模型对象

play35:02

然后我们再运行一下

play35:06

conversation chain的这样一个初始化

play35:11

以及调用run并且对他说你好呀

play35:15

我们看到这里面有很多的输出

play35:17

这个输出是因为我们web browser也是true

play35:20

然后我们看到他说human就是人类就是咱们

play35:23

我们说的是你好呀

play35:24

然后AI回复的是你好

play35:26

很高兴认识你

play35:27

我是一个人工智能可以回答你的问题

play35:28

你有什么问题可以问我

play35:29

目前来看好像和我们之前的LM语言模型

play35:35

用法类似

play35:37

但是现在我们说告诉他

play35:39

我今天领养一只小猫

play35:41

然后他会说那真是太棒了

play35:45

你能告诉我小猫的名字吗

play35:47

然后我们来说

play35:50

我暂时还没有有什么好的建议吗

play35:58

注意看这句里面我们并没有提到

play36:00

任何小猫或者名字相关的内容

play36:02

我们只是说有什么好的建议

play36:04

我们来告诉他

play36:07

看AI会如何回复我们

play36:09

他说我想取这名字很大的创意

play36:10

考虑和你个性相符的名字

play36:13

他给出的回答是

play36:15

关于如何给小猫取名字这样一件事情

play36:18

而注意我们在这里是并没有提到

play36:19

任何关于小猫和取名字的有关内容

play36:22

这是因为Conversation Chain

play36:24

它内部有关于整个对话记录的这样一个

play36:29

聊天记录这样一个工具

play36:32

它其实在内部有一个cache一个缓存

play36:34

把我们的对话AI回答了什么

play36:36

人类问了什么

play36:37

所有的内容全部都记下来

play36:39

所以说当它在处理这个问题的时候

play36:44

它实际上是有上下文的

play36:45

它有上下文的话

play36:46

就可以给出一个符合上下文的回答

play36:49

你看这里它其实把上下文都已经打出来了

play36:52

所以这就是对话模型的一个简单的应用

play37:02

好的 接下来我们和大家一起来阅读一下Lunchain的文档

play37:06

首先我们想看的是Lunchain的入门教程

play37:09

点开这个链接之后

play37:10

我们会进入到Lunchain的入门教程

play37:13

也就是Quick Start这个界面

play37:15

在Quick Start中我们看到它实际上是给大家介绍

play37:19

如何去搭建这个环境

play37:20

然后如何去搭建一个简单的应用

play37:23

然后讲解了什么是大型语言模型

play37:25

它里面的一个基础的模块

play37:28

然后我们看到它的整个流程

play37:30

和我们之前的课程讲解的内容是差不多的

play37:34

然后这部分需要大家有一定的英文阅读的能力

play37:39

当然也可以通过翻译软件来阅读文档

play37:44

我觉得阅读这些文档其实还是挺有用的

play37:45

对于大家掌握 Longchain开发来讲的话

play37:50

文档其实是大家最需要关注的一个东西

play37:55

然后它的集成组件

play37:57

我们可以看到这个链接

play37:58

这个链接点进去之后

play37:59

我们会到它的集成组件这里

play38:02

这里我主要想说的是它的大型语言模型的集成组件

play38:05

我们在左边的菜单中可以看到

play38:08

它其实会支持很多的大型语言模型

play38:11

这里面有一些开源的

play38:13

比如说GBT for all

play38:16

然后一些HuggingFace上能储存到的一些模型

play38:20

大家这里也可以直接用

play38:22

然后包括Llama

play38:23

包括OpenAI包括OpenAI

play38:25

包括OpenLIM这些模型

play38:27

大家都可以使用

play38:29

这里有replicate

play38:30

也就是说你只要在这里看到了integration里面有的东西

play38:34

然后你又有模型的

play38:36

比如说API的密钥或者是其他的东西

play38:42

或者说你有自己的模型

play38:44

甚至也可以在这里找到的话

play38:46

那么Luncheon会为你提供一个非常方便的

play38:50

和这些模型交互的这样一个工具

play38:52

比较有意思的一点就是我们在这里看到

play38:54

它还有来自阿里巴巴达摩院的

play38:58

同意签问这样一个集成组件

play39:01

同样的你需要同意签问的API Key

play39:05

然后有了这个之后

play39:06

你就可以和咱们阿里的同意签问

play39:09

进行一个简单的交流

play39:14

再一个就是我们的API文档

play39:16

API文档我们点去看一下

play39:19

你看到它实际上是一个非常有利于

play39:22

我们在写代码的时候

play39:24

对于一个新的类

play39:26

不知道该怎么用

play39:28

对于新的工具不知道它有哪些功能的时候

play39:30

我们又不想去看原代码

play39:31

那么看API文档是一个非常有用的工具

play39:36

比方说我们刚才在例子中用到的

play39:39

Conversation Chain

play39:40

我们不知道它具体有哪些功能

play39:41

那么可以在这边搜索Conversation Chain

play39:44

然后就看到它给我们索conversation chain

play39:46

然后就看到它给我们找到conversation chain相关的一些文档

play39:49

我们点进去

play39:51

OK

play39:52

所以它这里就是一个关于这个类别叫

play39:54

conversation chain

play39:55

它具体的一些包括事例

play39:58

包括它在初始化的时候需要提供哪些东西

play40:01

然后它的一些具体的功能

play40:07

包括它的一些方法名以及这些返回参数

play40:09

返回之类型什么的都非常的清晰

play40:11

所以这是个非常有助于我们在写

play40:15

LongChain相关代码时候用到的工具

play40:16

另外一个我想要提的比较有意思的点是

play40:18

它还支持百度文心

play40:19

这个链接点开之后

play40:21

我们会到它的一个百度文心的一个界面

play40:26

就这儿

play40:28

但这里和我们之前看的文档其实是两个不一样的文档

play40:32

大家注意到这个文档这边写Python docs

play40:37

也就是说这个文档实际上它不是Python docs

play40:40

也就是说这个文档是Longchain的JavaScript版本的文档

play40:46

大家看到这边全部都是JavaScript的语法

play40:49

也就是说Longchain实际上它有两个项目在并行开发

play40:52

一个是Python项目 一个是JavaScript项目

play40:55

我们的系列课程会以Python项目为主

play40:58

不会涉及到JavaScript项目的一些指导

play41:02

有兴趣的同学可以去看看JavaScript

play41:06

它的那个Python是如何使用的

play41:11

好 我们接着看

play41:13

Langshan文档它最重要的部分就是它的这部分分类文档

play41:17

所谓分类文档就是它把Langshan的核心模块分成了好几个部分

play41:22

然后每个部分它都有详细的示例来给你讲解

play41:26

当然我们这堂课也会在第三章

play41:29

跟大家进行模块的拆解

play41:32

然后把里面的具体内容

play41:34

重要的内容跟大家手把手的学习一下

play41:40

当然Longchain的文档它也是有一定的局限性的

play41:45

首先Longchain的开发速度非常的快

play41:48

文档的内容经常是跟不上

play41:50

也就是说Luncheon一些新功能

play41:52

可能你需要去看它的release log

play41:54

就是它的发那个更新的日志

play41:58

然后它的文档的内容不一定在更新日志里有

play42:02

所以它文档经常是之后

play42:04

再一个就是文档结构的逻辑关系不是特别清晰

play42:07

需要跳着看

play42:08

我觉得这个问题其实比较严重

play42:11

因为LangQian里面的各个模块之间的关系

play42:15

其实是千丝万缕的

play42:16

它很难有一个层层递进的这样逻辑关系让你去学习

play42:21

所以说大家在看这个LangQian的文档的时候

play42:24

可能需要做笔记然后联系上下文

play42:29

才能知道它具体讲的是什么东西

play42:31

第三点就是文档里面有些重复出现的失利

play42:34

影响阅读效率

play42:35

这和第四点一样

play42:37

文档里面经常会有失利的新闻消失很不方便

play42:39

就这两点让我非常的头疼

play42:42

首先我们准备视频的时候

play42:44

有很多之前我们学习Longain在教程里看到过的实例

play42:49

我现在在文档里找不到

play42:51

这个就非常让人头痛

play42:53

所以建议大家如果有能力的话

play42:56

还是可以去看它的原代码

play42:58

毕竟原代码比文档还是要清晰清楚的多

play43:02

大家把文档作为一个学习的参考资料

play43:05

正是因为Luncheon的文档具有这些局限性

play43:08

在很多时候我们在开发过程中

play43:10

需要去阅读Luncheon的原代码

play43:13

才能解决我们想要的解决的问题

play43:17

那么阅读Luncheon的原代码

play43:18

我们有两种方式

play43:19

第一种就是直接去GitHub

play43:21

也就是它的官方的代码库去看

play43:26

打开Github

play43:30

OK

play43:33

好像我的链接需要更新一下我们可以看在这里面

play43:36

大家可以去找自己想要找的任何的代码

play43:40

Python原码

play43:41

光线当前原码全部在这

play43:43

这种方式是我不太建议的

play43:46

因为你可能会漫无目的去寻找

play43:48

倒不如用我们之前提到的API文档

play43:51

可能还来得快一些

play43:52

然后第二种方式就是在VS Code中

play43:55

利用代码跳转功能来查看它的原代码

play43:58

这里我们给大家举一个例子

play43:59

以我们之前用到的代理人的这段代码为例

play44:06

在这段代码中我们使用了loadtools这个函数

play44:11

然后告诉他我们要用llm math这样一个工具来初始化它

play44:19

那么我在写这段代码时候就有一个问题

play44:22

我怎么知道llm math是一个合适的名字

play44:28

或者说它是一个可以用的名字呢

play44:30

除此之外有没有什么其他的名字呢

play44:32

关于这个问题我在Luncheon的文档中是没有找到答案的

play44:38

所以我就通过VSCode的代码跳转功能

play44:43

如果你是用MacBook的话

play44:45

那么当你按住Command键在点击这个时候

play44:48

你可以跳转到这个函数的定义

play44:50

非常方便

play44:51

那么我先加点到loadtools

play44:53

看他到底在干什么

play44:54

play44:56

我们看到loadtools他接收的是一个字符串的list

play45:03

那么它叫tool names

play45:05

那么看这个tool names

play45:06

它在里面是怎么用的

play45:08

play45:08

在这里是做一个循环

play45:10

然后对于它里面的每个name

play45:12

它先做一个判断

play45:13

是不是等于request

play45:14

是不是等于request all

play45:16

然后再看是不是name是不是在某一个

play45:20

这点里面

play45:22

OK

play45:23

所以我们点开看看这些分别都是什么东西

play45:27

Basic tools

play45:28

好的

play45:29

我们看到它是有很多的字符串到某一个callable的

play45:35

这样一个对象的一个映射

play45:37

那么这里我们没有看到有LLM math

play45:40

所以我们就先往回走

play45:42

那么再看接下来看LLM tools

play45:44

我们在LLM tools里面找到了LLM math所以我们就先往回走那么再看接下来看lm tools

play45:48

我们在lm tools里面找到了lm math

play45:50

加了一个字符串

play45:54

那么对应的我们会有open material API

play45:56

我现在不太知道这个东西干什么的

play46:00

但是我知道这个是我可以使用的另外一个LangTang内置的这样一个工具

play46:03

我通过就使用它的名字把LM Math换成OpenMaterial API

play46:07

我就可以让代理人使用另外一个LangTan自带的工具

play46:12

这个就非常方便

play46:14

像这种知识我在文档里是没有找到的

play46:17

当然如果你能在文档里找到的话那就非常好

play46:20

但是我是通过元码去阅读元码

play46:23

来了解到这样一个知识的

play46:25

所以阅读圆码的重要性也是不容忽视的

play46:29

好 回到我们的PPT

play46:33

这堂课内容已经接近尾声了

play46:36

在课程结束之前

play46:38

我希望大家可以在这堂课之后

play46:44

去阅读一下Luncheon的文档

play46:47

主要是它的教程部分

play46:49

看看作为我们这堂视频课程的一个补充

play46:53

另外我希望大家可以选择性的去阅读文档的

play46:57

关于模块部分的讲解

play46:59

这样会对我们在下一章的课程开始之前

play47:03

有一个心理上的认识

play47:05

然后也做好一个预习

play47:07

play47:08

然后

play47:09

今天的课就到这里

play47:11

谢谢大家

play47:12

也希望大家能够享受

play47:14

Lunchain这门课程的学习

play47:16

play47:16

我们下次再见

Rate This

5.0 / 5 (0 votes)

Related Tags
LongchainPython编程Jupyter Notebook大型语言模型开发教程技术实践硅谷讲师软件工程师交互式编程API集成
Do you need a summary in English?