Learning and Inference for Hierarchically Split PC中文字幕

WEBVTT
Kind: captions
Language: zh-Hans

00:00:23.850 --> 00:00:27.960
我的名字叫彼得罗夫（Petrov），在那之后我将与我的顾问当当交谈

00:00:27.960 --> 00:00:33.510
时间的目标是要句子和产生解析树

00:00:33.510 --> 00:00:40.110
他们，我们会假设我们有，所以出于很多原因，我想这样做

00:00:40.110 --> 00:00:44.430
无需向您解释，我们假设我们有一堆标记

00:00:44.430 --> 00:00:50.370
例如我们将开始的树库，然后我们将尝试学习

00:00:50.370 --> 00:00:56.640
上下文无关的语法，我将首先讨论如何学习

00:00:56.640 --> 00:01:00.239
语法，然后讲的第二部分将是关于

00:01:00.239 --> 00:01:06.540
有效的推理，因此在设计语法时遇到的问题或挑战

00:01:06.540 --> 00:01:11.490
解析是树库中的类别太粗糙，无法建模

00:01:11.490 --> 00:01:16.010
复杂的基础过程，例如，如果您查看这两个名词短语

00:01:16.010 --> 00:01:19.830
那么我们在句子中有一个处于主语位置，另一个在

00:01:19.830 --> 00:01:24.810
对象位置，它们具有非常不同的分布，因此为了

00:01:24.810 --> 00:01:30.990
设计捕捉这些现象的语法，您需要改进

00:01:30.990 --> 00:01:35.310
观察到的类别，通常这是通过以下方式手动完成的：

00:01:35.310 --> 00:01:40.140
例如，如果您做父母模仿的结构表示形式

00:01:40.140 --> 00:01:45.119
知道这个短语的父词是句子符号，那么

00:01:45.119 --> 00:01:48.570
这不太可能成为主题名词短语，如果名词

00:01:48.570 --> 00:01:53.759
短语在动词短语下，那么可能是另一种宾语

00:01:53.759 --> 00:01:58.229
通过将您传播信息的语法词法化为语法来捕获该信息

00:01:58.229 --> 00:02:06.210
从头到尾从头到尾的形式导致语法大小变大

00:02:06.210 --> 00:02:09.390
更大，您需要复杂的平滑技术来处理

00:02:09.390 --> 00:02:16.920
这项工作的稀疏性，我们会尝试做一些我们认为有不同之处的事情

00:02:16.920 --> 00:02:21.540
K个类别，我们将尝试自动学习这些类别

00:02:21.540 --> 00:02:25.920
类别使用e / m算法将它们聚类成希望

00:02:25.920 --> 00:02:31.440
有意义的类别，我们将从一个

00:02:31.440 --> 00:02:34.740
x-bar语法，我们刚刚在树库中观察到类别，

00:02:34.740 --> 00:02:39.750
我们将继续完善我们的类别

00:02:39.750 --> 00:02:46.590
以分层方式仅在需要时分配复杂性

00:02:46.590 --> 00:02:54.750
在他介绍之后，第一部分将是学习我们想要做的

00:02:54.750 --> 00:02:59.800
好吧，这是我以前的工作

00:02:59.800 --> 00:03:06.040
顾问，当他是斯坦福大学的研究生时，花了很多时间

00:03:06.040 --> 00:03:10.780
首先通过结构注释来找到这些语法。

00:03:10.780 --> 00:03:15.420
父级和同级注释形式的信息，然后手动进行

00:03:15.420 --> 00:03:23.170
做一种e / m型爬坡，他用手将类别划分

00:03:23.170 --> 00:03:27.190
语言上有意义的子类别，并检查这是否对实际有帮助

00:03:27.190 --> 00:03:33.070
用于解析性能，但一段时间后性能开始达到水平

00:03:33.070 --> 00:03:36.430
耗尽，因为他我们开始耗尽创意，这是一个非常乏味的过程

00:03:36.430 --> 00:03:42.880
必须针对每种语言进行重做，以使其无法扩展到解析

00:03:42.880 --> 00:03:49.690
几年后的任何任意语言，因此从幼稚的树开始

00:03:49.690 --> 00:03:54.640
刚好在树库旁边的银行，您最多可以进行86％的解析

00:03:54.640 --> 00:04:02.650
精确度，现在我需要做的是90 91

00:04:02.650 --> 00:04:07.660
几年后，有一些工作在自动诱导这些

00:04:07.660 --> 00:04:14.860
子类别，每个类别分为K个不同的版本，

00:04:14.860 --> 00:04:19.210
算法被用来学习那些类别，但是这个问题

00:04:19.210 --> 00:04:24.940
方法是，因为每个类别在同一时间划分为同一时间

00:04:24.940 --> 00:04:29.680
像这样的二元规则的子类别数

00:04:29.680 --> 00:04:35.560
参数在潜在变量的基数上是三次lis

00:04:35.560 --> 00:04:40.870
因此您很快就达到了适合内存的极限，并且解析非常慢

00:04:40.870 --> 00:04:45.430
所以我们想做的是，但是他们大致达到了相同的性能，

00:04:45.430 --> 00:04:49.540
我们想要做的就是将两者中的最好的事情都用于我们将要实现的目标

00:04:49.540 --> 00:04:53.260
喜欢只在需要的地方分配拆分，但会自动学习

00:04:53.260 --> 00:04:58.210
在哪里分配它们，语法应紧凑并易于捕获

00:04:58.210 --> 00:05:03.370
数据中存在的许多功能以及应做的所有事情

00:05:03.370 --> 00:05:07.920
自动，这样我们就不需要语言学家坐下来并指定

00:05:07.920 --> 00:05:14.700
类别我们将如何做到这一点，我们将从这些零件树开始，

00:05:14.700 --> 00:05:19.060
首先要注意的是，由于括号的整个结构是

00:05:19.060 --> 00:05:23.770
观察到并且已经观察到基本类别，我们不需要运行

00:05:23.770 --> 00:05:28.270
一般的内外算法，但我们可以运行简化版本

00:05:28.270 --> 00:05:35.160
这更像是hmm的前向后退算法，我们不必

00:05:35.160 --> 00:05:39.910
是的，在内部得分的内部向上和向下进行计算是

00:05:39.910 --> 00:05:48.040
受限于与该观察结构一致，因此该算法是

00:05:48.040 --> 00:05:53.440
字数线性，而不是三次，因此如果我们

00:05:53.440 --> 00:05:58.480
为此，我们可以从一个包含大约100个Cyber​​com类别的语法开始，

00:05:58.480 --> 00:06:05.230
然后，当我们每个类别有两个子类别时，我们从64改善为76，

00:06:05.230 --> 00:06:09.970
继续前进，这就是以前的工作原理，

00:06:09.970 --> 00:06:19.120
在某些情况下，我们用尽了内存，也耐心地运行它，所以当我有

00:06:19.120 --> 00:06:25.660
将每个类别划分为16个子州的绩效水平，凯尔特人约占86％，

00:06:25.660 --> 00:06:31.480
我们的贡献将是3个故障良好的分层培训方案

00:06:31.480 --> 00:06:35.680
这使我们可以收敛到更好的局部最优值，因为en是局部的

00:06:35.680 --> 00:06:39.940
方法，可以卡在次优解决方案中

00:06:39.940 --> 00:06:43.150
以自适应方式进行拆分，我们仅在需要时分配拆分

