1
00:00:00,120 --> 00:00:02,360
我再次来到莱迪史密斯只是为了向您展示。

2
00:00:02,360 --> 00:00:08,560
我想我从错误的地方读到 GPT 的最终输出就在这里。

3
00:00:08,560 --> 00:00:11,800
我已向您发送了包含当前美元 GP 汇率的推送通知。

4
00:00:11,800 --> 00:00:16,600
这就是您在底部看到整个迹线的末端的地方。

5
00:00:17,160 --> 00:00:20,480
好的，我们回到本次聊天。

6
00:00:20,480 --> 00:00:22,000
现在让我向您展示一些东西。

7
00:00:22,320 --> 00:00:29,240
尽管这次对话具有令人难以置信的智慧，但我们现在可以说的是，呃，我的名字

8
00:00:29,560 --> 00:00:30,000
埃德。

9
00:00:31,320 --> 00:00:32,200
呃，很高兴认识你，艾德。

10
00:00:32,200 --> 00:00:33,160
今天我能为您提供什么帮助？

11
00:00:33,160 --> 00:00:34,480
我可以说，我叫什么名字？

12
00:00:37,720 --> 00:00:40,400
它说我无权访问您的个人信息。

13
00:00:40,560 --> 00:00:45,640
呃，所以我用这个来向你展示，呃，尽管我们拥有所有这些状态

14
00:00:45,640 --> 00:00:51,160
管理，尽管事实上我们已经建立了这个，这个，嗯，这些减速器和这个聪明的

15
00:00:51,200 --> 00:00:54,080
结构，它没有任何记忆。

16
00:00:54,120 --> 00:00:58,560
它没有能力记住不同的对话。

17
00:00:58,560 --> 00:01:02,520
你可能会想，好吧，我猜你没有在想，因为我已经解释过了，但是

18
00:01:02,520 --> 00:01:04,480
但如果我没有解释的话，你可能会想。

19
00:01:04,480 --> 00:01:05,480
但是，坚持住。

20
00:01:05,680 --> 00:01:06,320
呃，为什么？

21
00:01:06,560 --> 00:01:08,120
呃，我们有所有这些减速器。

22
00:01:08,120 --> 00:01:11,800
我们已经拥有所有这些东西来处理状态并添加状态。

23
00:01:11,840 --> 00:01:15,560
那为什么，为什么不是，为什么它不能自然地记住正在发生的事情呢？

24
00:01:15,560 --> 00:01:17,880
是的，这一切都取决于超级步骤。

25
00:01:18,080 --> 00:01:25,320
关键是每次调用，每次我们调用这个图，它就像一个单独的新鲜调用

26
00:01:25,520 --> 00:01:29,760
并且状态是在任何一次调用中管理和维护的。

27
00:01:29,760 --> 00:01:31,520
这就是它存在的目的。

28
00:01:31,560 --> 00:01:34,960
它的作用是让多个节点并行运行。

29
00:01:35,000 --> 00:01:39,800
你可能会发生各种各样的事情，并且状态将通过整个图表进行管理

30
00:01:39,920 --> 00:01:41,760
以一种可重复的方式。

31
00:01:41,920 --> 00:01:44,400
这就是状态管理部分的权力。

32
00:01:44,680 --> 00:01:48,400
但这对您在单独的超级步骤之间没有帮助。

33
00:01:48,520 --> 00:01:51,960
每个超级步骤都是对图的不同调用。

34
00:01:52,120 --> 00:01:56,760
执行此操作的方法是使用检查点。

35
00:01:56,760 --> 00:01:58,520
这就是添加内存的方法。

36
00:01:58,840 --> 00:02:03,240
好吧，我必须告诉你，我有时对兰德格拉夫有些疑虑。

37
00:02:03,240 --> 00:02:06,960
有时我们必须学习的一些东西是多么重要。

