diff --git a/5_nn/1-Perceptron.ipynb b/5_nn/1-Perceptron.ipynb index 743f6aa..53914dd 100644 --- a/5_nn/1-Perceptron.ipynb +++ b/5_nn/1-Perceptron.ipynb @@ -6,23 +6,27 @@ "source": [ "# 感知机\n", "\n", - "感知机(perceptron)是二分类的线性分类模型,输入为实例的特征向量,输出为实例的类别(取+1和-1)。感知机对应于输入空间中将实例划分为两类的分离超平面,感知机旨在求出该超平面。为求得超平面导入了基于误分类的损失函数,利用梯度下降法 对损失函数进行最优化(最优化)。感知机的学习算法具有简单而易于实现的优点,感知机预测是用学习得到的感知机模型对新的实例进行预测的,因此属于判别模型。感知机由Rosenblatt于1957年提出的,是神经网络和支持向量机的基础。\n", - "\n" + "感知机(Perceptron)是二分类的线性分类模型,输入为实例的特征向量,输出为实例的类别(取+1和-1)。感知机对应于输入空间中将实例划分为两类的分离超平面,感知机旨在求出该超平面。为求得超平面导入了基于误分类的损失函数,利用梯度下降法对损失函数进行最优化。感知机的学习算法具有简单而易于实现的优点,感知机预测是用学习得到的感知机模型对新的实例进行预测的,因此属于判别模型。\n", + "\n", + "![perceptron](images/perceptron.png)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## 1. 生物学解释\n", - "心理学家Rosenblatt构想了感知机,它作为简化的数学模型解释大脑神经元如何工作:它取一组二进制输入值(附近的神经元),将每个输入值乘以一个连续值权重(每个附近神经元的突触强度),并设立一个阈值,如果这些加权输入值的和超过这个阈值,就输出1,否则输出0(同理于神经元是否放电)。对于感知机,绝大多数输入值不是一些数据,就是别的感知机的输出值。\n", + "## 1. 生物学、心理学解释\n", + "\n", + "心理学家唐纳德·赫布(Donald Olding Hebb)于1949年提出赫布理论,该理论能够解释学习的过程中脑中的神经元所发生的变化。赫布理论描述了突触可塑性的基本原理,即突触前神经元向突触后神经元的持续重复的刺激,可以导致突触传递效能的增加:\n", + "> 当细胞A的轴突足以接近以激发细胞B,并反复持续地对细胞B放电,一些生长过程或代谢变化将发生在某一个或这两个细胞内,以致A作为对B放电的细胞中的一个,导致突触传递效能的增加。\n", "\n", - "唐纳德·赫布提出了一个出人意料并影响深远的想法,称知识和学习发生在大脑主要是通过神经元间突触的形成与变化,简要表述为赫布法则:\n", + "![neuron_cell](images/neuron_cell_cn.png)\n", "\n", - "> 当细胞A的轴突足以接近以激发细胞B,并反复持续地对细胞B放电,一些生长过程或代谢变化将发生在某一个或这两个细胞内,以致A作为对B放电的细胞中的一个,效率增加。\n", "\n", + "心理学家弗兰克·罗森布拉特(Frank Rosenblatt)于1957年提出了感知机,它作为简化的数学模型解释大脑神经元如何工作:它取一组二进制输入值(附近的神经元),将每个输入值乘以一个连续值权重(每个附近神经元的突触强度),并设立一个阈值,如果这些加权输入值的和超过这个阈值,就输出1,否则输出0,这样的工作原理就相当于神经元是否放电。\n", "\n", - "感知机并没有完全遵循这个想法,**但通过调输入值的权重,可以有一个非常简单直观的学习方案:给定一个有输入输出实例的训练集,感知机应该「学习」一个函数:对每个例子,若感知机的输出值比实例低太多,则增加它的权重,否则若设比实例高太多,则减少它的权重。**\n", + "\n", + "感知机并没有完全遵循赫布理论,**但通过调输入值的权重,可以有一个非常简单直观的学习方案:给定一个有输入输出实例的训练集,感知机应该「学习」一个函数:对每个例子,若感知机的输出值比实例低太多,则增加它的权重,否则若设比实例高太多,则减少它的权重。**\n", "\n", "\n", "模仿的是生物神经系统内的神经元,它能够接受来自多个源的信号输入,然后将信号转化为便于传播的信号在进行输出(在生物体内表现为电信号)。\n", @@ -40,7 +44,7 @@ "source": [ "## 2. 感知机模型\n", "\n", - "假设输入空间(特征向量)为$X \\subseteq R^n$,输出空间为$Y=\\{-1, +1\\}$。输入$x \\in X$ 表示实例的特征向量,对应于输入空间的点;输出$y \\in Y$表示示例的类别。由输入空间到输出空间的函数为\n", + "假设输入空间(特征向量)为$\\mathbf{X} \\subseteq \\mathbb{R}^n$,输出空间为$\\mathbf{Y} \\in \\{-1, +1\\}$。输入$x \\in \\mathbf{X}$ 表示实例的特征向量,对应于输入空间的点;输出$y \\in \\mathbf{Y}$表示示例的类别。由输入空间到输出空间的函数为\n", "\n", "$$\n", "f(x) = sign(w x + b)\n", @@ -49,13 +53,19 @@ "称为感知机。其中,参数$w$叫做权值向量,$b$称为偏置。$w·x$表示$w$和$x$的内积。$sign$为符号函数,即\n", "![sign_function](images/sign.png)\n", "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ "### 2.1 几何解释 \n", - "感知机模型是线性分类模型,感知机模型的假设空间是定义在特征空间中的所有线性分类模型,即函数集合{f|f(x)=w·x+b}。线性方程 w·x+b=0对应于特征空间Rn中的一个超平面S,其中w是超平面的法向量,b是超平面的截踞。这个超平面把特征空间划分为两部分。位于两侧的点分别为正负两类。超平面S称为分离超平面,如下图:\n", + "感知机模型是线性分类模型,感知机模型的假设空间是定义在特征空间中的所有线性分类模型,即函数集合$\\{ f | f(x)=w·x+b\\}$。线性方程 $w·x+b=0$对应于特征空间$\\mathbb{R}^n$中的一个超平面$S$,其中$w$是超平面的法向量,$b$是超平面的截距。这个超平面把特征空间划分为两部分,位于两侧的点分别为正负两类。超平面$S$称为分离超平面,如下图:\n", "![perceptron_geometry_def](images/perceptron_geometry_def.png)\n", "\n", "### 2.2 生物学类比\n", "![perceptron_2](images/perceptron_2.PNG)\n", - "\n", "\n" ] }, @@ -65,32 +75,43 @@ "source": [ "## 3. 感知机学习策略\n", "\n", - "假设训练数据集是线性可分的,感知机学习的目标是求得一个能够将训练数据的正负实例点完全分开的分离超平面,即最终求得参数w、b。这需要一个学习策略,即定义(经验)损失函数并将损失函数最小化。\n", + "假设训练数据集是 **线性可分**,感知机学习的目标是求得一个能够将训练数据的正负实例点完全分开的分离超平面,即最终求得参数$w, b$。这需要一个学习策略,即定义(经验)损失函数并将损失函数最小化。\n", "\n", - "损失函数的一个自然的选择是误分类的点的总数。但是这样得到的损失函数不是参数w、b的连续可导函数,不宜优化。损失函数的另一个选择是误分类点到分类面的距离之和。\n", + "损失函数的一个自然的选择是误分类的点的总数。但是这样得到的损失函数不是参数$w,b$的连续可导函数,不宜优化。损失函数的另一个选择是误分类点到分类面的距离之和。\n", "\n", - "首先,对于任意一点xo到超平面的距离为\n", + "首先,对于任意一点$x$到超平面的距离([参考资料](https://www.cnblogs.com/graphics/archive/2010/07/10/1774809.html))为\n", "$$\n", - "\\frac{1}{||w||} | w \\cdot xo + b |\n", + "\\frac{1}{||w||} | w \\cdot x + b |\n", "$$\n", "\n", "其次,对于误分类点$(x_i,y_i)$来说 $-y_i(w \\cdot x_i + b) > 0$\n", "\n", - "这样,假设超平面S的总的误分类点集合为M,那么所有误分类点到S的距离之和为\n", + "这样,假设超平面$S$的总的误分类点集合为$\\mathbf{M}$,那么所有误分类点到$S$的距离之和为\n", "$$\n", "-\\frac{1}{||w||} \\sum_{x_i \\in M} y_i (w \\cdot x_i + b)\n", "$$\n", - "不考虑1/||w||,就得到了感知机学习的损失函数。\n", + "不考虑$1/||w||$,就得到了感知机学习的损失函数\n", + "$$\n", + "L = - \\sum_{x_i \\in M} y_i (w \\cdot x_i + b)\n", + "$$\n", "\n", "### 3.1 经验风险函数\n", "\n", - "给定数据集$T = \\{(x_1,y_1), (x_2, y_2), ... (x_N, y_N)\\}$(其中$x_i \\in R^n$, $y_i \\in \\{-1, +1\\},i=1,2...N$),感知机sign(w·x+b)学习的损失函数定义为\n", + "给定数据集$\\mathbf{T} = \\{(x_1,y_1), (x_2, y_2), ... (x_N, y_N)\\}$,其中\n", + "* $x_i \\in \\mathbb{R}^n$\n", + "* $y_i \\in \\{-1, +1\\},i=1,2...N$\n", + "\n", + "感知机$sign(w·x+b)$学习的损失函数定义为\n", "$$\n", - "L(w, b) = - \\sum_{x_i \\in M} y_i (w \\cdot x_i + b)\n", + "L(w, b) = - \\sum_{x_i \\in \\mathbf{M}} y_i (w \\cdot x_i + b)\n", "$$\n", - "其中M为误分类点的集合,这个损失函数就是感知机学习的[《经验风险函数》](https://blog.csdn.net/zhzhx1204/article/details/70163099)。\n", + "其中$\\mathbf{M}$为误分类点的集合,这个损失函数就是感知机学习的[经验风险函数](https://blog.csdn.net/zhzhx1204/article/details/70163099)。\n", "\n", - "显然,损失函数$L(w,b)$是非负的。如果没有误分类点,那么$L(w,b)$为0,误分类点数越少,$L(w,b)$值越小。一个特定的损失函数:在误分类时是参数$w,b$的线性函数,在正确分类时,是0.因此,给定训练数据集T,损失函数$L(w,b)$是$w,b$的连续可导函数。\n" + "显然,损失函数$L(w,b)$是非负的。\n", + "* 如果没有误分类点,那么$L(w,b)$为0\n", + "* 误分类点数越少,$L(w,b)$值越小\n", + "\n", + "一个特定的损失函数:在误分类时是参数$w,b$的线性函数,在正确分类时该损失函数是0。因此,给定训练数据集T,损失函数$L(w,b)$是$w,b$的连续可导函数。\n" ] }, { @@ -100,39 +121,55 @@ "## 4. 感知机学习算法\n", "\n", "\n", - "最优化问题:给定数据集$T = \\{(x_1,y_1), (x_2, y_2), ... (x_N, y_N)\\}$,其中$x_i \\in R^n$, $y_i \\in \\{-1, +1\\},i=1,2...N$,求参数$w,b$,使其成为损失函数的解($M$为误分类的集合):\n", + "最优化问题:给定数据集$\\mathbf{T} = \\{(x_1,y_1), (x_2, y_2), ... (x_N, y_N)\\}$,其中$x_i \\in \\mathbb{R}^n$, $y_i \\in \\{-1, +1\\},i=1,2...N$,求参数$w,b$,使其成为损失函数的解,其中$\\mathbf{M}$为误分类数据的集合:\n", "\n", "$$\n", - "min_{w,b} L(w, b) = - \\sum_{x_i \\in M} y_i (w \\cdot x_i + b)\n", + "min_{w,b} L(w, b) = - \\sum_{x_i \\in \\mathbf{M}} y_i (w \\cdot x_i + b)\n", "$$\n", "\n", - "感知机学习是误分类驱动的,具体采用随机梯度下降法。首先,任意选定$w_0$、$b_0$,然后用梯度下降法不断极小化目标函数,极小化的过程不是一次性的把$M$中的所有误分类点梯度下降,而是一次随机选取一个误分类点使其梯度下降。\n", + "感知机学习是误分类驱动的,具体采用随机梯度下降法:\n", + "* 首先,任意选定$w_0$、$b_0$,\n", + "* 然后用梯度下降法不断极小化目标函数\n", + " - 极小化的过程不是一次性的把$\\mathbf{M}$中的所有误分类点梯度下降\n", + " - 而是一次随机选取一个误分类点使其梯度下降。\n", "\n", - "假设误分类集合$M$是固定的,那么损失函数$L(w,b)$的梯度为\n", + "假设误分类集合$\\mathbf{M}$是固定的,那么损失函数$L(w,b)$的梯度为\n", "$$\n", - "\\triangledown_w L(w, b) = - \\sum_{x_i \\in M} y_i x_i \\\\\n", - "\\triangledown_b L(w, b) = - \\sum_{x_i \\in M} y_i \\\\\n", + "\\triangledown_w L(w, b) = - \\sum_{x_i \\in \\mathbf{M}} y_i x_i \\\\\n", + "\\triangledown_b L(w, b) = - \\sum_{x_i \\in \\mathbf{M}} y_i \\\\\n", "$$\n", "\n", "随机选取一个误分类点$(x_i,y_i)$,对$w,b$进行更新:\n", - "$$\n", - "w = w + \\eta y_i x_i \\\\\n", - "b = b + \\eta y_i\n", - "$$\n", - "\n", - "式中$\\eta$(0 ≤ $ \\eta $ ≤ 1)是学习速率(步长)。步长越大,梯度下降的速度越快,更能接近极小点。如果步长过大,有可能导致跨过极小点,导致函数发散;如果步长过小,有可能会耗很长时间才能达到极小点。\n", - "\n", - "直观解释:当一个实例点被误分类时,调整w,b,使分离超平面向该误分类点的一侧移动,以减少该误分类点与超平面的距离,直至超越该点被正确分类。\n", - "\n", + "\\begin{eqnarray}\n", + "w & = & w + \\eta y_i x_i \\\\\n", + "b & = & b + \\eta y_i\n", + "\\end{eqnarray}\n", "\n", + "式中$\\eta$(0 ≤ $ \\eta $ ≤ 1)是学习速率(步长):\n", + "* 步长越大,梯度下降的速度越快,更能接近极小点。如果步长过大,有可能导致跨过极小点,导致函数发散;\n", + "* 如果步长过小,有可能会耗很长时间才能达到极小点。\n", "\n", + "> 直观解释:当一个实例点被误分类时,调整$w,b$,使分离超平面向该误分类点的一侧移动,以减少该误分类点与超平面的距离,直至超越该点被正确分类。\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ "### 4.1 算法\n", "\n", "\n", - "输入:$T=\\{(x_1,y_1),(x_2,y_2), ..., (x_N,y_N)\\}$, 其中$x_i \\in X=R^n$,$y_i \\in Y = {-1, +1}$,i=1,2...N,学习速率为η\n", + "**输入:**\n", + "* $\\mathbf{T}=\\{(x_1,y_1),(x_2,y_2), ..., (x_N,y_N)\\}$, 其中$x_i \\in \\mathbf{X}=\\mathbb{R}^n$,\n", + "* $y_i \\in \\mathbf{Y} = {-1, +1},i=1,2...N$,\n", + "* 学习速率为η\n", "\n", - "输出:$w$, $b$; 感知机模型$f(x)=sign(w·x+b)$\n", + "**输出:**\n", + "* $w$, $b$; \n", + "* 感知机模型$f(x)=sign(w·x+b)$\n", "\n", + "**处理过程:**\n", "1. 初始化$w_0$,$b_0$\n", "2. 在训练数据集中选取$(x_i, y_i)$\n", "3. 如果$y_i(w * x_i+b)≤0$\n", @@ -142,25 +179,26 @@ " $b = b + η y_i$\n", "\n", "4. 如果所有的样本都正确分类,或者迭代次数超过设定值,则终止\n", - "5. 否则,跳转至(2)\n", - "\n" + "5. 否则,跳转至(2)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## 5. 示例程序\n" + "## 5. 示例程序\n", + "\n", + "生成数据:" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -180,11 +218,11 @@ "# data generation\n", "np.random.seed(314)\n", "\n", - "data_size1 = 20\n", + "data_size1 = 10\n", "x1 = np.random.randn(data_size1, 2) + np.array([2,2])\n", "y1 = [-1 for _ in range(data_size1)]\n", "\n", - "data_size2 = 20\n", + "data_size2 = 10\n", "x2 = np.random.randn(data_size2, 2)*2 + np.array([8,8])\n", "y2 = [1 for _ in range(data_size2)]\n", "\n", @@ -206,8 +244,15 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "学习模型:" + ] + }, + { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "lines_to_end_of_cell_marker": 2 }, @@ -216,56 +261,37 @@ "name": "stdout", "output_type": "stream", "text": [ - "update weight and bias: 3.7185416425430744 4.415441255489154 0.5\n", - "update weight and bias: 2.63445626503829 3.324758332173668 0.0\n", - "update weight and bias: 2.0207439860270506 1.893264739036497 -0.5\n", - "update weight and bias: 1.2322166573021474 0.22799125733467895 -1.0\n", - "update weight and bias: -0.6006428863030957 -1.6411028433624717 -1.5\n", - "update weight and bias: 5.109204567082854 1.9813789454818795 -1.0\n", - "update weight and bias: 4.489662780423084 -0.3506475821384758 -1.5\n", - "update weight and bias: 3.3939105634317013 -1.0412656669082738 -2.0\n", - "update weight and bias: 2.504805392463895 -2.232127455753232 -2.5\n", - "update weight and bias: 6.223347035006969 2.183313799735922 -2.0\n", - "update weight and bias: 5.140304315636703 0.7923315584800992 -2.5\n", - "update weight and bias: 4.5265920366254635 -0.6391620346570717 -3.0\n", - "update weight and bias: 3.6672220497312384 -1.1731993200750104 -3.5\n", - "update weight and bias: 2.0065425403755413 -2.3921089617658904 -4.0\n", - "update weight and bias: 4.533466246969885 1.4498630856120154 -3.5\n", - "update weight and bias: 3.4493808694651005 0.3591801622965294 -4.0\n", - "update weight and bias: 2.5900108825708754 -0.17485712312140933 -4.5\n", - "update weight and bias: 0.9293313732151782 -1.3937667648122891 -5.0\n", - "update weight and bias: 4.046427755076163 3.0054356400349302 -4.5\n", - "update weight and bias: 3.2956963801872607 1.6232728971525268 -5.0\n", - "update weight and bias: 2.6761545935274915 -0.7087536304678286 -5.5\n", - "update weight and bias: 1.0154750841717943 -1.9276632721587084 -6.0\n", - "update weight and bias: 5.37894106506809 3.555613771026151 -5.5\n", - "update weight and bias: 4.7593992784083206 1.2235872434057957 -6.0\n", - "update weight and bias: 4.139857491748551 -1.1084392842145596 -6.5\n", - "update weight and bias: 2.479177982392854 -2.327348925905439 -7.0\n", - "update weight and bias: 5.809083413002281 0.646001016876383 -6.5\n", - "update weight and bias: 5.195371133991041 -0.7854925762607878 -7.0\n", - "update weight and bias: 4.306265963023234 -1.9763543651057456 -7.5\n", - "update weight and bias: 2.88012341642224 -2.622818885634949 -8.0\n", - "update weight and bias: 6.331829427476793 1.6208587585142347 -7.5\n", - "update weight and bias: 4.905686880875798 0.9743942379850314 -8.0\n", - "update weight and bias: 4.371515476010486 -0.46893620150732485 -8.5\n", - "update weight and bias: 2.7108359666547885 -1.6878458431982046 -9.0\n", - "update weight and bias: 6.254961478724868 2.5307472883846627 -8.5\n", - "update weight and bias: 4.663848346587878 0.9710594278881524 -9.0\n", - "update weight and bias: 4.044306559928109 -1.360967099732203 -9.5\n", - "update weight and bias: 2.6181640133271147 -2.007431620261406 -10.0\n", - "update weight and bias: 5.145087719921459 1.8345404271164996 -9.5\n", - "update weight and bias: 4.061002342416674 0.7438575038010136 -10.0\n", - "w = [4.061002342416674, 0.7438575038010136]\n", - "b = -10.0\n", + "update weight/bias: 3.662519607024163 3.038628576040485 0.5\n", + "update weight/bias: 3.1283482021588505 1.595298136548129 0.0\n", + "update weight/bias: 1.7022056555578562 0.9488336160189257 -0.5\n", + "update weight/bias: 0.6064534385664728 0.25821553124912766 -1.0\n", + "update weight/bias: -0.0072588404447664345 -1.1732780618880432 -1.5\n", + "update weight/bias: 3.56979581700504 4.157268901515593 -1.0\n", + "update weight/bias: 2.7104258301108155 3.6232316160976543 -1.5\n", + "update weight/bias: 1.6146736131194321 2.9326135313278563 -2.0\n", + "update weight/bias: 1.0805022082541196 1.4892830918355 -2.5\n", + "update weight/bias: -0.3456403383468747 0.8428185713062968 -3.0\n", + "update weight/bias: 3.4230241861565407 3.6955935657768997 -2.5\n", + "update weight/bias: 2.5636541992623156 3.161556280358961 -3.0\n", + "update weight/bias: 1.1375116526613214 2.5150917598297577 -3.5\n", + "update weight/bias: 0.38678027777241897 1.1329290169473543 -4.0\n", + "update weight/bias: -1.446079265832824 -0.7361650837497964 -4.5\n", + "update weight/bias: 1.7930043074867144 5.9278879714909145 -4.0\n", + "update weight/bias: 1.2588329026214018 4.484557531998558 -4.5\n", + "update weight/bias: 0.3697277316535954 3.2936957431536 -5.0\n", + "update weight/bias: -0.519377439314211 2.1028339543086423 -5.5\n", + "update weight/bias: -2.352236982919454 0.23373985361149163 -6.0\n", + "update weight/bias: 1.8159337720901148 4.415105700242464 -5.5\n", + "update weight/bias: 0.7328910527198487 3.024123458986641 -6.0\n", + "update weight/bias: -0.3501516666504174 1.6331412177308182 -6.5\n", + "w = [-0.3501516666504174, 1.6331412177308182]\n", + "b = -6.5\n", "\n", "\n", - "ground_truth: [ 1. -1. 1. 1. -1. -1. -1. 1. -1. 1. 1. -1. 1. -1. -1. -1. 1. 1.\n", - " -1. -1. -1. -1. -1. -1. 1. 1. 1. 1. 1. -1. -1. 1. 1. -1. 1. -1.\n", - " 1. 1. 1. -1.]\n", - "predicted: [ 1. -1. 1. 1. 1. -1. 1. 1. -1. 1. 1. -1. 1. -1. -1. -1. 1. 1.\n", - " 1. -1. 1. -1. -1. -1. 1. 1. 1. 1. 1. 1. 1. 1. 1. -1. 1. -1.\n", - " 1. 1. 1. -1.]\n" + "ground_truth: [-1. -1. -1. -1. -1. 1. 1. -1. 1. 1. 1. 1. -1. 1. 1. 1. 1. -1.\n", + " -1. -1.]\n", + "predicted: [-1. -1. -1. -1. -1. -1. 1. -1. 1. 1. 1. 1. -1. 1. 1. 1. 1. -1.\n", + " -1. -1.]\n" ] } ], @@ -296,7 +322,7 @@ " weight[0] = weight[0] + learning_rate * y * x1 # 更新权重\n", " weight[1] = weight[1] + learning_rate * y * x2\n", " bias = bias + learning_rate * y # 更新偏置量\n", - " print(\"update weight and bias: \", weight[0], weight[1], bias)\n", + " print(\"update weight/bias: \", weight[0], weight[1], bias)\n", "\n", " return weight, bias\n", "\n", @@ -327,7 +353,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Reference\n", + "## 参考资料\n", "* [感知机(Python实现)](http://www.cnblogs.com/kaituorensheng/p/3561091.html)\n", "* [Programming a Perceptron in Python](https://blog.dbrgn.ch/2013/3/26/perceptrons-in-python/)\n", "* [损失函数、风险函数、经验风险最小化、结构风险最小化](https://blog.csdn.net/zhzhx1204/article/details/70163099)" diff --git a/5_nn/2-mlp_bp.ipynb b/5_nn/2-mlp_bp.ipynb index 55b92f7..1b4340f 100644 --- a/5_nn/2-mlp_bp.ipynb +++ b/5_nn/2-mlp_bp.ipynb @@ -4,7 +4,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# 多层神经网络\n" + "# 多层神经网络\n", + "\n", + "基于生物神经元模型可得到多层感知器(Multi-layer Perceptron, MLP)的基本结构,最典型的MLP包括包括三层:**输入层(Input Layer)**、**隐层(Hidden Layer)**和**输出层(Output Layer)**,MLP神经网络不同层之间是全连接的(全连接的意思就是:上一层的任何一个神经元与下一层的所有神经元都有连接)。\n", + "\n", + "![mlp_theory](images/mlp_theory.gif)\n" ] }, { @@ -49,7 +53,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 2. 神经网络是啥?\n", + "## 2. 神经网络的结构\n", "\n", "![nn1](images/nn1.jpeg)\n", "\n", @@ -63,6 +67,12 @@ "* 第N层的每个神经元和第N-1层的所有神经元相连(这就是full connected的含义),第N-1层神经元的输出就是第N层神经元的输入。\n", "* 每个连接都有一个权值。\n", "\n", + "\n", + "由此可知,神经网络主要有三个基本要素:权重、偏置和激活函数\n", + "* 权重:神经元之间的连接强度由权重表示,权重的大小表示可能性的大小\n", + "* 偏置:偏置的设置是为了正确分类样本,是模型中一个重要的参数,即保证通过输入算出的输出值不能随便激活。\n", + "* 激活函数:起非线性映射的作用,其可将神经元的输出幅度限制在一定范围内,一般限制在(-1~1)或(0~1)之间。最常用的激活函数是Sigmoid函数,其可将(-∞,+∞)的数映射到(0~1)的范围内。\n", + "\n", "上面这些规则定义了全连接神经网络的结构。事实上还存在很多其它结构的神经网络,比如卷积神经网络(CNN)、循环神经网络(RNN),他们都具有不同的连接规则。\n" ] }, @@ -153,13 +163,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "在式2中,\n", + "在(式2)中,\n", "* $f$是激活函数,在本例中是$sigmod$函数;\n", "* $W$是某一层的权重矩阵;\n", "* $\\vec{x}$是某层的输入向量;\n", "* $\\vec{a}$是某层的输出向量。\n", "\n", - "式2说明神经网络的每一层的作用实际上就是先将输入向量左乘一个数组进行线性变换,得到一个新的向量,然后再对这个向量逐元素应用一个激活函数。\n", + "(式2)说明神经网络的每一层的作用实际上就是先将输入向量左乘一个数组进行线性变换,得到一个新的向量,然后再对这个向量逐元素应用一个激活函数。\n", "\n", "每一层的算法都是一样的。比如,对于包含一个输入层,一个输出层和三个隐藏层的神经网络,我们假设其权重矩阵分别为$W_1$,$W_2$,$W_3$,$W_4$,每个隐藏层的输出分别是$\\vec{a}_1$,$\\vec{a}_2$,$\\vec{a}_3$,神经网络的输入为$\\vec{x}$,神经网络的输出为$\\vec{y}$,如下图所示:\n", "\n", @@ -183,8 +193,8 @@ "metadata": {}, "source": [ "\n", - "神经网络正向计算的过程比较简单,就是一层一层不断做运算就可以了,动态的演示如下图所示:\n", - "![](images/nn-forward.gif)" + "神经网络正向计算的过程比较简单,就是一层一层不断做运算,动态的演示如下图所示:\n", + "![](images/neural_network_demo.gif)" ] }, { @@ -193,9 +203,13 @@ "source": [ "## 5. 神经网络的训练 - 反向传播算法\n", "\n", - "神经网络的每个连接上的权值如果知道,那么就可以将输入数据代入得到希望的结果。我们可以说神经网络是一个模型,那么这些权值就是**模型的参数**,也就是模型要学习的东西。然而,一个神经网络的连接方式、网络的层数、每层的节点数这些参数,则不是学习出来的,而是人为事先设置的。对于这些人为设置的参数,我们称之为**超参数(Hyper-Parameters)**。\n", + "神经网络的每个连接上的权值如果知道,那么就可以将输入数据代入得到希望的结果。神经网络是一个模型,那么这些权值就是**模型的参数**,也就是模型要学习的东西。然而,一个神经网络的连接方式、网络的层数、每层的节点数这些参数,则不是学习出来的,而是人为事先设置的。对于这些人为设置的参数,我们称之为**超参数(Hyper-Parameters)**。\n", "\n", - "前面课程中所学的最小二乘、逻辑回归等可以直接优化损失函数来求解模型参数的更新值。在多层神经网络中,最后一层的参数可以用这样的方式求解得到;隐层节点没有输出的真值,因此无法直接构建损失函数来求解,如何化解这个难题?\n", + "前面课程中所学的最小二乘、逻辑回归等可以直接优化损失函数来求解模型参数的更新值。在多层神经网络中:\n", + "* 最后一层的参数可以用这样的方式求解得到;\n", + "* 隐层节点没有输出的真值,因此无法直接构建损失函数来求解\n", + "\n", + "如何化解这个难题?\n", "\n", "反向传播算法其实就是链式求导法则的应用。然而,这个如此简单且显而易见的方法,却是在Roseblatt提出感知器算法将近30年之后才被发明和普及的。对此,Bengio这样回应道:\n", "\n", @@ -213,7 +227,7 @@ "\n", "![bp_weight_update](images/bp_weight_update.png)\n", "\n", - "随机梯度下降算法也就是需要求出误差$E_d$对于每个权重$w_{ji}$的偏导数(也就是梯度),怎么求呢?\n", + "随机梯度下降算法也就是需要求出误差$E_d$对于每个权重$w_{ji}$的偏导数(也就是梯度),如何求解?\n", "\n", "![nn3](images/nn3.png)\n", "\n", @@ -221,7 +235,7 @@ "\n", "![eqn_21_22](images/eqn_21_22.png)\n", "\n", - "$E_d$是$net_j$的函数,而$net_j$是$w_{ji}$的函数。根据链式求导法则,可以得到:(FIXME: change i -> k)\n", + "$E_d$是$net_j$的函数,而$net_j$是$w_{ji}$的函数。根据链式求导法则,可以得到:\n", "\n", "![eqn_23_25](images/eqn_23_25.png)\n", "\n", @@ -432,7 +446,7 @@ "1. sigmoid'(x) ∈ (0,1) 导数缩放\n", "2. x∈(0,1)或x∈(-1,1) 饱和值缩放\n", "\n", - "这样,经过每一层时,Error都是成倍的衰减,一旦进行递推式的多层的反向传播,梯度就会不停的衰减,消失,使得网络学习变慢。而校正激活函数的梯度是1,且只有一端饱和,梯度很好的在反向传播中流动,训练速度得到了很大的提高。" + "这样,经过每一层时,误差都是成倍的衰减,一旦进行递推式的多层的反向传播,梯度就会不停的衰减,消失,使得网络学习变慢。而校正激活函数的梯度是1,且只有一端饱和,梯度很好的在反向传播中流动,训练速度得到了很大的提高。" ] }, { @@ -490,12 +504,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 1, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -534,12 +548,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -589,2031 +603,33 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "epoch [ 0] L = 104.423202, acc = 0.500000\n", - "epoch [ 1] L = 100.893370, acc = 0.525000\n", - "epoch [ 2] L = 97.708048, acc = 0.560000\n", - "epoch [ 3] L = 94.789881, acc = 0.685000\n", - "epoch [ 4] L = 92.079900, acc = 0.750000\n", - "epoch [ 5] L = 89.537059, acc = 0.755000\n", - "epoch [ 6] L = 87.133933, acc = 0.765000\n", - "epoch [ 7] L = 84.852266, acc = 0.780000\n", - "epoch [ 8] L = 82.679642, acc = 0.795000\n", - "epoch [ 9] L = 80.607323, acc = 0.805000\n", - "epoch [ 10] L = 78.628932, acc = 0.805000\n", - "epoch [ 11] L = 76.739658, acc = 0.805000\n", - "epoch [ 12] L = 74.935756, acc = 0.810000\n", - "epoch [ 13] L = 73.214206, acc = 0.810000\n", - "epoch [ 14] L = 71.572471, acc = 0.810000\n", - "epoch [ 15] L = 70.008310, acc = 0.820000\n", - "epoch [ 16] L = 68.519636, acc = 0.825000\n", - "epoch [ 17] L = 67.104410, acc = 0.825000\n", - "epoch [ 18] L = 65.760563, acc = 0.830000\n", - "epoch [ 19] L = 64.485947, acc = 0.830000\n", - "epoch [ 20] L = 63.278308, acc = 0.830000\n", - "epoch [ 21] L = 62.135274, acc = 0.830000\n", - "epoch [ 22] L = 61.054365, acc = 0.830000\n", - "epoch [ 23] L = 60.033001, acc = 0.830000\n", - "epoch [ 24] L = 59.068532, acc = 0.830000\n", - "epoch [ 25] L = 58.158254, acc = 0.830000\n", - "epoch [ 26] L = 57.299447, acc = 0.830000\n", - "epoch [ 27] L = 56.489392, acc = 0.830000\n", - "epoch [ 28] L = 55.725401, acc = 0.830000\n", - "epoch [ 29] L = 55.004839, acc = 0.830000\n", - "epoch [ 30] L = 54.325139, acc = 0.830000\n", - "epoch [ 31] L = 53.683821, acc = 0.830000\n", - "epoch [ 32] L = 53.078504, acc = 0.830000\n", - "epoch [ 33] L = 52.506910, acc = 0.830000\n", - "epoch [ 34] L = 51.966875, acc = 0.830000\n", - "epoch [ 35] L = 51.456352, acc = 0.830000\n", - "epoch [ 36] L = 50.973407, acc = 0.830000\n", - "epoch [ 37] L = 50.516225, acc = 0.830000\n", - "epoch [ 38] L = 50.083104, acc = 0.830000\n", - "epoch [ 39] L = 49.672451, acc = 0.830000\n", - "epoch [ 40] L = 49.282781, acc = 0.830000\n", - "epoch [ 41] L = 48.912712, acc = 0.835000\n", - "epoch [ 42] L = 48.560956, acc = 0.835000\n", - "epoch [ 43] L = 48.226319, acc = 0.835000\n", - "epoch [ 44] L = 47.907692, acc = 0.835000\n", - "epoch [ 45] L = 47.604046, acc = 0.835000\n", - "epoch [ 46] L = 47.314430, acc = 0.835000\n", - "epoch [ 47] L = 47.037961, acc = 0.835000\n", - "epoch [ 48] L = 46.773822, acc = 0.835000\n", - "epoch [ 49] L = 46.521256, acc = 0.835000\n", - "epoch [ 50] L = 46.279563, acc = 0.835000\n", - "epoch [ 51] L = 46.048094, acc = 0.835000\n", - "epoch [ 52] L = 45.826249, acc = 0.835000\n", - "epoch [ 53] L = 45.613471, acc = 0.835000\n", - "epoch [ 54] L = 45.409245, acc = 0.835000\n", - "epoch [ 55] L = 45.213091, acc = 0.835000\n", - "epoch [ 56] L = 45.024567, acc = 0.835000\n", - "epoch [ 57] L = 44.843259, acc = 0.835000\n", - "epoch [ 58] L = 44.668784, acc = 0.840000\n", - "epoch [ 59] L = 44.500787, acc = 0.835000\n", - "epoch [ 60] L = 44.338935, acc = 0.835000\n", - "epoch [ 61] L = 44.182920, acc = 0.835000\n", - "epoch [ 62] L = 44.032454, acc = 0.835000\n", - "epoch [ 63] L = 43.887267, acc = 0.835000\n", - "epoch [ 64] L = 43.747109, acc = 0.835000\n", - "epoch [ 65] L = 43.611745, acc = 0.835000\n", - "epoch [ 66] L = 43.480954, acc = 0.835000\n", - "epoch [ 67] L = 43.354530, acc = 0.835000\n", - "epoch [ 68] L = 43.232281, acc = 0.835000\n", - "epoch [ 69] L = 43.114023, acc = 0.835000\n", - "epoch [ 70] L = 42.999587, acc = 0.835000\n", - "epoch [ 71] L = 42.888811, acc = 0.835000\n", - "epoch [ 72] L = 42.781543, acc = 0.835000\n", - "epoch [ 73] L = 42.677640, acc = 0.835000\n", - "epoch [ 74] L = 42.576967, acc = 0.830000\n", - "epoch [ 75] L = 42.479395, acc = 0.830000\n", - "epoch [ 76] L = 42.384805, acc = 0.830000\n", - "epoch [ 77] L = 42.293080, acc = 0.830000\n", - "epoch [ 78] L = 42.204112, acc = 0.830000\n", - "epoch [ 79] L = 42.117798, acc = 0.830000\n", - "epoch [ 80] L = 42.034038, acc = 0.835000\n", - "epoch [ 81] L = 41.952740, acc = 0.835000\n", - "epoch [ 82] L = 41.873814, acc = 0.835000\n", - "epoch [ 83] L = 41.797175, acc = 0.835000\n", - "epoch [ 84] L = 41.722743, acc = 0.835000\n", - "epoch [ 85] L = 41.650439, acc = 0.835000\n", - "epoch [ 86] L = 41.580189, acc = 0.835000\n", - "epoch [ 87] L = 41.511923, acc = 0.835000\n", - "epoch [ 88] L = 41.445574, acc = 0.835000\n", - "epoch [ 89] L = 41.381075, acc = 0.835000\n", - "epoch [ 90] L = 41.318365, acc = 0.835000\n", - "epoch [ 91] L = 41.257384, acc = 0.835000\n", - "epoch [ 92] L = 41.198075, acc = 0.835000\n", - "epoch [ 93] L = 41.140383, acc = 0.835000\n", - "epoch [ 94] L = 41.084255, acc = 0.835000\n", - "epoch [ 95] L = 41.029641, acc = 0.835000\n", - "epoch [ 96] L = 40.976491, acc = 0.835000\n", - "epoch [ 97] L = 40.924759, acc = 0.835000\n", - "epoch [ 98] L = 40.874400, acc = 0.835000\n", - "epoch [ 99] L = 40.825370, acc = 0.835000\n", - "epoch [ 100] L = 40.777627, acc = 0.835000\n", - "epoch [ 101] L = 40.731131, acc = 0.835000\n", - "epoch [ 102] L = 40.685844, acc = 0.835000\n", - "epoch [ 103] L = 40.641727, acc = 0.835000\n", - "epoch [ 104] L = 40.598744, acc = 0.835000\n", - "epoch [ 105] L = 40.556862, acc = 0.840000\n", - "epoch [ 106] L = 40.516046, acc = 0.840000\n", - "epoch [ 107] L = 40.476263, acc = 0.840000\n", - "epoch [ 108] L = 40.437484, acc = 0.840000\n", - "epoch [ 109] L = 40.399676, acc = 0.840000\n", - "epoch [ 110] L = 40.362812, acc = 0.840000\n", - "epoch [ 111] L = 40.326863, acc = 0.840000\n", - "epoch [ 112] L = 40.291802, acc = 0.840000\n", - "epoch [ 113] L = 40.257603, acc = 0.840000\n", - "epoch [ 114] L = 40.224240, acc = 0.840000\n", - "epoch [ 115] L = 40.191689, acc = 0.840000\n", - "epoch [ 116] L = 40.159926, acc = 0.840000\n", - "epoch [ 117] L = 40.128928, acc = 0.845000\n", - "epoch [ 118] L = 40.098673, acc = 0.850000\n", - "epoch [ 119] L = 40.069140, acc = 0.850000\n", - "epoch [ 120] L = 40.040308, acc = 0.850000\n", - "epoch [ 121] L = 40.012157, acc = 0.850000\n", - "epoch [ 122] L = 39.984667, acc = 0.850000\n", - "epoch [ 123] L = 39.957820, acc = 0.850000\n", - "epoch [ 124] L = 39.931599, acc = 0.850000\n", - "epoch [ 125] L = 39.905984, acc = 0.850000\n", - "epoch [ 126] L = 39.880959, acc = 0.850000\n", - "epoch [ 127] L = 39.856509, acc = 0.850000\n", - "epoch [ 128] L = 39.832616, acc = 0.850000\n", - "epoch [ 129] L = 39.809266, acc = 0.850000\n", - "epoch [ 130] L = 39.786443, acc = 0.850000\n", - "epoch [ 131] L = 39.764134, acc = 0.855000\n", - "epoch [ 132] L = 39.742323, acc = 0.855000\n", - "epoch [ 133] L = 39.720999, acc = 0.855000\n", - "epoch [ 134] L = 39.700147, acc = 0.855000\n", - "epoch [ 135] L = 39.679754, acc = 0.855000\n", - "epoch [ 136] L = 39.659810, acc = 0.855000\n", - "epoch [ 137] L = 39.640301, acc = 0.855000\n", - "epoch [ 138] L = 39.621216, acc = 0.855000\n", - "epoch [ 139] L = 39.602543, acc = 0.855000\n", - "epoch [ 140] L = 39.584273, acc = 0.855000\n", - "epoch [ 141] L = 39.566394, acc = 0.855000\n", - "epoch [ 142] L = 39.548897, acc = 0.855000\n", - "epoch [ 143] L = 39.531770, acc = 0.855000\n", - "epoch [ 144] L = 39.515006, acc = 0.855000\n", - "epoch [ 145] L = 39.498594, acc = 0.855000\n", - "epoch [ 146] L = 39.482525, acc = 0.855000\n", - "epoch [ 147] L = 39.466790, acc = 0.855000\n", - "epoch [ 148] L = 39.451382, acc = 0.855000\n", - "epoch [ 149] L = 39.436292, acc = 0.855000\n", - "epoch [ 150] L = 39.421511, acc = 0.855000\n", - "epoch [ 151] L = 39.407033, acc = 0.855000\n", - "epoch [ 152] L = 39.392849, acc = 0.855000\n", - "epoch [ 153] L = 39.378952, acc = 0.855000\n", - "epoch [ 154] L = 39.365336, acc = 0.855000\n", - "epoch [ 155] L = 39.351992, acc = 0.855000\n", - "epoch [ 156] L = 39.338915, acc = 0.855000\n", - "epoch [ 157] L = 39.326098, acc = 0.855000\n", - "epoch [ 158] L = 39.313534, acc = 0.855000\n", - "epoch [ 159] L = 39.301218, acc = 0.855000\n", - "epoch [ 160] L = 39.289143, acc = 0.855000\n", - "epoch [ 161] L = 39.277304, acc = 0.855000\n", - "epoch [ 162] L = 39.265695, acc = 0.855000\n", - "epoch [ 163] L = 39.254311, acc = 0.855000\n", - "epoch [ 164] L = 39.243145, acc = 0.855000\n", - "epoch [ 165] L = 39.232194, acc = 0.855000\n", - "epoch [ 166] L = 39.221452, acc = 0.855000\n", - "epoch [ 167] L = 39.210913, acc = 0.855000\n", - "epoch [ 168] L = 39.200574, acc = 0.855000\n", - "epoch [ 169] L = 39.190430, acc = 0.855000\n", - "epoch [ 170] L = 39.180476, acc = 0.855000\n", - "epoch [ 171] L = 39.170707, acc = 0.855000\n", - "epoch [ 172] L = 39.161120, acc = 0.855000\n", - "epoch [ 173] L = 39.151711, acc = 0.855000\n", - "epoch [ 174] L = 39.142474, acc = 0.855000\n", - "epoch [ 175] L = 39.133407, acc = 0.855000\n", - "epoch [ 176] L = 39.124505, acc = 0.855000\n", - "epoch [ 177] L = 39.115765, acc = 0.855000\n", - "epoch [ 178] L = 39.107184, acc = 0.855000\n", - "epoch [ 179] L = 39.098757, acc = 0.855000\n", - "epoch [ 180] L = 39.090481, acc = 0.855000\n", - "epoch [ 181] L = 39.082353, acc = 0.855000\n", - "epoch [ 182] L = 39.074369, acc = 0.855000\n", - "epoch [ 183] L = 39.066527, acc = 0.855000\n", - "epoch [ 184] L = 39.058823, acc = 0.855000\n", - "epoch [ 185] L = 39.051254, acc = 0.855000\n", - "epoch [ 186] L = 39.043817, acc = 0.855000\n", - "epoch [ 187] L = 39.036510, acc = 0.855000\n", - "epoch [ 188] L = 39.029330, acc = 0.855000\n", - "epoch [ 189] L = 39.022273, acc = 0.855000\n", - "epoch [ 190] L = 39.015338, acc = 0.855000\n", - "epoch [ 191] L = 39.008521, acc = 0.855000\n", - "epoch [ 192] L = 39.001820, acc = 0.855000\n", - "epoch [ 193] L = 38.995233, acc = 0.855000\n", - "epoch [ 194] L = 38.988758, acc = 0.855000\n", - "epoch [ 195] L = 38.982391, acc = 0.855000\n", - "epoch [ 196] L = 38.976131, acc = 0.855000\n", - "epoch [ 197] L = 38.969975, acc = 0.855000\n", - "epoch [ 198] L = 38.963921, acc = 0.855000\n", - "epoch [ 199] L = 38.957967, acc = 0.855000\n", - "epoch [ 200] L = 38.952112, acc = 0.855000\n", - "epoch [ 201] L = 38.946352, acc = 0.855000\n", - "epoch [ 202] L = 38.940687, acc = 0.855000\n", - "epoch [ 203] L = 38.935113, acc = 0.855000\n", - "epoch [ 204] L = 38.929630, acc = 0.855000\n", - "epoch [ 205] L = 38.924235, acc = 0.855000\n", - "epoch [ 206] L = 38.918927, acc = 0.855000\n", - "epoch [ 207] L = 38.913703, acc = 0.855000\n", - "epoch [ 208] L = 38.908563, acc = 0.855000\n", - "epoch [ 209] L = 38.903504, acc = 0.855000\n", - "epoch [ 210] L = 38.898525, acc = 0.855000\n", - "epoch [ 211] L = 38.893624, acc = 0.855000\n", - "epoch [ 212] L = 38.888799, acc = 0.855000\n", - "epoch [ 213] L = 38.884050, acc = 0.855000\n", - "epoch [ 214] L = 38.879375, acc = 0.855000\n", - "epoch [ 215] L = 38.874772, acc = 0.855000\n", - "epoch [ 216] L = 38.870239, acc = 0.855000\n", - "epoch [ 217] L = 38.865776, acc = 0.855000\n", - "epoch [ 218] L = 38.861381, acc = 0.855000\n", - "epoch [ 219] L = 38.857053, acc = 0.855000\n", - "epoch [ 220] L = 38.852790, acc = 0.855000\n", - "epoch [ 221] L = 38.848591, acc = 0.855000\n", - "epoch [ 222] L = 38.844456, acc = 0.855000\n", - "epoch [ 223] L = 38.840382, acc = 0.855000\n", - "epoch [ 224] L = 38.836368, acc = 0.855000\n", - "epoch [ 225] L = 38.832414, acc = 0.855000\n", - "epoch [ 226] L = 38.828518, acc = 0.855000\n", - "epoch [ 227] L = 38.824680, acc = 0.855000\n", - "epoch [ 228] L = 38.820897, acc = 0.855000\n", - "epoch [ 229] L = 38.817169, acc = 0.855000\n", - "epoch [ 230] L = 38.813496, acc = 0.855000\n", - "epoch [ 231] L = 38.809875, acc = 0.855000\n", - "epoch [ 232] L = 38.806306, acc = 0.855000\n", - "epoch [ 233] L = 38.802789, acc = 0.855000\n", - "epoch [ 234] L = 38.799321, acc = 0.855000\n", - "epoch [ 235] L = 38.795902, acc = 0.855000\n", - "epoch [ 236] L = 38.792532, acc = 0.855000\n", - "epoch [ 237] L = 38.789209, acc = 0.855000\n", - "epoch [ 238] L = 38.785932, acc = 0.855000\n", - "epoch [ 239] L = 38.782701, acc = 0.855000\n", - "epoch [ 240] L = 38.779515, acc = 0.855000\n", - "epoch [ 241] L = 38.776373, acc = 0.855000\n", - "epoch [ 242] L = 38.773274, acc = 0.855000\n", - "epoch [ 243] L = 38.770217, acc = 0.855000\n", - "epoch [ 244] L = 38.767202, acc = 0.850000\n", - "epoch [ 245] L = 38.764227, acc = 0.850000\n", - "epoch [ 246] L = 38.761293, acc = 0.850000\n", - "epoch [ 247] L = 38.758398, acc = 0.850000\n", - "epoch [ 248] L = 38.755542, acc = 0.850000\n", - "epoch [ 249] L = 38.752723, acc = 0.850000\n", - "epoch [ 250] L = 38.749942, acc = 0.850000\n", - "epoch [ 251] L = 38.747198, acc = 0.850000\n", - "epoch [ 252] L = 38.744490, acc = 0.850000\n", - "epoch [ 253] L = 38.741817, acc = 0.850000\n", - "epoch [ 254] L = 38.739179, acc = 0.850000\n", - "epoch [ 255] L = 38.736574, acc = 0.850000\n", - "epoch [ 256] L = 38.734004, acc = 0.845000\n", - "epoch [ 257] L = 38.731466, acc = 0.845000\n", - "epoch [ 258] L = 38.728961, acc = 0.845000\n", - "epoch [ 259] L = 38.726487, acc = 0.845000\n", - "epoch [ 260] L = 38.724045, acc = 0.845000\n", - "epoch [ 261] L = 38.721633, acc = 0.845000\n", - "epoch [ 262] L = 38.719252, acc = 0.845000\n", - "epoch [ 263] L = 38.716900, acc = 0.845000\n", - "epoch [ 264] L = 38.714577, acc = 0.845000\n", - "epoch [ 265] L = 38.712283, acc = 0.845000\n", - "epoch [ 266] L = 38.710017, acc = 0.845000\n", - "epoch [ 267] L = 38.707778, acc = 0.845000\n", - "epoch [ 268] L = 38.705567, acc = 0.845000\n", - "epoch [ 269] L = 38.703383, acc = 0.845000\n", - "epoch [ 270] L = 38.701224, acc = 0.845000\n", - "epoch [ 271] L = 38.699092, acc = 0.845000\n", - "epoch [ 272] L = 38.696985, acc = 0.845000\n", - "epoch [ 273] L = 38.694903, acc = 0.845000\n", - "epoch [ 274] L = 38.692845, acc = 0.845000\n", - "epoch [ 275] L = 38.690812, acc = 0.845000\n", - "epoch [ 276] L = 38.688802, acc = 0.845000\n", - "epoch [ 277] L = 38.686815, acc = 0.845000\n", - "epoch [ 278] L = 38.684852, acc = 0.845000\n", - "epoch [ 279] L = 38.682911, acc = 0.845000\n", - "epoch [ 280] L = 38.680992, acc = 0.845000\n", - "epoch [ 281] L = 38.679094, acc = 0.845000\n", - "epoch [ 282] L = 38.677219, acc = 0.845000\n", - "epoch [ 283] L = 38.675364, acc = 0.845000\n", - "epoch [ 284] L = 38.673530, acc = 0.845000\n", - "epoch [ 285] L = 38.671716, acc = 0.845000\n", - "epoch [ 286] L = 38.669923, acc = 0.845000\n", - "epoch [ 287] L = 38.668149, acc = 0.845000\n", - "epoch [ 288] L = 38.666394, acc = 0.845000\n", - "epoch [ 289] L = 38.664659, acc = 0.845000\n", - "epoch [ 290] L = 38.662942, acc = 0.845000\n", - "epoch [ 291] L = 38.661244, acc = 0.845000\n", - "epoch [ 292] L = 38.659564, acc = 0.845000\n", - "epoch [ 293] L = 38.657901, acc = 0.845000\n", - "epoch [ 294] L = 38.656257, acc = 0.845000\n", - "epoch [ 295] L = 38.654629, acc = 0.845000\n", - "epoch [ 296] L = 38.653019, acc = 0.845000\n", - "epoch [ 297] L = 38.651425, acc = 0.845000\n", - "epoch [ 298] L = 38.649847, acc = 0.845000\n", - "epoch [ 299] L = 38.648286, acc = 0.845000\n", - "epoch [ 300] L = 38.646741, acc = 0.845000\n", - "epoch [ 301] L = 38.645211, acc = 0.845000\n", - "epoch [ 302] L = 38.643697, acc = 0.845000\n", - "epoch [ 303] L = 38.642198, acc = 0.845000\n", - "epoch [ 304] L = 38.640714, acc = 0.845000\n", - "epoch [ 305] L = 38.639244, acc = 0.845000\n", - "epoch [ 306] L = 38.637789, acc = 0.845000\n", - "epoch [ 307] L = 38.636348, acc = 0.845000\n", - "epoch [ 308] L = 38.634921, acc = 0.845000\n", - "epoch [ 309] L = 38.633508, acc = 0.845000\n", - "epoch [ 310] L = 38.632109, acc = 0.845000\n", - "epoch [ 311] L = 38.630722, acc = 0.845000\n", - "epoch [ 312] L = 38.629349, acc = 0.845000\n", - "epoch [ 313] L = 38.627989, acc = 0.845000\n", - "epoch [ 314] L = 38.626641, acc = 0.845000\n", - "epoch [ 315] L = 38.625306, acc = 0.845000\n", - "epoch [ 316] L = 38.623984, acc = 0.845000\n", - "epoch [ 317] L = 38.622673, acc = 0.845000\n", - "epoch [ 318] L = 38.621374, acc = 0.845000\n", - "epoch [ 319] L = 38.620087, acc = 0.845000\n", - "epoch [ 320] L = 38.618812, acc = 0.845000\n", - "epoch [ 321] L = 38.617547, acc = 0.845000\n", - "epoch [ 322] L = 38.616294, acc = 0.845000\n", - "epoch [ 323] L = 38.615053, acc = 0.845000\n", - "epoch [ 324] L = 38.613821, acc = 0.845000\n", - "epoch [ 325] L = 38.612601, acc = 0.845000\n", - "epoch [ 326] L = 38.611391, acc = 0.845000\n", - "epoch [ 327] L = 38.610191, acc = 0.845000\n", - "epoch [ 328] L = 38.609002, acc = 0.845000\n", - "epoch [ 329] L = 38.607822, acc = 0.845000\n", - "epoch [ 330] L = 38.606653, acc = 0.845000\n", - "epoch [ 331] L = 38.605493, acc = 0.845000\n", - "epoch [ 332] L = 38.604343, acc = 0.845000\n", - "epoch [ 333] L = 38.603202, acc = 0.845000\n", - "epoch [ 334] L = 38.602070, acc = 0.845000\n", - "epoch [ 335] L = 38.600947, acc = 0.845000\n", - "epoch [ 336] L = 38.599834, acc = 0.845000\n", - "epoch [ 337] L = 38.598729, acc = 0.845000\n", - "epoch [ 338] L = 38.597633, acc = 0.845000\n", - "epoch [ 339] L = 38.596545, acc = 0.845000\n", - "epoch [ 340] L = 38.595466, acc = 0.845000\n", - "epoch [ 341] L = 38.594395, acc = 0.845000\n", - "epoch [ 342] L = 38.593333, acc = 0.845000\n", - "epoch [ 343] L = 38.592278, acc = 0.845000\n", - "epoch [ 344] L = 38.591231, acc = 0.845000\n", - "epoch [ 345] L = 38.590192, acc = 0.845000\n", - "epoch [ 346] L = 38.589161, acc = 0.845000\n", - "epoch [ 347] L = 38.588137, acc = 0.845000\n", - "epoch [ 348] L = 38.587121, acc = 0.845000\n", - "epoch [ 349] L = 38.586112, acc = 0.845000\n", - "epoch [ 350] L = 38.585111, acc = 0.845000\n", - "epoch [ 351] L = 38.584116, acc = 0.845000\n", - "epoch [ 352] L = 38.583128, acc = 0.845000\n", - "epoch [ 353] L = 38.582147, acc = 0.845000\n", - "epoch [ 354] L = 38.581173, acc = 0.845000\n", - "epoch [ 355] L = 38.580206, acc = 0.845000\n", - "epoch [ 356] L = 38.579245, acc = 0.845000\n", - "epoch [ 357] L = 38.578291, acc = 0.845000\n", - "epoch [ 358] L = 38.577343, acc = 0.845000\n", - "epoch [ 359] L = 38.576401, acc = 0.845000\n", - "epoch [ 360] L = 38.575466, acc = 0.845000\n", - "epoch [ 361] L = 38.574536, acc = 0.845000\n", - "epoch [ 362] L = 38.573613, acc = 0.845000\n", - "epoch [ 363] L = 38.572695, acc = 0.845000\n", - "epoch [ 364] L = 38.571784, acc = 0.845000\n", - "epoch [ 365] L = 38.570877, acc = 0.845000\n", - "epoch [ 366] L = 38.569977, acc = 0.845000\n", - "epoch [ 367] L = 38.569082, acc = 0.845000\n", - "epoch [ 368] L = 38.568193, acc = 0.845000\n", - "epoch [ 369] L = 38.567308, acc = 0.845000\n", - "epoch [ 370] L = 38.566429, acc = 0.845000\n", - "epoch [ 371] L = 38.565556, acc = 0.845000\n", - "epoch [ 372] L = 38.564687, acc = 0.845000\n", - "epoch [ 373] L = 38.563824, acc = 0.845000\n", - "epoch [ 374] L = 38.562965, acc = 0.845000\n", - "epoch [ 375] L = 38.562111, acc = 0.845000\n", - "epoch [ 376] L = 38.561262, acc = 0.845000\n", - "epoch [ 377] L = 38.560418, acc = 0.845000\n", - "epoch [ 378] L = 38.559578, acc = 0.845000\n", - "epoch [ 379] L = 38.558743, acc = 0.845000\n", - "epoch [ 380] L = 38.557913, acc = 0.845000\n", - "epoch [ 381] L = 38.557087, acc = 0.845000\n", - "epoch [ 382] L = 38.556265, acc = 0.845000\n", - "epoch [ 383] L = 38.555448, acc = 0.845000\n", - "epoch [ 384] L = 38.554635, acc = 0.845000\n", - "epoch [ 385] L = 38.553825, acc = 0.845000\n", - "epoch [ 386] L = 38.553021, acc = 0.845000\n", - "epoch [ 387] L = 38.552220, acc = 0.845000\n", - "epoch [ 388] L = 38.551423, acc = 0.845000\n", - "epoch [ 389] L = 38.550630, acc = 0.845000\n", - "epoch [ 390] L = 38.549840, acc = 0.845000\n", - "epoch [ 391] L = 38.549055, acc = 0.845000\n", - "epoch [ 392] L = 38.548273, acc = 0.845000\n", - "epoch [ 393] L = 38.547495, acc = 0.845000\n", - "epoch [ 394] L = 38.546720, acc = 0.845000\n", - "epoch [ 395] L = 38.545949, acc = 0.845000\n", - "epoch [ 396] L = 38.545182, acc = 0.845000\n", - "epoch [ 397] L = 38.544418, acc = 0.845000\n", - "epoch [ 398] L = 38.543657, acc = 0.845000\n", - "epoch [ 399] L = 38.542900, acc = 0.845000\n", - "epoch [ 400] L = 38.542146, acc = 0.845000\n", - "epoch [ 401] L = 38.541395, acc = 0.845000\n", - "epoch [ 402] L = 38.540647, acc = 0.845000\n", - "epoch [ 403] L = 38.539902, acc = 0.845000\n", - "epoch [ 404] L = 38.539161, acc = 0.845000\n", - "epoch [ 405] L = 38.538422, acc = 0.845000\n", - "epoch [ 406] L = 38.537686, acc = 0.845000\n", - "epoch [ 407] L = 38.536953, acc = 0.845000\n", - "epoch [ 408] L = 38.536223, acc = 0.845000\n", - "epoch [ 409] L = 38.535496, acc = 0.845000\n", - "epoch [ 410] L = 38.534772, acc = 0.845000\n", - "epoch [ 411] L = 38.534050, acc = 0.850000\n", - "epoch [ 412] L = 38.533331, acc = 0.850000\n", - "epoch [ 413] L = 38.532614, acc = 0.850000\n", - "epoch [ 414] L = 38.531901, acc = 0.850000\n", - "epoch [ 415] L = 38.531189, acc = 0.850000\n", - "epoch [ 416] L = 38.530480, acc = 0.850000\n", - "epoch [ 417] L = 38.529774, acc = 0.850000\n", - "epoch [ 418] L = 38.529070, acc = 0.850000\n", - "epoch [ 419] L = 38.528368, acc = 0.850000\n", - "epoch [ 420] L = 38.527669, acc = 0.850000\n", - "epoch [ 421] L = 38.526971, acc = 0.850000\n", - "epoch [ 422] L = 38.526276, acc = 0.850000\n", - "epoch [ 423] L = 38.525584, acc = 0.850000\n", - "epoch [ 424] L = 38.524893, acc = 0.850000\n", - "epoch [ 425] L = 38.524204, acc = 0.850000\n", - "epoch [ 426] L = 38.523518, acc = 0.850000\n", - "epoch [ 427] L = 38.522834, acc = 0.850000\n", - "epoch [ 428] L = 38.522151, acc = 0.850000\n", - "epoch [ 429] L = 38.521471, acc = 0.850000\n", - "epoch [ 430] L = 38.520792, acc = 0.850000\n", - "epoch [ 431] L = 38.520115, acc = 0.850000\n", - "epoch [ 432] L = 38.519441, acc = 0.850000\n", - "epoch [ 433] L = 38.518768, acc = 0.850000\n", - "epoch [ 434] L = 38.518096, acc = 0.850000\n", - "epoch [ 435] L = 38.517427, acc = 0.850000\n", - "epoch [ 436] L = 38.516759, acc = 0.850000\n", - "epoch [ 437] L = 38.516093, acc = 0.850000\n", - "epoch [ 438] L = 38.515428, acc = 0.850000\n", - "epoch [ 439] L = 38.514765, acc = 0.850000\n", - "epoch [ 440] L = 38.514104, acc = 0.850000\n", - "epoch [ 441] L = 38.513444, acc = 0.850000\n", - "epoch [ 442] L = 38.512786, acc = 0.850000\n", - "epoch [ 443] L = 38.512129, acc = 0.850000\n", - "epoch [ 444] L = 38.511473, acc = 0.850000\n", - "epoch [ 445] L = 38.510819, acc = 0.850000\n", - "epoch [ 446] L = 38.510167, acc = 0.850000\n", - "epoch [ 447] L = 38.509515, acc = 0.850000\n", - "epoch [ 448] L = 38.508865, acc = 0.850000\n", - "epoch [ 449] L = 38.508217, acc = 0.850000\n", - "epoch [ 450] L = 38.507569, acc = 0.850000\n", - "epoch [ 451] L = 38.506923, acc = 0.850000\n", - "epoch [ 452] L = 38.506278, acc = 0.850000\n", - "epoch [ 453] L = 38.505634, acc = 0.850000\n", - "epoch [ 454] L = 38.504992, acc = 0.850000\n", - "epoch [ 455] L = 38.504350, acc = 0.850000\n", - "epoch [ 456] L = 38.503709, acc = 0.850000\n", - "epoch [ 457] L = 38.503070, acc = 0.850000\n", - "epoch [ 458] L = 38.502432, acc = 0.850000\n", - "epoch [ 459] L = 38.501794, acc = 0.850000\n", - "epoch [ 460] L = 38.501158, acc = 0.850000\n", - "epoch [ 461] L = 38.500522, acc = 0.850000\n", - "epoch [ 462] L = 38.499888, acc = 0.850000\n", - "epoch [ 463] L = 38.499254, acc = 0.850000\n", - "epoch [ 464] L = 38.498621, acc = 0.850000\n", - "epoch [ 465] L = 38.497990, acc = 0.850000\n", - "epoch [ 466] L = 38.497359, acc = 0.850000\n", - "epoch [ 467] L = 38.496728, acc = 0.850000\n", - "epoch [ 468] L = 38.496099, acc = 0.850000\n", - "epoch [ 469] L = 38.495470, acc = 0.850000\n", - "epoch [ 470] L = 38.494842, acc = 0.850000\n", - "epoch [ 471] L = 38.494215, acc = 0.850000\n", - "epoch [ 472] L = 38.493588, acc = 0.850000\n", - "epoch [ 473] L = 38.492962, acc = 0.850000\n", - "epoch [ 474] L = 38.492337, acc = 0.850000\n", - "epoch [ 475] L = 38.491712, acc = 0.850000\n", - "epoch [ 476] L = 38.491088, acc = 0.850000\n", - "epoch [ 477] L = 38.490464, acc = 0.850000\n", - "epoch [ 478] L = 38.489841, acc = 0.850000\n", - "epoch [ 479] L = 38.489219, acc = 0.850000\n", - "epoch [ 480] L = 38.488597, acc = 0.850000\n", - "epoch [ 481] L = 38.487975, acc = 0.850000\n", - "epoch [ 482] L = 38.487354, acc = 0.850000\n", - "epoch [ 483] L = 38.486734, acc = 0.850000\n", - "epoch [ 484] L = 38.486114, acc = 0.850000\n", - "epoch [ 485] L = 38.485494, acc = 0.850000\n", - "epoch [ 486] L = 38.484874, acc = 0.850000\n", - "epoch [ 487] L = 38.484255, acc = 0.850000\n", - "epoch [ 488] L = 38.483636, acc = 0.850000\n", - "epoch [ 489] L = 38.483018, acc = 0.850000\n", - "epoch [ 490] L = 38.482400, acc = 0.850000\n", - "epoch [ 491] L = 38.481782, acc = 0.850000\n", - "epoch [ 492] L = 38.481164, acc = 0.850000\n", - "epoch [ 493] L = 38.480547, acc = 0.850000\n", - "epoch [ 494] L = 38.479930, acc = 0.850000\n", - "epoch [ 495] L = 38.479313, acc = 0.850000\n", - "epoch [ 496] L = 38.478696, acc = 0.850000\n", - "epoch [ 497] L = 38.478079, acc = 0.850000\n", - "epoch [ 498] L = 38.477463, acc = 0.850000\n", - "epoch [ 499] L = 38.476846, acc = 0.850000\n", - "epoch [ 500] L = 38.476230, acc = 0.850000\n", - "epoch [ 501] L = 38.475614, acc = 0.850000\n", - "epoch [ 502] L = 38.474998, acc = 0.850000\n", - "epoch [ 503] L = 38.474381, acc = 0.850000\n", - "epoch [ 504] L = 38.473765, acc = 0.850000\n", - "epoch [ 505] L = 38.473149, acc = 0.850000\n", - "epoch [ 506] L = 38.472533, acc = 0.850000\n", - "epoch [ 507] L = 38.471917, acc = 0.850000\n", - "epoch [ 508] L = 38.471301, acc = 0.850000\n", - "epoch [ 509] L = 38.470684, acc = 0.850000\n", - "epoch [ 510] L = 38.470068, acc = 0.850000\n", - "epoch [ 511] L = 38.469451, acc = 0.850000\n", - "epoch [ 512] L = 38.468835, acc = 0.850000\n", - "epoch [ 513] L = 38.468218, acc = 0.850000\n", - "epoch [ 514] L = 38.467601, acc = 0.850000\n", - "epoch [ 515] L = 38.466984, acc = 0.850000\n", - "epoch [ 516] L = 38.466367, acc = 0.850000\n", - "epoch [ 517] L = 38.465750, acc = 0.850000\n", - "epoch [ 518] L = 38.465132, acc = 0.850000\n", - "epoch [ 519] L = 38.464514, acc = 0.850000\n", - "epoch [ 520] L = 38.463896, acc = 0.850000\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch [ 521] L = 38.463277, acc = 0.850000\n", - "epoch [ 522] L = 38.462659, acc = 0.850000\n", - "epoch [ 523] L = 38.462040, acc = 0.850000\n", - "epoch [ 524] L = 38.461420, acc = 0.850000\n", - "epoch [ 525] L = 38.460800, acc = 0.850000\n", - "epoch [ 526] L = 38.460180, acc = 0.850000\n", - "epoch [ 527] L = 38.459560, acc = 0.850000\n", - "epoch [ 528] L = 38.458939, acc = 0.850000\n", - "epoch [ 529] L = 38.458318, acc = 0.850000\n", - "epoch [ 530] L = 38.457696, acc = 0.850000\n", - "epoch [ 531] L = 38.457074, acc = 0.850000\n", - "epoch [ 532] L = 38.456452, acc = 0.850000\n", - "epoch [ 533] L = 38.455829, acc = 0.850000\n", - "epoch [ 534] L = 38.455205, acc = 0.850000\n", - "epoch [ 535] L = 38.454581, acc = 0.850000\n", - "epoch [ 536] L = 38.453957, acc = 0.850000\n", - "epoch [ 537] L = 38.453332, acc = 0.850000\n", - "epoch [ 538] L = 38.452706, acc = 0.850000\n", - "epoch [ 539] L = 38.452080, acc = 0.850000\n", - "epoch [ 540] L = 38.451453, acc = 0.850000\n", - "epoch [ 541] L = 38.450826, acc = 0.850000\n", - "epoch [ 542] L = 38.450198, acc = 0.850000\n", - "epoch [ 543] L = 38.449569, acc = 0.850000\n", - "epoch [ 544] L = 38.448940, acc = 0.850000\n", - "epoch [ 545] L = 38.448310, acc = 0.850000\n", - "epoch [ 546] L = 38.447680, acc = 0.850000\n", - "epoch [ 547] L = 38.447049, acc = 0.850000\n", - "epoch [ 548] L = 38.446417, acc = 0.850000\n", - "epoch [ 549] L = 38.445784, acc = 0.850000\n", - "epoch [ 550] L = 38.445151, acc = 0.850000\n", - "epoch [ 551] L = 38.444517, acc = 0.850000\n", - "epoch [ 552] L = 38.443882, acc = 0.850000\n", - "epoch [ 553] L = 38.443246, acc = 0.850000\n", - "epoch [ 554] L = 38.442610, acc = 0.850000\n", - "epoch [ 555] L = 38.441973, acc = 0.850000\n", - "epoch [ 556] L = 38.441335, acc = 0.850000\n", - "epoch [ 557] L = 38.440696, acc = 0.850000\n", - "epoch [ 558] L = 38.440056, acc = 0.850000\n", - "epoch [ 559] L = 38.439416, acc = 0.850000\n", - "epoch [ 560] L = 38.438774, acc = 0.850000\n", - "epoch [ 561] L = 38.438132, acc = 0.850000\n", - "epoch [ 562] L = 38.437489, acc = 0.850000\n", - "epoch [ 563] L = 38.436844, acc = 0.850000\n", - "epoch [ 564] L = 38.436199, acc = 0.850000\n", - "epoch [ 565] L = 38.435553, acc = 0.850000\n", - "epoch [ 566] L = 38.434906, acc = 0.850000\n", - "epoch [ 567] L = 38.434258, acc = 0.850000\n", - "epoch [ 568] L = 38.433609, acc = 0.850000\n", - "epoch [ 569] L = 38.432959, acc = 0.850000\n", - "epoch [ 570] L = 38.432308, acc = 0.850000\n", - "epoch [ 571] L = 38.431656, acc = 0.850000\n", - "epoch [ 572] L = 38.431003, acc = 0.850000\n", - "epoch [ 573] L = 38.430348, acc = 0.850000\n", - "epoch [ 574] L = 38.429693, acc = 0.850000\n", - "epoch [ 575] L = 38.429037, acc = 0.850000\n", - "epoch [ 576] L = 38.428379, acc = 0.850000\n", - "epoch [ 577] L = 38.427720, acc = 0.850000\n", - "epoch [ 578] L = 38.427060, acc = 0.850000\n", - "epoch [ 579] L = 38.426399, acc = 0.850000\n", - "epoch [ 580] L = 38.425737, acc = 0.850000\n", - "epoch [ 581] L = 38.425074, acc = 0.850000\n", - "epoch [ 582] L = 38.424409, acc = 0.850000\n", - "epoch [ 583] L = 38.423743, acc = 0.850000\n", - "epoch [ 584] L = 38.423076, acc = 0.850000\n", - "epoch [ 585] L = 38.422408, acc = 0.850000\n", - "epoch [ 586] L = 38.421739, acc = 0.850000\n", - "epoch [ 587] L = 38.421068, acc = 0.850000\n", - "epoch [ 588] L = 38.420396, acc = 0.850000\n", - "epoch [ 589] L = 38.419722, acc = 0.850000\n", - "epoch [ 590] L = 38.419047, acc = 0.850000\n", - "epoch [ 591] L = 38.418371, acc = 0.850000\n", - "epoch [ 592] L = 38.417694, acc = 0.850000\n", - "epoch [ 593] L = 38.417015, acc = 0.850000\n", - "epoch [ 594] L = 38.416335, acc = 0.850000\n", - "epoch [ 595] L = 38.415653, acc = 0.850000\n", - "epoch [ 596] L = 38.414970, acc = 0.850000\n", - "epoch [ 597] L = 38.414285, acc = 0.850000\n", - "epoch [ 598] L = 38.413599, acc = 0.850000\n", - "epoch [ 599] L = 38.412912, acc = 0.850000\n", - "epoch [ 600] L = 38.412223, acc = 0.850000\n", - "epoch [ 601] L = 38.411533, acc = 0.850000\n", - "epoch [ 602] L = 38.410841, acc = 0.850000\n", - "epoch [ 603] L = 38.410147, acc = 0.850000\n", - "epoch [ 604] L = 38.409452, acc = 0.850000\n", - "epoch [ 605] L = 38.408756, acc = 0.850000\n", - "epoch [ 606] L = 38.408058, acc = 0.850000\n", - "epoch [ 607] L = 38.407358, acc = 0.850000\n", - "epoch [ 608] L = 38.406657, acc = 0.850000\n", - "epoch [ 609] L = 38.405954, acc = 0.850000\n", - "epoch [ 610] L = 38.405249, acc = 0.850000\n", - "epoch [ 611] L = 38.404543, acc = 0.850000\n", - "epoch [ 612] L = 38.403835, acc = 0.850000\n", - "epoch [ 613] L = 38.403126, acc = 0.850000\n", - "epoch [ 614] L = 38.402414, acc = 0.850000\n", - "epoch [ 615] L = 38.401701, acc = 0.850000\n", - "epoch [ 616] L = 38.400987, acc = 0.850000\n", - "epoch [ 617] L = 38.400270, acc = 0.850000\n", - "epoch [ 618] L = 38.399552, acc = 0.850000\n", - "epoch [ 619] L = 38.398832, acc = 0.850000\n", - "epoch [ 620] L = 38.398110, acc = 0.850000\n", - "epoch [ 621] L = 38.397387, acc = 0.850000\n", - "epoch [ 622] L = 38.396661, acc = 0.850000\n", - "epoch [ 623] L = 38.395934, acc = 0.850000\n", - "epoch [ 624] L = 38.395205, acc = 0.850000\n", - "epoch [ 625] L = 38.394474, acc = 0.850000\n", - "epoch [ 626] L = 38.393741, acc = 0.850000\n", - "epoch [ 627] L = 38.393006, acc = 0.850000\n", - "epoch [ 628] L = 38.392269, acc = 0.850000\n", - "epoch [ 629] L = 38.391531, acc = 0.850000\n", - "epoch [ 630] L = 38.390790, acc = 0.850000\n", - "epoch [ 631] L = 38.390047, acc = 0.850000\n", - "epoch [ 632] L = 38.389303, acc = 0.850000\n", - "epoch [ 633] L = 38.388556, acc = 0.850000\n", - "epoch [ 634] L = 38.387807, acc = 0.850000\n", - "epoch [ 635] L = 38.387057, acc = 0.850000\n", - "epoch [ 636] L = 38.386304, acc = 0.850000\n", - "epoch [ 637] L = 38.385549, acc = 0.850000\n", - "epoch [ 638] L = 38.384792, acc = 0.850000\n", - "epoch [ 639] L = 38.384033, acc = 0.850000\n", - "epoch [ 640] L = 38.383272, acc = 0.850000\n", - "epoch [ 641] L = 38.382508, acc = 0.850000\n", - "epoch [ 642] L = 38.381743, acc = 0.850000\n", - "epoch [ 643] L = 38.380975, acc = 0.850000\n", - "epoch [ 644] L = 38.380205, acc = 0.850000\n", - "epoch [ 645] L = 38.379433, acc = 0.850000\n", - "epoch [ 646] L = 38.378658, acc = 0.850000\n", - "epoch [ 647] L = 38.377882, acc = 0.850000\n", - "epoch [ 648] L = 38.377103, acc = 0.850000\n", - "epoch [ 649] L = 38.376321, acc = 0.850000\n", - "epoch [ 650] L = 38.375538, acc = 0.850000\n", - "epoch [ 651] L = 38.374752, acc = 0.850000\n", - "epoch [ 652] L = 38.373964, acc = 0.850000\n", - "epoch [ 653] L = 38.373173, acc = 0.850000\n", - "epoch [ 654] L = 38.372380, acc = 0.850000\n", - "epoch [ 655] L = 38.371585, acc = 0.850000\n", - "epoch [ 656] L = 38.370787, acc = 0.850000\n", - "epoch [ 657] L = 38.369986, acc = 0.850000\n", - "epoch [ 658] L = 38.369184, acc = 0.850000\n", - "epoch [ 659] L = 38.368378, acc = 0.850000\n", - "epoch [ 660] L = 38.367570, acc = 0.850000\n", - "epoch [ 661] L = 38.366760, acc = 0.850000\n", - "epoch [ 662] L = 38.365947, acc = 0.850000\n", - "epoch [ 663] L = 38.365132, acc = 0.850000\n", - "epoch [ 664] L = 38.364314, acc = 0.850000\n", - "epoch [ 665] L = 38.363493, acc = 0.850000\n", - "epoch [ 666] L = 38.362670, acc = 0.850000\n", - "epoch [ 667] L = 38.361844, acc = 0.850000\n", - "epoch [ 668] L = 38.361015, acc = 0.850000\n", - "epoch [ 669] L = 38.360184, acc = 0.850000\n", - "epoch [ 670] L = 38.359350, acc = 0.850000\n", - "epoch [ 671] L = 38.358513, acc = 0.850000\n", - "epoch [ 672] L = 38.357674, acc = 0.850000\n", - "epoch [ 673] L = 38.356832, acc = 0.850000\n", - "epoch [ 674] L = 38.355987, acc = 0.850000\n", - "epoch [ 675] L = 38.355139, acc = 0.850000\n", - "epoch [ 676] L = 38.354288, acc = 0.850000\n", - "epoch [ 677] L = 38.353435, acc = 0.850000\n", - "epoch [ 678] L = 38.352578, acc = 0.850000\n", - "epoch [ 679] L = 38.351719, acc = 0.850000\n", - "epoch [ 680] L = 38.350857, acc = 0.850000\n", - "epoch [ 681] L = 38.349992, acc = 0.850000\n", - "epoch [ 682] L = 38.349124, acc = 0.850000\n", - "epoch [ 683] L = 38.348253, acc = 0.850000\n", - "epoch [ 684] L = 38.347378, acc = 0.850000\n", - "epoch [ 685] L = 38.346501, acc = 0.850000\n", - "epoch [ 686] L = 38.345621, acc = 0.850000\n", - "epoch [ 687] L = 38.344738, acc = 0.850000\n", - "epoch [ 688] L = 38.343852, acc = 0.850000\n", - "epoch [ 689] L = 38.342962, acc = 0.850000\n", - "epoch [ 690] L = 38.342069, acc = 0.850000\n", - "epoch [ 691] L = 38.341174, acc = 0.850000\n", - "epoch [ 692] L = 38.340275, acc = 0.850000\n", - "epoch [ 693] L = 38.339372, acc = 0.850000\n", - "epoch [ 694] L = 38.338467, acc = 0.850000\n", - "epoch [ 695] L = 38.337558, acc = 0.850000\n", - "epoch [ 696] L = 38.336646, acc = 0.850000\n", - "epoch [ 697] L = 38.335731, acc = 0.850000\n", - "epoch [ 698] L = 38.334812, acc = 0.850000\n", - "epoch [ 699] L = 38.333890, acc = 0.850000\n", - "epoch [ 700] L = 38.332965, acc = 0.850000\n", - "epoch [ 701] L = 38.332036, acc = 0.850000\n", - "epoch [ 702] L = 38.331104, acc = 0.850000\n", - "epoch [ 703] L = 38.330168, acc = 0.850000\n", - "epoch [ 704] L = 38.329229, acc = 0.850000\n", - "epoch [ 705] L = 38.328287, acc = 0.850000\n", - "epoch [ 706] L = 38.327340, acc = 0.850000\n", - "epoch [ 707] L = 38.326391, acc = 0.850000\n", - "epoch [ 708] L = 38.325437, acc = 0.850000\n", - "epoch [ 709] L = 38.324480, acc = 0.850000\n", - "epoch [ 710] L = 38.323520, acc = 0.850000\n", - "epoch [ 711] L = 38.322556, acc = 0.850000\n", - "epoch [ 712] L = 38.321588, acc = 0.850000\n", - "epoch [ 713] L = 38.320616, acc = 0.850000\n", - "epoch [ 714] L = 38.319641, acc = 0.850000\n", - "epoch [ 715] L = 38.318661, acc = 0.850000\n", - "epoch [ 716] L = 38.317679, acc = 0.850000\n", - "epoch [ 717] L = 38.316692, acc = 0.850000\n", - "epoch [ 718] L = 38.315701, acc = 0.850000\n", - "epoch [ 719] L = 38.314707, acc = 0.850000\n", - "epoch [ 720] L = 38.313708, acc = 0.850000\n", - "epoch [ 721] L = 38.312706, acc = 0.850000\n", - "epoch [ 722] L = 38.311700, acc = 0.850000\n", - "epoch [ 723] L = 38.310689, acc = 0.850000\n", - "epoch [ 724] L = 38.309675, acc = 0.850000\n", - "epoch [ 725] L = 38.308657, acc = 0.850000\n", - "epoch [ 726] L = 38.307634, acc = 0.850000\n", - "epoch [ 727] L = 38.306608, acc = 0.850000\n", - "epoch [ 728] L = 38.305577, acc = 0.850000\n", - "epoch [ 729] L = 38.304542, acc = 0.850000\n", - "epoch [ 730] L = 38.303503, acc = 0.850000\n", - "epoch [ 731] L = 38.302460, acc = 0.850000\n", - "epoch [ 732] L = 38.301412, acc = 0.850000\n", - "epoch [ 733] L = 38.300360, acc = 0.850000\n", - "epoch [ 734] L = 38.299304, acc = 0.850000\n", - "epoch [ 735] L = 38.298244, acc = 0.850000\n", - "epoch [ 736] L = 38.297179, acc = 0.850000\n", - "epoch [ 737] L = 38.296110, acc = 0.850000\n", - "epoch [ 738] L = 38.295036, acc = 0.850000\n", - "epoch [ 739] L = 38.293958, acc = 0.850000\n", - "epoch [ 740] L = 38.292875, acc = 0.850000\n", - "epoch [ 741] L = 38.291788, acc = 0.850000\n", - "epoch [ 742] L = 38.290696, acc = 0.850000\n", - "epoch [ 743] L = 38.289600, acc = 0.850000\n", - "epoch [ 744] L = 38.288499, acc = 0.850000\n", - "epoch [ 745] L = 38.287393, acc = 0.850000\n", - "epoch [ 746] L = 38.286282, acc = 0.850000\n", - "epoch [ 747] L = 38.285167, acc = 0.850000\n", - "epoch [ 748] L = 38.284047, acc = 0.850000\n", - "epoch [ 749] L = 38.282923, acc = 0.850000\n", - "epoch [ 750] L = 38.281793, acc = 0.850000\n", - "epoch [ 751] L = 38.280659, acc = 0.850000\n", - "epoch [ 752] L = 38.279520, acc = 0.850000\n", - "epoch [ 753] L = 38.278375, acc = 0.850000\n", - "epoch [ 754] L = 38.277226, acc = 0.850000\n", - "epoch [ 755] L = 38.276072, acc = 0.850000\n", - "epoch [ 756] L = 38.274913, acc = 0.850000\n", - "epoch [ 757] L = 38.273748, acc = 0.850000\n", - "epoch [ 758] L = 38.272579, acc = 0.850000\n", - "epoch [ 759] L = 38.271404, acc = 0.850000\n", - "epoch [ 760] L = 38.270225, acc = 0.850000\n", - "epoch [ 761] L = 38.269040, acc = 0.850000\n", - "epoch [ 762] L = 38.267849, acc = 0.850000\n", - "epoch [ 763] L = 38.266654, acc = 0.850000\n", - "epoch [ 764] L = 38.265453, acc = 0.850000\n", - "epoch [ 765] L = 38.264247, acc = 0.850000\n", - "epoch [ 766] L = 38.263035, acc = 0.850000\n", - "epoch [ 767] L = 38.261818, acc = 0.850000\n", - "epoch [ 768] L = 38.260595, acc = 0.850000\n", - "epoch [ 769] L = 38.259367, acc = 0.850000\n", - "epoch [ 770] L = 38.258133, acc = 0.850000\n", - "epoch [ 771] L = 38.256894, acc = 0.850000\n", - "epoch [ 772] L = 38.255649, acc = 0.850000\n", - "epoch [ 773] L = 38.254399, acc = 0.850000\n", - "epoch [ 774] L = 38.253142, acc = 0.850000\n", - "epoch [ 775] L = 38.251880, acc = 0.850000\n", - "epoch [ 776] L = 38.250612, acc = 0.850000\n", - "epoch [ 777] L = 38.249338, acc = 0.850000\n", - "epoch [ 778] L = 38.248059, acc = 0.850000\n", - "epoch [ 779] L = 38.246773, acc = 0.850000\n", - "epoch [ 780] L = 38.245482, acc = 0.850000\n", - "epoch [ 781] L = 38.244184, acc = 0.850000\n", - "epoch [ 782] L = 38.242880, acc = 0.850000\n", - "epoch [ 783] L = 38.241571, acc = 0.850000\n", - "epoch [ 784] L = 38.240255, acc = 0.850000\n", - "epoch [ 785] L = 38.238933, acc = 0.850000\n", - "epoch [ 786] L = 38.237604, acc = 0.850000\n", - "epoch [ 787] L = 38.236270, acc = 0.850000\n", - "epoch [ 788] L = 38.234929, acc = 0.850000\n", - "epoch [ 789] L = 38.233582, acc = 0.850000\n", - "epoch [ 790] L = 38.232228, acc = 0.850000\n", - "epoch [ 791] L = 38.230868, acc = 0.850000\n", - "epoch [ 792] L = 38.229502, acc = 0.850000\n", - "epoch [ 793] L = 38.228128, acc = 0.850000\n", - "epoch [ 794] L = 38.226749, acc = 0.850000\n", - "epoch [ 795] L = 38.225362, acc = 0.850000\n", - "epoch [ 796] L = 38.223969, acc = 0.850000\n", - "epoch [ 797] L = 38.222570, acc = 0.850000\n", - "epoch [ 798] L = 38.221163, acc = 0.850000\n", - "epoch [ 799] L = 38.219750, acc = 0.850000\n", - "epoch [ 800] L = 38.218330, acc = 0.850000\n", - "epoch [ 801] L = 38.216902, acc = 0.850000\n", - "epoch [ 802] L = 38.215468, acc = 0.850000\n", - "epoch [ 803] L = 38.214027, acc = 0.850000\n", - "epoch [ 804] L = 38.212579, acc = 0.850000\n", - "epoch [ 805] L = 38.211124, acc = 0.850000\n", - "epoch [ 806] L = 38.209661, acc = 0.850000\n", - "epoch [ 807] L = 38.208191, acc = 0.850000\n", - "epoch [ 808] L = 38.206715, acc = 0.850000\n", - "epoch [ 809] L = 38.205230, acc = 0.850000\n", - "epoch [ 810] L = 38.203739, acc = 0.850000\n", - "epoch [ 811] L = 38.202239, acc = 0.850000\n", - "epoch [ 812] L = 38.200733, acc = 0.850000\n", - "epoch [ 813] L = 38.199219, acc = 0.850000\n", - "epoch [ 814] L = 38.197697, acc = 0.850000\n", - "epoch [ 815] L = 38.196168, acc = 0.850000\n", - "epoch [ 816] L = 38.194631, acc = 0.850000\n", - "epoch [ 817] L = 38.193086, acc = 0.850000\n", - "epoch [ 818] L = 38.191534, acc = 0.850000\n", - "epoch [ 819] L = 38.189973, acc = 0.850000\n", - "epoch [ 820] L = 38.188405, acc = 0.850000\n", - "epoch [ 821] L = 38.186829, acc = 0.850000\n", - "epoch [ 822] L = 38.185244, acc = 0.850000\n", - "epoch [ 823] L = 38.183652, acc = 0.850000\n", - "epoch [ 824] L = 38.182051, acc = 0.850000\n", - "epoch [ 825] L = 38.180443, acc = 0.850000\n", - "epoch [ 826] L = 38.178826, acc = 0.850000\n", - "epoch [ 827] L = 38.177201, acc = 0.850000\n", - "epoch [ 828] L = 38.175567, acc = 0.850000\n", - "epoch [ 829] L = 38.173925, acc = 0.850000\n", - "epoch [ 830] L = 38.172274, acc = 0.850000\n", - "epoch [ 831] L = 38.170615, acc = 0.850000\n", - "epoch [ 832] L = 38.168948, acc = 0.850000\n", - "epoch [ 833] L = 38.167271, acc = 0.850000\n", - "epoch [ 834] L = 38.165586, acc = 0.850000\n", - "epoch [ 835] L = 38.163892, acc = 0.850000\n", - "epoch [ 836] L = 38.162190, acc = 0.850000\n", - "epoch [ 837] L = 38.160478, acc = 0.850000\n", - "epoch [ 838] L = 38.158757, acc = 0.850000\n", - "epoch [ 839] L = 38.157028, acc = 0.850000\n", - "epoch [ 840] L = 38.155289, acc = 0.850000\n", - "epoch [ 841] L = 38.153541, acc = 0.850000\n", - "epoch [ 842] L = 38.151784, acc = 0.850000\n", - "epoch [ 843] L = 38.150017, acc = 0.850000\n", - "epoch [ 844] L = 38.148242, acc = 0.850000\n", - "epoch [ 845] L = 38.146456, acc = 0.850000\n", - "epoch [ 846] L = 38.144662, acc = 0.850000\n", - "epoch [ 847] L = 38.142857, acc = 0.850000\n", - "epoch [ 848] L = 38.141043, acc = 0.850000\n", - "epoch [ 849] L = 38.139220, acc = 0.850000\n", - "epoch [ 850] L = 38.137386, acc = 0.850000\n", - "epoch [ 851] L = 38.135543, acc = 0.850000\n", - "epoch [ 852] L = 38.133690, acc = 0.850000\n", - "epoch [ 853] L = 38.131827, acc = 0.850000\n", - "epoch [ 854] L = 38.129954, acc = 0.850000\n", - "epoch [ 855] L = 38.128070, acc = 0.850000\n", - "epoch [ 856] L = 38.126177, acc = 0.850000\n", - "epoch [ 857] L = 38.124273, acc = 0.850000\n", - "epoch [ 858] L = 38.122359, acc = 0.850000\n", - "epoch [ 859] L = 38.120435, acc = 0.850000\n", - "epoch [ 860] L = 38.118500, acc = 0.850000\n", - "epoch [ 861] L = 38.116554, acc = 0.850000\n", - "epoch [ 862] L = 38.114598, acc = 0.850000\n", - "epoch [ 863] L = 38.112631, acc = 0.850000\n", - "epoch [ 864] L = 38.110654, acc = 0.850000\n", - "epoch [ 865] L = 38.108665, acc = 0.850000\n", - "epoch [ 866] L = 38.106666, acc = 0.850000\n", - "epoch [ 867] L = 38.104656, acc = 0.850000\n", - "epoch [ 868] L = 38.102634, acc = 0.850000\n", - "epoch [ 869] L = 38.100602, acc = 0.850000\n", - "epoch [ 870] L = 38.098558, acc = 0.850000\n", - "epoch [ 871] L = 38.096503, acc = 0.850000\n", - "epoch [ 872] L = 38.094436, acc = 0.850000\n", - "epoch [ 873] L = 38.092358, acc = 0.850000\n", - "epoch [ 874] L = 38.090269, acc = 0.850000\n", - "epoch [ 875] L = 38.088167, acc = 0.850000\n", - "epoch [ 876] L = 38.086054, acc = 0.850000\n", - "epoch [ 877] L = 38.083930, acc = 0.850000\n", - "epoch [ 878] L = 38.081793, acc = 0.850000\n", - "epoch [ 879] L = 38.079645, acc = 0.850000\n", - "epoch [ 880] L = 38.077484, acc = 0.850000\n", - "epoch [ 881] L = 38.075311, acc = 0.850000\n", - "epoch [ 882] L = 38.073126, acc = 0.850000\n", - "epoch [ 883] L = 38.070929, acc = 0.850000\n", - "epoch [ 884] L = 38.068719, acc = 0.850000\n", - "epoch [ 885] L = 38.066497, acc = 0.850000\n", - "epoch [ 886] L = 38.064262, acc = 0.850000\n", - "epoch [ 887] L = 38.062015, acc = 0.850000\n", - "epoch [ 888] L = 38.059755, acc = 0.850000\n", - "epoch [ 889] L = 38.057482, acc = 0.850000\n", - "epoch [ 890] L = 38.055196, acc = 0.850000\n", - "epoch [ 891] L = 38.052897, acc = 0.850000\n", - "epoch [ 892] L = 38.050585, acc = 0.850000\n", - "epoch [ 893] L = 38.048260, acc = 0.850000\n", - "epoch [ 894] L = 38.045921, acc = 0.850000\n", - "epoch [ 895] L = 38.043569, acc = 0.850000\n", - "epoch [ 896] L = 38.041204, acc = 0.850000\n", - "epoch [ 897] L = 38.038825, acc = 0.850000\n", - "epoch [ 898] L = 38.036432, acc = 0.850000\n", - "epoch [ 899] L = 38.034026, acc = 0.850000\n", - "epoch [ 900] L = 38.031606, acc = 0.850000\n", - "epoch [ 901] L = 38.029172, acc = 0.850000\n", - "epoch [ 902] L = 38.026723, acc = 0.850000\n", - "epoch [ 903] L = 38.024261, acc = 0.850000\n", - "epoch [ 904] L = 38.021784, acc = 0.850000\n", - "epoch [ 905] L = 38.019294, acc = 0.850000\n", - "epoch [ 906] L = 38.016788, acc = 0.850000\n", - "epoch [ 907] L = 38.014268, acc = 0.850000\n", - "epoch [ 908] L = 38.011734, acc = 0.850000\n", - "epoch [ 909] L = 38.009184, acc = 0.850000\n", - "epoch [ 910] L = 38.006620, acc = 0.850000\n", - "epoch [ 911] L = 38.004041, acc = 0.850000\n", - "epoch [ 912] L = 38.001447, acc = 0.850000\n", - "epoch [ 913] L = 37.998838, acc = 0.850000\n", - "epoch [ 914] L = 37.996213, acc = 0.850000\n", - "epoch [ 915] L = 37.993573, acc = 0.850000\n", - "epoch [ 916] L = 37.990918, acc = 0.850000\n", - "epoch [ 917] L = 37.988247, acc = 0.850000\n", - "epoch [ 918] L = 37.985560, acc = 0.850000\n", - "epoch [ 919] L = 37.982858, acc = 0.850000\n", - "epoch [ 920] L = 37.980139, acc = 0.855000\n", - "epoch [ 921] L = 37.977405, acc = 0.855000\n", - "epoch [ 922] L = 37.974654, acc = 0.855000\n", - "epoch [ 923] L = 37.971888, acc = 0.855000\n", - "epoch [ 924] L = 37.969105, acc = 0.855000\n", - "epoch [ 925] L = 37.966305, acc = 0.855000\n", - "epoch [ 926] L = 37.963489, acc = 0.855000\n", - "epoch [ 927] L = 37.960656, acc = 0.855000\n", - "epoch [ 928] L = 37.957807, acc = 0.855000\n", - "epoch [ 929] L = 37.954940, acc = 0.855000\n", - "epoch [ 930] L = 37.952057, acc = 0.855000\n", - "epoch [ 931] L = 37.949156, acc = 0.855000\n", - "epoch [ 932] L = 37.946238, acc = 0.855000\n", - "epoch [ 933] L = 37.943303, acc = 0.855000\n", - "epoch [ 934] L = 37.940350, acc = 0.855000\n", - "epoch [ 935] L = 37.937379, acc = 0.855000\n", - "epoch [ 936] L = 37.934391, acc = 0.855000\n", - "epoch [ 937] L = 37.931385, acc = 0.855000\n", - "epoch [ 938] L = 37.928361, acc = 0.855000\n", - "epoch [ 939] L = 37.925319, acc = 0.855000\n", - "epoch [ 940] L = 37.922259, acc = 0.855000\n", - "epoch [ 941] L = 37.919180, acc = 0.855000\n", - "epoch [ 942] L = 37.916083, acc = 0.855000\n", - "epoch [ 943] L = 37.912967, acc = 0.855000\n", - "epoch [ 944] L = 37.909832, acc = 0.855000\n", - "epoch [ 945] L = 37.906679, acc = 0.855000\n", - "epoch [ 946] L = 37.903507, acc = 0.855000\n", - "epoch [ 947] L = 37.900315, acc = 0.855000\n", - "epoch [ 948] L = 37.897105, acc = 0.855000\n", - "epoch [ 949] L = 37.893875, acc = 0.855000\n", - "epoch [ 950] L = 37.890625, acc = 0.855000\n", - "epoch [ 951] L = 37.887356, acc = 0.855000\n", - "epoch [ 952] L = 37.884067, acc = 0.855000\n", - "epoch [ 953] L = 37.880758, acc = 0.855000\n", - "epoch [ 954] L = 37.877430, acc = 0.855000\n", - "epoch [ 955] L = 37.874081, acc = 0.855000\n", - "epoch [ 956] L = 37.870712, acc = 0.855000\n", - "epoch [ 957] L = 37.867322, acc = 0.855000\n", - "epoch [ 958] L = 37.863912, acc = 0.855000\n", - "epoch [ 959] L = 37.860481, acc = 0.855000\n", - "epoch [ 960] L = 37.857029, acc = 0.855000\n", - "epoch [ 961] L = 37.853557, acc = 0.855000\n", - "epoch [ 962] L = 37.850063, acc = 0.855000\n", - "epoch [ 963] L = 37.846548, acc = 0.855000\n", - "epoch [ 964] L = 37.843011, acc = 0.855000\n", - "epoch [ 965] L = 37.839453, acc = 0.855000\n", - "epoch [ 966] L = 37.835874, acc = 0.855000\n", - "epoch [ 967] L = 37.832272, acc = 0.855000\n", - "epoch [ 968] L = 37.828649, acc = 0.855000\n", - "epoch [ 969] L = 37.825004, acc = 0.855000\n", - "epoch [ 970] L = 37.821336, acc = 0.855000\n", - "epoch [ 971] L = 37.817646, acc = 0.855000\n", - "epoch [ 972] L = 37.813933, acc = 0.855000\n", - "epoch [ 973] L = 37.810198, acc = 0.855000\n", - "epoch [ 974] L = 37.806440, acc = 0.855000\n", - "epoch [ 975] L = 37.802659, acc = 0.855000\n", - "epoch [ 976] L = 37.798855, acc = 0.855000\n", - "epoch [ 977] L = 37.795027, acc = 0.855000\n", - "epoch [ 978] L = 37.791176, acc = 0.855000\n", - "epoch [ 979] L = 37.787302, acc = 0.855000\n", - "epoch [ 980] L = 37.783404, acc = 0.855000\n", - "epoch [ 981] L = 37.779482, acc = 0.855000\n", - "epoch [ 982] L = 37.775535, acc = 0.855000\n", - "epoch [ 983] L = 37.771565, acc = 0.855000\n", - "epoch [ 984] L = 37.767571, acc = 0.855000\n", - "epoch [ 985] L = 37.763552, acc = 0.855000\n", - "epoch [ 986] L = 37.759508, acc = 0.855000\n", - "epoch [ 987] L = 37.755439, acc = 0.855000\n", - "epoch [ 988] L = 37.751346, acc = 0.855000\n", - "epoch [ 989] L = 37.747227, acc = 0.855000\n", - "epoch [ 990] L = 37.743083, acc = 0.855000\n", - "epoch [ 991] L = 37.738914, acc = 0.855000\n", - "epoch [ 992] L = 37.734719, acc = 0.855000\n", - "epoch [ 993] L = 37.730498, acc = 0.855000\n", - "epoch [ 994] L = 37.726251, acc = 0.855000\n", - "epoch [ 995] L = 37.721979, acc = 0.855000\n", - "epoch [ 996] L = 37.717680, acc = 0.855000\n", - "epoch [ 997] L = 37.713354, acc = 0.855000\n", - "epoch [ 998] L = 37.709003, acc = 0.855000\n", - "epoch [ 999] L = 37.704624, acc = 0.855000\n", - "epoch [1000] L = 37.700218, acc = 0.855000\n", - "epoch [1001] L = 37.695786, acc = 0.855000\n", - "epoch [1002] L = 37.691326, acc = 0.855000\n", - "epoch [1003] L = 37.686838, acc = 0.855000\n", - "epoch [1004] L = 37.682324, acc = 0.855000\n", - "epoch [1005] L = 37.677781, acc = 0.855000\n", - "epoch [1006] L = 37.673211, acc = 0.855000\n", - "epoch [1007] L = 37.668612, acc = 0.855000\n", - "epoch [1008] L = 37.663985, acc = 0.855000\n", - "epoch [1009] L = 37.659330, acc = 0.855000\n", - "epoch [1010] L = 37.654646, acc = 0.855000\n", - "epoch [1011] L = 37.649933, acc = 0.855000\n", - "epoch [1012] L = 37.645192, acc = 0.855000\n", - "epoch [1013] L = 37.640421, acc = 0.855000\n", - "epoch [1014] L = 37.635621, acc = 0.855000\n", - "epoch [1015] L = 37.630792, acc = 0.855000\n", - "epoch [1016] L = 37.625933, acc = 0.855000\n", - "epoch [1017] L = 37.621044, acc = 0.855000\n", - "epoch [1018] L = 37.616125, acc = 0.855000\n", - "epoch [1019] L = 37.611176, acc = 0.855000\n", - "epoch [1020] L = 37.606197, acc = 0.855000\n", - "epoch [1021] L = 37.601187, acc = 0.855000\n", - "epoch [1022] L = 37.596146, acc = 0.855000\n", - "epoch [1023] L = 37.591075, acc = 0.855000\n", - "epoch [1024] L = 37.585972, acc = 0.855000\n", - "epoch [1025] L = 37.580839, acc = 0.855000\n", - "epoch [1026] L = 37.575674, acc = 0.855000\n", - "epoch [1027] L = 37.570477, acc = 0.855000\n", - "epoch [1028] L = 37.565248, acc = 0.855000\n", - "epoch [1029] L = 37.559988, acc = 0.855000\n", - "epoch [1030] L = 37.554695, acc = 0.855000\n", - "epoch [1031] L = 37.549370, acc = 0.855000\n", - "epoch [1032] L = 37.544013, acc = 0.855000\n", - "epoch [1033] L = 37.538622, acc = 0.855000\n", - "epoch [1034] L = 37.533199, acc = 0.855000\n", - "epoch [1035] L = 37.527743, acc = 0.855000\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch [1036] L = 37.522254, acc = 0.855000\n", - "epoch [1037] L = 37.516731, acc = 0.855000\n", - "epoch [1038] L = 37.511175, acc = 0.855000\n", - "epoch [1039] L = 37.505584, acc = 0.855000\n", - "epoch [1040] L = 37.499960, acc = 0.855000\n", - "epoch [1041] L = 37.494302, acc = 0.855000\n", - "epoch [1042] L = 37.488609, acc = 0.855000\n", - "epoch [1043] L = 37.482882, acc = 0.855000\n", - "epoch [1044] L = 37.477119, acc = 0.855000\n", - "epoch [1045] L = 37.471322, acc = 0.855000\n", - "epoch [1046] L = 37.465490, acc = 0.860000\n", - "epoch [1047] L = 37.459623, acc = 0.860000\n", - "epoch [1048] L = 37.453720, acc = 0.860000\n", - "epoch [1049] L = 37.447781, acc = 0.860000\n", - "epoch [1050] L = 37.441806, acc = 0.860000\n", - "epoch [1051] L = 37.435796, acc = 0.860000\n", - "epoch [1052] L = 37.429749, acc = 0.865000\n", - "epoch [1053] L = 37.423665, acc = 0.865000\n", - "epoch [1054] L = 37.417545, acc = 0.865000\n", - "epoch [1055] L = 37.411389, acc = 0.865000\n", - "epoch [1056] L = 37.405195, acc = 0.865000\n", - "epoch [1057] L = 37.398964, acc = 0.865000\n", - "epoch [1058] L = 37.392695, acc = 0.865000\n", - "epoch [1059] L = 37.386389, acc = 0.865000\n", - "epoch [1060] L = 37.380045, acc = 0.865000\n", - "epoch [1061] L = 37.373663, acc = 0.865000\n", - "epoch [1062] L = 37.367243, acc = 0.865000\n", - "epoch [1063] L = 37.360785, acc = 0.865000\n", - "epoch [1064] L = 37.354288, acc = 0.865000\n", - "epoch [1065] L = 37.347752, acc = 0.865000\n", - "epoch [1066] L = 37.341177, acc = 0.865000\n", - "epoch [1067] L = 37.334563, acc = 0.865000\n", - "epoch [1068] L = 37.327910, acc = 0.865000\n", - "epoch [1069] L = 37.321217, acc = 0.865000\n", - "epoch [1070] L = 37.314485, acc = 0.865000\n", - "epoch [1071] L = 37.307713, acc = 0.865000\n", - "epoch [1072] L = 37.300900, acc = 0.865000\n", - "epoch [1073] L = 37.294047, acc = 0.865000\n", - "epoch [1074] L = 37.287154, acc = 0.865000\n", - "epoch [1075] L = 37.280220, acc = 0.865000\n", - "epoch [1076] L = 37.273245, acc = 0.865000\n", - "epoch [1077] L = 37.266229, acc = 0.865000\n", - "epoch [1078] L = 37.259172, acc = 0.865000\n", - "epoch [1079] L = 37.252074, acc = 0.865000\n", - "epoch [1080] L = 37.244934, acc = 0.865000\n", - "epoch [1081] L = 37.237752, acc = 0.865000\n", - "epoch [1082] L = 37.230527, acc = 0.865000\n", - "epoch [1083] L = 37.223261, acc = 0.865000\n", - "epoch [1084] L = 37.215953, acc = 0.865000\n", - "epoch [1085] L = 37.208601, acc = 0.865000\n", - "epoch [1086] L = 37.201207, acc = 0.865000\n", - "epoch [1087] L = 37.193770, acc = 0.865000\n", - "epoch [1088] L = 37.186290, acc = 0.865000\n", - "epoch [1089] L = 37.178767, acc = 0.865000\n", - "epoch [1090] L = 37.171199, acc = 0.865000\n", - "epoch [1091] L = 37.163589, acc = 0.865000\n", - "epoch [1092] L = 37.155934, acc = 0.865000\n", - "epoch [1093] L = 37.148235, acc = 0.865000\n", - "epoch [1094] L = 37.140492, acc = 0.865000\n", - "epoch [1095] L = 37.132704, acc = 0.865000\n", - "epoch [1096] L = 37.124872, acc = 0.865000\n", - "epoch [1097] L = 37.116995, acc = 0.865000\n", - "epoch [1098] L = 37.109073, acc = 0.865000\n", - "epoch [1099] L = 37.101106, acc = 0.865000\n", - "epoch [1100] L = 37.093093, acc = 0.865000\n", - "epoch [1101] L = 37.085035, acc = 0.865000\n", - "epoch [1102] L = 37.076931, acc = 0.865000\n", - "epoch [1103] L = 37.068781, acc = 0.865000\n", - "epoch [1104] L = 37.060584, acc = 0.865000\n", - "epoch [1105] L = 37.052342, acc = 0.865000\n", - "epoch [1106] L = 37.044053, acc = 0.865000\n", - "epoch [1107] L = 37.035717, acc = 0.865000\n", - "epoch [1108] L = 37.027335, acc = 0.865000\n", - "epoch [1109] L = 37.018906, acc = 0.865000\n", - "epoch [1110] L = 37.010429, acc = 0.865000\n", - "epoch [1111] L = 37.001905, acc = 0.865000\n", - "epoch [1112] L = 36.993333, acc = 0.865000\n", - "epoch [1113] L = 36.984714, acc = 0.865000\n", - "epoch [1114] L = 36.976047, acc = 0.865000\n", - "epoch [1115] L = 36.967331, acc = 0.865000\n", - "epoch [1116] L = 36.958568, acc = 0.865000\n", - "epoch [1117] L = 36.949756, acc = 0.865000\n", - "epoch [1118] L = 36.940895, acc = 0.865000\n", - "epoch [1119] L = 36.931986, acc = 0.865000\n", - "epoch [1120] L = 36.923028, acc = 0.865000\n", - "epoch [1121] L = 36.914021, acc = 0.865000\n", - "epoch [1122] L = 36.904964, acc = 0.865000\n", - "epoch [1123] L = 36.895858, acc = 0.865000\n", - "epoch [1124] L = 36.886702, acc = 0.865000\n", - "epoch [1125] L = 36.877497, acc = 0.865000\n", - "epoch [1126] L = 36.868242, acc = 0.865000\n", - "epoch [1127] L = 36.858937, acc = 0.865000\n", - "epoch [1128] L = 36.849581, acc = 0.865000\n", - "epoch [1129] L = 36.840175, acc = 0.865000\n", - "epoch [1130] L = 36.830719, acc = 0.865000\n", - "epoch [1131] L = 36.821212, acc = 0.860000\n", - "epoch [1132] L = 36.811654, acc = 0.860000\n", - "epoch [1133] L = 36.802045, acc = 0.865000\n", - "epoch [1134] L = 36.792385, acc = 0.865000\n", - "epoch [1135] L = 36.782673, acc = 0.865000\n", - "epoch [1136] L = 36.772910, acc = 0.865000\n", - "epoch [1137] L = 36.763096, acc = 0.865000\n", - "epoch [1138] L = 36.753230, acc = 0.865000\n", - "epoch [1139] L = 36.743312, acc = 0.865000\n", - "epoch [1140] L = 36.733341, acc = 0.865000\n", - "epoch [1141] L = 36.723319, acc = 0.865000\n", - "epoch [1142] L = 36.713244, acc = 0.865000\n", - "epoch [1143] L = 36.703117, acc = 0.865000\n", - "epoch [1144] L = 36.692938, acc = 0.865000\n", - "epoch [1145] L = 36.682705, acc = 0.865000\n", - "epoch [1146] L = 36.672420, acc = 0.865000\n", - "epoch [1147] L = 36.662082, acc = 0.865000\n", - "epoch [1148] L = 36.651690, acc = 0.865000\n", - "epoch [1149] L = 36.641245, acc = 0.865000\n", - "epoch [1150] L = 36.630747, acc = 0.865000\n", - "epoch [1151] L = 36.620196, acc = 0.865000\n", - "epoch [1152] L = 36.609591, acc = 0.865000\n", - "epoch [1153] L = 36.598932, acc = 0.865000\n", - "epoch [1154] L = 36.588219, acc = 0.865000\n", - "epoch [1155] L = 36.577452, acc = 0.865000\n", - "epoch [1156] L = 36.566631, acc = 0.865000\n", - "epoch [1157] L = 36.555756, acc = 0.865000\n", - "epoch [1158] L = 36.544827, acc = 0.865000\n", - "epoch [1159] L = 36.533843, acc = 0.865000\n", - "epoch [1160] L = 36.522804, acc = 0.865000\n", - "epoch [1161] L = 36.511711, acc = 0.865000\n", - "epoch [1162] L = 36.500563, acc = 0.865000\n", - "epoch [1163] L = 36.489360, acc = 0.865000\n", - "epoch [1164] L = 36.478102, acc = 0.865000\n", - "epoch [1165] L = 36.466790, acc = 0.865000\n", - "epoch [1166] L = 36.455421, acc = 0.865000\n", - "epoch [1167] L = 36.443998, acc = 0.865000\n", - "epoch [1168] L = 36.432519, acc = 0.865000\n", - "epoch [1169] L = 36.420985, acc = 0.865000\n", - "epoch [1170] L = 36.409396, acc = 0.865000\n", - "epoch [1171] L = 36.397750, acc = 0.865000\n", - "epoch [1172] L = 36.386049, acc = 0.865000\n", - "epoch [1173] L = 36.374292, acc = 0.865000\n", - "epoch [1174] L = 36.362480, acc = 0.865000\n", - "epoch [1175] L = 36.350611, acc = 0.865000\n", - "epoch [1176] L = 36.338686, acc = 0.865000\n", - "epoch [1177] L = 36.326705, acc = 0.865000\n", - "epoch [1178] L = 36.314668, acc = 0.865000\n", - "epoch [1179] L = 36.302575, acc = 0.865000\n", - "epoch [1180] L = 36.290425, acc = 0.865000\n", - "epoch [1181] L = 36.278219, acc = 0.865000\n", - "epoch [1182] L = 36.265957, acc = 0.865000\n", - "epoch [1183] L = 36.253638, acc = 0.865000\n", - "epoch [1184] L = 36.241262, acc = 0.865000\n", - "epoch [1185] L = 36.228830, acc = 0.865000\n", - "epoch [1186] L = 36.216341, acc = 0.865000\n", - "epoch [1187] L = 36.203796, acc = 0.865000\n", - "epoch [1188] L = 36.191193, acc = 0.865000\n", - "epoch [1189] L = 36.178534, acc = 0.865000\n", - "epoch [1190] L = 36.165818, acc = 0.865000\n", - "epoch [1191] L = 36.153045, acc = 0.865000\n", - "epoch [1192] L = 36.140215, acc = 0.865000\n", - "epoch [1193] L = 36.127328, acc = 0.865000\n", - "epoch [1194] L = 36.114384, acc = 0.865000\n", - "epoch [1195] L = 36.101383, acc = 0.865000\n", - "epoch [1196] L = 36.088325, acc = 0.865000\n", - "epoch [1197] L = 36.075210, acc = 0.865000\n", - "epoch [1198] L = 36.062037, acc = 0.865000\n", - "epoch [1199] L = 36.048808, acc = 0.865000\n", - "epoch [1200] L = 36.035521, acc = 0.865000\n", - "epoch [1201] L = 36.022177, acc = 0.865000\n", - "epoch [1202] L = 36.008776, acc = 0.865000\n", - "epoch [1203] L = 35.995318, acc = 0.865000\n", - "epoch [1204] L = 35.981802, acc = 0.865000\n", - "epoch [1205] L = 35.968229, acc = 0.865000\n", - "epoch [1206] L = 35.954599, acc = 0.865000\n", - "epoch [1207] L = 35.940912, acc = 0.865000\n", - "epoch [1208] L = 35.927168, acc = 0.865000\n", - "epoch [1209] L = 35.913366, acc = 0.865000\n", - "epoch [1210] L = 35.899507, acc = 0.865000\n", - "epoch [1211] L = 35.885591, acc = 0.865000\n", - "epoch [1212] L = 35.871617, acc = 0.865000\n", - "epoch [1213] L = 35.857587, acc = 0.865000\n", - "epoch [1214] L = 35.843499, acc = 0.865000\n", - "epoch [1215] L = 35.829354, acc = 0.865000\n", - "epoch [1216] L = 35.815152, acc = 0.865000\n", - "epoch [1217] L = 35.800893, acc = 0.865000\n", - "epoch [1218] L = 35.786577, acc = 0.865000\n", - "epoch [1219] L = 35.772204, acc = 0.865000\n", - "epoch [1220] L = 35.757773, acc = 0.865000\n", - "epoch [1221] L = 35.743286, acc = 0.865000\n", - "epoch [1222] L = 35.728742, acc = 0.865000\n", - "epoch [1223] L = 35.714141, acc = 0.865000\n", - "epoch [1224] L = 35.699483, acc = 0.865000\n", - "epoch [1225] L = 35.684769, acc = 0.865000\n", - "epoch [1226] L = 35.669997, acc = 0.870000\n", - "epoch [1227] L = 35.655169, acc = 0.870000\n", - "epoch [1228] L = 35.640284, acc = 0.870000\n", - "epoch [1229] L = 35.625343, acc = 0.870000\n", - "epoch [1230] L = 35.610345, acc = 0.870000\n", - "epoch [1231] L = 35.595291, acc = 0.870000\n", - "epoch [1232] L = 35.580180, acc = 0.870000\n", - "epoch [1233] L = 35.565013, acc = 0.870000\n", - "epoch [1234] L = 35.549790, acc = 0.870000\n", - "epoch [1235] L = 35.534511, acc = 0.870000\n", - "epoch [1236] L = 35.519175, acc = 0.870000\n", - "epoch [1237] L = 35.503784, acc = 0.875000\n", - "epoch [1238] L = 35.488336, acc = 0.875000\n", - "epoch [1239] L = 35.472833, acc = 0.875000\n", - "epoch [1240] L = 35.457274, acc = 0.875000\n", - "epoch [1241] L = 35.441659, acc = 0.875000\n", - "epoch [1242] L = 35.425989, acc = 0.875000\n", - "epoch [1243] L = 35.410264, acc = 0.875000\n", - "epoch [1244] L = 35.394483, acc = 0.875000\n", - "epoch [1245] L = 35.378646, acc = 0.875000\n", - "epoch [1246] L = 35.362755, acc = 0.875000\n", - "epoch [1247] L = 35.346808, acc = 0.875000\n", - "epoch [1248] L = 35.330807, acc = 0.875000\n", - "epoch [1249] L = 35.314751, acc = 0.875000\n", - "epoch [1250] L = 35.298640, acc = 0.875000\n", - "epoch [1251] L = 35.282474, acc = 0.875000\n", - "epoch [1252] L = 35.266254, acc = 0.875000\n", - "epoch [1253] L = 35.249980, acc = 0.875000\n", - "epoch [1254] L = 35.233651, acc = 0.875000\n", - "epoch [1255] L = 35.217268, acc = 0.875000\n", - "epoch [1256] L = 35.200832, acc = 0.875000\n", - "epoch [1257] L = 35.184341, acc = 0.875000\n", - "epoch [1258] L = 35.167797, acc = 0.875000\n", - "epoch [1259] L = 35.151199, acc = 0.875000\n", - "epoch [1260] L = 35.134548, acc = 0.875000\n", - "epoch [1261] L = 35.117844, acc = 0.875000\n", - "epoch [1262] L = 35.101086, acc = 0.875000\n", - "epoch [1263] L = 35.084276, acc = 0.875000\n", - "epoch [1264] L = 35.067413, acc = 0.875000\n", - "epoch [1265] L = 35.050497, acc = 0.875000\n", - "epoch [1266] L = 35.033529, acc = 0.875000\n", - "epoch [1267] L = 35.016508, acc = 0.875000\n", - "epoch [1268] L = 34.999435, acc = 0.875000\n", - "epoch [1269] L = 34.982310, acc = 0.875000\n", - "epoch [1270] L = 34.965134, acc = 0.875000\n", - "epoch [1271] L = 34.947905, acc = 0.875000\n", - "epoch [1272] L = 34.930625, acc = 0.875000\n", - "epoch [1273] L = 34.913294, acc = 0.875000\n", - "epoch [1274] L = 34.895912, acc = 0.875000\n", - "epoch [1275] L = 34.878479, acc = 0.875000\n", - "epoch [1276] L = 34.860995, acc = 0.875000\n", - "epoch [1277] L = 34.843460, acc = 0.875000\n", - "epoch [1278] L = 34.825875, acc = 0.875000\n", - "epoch [1279] L = 34.808240, acc = 0.875000\n", - "epoch [1280] L = 34.790555, acc = 0.875000\n", - "epoch [1281] L = 34.772820, acc = 0.875000\n", - "epoch [1282] L = 34.755035, acc = 0.875000\n", - "epoch [1283] L = 34.737201, acc = 0.875000\n", - "epoch [1284] L = 34.719318, acc = 0.875000\n", - "epoch [1285] L = 34.701385, acc = 0.875000\n", - "epoch [1286] L = 34.683404, acc = 0.875000\n", - "epoch [1287] L = 34.665374, acc = 0.875000\n", - "epoch [1288] L = 34.647296, acc = 0.875000\n", - "epoch [1289] L = 34.629170, acc = 0.875000\n", - "epoch [1290] L = 34.610995, acc = 0.875000\n", - "epoch [1291] L = 34.592773, acc = 0.875000\n", - "epoch [1292] L = 34.574504, acc = 0.875000\n", - "epoch [1293] L = 34.556187, acc = 0.875000\n", - "epoch [1294] L = 34.537823, acc = 0.875000\n", - "epoch [1295] L = 34.519412, acc = 0.875000\n", - "epoch [1296] L = 34.500954, acc = 0.875000\n", - "epoch [1297] L = 34.482450, acc = 0.875000\n", - "epoch [1298] L = 34.463900, acc = 0.875000\n", - "epoch [1299] L = 34.445304, acc = 0.875000\n", - "epoch [1300] L = 34.426662, acc = 0.875000\n", - "epoch [1301] L = 34.407975, acc = 0.875000\n", - "epoch [1302] L = 34.389242, acc = 0.875000\n", - "epoch [1303] L = 34.370465, acc = 0.875000\n", - "epoch [1304] L = 34.351643, acc = 0.875000\n", - "epoch [1305] L = 34.332776, acc = 0.875000\n", - "epoch [1306] L = 34.313865, acc = 0.875000\n", - "epoch [1307] L = 34.294910, acc = 0.875000\n", - "epoch [1308] L = 34.275911, acc = 0.875000\n", - "epoch [1309] L = 34.256868, acc = 0.875000\n", - "epoch [1310] L = 34.237783, acc = 0.875000\n", - "epoch [1311] L = 34.218654, acc = 0.875000\n", - "epoch [1312] L = 34.199483, acc = 0.875000\n", - "epoch [1313] L = 34.180269, acc = 0.875000\n", - "epoch [1314] L = 34.161013, acc = 0.875000\n", - "epoch [1315] L = 34.141714, acc = 0.875000\n", - "epoch [1316] L = 34.122375, acc = 0.875000\n", - "epoch [1317] L = 34.102993, acc = 0.875000\n", - "epoch [1318] L = 34.083571, acc = 0.875000\n", - "epoch [1319] L = 34.064107, acc = 0.875000\n", - "epoch [1320] L = 34.044603, acc = 0.875000\n", - "epoch [1321] L = 34.025059, acc = 0.875000\n", - "epoch [1322] L = 34.005474, acc = 0.875000\n", - "epoch [1323] L = 33.985850, acc = 0.875000\n", - "epoch [1324] L = 33.966186, acc = 0.875000\n", - "epoch [1325] L = 33.946482, acc = 0.880000\n", - "epoch [1326] L = 33.926740, acc = 0.880000\n", - "epoch [1327] L = 33.906959, acc = 0.880000\n", - "epoch [1328] L = 33.887140, acc = 0.880000\n", - "epoch [1329] L = 33.867282, acc = 0.880000\n", - "epoch [1330] L = 33.847386, acc = 0.880000\n", - "epoch [1331] L = 33.827453, acc = 0.880000\n", - "epoch [1332] L = 33.807482, acc = 0.880000\n", - "epoch [1333] L = 33.787475, acc = 0.880000\n", - "epoch [1334] L = 33.767431, acc = 0.880000\n", - "epoch [1335] L = 33.747350, acc = 0.880000\n", - "epoch [1336] L = 33.727233, acc = 0.880000\n", - "epoch [1337] L = 33.707080, acc = 0.880000\n", - "epoch [1338] L = 33.686891, acc = 0.880000\n", - "epoch [1339] L = 33.666667, acc = 0.880000\n", - "epoch [1340] L = 33.646408, acc = 0.880000\n", - "epoch [1341] L = 33.626115, acc = 0.880000\n", - "epoch [1342] L = 33.605787, acc = 0.880000\n", - "epoch [1343] L = 33.585425, acc = 0.880000\n", - "epoch [1344] L = 33.565028, acc = 0.880000\n", - "epoch [1345] L = 33.544599, acc = 0.880000\n", - "epoch [1346] L = 33.524136, acc = 0.880000\n", - "epoch [1347] L = 33.503640, acc = 0.880000\n", - "epoch [1348] L = 33.483111, acc = 0.885000\n", - "epoch [1349] L = 33.462551, acc = 0.885000\n", - "epoch [1350] L = 33.441958, acc = 0.885000\n", - "epoch [1351] L = 33.421333, acc = 0.885000\n", - "epoch [1352] L = 33.400677, acc = 0.885000\n", - "epoch [1353] L = 33.379989, acc = 0.885000\n", - "epoch [1354] L = 33.359271, acc = 0.885000\n", - "epoch [1355] L = 33.338522, acc = 0.890000\n", - "epoch [1356] L = 33.317743, acc = 0.890000\n", - "epoch [1357] L = 33.296934, acc = 0.890000\n", - "epoch [1358] L = 33.276095, acc = 0.890000\n", - "epoch [1359] L = 33.255227, acc = 0.890000\n", - "epoch [1360] L = 33.234330, acc = 0.890000\n", - "epoch [1361] L = 33.213404, acc = 0.890000\n", - "epoch [1362] L = 33.192450, acc = 0.890000\n", - "epoch [1363] L = 33.171467, acc = 0.890000\n", - "epoch [1364] L = 33.150457, acc = 0.890000\n", - "epoch [1365] L = 33.129419, acc = 0.890000\n", - "epoch [1366] L = 33.108354, acc = 0.890000\n", - "epoch [1367] L = 33.087262, acc = 0.895000\n", - "epoch [1368] L = 33.066143, acc = 0.895000\n", - "epoch [1369] L = 33.044998, acc = 0.895000\n", - "epoch [1370] L = 33.023828, acc = 0.895000\n", - "epoch [1371] L = 33.002631, acc = 0.895000\n", - "epoch [1372] L = 32.981409, acc = 0.895000\n", - "epoch [1373] L = 32.960162, acc = 0.895000\n", - "epoch [1374] L = 32.938890, acc = 0.895000\n", - "epoch [1375] L = 32.917594, acc = 0.895000\n", - "epoch [1376] L = 32.896273, acc = 0.895000\n", - "epoch [1377] L = 32.874929, acc = 0.895000\n", - "epoch [1378] L = 32.853561, acc = 0.895000\n", - "epoch [1379] L = 32.832170, acc = 0.895000\n", - "epoch [1380] L = 32.810756, acc = 0.895000\n", - "epoch [1381] L = 32.789319, acc = 0.895000\n", - "epoch [1382] L = 32.767860, acc = 0.895000\n", - "epoch [1383] L = 32.746379, acc = 0.895000\n", - "epoch [1384] L = 32.724877, acc = 0.895000\n", - "epoch [1385] L = 32.703353, acc = 0.895000\n", - "epoch [1386] L = 32.681807, acc = 0.895000\n", - "epoch [1387] L = 32.660241, acc = 0.895000\n", - "epoch [1388] L = 32.638655, acc = 0.895000\n", - "epoch [1389] L = 32.617048, acc = 0.895000\n", - "epoch [1390] L = 32.595422, acc = 0.895000\n", - "epoch [1391] L = 32.573775, acc = 0.895000\n", - "epoch [1392] L = 32.552110, acc = 0.895000\n", - "epoch [1393] L = 32.530426, acc = 0.895000\n", - "epoch [1394] L = 32.508723, acc = 0.895000\n", - "epoch [1395] L = 32.487001, acc = 0.895000\n", - "epoch [1396] L = 32.465262, acc = 0.895000\n", - "epoch [1397] L = 32.443504, acc = 0.895000\n", - "epoch [1398] L = 32.421730, acc = 0.895000\n", - "epoch [1399] L = 32.399938, acc = 0.895000\n", - "epoch [1400] L = 32.378129, acc = 0.895000\n", - "epoch [1401] L = 32.356304, acc = 0.895000\n", - "epoch [1402] L = 32.334462, acc = 0.895000\n", - "epoch [1403] L = 32.312604, acc = 0.895000\n", - "epoch [1404] L = 32.290731, acc = 0.895000\n", - "epoch [1405] L = 32.268842, acc = 0.895000\n", - "epoch [1406] L = 32.246939, acc = 0.895000\n", - "epoch [1407] L = 32.225020, acc = 0.895000\n", - "epoch [1408] L = 32.203087, acc = 0.895000\n", - "epoch [1409] L = 32.181140, acc = 0.895000\n", - "epoch [1410] L = 32.159179, acc = 0.895000\n", - "epoch [1411] L = 32.137204, acc = 0.895000\n", - "epoch [1412] L = 32.115216, acc = 0.895000\n", - "epoch [1413] L = 32.093215, acc = 0.895000\n", - "epoch [1414] L = 32.071201, acc = 0.895000\n", - "epoch [1415] L = 32.049175, acc = 0.895000\n", - "epoch [1416] L = 32.027136, acc = 0.895000\n", - "epoch [1417] L = 32.005086, acc = 0.895000\n", - "epoch [1418] L = 31.983024, acc = 0.895000\n", - "epoch [1419] L = 31.960950, acc = 0.895000\n", - "epoch [1420] L = 31.938866, acc = 0.895000\n", - "epoch [1421] L = 31.916771, acc = 0.895000\n", - "epoch [1422] L = 31.894666, acc = 0.895000\n", - "epoch [1423] L = 31.872550, acc = 0.895000\n", - "epoch [1424] L = 31.850424, acc = 0.895000\n", - "epoch [1425] L = 31.828289, acc = 0.895000\n", - "epoch [1426] L = 31.806145, acc = 0.895000\n", - "epoch [1427] L = 31.783991, acc = 0.900000\n", - "epoch [1428] L = 31.761829, acc = 0.900000\n", - "epoch [1429] L = 31.739658, acc = 0.900000\n", - "epoch [1430] L = 31.717479, acc = 0.900000\n", - "epoch [1431] L = 31.695292, acc = 0.900000\n", - "epoch [1432] L = 31.673097, acc = 0.900000\n", - "epoch [1433] L = 31.650895, acc = 0.900000\n", - "epoch [1434] L = 31.628685, acc = 0.900000\n", - "epoch [1435] L = 31.606469, acc = 0.900000\n", - "epoch [1436] L = 31.584247, acc = 0.900000\n", - "epoch [1437] L = 31.562017, acc = 0.900000\n", - "epoch [1438] L = 31.539782, acc = 0.900000\n", - "epoch [1439] L = 31.517541, acc = 0.900000\n", - "epoch [1440] L = 31.495295, acc = 0.900000\n", - "epoch [1441] L = 31.473043, acc = 0.900000\n", - "epoch [1442] L = 31.450786, acc = 0.900000\n", - "epoch [1443] L = 31.428525, acc = 0.900000\n", - "epoch [1444] L = 31.406259, acc = 0.900000\n", - "epoch [1445] L = 31.383989, acc = 0.900000\n", - "epoch [1446] L = 31.361714, acc = 0.900000\n", - "epoch [1447] L = 31.339436, acc = 0.900000\n", - "epoch [1448] L = 31.317155, acc = 0.900000\n", - "epoch [1449] L = 31.294870, acc = 0.900000\n", - "epoch [1450] L = 31.272583, acc = 0.900000\n", - "epoch [1451] L = 31.250292, acc = 0.900000\n", - "epoch [1452] L = 31.228000, acc = 0.900000\n", - "epoch [1453] L = 31.205705, acc = 0.900000\n", - "epoch [1454] L = 31.183408, acc = 0.900000\n", - "epoch [1455] L = 31.161109, acc = 0.900000\n", - "epoch [1456] L = 31.138809, acc = 0.900000\n", - "epoch [1457] L = 31.116508, acc = 0.900000\n", - "epoch [1458] L = 31.094205, acc = 0.900000\n", - "epoch [1459] L = 31.071902, acc = 0.900000\n", - "epoch [1460] L = 31.049599, acc = 0.900000\n", - "epoch [1461] L = 31.027295, acc = 0.900000\n", - "epoch [1462] L = 31.004991, acc = 0.900000\n", - "epoch [1463] L = 30.982687, acc = 0.900000\n", - "epoch [1464] L = 30.960384, acc = 0.900000\n", - "epoch [1465] L = 30.938082, acc = 0.900000\n", - "epoch [1466] L = 30.915780, acc = 0.900000\n", - "epoch [1467] L = 30.893480, acc = 0.900000\n", - "epoch [1468] L = 30.871180, acc = 0.900000\n", - "epoch [1469] L = 30.848883, acc = 0.900000\n", - "epoch [1470] L = 30.826587, acc = 0.900000\n", - "epoch [1471] L = 30.804294, acc = 0.900000\n", - "epoch [1472] L = 30.782002, acc = 0.900000\n", - "epoch [1473] L = 30.759713, acc = 0.905000\n", - "epoch [1474] L = 30.737427, acc = 0.905000\n", - "epoch [1475] L = 30.715144, acc = 0.905000\n", - "epoch [1476] L = 30.692864, acc = 0.905000\n", - "epoch [1477] L = 30.670587, acc = 0.905000\n", - "epoch [1478] L = 30.648314, acc = 0.905000\n", - "epoch [1479] L = 30.626045, acc = 0.905000\n", - "epoch [1480] L = 30.603779, acc = 0.905000\n", - "epoch [1481] L = 30.581518, acc = 0.905000\n", - "epoch [1482] L = 30.559262, acc = 0.905000\n", - "epoch [1483] L = 30.537010, acc = 0.905000\n", - "epoch [1484] L = 30.514763, acc = 0.905000\n", - "epoch [1485] L = 30.492520, acc = 0.905000\n", - "epoch [1486] L = 30.470284, acc = 0.905000\n", - "epoch [1487] L = 30.448052, acc = 0.905000\n", - "epoch [1488] L = 30.425827, acc = 0.905000\n", - "epoch [1489] L = 30.403607, acc = 0.905000\n", - "epoch [1490] L = 30.381393, acc = 0.905000\n", - "epoch [1491] L = 30.359186, acc = 0.905000\n", - "epoch [1492] L = 30.336985, acc = 0.905000\n", - "epoch [1493] L = 30.314790, acc = 0.905000\n", - "epoch [1494] L = 30.292603, acc = 0.905000\n", - "epoch [1495] L = 30.270422, acc = 0.905000\n", - "epoch [1496] L = 30.248249, acc = 0.905000\n", - "epoch [1497] L = 30.226083, acc = 0.905000\n", - "epoch [1498] L = 30.203925, acc = 0.910000\n", - "epoch [1499] L = 30.181775, acc = 0.910000\n", - "epoch [1500] L = 30.159633, acc = 0.910000\n", - "epoch [1501] L = 30.137498, acc = 0.910000\n", - "epoch [1502] L = 30.115373, acc = 0.910000\n", - "epoch [1503] L = 30.093255, acc = 0.910000\n", - "epoch [1504] L = 30.071147, acc = 0.910000\n", - "epoch [1505] L = 30.049047, acc = 0.910000\n", - "epoch [1506] L = 30.026957, acc = 0.910000\n", - "epoch [1507] L = 30.004875, acc = 0.910000\n", - "epoch [1508] L = 29.982803, acc = 0.910000\n", - "epoch [1509] L = 29.960741, acc = 0.910000\n", - "epoch [1510] L = 29.938689, acc = 0.915000\n", - "epoch [1511] L = 29.916646, acc = 0.915000\n", - "epoch [1512] L = 29.894613, acc = 0.915000\n", - "epoch [1513] L = 29.872591, acc = 0.915000\n", - "epoch [1514] L = 29.850579, acc = 0.915000\n", - "epoch [1515] L = 29.828578, acc = 0.915000\n", - "epoch [1516] L = 29.806588, acc = 0.915000\n", - "epoch [1517] L = 29.784609, acc = 0.915000\n", - "epoch [1518] L = 29.762640, acc = 0.915000\n", - "epoch [1519] L = 29.740683, acc = 0.915000\n", - "epoch [1520] L = 29.718737, acc = 0.915000\n", - "epoch [1521] L = 29.696803, acc = 0.915000\n", - "epoch [1522] L = 29.674881, acc = 0.915000\n", - "epoch [1523] L = 29.652971, acc = 0.915000\n", - "epoch [1524] L = 29.631072, acc = 0.915000\n", - "epoch [1525] L = 29.609186, acc = 0.915000\n", - "epoch [1526] L = 29.587312, acc = 0.915000\n", - "epoch [1527] L = 29.565451, acc = 0.915000\n", - "epoch [1528] L = 29.543602, acc = 0.915000\n", - "epoch [1529] L = 29.521766, acc = 0.915000\n", - "epoch [1530] L = 29.499943, acc = 0.915000\n", - "epoch [1531] L = 29.478133, acc = 0.915000\n", - "epoch [1532] L = 29.456336, acc = 0.915000\n", - "epoch [1533] L = 29.434553, acc = 0.915000\n", - "epoch [1534] L = 29.412783, acc = 0.915000\n", - "epoch [1535] L = 29.391027, acc = 0.915000\n", - "epoch [1536] L = 29.369284, acc = 0.915000\n", - "epoch [1537] L = 29.347556, acc = 0.915000\n", - "epoch [1538] L = 29.325841, acc = 0.915000\n", - "epoch [1539] L = 29.304141, acc = 0.915000\n", - "epoch [1540] L = 29.282455, acc = 0.915000\n", - "epoch [1541] L = 29.260784, acc = 0.915000\n", - "epoch [1542] L = 29.239127, acc = 0.915000\n", - "epoch [1543] L = 29.217484, acc = 0.915000\n", - "epoch [1544] L = 29.195857, acc = 0.915000\n", - "epoch [1545] L = 29.174245, acc = 0.915000\n", - "epoch [1546] L = 29.152647, acc = 0.915000\n", - "epoch [1547] L = 29.131065, acc = 0.915000\n", - "epoch [1548] L = 29.109498, acc = 0.915000\n", - "epoch [1549] L = 29.087947, acc = 0.915000\n", - "epoch [1550] L = 29.066411, acc = 0.915000\n", - "epoch [1551] L = 29.044891, acc = 0.915000\n", - "epoch [1552] L = 29.023387, acc = 0.915000\n", - "epoch [1553] L = 29.001899, acc = 0.915000\n", - "epoch [1554] L = 28.980427, acc = 0.915000\n", - "epoch [1555] L = 28.958971, acc = 0.915000\n", - "epoch [1556] L = 28.937531, acc = 0.915000\n", - "epoch [1557] L = 28.916108, acc = 0.915000\n", - "epoch [1558] L = 28.894701, acc = 0.915000\n", - "epoch [1559] L = 28.873311, acc = 0.915000\n", - "epoch [1560] L = 28.851937, acc = 0.915000\n", - "epoch [1561] L = 28.830580, acc = 0.915000\n", - "epoch [1562] L = 28.809241, acc = 0.915000\n", - "epoch [1563] L = 28.787918, acc = 0.915000\n", - "epoch [1564] L = 28.766612, acc = 0.915000\n", - "epoch [1565] L = 28.745324, acc = 0.915000\n", - "epoch [1566] L = 28.724053, acc = 0.915000\n", - "epoch [1567] L = 28.702800, acc = 0.915000\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch [1568] L = 28.681564, acc = 0.915000\n", - "epoch [1569] L = 28.660346, acc = 0.915000\n", - "epoch [1570] L = 28.639145, acc = 0.915000\n", - "epoch [1571] L = 28.617963, acc = 0.915000\n", - "epoch [1572] L = 28.596798, acc = 0.915000\n", - "epoch [1573] L = 28.575651, acc = 0.915000\n", - "epoch [1574] L = 28.554523, acc = 0.915000\n", - "epoch [1575] L = 28.533413, acc = 0.915000\n", - "epoch [1576] L = 28.512321, acc = 0.915000\n", - "epoch [1577] L = 28.491247, acc = 0.915000\n", - "epoch [1578] L = 28.470192, acc = 0.915000\n", - "epoch [1579] L = 28.449156, acc = 0.915000\n", - "epoch [1580] L = 28.428138, acc = 0.915000\n", - "epoch [1581] L = 28.407139, acc = 0.915000\n", - "epoch [1582] L = 28.386159, acc = 0.915000\n", - "epoch [1583] L = 28.365198, acc = 0.915000\n", - "epoch [1584] L = 28.344256, acc = 0.915000\n", - "epoch [1585] L = 28.323333, acc = 0.915000\n", - "epoch [1586] L = 28.302429, acc = 0.915000\n", - "epoch [1587] L = 28.281545, acc = 0.915000\n", - "epoch [1588] L = 28.260680, acc = 0.915000\n", - "epoch [1589] L = 28.239834, acc = 0.915000\n", - "epoch [1590] L = 28.219008, acc = 0.915000\n", - "epoch [1591] L = 28.198201, acc = 0.915000\n", - "epoch [1592] L = 28.177414, acc = 0.915000\n", - "epoch [1593] L = 28.156647, acc = 0.915000\n", - "epoch [1594] L = 28.135899, acc = 0.915000\n", - "epoch [1595] L = 28.115172, acc = 0.915000\n", - "epoch [1596] L = 28.094464, acc = 0.915000\n", - "epoch [1597] L = 28.073777, acc = 0.915000\n", - "epoch [1598] L = 28.053109, acc = 0.915000\n", - "epoch [1599] L = 28.032462, acc = 0.915000\n", - "epoch [1600] L = 28.011835, acc = 0.915000\n", - "epoch [1601] L = 27.991228, acc = 0.915000\n", - "epoch [1602] L = 27.970642, acc = 0.915000\n", - "epoch [1603] L = 27.950076, acc = 0.915000\n", - "epoch [1604] L = 27.929530, acc = 0.915000\n", - "epoch [1605] L = 27.909006, acc = 0.915000\n", - "epoch [1606] L = 27.888501, acc = 0.915000\n", - "epoch [1607] L = 27.868018, acc = 0.915000\n", - "epoch [1608] L = 27.847555, acc = 0.915000\n", - "epoch [1609] L = 27.827113, acc = 0.915000\n", - "epoch [1610] L = 27.806692, acc = 0.915000\n", - "epoch [1611] L = 27.786292, acc = 0.915000\n", - "epoch [1612] L = 27.765913, acc = 0.915000\n", - "epoch [1613] L = 27.745555, acc = 0.915000\n", - "epoch [1614] L = 27.725218, acc = 0.915000\n", - "epoch [1615] L = 27.704902, acc = 0.915000\n", - "epoch [1616] L = 27.684607, acc = 0.915000\n", - "epoch [1617] L = 27.664334, acc = 0.915000\n", - "epoch [1618] L = 27.644082, acc = 0.915000\n", - "epoch [1619] L = 27.623851, acc = 0.915000\n", - "epoch [1620] L = 27.603642, acc = 0.915000\n", - "epoch [1621] L = 27.583455, acc = 0.915000\n", - "epoch [1622] L = 27.563288, acc = 0.915000\n", - "epoch [1623] L = 27.543144, acc = 0.915000\n", - "epoch [1624] L = 27.523021, acc = 0.915000\n", - "epoch [1625] L = 27.502920, acc = 0.915000\n", - "epoch [1626] L = 27.482840, acc = 0.915000\n", - "epoch [1627] L = 27.462783, acc = 0.915000\n", - "epoch [1628] L = 27.442747, acc = 0.915000\n", - "epoch [1629] L = 27.422733, acc = 0.915000\n", - "epoch [1630] L = 27.402741, acc = 0.915000\n", - "epoch [1631] L = 27.382770, acc = 0.915000\n", - "epoch [1632] L = 27.362822, acc = 0.915000\n", - "epoch [1633] L = 27.342896, acc = 0.915000\n", - "epoch [1634] L = 27.322992, acc = 0.915000\n", - "epoch [1635] L = 27.303110, acc = 0.915000\n", - "epoch [1636] L = 27.283251, acc = 0.915000\n", - "epoch [1637] L = 27.263413, acc = 0.915000\n", - "epoch [1638] L = 27.243598, acc = 0.915000\n", - "epoch [1639] L = 27.223805, acc = 0.915000\n", - "epoch [1640] L = 27.204034, acc = 0.920000\n", - "epoch [1641] L = 27.184286, acc = 0.920000\n", - "epoch [1642] L = 27.164560, acc = 0.920000\n", - "epoch [1643] L = 27.144857, acc = 0.920000\n", - "epoch [1644] L = 27.125176, acc = 0.920000\n", - "epoch [1645] L = 27.105518, acc = 0.920000\n", - "epoch [1646] L = 27.085882, acc = 0.920000\n", - "epoch [1647] L = 27.066268, acc = 0.920000\n", - "epoch [1648] L = 27.046678, acc = 0.920000\n", - "epoch [1649] L = 27.027110, acc = 0.920000\n", - "epoch [1650] L = 27.007564, acc = 0.920000\n", - "epoch [1651] L = 26.988042, acc = 0.920000\n", - "epoch [1652] L = 26.968542, acc = 0.920000\n", - "epoch [1653] L = 26.949064, acc = 0.920000\n", - "epoch [1654] L = 26.929610, acc = 0.920000\n", - "epoch [1655] L = 26.910178, acc = 0.925000\n", - "epoch [1656] L = 26.890770, acc = 0.925000\n", - "epoch [1657] L = 26.871384, acc = 0.925000\n", - "epoch [1658] L = 26.852021, acc = 0.925000\n", - "epoch [1659] L = 26.832681, acc = 0.925000\n", - "epoch [1660] L = 26.813364, acc = 0.925000\n", - "epoch [1661] L = 26.794070, acc = 0.925000\n", - "epoch [1662] L = 26.774798, acc = 0.925000\n", - "epoch [1663] L = 26.755550, acc = 0.925000\n", - "epoch [1664] L = 26.736325, acc = 0.925000\n", - "epoch [1665] L = 26.717123, acc = 0.925000\n", - "epoch [1666] L = 26.697944, acc = 0.925000\n", - "epoch [1667] L = 26.678789, acc = 0.925000\n", - "epoch [1668] L = 26.659656, acc = 0.925000\n", - "epoch [1669] L = 26.640547, acc = 0.925000\n", - "epoch [1670] L = 26.621460, acc = 0.930000\n", - "epoch [1671] L = 26.602397, acc = 0.930000\n", - "epoch [1672] L = 26.583358, acc = 0.930000\n", - "epoch [1673] L = 26.564341, acc = 0.930000\n", - "epoch [1674] L = 26.545348, acc = 0.930000\n", - "epoch [1675] L = 26.526377, acc = 0.930000\n", - "epoch [1676] L = 26.507431, acc = 0.930000\n", - "epoch [1677] L = 26.488507, acc = 0.930000\n", - "epoch [1678] L = 26.469607, acc = 0.930000\n", - "epoch [1679] L = 26.450730, acc = 0.930000\n", - "epoch [1680] L = 26.431877, acc = 0.930000\n", - "epoch [1681] L = 26.413047, acc = 0.930000\n", - "epoch [1682] L = 26.394240, acc = 0.930000\n", - "epoch [1683] L = 26.375457, acc = 0.930000\n", - "epoch [1684] L = 26.356697, acc = 0.930000\n", - "epoch [1685] L = 26.337960, acc = 0.930000\n", - "epoch [1686] L = 26.319247, acc = 0.930000\n", - "epoch [1687] L = 26.300558, acc = 0.930000\n", - "epoch [1688] L = 26.281891, acc = 0.930000\n", - "epoch [1689] L = 26.263249, acc = 0.930000\n", - "epoch [1690] L = 26.244630, acc = 0.930000\n", - "epoch [1691] L = 26.226034, acc = 0.930000\n", - "epoch [1692] L = 26.207462, acc = 0.930000\n", - "epoch [1693] L = 26.188913, acc = 0.930000\n", - "epoch [1694] L = 26.170388, acc = 0.930000\n", - "epoch [1695] L = 26.151886, acc = 0.930000\n", - "epoch [1696] L = 26.133408, acc = 0.930000\n", - "epoch [1697] L = 26.114954, acc = 0.930000\n", - "epoch [1698] L = 26.096523, acc = 0.930000\n", - "epoch [1699] L = 26.078115, acc = 0.930000\n", - "epoch [1700] L = 26.059731, acc = 0.930000\n", - "epoch [1701] L = 26.041371, acc = 0.930000\n", - "epoch [1702] L = 26.023034, acc = 0.930000\n", - "epoch [1703] L = 26.004721, acc = 0.930000\n", - "epoch [1704] L = 25.986432, acc = 0.930000\n", - "epoch [1705] L = 25.968166, acc = 0.930000\n", - "epoch [1706] L = 25.949924, acc = 0.930000\n", - "epoch [1707] L = 25.931705, acc = 0.930000\n", - "epoch [1708] L = 25.913510, acc = 0.930000\n", - "epoch [1709] L = 25.895338, acc = 0.930000\n", - "epoch [1710] L = 25.877190, acc = 0.930000\n", - "epoch [1711] L = 25.859066, acc = 0.930000\n", - "epoch [1712] L = 25.840965, acc = 0.930000\n", - "epoch [1713] L = 25.822888, acc = 0.930000\n", - "epoch [1714] L = 25.804835, acc = 0.930000\n", - "epoch [1715] L = 25.786805, acc = 0.930000\n", - "epoch [1716] L = 25.768799, acc = 0.930000\n", - "epoch [1717] L = 25.750816, acc = 0.930000\n", - "epoch [1718] L = 25.732857, acc = 0.930000\n", - "epoch [1719] L = 25.714922, acc = 0.930000\n", - "epoch [1720] L = 25.697010, acc = 0.930000\n", - "epoch [1721] L = 25.679122, acc = 0.930000\n", - "epoch [1722] L = 25.661258, acc = 0.930000\n", - "epoch [1723] L = 25.643417, acc = 0.930000\n", - "epoch [1724] L = 25.625599, acc = 0.930000\n", - "epoch [1725] L = 25.607806, acc = 0.930000\n", - "epoch [1726] L = 25.590036, acc = 0.930000\n", - "epoch [1727] L = 25.572289, acc = 0.930000\n", - "epoch [1728] L = 25.554567, acc = 0.930000\n", - "epoch [1729] L = 25.536867, acc = 0.930000\n", - "epoch [1730] L = 25.519192, acc = 0.930000\n", - "epoch [1731] L = 25.501540, acc = 0.930000\n", - "epoch [1732] L = 25.483911, acc = 0.930000\n", - "epoch [1733] L = 25.466306, acc = 0.930000\n", - "epoch [1734] L = 25.448725, acc = 0.930000\n", - "epoch [1735] L = 25.431167, acc = 0.930000\n", - "epoch [1736] L = 25.413633, acc = 0.930000\n", - "epoch [1737] L = 25.396122, acc = 0.930000\n", - "epoch [1738] L = 25.378635, acc = 0.930000\n", - "epoch [1739] L = 25.361172, acc = 0.930000\n", - "epoch [1740] L = 25.343732, acc = 0.930000\n", - "epoch [1741] L = 25.326315, acc = 0.930000\n", - "epoch [1742] L = 25.308923, acc = 0.930000\n", - "epoch [1743] L = 25.291553, acc = 0.930000\n", - "epoch [1744] L = 25.274207, acc = 0.930000\n", - "epoch [1745] L = 25.256885, acc = 0.930000\n", - "epoch [1746] L = 25.239586, acc = 0.930000\n", - "epoch [1747] L = 25.222310, acc = 0.930000\n", - "epoch [1748] L = 25.205059, acc = 0.930000\n", - "epoch [1749] L = 25.187830, acc = 0.930000\n", - "epoch [1750] L = 25.170625, acc = 0.930000\n", - "epoch [1751] L = 25.153443, acc = 0.930000\n", - "epoch [1752] L = 25.136285, acc = 0.930000\n", - "epoch [1753] L = 25.119151, acc = 0.930000\n", - "epoch [1754] L = 25.102039, acc = 0.930000\n", - "epoch [1755] L = 25.084951, acc = 0.930000\n", - "epoch [1756] L = 25.067887, acc = 0.930000\n", - "epoch [1757] L = 25.050846, acc = 0.930000\n", - "epoch [1758] L = 25.033828, acc = 0.930000\n", - "epoch [1759] L = 25.016833, acc = 0.930000\n", - "epoch [1760] L = 24.999862, acc = 0.930000\n", - "epoch [1761] L = 24.982915, acc = 0.930000\n", - "epoch [1762] L = 24.965990, acc = 0.930000\n", - "epoch [1763] L = 24.949089, acc = 0.930000\n", - "epoch [1764] L = 24.932211, acc = 0.930000\n", - "epoch [1765] L = 24.915357, acc = 0.930000\n", - "epoch [1766] L = 24.898526, acc = 0.930000\n", - "epoch [1767] L = 24.881718, acc = 0.930000\n", - "epoch [1768] L = 24.864933, acc = 0.930000\n", - "epoch [1769] L = 24.848171, acc = 0.930000\n", - "epoch [1770] L = 24.831433, acc = 0.930000\n", - "epoch [1771] L = 24.814718, acc = 0.930000\n", - "epoch [1772] L = 24.798026, acc = 0.930000\n", - "epoch [1773] L = 24.781357, acc = 0.930000\n", - "epoch [1774] L = 24.764712, acc = 0.930000\n", - "epoch [1775] L = 24.748089, acc = 0.930000\n", - "epoch [1776] L = 24.731490, acc = 0.930000\n", - "epoch [1777] L = 24.714913, acc = 0.930000\n", - "epoch [1778] L = 24.698360, acc = 0.930000\n", - "epoch [1779] L = 24.681830, acc = 0.930000\n", - "epoch [1780] L = 24.665323, acc = 0.930000\n", - "epoch [1781] L = 24.648839, acc = 0.930000\n", - "epoch [1782] L = 24.632378, acc = 0.930000\n", - "epoch [1783] L = 24.615940, acc = 0.930000\n", - "epoch [1784] L = 24.599525, acc = 0.930000\n", - "epoch [1785] L = 24.583133, acc = 0.930000\n", - "epoch [1786] L = 24.566764, acc = 0.930000\n", - "epoch [1787] L = 24.550418, acc = 0.930000\n", - "epoch [1788] L = 24.534095, acc = 0.930000\n", - "epoch [1789] L = 24.517795, acc = 0.930000\n", - "epoch [1790] L = 24.501518, acc = 0.930000\n", - "epoch [1791] L = 24.485263, acc = 0.930000\n", - "epoch [1792] L = 24.469031, acc = 0.930000\n", - "epoch [1793] L = 24.452823, acc = 0.930000\n", - "epoch [1794] L = 24.436637, acc = 0.930000\n", - "epoch [1795] L = 24.420473, acc = 0.930000\n", - "epoch [1796] L = 24.404333, acc = 0.930000\n", - "epoch [1797] L = 24.388215, acc = 0.930000\n", - "epoch [1798] L = 24.372120, acc = 0.930000\n", - "epoch [1799] L = 24.356048, acc = 0.930000\n", - "epoch [1800] L = 24.339998, acc = 0.930000\n", - "epoch [1801] L = 24.323972, acc = 0.930000\n", - "epoch [1802] L = 24.307967, acc = 0.930000\n", - "epoch [1803] L = 24.291986, acc = 0.930000\n", - "epoch [1804] L = 24.276027, acc = 0.930000\n", - "epoch [1805] L = 24.260090, acc = 0.930000\n", - "epoch [1806] L = 24.244177, acc = 0.930000\n", - "epoch [1807] L = 24.228285, acc = 0.930000\n", - "epoch [1808] L = 24.212417, acc = 0.930000\n", - "epoch [1809] L = 24.196570, acc = 0.930000\n", - "epoch [1810] L = 24.180747, acc = 0.930000\n", - "epoch [1811] L = 24.164945, acc = 0.930000\n", - "epoch [1812] L = 24.149167, acc = 0.930000\n", - "epoch [1813] L = 24.133410, acc = 0.930000\n", - "epoch [1814] L = 24.117676, acc = 0.930000\n", - "epoch [1815] L = 24.101965, acc = 0.930000\n", - "epoch [1816] L = 24.086275, acc = 0.930000\n", - "epoch [1817] L = 24.070608, acc = 0.930000\n", - "epoch [1818] L = 24.054964, acc = 0.930000\n", - "epoch [1819] L = 24.039341, acc = 0.930000\n", - "epoch [1820] L = 24.023741, acc = 0.930000\n", - "epoch [1821] L = 24.008163, acc = 0.930000\n", - "epoch [1822] L = 23.992608, acc = 0.930000\n", - "epoch [1823] L = 23.977074, acc = 0.930000\n", - "epoch [1824] L = 23.961563, acc = 0.930000\n", - "epoch [1825] L = 23.946074, acc = 0.935000\n", - "epoch [1826] L = 23.930607, acc = 0.935000\n", - "epoch [1827] L = 23.915162, acc = 0.935000\n", - "epoch [1828] L = 23.899739, acc = 0.935000\n", - "epoch [1829] L = 23.884339, acc = 0.935000\n", - "epoch [1830] L = 23.868960, acc = 0.935000\n", - "epoch [1831] L = 23.853603, acc = 0.935000\n", - "epoch [1832] L = 23.838269, acc = 0.935000\n", - "epoch [1833] L = 23.822956, acc = 0.935000\n", - "epoch [1834] L = 23.807665, acc = 0.935000\n", - "epoch [1835] L = 23.792396, acc = 0.935000\n", - "epoch [1836] L = 23.777149, acc = 0.935000\n", - "epoch [1837] L = 23.761924, acc = 0.935000\n", - "epoch [1838] L = 23.746720, acc = 0.935000\n", - "epoch [1839] L = 23.731539, acc = 0.935000\n", - "epoch [1840] L = 23.716379, acc = 0.935000\n", - "epoch [1841] L = 23.701241, acc = 0.935000\n", - "epoch [1842] L = 23.686125, acc = 0.935000\n", - "epoch [1843] L = 23.671030, acc = 0.935000\n", - "epoch [1844] L = 23.655957, acc = 0.935000\n", - "epoch [1845] L = 23.640906, acc = 0.935000\n", - "epoch [1846] L = 23.625876, acc = 0.935000\n", - "epoch [1847] L = 23.610868, acc = 0.935000\n", - "epoch [1848] L = 23.595882, acc = 0.935000\n", - "epoch [1849] L = 23.580917, acc = 0.935000\n", - "epoch [1850] L = 23.565973, acc = 0.935000\n", - "epoch [1851] L = 23.551052, acc = 0.935000\n", - "epoch [1852] L = 23.536151, acc = 0.935000\n", - "epoch [1853] L = 23.521272, acc = 0.935000\n", - "epoch [1854] L = 23.506415, acc = 0.935000\n", - "epoch [1855] L = 23.491578, acc = 0.935000\n", - "epoch [1856] L = 23.476764, acc = 0.935000\n", - "epoch [1857] L = 23.461970, acc = 0.935000\n", - "epoch [1858] L = 23.447198, acc = 0.935000\n", - "epoch [1859] L = 23.432447, acc = 0.935000\n", - "epoch [1860] L = 23.417717, acc = 0.935000\n", - "epoch [1861] L = 23.403009, acc = 0.935000\n", - "epoch [1862] L = 23.388322, acc = 0.935000\n", - "epoch [1863] L = 23.373656, acc = 0.935000\n", - "epoch [1864] L = 23.359011, acc = 0.935000\n", - "epoch [1865] L = 23.344387, acc = 0.935000\n", - "epoch [1866] L = 23.329784, acc = 0.935000\n", - "epoch [1867] L = 23.315202, acc = 0.935000\n", - "epoch [1868] L = 23.300642, acc = 0.935000\n", - "epoch [1869] L = 23.286102, acc = 0.935000\n", - "epoch [1870] L = 23.271583, acc = 0.935000\n", - "epoch [1871] L = 23.257086, acc = 0.935000\n", - "epoch [1872] L = 23.242609, acc = 0.935000\n", - "epoch [1873] L = 23.228153, acc = 0.935000\n", - "epoch [1874] L = 23.213718, acc = 0.935000\n", - "epoch [1875] L = 23.199304, acc = 0.935000\n", - "epoch [1876] L = 23.184910, acc = 0.935000\n", - "epoch [1877] L = 23.170538, acc = 0.935000\n", - "epoch [1878] L = 23.156186, acc = 0.935000\n", - "epoch [1879] L = 23.141855, acc = 0.935000\n", - "epoch [1880] L = 23.127544, acc = 0.935000\n", - "epoch [1881] L = 23.113254, acc = 0.935000\n", - "epoch [1882] L = 23.098985, acc = 0.935000\n", - "epoch [1883] L = 23.084736, acc = 0.935000\n", - "epoch [1884] L = 23.070508, acc = 0.935000\n", - "epoch [1885] L = 23.056301, acc = 0.935000\n", - "epoch [1886] L = 23.042114, acc = 0.935000\n", - "epoch [1887] L = 23.027947, acc = 0.935000\n", - "epoch [1888] L = 23.013801, acc = 0.935000\n", - "epoch [1889] L = 22.999676, acc = 0.935000\n", - "epoch [1890] L = 22.985571, acc = 0.935000\n", - "epoch [1891] L = 22.971486, acc = 0.935000\n", - "epoch [1892] L = 22.957421, acc = 0.935000\n", - "epoch [1893] L = 22.943377, acc = 0.935000\n", - "epoch [1894] L = 22.929353, acc = 0.935000\n", - "epoch [1895] L = 22.915349, acc = 0.935000\n", - "epoch [1896] L = 22.901366, acc = 0.935000\n", - "epoch [1897] L = 22.887402, acc = 0.935000\n", - "epoch [1898] L = 22.873459, acc = 0.935000\n", - "epoch [1899] L = 22.859536, acc = 0.935000\n", - "epoch [1900] L = 22.845633, acc = 0.935000\n", - "epoch [1901] L = 22.831750, acc = 0.935000\n", - "epoch [1902] L = 22.817888, acc = 0.935000\n", - "epoch [1903] L = 22.804045, acc = 0.935000\n", - "epoch [1904] L = 22.790222, acc = 0.935000\n", - "epoch [1905] L = 22.776419, acc = 0.935000\n", - "epoch [1906] L = 22.762636, acc = 0.935000\n", - "epoch [1907] L = 22.748873, acc = 0.935000\n", - "epoch [1908] L = 22.735130, acc = 0.935000\n", - "epoch [1909] L = 22.721406, acc = 0.935000\n", - "epoch [1910] L = 22.707702, acc = 0.935000\n", - "epoch [1911] L = 22.694018, acc = 0.935000\n", - "epoch [1912] L = 22.680354, acc = 0.935000\n", - "epoch [1913] L = 22.666710, acc = 0.935000\n", - "epoch [1914] L = 22.653085, acc = 0.935000\n", - "epoch [1915] L = 22.639480, acc = 0.935000\n", - "epoch [1916] L = 22.625894, acc = 0.935000\n", - "epoch [1917] L = 22.612328, acc = 0.935000\n", - "epoch [1918] L = 22.598782, acc = 0.935000\n", - "epoch [1919] L = 22.585255, acc = 0.935000\n", - "epoch [1920] L = 22.571747, acc = 0.935000\n", - "epoch [1921] L = 22.558259, acc = 0.935000\n", - "epoch [1922] L = 22.544791, acc = 0.940000\n", - "epoch [1923] L = 22.531341, acc = 0.940000\n", - "epoch [1924] L = 22.517911, acc = 0.940000\n", - "epoch [1925] L = 22.504501, acc = 0.940000\n", - "epoch [1926] L = 22.491110, acc = 0.940000\n", - "epoch [1927] L = 22.477738, acc = 0.940000\n", - "epoch [1928] L = 22.464385, acc = 0.940000\n", - "epoch [1929] L = 22.451051, acc = 0.940000\n", - "epoch [1930] L = 22.437737, acc = 0.940000\n", - "epoch [1931] L = 22.424441, acc = 0.940000\n", - "epoch [1932] L = 22.411165, acc = 0.940000\n", - "epoch [1933] L = 22.397908, acc = 0.940000\n", - "epoch [1934] L = 22.384670, acc = 0.940000\n", - "epoch [1935] L = 22.371451, acc = 0.940000\n", - "epoch [1936] L = 22.358251, acc = 0.940000\n", - "epoch [1937] L = 22.345070, acc = 0.940000\n", - "epoch [1938] L = 22.331908, acc = 0.940000\n", - "epoch [1939] L = 22.318764, acc = 0.940000\n", - "epoch [1940] L = 22.305640, acc = 0.940000\n", - "epoch [1941] L = 22.292534, acc = 0.940000\n", - "epoch [1942] L = 22.279447, acc = 0.940000\n", - "epoch [1943] L = 22.266379, acc = 0.940000\n", - "epoch [1944] L = 22.253329, acc = 0.940000\n", - "epoch [1945] L = 22.240299, acc = 0.940000\n", - "epoch [1946] L = 22.227287, acc = 0.940000\n", - "epoch [1947] L = 22.214293, acc = 0.940000\n", - "epoch [1948] L = 22.201318, acc = 0.940000\n", - "epoch [1949] L = 22.188362, acc = 0.940000\n", - "epoch [1950] L = 22.175424, acc = 0.940000\n", - "epoch [1951] L = 22.162505, acc = 0.940000\n", - "epoch [1952] L = 22.149604, acc = 0.940000\n", - "epoch [1953] L = 22.136722, acc = 0.940000\n", - "epoch [1954] L = 22.123858, acc = 0.940000\n", - "epoch [1955] L = 22.111012, acc = 0.940000\n", - "epoch [1956] L = 22.098185, acc = 0.940000\n", - "epoch [1957] L = 22.085376, acc = 0.940000\n", - "epoch [1958] L = 22.072585, acc = 0.940000\n", - "epoch [1959] L = 22.059813, acc = 0.940000\n", - "epoch [1960] L = 22.047058, acc = 0.940000\n", - "epoch [1961] L = 22.034322, acc = 0.940000\n", - "epoch [1962] L = 22.021604, acc = 0.940000\n", - "epoch [1963] L = 22.008904, acc = 0.940000\n", - "epoch [1964] L = 21.996223, acc = 0.940000\n", - "epoch [1965] L = 21.983559, acc = 0.940000\n", - "epoch [1966] L = 21.970913, acc = 0.940000\n", - "epoch [1967] L = 21.958286, acc = 0.940000\n", - "epoch [1968] L = 21.945676, acc = 0.940000\n", - "epoch [1969] L = 21.933084, acc = 0.940000\n", - "epoch [1970] L = 21.920510, acc = 0.940000\n", - "epoch [1971] L = 21.907954, acc = 0.940000\n", - "epoch [1972] L = 21.895416, acc = 0.940000\n", - "epoch [1973] L = 21.882895, acc = 0.940000\n", - "epoch [1974] L = 21.870393, acc = 0.940000\n", - "epoch [1975] L = 21.857908, acc = 0.940000\n", - "epoch [1976] L = 21.845440, acc = 0.940000\n", - "epoch [1977] L = 21.832991, acc = 0.940000\n", - "epoch [1978] L = 21.820559, acc = 0.940000\n", - "epoch [1979] L = 21.808144, acc = 0.940000\n", - "epoch [1980] L = 21.795747, acc = 0.940000\n", - "epoch [1981] L = 21.783368, acc = 0.940000\n", - "epoch [1982] L = 21.771006, acc = 0.940000\n", - "epoch [1983] L = 21.758662, acc = 0.940000\n", - "epoch [1984] L = 21.746335, acc = 0.945000\n", - "epoch [1985] L = 21.734025, acc = 0.945000\n", - "epoch [1986] L = 21.721733, acc = 0.945000\n", - "epoch [1987] L = 21.709458, acc = 0.945000\n", - "epoch [1988] L = 21.697201, acc = 0.945000\n", - "epoch [1989] L = 21.684961, acc = 0.945000\n", - "epoch [1990] L = 21.672738, acc = 0.945000\n", - "epoch [1991] L = 21.660532, acc = 0.945000\n", - "epoch [1992] L = 21.648343, acc = 0.945000\n", - "epoch [1993] L = 21.636172, acc = 0.945000\n", - "epoch [1994] L = 21.624017, acc = 0.945000\n", - "epoch [1995] L = 21.611880, acc = 0.945000\n", - "epoch [1996] L = 21.599760, acc = 0.945000\n", - "epoch [1997] L = 21.587657, acc = 0.945000\n", - "epoch [1998] L = 21.575570, acc = 0.945000\n", - "epoch [1999] L = 21.563501, acc = 0.945000\n" + "epoch [ 0] L = 21.551449, acc = 0.945000\n", + "epoch [ 100] L = 20.426241, acc = 0.950000\n", + "epoch [ 200] L = 19.439654, acc = 0.950000\n", + "epoch [ 300] L = 18.566054, acc = 0.955000\n", + "epoch [ 400] L = 17.785764, acc = 0.955000\n", + "epoch [ 500] L = 17.084338, acc = 0.955000\n", + "epoch [ 600] L = 16.450998, acc = 0.960000\n", + "epoch [ 700] L = 15.877223, acc = 0.960000\n", + "epoch [ 800] L = 15.355889, acc = 0.960000\n", + "epoch [ 900] L = 14.880860, acc = 0.960000\n", + "epoch [1000] L = 14.446814, acc = 0.960000\n", + "epoch [1100] L = 14.049131, acc = 0.960000\n", + "epoch [1200] L = 13.683787, acc = 0.965000\n", + "epoch [1300] L = 13.347243, acc = 0.965000\n", + "epoch [1400] L = 13.036353, acc = 0.965000\n", + "epoch [1500] L = 12.748284, acc = 0.965000\n", + "epoch [1600] L = 12.480470, acc = 0.965000\n", + "epoch [1700] L = 12.230590, acc = 0.965000\n", + "epoch [1800] L = 11.996560, acc = 0.965000\n", + "epoch [1900] L = 11.776538, acc = 0.965000\n" ] } ], @@ -2631,7 +647,8 @@ " y_pred = np.argmax(nn.z2, axis=1)\n", " acc = accuracy_score(y_true, y_pred)\n", " \n", - " print(\"epoch [%4d] L = %f, acc = %f\" % (i, L, acc))\n", + " if i % 100 == 0:\n", + " print(\"epoch [%4d] L = %f, acc = %f\" % (i, L, acc))\n", " \n", " # calc weights update\n", " d2 = n.z2*(1-n.z2)*(t - n.z2)\n", @@ -2649,12 +666,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2666,7 +683,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2699,7 +716,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -2764,6 +781,7 @@ " # forward to calculate each node's output\n", " self.forward(X)\n", "\n", + " self.epoch = i\n", " self.evaluate()\n", " \n", " # calc weights update\n", @@ -2807,18 +825,19 @@ " y_true = np.argmax(self.Y, axis=1)\n", " acc = accuracy_score(y_true, y_pred)\n", " \n", - " print(\"L = %f, acc = %f\" % (L, acc))\n", + " if self.epoch % 100 == 0:\n", + " print(\"L = %f, acc = %f\" % (L, acc))\n", " " ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2846,2037 +865,33 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "L = 120.450672, acc = 0.500000\n", - "L = 114.599131, acc = 0.500000\n", - "L = 109.796619, acc = 0.500000\n", - "L = 106.133081, acc = 0.500000\n", - "L = 103.520770, acc = 0.500000\n", - "L = 101.758582, acc = 0.500000\n", - "L = 100.614302, acc = 0.500000\n", - "L = 99.883624, acc = 0.500000\n", - "L = 99.413454, acc = 0.500000\n", - "L = 99.100287, acc = 0.500000\n", - "L = 98.878649, acc = 0.500000\n", - "L = 98.708861, acc = 0.500000\n", - "L = 98.567524, acc = 0.525000\n", - "L = 98.441059, acc = 0.720000\n", - "L = 98.321651, acc = 0.765000\n", - "L = 98.204802, acc = 0.745000\n", - "L = 98.087896, acc = 0.745000\n", - "L = 97.969379, acc = 0.725000\n", - "L = 97.848284, acc = 0.735000\n", - "L = 97.723969, acc = 0.750000\n", - "L = 97.595969, acc = 0.755000\n", - "L = 97.463912, acc = 0.765000\n", - "L = 97.327472, acc = 0.765000\n", - "L = 97.186346, acc = 0.770000\n", - "L = 97.040234, acc = 0.770000\n", - "L = 96.888838, acc = 0.770000\n", - "L = 96.731850, acc = 0.770000\n", - "L = 96.568956, acc = 0.770000\n", - "L = 96.399828, acc = 0.770000\n", - "L = 96.224128, acc = 0.770000\n", - "L = 96.041502, acc = 0.770000\n", - "L = 95.851585, acc = 0.770000\n", - "L = 95.653996, acc = 0.770000\n", - "L = 95.448342, acc = 0.770000\n", - "L = 95.234212, acc = 0.770000\n", - "L = 95.011183, acc = 0.770000\n", - "L = 94.778815, acc = 0.770000\n", - "L = 94.536655, acc = 0.775000\n", - "L = 94.284235, acc = 0.775000\n", - "L = 94.021071, acc = 0.775000\n", - "L = 93.746669, acc = 0.775000\n", - "L = 93.460519, acc = 0.775000\n", - "L = 93.162101, acc = 0.780000\n", - "L = 92.850884, acc = 0.780000\n", - "L = 92.526330, acc = 0.780000\n", - "L = 92.187891, acc = 0.780000\n", - "L = 91.835017, acc = 0.780000\n", - "L = 91.467156, acc = 0.780000\n", - "L = 91.083757, acc = 0.780000\n", - "L = 90.684274, acc = 0.785000\n", - "L = 90.268170, acc = 0.785000\n", - "L = 89.834924, acc = 0.785000\n", - "L = 89.384033, acc = 0.785000\n", - "L = 88.915021, acc = 0.790000\n", - "L = 88.427441, acc = 0.790000\n", - "L = 87.920889, acc = 0.790000\n", - "L = 87.395006, acc = 0.790000\n", - "L = 86.849489, acc = 0.790000\n", - "L = 86.284099, acc = 0.790000\n", - "L = 85.698671, acc = 0.790000\n", - "L = 85.093122, acc = 0.785000\n", - "L = 84.467464, acc = 0.785000\n", - "L = 83.821809, acc = 0.785000\n", - "L = 83.156381, acc = 0.785000\n", - "L = 82.471524, acc = 0.785000\n", - "L = 81.767711, acc = 0.790000\n", - "L = 81.045549, acc = 0.795000\n", - "L = 80.305784, acc = 0.805000\n", - "L = 79.549307, acc = 0.805000\n", - "L = 78.777153, acc = 0.805000\n", - "L = 77.990498, acc = 0.805000\n", - "L = 77.190660, acc = 0.800000\n", - "L = 76.379088, acc = 0.800000\n", - "L = 75.557353, acc = 0.800000\n", - "L = 74.727136, acc = 0.805000\n", - "L = 73.890211, acc = 0.805000\n", - "L = 73.048431, acc = 0.805000\n", - "L = 72.203701, acc = 0.810000\n", - "L = 71.357961, acc = 0.810000\n", - "L = 70.513161, acc = 0.810000\n", - "L = 69.671238, acc = 0.810000\n", - "L = 68.834091, acc = 0.810000\n", - "L = 68.003559, acc = 0.810000\n", - "L = 67.181400, acc = 0.810000\n", - "L = 66.369273, acc = 0.810000\n", - "L = 65.568719, acc = 0.810000\n", - "L = 64.781148, acc = 0.810000\n", - "L = 64.007829, acc = 0.810000\n", - "L = 63.249883, acc = 0.810000\n", - "L = 62.508277, acc = 0.810000\n", - "L = 61.783827, acc = 0.810000\n", - "L = 61.077193, acc = 0.810000\n", - "L = 60.388892, acc = 0.810000\n", - "L = 59.719297, acc = 0.810000\n", - "L = 59.068651, acc = 0.810000\n", - "L = 58.437071, acc = 0.810000\n", - "L = 57.824564, acc = 0.815000\n", - "L = 57.231037, acc = 0.815000\n", - "L = 56.656306, acc = 0.815000\n", - "L = 56.100110, acc = 0.815000\n", - "L = 55.562122, acc = 0.815000\n", - "L = 55.041959, acc = 0.815000\n", - "L = 54.539192, acc = 0.815000\n", - "L = 54.053357, acc = 0.815000\n", - "L = 53.583961, acc = 0.815000\n", - "L = 53.130494, acc = 0.820000\n", - "L = 52.692430, acc = 0.825000\n", - "L = 52.269238, acc = 0.825000\n", - "L = 51.860385, acc = 0.825000\n", - "L = 51.465342, acc = 0.825000\n", - "L = 51.083586, acc = 0.830000\n", - "L = 50.714603, acc = 0.830000\n", - "L = 50.357894, acc = 0.830000\n", - "L = 50.012971, acc = 0.830000\n", - "L = 49.679365, acc = 0.830000\n", - "L = 49.356622, acc = 0.830000\n", - "L = 49.044308, acc = 0.830000\n", - "L = 48.742004, acc = 0.830000\n", - "L = 48.449313, acc = 0.830000\n", - "L = 48.165855, acc = 0.830000\n", - "L = 47.891266, acc = 0.830000\n", - "L = 47.625203, acc = 0.830000\n", - "L = 47.367339, acc = 0.830000\n", - "L = 47.117363, acc = 0.830000\n", - "L = 46.874981, acc = 0.830000\n", - "L = 46.639915, acc = 0.830000\n", - "L = 46.411899, acc = 0.830000\n", - "L = 46.190683, acc = 0.830000\n", - "L = 45.976030, acc = 0.830000\n", - "L = 45.767714, acc = 0.835000\n", - "L = 45.565522, acc = 0.835000\n", - "L = 45.369250, acc = 0.835000\n", - "L = 45.178706, acc = 0.835000\n", - "L = 44.993707, acc = 0.835000\n", - "L = 44.814077, acc = 0.835000\n", - "L = 44.639650, acc = 0.835000\n", - "L = 44.470267, acc = 0.835000\n", - "L = 44.305775, acc = 0.835000\n", - "L = 44.146029, acc = 0.835000\n", - "L = 43.990888, acc = 0.835000\n", - "L = 43.840218, acc = 0.840000\n", - "L = 43.693890, acc = 0.835000\n", - "L = 43.551779, acc = 0.835000\n", - "L = 43.413764, acc = 0.835000\n", - "L = 43.279728, acc = 0.835000\n", - "L = 43.149560, acc = 0.835000\n", - "L = 43.023150, acc = 0.835000\n", - "L = 42.900392, acc = 0.835000\n", - "L = 42.781182, acc = 0.835000\n", - "L = 42.665421, acc = 0.835000\n", - "L = 42.553011, acc = 0.835000\n", - "L = 42.443857, acc = 0.840000\n", - "L = 42.337866, acc = 0.835000\n", - "L = 42.234948, acc = 0.835000\n", - "L = 42.135015, acc = 0.835000\n", - "L = 42.037981, acc = 0.835000\n", - "L = 41.943762, acc = 0.835000\n", - "L = 41.852275, acc = 0.835000\n", - "L = 41.763440, acc = 0.835000\n", - "L = 41.677180, acc = 0.835000\n", - "L = 41.593417, acc = 0.835000\n", - "L = 41.512078, acc = 0.835000\n", - "L = 41.433089, acc = 0.835000\n", - "L = 41.356378, acc = 0.835000\n", - "L = 41.281878, acc = 0.835000\n", - "L = 41.209519, acc = 0.835000\n", - "L = 41.139235, acc = 0.835000\n", - "L = 41.070963, acc = 0.835000\n", - "L = 41.004640, acc = 0.835000\n", - "L = 40.940203, acc = 0.835000\n", - "L = 40.877595, acc = 0.835000\n", - "L = 40.816756, acc = 0.835000\n", - "L = 40.757630, acc = 0.835000\n", - "L = 40.700162, acc = 0.840000\n", - "L = 40.644300, acc = 0.840000\n", - "L = 40.589990, acc = 0.840000\n", - "L = 40.537183, acc = 0.840000\n", - "L = 40.485829, acc = 0.840000\n", - "L = 40.435881, acc = 0.840000\n", - "L = 40.387293, acc = 0.840000\n", - "L = 40.340020, acc = 0.840000\n", - "L = 40.294018, acc = 0.850000\n", - "L = 40.249246, acc = 0.850000\n", - "L = 40.205663, acc = 0.855000\n", - "L = 40.163228, acc = 0.855000\n", - "L = 40.121904, acc = 0.855000\n", - "L = 40.081653, acc = 0.855000\n", - "L = 40.042440, acc = 0.855000\n", - "L = 40.004229, acc = 0.855000\n", - "L = 39.966988, acc = 0.855000\n", - "L = 39.930682, acc = 0.855000\n", - "L = 39.895282, acc = 0.855000\n", - "L = 39.860756, acc = 0.855000\n", - "L = 39.827075, acc = 0.855000\n", - "L = 39.794209, acc = 0.855000\n", - "L = 39.762133, acc = 0.855000\n", - "L = 39.730818, acc = 0.855000\n", - "L = 39.700240, acc = 0.855000\n", - "L = 39.670372, acc = 0.855000\n", - "L = 39.641192, acc = 0.855000\n", - "L = 39.612675, acc = 0.855000\n", - "L = 39.584799, acc = 0.855000\n", - "L = 39.557543, acc = 0.855000\n", - "L = 39.530885, acc = 0.855000\n", - "L = 39.504805, acc = 0.855000\n", - "L = 39.479283, acc = 0.855000\n", - "L = 39.454300, acc = 0.855000\n", - "L = 39.429838, acc = 0.855000\n", - "L = 39.405880, acc = 0.855000\n", - "L = 39.382407, acc = 0.855000\n", - "L = 39.359404, acc = 0.855000\n", - "L = 39.336854, acc = 0.855000\n", - "L = 39.314741, acc = 0.855000\n", - "L = 39.293052, acc = 0.855000\n", - "L = 39.271771, acc = 0.855000\n", - "L = 39.250884, acc = 0.855000\n", - "L = 39.230377, acc = 0.855000\n", - "L = 39.210239, acc = 0.855000\n", - "L = 39.190455, acc = 0.855000\n", - "L = 39.171014, acc = 0.855000\n", - "L = 39.151903, acc = 0.855000\n", - "L = 39.133112, acc = 0.855000\n", - "L = 39.114629, acc = 0.855000\n", - "L = 39.096444, acc = 0.855000\n", - "L = 39.078546, acc = 0.855000\n", - "L = 39.060924, acc = 0.855000\n", - "L = 39.043570, acc = 0.855000\n", - "L = 39.026473, acc = 0.855000\n", - "L = 39.009625, acc = 0.855000\n", - "L = 38.993017, acc = 0.855000\n", - "L = 38.976640, acc = 0.855000\n", - "L = 38.960486, acc = 0.855000\n", - "L = 38.944547, acc = 0.855000\n", - "L = 38.928815, acc = 0.855000\n", - "L = 38.913282, acc = 0.855000\n", - "L = 38.897942, acc = 0.855000\n", - "L = 38.882786, acc = 0.855000\n", - "L = 38.867809, acc = 0.855000\n", - "L = 38.853004, acc = 0.855000\n", - "L = 38.838363, acc = 0.855000\n", - "L = 38.823882, acc = 0.860000\n", - "L = 38.809553, acc = 0.860000\n", - "L = 38.795371, acc = 0.860000\n", - "L = 38.781330, acc = 0.860000\n", - "L = 38.767424, acc = 0.860000\n", - "L = 38.753649, acc = 0.860000\n", - "L = 38.739999, acc = 0.860000\n", - "L = 38.726469, acc = 0.860000\n", - "L = 38.713054, acc = 0.860000\n", - "L = 38.699749, acc = 0.860000\n", - "L = 38.686549, acc = 0.860000\n", - "L = 38.673451, acc = 0.860000\n", - "L = 38.660449, acc = 0.860000\n", - "L = 38.647539, acc = 0.860000\n", - "L = 38.634718, acc = 0.860000\n", - "L = 38.621981, acc = 0.860000\n", - "L = 38.609325, acc = 0.860000\n", - "L = 38.596744, acc = 0.860000\n", - "L = 38.584237, acc = 0.860000\n", - "L = 38.571799, acc = 0.860000\n", - "L = 38.559427, acc = 0.860000\n", - "L = 38.547117, acc = 0.860000\n", - "L = 38.534866, acc = 0.860000\n", - "L = 38.522671, acc = 0.860000\n", - "L = 38.510529, acc = 0.860000\n", - "L = 38.498436, acc = 0.860000\n", - "L = 38.486390, acc = 0.860000\n", - "L = 38.474388, acc = 0.860000\n", - "L = 38.462427, acc = 0.860000\n", - "L = 38.450505, acc = 0.860000\n", - "L = 38.438617, acc = 0.860000\n", - "L = 38.426763, acc = 0.860000\n", - "L = 38.414940, acc = 0.860000\n", - "L = 38.403144, acc = 0.860000\n", - "L = 38.391374, acc = 0.860000\n", - "L = 38.379627, acc = 0.860000\n", - "L = 38.367902, acc = 0.860000\n", - "L = 38.356195, acc = 0.860000\n", - "L = 38.344505, acc = 0.860000\n", - "L = 38.332829, acc = 0.860000\n", - "L = 38.321165, acc = 0.860000\n", - "L = 38.309512, acc = 0.860000\n", - "L = 38.297868, acc = 0.860000\n", - "L = 38.286229, acc = 0.860000\n", - "L = 38.274596, acc = 0.860000\n", - "L = 38.262965, acc = 0.860000\n", - "L = 38.251335, acc = 0.860000\n", - "L = 38.239704, acc = 0.860000\n", - "L = 38.228071, acc = 0.860000\n", - "L = 38.216434, acc = 0.860000\n", - "L = 38.204790, acc = 0.860000\n", - "L = 38.193139, acc = 0.860000\n", - "L = 38.181479, acc = 0.860000\n", - "L = 38.169809, acc = 0.860000\n", - "L = 38.158126, acc = 0.860000\n", - "L = 38.146430, acc = 0.860000\n", - "L = 38.134718, acc = 0.860000\n", - "L = 38.122990, acc = 0.860000\n", - "L = 38.111244, acc = 0.860000\n", - "L = 38.099479, acc = 0.860000\n", - "L = 38.087693, acc = 0.860000\n", - "L = 38.075885, acc = 0.860000\n", - "L = 38.064054, acc = 0.860000\n", - "L = 38.052198, acc = 0.860000\n", - "L = 38.040316, acc = 0.860000\n", - "L = 38.028407, acc = 0.860000\n", - "L = 38.016470, acc = 0.860000\n", - "L = 38.004503, acc = 0.860000\n", - "L = 37.992506, acc = 0.860000\n", - "L = 37.980476, acc = 0.860000\n", - "L = 37.968414, acc = 0.860000\n", - "L = 37.956317, acc = 0.860000\n", - "L = 37.944185, acc = 0.860000\n", - "L = 37.932016, acc = 0.860000\n", - "L = 37.919810, acc = 0.860000\n", - "L = 37.907565, acc = 0.865000\n", - "L = 37.895280, acc = 0.865000\n", - "L = 37.882955, acc = 0.865000\n", - "L = 37.870587, acc = 0.865000\n", - "L = 37.858177, acc = 0.865000\n", - "L = 37.845723, acc = 0.865000\n", - "L = 37.833224, acc = 0.865000\n", - "L = 37.820679, acc = 0.865000\n", - "L = 37.808086, acc = 0.865000\n", - "L = 37.795446, acc = 0.865000\n", - "L = 37.782757, acc = 0.865000\n", - "L = 37.770018, acc = 0.865000\n", - "L = 37.757228, acc = 0.865000\n", - "L = 37.744386, acc = 0.865000\n", - "L = 37.731491, acc = 0.865000\n", - "L = 37.718542, acc = 0.865000\n", - "L = 37.705538, acc = 0.865000\n", - "L = 37.692479, acc = 0.865000\n", - "L = 37.679363, acc = 0.865000\n", - "L = 37.666189, acc = 0.865000\n", - "L = 37.652956, acc = 0.865000\n", - "L = 37.639664, acc = 0.865000\n", - "L = 37.626312, acc = 0.865000\n", - "L = 37.612898, acc = 0.865000\n", - "L = 37.599422, acc = 0.865000\n", - "L = 37.585882, acc = 0.865000\n", - "L = 37.572278, acc = 0.865000\n", - "L = 37.558609, acc = 0.865000\n", - "L = 37.544874, acc = 0.865000\n", - "L = 37.531072, acc = 0.865000\n", - "L = 37.517202, acc = 0.865000\n", - "L = 37.503263, acc = 0.865000\n", - "L = 37.489255, acc = 0.865000\n", - "L = 37.475176, acc = 0.865000\n", - "L = 37.461025, acc = 0.865000\n", - "L = 37.446802, acc = 0.865000\n", - "L = 37.432505, acc = 0.865000\n", - "L = 37.418134, acc = 0.865000\n", - "L = 37.403688, acc = 0.865000\n", - "L = 37.389166, acc = 0.865000\n", - "L = 37.374566, acc = 0.865000\n", - "L = 37.359889, acc = 0.865000\n", - "L = 37.345132, acc = 0.865000\n", - "L = 37.330296, acc = 0.865000\n", - "L = 37.315379, acc = 0.865000\n", - "L = 37.300381, acc = 0.865000\n", - "L = 37.285299, acc = 0.865000\n", - "L = 37.270135, acc = 0.865000\n", - "L = 37.254886, acc = 0.865000\n", - "L = 37.239551, acc = 0.865000\n", - "L = 37.224130, acc = 0.865000\n", - "L = 37.208622, acc = 0.865000\n", - "L = 37.193026, acc = 0.865000\n", - "L = 37.177341, acc = 0.865000\n", - "L = 37.161566, acc = 0.870000\n", - "L = 37.145701, acc = 0.870000\n", - "L = 37.129743, acc = 0.870000\n", - "L = 37.113693, acc = 0.870000\n", - "L = 37.097549, acc = 0.870000\n", - "L = 37.081310, acc = 0.870000\n", - "L = 37.064976, acc = 0.870000\n", - "L = 37.048546, acc = 0.870000\n", - "L = 37.032018, acc = 0.870000\n", - "L = 37.015393, acc = 0.870000\n", - "L = 36.998668, acc = 0.870000\n", - "L = 36.981843, acc = 0.870000\n", - "L = 36.964917, acc = 0.870000\n", - "L = 36.947889, acc = 0.870000\n", - "L = 36.930758, acc = 0.870000\n", - "L = 36.913523, acc = 0.870000\n", - "L = 36.896184, acc = 0.870000\n", - "L = 36.878740, acc = 0.870000\n", - "L = 36.861189, acc = 0.870000\n", - "L = 36.843530, acc = 0.865000\n", - "L = 36.825763, acc = 0.865000\n", - "L = 36.807887, acc = 0.865000\n", - "L = 36.789901, acc = 0.865000\n", - "L = 36.771804, acc = 0.865000\n", - "L = 36.753596, acc = 0.870000\n", - "L = 36.735274, acc = 0.870000\n", - "L = 36.716838, acc = 0.870000\n", - "L = 36.698288, acc = 0.870000\n", - "L = 36.679623, acc = 0.870000\n", - "L = 36.660841, acc = 0.870000\n", - "L = 36.641942, acc = 0.870000\n", - "L = 36.622925, acc = 0.870000\n", - "L = 36.603789, acc = 0.870000\n", - "L = 36.584533, acc = 0.870000\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "L = 36.565157, acc = 0.870000\n", - "L = 36.545658, acc = 0.870000\n", - "L = 36.526038, acc = 0.875000\n", - "L = 36.506294, acc = 0.875000\n", - "L = 36.486425, acc = 0.875000\n", - "L = 36.466432, acc = 0.875000\n", - "L = 36.446313, acc = 0.875000\n", - "L = 36.426067, acc = 0.875000\n", - "L = 36.405694, acc = 0.875000\n", - "L = 36.385193, acc = 0.875000\n", - "L = 36.364562, acc = 0.875000\n", - "L = 36.343801, acc = 0.875000\n", - "L = 36.322910, acc = 0.875000\n", - "L = 36.301887, acc = 0.875000\n", - "L = 36.280731, acc = 0.875000\n", - "L = 36.259443, acc = 0.875000\n", - "L = 36.238020, acc = 0.875000\n", - "L = 36.216463, acc = 0.875000\n", - "L = 36.194770, acc = 0.875000\n", - "L = 36.172941, acc = 0.875000\n", - "L = 36.150975, acc = 0.875000\n", - "L = 36.128871, acc = 0.875000\n", - "L = 36.106629, acc = 0.875000\n", - "L = 36.084248, acc = 0.875000\n", - "L = 36.061726, acc = 0.875000\n", - "L = 36.039064, acc = 0.875000\n", - "L = 36.016260, acc = 0.875000\n", - "L = 35.993315, acc = 0.875000\n", - "L = 35.970226, acc = 0.875000\n", - "L = 35.946995, acc = 0.875000\n", - "L = 35.923619, acc = 0.875000\n", - "L = 35.900098, acc = 0.875000\n", - "L = 35.876432, acc = 0.875000\n", - "L = 35.852620, acc = 0.875000\n", - "L = 35.828661, acc = 0.875000\n", - "L = 35.804554, acc = 0.875000\n", - "L = 35.780300, acc = 0.875000\n", - "L = 35.755897, acc = 0.875000\n", - "L = 35.731345, acc = 0.875000\n", - "L = 35.706643, acc = 0.875000\n", - "L = 35.681791, acc = 0.875000\n", - "L = 35.656788, acc = 0.875000\n", - "L = 35.631634, acc = 0.875000\n", - "L = 35.606327, acc = 0.875000\n", - "L = 35.580868, acc = 0.875000\n", - "L = 35.555256, acc = 0.875000\n", - "L = 35.529491, acc = 0.875000\n", - "L = 35.503571, acc = 0.875000\n", - "L = 35.477497, acc = 0.875000\n", - "L = 35.451268, acc = 0.875000\n", - "L = 35.424883, acc = 0.875000\n", - "L = 35.398343, acc = 0.875000\n", - "L = 35.371646, acc = 0.875000\n", - "L = 35.344792, acc = 0.875000\n", - "L = 35.317781, acc = 0.875000\n", - "L = 35.290612, acc = 0.875000\n", - "L = 35.263286, acc = 0.875000\n", - "L = 35.235800, acc = 0.875000\n", - "L = 35.208157, acc = 0.875000\n", - "L = 35.180354, acc = 0.875000\n", - "L = 35.152391, acc = 0.875000\n", - "L = 35.124269, acc = 0.875000\n", - "L = 35.095986, acc = 0.875000\n", - "L = 35.067544, acc = 0.875000\n", - "L = 35.038940, acc = 0.875000\n", - "L = 35.010175, acc = 0.875000\n", - "L = 34.981249, acc = 0.875000\n", - "L = 34.952162, acc = 0.875000\n", - "L = 34.922913, acc = 0.880000\n", - "L = 34.893501, acc = 0.880000\n", - "L = 34.863928, acc = 0.880000\n", - "L = 34.834192, acc = 0.880000\n", - "L = 34.804293, acc = 0.880000\n", - "L = 34.774232, acc = 0.880000\n", - "L = 34.744008, acc = 0.880000\n", - "L = 34.713620, acc = 0.880000\n", - "L = 34.683070, acc = 0.880000\n", - "L = 34.652356, acc = 0.880000\n", - "L = 34.621478, acc = 0.880000\n", - "L = 34.590437, acc = 0.880000\n", - "L = 34.559232, acc = 0.880000\n", - "L = 34.527864, acc = 0.880000\n", - "L = 34.496331, acc = 0.880000\n", - "L = 34.464635, acc = 0.880000\n", - "L = 34.432775, acc = 0.880000\n", - "L = 34.400751, acc = 0.880000\n", - "L = 34.368563, acc = 0.880000\n", - "L = 34.336211, acc = 0.880000\n", - "L = 34.303696, acc = 0.880000\n", - "L = 34.271016, acc = 0.885000\n", - "L = 34.238173, acc = 0.885000\n", - "L = 34.205166, acc = 0.885000\n", - "L = 34.171995, acc = 0.885000\n", - "L = 34.138661, acc = 0.885000\n", - "L = 34.105164, acc = 0.885000\n", - "L = 34.071503, acc = 0.890000\n", - "L = 34.037679, acc = 0.890000\n", - "L = 34.003692, acc = 0.890000\n", - "L = 33.969541, acc = 0.890000\n", - "L = 33.935229, acc = 0.890000\n", - "L = 33.900753, acc = 0.890000\n", - "L = 33.866116, acc = 0.890000\n", - "L = 33.831316, acc = 0.890000\n", - "L = 33.796354, acc = 0.890000\n", - "L = 33.761231, acc = 0.890000\n", - "L = 33.725946, acc = 0.890000\n", - "L = 33.690500, acc = 0.890000\n", - "L = 33.654893, acc = 0.890000\n", - "L = 33.619125, acc = 0.890000\n", - "L = 33.583198, acc = 0.890000\n", - "L = 33.547110, acc = 0.890000\n", - "L = 33.510862, acc = 0.890000\n", - "L = 33.474455, acc = 0.890000\n", - "L = 33.437889, acc = 0.890000\n", - "L = 33.401165, acc = 0.890000\n", - "L = 33.364282, acc = 0.890000\n", - "L = 33.327242, acc = 0.890000\n", - "L = 33.290044, acc = 0.890000\n", - "L = 33.252689, acc = 0.890000\n", - "L = 33.215177, acc = 0.890000\n", - "L = 33.177509, acc = 0.890000\n", - "L = 33.139686, acc = 0.890000\n", - "L = 33.101707, acc = 0.890000\n", - "L = 33.063573, acc = 0.890000\n", - "L = 33.025285, acc = 0.895000\n", - "L = 32.986844, acc = 0.895000\n", - "L = 32.948248, acc = 0.895000\n", - "L = 32.909501, acc = 0.895000\n", - "L = 32.870601, acc = 0.895000\n", - "L = 32.831549, acc = 0.895000\n", - "L = 32.792346, acc = 0.895000\n", - "L = 32.752992, acc = 0.895000\n", - "L = 32.713489, acc = 0.895000\n", - "L = 32.673836, acc = 0.895000\n", - "L = 32.634034, acc = 0.895000\n", - "L = 32.594084, acc = 0.895000\n", - "L = 32.553987, acc = 0.895000\n", - "L = 32.513743, acc = 0.895000\n", - "L = 32.473352, acc = 0.895000\n", - "L = 32.432815, acc = 0.895000\n", - "L = 32.392134, acc = 0.895000\n", - "L = 32.351308, acc = 0.895000\n", - "L = 32.310339, acc = 0.895000\n", - "L = 32.269227, acc = 0.895000\n", - "L = 32.227973, acc = 0.895000\n", - "L = 32.186577, acc = 0.895000\n", - "L = 32.145040, acc = 0.895000\n", - "L = 32.103364, acc = 0.895000\n", - "L = 32.061548, acc = 0.895000\n", - "L = 32.019593, acc = 0.900000\n", - "L = 31.977501, acc = 0.900000\n", - "L = 31.935272, acc = 0.900000\n", - "L = 31.892907, acc = 0.900000\n", - "L = 31.850406, acc = 0.900000\n", - "L = 31.807771, acc = 0.900000\n", - "L = 31.765002, acc = 0.900000\n", - "L = 31.722099, acc = 0.900000\n", - "L = 31.679065, acc = 0.900000\n", - "L = 31.635900, acc = 0.900000\n", - "L = 31.592604, acc = 0.900000\n", - "L = 31.549179, acc = 0.900000\n", - "L = 31.505625, acc = 0.900000\n", - "L = 31.461943, acc = 0.900000\n", - "L = 31.418134, acc = 0.900000\n", - "L = 31.374199, acc = 0.900000\n", - "L = 31.330139, acc = 0.900000\n", - "L = 31.285955, acc = 0.900000\n", - "L = 31.241648, acc = 0.900000\n", - "L = 31.197218, acc = 0.900000\n", - "L = 31.152666, acc = 0.900000\n", - "L = 31.107995, acc = 0.900000\n", - "L = 31.063203, acc = 0.900000\n", - "L = 31.018293, acc = 0.900000\n", - "L = 30.973266, acc = 0.900000\n", - "L = 30.928122, acc = 0.900000\n", - "L = 30.882862, acc = 0.900000\n", - "L = 30.837487, acc = 0.900000\n", - "L = 30.791999, acc = 0.900000\n", - "L = 30.746398, acc = 0.900000\n", - "L = 30.700686, acc = 0.905000\n", - "L = 30.654863, acc = 0.905000\n", - "L = 30.608930, acc = 0.905000\n", - "L = 30.562889, acc = 0.905000\n", - "L = 30.516740, acc = 0.905000\n", - "L = 30.470484, acc = 0.905000\n", - "L = 30.424123, acc = 0.905000\n", - "L = 30.377658, acc = 0.905000\n", - "L = 30.331090, acc = 0.905000\n", - "L = 30.284419, acc = 0.910000\n", - "L = 30.237647, acc = 0.910000\n", - "L = 30.190775, acc = 0.910000\n", - "L = 30.143803, acc = 0.910000\n", - "L = 30.096734, acc = 0.910000\n", - "L = 30.049568, acc = 0.910000\n", - "L = 30.002307, acc = 0.910000\n", - "L = 29.954951, acc = 0.910000\n", - "L = 29.907501, acc = 0.910000\n", - "L = 29.859959, acc = 0.910000\n", - "L = 29.812326, acc = 0.910000\n", - "L = 29.764602, acc = 0.910000\n", - "L = 29.716790, acc = 0.910000\n", - "L = 29.668890, acc = 0.910000\n", - "L = 29.620903, acc = 0.910000\n", - "L = 29.572831, acc = 0.910000\n", - "L = 29.524674, acc = 0.910000\n", - "L = 29.476435, acc = 0.910000\n", - "L = 29.428113, acc = 0.910000\n", - "L = 29.379710, acc = 0.910000\n", - "L = 29.331228, acc = 0.910000\n", - "L = 29.282667, acc = 0.910000\n", - "L = 29.234030, acc = 0.910000\n", - "L = 29.185315, acc = 0.910000\n", - "L = 29.136527, acc = 0.910000\n", - "L = 29.087664, acc = 0.910000\n", - "L = 29.038729, acc = 0.910000\n", - "L = 28.989723, acc = 0.910000\n", - "L = 28.940646, acc = 0.910000\n", - "L = 28.891501, acc = 0.910000\n", - "L = 28.842289, acc = 0.910000\n", - "L = 28.793010, acc = 0.910000\n", - "L = 28.743666, acc = 0.910000\n", - "L = 28.694257, acc = 0.910000\n", - "L = 28.644787, acc = 0.910000\n", - "L = 28.595255, acc = 0.910000\n", - "L = 28.545662, acc = 0.910000\n", - "L = 28.496011, acc = 0.910000\n", - "L = 28.446303, acc = 0.910000\n", - "L = 28.396537, acc = 0.910000\n", - "L = 28.346717, acc = 0.910000\n", - "L = 28.296843, acc = 0.910000\n", - "L = 28.246916, acc = 0.910000\n", - "L = 28.196939, acc = 0.910000\n", - "L = 28.146911, acc = 0.910000\n", - "L = 28.096834, acc = 0.915000\n", - "L = 28.046710, acc = 0.915000\n", - "L = 27.996539, acc = 0.915000\n", - "L = 27.946324, acc = 0.915000\n", - "L = 27.896065, acc = 0.915000\n", - "L = 27.845764, acc = 0.915000\n", - "L = 27.795422, acc = 0.915000\n", - "L = 27.745040, acc = 0.915000\n", - "L = 27.694620, acc = 0.915000\n", - "L = 27.644163, acc = 0.915000\n", - "L = 27.593670, acc = 0.915000\n", - "L = 27.543142, acc = 0.915000\n", - "L = 27.492582, acc = 0.915000\n", - "L = 27.441989, acc = 0.915000\n", - "L = 27.391366, acc = 0.920000\n", - "L = 27.340714, acc = 0.920000\n", - "L = 27.290034, acc = 0.920000\n", - "L = 27.239328, acc = 0.920000\n", - "L = 27.188596, acc = 0.920000\n", - "L = 27.137840, acc = 0.920000\n", - "L = 27.087062, acc = 0.920000\n", - "L = 27.036263, acc = 0.920000\n", - "L = 26.985444, acc = 0.920000\n", - "L = 26.934606, acc = 0.920000\n", - "L = 26.883752, acc = 0.920000\n", - "L = 26.832881, acc = 0.920000\n", - "L = 26.781996, acc = 0.920000\n", - "L = 26.731098, acc = 0.920000\n", - "L = 26.680188, acc = 0.920000\n", - "L = 26.629267, acc = 0.920000\n", - "L = 26.578338, acc = 0.920000\n", - "L = 26.527401, acc = 0.920000\n", - "L = 26.476457, acc = 0.920000\n", - "L = 26.425509, acc = 0.920000\n", - "L = 26.374556, acc = 0.920000\n", - "L = 26.323602, acc = 0.920000\n", - "L = 26.272646, acc = 0.920000\n", - "L = 26.221691, acc = 0.920000\n", - "L = 26.170738, acc = 0.925000\n", - "L = 26.119788, acc = 0.925000\n", - "L = 26.068843, acc = 0.925000\n", - "L = 26.017903, acc = 0.925000\n", - "L = 25.966970, acc = 0.925000\n", - "L = 25.916047, acc = 0.925000\n", - "L = 25.865133, acc = 0.925000\n", - "L = 25.814230, acc = 0.925000\n", - "L = 25.763341, acc = 0.925000\n", - "L = 25.712465, acc = 0.925000\n", - "L = 25.661605, acc = 0.925000\n", - "L = 25.610761, acc = 0.925000\n", - "L = 25.559936, acc = 0.925000\n", - "L = 25.509130, acc = 0.925000\n", - "L = 25.458345, acc = 0.925000\n", - "L = 25.407582, acc = 0.925000\n", - "L = 25.356843, acc = 0.925000\n", - "L = 25.306130, acc = 0.925000\n", - "L = 25.255442, acc = 0.925000\n", - "L = 25.204782, acc = 0.925000\n", - "L = 25.154151, acc = 0.930000\n", - "L = 25.103551, acc = 0.930000\n", - "L = 25.052982, acc = 0.930000\n", - "L = 25.002447, acc = 0.930000\n", - "L = 24.951946, acc = 0.930000\n", - "L = 24.901481, acc = 0.930000\n", - "L = 24.851053, acc = 0.930000\n", - "L = 24.800663, acc = 0.930000\n", - "L = 24.750314, acc = 0.930000\n", - "L = 24.700006, acc = 0.930000\n", - "L = 24.649740, acc = 0.930000\n", - "L = 24.599519, acc = 0.930000\n", - "L = 24.549342, acc = 0.930000\n", - "L = 24.499213, acc = 0.930000\n", - "L = 24.449131, acc = 0.930000\n", - "L = 24.399098, acc = 0.930000\n", - "L = 24.349117, acc = 0.930000\n", - "L = 24.299187, acc = 0.930000\n", - "L = 24.249310, acc = 0.930000\n", - "L = 24.199488, acc = 0.930000\n", - "L = 24.149721, acc = 0.930000\n", - "L = 24.100012, acc = 0.930000\n", - "L = 24.050362, acc = 0.935000\n", - "L = 24.000771, acc = 0.935000\n", - "L = 23.951241, acc = 0.935000\n", - "L = 23.901774, acc = 0.935000\n", - "L = 23.852370, acc = 0.935000\n", - "L = 23.803032, acc = 0.935000\n", - "L = 23.753759, acc = 0.935000\n", - "L = 23.704554, acc = 0.935000\n", - "L = 23.655418, acc = 0.935000\n", - "L = 23.606352, acc = 0.935000\n", - "L = 23.557357, acc = 0.935000\n", - "L = 23.508435, acc = 0.935000\n", - "L = 23.459586, acc = 0.935000\n", - "L = 23.410812, acc = 0.935000\n", - "L = 23.362115, acc = 0.935000\n", - "L = 23.313495, acc = 0.935000\n", - "L = 23.264954, acc = 0.935000\n", - "L = 23.216493, acc = 0.935000\n", - "L = 23.168113, acc = 0.935000\n", - "L = 23.119815, acc = 0.935000\n", - "L = 23.071601, acc = 0.935000\n", - "L = 23.023472, acc = 0.935000\n", - "L = 22.975428, acc = 0.935000\n", - "L = 22.927472, acc = 0.935000\n", - "L = 22.879603, acc = 0.935000\n", - "L = 22.831824, acc = 0.935000\n", - "L = 22.784136, acc = 0.935000\n", - "L = 22.736539, acc = 0.935000\n", - "L = 22.689035, acc = 0.935000\n", - "L = 22.641625, acc = 0.935000\n", - "L = 22.594309, acc = 0.935000\n", - "L = 22.547090, acc = 0.935000\n", - "L = 22.499968, acc = 0.935000\n", - "L = 22.452945, acc = 0.935000\n", - "L = 22.406020, acc = 0.935000\n", - "L = 22.359197, acc = 0.935000\n", - "L = 22.312474, acc = 0.940000\n", - "L = 22.265854, acc = 0.940000\n", - "L = 22.219338, acc = 0.940000\n", - "L = 22.172926, acc = 0.940000\n", - "L = 22.126620, acc = 0.940000\n", - "L = 22.080420, acc = 0.940000\n", - "L = 22.034328, acc = 0.940000\n", - "L = 21.988345, acc = 0.940000\n", - "L = 21.942471, acc = 0.940000\n", - "L = 21.896707, acc = 0.940000\n", - "L = 21.851055, acc = 0.940000\n", - "L = 21.805515, acc = 0.940000\n", - "L = 21.760089, acc = 0.940000\n", - "L = 21.714777, acc = 0.940000\n", - "L = 21.669579, acc = 0.945000\n", - "L = 21.624498, acc = 0.945000\n", - "L = 21.579534, acc = 0.945000\n", - "L = 21.534687, acc = 0.945000\n", - "L = 21.489959, acc = 0.945000\n", - "L = 21.445351, acc = 0.945000\n", - "L = 21.400862, acc = 0.945000\n", - "L = 21.356495, acc = 0.945000\n", - "L = 21.312250, acc = 0.945000\n", - "L = 21.268127, acc = 0.945000\n", - "L = 21.224128, acc = 0.945000\n", - "L = 21.180252, acc = 0.945000\n", - "L = 21.136502, acc = 0.945000\n", - "L = 21.092877, acc = 0.945000\n", - "L = 21.049379, acc = 0.945000\n", - "L = 21.006008, acc = 0.945000\n", - "L = 20.962765, acc = 0.945000\n", - "L = 20.919650, acc = 0.945000\n", - "L = 20.876664, acc = 0.945000\n", - "L = 20.833808, acc = 0.945000\n", - "L = 20.791083, acc = 0.945000\n", - "L = 20.748488, acc = 0.945000\n", - "L = 20.706026, acc = 0.945000\n", - "L = 20.663695, acc = 0.945000\n", - "L = 20.621497, acc = 0.945000\n", - "L = 20.579433, acc = 0.945000\n", - "L = 20.537503, acc = 0.945000\n", - "L = 20.495707, acc = 0.945000\n", - "L = 20.454047, acc = 0.945000\n", - "L = 20.412521, acc = 0.945000\n", - "L = 20.371132, acc = 0.945000\n", - "L = 20.329880, acc = 0.945000\n", - "L = 20.288764, acc = 0.945000\n", - "L = 20.247786, acc = 0.945000\n", - "L = 20.206946, acc = 0.945000\n", - "L = 20.166245, acc = 0.945000\n", - "L = 20.125682, acc = 0.945000\n", - "L = 20.085258, acc = 0.945000\n", - "L = 20.044974, acc = 0.945000\n", - "L = 20.004830, acc = 0.945000\n", - "L = 19.964826, acc = 0.945000\n", - "L = 19.924962, acc = 0.945000\n", - "L = 19.885240, acc = 0.945000\n", - "L = 19.845659, acc = 0.945000\n", - "L = 19.806219, acc = 0.945000\n", - "L = 19.766922, acc = 0.945000\n", - "L = 19.727766, acc = 0.945000\n", - "L = 19.688753, acc = 0.945000\n", - "L = 19.649883, acc = 0.945000\n", - "L = 19.611155, acc = 0.945000\n", - "L = 19.572571, acc = 0.945000\n", - "L = 19.534130, acc = 0.945000\n", - "L = 19.495832, acc = 0.945000\n", - "L = 19.457678, acc = 0.945000\n", - "L = 19.419668, acc = 0.945000\n", - "L = 19.381802, acc = 0.945000\n", - "L = 19.344080, acc = 0.945000\n", - "L = 19.306502, acc = 0.945000\n", - "L = 19.269069, acc = 0.945000\n", - "L = 19.231780, acc = 0.945000\n", - "L = 19.194635, acc = 0.945000\n", - "L = 19.157636, acc = 0.945000\n", - "L = 19.120781, acc = 0.945000\n", - "L = 19.084070, acc = 0.945000\n", - "L = 19.047505, acc = 0.945000\n", - "L = 19.011084, acc = 0.945000\n", - "L = 18.974808, acc = 0.945000\n", - "L = 18.938677, acc = 0.945000\n", - "L = 18.902691, acc = 0.945000\n", - "L = 18.866849, acc = 0.945000\n", - "L = 18.831153, acc = 0.945000\n", - "L = 18.795600, acc = 0.945000\n", - "L = 18.760193, acc = 0.945000\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "L = 18.724930, acc = 0.945000\n", - "L = 18.689812, acc = 0.945000\n", - "L = 18.654838, acc = 0.945000\n", - "L = 18.620008, acc = 0.945000\n", - "L = 18.585322, acc = 0.945000\n", - "L = 18.550781, acc = 0.945000\n", - "L = 18.516383, acc = 0.945000\n", - "L = 18.482129, acc = 0.945000\n", - "L = 18.448019, acc = 0.945000\n", - "L = 18.414052, acc = 0.945000\n", - "L = 18.380229, acc = 0.945000\n", - "L = 18.346548, acc = 0.945000\n", - "L = 18.313010, acc = 0.945000\n", - "L = 18.279615, acc = 0.945000\n", - "L = 18.246363, acc = 0.945000\n", - "L = 18.213253, acc = 0.945000\n", - "L = 18.180284, acc = 0.945000\n", - "L = 18.147458, acc = 0.945000\n", - "L = 18.114773, acc = 0.945000\n", - "L = 18.082229, acc = 0.945000\n", - "L = 18.049826, acc = 0.945000\n", - "L = 18.017564, acc = 0.945000\n", - "L = 17.985442, acc = 0.945000\n", - "L = 17.953460, acc = 0.945000\n", - "L = 17.921619, acc = 0.945000\n", - "L = 17.889916, acc = 0.945000\n", - "L = 17.858353, acc = 0.945000\n", - "L = 17.826929, acc = 0.945000\n", - "L = 17.795643, acc = 0.945000\n", - "L = 17.764496, acc = 0.945000\n", - "L = 17.733486, acc = 0.945000\n", - "L = 17.702614, acc = 0.945000\n", - "L = 17.671879, acc = 0.945000\n", - "L = 17.641281, acc = 0.950000\n", - "L = 17.610819, acc = 0.950000\n", - "L = 17.580493, acc = 0.950000\n", - "L = 17.550303, acc = 0.950000\n", - "L = 17.520248, acc = 0.950000\n", - "L = 17.490328, acc = 0.950000\n", - "L = 17.460543, acc = 0.950000\n", - "L = 17.430891, acc = 0.950000\n", - "L = 17.401373, acc = 0.950000\n", - "L = 17.371989, acc = 0.950000\n", - "L = 17.342737, acc = 0.950000\n", - "L = 17.313617, acc = 0.955000\n", - "L = 17.284630, acc = 0.955000\n", - "L = 17.255774, acc = 0.955000\n", - "L = 17.227049, acc = 0.955000\n", - "L = 17.198455, acc = 0.955000\n", - "L = 17.169991, acc = 0.955000\n", - "L = 17.141656, acc = 0.955000\n", - "L = 17.113451, acc = 0.955000\n", - "L = 17.085375, acc = 0.955000\n", - "L = 17.057427, acc = 0.955000\n", - "L = 17.029607, acc = 0.955000\n", - "L = 17.001914, acc = 0.955000\n", - "L = 16.974348, acc = 0.955000\n", - "L = 16.946909, acc = 0.955000\n", - "L = 16.919596, acc = 0.955000\n", - "L = 16.892408, acc = 0.955000\n", - "L = 16.865345, acc = 0.955000\n", - "L = 16.838407, acc = 0.955000\n", - "L = 16.811592, acc = 0.955000\n", - "L = 16.784901, acc = 0.955000\n", - "L = 16.758334, acc = 0.955000\n", - "L = 16.731888, acc = 0.955000\n", - "L = 16.705565, acc = 0.955000\n", - "L = 16.679364, acc = 0.955000\n", - "L = 16.653283, acc = 0.955000\n", - "L = 16.627323, acc = 0.955000\n", - "L = 16.601482, acc = 0.955000\n", - "L = 16.575762, acc = 0.955000\n", - "L = 16.550160, acc = 0.955000\n", - "L = 16.524677, acc = 0.955000\n", - "L = 16.499311, acc = 0.955000\n", - "L = 16.474064, acc = 0.955000\n", - "L = 16.448933, acc = 0.955000\n", - "L = 16.423918, acc = 0.955000\n", - "L = 16.399019, acc = 0.955000\n", - "L = 16.374236, acc = 0.955000\n", - "L = 16.349567, acc = 0.955000\n", - "L = 16.325013, acc = 0.955000\n", - "L = 16.300573, acc = 0.955000\n", - "L = 16.276246, acc = 0.955000\n", - "L = 16.252031, acc = 0.955000\n", - "L = 16.227929, acc = 0.955000\n", - "L = 16.203938, acc = 0.955000\n", - "L = 16.180059, acc = 0.955000\n", - "L = 16.156290, acc = 0.955000\n", - "L = 16.132632, acc = 0.955000\n", - "L = 16.109083, acc = 0.955000\n", - "L = 16.085643, acc = 0.955000\n", - "L = 16.062311, acc = 0.955000\n", - "L = 16.039088, acc = 0.955000\n", - "L = 16.015972, acc = 0.955000\n", - "L = 15.992963, acc = 0.955000\n", - "L = 15.970061, acc = 0.955000\n", - "L = 15.947264, acc = 0.955000\n", - "L = 15.924573, acc = 0.955000\n", - "L = 15.901986, acc = 0.955000\n", - "L = 15.879504, acc = 0.955000\n", - "L = 15.857126, acc = 0.955000\n", - "L = 15.834851, acc = 0.955000\n", - "L = 15.812679, acc = 0.955000\n", - "L = 15.790610, acc = 0.955000\n", - "L = 15.768641, acc = 0.955000\n", - "L = 15.746775, acc = 0.955000\n", - "L = 15.725008, acc = 0.955000\n", - "L = 15.703343, acc = 0.955000\n", - "L = 15.681776, acc = 0.955000\n", - "L = 15.660309, acc = 0.955000\n", - "L = 15.638941, acc = 0.955000\n", - "L = 15.617670, acc = 0.955000\n", - "L = 15.596498, acc = 0.955000\n", - "L = 15.575422, acc = 0.955000\n", - "L = 15.554443, acc = 0.955000\n", - "L = 15.533561, acc = 0.955000\n", - "L = 15.512773, acc = 0.955000\n", - "L = 15.492081, acc = 0.955000\n", - "L = 15.471484, acc = 0.955000\n", - "L = 15.450980, acc = 0.955000\n", - "L = 15.430570, acc = 0.955000\n", - "L = 15.410254, acc = 0.955000\n", - "L = 15.390029, acc = 0.955000\n", - "L = 15.369897, acc = 0.955000\n", - "L = 15.349857, acc = 0.955000\n", - "L = 15.329907, acc = 0.955000\n", - "L = 15.310049, acc = 0.955000\n", - "L = 15.290280, acc = 0.955000\n", - "L = 15.270601, acc = 0.955000\n", - "L = 15.251011, acc = 0.955000\n", - "L = 15.231510, acc = 0.955000\n", - "L = 15.212097, acc = 0.955000\n", - "L = 15.192772, acc = 0.955000\n", - "L = 15.173534, acc = 0.955000\n", - "L = 15.154383, acc = 0.955000\n", - "L = 15.135318, acc = 0.960000\n", - "L = 15.116339, acc = 0.960000\n", - "L = 15.097445, acc = 0.960000\n", - "L = 15.078636, acc = 0.960000\n", - "L = 15.059911, acc = 0.960000\n", - "L = 15.041271, acc = 0.960000\n", - "L = 15.022714, acc = 0.960000\n", - "L = 15.004239, acc = 0.960000\n", - "L = 14.985848, acc = 0.960000\n", - "L = 14.967538, acc = 0.960000\n", - "L = 14.949310, acc = 0.960000\n", - "L = 14.931164, acc = 0.960000\n", - "L = 14.913098, acc = 0.960000\n", - "L = 14.895112, acc = 0.960000\n", - "L = 14.877206, acc = 0.960000\n", - "L = 14.859379, acc = 0.960000\n", - "L = 14.841632, acc = 0.960000\n", - "L = 14.823963, acc = 0.960000\n", - "L = 14.806371, acc = 0.960000\n", - "L = 14.788858, acc = 0.960000\n", - "L = 14.771422, acc = 0.960000\n", - "L = 14.754062, acc = 0.960000\n", - "L = 14.736779, acc = 0.960000\n", - "L = 14.719571, acc = 0.960000\n", - "L = 14.702439, acc = 0.960000\n", - "L = 14.685382, acc = 0.960000\n", - "L = 14.668400, acc = 0.960000\n", - "L = 14.651492, acc = 0.960000\n", - "L = 14.634658, acc = 0.960000\n", - "L = 14.617896, acc = 0.960000\n", - "L = 14.601208, acc = 0.960000\n", - "L = 14.584593, acc = 0.960000\n", - "L = 14.568049, acc = 0.960000\n", - "L = 14.551577, acc = 0.960000\n", - "L = 14.535176, acc = 0.960000\n", - "L = 14.518847, acc = 0.960000\n", - "L = 14.502587, acc = 0.960000\n", - "L = 14.486398, acc = 0.960000\n", - "L = 14.470278, acc = 0.960000\n", - "L = 14.454228, acc = 0.960000\n", - "L = 14.438247, acc = 0.960000\n", - "L = 14.422334, acc = 0.960000\n", - "L = 14.406489, acc = 0.960000\n", - "L = 14.390712, acc = 0.960000\n", - "L = 14.375002, acc = 0.960000\n", - "L = 14.359359, acc = 0.960000\n", - "L = 14.343782, acc = 0.960000\n", - "L = 14.328272, acc = 0.960000\n", - "L = 14.312827, acc = 0.960000\n", - "L = 14.297448, acc = 0.960000\n", - "L = 14.282134, acc = 0.960000\n", - "L = 14.266885, acc = 0.960000\n", - "L = 14.251700, acc = 0.960000\n", - "L = 14.236578, acc = 0.960000\n", - "L = 14.221521, acc = 0.960000\n", - "L = 14.206526, acc = 0.960000\n", - "L = 14.191595, acc = 0.960000\n", - "L = 14.176725, acc = 0.960000\n", - "L = 14.161918, acc = 0.960000\n", - "L = 14.147173, acc = 0.960000\n", - "L = 14.132489, acc = 0.960000\n", - "L = 14.117866, acc = 0.960000\n", - "L = 14.103304, acc = 0.960000\n", - "L = 14.088802, acc = 0.960000\n", - "L = 14.074360, acc = 0.960000\n", - "L = 14.059978, acc = 0.960000\n", - "L = 14.045655, acc = 0.960000\n", - "L = 14.031391, acc = 0.960000\n", - "L = 14.017185, acc = 0.960000\n", - "L = 14.003038, acc = 0.960000\n", - "L = 13.988949, acc = 0.960000\n", - "L = 13.974917, acc = 0.960000\n", - "L = 13.960943, acc = 0.960000\n", - "L = 13.947026, acc = 0.960000\n", - "L = 13.933165, acc = 0.960000\n", - "L = 13.919361, acc = 0.960000\n", - "L = 13.905613, acc = 0.960000\n", - "L = 13.891920, acc = 0.960000\n", - "L = 13.878282, acc = 0.960000\n", - "L = 13.864700, acc = 0.960000\n", - "L = 13.851172, acc = 0.960000\n", - "L = 13.837699, acc = 0.960000\n", - "L = 13.824280, acc = 0.960000\n", - "L = 13.810915, acc = 0.960000\n", - "L = 13.797603, acc = 0.960000\n", - "L = 13.784344, acc = 0.960000\n", - "L = 13.771138, acc = 0.960000\n", - "L = 13.757985, acc = 0.960000\n", - "L = 13.744884, acc = 0.960000\n", - "L = 13.731834, acc = 0.960000\n", - "L = 13.718837, acc = 0.960000\n", - "L = 13.705891, acc = 0.960000\n", - "L = 13.692996, acc = 0.960000\n", - "L = 13.680151, acc = 0.960000\n", - "L = 13.667357, acc = 0.960000\n", - "L = 13.654614, acc = 0.960000\n", - "L = 13.641920, acc = 0.960000\n", - "L = 13.629276, acc = 0.960000\n", - "L = 13.616681, acc = 0.960000\n", - "L = 13.604135, acc = 0.960000\n", - "L = 13.591638, acc = 0.960000\n", - "L = 13.579190, acc = 0.960000\n", - "L = 13.566789, acc = 0.960000\n", - "L = 13.554437, acc = 0.960000\n", - "L = 13.542132, acc = 0.960000\n", - "L = 13.529875, acc = 0.960000\n", - "L = 13.517665, acc = 0.960000\n", - "L = 13.505501, acc = 0.960000\n", - "L = 13.493385, acc = 0.960000\n", - "L = 13.481314, acc = 0.960000\n", - "L = 13.469290, acc = 0.960000\n", - "L = 13.457311, acc = 0.960000\n", - "L = 13.445378, acc = 0.960000\n", - "L = 13.433490, acc = 0.960000\n", - "L = 13.421648, acc = 0.960000\n", - "L = 13.409850, acc = 0.960000\n", - "L = 13.398096, acc = 0.960000\n", - "L = 13.386387, acc = 0.960000\n", - "L = 13.374722, acc = 0.960000\n", - "L = 13.363101, acc = 0.960000\n", - "L = 13.351523, acc = 0.960000\n", - "L = 13.339988, acc = 0.960000\n", - "L = 13.328496, acc = 0.960000\n", - "L = 13.317048, acc = 0.960000\n", - "L = 13.305641, acc = 0.960000\n", - "L = 13.294277, acc = 0.960000\n", - "L = 13.282955, acc = 0.960000\n", - "L = 13.271675, acc = 0.960000\n", - "L = 13.260437, acc = 0.960000\n", - "L = 13.249239, acc = 0.960000\n", - "L = 13.238083, acc = 0.960000\n", - "L = 13.226968, acc = 0.960000\n", - "L = 13.215894, acc = 0.960000\n", - "L = 13.204859, acc = 0.960000\n", - "L = 13.193866, acc = 0.960000\n", - "L = 13.182912, acc = 0.960000\n", - "L = 13.171997, acc = 0.960000\n", - "L = 13.161123, acc = 0.960000\n", - "L = 13.150287, acc = 0.960000\n", - "L = 13.139491, acc = 0.960000\n", - "L = 13.128734, acc = 0.960000\n", - "L = 13.118015, acc = 0.960000\n", - "L = 13.107335, acc = 0.960000\n", - "L = 13.096693, acc = 0.960000\n", - "L = 13.086088, acc = 0.960000\n", - "L = 13.075522, acc = 0.960000\n", - "L = 13.064993, acc = 0.960000\n", - "L = 13.054502, acc = 0.960000\n", - "L = 13.044048, acc = 0.960000\n", - "L = 13.033631, acc = 0.960000\n", - "L = 13.023250, acc = 0.960000\n", - "L = 13.012906, acc = 0.960000\n", - "L = 13.002599, acc = 0.960000\n", - "L = 12.992327, acc = 0.960000\n", - "L = 12.982092, acc = 0.960000\n", - "L = 12.971892, acc = 0.960000\n", - "L = 12.961728, acc = 0.960000\n", - "L = 12.951599, acc = 0.960000\n", - "L = 12.941505, acc = 0.960000\n", - "L = 12.931447, acc = 0.960000\n", - "L = 12.921423, acc = 0.960000\n", - "L = 12.911433, acc = 0.960000\n", - "L = 12.901478, acc = 0.960000\n", - "L = 12.891558, acc = 0.960000\n", - "L = 12.881671, acc = 0.965000\n", - "L = 12.871818, acc = 0.965000\n", - "L = 12.861999, acc = 0.965000\n", - "L = 12.852213, acc = 0.965000\n", - "L = 12.842460, acc = 0.965000\n", - "L = 12.832741, acc = 0.965000\n", - "L = 12.823054, acc = 0.965000\n", - "L = 12.813400, acc = 0.965000\n", - "L = 12.803779, acc = 0.965000\n", - "L = 12.794190, acc = 0.965000\n", - "L = 12.784633, acc = 0.965000\n", - "L = 12.775109, acc = 0.965000\n", - "L = 12.765616, acc = 0.965000\n", - "L = 12.756155, acc = 0.965000\n", - "L = 12.746725, acc = 0.965000\n", - "L = 12.737326, acc = 0.965000\n", - "L = 12.727959, acc = 0.965000\n", - "L = 12.718623, acc = 0.965000\n", - "L = 12.709318, acc = 0.965000\n", - "L = 12.700043, acc = 0.965000\n", - "L = 12.690799, acc = 0.965000\n", - "L = 12.681585, acc = 0.965000\n", - "L = 12.672401, acc = 0.965000\n", - "L = 12.663247, acc = 0.965000\n", - "L = 12.654123, acc = 0.965000\n", - "L = 12.645029, acc = 0.965000\n", - "L = 12.635964, acc = 0.965000\n", - "L = 12.626929, acc = 0.965000\n", - "L = 12.617922, acc = 0.965000\n", - "L = 12.608945, acc = 0.965000\n", - "L = 12.599997, acc = 0.965000\n", - "L = 12.591077, acc = 0.965000\n", - "L = 12.582187, acc = 0.965000\n", - "L = 12.573324, acc = 0.965000\n", - "L = 12.564490, acc = 0.965000\n", - "L = 12.555684, acc = 0.965000\n", - "L = 12.546905, acc = 0.965000\n", - "L = 12.538155, acc = 0.965000\n", - "L = 12.529432, acc = 0.965000\n", - "L = 12.520737, acc = 0.965000\n", - "L = 12.512070, acc = 0.965000\n", - "L = 12.503429, acc = 0.965000\n", - "L = 12.494816, acc = 0.965000\n", - "L = 12.486229, acc = 0.965000\n", - "L = 12.477670, acc = 0.965000\n", - "L = 12.469137, acc = 0.965000\n", - "L = 12.460630, acc = 0.965000\n", - "L = 12.452150, acc = 0.965000\n", - "L = 12.443697, acc = 0.965000\n", - "L = 12.435269, acc = 0.965000\n", - "L = 12.426867, acc = 0.965000\n", - "L = 12.418491, acc = 0.965000\n", - "L = 12.410141, acc = 0.965000\n", - "L = 12.401817, acc = 0.965000\n", - "L = 12.393517, acc = 0.965000\n", - "L = 12.385244, acc = 0.965000\n", - "L = 12.376995, acc = 0.965000\n", - "L = 12.368771, acc = 0.965000\n", - "L = 12.360572, acc = 0.965000\n", - "L = 12.352399, acc = 0.965000\n", - "L = 12.344249, acc = 0.965000\n", - "L = 12.336124, acc = 0.965000\n", - "L = 12.328024, acc = 0.965000\n", - "L = 12.319948, acc = 0.965000\n", - "L = 12.311896, acc = 0.965000\n", - "L = 12.303868, acc = 0.965000\n", - "L = 12.295864, acc = 0.965000\n", - "L = 12.287884, acc = 0.965000\n", - "L = 12.279927, acc = 0.965000\n", - "L = 12.271994, acc = 0.965000\n", - "L = 12.264084, acc = 0.965000\n", - "L = 12.256198, acc = 0.965000\n", - "L = 12.248335, acc = 0.965000\n", - "L = 12.240495, acc = 0.965000\n", - "L = 12.232677, acc = 0.965000\n", - "L = 12.224883, acc = 0.965000\n", - "L = 12.217111, acc = 0.965000\n", - "L = 12.209362, acc = 0.965000\n", - "L = 12.201636, acc = 0.965000\n", - "L = 12.193931, acc = 0.965000\n", - "L = 12.186249, acc = 0.965000\n", - "L = 12.178589, acc = 0.965000\n", - "L = 12.170951, acc = 0.965000\n", - "L = 12.163335, acc = 0.965000\n", - "L = 12.155741, acc = 0.965000\n", - "L = 12.148169, acc = 0.965000\n", - "L = 12.140618, acc = 0.965000\n", - "L = 12.133088, acc = 0.965000\n", - "L = 12.125580, acc = 0.965000\n", - "L = 12.118093, acc = 0.965000\n", - "L = 12.110628, acc = 0.965000\n", - "L = 12.103183, acc = 0.965000\n", - "L = 12.095759, acc = 0.965000\n", - "L = 12.088356, acc = 0.965000\n", - "L = 12.080974, acc = 0.965000\n", - "L = 12.073613, acc = 0.965000\n", - "L = 12.066272, acc = 0.965000\n", - "L = 12.058951, acc = 0.965000\n", - "L = 12.051651, acc = 0.965000\n", - "L = 12.044371, acc = 0.965000\n", - "L = 12.037111, acc = 0.965000\n", - "L = 12.029871, acc = 0.965000\n", - "L = 12.022651, acc = 0.965000\n", - "L = 12.015451, acc = 0.965000\n", - "L = 12.008270, acc = 0.965000\n", - "L = 12.001109, acc = 0.965000\n", - "L = 11.993968, acc = 0.965000\n", - "L = 11.986846, acc = 0.965000\n", - "L = 11.979744, acc = 0.965000\n", - "L = 11.972660, acc = 0.965000\n", - "L = 11.965596, acc = 0.965000\n", - "L = 11.958551, acc = 0.965000\n", - "L = 11.951525, acc = 0.965000\n", - "L = 11.944518, acc = 0.965000\n", - "L = 11.937530, acc = 0.965000\n", - "L = 11.930560, acc = 0.965000\n", - "L = 11.923609, acc = 0.965000\n", - "L = 11.916676, acc = 0.965000\n", - "L = 11.909762, acc = 0.965000\n", - "L = 11.902866, acc = 0.965000\n", - "L = 11.895989, acc = 0.965000\n", - "L = 11.889130, acc = 0.965000\n", - "L = 11.882288, acc = 0.965000\n", - "L = 11.875465, acc = 0.965000\n", - "L = 11.868659, acc = 0.965000\n", - "L = 11.861872, acc = 0.965000\n", - "L = 11.855102, acc = 0.965000\n", - "L = 11.848350, acc = 0.965000\n", - "L = 11.841615, acc = 0.965000\n", - "L = 11.834898, acc = 0.965000\n", - "L = 11.828198, acc = 0.965000\n", - "L = 11.821516, acc = 0.965000\n", - "L = 11.814851, acc = 0.965000\n", - "L = 11.808203, acc = 0.965000\n", - "L = 11.801572, acc = 0.965000\n", - "L = 11.794958, acc = 0.965000\n", - "L = 11.788361, acc = 0.965000\n", - "L = 11.781780, acc = 0.965000\n", - "L = 11.775217, acc = 0.965000\n", - "L = 11.768670, acc = 0.965000\n", - "L = 11.762140, acc = 0.965000\n", - "L = 11.755626, acc = 0.965000\n", - "L = 11.749129, acc = 0.965000\n", - "L = 11.742648, acc = 0.965000\n", - "L = 11.736184, acc = 0.965000\n", - "L = 11.729735, acc = 0.965000\n", - "L = 11.723303, acc = 0.965000\n", - "L = 11.716887, acc = 0.965000\n", - "L = 11.710487, acc = 0.965000\n", - "L = 11.704103, acc = 0.965000\n", - "L = 11.697735, acc = 0.965000\n", - "L = 11.691382, acc = 0.965000\n", - "L = 11.685045, acc = 0.965000\n", - "L = 11.678724, acc = 0.965000\n", - "L = 11.672419, acc = 0.965000\n", - "L = 11.666129, acc = 0.965000\n", - "L = 11.659854, acc = 0.965000\n", - "L = 11.653595, acc = 0.965000\n", - "L = 11.647351, acc = 0.965000\n", - "L = 11.641122, acc = 0.965000\n", - "L = 11.634908, acc = 0.965000\n", - "L = 11.628710, acc = 0.965000\n", - "L = 11.622526, acc = 0.965000\n", - "L = 11.616358, acc = 0.965000\n", - "L = 11.610204, acc = 0.965000\n", - "L = 11.604065, acc = 0.965000\n", - "L = 11.597941, acc = 0.965000\n", - "L = 11.591832, acc = 0.965000\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "L = 11.585737, acc = 0.965000\n", - "L = 11.579657, acc = 0.965000\n", - "L = 11.573591, acc = 0.965000\n", - "L = 11.567539, acc = 0.965000\n", - "L = 11.561503, acc = 0.965000\n", - "L = 11.555480, acc = 0.965000\n", - "L = 11.549472, acc = 0.965000\n", - "L = 11.543477, acc = 0.965000\n", - "L = 11.537497, acc = 0.965000\n", - "L = 11.531531, acc = 0.965000\n", - "L = 11.525579, acc = 0.965000\n", - "L = 11.519641, acc = 0.965000\n", - "L = 11.513717, acc = 0.965000\n", - "L = 11.507807, acc = 0.965000\n", - "L = 11.501910, acc = 0.965000\n", - "L = 11.496027, acc = 0.965000\n", - "L = 11.490158, acc = 0.965000\n", - "L = 11.484302, acc = 0.965000\n", - "L = 11.478460, acc = 0.965000\n", - "L = 11.472631, acc = 0.965000\n", - "L = 11.466816, acc = 0.965000\n", - "L = 11.461014, acc = 0.965000\n", - "L = 11.455226, acc = 0.965000\n", - "L = 11.449450, acc = 0.965000\n", - "L = 11.443688, acc = 0.965000\n", - "L = 11.437939, acc = 0.965000\n", - "L = 11.432203, acc = 0.965000\n", - "L = 11.426480, acc = 0.965000\n", - "L = 11.420770, acc = 0.965000\n", - "L = 11.415073, acc = 0.965000\n", - "L = 11.409389, acc = 0.965000\n", - "L = 11.403718, acc = 0.965000\n", - "L = 11.398059, acc = 0.965000\n", - "L = 11.392413, acc = 0.965000\n", - "L = 11.386780, acc = 0.965000\n", - "L = 11.381159, acc = 0.965000\n", - "L = 11.375551, acc = 0.965000\n", - "L = 11.369956, acc = 0.965000\n", - "L = 11.364372, acc = 0.965000\n", - "L = 11.358802, acc = 0.965000\n", - "L = 11.353243, acc = 0.965000\n", - "L = 11.347697, acc = 0.965000\n", - "L = 11.342163, acc = 0.965000\n", - "L = 11.336642, acc = 0.965000\n", - "L = 11.331132, acc = 0.965000\n", - "L = 11.325635, acc = 0.965000\n", - "L = 11.320149, acc = 0.965000\n", - "L = 11.314676, acc = 0.965000\n", - "L = 11.309215, acc = 0.965000\n", - "L = 11.303765, acc = 0.965000\n", - "L = 11.298328, acc = 0.965000\n", - "L = 11.292902, acc = 0.965000\n", - "L = 11.287488, acc = 0.965000\n", - "L = 11.282086, acc = 0.965000\n", - "L = 11.276695, acc = 0.965000\n", - "L = 11.271316, acc = 0.965000\n", - "L = 11.265949, acc = 0.965000\n", - "L = 11.260593, acc = 0.965000\n", - "L = 11.255249, acc = 0.965000\n", - "L = 11.249916, acc = 0.965000\n", - "L = 11.244594, acc = 0.965000\n", - "L = 11.239284, acc = 0.965000\n", - "L = 11.233985, acc = 0.965000\n", - "L = 11.228698, acc = 0.965000\n", - "L = 11.223422, acc = 0.965000\n", - "L = 11.218157, acc = 0.965000\n", - "L = 11.212903, acc = 0.965000\n", - "L = 11.207660, acc = 0.965000\n", - "L = 11.202428, acc = 0.965000\n", - "L = 11.197208, acc = 0.965000\n", - "L = 11.191998, acc = 0.965000\n", - "L = 11.186799, acc = 0.965000\n", - "L = 11.181612, acc = 0.965000\n", - "L = 11.176435, acc = 0.965000\n", - "L = 11.171268, acc = 0.965000\n", - "L = 11.166113, acc = 0.965000\n", - "L = 11.160969, acc = 0.965000\n", - "L = 11.155835, acc = 0.965000\n", - "L = 11.150711, acc = 0.965000\n", - "L = 11.145599, acc = 0.965000\n", - "L = 11.140497, acc = 0.965000\n", - "L = 11.135405, acc = 0.965000\n", - "L = 11.130325, acc = 0.965000\n", - "L = 11.125254, acc = 0.965000\n", - "L = 11.120194, acc = 0.965000\n", - "L = 11.115144, acc = 0.965000\n", - "L = 11.110105, acc = 0.965000\n", - "L = 11.105076, acc = 0.965000\n", - "L = 11.100058, acc = 0.965000\n", - "L = 11.095049, acc = 0.965000\n", - "L = 11.090051, acc = 0.965000\n", - "L = 11.085063, acc = 0.965000\n", - "L = 11.080085, acc = 0.965000\n", - "L = 11.075118, acc = 0.965000\n", - "L = 11.070160, acc = 0.965000\n", - "L = 11.065212, acc = 0.965000\n", - "L = 11.060275, acc = 0.965000\n", - "L = 11.055347, acc = 0.965000\n", - "L = 11.050430, acc = 0.965000\n", - "L = 11.045522, acc = 0.965000\n", - "L = 11.040624, acc = 0.965000\n", - "L = 11.035736, acc = 0.965000\n", - "L = 11.030857, acc = 0.970000\n", - "L = 11.025989, acc = 0.970000\n", - "L = 11.021130, acc = 0.970000\n", - "L = 11.016281, acc = 0.970000\n", - "L = 11.011442, acc = 0.970000\n", - "L = 11.006612, acc = 0.970000\n", - "L = 11.001792, acc = 0.970000\n", - "L = 10.996981, acc = 0.970000\n", - "L = 10.992180, acc = 0.970000\n", - "L = 10.987388, acc = 0.970000\n", - "L = 10.982606, acc = 0.970000\n", - "L = 10.977834, acc = 0.970000\n", - "L = 10.973070, acc = 0.970000\n", - "L = 10.968317, acc = 0.970000\n", - "L = 10.963572, acc = 0.970000\n", - "L = 10.958837, acc = 0.970000\n", - "L = 10.954111, acc = 0.970000\n", - "L = 10.949394, acc = 0.970000\n", - "L = 10.944687, acc = 0.970000\n", - "L = 10.939989, acc = 0.970000\n", - "L = 10.935300, acc = 0.970000\n", - "L = 10.930620, acc = 0.970000\n", - "L = 10.925949, acc = 0.970000\n", - "L = 10.921288, acc = 0.970000\n", - "L = 10.916635, acc = 0.970000\n", - "L = 10.911991, acc = 0.970000\n", - "L = 10.907357, acc = 0.970000\n", - "L = 10.902731, acc = 0.970000\n", - "L = 10.898114, acc = 0.970000\n", - "L = 10.893507, acc = 0.970000\n", - "L = 10.888908, acc = 0.970000\n", - "L = 10.884318, acc = 0.970000\n", - "L = 10.879737, acc = 0.970000\n", - "L = 10.875164, acc = 0.970000\n", - "L = 10.870601, acc = 0.970000\n", - "L = 10.866046, acc = 0.970000\n", - "L = 10.861500, acc = 0.970000\n", - "L = 10.856962, acc = 0.970000\n", - "L = 10.852433, acc = 0.970000\n", - "L = 10.847913, acc = 0.970000\n", - "L = 10.843402, acc = 0.970000\n", - "L = 10.838899, acc = 0.970000\n", - "L = 10.834404, acc = 0.970000\n", - "L = 10.829918, acc = 0.970000\n", - "L = 10.825441, acc = 0.970000\n", - "L = 10.820972, acc = 0.970000\n", - "L = 10.816512, acc = 0.970000\n", - "L = 10.812060, acc = 0.970000\n", - "L = 10.807616, acc = 0.970000\n", - "L = 10.803181, acc = 0.970000\n", - "L = 10.798755, acc = 0.970000\n", - "L = 10.794336, acc = 0.970000\n", - "L = 10.789926, acc = 0.970000\n", - "L = 10.785524, acc = 0.970000\n", - "L = 10.781131, acc = 0.970000\n", - "L = 10.776745, acc = 0.970000\n", - "L = 10.772368, acc = 0.970000\n", - "L = 10.767999, acc = 0.970000\n", - "L = 10.763638, acc = 0.970000\n", - "L = 10.759286, acc = 0.970000\n", - "L = 10.754941, acc = 0.970000\n", - "L = 10.750605, acc = 0.970000\n", - "L = 10.746277, acc = 0.970000\n", - "L = 10.741956, acc = 0.970000\n", - "L = 10.737644, acc = 0.970000\n", - "L = 10.733340, acc = 0.970000\n", - "L = 10.729044, acc = 0.970000\n", - "L = 10.724755, acc = 0.970000\n", - "L = 10.720475, acc = 0.970000\n", - "L = 10.716203, acc = 0.970000\n", - "L = 10.711938, acc = 0.970000\n", - "L = 10.707682, acc = 0.970000\n", - "L = 10.703433, acc = 0.970000\n", - "L = 10.699192, acc = 0.970000\n", - "L = 10.694959, acc = 0.970000\n", - "L = 10.690733, acc = 0.970000\n", - "L = 10.686516, acc = 0.970000\n", - "L = 10.682306, acc = 0.970000\n", - "L = 10.678104, acc = 0.970000\n", - "L = 10.673910, acc = 0.970000\n", - "L = 10.669723, acc = 0.970000\n", - "L = 10.665544, acc = 0.970000\n", - "L = 10.661372, acc = 0.970000\n", - "L = 10.657209, acc = 0.970000\n", - "L = 10.653053, acc = 0.970000\n", - "L = 10.648904, acc = 0.970000\n", - "L = 10.644763, acc = 0.970000\n", - "L = 10.640629, acc = 0.970000\n", - "L = 10.636503, acc = 0.970000\n", - "L = 10.632385, acc = 0.970000\n", - "L = 10.628274, acc = 0.970000\n", - "L = 10.624171, acc = 0.970000\n", - "L = 10.620074, acc = 0.970000\n", - "L = 10.615986, acc = 0.970000\n", - "L = 10.611905, acc = 0.970000\n", - "L = 10.607831, acc = 0.970000\n", - "L = 10.603764, acc = 0.970000\n", - "L = 10.599705, acc = 0.970000\n", - "L = 10.595653, acc = 0.970000\n", - "L = 10.591609, acc = 0.970000\n", - "L = 10.587572, acc = 0.970000\n", - "L = 10.583542, acc = 0.970000\n", - "L = 10.579519, acc = 0.970000\n", - "L = 10.575503, acc = 0.970000\n", - "L = 10.571495, acc = 0.970000\n", - "L = 10.567494, acc = 0.970000\n", - "L = 10.563500, acc = 0.970000\n", - "L = 10.559514, acc = 0.970000\n", - "L = 10.555534, acc = 0.970000\n", - "L = 10.551562, acc = 0.970000\n", - "L = 10.547596, acc = 0.970000\n", - "L = 10.543638, acc = 0.970000\n", - "L = 10.539687, acc = 0.970000\n", - "L = 10.535743, acc = 0.970000\n", - "L = 10.531806, acc = 0.970000\n", - "L = 10.527876, acc = 0.970000\n", - "L = 10.523953, acc = 0.970000\n", - "L = 10.520037, acc = 0.970000\n", - "L = 10.516128, acc = 0.970000\n", - "L = 10.512226, acc = 0.970000\n", - "L = 10.508330, acc = 0.970000\n", - "L = 10.504442, acc = 0.970000\n", - "L = 10.500561, acc = 0.970000\n", - "L = 10.496686, acc = 0.970000\n", - "L = 10.492819, acc = 0.970000\n", - "L = 10.488958, acc = 0.970000\n", - "L = 10.485104, acc = 0.970000\n", - "L = 10.481257, acc = 0.970000\n", - "L = 10.477417, acc = 0.970000\n", - "L = 10.473583, acc = 0.970000\n", - "L = 10.469756, acc = 0.965000\n", - "L = 10.465936, acc = 0.965000\n", - "L = 10.462123, acc = 0.965000\n", - "L = 10.458317, acc = 0.965000\n", - "L = 10.454517, acc = 0.965000\n", - "L = 10.450724, acc = 0.965000\n", - "L = 10.446937, acc = 0.965000\n", - "L = 10.443157, acc = 0.965000\n", - "L = 10.439384, acc = 0.965000\n", - "L = 10.435618, acc = 0.965000\n", - "L = 10.431858, acc = 0.965000\n", - "L = 10.428105, acc = 0.965000\n", - "L = 10.424358, acc = 0.965000\n", - "L = 10.420618, acc = 0.965000\n", - "L = 10.416884, acc = 0.965000\n", - "L = 10.413157, acc = 0.965000\n", - "L = 10.409436, acc = 0.965000\n", - "L = 10.405722, acc = 0.965000\n", - "L = 10.402015, acc = 0.965000\n", - "L = 10.398314, acc = 0.965000\n", - "L = 10.394619, acc = 0.965000\n", - "L = 10.390931, acc = 0.965000\n", - "L = 10.387249, acc = 0.965000\n", - "L = 10.383574, acc = 0.965000\n", - "L = 10.379905, acc = 0.965000\n", - "L = 10.376242, acc = 0.965000\n", - "L = 10.372586, acc = 0.965000\n", - "L = 10.368936, acc = 0.965000\n", - "L = 10.365293, acc = 0.965000\n", - "L = 10.361656, acc = 0.965000\n", - "L = 10.358025, acc = 0.965000\n", - "L = 10.354400, acc = 0.965000\n", - "L = 10.350782, acc = 0.965000\n", - "L = 10.347170, acc = 0.965000\n", - "L = 10.343564, acc = 0.965000\n", - "L = 10.339965, acc = 0.965000\n", - "L = 10.336372, acc = 0.965000\n", - "L = 10.332785, acc = 0.965000\n", - "L = 10.329204, acc = 0.965000\n", - "L = 10.325629, acc = 0.965000\n", - "L = 10.322061, acc = 0.965000\n", - "L = 10.318499, acc = 0.965000\n", - "L = 10.314942, acc = 0.965000\n", - "L = 10.311392, acc = 0.965000\n", - "L = 10.307849, acc = 0.965000\n", - "L = 10.304311, acc = 0.965000\n", - "L = 10.300779, acc = 0.965000\n", - "L = 10.297253, acc = 0.965000\n", - "L = 10.293734, acc = 0.965000\n", - "L = 10.290220, acc = 0.965000\n", - "L = 10.286713, acc = 0.965000\n", - "L = 10.283212, acc = 0.965000\n", - "L = 10.279716, acc = 0.965000\n", - "L = 10.276227, acc = 0.965000\n", - "L = 10.272743, acc = 0.965000\n", - "L = 10.269266, acc = 0.965000\n", - "L = 10.265795, acc = 0.965000\n", - "L = 10.262329, acc = 0.965000\n", - "L = 10.258869, acc = 0.965000\n", - "L = 10.255416, acc = 0.965000\n", - "L = 10.251968, acc = 0.965000\n", - "L = 10.248526, acc = 0.965000\n", - "L = 10.245090, acc = 0.965000\n", - "L = 10.241660, acc = 0.965000\n", - "L = 10.238236, acc = 0.965000\n", - "L = 10.234817, acc = 0.965000\n", - "L = 10.231405, acc = 0.965000\n", - "L = 10.227998, acc = 0.965000\n", - "L = 10.224597, acc = 0.965000\n", - "L = 10.221202, acc = 0.965000\n", - "L = 10.217813, acc = 0.965000\n", - "L = 10.214429, acc = 0.965000\n", - "L = 10.211051, acc = 0.965000\n", - "L = 10.207679, acc = 0.965000\n", - "L = 10.204313, acc = 0.965000\n", - "L = 10.200952, acc = 0.965000\n", - "L = 10.197597, acc = 0.965000\n", - "L = 10.194248, acc = 0.965000\n", - "L = 10.190905, acc = 0.965000\n", - "L = 10.187567, acc = 0.965000\n", - "L = 10.184235, acc = 0.965000\n", - "L = 10.180908, acc = 0.965000\n", - "L = 10.177587, acc = 0.965000\n", - "L = 10.174272, acc = 0.965000\n", - "L = 10.170962, acc = 0.965000\n", - "L = 10.167658, acc = 0.965000\n", - "L = 10.164360, acc = 0.965000\n", - "L = 10.161067, acc = 0.965000\n", - "L = 10.157780, acc = 0.965000\n", - "L = 10.154498, acc = 0.965000\n", - "L = 10.151222, acc = 0.965000\n", - "L = 10.147951, acc = 0.965000\n", - "L = 10.144686, acc = 0.965000\n", - "L = 10.141426, acc = 0.965000\n", - "L = 10.138172, acc = 0.965000\n", - "L = 10.134923, acc = 0.965000\n", - "L = 10.131680, acc = 0.965000\n", - "L = 10.128442, acc = 0.965000\n", - "L = 10.125210, acc = 0.965000\n", - "L = 10.121983, acc = 0.965000\n", - "L = 10.118762, acc = 0.965000\n", - "L = 10.115546, acc = 0.965000\n", - "L = 10.112335, acc = 0.965000\n", - "L = 10.109130, acc = 0.965000\n", - "L = 10.105930, acc = 0.965000\n", - "L = 10.102736, acc = 0.965000\n", - "L = 10.099547, acc = 0.965000\n", - "L = 10.096363, acc = 0.965000\n", - "L = 10.093185, acc = 0.965000\n", - "L = 10.090011, acc = 0.965000\n", - "L = 10.086844, acc = 0.965000\n", - "L = 10.083681, acc = 0.965000\n", - "L = 10.080524, acc = 0.965000\n", - "L = 10.077372, acc = 0.965000\n", - "L = 10.074226, acc = 0.965000\n", - "L = 10.071084, acc = 0.965000\n", - "L = 10.067948, acc = 0.965000\n", - "L = 10.064817, acc = 0.965000\n", - "L = 10.061692, acc = 0.965000\n", - "L = 10.058571, acc = 0.965000\n", - "L = 10.055456, acc = 0.965000\n", - "L = 10.052346, acc = 0.965000\n", - "L = 10.049241, acc = 0.965000\n", - "L = 10.046141, acc = 0.965000\n", - "L = 10.043047, acc = 0.965000\n", - "L = 10.039958, acc = 0.965000\n", - "L = 10.036873, acc = 0.965000\n", - "L = 10.033794, acc = 0.965000\n", - "L = 10.030720, acc = 0.965000\n", - "L = 10.027651, acc = 0.965000\n", - "L = 10.024588, acc = 0.965000\n", - "L = 10.021529, acc = 0.965000\n", - "L = 10.018475, acc = 0.965000\n", - "L = 10.015427, acc = 0.965000\n", - "L = 10.012384, acc = 0.965000\n", - "L = 10.009345, acc = 0.965000\n", - "L = 10.006312, acc = 0.965000\n", - "L = 10.003283, acc = 0.965000\n", - "L = 10.000260, acc = 0.965000\n", - "L = 9.997242, acc = 0.965000\n", - "L = 9.994228, acc = 0.965000\n", - "L = 9.991220, acc = 0.965000\n", - "L = 9.988217, acc = 0.965000\n", - "L = 9.985218, acc = 0.965000\n", - "L = 9.982225, acc = 0.965000\n", - "L = 9.979236, acc = 0.965000\n", - "L = 9.976253, acc = 0.965000\n", - "L = 9.973274, acc = 0.965000\n", - "L = 9.970300, acc = 0.965000\n", - "L = 9.967331, acc = 0.965000\n", - "L = 9.964367, acc = 0.965000\n", - "L = 9.961408, acc = 0.965000\n", - "L = 9.958454, acc = 0.965000\n", - "L = 9.955505, acc = 0.965000\n", - "L = 9.952560, acc = 0.965000\n", - "L = 9.949621, acc = 0.965000\n", - "L = 9.946686, acc = 0.965000\n", - "L = 9.943756, acc = 0.965000\n", - "L = 9.940831, acc = 0.965000\n", - "L = 9.937910, acc = 0.965000\n", - "L = 9.934995, acc = 0.965000\n", - "L = 9.932084, acc = 0.965000\n", - "L = 9.929178, acc = 0.965000\n", - "L = 9.926276, acc = 0.965000\n", - "L = 9.923380, acc = 0.970000\n", - "L = 9.920488, acc = 0.970000\n", - "L = 9.917601, acc = 0.970000\n", - "L = 9.914719, acc = 0.970000\n", - "L = 9.911841, acc = 0.970000\n", - "L = 9.908968, acc = 0.970000\n", - "L = 9.906100, acc = 0.970000\n", - "L = 9.903236, acc = 0.970000\n", - "L = 9.900378, acc = 0.970000\n", - "L = 9.897523, acc = 0.970000\n", - "L = 9.894674, acc = 0.970000\n", - "L = 9.891829, acc = 0.970000\n", - "L = 9.888989, acc = 0.970000\n", - "L = 9.886153, acc = 0.970000\n", - "L = 9.883322, acc = 0.970000\n", - "L = 9.880496, acc = 0.970000\n", - "L = 9.877674, acc = 0.970000\n", - "L = 9.874857, acc = 0.970000\n", - "L = 9.872044, acc = 0.970000\n", - "L = 9.869236, acc = 0.970000\n", - "L = 9.866432, acc = 0.970000\n", - "L = 9.863633, acc = 0.970000\n", - "L = 9.860839, acc = 0.970000\n", - "L = 9.858049, acc = 0.970000\n", - "L = 9.855264, acc = 0.970000\n", - "L = 9.852483, acc = 0.970000\n", - "L = 9.849706, acc = 0.970000\n", - "L = 9.846935, acc = 0.970000\n", - "L = 9.844167, acc = 0.970000\n", - "L = 9.841404, acc = 0.970000\n", - "L = 9.838646, acc = 0.970000\n", - "L = 9.835892, acc = 0.970000\n", - "L = 9.833142, acc = 0.970000\n", - "L = 9.830397, acc = 0.970000\n", - "L = 9.827657, acc = 0.970000\n", - "L = 9.824920, acc = 0.970000\n", - "L = 9.822188, acc = 0.970000\n", - "L = 9.819461, acc = 0.970000\n", - "L = 9.816738, acc = 0.970000\n", - "L = 9.814019, acc = 0.970000\n", - "L = 9.811305, acc = 0.970000\n", - "L = 9.808595, acc = 0.970000\n", - "L = 9.805890, acc = 0.970000\n", - "L = 9.803188, acc = 0.970000\n", - "L = 9.800491, acc = 0.970000\n", - "L = 9.797799, acc = 0.970000\n", - "L = 9.795111, acc = 0.970000\n", - "L = 9.792427, acc = 0.970000\n", - "L = 9.789747, acc = 0.970000\n", - "L = 9.787072, acc = 0.970000\n", - "L = 9.784401, acc = 0.970000\n", - "L = 9.781734, acc = 0.970000\n", - "L = 9.779072, acc = 0.970000\n", - "L = 9.776413, acc = 0.970000\n", - "L = 9.773759, acc = 0.970000\n", - "L = 9.771110, acc = 0.970000\n", - "L = 9.768464, acc = 0.970000\n", - "L = 9.765823, acc = 0.970000\n", - "L = 9.763186, acc = 0.970000\n", - "L = 9.760553, acc = 0.970000\n", - "L = 9.757924, acc = 0.970000\n", - "L = 9.755300, acc = 0.970000\n", - "L = 9.752679, acc = 0.970000\n", - "L = 9.750063, acc = 0.970000\n", - "L = 9.747451, acc = 0.970000\n", - "L = 9.744843, acc = 0.970000\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "L = 9.742240, acc = 0.970000\n", - "L = 9.739640, acc = 0.970000\n", - "L = 9.737045, acc = 0.970000\n", - "L = 9.734453, acc = 0.970000\n", - "L = 9.731866, acc = 0.970000\n", - "L = 9.729283, acc = 0.970000\n", - "L = 9.726704, acc = 0.970000\n", - "L = 9.724129, acc = 0.970000\n", - "L = 9.721558, acc = 0.970000\n", - "L = 9.718992, acc = 0.970000\n", - "L = 9.716429, acc = 0.970000\n", - "L = 9.713870, acc = 0.970000\n", - "L = 9.711316, acc = 0.970000\n", - "L = 9.708765, acc = 0.970000\n", - "L = 9.706218, acc = 0.970000\n", - "L = 9.703676, acc = 0.970000\n", - "L = 9.701137, acc = 0.970000\n", - "L = 9.698603, acc = 0.970000\n", - "L = 9.696072, acc = 0.970000\n", - "L = 9.693546, acc = 0.970000\n", - "L = 9.691023, acc = 0.970000\n", - "L = 9.688504, acc = 0.970000\n", - "L = 9.685990, acc = 0.970000\n", - "L = 9.683479, acc = 0.970000\n", - "L = 9.680972, acc = 0.970000\n", - "L = 9.678469, acc = 0.970000\n", - "L = 9.675970, acc = 0.970000\n", - "L = 9.673475, acc = 0.970000\n", - "L = 9.670984, acc = 0.970000\n", - "L = 9.668497, acc = 0.970000\n", - "L = 9.666014, acc = 0.970000\n", - "L = 9.663534, acc = 0.970000\n", - "L = 9.661059, acc = 0.970000\n", - "L = 9.658587, acc = 0.970000\n", - "L = 9.656119, acc = 0.970000\n", - "L = 9.653655, acc = 0.970000\n", - "L = 9.651195, acc = 0.970000\n", - "L = 9.648739, acc = 0.970000\n", - "L = 9.646286, acc = 0.970000\n", - "L = 9.643838, acc = 0.970000\n", - "L = 9.641393, acc = 0.970000\n", - "L = 9.638952, acc = 0.970000\n", - "L = 9.636515, acc = 0.970000\n", - "L = 9.634081, acc = 0.970000\n", - "L = 9.631651, acc = 0.970000\n", - "L = 9.629226, acc = 0.970000\n", - "L = 9.626803, acc = 0.970000\n", - "L = 9.624385, acc = 0.970000\n", - "L = 9.621970, acc = 0.970000\n", - "L = 9.619560, acc = 0.970000\n", - "L = 9.617152, acc = 0.970000\n", - "L = 9.614749, acc = 0.970000\n", - "L = 9.612349, acc = 0.970000\n", - "L = 9.609953, acc = 0.970000\n", - "L = 9.607561, acc = 0.970000\n", - "L = 9.605172, acc = 0.970000\n", - "L = 9.602787, acc = 0.970000\n", - "L = 9.600406, acc = 0.970000\n", - "L = 9.598028, acc = 0.970000\n", - "L = 9.595654, acc = 0.970000\n", - "L = 9.593284, acc = 0.970000\n", - "L = 9.590918, acc = 0.970000\n", - "L = 9.588555, acc = 0.970000\n", - "L = 9.586195, acc = 0.970000\n", - "L = 9.583839, acc = 0.970000\n", - "L = 9.581487, acc = 0.970000\n", - "L = 9.579139, acc = 0.970000\n", - "L = 9.576794, acc = 0.970000\n", - "L = 9.574453, acc = 0.970000\n", - "L = 9.572115, acc = 0.970000\n", - "L = 9.569781, acc = 0.970000\n", - "L = 9.567450, acc = 0.970000\n", - "L = 9.565123, acc = 0.970000\n", - "L = 9.562800, acc = 0.970000\n", - "L = 9.560480, acc = 0.970000\n", - "L = 9.558163, acc = 0.970000\n", - "L = 9.555850, acc = 0.970000\n", - "L = 9.553541, acc = 0.970000\n", - "L = 9.551235, acc = 0.970000\n", - "L = 9.548933, acc = 0.970000\n", - "L = 9.546634, acc = 0.970000\n", - "L = 9.544339, acc = 0.970000\n", - "L = 9.542047, acc = 0.970000\n", - "L = 9.539759, acc = 0.970000\n", - "L = 9.537474, acc = 0.970000\n", - "L = 9.535192, acc = 0.970000\n", - "L = 9.532914, acc = 0.970000\n", - "L = 9.530640, acc = 0.970000\n", - "L = 9.528369, acc = 0.970000\n", - "L = 9.526101, acc = 0.970000\n", - "L = 9.523837, acc = 0.970000\n", - "L = 9.521576, acc = 0.970000\n", - "L = 9.519319, acc = 0.970000\n", - "L = 9.517065, acc = 0.970000\n", - "L = 9.514815, acc = 0.970000\n", - "L = 9.512567, acc = 0.970000\n", - "L = 9.510324, acc = 0.970000\n", - "L = 9.508083, acc = 0.970000\n", - "L = 9.505846, acc = 0.970000\n", - "L = 9.503613, acc = 0.970000\n", - "L = 9.501382, acc = 0.970000\n", - "L = 9.499156, acc = 0.970000\n", - "L = 9.496932, acc = 0.970000\n", - "L = 9.494712, acc = 0.970000\n", - "L = 9.492495, acc = 0.970000\n", - "L = 9.490281, acc = 0.970000\n", - "L = 9.488071, acc = 0.970000\n", - "L = 9.485864, acc = 0.970000\n", - "L = 9.483660, acc = 0.970000\n", - "L = 9.481460, acc = 0.970000\n", - "L = 9.479263, acc = 0.970000\n", - "L = 9.477069, acc = 0.970000\n", - "L = 9.474878, acc = 0.970000\n", - "L = 9.472691, acc = 0.970000\n", - "L = 9.470507, acc = 0.970000\n", - "L = 9.468326, acc = 0.970000\n", - "L = 9.466149, acc = 0.970000\n", - "L = 9.463975, acc = 0.970000\n", - "L = 9.461804, acc = 0.970000\n", - "L = 9.459636, acc = 0.970000\n", - "L = 9.457471, acc = 0.970000\n", - "L = 9.455310, acc = 0.970000\n", - "L = 9.453152, acc = 0.970000\n", - "L = 9.450997, acc = 0.970000\n", - "L = 9.448845, acc = 0.970000\n", - "L = 9.446696, acc = 0.970000\n", - "L = 9.444551, acc = 0.970000\n", - "L = 9.442409, acc = 0.970000\n", - "L = 9.440269, acc = 0.970000\n", - "L = 9.438133, acc = 0.970000\n", - "L = 9.436001, acc = 0.970000\n", - "L = 9.433871, acc = 0.970000\n", - "L = 9.431745, acc = 0.970000\n", - "L = 9.429621, acc = 0.975000\n", - "L = 9.427501, acc = 0.975000\n", - "L = 9.425384, acc = 0.975000\n", - "L = 9.423270, acc = 0.975000\n", - "L = 9.421159, acc = 0.975000\n", - "L = 9.419051, acc = 0.975000\n", - "L = 9.416946, acc = 0.975000\n", - "L = 9.414845, acc = 0.975000\n", - "L = 9.412746, acc = 0.975000\n", - "L = 9.410651, acc = 0.975000\n", - "L = 9.408558, acc = 0.975000\n", - "L = 9.406469, acc = 0.975000\n", - "L = 9.404383, acc = 0.975000\n", - "L = 9.402299, acc = 0.975000\n", - "L = 9.400219, acc = 0.975000\n", - "L = 9.398142, acc = 0.975000\n", - "L = 9.396068, acc = 0.975000\n", - "L = 9.393997, acc = 0.975000\n", - "L = 9.391928, acc = 0.975000\n", - "L = 9.389863, acc = 0.975000\n", - "L = 9.387801, acc = 0.975000\n", - "L = 9.385742, acc = 0.975000\n", - "L = 9.383686, acc = 0.975000\n", - "L = 9.381633, acc = 0.975000\n", - "L = 9.379583, acc = 0.975000\n", - "L = 9.377535, acc = 0.975000\n", - "L = 9.375491, acc = 0.975000\n", - "L = 9.373450, acc = 0.975000\n", - "L = 9.371411, acc = 0.975000\n", - "L = 9.369376, acc = 0.975000\n", - "L = 9.367344, acc = 0.975000\n", - "L = 9.365314, acc = 0.975000\n", - "L = 9.363287, acc = 0.975000\n", - "L = 9.361264, acc = 0.975000\n", - "L = 9.359243, acc = 0.975000\n", - "L = 9.357225, acc = 0.975000\n", - "L = 9.355210, acc = 0.975000\n", - "L = 9.353198, acc = 0.975000\n", - "L = 9.351189, acc = 0.975000\n", - "L = 9.349183, acc = 0.975000\n", - "L = 9.347179, acc = 0.975000\n", - "L = 9.345179, acc = 0.975000\n", - "L = 9.343181, acc = 0.975000\n", - "L = 9.341186, acc = 0.975000\n", - "L = 9.339194, acc = 0.975000\n", - "L = 9.337205, acc = 0.975000\n", - "L = 9.335219, acc = 0.975000\n", - "L = 9.333235, acc = 0.975000\n", - "L = 9.331255, acc = 0.975000\n", - "L = 9.329277, acc = 0.975000\n", - "L = 9.327302, acc = 0.975000\n", - "L = 9.325330, acc = 0.975000\n", - "L = 9.323361, acc = 0.975000\n", - "L = 9.321394, acc = 0.975000\n", - "L = 9.319430, acc = 0.975000\n", - "L = 9.317469, acc = 0.975000\n", - "L = 9.315511, acc = 0.975000\n", - "L = 9.313556, acc = 0.975000\n", - "L = 9.311603, acc = 0.975000\n", - "L = 9.309653, acc = 0.975000\n", - "L = 9.307706, acc = 0.975000\n", - "L = 9.305762, acc = 0.975000\n", - "L = 9.303820, acc = 0.975000\n", - "L = 9.301881, acc = 0.975000\n", - "L = 9.299945, acc = 0.975000\n", - "L = 9.298012, acc = 0.975000\n", - "L = 9.296081, acc = 0.975000\n", - "L = 9.294153, acc = 0.975000\n", - "L = 9.292228, acc = 0.975000\n", - "L = 9.290305, acc = 0.975000\n", - "L = 9.288385, acc = 0.975000\n", - "L = 9.286468, acc = 0.975000\n", - "L = 9.284554, acc = 0.975000\n", - "L = 9.282642, acc = 0.975000\n", - "L = 9.280733, acc = 0.975000\n", - "L = 9.278826, acc = 0.975000\n", - "L = 9.276923, acc = 0.975000\n", - "L = 9.275021, acc = 0.975000\n", - "L = 9.273123, acc = 0.975000\n", - "L = 9.271227, acc = 0.975000\n", - "L = 9.269334, acc = 0.975000\n", - "L = 9.267444, acc = 0.975000\n", - "L = 9.265556, acc = 0.975000\n", - "L = 9.263670, acc = 0.975000\n", - "L = 9.261788, acc = 0.975000\n", - "L = 9.259908, acc = 0.975000\n", - "L = 9.258030, acc = 0.975000\n", - "L = 9.256156, acc = 0.975000\n", - "L = 9.254283, acc = 0.975000\n", - "L = 9.252414, acc = 0.975000\n", - "L = 9.250547, acc = 0.975000\n", - "L = 9.248682, acc = 0.975000\n", - "L = 9.246821, acc = 0.975000\n", - "L = 9.244961, acc = 0.975000\n", - "L = 9.243105, acc = 0.975000\n", - "L = 9.241251, acc = 0.975000\n", - "L = 9.239399, acc = 0.975000\n", - "L = 9.237550, acc = 0.975000\n" + "L = 104.605395, acc = 0.500000\n", + "L = 49.016934, acc = 0.835000\n", + "L = 39.837293, acc = 0.855000\n", + "L = 38.941325, acc = 0.850000\n", + "L = 38.529515, acc = 0.845000\n", + "L = 37.909320, acc = 0.860000\n", + "L = 36.647360, acc = 0.865000\n", + "L = 33.967945, acc = 0.885000\n", + "L = 29.328960, acc = 0.910000\n", + "L = 23.732502, acc = 0.935000\n", + "L = 18.992955, acc = 0.945000\n", + "L = 15.867548, acc = 0.955000\n", + "L = 13.954345, acc = 0.960000\n", + "L = 12.723923, acc = 0.965000\n", + "L = 11.862862, acc = 0.965000\n", + "L = 11.206181, acc = 0.970000\n", + "L = 10.665492, acc = 0.970000\n", + "L = 10.200185, acc = 0.970000\n", + "L = 9.800324, acc = 0.965000\n", + "L = 9.462811, acc = 0.970000\n" ] } ], @@ -4890,12 +905,12 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -4907,7 +922,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -4942,22 +957,22 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[[0.00685236 0.9927955 ]\n", - " [0.1246441 0.8746923 ]\n", - " [0.98246862 0.01635913]\n", - " [0.00689292 0.99277992]\n", - " [0.0035196 0.99630283]\n", - " [0.95959029 0.04206601]\n", - " [0.01404427 0.98588945]\n", - " [0.97727229 0.02378811]\n", - " [0.03279357 0.96616133]]\n" + "[[0.01103025 0.98838025]\n", + " [0.13185941 0.86852082]\n", + " [0.98375489 0.01562161]\n", + " [0.01149807 0.98788055]\n", + " [0.00798938 0.99154954]\n", + " [0.95984579 0.0412429 ]\n", + " [0.02283659 0.97733521]\n", + " [0.97419109 0.02667465]\n", + " [0.0302959 0.96889168]]\n" ] } ], @@ -4982,7 +997,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## References\n", + "## 参考资料\n", "\n", "* [零基础入门深度学习(3) - 神经网络和反向传播算法](https://www.zybuluo.com/hanbingtao/note/476663)\n", "* [Neural Network Using Python and Numpy](https://www.python-course.eu/neural_networks_with_python_numpy.php)\n", diff --git a/5_nn/3-softmax_ce.ipynb b/5_nn/3-softmax_ce.ipynb index 971f296..09442d8 100644 --- a/5_nn/3-softmax_ce.ipynb +++ b/5_nn/3-softmax_ce.ipynb @@ -242,13 +242,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## References\n", + "## 参考资料\n", "\n", - "* Softmax & 交叉熵\n", - " * [一文详解Softmax函数](https://zhuanlan.zhihu.com/p/105722023)\n", - " * [交叉熵代价函数(作用及公式推导)](https://blog.csdn.net/u014313009/article/details/51043064)\n", - " * [手打例子一步一步带你看懂softmax函数以及相关求导过程](https://www.jianshu.com/p/ffa51250ba2e)\n", - " * [简单易懂的softmax交叉熵损失函数求导](https://www.jianshu.com/p/c02a1fbffad6)" + "* [一文详解Softmax函数](https://zhuanlan.zhihu.com/p/105722023)\n", + "* [交叉熵代价函数(作用及公式推导)](https://blog.csdn.net/u014313009/article/details/51043064)\n", + "* [手打例子一步一步带你看懂softmax函数以及相关求导过程](https://www.jianshu.com/p/ffa51250ba2e)\n", + "* [简单易懂的softmax交叉熵损失函数求导](https://www.jianshu.com/p/c02a1fbffad6)" ] } ], @@ -268,7 +267,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.7.9" } }, "nbformat": 4, diff --git a/5_nn/images/mlp_theory.gif b/5_nn/images/mlp_theory.gif new file mode 100644 index 0000000..1fb0b24 Binary files /dev/null and b/5_nn/images/mlp_theory.gif differ diff --git a/5_nn/images/neural_network_demo.gif b/5_nn/images/neural_network_demo.gif new file mode 100644 index 0000000..288f4b0 Binary files /dev/null and b/5_nn/images/neural_network_demo.gif differ diff --git a/5_nn/images/neuron.png b/5_nn/images/neuron.png index 1d99037..139ab00 100644 Binary files a/5_nn/images/neuron.png and b/5_nn/images/neuron.png differ diff --git a/5_nn/images/neuron_0.png b/5_nn/images/neuron_0.png new file mode 100644 index 0000000..1d99037 Binary files /dev/null and b/5_nn/images/neuron_0.png differ diff --git a/5_nn/images/neuron_cell_cn.png b/5_nn/images/neuron_cell_cn.png new file mode 100644 index 0000000..6fc0f1e Binary files /dev/null and b/5_nn/images/neuron_cell_cn.png differ diff --git a/5_nn/images/neuron_cell_cn_0.png b/5_nn/images/neuron_cell_cn_0.png new file mode 100644 index 0000000..7067de5 Binary files /dev/null and b/5_nn/images/neuron_cell_cn_0.png differ diff --git a/5_nn/images/neuron_cell_diagram.png b/5_nn/images/neuron_cell_diagram.png new file mode 100644 index 0000000..7adc508 Binary files /dev/null and b/5_nn/images/neuron_cell_diagram.png differ diff --git a/5_nn/images/perceptron.png b/5_nn/images/perceptron.png new file mode 100644 index 0000000..287bd43 Binary files /dev/null and b/5_nn/images/perceptron.png differ diff --git a/5_nn/images/perceptron_0.png b/5_nn/images/perceptron_0.png new file mode 100644 index 0000000..5f2262d Binary files /dev/null and b/5_nn/images/perceptron_0.png differ