00:06:43.150 --> 00:06:48.460
最后，为防止过度拟合，我们将平滑参数，这将导致

00:06:48.460 --> 00:06:53.790
各种语言的最新解析性能

00:06:53.790 --> 00:07:06.570
是的，请，是的，所以我们最简单的方法是

00:07:06.570 --> 00:07:10.320
只是剥去印度教徒说你可以做治疗解码然后

00:07:10.320 --> 00:07:17.010
只需删除第二部分中的标签，我将在此介绍推理及其

00:07:17.010 --> 00:07:20.610
事实证明，最好将这些注解边缘化

00:07:20.610 --> 00:07:24.330
您无法做到精确，因为它实际上已经完成，但是有一个

00:07:24.330 --> 00:07:29.010
变分方法可以提供良好的性能，但我将在后面讨论

00:07:29.010 --> 00:07:34.530
第二点，是的，我们只是有兴趣恢复

00:07:34.530 --> 00:07:38.940
观察到的类别，它们是我们诱导的隐藏类别，

00:07:38.940 --> 00:07:42.810
帮助我们更好地对此建模，但是尽管他们本身对此并不感兴趣

00:07:42.810 --> 00:07:50.190
语言学上的东西很重要胶束显示还可以，所以实际上

00:07:50.190 --> 00:07:55.350
第一个例子，如果我们看一看类别时会发生什么

00:07:55.350 --> 00:07:59.940
行列式类别这是类别中最可能出现的三个词

00:07:59.940 --> 00:08:03.840
当我们去找一个有四个类别的奶奶时，我们可能最终会

00:08:03.840 --> 00:08:09.390
当我们想学习语法时，这是一个真实的例子

00:08:09.390 --> 00:08:13.830
有八类，她在这个幼稚版本中做的较弱

00:08:13.830 --> 00:08:19.190
从同一个开始，并尝试一次诱导所有类别，但

00:08:19.190 --> 00:08:24.960
更好的是将类别分成两部分，然后

00:08:24.960 --> 00:08:29.160
这些类别中的每一个都将其拆分为面包，并添加了一些随机噪声

00:08:29.160 --> 00:08:35.099
和随机算法从此先前的局部最大值进行初始化

00:08:35.099 --> 00:08:39.180
这样可以最大程度地减少您需要进行的训练迭代次数

00:08:39.180 --> 00:08:44.490
事实证明，就对数而言，您收敛到两个更好的局部最优

00:08:44.490 --> 00:08:49.440
可能性以及解析的准确性，这样做的好处是

00:08:49.440 --> 00:08:56.250
我们了解到的分裂常常以相同的方式出现，所以在这里我们有

00:08:56.250 --> 00:09:02.210
了解到行列式类别实际上既有确定因素，也有

00:09:02.210 --> 00:09:06.420
指示性的，在语言上有点

00:09:06.420 --> 00:09:10.320
朋友，他们倾向于发生在不同的情况下，这种分裂

00:09:10.320 --> 00:09:16.079
总是首先发生，然后再走一步，我们就会知道

00:09:16.079 --> 00:09:21.540
是不确定的和确定的确定者，并且有相当多的当前

00:09:21.540 --> 00:09:26.190
那些怪异的和量化的元素以及那些模式经常是

00:09:26.190 --> 00:09:30.750
观察它，我们学习的类别有时在语言上是明智的

00:09:30.750 --> 00:09:36.449
他们是出于语法动机，有时是语义上的混合

00:09:36.449 --> 00:09:41.160
两者兼而有之，因此，如果我们着眼于解析性能，我们将在开始时看到

00:09:41.160 --> 00:09:45.720
两种方法完全相同，但是已经具有四个子类别，因为

00:09:45.720 --> 00:09:51.029
我们最初是因为位置倾向于趋向于更好的局部最优

00:09:51.029 --> 00:09:56.910
当我们这样做时，解析性能提高了大约百分之一

00:09:56.910 --> 00:10:01.170
分级培训，但无论我们是否这样做

00:10:01.170 --> 00:10:05.610
以分层的方式来划分某些类别的培训对于

00:10:05.610 --> 00:10:11.120
例如，有一个共同的类别，没有必要将它们分开

00:10:11.120 --> 00:10:18.600
可以手动捕获一些琐碎的示例，但可以这样，它们会夸大其词

00:10:18.600 --> 00:10:23.160
只要您不断分裂，对于任何类别最终都会发生

00:10:23.160 --> 00:10:26.430
例如，我们可以再次查看确定攻击，我刚刚放大了

00:10:26.430 --> 00:10:32.070
左边的分支有两个不确定的确定器，然后当我们走时

00:10:32.070 --> 00:10:37.620
当我们再进行一轮拆分时，我们会发现最后得到两个

00:10:37.620 --> 00:10:41.880
一方面我们有句子首字母和句子我做的类别

00:10:41.880 --> 00:10:47.070
区别，但是这两个类别看起来很相似

00:10:47.070 --> 00:10:50.490
说他们是一样的，这显然已经认为我们不是真的

00:10:50.490 --> 00:10:54.930
知道统计数据是什么，所以很难从人类来判断

00:10:54.930 --> 00:10:58.589
视角，我们不想让一个人陷入困境，所以我们想

00:10:58.589 --> 00:11:03.690
有一些方法可以划分类别并评估

00:11:03.690 --> 00:11:11.250
拆分是因为很难说接下来要拆分的类别

00:11:11.250 --> 00:11:15.269
这种方法是将所有内容拆分，然后重新访问并合并回去

00:11:15.269 --> 00:11:19.980
因此，对于这件事，我们可以很好地说这些类别

00:11:19.980 --> 00:11:26.700
并做出很多贡献，我们想将它们合并回来，但其他类别可能

00:11:26.700 --> 00:11:33.270
可能会幸存下来，所以可以制作一些动画，是的，所以我们将

00:11:33.270 --> 00:11:38.760
拆分，我们将查看拆分，然后将其合并回拆分

00:11:38.760 --> 00:11:42.870
另一面，我们可能会保留它，以便谁拥有而不是完全分裂

00:11:42.870 --> 00:11:48.480
树将拥有这棵坚固的树，并且我们将评估树的用途

00:11:48.480 --> 00:11:56.520
分裂激发了简单似然比，我们在其中计算了

00:11:56.520 --> 00:12:00.990
拆分后的数据在没有

00:12:00.990 --> 00:12:09.510
分裂，我们将做一个简单的近似，我们只对待我们

00:12:09.510 --> 00:12:13.800
仅针对解析树中给定节点本地计算似然性，以便我们

00:12:13.800 --> 00:12:20.880
不需要重新分析整个训练集，这使我们可以控制

00:12:20.880 --> 00:12:25.970
确定要保留多少拆分的方式，我们可以通过以下方式对这种幸福进行排序

00:12:25.970 --> 00:12:32.160
他们的可能性增加并扭转了其中的一小部分，我们发现，如果我们

00:12:32.160 --> 00:12:37.410
扭转分裂的一半，我们不会损失太多可能性，也不会损失

00:12:37.410 --> 00:12:46.770
解析精度方面的任何问题，因此我们将其固定为50％，并且并未真正进行实验

00:12:46.770 --> 00:12:49.730
更多的一面

00:12:52.450 --> 00:13:02.279
所以当你为一个方向做出贡献时

00:13:10.350 --> 00:13:38.860
当你有水平的时候，所以现在我们有一种可能性，你有一种