38
00:02:07,320 --> 00:02:14,040
但这确实是一个让我印象非常深刻的案例，当我明白这一点时，这对我来说是一个时刻。

39
00:02:14,040 --> 00:02:19,040
我明白为什么人们如此喜欢这个，我真的很欣赏它的力量。

40
00:02:19,080 --> 00:02:26,200
检查点非常优雅、非常简单，并且可以带来稳健、可重复的流程。

41
00:02:26,200 --> 00:02:27,360
你也会看到这一点。

42
00:02:27,400 --> 00:02:31,000
我想你最终会像我一样印象深刻。

43
00:02:31,560 --> 00:02:36,000
因此，我们首先创建一个名为内存保护程序的新对象。

44
00:02:36,160 --> 00:02:40,600
内存保护程序并不意味着保存内存。

45
00:02:40,600 --> 00:02:46,480
它谈论的是保存到内存中的存储，保存到内存中，而不是保存到磁盘或保存到

46
00:02:46,480 --> 00:02:47,200
数据库。

47
00:02:47,240 --> 00:02:48,160
这有点令人困惑。

48
00:02:48,160 --> 00:02:50,520
这就是 Memory Saver 的含义。

49
00:02:50,520 --> 00:02:52,040
这与我们之前的代码相同。

50
00:02:52,080 --> 00:02:53,160
完全相同的代码。

51
00:02:53,160 --> 00:02:57,040
我放入了打印语句，以便我们可以看到它在做什么以及其他情况。

52
00:02:57,040 --> 00:03:03,690
唯一的变化是当我们编译图时，我们传入检查指针等于内存。

53
00:03:03,730 --> 00:03:05,490
我们正在传递该内存对象。

54
00:03:05,490 --> 00:03:06,290
但这是我们的图表。

55
00:03:06,290 --> 00:03:08,370
它看起来一模一样，一模一样。

56
00:03:08,810 --> 00:03:12,770
现在这是我们实际运行代码的地方。

57
00:03:12,930 --> 00:03:18,410
这里有一些东西有点老套，有点做作，但你的想法是

58
00:03:18,410 --> 00:03:20,330
创建这个名为 config 的对象。

59
00:03:20,650 --> 00:03:27,250
它是一本字典，其中一个字段是可配置的，然后您必须在该字段中放入线程 ID 并

60
00:03:27,250 --> 00:03:31,650
线程 ID 并不意味着像技术线程，它意味着像对话线程，例如

61
00:03:31,650 --> 00:03:37,930
它指的是这一点，这条需要连接在一起的记忆线。

62
00:03:37,930 --> 00:03:43,530
这就是您指定的方式，这是内存中的特定分组。

63
00:03:44,010 --> 00:03:48,770
然后，当您调用图表时，您必须传入该配置。

64
00:03:48,890 --> 00:03:53,050
这就是如何确保当您调用图表时，它与正确的关联

65
00:03:53,090 --> 00:03:55,090
内存中的某种插槽。

66
00:03:55,370 --> 00:03:57,130
这就是全部内容。

67
00:03:57,130 --> 00:03:59,850
那么，让我们提出这个问题并打个招呼。

68
00:04:01,650 --> 00:04:02,050
你好。

69
00:04:02,090 --> 00:04:03,010
今天我能为您提供什么帮助？

70
00:04:03,370 --> 00:04:04,170
我的名字是艾德。

71
00:04:06,370 --> 00:04:07,410
很高兴认识你，艾德。

72
00:04:07,450 --> 00:04:08,530
我怎么帮你？

73
00:04:08,930 --> 00:04:09,930
我叫什么名字？

74
00:04:12,490 --> 00:04:13,450
我想它会得到它。

75
00:04:14,330 --> 00:04:15,210
你的名字是艾德。

76
00:04:15,250 --> 00:04:16,450
我该如何进一步帮助您？

77
00:04:16,570 --> 00:04:17,010
哈，哈。