00:13:38.860 --> 00:13:56.019
一点，然后您可以决定哪一点最不重要，因此我们需要进行一些后续工作

00:13:56.019 --> 00:14:01.930
区分性分析，我们将每个拆分视为独立特征，然后

00:14:01.930 --> 00:14:07.570
在那里，您可以引入这些功能，并且根据上下文，我们不会

00:14:07.570 --> 00:14:11.260
明确地将它们合并回去，但您可能会说得很好，我想拥有该功能

00:14:11.260 --> 00:14:15.399
对于全球而言，对于这一类别，我不在乎这种特殊的划分

00:14:15.399 --> 00:14:19.540
并根据上下文，您可能需要重新设置条件

00:14:19.540 --> 00:14:23.230
许多功能，在其他情况下，您可能会回到非常

00:14:23.230 --> 00:14:27.820
一般类别我在生成器中没有考虑太多

00:14:27.820 --> 00:14:34.300
这种情况下我们尝试的是强制执行，而不是让每个

00:14:34.300 --> 00:14:39.339
这样考虑的时候，每个事物的类别都会独立地分开

00:14:39.339 --> 00:14:42.850
这是我们的词汇类别，因为它更易于显示，但是当您拥有

00:14:42.850 --> 00:14:50.110
二进制规则将您分割，以便获得二进制规则，您在遇到Harry时

00:14:50.110 --> 00:14:54.100
二值化它，您必须指定骨骼结构，所以我们尝试修复特定的

00:14:54.100 --> 00:14:57.459
骨干的一部分，因为我们认为我们想传播

00:14:57.459 --> 00:15:02.110
整个骨干网中的信息，结果证明限制了

00:15:02.110 --> 00:15:05.740
这样的语法表现似乎更好

00:15:05.740 --> 00:15:13.950
让他们自己做自己的事吧

00:15:16.590 --> 00:15:45.280
是的，所以我们接受了这个，然后添加到参数中，然后运行

00:15:45.280 --> 00:15:52.900
在训练数据上我们可以使用数据，但是在训练中似乎可以正常工作

00:15:52.900 --> 00:16:01.270
数据事实上，我们尝试了多种不同的方式

00:16:01.270 --> 00:16:06.520
合并回去，看起来很健壮

00:16:06.520 --> 00:16:11.920
如果合并太多，拆分会合并，最终会伤害您的

00:16:11.920 --> 00:16:14.770
解析性能，但在下一轮中，您再次引入相同的吐痰

00:16:14.770 --> 00:16:20.590
所以您有点像一遍又一遍地做同样的工作，所以

00:16:20.590 --> 00:16:27.090
为什么我们将其固定为不执行的50％是任何分析性能

00:16:32.710 --> 00:16:48.020
是的，我们刚才说得很好，就像1 2 3 4

00:16:48.020 --> 00:16:52.700
将它们解释为二进制文件，但就像您具有两个二进制文件功能，然后

00:16:52.700 --> 00:16:56.540
您只是说第一个像奇数特征不能随

00:16:56.540 --> 00:17:01.640
规则的类似提议的主干，这些规则的结果来自

00:17:01.640 --> 00:17:08.870
二进制文件更大，是的，我们也进行了二值化实验

00:17:08.870 --> 00:17:13.730
右左组织，似乎只是在做简单的右分支公司

00:17:13.730 --> 00:17:22.490
很好，尽管分支方向似乎对某些人有影响

00:17:22.490 --> 00:17:32.930
其他语言还可以，所以如果您看一下解析性能，那会发生什么

00:17:32.930 --> 00:17:41.930
如果我们看一些类似的分割回合，我们不会损失任何东西

00:17:41.930 --> 00:17:46.970
失去任何个人表现，但我们能做的就是我们现在能做

00:17:46.970 --> 00:17:53.540
再进行两次拆分，以使某些类别在

00:17:53.540 --> 00:18:01.430
但这又使性能提高了百分之一

00:18:01.430 --> 00:18:05.480
现在开始开始担心的是，在这一点上，我们拆分了一些

00:18:05.480 --> 00:18:11.690
类别最多可分为64个类别的子载波，因此我们可以对其进行查看

00:18:11.690 --> 00:18:17.060
子类别的短语，我们看到每个类别的每个类别

00:18:17.060 --> 00:18:22.040
类别一些拆分已被逆转，所以好像我们要达到一个点

00:18:22.040 --> 00:18:28.460
即使我们进行了更多拆分，性能还是很平静的

00:18:28.460 --> 00:18:32.510
有趣的是，已经在

00:18:32.510 --> 00:18:36.470
频繁且结构复杂的合理类别

00:18:36.470 --> 00:18:41.360
已经分裂了很多，而其他罕见的事情

00:18:41.360 --> 00:18:45.080
或没有太多变化，因为它们总是产生相同的东西

00:18:45.080 --> 00:18:51.380
并没有太大的分裂，在词汇类别中我们也可以看到

00:18:51.380 --> 00:18:57.010
严重分裂的类别是链接名词和形容词的开放类

00:18:57.010 --> 00:19:01.370
实际上专有名词让您将它们拆分成三个

00:19:01.370 --> 00:19:12.890
子类别，因此即使没有合并，也不会自动存在

00:19:12.890 --> 00:19:17.210
了解到逗号不应该分开，因为它们总是产生相同的

00:19:17.210 --> 00:19:24.530
如果将它们分开，在工作中没有任何可能性

00:19:24.530 --> 00:19:28.790
从那时起我就做完了，实际上我们已经将其扩大以做更多和一两个

00:19:28.790 --> 00:19:34.809
更多的回合比赛和表现趋于平稳，所以好像我们已经

00:19:34.809 --> 00:19:43.070
在yeah结构之后提取了与此类类型一样多的数据

00:19:43.070 --> 00:19:54.230
模型是的，我将展示一些词汇示例，并且有很多

00:19:54.230 --> 00:19:58.160
本文中有关如何学习如何构造的示例

00:19:58.160 --> 00:20:03.530
传播父级信息，但由于存在

00:20:03.530 --> 00:20:07.280
语法中发生了很多事情，所以我们有一个小界面

00:20:07.280 --> 00:20:12.140
您可以点击解析树和规则以查看事物如何传播，但是

00:20:12.140 --> 00:20:19.070
这很难分析，但我想暗示的是一个问题

00:20:19.070 --> 00:20:23.030
该模型所具有的就是我们正在拆分，我们正在采用这些观察到的类别

00:20:23.030 --> 00:20:29.240
并将其分为大量子类别

00:20:29.240 --> 00:20:34.870
可能导致过度拟合，因为现在我们实际上有这64或63

00:20:34.870 --> 00:20:41.840
独立类别被视为完全独立的符号

00:20:41.840 --> 00:20:46.010
语法上没有什么可以说所有这些都不是专有名词

00:20:46.010 --> 00:20:53.910
该模型是将它们捆绑在一起的一种方式，

00:20:53.910 --> 00:20:59.310
共享统计信息就是做我们所谓的父母移动父母现在所在的位置

00:20:59.310 --> 00:21:05.400
不是树中的父项，而是未拆分的类别，我们进行了实验

00:21:05.400 --> 00:21:09.750
用不同的方式来做到这一点，但事实证明，无论如何

00:21:09.750 --> 00:21:13.680
进行平滑处理很重要，因此进行平滑的线性平滑处理很重要