78
00:04:17,410 --> 00:04:22,410
毫不奇怪，您可以在这里看到我提到的打印语句正在打印，

79
00:04:22,570 --> 00:04:23,770
呃，输入。

80
00:04:23,770 --> 00:04:30,210
我们每次都会获得完整的历史记录，这就是全部。

81
00:04:30,250 --> 00:04:37,610
这就是实际的检查点，在每个调用、每个超级步骤之间维护内存。

82
00:04:37,650 --> 00:04:38,770
现在，我知道你在想什么。

83
00:04:38,770 --> 00:04:40,930
你在想，好吧，有什么大不了的？

84
00:04:40,930 --> 00:04:42,490
为什么你对此印象如此深刻？

85
00:04:42,530 --> 00:04:46,650
我的意思是，就像您也可以通过存储该磁盘列表来到达那里一样。

86
00:04:46,650 --> 00:04:51,890
或者我们可以从此处的 Gradio UI 中获取它并将其放入全局链接中并继续播放。

87
00:04:52,010 --> 00:04:54,130
好吧，看看，看看其中的一些东西。

88
00:04:54,250 --> 00:04:57,850
所以你可以将graph称为编译图段。

89
00:04:58,130 --> 00:04:59,250
获取状态。

90
00:04:59,410 --> 00:05:06,490
考虑到配置，我们得到了一个称为状态快照的东西，其中包含

91
00:05:06,570 --> 00:05:10,850
消息，然后是迄今为止对话的完整历史记录。

92
00:05:11,250 --> 00:05:11,410
是的。

93
00:05:11,450 --> 00:05:11,770
好的。

94
00:05:11,810 --> 00:05:14,930
所以它就像一个全局变量，里面有这个。

95
00:05:15,170 --> 00:05:20,610
但您还可以获取更多配置的状态历史记录。

96
00:05:20,810 --> 00:05:28,610
我们现在得到的是时间上的每一步，每一个超级步骤，每次我们调用图表时，完整的，

97
00:05:28,850 --> 00:05:34,770
呃，那一刻的快照，从顶部最近的开始，然后回到过去。

98
00:05:35,490 --> 00:05:37,490
这就是它变得很酷的地方。

99
00:05:37,490 --> 00:05:41,650
它并不是超级复杂，但它绝对是一个很酷的结构。

100
00:05:41,890 --> 00:05:46,930
狼山可以让你回到过去的任何时刻。

101
00:05:46,930 --> 00:05:53,250
当您传递该配置时，您可以传递检查点 ID 来配置可配置的线程 ID

102
00:05:53,250 --> 00:05:57,690
快退到前一时刻，然后通过图表重播该时刻。

103
00:05:57,970 --> 00:06:03,650
呃，这，这给了你基本上做他们所谓的时间旅行的能力。

104
00:06:03,650 --> 00:06:09,010
这是Landgraf的官方名称，真正的意思是能够向后移动，获取快照

105
00:06:09,010 --> 00:06:12,010
在任何时间点并能够从那里重新运行它。

106
00:06:12,250 --> 00:06:18,250
这真的很棒，因为它允许您构建可重复且稳健的系统。

107
00:06:18,290 --> 00:06:23,170
如果出现故障，您可以从任何快照、任何时间点重新启动它。

108
00:06:23,170 --> 00:06:26,890
并且您可以对所发生的一切进行全面跟踪。

109
00:06:27,050 --> 00:06:30,530
是的，它很简单，但很优雅。

110
00:06:30,530 --> 00:06:34,450
这是一个对我来说真正有意义的抽象案例。

111
00:06:34,650 --> 00:06:38,410
呃，而且绝对是我认为非常有价值的东西。

112
00:06:38,450 --> 00:06:43,610
我只是想告诉你，这与 gradio 和 kind 无关

113
00:06:43,610 --> 00:06:44,330
变量。