00:21:13.680 --> 00:21:22.710
在这里，您只有一个参数设置为零点一，并说

00:21:22.710 --> 00:21:27.060
您相信您的统计数据所说的百分之九十，其余的

00:21:27.060 --> 00:21:33.390
从您的兄弟姐妹那里，我们这样做是在您计算完虚拟机之后，我们计算出的最大值

00:21:33.390 --> 00:21:39.150
不要忘记参数，并使其平滑向父级提供更多

00:21:39.150 --> 00:21:43.580
健壮性，所以当我们看结果时

00:21:49.760 --> 00:21:58.620
好吧，是的，我的意思是在房间里，总共五个，所以我们要做的就是

00:21:58.620 --> 00:22:05.040
看一下规则的父对象，以便获得一个固定的父鸡蛋，就像感谢

00:22:05.040 --> 00:22:10.740
是子类别，我们将所有四个类似的兄弟姐妹

00:22:10.740 --> 00:22:15.120
这些的配置我们采用所有其他组合，因此它们与

00:22:15.120 --> 00:22:22.080
他们是规则的负责人，所以所有规则都有

00:22:22.080 --> 00:22:27.810
您在这里就像B和C的子类别一样，所以会有

00:22:27.810 --> 00:22:31.920
是的，因此对于所有在左侧右侧带有X的规则，

00:22:31.920 --> 00:22:41.010
某些类型的B和某些类型的座椅在一起会更光滑，因此

00:22:41.010 --> 00:22:47.370
规则，所以如果我们有一个0到V 0 C 0，那么所有规则都将变得平滑

00:22:47.370 --> 00:22:52.500
那去0变成x cy他们将像父母一样被放在一起

00:22:52.500 --> 00:22:56.810
固定然后所有兄弟姐妹

00:23:00.300 --> 00:23:13.240
像那样，也许我已经确信那是很远的，所以因为我想

00:23:13.240 --> 00:23:31.540
这样做是为了减少专业水平，但是我的意思是我们可以做的是

00:23:31.540 --> 00:23:41.020
可以顺应完全不分割的规则，是的，我不

00:23:41.020 --> 00:23:46.930
认为我们尝试我们对于词法类别总是很有趣，没有

00:23:46.930 --> 00:23:51.760
差异，因为这只是一个方向，然后对你来说永远不会

00:23:51.760 --> 00:23:56.920
二元产量会有所不同，所以我们可以平均

00:23:56.920 --> 00:24:07.860
整个事情，但我们总是会更好

00:24:09.890 --> 00:24:19.190
是的，哦，那就是我们一直试图将两者反叛的原因

00:24:19.190 --> 00:24:23.330
只是这样做，但想法是当您尝试建立一个

00:24:23.330 --> 00:24:29.570
组成某物，所以，如果您像左侧那样平滑

00:24:29.570 --> 00:24:34.190
当您计算父母的左​​侧分数时的一种

00:24:34.190 --> 00:24:38.809
这样的动作将会生效，所以当您将其与

00:24:38.809 --> 00:24:43.070
就像它已经是该宪法的参数一样

00:24:43.070 --> 00:24:47.809
已经很光滑了，就像你不需要做的话

00:24:47.809 --> 00:24:55.250
您将开始进行更多的平滑处理，如n p0和p1

00:24:55.250 --> 00:25:01.100
然后你有不同的规则，是的，但是一旦建立了这个，你

00:25:01.100 --> 00:25:05.360
总是把它们当成其他东西来对待

00:25:05.360 --> 00:25:13.870
议员们否否否我们将其保留为n p0，所以也许我可以在黑板上写字

00:25:24.770 --> 00:25:36.240
因此，当我们启动npep时，它们将是一些参数P，这是

00:25:36.240 --> 00:25:43.620
检查树库中的规则，以便我们在0处创建的内容转到NP 0

00:25:43.620 --> 00:25:56.730
vp 0然后是0 o填充，p 0 1 0是所有组合的种类，依此类推

00:25:56.730 --> 00:26:00.300
我们将在第一个拆分中将类别一分为二时，将

00:26:00.300 --> 00:26:07.530
规则分为八件事，当我们应用平滑时，我们将平滑这四件事

00:26:07.530 --> 00:26:16.530
和这四个一起，如果您想产生S 0，我们说的很好

00:26:16.530 --> 00:26:23.790
重要的是什么类型的NP没有P，但并不是像应该有一些

00:26:23.790 --> 00:26:29.400
我的意思是说，平滑处理会使它们之间的差异有所减少，所以您

00:26:29.400 --> 00:26:35.550
更宽容，就像你在建筑时愿意的那样

00:26:35.550 --> 00:26:40.080
这和您想要共享NP统计信息的NP和V下水道

00:26:40.080 --> 00:26:45.240
右手边，所以您关心您的父母是什么，但是

00:26:45.240 --> 00:26:49.350
您在右侧会比较灵活，因为您会知道

00:26:49.350 --> 00:26:53.040
这样，当您进行大量拆分时，您将非常适合并且过度适合

00:26:53.040 --> 00:26:59.400
这样就收集了您的数据，这就是为什么我们只在左侧进行拆分，因为我们

00:26:59.400 --> 00:27:05.280
下次在某个规则中s 0在​​右侧的任何地方都说得好

00:27:05.280 --> 00:27:09.510
会在那里变得光滑，因为我们始终将其应用到右侧

00:27:09.510 --> 00:27:14.100
所以我们不需要像我们可以一起平滑整个事情那样平滑，但这

00:27:14.100 --> 00:27:19.160
我们有点少一点控制的方式

00:27:20.440 --> 00:27:29.470
是的，是的，我是说，我们只是以线性方式进行

00:27:29.470 --> 00:27:35.380
是某人的事，下次是某人的事，如果

00:27:35.380 --> 00:27:39.970
我们看性能时，我们会发现当事情开始时

00:27:39.970 --> 00:27:44.020
只有两个子类别，而实际上却与众不同

00:27:44.020 --> 00:27:47.530
有点伤害您，因为您只是试图将它们分开放置

00:27:47.530 --> 00:27:52.090
你把东西放回去，但是最后

00:27:52.090 --> 00:28:01.780
您会获得1％的准确度，是的，所以在撰写本文时，

00:28:01.780 --> 00:28:06.490
无法做更多的拆分，看起来差距越来越大，我们

00:28:06.490 --> 00:28:14.710
可以走得更远，我们扩大了规模，不幸的是，它趋于平缓，但这是

00:28:14.710 --> 00:28:17.740
看到另外四个树库也很有趣，所以我们在其他树上运行它

00:28:17.740 --> 00:28:22.990
从那以后，您需要的培训数据就更少了，所以这是英语

00:28:22.990 --> 00:28:27.910
如果您有一百万个德语和中文单词，那么您就有300,000或

00:28:27.910 --> 00:28:33.310
500,000个单词的性能实际上在这里下降，如果您不进行平滑处理

00:28:33.310 --> 00:28:35.920
它实际上开始下降，因为您过度拟合

00:28:35.920 --> 00:28:43.090
所以这个动作很关键，但是不是，我们尝试不同的方法，只是

00:28:43.090 --> 00:28:54.880
散布你的方式，它工作正常，我认为在当前版本中

00:28:54.880 --> 00:29:00.550
有两个是规则的，一个是词法产生的，但在

00:29:00.550 --> 00:29:07.720
开始，我认为这些数字只是一个，就像我们尝试给我们一些

00:29:07.720 --> 00:29:09.870
参数

00:29:11.580 --> 00:29:18.810
不，这是手册，就像我们尝试零点一点一点

00:29:18.810 --> 00:29:26.640
两个，然后再指出一个问题，我们将其修复并保留下来，以便举例说明

00:29:26.640 --> 00:29:34.620
正在学习中，我们会看到专有名词，我们会先观察诸如月之类的事物

00:29:34.620 --> 00:29:39.350
命名中间名姓，然后是第一个和第二个，make和

00:29:39.350 --> 00:29:46.860
用于人称代词的复合词我们学习机壳我们有一些主格

00:29:46.860 --> 00:29:52.070
还有一些X是来自人称代词

00:29:56.570 --> 00:30:02.180
是的，只是你可以说是

00:30:02.180 --> 00:30:07.500
这是多么有用，但是很高兴看到您学习到的东西

00:30:07.500 --> 00:30:12.120
实际上可以解释，我们坚持有意义的做法，当您查看

00:30:12.120 --> 00:30:16.710
规定您会看到我的顾问在读研究生时所做的许多事情

00:30:16.710 --> 00:30:21.120
就像以语言动机手动分割内容一样

00:30:21.120 --> 00:30:37.200
我自然会出现，是的，我比英语更像是计算机科学家

00:30:37.200 --> 00:30:42.900
先生，是的，这很好，所以现在我们谈到了

00:30:42.900 --> 00:30:47.640
学习中我们应该对推理有所思考，因为我做的一件事

00:30:47.640 --> 00:30:52.950
省略，因为它并不是真正有利的是解析

00:30:52.950 --> 00:30:58.850
每个句子大约需要一分钟的发展，所以如果您想做

00:30:58.850 --> 00:31:05.520
在任何类型的应用程序中解析都是没有用的，因此我们需要考虑如何

00:31:05.520 --> 00:31:09.180
加快速度，问题是即使语法很小

00:31:09.180 --> 00:31:13.260
在类别数中，因为参数数呈三次方增长

00:31:13.260 --> 00:31:20.400
它们之间的连接非常紧密，您需要为我们总结很多东西

00:31:20.400 --> 00:31:24.400
当您进行推断时，与我在一起的事情最多

00:31:24.400 --> 00:31:30.730
我们将借用一些想法，以便我们发现引入对比的家庭语法

00:31:30.730 --> 00:31:35.590
结果在这里得到语法处理，他们抓住并产生了基本的说

00:31:35.590 --> 00:31:41.309
中国的各个专栏这是什么

00:31:41.890 --> 00:31:46.510
所以我认为这与评论和培训大致相同，因为

00:31:46.510 --> 00:31:51.100
词法化，使诸如许多参数之类的东西变得如此，如果您需要

00:31:51.100 --> 00:31:58.540
平滑，但我们的语法解析起来有点慢，因为您有

00:31:58.540 --> 00:32:03.760
较少的成分成分类型，但参数数量相同，所以当

00:32:03.760 --> 00:32:08.770
您想要构造一个成分，需要遍历许多事物，但是在

00:32:08.770 --> 00:32:11.950
词汇化的语法，您知道单词，所以只有这个

00:32:11.950 --> 00:32:17.530
可以去那里的特定成分，所以这就是问题所在

00:32:17.530 --> 00:32:21.820
的方式，尽管与此同时判别语法说

00:32:21.820 --> 00:32:27.070
他们的数量级较小，是的，所以这个东西大约一到两个

00:32:27.070 --> 00:32:30.460
百万个参数，而有区别的参数有50,000个

00:32:30.460 --> 00:32:34.840
仅具有参数，并且具有相同的人员性能，但那不是一部分

00:32:34.840 --> 00:32:37.630
的股票，但我稍后再谈

00:32:37.630 --> 00:32:45.010
因此，我们将从先前的工作中借鉴一些想法，以加快解析和打印的速度

00:32:45.010 --> 00:32:48.670
而主要思想是当然可以找到将树带到哪里的解析

00:32:48.670 --> 00:32:54.760
然后您X估算精炼语法，例如以前使用的工作

00:32:54.760 --> 00:32:59.620
在我们的案例中，词汇化语法是我们仅拆分的语法，

00:32:59.620 --> 00:33:03.970
除此之外，您还有一个更紧凑的粗略语法

00:33:03.970 --> 00:33:07.360
更快地解析，然后只需要做的就是建立

00:33:07.360 --> 00:33:11.590
例如，这些语法的符号之间的某种对应关系

00:33:11.590 --> 00:33:16.809
说我们可以剥离词汇化或剥离隐藏的

00:33:16.809 --> 00:33:20.910
注释在我们的情况下，然后我们将使用粗略语法进行解析

00:33:20.910 --> 00:33:28.420
我们将计算成分的后验可能性，并修剪掉不太可能

00:33:28.420 --> 00:33:32.429
简明扼要，这样当我们使用精细的语法进行分析时，可以跳过很多

00:33:32.429 --> 00:33:42.010
类型，所以这是一个很好的解决方法，不能保证给我们

00:33:42.010 --> 00:33:48.059
根据我们的模型可以得出正确的结果，但在实践中效果确实很好，

00:33:48.809 --> 00:33:54.250
就像您有一个阈值需要为每个阈值设置一样，因此我们有一个全局

00:33:54.250 --> 00:34:02.410
我们用于所有修剪遍的阈值，并通过对其进行调整来进行设置

00:34:02.410 --> 00:34:07.330
在开发中表示我们解析时，我们不会发生任何解析错误，但我们

00:34:07.330 --> 00:34:10.929
不知道这是否意味着如果我们不做任何特别的假设

00:34:10.929 --> 00:34:14.649
真正的测试集以及我们要做的是通过成分计算机

00:34:14.649 --> 00:34:19.330
您的概率是多少，如果我们愿意，我们可能会说QP不太可能

00:34:19.330 --> 00:34:23.740
但是和平与VPS可能是根据课程语法而定的，所以当

00:34:23.740 --> 00:34:28.480
我们转到精制版本，我们可以跳过QP的精制版本

00:34:28.480 --> 00:34:37.179
数量短语，因此，如果应用此思想，则可以减少第一个

00:34:37.179 --> 00:34:41.560
事情时间很长，但是我们仍然太慢了

00:34:41.560 --> 00:34:46.600
应用程序，但是我们可以做的是我们可以以分层的方式来做

00:34:46.600 --> 00:34:51.159
可以代替课程版本升级到最多的三个五个

00:34:51.159 --> 00:34:55.090
可以进行几轮修剪我们先从课程开始，然后

00:34:55.090 --> 00:34:59.830
剪掉一个符号，然后我们去加泰罗尼亚语的程序员那里，然后有两个

00:34:59.830 --> 00:35:04.390
子类别，我们可以在这些符号之间进行跳过

00:35:04.390 --> 00:35:07.690
但是我们需要计算ap1和ap2的概率

00:35:07.690 --> 00:35:12.850
我们可能会说在p2和bp1中不太可能，所以在后续遍中

00:35:12.850 --> 00:35:17.050
可以跳过那些类别的提炼版本的所有内容，

00:35:17.050 --> 00:35:22.150
我们可以继续这样做，直到达到最终解析模型为止

00:35:22.150 --> 00:35:30.670
然后尽力而为，但仅使用这些符号就会出现一个问题