114
00:06:44,330 --> 00:06:51,450
我可以回来，我可以，我可以在这里重新启动我的 Gradio UI，我可以说，你好。

115
00:06:53,850 --> 00:06:55,890
它又打招呼了，我正想说，我叫什么名字？

116
00:06:55,890 --> 00:06:56,700
但我不需要。

117
00:06:56,740 --> 00:06:59,020
你可以立即看到它有记忆。

118
00:06:59,020 --> 00:07:00,420
它仍然保留着那段记忆。

119
00:07:00,420 --> 00:07:05,980
这与我们一直以来保存在电台聊天 UI 中的信息无关

120
00:07:05,980 --> 00:07:12,220
过去与 gradio 一起使用，而是内存，正在发生的检查点

121
00:07:12,420 --> 00:07:15,860
在这个，呃，这个内存对象里面。

122
00:07:16,860 --> 00:07:23,620
然后我实际上可以回来，如果我重新创建，我可以我可以创建一个全新的内存保护程序

123
00:07:23,620 --> 00:07:31,420
对象并进来，然后我必须用那里的新内存重新重建我的图表

124
00:07:31,420 --> 00:07:33,980
然后重新调出我的聊天界面。

125
00:07:33,980 --> 00:07:37,020
现在如果我在那里打个招呼。

126
00:07:39,260 --> 00:07:40,500
我叫什么名字。

127
00:07:41,780 --> 00:07:43,580
显然它不会知道。

128
00:07:45,140 --> 00:07:50,380
所以这只是解释了通过重新创建一个新的内存对象我们重置了一切。

129
00:07:50,420 --> 00:07:53,140
也就是说，这可以让您很好地了解正在发生的事情。

130
00:07:53,420 --> 00:07:55,300
我叫艾德。

131
00:07:56,620 --> 00:07:57,220
很高兴见到你。

132
00:07:57,420 --> 00:07:58,540
今天我能为您提供什么帮助？

133
00:07:58,980 --> 00:08:00,020
呃，我叫什么名字？

134
00:08:02,380 --> 00:08:04,140
为了证明这一点，你的名字叫艾德。

135
00:08:04,260 --> 00:08:06,500
然后让我在这里再展示一件事。

136
00:08:06,500 --> 00:08:10,020
我们还可以将线程ID更改为2。

137
00:08:10,300 --> 00:08:14,380
让我们重新运行一下，呃，看看这里。

138
00:08:14,940 --> 00:08:15,780
在那里打个招呼。

139
00:08:17,340 --> 00:08:17,580
你好。

140
00:08:17,620 --> 00:08:18,220
我该如何帮助您？

141
00:08:18,220 --> 00:08:19,140
我叫什么名字？

142
00:08:24,060 --> 00:08:27,060
它说它不知道，因为线程是两个。

143
00:08:27,220 --> 00:08:30,020
如果我们现在回到线程就是其中之一。

144
00:08:30,060 --> 00:08:32,220
我知道你明白这一点，但值得一说。

145
00:08:32,500 --> 00:08:32,980
现在。

146
00:08:33,060 --> 00:08:33,660
你好呀。

147
00:08:35,060 --> 00:08:35,620
又好。

148
00:08:36,060 --> 00:08:36,500
哈哈。

149
00:08:37,100 --> 00:08:37,620
就这样。

150
00:08:37,620 --> 00:08:38,140
你看到了吗？

151
00:08:38,180 --> 00:08:40,300
这是一个很好的，优雅的。

152
00:08:40,340 --> 00:08:43,700
它相对轻量且简单，但功能非常强大。

153
00:08:43,900 --> 00:08:46,780
这是一个很好的组合，我可以支持。

154
00:08:46,780 --> 00:08:51,340
当然，您可以进来查看线程一或线程的不同检查点

155
00:08:51,340 --> 00:08:52,500
第二个线程。

156
00:08:52,780 --> 00:08:56,140
呃，使用同样的这个，同样的结构。