00:35:30.670 --> 00:35:35.520
是从一件事中获得中间语法的地方

00:35:35.520 --> 00:35:40.840
在训练中我们也要立即想到的是，我们已经在生产它们，我们正在

00:35:40.840 --> 00:35:46.000
迭代地拆分每种机制，这样我们就可以保留它们并使用

00:35:46.000 --> 00:35:55.460
他们进行修剪，事实上，

00:35:55.460 --> 00:35:59.780
阈值调整，所以如果我们不对它的发展设定任何限制，那我们就倒下了

00:35:59.780 --> 00:36:07.579
到现在的35分钟，这变得合理，但我们可以做得更好，

00:36:07.579 --> 00:36:12.859
这里的认识是，当我们训练事物时，我们使用

00:36:12.859 --> 00:36:17.900
以前的语法，并有一些随机噪声，但随后我们让事情漂移

00:36:17.900 --> 00:36:22.040
没有什么限制它们成为新的子类别

00:36:22.040 --> 00:36:27.170
上一个类别的优化，所以我们初始化时添加nice，然后我们

00:36:27.170 --> 00:36:32.810
只是继续做，然后我们最终得到一些东西，例如

00:36:32.810 --> 00:36:40.250
这些词是这里第二高的作品，现在已经不合时宜了

00:36:40.250 --> 00:36:44.990
成为带有显性标签的子类别，因此如果我们使用前一个

00:36:44.990 --> 00:36:51.619
修剪的语法，我们需要更加谨慎，并且在设置

00:36:51.619 --> 00:36:56.540
阈值，如果我们的语法是最精致的语法的近似值

00:36:56.540 --> 00:37:01.220
语法，然后我们可能会修剪更多和获得这些的一种方法

00:37:01.220 --> 00:37:06.319
语法是通过向后投射最精巧的语法，因此我们采用初始

00:37:06.319 --> 00:37:10.190
语法我们做我们的学习程序，但是然后而不是保持中间

00:37:10.190 --> 00:37:15.520
语法，我们将其丢弃，然后计算

00:37:15.520 --> 00:37:21.170
在给定较小集合的情况下，最精细的语法尽可能接近

00:37:21.170 --> 00:37:26.450
参数到最精致的参数，这将使我们可以修剪

00:37:26.450 --> 00:37:33.280
加强修剪阈值的阈值以及其他四个阈值，我们如何才能做到这一点

00:37:33.280 --> 00:37:38.780
决定非终端集很容易，例如，如果我们有一个

00:37:38.780 --> 00:37:43.609
语法已拆分为两个预计版本，一个预计版本

00:37:43.609 --> 00:37:48.230
版本会有几个，例如可以消除所有延迟

00:37:48.230 --> 00:37:54.859
注解比较棘手的是如何计算这个较粗糙的参数

00:37:54.859 --> 00:38:00.349
语法，问题在于我们要采用所有这些规则并将其映射到

00:38:00.349 --> 00:38:06.470
一小部分规则，我们不能仅仅将这些参数加起来

00:38:06.470 --> 00:38:12.360
因为我们需要知道等待左侧的种类

00:38:12.360 --> 00:38:17.190
s1相对于s 2的频率，以便我们可以进行加权组合

00:38:17.190 --> 00:38:25.950
而做到这一点的方法是通过估计语法而不是从树库中

00:38:25.950 --> 00:38:32.400
我们可以从由我们最大的

00:38:32.400 --> 00:38:40.740
精致的语法，看起来有点复杂，但归结为

00:38:40.740 --> 00:38:45.900
我们需要的不仅仅是计数参数，因为我们没有真正的

00:38:45.900 --> 00:38:49.170
有兴趣引起的重新分配的语法，我们需要计算

00:38:49.170 --> 00:38:53.550
对这些规则及其左手边的期望，

00:38:53.550 --> 00:39:00.870
简单的递归，我们开始说一个符号的计数

00:39:00.870 --> 00:39:07.260
深度为0 c0，因此对于a来说，如果有一个痣是两个根，则为1，否则为1 0

00:39:07.260 --> 00:39:14.580
然后在深度I加1处，我们可以递归到从

00:39:14.580 --> 00:39:18.630
之前的深度，然后使用

00:39:18.630 --> 00:39:23.520
我们的语法，这给了我们一定深度的符号预期计数

00:39:23.520 --> 00:39:30.450
如果将此过程运行几轮，则这些方程式收敛的固定值将收敛

00:39:30.450 --> 00:39:36.750
很快，经过25次迭代，它们非常稳定，事实上，大多数

00:39:36.750 --> 00:39:40.860
树堤中的树木最深处为25棵，因此似乎已被捕获

00:39:40.860 --> 00:39:46.920
句子有多长的概率，那么我们可以使用这些

00:39:46.920 --> 00:39:52.050
期望或计数以计算较粗糙者的真实概率

00:39:52.050 --> 00:39:59.130
版本时，我们可以在不要求搜索者的情况下提高阈值

00:39:59.130 --> 00:40:06.720
最多15分钟，这是1,500个句子的50分钟，这是一个

00:40:06.720 --> 00:40:11.520
每秒几句话，实际上如果我们愿意犯一个小错误

00:40:11.520 --> 00:40:16.500
X 0.1％的解析精度，就像

00:40:16.500 --> 00:40:22.200
在三到四个句子中，我们可以将其缩减为大约七分钟

00:40:22.200 --> 00:40:28.560
是每秒四到五个句子，如果我们看一下

00:40:28.560 --> 00:40:33.660
花费的时间我们看到，该课程的第一关是格雷厄姆

00:40:33.660 --> 00:40:39.260
实际上是最昂贵的，如果我们真的想找到单位，我们可以

00:40:39.260 --> 00:40:45.349
计算我们合并的原始祖母的更多抽象版本

00:40:45.349 --> 00:40:51.480
类别的顶部和说得好的名词短语和动词短语都非常

00:40:51.480 --> 00:40:55.830
在某种意义上有所不同，但对于某种课程结构，可能会有

00:40:55.830 --> 00:41:01.140
如果和具有相似的行为并足以计算出更有吸引力的版本，则足够

00:41:01.140 --> 00:41:05.580
再说更多，但是现在这就是我们要做的

00:41:05.580 --> 00:41:11.780
我们在后括号中看到黑色的过程意味着

00:41:11.780 --> 00:41:17.460
体形跨越三角形的下方，很可能

00:41:17.460 --> 00:41:22.859
我们正在对成分的类型求和，因此在第一遍之后

00:41:22.859 --> 00:41:28.530
通过最简单的语法，我们看到很多事情已经排除在外

00:41:28.530 --> 00:41:32.270
语法说现在不可能在这个范围内放些东西

00:41:32.270 --> 00:41:37.200
特别是在有托马斯（Thomas）参与的情况下，

00:41:37.200 --> 00:41:44.849
精度可以跨越这个范围，然后当我们修剪时可以进行Harkaway

00:41:44.849 --> 00:41:50.300
这应该有一个视频

00:41:56.970 --> 00:42:01.790
所以我们开始，然后我们看到列表的某些区域

00:42:01.790 --> 00:42:07.579
图表被修剪掉，稀疏打架，最后，最终的图表是

00:42:07.579 --> 00:42:13.829
极为稀疏，仍然存在一些歧义，例如如何

00:42:13.829 --> 00:42:18.450
这句话是它附着在哪个级别，但其他大多数

00:42:18.450 --> 00:42:23.190
已经被整理出来，所以即使语法很大

00:42:23.190 --> 00:42:26.910
这种实现的词法化也要做的是

00:42:26.910 --> 00:42:32.460
一定范围，相对确定是什么类型，但不喜欢

00:42:32.460 --> 00:42:39.990
可能会有一些小的变化，这样我们就可以

00:42:39.990 --> 00:42:47.450
最后一遍，我们进行变分近似并计算最佳树

00:42:53.839 --> 00:42:58.430
是的，图表通过了，我可以扩展它，因为您还有更多

00:42:58.430 --> 00:43:03.930
变化但很好的是，是的，很多事情不需要

00:43:03.930 --> 00:43:07.170
扩展，因为它们已经完全移开，因此在以后的每个

00:43:07.170 --> 00:43:17.940
通过，您不再需要做那么多的工作，那就不一样了，所以如果您这样做

00:43:17.940 --> 00:43:22.829
您可以做同样的事情，但是我实际上在那找到了您，因此在每个级别上

00:43:22.829 --> 00:43:26.579
刚开始时似乎有点不同，您需要多一点

00:43:26.579 --> 00:43:30.540
慷慨大方是因为您不想语法太糟糕了，所以您不会

00:43:30.540 --> 00:43:33.299
想要修剪那么多，但是在以后的阶段中，您实际上可以

00:43:33.299 --> 00:43:42.180
激进的，因为我的语法足以说出我不喜欢的一部分

00:43:42.180 --> 00:43:47.609
我会说太多，因为我以为我不会

00:43:47.609 --> 00:43:52.799
时间是您的问题是什么，我们要用这个小注释做什么？

00:43:52.799 --> 00:43:57.299
授予我们感兴趣的是解析这些课程类别中的树，但是

00:43:57.299 --> 00:44:01.500
语法给我们的就是所谓的这些小类的派生

00:44:01.500 --> 00:44:07.290
因此可能有许多派生对应于相同的分析树

00:44:07.290 --> 00:44:14.640
在实践中，我们想总结隐藏的变量，但是我们不能

00:44:14.640 --> 00:44:19.410
因为它是np完整的，并且您可以做一些不同的事情

00:44:19.410 --> 00:44:24.210
事情是要做维特比解析并满足最佳推导

00:44:24.210 --> 00:44:30.780
可以，但是它不是最好的，您不应该这样做，因为

00:44:30.780 --> 00:44:35.400
其他事情很简单，更好的事情是提取N个最佳列表，然后

00:44:35.400 --> 00:44:39.990
然后计算出这些树的确切可能性，然后对它们进行排名，这有助于

00:44:39.990 --> 00:44:47.250
一点点，但最好的事情是，到目前为止，我们发现这样做

00:44:47.250 --> 00:44:51.060
给定后验分布的变分近似

00:44:51.060 --> 00:44:56.370
句子，因此，如果您构建了特定于句子的pcfg，

00:44:56.370 --> 00:45:02.790
这些成分的概率，实际上，结果只是

00:45:02.790 --> 00:45:07.710
在外面跑，然后再跑一遍，那很快

00:45:07.710 --> 00:45:15.210
它并不慢，但相差约1％至1.5％，这很关键

00:45:15.210 --> 00:45:21.900
获得最先进的性能，以便您了解结果

00:45:21.900 --> 00:45:27.570
效率方面，我们可以将其与恰尼克和约翰逊的人进行比较

00:45:27.570 --> 00:45:34.290
最先进的英语解析器，我们更快一点

00:45:34.290 --> 00:45:39.600
更加精确，我们的钱包使用Java而不是C，所以如果我们

00:45:39.600 --> 00:45:43.460
移植它以查看它在准确性方面可能甚至更快

00:45:43.460 --> 00:45:47.250
与没有排名的生成部分相比，因为真实

00:45:47.250 --> 00:45:56.550
排名可以应用于我们的东西哦，是，是，所以有点像

00:45:56.550 --> 00:46:06.600
最大限度地提高记忆力，但是是的，所以对于英语，我们

00:46:06.600 --> 00:46:09.720
比生成部分要好，然后如果我们对树进行排名

00:46:09.720 --> 00:46:15.330
我们最终得到的性能差不多是

00:46:15.330 --> 00:46:20.130
是因为我们做了很多修剪，所以最好的清单并不比

00:46:20.130 --> 00:46:23.620
他们的，因为我们已经修剪掉了许多

00:46:23.620 --> 00:46:30.050
几乎是正确的树木，但这种方法的优点之一是

00:46:30.050 --> 00:46:33.440
这里没有什么是英语专用的，参数很少

00:46:33.440 --> 00:46:40.850
实际上，我们可以将它们固定并在任何模型上运行模型

00:46:40.850 --> 00:46:44.870
语言它有一个树堤，这个实验中最难的部分是

00:46:44.870 --> 00:46:50.240
得到树木和许可证，但是一旦我们有了它们，我们就继续

00:46:50.240 --> 00:46:56.750
德语，我们大多数人都执行了以前最先进的模型

00:46:56.750 --> 00:47:02.420
因为在德语和中文方面的工作要少得多，所以我们也

00:47:02.420 --> 00:47:07.760
比以前的工作要好得多，与此同时

00:47:07.760 --> 00:47:13.400
法语，下周我将使用阿拉伯语，法语也更好

00:47:13.400 --> 00:47:20.900
所以这似乎是一种通用方法，适用于各种

00:47:20.900 --> 00:47:28.790
具有非常不同的语言特性的语言，所以某种

00:47:28.790 --> 00:47:33.650
不是将来的工作已经在过去，而是我们在上一次完成的工作中

00:47:33.650 --> 00:47:39.080
一年的扩展是使用相同的思想来学习结构化模型

00:47:39.080 --> 00:47:45.500
电话识别，您可以从简单的电话开始，然后代替

00:47:45.500 --> 00:47:48.800
手动将它们拆分为试用电话并对其进行群集，您可以尝试

00:47:48.800 --> 00:47:55.490
归纳出结构，并且效果很好，我们做了不同版本的

00:47:55.490 --> 00:48:00.050
在这里，我们没有进行拆分和合并启发式，

00:48:00.050 --> 00:48:06.080
不幸的是，尽管看起来不错，但模型稀疏

00:48:06.080 --> 00:48:12.560
围绕纸和数学薄它的性能稍差，但这是

00:48:12.560 --> 00:48:18.100
一种更清洁的模型，目前我正在开发具有歧视性的版本

00:48:18.100 --> 00:48:26.990
目前是准确的，但数量级稀疏到

00:48:26.990 --> 00:48:32.000
最后，我考虑过拆分隐藏结构的合并学习，

00:48:32.000 --> 00:48:36.140
我展示了结合了玲子的训练程序

00:48:36.140 --> 00:48:40.160
允许我们进行自适应拆分并与参数平滑组合

00:48:40.160 --> 00:48:43.880
获得非常好的准确性，在推理方面，我们谈到了

00:48:43.880 --> 00:48:48.380
将这些模型投射到较粗略的版本，以加快解析和

00:48:48.380 --> 00:48:53.680
关于将隐藏的结构边缘化，我只做了一张幻灯片

00:48:53.680 --> 00:49:01.729
而且它适用于多种语言，因此解析器位于我们的网页上，如果您愿意

00:49:01.729 --> 00:49:08.949
玩它，我们有两个问题

00:49:11.890 --> 00:49:38.269
这是我的问题，这是我一直想做的事情

00:49:38.269 --> 00:49:41.930
只是删除设置访问权限中所有内容的极端情况

00:49:41.930 --> 00:49:46.130
到处试图恢复包围结构我的问题

00:49:46.130 --> 00:49:51.829
从那以后，语法很快就变得亲了

00:49:51.829 --> 00:49:56.420
他们是立方的，是的，他们在类别中比较晚，所以

00:49:56.420 --> 00:50:01.819
因为它们是如此紧密地连接，所以发生了太多的事情

00:50:01.819 --> 00:50:07.099
同时打开，它转换为一些非常差的局部最大值，所以我

00:50:07.099 --> 00:50:11.509
认为您不需要稀疏，然后需要一点点初始化

00:50:11.509 --> 00:50:16.099
更多信息我想尝试开始融合的一件事

00:50:16.099 --> 00:50:22.130
稀有或相似的类别，看看我们会破坏多少语法

00:50:22.130 --> 00:50:26.269
在不影响解析性能的情况下，然后再进行其他类型的解析

00:50:26.269 --> 00:50:29.809
我们可以学习的结构，因为我有兴趣将其用于机器

00:50:29.809 --> 00:50:34.209
例如翻译，我不确定语言学家的类别是否

00:50:34.209 --> 00:50:38.209
为英语树银行指定的是机器翻译的最佳选择

00:50:38.209 --> 00:50:43.719
也许我们可以自动学习一些更有用的

00:50:46.910 --> 00:50:51.140
好吧，哦，真正的问题是你能削弱多少

00:50:51.140 --> 00:51:00.990
防止刺激我还是哦，你的意思是就像放噪音一样，不适

00:51:00.990 --> 00:51:03.540
那就是我刚才说的，我只做了极端的实验

00:51:03.540 --> 00:51:08.640
筹集一切，但我想看看我们能实际破坏多少

00:51:08.640 --> 00:51:16.620
在不损失解析精度的情况下，但这是我需要做的两件事

00:51:16.620 --> 00:51:22.560
问题，所以首先它总是让我感到困扰，您从未学过

00:51:22.560 --> 00:51:27.540
正确阅读《华尔街日报》，了解英语吧，为什么不训练自己的英语水平呢？

00:51:27.540 --> 00:51:32.010
首先使用非常简单的分析树对非常短的句子进行建模，然后

00:51:32.010 --> 00:51:36.510
从该语法中，您知道去更复杂的句子并尝试那种

00:51:36.510 --> 00:51:45.600
渐进式训练，看看一切是否改变

00:51:45.600 --> 00:51:50.670
我的意思是说，正在开展某种自我训练以进行解析和结果的工作

00:51:50.670 --> 00:51:54.750
如果您乘坐解析器在树上训练，然后解析一个

00:51:54.750 --> 00:52:00.630
一堆句子，并将其用作训练数据来分析性能

00:52:00.630 --> 00:52:06.120
遭受苦难是因为您有点在犯错误，但是

00:52:06.120 --> 00:52:10.050
如果您解析，则是否具有解析组件和后置引擎组件

00:52:10.050 --> 00:52:16.680
然后您可以解析外部句子，对它们重新排序并训练周围的部分

00:52:16.680 --> 00:52:20.430
该数据，然后它实际上会有所帮助，因为您那时就拥有了

00:52:20.430 --> 00:52:24.540
来自后锚的其他信息会反馈到

00:52:24.540 --> 00:52:30.390
解析器，但这是Charney将其变成棕色的一些工作，但您需要

00:52:30.390 --> 00:52:36.270
解析很多句子，例如小仆或句子，是的，

00:52:36.270 --> 00:52:40.110
引导方法，特别是对于资源匮乏的语言，您不需要

00:52:40.110 --> 00:52:43.830
拥有这么大的树木库，会有一些有趣的探索

00:52:43.830 --> 00:52:48.880
在树的范围内是3d，您可以拆分句子

00:52:48.880 --> 00:52:54.010
根据伦敦火车的第一个非常短的句子，选择语法使用它

00:52:54.010 --> 00:52:58.900
嗯，我认为这不会有太大帮助，我的意思是您可能会收敛到更好的水平

00:52:58.900 --> 00:53:04.780
局部最优，因为我是说先生。本地搜索，但请回到

00:53:04.780 --> 00:53:10.780
问题范围很广，所以也许当你写的时候会发生什么

00:53:10.780 --> 00:53:15.490
所有X就是您不知所措如果您以

00:53:15.490 --> 00:53:21.940
小短的句子，也许你已经做了一些分裂，像哦，发现一个数字

00:53:21.940 --> 00:53:28.030
名词和动词说没事，不会被包括

00:53:28.030 --> 00:53:33.280
将它们嵌入，然后一旦完成，就可以了，如果

00:53:33.280 --> 00:53:36.640
如果您要开始学习，则属于您，如果您尝试学习以下类别，

00:53:36.640 --> 00:53:40.630
如果您不认为它们已经被观察到，那就是第一名，是的，我

00:53:40.630 --> 00:53:45.900
认为这可能是个好方法

00:53:47.940 --> 00:53:53.410
这有什么希望吗，所以这里的一切都是真正的银行

00:53:53.410 --> 00:53:58.870
格式正确的句子对文本进行了消毒，但您知道现实世界是

00:53:58.870 --> 00:54:04.570
有点不同，我想知道你是否对这有任何希望

00:54:04.570 --> 00:54:11.680
将解析器用于一些数据，这些数据不太接近，所以我们

00:54:11.680 --> 00:54:18.760
想尽快与XE合作，这是语音数据的一部分，

00:54:18.760 --> 00:54:25.480
它在那里做什么以及我们是否可以使其适应语法语言建模

00:54:25.480 --> 00:54:33.340
然后推断演说，然后我想在秋天当约翰·布利泽（John Blitzer）来时，他非常

00:54:33.340 --> 00:54:37.690
对主要的两个患者都非常感兴趣，例如解析生物技术商店

00:54:37.690 --> 00:54:41.410
这是另外一个感谢，让我们脱离主流，因为通常情况下性能会下降

00:54:41.410 --> 00:54:48.550
下降了很多，但我们在这个方向上还没有做很多尝试，所以您做得很棒

00:54:48.550 --> 00:54:57.100
结构语法权您可以考虑对依赖项II做类似的事情吗

00:54:57.100 --> 00:55:00.790
在依赖和犯罪虹膜上什么都没做

00:55:00.790 --> 00:55:05.650
我猜想哲学之后，您可以提取出我的顾问哲学

00:55:05.650 --> 00:55:10.420
选区解析器的依赖性，并在一些早期实验中

00:55:10.420 --> 00:55:13.090
从战车零件中提取的依赖比我们更好

00:55:13.090 --> 00:55:17.470
最新的依赖项解析器，因此，如果要依赖项，请使用此

00:55:17.470 --> 00:55:24.760
并为它提取依赖项单元格的粗体语句，并且依赖项解析为

00:55:24.760 --> 00:55:30.210
通常要快得多，以至于我还没有完全摆好姿势，只是我没有

00:55:36.640 --> 00:55:39.360
谢谢

标签：00,Hierarchically,--,语法,PC,中文字幕,类别,解析,我们
来源： https://www.cnblogs.com/ageane/p/14399394.html