commit f19b2512d7706185228254e519ee8e6fa9dfb757 Author: wehub-resource-sync Date: Mon Jul 13 13:30:25 2026 +0800 chore: import upstream snapshot with attribution diff --git a/LICENSE b/LICENSE new file mode 100755 index 0000000..261eeb9 --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/Projects/lihang-code/code/gongzhong.jpg b/Projects/lihang-code/code/gongzhong.jpg new file mode 100755 index 0000000..4bc1156 Binary files /dev/null and b/Projects/lihang-code/code/gongzhong.jpg differ diff --git a/Projects/lihang-code/code/readme.md b/Projects/lihang-code/code/readme.md new file mode 100755 index 0000000..d1f3bd4 --- /dev/null +++ b/Projects/lihang-code/code/readme.md @@ -0,0 +1,33 @@ +**代码目录** + +第1章 统计学习方法概论 + +第2章 感知机 + +第3章 k近邻法 + +第4章 朴素贝叶斯 + +第5章 决策树 + +第6章 逻辑斯谛回归 + +第7章 支持向量机 + +第8章 提升方法 + +第9章 EM算法及其推广 + +第10章 隐马尔可夫模型 + +第11章 条件随机场 + +----------- +参考： +https://github.com/wzyonggege/statistical-learning-method +https://github.com/WenDesi/lihang_book_algorithm +https://blog.csdn.net/tudaodiaozhale + +代码整理和修改：机器学习初学者 （微信公众号，ID:ai-start-com） + + diff --git a/Projects/lihang-code/code/第10章 隐马尔可夫模型(HMM)/HMM.ipynb b/Projects/lihang-code/code/第10章 隐马尔可夫模型(HMM)/HMM.ipynb new file mode 100755 index 0000000..874c7a3 --- /dev/null +++ b/Projects/lihang-code/code/第10章 隐马尔可夫模型(HMM)/HMM.ipynb @@ -0,0 +1,310 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "原文代码作者：https://blog.csdn.net/tudaodiaozhale\n", + "\n", + "中文注释制作：机器学习初学者(微信公众号：ID:ai-start-com)\n", + "\n", + "配置环境：python 3.6\n", + "\n", + "代码全部测试通过。\n", + "![gongzhong](../gongzhong.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 第10章 隐马尔可夫模型" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "class HiddenMarkov:\n", + " def forward(self, Q, V, A, B, O, PI): # 使用前向算法\n", + " N = len(Q) # 状态序列的大小\n", + " M = len(O) # 观测序列的大小\n", + " alphas = np.zeros((N, M)) # alpha值\n", + " T = M # 有几个时刻，有几个观测序列，就有几个时刻\n", + " for t in range(T): # 遍历每一时刻，算出alpha值\n", + " indexOfO = V.index(O[t]) # 找出序列对应的索引\n", + " for i in range(N):\n", + " if t == 0: # 计算初值\n", + " alphas[i][t] = PI[t][i] * B[i][indexOfO] # P176（10.15）\n", + " print('alpha1(%d)=p%db%db(o1)=%f' % (i, i, i, alphas[i][t]))\n", + " else:\n", + " alphas[i][t] = np.dot([alpha[t - 1] for alpha in alphas], [a[i] for a in A]) * B[i][\n", + " indexOfO] # 对应P176（10.16）\n", + " print('alpha%d(%d)=[sigma alpha%d(i)ai%d]b%d(o%d)=%f' % (t, i, t - 1, i, i, t, alphas[i][t]))\n", + " # print(alphas)\n", + " P = np.sum([alpha[M - 1] for alpha in alphas]) # P176(10.17)\n", + " # alpha11 = pi[0][0] * B[0][0] #代表a1(1)\n", + " # alpha12 = pi[0][1] * B[1][0] #代表a1(2)\n", + " # alpha13 = pi[0][2] * B[2][0] #代表a1(3)\n", + "\n", + " def backward(self, Q, V, A, B, O, PI): # 后向算法\n", + " N = len(Q) # 状态序列的大小\n", + " M = len(O) # 观测序列的大小\n", + " betas = np.ones((N, M)) # beta\n", + " for i in range(N):\n", + " print('beta%d(%d)=1' % (M, i))\n", + " for t in range(M - 2, -1, -1):\n", + " indexOfO = V.index(O[t + 1]) # 找出序列对应的索引\n", + " for i in range(N):\n", + " betas[i][t] = np.dot(np.multiply(A[i], [b[indexOfO] for b in B]), [beta[t + 1] for beta in betas])\n", + " realT = t + 1\n", + " realI = i + 1\n", + " print('beta%d(%d)=[sigma a%djbj(o%d)]beta%d(j)=(' % (realT, realI, realI, realT + 1, realT + 1),\n", + " end='')\n", + " for j in range(N):\n", + " print(\"%.2f*%.2f*%.2f+\" % (A[i][j], B[j][indexOfO], betas[j][t + 1]), end='')\n", + " print(\"0)=%.3f\" % betas[i][t])\n", + " # print(betas)\n", + " indexOfO = V.index(O[0])\n", + " P = np.dot(np.multiply(PI, [b[indexOfO] for b in B]), [beta[0] for beta in betas])\n", + " print(\"P(O|lambda)=\", end=\"\")\n", + " for i in range(N):\n", + " print(\"%.1f*%.1f*%.5f+\" % (PI[0][i], B[i][indexOfO], betas[i][0]), end=\"\")\n", + " print(\"0=%f\" % P)\n", + "\n", + " def viterbi(self, Q, V, A, B, O, PI):\n", + " N = len(Q) # 状态序列的大小\n", + " M = len(O) # 观测序列的大小\n", + " deltas = np.zeros((N, M))\n", + " psis = np.zeros((N, M))\n", + " I = np.zeros((1, M))\n", + " for t in range(M):\n", + " realT = t+1\n", + " indexOfO = V.index(O[t]) # 找出序列对应的索引\n", + " for i in range(N):\n", + " realI = i+1\n", + " if t == 0:\n", + " deltas[i][t] = PI[0][i] * B[i][indexOfO]\n", + " psis[i][t] = 0\n", + " print('delta1(%d)=pi%d * b%d(o1)=%.2f * %.2f=%.2f'%(realI, realI, realI, PI[0][i], B[i][indexOfO], deltas[i][t]))\n", + " print('psis1(%d)=0' % (realI))\n", + " else:\n", + " deltas[i][t] = np.max(np.multiply([delta[t-1] for delta in deltas], [a[i] for a in A])) * B[i][indexOfO]\n", + " print('delta%d(%d)=max[delta%d(j)aj%d]b%d(o%d)=%.2f*%.2f=%.5f'%(realT, realI, realT-1, realI, realI, realT, np.max(np.multiply([delta[t-1] for delta in deltas], [a[i] for a in A])), B[i][indexOfO], deltas[i][t]))\n", + " psis[i][t] = np.argmax(np.multiply([delta[t-1] for delta in deltas], [a[i] for a in A]))\n", + " print('psis%d(%d)=argmax[delta%d(j)aj%d]=%d' % (realT, realI, realT-1, realI, psis[i][t]))\n", + " print(deltas)\n", + " print(psis)\n", + " I[0][M-1] = np.argmax([delta[M-1] for delta in deltas])\n", + " print('i%d=argmax[deltaT(i)]=%d' % (M, I[0][M-1]+1))\n", + " for t in range(M-2, -1, -1):\n", + " I[0][t] = psis[int(I[0][t+1])][t+1]\n", + " print('i%d=psis%d(i%d)=%d' % (t+1, t+2, t+2, I[0][t]+1))\n", + " print(I)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 习题10.1" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "#习题10.1\n", + "Q = [1, 2, 3]\n", + "V = ['红', '白']\n", + "A = [[0.5, 0.2, 0.3], [0.3, 0.5, 0.2], [0.2, 0.3, 0.5]]\n", + "B = [[0.5, 0.5], [0.4, 0.6], [0.7, 0.3]]\n", + "# O = ['红', '白', '红', '红', '白', '红', '白', '白']\n", + "O = ['红', '白', '红', '白'] #习题10.1的例子\n", + "PI = [[0.2, 0.4, 0.4]]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "delta1(1)=pi1 * b1(o1)=0.20 * 0.50=0.10\n", + "psis1(1)=0\n", + "delta1(2)=pi2 * b2(o1)=0.40 * 0.40=0.16\n", + "psis1(2)=0\n", + "delta1(3)=pi3 * b3(o1)=0.40 * 0.70=0.28\n", + "psis1(3)=0\n", + "delta2(1)=max[delta1(j)aj1]b1(o2)=0.06*0.50=0.02800\n", + "psis2(1)=argmax[delta1(j)aj1]=2\n", + "delta2(2)=max[delta1(j)aj2]b2(o2)=0.08*0.60=0.05040\n", + "psis2(2)=argmax[delta1(j)aj2]=2\n", + "delta2(3)=max[delta1(j)aj3]b3(o2)=0.14*0.30=0.04200\n", + "psis2(3)=argmax[delta1(j)aj3]=2\n", + "delta3(1)=max[delta2(j)aj1]b1(o3)=0.02*0.50=0.00756\n", + "psis3(1)=argmax[delta2(j)aj1]=1\n", + "delta3(2)=max[delta2(j)aj2]b2(o3)=0.03*0.40=0.01008\n", + "psis3(2)=argmax[delta2(j)aj2]=1\n", + "delta3(3)=max[delta2(j)aj3]b3(o3)=0.02*0.70=0.01470\n", + "psis3(3)=argmax[delta2(j)aj3]=2\n", + "delta4(1)=max[delta3(j)aj1]b1(o4)=0.00*0.50=0.00189\n", + "psis4(1)=argmax[delta3(j)aj1]=0\n", + "delta4(2)=max[delta3(j)aj2]b2(o4)=0.01*0.60=0.00302\n", + "psis4(2)=argmax[delta3(j)aj2]=1\n", + "delta4(3)=max[delta3(j)aj3]b3(o4)=0.01*0.30=0.00220\n", + "psis4(3)=argmax[delta3(j)aj3]=2\n", + "[[0.1 0.028 0.00756 0.00189 ]\n", + " [0.16 0.0504 0.01008 0.003024]\n", + " [0.28 0.042 0.0147 0.002205]]\n", + "[[0. 2. 1. 0.]\n", + " [0. 2. 1. 1.]\n", + " [0. 2. 2. 2.]]\n", + "i4=argmax[deltaT(i)]=2\n", + "i3=psis4(i4)=2\n", + "i2=psis3(i3)=2\n", + "i1=psis2(i2)=3\n", + "[[2. 1. 1. 1.]]\n" + ] + } + ], + "source": [ + "HMM = HiddenMarkov()\n", + "# HMM.forward(Q, V, A, B, O, PI)\n", + "# HMM.backward(Q, V, A, B, O, PI)\n", + "HMM.viterbi(Q, V, A, B, O, PI)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 习题10.2" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "Q = [1, 2, 3]\n", + "V = ['红', '白']\n", + "A = [[0.5, 0.2, 0.3], [0.3, 0.5, 0.2], [0.2, 0.3, 0.5]]\n", + "B = [[0.5, 0.5], [0.4, 0.6], [0.7, 0.3]]\n", + "O = ['红', '白', '红', '红', '白', '红', '白', '白']\n", + "PI = [[0.2, 0.3, 0.5]]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "alpha1(0)=p0b0b(o1)=0.100000\n", + "alpha1(1)=p1b1b(o1)=0.120000\n", + "alpha1(2)=p2b2b(o1)=0.350000\n", + "alpha1(0)=[sigma alpha0(i)ai0]b0(o1)=0.078000\n", + "alpha1(1)=[sigma alpha0(i)ai1]b1(o1)=0.111000\n", + "alpha1(2)=[sigma alpha0(i)ai2]b2(o1)=0.068700\n", + "alpha2(0)=[sigma alpha1(i)ai0]b0(o2)=0.043020\n", + "alpha2(1)=[sigma alpha1(i)ai1]b1(o2)=0.036684\n", + "alpha2(2)=[sigma alpha1(i)ai2]b2(o2)=0.055965\n", + "alpha3(0)=[sigma alpha2(i)ai0]b0(o3)=0.021854\n", + "alpha3(1)=[sigma alpha2(i)ai1]b1(o3)=0.017494\n", + "alpha3(2)=[sigma alpha2(i)ai2]b2(o3)=0.033758\n", + "alpha4(0)=[sigma alpha3(i)ai0]b0(o4)=0.011463\n", + "alpha4(1)=[sigma alpha3(i)ai1]b1(o4)=0.013947\n", + "alpha4(2)=[sigma alpha3(i)ai2]b2(o4)=0.008080\n", + "alpha5(0)=[sigma alpha4(i)ai0]b0(o5)=0.005766\n", + "alpha5(1)=[sigma alpha4(i)ai1]b1(o5)=0.004676\n", + "alpha5(2)=[sigma alpha4(i)ai2]b2(o5)=0.007188\n", + "alpha6(0)=[sigma alpha5(i)ai0]b0(o6)=0.002862\n", + "alpha6(1)=[sigma alpha5(i)ai1]b1(o6)=0.003389\n", + "alpha6(2)=[sigma alpha5(i)ai2]b2(o6)=0.001878\n", + "alpha7(0)=[sigma alpha6(i)ai0]b0(o7)=0.001411\n", + "alpha7(1)=[sigma alpha6(i)ai1]b1(o7)=0.001698\n", + "alpha7(2)=[sigma alpha6(i)ai2]b2(o7)=0.000743\n", + "beta8(0)=1\n", + "beta8(1)=1\n", + "beta8(2)=1\n", + "beta7(1)=[sigma a1jbj(o8)]beta8(j)=(0.50*0.50*1.00+0.20*0.60*1.00+0.30*0.30*1.00+0)=0.460\n", + "beta7(2)=[sigma a2jbj(o8)]beta8(j)=(0.30*0.50*1.00+0.50*0.60*1.00+0.20*0.30*1.00+0)=0.510\n", + "beta7(3)=[sigma a3jbj(o8)]beta8(j)=(0.20*0.50*1.00+0.30*0.60*1.00+0.50*0.30*1.00+0)=0.430\n", + "beta6(1)=[sigma a1jbj(o7)]beta7(j)=(0.50*0.50*0.46+0.20*0.60*0.51+0.30*0.30*0.43+0)=0.215\n", + "beta6(2)=[sigma a2jbj(o7)]beta7(j)=(0.30*0.50*0.46+0.50*0.60*0.51+0.20*0.30*0.43+0)=0.248\n", + "beta6(3)=[sigma a3jbj(o7)]beta7(j)=(0.20*0.50*0.46+0.30*0.60*0.51+0.50*0.30*0.43+0)=0.202\n", + "beta5(1)=[sigma a1jbj(o6)]beta6(j)=(0.50*0.50*0.21+0.20*0.40*0.25+0.30*0.70*0.20+0)=0.116\n", + "beta5(2)=[sigma a2jbj(o6)]beta6(j)=(0.30*0.50*0.21+0.50*0.40*0.25+0.20*0.70*0.20+0)=0.110\n", + "beta5(3)=[sigma a3jbj(o6)]beta6(j)=(0.20*0.50*0.21+0.30*0.40*0.25+0.50*0.70*0.20+0)=0.122\n", + "beta4(1)=[sigma a1jbj(o5)]beta5(j)=(0.50*0.50*0.12+0.20*0.60*0.11+0.30*0.30*0.12+0)=0.053\n", + "beta4(2)=[sigma a2jbj(o5)]beta5(j)=(0.30*0.50*0.12+0.50*0.60*0.11+0.20*0.30*0.12+0)=0.058\n", + "beta4(3)=[sigma a3jbj(o5)]beta5(j)=(0.20*0.50*0.12+0.30*0.60*0.11+0.50*0.30*0.12+0)=0.050\n", + "beta3(1)=[sigma a1jbj(o4)]beta4(j)=(0.50*0.50*0.05+0.20*0.40*0.06+0.30*0.70*0.05+0)=0.028\n", + "beta3(2)=[sigma a2jbj(o4)]beta4(j)=(0.30*0.50*0.05+0.50*0.40*0.06+0.20*0.70*0.05+0)=0.026\n", + "beta3(3)=[sigma a3jbj(o4)]beta4(j)=(0.20*0.50*0.05+0.30*0.40*0.06+0.50*0.70*0.05+0)=0.030\n", + "beta2(1)=[sigma a1jbj(o3)]beta3(j)=(0.50*0.50*0.03+0.20*0.40*0.03+0.30*0.70*0.03+0)=0.015\n", + "beta2(2)=[sigma a2jbj(o3)]beta3(j)=(0.30*0.50*0.03+0.50*0.40*0.03+0.20*0.70*0.03+0)=0.014\n", + "beta2(3)=[sigma a3jbj(o3)]beta3(j)=(0.20*0.50*0.03+0.30*0.40*0.03+0.50*0.70*0.03+0)=0.016\n", + "beta1(1)=[sigma a1jbj(o2)]beta2(j)=(0.50*0.50*0.02+0.20*0.60*0.01+0.30*0.30*0.02+0)=0.007\n", + "beta1(2)=[sigma a2jbj(o2)]beta2(j)=(0.30*0.50*0.02+0.50*0.60*0.01+0.20*0.30*0.02+0)=0.007\n", + "beta1(3)=[sigma a3jbj(o2)]beta2(j)=(0.20*0.50*0.02+0.30*0.60*0.01+0.50*0.30*0.02+0)=0.006\n", + "P(O|lambda)=0.2*0.5*0.00698+0.3*0.4*0.00741+0.5*0.7*0.00647+0=0.003852\n" + ] + } + ], + "source": [ + "HMM.forward(Q, V, A, B, O, PI)\n", + "HMM.backward(Q, V, A, B, O, PI)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Projects/lihang-code/code/第11章 条件随机场(CRF)/CRF.ipynb b/Projects/lihang-code/code/第11章 条件随机场(CRF)/CRF.ipynb new file mode 100755 index 0000000..9c45e5b --- /dev/null +++ b/Projects/lihang-code/code/第11章 条件随机场(CRF)/CRF.ipynb @@ -0,0 +1,133 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "原文代码作者：https://blog.csdn.net/GrinAndBearIt/article/details/79229803\n", + "\n", + "中文注释制作：机器学习初学者(微信公众号：ID:ai-start-com)\n", + "\n", + "配置环境：python 3.6\n", + "\n", + "代码全部测试通过。\n", + "![gongzhong](../gongzhong.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 第11章 条件随机场\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 例11.1" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from numpy import *" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "24.532530197109345\n", + "24.532530197109352\n" + ] + } + ], + "source": [ + "#这里定义T为转移矩阵列代表前一个y(ij)代表由状态i转到状态j的概率,Tx矩阵x对应于时间序列\n", + "#这里将书上的转移特征转换为如下以时间轴为区别的三个多维列表，维度为输出的维度\n", + "T1=[[0.6,1],[1,0]];T2=[[0,1],[1,0.2]]\n", + "#将书上的状态特征同样转换成列表,第一个是为y1的未规划概率，第二个为y2的未规划概率\n", + "S0=[1,0.5];S1=[0.8,0.5];S2=[0.8,0.5]\n", + "Y=[1,2,2] #即书上例一需要计算的非规划条件概率的标记序列\n", + "Y=array(Y)-1 #这里为了将数与索引相对应即从零开始\n", + "P=exp(S0[Y[0]])\n", + "for i in range(1,len(Y)):\n", + " P *= exp((eval('S%d' % i)[Y[i]])+eval('T%d' % i)[Y[i-1]][Y[i]])\n", + "print(P)\n", + "print(exp(3.2))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 例11.2" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "非规范化概率 24.532530197109345\n" + ] + } + ], + "source": [ + "#这里根据例11.2的启发整合为一个矩阵\n", + "F0=S0;F1=T1+array(S1*len(T1)).reshape(shape(T1));F2=T2+array(S2*len(T2)).reshape(shape(T2))\n", + "Y=[1,2,2] #即书上例一需要计算的非规划条件概率的标记序列\n", + "Y=array(Y)-1\n", + "\n", + "P=exp(F0[Y[0]])\n", + "Sum=P\n", + "for i in range(1,len(Y)):\n", + " PIter=exp((eval('F%d' % i)[Y[i-1]][Y[i]]))\n", + " P *= PIter\n", + " Sum += PIter\n", + "print('非规范化概率',P)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Projects/lihang-code/code/第11章 条件随机场/.ipynb_checkpoints/CRF-checkpoint.ipynb b/Projects/lihang-code/code/第11章 条件随机场/.ipynb_checkpoints/CRF-checkpoint.ipynb new file mode 100755 index 0000000..9c45e5b --- /dev/null +++ b/Projects/lihang-code/code/第11章 条件随机场/.ipynb_checkpoints/CRF-checkpoint.ipynb @@ -0,0 +1,133 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "原文代码作者：https://blog.csdn.net/GrinAndBearIt/article/details/79229803\n", + "\n", + "中文注释制作：机器学习初学者(微信公众号：ID:ai-start-com)\n", + "\n", + "配置环境：python 3.6\n", + "\n", + "代码全部测试通过。\n", + "![gongzhong](../gongzhong.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 第11章 条件随机场\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 例11.1" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from numpy import *" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "24.532530197109345\n", + "24.532530197109352\n" + ] + } + ], + "source": [ + "#这里定义T为转移矩阵列代表前一个y(ij)代表由状态i转到状态j的概率,Tx矩阵x对应于时间序列\n", + "#这里将书上的转移特征转换为如下以时间轴为区别的三个多维列表，维度为输出的维度\n", + "T1=[[0.6,1],[1,0]];T2=[[0,1],[1,0.2]]\n", + "#将书上的状态特征同样转换成列表,第一个是为y1的未规划概率，第二个为y2的未规划概率\n", + "S0=[1,0.5];S1=[0.8,0.5];S2=[0.8,0.5]\n", + "Y=[1,2,2] #即书上例一需要计算的非规划条件概率的标记序列\n", + "Y=array(Y)-1 #这里为了将数与索引相对应即从零开始\n", + "P=exp(S0[Y[0]])\n", + "for i in range(1,len(Y)):\n", + " P *= exp((eval('S%d' % i)[Y[i]])+eval('T%d' % i)[Y[i-1]][Y[i]])\n", + "print(P)\n", + "print(exp(3.2))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 例11.2" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "非规范化概率 24.532530197109345\n" + ] + } + ], + "source": [ + "#这里根据例11.2的启发整合为一个矩阵\n", + "F0=S0;F1=T1+array(S1*len(T1)).reshape(shape(T1));F2=T2+array(S2*len(T2)).reshape(shape(T2))\n", + "Y=[1,2,2] #即书上例一需要计算的非规划条件概率的标记序列\n", + "Y=array(Y)-1\n", + "\n", + "P=exp(F0[Y[0]])\n", + "Sum=P\n", + "for i in range(1,len(Y)):\n", + " PIter=exp((eval('F%d' % i)[Y[i-1]][Y[i]]))\n", + " P *= PIter\n", + " Sum += PIter\n", + "print('非规范化概率',P)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Projects/lihang-code/code/第1章 统计学习方法概论(LeastSquaresMethod)/least_sqaure_method.ipynb b/Projects/lihang-code/code/第1章 统计学习方法概论(LeastSquaresMethod)/least_sqaure_method.ipynb new file mode 100755 index 0000000..bd07817 --- /dev/null +++ b/Projects/lihang-code/code/第1章 统计学习方法概论(LeastSquaresMethod)/least_sqaure_method.ipynb @@ -0,0 +1,366 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "原文代码作者：https://github.com/wzyonggege/statistical-learning-method\n", + "\n", + "中文注释制作：机器学习初学者\n", + "\n", + "微信公众号：ID:ai-start-com\n", + "\n", + "配置环境：python 3.6\n", + "\n", + "代码全部测试通过。\n", + "![gongzhong](../gongzhong.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 第1章 统计学习方法概论" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "高斯于1823年在误差e1 ,… , en独立同分布的假定下,证明了最小二乘方法的一个最优性质: 在所有无偏的线性估计类中,最小二乘方法是其中方差最小的！" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 使用最小二乘法拟和曲线\n", + "\n", + "对于数据$(x_i, y_i)(i=1, 2, 3...,m)$\n", + "\n", + "拟合出函数$h(x)$\n", + "\n", + "有误差，即残差：$r_i=h(x_i)-y_i$\n", + "\n", + "此时L2范数(残差平方和)最小时，h(x) 和 y 相似度最高，更拟合" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "一般的H(x)为n次的多项式，$H(x)=w_0+w_1x+w_2x^2+...w_nx^n$\n", + "\n", + "$w(w_0,w_1,w_2,...,w_n)$为参数\n", + "\n", + "最小二乘法就是要找到一组 $w(w_0,w_1,w_2,...,w_n)$ 使得$\\sum_{i=1}^n(h(x_i)-y_i)^2$ (残差平方和) 最小\n", + "\n", + "即，求 $min\\sum_{i=1}^n(h(x_i)-y_i)^2$\n", + "\n", + "----" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "举例：我们用目标函数$y=sin2{\\pi}x$, 加上一个正太分布的噪音干扰，用多项式去拟合【例1.1 11页】" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import scipy as sp\n", + "from scipy.optimize import leastsq\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*ps: numpy.poly1d([1,2,3]) 生成 $1x^2+2x^1+3x^0$*" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# 目标函数\n", + "def real_func(x):\n", + " return np.sin(2*np.pi*x)\n", + "\n", + "# 多项式\n", + "def fit_func(p, x):\n", + " f = np.poly1d(p)\n", + " return f(x)\n", + "\n", + "# 残差\n", + "def residuals_func(p, x, y):\n", + " ret = fit_func(p, x) - y\n", + " return ret" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# 十个点\n", + "x = np.linspace(0, 1, 10)\n", + "x_points = np.linspace(0, 1, 1000)\n", + "# 加上正态分布噪音的目标函数的值\n", + "y_ = real_func(x)\n", + "y = [np.random.normal(0, 0.1)+y1 for y1 in y_]\n", + "\n", + "def fitting(M=0):\n", + " \"\"\"\n", + " M 为 多项式的次数\n", + " \"\"\" \n", + " # 随机初始化多项式参数\n", + " p_init = np.random.rand(M+1)\n", + " # 最小二乘法\n", + " p_lsq = leastsq(residuals_func, p_init, args=(x, y))\n", + " print('Fitting Parameters:', p_lsq[0])\n", + " \n", + " # 可视化\n", + " plt.plot(x_points, real_func(x_points), label='real')\n", + " plt.plot(x_points, fit_func(p_lsq[0], x_points), label='fitted curve')\n", + " plt.plot(x, y, 'bo', label='noise')\n", + " plt.legend()\n", + " return p_lsq" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting Parameters: [-0.03353208]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# M=0\n", + "p_lsq_0 = fitting(M=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting Parameters: [-1.5025198 0.71772782]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# M=1\n", + "p_lsq_1 = fitting(M=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting Parameters: [ 21.14354912 -31.85091 10.66661731 -0.03324716]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# M=3\n", + "p_lsq_3 = fitting(M=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting Parameters: [-7.35300865e+03 3.20446626e+04 -5.87661832e+04 5.89723258e+04\n", + " -3.52349521e+04 1.27636926e+04 -2.70301291e+03 2.80321069e+02\n", + " -3.97563291e+00 -2.00783231e-02]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# M=9\n", + "p_lsq_9 = fitting(M=9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "当M=9时，多项式曲线通过了每个数据点，但是造成了过拟合" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 正则化" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "结果显示过拟合， 引入正则化项(regularizer)，降低过拟合\n", + "\n", + "$Q(x)=\\sum_{i=1}^n(h(x_i)-y_i)^2+\\lambda||w||^2$。\n", + "\n", + "回归问题中，损失函数是平方损失，正则化可以是参数向量的L2范数,也可以是L1范数。\n", + "\n", + "- L1: regularization\\*abs(p)\n", + "\n", + "- L2: 0.5 \\* regularization \\* np.square(p)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "regularization = 0.0001\n", + "\n", + "def residuals_func_regularization(p, x, y):\n", + " ret = fit_func(p, x) - y\n", + " ret = np.append(ret, np.sqrt(0.5*regularization*np.square(p))) # L2范数作为正则化项\n", + " return ret" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# 最小二乘法,加正则化项\n", + "p_init = np.random.rand(9+1)\n", + "p_lsq_regularization = leastsq(residuals_func_regularization, p_init, args=(x, y))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x_points, real_func(x_points), label='real')\n", + "plt.plot(x_points, fit_func(p_lsq_9[0], x_points), label='fitted curve')\n", + "plt.plot(x_points, fit_func(p_lsq_regularization[0], x_points), label='regularization')\n", + "plt.plot(x, y, 'bo', label='noise')\n", + "plt.legend()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Projects/lihang-code/code/第2章 感知机(Perceptron)/Iris_perceptron.ipynb b/Projects/lihang-code/code/第2章 感知机(Perceptron)/Iris_perceptron.ipynb new file mode 100755 index 0000000..f4f6d21 --- /dev/null +++ b/Projects/lihang-code/code/第2章 感知机(Perceptron)/Iris_perceptron.ipynb @@ -0,0 +1,408 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "原文代码作者：https://github.com/wzyonggege/statistical-learning-method\n", + "\n", + "中文注释制作：机器学习初学者\n", + "\n", + "微信公众号：ID:ai-start-com\n", + "\n", + "配置环境：python 3.6\n", + "\n", + "代码全部测试通过。\n", + "![gongzhong](../gongzhong.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 第2章 感知机\n", + "\n", + "二分类模型" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$f(x) = sign(w*x + b)$\n", + "\n", + "损失函数 $L(w, b) = -\\Sigma{y_{i}(w*x_{i} + b)}$\n", + "\n", + "---\n", + "#### 算法\n", + "\n", + "随即梯度下降法 Stochastic Gradient Descent\n", + "\n", + "随机抽取一个误分类点使其梯度下降。\n", + "\n", + "$w = w + \\eta y_{i}x_{i}$\n", + "\n", + "$b = b + \\eta y_{i}$\n", + "\n", + "当实例点被误分类，即位于分离超平面的错误侧，则调整w, b的值，使分离超平面向该无分类点的一侧移动，直至误分类点被正确分类" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "拿出iris数据集中两个分类的数据和[sepal length，sepal width]作为特征" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from sklearn.datasets import load_iris\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# load data\n", + "iris = load_iris()\n", + "df = pd.DataFrame(iris.data, columns=iris.feature_names)\n", + "df['label'] = iris.target" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2 50\n", + "1 50\n", + "0 50\n", + "Name: label, dtype: int64" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#\n", + "df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']\n", + "df.label.value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(df[:50]['sepal length'], df[:50]['sepal width'], label='0')\n", + "plt.scatter(df[50:100]['sepal length'], df[50:100]['sepal width'], label='1')\n", + "plt.xlabel('sepal length')\n", + "plt.ylabel('sepal width')\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "data = np.array(df.iloc[:100, [0, 1, -1]])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "X, y = data[:,:-1], data[:,-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "y = np.array([1 if i == 1 else -1 for i in y])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Perceptron" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# 数据线性可分，二分类数据\n", + "# 此处为一元一次线性方程\n", + "class Model:\n", + " def __init__(self):\n", + " self.w = np.ones(len(data[0])-1, dtype=np.float32)\n", + " self.b = 0\n", + " self.l_rate = 0.1\n", + " # self.data = data\n", + " \n", + " def sign(self, x, w, b):\n", + " y = np.dot(x, w) + b\n", + " return y\n", + " \n", + " # 随机梯度下降法\n", + " def fit(self, X_train, y_train):\n", + " is_wrong = False\n", + " while not is_wrong:\n", + " wrong_count = 0\n", + " for d in range(len(X_train)):\n", + " X = X_train[d]\n", + " y = y_train[d]\n", + " if y * self.sign(X, self.w, self.b) <= 0:\n", + " self.w = self.w + self.l_rate*np.dot(y, X)\n", + " self.b = self.b + self.l_rate*y\n", + " wrong_count += 1\n", + " if wrong_count == 0:\n", + " is_wrong = True\n", + " return 'Perceptron Model!'\n", + " \n", + " def score(self):\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Perceptron Model!'" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "perceptron = Model()\n", + "perceptron.fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x_points = np.linspace(4, 7,10)\n", + "y_ = -(perceptron.w[0]*x_points + perceptron.b)/perceptron.w[1]\n", + "plt.plot(x_points, y_)\n", + "\n", + "plt.plot(data[:50, 0], data[:50, 1], 'bo', color='blue', label='0')\n", + "plt.plot(data[50:100, 0], data[50:100, 1], 'bo', color='orange', label='1')\n", + "plt.xlabel('sepal length')\n", + "plt.ylabel('sepal width')\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## scikit-learn Perceptron" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import Perceptron" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Perceptron(alpha=0.0001, class_weight=None, eta0=1.0, fit_intercept=False,\n", + " max_iter=1000, n_iter=None, n_jobs=1, penalty=None, random_state=0,\n", + " shuffle=False, tol=None, verbose=0, warm_start=False)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clf = Perceptron(fit_intercept=False, max_iter=1000, shuffle=False)\n", + "clf.fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 74.6 -127.2]]\n" + ] + } + ], + "source": [ + "# Weights assigned to the features.\n", + "print(clf.coef_)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.]\n" + ] + } + ], + "source": [ + "# 截距 Constants in decision function.\n", + "print(clf.intercept_)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x_ponits = np.arange(4, 8)\n", + "y_ = -(clf.coef_[0][0]*x_ponits + clf.intercept_)/clf.coef_[0][1]\n", + "plt.plot(x_ponits, y_)\n", + "\n", + "plt.plot(data[:50, 0], data[:50, 1], 'bo', color='blue', label='0')\n", + "plt.plot(data[50:100, 0], data[50:100, 1], 'bo', color='orange', label='1')\n", + "plt.xlabel('sepal length')\n", + "plt.ylabel('sepal width')\n", + "plt.legend()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Projects/lihang-code/code/第3章 k近邻法(KNearestNeighbors)/KDT.py b/Projects/lihang-code/code/第3章 k近邻法(KNearestNeighbors)/KDT.py new file mode 100755 index 0000000..e38a175 --- /dev/null +++ b/Projects/lihang-code/code/第3章 k近邻法(KNearestNeighbors)/KDT.py @@ -0,0 +1,123 @@ +import numpy as np +from math import sqrt +import pandas as pd +from sklearn.datasets import load_iris +import matplotlib.pyplot as plt +from sklearn.model_selection import train_test_split + +iris = load_iris() +df = pd.DataFrame(iris.data, columns=iris.feature_names) +df['label'] = iris.target +df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label'] + +data = np.array(df.iloc[:100, [0, 1, -1]]) +train, test = train_test_split(data, test_size=0.1) +x0 = np.array([x0 for i, x0 in enumerate(train) if train[i][-1] == 0]) +x1 = np.array([x1 for i, x1 in enumerate(train) if train[i][-1] == 1]) + + +def show_train(): + plt.scatter(x0[:, 0], x0[:, 1], c='pink', label='[0]') + plt.scatter(x1[:, 0], x1[:, 1], c='orange', label='[1]') + plt.xlabel('sepal length') + plt.ylabel('sepal width') + + +class Node: + def __init__(self, data, depth=0, lchild=None, rchild=None): + self.data = data + self.depth = depth + self.lchild = lchild + self.rchild = rchild + + +class KdTree: + def __init__(self): + self.KdTree = None + self.n = 0 + self.nearest = None + + def create(self, dataSet, depth=0): + if len(dataSet) > 0: + m, n = np.shape(dataSet) + self.n = n - 1 + axis = depth % self.n + mid = int(m / 2) + dataSetcopy = sorted(dataSet, key=lambda x: x[axis]) + node = Node(dataSetcopy[mid], depth) + if depth == 0: + self.KdTree = node + node.lchild = self.create(dataSetcopy[:mid], depth+1) + node.rchild = self.create(dataSetcopy[mid+1:], depth+1) + return node + return None + + def preOrder(self, node): + if node is not None: + print(node.depth, node.data) + self.preOrder(node.lchild) + self.preOrder(node.rchild) + + def search(self, x, count=1): + nearest = [] + for i in range(count): + nearest.append([-1, None]) + self.nearest = np.array(nearest) + + def recurve(node): + if node is not None: + axis = node.depth % self.n + daxis = x[axis] - node.data[axis] + if daxis < 0: + recurve(node.lchild) + else: + recurve(node.rchild) + + dist = sqrt(sum((p1 - p2) ** 2 for p1, p2 in zip(x, node.data))) + for i, d in enumerate(self.nearest): + if d[0] < 0 or dist < d[0]: + self.nearest = np.insert(self.nearest, i, [dist, node], axis=0) + self.nearest = self.nearest[:-1] + break + + n = list(self.nearest[:, 0]).count(-1) + if self.nearest[-n-1, 0] > abs(daxis): + if daxis < 0: + recurve(node.rchild) + else: + recurve(node.lchild) + + recurve(self.KdTree) + + knn = self.nearest[:, 1] + belong = [] + for i in knn: + belong.append(i.data[-1]) + b = max(set(belong), key=belong.count) + + return self.nearest, b + + +kdt = KdTree() +kdt.create(train) +kdt.preOrder(kdt.KdTree) + +score = 0 +for x in test: + input('press Enter to show next:') + show_train() + plt.scatter(x[0], x[1], c='red', marker='x') # 测试点 + near, belong = kdt.search(x[:-1], 5) # 设置临近点的个数 + if belong == x[-1]: + score += 1 + print("test:") + print(x, "predict:", belong) + print("nearest:") + for n in near: + print(n[1].data, "dist:", n[0]) + plt.scatter(n[1].data[0], n[1].data[1], c='green', marker='+') # k个最近邻点 + plt.legend() + plt.show() + +score /= len(test) +print("score:", score) diff --git a/Projects/lihang-code/code/第3章 k近邻法(KNearestNeighbors)/KNN.ipynb b/Projects/lihang-code/code/第3章 k近邻法(KNearestNeighbors)/KNN.ipynb new file mode 100755 index 0000000..ab1799e --- /dev/null +++ b/Projects/lihang-code/code/第3章 k近邻法(KNearestNeighbors)/KNN.ipynb @@ -0,0 +1,1230 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "原文代码作者：https://github.com/wzyonggege/statistical-learning-method\n", + "\n", + "中文注释制作：机器学习初学者(微信公众号：ID:ai-start-com)\n", + "\n", + "配置环境：python 3.6\n", + "\n", + "代码全部测试通过。\n", + "![gongzhong](../gongzhong.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 第3章 k近邻法" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 距离度量" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "from itertools import combinations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- p = 1 曼哈顿距离\n", + "- p = 2 欧氏距离\n", + "- p = inf 闵式距离minkowski_distance " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def L(x, y, p=2):\n", + " # x1 = [1, 1], x2 = [5,1]\n", + " if len(x) == len(y) and len(x) > 1:\n", + " sum = 0\n", + " for i in range(len(x)):\n", + " sum += math.pow(abs(x[i] - y[i]), p)\n", + " return math.pow(sum, 1/p)\n", + " else:\n", + " return 0" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# 课本例3.1\n", + "x1 = [1, 1]\n", + "x2 = [5, 1]\n", + "x3 = [4, 4]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(4.0, '1-[5, 1]')\n", + "(4.0, '1-[5, 1]')\n", + "(3.7797631496846193, '1-[4, 4]')\n", + "(3.5676213450081633, '1-[4, 4]')\n" + ] + } + ], + "source": [ + "# x1, x2\n", + "for i in range(1, 5):\n", + " r = { '1-{}'.format(c):L(x1, c, p=i) for c in [x2, x3]}\n", + " print(min(zip(r.values(), r.keys())))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "python实现，遍历所有数据点，找出n个距离最近的点的分类情况，少数服从多数" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from sklearn.datasets import load_iris\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "from collections import Counter" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# data\n", + "iris = load_iris()\n", + "df = pd.DataFrame(iris.data, columns=iris.feature_names)\n", + "df['label'] = iris.target\n", + "df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']\n", + "# data = np.array(df.iloc[:100, [0, 1, -1]])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sepal lengthsepal widthpetal lengthpetal widthlabel
05.13.51.40.20
14.93.01.40.20
24.73.21.30.20
34.63.11.50.20
45.03.61.40.20
55.43.91.70.40
64.63.41.40.30
75.03.41.50.20
84.42.91.40.20
94.93.11.50.10
105.43.71.50.20
114.83.41.60.20
124.83.01.40.10
134.33.01.10.10
145.84.01.20.20
155.74.41.50.40
165.43.91.30.40
175.13.51.40.30
185.73.81.70.30
195.13.81.50.30
205.43.41.70.20
215.13.71.50.40
224.63.61.00.20
235.13.31.70.50
244.83.41.90.20
255.03.01.60.20
265.03.41.60.40
275.23.51.50.20
285.23.41.40.20
294.73.21.60.20
..................
1206.93.25.72.32
1215.62.84.92.02
1227.72.86.72.02
1236.32.74.91.82
1246.73.35.72.12
1257.23.26.01.82
1266.22.84.81.82
1276.13.04.91.82
1286.42.85.62.12
1297.23.05.81.62
1307.42.86.11.92
1317.93.86.42.02
1326.42.85.62.22
1336.32.85.11.52
1346.12.65.61.42
1357.73.06.12.32
1366.33.45.62.42
1376.43.15.51.82
1386.03.04.81.82
1396.93.15.42.12
1406.73.15.62.42
1416.93.15.12.32
1425.82.75.11.92
1436.83.25.92.32
1446.73.35.72.52
1456.73.05.22.32
1466.32.55.01.92
1476.53.05.22.02
1486.23.45.42.32
1495.93.05.11.82
\n", + "

150 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " sepal length sepal width petal length petal width label\n", + "0 5.1 3.5 1.4 0.2 0\n", + "1 4.9 3.0 1.4 0.2 0\n", + "2 4.7 3.2 1.3 0.2 0\n", + "3 4.6 3.1 1.5 0.2 0\n", + "4 5.0 3.6 1.4 0.2 0\n", + "5 5.4 3.9 1.7 0.4 0\n", + "6 4.6 3.4 1.4 0.3 0\n", + "7 5.0 3.4 1.5 0.2 0\n", + "8 4.4 2.9 1.4 0.2 0\n", + "9 4.9 3.1 1.5 0.1 0\n", + "10 5.4 3.7 1.5 0.2 0\n", + "11 4.8 3.4 1.6 0.2 0\n", + "12 4.8 3.0 1.4 0.1 0\n", + "13 4.3 3.0 1.1 0.1 0\n", + "14 5.8 4.0 1.2 0.2 0\n", + "15 5.7 4.4 1.5 0.4 0\n", + "16 5.4 3.9 1.3 0.4 0\n", + "17 5.1 3.5 1.4 0.3 0\n", + "18 5.7 3.8 1.7 0.3 0\n", + "19 5.1 3.8 1.5 0.3 0\n", + "20 5.4 3.4 1.7 0.2 0\n", + "21 5.1 3.7 1.5 0.4 0\n", + "22 4.6 3.6 1.0 0.2 0\n", + "23 5.1 3.3 1.7 0.5 0\n", + "24 4.8 3.4 1.9 0.2 0\n", + "25 5.0 3.0 1.6 0.2 0\n", + "26 5.0 3.4 1.6 0.4 0\n", + "27 5.2 3.5 1.5 0.2 0\n", + "28 5.2 3.4 1.4 0.2 0\n", + "29 4.7 3.2 1.6 0.2 0\n", + ".. ... ... ... ... ...\n", + "120 6.9 3.2 5.7 2.3 2\n", + "121 5.6 2.8 4.9 2.0 2\n", + "122 7.7 2.8 6.7 2.0 2\n", + "123 6.3 2.7 4.9 1.8 2\n", + "124 6.7 3.3 5.7 2.1 2\n", + "125 7.2 3.2 6.0 1.8 2\n", + "126 6.2 2.8 4.8 1.8 2\n", + "127 6.1 3.0 4.9 1.8 2\n", + "128 6.4 2.8 5.6 2.1 2\n", + "129 7.2 3.0 5.8 1.6 2\n", + "130 7.4 2.8 6.1 1.9 2\n", + "131 7.9 3.8 6.4 2.0 2\n", + "132 6.4 2.8 5.6 2.2 2\n", + "133 6.3 2.8 5.1 1.5 2\n", + "134 6.1 2.6 5.6 1.4 2\n", + "135 7.7 3.0 6.1 2.3 2\n", + "136 6.3 3.4 5.6 2.4 2\n", + "137 6.4 3.1 5.5 1.8 2\n", + "138 6.0 3.0 4.8 1.8 2\n", + "139 6.9 3.1 5.4 2.1 2\n", + "140 6.7 3.1 5.6 2.4 2\n", + "141 6.9 3.1 5.1 2.3 2\n", + "142 5.8 2.7 5.1 1.9 2\n", + "143 6.8 3.2 5.9 2.3 2\n", + "144 6.7 3.3 5.7 2.5 2\n", + "145 6.7 3.0 5.2 2.3 2\n", + "146 6.3 2.5 5.0 1.9 2\n", + "147 6.5 3.0 5.2 2.0 2\n", + "148 6.2 3.4 5.4 2.3 2\n", + "149 5.9 3.0 5.1 1.8 2\n", + "\n", + "[150 rows x 5 columns]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(df[:50]['sepal length'], df[:50]['sepal width'], label='0')\n", + "plt.scatter(df[50:100]['sepal length'], df[50:100]['sepal width'], label='1')\n", + "plt.xlabel('sepal length')\n", + "plt.ylabel('sepal width')\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "data = np.array(df.iloc[:100, [0, 1, -1]])\n", + "X, y = data[:,:-1], data[:,-1]\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "class KNN:\n", + " def __init__(self, X_train, y_train, n_neighbors=3, p=2):\n", + " \"\"\"\n", + " parameter: n_neighbors 临近点个数\n", + " parameter: p 距离度量\n", + " \"\"\"\n", + " self.n = n_neighbors\n", + " self.p = p\n", + " self.X_train = X_train\n", + " self.y_train = y_train\n", + " \n", + " def predict(self, X):\n", + " # 取出n个点\n", + " knn_list = []\n", + " for i in range(self.n):\n", + " dist = np.linalg.norm(X - self.X_train[i], ord=self.p)\n", + " knn_list.append((dist, self.y_train[i]))\n", + " \n", + " for i in range(self.n, len(self.X_train)):\n", + " max_index = knn_list.index(max(knn_list, key=lambda x: x[0]))\n", + " dist = np.linalg.norm(X - self.X_train[i], ord=self.p)\n", + " if knn_list[max_index][0] > dist:\n", + " knn_list[max_index] = (dist, self.y_train[i])\n", + " \n", + " # 统计\n", + " knn = [k[-1] for k in knn_list]\n", + " count_pairs = Counter(knn)\n", + " max_count = sorted(count_pairs, key=lambda x:x)[-1]\n", + " return max_count\n", + " \n", + " def score(self, X_test, y_test):\n", + " right_count = 0\n", + " n = 10\n", + " for X, y in zip(X_test, y_test):\n", + " label = self.predict(X)\n", + " if label == y:\n", + " right_count += 1\n", + " return right_count / len(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "clf = KNN(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.0" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clf.score(X_test, y_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Point: 1.0\n" + ] + } + ], + "source": [ + "test_point = [6.0, 3.0]\n", + "print('Test Point: {}'.format(clf.predict(test_point)))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(df[:50]['sepal length'], df[:50]['sepal width'], label='0')\n", + "plt.scatter(df[50:100]['sepal length'], df[50:100]['sepal width'], label='1')\n", + "plt.plot(test_point[0], test_point[1], 'bo', label='test_point')\n", + "plt.xlabel('sepal length')\n", + "plt.ylabel('sepal width')\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# scikitlearn" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.neighbors import KNeighborsClassifier" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n", + " metric_params=None, n_jobs=1, n_neighbors=5, p=2,\n", + " weights='uniform')" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clf_sk = KNeighborsClassifier()\n", + "clf_sk.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.0" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clf_sk.score(X_test, y_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "### sklearn.neighbors.KNeighborsClassifier\n", + "\n", + "- n_neighbors: 临近点个数\n", + "- p: 距离度量\n", + "- algorithm: 近邻算法，可选{'auto', 'ball_tree', 'kd_tree', 'brute'}\n", + "- weights: 确定近邻的权重" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### kd树" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# kd-tree每个结点中主要包含的数据结构如下 \n", + "class KdNode(object):\n", + " def __init__(self, dom_elt, split, left, right):\n", + " self.dom_elt = dom_elt # k维向量节点(k维空间中的一个样本点)\n", + " self.split = split # 整数（进行分割维度的序号）\n", + " self.left = left # 该结点分割超平面左子空间构成的kd-tree\n", + " self.right = right # 该结点分割超平面右子空间构成的kd-tree\n", + " \n", + " \n", + "class KdTree(object):\n", + " def __init__(self, data):\n", + " k = len(data[0]) # 数据维度\n", + " \n", + " def CreateNode(split, data_set): # 按第split维划分数据集exset创建KdNode\n", + " if not data_set: # 数据集为空\n", + " return None\n", + " # key参数的值为一个函数，此函数只有一个参数且返回一个值用来进行比较\n", + " # operator模块提供的itemgetter函数用于获取对象的哪些维的数据，参数为需要获取的数据在对象中的序号\n", + " #data_set.sort(key=itemgetter(split)) # 按要进行分割的那一维数据排序\n", + " data_set.sort(key=lambda x: x[split])\n", + " split_pos = len(data_set) // 2 # //为Python中的整数除法\n", + " median = data_set[split_pos] # 中位数分割点 \n", + " split_next = (split + 1) % k # cycle coordinates\n", + " \n", + " # 递归的创建kd树\n", + " return KdNode(median, split, \n", + " CreateNode(split_next, data_set[:split_pos]), # 创建左子树\n", + " CreateNode(split_next, data_set[split_pos + 1:])) # 创建右子树\n", + " \n", + " self.root = CreateNode(0, data) # 从第0维分量开始构建kd树,返回根节点\n", + "\n", + "\n", + "# KDTree的前序遍历\n", + "def preorder(root): \n", + " print (root.dom_elt) \n", + " if root.left: # 节点不为空\n", + " preorder(root.left) \n", + " if root.right: \n", + " preorder(root.right) " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# 对构建好的kd树进行搜索，寻找与目标点最近的样本点：\n", + "from math import sqrt\n", + "from collections import namedtuple\n", + "\n", + "# 定义一个namedtuple,分别存放最近坐标点、最近距离和访问过的节点数\n", + "result = namedtuple(\"Result_tuple\", \"nearest_point nearest_dist nodes_visited\")\n", + " \n", + "def find_nearest(tree, point):\n", + " k = len(point) # 数据维度\n", + " def travel(kd_node, target, max_dist):\n", + " if kd_node is None: \n", + " return result([0] * k, float(\"inf\"), 0) # python中用float(\"inf\")和float(\"-inf\")表示正负无穷\n", + " \n", + " nodes_visited = 1\n", + " \n", + " s = kd_node.split # 进行分割的维度\n", + " pivot = kd_node.dom_elt # 进行分割的“轴”\n", + " \n", + " if target[s] <= pivot[s]: # 如果目标点第s维小于分割轴的对应值(目标离左子树更近)\n", + " nearer_node = kd_node.left # 下一个访问节点为左子树根节点\n", + " further_node = kd_node.right # 同时记录下右子树\n", + " else: # 目标离右子树更近\n", + " nearer_node = kd_node.right # 下一个访问节点为右子树根节点\n", + " further_node = kd_node.left\n", + " \n", + " temp1 = travel(nearer_node, target, max_dist) # 进行遍历找到包含目标点的区域\n", + " \n", + " nearest = temp1.nearest_point # 以此叶结点作为“当前最近点”\n", + " dist = temp1.nearest_dist # 更新最近距离\n", + " \n", + " nodes_visited += temp1.nodes_visited \n", + " \n", + " if dist < max_dist: \n", + " max_dist = dist # 最近点将在以目标点为球心，max_dist为半径的超球体内\n", + " \n", + " temp_dist = abs(pivot[s] - target[s]) # 第s维上目标点与分割超平面的距离\n", + " if max_dist < temp_dist: # 判断超球体是否与超平面相交\n", + " return result(nearest, dist, nodes_visited) # 不相交则可以直接返回，不用继续判断\n", + " \n", + " #---------------------------------------------------------------------- \n", + " # 计算目标点与分割点的欧氏距离 \n", + " temp_dist = sqrt(sum((p1 - p2) ** 2 for p1, p2 in zip(pivot, target))) \n", + " \n", + " if temp_dist < dist: # 如果“更近”\n", + " nearest = pivot # 更新最近点\n", + " dist = temp_dist # 更新最近距离\n", + " max_dist = dist # 更新超球体半径\n", + " \n", + " # 检查另一个子结点对应的区域是否有更近的点\n", + " temp2 = travel(further_node, target, max_dist) \n", + " \n", + " nodes_visited += temp2.nodes_visited\n", + " if temp2.nearest_dist < dist: # 如果另一个子结点内存在更近距离\n", + " nearest = temp2.nearest_point # 更新最近点\n", + " dist = temp2.nearest_dist # 更新最近距离\n", + " \n", + " return result(nearest, dist, nodes_visited)\n", + " \n", + " return travel(tree.root, point, float(\"inf\")) # 从根节点开始递归" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 例3.2" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[7, 2]\n", + "[5, 4]\n", + "[2, 3]\n", + "[4, 7]\n", + "[9, 6]\n", + "[8, 1]\n" + ] + } + ], + "source": [ + "data = [[2,3],[5,4],[9,6],[4,7],[8,1],[7,2]]\n", + "kd = KdTree(data)\n", + "preorder(kd.root)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "from time import clock\n", + "from random import random\n", + "\n", + "# 产生一个k维随机向量，每维分量值在0~1之间\n", + "def random_point(k):\n", + " return [random() for _ in range(k)]\n", + " \n", + "# 产生n个k维随机向量 \n", + "def random_points(k, n):\n", + " return [random_point(k) for _ in range(n)] " + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result_tuple(nearest_point=[2, 3], nearest_dist=1.8027756377319946, nodes_visited=4)\n" + ] + } + ], + "source": [ + "ret = find_nearest(kd, [3,4.5])\n", + "print (ret)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "time: 7.299844505209247 s\n", + "Result_tuple(nearest_point=[0.10505669630674175, 0.49542598718931097, 0.8033166919543026], nearest_dist=0.007582362181450973, nodes_visited=53)\n" + ] + } + ], + "source": [ + "N = 400000\n", + "t0 = clock()\n", + "kd2 = KdTree(random_points(3, N)) # 构建包含四十万个3维空间样本点的kd树\n", + "ret2 = find_nearest(kd2, [0.1,0.5,0.8]) # 四十万个样本点中寻找离目标最近的点\n", + "t1 = clock()\n", + "print (\"time: \",t1-t0, \"s\")\n", + "print (ret2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Projects/lihang-code/code/第4章 朴素贝叶斯(NaiveBayes)/GaussianNB.ipynb b/Projects/lihang-code/code/第4章 朴素贝叶斯(NaiveBayes)/GaussianNB.ipynb new file mode 100755 index 0000000..0998492 --- /dev/null +++ b/Projects/lihang-code/code/第4章 朴素贝叶斯(NaiveBayes)/GaussianNB.ipynb @@ -0,0 +1,372 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "原文代码作者：https://github.com/wzyonggege/statistical-learning-method\n", + "\n", + "中文注释制作：机器学习初学者(微信公众号：ID:ai-start-com)\n", + "\n", + "配置环境：python 3.6\n", + "\n", + "代码全部测试通过。\n", + "![gongzhong](../gongzhong.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 第4章 朴素贝叶斯" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "基于贝叶斯定理与特征条件独立假设的分类方法。\n", + "\n", + "模型：\n", + "\n", + "- 高斯模型\n", + "- 多项式模型\n", + "- 伯努利模型" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from sklearn.datasets import load_iris\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "from collections import Counter\n", + "import math" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# data\n", + "def create_data():\n", + " iris = load_iris()\n", + " df = pd.DataFrame(iris.data, columns=iris.feature_names)\n", + " df['label'] = iris.target\n", + " df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']\n", + " data = np.array(df.iloc[:100, :])\n", + " # print(data)\n", + " return data[:,:-1], data[:,-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "X, y = create_data()\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([4.6, 3.4, 1.4, 0.3]), 0.0)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_test[0], y_test[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "参考：https://machinelearningmastery.com/naive-bayes-classifier-scratch-python/\n", + "\n", + "## GaussianNB 高斯朴素贝叶斯\n", + "\n", + "特征的可能性被假设为高斯\n", + "\n", + "概率密度函数：\n", + "$$P(x_i | y_k)=\\frac{1}{\\sqrt{2\\pi\\sigma^2_{yk}}}exp(-\\frac{(x_i-\\mu_{yk})^2}{2\\sigma^2_{yk}})$$\n", + "\n", + "数学期望(mean)：$\\mu$，方差：$\\sigma^2=\\frac{\\sum(X-\\mu)^2}{N}$" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class NaiveBayes:\n", + " def __init__(self):\n", + " self.model = None\n", + "\n", + " # 数学期望\n", + " @staticmethod\n", + " def mean(X):\n", + " return sum(X) / float(len(X))\n", + "\n", + " # 标准差（方差）\n", + " def stdev(self, X):\n", + " avg = self.mean(X)\n", + " return math.sqrt(sum([pow(x-avg, 2) for x in X]) / float(len(X)))\n", + "\n", + " # 概率密度函数\n", + " def gaussian_probability(self, x, mean, stdev):\n", + " exponent = math.exp(-(math.pow(x-mean,2)/(2*math.pow(stdev,2))))\n", + " return (1 / (math.sqrt(2*math.pi) * stdev)) * exponent\n", + "\n", + " # 处理X_train\n", + " def summarize(self, train_data):\n", + " summaries = [(self.mean(i), self.stdev(i)) for i in zip(*train_data)]\n", + " return summaries\n", + "\n", + " # 分类别求出数学期望和标准差\n", + " def fit(self, X, y):\n", + " labels = list(set(y))\n", + " data = {label:[] for label in labels}\n", + " for f, label in zip(X, y):\n", + " data[label].append(f)\n", + " self.model = {label: self.summarize(value) for label, value in data.items()}\n", + " return 'gaussianNB train done!'\n", + "\n", + " # 计算概率\n", + " def calculate_probabilities(self, input_data):\n", + " # summaries:{0.0: [(5.0, 0.37),(3.42, 0.40)], 1.0: [(5.8, 0.449),(2.7, 0.27)]}\n", + " # input_data:[1.1, 2.2]\n", + " probabilities = {}\n", + " for label, value in self.model.items():\n", + " probabilities[label] = 1\n", + " for i in range(len(value)):\n", + " mean, stdev = value[i]\n", + " probabilities[label] *= self.gaussian_probability(input_data[i], mean, stdev)\n", + " return probabilities\n", + "\n", + " # 类别\n", + " def predict(self, X_test):\n", + " # {0.0: 2.9680340789325763e-27, 1.0: 3.5749783019849535e-26}\n", + " label = sorted(self.calculate_probabilities(X_test).items(), key=lambda x: x[-1])[-1][0]\n", + " return label\n", + "\n", + " def score(self, X_test, y_test):\n", + " right = 0\n", + " for X, y in zip(X_test, y_test):\n", + " label = self.predict(X)\n", + " if label == y:\n", + " right += 1\n", + "\n", + " return right / float(len(X_test))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "model = NaiveBayes()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'gaussianNB train done!'" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n" + ] + } + ], + "source": [ + "print(model.predict([4.4, 3.2, 1.3, 0.2]))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.0" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.score(X_test, y_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "scikit-learn实例\n", + "\n", + "# sklearn.naive_bayes" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.naive_bayes import GaussianNB" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "GaussianNB(priors=None)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clf = GaussianNB()\n", + "clf.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.0" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clf.score(X_test, y_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clf.predict([[4.4, 3.2, 1.3, 0.2]])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.naive_bayes import BernoulliNB, MultinomialNB # 伯努利模型和多项式模型" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Projects/lihang-code/code/第5章 决策树(DecisonTree)/DT.ipynb b/Projects/lihang-code/code/第5章 决策树(DecisonTree)/DT.ipynb new file mode 100755 index 0000000..709f7b3 --- /dev/null +++ b/Projects/lihang-code/code/第5章 决策树(DecisonTree)/DT.ipynb @@ -0,0 +1,886 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "原文代码作者：https://github.com/wzyonggege/statistical-learning-method\n", + "\n", + "中文注释制作：机器学习初学者(微信公众号：ID:ai-start-com)\n", + "\n", + "配置环境：python 3.6\n", + "\n", + "代码全部测试通过。\n", + "![gongzhong](../gongzhong.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 第5章 决策树" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- ID3（基于信息增益）\n", + "- C4.5（基于信息增益比）\n", + "- CART（gini指数）" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### entropy：$H(x) = -\\sum_{i=1}^{n}p_i\\log{p_i}$\n", + "\n", + "#### conditional entropy: $H(X|Y)=\\sum{P(X|Y)}\\log{P(X|Y)}$\n", + "\n", + "#### information gain : $g(D, A)=H(D)-H(D|A)$\n", + "\n", + "#### information gain ratio: $g_R(D, A) = \\frac{g(D,A)}{H(A)}$\n", + "\n", + "#### gini index:$Gini(D)=\\sum_{k=1}^{K}p_k\\log{p_k}=1-\\sum_{k=1}^{K}p_k^2$" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from sklearn.datasets import load_iris\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "from collections import Counter\n", + "import math\n", + "from math import log\n", + "\n", + "import pprint" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 书上题目5.1" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# 书上题目5.1\n", + "def create_data():\n", + " datasets = [['青年', '否', '否', '一般', '否'],\n", + " ['青年', '否', '否', '好', '否'],\n", + " ['青年', '是', '否', '好', '是'],\n", + " ['青年', '是', '是', '一般', '是'],\n", + " ['青年', '否', '否', '一般', '否'],\n", + " ['中年', '否', '否', '一般', '否'],\n", + " ['中年', '否', '否', '好', '否'],\n", + " ['中年', '是', '是', '好', '是'],\n", + " ['中年', '否', '是', '非常好', '是'],\n", + " ['中年', '否', '是', '非常好', '是'],\n", + " ['老年', '否', '是', '非常好', '是'],\n", + " ['老年', '否', '是', '好', '是'],\n", + " ['老年', '是', '否', '好', '是'],\n", + " ['老年', '是', '否', '非常好', '是'],\n", + " ['老年', '否', '否', '一般', '否'],\n", + " ]\n", + " labels = [u'年龄', u'有工作', u'有自己的房子', u'信贷情况', u'类别']\n", + " # 返回数据集和每个维度的名称\n", + " return datasets, labels" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "datasets, labels = create_data()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "train_data = pd.DataFrame(datasets, columns=labels)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
年龄有工作有自己的房子信贷情况类别
0青年否否一般否
1青年否否好否
2青年是否好是
3青年是是一般是
4青年否否一般否
5中年否否一般否
6中年否否好否
7中年是是好是
8中年否是非常好是
9中年否是非常好是
10老年否是非常好是
11老年否是好是
12老年是否好是
13老年是否非常好是
14老年否否一般否
\n", + "
" + ], + "text/plain": [ + " 年龄 有工作 有自己的房子 信贷情况 类别\n", + "0 青年 否 否 一般 否\n", + "1 青年 否 否 好 否\n", + "2 青年 是 否 好 是\n", + "3 青年 是 是 一般 是\n", + "4 青年 否 否 一般 否\n", + "5 中年 否 否 一般 否\n", + "6 中年 否 否 好 否\n", + "7 中年 是 是 好 是\n", + "8 中年 否 是 非常好 是\n", + "9 中年 否 是 非常好 是\n", + "10 老年 否 是 非常好 是\n", + "11 老年 否 是 好 是\n", + "12 老年 是 否 好 是\n", + "13 老年 是 否 非常好 是\n", + "14 老年 否 否 一般 否" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# 熵\n", + "def calc_ent(datasets):\n", + " data_length = len(datasets)\n", + " label_count = {}\n", + " for i in range(data_length):\n", + " label = datasets[i][-1]\n", + " if label not in label_count:\n", + " label_count[label] = 0\n", + " label_count[label] += 1\n", + " ent = -sum([(p/data_length)*log(p/data_length, 2) for p in label_count.values()])\n", + " return ent\n", + "\n", + "# 经验条件熵\n", + "def cond_ent(datasets, axis=0):\n", + " data_length = len(datasets)\n", + " feature_sets = {}\n", + " for i in range(data_length):\n", + " feature = datasets[i][axis]\n", + " if feature not in feature_sets:\n", + " feature_sets[feature] = []\n", + " feature_sets[feature].append(datasets[i])\n", + " cond_ent = sum([(len(p)/data_length)*calc_ent(p) for p in feature_sets.values()])\n", + " return cond_ent\n", + "\n", + "# 信息增益\n", + "def info_gain(ent, cond_ent):\n", + " return ent - cond_ent\n", + "\n", + "def info_gain_train(datasets):\n", + " count = len(datasets[0]) - 1\n", + " ent = calc_ent(datasets)\n", + " best_feature = []\n", + " for c in range(count):\n", + " c_info_gain = info_gain(ent, cond_ent(datasets, axis=c))\n", + " best_feature.append((c, c_info_gain))\n", + " print('特征({}) - info_gain - {:.3f}'.format(labels[c], c_info_gain))\n", + " # 比较大小\n", + " best_ = max(best_feature, key=lambda x: x[-1])\n", + " return '特征({})的信息增益最大，选择为根节点特征'.format(labels[best_[0]])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "特征(年龄) - info_gain - 0.083\n", + "特征(有工作) - info_gain - 0.324\n", + "特征(有自己的房子) - info_gain - 0.420\n", + "特征(信贷情况) - info_gain - 0.363\n" + ] + }, + { + "data": { + "text/plain": [ + "'特征(有自己的房子)的信息增益最大，选择为根节点特征'" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "info_gain_train(np.array(datasets))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "---\n", + "\n", + "利用ID3算法生成决策树，例5.3" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# 定义节点类 二叉树\n", + "class Node:\n", + " def __init__(self, root=True, label=None, feature_name=None, feature=None):\n", + " self.root = root\n", + " self.label = label\n", + " self.feature_name = feature_name\n", + " self.feature = feature\n", + " self.tree = {}\n", + " self.result = {'label:': self.label, 'feature': self.feature, 'tree': self.tree}\n", + "\n", + " def __repr__(self):\n", + " return '{}'.format(self.result)\n", + "\n", + " def add_node(self, val, node):\n", + " self.tree[val] = node\n", + "\n", + " def predict(self, features):\n", + " if self.root is True:\n", + " return self.label\n", + " return self.tree[features[self.feature]].predict(features)\n", + " \n", + "class DTree:\n", + " def __init__(self, epsilon=0.1):\n", + " self.epsilon = epsilon\n", + " self._tree = {}\n", + "\n", + " # 熵\n", + " @staticmethod\n", + " def calc_ent(datasets):\n", + " data_length = len(datasets)\n", + " label_count = {}\n", + " for i in range(data_length):\n", + " label = datasets[i][-1]\n", + " if label not in label_count:\n", + " label_count[label] = 0\n", + " label_count[label] += 1\n", + " ent = -sum([(p/data_length)*log(p/data_length, 2) for p in label_count.values()])\n", + " return ent\n", + "\n", + " # 经验条件熵\n", + " def cond_ent(self, datasets, axis=0):\n", + " data_length = len(datasets)\n", + " feature_sets = {}\n", + " for i in range(data_length):\n", + " feature = datasets[i][axis]\n", + " if feature not in feature_sets:\n", + " feature_sets[feature] = []\n", + " feature_sets[feature].append(datasets[i])\n", + " cond_ent = sum([(len(p)/data_length)*self.calc_ent(p) for p in feature_sets.values()])\n", + " return cond_ent\n", + "\n", + " # 信息增益\n", + " @staticmethod\n", + " def info_gain(ent, cond_ent):\n", + " return ent - cond_ent\n", + "\n", + " def info_gain_train(self, datasets):\n", + " count = len(datasets[0]) - 1\n", + " ent = self.calc_ent(datasets)\n", + " best_feature = []\n", + " for c in range(count):\n", + " c_info_gain = self.info_gain(ent, self.cond_ent(datasets, axis=c))\n", + " best_feature.append((c, c_info_gain))\n", + " # 比较大小\n", + " best_ = max(best_feature, key=lambda x: x[-1])\n", + " return best_\n", + "\n", + " def train(self, train_data):\n", + " \"\"\"\n", + " input:数据集D(DataFrame格式)，特征集A，阈值eta\n", + " output:决策树T\n", + " \"\"\"\n", + " _, y_train, features = train_data.iloc[:, :-1], train_data.iloc[:, -1], train_data.columns[:-1]\n", + " # 1,若D中实例属于同一类Ck，则T为单节点树，并将类Ck作为结点的类标记，返回T\n", + " if len(y_train.value_counts()) == 1:\n", + " return Node(root=True,\n", + " label=y_train.iloc[0])\n", + "\n", + " # 2, 若A为空，则T为单节点树，将D中实例树最大的类Ck作为该节点的类标记，返回T\n", + " if len(features) == 0:\n", + " return Node(root=True, label=y_train.value_counts().sort_values(ascending=False).index[0])\n", + "\n", + " # 3,计算最大信息增益 同5.1,Ag为信息增益最大的特征\n", + " max_feature, max_info_gain = self.info_gain_train(np.array(train_data))\n", + " max_feature_name = features[max_feature]\n", + "\n", + " # 4,Ag的信息增益小于阈值eta,则置T为单节点树，并将D中是实例数最大的类Ck作为该节点的类标记，返回T\n", + " if max_info_gain < self.epsilon:\n", + " return Node(root=True, label=y_train.value_counts().sort_values(ascending=False).index[0])\n", + "\n", + " # 5,构建Ag子集\n", + " node_tree = Node(root=False, feature_name=max_feature_name, feature=max_feature)\n", + "\n", + " feature_list = train_data[max_feature_name].value_counts().index\n", + " for f in feature_list:\n", + " sub_train_df = train_data.loc[train_data[max_feature_name] == f].drop([max_feature_name], axis=1)\n", + "\n", + " # 6, 递归生成树\n", + " sub_tree = self.train(sub_train_df)\n", + " node_tree.add_node(f, sub_tree)\n", + "\n", + " # pprint.pprint(node_tree.tree)\n", + " return node_tree\n", + "\n", + " def fit(self, train_data):\n", + " self._tree = self.train(train_data)\n", + " return self._tree\n", + "\n", + " def predict(self, X_test):\n", + " return self._tree.predict(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "datasets, labels = create_data()\n", + "data_df = pd.DataFrame(datasets, columns=labels)\n", + "dt = DTree()\n", + "tree = dt.fit(data_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'label:': None, 'feature': 2, 'tree': {'否': {'label:': None, 'feature': 1, 'tree': {'否': {'label:': '否', 'feature': None, 'tree': {}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tree" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'否'" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dt.predict(['老年', '否', '否', '一般'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## sklearn.tree.DecisionTreeClassifier\n", + "\n", + "### criterion : string, optional (default=”gini”)\n", + "The function to measure the quality of a split. Supported criteria are “gini” for the Gini impurity and “entropy” for the information gain." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# data\n", + "def create_data():\n", + " iris = load_iris()\n", + " df = pd.DataFrame(iris.data, columns=iris.feature_names)\n", + " df['label'] = iris.target\n", + " df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']\n", + " data = np.array(df.iloc[:100, [0, 1, -1]])\n", + " # print(data)\n", + " return data[:,:2], data[:,-1]\n", + "\n", + "X, y = create_data()\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.tree import DecisionTreeClassifier\n", + "\n", + "from sklearn.tree import export_graphviz\n", + "import graphviz" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=None,\n", + " max_features=None, max_leaf_nodes=None,\n", + " min_impurity_decrease=0.0, min_impurity_split=None,\n", + " min_samples_leaf=1, min_samples_split=2,\n", + " min_weight_fraction_leaf=0.0, presort=False, random_state=None,\n", + " splitter='best')" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clf = DecisionTreeClassifier()\n", + "clf.fit(X_train, y_train,)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.0" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clf.score(X_test, y_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "tree_pic = export_graphviz(clf, out_file=\"mytree.pdf\")\n", + "with open('mytree.pdf') as f:\n", + " dot_graph = f.read()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "Tree\r\n", + "\r\n", + "\r\n", + "0\r\n", + "\r\n", + "X[0] <= 5.45\r\n", + "gini = 0.5\r\n", + "samples = 70\r\n", + "value = [35, 35]\r\n", + "\r\n", + "\r\n", + "1\r\n", + "\r\n", + "X[1] <= 2.85\r\n", + "gini = 0.234\r\n", + "samples = 37\r\n", + "value = [32, 5]\r\n", + "\r\n", + "\r\n", + "0->1\r\n", + "\r\n", + "\r\n", + "True\r\n", + "\r\n", + "\r\n", + "10\r\n", + "\r\n", + "X[1] <= 3.45\r\n", + "gini = 0.165\r\n", + "samples = 33\r\n", + "value = [3, 30]\r\n", + "\r\n", + "\r\n", + "0->10\r\n", + "\r\n", + "\r\n", + "False\r\n", + "\r\n", + "\r\n", + "2\r\n", + "\r\n", + "X[0] <= 4.7\r\n", + "gini = 0.32\r\n", + "samples = 5\r\n", + "value = [1, 4]\r\n", + "\r\n", + "\r\n", + "1->2\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "5\r\n", + "\r\n", + "X[0] <= 5.35\r\n", + "gini = 0.061\r\n", + "samples = 32\r\n", + "value = [31, 1]\r\n", + "\r\n", + "\r\n", + "1->5\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "3\r\n", + "\r\n", + "gini = 0.0\r\n", + "samples = 1\r\n", + "value = [1, 0]\r\n", + "\r\n", + "\r\n", + "2->3\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "4\r\n", + "\r\n", + "gini = 0.0\r\n", + "samples = 4\r\n", + "value = [0, 4]\r\n", + "\r\n", + "\r\n", + "2->4\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "6\r\n", + "\r\n", + "gini = 0.0\r\n", + "samples = 28\r\n", + "value = [28, 0]\r\n", + "\r\n", + "\r\n", + "5->6\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "7\r\n", + "\r\n", + "X[1] <= 3.2\r\n", + "gini = 0.375\r\n", + "samples = 4\r\n", + "value = [3, 1]\r\n", + "\r\n", + "\r\n", + "5->7\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "8\r\n", + "\r\n", + "gini = 0.0\r\n", + "samples = 1\r\n", + "value = [0, 1]\r\n", + "\r\n", + "\r\n", + "7->8\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "9\r\n", + "\r\n", + "gini = 0.0\r\n", + "samples = 3\r\n", + "value = [3, 0]\r\n", + "\r\n", + "\r\n", + "7->9\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "11\r\n", + "\r\n", + "gini = 0.0\r\n", + "samples = 30\r\n", + "value = [0, 30]\r\n", + "\r\n", + "\r\n", + "10->11\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "12\r\n", + "\r\n", + "gini = 0.0\r\n", + "samples = 3\r\n", + "value = [3, 0]\r\n", + "\r\n", + "\r\n", + "10->12\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "graphviz.Source(dot_graph)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Projects/lihang-code/code/第5章 决策树(DecisonTree)/Decision Tree (ID3 剪枝) b/Projects/lihang-code/code/第5章 决策树(DecisonTree)/Decision Tree (ID3 剪枝) new file mode 100755 index 0000000..b7efc7c --- /dev/null +++ b/Projects/lihang-code/code/第5章 决策树(DecisonTree)/Decision Tree (ID3 剪枝) @@ -0,0 +1,206 @@ +import numpy as np +import pandas as pd +from collections import Counter +import math + + +class Node: + def __init__(self, x=None, label=None, y=None, data=None): + self.label = label # label:子节点分类依据的特征 + self.x = x # x:特征 + self.child = [] # child:子节点 + self.y = y # y:类标记（叶节点才有） + self.data = data # data:包含数据（叶节点才有） + + def append(self, node): # 添加子节点 + self.child.append(node) + + def predict(self, features): # 预测数据所述类 + if self.y is not None: + return self.y + for c in self.child: + if c.x == features[self.label]: + return c.predict(features) + + +def printnode(node, depth=0): # 打印树所有节点 + if node.label is None: + print(depth, (node.label, node.x, node.y, len(node.data))) + else: + print(depth, (node.label, node.x)) + for c in node.child: + printnode(c, depth+1) + + +class DTree: + def __init__(self, epsilon=0, alpha=0): # 预剪枝、后剪枝参数 + self.epsilon = epsilon + self.alpha = alpha + self.tree = Node() + + def prob(self, datasets): # 求概率 + datalen = len(datasets) + labelx = set(datasets) + p = {l: 0 for l in labelx} + for d in datasets: + p[d] += 1 + for i in p.items(): + p[i[0]] /= datalen + return p + + def calc_ent(self, datasets): # 求熵 + p = self.prob(datasets) + ent = sum([-v * math.log(v, 2) for v in p.values()]) + return ent + + def cond_ent(self, datasets, col): # 求条件熵 + labelx = set(datasets.iloc[col]) + p = {x: [] for x in labelx} + for i, d in enumerate(datasets.iloc[-1]): + p[datasets.iloc[col][i]].append(d) + return sum([self.prob(datasets.iloc[col])[k] * self.calc_ent(p[k]) for k in p.keys()]) + + def info_gain_train(self, datasets, datalabels): # 求信息增益（互信息） + #print('----信息增益----') + datasets = datasets.T + ent = self.calc_ent(datasets.iloc[-1]) + gainmax = {} + for i in range(len(datasets) - 1): + cond = self.cond_ent(datasets, i) + #print(datalabels[i], ent - cond) + gainmax[ent - cond] = i + m = max(gainmax.keys()) + return gainmax[m], m + + def train(self, datasets, node): + labely = datasets.columns[-1] + if len(datasets[labely].value_counts()) == 1: + node.data = datasets[labely] + node.y = datasets[labely][0] + return + if len(datasets.columns[:-1]) == 0: + node.data = datasets[labely] + node.y = datasets[labely].value_counts().index[0] + return + gainmaxi, gainmax = self.info_gain_train(datasets, datasets.columns) + #print('选择特征：', gainmaxi) + if gainmax <= self.epsilon: # 若信息增益（互信息）为0意为输入特征x完全相同而标签y相反 + node.data = datasets[labely] + node.y = datasets[labely].value_counts().index[0] + return + + vc = datasets[datasets.columns[gainmaxi]].value_counts() + for Di in vc.index: + node.label = gainmaxi + child = Node(Di) + node.append(child) + new_datasets = pd.DataFrame([list(i) for i in datasets.values if i[gainmaxi]==Di], columns=datasets.columns) + self.train(new_datasets, child) + + def fit(self, datasets): + self.train(datasets, self.tree) + + def findleaf(self, node, leaf): # 找到所有叶节点 + for t in node.child: + if t.y is not None: + leaf.append(t.data) + else: + for c in node.child: + self.findleaf(c, leaf) + + def findfather(self, node, errormin): + if node.label is not None: + cy = [c.y for c in node.child] + if None not in cy: # 全是叶节点 + childdata = [] + for c in node.child: + for d in list(c.data): + childdata.append(d) + childcounter = Counter(childdata) + + old_child = node.child # 剪枝前先拷贝一下 + old_label = node.label + old_y = node.y + old_data = node.data + + node.label = None # 剪枝 + node.y = childcounter.most_common(1)[0][0] + node.data = childdata + + error = self.c_error() + if error <= errormin: # 剪枝前后损失比较 + errormin = error + return 1 + else: + node.child = old_child # 剪枝效果不好，则复原 + node.label = old_label + node.y = old_y + node.data = old_data + else: + re = 0 + i = 0 + while i < len(node.child): + if_re = self.findfather(node.child[i], errormin) # 若剪过枝，则其父节点要重新检测 + if if_re == 1: + re = 1 + elif if_re == 2: + i -= 1 + i += 1 + if re: + return 2 + return 0 + + def c_error(self): # 求C(T) + leaf = [] + self.findleaf(self.tree, leaf) + leafnum = [len(l) for l in leaf] + ent = [self.calc_ent(l) for l in leaf] + print("Ent:", ent) + error = self.alpha*len(leafnum) + for l, e in zip(leafnum, ent): + error += l*e + print("C(T):", error) + return error + + def cut(self, alpha=0): # 剪枝 + if alpha: + self.alpha = alpha + errormin = self.c_error() + self.findfather(self.tree, errormin) + + +datasets = np.array([['青年', '否', '否', '一般', '否'], + ['青年', '否', '否', '好', '否'], + ['青年', '是', '否', '好', '是'], + ['青年', '是', '是', '一般', '是'], + ['青年', '否', '否', '一般', '否'], + ['中年', '否', '否', '一般', '否'], + ['中年', '否', '否', '好', '否'], + ['中年', '是', '是', '好', '是'], + ['中年', '否', '是', '非常好', '是'], + ['中年', '否', '是', '非常好', '是'], + ['老年', '否', '是', '非常好', '是'], + ['老年', '否', '是', '好', '是'], + ['老年', '是', '否', '好', '是'], + ['老年', '是', '否', '非常好', '是'], + ['老年', '否', '否', '一般', '否'], + ['青年', '否', '否', '一般', '是']]) # 在李航原始数据上多加了最后这行数据，以便体现剪枝效果 + +datalabels = np.array(['年龄', '有工作', '有自己的房子', '信贷情况', '类别']) +train_data = pd.DataFrame(datasets, columns=datalabels) +test_data = ['老年', '否', '否', '一般'] + +dt = DTree(epsilon=0) # 可修改epsilon查看预剪枝效果 +dt.fit(train_data) + +print('DTree:') +printnode(dt.tree) +y = dt.tree.predict(test_data) +print('result:', y) + +dt.cut(alpha=0.5) # 可修改正则化参数alpha查看后剪枝效果 + +print('DTree:') +printnode(dt.tree) +y = dt.tree.predict(test_data) +print('result:', y) diff --git a/Projects/lihang-code/code/第5章 决策树(DecisonTree)/mytree.pdf b/Projects/lihang-code/code/第5章 决策树(DecisonTree)/mytree.pdf new file mode 100755 index 0000000..7c2a8a2 --- /dev/null +++ b/Projects/lihang-code/code/第5章 决策树(DecisonTree)/mytree.pdf @@ -0,0 +1,28 @@ +digraph Tree { +node [shape=box] ; +0 [label="X[0] <= 5.45\ngini = 0.5\nsamples = 70\nvalue = [35, 35]"] ; +1 [label="X[1] <= 2.85\ngini = 0.234\nsamples = 37\nvalue = [32, 5]"] ; +0 -> 1 [labeldistance=2.5, labelangle=45, headlabel="True"] ; +2 [label="X[0] <= 4.7\ngini = 0.32\nsamples = 5\nvalue = [1, 4]"] ; +1 -> 2 ; +3 [label="gini = 0.0\nsamples = 1\nvalue = [1, 0]"] ; +2 -> 3 ; +4 [label="gini = 0.0\nsamples = 4\nvalue = [0, 4]"] ; +2 -> 4 ; +5 [label="X[0] <= 5.35\ngini = 0.061\nsamples = 32\nvalue = [31, 1]"] ; +1 -> 5 ; +6 [label="gini = 0.0\nsamples = 28\nvalue = [28, 0]"] ; +5 -> 6 ; +7 [label="X[1] <= 3.2\ngini = 0.375\nsamples = 4\nvalue = [3, 1]"] ; +5 -> 7 ; +8 [label="gini = 0.0\nsamples = 1\nvalue = [0, 1]"] ; +7 -> 8 ; +9 [label="gini = 0.0\nsamples = 3\nvalue = [3, 0]"] ; +7 -> 9 ; +10 [label="X[1] <= 3.45\ngini = 0.165\nsamples = 33\nvalue = [3, 30]"] ; +0 -> 10 [labeldistance=2.5, labelangle=-45, headlabel="False"] ; +11 [label="gini = 0.0\nsamples = 30\nvalue = [0, 30]"] ; +10 -> 11 ; +12 [label="gini = 0.0\nsamples = 3\nvalue = [3, 0]"] ; +10 -> 12 ; +} \ No newline at end of file diff --git a/Projects/lihang-code/code/第6章 逻辑斯谛回归(LogisticRegression)/LR.ipynb b/Projects/lihang-code/code/第6章 逻辑斯谛回归(LogisticRegression)/LR.ipynb new file mode 100755 index 0000000..76d9b42 --- /dev/null +++ b/Projects/lihang-code/code/第6章 逻辑斯谛回归(LogisticRegression)/LR.ipynb @@ -0,0 +1,359 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "原文代码作者：https://github.com/wzyonggege/statistical-learning-method\n", + "\n", + "中文注释制作：机器学习初学者(微信公众号：ID:ai-start-com)\n", + "\n", + "配置环境：python 3.6\n", + "\n", + "代码全部测试通过。\n", + "![gongzhong](../gongzhong.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 第6章 逻辑斯谛回归" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "LR是经典的分类方法" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "回归模型：$f(x) = \\frac{1}{1+e^{-wx}}$\n", + "\n", + "其中wx线性函数：$wx =w_0*x_0 + w_1*x_1 + w_2*x_2 +...+w_n*x_n,(x_0=1)$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from math import exp\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from sklearn.datasets import load_iris\n", + "from sklearn.model_selection import train_test_split" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# data\n", + "def create_data():\n", + " iris = load_iris()\n", + " df = pd.DataFrame(iris.data, columns=iris.feature_names)\n", + " df['label'] = iris.target\n", + " df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']\n", + " data = np.array(df.iloc[:100, [0,1,-1]])\n", + " # print(data)\n", + " return data[:,:2], data[:,-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "X, y = create_data()\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "class LogisticReressionClassifier:\n", + " def __init__(self, max_iter=200, learning_rate=0.01):\n", + " self.max_iter = max_iter\n", + " self.learning_rate = learning_rate\n", + " \n", + " def sigmoid(self, x):\n", + " return 1 / (1 + exp(-x))\n", + "\n", + " def data_matrix(self, X):\n", + " data_mat = []\n", + " for d in X:\n", + " data_mat.append([1.0, *d])\n", + " return data_mat\n", + "\n", + " def fit(self, X, y):\n", + " # label = np.mat(y)\n", + " data_mat = self.data_matrix(X) # m*n\n", + " self.weights = np.zeros((len(data_mat[0]),1), dtype=np.float32)\n", + "\n", + " for iter_ in range(self.max_iter):\n", + " for i in range(len(X)):\n", + " result = self.sigmoid(np.dot(data_mat[i], self.weights))\n", + " error = y[i] - result \n", + " self.weights += self.learning_rate * error * np.transpose([data_mat[i]])\n", + " print('LogisticRegression Model(learning_rate={},max_iter={})'.format(self.learning_rate, self.max_iter))\n", + "\n", + " # def f(self, x):\n", + " # return -(self.weights[0] + self.weights[1] * x) / self.weights[2]\n", + "\n", + " def score(self, X_test, y_test):\n", + " right = 0\n", + " X_test = self.data_matrix(X_test)\n", + " for x, y in zip(X_test, y_test):\n", + " result = np.dot(x, self.weights)\n", + " if (result > 0 and y == 1) or (result < 0 and y == 0):\n", + " right += 1\n", + " return right / len(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LogisticRegression Model(learning_rate=0.01,max_iter=200)\n" + ] + } + ], + "source": [ + "lr_clf = LogisticReressionClassifier()\n", + "lr_clf.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9666666666666667" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lr_clf.score(X_test, y_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xl8VPXZ9/HPRQgQEEEWFQgQSBQFBBEUkQoRFypu1BW3lmpF0T62d62t9uljW+4+T7W2te1tgyLeroh6uyBal1oh7KJBEBBEk7AlIEuAsEOW6/ljBggxJCfJmTm/OXO9Xy9eZM4czvx+M3pxOPO9fkdUFWOMMeHSJOgBGGOM8Z8Vd2OMCSEr7sYYE0JW3I0xJoSsuBtjTAhZcTfGmBCy4m6MMSFkxd0YY0LIirsxxoRQ06BeuEOHDpqRkRHUyxtjTEJatGjRVlXtWNd+nou7iKQAeUCxql5e7bmxwKNAcXTT46o6ubbjZWRkkJeX5/XljTHGACKy1st+9Tlz/wmwEjj+GM+/oqo/rsfxjDHGxIina+4ikg5cBtR6Nm6MMcYNXr9Q/SvwC6Cyln2uEZGlIvKaiHStaQcRGScieSKSt2XLlvqO1RhjjEd1XpYRkcuBzaq6SESyj7Hb28BUVT0gIncBzwEjqu+kqpOASQCDBg2ytYaNMYEoKyujqKiI/fv3Bz2UY2rRogXp6emkpqY26M97ueY+FLhSREYBLYDjReRFVb3l0A6qWlJl/6eARxo0GmOMiYOioiJat25NRkYGIhL0cL5FVSkpKaGoqIgePXo06Bh1XpZR1QdVNV1VM4AxwIyqhR1ARDpVeXglkS9ejTHGSfv376d9+/ZOFnYAEaF9+/aN+pdFg3PuIjIByFPV6cC9InIlUA5sA8Y2eETGGBMHrhb2Qxo7vnoVd1XNBXKjPz9UZfuDwIONGokxITJtcTGPfrCKDTv20bltGveP7MXoAV2CHpZJIrb8gDE+m7a4mAffWEbxjn0oULxjHw++sYxpi4vr/LMmebz//vv06tWLrKwsHn74Yd+Pb8XdGJ89+sEq9pVVHLVtX1kFj36wKqARGddUVFRwzz338N5777FixQqmTp3KihUrfH2NwNaWMSasNuzYV6/txn1+X2b75JNPyMrKomfPngCMGTOGt956i969e/s1ZDtzN8Zvndum1Wu7cVssLrMVFxfTteuRXs/09HSKi/29bGfF3Rif3T+yF2mpKUdtS0tN4f6RvQIakWmMWFxmU/12D6ff6R27LGOMzw79c93SMuEQi8ts6enprF+//vDjoqIiOnfu3ODj1cSKuzExMHpAFyvmIdG5bRrFNRTyxlxmO/vss/n6669ZvXo1Xbp04eWXX+all15qzDC/xS7LGGNMLWJxma1p06Y8/vjjjBw5ktNPP53rr7+ePn36NHaoR7+Gr0czxpiQidVltlGjRjFq1Cg/hlgjK+7GGFOHRLzMZpdljDEmhKy4G2NMCFlxN8aYELLibowxIWTF3RhjQsiKuzFE1g8Z+vAMejzwT4Y+PMOW5zUxd9ttt3HiiSfSt2/fmBzfirtJerb+ugnC2LFjef/992N2fCvuJunZ+uumTktfhcf6wm/bRn5f+mqjDzls2DDatWvnw+BqZk1MJunZ+uumVktfhbfvhbLofw+l6yOPAfpdH9y46mBn7ibp2frrplYfTThS2A8p2xfZ7jAr7ibp2frrplalRfXb7gi7LGOSnq2/bmrVJj1yKaam7Q6z4m4MibkwlImTCx86+po7QGpaZHsj3HjjjeTm5rJ161bS09P53e9+x+23397IwR5hxd0YY2pz6EvTjyZELsW0SY8U9kZ+mTp16lQfBndsVtyNU/y+y7wxvuh3vdPJmJpYcTfOONRMdChzfqiZCLACb0w9WVrGOMOaiUw8qWrQQ6hVY8dnxd04w5qJTLy0aNGCkpISZwu8qlJSUkKLFi0afAy7LGOcEYu7zBtTk/T0dIqKitiyZUvQQzmmFi1akJ7e8LilFXfjjPtH9jrqmjtYM5GJjdTUVHr06BH0MGLKirtxhjUTGeMfz8VdRFKAPKBYVS+v9lxz4HlgIFAC3KCqa3wcp0kS1kxkjD/qc+b+E2AlcHwNz90ObFfVLBEZAzwC3ODD+IwJNcv1m1jxlJYRkXTgMmDyMXa5Cngu+vNrwIUiIo0fnjHhZTcJMbHkNQr5V+AXQOUxnu8CrAdQ1XKgFGjf6NEZE2KW6zexVGdxF5HLgc2quqi23WrY9q0AqYiME5E8EclzOYJkTDxYrj95LFq7jfzNu+P6ml7O3IcCV4rIGuBlYISIvFhtnyKgK4CINAXaANuqH0hVJ6nqIFUd1LFjx0YN3JhEZzcJCTdVJXfVZq5/cgHXTFzAk7MK4vr6dRZ3VX1QVdNVNQMYA8xQ1Vuq7TYd+EH052uj+7jZ+mWMI+wmIeFUUan8c+lGLv+vuYx95lPWb9vLQ5f35ndX9YnrOBqccxeRCUCeqk4HngZeEJF8ImfsY3wanzGhZbn+cDlYXsmbi4t4clYhhVv30LNDK/54TT9GD+hCs6bxX+lFgjrBHjRokObl5QXy2sYY45e9B8t5aeE6Js9ZzTc799O3y/HcnZ3FyD4nk9LE/9CgiCxS1UF17WcdqibUfj1tGVMXrqdClRQRbhzcld+PPiPoYZkQ2LH3IM/NX8uz81ezfW8Zg3u044/X9uP8UzrgQhLcirsJrV9PW8aLH687/LhC9fBjK/CmoTbt3M/kOYW8tHAdew5WcNHpJzI+O4uB3U8IemhHseJuQmvqwhpuahzdbsXd1Nfakj08MauQ1xcVUV5ZyRX9OzM+O5PTTq6paT94VtxNaFUc4/ukY203piYrN+4kJ7eAfy7dQNOUJlw3KJ07h2XSrX3LoIdWKyvuJrRSRGos5CkOXA817stbs42c3AJmfLmZVs1SuOP8ntz+nR6ceHzDb6ART1bcTWjdOLjrUdfcq243piaqyqyvtpAzs4BP1myjXatm3HfxqXx/SAZtWqYGPbx6seJuQuvQdXVLy5i6VFQq7y3fyMTcAr7YsJNObVrwmyt6c8PZXWnZLDHLpOXcjTFJ60B5BW9+VsyTswtZvXUPPTu24q7hmYw+M5jGIy8s526ccvNTC5hXcGS5oaGZ7Zhyx5AARxRbtk672/YcKGfqJ0caj87o0oaJN5/FJTFqPAqCFXcTc9ULO8C8gm3c/NSCUBb4Q+u0H1rO99A67YAV+IDt2HuQZ+ev4dn5a9ixt4xze7rVeOQnK+4m5qoX9rq2J7ra1mm34h6Mb0qjjUefrGPvwQouOv0k7r4gk7O6udV45Ccr7sb4zNZpd8earXt4cnYBry8qpkKVK/p1Ynx2Fr1Obh300GLOirsxPuvcNo3iGgq5rdMePys27GTirCONR9efnc64891vPPKTFXcTc0Mz29V4CWZoZrsARhN794/sddQ1d7B12uPl0zXbyJmZz8xVWziueVPuGBZtPGqdGI1HfrLibmJuyh1DkiotY+u0x5eqkvvVFnJm5vPpmu20a9WMn19yKrcOyaBNWmI1HvnJcu7GmIRUUam8uyzSeLRi4046t2nBHcN6MubsbqQ1S6n7AAnKcu7GKX7nvr0ez/Lm4XOgvII3PivmyVkFrCnZS2bHVjx6bT+ucrjxKAhW3E3M+Z379no8y5uHy6HGo6fmFLJp5wHO6NKGJ245i0t6n0yTkDQe+cmKu4k5v3PfXo9nefNw2L4n0nj03IJI49GQnu3503X9+U5W+BqP/GTF3cSc37lvr8ezvHliq954dHHvkxifHe7GIz9ZcTcx53fu2+vxLG+emFZv3cOTswp4/bMiKhWu7N+Zu4ZnJkXjkZ/s2wcTc/eP7EVa6tHphcbkvr0ez+/XNbH1xYZSfvzSZ1z451zeWFzMmLO7kfvzbB674Uwr7A1gZ+4m5vzOfXs9nuXNE8Mnq7eRk5tPbrTxaNywTG77TkZSNh75yXLuxpi4U1VyV20hJzfSeNS+VTNu+04Pbjm3e1I3HnlhOfeQcD2n7fr4jFsqKpV/RhuPVm7cSZe2afz2it7cEPLGoyBYcXeY6zlt18dn3HGo8eiJWQWsjTYe/em6/lx1ZmdSU+yrv1iw4u4w13Paro/PBG/PgXJeWriOyXMjjUf90tvwxC0DuaT3SdZ4FGNW3B3mek7b9fGZ4Gzfc5Bn5q/huflrKN1XxnmZ7fnzdWcyNKu9NR7FiRV3h7me03Z9fCb+vindz1NzCpkabTy6JNp4NMAaj+LOirvDXF8X3PXxmfhZvXUPT+QW8MbiSOPRVf07c1d2JqeeZPn0oFhxd5jrOW3Xx2dib3lxKRNnFfDuso00S2nCmLO7MW5YT7q2S547Hrmqzpy7iLQAZgPNifxl8Jqq/qbaPmOBR4Hi6KbHVXVybce1nLsxieuT1dv4x8x8Zn21hdbNm3LLkO7cNrQHHVs3D3pooednzv0AMEJVd4tIKjBXRN5T1Y+r7feKqv64IYM1ievX05YxdeF6KlRJEeHGwV35/egzGrxfULl5y+vXTVWZuWozOTMLyFsbaTy6f2QvazxyVJ3FXSOn9rujD1Ojv4JpazVO+fW0Zbz48brDjytUDz+uWri97hdUbt7y+rUrr6g83Hj05Te76NI2jd9d2YfrB3W1xiOHeeoeEJEUEVkCbAY+VNWFNex2jYgsFZHXRKSrr6M0Tpq6cL2n7V73qy03H0tBva7rDpRX8NLCdYz48yx+8vISyiuVP1/Xn9z7s/nBeRlW2B3n6QtVVa0AzhSRtsCbItJXVZdX2eVtYKqqHhCRu4DngBHVjyMi44BxAN26dWv04E2wKo7xfU317V73Cyo3b3n9o+0+UM5LC9cyec5qNu86QP/0NvxqlDUeJZp6pWVUdYeI5ALfBZZX2V5SZbengEeO8ecnAZMg8oVqfQdr3JIiUmPhTqnWpOJ1v6By85bXj9i25yDPzlvNcwvWUrqvjKFZ7XnshjM5L9MajxJRnZdlRKRj9IwdEUkDLgK+rLZPpyoPrwRW+jlI46YbB9d89a36dq/7BbX+erKv+76xdB8T3l7B0Idn8PcZ+Qzu0Y5p9wxlyo/OZajdyi5heTlz7wQ8JyIpRP4yeFVV3xGRCUCeqk4H7hWRK4FyYBswNlYDNu449GVoXSkYr/sFlZtP1rx+4ZbdPDGrgDcXF0caj87szPjhmZxijUehYOu5G5NklheXMjG3gHeXRxqPbji7K3ecb41HicLWcw8Jv/PXXvPmfh/P6zxcn6/zlr4KH02A0iJokw4XPgT9rkdVI41HuQXMjjYejR+eyQ+t8Si0rLg7zO/8tde8ud/H8zoP1+frvKWvwtv3Qln0y+HS9ej0e5lRnELOmk4sWrudDsdFGo9uHdKd41tY41GY2Sr5DvM7f+01b+738bzOw/X5Ou+jCYcLe7k24a2KIVy65zfcPqsF35TuZ8JVfZj7yxHcc0GWFfYkYGfuDvM7f+01b+738bzOw/X5Oq+0iP2ayusV5/NkxRWs05PIkiL+kjqRK+6fbnc8SjJW3B3md/7aa97c7+N5nYfr83XZ7gPlTGl6E5N3n8cWTqC/5PO/U6dwcZNFNGmbDlbYk4594g7zO3/tNW/u9/G8zsP1+bpo256D/OVfqzjvDx/xh92X0StlAy+l/p5pzR5iZEoeTZq1iHypapKOnbk7zO/8tde8ud/H8zoP1+frkg079vHUnEJe/mQ9+8oqGNnnJO7OzqL/9j3w0S4olaPSMib5WM7dmARSsGU3T+QWMG1JMapw1ZldGJ/dk6wTrfEoWVjO3cRFUPn1ZLO8uJSc3HzeW/4NzVKacNM53bhjWE/ST3Ck8egY+XoTHCvupsGCyq8nC1VlYfSOR3O+3krrFk25OzvSeNThOIcaj2rI1/P2vZGfrcAHxoq7abDaculVi7bX/UxEZaUy48vN5OTm89m6HXQ4rhm/+G7kjkdO5tOr5OsPK9sX2W7FPTBW3E2DBZVfD6tDdzzKmVnAqk27SD8hjf+8qg/XDepKi1SHb4xRWlS/7SYurLibBgsqvx42+8sqeG1REZNmF7Ju215OOfE4/nJ9f67o3zkxGo/apEcuxdS03QQmAf7LMa4KKr8eFrv2l/HErALO/+NMfj1tOe1aNWPSrQP54KfDuPqs9MQo7BD58jS12l/UqWmWrw+YnbmbBgsqv57oSnYf4Nn5a3hu/hp27i/nO1kd+NuYMxnSM0HveHTourqlZZxiOXdj4mTDjn1Mml3Iy5+u40B5JSN7n8z47Ez6d20b9NBMArGce0D8znN7PV5Q65Zbfr1u+ZsjdzyatrgYiPxL5q7h9Ww8ClOOPExz8SKg+Vpx95HfeW6vxwtq3XLLr9duWVGk8ej9L76hedMm3HJud+4Y1pMu9f0iOUw58jDNxYsA55sg39gkBr/XI/d6vKDWLfd7vmGgqiwoKOHWpxdyxeNzmZu/lXuys5j7yxH89so+9S/sUHuOPNGEaS5eBDhfO3P3kd95bq/HC2rdcsuvH1FZqXwUbTxavG4HHY5rzi+/exq3nNuN1o1tPApTjjxMc/EiwPlacfeR33lur8cLat1yy69HGo/eWbqRnNx8vtq0O9J4NLov1w1M96/xKEw58jDNxYsA52uXZXzkd57b6/GCWrc8mfPr+8sqeOHjtVzw51x++soSAB67oT+5P8/m1nO7+9tRGqYceZjm4kWA87Uzdx/5nef2eryg1i1Pxvz6rv1lTFm4jslzVrN19wEGdGvLQ5f34cLTTqRJkxj9SylMOfIwzcWLAOdrOXdjPCjZfYBn5q3h+QWRxqPzT+nA3dlZnNuzXWI2HpmEZTn3kAgqN3/zUwuYV7Dt8OOhme2YcseQBr9uoiresY+nqjQefbdPpPGoX7o1HiWcd34Gi54FrQBJgYFj4fK/NPx4juf1rbg7LKjcfPXCDjCvYBs3P7UgaQp89caj7w3owp3DM8k68biAR2Ya5J2fQd7TRx5rxZHHDSnwCZDXty9UHRZUbr56Ya9re5gsLdrBXS8s4uLHZvHO0g3ccm53Zv3iAh69rr8V9kS26Nn6ba9LAuT17czdYUHl5pONqrKgsISJuQWH73j04wuyGHteBu1duuORaTitqN/2uiRAXt+Ku8OCys0ni8pK5d8rN5GTW8CS9ZHGowcuPY2bB/vQeGTcIik1F3JpYGQ1AfL6dlnGYUHl5odmtqvxzx9re6Ipr6jkzcVFfPdvsxn3wiJK9hzg96P7MveXF3DX8Ewr7GE0cGz9ttclAfL6dubusKBy81PuGBLKtMz+sgr+J289T84upGj7Pnqd1Jq/3nAml/frRNNEuTGGaZhDX5r6lZZJgLx+nTl3EWkBzAaaE/nL4DVV/U21fZoDzwMDgRLgBlVdU9txLedu4mXX/jJe/HgdT8+NNB6d1a0td2dnMSKWjUfGxIifOfcDwAhV3S0iqcBcEXlPVT+uss/twHZVzRKRMcAjwA0NGrmjvObDXV/f3Ou672GY79bdB3jmzXd5fkUFuzSN85t9xT0XdmXwRaMa3njkNSvtdwba9eMFyetcwjRnD+os7ho5td8dfZga/VX9dP8q4LfRn18DHhcR0aDaX33mNR/u+vrmXtd9T/T5Fm3fy1OzC3nlkzUcqGjKpU0WMz51Omc0WQ2fpMFJlQ37n9prVtrvDLTrxwuS17mEac4eebrQKCIpIrIE2Ax8qKoLq+3SBVgPoKrlQCnQ3s+BBslrPtz19c29rvueqPPN37yL+179nOxHc5mycB1XpObx72b3k9Psb5HCDo3LInvNSvudgXb9eEHyOpcwzdkjT1+oqmoFcKaItAXeFJG+qrq8yi41/Rv3W2ftIjIOGAfQrVu3Bgw3GF7z4a7nyL2u+55o8/18/Q5ycvP514pNNG/ahFuHdOeO83vS+a83QZMa5tzQLLLXrLTfGWjXjxckr3MJ05w9qldEQFV3ALnAd6s9VQR0BRCRpkAb4FvtjKo6SVUHqeqgjh07NmjAQThWDrz6dq/7BeVY67tX354I81VV5udv5ZbJC7nqH/NYUFDCjy/IYt4vR/CbK/pExnCszHFDs8jHykRX3+7367p+vCB5nUuY5uxRncVdRDpGz9gRkTTgIuDLartNB34Q/flaYEZYrreD93y46+ube1333eX5VlYqH3zxDaNz5nPT5IWs2rSLBy89jXkPjOC+S3od3VHqdxbZa1ba79d1/XhB8jqXMM3ZIy+XZToBz4lICpG/DF5V1XdEZAKQp6rTgaeBF0Qkn8gZ+5iYjTgAXvPhrq9v7nXddxfnW1ZRydufb2BibgFfb95N13Zp/H50X66t7Y5HfmeRvWal/X5d148XJK9zCdOcPbL13I3T9pdV8Greep6cVUjxjn2cdnJrxmdnctkZ1nhkkpOt5x4Ql3PfiWTn/jJe/Hgt/z13NVt3H+Ssbm2ZcFUfRpx2YrA3x3A9U+33+GIxD8vsx4UVdx+5mvtOJFt3H+C/567mhQVr2XWgnGGnduTu7EwG93DgjkeuZ6r9Hl8s5mGZ/bixyzI+GvrwjBpXXezSNo15D4wIYESJo2j7XibNLuSVT9dzsKKSUX07MT47k75d2gQ9tCMe63uMlQC7wn8sr/9+ro8vFvPw+5hBvdcBsssyAXAl951Ivt60i4mzCpi+ZAMiR+54lNnRwRtjuJ6p9nt8sZiHZfbjxoq7j2y9dO+WrN9BzsxI41FaagrfH5LBj87v4fZ75XUN76DW+vZ7fLGYh9/HTIB11YNicQMfuZ5zD5qqMi9/KzdP/pjR/5jHx4Ul3Dsii3kPjOChK3q7XdjB/Uy13+OLxTwssx83dubuI9dz7kGprFQ+jN7x6PP1OzixdXN+Neo0bhrcneOaJ9B/gq5nqv0eXyzmYZn9uLEvVE3MlFVUMn3JBp6YFWk86tauJXcO78k1Z9XSeGSMqZV9oWoCU1Pj0d/GnJlcjUde130PiuvjA/d7BRxnxd34Zuf+Ml5YsJZn5kUajwZ2P4H/HN2HC3oF3HgUb17XfQ+K6+MD93sFEoBdljGNtmXXAf573mpejDYeDY82Hp3jQuNREH7XrublgSUFfvOtxVLjz/Xxgfu9AgGyyzIm5tZv28tTc6o0Hp3RifHDHWs8CoLXdd+D4vr4wP1egQRgxd3U29ebdjExt4C3Pt9AE4GrB6Rz5/Ce9HSx8SgIknLsM2MXuD4+cL9XIAEkybdbxg+L123njufzuPix2by3/BvGnpfB7F9cwCPX9rPCXpXXdd+D4vr4wP1egQRgZ+6mVpHGoxJycvOZX1BCm7RU7r3wFMael0G7Vs2CHp6bvK77HhTXxwfu9wokAPtC1dSoslL514pNTMzN5/OiUk5s3Zw7zu/JjYO7JVbjkTEhY1+omgYpq6jkrWjjUf7m3XRv35L/970zuGZgF5o3jcM1Wdczxn6Pz++8uevvn4kbK+4GgH0HI41Hk2YfaTz6+40DGNX35Pg1HrmeMfZ7fH7nzV1//0xc2WWZJFe678gdj0r2HGRQ9xO4+4LMYBqPXM8Y+z0+v/Pmrr9/xhd2WcbUasuuAzw9dzVTPo40HmX36sjd2Vmc06NdcINyPWPs9/j8zpu7/v6ZuLLinmTWb4ve8ShvPWWuNR65njH2e3x+581df/9MXFnOPUl8tWkX//HKErL/lMvLn67j6gFdmHFfNv+46Sw3Cju4nzH2e3x+581df/9MXNmZe8gtXrednNwCPlyxiZbNUvjheRn86PyenNymRdBD+zbXM8Z+j8/vvLnr75+JK/tCNYRUlbn5W8mZWcCCwkjj0djzMhh7XgYnWOORMQnNvlBNQpHGo2/IyS1gaVEpJx3fnF9fdjo3ntONVtZ4VDu/8+Fej2e5dBMj9n98CJRVVDJtcTFPzCqgYMseMtq35A9Xn8HVZ8Wp8SjR+Z0P93o8y6WbGLLLMgls38EKXvl0HZNmF7KhdD+ndzqeu7MzGXVGJ1KaJOE66g3ldz7c6/Esl24awC7LhFjpvjJeWLCGZ+atoWTPQc7OOIH/+70zyO7VMTlvjtFYfufDvR7Pcukmhqy4J5DNu/ZHG4/WsftAORf06sjdF2RxdkaAjUdh4Hc+3OvxLJduYsiKewJYv20vT84u4NW8IsoPNR5lZ9KnsyP59ER34UNHX/uGxuXDvR7P79c1pgor7g5b9c0uJubm8/bSjaSIcM3ALtw5LJOMDq2CHlq4+J0P93o8y6WbGKrzC1UR6Qo8D5wMVAKTVPVv1fbJBt4CVkc3vaGqE2o7rn2hemyfrdtOzswC/r0y0nh08+Bu3P4dRxuPjDFx5ecXquXAfar6mYi0BhaJyIequqLafnNU9fKGDNZEGo/mfL2VnNx8Pi7cRtuWqfz0olP4wZCQNB65nue2XHrj2PvinDqLu6puBDZGf94lIiuBLkD14m4aoLJS+eCLSOPRsuKQNh65nue2XHrj2PvipHrl3EUkA5gN9FXVnVW2ZwOvA0XABuDnqvpFbcdK9ssyB8srmbYk0nhUGG08umt4Jt8LY+OR63luy6U3jr0vceV7zl1EjiNSwH9atbBHfQZ0V9XdIjIKmAacUsMxxgHjALp16+b1pUNl38EKXv50HU9VaTz6rxsHhLvxyPU8t+XSG8feFyd5Ku4ikkqksE9R1TeqP1+12KvquyKSIyIdVHVrtf0mAZMgcubeqJEnmNK9ZTy/YA3PzF/Dtj0HOSejHf/36jPIPjUJGo9cz3NbLr1x7H1xUp3ruUuk8jwNrFTVGtciFZGTo/shIudEj1vi50AT1ead+/nDuysZ+sgM/vzhV5zZtS2v3TWEV+8aEsyt7ILg+jrjXsfn+jyCYu+Lk7ycuQ8FbgWWiciS6LZfAd0AVPUJ4FpgvIiUA/uAMRrUojWOWFcSaTz6n0WRxqPL+nVm/PBMenc+PuihxZ/reW7LpTeOvS9OsoXDfPblNzuZmFvAO4cbj9K5c1hPazwyxvjCFg6Ls0VrtzMxN59/r9xMy2Yp3DY0csejk45P0MajZMstv/Mz/+6IZIwDrLg3gqoy++ut5MzMZ+HqSOPRf1x0Kj84rzttWyZw41Gy5Zbf+RnkPX3ksVYceWwF3iQoK+4NUHG48ShI8O3rAAAJcUlEQVSf5cU7Ofn4FuFqPPpowtGLWUHk8UcTwlncFz177O1W3E2CCkElip+D5UfueFS4dQ89OrTikWvOYPSAkDUeJVtuWSvqt92YBGDF3YO9B8uZ+sl6Js8pZGPpfnp3Op7HbxrApX1D2niUbLllSam5kEuI/sI2SceKey1K95bx3II1PDNvNdv3lnFOj3b84eozGB72xqNkW2d84Nijr7lX3W5MgrLiXoPNO/czee5qpny8lj0HK7jwtBO5+4JMBnZPkjseJVtu+dB1dUvLmBCxnHsVa0v28OTsQl7LK6K8spLL+3VmfHYmp3dKwsYjY4yTLOdeDys3Hmo82kDTJk24dlCk8ah7+9g1Hk1bXMyjH6xiw459dG6bxv0jezF6QJeYvV7MhCUPH5Z5BMXeP+ckdXFftHYbOTML+OjLzbRqlsKPzu/J7d/pEfPGo2mLi3nwjWXsK4t8iVe8Yx8PvrEMILEKfFjy8GGZR1Ds/XNS0l2WUVVmfbWFnNwCPlm9jRNapvLDoT34/pD4NR4NfXgGxTv2fWt7l7ZpzHtgRFzG4IuwrOMdlnkExd6/uLLLMtVUVCrvL480Hn2xIdJ49H8u782N53SlZbP4vg0baijstW13Vljy8GGZR1Ds/XNS6Iv7wfJK3lxcxJOzCincuoeeHVrxx2v6MXpAF5o1rXPF45jo3DatxjP3zm3TatjbYWHJw4dlHkGx989JwVS3ONh7sJzJcwoZ9seZ/PL1ZaQ1S+EfN53Fhz8bzvVndw2ssAPcP7IXaalHN8ikpaZw/8heAY2ogcKyjndY5hEUe/+cFLoz9x17D/Lc/LU8Oz/SeDS4RzseubYfw07p4Ezj0aEvTRM+LROWPHxY5hEUe/+cFJovVDft3M/kOYW8tHBdcjYeGWOSQtJ8obq2ZA9PzCrk9UWRxqMr+kcaj0472RqPTBLyO29u+fWElbDFfeXGneTkFvDPODYeGeM0v/Pmll9PaAlX3Fds2Mmf/rWKGdHGozuijUcnJuodj4zxi9/r8Cfbuv4hk3DFfcfegyxet537Lj6V7w/JoE3L1KCHZIwb/M6bW349oSVccR+S2Z75D1xIWjNba9uYo/idN7f8ekJLuJy7iFhhN6YmfufNLb+e0BKuuBtjjqHf9XDF3yNruiCR36/4e8Ovj/t9PBNXocm5G2NMMvCac7czd2OMCSEr7sYYE0JW3I0xJoSsuBtjTAhZcTfGmBCy4m6MMSFkxd0YY0LIirsxxoRQncVdRLqKyEwRWSkiX4jIT2rYR0Tk7yKSLyJLReSs2AzXOGfpq/BYX/ht28jvS18NekTGGLwtHFYO3Keqn4lIa2CRiHyoqiuq7HMpcEr012BgYvR3E2a23rcxzqrzzF1VN6rqZ9GfdwErgeo3+7wKeF4jPgbaikgn30dr3FLbet/GmEDV65q7iGQAA4CF1Z7qAlRdG7SIb/8FgIiME5E8EcnbsmVL/UZq3GPrfRvjLM/FXUSOA14HfqqqO6s/XcMf+daKZKo6SVUHqeqgjh071m+kxj3HWtfb1vs2JnCeiruIpBIp7FNU9Y0adikCulZ5nA5saPzwjNNsvW9jnOUlLSPA08BKVf3LMXabDnw/mpo5FyhV1Y0+jtO4yNb7NsZZXtIyQ4FbgWUisiS67VdANwBVfQJ4FxgF5AN7gR/6P1TjpH7XWzE3xkF1FndVnUvN19Sr7qPAPX4NyhhjTONYh6oxxoSQFXdjjAkhK+7GGBNCVtyNMSaErLgbY0wIWXE3xpgQsuJujDEhJJGIegAvLLIFWNvAP94B2OrjcIIUlrnYPNwSlnlAeObi1zy6q2qdi3MFVtwbQ0TyVHVQ0OPwQ1jmYvNwS1jmAeGZS7znYZdljDEmhKy4G2NMCCVqcZ8U9AB8FJa52DzcEpZ5QHjmEtd5JOQ1d2OMMbVL1DN3Y4wxtXC+uItIiogsFpF3aniuuYi8IiL5IrIweo9XJ9Uxj7EiskVElkR//SiIMXohImtEZFl0nHk1PC8i8vfoZ7JURM4KYpx18TCPbBEprfKZOHl7KRFpKyKviciXIrJSRIZUez5RPo+65pEon0evKmNcIiI7ReSn1faJy2fi5WYdQfsJsBI4vobnbge2q2qWiIwBHgFuiOfg6qG2eQC8oqo/juN4GuMCVT1WXvdS4JTor8HAxOjvLqptHgBzVPXyuI2mYf4GvK+q14pIM6BltecT5fOoax6QAJ+Hqq4CzoTICR1QDLxZbbe4fCZOn7mLSDpwGTD5GLtcBTwX/fk14MLobQGd4mEeYXIV8LxGfAy0FZFOQQ8qjETkeGAYkdtgoqoHVXVHtd2c/zw8ziMRXQgUqGr1Zs24fCZOF3fgr8AvgMpjPN8FWA+gquVAKdA+PkOrl7rmAXBN9J9or4lI11r2C5oC/xKRRSIyrobnD38mUUXRba6pax4AQ0TkcxF5T0T6xHNwHvUEtgDPRC/5TRaRVtX2SYTPw8s8wP3Po7oxwNQatsflM3G2uIvI5cBmVV1U2241bHMq/uNxHm8DGaraD/g3R/414qKhqnoWkX9a3iMiw6o97/xnElXXPD4j0ubdH/gvYFq8B+hBU+AsYKKqDgD2AA9U2ycRPg8v80iEz+Ow6KWlK4H/qenpGrb5/pk4W9yJ3Jj7ShFZA7wMjBCRF6vtUwR0BRCRpkAbYFs8B+lBnfNQ1RJVPRB9+BQwML5D9E5VN0R/30zkWuI51XY5/JlEpQMb4jM67+qah6ruVNXd0Z/fBVJFpEPcB1q7IqBIVRdGH79GpEhW38f1z6POeSTI51HVpcBnqrqphufi8pk4W9xV9UFVTVfVDCL/vJmhqrdU22068IPoz9dG93HqrMTLPKpdb7uSyBevzhGRViLS+tDPwCXA8mq7TQe+H00EnAuUqurGOA+1Vl7mISInH/r+RkTOIfL/Skm8x1obVf0GWC8ivaKbLgRWVNvN+c/DyzwS4fOo5kZqviQDcfpMEiEtcxQRmQDkqep0Il/AvCAi+UTO2McEOrh6qDaPe0XkSqCcyDzGBjm2WpwEvBn9f6wp8JKqvi8idwGo6hPAu8AoIB/YC/wwoLHWxss8rgXGi0g5sA8Y49qJQ9T/AqZELwMUAj9MwM8D6p5HonweiEhL4GLgzirb4v6ZWIeqMcaEkLOXZYwxxjScFXdjjAkhK+7GGBNCVtyNMSaErLgbY0wIWXE3xpgQsuJujDEhZMXdGGNC6P8DrXoM1rj8MesAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x_ponits = np.arange(4, 8)\n", + "y_ = -(lr_clf.weights[1]*x_ponits + lr_clf.weights[0])/lr_clf.weights[2]\n", + "plt.plot(x_ponits, y_)\n", + "\n", + "#lr_clf.show_graph()\n", + "plt.scatter(X[:50,0],X[:50,1], label='0')\n", + "plt.scatter(X[50:,0],X[50:,1], label='1')\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## sklearn\n", + "\n", + "### sklearn.linear_model.LogisticRegression\n", + "\n", + "solver参数决定了我们对逻辑回归损失函数的优化方法，有四种算法可以选择，分别是：\n", + "- a) liblinear：使用了开源的liblinear库实现，内部使用了坐标轴下降法来迭代优化损失函数。\n", + "- b) lbfgs：拟牛顿法的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。\n", + "- c) newton-cg：也是牛顿法家族的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。\n", + "- d) sag：即随机平均梯度下降，是梯度下降法的变种，和普通梯度下降法的区别是每次迭代仅仅用一部分的样本来计算梯度，适合于样本数据多的时候。" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "clf = LogisticRegression(max_iter=200)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n", + " intercept_scaling=1, max_iter=200, multi_class='ovr', n_jobs=1,\n", + " penalty='l2', random_state=None, solver='liblinear', tol=0.0001,\n", + " verbose=0, warm_start=False)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clf.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9666666666666667" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clf.score(X_test, y_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 1.94474283 -3.29077674]] [-0.53064339]\n" + ] + } + ], + "source": [ + "print(clf.coef_, clf.intercept_)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x_ponits = np.arange(4, 8)\n", + "y_ = -(clf.coef_[0][0]*x_ponits + clf.intercept_)/clf.coef_[0][1]\n", + "plt.plot(x_ponits, y_)\n", + "\n", + "plt.plot(X[:50, 0], X[:50, 1], 'bo', color='blue', label='0')\n", + "plt.plot(X[50:, 0], X[50:, 1], 'bo', color='orange', label='1')\n", + "plt.xlabel('sepal length')\n", + "plt.ylabel('sepal width')\n", + "plt.legend()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Projects/lihang-code/code/第6章 逻辑斯谛回归(LogisticRegression)/最大熵模型 IIS.py b/Projects/lihang-code/code/第6章 逻辑斯谛回归(LogisticRegression)/最大熵模型 IIS.py new file mode 100755 index 0000000..3ac2112 --- /dev/null +++ b/Projects/lihang-code/code/第6章 逻辑斯谛回归(LogisticRegression)/最大熵模型 IIS.py @@ -0,0 +1,122 @@ +import math +from copy import deepcopy + + +class MaxEntropy: + def __init__(self, EPS=0.005): + self._samples = [] + self._Y = set() # 标签集合，相当去去重后的y + self._numXY = {} # key为(x,y)，value为出现次数 + self._N = 0 # 样本数 + self._Ep_ = [] # 样本分布的特征期望值 + self._xyID = {} # key记录(x,y),value记录id号 + self._n = 0 # 特征键值(x,y)的个数 + self._C = 0 # 最大特征数 + self._IDxy = {} # key为(x,y)，value为对应的id号 + self._w = [] + self._EPS = EPS # 收敛条件 + self._lastw = [] # 上一次w参数值 + + def loadData(self, dataset): + self._samples = deepcopy(dataset) + for items in self._samples: + y = items[0] + X = items[1:] + self._Y.add(y) # 集合中y若已存在则会自动忽略 + for x in X: + if (x, y) in self._numXY: + self._numXY[(x, y)] += 1 + else: + self._numXY[(x, y)] = 1 + + self._N = len(self._samples) + self._n = len(self._numXY) + self._C = max([len(sample)-1 for sample in self._samples]) + self._w = [0]*self._n + self._lastw = self._w[:] + + self._Ep_ = [0] * self._n + for i, xy in enumerate(self._numXY): # 计算特征函数fi关于经验分布的期望 + self._Ep_[i] = self._numXY[xy]/self._N + self._xyID[xy] = i + self._IDxy[i] = xy + + def _Zx(self, X): # 计算每个Z(x)值 + zx = 0 + for y in self._Y: + ss = 0 + for x in X: + if (x, y) in self._numXY: + ss += self._w[self._xyID[(x, y)]] + zx += math.exp(ss) + return zx + + def _model_pyx(self, y, X): # 计算每个P(y|x) + zx = self._Zx(X) + ss = 0 + for x in X: + if (x, y) in self._numXY: + ss += self._w[self._xyID[(x, y)]] + pyx = math.exp(ss)/zx + return pyx + + def _model_ep(self, index): # 计算特征函数fi关于模型的期望 + x, y = self._IDxy[index] + ep = 0 + for sample in self._samples: + if x not in sample: + continue + pyx = self._model_pyx(y, sample) + ep += pyx/self._N + return ep + + def _convergence(self): # 判断是否全部收敛 + for last, now in zip(self._lastw, self._w): + if abs(last - now) >= self._EPS: + return False + return True + + def predict(self, X): # 计算预测概率 + Z = self._Zx(X) + result = {} + for y in self._Y: + ss = 0 + for x in X: + if (x, y) in self._numXY: + ss += self._w[self._xyID[(x, y)]] + pyx = math.exp(ss)/Z + result[y] = pyx + return result + + def train(self, maxiter=1000): # 训练数据 + for loop in range(maxiter): # 最大训练次数 + print("iter:%d" % loop) + self._lastw = self._w[:] + for i in range(self._n): + ep = self._model_ep(i) # 计算第i个特征的模型期望 + self._w[i] += math.log(self._Ep_[i]/ep)/self._C # 更新参数 + print("w:", self._w) + if self._convergence(): # 判断是否收敛 + break + + +dataset = [['no', 'sunny', 'hot', 'high', 'FALSE'], + ['no', 'sunny', 'hot', 'high', 'TRUE'], + ['yes', 'overcast', 'hot', 'high', 'FALSE'], + ['yes', 'rainy', 'mild', 'high', 'FALSE'], + ['yes', 'rainy', 'cool', 'normal', 'FALSE'], + ['no', 'rainy', 'cool', 'normal', 'TRUE'], + ['yes', 'overcast', 'cool', 'normal', 'TRUE'], + ['no', 'sunny', 'mild', 'high', 'FALSE'], + ['yes', 'sunny', 'cool', 'normal', 'FALSE'], + ['yes', 'rainy', 'mild', 'normal', 'FALSE'], + ['yes', 'sunny', 'mild', 'normal', 'TRUE'], + ['yes', 'overcast', 'mild', 'high', 'TRUE'], + ['yes', 'overcast', 'hot', 'normal', 'FALSE'], + ['no', 'rainy', 'mild', 'high', 'TRUE']] + +maxent = MaxEntropy() +x = ['overcast', 'mild', 'high', 'FALSE'] +maxent.loadData(dataset) +maxent.train() +print('predict:', maxent.predict(x)) diff --git a/Projects/lihang-code/code/第7章 支持向量机(SVM)/support-vector-machine.ipynb b/Projects/lihang-code/code/第7章 支持向量机(SVM)/support-vector-machine.ipynb new file mode 100755 index 0000000..2def408 --- /dev/null +++ b/Projects/lihang-code/code/第7章 支持向量机(SVM)/support-vector-machine.ipynb @@ -0,0 +1,577 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "原文代码作者：https://github.com/wzyonggege/statistical-learning-method\n", + "\n", + "中文注释制作：机器学习初学者(微信公众号：ID:ai-start-com)\n", + "\n", + "配置环境：python 3.6\n", + "\n", + "代码全部测试通过。\n", + "![gongzhong](../gongzhong.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 第7章 支持向量机" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "----\n", + "分离超平面：$w^Tx+b=0$\n", + "\n", + "点到直线距离：$r=\\frac{|w^Tx+b|}{||w||_2}$\n", + "\n", + "$||w||_2$为2-范数：$||w||_2=\\sqrt[2]{\\sum^m_{i=1}w_i^2}$\n", + "\n", + "直线为超平面，样本可表示为：\n", + "\n", + "$w^Tx+b\\ \\geq+1$\n", + "\n", + "$w^Tx+b\\ \\leq+1$\n", + "\n", + "#### margin：\n", + "\n", + "**函数间隔**：$label(w^Tx+b)\\ or\\ y_i(w^Tx+b)$\n", + "\n", + "**几何间隔**：$r=\\frac{label(w^Tx+b)}{||w||_2}$，当数据被正确分类时，几何间隔就是点到超平面的距离\n", + "\n", + "为了求几何间隔最大，SVM基本问题可以转化为求解:($\\frac{r^*}{||w||}$为几何间隔，(${r^*}$为函数间隔)\n", + "\n", + "$$\\max\\ \\frac{r^*}{||w||}$$\n", + "\n", + "$$(subject\\ to)\\ y_i({w^T}x_i+{b})\\geq {r^*},\\ i=1,2,..,m$$\n", + "\n", + "分类点几何间隔最大，同时被正确分类。但这个方程并非凸函数求解，所以要先①将方程转化为凸函数，②用拉格朗日乘子法和KKT条件求解对偶问题。\n", + "\n", + "①转化为凸函数：\n", + "\n", + "先令${r^*}=1$，方便计算（参照衡量，不影响评价结果）\n", + "\n", + "$$\\max\\ \\frac{1}{||w||}$$\n", + "\n", + "$$s.t.\\ y_i({w^T}x_i+{b})\\geq {1},\\ i=1,2,..,m$$\n", + "\n", + "再将$\\max\\ \\frac{1}{||w||}$转化成$\\min\\ \\frac{1}{2}||w||^2$求解凸函数，1/2是为了求导之后方便计算。\n", + "\n", + "$$\\min\\ \\frac{1}{2}||w||^2$$\n", + "\n", + "$$s.t.\\ y_i(w^Tx_i+b)\\geq 1,\\ i=1,2,..,m$$\n", + "\n", + "②用拉格朗日乘子法和KKT条件求解最优值：\n", + "\n", + "$$\\min\\ \\frac{1}{2}||w||^2$$\n", + "\n", + "$$s.t.\\ -y_i(w^Tx_i+b)+1\\leq 0,\\ i=1,2,..,m$$\n", + "\n", + "整合成：\n", + "\n", + "$$L(w, b, \\alpha) = \\frac{1}{2}||w||^2+\\sum^m_{i=1}\\alpha_i(-y_i(w^Tx_i+b)+1)$$\n", + "\n", + "推导：$\\min\\ f(x)=\\min \\max\\ L(w, b, \\alpha)\\geq \\max \\min\\ L(w, b, \\alpha)$\n", + "\n", + "根据KKT条件：\n", + "\n", + "$$\\frac{\\partial }{\\partial w}L(w, b, \\alpha)=w-\\sum\\alpha_iy_ix_i=0,\\ w=\\sum\\alpha_iy_ix_i$$\n", + "\n", + "$$\\frac{\\partial }{\\partial b}L(w, b, \\alpha)=\\sum\\alpha_iy_i=0$$\n", + "\n", + "带入$ L(w, b, \\alpha)$\n", + "\n", + "$\\min\\ L(w, b, \\alpha)=\\frac{1}{2}||w||^2+\\sum^m_{i=1}\\alpha_i(-y_i(w^Tx_i+b)+1)$\n", + "\n", + "$\\qquad\\qquad\\qquad=\\frac{1}{2}w^Tw-\\sum^m_{i=1}\\alpha_iy_iw^Tx_i-b\\sum^m_{i=1}\\alpha_iy_i+\\sum^m_{i=1}\\alpha_i$\n", + "\n", + "$\\qquad\\qquad\\qquad=\\frac{1}{2}w^T\\sum\\alpha_iy_ix_i-\\sum^m_{i=1}\\alpha_iy_iw^Tx_i+\\sum^m_{i=1}\\alpha_i$\n", + "\n", + "$\\qquad\\qquad\\qquad=\\sum^m_{i=1}\\alpha_i-\\frac{1}{2}\\sum^m_{i=1}\\alpha_iy_iw^Tx_i$\n", + "\n", + "$\\qquad\\qquad\\qquad=\\sum^m_{i=1}\\alpha_i-\\frac{1}{2}\\sum^m_{i,j=1}\\alpha_i\\alpha_jy_iy_j(x_ix_j)$\n", + "\n", + "再把max问题转成min问题：\n", + "\n", + "$\\max\\ \\sum^m_{i=1}\\alpha_i-\\frac{1}{2}\\sum^m_{i,j=1}\\alpha_i\\alpha_jy_iy_j(x_ix_j)=\\min \\frac{1}{2}\\sum^m_{i,j=1}\\alpha_i\\alpha_jy_iy_j(x_ix_j)-\\sum^m_{i=1}\\alpha_i$\n", + "\n", + "$s.t.\\ \\sum^m_{i=1}\\alpha_iy_i=0,$\n", + "\n", + "$ \\alpha_i \\geq 0,i=1,2,...,m$\n", + "\n", + "以上为SVM对偶问题的对偶形式\n", + "\n", + "-----\n", + "#### kernel\n", + "\n", + "在低维空间计算获得高维空间的计算结果，也就是说计算结果满足高维（满足高维，才能说明高维下线性可分）。\n", + "\n", + "#### soft margin & slack variable\n", + "\n", + "引入松弛变量$\\xi\\geq0$，对应数据点允许偏离的functional margin 的量。\n", + "\n", + "目标函数：$\\min\\ \\frac{1}{2}||w||^2+C\\sum\\xi_i\\qquad s.t.\\ y_i(w^Tx_i+b)\\geq1-\\xi_i$ \n", + "\n", + "对偶问题：\n", + "\n", + "$$\\max\\ \\sum^m_{i=1}\\alpha_i-\\frac{1}{2}\\sum^m_{i,j=1}\\alpha_i\\alpha_jy_iy_j(x_ix_j)=\\min \\frac{1}{2}\\sum^m_{i,j=1}\\alpha_i\\alpha_jy_iy_j(x_ix_j)-\\sum^m_{i=1}\\alpha_i$$\n", + "\n", + "$$s.t.\\ C\\geq\\alpha_i \\geq 0,i=1,2,...,m\\quad \\sum^m_{i=1}\\alpha_iy_i=0,$$\n", + "\n", + "-----\n", + "\n", + "#### Sequential Minimal Optimization\n", + "\n", + "首先定义特征到结果的输出函数：$u=w^Tx+b$.\n", + "\n", + "因为$w=\\sum\\alpha_iy_ix_i$\n", + "\n", + "有$u=\\sum y_i\\alpha_iK(x_i, x)-b$\n", + "\n", + "\n", + "----\n", + "\n", + "$\\max \\sum^m_{i=1}\\alpha_i-\\frac{1}{2}\\sum^m_{i=1}\\sum^m_{j=1}\\alpha_i\\alpha_jy_iy_j<\\phi(x_i)^T,\\phi(x_j)>$\n", + "\n", + "$s.t.\\ \\sum^m_{i=1}\\alpha_iy_i=0,$\n", + "\n", + "$ \\alpha_i \\geq 0,i=1,2,...,m$\n", + "\n", + "-----\n", + "参考资料：\n", + "\n", + "[1] :[Lagrange Multiplier and KKT](http://blog.csdn.net/xianlingmao/article/details/7919597)\n", + "\n", + "[2] :[推导SVM](https://my.oschina.net/dfsj66011/blog/517766)\n", + "\n", + "[3] :[机器学习算法实践-支持向量机(SVM)算法原理](http://pytlab.org/2017/08/15/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E7%AE%97%E6%B3%95%E5%AE%9E%E8%B7%B5-%E6%94%AF%E6%8C%81%E5%90%91%E9%87%8F%E6%9C%BA-SVM-%E7%AE%97%E6%B3%95%E5%8E%9F%E7%90%86/)\n", + "\n", + "[4] :[Python实现SVM](http://blog.csdn.net/wds2006sdo/article/details/53156589)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from sklearn.datasets import load_iris\n", + "from sklearn.model_selection import train_test_split\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# data\n", + "def create_data():\n", + " iris = load_iris()\n", + " df = pd.DataFrame(iris.data, columns=iris.feature_names)\n", + " df['label'] = iris.target\n", + " df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']\n", + " data = np.array(df.iloc[:100, [0, 1, -1]])\n", + " for i in range(len(data)):\n", + " if data[i,-1] == 0:\n", + " data[i,-1] = -1\n", + " # print(data)\n", + " return data[:,:2], data[:,-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "X, y = create_data()\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(X[:50,0],X[:50,1], label='0')\n", + "plt.scatter(X[50:,0],X[50:,1], label='1')\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "----\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class SVM:\n", + " def __init__(self, max_iter=100, kernel='linear'):\n", + " self.max_iter = max_iter\n", + " self._kernel = kernel\n", + " \n", + " def init_args(self, features, labels):\n", + " self.m, self.n = features.shape\n", + " self.X = features\n", + " self.Y = labels\n", + " self.b = 0.0\n", + " \n", + " # 将Ei保存在一个列表里\n", + " self.alpha = np.ones(self.m)\n", + " self.E = [self._E(i) for i in range(self.m)]\n", + " # 松弛变量\n", + " self.C = 1.0\n", + " \n", + " def _KKT(self, i):\n", + " y_g = self._g(i)*self.Y[i]\n", + " if self.alpha[i] == 0:\n", + " return y_g >= 1\n", + " elif 0 < self.alpha[i] < self.C:\n", + " return y_g == 1\n", + " else:\n", + " return y_g <= 1\n", + " \n", + " # g(x)预测值，输入xi（X[i]）\n", + " def _g(self, i):\n", + " r = self.b\n", + " for j in range(self.m):\n", + " r += self.alpha[j]*self.Y[j]*self.kernel(self.X[i], self.X[j])\n", + " return r\n", + " \n", + " # 核函数\n", + " def kernel(self, x1, x2):\n", + " if self._kernel == 'linear':\n", + " return sum([x1[k]*x2[k] for k in range(self.n)])\n", + " elif self._kernel == 'poly':\n", + " return (sum([x1[k]*x2[k] for k in range(self.n)]) + 1)**2\n", + " \n", + " return 0\n", + " \n", + " # E（x）为g(x)对输入x的预测值和y的差\n", + " def _E(self, i):\n", + " return self._g(i) - self.Y[i]\n", + " \n", + " def _init_alpha(self):\n", + " # 外层循环首先遍历所有满足0= 0:\n", + " j = min(range(self.m), key=lambda x: self.E[x])\n", + " else:\n", + " j = max(range(self.m), key=lambda x: self.E[x])\n", + " return i, j\n", + " \n", + " def _compare(self, _alpha, L, H):\n", + " if _alpha > H:\n", + " return H\n", + " elif _alpha < L:\n", + " return L\n", + " else:\n", + " return _alpha \n", + " \n", + " def fit(self, features, labels):\n", + " self.init_args(features, labels)\n", + " \n", + " for t in range(self.max_iter):\n", + " # train\n", + " i1, i2 = self._init_alpha()\n", + " \n", + " # 边界\n", + " if self.Y[i1] == self.Y[i2]:\n", + " L = max(0, self.alpha[i1]+self.alpha[i2]-self.C)\n", + " H = min(self.C, self.alpha[i1]+self.alpha[i2])\n", + " else:\n", + " L = max(0, self.alpha[i2]-self.alpha[i1])\n", + " H = min(self.C, self.C+self.alpha[i2]-self.alpha[i1])\n", + " \n", + " E1 = self.E[i1]\n", + " E2 = self.E[i2]\n", + " # eta=K11+K22-2K12\n", + " eta = self.kernel(self.X[i1], self.X[i1]) + self.kernel(self.X[i2], self.X[i2]) - 2*self.kernel(self.X[i1], self.X[i2])\n", + " if eta <= 0:\n", + " # print('eta <= 0')\n", + " continue\n", + " \n", + " alpha2_new_unc = self.alpha[i2] + self.Y[i2] * (E1 - E2) / eta#此处有修改，根据书上应该是E1 - E2，书上130-131页\n", + " alpha2_new = self._compare(alpha2_new_unc, L, H)\n", + " \n", + " alpha1_new = self.alpha[i1] + self.Y[i1] * self.Y[i2] * (self.alpha[i2] - alpha2_new)\n", + " \n", + " b1_new = -E1 - self.Y[i1] * self.kernel(self.X[i1], self.X[i1]) * (alpha1_new-self.alpha[i1]) - self.Y[i2] * self.kernel(self.X[i2], self.X[i1]) * (alpha2_new-self.alpha[i2])+ self.b \n", + " b2_new = -E2 - self.Y[i1] * self.kernel(self.X[i1], self.X[i2]) * (alpha1_new-self.alpha[i1]) - self.Y[i2] * self.kernel(self.X[i2], self.X[i2]) * (alpha2_new-self.alpha[i2])+ self.b \n", + " \n", + " if 0 < alpha1_new < self.C:\n", + " b_new = b1_new\n", + " elif 0 < alpha2_new < self.C:\n", + " b_new = b2_new\n", + " else:\n", + " # 选择中点\n", + " b_new = (b1_new + b2_new) / 2\n", + " \n", + " # 更新参数\n", + " self.alpha[i1] = alpha1_new\n", + " self.alpha[i2] = alpha2_new\n", + " self.b = b_new\n", + " \n", + " self.E[i1] = self._E(i1)\n", + " self.E[i2] = self._E(i2)\n", + " return 'train done!'\n", + " \n", + " def predict(self, data):\n", + " r = self.b\n", + " for i in range(self.m):\n", + " r += self.alpha[i] * self.Y[i] * self.kernel(data, self.X[i])\n", + " \n", + " return 1 if r > 0 else -1\n", + " \n", + " def score(self, X_test, y_test):\n", + " right_count = 0\n", + " for i in range(len(X_test)):\n", + " result = self.predict(X_test[i])\n", + " if result == y_test[i]:\n", + " right_count += 1\n", + " return right_count / len(X_test)\n", + " \n", + " def _weight(self):\n", + " # linear model\n", + " yx = self.Y.reshape(-1, 1)*self.X\n", + " self.w = np.dot(yx.T, self.alpha)\n", + " return self.w" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "svm = SVM(max_iter=200)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'train done!'" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "svm.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.92" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "svm.score(X_test, y_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## sklearn.svm.SVC" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,\n", + " decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',\n", + " max_iter=-1, probability=False, random_state=None, shrinking=True,\n", + " tol=0.001, verbose=False)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.svm import SVC\n", + "clf = SVC()\n", + "clf.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.96" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clf.score(X_test, y_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### sklearn.svm.SVC\n", + "\n", + "*(C=1.0, kernel='rbf', degree=3, gamma='auto', coef0=0.0, shrinking=True, probability=False,tol=0.001, cache_size=200, class_weight=None, verbose=False, max_iter=-1, decision_function_shape=None,random_state=None)*\n", + "\n", + "参数：\n", + "\n", + "- C：C-SVC的惩罚参数C?默认值是1.0\n", + "\n", + "C越大，相当于惩罚松弛变量，希望松弛变量接近0，即对误分类的惩罚增大，趋向于对训练集全分对的情况，这样对训练集测试时准确率很高，但泛化能力弱。C值小，对误分类的惩罚减小，允许容错，将他们当成噪声点，泛化能力较强。\n", + "\n", + "- kernel ：核函数，默认是rbf，可以是‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’ \n", + " \n", + " – 线性：u'v\n", + " \n", + " – 多项式：(gamma*u'*v + coef0)^degree\n", + "\n", + " – RBF函数：exp(-gamma|u-v|^2)\n", + "\n", + " – sigmoid：tanh(gamma*u'*v + coef0)\n", + "\n", + "\n", + "- degree ：多项式poly函数的维度，默认是3，选择其他核函数时会被忽略。\n", + "\n", + "\n", + "- gamma ： ‘rbf’,‘poly’ 和‘sigmoid’的核函数参数。默认是’auto’，则会选择1/n_features\n", + "\n", + "\n", + "- coef0 ：核函数的常数项。对于‘poly’和 ‘sigmoid’有用。\n", + "\n", + "\n", + "- probability ：是否采用概率估计？.默认为False\n", + "\n", + "\n", + "- shrinking ：是否采用shrinking heuristic方法，默认为true\n", + "\n", + "\n", + "- tol ：停止训练的误差值大小，默认为1e-3\n", + "\n", + "\n", + "- cache_size ：核函数cache缓存大小，默认为200\n", + "\n", + "\n", + "- class_weight ：类别的权重，字典形式传递。设置第几类的参数C为weight*C(C-SVC中的C)\n", + "\n", + "\n", + "- verbose ：允许冗余输出？\n", + "\n", + "\n", + "- max_iter ：最大迭代次数。-1为无限制。\n", + "\n", + "\n", + "- decision_function_shape ：‘ovo’, ‘ovr’ or None, default=None3\n", + "\n", + "\n", + "- random_state ：数据洗牌时的种子值，int值\n", + "\n", + "\n", + "主要调节的参数有：C、kernel、degree、gamma、coef0。" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Projects/lihang-code/code/第8章 提升方法(AdaBoost)/Adaboost.ipynb b/Projects/lihang-code/code/第8章 提升方法(AdaBoost)/Adaboost.ipynb new file mode 100755 index 0000000..ac90e67 --- /dev/null +++ b/Projects/lihang-code/code/第8章 提升方法(AdaBoost)/Adaboost.ipynb @@ -0,0 +1,461 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "原文代码作者：https://github.com/wzyonggege/statistical-learning-method\n", + "\n", + "中文注释制作：机器学习初学者(微信公众号：ID:ai-start-com)\n", + "\n", + "配置环境：python 3.6\n", + "\n", + "代码全部测试通过。\n", + "![gongzhong](../gongzhong.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 第8章 提升方法" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "# Boost\n", + "\n", + "“装袋”（bagging）和“提升”（boost）是构建组合模型的两种最主要的方法，所谓的组合模型是由多个基本模型构成的模型，组合模型的预测效果往往比任意一个基本模型的效果都要好。\n", + "\n", + "- 装袋：每个基本模型由从总体样本中随机抽样得到的不同数据集进行训练得到，通过重抽样得到不同训练数据集的过程称为装袋。\n", + "\n", + "- 提升：每个基本模型训练时的数据集采用不同权重，针对上一个基本模型分类错误的样本增加权重，使得新的模型重点关注误分类样本\n", + "\n", + "### AdaBoost\n", + "\n", + "AdaBoost是AdaptiveBoost的缩写，表明该算法是具有适应性的提升算法。\n", + "\n", + "算法的步骤如下：\n", + "\n", + "1）给每个训练样本（$x_{1},x_{2},….,x_{N}$）分配权重，初始权重$w_{1}$均为1/N。\n", + "\n", + "2）针对带有权值的样本进行训练，得到模型$G_m$（初始模型为G1）。\n", + "\n", + "3）计算模型$G_m$的误分率$e_m=\\sum_{i=1}^Nw_iI(y_i\\not= G_m(x_i))$\n", + "\n", + "4）计算模型$G_m$的系数$\\alpha_m=0.5\\log[(1-e_m)/e_m]$\n", + "\n", + "5）根据误分率e和当前权重向量$w_m$更新权重向量$w_{m+1}$。\n", + "\n", + "6）计算组合模型$f(x)=\\sum_{m=1}^M\\alpha_mG_m(x_i)$的误分率。\n", + "\n", + "7）当组合模型的误分率或迭代次数低于一定阈值，停止迭代；否则，回到步骤2）" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from sklearn.datasets import load_iris\n", + "from sklearn.model_selection import train_test_split\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# data\n", + "def create_data():\n", + " iris = load_iris()\n", + " df = pd.DataFrame(iris.data, columns=iris.feature_names)\n", + " df['label'] = iris.target\n", + " df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']\n", + " data = np.array(df.iloc[:100, [0, 1, -1]])\n", + " for i in range(len(data)):\n", + " if data[i,-1] == 0:\n", + " data[i,-1] = -1\n", + " # print(data)\n", + " return data[:,:2], data[:,-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "X, y = create_data()\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(X[:50,0],X[:50,1], label='0')\n", + "plt.scatter(X[50:,0],X[50:,1], label='1')\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "----\n", + "\n", + "### AdaBoost in Python" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class AdaBoost:\n", + " def __init__(self, n_estimators=50, learning_rate=1.0):\n", + " self.clf_num = n_estimators\n", + " self.learning_rate = learning_rate\n", + " \n", + " def init_args(self, datasets, labels):\n", + " \n", + " self.X = datasets\n", + " self.Y = labels\n", + " self.M, self.N = datasets.shape\n", + " \n", + " # 弱分类器数目和集合\n", + " self.clf_sets = []\n", + " \n", + " # 初始化weights\n", + " self.weights = [1.0/self.M]*self.M\n", + " \n", + " # G(x)系数 alpha\n", + " self.alpha = []\n", + " \n", + " def _G(self, features, labels, weights):\n", + " m = len(features)\n", + " error = 100000.0 # 无穷大\n", + " best_v = 0.0\n", + " # 单维features\n", + " features_min = min(features)\n", + " features_max = max(features)\n", + " n_step = (features_max - features_min + self.learning_rate) // self.learning_rate\n", + " # print('n_step:{}'.format(n_step))\n", + " direct, compare_array = None, None\n", + " for i in range(1, int(n_step)):\n", + " v = features_min + self.learning_rate * i\n", + " \n", + " if v not in features:\n", + " # 误分类计算\n", + " compare_array_positive = np.array([1 if features[k] > v else -1 for k in range(m)])\n", + " weight_error_positive = sum([weights[k] for k in range(m) if compare_array_positive[k] != labels[k]])\n", + " \n", + " compare_array_nagetive = np.array([-1 if features[k] > v else 1 for k in range(m)])\n", + " weight_error_nagetive = sum([weights[k] for k in range(m) if compare_array_nagetive[k] != labels[k]])\n", + "\n", + " if weight_error_positive < weight_error_nagetive:\n", + " weight_error = weight_error_positive\n", + " _compare_array = compare_array_positive\n", + " direct = 'positive'\n", + " else:\n", + " weight_error = weight_error_nagetive\n", + " _compare_array = compare_array_nagetive\n", + " direct = 'nagetive'\n", + " \n", + " # print('v:{} error:{}'.format(v, weight_error))\n", + " if weight_error < error:\n", + " error = weight_error\n", + " compare_array = _compare_array\n", + " best_v = v\n", + " return best_v, direct, error, compare_array\n", + " \n", + " # 计算alpha\n", + " def _alpha(self, error):\n", + " return 0.5 * np.log((1-error)/error)\n", + " \n", + " # 规范化因子\n", + " def _Z(self, weights, a, clf):\n", + " return sum([weights[i]*np.exp(-1*a*self.Y[i]*clf[i]) for i in range(self.M)])\n", + " \n", + " # 权值更新\n", + " def _w(self, a, clf, Z):\n", + " for i in range(self.M):\n", + " self.weights[i] = self.weights[i]*np.exp(-1*a*self.Y[i]*clf[i])/ Z\n", + " \n", + " # G(x)的线性组合\n", + " def _f(self, alpha, clf_sets):\n", + " pass\n", + " \n", + " def G(self, x, v, direct):\n", + " if direct == 'positive':\n", + " return 1 if x > v else -1 \n", + " else:\n", + " return -1 if x > v else 1 \n", + " \n", + " def fit(self, X, y):\n", + " self.init_args(X, y)\n", + " \n", + " for epoch in range(self.clf_num):\n", + " best_clf_error, best_v, clf_result = 100000, None, None\n", + " # 根据特征维度, 选择误差最小的\n", + " for j in range(self.N):\n", + " features = self.X[:, j]\n", + " # 分类阈值，分类误差，分类结果\n", + " v, direct, error, compare_array = self._G(features, self.Y, self.weights)\n", + " \n", + " if error < best_clf_error:\n", + " best_clf_error = error\n", + " best_v = v\n", + " final_direct = direct\n", + " clf_result = compare_array\n", + " axis = j\n", + " \n", + " # print('epoch:{}/{} feature:{} error:{} v:{}'.format(epoch, self.clf_num, j, error, best_v))\n", + " if best_clf_error == 0:\n", + " break\n", + " \n", + " # 计算G(x)系数a\n", + " a = self._alpha(best_clf_error)\n", + " self.alpha.append(a)\n", + " # 记录分类器\n", + " self.clf_sets.append((axis, best_v, final_direct))\n", + " # 规范化因子\n", + " Z = self._Z(self.weights, a, clf_result)\n", + " # 权值更新\n", + " self._w(a, clf_result, Z)\n", + " \n", + "# print('classifier:{}/{} error:{:.3f} v:{} direct:{} a:{:.5f}'.format(epoch+1, self.clf_num, error, best_v, final_direct, a))\n", + "# print('weight:{}'.format(self.weights))\n", + "# print('\\n')\n", + " \n", + " def predict(self, feature):\n", + " result = 0.0\n", + " for i in range(len(self.clf_sets)):\n", + " axis, clf_v, direct = self.clf_sets[i]\n", + " f_input = feature[axis]\n", + " result += self.alpha[i] * self.G(f_input, clf_v, direct)\n", + " # sign\n", + " return 1 if result > 0 else -1\n", + " \n", + " def score(self, X_test, y_test):\n", + " right_count = 0\n", + " for i in range(len(X_test)):\n", + " feature = X_test[i]\n", + " if self.predict(feature) == y_test[i]:\n", + " right_count += 1\n", + " \n", + " return right_count / len(X_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 例8.1" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "X = np.arange(10).reshape(10, 1)\n", + "y = np.array([1, 1, 1, -1, -1, -1, 1, 1, 1, -1])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "clf = AdaBoost(n_estimators=3, learning_rate=0.5)\n", + "clf.fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "X, y = create_data()\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.6363636363636364" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clf = AdaBoost(n_estimators=10, learning_rate=0.2)\n", + "clf.fit(X_train, y_train)\n", + "clf.score(X_test, y_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "average score:65.000%\n" + ] + } + ], + "source": [ + "# 100次结果\n", + "result = []\n", + "for i in range(1, 101):\n", + " X, y = create_data()\n", + " X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33)\n", + " clf = AdaBoost(n_estimators=100, learning_rate=0.2)\n", + " clf.fit(X_train, y_train)\n", + " r = clf.score(X_test, y_test)\n", + " # print('{}/100 score：{}'.format(i, r))\n", + " result.append(r)\n", + "\n", + "print('average score:{:.3f}%'.format(sum(result)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "-----\n", + "# sklearn.ensemble.AdaBoostClassifier\n", + "\n", + "- algorithm：这个参数只有AdaBoostClassifier有。主要原因是scikit-learn实现了两种Adaboost分类算法，SAMME和SAMME.R。两者的主要区别是弱学习器权重的度量，SAMME使用了和我们的原理篇里二元分类Adaboost算法的扩展，即用对样本集分类效果作为弱学习器权重，而SAMME.R使用了对样本集分类的预测概率大小来作为弱学习器权重。由于SAMME.R使用了概率度量的连续值，迭代一般比SAMME快，因此AdaBoostClassifier的默认算法algorithm的值也是SAMME.R。我们一般使用默认的SAMME.R就够了，但是要注意的是使用了SAMME.R， 则弱分类学习器参数base_estimator必须限制使用支持概率预测的分类器。SAMME算法则没有这个限制。\n", + "\n", + "- n_estimators： AdaBoostClassifier和AdaBoostRegressor都有，就是我们的弱学习器的最大迭代次数，或者说最大的弱学习器的个数。一般来说n_estimators太小，容易欠拟合，n_estimators太大，又容易过拟合，一般选择一个适中的数值。默认是50。在实际调参的过程中，我们常常将n_estimators和下面介绍的参数learning_rate一起考虑。\n", + "\n", + "- learning_rate: AdaBoostClassifier和AdaBoostRegressor都有，即每个弱学习器的权重缩减系数ν\n", + "\n", + "- base_estimator：AdaBoostClassifier和AdaBoostRegressor都有，即我们的弱分类学习器或者弱回归学习器。理论上可以选择任何一个分类或者回归学习器，不过需要支持样本权重。我们常用的一般是CART决策树或者神经网络MLP。" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\programdata\\anaconda3\\envs\\tf\\lib\\site-packages\\sklearn\\ensemble\\weight_boosting.py:29: DeprecationWarning: numpy.core.umath_tests is an internal NumPy module and should not be imported. It will be removed in a future NumPy release.\n", + " from numpy.core.umath_tests import inner1d\n" + ] + }, + { + "data": { + "text/plain": [ + "AdaBoostClassifier(algorithm='SAMME.R', base_estimator=None,\n", + " learning_rate=0.5, n_estimators=100, random_state=None)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.ensemble import AdaBoostClassifier\n", + "clf = AdaBoostClassifier(n_estimators=100, learning_rate=0.5)\n", + "clf.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9393939393939394" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clf.score(X_test, y_test)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Projects/lihang-code/code/第9章 EM算法及其推广(EM)/em.ipynb b/Projects/lihang-code/code/第9章 EM算法及其推广(EM)/em.ipynb new file mode 100755 index 0000000..b88f79d --- /dev/null +++ b/Projects/lihang-code/code/第9章 EM算法及其推广(EM)/em.ipynb @@ -0,0 +1,257 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "原文代码作者：https://github.com/wzyonggege/statistical-learning-method\n", + "\n", + "中文注释制作：机器学习初学者(微信公众号：ID:ai-start-com)\n", + "\n", + "配置环境：python 3.6\n", + "\n", + "代码全部测试通过。\n", + "![gongzhong](../gongzhong.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 第9章 EM算法及其推广" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Expectation Maximization algorithm\n", + "\n", + "### Maximum likehood function\n", + "\n", + "[likehood & maximum likehood](http://fangs.in/post/thinkstats/likelihood/)\n", + "\n", + "> 在统计学中，似然函数（likelihood function，通常简写为likelihood，似然）是一个非常重要的内容，在非正式场合似然和概率（Probability）几乎是一对同义词，但是在统计学中似然和概率却是两个不同的概念。概率是在特定环境下某件事情发生的可能性，也就是结果没有产生之前依据环境所对应的参数来预测某件事情发生的可能性，比如抛硬币，抛之前我们不知道最后是哪一面朝上，但是根据硬币的性质我们可以推测任何一面朝上的可能性均为50%，这个概率只有在抛硬币之前才是有意义的，抛完硬币后的结果便是确定的；而似然刚好相反，是在确定的结果下去推测产生这个结果的可能环境（参数），还是抛硬币的例子，假设我们随机抛掷一枚硬币1,000次，结果500次人头朝上，500次数字朝上（实际情况一般不会这么理想，这里只是举个例子），我们很容易判断这是一枚标准的硬币，两面朝上的概率均为50%，这个过程就是我们运用出现的结果来判断这个事情本身的性质（参数），也就是似然。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$P(Y|\\theta) = \\prod[\\pi p^{y_i}(1-p)^{1-y_i}+(1-\\pi) q^{y_i}(1-q)^{1-y_i}]$$\n", + "\n", + "### E step:\n", + "\n", + "$$\\mu^{i+1}=\\frac{\\pi (p^i)^{y_i}(1-(p^i))^{1-y_i}}{\\pi (p^i)^{y_i}(1-(p^i))^{1-y_i}+(1-\\pi) (q^i)^{y_i}(1-(q^i))^{1-y_i}}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import math" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "pro_A, pro_B, por_C = 0.5, 0.5, 0.5\n", + "\n", + "def pmf(i, pro_A, pro_B, por_C):\n", + " pro_1 = pro_A * math.pow(pro_B, data[i]) * math.pow((1-pro_B), 1-data[i])\n", + " pro_2 = pro_A * math.pow(pro_C, data[i]) * math.pow((1-pro_C), 1-data[i])\n", + " return pro_1 / (pro_1 + pro_2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### M step:\n", + "\n", + "$$\\pi^{i+1}=\\frac{1}{n}\\sum_{j=1}^n\\mu^{i+1}_j$$\n", + "\n", + "$$p^{i+1}=\\frac{\\sum_{j=1}^n\\mu^{i+1}_jy_i}{\\sum_{j=1}^n\\mu^{i+1}_j}$$\n", + "\n", + "$$q^{i+1}=\\frac{\\sum_{j=1}^n(1-\\mu^{i+1}_jy_i)}{\\sum_{j=1}^n(1-\\mu^{i+1}_j)}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "class EM:\n", + " def __init__(self, prob):\n", + " self.pro_A, self.pro_B, self.pro_C = prob\n", + " \n", + " # e_step\n", + " def pmf(self, i):\n", + " pro_1 = self.pro_A * math.pow(self.pro_B, data[i]) * math.pow((1-self.pro_B), 1-data[i])\n", + " pro_2 = (1 - self.pro_A) * math.pow(self.pro_C, data[i]) * math.pow((1-self.pro_C), 1-data[i])\n", + " return pro_1 / (pro_1 + pro_2)\n", + " \n", + " # m_step\n", + " def fit(self, data):\n", + " count = len(data)\n", + " print('init prob:{}, {}, {}'.format(self.pro_A, self.pro_B, self.pro_C))\n", + " for d in range(count):\n", + " _ = yield\n", + " _pmf = [self.pmf(k) for k in range(count)]\n", + " pro_A = 1/ count * sum(_pmf)\n", + " pro_B = sum([_pmf[k]*data[k] for k in range(count)]) / sum([_pmf[k] for k in range(count)])\n", + " pro_C = sum([(1-_pmf[k])*data[k] for k in range(count)]) / sum([(1-_pmf[k]) for k in range(count)])\n", + " print('{}/{} pro_a:{:.3f}, pro_b:{:.3f}, pro_c:{:.3f}'.format(d+1, count, pro_A, pro_B, pro_C))\n", + " self.pro_A = pro_A\n", + " self.pro_B = pro_B\n", + " self.pro_C = pro_C\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "data=[1,1,0,1,0,0,1,0,1,1]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "init prob:0.5, 0.5, 0.5\n" + ] + } + ], + "source": [ + "em = EM(prob=[0.5, 0.5, 0.5])\n", + "f = em.fit(data)\n", + "next(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1/10 pro_a:0.500, pro_b:0.600, pro_c:0.600\n" + ] + } + ], + "source": [ + "# 第一次迭代\n", + "f.send(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2/10 pro_a:0.500, pro_b:0.600, pro_c:0.600\n" + ] + } + ], + "source": [ + "# 第二次\n", + "f.send(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "init prob:0.4, 0.6, 0.7\n" + ] + } + ], + "source": [ + "em = EM(prob=[0.4, 0.6, 0.7])\n", + "f2 = em.fit(data)\n", + "next(f2)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1/10 pro_a:0.406, pro_b:0.537, pro_c:0.643\n" + ] + } + ], + "source": [ + "f2.send(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2/10 pro_a:0.406, pro_b:0.537, pro_c:0.643\n" + ] + } + ], + "source": [ + "f2.send(2)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Projects/lihang-code/images/1543246677825.png b/Projects/lihang-code/images/1543246677825.png new file mode 100755 index 0000000..907e4cd Binary files /dev/null and b/Projects/lihang-code/images/1543246677825.png differ diff --git a/Projects/lihang-code/images/gongzhong.png b/Projects/lihang-code/images/gongzhong.png new file mode 100755 index 0000000..2fc9979 Binary files /dev/null and b/Projects/lihang-code/images/gongzhong.png differ diff --git a/Projects/lihang-code/ppt/readme.md b/Projects/lihang-code/ppt/readme.md new file mode 100755 index 0000000..8d505c1 --- /dev/null +++ b/Projects/lihang-code/ppt/readme.md @@ -0,0 +1,37 @@ +**《统计学习方法》简介** + +**《统计学习方法》**，作者李航，本书全面系统地介绍了统计学习的主要方法，特别是监督学习方法，包括感知机、k近邻法、朴素贝叶斯法、决策树、逻辑斯谛回归与支持向量机、提升方法、EM算法、隐马尔可夫模型和条件随机场等。除第1章概论和最后一章总结外，每章介绍一种方法。叙述从具体问题或实例入手，由浅入深，阐明思路，给出必要的数学推导，便于读者掌握统计学习方法的实质，学会运用。 + +**目录:** + +第1章 统计学习方法概论 + +第2章 感知机 + +第3章 k近邻法 + +第4章 朴素贝叶斯 + +第5章 决策树 + +第6章 逻辑斯谛回归 + +第7章 支持向量机 + +第8章 提升方法 + +第9章 EM算法及其推广 + +第10章 隐马尔可夫模型 + +第11章 条件随机场 + +第12章 统计学习方法总结 + + + +**《统计学习方法》课件** + +作者袁春： 清华大学深圳研究生院，提供了全书12章的PPT课件。 + +整理：机器学习初学者 （微信公众号，ID:ai-start-com） diff --git a/Projects/lihang-code/ppt/第10章 隐马尔科夫模型.pdf b/Projects/lihang-code/ppt/第10章 隐马尔科夫模型.pdf new file mode 100755 index 0000000..48a4106 Binary files /dev/null and b/Projects/lihang-code/ppt/第10章 隐马尔科夫模型.pdf differ diff --git a/Projects/lihang-code/ppt/第11章 条件随机场.pdf b/Projects/lihang-code/ppt/第11章 条件随机场.pdf new file mode 100755 index 0000000..c101547 Binary files /dev/null and b/Projects/lihang-code/ppt/第11章 条件随机场.pdf differ diff --git a/Projects/lihang-code/ppt/第12章 统计学习方法总结.pdf b/Projects/lihang-code/ppt/第12章 统计学习方法总结.pdf new file mode 100755 index 0000000..c06eb24 Binary files /dev/null and b/Projects/lihang-code/ppt/第12章 统计学习方法总结.pdf differ diff --git a/Projects/lihang-code/ppt/第1章 统计学习方法概论.pdf b/Projects/lihang-code/ppt/第1章 统计学习方法概论.pdf new file mode 100755 index 0000000..79bcbaa Binary files /dev/null and b/Projects/lihang-code/ppt/第1章 统计学习方法概论.pdf differ diff --git a/Projects/lihang-code/ppt/第2章 感知机.pdf b/Projects/lihang-code/ppt/第2章 感知机.pdf new file mode 100755 index 0000000..efcb568 Binary files /dev/null and b/Projects/lihang-code/ppt/第2章 感知机.pdf differ diff --git a/Projects/lihang-code/ppt/第3章 k 近邻法.pdf b/Projects/lihang-code/ppt/第3章 k 近邻法.pdf new file mode 100755 index 0000000..1cdfcfd Binary files /dev/null and b/Projects/lihang-code/ppt/第3章 k 近邻法.pdf differ diff --git a/Projects/lihang-code/ppt/第4章 朴素贝叶斯法.pdf b/Projects/lihang-code/ppt/第4章 朴素贝叶斯法.pdf new file mode 100755 index 0000000..d7bd315 Binary files /dev/null and b/Projects/lihang-code/ppt/第4章 朴素贝叶斯法.pdf differ diff --git a/Projects/lihang-code/ppt/第5章 决策树-2016-ID3CART.pdf b/Projects/lihang-code/ppt/第5章 决策树-2016-ID3CART.pdf new file mode 100755 index 0000000..0ffa5bb Binary files /dev/null and b/Projects/lihang-code/ppt/第5章 决策树-2016-ID3CART.pdf differ diff --git a/Projects/lihang-code/ppt/第6章 Logistic回归.pdf b/Projects/lihang-code/ppt/第6章 Logistic回归.pdf new file mode 100755 index 0000000..9509efc Binary files /dev/null and b/Projects/lihang-code/ppt/第6章 Logistic回归.pdf differ diff --git a/Projects/lihang-code/ppt/第7章 支持向量机.pdf b/Projects/lihang-code/ppt/第7章 支持向量机.pdf new file mode 100755 index 0000000..c0053c0 Binary files /dev/null and b/Projects/lihang-code/ppt/第7章 支持向量机.pdf differ diff --git a/Projects/lihang-code/ppt/第8章 提升方法.pdf b/Projects/lihang-code/ppt/第8章 提升方法.pdf new file mode 100755 index 0000000..7a7117d Binary files /dev/null and b/Projects/lihang-code/ppt/第8章 提升方法.pdf differ diff --git a/Projects/lihang-code/ppt/第9章 EM算法及其推广.pdf b/Projects/lihang-code/ppt/第9章 EM算法及其推广.pdf new file mode 100755 index 0000000..b2c7bb1 Binary files /dev/null and b/Projects/lihang-code/ppt/第9章 EM算法及其推广.pdf differ diff --git a/Projects/lihang-code/readme.md b/Projects/lihang-code/readme.md new file mode 100755 index 0000000..c1edf86 --- /dev/null +++ b/Projects/lihang-code/readme.md @@ -0,0 +1,55 @@ +《**统计学习方法**》可以说是机器学习的入门宝典，许多机器学习培训班、互联网企业的面试、笔试题目，很多都参考这本书。本站根据网上资料用**Python**复现了课程内容，并提供本书的代码实现、课件下载。 + +**《统计学习方法》**，作者李航，本书全面系统地介绍了统计学习的主要方法，特别是监督学习方法，包括感知机、k近邻法、朴素贝叶斯法、决策树、逻辑斯谛回归与支持向量机、提升方法、EM算法、隐马尔可夫模型和条件随机场等。除第1章概论和最后一章总结外，每章介绍一种方法。叙述从具体问题或实例入手，由浅入深，阐明思路，给出必要的数学推导，便于读者掌握统计学习方法的实质，学会运用。 + +**目录:** + +第1章 统计学习方法概论 + +第2章 感知机 + +第3章 k近邻法 + +第4章 朴素贝叶斯 + +第5章 决策树 + +第6章 逻辑斯谛回归 + +第7章 支持向量机 + +第8章 提升方法 + +第9章 EM算法及其推广 + +第10章 隐马尔可夫模型 + +第11章 条件随机场 + +第12章 统计学习方法总结 + +**1.统计学习方法的代码实现（code文件夹）** + +**《统计学习方法》**官方没有提供代码实现，但是网上有许多机器学习爱好者尝试对每一章的内容进行了代码实现。 本站在github网站搜集了一些代码进行整理，并作了一定的修改，使用**Python3.6**实现了第1-11章的课程代码。 + +**代码目录与截图：** + +![1543246677825](images/1543246677825.png) + +**2.《统计学习方法》课件（ppt文件夹）** + +作者袁春： 清华大学深圳研究生院，提供了全书12章的PPT课件。 + +**参考** + +[https://github.com/wzyonggege/statistical-learning-method](http://link.zhihu.com/?target=https%3A//github.com/wzyonggege/statistical-learning-method) + +[https://github.com/WenDesi/lihang_book_algorithm](http://link.zhihu.com/?target=https%3A//github.com/WenDesi/lihang_book_algorithm) + +[https://blog.csdn.net/tudaodiaozhale](http://link.zhihu.com/?target=https%3A//blog.csdn.net/tudaodiaozhale) + +代码整理和修改：机器学习初学者 （微信公众号，ID:ai-start-com），qq群：774999266。 + +![gongzhong](/images/gongzhong.png) + +[我的知乎](https://www.zhihu.com/people/fengdu78) \ No newline at end of file diff --git a/README.md b/README.md new file mode 100755 index 0000000..c6bb659 --- /dev/null +++ b/README.md @@ -0,0 +1,1067 @@ +# DeepLearning Tutorial +## 一. 入门资料 + +[**完备的 AI 学习路线，最详细的中英文资源整理**](https://zhuanlan.zhihu.com/p/64052743) :star: + +[AiLearning: 机器学习 - MachineLearning - ML、深度学习 - DeepLearning - DL、自然语言处理 NL](https://github.com/apachecn/AiLearning) + +[Machine-Learning](https://github.com/shunliz/Machine-Learning) + +### 数学基础 + +![](notes/Images/MathematicalBasis.png) + +* [矩阵微积分](https://zh.wikipedia.org/wiki/%E7%9F%A9%E9%98%B5%E5%BE%AE%E7%A7%AF%E5%88%86) +* [机器学习的数学基础](https://github.com/fengdu78/Data-Science-Notes/tree/master/0.math/0.basic) +* [CS229线性代数与概率论基础](https://github.com/fengdu78/Data-Science-Notes/tree/master/0.math/1.CS229) + +### 机器学习基础 + +#### 快速入门 +* [机器学习算法地图](http://www.tensorinfinity.com/paper_18.html) +* [机器学习 吴恩达 Coursera个人笔记](https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BML-Coursera%5D%5B2014%5D%5BAndrew%20Ng%5D/%5B2014%5D%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E4%B8%AA%E4%BA%BA%E7%AC%94%E8%AE%B0%E5%AE%8C%E6%95%B4%E7%89%88v5.1.pdf)  && [视频（含官方笔记）](https://www.coursera.org/learn/machine-learning)   +* [CS229 课程讲义中文翻译](https://kivy-cn.github.io/Stanford-CS-229-CN/#/) && [机器学习 吴恩达 cs229个人笔记](https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BML-CS229%5D%5B2011%5D%5BAndrew%20NG%5D/%5B2011%5D%E6%96%AF%E5%9D%A6%E7%A6%8F%E5%A4%A7%E5%AD%A6%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E8%AF%BE%E7%A8%8B%E4%B8%AA%E4%BA%BA%E7%AC%94.pdf) && [官网（笔记）](http://cs229.stanford.edu/)  && [视频（中文字幕）](http://open.163.com/newview/movie/free?pid=M6SGF6VB4&mid=M6SGHFBMC)   +* [百页机器学习](http://themlbook.com/wiki/doku.php) + +#### 深入理解 +* [《统计学习方法》李航](https://github.com/Mikoto10032/DeepLearning/tree/master/books/%E6%9D%8E%E8%88%AA-%E7%BB%9F%E8%AE%A1%E5%AD%A6%E4%B9%A0) && [《统计学习方法》各章节笔记](https://www.cnblogs.com/YongSun/tag/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/) && [《统计学习方法》各章节笔记](https://zhuanlan.zhihu.com/c_1213397558586257408) && [推荐答案：statistical-learning-method-solutions-manual](https://github.com/datawhalechina/statistical-learning-method-solutions-manual) [《统计学习方法》各章节笔记](https://www.cnblogs.com/liaohuiqiang/category/1039314.html) && [《统计学习方法》各章节代码实现与课后习题参考解答](https://blog.csdn.net/breeze_blows/article/details/85469944) +* [《模式识别与机器学习》 Christopher Bishop](https://github.com/Mikoto10032/DeepLearning/blob/master/books/模式识别与机器学习PRML_Chinese_vision.pdf) +* [《机器学习》 周志华](https://github.com/Mikoto10032/DeepLearning/blob/master/books/机器学习周志华.pdf) && [南瓜书：pumpkin-book](https://github.com/datawhalechina/pumpkin-book) +* [《机器学习实战》 PelerHarrington](https://github.com/Mikoto10032/DeepLearning/blob/master/books/机器学习实战%20中文双页版.pdf) +* [机器学习与深度学习书单](https://mp.weixin.qq.com/s?__biz=MzAxMjcyNjE5MQ==&mid=2650488718&idx=1&sn=815a79d27d500f0fb8db1fe1fc6cfe48&chksm=83a2e54eb4d56c58a0989654f920d64ad2784ce52e4b2bc6883974257cf475c9983f05fb88c1&scene=0&xtrack=1&ascene=14&devicetype=android-28&version=27000339&nettype=WIFI&abtest_cookie=AwABAAoACwATAAQAI5ceAFaZHgDQmR4A3JkeAAAA&lang=zh_CN&pass_ticket=oEB1108Pes6HkdxEITmBjTb2Glju5%2BEGqHZKz50fMg0rgK4l9Fodlbe%2FDm96iX57&wx_header=1) + +### 深度学习基础 + +#### 快速入门 +* [深度学习思维导图](https://github.com/dformoso/deeplearning-mindmap) && [深度学习算法地图](http://www.tensorinfinity.com/paper_158.html) +* [《斯坦福大学深度学习基础教程》 Andrew Ng（吴恩达）](https://github.com/Mikoto10032/DeepLearning/blob/master/books/斯坦福大学-深度学习基础教程.pdf) +* [深度学习 吴恩达 个人笔记](http://www.ai-start.com/dl2017/)  && [视频](http://mooc.study.163.com/smartSpec/detail/1001319001.htm) +* [MIT深度学习基础-2019视频课程](https://deeplearning.mit.edu/) +* [台湾大学（NTU）李宏毅教授课程](http://speech.ee.ntu.edu.tw/~tlkagk/index.html) && [[leeml-notes](https://github.com/datawhalechina/leeml-notes) +* [图解深度学习_Grokking-Deep-Learning](https://github.com/iamtrask/Grokking-Deep-Learning) +* [《神经网络与深度学习》 Michael Nielsen](https://github.com/Mikoto10032/DeepLearning/blob/master/books/神经网络和深度学习neural%20networks%20and%20deep-learning-中文_ALL.pdf)     +* [ CS321-Hinton](http://www.cs.toronto.edu/~tijmen/csc321/) +* [ CS230: Deep Learning](https://web.stanford.edu/class/cs230/) +* [ CS294-112](http://rail.eecs.berkeley.edu/deeprlcourse/resources/) + +##### 计算机视觉 +* [CS231 李飞飞 已授权个人翻译笔记](https://zhuanlan.zhihu.com/p/21930884) && [视频](http://study.163.com/course/courseMain.htm?courseId=1003223001) +* [计算机视觉研究方向](https://mp.weixin.qq.com/s/WNkzfvYtEO5zJoe_-yAPow) + +##### 自然语言处理 +* [CS224n: Natural Language Processing with Deep Learning](http://web.stanford.edu/class/cs224n/index.html) +* [NLP上手教程](https://github.com/FudanNLP/nlp-beginner) +* [NLP入门推荐书目（2019版）](https://zhuanlan.zhihu.com/p/58874484) + +##### 深度强化学习 +* [CS234: Reinforcement Learning](http://web.stanford.edu/class/cs234/index.html) + +#### 深入理解 +* [《深度学习》 Yoshua Bengio.Ian GoodFellow](https://github.com/Mikoto10032/DeepLearning/blob/master/books/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0.Yoshua%20Bengio%2BIan%20GoodFellow.pdf):star:   +* [《自然语言处理》Jacob Eisenstein](https://github.com/Mikoto10032/DeepLearning/blob/master/books/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86.Jacob%20Eisenstein.pdf) +* [《强化学习》](https://github.com/Mikoto10032/DeepLearning/blob/master/books/Reinforcement%20Learning.Sutton.pdf) && [第二版](http://incompleteideas.net/book/RLbook2018trimmed.pdf) +* [hangdong的深度学习博客,论文推荐](https://handong1587.github.io/categories.html#deep_learning-ref) +* [Practical Deep Learning for Coders, v3](https://course.fast.ai/) +* [《Tensorflow实战Google深度学习框架》 郑泽宇 顾思宇](https://github.com/Mikoto10032/DeepLearning/blob/master/books/Tensorflow%20实战Google深度学习框架.pdf) + +#### 一些书单 + +* [2019年最新-深度学习、生成对抗、Pytorch优秀教材推荐](https://zhuanlan.zhihu.com/p/63784033) + +### 工程能力 + +![](https://pic4.zhimg.com/v2-009013278688f520c070b27910255cb1_r.jpg) + +* [如何系统地学习算法？](https://www.zhihu.com/question/20588261/answer/798928056) && [LeetCode](https://leetcode.com/) && [leetcode题解](https://github.com/azl397985856/leetcode) && [《算法导论》中算法的C++实现](https://github.com/huaxz1986/cplusplus-_Implementation_Of_Introduction_to_Algorithms) +* [机器学习算法实战](#机器学习实战篇) +* [深度学习框架](#深度学习框架) +* [如何成为一名算法工程师](https://mp.weixin.qq.com/s/YMtnBAVDZepsMTO4h-VRtQ) && [从小白到入门算法，我的经验分享给你～](https://mp.weixin.qq.com/s?__biz=MzAxMjcyNjE5MQ==&mid=2650488786&idx=1&sn=68b9536d0b0b3105ab8d79f8efcb0a4b&chksm=83a2e512b4d56c045c6ab0349108842e6a5b26e8f3e507ff5d19ee50e3bd63ef149a36d23eef&scene=0&xtrack=1&ascene=14&devicetype=android-28&version=27000437&nettype=WIFI&abtest_cookie=BAABAAoACwASABMABgAjlx4AVpkeANCZHgDcmR4A8ZkeAAOaHgAAAA%3D%3D&lang=zh_CN&pass_ticket=4yovfEr0v09yZCvvQ1NEy12qGIonnRpGi774X09Mh5EZD2oL%2BRz6FTtX9R5gALB1&wx_header=1) && [我的研究生这三年](https://zhuanlan.zhihu.com/p/54161673) :star: +* [编程面试的题目分类](https://zhuanlan.zhihu.com/p/89392459) +* [《AI算法工程师手册》](http://www.huaxiaozhuan.com/) +* [如何准备算法工程师面试，斩获一线互联网公司机器学习岗offer？](https://zhuanlan.zhihu.com/p/76827460) +* [【完结】深度学习CV算法工程师从入门到初级面试有多远，大概是25篇文章的距离](https://mp.weixin.qq.com/s/HZ3Cd2jHuikyFN9ydvcMTw) +* [ 计算机相关技术面试必备](https://github.com/CyC2018/CS-Notes) && [CS-WiKi](https://veal98.gitee.io/cs-wiki/#/) && [计算机基础面试问题全面总结](https://github.com/wolverinn/Waking-Up) && [TeachYourselfCS-CN](https://github.com/keithnull/TeachYourselfCS-CN) && [面试算法笔记-中文](https://github.com/imhuay/Algorithm_for_Interview-Chinese) +* [算法工程师面试](https://github.com/DarLiner/Algorithm_Interview_Notes-Chinese) +* [深度学习面试题目](https://github.com/ShanghaiTechAIClub/DLInterview) +* [深度学习500问](https://github.com/scutan90/DeepLearning-500-questions) +* [AI算法岗求职攻略](https://github.com/amusi/AI-Job-Notes#Strategy) +* [Kaggle实战]() + * 常用算法： + * Feature Engineering：continue variable && categorical variable + * Classic machine learning algorithm：LR, KNN, SVM, Random Forest, GBDT(XGBoost&&LightGBM), Factorization Machine, Field-aware Factorization Machine, Neural Network + * Cross validation, model selection：grid search, random search, hyper-opt + * Ensemble learning + * [kaggle竞赛宝典第一章-竞赛框架篇！:star:](https://mp.weixin.qq.com/s/EGiFG6u9BYr1aBdq0a0wIQ) + * [Kaggle 项目实战（教程） = 文档 + 代码 + 视频](https://github.com/apachecn/kaggle) + * [Kaggle入门系列：（一）机器学习环境搭建](https://zhuanlan.zhihu.com/p/29086448) && [Kaggle入门系列：（二）Kaggle简介](https://zhuanlan.zhihu.com/p/29417603) && [Kaggle入门系列（三）Titanic初试身手](https://zhuanlan.zhihu.com/p/29086614) + * [从 0 到 1 走进 Kaggle](https://zhuanlan.zhihu.com/p/61660061) + * [Kaggle 入门指南](https://zhuanlan.zhihu.com/p/25742261) + * [一个框架解决几乎所有机器学习问题](https://zhuanlan.zhihu.com/p/61657532) && [Approaching (Almost) Any Machine Learning Problem | Abhishek Thakur](http://blog.kaggle.com/2016/07/21/approaching-almost-any-machine-learning-problem-abhishek-thakur/) + * [分分钟带你杀入Kaggle Top 1%](https://zhuanlan.zhihu.com/p/27424282) + * [如何达到Kaggle竞赛top 2%？这里有一篇特征探索经验帖](https://zhuanlan.zhihu.com/p/48758045) + * [如何在 Kaggle 首战中进入前 10%？](https://zhuanlan.zhihu.com/p/27486736) + * [Kaggle 首战 Top 2%, APTOS 2019 复盘总结 + 机器学习竞赛通用流程归纳](http://bbs.cvmart.net/topics/1717) + * [kaggle的riiid比赛里关于数据处理时间空间优化的笔记](https://zhuanlan.zhihu.com/p/344388290) +* [大数据&机器学习相关竞赛推荐](https://blog.csdn.net/weixin_33739541/article/details/87565983) + +## 二. 神经网络模型概览 + +* [1. 一文看懂25个神经网络模型](https://blog.csdn.net/qq_35082030/article/details/73368962) +* [2. DNN概述论文：详解前馈、卷积和循环神经网络技术](https://zhuanlan.zhihu.com/p/29141828) +* [3. colah's blog](http://colah.github.io/) +* [4. Model Zoom](https://modelzoo.co/) +* [5. DNN概述](https://zhuanlan.zhihu.com/p/29141828) +* [GitHub上的机器学习/深度学习综述项目合集](https://zhuanlan.zhihu.com/p/60245227) +* [AlphaTree-graphic-deep-neural-network](https://github.com/weslynn/AlphaTree-graphic-deep-neural-network) + +### CNN + +#### 发展史 + +* [94页论文综述卷积神经网络：从基础技术到研究前景](https://zhuanlan.zhihu.com/p/35388569) + +##### 图像分类 + +* [从LeNet-5到DenseNet](https://zhuanlan.zhihu.com/p/31006686) +* [深度学习笔记（十一）网络 Inception, Xception, MobileNet, ShuffeNet, ResNeXt, SqueezeNet, EfficientNet, MixConv](https://www.cnblogs.com/xuanyuyt/p/11329998.html) +* [CNN网络结构的发展](https://zhuanlan.zhihu.com/p/68411179) +* [Awesome - Image Classification：论文&&代码大全](https://github.com/weiaicunzai/awesome-image-classification) +* [pytorch-image-models](https://github.com/rwightman/pytorch-image-models) + +##### 目标检测 + +- [深度学习之目标检测的前世今生（Mask R-CNN）](https://zhuanlan.zhihu.com/p/32830206) +- [深度学习目标检测模型全面综述：Faster R-CNN、R-FCN和SSD](https://zhuanlan.zhihu.com/p/29434605) +- [从RCNN到SSD，这应该是最全的一份目标检测算法盘点](https://zhuanlan.zhihu.com/p/36184131) +- [目标检测算法综述三部曲](https://zhuanlan.zhihu.com/p/40047760) + - [基于深度学习的目标检测算法综述（一）](https://zhuanlan.zhihu.com/p/40047760) + - [基于深度学习的目标检测算法综述（二）](https://zhuanlan.zhihu.com/p/40020809) + - [基于深度学习的目标检测算法综述（三）](https://zhuanlan.zhihu.com/p/40102001) +- [From RCNN to YOLOv3]()：[上](https://zhuanlan.zhihu.com/p/35724768)，[下](https://zhuanlan.zhihu.com/p/35731743) +- [后 R-CNN时代， Faster R-CNN、SSD、YOLO 各类变体统治下的目标检测综述：Faster R-CNN系列胜了吗？](https://zhuanlan.zhihu.com/p/38709522) +- [目标检测进化史](https://zhuanlan.zhihu.com/p/60590369) +- [CVPR2019目标检测方法进展综述](https://zhuanlan.zhihu.com/p/59376548) +- [一文看尽21篇目标检测最新论文（腾讯/Google/商汤/旷视/清华/浙大/CMU/华科/中科院等](https://zhuanlan.zhihu.com/p/61080508) +- [我这两年的目标检测](https://zhuanlan.zhihu.com/p/82491218) +- [Anchor-Free目标检测算法](): [第一篇：arxiv2015_baidu_DenseBox](https://zhuanlan.zhihu.com/p/40221183)， [如何评价最新的anchor-free目标检测模型FoveaBox？](https://www.zhihu.com/question/319605567/answer/647844997), [FCOS: 最新的one-stage逐像素目标检测算法](https://zhuanlan.zhihu.com/p/61644900) && [最新的Anchor-Free目标检测模型FCOS，现已开源！](https://zhuanlan.zhihu.com/p/62198865) && [中科院牛津华为诺亚提出CenterNet，one-stage detector可达47AP，已开源！](https://zhuanlan.zhihu.com/p/62789701) && [AnchorFreeDetection](https://github.com/VCBE123/AnchorFreeDetection) +- [Anchor free深度学习的目标检测方法](https://zhuanlan.zhihu.com/p/64563186) +- [聊聊Anchor的"前世今生"（上）](https://zhuanlan.zhihu.com/p/63273342)&&[聊聊Anchor的"前世今生"（下）](https://zhuanlan.zhihu.com/p/68291859) +- [目标检测算法综述之FPN优化篇](https://zhuanlan.zhihu.com/p/62975854) && [一文看尽物体检测中的各种FPN](https://zhuanlan.zhihu.com/p/148738276) +- [awesome-object-detection：论文&&代码](https://github.com/amusi/awesome-object-detection) +- [deep_learning_object_detection](https://github.com/hoya012/deep_learning_object_detection) +- [ObjectDetectionImbalance](https://github.com/kemaloksuz/ObjectDetectionImbalance) + +##### 图像分割（语义分割、实例分割、全景分割） + +* [图像语义分割(Semantic segmentation) Survey](https://zhuanlan.zhihu.com/p/36801104) +* [干货 | 一文概览主要语义分割网络](https://blog.csdn.net/qq_20084101/article/details/80432960) +* [语义分割 发展综述](https://zhuanlan.zhihu.com/p/37618829) +* [9102年了，语义分割的入坑指南和最新进展都是什么样的](https://zhuanlan.zhihu.com/p/76603228) +* [实例分割最新最全面综述：从Mask R-CNN到BlendMask](https://zhuanlan.zhihu.com/p/110132002) +* [语义分割综述：深度学习背景下的语义分割的发展状况【推荐】](https://zhuanlan.zhihu.com/p/133212654) +* [Awesome Semantic Segmentation：论文&&代码](https://github.com/mrgloom/awesome-semantic-segmentation) +* [一篇看完就懂的最新语义分割综述](https://zhuanlan.zhihu.com/p/110123136) +* [基于深度学习的语义分割综述](https://zhuanlan.zhihu.com/p/142451150) + +##### 轻量化卷积神经网络 + +- [纵览轻量化卷积神经网络：SqueezeNet、MobileNet、ShuffleNet、Xception](https://zhuanlan.zhihu.com/p/32746221) + +##### 人脸相关 + +* [如何走近深度学习人脸识别？你需要这篇超长综述 | 附开源代码](https://zhuanlan.zhihu.com/p/35295839) +* [人脸检测和识别算法综述]()       + * [人脸检测算法综述 ](https://zhuanlan.zhihu.com/p/36621308)           + * [人脸检测背景介绍和发展现状](https://zhuanlan.zhihu.com/p/32702868) + * [人脸识别算法演化史](https://zhuanlan.zhihu.com/p/36416906) + * [CascadeCNN](https://blog.csdn.net/shuzfan/article/details/50358809)   + * [MTCNN](https://blog.csdn.net/qq_14845119/article/details/52680940) + * [awesome-Face_Recognition](https://github.com/ChanChiChoi/awesome-Face_Recognition) + * [异质人脸识别研究综述](https://zhuanlan.zhihu.com/p/64191484) + * [老板来了：人脸识别+手机推送，老板来了你立刻知道。](https://zhuanlan.zhihu.com/p/26431250)&& [手把手教你用Python实现人脸识别](https://zhuanlan.zhihu.com/p/33456076) && [人脸识别项目，网络模型，损失函数，数据集相关总结](https://www.jianshu.com/p/e57205edc364) + * [基于深度学习的人脸识别技术综述](https://zhuanlan.zhihu.com/p/24816781) && [如何走近深度学习人脸识别？你需要这篇超长综述](https://zhuanlan.zhihu.com/p/35295839) && [人脸识别损失函数综述（附开源实现）](https://zhuanlan.zhihu.com/p/51324547) && [Face Recognition Loss on Mnist with Pytorch](https://zhuanlan.zhihu.com/p/64427565) && [人脸识别的LOSS（上）](https://zhuanlan.zhihu.com/p/34404607) && [人脸识别的LOSS（下）](https://zhuanlan.zhihu.com/p/34436551) +* [人脸关键点检测]() + * [【每周CV论文推荐】 初学深度学习人脸关键点检测必读文章](https://zhuanlan.zhihu.com/p/88344339) + * [从传统方法到深度学习，人脸关键点检测方法综述](https://mp.weixin.qq.com/s/CvdeV5xgUF0kStJQdRst0w) + * [人脸关键点检测综述](https://zhuanlan.zhihu.com/p/42968117) + * [人脸专集4 | 遮挡、光照等因素的人脸关键点检测](https://zhuanlan.zhihu.com/p/62824113) + * [【Face key point detection】人脸关键点检测实现](https://zhuanlan.zhihu.com/p/52525598) + * [OpenCV实战：人脸关键点检测（FaceMark）](https://zhuanlan.zhihu.com/p/35390012) + * [CenterFace+TensorRT部署人脸和关键点检测400fps](https://zhuanlan.zhihu.com/p/106774468) + +##### 图像超分辨率 + +* [深度学习图像超分辨率综述](https://zhuanlan.zhihu.com/p/57564211) +* [从SRCNN到EDSR，总结深度学习端到端超分辨率方法发展历程](https://zhuanlan.zhihu.com/p/31664818) + +##### 行人重识别 + +* [【CVPR2019正式公布】行人重识别论文](https://zhuanlan.zhihu.com/p/62843442) +* [【CVPR2019正式公布】行人重识别论文](https://zhuanlan.zhihu.com/p/62843442)，[2019 行人再识别年度进展回顾](https://zhuanlan.zhihu.com/p/64004977) + +##### 图像着色 + +* [Awesome-Image-Colorization](https://github.com/MarkMoHR/Awesome-Image-Colorization) + +##### 边检测 + +* [Awesome-Edge-Detection-Papers](https://github.com/MarkMoHR/Awesome-Edge-Detection-Papers) + +##### OCR&&文本检测 + +* [2019CVPR文本检测综述](https://zhuanlan.zhihu.com/p/67319122) +* [OCR文字处理](https://zhuanlan.zhihu.com/p/65707543) +* [自然场景文本检测识别技术综述](https://mp.weixin.qq.com/s?__biz=MzU4MjQ3MDkwNA==&mid=2247485142&idx=1&sn=c0e01da30eb5e750be453eabe4be2bf4&chksm=fdb69b41cac11257ae22c7dac395e9651dab628fc35dd6d3c02d9566a8c7f5f2b56353d58a64&token=1065243837&lang=zh_CN#rd) + +##### 点云 + +* [awesome-point-cloud-analysis](https://zhuanlan.zhihu.com/p/65690433) + +##### 细粒度图像分类 + +* [超全深度学习细粒度图像分析：项目、综述、教程一网打尽](https://zhuanlan.zhihu.com/p/73542103) + +##### 图像检索 + +* 图像检索的十年[上](https://mp.weixin.qq.com/s/sM78DCOK3fuG2JrP2QaSZA)、[下](https://mp.weixin.qq.com/s/yzVMDEpwbXVS0y-CwWSBEA) + +##### 人群计数 + +* [人群计数](http://chuansong.me/n/443237851736), [1](https://www.cnblogs.com/wmr95/p/8134692.html), [2](https://blog.csdn.net/u011285477/article/details/51954989), [3](https://blog.csdn.net/qingqingdeaini/article/details/79922549) + +#### 教程 + +##### 前馈神经网络 + +* [从基本原理到梯度下降，小白都能看懂的神经网络教程](https://zhuanlan.zhihu.com/p/59385110) + +##### 激活函数 + +* [激活函数一览](https://zhuanlan.zhihu.com/p/30567264) && [深度学习中几种常见的激活函数理解与总结](https://www.cnblogs.com/XDU-Lakers/p/10557496.html) +* [一个激活函数需要具有哪些必要的属性](https://www.zhihu.com/question/67366051) + +##### 反向传播算法 + +* [反向传播算法（过程及公式推导）](https://blog.csdn.net/u014313009/article/details/51039334) +* [通俗理解神经网络BP传播算法](https://zhuanlan.zhihu.com/p/24801814) + +##### 优化问题 + +* [神经网络训练中的梯度消失与梯度爆炸](https://zhuanlan.zhihu.com/p/25631496) +* [梯度消失和梯度爆炸问题详解](https://www.jianshu.com/p/3f35e555d5ba) +* [详解深度学习中的梯度消失、爆炸原因及其解决方法](https://zhuanlan.zhihu.com/p/33006526) && [神经网络梯度消失和梯度爆炸及解决办法](https://blog.csdn.net/program_developer/article/details/80032376) + +##### 卷积层 + +* [A Comprehensive Introduction to Different Types of Convolutions in Deep Learning](https://towardsdatascience.com/a-comprehensive-introduction-to-different-types-of-convolutions-in-deep-learning-669281e58215) && 翻译：[上](https://www.leiphone.com/news/201902/D2Mkv61w9IPq9qGh.html)、[下](https://www.leiphone.com/news/201902/biIqSBpehsaXFwpN.html?uniqueCode=OTEsp9649VqJfUcO) +* [卷积有多少种？一文读懂深度学习中的各种卷积](https://zhuanlan.zhihu.com/p/57575810) +* [各种卷积](https://www.cnblogs.com/cvtoEyes/p/8848815.html) +* [Convolution Network及其变种（反卷积、扩展卷积、因果卷积、图卷积）](https://www.cnblogs.com/yangperasd/p/7071657.html) +* [深度学习基础--卷积类型](https://zhuanlan.zhihu.com/p/59839551) +* [变形卷积核、可分离卷积](https://zhuanlan.zhihu.com/p/28749411) +* [对深度可分离卷积、分组卷积、扩张卷积、转置卷积（反卷积）的理解](https://blog.csdn.net/chaolei3/article/details/79374563) +* [反卷积](https://buptldy.github.io/2016/10/29/2016-10-29-deconv/) +* [Dilated/Atrous conv 空洞卷积/多孔卷积](https://blog.csdn.net/silence2015/article/details/79748729) +* [卷积层输出大小尺寸计算及 “SAME” 和 “VALID”](https://blog.csdn.net/weixin_37697191/article/details/89527315) && [卷积的三种模式full, same, valid以及padding的same, valid](https://zhuanlan.zhihu.com/p/62760780) +* [正常卷积与空洞卷积输出特征图与感受野大小的计算](https://blog.csdn.net/qq_43232545/article/details/103317773) +* [【Tensorflow】tf.nn.depthwise_conv2d如何实现深度卷积?](https://blog.csdn.net/mao_xiao_feng/article/details/78003476) +* [【Tensorflow】tf.nn.atrous_conv2d如何实现空洞卷积？](https://blog.csdn.net/mao_xiao_feng/article/details/78003730) +* [【Tensorflow】tf.nn.separable_conv2d如何实现深度可分卷积?](https://blog.csdn.net/mao_xiao_feng/article/details/78002811) +* [【TensorFlow】tf.nn.conv2d_transpose是怎样实现反卷积的？](https://blog.csdn.net/mao_xiao_feng/article/details/71713358) + +##### 池化层 + +* [卷积神经网络中的各种池化操作](https://zhuanlan.zhihu.com/p/112216409) + +##### 卷积神经网络 + +- [卷积神经网络工作原理](https://www.zhihu.com/question/39022858) +- [「七夕的礼物」: 一日搞懂卷积神经网络](https://zhuanlan.zhihu.com/p/28863709) +- [一文读懂卷积神经网络中的1x1卷积核](https://zhuanlan.zhihu.com/p/40050371) +- [如何理解神经网络中通过add和concate的方式融合特征？](https://blog.csdn.net/xiaojiajia007/article/details/86008415) && [神经网络中对需要concat的特征进行线性变换然后相加是否好于直接concat?](https://www.zhihu.com/question/389912594/answer/1178054600) +- [CNN 模型所需的计算力（flops）和参数（parameters）数量是怎么计算的？](https://www.zhihu.com/question/65305385) && [深度学习中卷积的参数量和计算量](https://www.cnblogs.com/hejunlin1992/p/12978988.html) + +##### 图像分类网络详解 + +* [经典CNN模型LeNet解读](https://zhuanlan.zhihu.com/p/41736894) +* [机器学习进阶笔记之三 | 深入理解Alexnet](https://zhuanlan.zhihu.com/p/22659166) +* [一文读懂VGG网络](https://zhuanlan.zhihu.com/p/41423739) +* [Inception V1,V2,V3,V4 模型总结](https://zhuanlan.zhihu.com/p/52802896) +* [ResNet解析](https://blog.csdn.net/lanran2/article/details/79057994) +* [一文简述ResNet及其多种变体](https://zhuanlan.zhihu.com/p/35985680) +* [CapsNet入门系列](http://mp.weixin.qq.com/s?__biz=MzI3ODkxODU3Mg==&mid=2247484099&idx=1&sn=97e209f1a9860c8d8c51e81d98fc8a0a&chksm=eb4ee600dc396f16624a33cdfc0ead905e62ae9447b49b20146020e6cbd7d71f089101512a40&scene=21#wechat_redirect) + - [CapsNet入门系列之一：胶囊网络背后的直觉](http://mp.weixin.qq.com/s?__biz=MzI3ODkxODU3Mg==&mid=2247484099&idx=1&sn=97e209f1a9860c8d8c51e81d98fc8a0a&chksm=eb4ee600dc396f16624a33cdfc0ead905e62ae9447b49b20146020e6cbd7d71f089101512a40&scene=21#wechat_redirect) + - [CapsNet入门系列之二：胶囊如何工作](http://mp.weixin.qq.com/s?__biz=MzI3ODkxODU3Mg==&mid=2247484165&idx=1&sn=0ca679e3a5f499f8d8addb405fe3df83&chksm=eb4ee7c6dc396ed0a330fcac12690110bcaf9a8a10794dbc5e1a326c69ecbb140140f55fd6ba&scene=21#wechat_redirect) + - [CapsNet入门系列之三：囊间动态路由算法](http://mp.weixin.qq.com/s?__biz=MzI3ODkxODU3Mg==&mid=2247484433&idx=1&sn=3afe4605bc2501eebbc41c6dd1af9572&chksm=eb4ee0d2dc3969c4619d6c1097d5c949c76c6c854e60d36eba4388da2c3855747818d062c90a&scene=21#wechat_redirect) + - [CapsNet入门系列之四：胶囊网络架构](https://mp.weixin.qq.com/s/6CRSen8P6zKaMGtX8IRfqw) +* [深入剖析MobileNet和它的变种（例如：ShuffleNet）为什么会变快？](https://zhuanlan.zhihu.com/p/158591662) +* [CNN模型之ShuffleNet](https://zhuanlan.zhihu.com/p/32304419) +* [ShuffleNet V2和四个网络架构设计准则](https://zhuanlan.zhihu.com/p/40980942) +* [ResNeXt 深入解读与模型实现](https://zhuanlan.zhihu.com/p/78019001) +* [如何评价Momenta ImageNet 2017夺冠架构SENet?](https://www.zhihu.com/question/63460684) +* [CBAM：卷积块注意力模块](https://zhuanlan.zhihu.com/p/79419670) && [CBAM: Convolutional Block Attention Module](https://zhuanlan.zhihu.com/p/65529934) +* [SKNet——SENet孪生兄弟篇](https://zhuanlan.zhihu.com/p/59690223) +* [GCNet：当Non-local遇见SENet](https://zhuanlan.zhihu.com/p/64988633) +* [深度学习笔记（十一）网络 Inception, Xception, MobileNet, ShuffeNet, ResNeXt, SqueezeNet, EfficientNet, MixConv](https://www.cnblogs.com/xuanyuyt/p/11329998.html) +* [如何评价最新的Octave Convolution？](https://www.zhihu.com/question/320462422) +* [ResNeSt 之语义分割](https://zhuanlan.zhihu.com/p/136105870) && [关于ResNeSt的点滴疑惑](https://zhuanlan.zhihu.com/p/133805433) && [ResNeSt在刷榜之后被ECCV2020 strong reject](https://zhuanlan.zhihu.com/p/143214871) + +##### 目标检测网络详解 + +* [目标检测的性能评价指标](https://zhuanlan.zhihu.com/p/70306015) && [NMS和计算mAP时的置信度阈值和IoU阈值 ](https://zhuanlan.zhihu.com/p/75348108) && [白话mAP](https://zhuanlan.zhihu.com/p/60834912) && [目标检测模型的评估指标mAP详解(附代码）](https://zhuanlan.zhihu.com/p/37910324) +* [深度学习中IU、IoU(Intersection over Union)](https://blog.csdn.net/iamoldpan/article/details/78799857) +* [Selective Search for Object Detection ](https://www.learnopencv.com/selective-search-for-object-detection-cpp-python/)[（译文）](https://blog.csdn.net/guoyunfei20/article/details/78723646) +* [Region Proposal Network(RPN)](https://zhuanlan.zhihu.com/p/106192020) +* [边框回归(Bounding Box Regression)详解](https://blog.csdn.net/zijin0802034/article/details/77685438) +* [NMS——非极大值抑制](https://blog.csdn.net/shuzfan/article/details/52711706) && [非极大值抑制NMS的python实现](https://zhuanlan.zhihu.com/p/128125301) +* [一文打尽目标检测NMS——精度提升篇](https://zhuanlan.zhihu.com/p/151914931) && [一文打尽目标检测NMS——效率提升篇](https://zhuanlan.zhihu.com/p/157900024) +* [目标检测回归损失函数简介：SmoothL1/IoU/GIoU/DIoU/CIoU Loss](https://zhuanlan.zhihu.com/p/104236411) +* [将CNN引入目标检测的开山之作：R-CNN](https://zhuanlan.zhihu.com/p/23006190) +* [R-CNN论文详解](https://blog.csdn.net/u014696921/article/details/52824097) +* [深度学习（十八）基于R-CNN的物体检测](https://blog.csdn.net/hjimce/article/details/50187029) +* [Fast R-CNN](https://zhuanlan.zhihu.com/p/24780395) +* [深度学习（六十四）Faster R-CNN物体检测](https://blog.csdn.net/hjimce/article/details/73382553) && [你真的学会RoI Pooling了吗?](https://zhuanlan.zhihu.com/p/59692298) +* [目标检测论文阅读：Feature Pyramid Networks for Object Detection](https://zhuanlan.zhihu.com/p/36461718) +* [SSD](https://zhuanlan.zhihu.com/p/24954433) +* [实例分割--Mask RCNN详解(ROI Align / Loss Function)](https://www.codetd.com/article/2554465) && [令人拍案称奇的Mask RCNN](https://zhuanlan.zhihu.com/p/37998710) +* [何恺明大神的「Focal Loss」，如何更好地理解？](https://zhuanlan.zhihu.com/p/32423092) && [FocalLoss 对样本不平衡的权重调节和减低损失值](https://zhuanlan.zhihu.com/p/82148525) && [focal_loss 多类别和二分类 Pytorch代码实现](https://blog.csdn.net/qq_33278884/article/details/91572173) && [多分类focal loss及其tensorflow实现](https://blog.csdn.net/qq_39012149/article/details/96184383) +* [堪比Focal Loss！解决目标检测中样本不平衡的无采样方法](https://zhuanlan.zhihu.com/p/93658728) +* [目标检测正负样本区分策略和平衡策略总结(一)](https://zhuanlan.zhihu.com/p/138824387) && [目标检测正负样本区分策略和平衡策略总结(二)](https://zhuanlan.zhihu.com/p/138828372) && [目标检测正负样本区分策略和平衡策略总结(三）](https://zhuanlan.zhihu.com/p/144659734) +* [YOLO](http://www.mamicode.com/info-detail-2314392.html) && [目标检测|YOLO原理与实现](https://zhuanlan.zhihu.com/p/32525231) && [图解YOLO](https://zhuanlan.zhihu.com/p/24916786) && [【论文解读】Yolo三部曲解读——Yolov1](https://zhuanlan.zhihu.com/p/70387154) +* [目标检测|YOLOv2原理与实现(附YOLOv3)](https://zhuanlan.zhihu.com/p/35325884?group_id=966229905398362112) && [YOLO2](https://zhuanlan.zhihu.com/p/25167153) && [【论文解读】Yolo三部曲解读——Yolov2](https://zhuanlan.zhihu.com/p/74540100) +* [<机器爱学习>YOLO v3深入理解](https://zhuanlan.zhihu.com/p/49556105) && [【论文解读】Yolo三部曲解读——Yolov3](https://zhuanlan.zhihu.com/p/76802514) +* [YOLOv4](https://zhuanlan.zhihu.com/p/138510087) +* [目标检测之CornerNet](https://arxiv.org/abs/1808.01244), [1](https://zhuanlan.zhihu.com/p/41825737), [2](https://blog.csdn.net/Hibercraft/article/details/81637451), [3](https://zhuanlan.zhihu.com/p/41759548) +* [目标检测小tricks--样本不均衡处理](https://zhuanlan.zhihu.com/p/60612064) + +##### 图像分割网络详解 + +* [超像素、语义分割、实例分割、全景分割 傻傻分不清 ](https://zhuanlan.zhihu.com/p/50996404) && [语义分割、实例分割和全景分割的区别](https://blog.csdn.net/u013066730/article/details/103613154) +* [语义分割卷积神经网络快速入门](https://blog.csdn.net/qq_20084101/article/details/80455877) +* [图像语义分割入门+FCN/U-Net网络解析](https://zhuanlan.zhihu.com/p/31428783) && [深入理解深度学习分割网络Ｕnet](https://blog.csdn.net/Formlsl/article/details/80373200) +* [Unet神经网络为什么会在医学图像分割表现好？](https://www.zhihu.com/question/269914775) +* [图像语义分割的工作原理和CNN架构变迁](https://zhuanlan.zhihu.com/p/38033032) +* [语义分割中的Attention和低秩重建](https://zhuanlan.zhihu.com/p/77834369) +* [打通多个视觉任务的全能Backbone:HRNet](https://zhuanlan.zhihu.com/p/134253318) + +##### 注意力机制 + +* [深度学习中的注意力模型（2017版）](https://zhuanlan.zhihu.com/p/37601161) +* [Attention Model（mechanism） 的 套路](https://blog.csdn.net/bvl10101111/article/details/78470716) +* [计算机视觉中的注意力机制（推荐）](https://zhuanlan.zhihu.com/p/146130215) +* [More About Attention（推荐）](https://zhuanlan.zhihu.com/p/106662375) +* [计算机视觉中的注意力机制](https://zhuanlan.zhihu.com/p/32928645) +* [NLP中的Attention Mechanism](https://zhuanlan.zhihu.com/p/31547842) +* [Transformer中的Attention](https://mp.weixin.qq.com/s/k8PdZAld2ANVoekuyQxI3w) +* [综述：图像处理中的注意力机制](https://bbs.cvmart.net/topics/2581) + +##### 特征融合 + +* [盘点目标检测中的特征融合技巧（根据YOLO v4总结）](https://zhuanlan.zhihu.com/p/141685352) +* [多尺度融合介绍](https://zhuanlan.zhihu.com/p/147820687) + +#### Action + +* [PyTorch官方实现ResNet](https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py) && [pytorch_resnet_cifar10](https://github.com/akamaster/pytorch_resnet_cifar10) +* [PyTorch 63.Coding for FLOPs, Params and Latency](https://zhuanlan.zhihu.com/p/268816646) +* [先读懂CapsNet架构然后用TensorFlow实现](https://zhuanlan.zhihu.com/p/30753326) +* [目标检测-20种模型的原味代码汇总](https://zhuanlan.zhihu.com/p/37056927) +* [TensorFlow Object Detection API 教程](https://blog.csdn.net/qq_36148847/article/details/79306762) + * [TensorFlow 对象检测 API 教程1](https://blog.csdn.net/qq_36148847/article/details/79306762) + * [TensorFlow 对象检测 API 教程2](https://blog.csdn.net/qq_36148847/article/details/79307598) + * [TensorFlow 对象检测 API 教程3](https://blog.csdn.net/qq_36148847/article/details/79307751) + * [TensorFlow 对象检测 API 教程 4](https://blog.csdn.net/qq_36148847/article/details/79307931) + * [TensorFlow 对象检测 API 教程5](https://blog.csdn.net/qq_36148847/article/details/79307933) +* [在TensorFlow+Keras环境下使用RoI池化一步步实现注意力机制](https://zhuanlan.zhihu.com/p/65327747) +* [mxnet如何查看参数数量](https://discuss.gluon.ai/t/topic/7216) && [mxnet查看FLOPS](https://github.com/likelyzhao/CalFLOPS-Mxnet) +* [Pytorch-UNet](https://github.com/milesial/Pytorch-UNet) +* [segmentation_models.pytorch](https://github.com/qubvel/segmentation_models.pytorch) + +### GAN + +#### 发展史 + +* [千奇百怪的GAN变体](https://zhuanlan.zhihu.com/p/26491601) +* [苏剑林博客，讲解得淋漓尽致](https://kexue.fm/tag/GAN/) +* [The GAN Landscape：Losses, Architectures, Regularization, and Normalization](https://arxiv.org/pdf/1807.04720.pdf) +* [深度学习新星：GAN的基本原理、应用和走向](https://www.leiphone.com/news/201701/Kq6FvnjgbKK8Lh8N.html) +* [GAN生成图像综述](https://zhuanlan.zhihu.com/p/62746494) +* [2017年GAN 计算机视觉相关paper汇总](https://zhuanlan.zhihu.com/p/29882709) +* [必读的10篇关于GAN的论文](https://zhuanlan.zhihu.com/p/72745900) + +#### 教程 + +* [GAN原理学习笔记](https://zhuanlan.zhihu.com/p/27295635) +* [GAN万字长文综述](https://zhuanlan.zhihu.com/p/58812258) +* [极端图像压缩的对抗生成网络](https://zhuanlan.zhihu.com/p/35783437?group_id=969598777652420608) +* [台湾大学李宏毅GAN教程](https://www.youtube.com/watch?v=0CKeqXl5IY0&feature=youtu.be) + * [Basic](https://github.com/Mikoto10032/DeepLearning/blob/master/books/GAN-Basic%20Idea%20(2017.04.21).pdf) + * [Improving](https://github.com/Mikoto10032/DeepLearning/blob/master/books/GAN-Improving%20GAN%20(2017.05.05).pdf) +* [CycleGAN：图片风格，想换就换 | ICCV 2017论文解读](https://zhuanlan.zhihu.com/p/34711316) +* [Wasserstein GAN](https://zhuanlan.zhihu.com/p/25071913) && [GAN：两者分布不重合JS散度为log2的数学证明](https://blog.csdn.net/Invokar/article/details/88917214) +* [用变分推断统一理解生成模型（VAE、GAN、AAE、ALI）](https://zhuanlan.zhihu.com/p/40105143) +#### Action + +* [GAN学习指南：从原理入门到制作生成Demo](https://zhuanlan.zhihu.com/p/24767059) +* [机器之心GitHub项目：GAN完整理论推导与实现](https://zhuanlan.zhihu.com/p/29837245) +* [在Keras上实现GAN：构建消除图片模糊的应用](https://zhuanlan.zhihu.com/p/35030377) + +### RNN + +#### 发展史 + +* [从90年代的SRNN开始，纵览循环神经网络27年的研究进展](https://zhuanlan.zhihu.com/p/32668465) + +#### 教程 + +* [Awesome-Chinese-NLP](https://github.com/crownpku/Awesome-Chinese-NLP) +* [nlp-pytorch-zh](https://github.com/apachecn/nlp-pytorch-zh) +* [完全图解RNN、RNN变体、Seq2Seq、Attention机制](https://zhuanlan.zhihu.com/p/28054589) +* [循环神经网络(RNN, Recurrent Neural Networks)介绍](https://blog.csdn.net/heyongluoyao8/article/details/48636251) +* [RNN以及LSTM的介绍和公式梳理](https://blog.csdn.net/Dark_Scope/article/details/47056361) +* [（译）理解长短期记忆(LSTM) 神经网络](https://zhuanlan.zhihu.com/p/24018768) +* [ 一文读懂LSTM和RNN](https://zhuanlan.zhihu.com/p/35878575?group_id=970350175025385472) +* [探索LSTM：基本概念到内部结构](https://zhuanlan.zhihu.com/p/27345523) +* [ 翻译：深入理解LSTM系列](https://blog.csdn.net/matrix_space/article/details/53374040)             +* [深入理解 LSTM 网络 (一)](https://blog.csdn.net/matrix_space/article/details/53374040) +* [深入理解 LSTM 网络 (二)](https://blog.csdn.net/matrix_space/article/details/53376870) +* [LSTM](https://zhuanlan.zhihu.com/p/32085405) +* [深度学习其五 循环神经网络](https://zybuluo.com/hanbingtao/note/541458)                       +* [用循环神经网络进行文件无损压缩：斯坦福大学提出DeepZip](https://zhuanlan.zhihu.com/p/32582764) +* [吴恩达序列建模课程]() + * [Coursera吴恩达《序列模型》课程笔记（1）-- 循环神经网络（RNN）](https://zhuanlan.zhihu.com/p/34309635) + * [Coursera吴恩达《序列模型》课程笔记（2）-- NLP & Word Embeddings](https://zhuanlan.zhihu.com/p/34975871) + * [Coursera吴恩达《序列模型》课程笔记（3）-- Sequence models & Attention mechanism](https://zhuanlan.zhihu.com/p/35532553) +* word2vec + + - 原理 + - [NLP 秒懂词向量Word2vec的本质](https://zhuanlan.zhihu.com/p/26306795) + - [一篇通俗易懂的word2vec](https://zhuanlan.zhihu.com/p/35500923) + - [YJango的Word Embedding--介绍](https://zhuanlan.zhihu.com/p/27830489) + - [nlp中的词向量对比：word2vec/glove/fastText/elmo/GPT/bert](https://zhuanlan.zhihu.com/p/56382372) + - [词嵌入（word2vec）](https://zh.diveintodeeplearning.org/chapter_natural-language-processing/word2vec.html) + - [谈谈谷歌word2vec的原理](https://blog.csdn.net/wangyangzhizhou/article/details/77073023) + - [Word2Vec中为什么使用负采样？](https://zhuanlan.zhihu.com/p/67117737) + - 训练词向量 + - [练习-word2vec](https://zhuanlan.zhihu.com/p/29200034) + - [word2vec方法的实现和应用](https://zhuanlan.zhihu.com/p/31886824) + - [自然语言处理入门 word2vec 使用tensorflow自己训练词向量](https://blog.csdn.net/wzdjsgf/article/details/79541492) + - [使用tensorflow实现word2vec中文词向量的训练](https://zhuanlan.zhihu.com/p/28979653) + - [如何用TensorFlow训练词向量](https://blog.csdn.net/wangyangzhizhou/article/details/77530479?locationNum=1&fps=1) +* [聊聊 Transformer](https://zhuanlan.zhihu.com/p/47812375) +* [基于Transform的机器翻译系统](https://zhuanlan.zhihu.com/p/144825330) +* [基于word2vec训练词向量(一)](https://zhuanlan.zhihu.com/p/35648927) +* [基于word2vec训练词向量(二)](https://zhuanlan.zhihu.com/p/35889385) +* [自然语言处理中的自注意力机制（Self-Attention Mechanism）](https://zhuanlan.zhihu.com/p/35041012)     +* [自然语言处理中注意力机制综述](https://zhuanlan.zhihu.com/p/54491016) +* [YJango的Word Embedding--介绍](https://zhuanlan.zhihu.com/p/27830489) + +#### Action + +* [推荐：nlp-tutorial](https://github.com/graykode/nlp-tutorial) +* [nlp-tutorial](https://github.com/lyeoni/nlp-tutorial) +* [tensorflow中RNNcell源码分析以及自定义RNNCell的方法](https://blog.csdn.net/liuchonge/article/details/78405185?locationNum=8&fps=1) +* [TensorFlow中RNN实现的正确打开方式](https://zhuanlan.zhihu.com/p/28196873) +* [TensorFlow RNN 代码](https://zhuanlan.zhihu.com/p/27906426) +* [Tensorflow实现的深度NLP模型集锦](https://zhuanlan.zhihu.com/p/67031035) +* [用tensorflow LSTM如何预测股票价格](https://zhuanlan.zhihu.com/p/33186759) +* [TensorFlow的多层LSTM实践](https://zhuanlan.zhihu.com/p/29797089) +* [《安娜卡列尼娜》文本生成——利用TensorFlow构建LSTM模型](https://zhuanlan.zhihu.com/p/27087310) + +### GNN + +#### 发展史 + +* [Graph Neural Network（GNN）综述](https://zhuanlan.zhihu.com/p/65539782) +* [深度学习时代的图模型，清华发文综述图网络](https://mp.weixin.qq.com/s?__biz=MzA3MzI4MjgzMw==&mid=2650754422&idx=4&sn=0dc881487f362322a875b4ce06e645f7&chksm=871a8908b06d001ef7386ccc752827c20711877a4a23d6a8318978095dd241d118257c607b22&scene=21#wechat_redirect) +* [清华大学图神经网络综述：模型与应用](https://mp.weixin.qq.com/s?__biz=MzA3MzI4MjgzMw==&mid=2650754558&idx=2&sn=7d79191b9ed30679d5d40e22d9cabdf8&chksm=871a8980b06d00962e0dbe984e1d3469214db31cb402b4725a0dfe330249a830b45cb26932b5&scene=21#wechat_redirect) +* [图神经网络概述第三弹：来自IEEE Fellow的GNN综述](https://zhuanlan.zhihu.com/p/54241746) +* [GNN最全文献资料整理](https://github.com/DeepGraphLearning/LiteratureDL4Graph) && [Awesome-Graph-Neural-Networks](https://github.com/nnzhan/Awesome-Graph-Neural-Networks) + +#### 教程 + +* [如何理解 Graph Convolutional Network（GCN）](https://www.zhihu.com/question/54504471) +* [图卷积网络(GCN)新手村完全指南](https://zhuanlan.zhihu.com/p/54505069) +* [何时能懂你的心——图卷积神经网络（GCN）](https://zhuanlan.zhihu.com/p/71200936) +* [图卷积网络GCN的理解与介绍](https://zhuanlan.zhihu.com/p/90470499) +* [一文读懂图卷积GCN](https://zhuanlan.zhihu.com/p/89503068) +* [2020 年 GNN 开卷有益与再谈图卷积](https://zhuanlan.zhihu.com/p/101310106) +* [【GCN】万字长文带你入门 GCN](https://zhuanlan.zhihu.com/p/120311352) +* [如何解决图神经网络（GNN）训练中过度平滑的问题？](https://www.zhihu.com/question/346942899/answer/848298494) +* [全连接的图卷积网络(GCN)和self-attention这些机制有什么区别联系](https://www.zhihu.com/question/366088445) && [CNN与GCN的区别、联系及融合](https://zhuanlan.zhihu.com/p/147654689) + +#### Action + +* [图卷积网络到底怎么做，这是一份极简的Numpy实现](https://zhuanlan.zhihu.com/p/57235377) +* [DGL](https://docs.dgl.ai/index.html) + +## 三. 深度模型的优化与正则化 + +* [1. 优化算法纵览](http://fa.bianp.net/teaching/2018/eecs227at/) +* [2. 从梯度下降到Adam](https://zhuanlan.zhihu.com/p/27449596) +* [3. 从梯度下降到拟牛顿法：盘点训练神经网络的五大学习算法](https://zhuanlan.zhihu.com/p/25703402) +* [4. 正则化技术总结](https://zhuanlan.zhihu.com/p/35429054?group_id=966442942538444800) + * [史上最全面的正则化技术总结与分析--part1](https://zhuanlan.zhihu.com/p/35429054?group_id=966442942538444800) + * [史上最全面的正则化技术总结与分析--part2](https://zhuanlan.zhihu.com/p/35432128?group_id=966443101011738624) +* [权重衰减（weight decay）与学习率衰减（learning rate decay）](https://zhuanlan.zhihu.com/p/38709373) && [pytorch必须掌握的的4种学习率衰减策略](https://zhuanlan.zhihu.com/p/93624972) +* [5. 最优化算法系列（math）](https://blog.csdn.net/chunyun0716/article/category/6188191/2) +* [6. 神经网络训练中的梯度消失与梯度爆炸](https://zhuanlan.zhihu.com/p/25631496)         +* [7. 神经网络的优化及训练](https://zhuanlan.zhihu.com/p/36050743) +* [8. 通俗讲解查全率和查准率](https://zhuanlan.zhihu.com/p/35888543) && [全面梳理：准确率,精确率,召回率,查准率,查全率,假阳性,真阳性,PRC,ROC,AUC,F1](https://zhuanlan.zhihu.com/p/34079183) && [机器学习之类别不平衡问题 (1) —— 各种评估指标](https://zhuanlan.zhihu.com/p/34473430) && [机器学习之类别不平衡问题 (2) —— ROC和PR曲线](https://zhuanlan.zhihu.com/p/34655990) && [AUC详解与python实现](https://zhuanlan.zhihu.com/p/84035782) && [微平均和宏平均](https://zhuanlan.zhihu.com/p/78628437) && [机器学习中的性能度量](https://zhuanlan.zhihu.com/p/74980268) && [精确率、召回率、F1 值、ROC、AUC 各自的优缺点是什么](https://www.zhihu.com/question/30643044) +* [激活函数一览](https://zhuanlan.zhihu.com/p/30567264) && [深度学习中几种常见的激活函数理解与总结](https://www.cnblogs.com/XDU-Lakers/p/10557496.html) +* [深度学习笔记(三)：激活函数和损失函数](https://blog.csdn.net/u014595019/article/details/52562159) +* [激活函数/损失函数汇总](https://zhuanlan.zhihu.com/p/30385380) +* [机器学习中常见的损失函数及其应用场景](https://blog.csdn.net/zuolixiangfisher/article/details/88649110) && [PyTorch的十八个损失函数](https://zhuanlan.zhihu.com/p/61379965) +* [深度度量学习中的损失函数](https://zhuanlan.zhihu.com/p/82199561) +* [反向传播算法（过程及公式推导）](https://blog.csdn.net/u014313009/article/details/51039334) +* [通俗理解神经网络BP传播算法](https://zhuanlan.zhihu.com/p/24801814) +* [10. Coursera吴恩达《优化深度神经网络》课程笔记（3）-- 超参数调试、Batch正则化和编程框架](https://zhuanlan.zhihu.com/p/30922689) +* [11. 机器学习各种熵](https://zhuanlan.zhihu.com/p/35423404) +* [12. 距离和相似性度量](https://zhuanlan.zhihu.com/p/27305237) +* [13. 机器学习里的黑色艺术：normalization, standardization, regularization](https://zhuanlan.zhihu.com/p/29974820) && [数据标准化/归一化normalization](https://blog.csdn.net/pipisorry/article/details/52247379) && [特征工程中的「归一化」有什么作用？](https://www.zhihu.com/question/20455227) +* [14. LSTM系列的梯度问题](https://zhuanlan.zhihu.com/p/36101196) +* [15. 损失函数整理](https://zhuanlan.zhihu.com/p/35027284) +* [16. 详解残差块为何有助于解决梯度弥散问题](https://zhuanlan.zhihu.com/p/28124810) +* [17. FAIR何恺明等人提出组归一化：替代批归一化，不受批量大小限制](https://zhuanlan.zhihu.com/p/34858971) +* [18. Batch Normalization（BN）]():[1 ](https://zhuanlan.zhihu.com/p/26702482),[2 ](https://blog.csdn.net/hjimce/article/details/50866313),[3 ](https://bbs.cvmart.net/topics/576),[4 ](https://blog.csdn.net/edogawachia/article/details/80040456), [5](https://zhuanlan.zhihu.com/p/38176412), [6](https://www.zhihu.com/question/38102762), [7](https://zhuanlan.zhihu.com/p/52132614) +* [19. 详解深度学习中的Normalization，不只是BN](https://zhuanlan.zhihu.com/p/33173246) && [如何区分并记住常见的几种 Normalization 算法](https://zhuanlan.zhihu.com/p/69659844) +* [20. BFGS](https://blog.csdn.net/philosophyatmath/article/details/70173128) +* [21. 详解深度学习中的梯度消失、爆炸原因及其解决方法](https://zhuanlan.zhihu.com/p/33006526) && [神经网络梯度消失和梯度爆炸及解决办法](https://blog.csdn.net/program_developer/article/details/80032376) +* [22. Dropout](https://arxiv.org/pdf/1207.0580.pdf), [1](https://blog.csdn.net/stdcoutzyx/article/details/49022443), [2](https://blog.csdn.net/hjimce/article/details/50413257), [3](https://blog.csdn.net/shuzfan/article/details/50580915)，[系列解读Dropout](https://blog.csdn.net/shuzfan/article/details/50580915) +* [23.谱归一化（Spectral Normalization）的理解](https://blog.csdn.net/StreamRock/article/details/83590347)，[常见向量范数和矩阵范数](https://blog.csdn.net/left_la/article/details/9159949)，[谱范数正则（Spectral Norm Regularization）的理解](https://blog.csdn.net/StreamRock/article/details/83539937) +* [24.L1正则化与L2正则化](https://zhuanlan.zhihu.com/p/35356992) && [深入理解L1、L2正则化](https://zhuanlan.zhihu.com/p/29360425) && [L2正则=Weight Decay？并不是这样](https://zhuanlan.zhihu.com/p/40814046) && [都9102年了，别再用Adam + L2 regularization](https://zhuanlan.zhihu.com/p/63982470) +* [25.为什么选用交叉熵而不是MSE](https://zhuanlan.zhihu.com/p/61944055) &&[为什么使用交叉熵作为损失函数](https://zhuanlan.zhihu.com/p/63731947) &&[二元分类为什么不能用MSE做为损失函数？](http://sofasofa.io/forum_main_post.php?postid=1001792)&& [为什么平方损失函数不适用分类问题？](https://www.zhihu.com/question/319865092) +* [浅谈神经网络中的梯度爆炸问题](https://zhuanlan.zhihu.com/p/32154263) +* [为什么weight decay能够防止过拟合](https://www.zhihu.com/question/65626362) +* [交叉熵代价函数（作用及公式推导）](https://blog.csdn.net/u014313009/article/details/51043064) && [交叉熵损失的来源、说明、求导与pytorch实现](https://zhuanlan.zhihu.com/p/67782576) && [Softmax函数与交叉熵](https://zhuanlan.zhihu.com/p/27223959) && [极大似然估计与最小化交叉熵损失或者KL散度为什么等价](https://zhuanlan.zhihu.com/p/84764177) +* [梯度下降优化算法纵览](http://ruder.io/optimizing-gradient-descent/), [1](https://blog.csdn.net/qq_23269761/article/details/80901411), [2](https://www.cnblogs.com/guoyaohua/p/8542554.html), [几种优化算法的比较（BGD、SGD、Adam、RMSPROP）](https://blog.csdn.net/qq_32172681/article/details/100979476) +* **Softmax**：[详解softmax函数以及相关求导过程](https://zhuanlan.zhihu.com/p/25723112) && [softmax的log似然代价函数（公式求导）](https://blog.csdn.net/u014313009/article/details/51045303) && [【技术综述】一文道尽softmax loss及其变种](https://zhuanlan.zhihu.com/p/34044634) +* [从最优化的角度看待Softmax损失函数](https://zhuanlan.zhihu.com/p/45014864) && [Softmax理解之二分类与多分类](https://zhuanlan.zhihu.com/p/45368976) && [Softmax理解之Smooth程度控制](https://zhuanlan.zhihu.com/p/49939159) && [Softmax理解之margin](https://zhuanlan.zhihu.com/p/52108088) +* **权重初始化** + * [神经网络中的权重初始化一览：从基础到Kaiming](https://zhuanlan.zhihu.com/p/62850258) + * [深度学习中常见的权重初始化方法](https://zhuanlan.zhihu.com/p/138064188) + * [深度学习中神经网络的几种权重初始化方法](https://blog.csdn.net/u012328159/article/details/80025785) + * [谈谈神经网络权重为什么不能初始化为0](https://zhuanlan.zhihu.com/p/75879624) + * [神经网络中的偏置（bias）究竟有这么用？](https://www.zhihu.com/question/305340182) + * [深度学习里面的偏置为什么不加正则？](https://www.zhihu.com/question/66894061) +* [为什么说bagging是减少variance，而boosting是减少bias?](https://www.zhihu.com/question/26760839) + +## 四. 炼丹术士那些事 + +### 调参经验 +* [训练的神经网络不工作？一文带你跨过这37个坑](https://blog.csdn.net/jiandanjinxin/article/details/77190687) +* [Deep Learning 之 训练过程中出现NaN问题](https://blog.csdn.net/BVL10101111/article/details/76086344) +* [神经网络训练trick](https://zhuanlan.zhihu.com/p/59918821) +* [你有哪些deep learning（rnn、cnn）调参的经验？](https://www.zhihu.com/question/41631631) +* [GAN的一些小trick](https://zhuanlan.zhihu.com/p/27725664) +* [深度学习与计算机视觉系列(8)_神经网络训练与注意点](https://blog.csdn.net/han_xiaoyang/article/details/50521064) +* [神经网络训练loss不下降原因集合](https://blog.csdn.net/liuweiyuxiang/article/details/80856991) && [ loss不下降的解决方法](https://blog.csdn.net/zongza/article/details/89185852) +* [深度学习：欠拟合问题的几种解决方案](https://blog.csdn.net/u014038273/article/details/84108688) &&[过拟合和欠拟合问题](https://blog.csdn.net/mzpmzk/article/details/79741682) +* [机器学习：如何找到最优学习率](https://blog.csdn.net/whut_ldz/article/details/78882871)及[实现](https://github.com/L1aoXingyu/torchlib) +* [神经网络中 warmup 策略为什么有效](https://www.zhihu.com/question/338066667) +* [不平衡数据集处理方法](): [其一](https://machinelearningmastery.com/tactics-to-combat-imbalanced-classes-in-your-machine-learning-dataset/), [其二](https://www.zhihu.com/question/285824343), [其三](https://blog.csdn.net/songhk0209/article/details/71484469) && [Awesome Imbalanced Learning](https://github.com/ZhiningLiu1998/awesome-imbalanced-learning) && [Class-balanced-loss-pytorch](https://github.com/vandit15/Class-balanced-loss-pytorch) +* [同一个神经网络使用不同激活函数的表达能力是否一致](https://www.zhihu.com/question/41841299) +* [论文笔记之数据增广：mixup](https://blog.csdn.net/ly244855983/article/details/78938667#%E8%AE%A8%E8%AE%BA) +* [避坑指南：数据科学家新手常犯的13个错误](https://zhuanlan.zhihu.com/p/44331706) +* [凭什么相信CNN的结果?--可视化](https://bindog.github.io/blog/2018/02/10/model-explanation/) + * [凭什么相信你，我的CNN模型？（篇一：CAM和Grad-CAM)](https://bindog.github.io/blog/2018/02/10/model-explanation/) && [pytorch-grad-cam](https://github.com/jacobgil/pytorch-grad-cam) && [Grad-CAM-tensorflow](https://github.com/insikk/Grad-CAM-tensorflow) && [grad-cam.tensorflow](https://github.com/Ankush96/grad-cam.tensorflow) && [cnn_visualization](https://github.com/js-fan/mxnet/tree/d2b802e2d2af3dae5b4ac941354602630d2ef1c7/example/cnn_visualization) + * [凭什么相信你，我的CNN模型？（篇二：万金油LIME)](http://bindog.github.io/blog/2018/02/11/model-explanation-2/) + * [论文笔记:Grad-CAM: Visual Explanations from Deep Networks via Gradient-based Localization](https://www.jianshu.com/p/294ad9ae2e50) + * [CV：基于Keras利用训练好的hdf5模型进行目标检测实现输出模型中的表情或性别的gradcam(可视化)](https://blog.csdn.net/qq_41185868/article/details/80323646) +* [大卷积核还是小卷积核?]() [1](https://www.jianshu.com/p/d75375dd7ebd), [2](https://blog.csdn.net/kuangtun9713/article/details/79475457) +* [模型可解释性差？你考虑了各种不确定性了吗？](https://baijiahao.baidu.com/s?id=1608193373391996908) +* [炼丹笔记系列]() + * [炼丹笔记一：样本不平衡问题](https://zhuanlan.zhihu.com/p/56882616) + * [炼丹笔记二：数据清洗](https://zhuanlan.zhihu.com/p/56022212) + * [炼丹笔记三：数据增强](https://zhuanlan.zhihu.com/p/56139575) + * [炼丹笔记四：小样本问题](https://zhuanlan.zhihu.com/p/56365469) + * [炼丹笔记五：数据标注](https://zhuanlan.zhihu.com/p/56443169) + * [炼丹笔记六 : 调参技巧](https://zhuanlan.zhihu.com/p/56745640) + * [炼丹笔记七：卷积神经网络模型设计](https://zhuanlan.zhihu.com/p/57738934) + +### 刷排行榜的小技巧 + +* [Kaggle 六大比赛最全面解析（上）](https://www.leiphone.com/news/201803/XBjvQriKTyTMPLcz.html) + +* [Kaggle 六大比赛最全面解析（下）](https://www.leiphone.com/news/201803/chz1DNHqgVWNEm5t.html) + +#### 图像分类 + +* [炼丹笔记三：数据增强](https://zhuanlan.zhihu.com/p/56139575) && [数据增强(Data Augmentation)](https://zhuanlan.zhihu.com/p/41679153) +* [【技术综述】 深度学习中的数据增强（上）](https://zhuanlan.zhihu.com/p/38345420) && [【技术综述】深度学习中的数据增强（下）](https://zhuanlan.zhihu.com/p/38437739) +* [深度学习数据增广技术一览](https://zhuanlan.zhihu.com/p/144921458) +* [《Bag of Tricks for Image Classification with CNN》](https://zhuanlan.zhihu.com/p/53324148)&& [pdf](https://arxiv.org/pdf/1812.01187.pdf) +* [深度神经网络模型训练中的最新tricks总结【原理与代码汇总】](https://zhuanlan.zhihu.com/p/66080948) && [神经网络训练trick](https://zhuanlan.zhihu.com/p/59918821) +* [Kaggle解决方案分享]() + * [从0上手Kaggle图像分类挑战：冠军解决方案详解](https://www.itcodemonkey.com/article/4898.html) + * [Kaggle 冰山图像分类大赛近日落幕，看冠军团队方案有何亮点](https://www.leiphone.com/news/201803/u40cjEZWArBfFaBm.html) + * [【Kaggle冠军分享】图像识别和分类竞赛，数据增强及优化算法](https://mp.weixin.qq.com/s/_S8EBBJ-u9g_fHp7I3ChMQ?) + * [识别座头鲸，Kaggle竞赛第一名解决方案解读](https://zhuanlan.zhihu.com/p/58496385) + * [kaggle 首战拿金牌总结](https://zhuanlan.zhihu.com/p/60953933) + * [16岁高中生夺冠Kaggle地标检索挑战赛！而且竟然是Kaggle老兵](https://zhuanlan.zhihu.com/p/37522227) + * [6次Kaggle计算机视觉类比赛赛后感](https://zhuanlan.zhihu.com/p/37663895) + * [Kaggle首战斩获第三-卫星图像识别](https://zhuanlan.zhihu.com/p/63275166) + +#### 目标检测 + +* ensemble +* deformable +* sync bn +* ms train/test +* [目标检测任务的优化策略tricks](https://zhuanlan.zhihu.com/p/56792817) +* [目标检测小tricks--样本不均衡处理](https://zhuanlan.zhihu.com/p/60612064) +* [汇总|目标检测中的数据增强、backbone、head、neck、损失函数](https://zhuanlan.zhihu.com/p/137769687) +* [目标检测算法中的常见trick](https://zhuanlan.zhihu.com/p/39262769) +* [Bag of Freebies —— 提升目标检测模型性能的免费tricks](https://zhuanlan.zhihu.com/p/141878389) +* [目标检测比赛中的tricks（已更新更多代码解析）](https://zhuanlan.zhihu.com/p/102817180) +* [Kaggle：肺癌自动诊断系统3D Deep Leaky Noisy-or Network 论文阅读](https://www.jianshu.com/p/50158f8daf0d) +* [干货|大神教你如何参加kaggle比赛——根据CT扫描图预测肺癌](https://yq.aliyun.com/articles/89312) + +## 五. 年度总结 +* [新年大礼包：机器之心2018高分教程合集](https://zhuanlan.zhihu.com/p/53717510) +* [收藏、退出一气呵成，2019年机器之心干货教程都在这里了](https://zhuanlan.zhihu.com/p/104022144) + +## 六. 科研相关 + +### 深度学习框架 + +#### Python3.x(先修) + +* [The Python Tutorial](https://docs.python.org/3/tutorial/) +* [廖雪峰Python教程](https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000) +* [菜鸟教程](http://www.runoob.com/python3/python3-tutorial.html)     +* [给深度学习入门者的Python快速教程 - 基础篇](https://zhuanlan.zhihu.com/p/24162430) +* [Python - 100天从新手到大师](https://github.com/jackfrued/Python-100-Days) +* [Python中读取,显示,保存图片的方法](https://blog.csdn.net/u010472607/article/details/78855816) && [Python的图像打开保存显示的几种方式](https://blog.csdn.net/weixin_37619439/article/details/86559239) + +#### Numpy(先修) + +* [Quickstart tutorial](https://www.numpy.org/devdocs/user/quickstart.html) + +* [Numpy快速入门(Numpy 1.14 官方文档中文翻译)](https://www.jianshu.com/p/3e566f09a0cf) +* [Numpy中文文档](https://www.numpy.org.cn/index.html) +* [给深度学习入门者的Python快速教程 - numpy和Matplotlib篇](https://zhuanlan.zhihu.com/p/24309547) + +#### Opencv-python + +* [OpenCV-Python Tutorials](https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_tutorials.html) +* [OpenCV官方教程中文版（For Python）](https://www.cnblogs.com/Undo-self-blog/p/8423851.html) +* [数字图像处理系列](https://blog.csdn.net/feilong_csdn/article/category/8037591) +* [python+OpenCV图像处理](https://blog.csdn.net/qq_40962368/article/category/7688903) +* [给深度学习入门者的Python快速教程 - 番外篇之Python-OpenCV](https://zhuanlan.zhihu.com/p/24425116) + +#### Pandas + +* [Python 数据科学入门教程：Pandas](https://www.jianshu.com/p/d9774cf1fea5?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation) + +#### Tensorflow + +* [如何高效地学习 TensorFlow 代码](https://www.zhihu.com/question/41667903) +* [中文教程](http://www.tensorfly.cn/tfdoc/tutorials/overview.html) +* [TensorFlow官方文档](https://www.w3cschool.cn/tensorflow_python/) +* [CS20:Tensorflow for DeepLearning Research](http://web.stanford.edu/class/cs20si/syllabus.html) +* [吴恩达TensorFlow专项课程](https://zhuanlan.zhihu.com/p/62981537) +* [【干货】史上最全的Tensorflow学习资源汇总](https://zhuanlan.zhihu.com/p/35515805?group_id=967136289941897216) +* [《21个项目玩转深度学习———基于TensorFlow的实践详解》](https://github.com/hzy46/Deep-Learning-21-Examples)   +* [最全Tensorflow2.0 入门教程持续更新](https://zhuanlan.zhihu.com/p/59507137) +* [Github优秀开源教程](https://github.com/search?o=desc&q=tensorflow+tutorial&s=&type=Repositories) + +#### MXNet +* [Gluon](http://zh.gluon.ai/#) +* [GluonCV](https://gluon-cv.mxnet.io/index.html#) +* [GluonNLP](http://gluon-nlp.mxnet.io/) + +#### PyTorch + +* [Pytorch版动手学深度学习](https://github.com/ShusenTang/Dive-into-DL-PyTorch) +* [PyTorch中文文档](https://pytorch-cn.readthedocs.io/zh/latest/) +* [WELCOME TO PYTORCH TUTORIALS](https://pytorch.org/tutorials/index.html) +* [史上最全的PyTorch学习资源汇总](https://zhuanlan.zhihu.com/p/64895011) +* [【干货】史上最全的PyTorch学习资源汇总](https://github.com/INTERMT/Awesome-PyTorch-Chinese) +* [Hands-on tour to deep learning with PyTorch](https://mlelarge.github.io/dataflowr-web/cea_edf_inria.html) +* [pytorch学习(五)—图像的加载/读取方式](https://www.jianshu.com/p/cfca9c4338e7) && [PyTorch—ImageFolder/自定义类 读取图片数据](https://blog.csdn.net/wsp_1138886114/article/details/83620869) + +### 深度学习常用命令 + +* [command_for_deeplearning](https://github.com/Stephenfang51/command_for_deeplearning/blob/master/command%20for%20deeplearning.md) +* [Shell编程](https://zhuanlan.zhihu.com/p/102176365) + +### Python可视化 + +* [Top 50 matplotlib Visualizations – The Master Plots (with full python code)](https://www.machinelearningplus.com/plots/top-50-matplotlib-visualizations-the-master-plots-python/) +* [Python之MatPlotLib使用教程](https://blog.csdn.net/zhw864680355/article/details/102500263) +* [十分钟上手matplotlib，开启你的python可视化](https://mp.weixin.qq.com/s/UfvEdzr-ZGmyT08yKDOchA) +* [给深度学习入门者的Python快速教程 - numpy和Matplotlib篇](https://zhuanlan.zhihu.com/p/24309547) + +### 标注工具 +* 目标检测标注工具 + * [labelImg](https://github.com/tzutalin/labelImg) +* 语义分割标注工具 + * [labelme](https://github.com/wkentaro/labelme) + +### 数据集 +* [1. 25个深度学习相关公开数据集](https://zhuanlan.zhihu.com/p/35449783) +* [2. 自然语言处理（NLP）数据集](https://zhuanlan.zhihu.com/p/35423943) +* [3.全唐诗(43030首)](https://pan.baidu.com/s/1o7QlUhO) +* [4. 伯克利大学公开数据集](https://people.eecs.berkeley.edu/~taesung_park/) +* [5. ACL 2018资源：100+ 预训练的中文词向量](https://zhuanlan.zhihu.com/p/36835964) +* [6. 预训练中文词向量](https://github.com/Embedding/Chinese-Word-Vectors) +* [7. 公开数据集种子库](http://academictorrents.com) +* [8. 计算机视觉，深度学习，数据挖掘数据集整理](https://blog.csdn.net/c20081052/article/details/79814082) +* [9. 计算机视觉著名数据集CV Datasets](https://blog.csdn.net/accepthjp/article/details/51831026) +* [10. 计算机视觉相关数据集和比赛](https://blog.csdn.net/NNNNNNNNNNNNY/article/details/68485160) +* [11. 这是一份非常全面的开源数据集，你，真的不想要吗？](https://zhuanlan.zhihu.com/p/43846002) +* [12. 人群密度估计现有主要数据集特点及其比较](https://blog.csdn.net/weixin_40516558/article/details/81564464) +* [13. DANBOORU2017: A LARGE-SCALE CROWDSOURCED AND TAGGED ANIME ILLUSTRATION DATASET](https://www.gwern.net/Danbooru2017) +* [14. 行人重识别数据集](http://robustsystems.coe.neu.edu/sites/robustsystems.coe.neu.edu/files/systems/projectpages/reiddataset.html) +* [15. 自然语言处理常见数据集、论文最全整理分享](https://zhuanlan.zhihu.com/p/56144877) +* [16. paper, code, sota](https://paperswithcode.com/) +* [17. 旷视RPC大型商品数据集发布！](https://zhuanlan.zhihu.com/p/55627416) +* [18. CVPR 2019「准满分」论文：英伟达推出首个跨摄像头汽车跟踪数据集(汽车Re-ID)](https://zhuanlan.zhihu.com/p/60617001) +* [19.【OCR技术】大批量生成文字训练集](https://zhuanlan.zhihu.com/p/59052013) +* [20. 语义分析数据集-MSRA](https://github.com/msra-nlc/MSParS) +* [IEEE DataPort](https://ieee-dataport.org/) +* [数据集市](http://www.shujujishi.com/) +* [医疗/医学图像数据集]()：[Medical Data for Machine Learning](https://github.com/beamandrew/medical-data) && [医疗领域图像挑战赛数据集](https://grand-challenge.org/challenges/) && [【医学影像系列：一】数据集合集 最新最全](https://blog.csdn.net/qq_31622015/article/details/90573874) && [medical-imaging-datasets](https://github.com/sfikas/medical-imaging-datasets) && [【数据集】一文道尽医学图像数据集与竞赛](https://zhuanlan.zhihu.com/p/50615907) && [医学图像数据集汇总](https://zhuanlan.zhihu.com/p/102855802) + +### 记笔记工具 + +* [Markdown编辑器：Typora介绍](https://zhuanlan.zhihu.com/p/67153848) +* [Markdown语法介绍（常用）](https://zhuanlan.zhihu.com/p/47897214) +* [Markdown 语法手册 （完整整理版）](https://blog.csdn.net/witnessai1/article/details/52551362) +* [Markdown中Latex 数学公式基本语法](https://blog.csdn.net/u014630987/article/details/70156489) + +### 会议期刊列表 + +* [国际会议日期表](https://github.com/JackieTseng/conference_call_for_paper) +* [ai-deadlines](https://github.com/abhshkdz/ai-deadlines/) +* [Keep Up With New Trends](https://handong1587.github.io/deep_learning/2017/12/18/keep-up-with-new-trends.html) +* [计算机会议排名等级](https://blog.csdn.net/cserchen/article/details/40508181) +* [中国计算机学会(CCF)推荐国际学术刊物和会议](https://www.ccf.org.cn/Academic_Evaluation/By_category/) + +### 论文写作工具 +* [Windows: Texlive+Texstudio](https://jingyan.baidu.com/article/b2c186c83c9b40c46ff6ff4f.html) +* [Ubuntu: Texlive+Texmaker](https://jingyan.baidu.com/article/7c6fb4280b024180642c90e4.html) +* [Latex：基本用法、表格、公式、算法](https://blog.csdn.net/quiet_girl/article/details/72847208) +* [LaTeX 各种命令，符号](https://blog.csdn.net/garfielder007/article/details/51646604) + +### 论文画图工具 +* [Visio2016](https://msdn.itellyou.cn/) +* [Matplotlib](#Python可视化) + +### 论文写作教程 +* [刘知远_如何写一篇合格的NLP论文](https://zhuanlan.zhihu.com/p/58752815) +* [刘洋_如何写论文_V7](http://nlp.csai.tsinghua.edu.cn/~ly/talks/cwmt14_tut.pdf) +* [如何端到端地写科研论文-邱锡鹏](https://xpqiu.github.io/slides/20181019-PaperWriting.pdf) +* [论文Introduction写作其一](https://zhuanlan.zhihu.com/p/33876355), [论文Introduction写作其二](https://zhuanlan.zhihu.com/p/52494933), [论文Introduction写作其三](https://zhuanlan.zhihu.com/p/52494879) +* [毕业论文怎么写](https://zhuanlan.zhihu.com/c_179195484) +* [浅谈学术论文rebuttal](https://zhuanlan.zhihu.com/p/104298923) && [学术论文投稿与返修（Rebuttal）分享](https://zhuanlan.zhihu.com/p/344008879) +* [研之成理写作实验室](https://zhuanlan.zhihu.com/rationalscience-writing-lab) +* [智源论坛·论文写作专题报告会]()：[《论文写作小白的成长之路》](https://zhuanlan.zhihu.com/p/135989892) && [《谈如何写一篇合格的国际学术论文》](https://zhuanlan.zhihu.com/p/136005095) && [《计算机视觉会议论文从投稿到接收》](https://zhuanlan.zhihu.com/p/139571199) + +### ResearchGos + +* [ResearchGo:研究生活第一帖——文献检索与管理](https://zhuanlan.zhihu.com/p/22323250?refer=wjdml) +* [ResearchGo:研究生活第二贴——文献阅读](https://zhuanlan.zhihu.com/p/22402393?refer=wjdml) +* [ResearchGo:研究生活第三帖——阅读辅助](https://zhuanlan.zhihu.com/p/22622502?refer=wjdml) +* [ResearchGo:研究生活第四帖——文献调研](https://zhuanlan.zhihu.com/p/23178836?refer=wjdml) +* [ResearchGo:研究生活第五帖——文献综述](https://zhuanlan.zhihu.com/p/23356843?refer=wjdml) +* [ResearchGo:研究生活第六帖——如何讲论文](https://zhuanlan.zhihu.com/p/23872063?refer=wjdml) +* [ResearchGo:研究生活第七帖——专利检索与申请](https://zhuanlan.zhihu.com/p/25191025) +* [ResearchGo:研究生活第八帖——写论文、做PPT、写文档必备工具集锦](https://zhuanlan.zhihu.com/p/62100815) + +### 毕业论文排版 + +* [吐血推荐收藏的学位论文排版教程（完整版）](https://zhuanlan.zhihu.com/p/52495345) +* [论文怎么写——如何修改毕业论文格式](https://zhuanlan.zhihu.com/p/35951260) + +_____ + +______ + +## 信号处理 + +### 傅里叶变换 + +* [傅里叶分析之掐死教程（完整版）更新于2014.06.06](https://zhuanlan.zhihu.com/p/19763358) +* [如何简明的总结傅里叶变换？](https://www.zhihu.com/question/34899574/answer/612923473) +* [从连续时间傅里叶级数到快速傅里叶变换](https://blog.csdn.net/clover13/article/details/79469851) +* [十分简明易懂的FFT（快速傅里叶变换）](https://blog.csdn.net/enjoy_pascal/article/details/81478582) +* [傅里叶级数推导过程](https://blog.csdn.net/hanxiaohu88/article/details/8245687) + +### 小波变换 + +* [形象易懂讲解算法I——小波变换](https://zhuanlan.zhihu.com/p/22450818) + +* [小波变换完美通俗讲解系列之 （一）](https://zhuanlan.zhihu.com/p/44215123) && [小波变换完美通俗讲解系列之 （二）](https://zhuanlan.zhihu.com/p/44217268) + +#### 实战 +* [MWCNN中使用的haar小波变换 pytorch](https://www.cnblogs.com/wanghui-garcia/p/12524515.html) +* [【小波变换】小波变换入门----haar小波](https://blog.csdn.net/baidu_27643275/article/details/84826773) +* [（3）小波变换原理及应用](https://blog.csdn.net/hhaowang/article/details/82909332) +* [图像处理-小波变换](https://blog.csdn.net/qq_30815237/article/details/89704855) + +## 机器学习理论与实战 + +* [机器学习原理](https://github.com/shunliz/Machine-Learning):star: +* [ID3、C4.5、CART、随机森林、bagging、boosting、Adaboost、GBDT、xgboost算法总结](https://zhuanlan.zhihu.com/p/34534004) +* [数据挖掘十大算法简要说明](http://www.cnblogs.com/en-heng/p/5013995.html)，[机器学习十大经典算法入门](https://blog.csdn.net/qq_42379006/article/details/80741808) && [【算法模型】轻松看懂机器学习十大常用算法](https://www.cnblogs.com/ljt1412451704/p/9678248.html) +* [AdaBoost到GBDT系列]() + * [当我们在谈论GBDT：从 AdaBoost 到 Gradient Boosting](https://zhuanlan.zhihu.com/p/25096501?refer=data-miner) + * [当我们在谈论GBDT：Gradient Boosting 用于分类与回归](https://zhuanlan.zhihu.com/p/25257856?refer=data-miner) + * [当我们在谈论GBDT：其他 Ensemble Learning 算法](https://zhuanlan.zhihu.com/p/25443980) + +### 机器学习理论篇之经典算法 + +#### 信息论 +* [1. 机器学习中的各种熵](https://zhuanlan.zhihu.com/p/35423404)     +* [2. 从香农熵到手推KL散度：纵览机器学习中的信息论](https://zhuanlan.zhihu.com/p/32985487) + +#### 多层感知机(MLP) +* [多层感知机（MLP）学习与总结博客](https://blog.csdn.net/baidu_33718858/article/details/84972537) +* [多层感知机：Multi-Layer Perceptron](https://blog.csdn.net/xholes/article/details/78461164) +* [神经网络基础-多层感知器(MLP)](https://blog.csdn.net/weixin_38206214/article/details/81137911) + +#### k近邻(KNN) + +* [机器学习之KNN（k近邻）算法详解](https://blog.csdn.net/sinat_30353259/article/details/80901746) + +#### k均值(K-means) + +* [Kmeans聚类算法详解](https://blog.csdn.net/qq_32892383/article/details/80107795) + +#### 朴素贝叶斯(Naive Bayesian) + +* [一个例子搞清楚（先验分布/后验分布/似然估计）](https://blog.csdn.net/qq_23947237/article/details/78265026) +* [朴素贝叶斯分类器（Naive Bayesian Classifier）](https://blog.csdn.net/qq_32690999/article/details/78737393) +* [朴素贝叶斯分类器 详细解析](https://blog.csdn.net/qq_17073497/article/details/81076250) + +#### 决策树(Decision Tree) +* [最常见核心的决策树算法详细介绍，含ID3、C4.5、CART:star:](https://mp.weixin.qq.com/s/lXaPZyNrgG9LBv-JHdGm9A) && [最常用的决策树算法！Random Forest、Adaboost、GBDT 算法:star:](https://mp.weixin.qq.com/s/Nl_-PdF0nHBq8yGp6AdI-Q) && [终于有人把XGBoost 和 LightGBM 讲明白了，项目中最主流的集成算法！:star:](https://mp.weixin.qq.com/s/LoX987dypDg8jbeTJMpEPQ) +* [为什么xgboost要用泰勒展开，优势在哪里](http://blog.itblood.com/4082.html) +* [Python3《机器学习实战》学习笔记（二）：决策树基础篇之让我们从相亲说起](https://blog.csdn.net/c406495762/article/details/75663451) +* [Python3《机器学习实战》学习笔记（三）：决策树实战篇之为自己配个隐形眼镜](https://blog.csdn.net/c406495762/article/details/76262487) +* [机器学习实战教程（十三）：树回归基础篇之CART算法与树剪枝](http://cuijiahua.com/blog/2017/12/ml_13_regtree_1.html) +* [《机器学习实战》基于信息论的三种决策树算法(ID3,C4.5,CART)](https://blog.csdn.net/gamer_gyt/article/details/51242815) +* [说说决策树剪枝算法](https://zhuanlan.zhihu.com/p/31404571) +* [机器学习实战 第九章 树回归](https://blog.csdn.net/namelessml/article/details/52595066) +* [决策树值ID3、C4.5实现](https://blog.csdn.net/u014688145/article/details/53212112) +* [决策树之CART实现](https://blog.csdn.net/u014688145/article/details/53326910) + +#### 随机森林(Random Forest) +* [随机森林和GBDT的区别](https://blog.csdn.net/login_sonata/article/details/73929426) +* [随机森林（Random Forest）入门与实战](https://blog.csdn.net/sb19931201/article/details/52601058) +* [随机森林之特征选择](https://www.cnblogs.com/justcxtoworld/p/3447231.html) + +#### 线性回归（Linear Regression） + +* [线性回归最小二乘法和最大似然估计](https://blog.csdn.net/lt793843439/article/details/91392646) +* [【从入门到放弃】线性回归](https://zhuanlan.zhihu.com/p/147297924) +* [线性回归(频率学派-最大似然估计)与岭回归(贝叶斯角度-最大后验估计)的概率解释](https://blog.csdn.net/z_feng12489/article/details/101388745) +* [机器学习笔记四：线性回归回顾与logistic回归](https://blog.csdn.net/xierhacker/article/details/53316138) + +#### 逻辑回归(Logistic Regression) + +* [【机器学习面试总结】—— LR（逻辑回归）](https://zhuanlan.zhihu.com/p/100763009) +* [【机器学习面试题】逻辑回归篇](https://zhuanlan.zhihu.com/p/62653034) +* [极大似然概率和最小损失函数，以及正则化简介](https://www.jianshu.com/p/9d2686cd407e) +* [GLM(广义线性模型) 与 LR(逻辑回归) 详解](https://blog.csdn.net/Cdd2xd/article/details/75635688) + +#### 支持向量机(SVM) +* [【机器学习面试总结】—— SVM](https://zhuanlan.zhihu.com/p/93715996) +* [SVM系列-从基础到掌握](https://zhuanlan.zhihu.com/p/61123737) +* [SVM通俗导论 July](https://github.com/Mikoto10032/DeepLearning/blob/master/books/%E6%94%AF%E6%8C%81%E5%90%91%E9%87%8F%E6%9C%BA%E9%80%9A%E4%BF%97%E5%AF%BC%E8%AE%BA%EF%BC%88%E7%90%86%E8%A7%A3SVM%E7%9A%84%E4%B8%89%E5%B1%82%E5%A2%83%E7%95%8C%EF%BC%89LaTeX%E6%9C%80%E6%96%B0%E7%89%88_2015.1.9.pdf)  +* [核函数 ](): [机器学习有很多关于核函数的说法，核函数的定义和作用是什么？](https://www.zhihu.com/question/24627666) && [SVM中，高斯核为什么会把原始维度映射到无穷多维？](https://www.zhihu.com/question/35602879) && [svm核函数的理解和选择](https://blog.csdn.net/leonis_v/article/details/50688766) && [核函数和径向基核函数 (Radial Basis Function)--RBF](https://blog.csdn.net/huang1024rui/article/details/51510611) && [SVM核函数](https://blog.csdn.net/xiaowei_cqu/article/details/35993729) + +#### 提升方法(Adaboost) + +* [当我们在谈论GBDT：从 AdaBoost 到 Gradient Boosting](https://zhuanlan.zhihu.com/p/25096501) + +#### 梯度提升决策树(GBDT) +* [LightGBM大战XGBoost](https://zhuanlan.zhihu.com/p/35645973) +* [概述XGBoost、Light GBM和CatBoost的同与不同](https://zhuanlan.zhihu.com/p/34698733)   && [XGBoost、LightGBM、Catboost总结](https://www.cnblogs.com/lvdongjie/p/11391245.html) && [XGBoost、Light GBM和CatBoost的参数及性能比较](https://zhuanlan.zhihu.com/p/34698733) +* [梯度提升决策树](https://zhuanlan.zhihu.com/p/36339161) +* [GBDT原理及应用](https://zhuanlan.zhihu.com/p/30339807) +* [XGBOOST原理篇](https://zhuanlan.zhihu.com/p/31654000) +* [xgboost入门与实战（原理篇）](https://blog.csdn.net/sb19931201/article/details/52557382) && [xgboost入门与实战（实战调参篇）](https://blog.csdn.net/sb19931201/article/details/52577592) +* [【干货合集】通俗理解kaggle比赛大杀器xgboost](https://zhuanlan.zhihu.com/p/41417638) +* [GBDT分类的原理及Python实现](https://blog.csdn.net/bf02jgtrs00xktcx/article/details/82719765) +* [GBDT原理及利用GBDT构造新的特征-Python实现](https://blog.csdn.net/shine19930820/article/details/71713680) +* [Python+GBDT算法实战——预测实现100%准确率](https://www.jianshu.com/p/47e73a985ba1) +* [xgboost之近似分位数算法（直方图算法）详解](https://blog.csdn.net/m0_37870649/article/details/104561431) + +#### EM(期望最大化) +* [人人都懂的EM算法 ](https://zhuanlan.zhihu.com/p/36331115) +* [EM算法入门文章](https://zhuanlan.zhihu.com/p/61768577)                       + +#### 高斯混合模型(GMM) +* [高斯混合模型与EM算法的数学原理及应用实例](https://zhuanlan.zhihu.com/p/67107370) +* [高斯混合模型（GMM）](https://zhuanlan.zhihu.com/p/30483076) + +#### 马尔科夫决策过程(MDP) +* [马尔科夫决策过程之Markov Processes（马尔科夫过程）](https://zhuanlan.zhihu.com/p/35124726) +* [马尔科夫决策过程之Markov Reward Process（马尔科夫奖励过程）](https://zhuanlan.zhihu.com/p/35231424) +* [马尔科夫决策过程之Bellman Equation（贝尔曼方程）](https://zhuanlan.zhihu.com/p/35261164) +* [马尔科夫决策过程之Markov Decision Process(马尔科夫决策过程)](https://zhuanlan.zhihu.com/p/35354956) +* [马尔科夫决策过程之最优价值函数与最优策略](https://zhuanlan.zhihu.com/p/35373905) + +#### 条件随机场(CRF, 判别式模型) +* [如何轻松愉快地理解条件随机场](https://zhuanlan.zhihu.com/p/104562658) +* [如何用简单易懂的例子解释条件随机场（CRF）模型？它和HMM有什么区别？](https://www.zhihu.com/question/35866596) +* [HMM ,MHMM,CRF 优缺点与区别](https://blog.csdn.net/u013378306/article/details/55213029) + +#### 降维算法 +* [数据降维算法-从PCA到LargeVis](https://zhuanlan.zhihu.com/p/62470700) +* [12种降维方法终极指南（含Python代码）](https://zhuanlan.zhihu.com/p/43225794) + +#### 主成分分析(PCA) +* [主成分分析（PCA）原理详解](https://blog.csdn.net/program_developer/article/details/80632779) +* [图文并茂的PCA教程](https://blog.csdn.net/hustqb/article/details/78394058) +* [PCA数学原理](http://www.360doc.com/content/13/1124/02/9482_331688889.shtml) + +#### 奇异值分解(SVD) +* [强大的矩阵奇异值分解(SVD)及其应用](https://www.cnblogs.com/LeftNotEasy/archive/2011/01/19/svd-and-applications.html) +* [奇异值分解（SVD）](https://zhuanlan.zhihu.com/p/29846048) +* [奇异值分解(SVD)原理详解及推导](https://blog.csdn.net/zhongkejingwang/article/details/43053513)     +* [SVD在推荐系统中的应用详解以及算法推导](https://blog.csdn.net/zhongkejingwang/article/details/43083603) + +#### 线性判别分析(LDA) +* [教科书上的LDA为什么长这个样子？](https://zhuanlan.zhihu.com/p/42238953) + +#### 标签传播算法(Label Propagation Algorithm)     +* [标签传播算法（Label Propagation）及Python实现](https://blog.csdn.net/zouxy09/article/details/49105265) + * [参考资料](https://github.com/Mikoto10032/DeepLearning/blob/master/books/Semi-Supervised%20Learning%20with%20Graphs.pdf) + +#### 蒙塔卡罗树搜索(MCTS) +* [蒙特卡洛树搜索入门指南](https://zhuanlan.zhihu.com/p/34950988) + +#### 集成(Ensemble) + +* [集成学习之bagging,stacking,boosting概念理解](https://zhuanlan.zhihu.com/p/41809927) && [Bagging和Boosting的总结](https://www.zhihu.com/follow) + +* [集成学习法之bagging方法和boosting方法](https://blog.csdn.net/qq_30189255/article/details/51532442) +* [Bagging,Boosting,Stacking](https://blog.csdn.net/Mr_tyting/article/details/72957853) && [常用的模型集成方法介绍：bagging、boosting 、stacking](https://zhuanlan.zhihu.com/p/65888174) + +#### t分布随机邻居嵌入(TSNE) +* [流形学习-高维数据的降维与可视化](https://blog.csdn.net/u012162613/article/details/45920827) +* [tSNE](https://blog.csdn.net/flyingzhan/article/details/79521765) +* [使用t-SNE可视化图像embedding](https://zhuanlan.zhihu.com/p/81400277) + +#### 谱聚类(Spectral Clustering) +* [谱聚类（Spectral Clustering）算法介绍](https://blog.csdn.net/qq_24519677/article/details/82291867) +* [聚类5--谱和谱聚类](https://blog.csdn.net/xueyingxue001/article/details/51966980) + +#### 异常点检测 +* [数据挖掘中常见的「异常检测」算法有哪些？](https://www.zhihu.com/question/280696035/answer/417091151) +* [异常点检测算法综述](https://zhuanlan.zhihu.com/p/30169110) +* [异常检测的N种方法，其中有一个你一定想不到](https://mp.weixin.qq.com/s/RYLlUJiYbWqGIhzflbRGEg) +* [异常检测资源汇总：anomaly-detection-resources](https://zhuanlan.zhihu.com/p/158349346) + +### 机器学习实战篇 +* [机器学习中，有哪些特征选择的工程方法？](https://www.zhihu.com/question/28641663) && [机器学习（四）：数据预处理--特征工程概述](https://zhuanlan.zhihu.com/p/103070096) && [特征工程完全手册 - 从预处理、构造、选择、降维、不平衡处理，到放弃](https://zhuanlan.zhihu.com/p/94994902) && [特征工程中的「归一化」有什么作用](https://www.zhihu.com/question/20455227) +* [15分钟带你入门sklearn与机器学习——分类算法篇](https://mp.weixin.qq.com/s?__biz=Mzg5NzAxMDgwNg==&mid=2247484110&idx=1&sn=b016e270d7b7707e6ad41a81ca45fc28&chksm=c0791fd7f70e96c103a8a2aebee166ce14f5648b3b889dd85dd9786f48b6b8269f11e5e27e1c&scene=21#wechat_redirect) && [如何为你的回归问题选择最合适的机器学习方法？](https://zhuanlan.zhihu.com/p/62034592) +* [十分钟上手sklearn：安装，获取数据，数据预处理](https://zhuanlan.zhihu.com/p/105039597) && [十分钟上手sklearn：特征提取，常用模型，交叉验证](https://zhuanlan.zhihu.com/p/105041301) +* [MachineLearning_Python](https://github.com/lawlite19/MachineLearning_Python) +* [Machine Learning Course with Python](https://github.com/machinelearningmindset/machine-learning-course) +* [Statistical-Learning-Method_Code](https://github.com/Dod-o/Statistical-Learning-Method_Code) +* [Python3机器学习](https://blog.csdn.net/c406495762/column/info/16415) +* [含大牛总结的分类模型一般需要调节的参数](https://www.jianshu.com/p/9d2452fc93c2) + + +## 机器学习、深度学习的一些研究方向 + +### 多任务学习(Multi-Task Learning) +* [模型汇总-14 多任务学习-Multitask Learning概述](https://zhuanlan.zhihu.com/p/27421983) +* [(译)深度神经网络的多任务学习概览(An Overview of Multi-task Learning in Deep Neural Networks)](http://www.cnblogs.com/shuzirank/p/7141017.html) +* [Multi-task Learning and Beyond: 过去，现在与未来](https://zhuanlan.zhihu.com/p/138597214)； + +### 零次学习(Zero Shot Learning) +* [零次学习（Zero-Shot Learning）入门](https://zhuanlan.zhihu.com/p/34656727) + +### 小样本学习(Few-Shot Learning) + +* [few-shot learning是什么](https://blog.csdn.net/xhw205/article/details/79491649) +* [零次学习（Zero-Shot Learning）入门](https://zhuanlan.zhihu.com/p/34656727) +* [小样本学习（Few-shot Learning）综述](https://zhuanlan.zhihu.com/p/61215293) +* [Few-Shot Learning in CVPR 2019](https://towardsdatascience.com/few-shot-learning-in-cvpr19-6c6892fc8c5) +* [当小样本遇上机器学习 fewshot learning](https://blog.csdn.net/mao_feng/article/details/78939864) + +### 多视觉学习(Multi-View Learning) +* [Multi-view Learning 多视角学习入门](https://blog.csdn.net/danliwoo/article/details/79278574) +* [多视角学习 (Multi-View Learning)](https://blog.csdn.net/shine19930820/article/details/77426599) + +### 嵌入(Embedding) + +* [万物皆Embedding，从经典的word2vec到深度学习基本操作item2vec](https://zhuanlan.zhihu.com/p/53194407) +* [YJango的Word Embedding--介绍](https://zhuanlan.zhihu.com/p/27830489) + +### 迁移学习(Transfer Learning) +* [1. 迁移学习：经典算法解析](https://blog.csdn.net/linolzhang/article/details/73358219) +* [2. 什么是迁移学习 (Transfer Learning)？这个领域历史发展前景如何？](https://www.zhihu.com/question/41979241) +* [3. 迁移学习个人笔记](https://github.com/Mikoto10032/DeepLearning/blob/master/notes/日常阅读笔记/2018_4_12_迁移学习.pdf)   +* [迁移学习总结(One Shot Learning, Zero Shot Learning)](https://blog.csdn.net/XJTU_NOC_Wei/article/details/77850221) + +### 域自适应(Domain Adaptation) + +* [Domain Adaptation视频教程（附PPT）及经典论文分享](https://zhuanlan.zhihu.com/p/27519182) +* [模型汇总15 领域适应性Domain Adaptation、One-shot/zero-shot Learning概述](https://zhuanlan.zhihu.com/p/27449079) +* [【深度学习】论文导读：无监督域适应（Deep Transfer Network: Unsupervised Domain Adaptation）](https://blog.csdn.net/mao_xiao_feng/article/details/54426101) +* [【论文阅读笔记】基于反向传播的无监督域自适应研究](https://zhuanlan.zhihu.com/p/37298073) +* [【Valse大会首发】领域自适应及其在人脸识别中的应用](https://zhuanlan.zhihu.com/p/21441807) +* [CVPR 2018：基于域适应弱监督学习的目标检测](https://zhuanlan.zhihu.com/p/41126114) + +### 元学习(Meta Learning) + +* [OpenAI提出新型元学习方法EPG，调整损失函数实现新任务上的快速训练](https://zhuanlan.zhihu.com/p/35869158?group_id=970310501209645056)       + +### 强化学习(Reinforcement Learning) + +* [强化学习（Reinforcement Learning）知识整理](https://zhuanlan.zhihu.com/p/25498081) +* [强化学习从入门到放弃的资料](https://zhuanlan.zhihu.com/p/34918639) +* [强化学习入门](https://zhuanlan.zhihu.com/p/25498081) + * [强化学习入门 第一讲 MDP](https://zhuanlan.zhihu.com/p/25498081) +* [强化学习——从Q-Learning到DQN到底发生了什么？](https://zhuanlan.zhihu.com/p/35882937) +* [从强化学习到深度强化学习（上）](https://zhuanlan.zhihu.com/p/35688924)                   +* [从强化学习到深度强化学习（下）](https://zhuanlan.zhihu.com/p/35965070) +* [一文带你理解Q-Learning的搜索策略](https://zhuanlan.zhihu.com/p/37048004) + +### 对比学习(Contrastive Learning) + +* [论文列表](https://github.com/asheeshcric/awesome-contrastive-self-supervised-learning) +* [对比学习（Contrastive Learning）:研究进展精要](https://zhuanlan.zhihu.com/p/367290573) +* [对比学习（Contrastive Learning）综述](https://zhuanlan.zhihu.com/p/346686467) +* [理解对比损失的性质以及温度系数的作用](https://zhuanlan.zhihu.com/p/357071960) + +### 推荐系统(Recommendation System) + +#### 论文列表 + +* [Embedding从入门到专家必读的十篇论文](https://zhuanlan.zhihu.com/p/58805184) +* [Reco-papers](https://github.com/wzhe06/Reco-papers) +* [Ad-papers](https://github.com/wzhe06/Ad-papers) +* [deep-recommender-system](https://github.com/chocoluffy/deep-recommender-system) +* [CTR预估系列入门手册](https://zhuanlan.zhihu.com/p/243243145) + +#### 教程 + +* [推荐系统从入门到接着入门](https://zhuanlan.zhihu.com/p/27502172) +* [深度学习推荐系统笔记](https://zhuanlan.zhihu.com/p/133528693) +* [推荐系统干货总结](https://zhuanlan.zhihu.com/p/34004488) +* [入门推荐系统，你不应该错过的知识清单](https://zhuanlan.zhihu.com/p/54819505) +* [从零开始了解推荐系统全貌](https://zhuanlan.zhihu.com/p/259985388) +* [推荐系统玩家 之 推荐系统入门——推荐系统的发展历程（上）](https://zhuanlan.zhihu.com/p/148207613) +* [推荐系统技术演进趋势：从召回到排序再到重排](https://zhuanlan.zhihu.com/p/100019681) +* [深入理解推荐系统：召回](https://zhuanlan.zhihu.com/p/115690499) && [深入理解推荐系统：排序](https://zhuanlan.zhihu.com/p/138235048) +* [召回算法有哪些](https://www.zhihu.com/question/423384620/answer/1687201890) +* [《深度学习推荐系统》总结系列一](https://zhuanlan.zhihu.com/p/138446984) && [《深度学习推荐系统》总结系列二](https://zhuanlan.zhihu.com/p/140894123) +* [推荐系统--完整的架构设计和算法(协同过滤、隐语义)](https://zhuanlan.zhihu.com/p/81752025) && [从0到1打造推荐系统-架构篇](https://zhuanlan.zhihu.com/p/123951784) +* [协同过滤和基于内容推荐有什么区别？](https://www.zhihu.com/question/19971859) +* [CTR深度交叉特征入门总结](https://zhuanlan.zhihu.com/p/257895631) +* [推荐系统学习笔记](https://blog.csdn.net/wuzhongqiang/category_10128687.html) + +#### 实战 + +* [ AI-RecommenderSystem](https://github.com/zhongqiangwu960812/AI-RecommenderSystem) +* [team-learning-rs](https://github.com/datawhalechina/team-learning-rs) +* [RecommendSystemPractice](https://github.com/Magic-Bubble/RecommendSystemPractice) +* [Surprise](http://surpriselib.com/) \ No newline at end of file diff --git a/README.wehub.md b/README.wehub.md new file mode 100644 index 0000000..4c9071c --- /dev/null +++ b/README.wehub.md @@ -0,0 +1,7 @@ +# WeHub 来源说明 + +- 原始项目：`Mikoto10032/DeepLearning` +- 原始仓库：https://github.com/Mikoto10032/DeepLearning +- 导入方式：上游默认分支的最新快照 +- 原作者、版权和许可证信息以原始仓库及本仓库 LICENSE 为准 +- 本文件仅用于记录来源，不代表 WeHub 是原项目作者 diff --git a/books/Algorithms-JeffE-BW.pdf b/books/Algorithms-JeffE-BW.pdf new file mode 100755 index 0000000..d97f142 Binary files /dev/null and b/books/Algorithms-JeffE-BW.pdf differ diff --git a/books/Algorithms-JeffE.pdf b/books/Algorithms-JeffE.pdf new file mode 100755 index 0000000..a6903e5 Binary files /dev/null and b/books/Algorithms-JeffE.pdf differ diff --git a/books/Hung-yi Lee GAN-Basic Idea (2017.04.21).pdf b/books/Hung-yi Lee GAN-Basic Idea (2017.04.21).pdf new file mode 100755 index 0000000..4a4f5ca Binary files /dev/null and b/books/Hung-yi Lee GAN-Basic Idea (2017.04.21).pdf differ diff --git a/books/Hung-yi Lee GAN-Improving GAN (2017.05.05).pdf b/books/Hung-yi Lee GAN-Improving GAN (2017.05.05).pdf new file mode 100755 index 0000000..7c0342e Binary files /dev/null and b/books/Hung-yi Lee GAN-Improving GAN (2017.05.05).pdf differ diff --git a/books/Hung-yi Lee word2vec (v3).pdf b/books/Hung-yi Lee word2vec (v3).pdf new file mode 100755 index 0000000..42d2d45 Binary files /dev/null and b/books/Hung-yi Lee word2vec (v3).pdf differ diff --git a/books/Ng-MLY01-12.pdf b/books/Ng-MLY01-12.pdf new file mode 100755 index 0000000..d3e3a5e Binary files /dev/null and b/books/Ng-MLY01-12.pdf differ diff --git a/books/PRML/PRML solution.pdf b/books/PRML/PRML solution.pdf new file mode 100755 index 0000000..cda31d2 Binary files /dev/null and b/books/PRML/PRML solution.pdf differ diff --git a/books/PRML/PRML-master-Python/.gitignore b/books/PRML/PRML-master-Python/.gitignore new file mode 100755 index 0000000..a315e12 --- /dev/null +++ b/books/PRML/PRML-master-Python/.gitignore @@ -0,0 +1,93 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +env/ +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +*.egg-info/ +.installed.cfg +*.egg + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*,cover +.hypothesis/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# IPython Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# dotenv +.env + +# virtualenv +venv/ +ENV/ + +# Spyder project settings +.spyderproject + +# Rope project settings +.ropeproject + + +# VSCode project settings +.vscode/ diff --git a/books/PRML/PRML-master-Python/LICENSE b/books/PRML/PRML-master-Python/LICENSE new file mode 100755 index 0000000..2efc8c2 --- /dev/null +++ b/books/PRML/PRML-master-Python/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 ctgk + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/books/PRML/PRML-master-Python/README.md b/books/PRML/PRML-master-Python/README.md new file mode 100755 index 0000000..dedf419 --- /dev/null +++ b/books/PRML/PRML-master-Python/README.md @@ -0,0 +1,23 @@ +# PRML +Python codes implementing algorithms described in Bishop's book "Pattern Recognition and Machine Learning" + +## Required Packages +- python 3 +- numpy +- scipy +- jupyter (optional: to run jupyter notebooks) +- matplotlib (optional: to plot results in the notebooks) +- sklearn (optional: to fetch data) + +## Notebooks +- [ch1. Introduction](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/master/notebooks/ch01_Introduction.ipynb) +- [ch2. Probability Distributions](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/master/notebooks/ch02_Probability_Distributions.ipynb) +- [ch3. Linear Models for Regression](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/master/notebooks/ch03_Linear_Models_for_Regression.ipynb) +- [ch4. Linear Models for Classification](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/master/notebooks/ch04_Linear_Models_for_Classfication.ipynb) +- [ch5. Neural Networks](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/master/notebooks/ch05_Neural_Networks.ipynb) +- [ch6. Kernel Methods](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/master/notebooks/ch06_Kernel_Methods.ipynb) +- [ch7. Sparse Kernel Machines](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/master/notebooks/ch07_Sparse_Kernel_Machines.ipynb) +- [ch9. Mixture Models and EM](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/master/notebooks/ch09_Mixture_Models_and_EM.ipynb) +- [ch10. Approximate Inference](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/master/notebooks/ch10_Approximate_Inference.ipynb) +- [ch11. Sampling Methods](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/master/notebooks/ch11_Sampling_Methods.ipynb) +- [ch12. Continuous Latent Variables](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/master/notebooks/ch12_Continuous_Latent_Variables.ipynb) diff --git a/books/PRML/PRML-master-Python/notebooks/ch01_Introduction.ipynb b/books/PRML/PRML-master-Python/notebooks/ch01_Introduction.ipynb new file mode 100755 index 0000000..edea71c --- /dev/null +++ b/books/PRML/PRML-master-Python/notebooks/ch01_Introduction.ipynb @@ -0,0 +1,273 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 1. Introduction" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from prml.preprocess import PolynomialFeature\n", + "from prml.linear import (\n", + " LinearRegression,\n", + " RidgeRegression,\n", + " BayesianRegression\n", + ")\n", + "\n", + "np.random.seed(1234)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1.1. Example: Polynomial Curve Fitting" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def create_toy_data(func, sample_size, std):\n", + " x = np.linspace(0, 1, sample_size)\n", + " t = func(x) + np.random.normal(scale=std, size=x.shape)\n", + " return x, t\n", + "\n", + "def func(x):\n", + " return np.sin(2 * np.pi * x)\n", + "\n", + "x_train, y_train = create_toy_data(func, 10, 0.25)\n", + "x_test = np.linspace(0, 1, 100)\n", + "y_test = func(x_test)\n", + "\n", + "plt.scatter(x_train, y_train, facecolor=\"none\", edgecolor=\"b\", s=50, label=\"training data\")\n", + "plt.plot(x_test, y_test, c=\"g\", label=\"$\\sin(2\\pi x)$\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf8AAAEQCAYAAAC+433pAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzs3XV0FFcbx/HvREgILsElaHANXtyLFyjuDm2BliLFQoACLaUUWtyhhSIt7lbc3a24BA9x2ef94+ZtkaQE2M1E7uecOQ2zI79sb/bZmblzxxARNE3TNE2LP+zMDqBpmqZpWvTSxV/TNE3T4hld/DVN0zQtntHFX9M0TdPiGV38NU3TNC2e0cVf0zRN0+IZXfw1TdM0LZ7RxV/TNE3T4hld/DVN0zQtnnEwO4AZUqdOLW5ubmbH0OKwo0ePPhIR1+jer27bmi2Z1a4164uXxd/NzY0jR46YHeMVFgts3gxHjkDKlNC0KbjqP7FYyzCMG2bsNya27adPYelS8PaGIkXg44/B3t7sVNr7MKtda9anT/vHAHfvQrFi8M034O8P+/dD7twwb57ZyTTtwyxbBtmzw44dEBgI334LBQrA9etmJ9O0+C1eHvnHNK1bQ8OGMHw4GIaad/EiVKyojpSKFDE3n6a9j8uXoWdP2LkTChf+d/4PP6gzW4cO/dveNU2LXvrI32TnzqlCP2TIqx+E7u7wxRcwbZp52TTtQ8yYAZ07v1r4Afr2hefP4fBhc3JpmqaLv+muXIGiRcEhgnMwJUqooydNi40uX1Zt+HV2duDhAZcuRX8mTdMUXfxNljUrnDkDYWFvvnbqlHpd02IjNzfVhl8nAidPqtc1TTOHLv4mK1wY0qeHSZNenX/zJvz4I3TrZk4uTftQXbrA1Knq7NbLZs9WR//lypmTS9M03eEvRvjtN6heHdauhVq1VOH/7TcYNgxKlTI7naa9n/z5Ve/+kiWhWTPV63/7dtXPZdMm3dlP08ykj/xjgGzZ4OxZ1Tnq/n1Ilw6OHoXevc1OpmkfplMnderfzU217RYt4MIFyJPH7GSaFr/pI/8YwslJfTC2aGF2Ek2zrkyZYMAAs1NomvYyfeSvaZqmafGMLv6apmmaFs/EieJvGMYcwzC8DcM4Y3YWTbMm3bY1TbOFOFH8gXlALbNDaJoNzEO3bU3TrCxOFH8R2QU8MTuHplmbbtuaptmC7u0fgzz0e8i6y+vYc3MPZx+e5e6LuwSFBpE4QWIyJc1E4bSFqZKtCtVzVMfF0cXsuJoWJSLCifsn2HhlIwfvHOTq06s8CXiCiJAyYUpypcpFiQwlqJmjJsXSF8PQAwBoms0ZImJ2BqswDMMNWCsiBSJ5vSvQFSBLlizFb9yIOY+l3nVjFxP2T2DNpTVYxELKhCkpkq4ImZJmwtneGd8QX/5++jcnH5zEP8SfxAkS07JAS74q+xW5U+U2O74WAcMwjoqIh5W25UYsbNsBIQHMOjaLKUemcOHRBQByp8pN3tR5Se2SGgODRwGPOP/wPBcfXwTAPZU7vUr0olOxTvoLbgxkzXatmSveFP+XeXh4yJEjR2ye6W3OPTxHn4192HJtC6ldUtOpaCea5W9GkXRFIjz6CQ4LZs/NPSw8tZDFpxcTYgmhU9FOjKoyijSJ0pjwG2iRic7i/7KY0LYtYmHByQV8s+0b7vneo1TGUnQu1pn67vUjbafeft6subiGWcdnceD2AdIlTseoyqPoULQDdkacuDoZJ+jiH3fo4m+CkLAQRu8ezejdo0mSIAlDKwylu0d3EjomjPI2Hvg+YMyeMfxy+BeSOiXFq/TPlE7UgmzZIGVKG4bXoiS+Fv/rz67TbmU7dt3YRZlMZRhTdQwV3Sq+0zZ239jNgK0D2H97PxWyVGBg3rlkdMlO/vxgb2+j4FqU6OIfd8SJr9SGYSwG9gPuhmHcNgyjk9mZInPH5w4V51VkxF8jaF6gOZc+v0TfMn3fqfADpE2clom1JrK50UksD3Pz2Y6W1PilI9lzB9ClC/j72+gX0KJVbGrbf57/k8LTCnP83nFm1ZvFno573rnwA5TPWp69HffSK+Mc9lw5Sd01Ran15XKyZ1fPvNA07cPFieIvIi1EJL2IOIpIJhGZbXamiBy6c4jiM4pz6sEpFjdezMJGC0ntkvq9txcYCD2a5OPzRLsZWGYoT7POI9vICjwMvEurVlYMrpkmNrRtEWHEzhF8svQTcqfKzakep+hUrNMHna7futXgj2EdWFzxJCWz5eNe+aZUHT2UAQOFlSutGF7T4qk4Ufxjg3WX1lFpXiVcHF042PkgzQs0/+BtLl0KWbOCl6cDY2p4sbL5Sq48u8CJ4mXZd+lihM9S1zRrCrWE0ml1Jzz/8qRd4Xbs7rAbt+RuH7zd0aNhwgT4tEZWdrbfSaeinZh7dRTu/TswcnTIhwfXtHhOF/9osOzsMhr+3pB8rvnY32k/+dPkt8p2d+2CRo3+/Xd99/r81f4vAkID8GlcniXb9aBwWgQ6dlSPkPzAvgHBYcE0X96cuSfmMrzicOY2mIuzg/MHxxOBPXv+bdtODk7MrDcTr0pebHs8nxO5mvHsRfAH70fT4jNd/G3sj/N/0GJFC0plLMW2tttImzit1badODE8fvzqvGLpi7G7w26wODL5RWXOep+12v60OEAEEiaExYuhRAk1zZnzzp1EQi2htFzRkhXnVzChxgQ8K3la7f58wwAXl1fbtmEYDK04lLEVJ2Fx/5N2a5sREqbPAGja+9LF34Y2X91M8+XNKZmxJBtabSCZczKrbr95c5g1C168eHW+w/PcOP66k0QJHam+sDrXnl6z6n61WMww4Jdf4O5dmDwZAgKgUyfIkAF694Zz5966CYtY6LS60z+Fv2+ZvlaP2bw5TJz45vzg3Z9T7P5kVl9aSYdVHbCIxer71rR4QUTi3VS8eHGxtcN3Dkui0Ymk8NTC8jTgqU32YbGI9OghUqSIyLJlImfPikyfLpI5s8jUqSJnHpyRlONSSq5JueSh30ObZNAiBhyR2NC2LRaRXbtEWrYUSZBABEQqVBBZvFgkMDDCVfpv7i94IiN2jni3fb2DO3dEsmUT6dpV5MABkUOHRD77TCRTJpFr10RG7xoteCL9NvWzWQbtTWa1az1ZfzI9gBmTrYv/jWc3JN34dJL1x6xy1+euTfdlsYj89ptIlSoiefKINGoksn37v6/vvblXnEc5S9nZZSUgJMCmWbR/xZri/zJvb5GxY0WyZ1cfDa6uIgMHqmobbtrhaYIn0mNtD7FYLO+/ryjGGTpUpFAhkYIFRQYMELkb/udksVjks3WfCZ7IL4d+sWkO7V+6+MedKc4M8vMubDkQim+wL+XmlOPGsxvs67SPfK75bLKfd7H83HKaLmtKm0JtmN9wvh47PRqYNRiKVdq2xQJbtsDUqbBmjeonUKsWpxqVxePOcKrnrsWq5qtwsDP30SBhljAa/d6I9ZfXs77VemrkqGFqnvhAD/ITd+hr/lYkInRY1YEz3mf4vcnvMaLwAzTJ1wSvSl4sPLWQHw/8aHYcLaazs4OaNWHlSrhxA4YOJfT4UQp1HcqNSXasuFgUhwcPzU6JvZ09v37yK/lc89FseTOuPrlqdiRNizV08bei8fvGs/zccsZVG0fNnDXNjvOKIRWG8EneT+i/pT87/t5hdhwttsiUiYAhAykzND1tWruQrHApnL1GQ5Ys0KQJbN2qzhSYJIlTElY2X4mBQaPfG+Efooe21LSo0MXfSv66/hcDtw2kSb4mfFXmK7PjvMEwDOY1mEfuVLlpsaIF917cMzuSFkt8tv4zjjw8SfOhS3HZsQcuX4Y+fWDHDqheHfLkgR9+ePO+02iSPUV2FjdezBnvM/Ra38uUDJoW2+jibwUP/R7SYkULcqbMyZz6c2LsNfUkTklY1nQZL4Jf0GJFC8IsYWZH0mK4hScXMufEHL756Bvq5K6jZubMCd9/D3fuwMKF4OoK/fpBxozQrh0cOKD6CUSjmjlrMqTCEOadmMe8E/Oidd+aFhvp4v+BLGKh3cp2PAl4wtImS0nilMTsSP8pf5r8TPl4Cn/d+IvRu0ebHUeLwS49vkSPdT0on6U8IyqPeHMBZ2do3Rr27oWTJ9XIgX/+CWXKQNGiMG3am4NQ2NDwisOp5FaJXut7ceHRhWjbr6bFRrr4f6BJByex4coGJtScQME0hdm0CXr2hO7dVUfpsBh4cN22cFtaFWzFiL9GsPfmXrPjaDFQcFgwLVe0xMnBid8a/4avjwOTJqnxgAYPhkuXXluhUCGYMkWdDZg2Tc3r0UMNHtSjB9HxoAl7O3sWNVpEQoeEtFjRgqDQIJvvU9NiK138P8CpB6cYsHUA9d3r07FgD+rVg/791VnRvHnBywuqVgU/P7OTvsowDKbUmULWZFlp/WdrfIJ8zI6kxTDDdgzj6L2jzKo3iweXM5EnDxw8CKVLQ2gofPSRGijwDUmSQLducPw47N8PjRvDvHlQuDCULasuEwQG2ix3xqQZmdNgDifun2DojqE224+mxXpmDzRgxmSNQX4CQwKl4JSCkvb7tOLt6y0jRojUry8SEvLvMmFhauC0L7/84N3ZxN6be8VuhJ20+7Od2VHiHGLjID/hdl3fJYanIZ1XdZbQUDXS3vLlry5z/bpI2rQip05FYYOPH4tMmCCSO7cIiKRMqf4oLl364KyR6b6muxiehuz4e4fN9hEfmdWu9WT9yfQAZkzW+ID8/xCn6y6tExE17Ojp028u9/ffIilSiISGfvAubWLItiGCJ/Ln+T/NjhKnxNbi7xPoI24T3STHTznkRdAL2bxZxMMj4mWHDRPp0+cdNm6xiGzbJtKkiYiDg/r4qVZNfbMIDv6g3K/zDfKVnJNyStYfs8rzwOdW3XZ8pot/3Jn0af/3sO/WPr7f9z1di3Xl41wfI6IudebN++aybm4QFKSenxITDa04lKLpitJ1TVce+pk/cItmrn6b+3Hj2Q3mN5xP4gSJI23XAPnyqXYfZYYBVarAsmVw6xaMGgUXL6rxArJmhWHD1HwrSJQgEQsaLuCWzy36brT+g4c0LbbTxf8d+Yf4025lO7Imz8r4GuMB9ZmWNy/s2/fm8sePQ6pUkChRNAeNogT2CVjQaAHPAp/x2YbPzI6jmWjTlU3MODaDr8p8Rbks5QDVrvfvj3gcn717I/9i8Fbp0qmeg3//DatXq7sDRo1S35YbNIANGz548KAymcvQv2x/5pyYw4bLGz5oW5oW1+ji/46GbB/ClSdXmFN/ziu39fXuDX37wpMn/y7r4wNffKGmmHjrv4jqxLVgfAFK+I1g6dml/H56mdmxNBM8D3xO5zWdyZM6DyOrjPxnfsmS6svrt9++euv+nj3w22/QufMH7tjeHurVg3Xr4No1GDBAjRPw8ceq5+y4ceDt/c6bDQiA+fPh+SpPXCU/7f/szLPAZx8YVtPiDl38I/H8uTooCQ7+d96+W/uYeGAiPTx6UDlb5VeW79JF9ezPmVONc9KxI2TPrjo5f/llNIePgrAwlbFFC3VWol7Kr3F55kHrJb24dl+f/o+rROD2bbj32gCP/bf05+6Lu8xtMBdnB+d/5hsGrFihbt8vWBA+/xxq1YJPPlHFP3NmK4Zzc1PfMm7dgiVL1BDCAwdCpkyqoe7aFaXBg65cUZckfv8d3HM6Ud1vLt5+96k5oZ8Vw2paLGd2pwMzpv/qFHXnjsinn4okTSqSJYt6qqmXl4hvYIC4T3aXrD9mFZ9An0jXv3lTZOpUkV9+eeVJqDHOlCki5cqJ+Pn9O+/kvdNiN9xRcvRvYV6wOIIY2OFvzRr1aFxXV9XhvmRJkZ07RbZd2yZ4Iv029Yt0XYtFZMcOkZ9+ElmyRMTf//3el3d27pzIF1+IJEsmAiL58olMmiTy9GmkOUuUEJk8+dX5Pf8YIHgiE9dsjobQcZdZ7VpP1p9MD2DGFNkH5IsX6m6kwYNFnod3EL50SaRiRRGPAYMET2TTlU0RrhvbFCmiOl6/7uu1IwRPZOnJ1dEfKg6JacV/wwaR9OlFNm1SBTI0VHWyT53eVzKOyy65JuUS/+Doqujvwc9PZM4cVdlBxMVFpFMnkcOHX1ns2DF1a2JY2KurB4QEiOuI3JJ4SFZ5EfQiGoPHLbr4x51Jn/Z/yaJFqgPTqFGQNKmalysXeM04zhGn72iWu0OceWb4zZvqNO7rRtUaiMPjgnyxqQfPA59HfzDNJoYPVwPv1aihTuXb26vxd4p+OYw7AdeYVX8WCR0Tmh0zci4u0KEDHDoER45Ay5aweDGUKKGm2bPB35+bNyF/fvVU4pc5OzgzKP9sfO1vMnjbYHN+B02LQXTxf8nWrfDpp6/OC7WE0ndnZ5zCUlM17AdzgtlA7tyqs9/r7t1OgMuW2XgH3GPg1oHRH0yzOh8fOHMG6tR5df7hO4fZ5j8R+2PdqZC1gjnh3kfx4jBzJty9C5Mnq959nTtDhgyUX/YFPgfOERLy5mq+5z6iQEBPJh+azP5b+6M/t6bFIHGm+BuGUcswjIuGYVwxDOO9qpaT05tD8f64/0eO3TtG3r8nk8olhTWixgiffw6DBsGjR//OCw5Wdy10rVuCPqX6MO3oNHbd2GVeSM0q7drRUfWTC3ppqPvgsGA6re5EWpf0JNo/1lpxo1eyZPDZZ3D6NOzeDXXqkHLZdP56lJ/bOSoivy3+55c+exZ+/hlmNhtDpqSZ6LymM8FhwW/ZgabFXXGi+BuGYQ/8AtQG8gEtDMPI967badxYHVCEhqp/X31yleE7h1M1UwOub2hC9erWTG2uFi2gYUNwd1cHTb17Q44cqlCMGgUjq4wkW/JsdFnThcBQ243FrkXOWu06YUJ1J8qcOf/O+37v95z2Pk15nyk0rZ/MWpHNYRjqYQO//gq3b/NiyDgcvW9jtGrJi5RZWJl3EC3KXOfHH6F0sSRMqzuNcw/PMXZPLP3So2nWYHanA2tMQBlg00v/HgQMimz5yDpFhYSI1K4tUquWyO7dFik/s6ok9EoqGfPelmnTIlwl1rtxQ/Xg/v57kRMnXn1t85XNgicyeNtgc8LFMI/8HkV5WazQMepd27X8R9s+fVokTRp158rW4xckgZeTuA9pIhkzqnH64xpLaJgcH7NBLuZrIGGGnVgMQ/1xr1olEhoqzZc3F0cvRznnfc7sqKbzC/YTv2C/ty8o1mnXeooZU5w48gcyAi+PC3o7fN47cXBQ9zNXqwbNxsxn951tZL30HbMmZKRbN6tljVGyZFGDEPXrp8YkeFn1HNVpW7gt4/aO4/SD02+s++gRbNoU+Qhwccnxe8fJ/GNmVl9cHZ27tUq7BihQQA3Mc/2GhY+ndiUkICFln09m/341sm5cY9jbUWRgLXKfXYndzRsYQ4fCiRNq9MBs2Zh5Iis5gxLRZU0XLPJm4z11Sg0yeP169GePbkO2D6HItCL4Bcewx49qNuVgdgAriWj8vFdGAzEMoyvQFSBLliyRbsjJCb76Cjpc2s6TFRnJkXIxxtjFEE/PEM6yhND1DgQvKoekL4qBgUXg6lV4cB/SJYHgEDgUpi4hpEhudmLrE4Swe8fYGhpKsXvr4ef60bXrt7ZriHrbzpULZs00KH+yAwnsE9CyYDqrBY3RMmWCESNgyBBYswamTSPxqHGccbDnj1x7WRPQhwY9fwLD4NIlaNMGHjxQ7fnYMXVFYc4cSBF3uvz84/Cdw/x08Ce6FutKogQxdAxyzSbiypH/beDlscYyAXdfXkBEZoiIh4h4uLq6vnWDKROmJGfKnBF++sYnjnaO5EyZixdBL7jjo57icu0a+PtDqVLqbIGHh7p74NxZ8PM3ObAN3Pa5jW+QLzlT5npl9Lvo2DVvadfwbm3bMAzaF2lPy4ItrZs0NnB0VEMTbt4Mly9j9O5D9VuONPhsMiG5cxI0ZgJNKj+mXTvVxjdtUrfEZsyo+gPJ2wcXjFVCwkLosqYL6RKnY2y1eHp0E5+Zfd3BGhPqDMY1IBuQADgJ5I9seWs80jc+sVgsUntRbUk0OpGcvHFdkicXuX//zeVGjBDp1i3689nS1SdXJeGohFLvt3pisViivB7Wueb/Tu1adNt+Z1fvnJUOTRzlXO4UIiBBdk4ibduK7NunRkMSNSBStmwiBw+aHNbKvt317Ts/ztsa7VpPMWOKE0f+IhIKfAZsAs4DS0XkrLmp4g7DMJhaZyoAXVd3xz2PkDbtm8vVrq3GYIkrRIRua7vhYOfAlDpTMKL56Uy6Xdte9gz5yNf3W/K1fErnZt9zuXxH1fGnbFn1pMFp07D3f0HNmnGrbV96fIkRf42gSb4mNMzT0Ow4mgniRPEHEJH1IpJbRHKIyGiz88Q1WZNn5duq33Lw8UauuCyKsIPfnTtx67rovBPz2HptK+OqjSNT0kymZNDt2vb6lO5D8fTFWez+PfMqjlQNefp0dQthjx6QIQP1N/Qgm89Js6NahUUsdF7dmYSOCZlUa5LZcTSTxJnir9lerxK9KJOpDM9K92H6ogevvBYSAj/8oDpLxQX3fe/z5eYvKZ+lPN084uitHhoADnYOzK4/m2D7J/xy5UseBSWBrl1Vb7/9+3lSpQmVbsyjzuAi6ozAwoUQGHvHvphxdAa7b+5mQo0JpE+S3uw4mkl08deizN7Ontn1Z2Pn7EvfLZ/Tty9s366GWK9QQT33vXVrs1N+OBGhx7oeBIYGMqv+LOwM/WcS1xVOV5iBHw0kIPcCCn2ykWnT4K9dBqO3lSbvgblsnHUHJkyAx4+hbVvVC7BfP7h82ezo7+Tm85t8veVrqmWvRvsi7c2Oo5lIf6pp7ySva16GVxxGUM5l3HD5gxEj1HPdv/gCli9XYyXEdsvOLWPlhZV4VfIid6rcZsfRosmQCkPImzovobW7sGWXD0OHqt7+W7ZAo04poW9fuHBBPQSkShX46Sd1m0u1arBiBRE+UCAG+X8fFhFhZr2Z0d6HRYtZ4sBHtRbd+pfrz4rzK9j7ogfnNlQklUsqsyNZjbefN73W96JEhhL0LdPX7DhaNHJycGJug7mUnVOW1C2+ZkW96W8uZBhqrOSqVeHePTUAwPTp0KQJpE+vxsru0gUyZ35zXZPNOzGPjVc2Mrn2ZNySu5kdRzOZPvLX3pmjvSNzG8zlScATPt/wudlxrEZE6LW+Fz5BPsxtMBcHO/3dOL4plakUX5X5ihnHZrD56ub/Xjh9ehg8GP7+G1avVncHjBoFbm5qJMGNG2PM0Je3fW7Td1NfKmatSM8SPc2Oo8UAuvhr76VwusIMqzCMxWcWs+LcCrPjWMXvZ39n+bnleFb0JH+a/GbH0UziVdmLPKnz0Hl1Z54HPn/7Cvb2UK8erFunhr4cMAAOHFD3vubMCWPHgre37YNHQkTotLoToZZQ1WdH92HR0MVf+wADPxpI8fTF6b6uOw98H7x9hRjs3ot79FzXk1IZS/F1ua/NjqOZyNnBmfkN53P3xV16b+z9bitnywbffgu3bsGSJerhGYMGqSGGW7SAXbuifajA6Uens/nqZr6v/j05UuaI1n1rMZcu/tp7c7R3ZEGjBbwIekGXNV2QaP5QsxYRoePqjgSGBjK/4Xx9ul+jZMaSfFP+G+afnM8f5/949w0kSADNmsHOnXD+PPTsqS4DVKyonrI0eTI8e2b13K+79PgSX23+iurZq9Pdo7vN96fFHrr4ax8kn2s+xlUbx5pLa5hxdIbZcd7LL4d/YeOVjYyvMR731O5mx9FiiKEVhlI8fXG6runK3RdvPFIh6vLkgYkT1eBBc+ZAokTq9pgMGaBTJzhyxHqhXxISFkKbP9vgZK86Mure/drLdPHXPtjnpT6nevbq9N3UlwuPLpgd552c8T5Dv839qJ2zNj08ekS4zKFD0L69Gt+lRQt1MKfFfY72jiz6ZBH+If60X9k+wkf/vhMXF+jQQTWoo0ehVSt1aaBECTXNnq2emGUlnjs9OXTnENPrTidj0jefBB0crL6L1Kypnlw4ZAjc/YDvOFrsoou/9sHsDDvmNZxHogSJaLa8GYGhsWP0M/8Qf1qsaEFy5+SRHhnNmgWNGkGhQvDdd1C+vPr8HqsfghYv5Emdh4m1JrLl2hbG7xtvvQ0XKwYzZ6qzAZMnQ0CAuk0wQwbo3RvOnfugze/4ewdj9oyhY5GONM3f9I3XAwNVf8RFi6B7d3WTgo8PFC8OZ8580K612MLsJwuZMeknn9nG2otrBU+k59qeZkeJUGCgyIkTIhcvqge2dVndRfBENl7eGOHy3t4iyZOLXL786vy7d0VcXUUuXYp8X5j09DPdtq3PYrFIk6VNxMHLQfbf2m+rnYjs2iXSsqVIggQiIFKhgsjixSJBQW9d/cEDkaNHRR4+FHng+0DSjU8n7pPd5UXQiwiXnzhRpHZt9cTCl02fLlK+fOT7Matd68n6k+kBzJj0B6Tt9NvUT/BElpxeEukyW7eKNGki4uEh0ry5+syzJYtFfdilSSOSL59IpkwimessFDyRQVsHRbrelCkirVtH/NqXX4p4eka+T13845anAU8l28RsknlCZnnk9yjCZXx9VTurUEGkdGmRIUNE7t17j515e4uMGyeSPbv6iHZ1FRk4UOTatTcWffhQ/S0lTy5SuLBI0uShkq5/NXEe6Swn75+MdBceHiLbt785PzhY7e7GjYjX08U/7kz6tL9mVd9W/ZaymcvSaXUnzj1889TlmDFqALTq1eGXX9S1xpYt1ZlPW/n5Z3X6fudOOHsW1h46zYOSXXG4U4FPXb0iXe/pU3UWNiIZMqjXtfghuXNyljVdxgO/B7T8oyVhlrBXXvfxUR35d+xQd/aNG6ceA+DhAVeuvOPOXF2hf3/13IANG1Rnk+++gxw54OOP1YBCYWGEhUGtWuouwps34cQJ6PLrcO67bCXr2V8omKZQpLuIrG07OqrdR8ONCJrZzP72Ycakj45s6/bz25L2+7SSa1IueRrw9J/5V66IpE6tTpu/7Pp1deTy+nxrCA4WSZ9e5PRp9e9Hfo8k28Rskn58ehk85p60axf5utu2iRQooM4cvK5KFXVGNjLoI/84aebRmYInMmDLgFfmDxmizhJAFzEhAAAgAElEQVS93la+/16kXj0r7PjWLZFhw1RjBpHMmeV8Sy/5uMidf/a5/OxywRPpuLKT5Mkj8tdfkW+uVSuRCRPenH/1qkiqVCL+/hGvZ1a71pP1J9MDmDHpD0jb23V9lzh4OUiNhTUkJCxERERGjhTp3Tvi5Tt0EPnpJ+vnOHdOJGdO9XNwaLBUnV9VEoxMIPtv7ZeLF0WyZYt8XYtFpFQpkX79RAICwrcRLDJmjEju3P99KVYX/7ir25pugiey6OSif+ZlyyZyMoKz7H5+IkmSiDx9+uZr7yU4WGTFCpHq1UVAwuzsRRo3litLp0vikS5SelZpCQwJlIEDRby8It/MsWPqMtiOHf/Ou3tXpGzZ/15PF/+4M+nT/ppNlM9anml1prH56mZ6b+iNiPD8OaRLF/Hy6dLB8yiMpPquEiVS2w0JEXqu68m2v7cxve50SmcqzePHkDhx5OsaBqxZo8ZoyZJFPbzNzQ02bVJPekuQwPp5tZhvUu1JVHKrRKfVndhzcw9ApG3bxUW1QV9fK+3c0RE++QQ2b2bS55fZVawvYTu2k+PTbpz8KYiND6rj9Nz3rW27aFGYN0/dwlqokLpkkS8fVKqkHlegxQNmf/swY9JHR9Hn681fC57I2N1jZcUKkXLl3lzGYhEpVEhk82bbZChdWuSTn7wET+Sbrd/8s89mzURGjYraNq5eFdm0SeTChagtjz7yj9Me+T2S3JNzS4qxKeSc9zmpU0dk9uw3lztyRCRr1jd71VvDuXMirpmfSbEfC0rHpk7yokRhERCLk5MsTtBW7q/cH/E1q5eEhors26c64T579vZ9mtWu9WT9SR/5azY1ttpYWhRowcBtA/HOPJNnz2D4cAgKUq8HBMDXX4Ozs3pKqi1U7DeVP54Oo6ClDU1Tj2TXLvj0U9Wf6osvoraN7NmhRg1w1wMAakAql1RsaLWBBPYJqLGoBm2/uM7gwbB377/LXL0K7drBwIHq2T/WljWnP84d6nPs6Xlca6zi1vwTrB55kt+cOtKIP0jbsIw6xJ8+HV68iHAb9vZQpoz620uWzPoZtZhLF3/Npv4/AFDtnLXpub4bnX+ez8GD6jR6xYrqv5cvqwei2dmgNc45PodxZ3pSOUNdyjycTcsWdvTtq3ph79wJSZJYf59a/JA9RXY2t9mMb7Avgy5UZcTEm7RsqU6jly4NpUqpAaG6dbP+vgNCAmi4pCG37XbzpdtCji+rScOGMH1/IVIsnoLTo7swbZpauHt31bW/Rw84dcr6YbRYyVBncuIXDw8POWKj8bS1iAWEBNBgSQO2XtvK9LrTqZayC9evq7uXsmSxzT6nHJ5Cr/W9qJmjJiubr8TZwdk2O4qAYRhHRcQj2nYYTrft6HfoziFqLKxBioQp2NRyK0+v5SA4WI2W5+Ji/f29CHpBgyUN2Hl9J3MbzKVdkXaRLywCBw/C1KmwdKka2q9MGfVFoGlTdcrtHZjVrjXr00f+WrRI6JiQVc1XUStnLbqu7cqvt0ZRqZLYpPCLCMN3DKfX+l7Uy10v2gu/Fr+UzFiSrW234hPkQ4X55XDIfJTy5W1T+O/73qfy/MrsurGLBY0W/HfhB9VrtXRpmD9fDSU8YYIagKBtW8iYEb76Sp160+IdXfy1aPP/LwBtCrVh6I6htPmzDf4h1nuQCYBvsC8t/2iJ1y4vOhTpwIpPV+jCr9mcRwYP9nTYg5ODE+Xnluf3M79bfR9H7x6l1KxSnH90nj+b/UnrQq3fbQMpU0LfvnDhAmzbBlWqwKRJkDu3GnUrMHY8k0OzDl38tWjlaO/I/IbzGV1lNL+e/pWSM0ty6oF1rkMev3ecUrNKsfTsUsZWHcvs+rNxtHe0yrY17W3yuublUOdDFE1flOYrmtNzXU/8gv0+eLsWsTDp4CTKzSkHwK72u6jnXu/9N2gYqvAvWwa3bqmn+mTI8M6XALTYLdYXf8MwmhqGcdYwDIthGPpaVCxgGAbflP+GTa038dD/IcVnFGfo9qHv/UHpF+zHN9u+odSsUjwNeMrm1psZ8NGAWP38ct2uY6e0idOyo90OvirzFVOPTKXQtEJsuLyB9+1bdcb7DJXnV6b3xt5Uy16No12PUjxDcesFTpdO3dg/f771tqnFCrG++ANngE+AXWYH0d5NjRw1ONvzLM3yN2PU7lHkmpyLCfsn4BPkE6X1nwU+44d9P5B9UnbG7BlDy4ItOd3jNFWz2+ieweil23UslcA+AeNrjGdnu53YG/Z8/NvHVF1QlS1Xt2ARS5S2cerBKdr+2ZbC0wpzxvsMs+rNYk2LNaR2SW3j9Fp8EWd6+xuGsRPoJyJv7eqse0THPPtu7WPw9sHsvL4TZwdn6uauS43sNSiWvhiZk2UmkWMi/EP8ufH8BsfuHWPT1U1suLyBgNAAKrtVZlSVUZTNXNbsX+Mf1uoV/S7tGnTbjmmCw4KZengqY/eO5b7vfdySu9EoTyMqZq1IPtd8pEmUBjvDjicBT7j85DL7bu1j1cVVHLt3jIQOCelVohcDPhoQY4q+7u0fd+jir8UoR+4eYc7xOay8sJJ7vvciXS594vQ0ytOIzsU6UzR90WhMGDW6+GsvCwoNYvm55Sw6vYgdf+8gKCwo0mVLZSzFp/k/pX2R9qRMmDIaU76dLv5xh4PZAaLCMIytQESjwg8WkVVR3EZXoCtAFlvdWK59MI8MHnhk8OCXj3/h8pPLnH5wmnu+9/AP8SehQ0IszzJxeW9BEtzNQeXcBoXSmJ34/VmjXYdvR7ftGM7JwYlWhVrRqlArAkICOPngJBcfXeSR/yMAEjsm4+65bDw6VZw0JKduBUiZ0OTQWpymj/y1WEFEPeL811+hTRt119Iff4DFAhs3QqpUZid8lT7y16Lq3j01dHTy5FCvHnh7w8KF0KsXDBtmdrpX6SP/uCNWHPlr2vLlqsifPQspUqh5/fur25Z79YIlS8zNp2nvq2NHaNQIvLz+nde/P5Qtq4YIrlnTvGxa3BXre/sbhtHIMIzbQBlgnWEYm8zOpFnf9OnqgUD/L/ygblf28lKP2H340LxstqDbdfxw/TocPQrffPPq/DRpYNCgf4fn1zRri/XFX0T+FJFMIuIkImlFRH9PjoOuX1cPTHld0qSQObMauTQu0e06frh1Sw2wF9H4OoULw40b0Z9Jix9iffHX4odcueDw4TfnP32qPkB1PzctNsqWDc6fB/8IRrk+fFi1e02zBV38tVjhs8/A0xPu3/93XlgY9OsHDRuqDoCaFttkygSVKqlT/C/3vb55E8aMgZ49TYumxXG6w58WK9Spox5Fni8fNG6srv2vWqVO+f/5p9npNO39zZgB9etDgQKqt/+DB7ByJYwYARUrmp1Oi6v0kb8WawwaBCdPQv78kCwZzJkDW7ZAkiRmJ9O095cqFezZAz//rNpysWLqUsAXX5idTIvL9JG/Fqtkzgx9+pidQtOsyzCgcmU1aVp00Ef+mqZpmhbP6OKvaZqmafGMLv6apmmaFs/o4q9pmqZp8Ywu/pqmaZoWz+jir2mapmnxTJx5pO+7MAzjIRCVUbNTA49sHEdniD0ZIOo5soqIq63DvE63bZ3BxhlMadea9cXL4h9VhmEcMfvZ1TpDzMkQk3J8qJjwe+gMOoNmHn3aX9M0TdPiGV38NU3TNC2e0cX/v80wOwA6w//FhAwQc3J8qJjwe+gMis6gRTt9zV/TNE3T4hl95K9pmqZp8Ywu/pqmaZoWz8Tb4m8YRi3DMC4ahnHFMIyBEbzuZBjG7+GvHzQMw+2l1waFz79oGEZNG2b40jCMc4ZhnDIMY5thGFlfei3MMIwT4dNqG2ZobxjGw5f21fml19oZhnE5fGpnwww/vrT/S4ZhPHvpNWu9D3MMw/A2DONMJK8bhmFMCs94yjCMYi+9ZpX3wVp0245yhjjftuNSu9asTETi3QTYA1eB7EAC4CSQ77VlegLTwn9uDvwe/nO+8OWdgGzh27G3UYbKgEv4zz3+nyH8377R9D60B36OYN2UwLXw/6YI/zmFLTK8tvznwBxrvg/h26kAFAPORPL6x8AGwABKAwet+T7otq3bti3adlxp13qy/hRfj/xLAldE5JqIBANLgAavLdMAmB/+83KgqmEYRvj8JSISJCJ/A1fCt2f1DCKyQ0T8w/95AMj0Hvv5oAz/oSawRUSeiMhTYAtQKxoytAAWv8d+/pOI7AKe/MciDYAFohwAkhuGkR7rvQ/Wott2FDP8hzjTtuNQu9asLL4W/4zArZf+fTt8XoTLiEgo8BxIFcV1rZXhZZ1Q39D/z9kwjCOGYRwwDKPhe+z/XTI0Dj8luNwwjMzvuK61MhB+ajgbsP2l2dZ4H6IispzWeh+sRbftd8sQ39t2bGnXmpU5mB3AJEYE816/5zGyZaKyrrUyqAUNozXgAVR8aXYWEblrGEZ2YLthGKdF5KoNMqwBFotIkGEY3VFHjFXeJb8VMvxfc2C5iIS9NM8a70NU2Lo9WItu21HPoNt27GnXmpXF1yP/20Dml/6dCbgb2TKGYTgAyVCnz6KyrrUyYBhGNWAwUF9Egv4/X0Tuhv/3GrATKGqLDCLy+KX9zgSKv0t+a2R4SXNeOy1qpfchKiLLaa33wVp0245iBt22gdjTrjVrM7vTgRkT6ozHNdRptv93xMn/2jK9eLVT1NLwn/Pzaqeoa7xfp6ioZCiK6jCU67X5KQCn8J9TA5f5j45EH5gh/Us/NwIOhP+cEvg7PEuK8J9T2iJD+HLuwHXCB6ay5vvw0vbciLxjVB1e7Rh1yJrvg27bum3bqm3HhXatJ+tPpgcw7RdXvVwvhX8ADQ6f54U6CgFwBpahOj0dArK/tO7g8PUuArVtmGEr8AA4ET6tDp9fFjgd/mFyGuhkwwxjgLPh+9oB5Hlp3Y7h788VoIOtMoT/2xMY+9p61nwfFgP3gBDUUU8noDvQPfx1A/glPONpwMPa74Nu27ptW7ttx6V2rSfrTnp4X03TNE2LZ+LrNX9N0zRNi7d08dc0TdO0eEYXf03TNE2LZ+Llff6pU6cWNzc3s2NocdjRo0cfiYhrdO9Xt23Nlsxq15r1xcvi7+bmxpEjR8yO8Yp9++CHH+DwYUiVCtq0gV69wMnJ7GTa+zAM44YZ+41pbTskBKZPh3nz4MEDKFIEvvwSKlc2O5n2Psxq15r16dP+McCyZdC4MVSvDrt2waRJsHUr1K2rPjw1LTYKC4OmTeHPP+G772DPHvjkE2jbVn0Z0DTNPPHyyD8mCQ6GL76ANWvAw0PNc3ODsmWhUiVYuhRatTIzoaa9n3Xr4NYtOHAAHB3VvA4doFQpqFBBfTFIlMjcjJoWX+kjf5Pt3g1Zs/5b+P/P3h569oTffzcnl6Z9qKVLoVs3cHx4F6ZMUQ16+HDyBR6jWDHYssXshJoWf+kjf5MFBkKyZBG/liyZel3TYqOAACh6dBZ81Rd8fSF5cvDxAS8vvk1Xl5v3ZwNpzI6pafGSPvI3WenScPAgeHu/+dry5bpjlBZ7fWkZT4kZXaBkSTh7Fp48gSdPCPQcS4H7W2jgWRTOnzc7pqbFS7r4myxVKnVq9JNP4MoVNS8wECZMUKdFu3QxN5+mvZflyym38mvWJfqU0RU34++WDwyDG8+SUW/PACY0PYA9YVClCly+bHZaTYt3dPGPAcaMgVq1VCe/3LkhQwZV+HfsgNSpzU6nae/owQPo3h1KlKDQiQUcPGJPxoyqbRcvrjr89f+tCGzfDqGh0KCBuhygaVq00df8YwA7OxgyBPr1g+vXIUUKSJvW7FSa9p769oUXL2DePDLndGL1anj4EB4/Vp1bEyYMXy5fPnWfa7Vq6jaA5cvBMEyNrmnxhT7yj0GcnSFPHl34tVjsxAlYvBj691fFPZyrq2rb/xT+/6tUCcaOhT/+0Df/a1o00sVf0zTrGTZM9er/6quor/P/If+++AJu3rRdNk3T/qGLv6Zp1nHqlBqtql8/9QUgquzsYM4csFjUmNYitsuoaRoQR4q/YRhzDMPwNgzjjNlZNM2aYlXbnjxZndfv0ePd13VzAy8vWLtWXQLQNM2m4kTxB+YBtcwOoWk2MI/Y0LafPIFff4XWrSFlyvfbRu/eUKiQugzg72/dfJqmvSJO9PYXkV2GYbiZncNaAkMDufz4Mndf3CUoLIjECRKTKWkmcqTIgb2dvdnxtGgUa9r2/PlqSL/PPvvPxbz9vLn65CpPAp4gCCkTpiRXyly4JnIFBwd19qBiRfUkIE/P6MmuafFQnCj+UWEYRlegK0CWLFlMTvOmuy/usujUIlZeWMmRu0cIsbz5OL9Ejomo6FaRxnkb0yRfE5I6JTUhqRbTxIi2vWABlCihjtxfIiLsubmHxWcWs+HKBq4/ux7h6lmTZaVmjpq0LNiSCs2aYXz3HXTuDJkyRUN4TYt/DIkjnWvCj47WikiBty3r4eEhMeWZ55ceXeTnPwdxZv9qUviF4Z40G+5ZipE+ZxGS5i+GQ+o0+Ab7cv3ZdQ7fOczGqxu59vQaSRIkoYdHDwZ8NICUCd/zNKtmM4ZhHBURj7cvGaVtuRGT2/bp06roT5oEn38OgEUs/HH+D0buGsmpB6dwcXShRo4afJT5I/K65iVVwlQYhsEj/0dceHSBPTf3sPnqZvxC/Khp7866kdewa9YcY8GC6P1dtP9kzXatmUxE4sQEuAFnorJs8eLFxVT+/hLw63w5UdFdvF0Q4T8mNzeR9u1Fli8X8fcXi8Ui+27uk2bLmonhaUiKsSlk6uGpEmYJM/d30l4BHJH40ra//lrE3l7E21tERE7dPyVlZ5cVPJE8P+eR2cdmi2+Q71s34xvkK3OOzZF8v+STbz9S7f/SpsW2Tq+9A2u2az2ZO+kj/+j07BlMmEDo5J9weObDvcTwd4mcFKjXiaQFikOaNJAgAfj5wb176qEnBw+qcX6fPoWkSVWHqt69IXduTj04RZ+NfdhxfQfZqELZ+wspkScDbduqUQI188SbI38R1VO/QAEsa9cwft94hmwfQjLnZIyrNo52hdu9cz+VMEsYi/dMo9bHn3M6DQxuPIqiAQOpW8eOmjXVnYGaOfSRfxxi9rcPa0zAYuAeEALcBjr91/LRfnQUFiYydapIihRiMQxZlceQFj3SyI4rW6O2fmioyNatIm3aiDg5iRiGyKefily8KAsWWMSl/AxxGO4iiUe4SrXOOyVNGpF9+2z7K2n/DSsdIcX4tn3kiAiI3/Sfpe5vdQVPpPHvjeWh38MP2mxgoMjPBceIgNRqhbiPrCUFSjyVqlVF/PyslF17Z9Zq13oyfzI9gBlTtH5A3rolUqmSCMjFQpmkcDek9qLa8tj/8ftt78EDkUGDRBIlEou9vUx17iMXDj6Tc97nxH2yuzh4OUif+XMlQwaRoCDr/ipa1Jn1IRntxX/QILHY20uZcbnFwctBfj74s1gslg/e7IgRIg0/DhJL9hzyKGdGcfJ0EPfJ7lKn9TX5+msr5Nbeiy7+cWfSJ9BsaedOKFIEOXyYqT08cG90myqN+rKmxZr376SXJg18+y1cu8bRwp3oGvgT7p/kJ++BKxzofIBKbpWY+HcHnKt+x7p1Vv1tNO1VIgQtXcye7PacF2+2tNlCr5K9MKzwcJ6ZM2HEmAQYY74l1ZU7nEzUD28/bw4XLMf0laexWKyQX9PiMV38bWXRIqheHXFNTS+vUvRMe4Tvqn/HhJoTrHOvfpo0TCk8nTXfHFCDqtSvT/LP+rGuwVKaF2jOtRwDmHV55IfvR9MicWnvGpyuXmd9ASd2d9hNJbdKVtmuCNy5A/nzA02bQokSuE9cyJ7mW3BwMPBpVJlDN05aZV+aFl/p4m8LU6dCmzZYKpSn3QB3pr7Yzs+1f+brcl9bdTd588Lq+yXhyBEYNAjmzCFBqbIszDmQFLfasD5gGN/t/c6q+9Q0gPMPz/Pr2JYAdBu+hgJp3toXMcoMA9zdYf/+8H98/z3cuUO+xVuYWvIv7C0Jqbe8GucfnrfaPjUtvtHF39pmz4aePZF69ejRPTMLb6xmQo0J9CrZy+q7at8eVq+G7XsSqEsBW7fCs2dIybK03/Qxn+ZrxoCtA5hxdIbV963FX7ee36LGohpUvxBMUJ5cuBWuaPV9fPGFGuX32TPUiH/16iFjxjDr62R8mWoHDnYOVFtYjRvPblh935oWH+jib02rV0PXrlCrFiN7FWTGuQUMKT+EvmX62mR3rq6wfDm0aAG1akHfNVWoleYYp+2LMOF2C347lZPaOWrRY10P1l3SHQC0D/c88Dm1f62NPH9OuRuCU/1GNtlP9+7w0UeQM6ca6G+Y0zjCfPz40seTMV/nZHPrzfgF+/Hxbx/zNOCpTTJoWlymi7+1HDumqnDx4iwe3pjhB76lfZH2eFX2suluK1aE69ehQwfInBn6jEtP4UfboUMH7EeNZtX6ZJRMVZhmy5tx6sEpm2bR4rZQSyhNlzXl4uOLrE/TFyM0FOrUscm+DAMmTFBXtIoUAdcKefFt1Y1KF6djf/EcBdMWZGXzlVx+fJmmy5oSEvbmcNiapv0Hs283MGOy+u1Q3t4iWbKIZMkiR46tE6eRTlJpXiUJCjXxXjuLRWT0aBGQwEofSe7R6SXLj1nkge8D8zLFI8TBW/16b+gteCKzj80W6dJFJGlSkeBgm+3vDd7eIsmSidSoodq3iMw9PlfwRHqu7Rl9OeIxs9q1nqw/6SP/D2WxQKtW8OABjxbNoP6OLmRIkoHlTZeTwD6BebkMA775BubNw2n3fo4tTUHowwc0W96MUEuoebm0WGn+ifn8dPAn+pTqQ8ciHWDzZqhSBRwdoy+Eq6t60t/mzbBmDQDti7SnX5l+TDkyhbnH50ZfFk2L5XTx/1Djx8OWLYRN/JEmV8fwNOApK5uvJJVLKrOTKe3awZ9/kujCVc4sdeXcmZ0M3DrQ7FRaLHLy/km6r+tOJbdKfF/je7hyBW7cgBo1oj9Mr17qNpe+fdUjhIEx1cZQNVtVeqzrwbF7x6I/k6bFQrr4f4jjx2HwYGjalCE5bvDXjb+YUW8GhdIWevu60alePVi/nhR3n3BySXJ+3fwDqy6sMjuVFgv4BPnQZFkTUiZMyZLGS3Cwc1BH3mBO8Xd0hJ9/hmvXYOxYABzsHFjSZAmuiVxpuqwpzwOfR38uTYtldPF/X8HB6l671KnZ3v9Txu4bR5diXWhdqLXZySJWpQps2EDapyHs+9WZ/ova6tuktP8kInRb242/n/7NksZLSJs4rXph82bIlg1y5DAnWJUq0LKlKv4XLgCQ2iU1vzf5nZvPb9J5TWfU5WlN0yKji//7GjsWTp3i6U/f0WJnLwqkKcBPtX4C1AhlMXL40QoVMNavJ6uPwcqZvvSY31Rf/9ciNffEXJacWYJXZS/KZy0PgCU4VA1bXa2aueEmTIBEidR9gOF/bGUzl2VU5VEsP7ecmcdmmptP02I4Xfzfx+XL8O23SLNPaRnyGz5BPixpvISrFxPSuDE4O4OTkzrbfvSo2WFfU6ECdmvXkeu5PaPGHmb8+iFmJ9JioEuPL/H5hs+pkq0KA8oNZM4cKFAAyjodBR8ffr1fFV9fEwOmTQsTJ8LevTB58j+zvy73NdWzV6fPxj5ceHTBxICaFrPp4v+uROCzz8DJiTltCrLxykZ+qPEDPMxPlSpQvjw8fKhGJqtTRw2+c/iw2aFfU7kyDitXU+iRHeV7jePgpR1mJ9JikJCwEFr90QpnB2cWNFzA6FF2TJyoLrXvG7UNgN2OVahVC0LMvL2+TRv1RzZwIJw7B4CdYcf8hvNxcXSh1R+tCA4LNjGgpsVcRny8Nubh4SFHjhx5v5XXrIH69bk/ciDZjIlUyVaFtS3W0qyZQZkyqhPyy2bPhmXLYOPGD89tbX6/zse5TXv25HHB4/AdEiVKbnakOMMwjKMi4hHd+/2gth1u+I7heO3yYlnTZVRK04RcueD8eUiXDnW6/+FDLMdPUqGCGob300+tk/293L8PBQtCxoxw4IA67QasvLCSRr83Ykj5IYysoh9wZS1va9dHjx5N4+DgMAsogD64NJMFOBMaGtq5ePHi3hEt4BDNgWK34GD46iskTx4aptpMoheJmF1/NmCwerV6DOnrWrWCnj0hMPCfz6UYI1Grdly8eYaK34znUN2SlNx2Aez032t8dvjOYUbvHk2bQm1okq8JixdD5crhhT8wUJ1m79EDO7t/ny1havFPlw7mzYO6daFPH5g2DYCGeRrSvkh7vt3zLXVy16F0ptImhow/HBwcZqVLly6vq6vrUzs7u/h3ZBlDWCwW4+HDh/nu378/C6gf0TL6k/5dzJgBly+zpEMJDnofY1rdaaRLnA5QVwMieoy5YUQ8P6ZwH/Q969uVo+TOy9zo2szsOJqJAkMDabeyHekSp2NS7UnAa+16/371BaBKFUB9T4wRJw7r1IH+/WH6dJgz55/ZE2tOJFPSTLRb2Y6AkAATA8YrBVxdXX104TeXnZ2duLq6PkedgYl4mWjME7u9eAEjR+Jb1oN2gYtpXqA5TfI1AdSHY926MH/+m6stWaL6AcS0o/6XVZ6xmV/LJyfr7OUEjh9rdhzNJMN3DOf8o/PMrj+b5M7qElC1arB9O3h7o36wt4cKFRCBBQtUu48RRo+G6tXVE4F27QIgmXMyZtefzaXHlxi8fbDJAeMNO134Y4bw/w+R1nhd/KPqp5/A25teFV6QwiUlk2tPfuXlYcNg5EiYOhX8/dUB0ty50K8feNn22T7v7cYN6NQJMqR1ocudtfyRBxL0H6Q6KWjxysHbBxm/fzydi3amZs6a/8xPk0YNqlerFvis2o6UKMGNp0np2FENsNe4sYmhX+bgAL//rsYeqF+fHT+dolw5qJuvGi5nu/Pj/olsubDP7JSaFmPo4h+BBw/UXUTffKM+T4IfPocffuIHL9EAACAASURBVOBS2TwscL7I1DpTSe2S+pV1CheGTZtg/XpInhySJlVH/WvWQJkyJv0i/+HmTShXTvWTOnsW7h4tx+w2X7A/E4S2aqWu7Wpxiog6cz98uPpCeuKEmh8UGkSHVR3IkCQD42uMf2O9kSOhV9sXJDx9iHGHqlCkCCRLBlu2QAITH1/xhhQpYNMmfI3EFPyyOiOanePJE9g19DsShWam/uyOPH0RaHZKTYsRdPF/zaJFkCcPnDwJLi7qMuIv7pPg2TPaFL7Cp/k/5ZO8n0S4btGiqtj7+YGvr/oyUDqG9jMaOxZat1ZFIEMG9YVl+ddj6domO38nFqRBfTWegRYnBAXBJ5+ou+NCQ1X7rFcPOnYEr79Gcf7ReWbUnUEy52RvrGsY0Ml9D46E8uXaKjx+rL4cJ01qwi/yFv6ps1CNbSRLZU+1UZVwuXCM4gWTsKL9TAITX6TVjBh6Gk6zuaJFi+Z52zK+vr5GiRIl3ENDQ7ly5YpjqVKlcmfPnj1/zpw5848cOTLN++w3MDDQ8PDwcA8x9b7YN+ni/5ILF+DLL2HfPnXKfsgQ2L7qBT2CfmRtthRccUv6xun+iDg6xrAjogisWgVdurw6L6FjQn7uNJfarUPxC/aHjz+Gx4/NCahZlZeXGgjv/Hl1efy771R7P3H/JGP3jKVt4bbUzlU78g1s3w4JEpCgYpkYfUPI7t3gVMgdxz071bf3ChVg7Vpq5qxB5eQd2PjiO/3wn3jq+PHjbx31afLkyanr16//1MHBAUdHR3744Yfb165dO3v48OHzs2fPTnP06NF37r3l7OwsFStW9Jk1a1bK90tuGzH4zzj6zZypCmLevC/NnDEDZ/+njKz6lF7ZJ5Im0Xt9+YtxwsIifhprRbcK3L7Tg1pNA7HcugmNGqnDRi3WCgtTbfuHH8L/n586BceP45QwlIDqnTACU/JjzR//eyNbt0LZsqqgxmD/tOvcudU1Dnd3qF8fPD3pkuE7HENc6bS6EyFhMesoTLMeHx8fu0qVKuV0d3fPlytXrvwzZ85MAeDi4lL04sWLCbJnz56/efPmWXPmzJm/XLlyuXx9ff+5H2vp/9q787gasz8O4J/TvqeSbAmlTVQy2SJjSSZCWZIRso5hbOM3lrHPEFljzNj3pRlLxhKKxIw1pKlUQiqKUtr3e35/nItQCvd2697zfr3uS93nee7zvbfjnuec55zv+fNPvaFDh74CACMjoxIHB4d8ANDR0REYGxsXJCYmKkVGRirr6OhYN2nSpI25ubmltra2jaGhoVVGRoZchw4dTI8fP64FAD/88EPj0aNHGwLA4MGDXx0+fLhWVf58nn85jx6xbtE3iopQusYX/7aUQ5JOb5jk19JFez6DszO7xTFv3rvPnzsHtHrigycOJ/GTJ+C76wrLn753b+2es8hVKjubpagwMRE+MWYM0KAB1i/oiZjs25A77Q/dFR/5XkpPZwMEltX+ZDldurDbWUlJgKFhI+Cff9gMgCVLYFP/AqaP/RmrUqdg7bW1+MnhJ0mHK9W8T3gbRr6IFOnVolUDq/ydA3YmfWyfY8eOaTVs2LDk0qVL8QDw8uVL+fLbExMTVfbv3/+oc+fOT7755puWe/fu1Zk8eXJGYWEhSUpKUjYzM/sgLWRsbKxSdHS0mqOjY66urq6gffv2ubNmzXru7Oyca29vb7Zp06ZEXV1dweLFi58tWrSoSWpqqkJERIRacHBwPAB89dVXBREREeqi/Cy+lNS0/AkhzoSQWEJIPCHksxasb9ny3Vz89NAhKKQ8x9puilC7sAUmJtJT+c2dy+7bbt7MRm2XlbFbAd7egM8SLfzu8jtWGyUjxLsHu0r45RdJhyyTRFGutbTYbaj4eOETpqYoiYnCwpCFcNB3hUnxkI+/QIgw/XPPnp9z+hqlrQ3Mns2m/l+/DlAVVaSv2YPDLnvRNCMCPn6zsTe2NX69sAgPXvIxLdKoXbt2BVeuXNH67rvvmpw9e1ZDT0+vrPz2Jk2aFHXu3LkAAGxtbfMTEhKUASA1NVVBU1Pzg5XOsrKy5Nzc3Ix9fHySdHV1BQDw4MEDVTs7uwIAePTokUrbtm0LAaBv3765lFJs2rTJ4Pjx448UFFj7WngbgWZmZtaaOlcqWv6EEHkAvwHoDSAZwC1CyN+U0uhPeZ3x49mc/BEjAEsLilc+i/BUH1C09IHGXaNaOWr/c5mZsZ7cuXPZdERC2MItO3cCffsCQD8Maz0MznLH8HyIK+otXMi6UofxREA1RVTlWl6ele1Zs9gsTsVWrSDnfxhqAg0UHfsN30+u4qL2wgVAUxP46qvPfSs1as4cQFeX9QCkpbELW3f3kehx62toLvkeIw/9jQ76ctj5yh3L14SD1OZBDHVYVS10cWnbtm3RnTt3oo8ePao9f/78JsHBwdmrV69Oeb1dSUnpTR4CeXl5WlBQIAcA6urqguLi4ncKQ1FREXFxcTEeMmRIxqhRo14BbFBgUVER0dfXL4uPj1esV69eqYqKCgWAmzdvqqalpSnq6OiU6ujovLO2a0lJCVFTU6s1ORCkpdTbA4inlD6ilBYDOAxgwKe+iLk5aw136QIs6xsAndhEbLZtgbtbp+LIEenr9W7bFjh9mvXqpqQAN268rviZDc4boK6kAbde6aAODsCoUWwnGVQmKIPfDT/kl+TX5GlFUq4BlodCXp6NZ1kT8RzyFDA+MwNtmzfFlClVHBwUBDg6srn0dQAhwMSJbLJKQgIbs7pnD9CgXVPWvXXqFBqo6mPF+v+Q0rE1cEe2BwBGPI/A6bjTkg5DZBISEhQ1NTUFkydPzpg+ffrz8PDwat160NfXLysrKyP5+fkEAAQCATw8PIxMTU0LFy9e/Pz1fnfv3lU1NjYuBICIiAhVExOTAgB48uSJ4rffftvi2LFj8aqqqmVHjx59Mx8mNTVVXkdHp1RZWZlX/iLWBED5q8xk4XNvEEImEELCCCFhaWlplb7QiBFAbCwgr38cYY0A06F/4n6U/Nv7pVJITa3iaVsGGgZY47QGISlXsWfRAJYUwNUVePIEmZlsSfXBg9kt5KCgWpLqVUw239qMaWen1fSXZJXlGqhe2VZWBo4eBfYfEOCc/nkAwOGhNti+vYrlHOLj2WAYZ+fPfxcSQgib+q+s/N4GFxdoxSVgvWdLKEfFAnZ2bLBPcjIANrxh6lQ2NfLnn1lODGlVKijF2L/HYuzfY5FXnCfpcETi9u3bqjY2Nhbm5uaWK1eubLRw4cKUqo9iunXrlnX+/HkNAAgKCtIICAjQ++effzTNzc0tzc3NLf39/bXv3bunamFhUQAAampqgsjISPXbt2+rDBgwwHjlypXJ7dq1K1ywYEHKsmXLGr9+3cDAQK2ePXtmif7dfj6pWNWPEDIEQB9K6Tjh7yMB2FNKp1a0f3VWPqOUIjw1HLaNbEUeb11CKUXvfb1x8+lNPOh9Ega9BqDQoBlscv5B+x5a6N+fpX7dvJklM6qyMqmDErMSYfmbJRyaOSBwRCBINbqARLGq36eWa6B6ZTsz5TF0GrcEVq5kOfE/5rff2BLWDx5A2q6AY9Nj0XV9W2yJaolBgY8BOTn8+/V8eN7+EeO+V4aFBct1tW8fG/ZSB69/qrT22lrMOj8L/oP9MbR11Ss0VVWu7927l2BtbZ0u0iBr0L///qvq6+vbMCAg4LEoX9fJycnY19c32draukanTt27d6++tbV184q2ScvXdDIAw3K/NwXw7EtekBAi8xU/wD6HLf22oERQgonx60D/+gsKcdE4pzsc+3eXYtgw1kq6fZslRpK2zMCUUnx3+jtQUPzR749qVfwiJPJyDQA6jVqwvL1xcVXvfO4cGwkrZRU/AJjVN8M0p4Vws4lB0OmNyHHoiy5nfka8pi0W9LqGwYOBdevYnYKRI9nAWGnyOPMxFoQsQD/TfhhiWcWgTxnRpUuXgu7du2eXln4w7u+zFRYWEldX11c1XfFXRVoq/1sAWhFCWhBClAB4APhbwjFJDWNdYyztvhQnYk9gI8nCfO3fYBR1ho0gE1JTY43IXbskGKgYHI48jDMPzuDXHr+ieb3mNX168ZVrU9OqK//iYjbSv0+fj+9Xh83uMhttGrTBmHtLsLDdTuwacgaKxXmAgwOwYAFQWoouXYB27Vj2TmlBKcWEUxMgT+Txu8vvNX1RW6tNnz79pYIIx7eoqKjQKVOm1LpsaVJR+VNKSwFMAXAOwH0Af1JKoyQblXSZ0WkG2jVqhyW3piDEeghbO93Pj3ULC5mYCFd/kxLp+emYdnYavmr8FabaV9rTLjZiLddmZlVX/qGhLA9w349k/qvjlOSVsN11O1JyUxBYOgdlTn2ByEjAy4tNb3VyAl68kLqyvefeHgQ/CoZPLx801Woq6XA4CZCKyh8AKKVnKKWmlFJjSumvko5H2ijIKWCH6w5klaTjnsEsZM5fzdZz/eEH4OxZAGxGWNu2Eg5UhGacm4HMwkzscN0BeTn5qg8QA7GVazMztoJV+kduzwYEAOrqbF1fKWbfxB7TOkxDrOYfOHztMpvWuGsXmyJw7Rpohw54EhgtNWX7ee5zzDw3Ew7NHDCp/SRJh8NJiNRU/pz42TS0wezOs1HcejcGzr6Igp2HgDZtgKFDEeX/H9asAaZNk3SUohH4IBD7I/ZjnsM8tDFoI+lwRO/1ilNXK1nmViBgN7udnQFV1ZqLS0KWfb0MzbVa4pLWOBzwF97c9/JCWchl5KUV4ECiA7oqScc01ymBU5BXkodt/bdBjvAqQFbxvzz3SRZ1XwRTXTPcbjIehjYU3xudQnqRJrQ9XbDzl2ewlYIxklmFWZhwagIs9S0xr+u8qg+oi9q3Z0nwK1u6+fZt4OlTYODAmo1LQtSV1LFj4DaU1XuAKUcXwc6OJQlq5fkVxphfg3pTHZDevSq/WKojjkYfxZHoI1jkuAjm9atc5I6TYrzy5z6JioIKdg3ciXzFRDivnoNOQ5oicuUpNFHNgMvv/dg94jpudtBsPMt5hp2uO6Gs8P4kcSmhqsrmt1dW+fv7s4uDb76p2bgkqEeLHhjfbjyyrdbAe8EN9OnDZq/8FdYCClevAI0asfEP5XOA1yEvM5/BZ/8k2OuzHjxOtvHKn/tknQ07Y1qHaTgQtxlNuoSg+3RbkD//ZHP9hg1jC8bXUecfnse2O9sws+NMdGjaQdLhiFeXLkBY2IerNhYXs4WcXF1ZnlwZ4tvbF401G+O3p2MwZHgh7OyEGxo3ZoNadHTYBdGjRxKN85MUFQHz50O7gSFurUjHleXPoXgsQNJRic0vv/zSoGXLlq21tLRs5s2b1xAA9u3bV6/8crx+fn56CQkJb9Y1HTZsmNHnLNdbl/HKn/ssv/b8FSa6JvD+2xu5xbnsC/H334EzZ4DJk+tkur+swiyMPzkeZnpmWPr1UkmHI35durCK4f2W7OnTLCm+t7dk4pIgbRVtbO+/HffT72PxpcXvbjQ0ZINbS0tZeX/1SiIxfpKiIrbK0fLlOGwhwOkZLlAyaMQu0oUDdaXNjh079M+cOfMgOzs7fPny5akAEBAQUC8iIuLN4JX9+/fXT0xMfFP5+/v7P7GzsyuURLySwit/7rOoKaph14BdePLqCWadE873nzCBrRG8bVudWP71fTPPzURydjJ2D9wNVUXpH+SGrl1Zvv73MzNt2cJauk5OkolLwvqY9MH4duPhe9UXV5Peu8dvbs5mQTx6BHh4sFWDaitKgdGjgQsXMHWoJtZ+bwsn3+PAlStsoK6nJ/Dsi3NG1Sqenp7NkpOTlV1dXU2WLFnSwMvLq1lQUJB6cHBwvZ9//rmpubm55fz58xtGRkaqeXl5tTQ3N7fMzc0l9vb2ZpcvX1YDADU1NdupU6c2MTMzs7S2tjZPSkpSAICoqChla2trcysrK4vp06c3VlNTq9MjnOrGSh1creTQzAGzOs3C6murMdB8IPq26svmRicnA4sWsQpk3DhJh1ktJ2NPYmf4Tsx1mIuOTTtKOpyaUb8+MGQIW8px6VI2xS0khGX1W7GizizkIw5rnNYg6FEQvI57IXxSODSUNN5u7NoV2LSJrR60eHHtvdDdtQs4fBgHhlliq1U8bg/aC0V5RUBNkV3wWVoCvr4sjaE4eHsbIjKyWovqVJuVVT52Vr5a4MGDBxNDQ0O1Q0ND4/766y9tAOjdu3der169XvXr1y9rzJgxmQAQFBSkvXr16qRu3bp9sFJXQUGBXKdOnXI3btz4dNKkSU03btyov2rVqpQpU6YYTp48+cXEiRMzVq1apS/S9yUBvOXPfZFlPZbBqoEVvP/2Rnp+OltNZft2lhVu4kQ2XayWe5H3AuNOjoO1gTUWOS6SdDg1a9o0IDub/c3y84GZMwEjI5bESYZpKmti94DdeJT56G3PVnkTJrDbIr/8AgQG1nyAVUlMBKZNQ6qdGUaaRePXHr/CqoHV2+2mpmwVs61bP57rQQYpKipSDw+PLACws7PLe/LkiRIA3L17V8Pb2zsDAMaNG1frMvZ9Ktm9tOdEQkVBBfsH7Yf9dnuMPzkex4YeA1FUBI4cAXr2fHtvsXt3SYdaIUopxv49FlmFWbjgdaHS0f1ZT3NBJ0wAFi1GPXvTGo5SjDp0ALp1Y6ma16xh0/uOHAFUZGrsU4Ucmzvix84/wveqL1xMXeBq5vruDps2sQGTo0axwa6NGkkm0IrMmgVBWSl69khCtxaOmNlp5of7/PQTsHcvXq3YjJRxC2FiwiZ4iMxHWui1mYKCApUTrk6moKCA0tJSqcx9zFv+3BezbmiN5T2WIyAmAFtvb2VPamiwwX/GxkD//sCtW5INshKbb23GqbhTWNV71bstI6G8PNbI29NyCeqdOYQhPV5ixAggI0MCwYrL6dNsdSYtLbY2s7u7pCOqNZZ9vQw2DW3gfcIbz3Leuz+uqgocPsymt3p5scRItcHFi8CRI9jqpIdnekrYO2hvhcl8buZaIkzra6RtOIj+/SiaN2fZuuvgWN0qaWholGVnZ8uV/z0rK+uT0nba2Njk7t69WwcAdu7cWeenwfDKnxOJGZ1mwMnYCdPPTUfki0j2pJ4ecP48oK/PMsVFREg2yPeEp4Zj1vlZ6GvSt8Lc/ZQCgwcDeimRmFq2Dhg3DkeedoKeHns7tXms1yfR0AA2bACio6U+le+nUlZQxiH3QygoLcC3x75FmeC9P7qFBbB+PRAczHoCJE0gAGbNQoaBNqZbPcXWflvRTLvZB7vFxrLs3AK3IWhVFov4E1EIDGRLc5dbrkNqjBgxIsPPz6+hhYWFZVRUlLKXl1f61KlTjV4P+KvOa2zcuDFp48aNBm3atLFISUlR1NDQqNPfAIRK42VeFaqz5jn36Z7nPof1H9bQVdXFzfE33w6SevSIdS0XF7PFYiwskJbGepgNDdk1griVlLBB2pcusQZbP/ccTAizQ15JHsInhkNf/cPxO9evA14jyhCr7wAS/4B9Y+rpgVKWHffnn1mnRkWqWvdcXHjZFo9dd3fB+29vLHZcjEXd3xsXQikrCBcugN65izg5cxQXs+uCmhgzmZLCliFISAD65x6CywFPjHADNMdMxB/9/qjwmAkT2P+9BROes9sVCxYAS5YgMhLo3Rt48gRQUvrwuKrK9b179xKsra2lchBBTk6OnLq6ukBOTg5bt27V8ff3171w4cJDScf1Mffu3atvbW3dvKJtvOXPiYyBhgEOuh9E7MtYTDw1EW8uLFu2ZF2R8vIQdP8aM/veh6kpu1VqbMz+zcoSX1xpacBXXwEbN7JxTpqaFC5bxiL+5UMcGHSwwoofYBcKqw03gNy4zg4WXqUQwnrGQ0LEFzNXu4y2GQ0vay8sCV2CoIdB724kBNi2DcWKaoiwG40+vcoweDDQvDmwY4d44zpxArCyAh4/Bmxal6Ddybm4py+PG/ZtsK5P5aP4L10S3t0xMGAX5keOAGCvpa1d9YKPsujff/9Vs7CwsDQ1NbXcunVrgw0bNiRLOqYvwSt/TqR6tOiBpd2X4uB/B7Hx5sa3G0xNURYcgswMYElodyQFRuLePfalpaTEUsiLqxNqyhTWmx0ayga3azqtQ36Lv9D4/gokXnGs9LimryLR9595LNOdh8c72169AtREO4mJq8UIIdj8zWa0btAaHkc98Djz8TvbbyU3wlRsgnXBDTyesgaxscDJk2zG5N694okpLQ0YM4bNzNyyBfBW2oZG2U/wax9lZGw7htLCynNVqKqWu+CeNIn1XBQXQyBgkz9kYC2nT+bs7JwbGxsbHRcXFx0WFhZrZWVVVPVRtRev/DmRm9t1LlzNXDHz3EyEPH7bPA58bI6JZpegUU8eGv26A7dvQ0eHfXGlpLDcI6L28iX7cly4kDXQgh4GYXbQbLhZuGHziNnYtq2SAwsLMfSEJzIF2njxy1Z2sFBWFvtCHzpU9PFytZe6kjqODzsOARVgkP8gltlSyMcHsF7hAQwaBLJoIRAbC1tbVk6WLRPPWMADB9h1afv2AC0qQvbP/8ONJsC38w+ie1uT1435Cg0dCvj5CS+4PTzYG1BSwtGj7C5Ay5aij5erXXjlz4mcHJHDvkH7YFbfDO5/uuPBywcAgMuXgXae5iCXL7NBZj16AKGhkJNjLf/QUNHHkprKvsy0tICY9BgMPTIUlvqW2DNwD6ysCJIr67ibOhVKMf/h4re74OBugEOH2NCFgAA2a9HdHVKzvjtXfSa6Jjjkfgj/vfgPXse9IKCsVg8NBdzcCRstp6YGjB0LCATo1AnIyRFPIr2kJKB1a/bzufkeqJ+eh4fTvOBqPgCtW7PtlZk6FYiJYVP9r19nw1lWrGCZuf383rnW5aQUr/w5sdBS1sLJ4SchR+TwzcFvkJaXBnV14RQ5ExPWzG/ShCUDOnoUmZmAurro4zA0ZBcAkQkv4HLQBUrySjg5/CQ0lDRw7RpgZlbBQdu3s8fcufDY+w1Wr2bJ0nr0YMnQZs9mA7w52eRs4oy1TmtxPOY4/hf0PwB4W7YbNWKF5N9/gd9/R1ERUFAgnltE5ubAtWvAkTv70XpbAGLN6mP4rF0A2PPmH1mxV0uLXbBYWgLjx7OlCuLi2FiALl1EHytX+/DR/pxYXU26ip57e8LawBqb7IPRz0kD0dHCxeJevgRcXUGvXcMilVUYd38WmhmJvskx7vscHNP8GoWa0QgZFYIOTTvg6VPA0ZHNcHNxKbdzSAjLad+jB8tTIP9JU4Hf4KP9pRulFNPOTsPGmxuxxmkNUo/PRFYWu4UFStnSv//8g31zorD/ihHOnRN9DDk5gFH3ixjZ0AkbzpSh+NwZKDn1xcGDwNy5wIMHFY/Y/xKyPNq/LuKj/TmJ6WzYGYfcDyHsWRjmhA/Et6ML0bUrWy4+Nl0Ph8YGI1B9MJYWzEazJWM/XF72C+WX5CPOrj9eqYRD/cxf2L+yA0aOZKOaJ016r+IPDwcGDWJTAvz9P7vi56QfIQTr+qzDYMvBmHV+Fhr3247Ll9nMlWvXCe5P34KiEgLDZeOxZrV4GliRr65BzsUVcy4RhNfrjDmBzujaFZg/Hzh1SvQVvziUlQFPnkAxM1M0dVF6erq8j4/PZ+Xdd3R0NElPT//of/rp06c3DggI0Py86Crn5+en5+Xl9WFChnJOnTqlGRQUJLL+UV75c2I30Hwgdg3YhYuPL+K/1gMwf3EBtm9nSUb2/qUKwYHDbCGgXbsABwc2yVgE8orz4HrIFf8mX8F+970I+s0FLVuyU8TEAD/+WG7n6GjW4tfSYi3+evVEEgMnveTl5LF/0H44mzhjZsgETN62E8bG7KLSbYYRTnRaie7FQbC6uVPk576efB3OB5wxO0IFjfJL8WrWSjRuQvDjj6z7vk0bkZ9SpAQCYNUq6Ddrhja2trBs2hTWTk4wjonBF12yvHz5Un7Hjh0NKtpWWlr60WNDQ0Pj69ev/9HEPevXr382cODAnC8I8bNdvHhR88qVKxpV71lNlFKZe9jZ2VGu5u26u4uSxYR229WNZhZkfrhDQAClWlqU1qtH6ZEjX3SujPwM2mVHFyq3RI7uCd/z8Z1v36a0fn1KGzWiNCbmi877GoAwysu2TMgvzqd99vWhWAy67tq6txvKyih1dGRlOjFRZOcLfhhM1X9VpzYrmtNSnXqUOjuL7LWrUlW5Dg8PT6CUhlX1WLCAJpmY0IJLl2g0pTQsI4PemTOHJjdsSIuSk2l4dV6jooeLi0uGsrKywMzMLH/ChAmpJ0+ejLW3t8/u16/fy5YtWxZQSsN69uyZaWlpmWdsbFzg6+v7Jt7GjRsXPXv2LDwmJiaiRYsWBcOGDUszNjYu6Ny5c1ZOTs5tSmmYm5tb+s6dOx++3n/69OnPLCws8lq1apV/586dSEpp2NOnT8M7deqUZWFhkTd8+PC0Ro0aFT179uyD97R+/frHRkZGhe3bt88ZNmxY2siRI19QSsMOHDjwoE2bNrnm5ub5nTp1yk5MTAyPiYmJ0NPTK9HX1y82MzPLDwwMjKlov/fPIfx7VPi34i1/rsaMthmNg+4HcS3pGrru6oqEVwnv7jBgAHDnDtCqFcurO2rUZyXRf5z5GF12dsHNpzfhP9gfXtZele988iRLcqKmxqYjVDgCkOMqp6qoigCPALhZuGHGuRmYeW4mSwMsJ8eWSy4tZUtbi2B81Z7wPeh7oC9a6LTAleffQP5VFhumX4dkZ0POzw+NTpzAA0dH5AOAjg4EK1Yg1dER2evW4bOXy12zZk2yoaFhUUxMTPSWLVuSASAiIkLd19f36cOHD6MA4MCBAwlRUVH3w8PDo7ds2WKQmpr6QVd/YmKiyg8//PAiPj4+Sltbu2zv3r06FZ2vfv36pdHR0fe9vb3TfHx8DABgzpw5jR0dHXOio6Pvu7m5ZaakpHzQm/HkyRNFHx+fxlevXo25cuVKXFxcJH//0gAADzZJREFU3JvMCr17984NDw+PuX//fvTgwYMzli5d2tDMzKzYy8srbdKkSc9jYmKinZ2dcyva71M+K175czXKw8oDZ0acQVJWEr7a9hXOPzz/7g7GxsA//7B0owcOsByp+/ZVe6L02fizaL+tPVJyUxA0MgiDLQdXvGNJCbs56urKznH9OpuFwHGfQUVBBX8O/hNT7adi3fV1+ObgN3iR94JNmPf1ZWtcbN782a9fXFaMaYHTMPrEaHQ16op/exyAxu87gJEjARsbEb4T8btyBWotWqDQ0hLF72/z9ERGSAi0RHm+tm3b5pmbm78518qVKw3MzMws7ezsLFJTUxWjoqI+WMKySZMmRZ07dy4AAFtb2/yEhIQKl/v09PTMBAB7e/v8pKQkZQC4efOmxqhRozIAYPDgwdlaWlof3Eq4fPmyeseOHXMaN25cqqKiQt3c3N60ch4/fqzUtWvXVqamppZ+fn4NY2JiKky5VN39KsMrf67G9WrZCzfH34SBugGc9ztj1rlZyC/Jf7uDkhKwdClbLrV5c7ZiWseObMW5SlpPecV5mH52Ovoe6IumWk1xa/wtODavJHvfrVuAvT2wfDlrkV2+XLuWY+XqJHk5efj19cO2/tsQmhAKmz9scDL2JPDdd2wlqB9/ZGNLPtF/z/9Dh+0d4HfTDzM6zsDZEWehNXcxG5D6yy+ifyNipqQEWlhYcd2Tnw85BQWIdISkmpram5bDqVOnNENDQzXDwsJiYmNjoy0sLAoKCgo+iEVJSelNDPLy8rSyZX1VVFQowJYBfr0PrWYPD6kkmcKUKVOaTZ48+UVcXFz0pk2bnhQVFVX4WVV3v8rU+cqfEDKEEBJFCBEQQmp8ahX3eUz1THFz/E1Maj8Ja6+vRevNreEf6f8maQoA1qK5dg3YvZtN1ndyYuvPHzwIFBYCAARUgMORh2G52RIbbmzAVPupuD72Okx0K2jFR0QAw4ezij8lBTh6FNi2rVbmMuXluu4a124cboy7gfpq9eF62BWD/nTDw9XzAU1NllovP7/qFwGQnp+OmedmwnaLLZ5mP0XAsACs7bMWiueDgePHWe+YoaGY343ode+OvJcvoRASgneyHwgEwLZtqO/qilef+9ra2tpleXl5ldZrr169ktfW1i7T1NQU3L17V+XevXsizy5ib2+fu2/fPl0AOHbsmFZ2dvYHtxW6deuWd/36dc3U1FT5oqIicvz48Te3FXJycuSbNWtWAgC7d+9+s+yZpqZmWU5OjnxV+1VXna/8AUQCcANwWdKBcJ9GTVENm10249KoS9BS1oLHUQ9YbbbCbzd/w8v8l2wnOTl27//BA9ZtmpkJjBgBQUMDxPa1x//GNMWc7cNRT1kbV8ZcgV9fP6gqCivz0lJW4a9dC3TqBFhbszlQ8+axIdFubpJ781Xj5boOs25ojbAJYVjeYzmCHwXD9Kgjlk0wA6KiIJg0sdIeLEop7qTcwZQzU9B8fXNsuLEB3rbeuP/9fQwwH8ByS0+cyDL4zJxZw+9KNBQVgeXLkTRsGEw2boReairkb96Eqrs7mqemQmnqVHx2noCGDRuW2dnZ5bZq1ar1xIkTm76/3d3dPau0tJSYmppazps3r7G1tXXel72bD/n4+Dy7ePGilqWlpcXp06e19fX1S+rVq/dO17+RkVHJTz/99Kxjx44WDg4Opm3btn1zRTh//vxnw4cPN7azszPT09N7M0XB3d391enTp+uZm5tbnj17VqOy/apLapL8EEIuAfiRUlplhhOeCKX2KROUwT/KH6uvrsbd1LuQI3Kwa2QH24a2aKbdDOpK6sgvyceTjMeQvxQK+0sP4BoD6LIOAFANDRBDQzZVj1J2kZCY+DZvQNu27PaBtzegU+HYHZESVZKfTynXAC/btdHz3OdYf309/rj9B6YFvsLiUGDbtxaIG+kCAw0DyBE5ZBRkIO5lHK4lX0NydjKU5JUwrPUwzHWYCwt9i7cvNmYMWzDg6lXWC1bDRJnk5+RJaPr6ouHdu1DX0kKZmxsyFi9Gqp4ePjrdrrYrKCggCgoKVFFREcHBwepTpkwxiomJ+fT7PSLwsSQ/NbDadO1ACJkAYAIANGv20VwKnATIy8nDs40nPNt4Ijw1HAExAbiUcAlH7h9BRsHbEf96qnpoa9MWDQZ4IqmVK3RTKXDrFsj9+0ByMpCby3oLmjdnswesrYGuXQEjI8m9OTHjZbt2M9AwwIpeK7Co+yIE9juNO+NmYeyB+xhR8gCrLViDTZ7Iw6ieEboYdoGTsRMGmA2Antp7Pbnbt7NbYD//LJGKX9T690dO//6QyJx5cYqPj1caOnSosUAggKKiIt2yZUuCpGOqSJ1o+RNCggFUNI1hPqX0hHCfS+Atf6lUVFqE/JJ85GSqYu0qFfj7A3l5LD3vvHmsR7+2qU7LX9TlGuBlu07IzwecnEBv3ULB/l0ode2HW1fV4LtSAVevss4rT0+WovdNJ9XFiyxlcPfuX5R2+kvx9L51S51P70sp7UUptargcULSsXHip6ygDEG+Dnp1V4FAwNYESkhgDfuBAyGWvOk1gZdrGaWmBpw8CWJrCzWPkXj0/V58O1wenp4sueWFC+yuVbduQHY2WAHv14+lnT50iKed5kSiTlT+HOfnx74M/fzYdHxdXTZLb88eYNYskeRP4biao6MDBAeDOveFzY6piDJxhddX96Gjw/JMbd0KtDfORMzAOazF36oVuyrQ1ZV05FURCAQCviBwLSD8O1SaIKXOV/6EkEGEkGQAnQCcJoTU0XYg9zHHjgETJnz4fJ8+bHWzuLiaj0mceLmWARoaCFv4N1YZrIHuvUtsfV07O8DTE6SvM7adbwb7kJXA6NFsgF+DClPW1zaRaWlp2vwCQLIEAgFJS0vTBps1VKE6P+CPUnocwHFJx8GJV0kJoPJBHi6AEEBZmW2XJrxcy4ZSgRz8m8zE/86OBHbsAAIDWRIqNTWkOY3Aj/GTcGBn3cngV1paOi41NXV7amqqFaSgcVmHCQBElpaWjqtshzpf+XOywdmZ5fZp2/bd52/dYrP5LCwqPo7jajNbWyApCbifrg+LOXOAOXPebFv6HWDc9iMH10J2dnYvALhKOg6uavzKjKsTZsxg9/c3bGCDpSkFLl1iCdOWLeNjoLi6SUUFWLiQDVy9epWV65wcwMeH5aOaPFnSEXLSirf8uTrByAgICQFmz2br8SgpsXT8Pj7AsGGSjo7jPt+UKYCGxttFLIuKWCbr0FCg4Set08Zx1ccrf67OMDdnK/Dm5LDU/vXrs3v+HFfXjR7NKv+0NDYTUEND0hFx0o5X/lydo6nJHhwnTQipKwP6OWnA7/lzHMdxnIzhlT/HcRzHyRhe+XMcx3GcjOGVP8dxHMfJGF75cxzHcZyM4ZU/x3Ecx8kYQmVwOTRCSBqAJ9XYtT4ASa9NzWOoPTEA1Y/DiFKqL+5g3sfLNo9BzDFIpFxzoieTlX91EULCKKXteQw8htoWx5eqDe+Dx8Bj4CSHd/tzHMdxnIzhlT/HcRzHyRhe+X/cVkkHAB7Da7UhBqD2xPGlasP74DEwPAauxvF7/hzHcRwnY3jLn+M4juNkjMxW/oQQZ0JILCEknhAyp4LtyoQQf+H2G4SQ5uW2zRU+H0sI6SPGGGYSQqIJIRGEkAuEEKNy28oIIeHCx99ijGE0ISSt3LnGlds2ihDyQPgYJcYY1pU7fxwh5FW5baL6HHYSQl4QQiIr2U4IIX7CGCMIIe3KbRPJ5yAqvGxXOwapL9vSVK45EaOUytwDgDyAhwBaAlACcA+A5Xv7TAbwh/BnDwD+wp8thfsrA2ghfB15McXwNQA14c/fvY5B+HtuDX0OowFsquBYXQCPhP/qCH/WEUcM7+0/FcBOUX4OwtfpBqAdgMhKtn8DIBAAAdARwA1Rfg68bPOyLY6yLS3lmj9E/5DVlr89gHhK6SNKaTGAwwAGvLfPAAB7hD8fAdCTEEKEzx+mlBZRSh8DiBe+nshjoJSGUErzhb9eB9D0M87zRTF8RB8AQZTSDEppJoAgAM41EMNwAIc+4zwfRSm9DCDjI7sMALCXMtcB1COENILoPgdR4WW7mjF8hNSUbSkq15yIyWrl3wRAUrnfk4XPVbgPpbQUQBYAvWoeK6oYyhsLdoX+mgohJIwQcp0QMvAzzv8pMbgLuwSPEEIMP/FYUcUAYddwCwAXyz0tis+hOiqLU1Sfg6jwsv1pMch62a4r5ZoTMQVJByAhpILn3p/2UNk+1TlWVDGwHQn5FkB7AI7lnm5GKX1GCGkJ4CIh5D9K6UMxxHASwCFKaREhZBJYi7HHp8Qvghhe8wBwhFJaVu45UXwO1SHu8iAqvGxXPwZetutOueZETFZb/skADMv93hTAs8r2IYQoANAG6z6rzrGiigGEkF4A5gNwpZQWvX6eUvpM+O8jAJcA2IojBkrpy3Ln3QbA7lPiF0UM5XjgvW5REX0O1VFZnKL6HESFl+1qxsDLNoC6U645UZP0oANJPMB6PB6BdbO9HojT+r19vse7g6L+FP7cGu8OinqEzxsUVZ0YbMEGDLV673kdAMrCn+sDeICPDCT6whgalft5EIDrwp91ATwWxqIj/FlXHDEI9zMDkABhbgpRfg7lXq85Kh8Y5YJ3B0bdFOXnwMs2L9viKtvSUK75Q/QPiQcgsTfORrnGCb+A5gufWwrWCgEAFQB/gQ16ugmgZblj5wuPiwXQV4wxBAN4DiBc+Phb+HxnAP8Jv0z+AzBWjDGsABAlPFcIAPNyx3oLP594AGPEFYPw98UAfN47TpSfwyEAKQBKwFo9YwFMAjBJuJ0A+E0Y438A2ov6c+Blm5dtUZdtaSrX/CHaB8/wx3Ecx3EyRlbv+XMcx3GczOKVP8dxHMfJGF75cxzHcZyM4ZU/x3Ecx8kYXvlzHMdxnIzhlT/HcRzHyRhe+XMcx3GcjOGVP8dxHMfJGF75cxzHcZyM4ZU/x3Ecx8kYXvlzHMdxnIzhlT/HcRzHyRhe+XMcx3GcjOGVP8dxHMfJGF75cxzHcZyM4ZU/x3Ecx8kYXvlzHMdxnIzhlT/HcRzHyRhe+XMcx3GcjOGVP8dxHMfJGF75cxzHcZyM4ZU/x3Ecx8kYXvlzHMdxnIzhlT/HcRzHyRhe+XMcx3GcjOGVP8dxHMfJGF75cxzHcZyM4ZU/x3Ecx8mY/wMNdFYHdlaVkQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for i, degree in enumerate([0, 1, 3, 9]):\n", + " plt.subplot(2, 2, i + 1)\n", + " feature = PolynomialFeature(degree)\n", + " X_train = feature.transform(x_train)\n", + " X_test = feature.transform(x_test)\n", + "\n", + " model = LinearRegression()\n", + " model.fit(X_train, y_train)\n", + " y = model.predict(X_test)\n", + "\n", + " plt.scatter(x_train, y_train, facecolor=\"none\", edgecolor=\"b\", s=50, label=\"training data\")\n", + " plt.plot(x_test, y_test, c=\"g\", label=\"$\\sin(2\\pi x)$\")\n", + " plt.plot(x_test, y, c=\"r\", label=\"fitting\")\n", + " plt.ylim(-1.5, 1.5)\n", + " plt.annotate(\"M={}\".format(degree), xy=(-0.15, 1))\n", + "plt.legend(bbox_to_anchor=(1.05, 0.64), loc=2, borderaxespad=0.)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def rmse(a, b):\n", + " return np.sqrt(np.mean(np.square(a - b)))\n", + "\n", + "training_errors = []\n", + "test_errors = []\n", + "\n", + "for i in range(10):\n", + " feature = PolynomialFeature(i)\n", + " X_train = feature.transform(x_train)\n", + " X_test = feature.transform(x_test)\n", + "\n", + " model = LinearRegression()\n", + " model.fit(X_train, y_train)\n", + " y = model.predict(X_test)\n", + " training_errors.append(rmse(model.predict(X_train), y_train))\n", + " test_errors.append(rmse(model.predict(X_test), y_test + np.random.normal(scale=0.25, size=len(y_test))))\n", + "\n", + "plt.plot(training_errors, 'o-', mfc=\"none\", mec=\"b\", ms=10, c=\"b\", label=\"Training\")\n", + "plt.plot(test_errors, 'o-', mfc=\"none\", mec=\"r\", ms=10, c=\"r\", label=\"Test\")\n", + "plt.legend()\n", + "plt.xlabel(\"degree\")\n", + "plt.ylabel(\"RMSE\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Regularization" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "feature = PolynomialFeature(9)\n", + "X_train = feature.transform(x_train)\n", + "X_test = feature.transform(x_test)\n", + "\n", + "model = RidgeRegression(alpha=1e-3)\n", + "model.fit(X_train, y_train)\n", + "y = model.predict(X_test)\n", + "\n", + "y = model.predict(X_test)\n", + "plt.scatter(x_train, y_train, facecolor=\"none\", edgecolor=\"b\", s=50, label=\"training data\")\n", + "plt.plot(x_test, y_test, c=\"g\", label=\"$\\sin(2\\pi x)$\")\n", + "plt.plot(x_test, y, c=\"r\", label=\"fitting\")\n", + "plt.ylim(-1.5, 1.5)\n", + "plt.legend()\n", + "plt.annotate(\"M=9\", xy=(-0.15, 1))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2.6 Bayesian curve fitting" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model = BayesianRegression(alpha=2e-3, beta=2)\n", + "model.fit(X_train, y_train)\n", + "\n", + "y, y_err = model.predict(X_test, return_std=True)\n", + "plt.scatter(x_train, y_train, facecolor=\"none\", edgecolor=\"b\", s=50, label=\"training data\")\n", + "plt.plot(x_test, y_test, c=\"g\", label=\"$\\sin(2\\pi x)$\")\n", + "plt.plot(x_test, y, c=\"r\", label=\"mean\")\n", + "plt.fill_between(x_test, y - y_err, y + y_err, color=\"pink\", label=\"std.\", alpha=0.5)\n", + "plt.xlim(-0.1, 1.1)\n", + "plt.ylim(-1.5, 1.5)\n", + "plt.annotate(\"M=9\", xy=(0.8, 1))\n", + "plt.legend(bbox_to_anchor=(1.05, 1.), loc=2, borderaxespad=0.)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/books/PRML/PRML-master-Python/notebooks/ch02_Probability_Distributions.ipynb b/books/PRML/PRML-master-Python/notebooks/ch02_Probability_Distributions.ipynb new file mode 100755 index 0000000..6b1a1da --- /dev/null +++ b/books/PRML/PRML-master-Python/notebooks/ch02_Probability_Distributions.ipynb @@ -0,0 +1,629 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2. Probability Distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from prml.rv import (\n", + " Bernoulli,\n", + " Beta,\n", + " Categorical,\n", + " Dirichlet,\n", + " Gamma,\n", + " Gaussian,\n", + " MultivariateGaussian,\n", + " MultivariateGaussianMixture,\n", + " StudentsT,\n", + " Uniform\n", + ")\n", + "\n", + "np.random.seed(1234)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2.1 Binary Variables" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bernoulli(\n", + " mu=0.75\n", + ")\n" + ] + } + ], + "source": [ + "model = Bernoulli()\n", + "model.fit(np.array([0., 1., 1., 1.]))\n", + "print(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.1.1 The beta distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.linspace(0, 1, 100)\n", + "for i, [a, b] in enumerate([[0.1, 0.1], [1, 1], [2, 3], [8, 4]]):\n", + " plt.subplot(2, 2, i + 1)\n", + " beta = Beta(a, b)\n", + " plt.xlim(0, 1)\n", + " plt.ylim(0, 3)\n", + " plt.plot(x, beta.pdf(x))\n", + " plt.annotate(\"a={}\".format(a), (0.1, 2.5))\n", + " plt.annotate(\"b={}\".format(b), (0.1, 2.1))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD8CAYAAAB0IB+mAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3Xd4lFX68PHvnR5SgSQQUkiAhNBCb4IUCyIgqICyNrAsqyuu667ruruuruX9rWXtoIgKIquioCJgF1G6EHoNBAgkBEgjvU7mvH9MFpCWIWQySeb+XNdczGTO88zNuWbuOXOeU8QYg1JKqabPzdkBKKWUqh+a8JVSykVowldKKRehCV8ppVyEJnyllHIRmvCVUspF1JjwRSRKRJaLyG4R2SkiD56jjIjIayKSIiLbRKSXY8JVSilVWx52lLEAfzbGbBKRAGCjiHxvjNl1WplrgbjqW3/gzep/lVJKNRA1tvCNMUeNMZuq7xcCu4GIM4qNA943NuuAYBEJr/NolVJK1Zo9LfyTRCQG6An8csZTEUDaaY/Tq/929IzjpwJTAfz8/HonJCRcXLRKKeXiNm7cmG2MCa3NsXYnfBHxBz4F/miMKTjz6XMcctaaDcaYWcAsgD59+pikpKSLCFUppZSIHKrtsXaN0hERT2zJ/gNjzGfnKJIORJ32OBLIqG1QSiml6p49o3QEeBfYbYx56TzFFgN3VI/WGQDkG2OOnqesUkopJ7CnS2cQcDuwXUS2VP/t70A0gDFmJvAVMApIAUqAO+s+VKWUUpeixoRvjFnFufvoTy9jgPvrKiillFJ1T2faKqWUi9CEr5RSLkITvlJKuQhN+Eop5SI04SullIvQhK+UUi5CE75SSrkITfhKKeUiNOErpZSL0ISvlFIuQhO+Ukq5CE34SinlIjThX4THH3+cH374wdlhKKVUrVzUFoeurKqqiqeeeuqij3F3d3dQREopdXG0hQ+kpqaSkJDA5MmTSUxMZMKECZSUlBATE8NTTz3F4MGDWbBgAVOmTGHhwoUALFu2jJ49e9KtWzfuuusuysvLAc46RimlGgpN+NWSk5OZOnUq27ZtIzAwkDfeeAMAHx8fVq1axaRJk06WLSsrY8qUKXz88cds374di8XCm2++efL5cx2jlFLOZs8Wh7NFJFNEdpzn+WEiki8iW6pvj9d9mI4XFRXFoEGDALjttttYtWoVADfffPNZZZOTk4mNjSU+Ph6AyZMns2LFipPPn+sYpZRyNnv68N8DpgPvX6DMSmPMmDqJyElsW/ee/djPz++ssrYNvs7vXMcopZSz2bPF4QoRiXF8KM51+PBh1q5dy8CBA/noo48YPHgwmzdvPmfZhIQEUlNTSUlJoUOHDsybN4+hQ4fWc8TqfKqshrySCvJKK8krqSS/tILCMguFZRaKyi2UlFsorayirNJKuaUKS5Wh0mqoslo5/btcBNzd3PBwE9zdBG8PN3w93fHxdMfXy50AHw/8vW234GZeBDfzJNjXk+Z+Xni6a2+panjqapTOQBHZCmQADxtjdp6rkIhMBaYCREdH19FL141OnToxd+5cfve73xEXF8d9993H66+/fs6yPj4+zJkzh4kTJ2KxWOjbty/33ntvPUfsmsotVWTklZF+ooT0E6UczS/jWH4pxwrKySwoI7uogtzicqwX/hGGj6cbPp7u+Hi44+kheLi54e4muJ32Q89qwGo1VFqtWKoM5RYrZZVVlFVW1Xj+4GaehPh7E+rvTXiQD62CfAgP8iEi2JfI5s2IbO6Ln7cOklP1S2rqngCobuEvNcZ0PcdzgYDVGFMkIqOAV40xcTWds0+fPiYpKeniI3aA1NRUxowZw44d57xMoeqZ1Wo4klfKvsxCUjKLOJhdQmp2Mak5xRzNL/tVWREI9femdZAPYQE+hAZ4EeLvTQs/L1r4eRHk60lwMy8C/9ca9/HA19P9rC68i2GMLfkXlVsoqv7lkF9ayYmSCvJKKsgpriC7qJzswgoyC8s4XlDO8YIyLGd8S7T08yImxI+2LZvRLsSP9qH+xLXyp21LP/2FoM5LRDYaY/rU5thLbmIYYwpOu/+ViLwhIiHGmOxLPbdq+grLKtmZUcCujAL2HCtgz7FC9h4vpKzSerJMCz8v2rZsxsB2LYlu2Yyo6hZyRHNfWgX61HtyFBHbrwNPd0L8ve06xmo1ZBeVk55XSvqJUtJyS0jLLSE1p5g1KTl8tunIybIebkK7UD8SWgeSEB5Ap/BAukUE2f1aSp3PJSd8EWkNHDfGGBHph23kT84lR1aPYmJitHVfD8oqq9iZkc/mw3lsTc9nx5F8DmYXn3y+pZ8XCeEB3NKvLXGt/IkL86dDmD/BzbycGHXdcHMTwgJ9CAv0oVd087OeLy63cCCrmJSsQvYeL2LvsUI2HjrB4q0ZJ8u0DvSha0Qg3SOD6REdTGJkMEG+nvX531CNXI0JX0Q+AoYBISKSDjwBeAIYY2YCE4D7RMQClAKTjD39RKrJyykqZ0PqCZJSc9lw6AQ7j+Sf7NZoE+RDYmQw43tF0CUiiC5tAgkL8HFyxM7j5+1Bt8ggukUG/erv+aWV7D5awI4j+ezMKGBbeh4/7M48+XxcmD99YlrQN6Y5fWNaENnc95K6q1TTZlcfviM0pD58VTdOFFew9kAO66pve48XAeDl4UaPyGB6tW1Oz+hgekYFExbousn9UuWXVrItPY8th/PYePgEGw+doLDMAkBEsC/927VgQLuWDOoQQkSwr5OjVXXtUvrwNeGrWquwWEk6lMuKvdmsTslmR0Y+xkAzL3f6xtiSTr/Y5nSNCMLbQ9cUchSr1bA3s5D1B3Orv2xzyS2uACA2xI/BHUK4PC6EQR1CdGRQE6AJX9WbzMIyftydyfLkTFan5FBUbsHDTegV3ZxBHUIYHNeSxMhgHWXiRMYY9h4vYlWK7Yt43YEcSiqq8HQX+sW2YHjHMK7s1IrYEJ0g2BhpwlcOlZJZyLc7j/P9ruNsScsDbH3wQzuGMaxjKIM6hOCvLccG63+/xH5OzuKn5CySjxcC0C7Uj6s7tWJEl1b0jGqOm5v2/TcGmvBVnTLGsDOjgK93HOWbHcfYn2UbSdM9KpirO4VxVedWdGwVoBcHG6n0EyUs253JD7uPs+5ADpVVhrAAb67p0ppru7Wmf2xL3DX5N1ia8FWd2Hu8kCVbM1i67SgHs4txExjQriUju7ZmROfWtA7SC61NTUFZJcv3ZPL19mP8tDeTskorIf7ejOrWmjGJbejTVlv+DY0mfFVrR/NLWbwlg883H2HPscKTSX5MYhuu6dKKljrZx2WUVFhYvieLpdsy+HFPJuUWKxHBvozt0YYbekYQ3yrA2SEqNOGri1RaUcW3O4+xcGM6q/dnYwz0iArm+h5tGJUY7tLj4ZVNUbmFH3YdZ9GWI6zcl02V1dClTSATekcyrkcELfwa/2S4xkoTvqqRMYat6fl8vOEwS7YepajcQmRzX27sFckNPSN0xIY6r6zCcpZuy+DTTensOFKAp7twRUIYk/pGMyQ+VPv765kmfHVeBWWVfL7pCB+tP8yeY4X4eLoxqls4E3tH0T+2hfbPqouy+2gBn25M5/PNR8gprqBNkA8T+0Rxc98o2ugkr3qhCV+dZceRfD745RCLNmdQWllF14hAJvWNZmyPNgT66Por6tJUWKx8v+s48zccZlVKNgJc1akVtw1oy+AOIdqQcCCnrpapGo7KKitf7zjGe6sPsulwHj6ebozrHsGtA6JJjAx2dniqCfHycGN0YjijE8NJyy3hg18O80lSGt/tOk5siB+TB7ZlfO9IArRx0aBoC78JyC2u4IN1h/jvL4c4XlBOTMtm3D4whgm9Iglqph84VT/KLVV8vf0Yc9emsvlwHv7eHkzoHcmdg2Jo21KvEdUV7dJxUfuzinh31UE+3ZhOucXK5XEh3DUolqHxofqTWjnV1rQ85q5JZcm2DCxWw4jOrbjn8nb0adtcJ+xdIk34LmbjoRPM/Hk/3+86jpeHGzf2jODuwbHE6Thp1cBkFpTx/lrbr8+8kkp6RAVz79D2jOjcShsltaQJ3wUYY/gpOYs3f9rP+tRcgpt5csfAGO4Y2FZ3QlINXkmFhU83pvP2yoMczi2hXagf9w5pz/U9I/Dy0IX2LoYm/CbMajV8u/MY05ensDOjgDZBPtxzeTtu7hulS92qRsdSPbDgzZ/2s+uo7f1877D23NQnCh9PXULbHg5N+CIyGxgDZJ5nE3MBXgVGASXAFGPMpppeWBP+hVVZDV9uP8rry/axL7OI2BA/7hvWnht6RujSw6rRM8bw894sXv8xhY2HThAa4M3vhrTj1v5t8fXSxH8hjk74Q4Ai4P3zJPxRwAPYEn5/4FVjTP+aXlgT/rn9L9G/tmwfKZlFxIX588CVcYzuFq4zGlWTY4xh3YFcXv9xH2v25xDi7829QzXxX4hDx+EbY1aISMwFiozD9mVggHUiEiwi4caYo7UJyFUZY/h253Fe+j6ZvcdtiX76LT0Z1TVcL26pJktEGNi+JQPbt+SXAzm8umwfz3y5m7dWHOCBKzpwc98o3S2tDtVFJ3AEkHba4/Tqv52V8EVkKjAVIDo6ug5euvEzxrByXzb/+S6Zben5tAvx47Xf9GRMN030yrX0b9eSD9vZEv+L3+3l8S928tbPB3jwqjhu7BmBh3ZlXrK6SPjnykrn7CcyxswCZoGtS6cOXrtR25qWx7Nf72HtgRwim/vywoREbtA3tnJx/du15OPfDTjZEHpk4TZmrTjAI9d05OrOrXQc/yWoi4SfDkSd9jgSyKiD8zZZqdnFPP/tHr7afoyWfl7867rO3NK/rQ5PU6qaiDAkPpTL40L4ZscxXvg2manzNtK7bXP+dm0CfWJaODvERqkuEv5iYJqIzMd20TZf++/PLbe4gteW7eO/6w7h5eHGg1fG8dsh7XQ/WKXOQ0S4tls4V3duxYKN6bzyw14mzFzLtV1b89eRCcTost4XpcZMIyIfAcOAEBFJB54APAGMMTOBr7CN0EnBNizzTkcF21iVW6qYuyaV139Mobjcws19o3no6jjdaEQpO3m4u/GbftGM69GGd1YePDnT/LYBbfnjVXEEN9MNWeyhE68cyBjD97uO8/++2s2hnBKGdQzl76M66VZxSl2izMIyXv5+Lx9vSCPQ15OHrorn1v7RLnH9S2faNkB7jxfy5JKdrE7JoUOYP4+N7sSwjmHODkupJmX30QKeWrKLtQdyiAvz54nrujA4LsTZYTmUJvwGpKCskle+38fctan4e3vwp6vjuaV/tM6OVcpB/vdL+pkvd3M4t4Rru7bmH6M7Edm8mbNDcwjdAKUBMMbw2aYj/Pvr3eQUV/CbftE8PKKjbvaslIOJCCO6tGZIfCjvrDzA9OUpLE/O5PfDOvC7oe104tZptIVfB5KPFfLPRTtYn5pLz+hgnhrblW6RQc4OSymXlJFXyv/7cjdfbj9KbIgfT47twpD4UGeHVWe0S8dJSiosvPLDPt5ddZAAHw/+dm0CE3tH6QxZpRqAFXuzeGLxTg5mFzO6WziPX9eZVoGNf2ScJnwnWL4nk8cW7eBIXik394nir9cmaPeNUg1MuaWKWT8f4PXlKXi7u/HIyI7c0r9to16IUBN+PcosLOPJxbv4cvtR4sL8+b8bu9FXZ/0p1aClZhfz2KIdrErJpkdUMM+O70ZC60Bnh1UrmvDrgTGGBUnpPPPlLsosVv5wRQemDmmvyyEo1UgYY/hiSwZPL91Ffmkl9w1rz7QrOjS6i7o6SsfBDueU8LfPt7E6JYd+sS149sZutAv1d3ZYSqmLICJc3zOCofGhPL10F6//mMJX24/y/IREerd1jV/p2sK/AKvVMHdtKs9/k4yHm/DoqAR+0zdaL8oq1QT8lJzJPz7fQUZ+KXdeFstfrunYKDZd0S4dBziYXcxfF25jfWouwzqG8u8buxEe5OvssJRSdai43MJz3+zh/bWHaNuyGc+PT6R/u5bODuuCLiXhawf0GaxWw5zVB7n21RXsOVbAfyZ2Z86UvprslWqC/Lw9eGpcVz767QCMgZtnrePJJTsprahydmgOoX34p0nLLeEvC7ey7kAuwzuG8uz4xCYxblcpdWED27fkmz9eznNf72HO6lR+Ts7iPzd1p1d0c2eHVqe0hY/t6v0nSWlc++pKdhwp4Lnx3Zg9pa8me6VcSDMvD54c15UP7ulPucXKhDfX8MK3e6iwWJ0dWp1x+YSfU1TOvf/dyCMLt9E1IpCvH7ycm/tG6zZqSrmoQR1C+OaPlzO+VyQzlu9n/JtrSMksdHZYdcKuhC8iI0UkWURSROTRczw/RUSyRGRL9e2eug+17i1PzuSaV1ayfE8W/xjViQ/vGUBUi6a5wp5Syn4BPp68MLE7M2/rzZG8Uka/toq5a1Jx1iCXumLPjlfuwAzgamz7124QkcXGmF1nFP3YGDPNATHWubLKKp79eg/vrUkloXUA8+7uR6fwxjnrTinlOCO7tqZX22D+unAbTyzeyc97s3h+QiIh/t7ODq1W7Gnh9wNSjDEHjDEVwHxgnGPDcpzkY4VcP2M1761J5c5BMSy6f5Ame6XUeYUF+DB7Sl+eHNuFVSnZjHxlJT8lZzo7rFqxJ+FHAGmnPU6v/tuZxovINhFZKCJR5zqRiEwVkSQRScrKyqpFuLVnjOG/6w4xdvoqsovKee/OvjxxXRd8PBv+RAullHOJCJMvi2HJtMG09PNiypwNPLN0V6O7oGtPwj/X1cszO7KWADHGmETgB2DuuU5kjJlljOljjOkTGlp/61Pnl1Ty+w828diiHQxo15KvHxyi2w0qpS5ax9YBfDFtEJMHtuWdVQeZMHMNqdnFzg7LbvYk/HTg9BZ7JJBxegFjTI4xprz64dtA77oJ79JtPHSCUa+t5Ptdx/n7qATmTOlLaEDj7H9TSjmfj6c7T47ryqzbe3Mop4Qxr6/iiy1HnB2WXexJ+BuAOBGJFREvYBKw+PQCIhJ+2sOxwO66C7F2jDG8veIAN7+1Fjc3WHjfZUwd0l7XwVFK1YkRXVrz9YOX0yk8gAfnb+Fvn22nrLJhz9CtcZSOMcYiItOAbwF3YLYxZqeIPAUkGWMWA38QkbGABcgFpjgw5hrllVTw8IKt/LA7k2u7tubZ8YkE+Xo6MySlVBPUJtiXj347gJe+38sbP+1n8+ETvHFrrwa7mm6TWzxta1oev/9gE5mFZfxjVCcmXxajk6iUUg63PDmTP328hQqLlecndGd0YnjNB9WCLp6GrQtn3rpDTJy5FoCF917GlEGxmuyVUvVieMcwvnrwcjq2DuD+Dzfx5JKdDW4UT5NI+CUVFh76eAv/XLSDyzq0ZOkDg+keFezssJRSLiY8yJf5Uwdy56AY5qxOZdKstRzNL3V2WCc1+oSfml3MDTPW8MXWDP58dTyzJ/eluW4mrpRyEi8PN564rgszbulF8rFCrnt9FWv35zg7LKCRJ/xlu49z3fRVHC8sY+6d/XjgyjgdhaOUahBGJ4bzxbRBBPl6ctu7v/DOygNOX4unUSZ8q9Xw8vd7uXtuEtEtmrFk2mCGxNffRC6llLJHh7AAFt0/iKs7teKZL3fzh/lbKKmwOC2eRpfwC8sqmTpvI68u28f4XpF8et9lusKlUqrBCvDx5M3bevHIyI4s3ZbB+DfXkpZb4pRYGlXCP5BVxA1vrGF5cib/uq4z/5mYqGvhKKUaPBHh98M6MGdKX46cKGHs9FWsScmu9zgaTcL/eW8W42asJre4gv/e3V+HXCqlGp1hHcP4YtpgQvy9uX32euasPliv/foNPuEbY3hn5QHunLOeyObNWDxtEAPbN+xd5ZVS6nxiQ/z4/P5BXJEQxpNLdvG3z7bX23j9Bp3wyy1V/GXhNp75cjcjOrdm4b0DiWyu/fVKqcbN39uDt27rzbThHZi/IY1b31lHdlF5zQdeogab8HOKyrn17V9YuDGdB6+M441be+HnXePSP0op1Si4uQkPX9OR137Tk23p+Vw/YzXJxxy7d26DTPh7jxcybsZqth/JZ/otPXno6ngdX6+UapLGdm/DgnsHUmGxMv7NNSzf47jdtBpcwv8pOZMb31hDucXKx78byJjENs4OSSmlHCoxMpgvpg0iukUz7p67gdmrHHMxt0El/HnrDnHXexuIatGML+4fRA9dD0cp5SLCg3xZeN9ArurUiqeW7uKJxTuxVNXtxdwGkfCrrIZnlu7in4t2MKxjGAvvHUibYF9nh6WUUvWqmZcHM2/rzdQh7Xh/7SF++34SReV1NzPX6Qm/tKKK+/67kXdWHWTKZTG8fUcfvTirlHJZbm7C30d14pnru7JiXzYTZ9bdipt2JXwRGSkiySKSIiKPnuN5bxH5uPr5X0Qkxp7zZheVM+ntdXy/+ziPj+nMv8Z2wV0vziqlFLcNaMvsKX1Jyy3hhhlr2HOs4JLPWWPCFxF3YAZwLdAZ+I2IdD6j2N3ACWNMB+Bl4LmazltusXLjG2tIPlbAW7f15q7BsRcfvVJKNWFD40P55HcDMRgmvrmW1Ze4HIM9Lfx+QIox5oAxpgKYD4w7o8w4YG71/YXAlVLDugf7s4ooKrfw0W8HMKJL64uNWymlXELnNoF8/vtBtAn2ZfLs9Zd0Lns6yyOAtNMepwP9z1emetPzfKAl8KuvIxGZCkytfli++fERO3o9Xpuwm5wQzqgrF6Z1cYrWxSlaF6d0rO2B9iT8c7XUzxwgak8ZjDGzgFkAIpJU2414mxqti1O0Lk7RujhF6+IUEUmq7bH2dOmkA1GnPY4EMs5XRkQ8gCAgt7ZBKaWUqnv2JPwNQJyIxIqIFzAJWHxGmcXA5Or7E4AfjbP38lJKKfUrNXbpVPfJTwO+BdyB2caYnSLyFJBkjFkMvAvME5EUbC37SXa89qxLiLup0bo4ReviFK2LU7QuTql1XYg2xJVSyjU4faatUkqp+qEJXymlXITDE76jlmVojOyoiz+JyC4R2SYiy0SkrTPirA811cVp5SaIiBGRJjskz566EJGbqt8bO0Xkw/qOsb7Y8RmJFpHlIrK5+nMyyhlxOpqIzBaRTBHZcZ7nRUReq66nbSLSy64TG2McdsN2kXc/0A7wArYCnc8o83tgZvX9ScDHjozJWTc762I40Kz6/n2uXBfV5QKAFcA6oI+z43bi+yIO2Aw0r34c5uy4nVgXs4D7qu93BlKdHbeD6mII0AvYcZ7nRwFfY5sDNQD4xZ7zOrqF75BlGRqpGuvCGLPcGFNS/XAdtjkPTZE97wuAp4HngbL6DK6e2VMXvwVmGGNOABhjHLclknPZUxcGCKy+H8TZc4KaBGPMCi48l2kc8L6xWQcEi0h4Ted1dMI/17IMEecrY4yxAP9blqGpsacuTnc3tm/wpqjGuhCRnkCUMWZpfQbmBPa8L+KBeBFZLSLrRGRkvUVXv+ypi38Bt4lIOvAV8ED9hNbgXGw+AexbWuFS1NmyDE2A3f9PEbkN6AMMdWhEznPBuhARN2yrrk6pr4CcyJ73hQe2bp1h2H71rRSRrsaYPAfHVt/sqYvfAO8ZY14UkYHY5v90NcbU7dZQDV+t8qajW/i6LMMp9tQFInIV8A9grDGmvJ5iq2811UUA0BX4SURSsfVRLm6iF27t/Yx8YYypNMYcBJKxfQE0NfbUxd3AJwDGmLWAD7aF1VyNXfnkTI5O+Loswyk11kV1N8Zb2JJ9U+2nhRrqwhiTb4wJMcbEGGNisF3PGGuMqfWiUQ2YPZ+RRdgu6CMiIdi6eA7Ua5T1w566OAxcCSAinbAl/Kx6jbJhWAzcUT1aZwCQb4w5WtNBDu3SMY5blqHRsbMuXgD8gQXV160PG2PGOi1oB7GzLlyCnXXxLTBCRHYBVcBfjDE5zovaMeysiz8Db4vIQ9i6MKY0xQaiiHyErQsvpPp6xROAJ4AxZia26xejgBSgBLjTrvM2wbpSSil1DvZscRhVPdFhd/WkjwfPUaZ2kwCUUkrVG3u6dCzAn40xm0QkANgoIt8bY3adVuZabBeR4rDthvUmZ++KpZRSyolqbOEbY44aYzZV3y8EdnP2eM9aTQJQSilVfy7qom31Ojc9gV/OeOp8kwB+ddVYTtvT1s/Pr3dCQsLFRauUUi5u48aN2caY0Noca3fCFxF/4FPgj8aYgjOfPschF9zTtk+fPiYpqSmOslNKKccRkUO1Pdaucfgi4okt2X9gjPnsHEVqNQlAKaVU/bFnlI5gGyu/2xjz0nmK1WoSgFJKqfpjT5fOIOB2YLuIbKn+29+BaLi0SQBKKaXqjz2bmK/i3H30p5cxwP11FZRSSqm6p1scKqWUi9CEr5RSLkITvlJKuQhN+Eop5SIcveOVUsqBjDHklVRyJK+Uo/ll5BSVk1NcQU5RBYVllRSVWygqt1BeacVitWKxGqqsBg83wcPdDQ83oZmXO/4+nvh7exDk60logLft5u9NZHNfwoN88HDXtmFToAlfqUagtKKKvccLST5eyIGsYg5mF3Ewu5i03FJKK6vOKu/n5U6gry2J+3l74OPphp+nB+5ugrsIFqvBYrVSWWXILqogNaeEwjIL+aUVVFb9epK8h5vQJtiXdqF+dGwVQHyrADq2tt089YugUdGEr1QDU1pRxc6MfLak5bE1PZ+dGfmkZhdjrc7Dnu5C25Z+xIb4cXlcKBHBvrQJtrXEQwK8aennhY+ne61e2xhDfmklWYXlHC8oJ/1ECWknSjiUU8L+rGLW7M+hwmLbPtbbw42uEUF0jwymX2wLBrRrQXAzr7qqBuUATtsARdfSUcomv7SS9Qdz2ZCay/qDuew4ko+lOru3CfKha0QQncID6RQeQMfWgUQ193VaF4ulysqh3BJ2ZhSwNS2PrWl5bD+ST7nFigh0aRPIoA4hXJnQil7RwdoV5AAistEYU6v9nTXhK1XPKqusbDx0gpX7sliVksP29DysBrzc3egeFUSfmBb0im5O98ggwgJ9nB1ujSosVram57EmJYc1+7PZdPgElVWG4GaeDO8Yxqhu4QyJD8Hbo3a/OtSvacJXqoHLLa5g2e7j/JScxYp9WRSWWXB3E3qeQ18+AAAcY0lEQVREBTO4QwiXtW9J96jgWnfFNCSFZZWs3JfNst2Z/LjnOCdKKgnw8eCaLq25sWcEA9q1xM3tgpP31QVowleqATqaX8o3O47x7c5jrD+Yi9VAq0BvhncMY1jHMAZ1aEmAj6ezw3Soyiorq1OyWbL1KN/tPEZhuYXoFs24qU8kE3pH0Tqo4f+CaWg04SvVQGQWlvHVtqMs3XaUpEMnAIhv5c81XVozonNrukYEYluA1vWUVVbxzY5jfLwhjbUHcnB3E67t2pq7BsfSK7q5s8NrNDThNwCLFi0iPj6ezp07X9RxixcvZteuXTz66KMOikw5WkmFhW93HuOzTUdYnZKN1UBC6wDGJIYzqls47UL9nR1ig5OaXcwHvxxi/oY0CsssdI8K5r6h7RjRubV299RAE34DMGXKFMaMGcOECRPsPsZiseDhcXEjY2tzjKp7xhiSDp3gkw1pfLn9KCUVVUQE+3JDzwjG9WhDXKsAZ4fYKBSXW/h0UzrvrjrIoZwS4sL8mXZFB0Z3C9cRPuehCf8SpaamMnLkSPr378/mzZuJj4/n/fffZ+3atTz88MNYLBb69u3Lm2++ibe3N48++iiLFy/Gw8ODESNGcOONNzJmzBiCgoIICgri008/BeD+++8nKyuLZs2a8fbbb5OQkMCUKVNo0aIFmzdvplevXnTr1o2kpCSmT5/OoUOHuOuuu8jKyiI0NJQ5c+YQHR191jEvvviik2vMdeUUlbNgYzqfbEjjQHYxfl7ujElsw/jekfRp21xbp7VkqbLy5fajzFiewt7jRbQL9ePhER25tmtrl+0CO59LSfgYY5xy6927t2koDh48aACzatUqY4wxd955p3n66adNZGSkSU5ONsYYc/vtt5uXX37Z5OTkmPj4eGO1Wo0xxpw4ccIYY8zkyZPNggULTp7ziiuuMHv37jXGGLNu3TozfPjwk+VGjx5tLBaLMcaYOXPmmPvvv98YY8yYMWPMe++9Z4wx5t133zXjxo075zGqflmtVrNuf7Z54MNNJu7vX5m2f11qJry52nyy4bApLq90dnhNSlWV1Xy9/ai5+qWfTNu/LjXXvb7SrNyb5eywGhQgydQy79bYNyAis4ExQKYxpus5nh8GfAEcrP7TZ8aYp2r17eNEUVFRDBo0CIDbbruNp59+mtjYWOLj4wGYPHkyM2bMYNq0afj4+HDPPfcwevRoxowZc9a5ioqKWLNmDRMnTjz5t/Ly8pP3J06ciLv72cPv1q5dy2ef2bYMvv3223nkkUdqPEY5TkmFhUWbM3h/bSp7jhUS6OPBrQOiubV/NB3CtMvGEdzchJFdW3N151Z8vvkIL3+/l9ve/YWrOoXx2OjOxIT4OTvERs2ezuD3gOnA+xcos9IYc3bma0Ts/dno4eHB+vXrWbZsGfPnz2f69On8+OOPvypjtVoJDg5my5Yt5zyHn599b9rTY7L3GHXpjuSVMndNKvPXH6agzELn8ECeH5/Idd3b4OulX7r1wd1NmNA7kuu6hzNndSqvL9vHiJdXcNfgWB64ogN+3nodqzZqvCpijFkB5NZDLE51+PBh1q5dC8BHH33EVVddRWpqKikpKQDMmzePoUOHUlRURH5+PqNGjeKVV145mdQDAgIoLCwEIDAwkNjYWBYsWADYus22bt1aYwyXXXYZ8+fPB+CDDz5g8ODBdf7/VOe3JS2PaR9uYsjzy3l31UEujwtlwb0D+fIPg7mpb5Qmeyfw9nDn3qHtWf7wMK7r3oaZP+/n6pd+Ztnu484OrVGqq8vgA0Vkq4h8LSJdzldIRKaKSJKIJGVlZdXRS9eNTp06MXfuXBITE8nNzeWhhx5izpw5TJw4kW7duuHm5sa9995LYWEhY8aMITExkaFDh/Lyyy8DMGnSJF544QV69uzJ/v37+eCDD3j33Xfp3r07Xbp04Ysvvqgxhtdee405c+aQmJjIvHnzePXVVx3933Z5Vqvhxz3HufmttVw/YzU/J2dx9+BYVjwynBm39qJvTAu9aNgAhAX68OJN3fn0vsvw9/Hg7rlJ3P/BJjILypwdWqNi1ygdEYkBlp6nDz8QsBpjikRkFPCqMSaupnM2tFE6Y8aMYceOHc4ORdUTS5WVJdsyePOn/ew9XkSbIB/uGhzLpH7R+Gt3QYNWYbEya8V+XvsxBV9Pd54a14Wx3du4zBfzpYzSueR3tjGm4LT7X4nIGyISYozJvtRzK1XXyiqrWLgxnbdW7Cctt5SOrQJ4+ebujElso2u7NxJeHm5MuyKOa7uF8/CCrTw4fwvf7TzO09d3pYWfLs98IZec8EWkNXDcGGNEpB+2bqKcS46sHsXExGjrvokrrajio/WHeWvFfo4XlNMjKpgnxnThioQwHTvfSLUP9WfB7wby1ooDvPLDXtan5vLSTd25PC7U2aE1WPYMy/wIGAaEiEg68ATgCWCMmQlMAO4TEQtQCkwy9vQTKVUPSiuq+O+6Q7y14gDZReUMaNeCl2/qwcD2LV2mC6Ap83B34/7hHRjeMYwH52/mjtnruW9oex66Ol5/sZ2DzrRVTVJZpS3Rz/x5P9lFFQzq0JI/XBFH/3YtnR2acpDSiiqeXLKT+RvS6N22Oa/9picRwb7ODqvO6dIKSlUrt1Qxf30a05enkFVYzqAOLXnoqnj6xLRwdmiqnizemsHfP9uOp7sw/ZZeDOoQ4uyQ6pRTL9oq1RBYqqx8uimd15alcCSvlH6xLXj9Nz0ZoC16lzO2exu6RQQx9f0kbn/3F/46MoGpQ9ppFx6a8FUjZ7Uavt5xjBe/S+ZAdjHdo4J5dnw3BncI0Q+4C4sN8WPR/YP4y8Kt/PvrPWw7ks9/JnR3+clzmvBVo2SMYVVKNs9/k8z2I/nEt/Jn1u29ubpzK030CgA/bw9m3NKLt1Yc4Llv9pCWW8I7d/RpFPsEO4omfNXobE/P59lvdrM6JYeIYF9enNid63tG4K7DK9UZRIR7h7anfag/D87fzLgZq3l3cl86twl0dmhOoRdtVaNxOKeEF75LZsnWDJo382TaFXHcNiAabw/X/pmu7LMzI5+730uioKySGbf2YnjHMGeHVCs6Skc1aSeKK5i+PIX316bi7ibcM7gdU4e2I7CJbwCu6t7xgjLunruB3UcLeX58IuN7Rzo7pIumo3RUk1RuqWLumlSm/5hCUbmFib2jeOjqeFoHuW4frLo0rQJ9mD91IL+bl8SfF2wlu6jcpUbwaMJXDY4xhq+2H+PZb3aTllvK0PhQ/jYqgYTWrtnvquqWv7cHs6f05c+f2EbwZBWW84/RnVwi6WvCVw3KlrQ8nl66i42HTpDQOoB5d/fTtVFUnfP2cOe1ST0J8ffmnVUHKams4plxXZv8ukqa8FWDkJFXyvPf7GHRlgxCA7x5bnw3JvSO0pE3ymHc3IQnruuMr5c7b/60n7LKKp4fn4hHE16DRxO+cqqSCgszfz7ArBX7MQamDe/AvcPa65r0ql6ICI9c05Fmnu68+P1eyiutvDKpR5NdeE0/VcopjDF8sSWDZ7/ew7GCMsYkhvPotQlENm/m7NCUixERHrgyDh9Pd/7fV7sBeHVSjybZ0teEr+rdlrQ8nlyyk82H8+gWEcT0W3rq4mbK6X47pB0i8MyXu/FwF166qUeT61LUhK/qTWZBGc99k8ynm9IJDfDm+QmJTOgV2eQvlKnG457L21FZZXjumz24i/DCxO5NKunbswHKbGAMkHmePW0FeBUYBZQAU4wxm+o6UNV4lVuqmL0qlek/7qOyynDv0PZMu6KD9tOrBum+Ye2xVFl58fu9eHu68X83dGsyQzbt+cS9B0wH3j/P89cCcdW3/sCb1f8qF2eMYdnuTJ75chepOSVc1akVj43uREyIn7NDU+qCHrgyjjJLFTOW7yfI14tHr01wdkh1osaEb4xZISIxFygyDni/elvDdSISLCLhxpijdRSjaoT2ZxXx1JJd/Lw3i/ahfsy9qx9D43U8vWo8Hh7RkRMllcz8eT/Nm3nyu6HtnR3SJauL39QRQNppj9Or/3ZWwheRqcBUgOjo6Dp4adXQFJZVMv3HFGavPoiPhzuPje7E5MtimuwwN9V0iQhPj+tKQWkl//56D8HNPLm5b+POW3WR8M/VuXXOFdmMMbOAWWBbPK0OXls1EFarYdGWIyenqk/sHckjIxMIDfB2dmhK1Zq7m220TkGZhb99tp2wAB+GJzTOVTYB6qLZlQ5EnfY4Esiog/OqRmLHkXwmzFzDnz7ZSpsgHxbdP4gXJnbXZK+aBC8PN968tRed2wRy/4eb2J6e7+yQaq0uEv5i4A6xGQDka/+9a8gtruBvn23nuumrOJRTwvPjE/n894PoERXs7NCUqlN+1QuuNW/mxZ3vbSAtt8TZIdWKPcMyPwKGASEikg48AXgCGGNmAl9hG5KZgm1Y5p2OClY1DJYqKx+uP8yL3+2lqNzCnZfF8uBVcQT56vr0qukKC/Bh7l19ufGNNUyZs57P7htEULPG9Z7XDVDURVl/MJcnFu9k99ECLmvfkn+N7UJ8qwBnh6VUvVl3IIfb3/2FfrEteO/OfvU+IOFSNkDRoRPKLsfyy3hw/mZuemst+SUVzLilFx/c01+TvXI5A9q15P9u6MbqlByeWrLL2eFcFJ3qqC7oV7NkrYY/XNGB+4Z1wNdL95FVrmtinyj2ZRYxa8UB4lv5c/vAGGeHZBdN+Oq8lidn8tSSXRzMLuaqTq14fExnolvqapZKAfx1ZAL7M4v415JdxIb4MzguxNkh1Ui7dNRZUrOLuWfuBu6cswEB3ruzL+9M7qPJXqnTuLsJr0zqQftQP6Z9tKlRjNzRhK9OKi638Pw3exjx8grW7s/h0WsT+OaPQxjWsfFONFHKkQJ8PJl1ex+sVsO9/91IWWWVs0O6IE34qnozkiNc+eLPvPHTfsZ0D2f5w8O4d2h7vDz0LaLUhcSE+PHqpJ7sOlrA3z/bjrNGPtpD+/Bd3I4j+fxr8U6SDp2gW0QQM27tSe+2uhmJUhdjeEIYf7wynpd/2Ev3qGAmXxbj7JDOSRO+i8ouKufF75KZvyGNFs28eG58Nyb2jtLNSJSqpQeu6MD2I3k8vXQX3SKD6BXd3NkhnUV/r7uYCouVd1YeYPgLP7EgKZ27BsXy48PDuLlvtCZ7pS6Bm5vw4k09CA/24YEPN5NXUuHskM6iCd9FGGP4cc9xRr6ygme+3E2vts355o9D+OeYzrokglJ1JMjXkxm39CKrsJw/f7IVq7Vh9edrwncBKZmFTJ6zgbvesy1lMXtKH+be1Y8OYf5OjkyppicxMph/jO7Esj2ZvLPqgLPD+RXtw2/CThRX8MoPe/nvL4dp5mXbjOSOgTE68kYpB7tjYFt+OZjDc98k07tt8wYzEEITfhNUYbEyb90hXv3BtprlLf2jeeiqeFr66/r0StUHEeHZ8YlsP7KSP3y0ha//eDmBPs7vOtWmXhNijOHbnce45pUVPL10F92jgvn6wSE8c303TfZK1bNAH09endSTYwVlPPb5jgYxPl9b+E3E9vR8nvlyF78czKVDmD9zpvRlWMdQRHTkjVLO0iu6OX+8Mo4Xv9/LsI6h3Ngr0qnxaMJv5NJPlPCfb5NZtCWDln5ePHN9Vyb1jcJDNw1XqkH4/fAOrNyXzT8X7aB32+a0benntFjsygoiMlJEkkUkRUQePcfzU0QkS0S2VN/uqftQ1enySyr591e7ueLFn/l6xzF+P6w9y/8yjNsGtNVkr1QD4u4mvDypB+5uwoPzt2CpsjotFnu2OHQHZgBXY9uwfIOILDbGnLny/8fGmGkOiFGdpqyyivfXpjJj+X4Kyiq5sWckfx4RT5tgX2eHppQ6j4hgX565oRt/+GgzM3/ez7Qr4pwShz1dOv2AFGPMAQARmQ+MAxrXVi+NXJXVsGjzEV76fi9H8koZGh/KX0cm0LlNoLNDU0rZYWz3Nny38xiv/LCPYR3D6BoRVO8x2PPbPwJIO+1xevXfzjReRLaJyEIRiTrXiURkqogkiUhSVlZWLcJ1PcYYvtt5jGtfXcGfF2ylhZ8XH97Tn7l39dNkr1Qj8/S4rjT38+LPn2yl3FL/Synbk/DPNczjzPFFS4AYY0wi8AMw91wnMsbMMsb0Mcb0CQ0NvbhIXdCa/dmMf3MNU+dtxFJlmHFLL764fxCXdWj4O+sopc7W3M+L58cnkny8kJe+31vvr29Pl046cHqLPRLIOL2AMSbntIdvA89demiua9PhE/zn22TW7M+hdaAP/76xGxN7R+rFWKWagOEJYfymXxSzVhxgROdW9ToL156EvwGIE5FY4AgwCbjl9AIiEm6MOVr9cCywu06jdBHb0/N5+Ye9/Lgnk5Z+XvxzTGdu7R+Nj6duGK5UU/KP0Z1ZsTebRxZu48s/XF5vn/EaE74xxiIi04BvAXdgtjFmp4g8BSQZYxYDfxCRsYAFyAWmODDmJmfHkXxe+WEfP+w+TpCvJ3+5piNTLovBz1unSSjVFPl7e/DvG7txx+z1vLZsH4+MTKiX1xVnTfft06ePSUpKcsprNxRb0/J4/cd9/LA7k0AfD357eTumDIohoAGsuaGUcry/LNjKZ5uP8MX9g+wetSMiG40xfWrzetqEdIKk1FymL0/hp+Qsgnw9+dPV8Uy+LEbXpVfKxTw2ujM/7c3iLwu3sXjaIDwdfJ1OE349McawYl82M5ansP5gLi38vHhkZEduH9BWW/RKuaigZp78v+u7MnXeRmb+tJ8HrnTshCxN+A5mqbLy1Y5jvPXzfnZmFNA60IfHx3RmUr8omnlp9Svl6kZ0ac3oxHBeX57C6MRw2oU6bmMizTgOUlxuYUFSGu+sOkj6iVLahfrx3Phu3NAzUjcgUUr9yhNjOrNibxaPLdrBB/f0d9gqt5rw61hGXilz16Ty0frDFJRZ6N22OY+P6cxVnVrpJuFKqXMKC/ThryMTeGzRDj7bdITxvR2zjLIm/DpgjGFD6gnmrk3lmx3HMMZwbddw7hocS++2zZ0dnlKqEbilXzSfbUrnmS93MTwhjBZ+XnX+GprwL0FxuYXFWzN4f+0hdh8tINDHg7sGxXDHwBiiWjRzdnhKqUbEzU34942JjH5tJf/31W7+M7F7nb+GJvxa2HOsgA9/Ocznm45QWG4hoXUA/76xG+N6tNELsUqpWuvYOoDfDmnHmz/t56Y+UfSLrdtlFzQ72amgrJIlWzP4JCmdrWl5eHm4MaZbOLcOiKZXdHPdSlApVSceuKIDi7dk8PgXO1j6wOA6XUNLE/4FWKqsrErJ5vPNR/h25zHKKq10bBXAY6M7Mb5XJM0d0MemlHJtzbw8+OeYTtz7303MW3eIOwfF1tm5NeGfwRjDlrQ8lm47yuKtGWQVlhPk68n4XpHc1CeKxMggbc0rpRzqmi6tGRIfykvf7WV0YjhhAT51cl5N+IDVatiansc3O46xdNtRjuSV4uXuVr3LfATDE8Lw9tAVK5VS9UNEeHJsF655eQXPfrWHl27uUSfnddmEX26p4pcDuXy/6zjf7TrG8YJyPNyEy+NCeOjqeK7u3ErXtlFKOU1siB+/HRLLjOX7mdQvuk4u4LpUwj+cU8LKlCyW78lizf5sSiqq8PV0Z2h8KCO6tOLKhFYENdMkr5RqGO4f3oHPNx3hySU7WTxtMO6XOHmzSSf8I3mlbDiYy7oDOaxKySb9RClg20F+fK9IrkgIY0C7lvh6aXeNUqrhaeblwV+vTeDB+VtYuDGNm/tGX9L5mkzCL6usYmdGPlvS8tmalsfGQyc4kmdL8AE+Hgxs15KpQ9pxWfsQ2of66YVXpVSjMLZ7G+atPcQL3yYzqlv4JZ3LroQvIiOBV7HtePWOMebZM573Bt4HegM5wM3GmNRLiuw8KixWDueWcDC7mH2Zhew5WsieYwXszyqmymrbzCU8yIee0cHcc3ksfWNa0Ck88JJ/CimllDOICI9f15mx01cz/ceUSzpXjQlfRNyBGcDV2DY03yAii40xu04rdjdwwhjTQUQmYdvE/GZ7g6iyGoorLBSVWSgut3CipJKconKyiyvIKiwnI6+UjLxSjuSVkn6i9GRiB1v3TKfwQK7p0prEyGC6RwYRFlg3Q5iUUqohSIwMZmLvSGavPnhJ57Gnhd8PSDHGHAAQkfnAOOD0hD8O+Ff1/YXAdBERc4H9E3dmFBD3j6+wWA0X2mVRBFoF+BDR3JfEyGDGdm9DbIgfsSF+tA/zJ1A3D1FKuYC/jOzIV9uPXtI57En4EUDaaY/Tgf7nK1O96Xk+0BLIPr2QiEwFplY/LE/5v9E77Aky1Z5CjVsIZ9SVC9O6OEXr4hSti1M61vZAexL+uTq/z2yT21MGY8wsYBaAiCTVdiPepkbr4hSti1O0Lk7RujhFRJJqe6w9q/KkA1GnPY4EMs5XRkQ8gCAgt7ZBKaWUqnv2JPwNQJyIxIqIFzAJWHxGmcXA5Or7E4AfL9R/r5RSqv7V2KVT3Sc/DfgW27DM2caYnSLyFJBkjFkMvAvME5EUbC37SXa89qxLiLup0bo4ReviFK2LU7QuTql1XYg2xJVSyjXU3cr6SimlGjRN+Eop5SIcnvBFZKSIJItIiog8eo7nvUXk4+rnfxGRGEfH5Cx21MWfRGSXiGwTkWUi0tYZcdaHmuritHITRMSISJMdkmdPXYjITdXvjZ0i8mF9x1hf7PiMRIvIchHZXP05GeWMOB1NRGaLSKaInHOukti8Vl1P20Skl10nNsY47IbtIu9+oB3gBWwFOp9R5vfAzOr7k4CPHRmTs2521sVwoFn1/ftcuS6qywUAK4B1QB9nx+3E90UcsBloXv04zNlxO7EuZgH3Vd/vDKQ6O24H1cUQoBew4zzPjwK+xjYHagDwiz3ndXQL/+SyDMaYCuB/yzKcbhwwt/r+QuBKaZpLWdZYF8aY5caYkuqH67DNeWiK7HlfADwNPA+U1Wdw9cyeuvgtMMMYcwLAGJNZzzHWF3vqwgCB1feDOHtOUJNgjFnBhecyjQPeNzbrgGARqXEpTUcn/HMtyxBxvjLGGAvwv2UZmhp76uJ0d2P7Bm+KaqwLEekJRBljltZnYE5gz/siHogXkdUisq569dqmyJ66+Bdwm4ikA18BD9RPaA3OxeYTwPHr4dfZsgxNgN3/TxG5DegDDHVoRM5zwboQETfgZWBKfQXkRPa8LzywdesMw/arb6WIdDXG5Dk4tvpmT138BnjPGPOiiAzENv+nqzHG6vjwGpRa5U1Ht/B1WYZT7KkLROQq4B/AWGNMeT3FVt9qqosAoCvwk4ikYuujXNxEL9za+xn5whhTaYw5CCRj+wJoauypi7uBTwCMMWsBH2wLq7kau/LJmRyd8HVZhlNqrIvqboy3sCX7ptpPCzXUhTEm3xgTYoyJMcbEYLueMdYYU+tFoxowez4ji7Bd0EdEQrB18Ryo1yjrhz11cRi4EkBEOmFL+Fn1GmXDsBi4o3q0zgAg3xhT49rJDu3SMY5blqHRsbMuXgD8gQXV160PG2PGOi1oB7GzLlyCnXXxLTBCRHYBVcBfjDE5zovaMeysiz8Db4vIQ9i6MKY0xQaiiHyErQsvpPp6xROAJ4AxZia26xejgBSgBLjTrvM2wbpSSil1DjrTVimlXIQmfKWUchGa8JVSykVowldKKRehCV8ppVyEJnyllHIRmvCVUspF/H9Q5YxjMTNmbAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "beta = Beta(2, 2)\n", + "plt.subplot(2, 1, 1)\n", + "plt.xlim(0, 1)\n", + "plt.ylim(0, 2)\n", + "plt.plot(x, beta.pdf(x))\n", + "plt.annotate(\"prior\", (0.1, 1.5))\n", + "\n", + "model = Bernoulli(mu=beta)\n", + "model.fit(np.array([1]))\n", + "plt.subplot(2, 1, 2)\n", + "plt.xlim(0, 1)\n", + "plt.ylim(0, 2)\n", + "plt.plot(x, model.mu.pdf(x))\n", + "plt.annotate(\"posterior\", (0.1, 1.5))\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Maximum likelihood estimation\n", + "10000 out of 10000 is 1\n", + "Bayesian estimation\n", + "6649 out of 10000 is 1\n" + ] + } + ], + "source": [ + "print(\"Maximum likelihood estimation\")\n", + "model = Bernoulli()\n", + "model.fit(np.array([1]))\n", + "print(\"{} out of 10000 is 1\".format(model.draw(10000).sum()))\n", + "\n", + "print(\"Bayesian estimation\")\n", + "model = Bernoulli(mu=Beta(1, 1))\n", + "model.fit(np.array([1]))\n", + "print(\"{} out of 10000 is 1\".format(model.draw(10000).sum()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2.2 Multinomial Variables" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Categorical(\n", + " mu=[0.5 0.25 0.25]\n", + ")\n" + ] + } + ], + "source": [ + "model = Categorical()\n", + "model.fit(np.array([[0, 1, 0], [1, 0, 0], [1, 0, 0], [0, 0, 1]]))\n", + "print(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.2.1 The Dirichlet distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Categorical(\n", + " mu=Dirichlet(\n", + " alpha=[1. 1. 1.]\n", + " )\n", + ")\n", + "Categorical(\n", + " mu=Dirichlet(\n", + " alpha=[3. 2. 1.]\n", + " )\n", + ")\n" + ] + } + ], + "source": [ + "mu = Dirichlet(alpha=np.ones(3))\n", + "model = Categorical(mu=mu)\n", + "print(model)\n", + "\n", + "model.fit(np.array([[1., 0., 0.], [1., 0., 0.], [0., 1., 0.]]))\n", + "print(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2.3 The Gaussian Distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\r0735\\Anaconda3\\lib\\site-packages\\matplotlib\\axes\\_axes.py:6571: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n", + " warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "uniform = Uniform(low=0, high=1)\n", + "plt.figure(figsize=(10, 5))\n", + "\n", + "plt.subplot(1, 3, 1)\n", + "plt.xlim(0, 1)\n", + "plt.ylim(0, 5)\n", + "plt.annotate(\"N=1\", (0.1, 4.5))\n", + "plt.hist(uniform.draw(100000), bins=20, normed=True)\n", + "\n", + "plt.subplot(1, 3, 2)\n", + "plt.xlim(0, 1)\n", + "plt.ylim(0, 5)\n", + "plt.annotate(\"N=2\", (0.1, 4.5))\n", + "plt.hist(0.5 * (uniform.draw(100000) + uniform.draw(100000)), bins=20, normed=True)\n", + "\n", + "plt.subplot(1, 3, 3)\n", + "plt.xlim(0, 1)\n", + "plt.ylim(0, 5)\n", + "sample = 0\n", + "for _ in range(10):\n", + " sample = sample + uniform.draw(100000)\n", + "plt.annotate(\"N=10\", (0.1, 4.5))\n", + "plt.hist(sample * 0.1, bins=20, normed=True)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.3.4 Maximum Likelihood for the Gaussian" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MultivariateGaussian(\n", + " mu=[0.91852581 1.17919155]\n", + " cov=[[4.29224408 0.1551223 ]\n", + " [0.1551223 3.58170912]]\n", + ")\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAD8CAYAAACLrvgBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzs3Xd4VFX6wPHvnclMJr33RhJSSSBAQu+9iYANxY51XV39ua5rW8uuddXVtbOWtSKoIEWKSO8QSCAJIb33nswkmcnMnN8fibRACEqw7Pk8Dw/JnVsOl2Teuee85z2KEAJJkiRJ6g3VL90ASZIk6bdDBg1JkiSp12TQkCRJknpNBg1JkiSp12TQkCRJknpNBg1JkiSp1y5K0FAU5UNFUaoVRUk/ZZu7oiibFEXJ6frb7RzH3tS1T46iKDddjPZIkiRJfeNiPWn8F5hxxra/ApuFEBHA5q7vT6MoijvwJDAcGAY8ea7gIkmSJP3yLkrQEELsAOrP2Hw58HHX1x8D885y6HRgkxCiXgjRAGyie/CRJEmSfiVs+vDcPkKICgAhRIWiKN5n2ScAKDnl+9Kubd0oinIHcAeAg4PD0Ojo6IvcXEmSpN+3Q4cO1QohvH7OOfoyaPSGcpZtZ61rIoRYAiwBSExMFMnJyX3ZLkmSpN8dRVGKfu45+jJ7qkpRFD+Arr+rz7JPKRB0yveBQHkftkmSJEn6GfoyaKwGfsyGuglYdZZ9NgLTFEVx6xoAn9a1TZIkSfoVulgpt0uBvUCUoiiliqIsBl4ApiqKkgNM7foeRVESFUV5H0AIUQ/8HTjY9eeZrm2SJEnSr5DyWyyNLsc0JEmSLpyiKIeEEIk/5xxyRrgkSZLUazJoSJIkSb0mg4YkSZLUazJoSJIkSb0mg4YkSZLUazJoSJIkSb0mg4YkSZLUazJoSJIkSb0mg4YkSZLUazJoSJIkSb0mg4YkSZLUazJoSJIkSb0mg4YkSZLUazJoSJIkSb0mg4YkSZLUazJoSJIkSb0mg4YkSZLUazJoSJIkSb3Wp0FDUZQoRVFST/nTrCjK/WfsM0FRlKZT9vlbX7ZJkiRJ+uls+vLkQogsIAFAURQ1UAasPMuuO4UQc/qyLZIkSdLPdym7pyYDeUKIokt4TUmSJOkiupRBYyGw9ByvjVQU5YiiKOsVRRlwCdskSZIkXYBLEjQURdECc4GvzvLyYSBECDEIeAP49hznuENRlGRFUZJramr6rrGSJEnSOV2qJ42ZwGEhRNWZLwghmoUQ+q6v1wEaRVE8z7LfEiFEohAi0cvLq+9bLEmSJHVzqYLGtZyja0pRFF9FUZSur4d1tanuErVLkiRJugB9mj0FoCiKPTAVuPOUbXcBCCHeBa4E7lYUxQy0AQuFEKKv2yVJkiRduD4PGkKIVsDjjG3vnvL1m8Cbfd0OSZIk6eeTM8IlSZKkXpNBQ5IkSeo1GTQkSZKkXpNBQ5IkSeo1GTQkSZKkXpNBQ5IkSeo1GTQkSZKkXpNBQ5IkSeo1GTQkSZKkXpNBQ5IkSeq1Pi8jIklSdyazhR3HKiisbiHQw4EJA/zRaeWvo/TrJ580JOkSq9e384clO9mSXo6jTsPe7GrueG8HlY2tv3TTJOm85EcbSbrEPtqSxfBIH26fEnNi2xc7c1jy/TH+dnVit/3bTWbq9EY8nHToNOpL2VRJ6kYGDUm6xPZkVfHeneNO2zZvWChXvfw9FqtArVIAsArBp9uyWZ1chKPOBoPRzLxhoSwa25+uJWgk6ZKTQUOSLjG1SsFssZ62zWy1olIpnBoLvt6bT2phHe/eORYvZzuqm9r4+9eHcNTZMG9Y6CVutSR1kmMaknSJjR/gxxe7cvhxrTEhBEt35TIm2hfVKVFj1YFC7psVh5ezHQDeLnb8cWYc3x4o7PW1LFYreZXNcrxEumjkk4YkXWI3T4jisaUH+MN/djEwxJ3M0kY6LFaeXzTsxD5CCOpa2gn2cjzt2BBPR2qb23t1nd3HK3l7QwZ2WjUt7R0Eezryl3kJJ4KQJP0UMmhI0iXmoNPw6s2jSC2oo7C6maFhXgwN9zoxlgGgKAqR/q7sz65mVLTvie37squJDnA97zUKqpp5/bs0nr4mkZhAN8wWK8t25/H08kO8sXi0HBORfjIZNCTpF6BSFIaEeTIkzPOc+9w0MZKXvk2lwWAkNtCN9JJ6Pt2ew+NXDjnv+TekljA3qR8xgW4A2KhVXDe2P1vSysgqb+pV4JGks+nzoKEoSiHQAlgAsxAi8YzXFeB1YBbQCtwshDjc1+2SpF+7oWFePHl1Il/vzefbA4WEeDnyzMKkXr3h1+uNRPmfvp+iKPi529OgN/ZVk6X/AZfqSWOiEKL2HK/NBCK6/gwH3un6W5J+N4QQtJrM6DRq1Kre55/EBrrxt6uGXvD14oLc2JVZwaT4gBPbGg1GMksb+L/LBl7w+STpR7+G7qnLgU9EZyrJPkVRXBVF8RNCVPzSDZOki2FfdhUfbD5OdVMbNmqFmYODuWliFBp13yUvTh0UxPqUEl76NpVpCYE0Gkws3ZnLZYn9cHfU9dl1pd8/5ce0vz67gKIUAA2AAN4TQiw54/W1wAtCiF1d328GHhZCJJ+x3x3AHQDBwcFDi4qK+rTdknQxpBfX8cwn+7g5MRBvFRQVVLNudw46s4Vodzva9O20txoxthoxtXdgtVg7/1gFarUKtUaNjUaNVqfFzkmHnYMOe2d7XDydcPZ0xtXLGXc/V7yCPHH1cj5tgFvf3sG3Bwo5lFeDg86GaYOCGBvjKwfB/4cpinLozCGCC3UpnjRGCyHKFUXxBjYpinJcCLHjlNfP9hPcLZJ1BZslAImJiX0b6STpArW2tFGSVU5xZimF6SWU51VSnldJUXYFljYT/zrzAAXKXR1wdLFHa6fF1t4WrU6DSq3CRqNGUamwWqx0GDto17djbGvoDDD6dgxNrXSYzN3aoLHV4BPiSWCkP4GR/gRF+TMkLoj5VyTg4Gzf5/egqdWEjVrBwVbT59eSfjl9HjSEEOVdf1crirISGAacGjRKgaBTvg8Eyvu6XZL0U7U06Dm2N5vs5DzyjhSSl1pIZUH1iddtNGr8wn3xD/eh3sOViWMiiY0JwMPfHTdfVyy2Wh5bkcKDlw9icKjXBV9fCEG7oZ21O7JZujEdZ7OZpsoGbFvb8bNVUZlfyaFNR+kwdpw4xivIg/BB/YhK6k/08AiiksJxcnPs4Sq9l1PRxFvr0ymq1SOEIKGfJ/fOisPDSXaD/R71adBQFMUBUAkhWrq+ngY8c8Zuq4E/KoryJZ0D4E1yPEP6NdE3GkjZks7hTUdI332cwvQSoDMbKSDCl6ikcGYunkxwTABB0QEE9PfFRtP5q/XK6iO4uzswYUx/zBYrb65PZ/uxCowdFv7x9WFGRvpy3+w4tDa9L0SoKApFTe2szK7h1cfm0s/bCYtVsHxPHnuOV7Jk8WisVivVRbUUZpRQmF5CYUYxOYcL2Lf20IlzhCf0Y/CkOAZPjid+XCw6e9sLvjcNeiOPLz3AbZNjmBQfQIfZwpe783h86UHeun3MaTPcpd+HPh3TUBQlDFjZ9a0N8IUQ4llFUe4CEEK825Vy+yYwg86U21vOHM84U2JiokhO7nEX6Tek1WhmY2oJGSUNeDjZMnNwMP28nX6x9litVrKT89i35hAHN6aSezgfq1Vg72THgNFRDBgVzYDRUUQlhWPn2PPs6qKaFh76ZB/Xj4ugsrGNtKJaOiyCcbF+LBgeynMrUujn5cStk6MvqI3/WnuUQA8HrhoZfrLdQnDrW9t47IohRPi5nPU4Q5OBrOR8MnYfJ3VrOpl7s+kwmdHYahg4PpZhMwYzfM4QAvr79aody/fkUVZv4IE5JzOyhBDc859d3D41hsGh556HIl16F2NMo88HwvuCDBq/H81tJh78715CvBwZHe1LWZ2B1clF3D8nnlFRvuc/wUVisVhI25HJ1qW72LsmmYaqJlQqhZiRkQyeFM/QqQOJHh5x4gniQuRVNvHZjhz2ZlcR4O7AlSPDmJEQhKIolNcb+NOHu/nqz9Mu6JxPLUtmUnwA42JPf3P/y6f7uGZUOEPDe9ft1d5qJH3XcQ6uT+HghhRKsjp7hiOGhjFx4RjGXz0S76Bzv/G/sS6NYE9HLj+jgOLLq44QH+LO9ISgcxwp/RJ+KwPhknROK/cVEB3gyoNzB53YlhDqyQsrUxge4X1Bcxp+irwjhXz/321s/2oPdeUN6BxsGT57CCPmJDJs5mCcPX7+E0+4rwtPXp3I3OfX8+/Fo08bKPZ01qFv78AqxAV15QwMcWd7Rvlp2VDVTW3kVTYR6d/72d46e1sSpw0icdog7v7XzVTkV7Fr5QG2LdvNkoc+4T9/+ZSESXHMuHUSo+clYWt3ehdWfz8X9hyvPC1odFispBTWMn94v163Q/rtkEFD+kUdLqjltjO6ZuKC3dHYqCipNfRJN5WhuZWtS3ez/oPNZCfnodHakDRzMJOuHcPwOUN/Ut9+bwzs58HW9HLmDA05sW1bRjnxIR4X3Pc/Y3Aw3x8p5YWVqUyOD6Be386Xu/NYOKY/TnY/PXvJL8yHqx68jKsevIyy3Aq2fL6L7z/eyvOLXsfR1YFpN01g3n0z8Qv1AWBiXAAr9hXwxro0LkvsR5vJzGc7cogJcCXc9+xdZNJvm+yekn5Rj3y+n1mDgxl7SjdLh8XKotc28+ZtY/B2uXgVWSvyq/j2jfVs+HALrS1thMYHM3PxZCYvGntRnih6IoTgaG4NT3+2l6FBbng7aMgraSC9sJaxUT442KgwmswIq0AAVqvAxkaFVmuDVmuDTqfByVGHo6MOZ2cd7u6O2Dvp2J1by+HCWpx0WmYMDiKxl91SF8JqtXJkWwbrP9jMjq/2IaxWRi8YztV/nkv0sAiaWk0s3ZXLvuwqbG3UTIr3Z8GIsD6dvCj9NHJMQ/rN25pexrLdebx4wwhc7LVYheCz7TlklNbz4vUjLso1clMK+PzZb9i98gAqtYrxV49k3r2ziB528VfAM5nM5OVVU1hUQ1FxHcXFdZSXN1Jd00x7e8dZj1GrVeh0GmxtbVAUpXMxJhTMFgsmk5mODgtGY/d5GQA2Nip8vF0IDHQnMNCN4CAPIiJ8CQv1Qqu9+B0JtWV1fPvGeta+twlDUyvDZw/h5r8vpH+CXBTqt0AGDek3TwjBR1uz+O5QETGBbpTXt+Kgs+GpqxN/dp5/bmoBnz79FXtWHcTBxZ7L7p7O5fdMxzPA46K1vaKyifT0EtLSS8nKqqCgsBZL16p8Go2aoEB3AgLc8PFxwdvbGW8vJ9zcHHBxtsfZ2Q5HR1tsepFua7FY0RuM6FvaaW5uo7auhdpaPTW1LVRUNFJaWk9pWf2J4KJSKfTr58mA2EDi4wKJjw/Ex/vidRe1trSx6s0NLP/nKvSNBsZdNZJbn72211lX0i9DBg3pd6Ne305WWRPuTrZE+rn8rCeA6pJaPnz0CzZ/vhNHVwcW3D+b+ffNwtHV4We3s6m5jeTkfPYfyCclpYi6ej0Ajo62REX6ERXpR2SkL+Hh3vj6uKC+hF00VqugqqqJnNwqcnKryM6uIONYGa2tJgD8fF0YNiyc4cPCSRgUjE7382du6xsNfP3qGla89h1mk5krH7yMax9dgJ2DnNj3aySDhiSdos3QzrIXvuWrV1YDcMUDc7j6oct/drCorW1h+47jbN+RxbHMMqxWgYuLHUOHhBIfH8jAuCBCQjxRqS7+RDYhBMdKG8gqb8LbWcfwSJ8LGiuwWKwUFNRwNL2EQ4cKSUktor29A1tbG0YM78/ECTGMGB7+s7uy6ioaeP+vn/HDpzvwCvTgrldvYtyVI3/WOaWLTwYNSepycEMKr921hOriWiZeO5rbnl+Ed/BPHxRuazOxbXsmG79PJy29BCEgLMyLMaMiGT48nKhIvz4JEqcymTtnjZfWGRga7klhdQs1ze08v2g4fm7nriVV19LOd4eKKaxuJsDDkdlDg/F17dzfZDJz5GgJu/dks2VbJvqWdtQaNXFDQ7nzxtFER/y87qX03cd5894PyEstZOK1o7n3zdsuWrkS6eeTQUP6n9dU28w7D/yXzZ/vJDgmgAeW3EXc6AubXX2qgoIaVq9J4YfNGRhajQQFuTN5YiwTxscQHPzTx0KEEORVNVDR2IzBZKSmxUBtSytNbe20GjswmEwYO8xYheDHX8n6FiNtJgtDw7xxttPh6WRPYZWB8vp2nrxyBP5uzt3Kj5TU6vnLp/sYHe3LoBAPjpc3sulIKc9eN+y0WeLL9+Sx5mAhSV725KeVkJZSiLBYiY31Z/7liUwYH/2Tu9YsZgtfvvAtnzy9HA8/N/7y8R9JmBj3k++ddPHIoCH9Tzu4IYWXbn4LfYOehX+dz7WPLkD7EyqsCiFIPVLMl8v2cTC5AI1Gzfhx0cyZnUB8XOAFj680GNo4VlZNZkU1x8trOFZWTUl9E1ZhPW0/G7UKFzsd9loNDrZadJrO7KkfL5dd3oiLgwaL1UpzWzutptOzr1SKgp+rE+HeHkT7exHt58WWIzUMDfPh6lH9T+y3MbWEzWllvHRDZzZao8HI4re38d6d4/F07hx7aGxq5b4XvsNQWE1DbQt+fq5cf91Ipk6J69VA/dkcP5DDCze8QXluJTc9cw3XPbpAlmX/hcmgIf3PMZkt7EwrY/WLKzm2fBchA4J47Is/ERofcv6DzyCE4GByAf/9ZCfHj1fg5mrP/HmJXHbZYFycez8/pMHQxt7cYpILSjlYUEp+df2J13xdnDC0wZB+voyOCiDAzYW0wiYO5NTxwd0T0WrO/YZ8x7vbeXDuoBPLthqMJnYdL+OVNSnMTgpApbJQXNdIblUdedV1WKydv8s+zo4MDw9iWFgQYyJDcHWwZ+7zG1jzyAxs1Cp2ZVbw/ZFSnlmYdNr1NqQUc6SwjjE+Dnz62R6ycyrx9XXh1pvHMWli7E/qjmsztPPane+x5YtdjL1yBA99+Ifz1uuS+o4sIyL9T2nQG/m/NzfT8MEGDHkVeE0ehHnWcBxDvC/4XFlZFby7ZAtHjpbg6+vC/fdNZ/q0OGx7+aRSXNfIDxm5bM3MI7WoAqsQONhqGRLiz+VDYhkY5EuUnxfb0ivJLG3gr/MHnzh2Qgw8WL2X5PyaHutrjYryZeX+Ah6el0CDwcgTSw/SaDDhonPkQKae2CA3nrtqBhq1CmOHmdzqOh78ZDshPlp2ZReyOiUTgFh/b1otUN7YTLCHK452Gupa2mluM6HTqE90cdXrjTjZaRk9KpJRIyPYfyCfD/+7g+deWMOKb5O5/77pREZcWD0wOwcdf/30PvoPDuP9hz+lLKeC59Y9hoef2wWdR/r1kE8a0m/Gk69tJOW55YhWI3/+8A+Mv3oUH2/NoryhlUcWDD7/CYDGxlbe+89WNn6fhqurPTdeP5rZsxLQ9PCJ/0dNbe1sPJrNqpRjpBZ1Vu+P8fdmfHQo46PDiPX3xuaMcYD//JCJs52Ga0b3P237m+vTCfRwYN6wc0+KMxg7ePTzA6hVCi1tnV1TLW0mnr1uGEGejjy1/BCDQjy4ZvTJSrefbc8ms6yRx68cQnFdA5uP5bF0Tzr1rS0ADA8PYnBQMOuSq7FR1KhVChPjA5g9JIgnvkzm7wuT6H/K2IfVKtj0QzpL3t9GU1Mr8+cNZfEt439Suu7Bjak8c+XLuPu68uKmv+Hb78KDvfTzyO4p6X/G/nWHeXz+P/HwceEfqx8+MQNZ397Bwld/YPUjM3qs3yRE55vf2+9sxtBq4qorklh03SgcHM5fZyqnspaPdx3muyPHMZkthHu7c/mQWGYOisLf1bnHY7dnlLMmuYh/3jgCRVEwWsyUG5r4v6U7mZrkh72jCn2HEb3ZSLv55JiFoijY22hxUGupqG1jW0oVCxIimT8oghDXznksx0obeH1tGu/dNe7EcR0WK6+tPcrB3Boi/FzIr2omJsCVGyaGszEtm+X7j1LVrMdOq8Fd546vozftJoHB2MF9s+LPWpV29/FKVuzOIW9/Ls0FVfj4uvDU4/OIirrwTKvM/Tk8NutZbO1teWXb0/iHX7pKxpIMGr90M6RLZOc3+3j22tcQPm78Y81f8fBzI9DDAa2NmuZWE4te38zqv8445yBrY2MrL7+6jj17c4kbEMgD908ntN/503GTC0p5b+sB9uQUYaexYe6QWK5MiiPG37tXA7qNxjb2Vxfz6tYDWOyMmGzbqWhrxtp9NWNs1TbYqTUodK51bBWCNouJDqv1rPtGOHsSqHMnO6eNRyePoLZSoFZUjIrywdfVnsqGVopqWwhwdyDQ42TK62trj9JmNlCpr+WHjFx0NjZMiI4gv8zKu3dMwMf19FTe1QcLWXmggFsnRRPk4cjXG9PYsHwfSoeZP9w1mXmXD7ngwe38o0U8NPlpHF3teW33s7j1MFNdCEFJrR6T2UqojzPqPk5z/r2TQUP63duydBcv3vgGEUn9abx8DI0W8HHRoTeauWViFMW1ehoNJv4yL+Gsx6ceKeLZ59bQ3NLG4lvGccWCpPOmkmaWV/Pqhl3sySnCw9Ge60cN5urhA3G173mWs9FiZl91EVvKc9hfXUxOcw0AKhTc1A6oWm1xFPYk+PoyOy6MYCdX3G3tcbCxRavu3j0mhMBoMdPSYeQvy3YTH+GMp7cNJfpGjjdVk1JdTpvonO2txQZ/tTsdtbbclpDIjSNiz9rGRz7fz4LhoST19ya3qpb3th5gw9FsVIqKa4YN4qE5Y9B0tcVktnD961t45aaRBHmeDDzvb0hn84oDVBVUM21qHA8+MLNX3XunOrIrk0en/4OQAUG8svWps84gL67V8+LKFJrbOtBp1LR3WLh/dnyv1wqRupNBQ/pdO7A+hSfmvkDcmGjsbp6Om5s9+VUtqFUqgj0d2JpRjqeTjtdvHY3rGd1MQghWr0nhjbc2ERDgxhOPXk7//j49Xq/R0MarG3ax4lA6LnY6bp8wjIUjBqHrYeEls9XKjso8VhamsaMiD73ZhL2NhkTPIJK8gkn0DGKgux86m59XsiO7vJEnvjzIqChfwnycSc6robCmmXqTgWtmBpJlqGRfdRH5LXUAxDj5EmMbyDDnMKbEBOPm2Hl/lnx/jOJaPd6udrg52DJ1UCCVTc3c8cEaDB16In09eXr+FAYG+1Fc08JTyw/x4T0TTmtLTkUTr64+wgh7FR9/sothSWE89bf5vRrnEEKwfE8+X+/NQ5VTRv376wieMJD3vn8Um1MCp9liZfHb27h6VDgzhwSjUhRSC2t59uvDvHnbmG5PRFLvyOwp6Xfr+IEc/n7VK4QNDOHeT/7EQ8uS+XzRcNQqFQdzqymu1TMjIZhGg7FbwLBYrLz59g+sWn2YEcPDeeyRuT2OXQgh+C71OC98t52WNiM3jRnKXZOG46Q79zFlhia+zE/hm4IjVLXpcbe1Z3ZwLFMDohjl0w9b9cX91Yr0d+WdO8byfWop+VXNDI/wJjrAlZrmNq6PiT+xX0FLHX9ctZH8ugoytZWsqj3MS0fduW/QaK4aFENacT35Vc0MDfeiw2Ll7iU7cXe05fZxYwj31/KPVVtY9O4y7pg4jEWjhtBoMGJo78DhlIBQWN2Ct4sdNy1MwtPDiVdfW8/Djy7jub9fdd4xog2pJWxNL+Pfi8fg52bPB34OfPnMVzzxp094/s1bTuyXnFeDh5OO2aesPZLQz5OJcQFsOlrG9eMiLuLdlS5EnwUNRVGCgE8AX8AKLBFCvH7GPhOAVUBB16YVQohn+qpN0m9DXUUDf7v8Rdx8XXlu3aPUWMDL2e5EauiISB9GRPqQWljLJ9uySS2sZXtGBWaLlRER3mxZeYCtWzO5+qph3L54QrfuqAa9kSNFdTjY2hDu68Q/Vm9mY1oOA4N8eWr+FKL8zt39sT4znzfSdpFtLQUFxviE8uSQ6Uzyj0Cj6n0XTau5hTpTJXpzI+0WPW0WA0ZLOypFQUGFSlGhUzviaOOCo40Lrhov3BxcWDjmZBbWV3vzug3+q9u1qErceGj4EEYOcePTnEOsLEzjqbxVLC09SLRTGO/OG8fSXbkczqvFxV5Lo8HEzROj0KhVDAsL5Pm123h3y36OFFeQ1D+Ef61N475ZcTjba8mpaOLjbVk8cFnnmuCzZw3C3l7Lcy+s4YmnvuGFZ6/usY7VqgOF/GHGgBNlUG7525VkH8wl+b0N5N81mbC4YKBzAqLvWZ4m/NzsKas39Po+SxdfXz5pmIEHhRCHFUVxAg4pirJJCHHsjP12CiHm9GE7pN+QDlMHz1z5Mm0t7by46W+4+bhiZzJT3dxGWZ2BAI+TxQd3H6/EahW8tjaNuYkhqICXXlpLS2kdty0ez3ULuxfM+2pvHl/uymVgiAel9Y0kl2ZhER3cP300t45LPOfystVtLfxp83cc1OejVilM8YrBpc4LfY4gPMqP7LImwn2c0Z3xhimEoN5USUlrNsWt2ZS15lJnqqDNor/ge2OndsRHF4y3LogQ+2gG9g/jiU/yuWZ0OF5dkxE3pJYAMC0hiABXB55NmsVDAydyx5o1pLblkauqwL3ExL2zxuCi7Tzmtre3UVzTQrivC446W569cjqJoYE8vXIzJfVNjAyJ4aY3t2JvawMCbp4YxdCwk4F14oQYzGYLz7+4lhf/+R2PPTL3nBMBa1vaCT5lfESlUvHXj+7h6tB7eP3uJfxr+zOoVCrigt35aGsWrUZz53XpTA7YmVnB3KR+F3zvpIunz4KGEKICqOj6ukVRlEwgADgzaEjSCR8+upRje7N5fNn/Edr1qVOnteGG8ZE8tvQA14+LwM/Nnp2ZlezKrKTDYuXDP0zAyU7DP19ZR0tpHW4DgokfGdnt3GnF9aw+WMR7d44ns6KCBz7fi51Wg699MIODQnn2mxTq9e3EBrqxYHgYns46hBB8VXCEZ1M2YejoYEHIQB4YNA4/e2dqm9u4a8lO/vLpPgI8HKhoaOWWiVHMHBJEaWsOGU17SW/aR2NHNQBalY4Au/7Eu47GQ+uHh9YXJ407dmpH7NQOaFU6BAKBFauw0GYxoDc3ou9opKGjhur2EqrbSzhE7a3HAAAgAElEQVTSsJMDdRsBiJ/syxObDzDAaTw2FjfWHy4mNtCNAPeTwdXV1o7h2ih0tW7YhDXycc5BVhdl8MqIuYz2CaWtw9KthtX8oQMI9XTjvs/W8EP2Ed65aT5eTk54OevOGlinTomjrk7Pkve30S/Ek+sXjeKHo2WsTi6kvsVITKAri8ZGEB3gyr7sKmYMDj5xbH6LCa8rx3Ds0818//F2ZtwykUAPR8bG+PGXT/dx1cgw7G1tWJtchKIojImWabq/pEsyEK4oSj9gBxAnhGg+ZfsE4BugFCgH/iyEyDjHOe4A7gAIDg4eWlRU1LeNli65jD1ZPDD2CWbfMYU/vXNHt9cP5FTz3aEi6g1G4oPdcdRpqGpq44E5A/ns8z18+N8d3HjDaNQhPnSYrdx6xtrjr609SqCHI7Y6I499vZEoXy/evnkeD360n/YOM7dOisZWY8P6lGLyKpt5eGEcb+VtY1dVAbGOfgTV9+PtGyadON+DH+/FxV6LsFp58poksqvLeX3PZ/iH59Aq6hBWFc01/tDSn2n9RzInfggq5exdWNszyll1sJC6lnaiA9y4dkz/c66PbhUWKtoKydenkd1ymHxDBiBwMIcRbjuW1T/Y8fbtE3Cx1wJQ3dTG3Ut2csO4CDYdLeXWuaE8dngduc01THWLQ1XszpuLx5w1dbaotoEblyxHpSh8cufVBLm7nvP/TwjBcy+sYeu2TObeOpGMhnbumBpDoIcDu7Oq+HJXLvfMiOWtDcdYOKY/g/t5kF3RxH+3ZnHfrDi+uPnf1JTU8lHWv7HRadmfXcW+7GrKGwyoVQojIn2YMzQE2wvM1JJO+k1kTymK4ghsB54VQqw44zVnwCqE0CuKMgt4XQhx3hEumT31+2PuMHPHwAcxtXew5Ogr2Dudvz7RpiOl7M2qZFKAM397agVTJg/gkYfn8PbGDNwddVw75vRZ2C+sTMGiGFh64CBJoUG8ccNl2Go0zHthA3dMjaGptYO1h4oYHuHNzooCMpyOo9WoeGzwZIbYhfHSt0f44A/jURSF4lo9j3y2n7nDQihtqiAsPo2Uhm1YhBlzUxBt1bHcOWIusf6+ZJQ08NKqVG6bHMO42O4T4lYdLGT1gUJumxJDsJcje7OqWL4nj5dvHEGw1/nXLm801ZLSsJXD9Vup76jExuJGeWYSI3zHY7EIfjhaxqKx/Zmb1I+3N2awPaOCfr4O7LMeo0xbRZJ7MB9MuAYHjfas58+prOWmJV/hpNOy7I+Lekw91uvbWXzHh9QZjHy4ZDHBPicnP36xM4eqxjbmJoWwfE8++VXNBLg7cMWIUOJDPMjYk8X9Yx5nwaNXsNfHGx8XOwI9HDmYW018sDt/vnzQObsPpd65GEGjT/8HFEXR0Pkk8fmZAQNACNEshNB3fb0O0CiK4tmXbZJ+nb5b8gMlWeXc8+9bexUwAEZF+XAkp4oXX/6OiAgf/vx/MymobmFbejkT4/y77e/iKFi6PxkXWycqKm2594M9vPt9BhYh8HG1Z0t6GUvuGkf4QBWZbpnohJb+5TFc2S+BKH9X7LRqvt6bj1UImlpNONkrbKv6mqaAt0ht2M5Qt8lM0D5Bxs4Z3DdqIQMC/FAUhbhgd+6dGcfyPXnd2mQyW/h8Rw5PXpPIyCgfAtwduHJkGFeMCGX5nvxe3Ye0vA6+WOHN1pVzqEiZhQ06vOO+p9xlCSq7Ol6+cQSXDwtFURRCvZ0xW6xU1bfjUxXMIGMkhxtKWLzzS1rNprOeP8LXk3dvnkdls57Hvt5ITx80HR113HjbBKytRnZtOb3TYGi4F7mVTYT7uvDIgsH85+7xPHVNIvEhnSXnB4yKImlGAqvf2sCCxGD+eeNI/jQ7ng/vmUB1czvrU0p6dT+kvtWX2VMK8AGQKYR49Rz7+AJVQgihKMowOoNYXV+1Sfr5zBYrRrMFe63NRStzbWgy8MlTyxk4PpYRc4b2+jgHnQb/hiYyWk1oYoJ46qtDZJU3ce+suG6ZNwU19Xywaw82Kg393fsxf3g4BdUtrDtUgkpR2JNVyZyhIXxdksLzRzYTZe9LvDUGi6tCSkEtwyN8eOKqoTz7zWHWJBfh5l2FQ/wGdA4tRLuMYKbfzbhpvXl+RQoWq5Vw385P2K1GMwdzq9G3mSip1VNWb8DfzR6wgDmH5sZsZsccJtA2A2tzC6AFxZbJ4bCywYTo0IBNOIpy9lTW5Lwa3t14jKtGhXGspIHSOicytgaTlFSB0X0rxdo3KFduIZiZpBXX8/nOHF6/dTRBno5YrIKlu3JRF9pwqDaTO3Z+xUfjF541C2xgsB8PzRzH82u38cXeIywadfbJlADjRkbwby8XPvtiD9OnxePRNSM9r7L5rBlRpxp/yyQObkjFsaACRnY+KWpt1FwzKpzle/KYM/TCqxlLF1dfZk+NBm4A0hRFSe3a9igQDCCEeBe4ErhbURQz0AYsFL/F2Yb/A0xmCx9tzWJjSglmq8DfzZ7Fk6NJ6v/zi86tfvt7mutauPPlG7sFonaTmeS8GsxWwZAwT5ztTnah7D+QR8aRYm5bPJ7woWFYrILH+3meyLb5UYfFwsPL1mO2CB6fMw1vFycO5dVgb2vDowsG8+K3qaQX1VNnV8uXxfuY6BOBKd2DBdPDWXWwCIul80fS19Wef986mvVFq9jT/A1aqzslqZMYOWACuR2wNT2V3IpGvF3sOFbagKHdzEurUgn2dCCnookglxJ2HlzLIP8iIryKUdGGO3DDEBAGhc6eXDOIdtwRLE4EUfc+oELYRIDtJBTbSaCJR1E6Owm+2pvH2Bhflu3O47qx/bksMYQt6eWs39bB67c/y/62j1lT/h/qTZWkHU7g6pFhJ2Z3q1UK147pz8bUEv48fgovHd/Eq2nbeXjQJM5m0agEtmcV8Pr3uwl09STK3/2sQcDJTsP42YP54b/b+PLrA/zhjokcKarj0+3ZPHrFkB5/FmImDEDl6sj2L3cz5bqxJ7ZrNSrMlu4lVaRLry+zp3YBPX4UFUK8CbzZV22QLp63NmTQaDCx5K7xeDjZkpxXw8urj/DMwqQT6z38FMY2Iyte/46kGQlEDg0/7bXkvBpeXJlChJ8LGhs1b6xL485psUwbFERHh4W33tlMYKA7V10xrMcyFu9u2U9GWTUhLsGMiw3C28XutLGF1747Spu9ni9r03Azu9CQ7MxN48PxcbEnq6yRx67orKBrFVbWlr/P/uYNRDklcnXw/Rx3aWXd4WKa2zoYGOLO3dMHsC+7ihdXptLcZuLReaFk573Hn0YcIMi1GotVRUF9AOuOJTJl6Bzs7KP4cFsdJfUa7pudgLujjuNl9byw4gAPzXEj1rcOYc6BjmQwLEEY3gGVN8LuWg5VzuF4aSOZpQ3cOD6SOUNDUBSF+BAPtqSVsWJPNQ/Pf5h15f9ld+0a8MjB0/mPp90btUrBy1nHCJdwrg2vZcnxvQz3DmaC3+njQQAWq8Df0Zc9xiJeXLsTR7Ung0M9eXDuwG7ZVw8tHMaxXcdZseowP9QbcXe2448z4xgQ5MZ3h4r44WgZxg4LSf29uHJkOE52nZMHgzydcEgII/n7I7Tp27BztMMqBKsPFDIyqucZ/dKlIWeES+fVaDCyK7OCT+6ddGJmcFJ/b64d059v9xfw8PzelSU/m10rDtBY3cRVf5572nZDewcvrEzh6WsSGRDkDnQuZfrgx3sZEOhOxuECSkvr+fvTV/QYMMobmvlgezJzEqLB5Maxkga8XU6OmRRWt6DWCIo9C3BpsyeyIZLpiSGU1Rv4bEcO98wYgIOtBiFEZ8Co28BYr3lM812ESlGTEGpPQujpw3BTBwVyvKwOVfsKIm0fIXGIgaKmaHC6h8/3haKo3Fh7uIj0Bk8evSKWGyZa+GDzcW57ezsaGxW2NmpunhjPgNAA4OQnL2FtBOMORPsaMLxOP/WnTIu+kg3HYlmfUkJti5G7psVSWN2CVqMmu7wRlaJmTsBinDVubOQzNpV/zejo+060taKhlaIaPRF+LjweOJXkmlKePrSR0bNCu3VTLd+Th9Gk5vIhsWw4msXGh+byzsbjfLQ1izunnl7rSqNW8adbx/Hwo8u5Z0Q/Jk+IRlEUXv8ujYLqZhaNjcBRp2Hd4WIe+mQvr906Gp1GjaIoXH/7JN7ZdpRnXlnP4KmD2JNViUpRuFzOz/hVkEFDOq+a5na8XexPKyUBEOHnwraM8p917s2f78A72JNBEwactn1PVhUDg91PBAyAIE9HJscHsCW9jJ0rDhIS7MGokd0/Ef/IYrXy6PIfsFitKGZnogPdePf7DHRaNYldg7KvrU1DE9FEtUHP8sk3otLbcTC3Gmc7La/dMgr/rvkOu2pXnQgYM/xuPO06HRZrZyZXdhUalcKsQe1cN+CfuNlmUtUay2MrZ/PK4ltQaW1Q22TTYbYyJNyLI4Wdw3daGzV3Tx/ArZOi0bd34Opge9ZqrorKFezmkt0wjq+2LeOvU9dy94glDPKNo155mi/2lBPi6ciK/QWMjvKhpO7kzOmxXvMpMRSQIbbzj3UhTI0YQU1zO8t353Hj+IgTXXoPD5rIbTuX81X+Ea7rf3pX0oaUEp66JhGjpZ1Vh4/xfXo2d02L5a73dnDHlJhuXYsJCSE42NuSmlLIlIkxlNUb2H28ko/vnYhd1yTI6ABX/rYsmS1pZcwa0jl3Y/rswbyrKIjSGhoMRq4YEcbISJ9ua5VIvwz5vyCdl7+7PdVNrdS1tJ+2PSW/llDvnteT6ImhycChTUeZuHA0qjNSKY1mC/ZnKYDnoNNQUVJHbm4V8+clnnMwXgjBY0v3cbCwiAlREUyJD+FgbjXhvi58viOHy57fwIvfpjI03oV9+lxuiRjGYM9ABvXz4LYpMSwaF3EiYFS2FbKx4jPiXEYxzff6065jsQqeXp7Mtoxypg0MZHpcAwMc7sZWVcZbu28gpeE18uv8UasVWo1mNqeVkdjfk6zSRs6MC7YaNR5OuvOW/07OrcHXexxqz5UoTg8zPDiTUNtHaG1v45Pt2UxPCORYaQOzh5ycQKcoClcE342b1hvht5FvDxSQVlTP/XPiufyUhaAm+PUnwd2fD7P3d8uSamnrwNNJR4y/N9F+Xqw/mo27oy1tJsuJpWZPpdGoGTIkhMMphQBklTWS0M/jRMD4sV0jI33ILG04sc3B2Z6gaH+0NY3cOTWWsTF+MmD8isj/Cem8HGw1XJ4UypPLkjlaVEdtczsr9xewOrmIK0eE/eTzHt2RidViJWlG9+6txDAv9mdXUa8/GajaTWY2p5VirW1CpVIYPz6623E/Simo40hpZ4pmfaMNb2/IwNXBltyKJh64bCDrH5/FR/dMJEddjJ1aw92xo856ns5uqQ+wUztwecCdqJTTf2UO5lbToDfy/KJhjInQk+TxGBqtN39e+1e0Tgv4bEcuapWKG/+9ldvf2U6wpwNLd+VhFeInz2y2s7Whuc2EotigOCxGOP2DAb7Z3D3qK1QKLN2Vx+T4gG5pxzq1PVN8r6FdXcn0MSZa2kw89sVBrnr5e97/IROT2YKiKMzvF09BSz05zbWnHZ8Q6sHmtDIARkWEkFZaycbUYgYEuZ3zTT0q0o/KyiYMBiOezjqKa/XdglFJrR5P59PnfgRF+VOeW/mT7o/Ut2TQkHrlhvERzBgcxNsbMrjn/Z2kF9fz4vXDT6sFdaHSdhxDY6shZkT3+Zy+bvYsGBHGfR/s5oudOXyzL597P9jNoBAP8o+XEx8XiIvzuedzpBbW0tDWiIvOkcevGMZHf5zIyCgfWk1mtnZ1qTWZ2lhdnM6VoQNxsz17KmiuPpUCQwZTfa/D3qb7RLsjhXWMH+CPSjEjGu8GRYva/SMiAyMI8HDsnH8R6U1Tqwljh4XiWgMNeiM2KoVrx/y0Sq3jY/3Yk1VFVnkjAFqnK6i13sL0qH08M7+JT++bxDWj+5/1KWyg6xgc1R58m7uCMTF+fPvwdP69eAxl9QZeWX0UgGmBUQBsLc857dibJkTx5e5c3tt0DEetA2aLlbc3pXLblHMH79DQzhpVRUW1xAV3djV+sTMXk9mCEIL9OVVsTivrtmKgf7gv5XlVP+n+SH1LjmlIvaIoCnOGhlzUPPnCjBL6DQhEqzv7TORrx/QnoZ8H2zLKMVus3DUtlrhAV2a/sZ5rz1KM8FRCWGkxtjIlJpot6WV4OumYMjCQlfsKON7VFbK3qogOq5U5wQPOeZ7Uhh3o1A4McZvUdV5Bcl5NV5sEViEwma3QugwsxShu/0GxCaamuYKkcC1R/q48duVQqpva2JhaQlVTG5F+LkwZGNgtNbi3PJx0PHjZIB7/4gBhPs5YhaC4dgj/XbiOUKfVqGyvOOexasUGRR+Gk0caMwcFoSgKfm72PLJgMNe/voWKhlb83Jzw1jmeWJvjR/28nXhj8RjWJBeRVtxZDWjhmFCiA9zO3Vb3zvTehsZWVIrC369N4tU1R1nxrwJ0GjV2WjWPXjG4W+qug6sDHcYOOkwdaLQ/by0S6eKSQUP6xRQdKyV+bEyP+8QEuhETePJNKSurAqtVEHGe+SEWOru1qhusTIhyoLhWz21vb0cgcNB1/tjvqSrA0UbLII/us8cBLMJCZvMB4lxGYaPqfOP6cEsWe7IqmTesH1obNd/uL6Skrpw7Br+NRjsMoRnL9vRyimpaGB55so3eLnbcML57EcWfamSUD5+GTiK1sA5F6VxrQmvMRujfQFhqUNTnLu9uaPTC6tdOvakSD9vO1GOtjZpwX2dK6/T4udkT7OhGsb4RIQTHShuoaWonwt+FAHcHFk+OpqU9lE1Pp2C2dpzzOgCOTp3dTi0tbUBnifvnFw2nXt+OscOKr6vdWZ+IflzJr91glEHjV0YGDekXIYSgvqIBr0CPCzquuqbzE66fX89zQ9JKO/vj203ww9FSzBaBVqPCYhUn1swuNjQS5uxxznUwWjrqMVrbCLLvfLMvqzOwMbWED7qq6gJMjPPnoY9WoFHq+PLQLLbk7kAIeOaapG5zF6Bz4Ly51YSjnQbNzxzc1WltGBF5cu6CMHcNaIsm4NxBw8vehSrAZDVxMLeaQ/m12NqoyC5vOjHxT6tWYzCZuPeD3Rg7LIR4OfL2xgxGR/vyx5lxJ9KAz1cVwNo1Ie/MNU3cHXteOrfDZAZAYysDxq+NDBrSL6K1pQ1zhwVnj/MX5DtVU1PnJ1ZXl57LUeRXdnZB9fN0wcvZHgWBr5s3y/bknZjYV9OmJ9DB5dzX6ujsnikoE5TnF9LcamJEpPeJgAGdn9AvG9z5xjkyNonEuAT6+7l0WxwJYN3hYj7fkUOHxYoQgssS+7FoXMR5s6V6UtnQSkt7B/28nbDhxwHmns+XEObKxjp49qsjmFpdSAz3YltGOcYOC8dKGvB1tafN3EFVfTujvZ3oMFspb2hlRIQ32eWNrDtczIjIzmBv18OCSwCtbZ31rOzszt4FeS6GJgMqtQrbCzyuJ1YhyChpoNFgJCbArdvgu9Q7MmhIvwhTe2e3hrYXbwqNBiNrk4vIrmiiJb8zo0bTw7rdAD8mOeVUNJNT0YLFau3M8BFwtLAOnVaNFdHjJ+XC6s6FktKKa/HAlx3HKnCy65zod+pxDYbOINLPw0yryoHvDhVTWqcnyNORSXEB2NvasD2jnGV7cnl43iAG9vOksrGVf646gmqXwvXjIsgoqWfl/gIqGloJ9XHmyhFh5yyNDlDX0s5L36ZSWNOCq70tTa0m/jl/OwF2WlD1PHO6TVWJItRU1KhobzfQ1Gpi6sBAxg/w56+f7WdEpDcFLfWgt+NAWTXXju3PZUkhpBbUset4Jd8dKiLQq/Pf7OXk2OO1qqs7nwx/HNvorZrSOtx9XS9afbPKxlae/LKzMravmz2vrT3K7KEh3DIx6qJd43+FzJ6SfhE/dldYz1NPqLqpjT++v4valnZmJAThaN9ZuO9QbnWPx0X6dY6D3DMzltlDg4kKcMVi7XyzL6nT89b6DJoazdS1tyKEoKzOQMkp6aAWq5X313cGqJkjXLh/zkDeu2sc1U1tfLbjZFZRTkUTXyXbYsWJVv127n5vJ6kFtfi42JGSX8td7+0gr7KJN9enU99i5Mllh7j3g13U6408eNlAVh8sZG9WJX//6jBRAa6MiPSh3WThoU/2klPRdM5/37PfHCY20I3P/zSZ9+4ax7PXxuBu8z1N1ikoqp7foHP1R1C1BzAroT/9/VxoN1lYk1zEyv0F9PN25IfsQhpNbdi2OfDAZQOZNyyUAUHuLBoXwayhwVQ2tpJZ3nn/Y/x7HlsqLul8WgsOvrBuyNLsCgKjzj7W9FO8sDKFKYMCePfOsTx9TSIf3TORfdlV7MqUab0XSj5pSL8ITdfEPWOrscf9lu7KZVJ8ALdO6kzrNFU1svu7w3y86RiTumot/ajRYKSs3oCfmz0hnp3dTi+vOUyEjyeldfquMQSB2SJ4986xTF+WT2Z9Nfe8v5MmQweK0tnd8uDcQZjMFly0LjjauJKvT2OU52y8nO1YMCKMr/bkcSC3GlsbNUU1Ldw3exAq3RQ0rWu4etg05ozorNS7YAR8tj2bRz4/gLHDwtu3j8Xf3YGdmRU8tSyZf986GlOHhQ+3ZDEp3p8vd+UyONQLIQTGDguvrT3KW7eP7XZPCqqaqW1u5/rxkahVCkJYCdU9h2g38W3meBb18F5b0ppDeVs+Wv1kVh8s5P458YyL9afVaOajrcfJr2rBuWvQWtfqgPWMORV1LUYsVsGB/BK8nBzwdek5QB0/XoGvrwsODmev0ns2FouF4mOlTLlhXK+P6UlZnYHqpjYWDA878fPibK9l4ej+bDpaytizrHEinZsMGtIvws5Bh52jjvrKxh73Sy2s5amrT64Z499VHLGpXk+93oiHkw6L1co7G4+xNb2MIA9HSuoMBHp2dnsNi3RjUKA/X+3N58v/m8I/v00lvaQetUrF9H4RvFtcztCBLtwybCAKsCuzkieXHeTemfFo1GoSXMezp3YtenMjjjauhHg5MizCmzmJIZgtgrhgd3QaNcLyF/QNm5gR/gZCjEdROq8fF+zBpztySAr35FhpA0GejkwY4E9WWSOf7cjB2UFLZWMrG1NL+Ncto0+sn32ksI6/fLqPupZ2PJxO73uvNxjxcbU7ORZieAuMmyhq/yNZ1YE93s8fKpdir3ZC1TIUtaqJwaGeqFUKTnYahvf3Zt3hIn6oySXAxh2d2Y7nvjlMbJA7dS3t1OuNCCFwc9SyKyuXuUNie+zasVispKQU9TgJ82wK00tobWkjdmTUBR13Lq0mM446TbexIxd7La1G80W5xv8S2T0l/WI8Az2oLq7pcR9HnYa6lpNPI4EBbigKmJpa0Wk7s5OW7c6jpFbPx/dO4rVbR/PJfRPR2diioNDQ2sL4Af5obVS0mczkVTXT1No1nqJ3AAENdvWoFAVFURgb60dCP09qmtsoqzfg3pGEFQvbq7/BZLbw3aFiRkf7ktDPk8RwL6oaW3nyy4PMeWE/r++8GpXlOJb62xHWzvGQsno9apXCdeMi+WDzcdYdLqaysRWz1crOzApuGBuBQmcByB8DBoCidP7bd2VWdLsnkX6u5Fc1U9vUiLX5Hwj9G6Cbx7KUMcQHu3fb/0cpDVvJ1acyzns+WG1J6OfB7e9s56VvU3nsiwO8uvYojgEdlLc3EqcJYWiYFzZqFUcK63C0tWFSvD+2NmrKm2pp6zAzPb7nFOKU1CIMrUaGJYX2uN+ZjmztXLxpwP+3d99hUR1rAId/w9KWjvQqoFhQsWEvMbaoMUVTNNWYRGN6uem56Tc3vXfTTFejJprYjRp7RcGChSoI0jss2+b+sRsEs+BaEPXO+zw87p4z5+zH7LofZ2bOzKCzkzSiAz2p0hkaTVUipWTZ7mz6tG96lJlim0oaSquJiY8kLan5td7H9oxk1pqDVFhH4Ti7OOEV4IVWV4e7dTjmksQjzBgdh4e1ycvFUUOEnweuGg82Hs7k/q82oNObmPLBGjqH+eLt5oTJbCb5cDkh5gB+SktstGpdWBt3Kmr0PDS+G2/9koNbVV82FS7hwZ/nEeClZWicpf2npErHkz9spUe0P/MeG43W8zK+3HYr6Lcii6/CXLedXZlFaBwEMUFevDQ5ga2H8nnsuy2s25/H0LgQRvWIIDbUm33ZpVTUWGIoKK/l8xX7ifR3Z1tqAW8tTOKXTWn1+z21Ttw9XIe+4Aqo+Y4i43W8u24yaccqGNtgvqmGjtVmsTDnc6LduzDQ/wraBXuhdXHkwzsH061tG0Z3D+eDaQPZ65RKgKMXH4wfw0Pju2EwmXHSOJBdXM3avbmM6RVBjamMIE8v+sY0f1WzeEkSXp6u9O/X9KSStmz4dSvR3SIJjjrztVoAHDUO3DumK8/P2cG3aw6yIimbZ2dvJ7ekmvEJalGnU6WShtJq2nWP5lhGAeVFFU2WGdMzgq6Rvkz9aA1PfL+FWz9cjXuQD1WF5VRUWNrey6r1BDW4o/jDJXs5WlqDm8YTMyaC/YRlplsB29MKCPFx456ZG/BwdSKwPJhyvY6vDm4FLPdRbD6UT1yELwM7BvPxtCFEmcejMXsS0WM1D14ZXd/MsSQxmwEdg5jQLxqtsyP3je3K/uJLeXLxfZRW1UHpTVzR/k2u6V3F87O3YTJLpo3qzDDrlU+vGH92phcyfWRnymv03PbRGu78ZC13z1xP+2Av9ueU4ebsRLe2bcgqrOLeL9dSVLQcc+ndDA97DB93B75LeorXVl1OoLcH70wdWJ84G8rXHeG7zP/gonFjUuQjaISGMT0j2JNVwtLEI3Rv60eQj5Zbf5+HwUnPmwMux9HBgeyiKuLCffl0+mBMZsl3DwzH29NIua6GSN+QZpumjuWXs3HTIUaN6orzSYblNlSQXcTeDQcYPKGf3cfYY1CnYN68tQEdsKUAACAASURBVD86o4ld6UUM7BjM27cNrP/DQ7Gf6tNQWk2P4V0B2LkymeE3DLZZxkEIpo+K49oBMWTkVxLgrUVfVs30u7/hz9X7mXB1b+KtU42M6xVJUYWODQeOccfwjugMRrZklbIpLZU4/1jKagxEB3rSI8qfrm3b0L1tG16Zv4sSQwEf7ttAqAxg954KfNyd6d3O0mwR6K3lpsFdOVL9FF+nv8BXGc9xe8yLeDm1Ibuoir4Nmjc8XJ1497aB/OtbweyUPlwTv5ZuwXPpFvQMlYYw1qX3YFNmL0wO7anSGVmRlENtnZHCCh1DO4ewK7OIHlF+uLk4sWBbBn3bB/D0xE5g2MOomFXoKhbiaiwDkw/C4wG0blO5LbT5ub8yqvbxQ9ZrOAlnpkQ/i6eTZVSZl9aZt6YM4Md1h3nsuy2UexaT6pGDX3kgcZ6WKyk/T1eOllSjN5rx0DpRo9fz5uJ1RLZpQ/fwsGZf99tv1yOE4Lpr+tr3YbD6/ZPlCAGjbxt2SsfZo22A5z/W/VBOnbgQV1dNSEiQO3bsaO0wlDNkMpmYFDKNXqPiefrHh07p2Bn3zEJvMPLl53eQll/BMz9tY3zvtmidNfy+IwudwcSLkxI4XJDHU78s56ruPdHrXXjr1sZzVhlNZn7ZfpiXMxfhLJ14tO0Yru8ba/Nu7szq/Xyb8R/cHb25IfJR1u4wU1yl44Fx3erv3TCYzEz5cDWv3tSPtgGeSHMF6JYgdUtAvw0wU6N3RePcDhfXKNCEkFMiWbuvlBHxERwrOYaLppKi8lwGt6/CwZwBmAAnDI7DeGdFW5684aH6jvammKWZrcXLWJo3izbOQUyJfhZfZ9vNPZvyM7lj3Wx6+0fQt7YbtXUm/nVldxw1Djz5wxbySmoYEhfMrtzDbDyUSbRXe968ZTDtQ2zfGHk49Rgz7pnFtdf05e67bC8da0tNZS23xNxLtyGdeGHB4wBkFVZSUWsgNtgL11O4YlFsE0LslFImnLxk01r8XRBCjAHeBzTAl1LK107Y7wJ8B/QGioFJUsrMlo5LaX0ajYYh1/RnxbdrqSytwtPX/hvArru2L6+8uog1a/czYngX3r1tIL9uyyAxo5ySqjremTqQDiHedAj15qfNSSzfv5cbEv45/bmjxoEb+nckMvpa7lg3myW67VwnbLfBR7nHcXvMi/yc9Safpz3F4JhJzP/ZjQ0pxyiv0ePj7kyAl5aOoT60DbDcmCccvMBtMsJtMtJUyMakn/F1SadzSCkYkkG3gnAXAzdb1zsKDhDUGNzwdtSyMysIB+dr6BE7HEfXPhSWCpLzt5w0YeTWZrDo6Odk1xyig2cvrot40OYMvWCZyfbeTQuI8mzDBwMnoBXOvLpgF1M+XEP7EG/S8ytx0jjw3cZEinWFRHiF8uiVvZtMGEajiTffWoKvrzs33dA4QR8rq2HjgWOYzZKBHYP/MUPy3DcWUlFcyeQnJ1BYUct/5++isKK2/opn6qUdufwsTpipnJ4WvdIQQmiAQ8AoIAfYDtwgpdzfoMw9QLyUcoYQYjIwQUo5qbnzqiuNi8fhxHTuSXiCe96byoQHxtl9nNksmXHPN1RX1/H1l3fi0qBt+q1FSZTX6JkxOo4AL1dmbzrAG0tX0js6nK/vnIjGwTKSKruoCj9P1/ohrYuy9vHwlt8YFtKO9wdMwMPJ9r0FNcZKFuR8TErFNmrL/cjZn0BFYRgCB6SUTBrUjqnDbQ8z/XjZXoK83bh2wPF1SKQ08s6irbT11/LL1kLuGxvPrvQiKmoNmMxmtM6OPHJFPK8u2EWodcJAW8r0hfxVuIDtxStx03gwNnQKPXyG2ex7kFIyO30Xz+9cRmefIL4eOhk/1+Nf4pkFlRwtqaZtgAd7jh7l0Z+XMLprB96cPLbZBZG++34Ds77bwEsvTGTwoOOjq5YkHuHr1QcY0jkEjYNg3f48rh/Yrr4eCnOKmdrxAQZc1Yenf3yQh2dtok+7QCYPbo/GQZBTXMWTP2zliat70K3tqd0oqBx3Nq40WjppDABekFJeZn3+FICU8tUGZZZby2wWQjgCx4AA2UxgKmlcXB4a8m8KsoqYdeiDJqdJtyVxVyaPPj6bydf3Y/q0S+u3G0xmfvjrEEt3ZVNZqyc+yo/wQPhszWZu6N+d9n6R/LI5nSBvLQUVtfSOCeCh8d3QOjvyc1oiz+1cRnsvfz4ffB2RHran/ZZScu/cL/CI2oCTtopIt44M9B9PUrIvP63P5PenxtqcU2rLoXy+XXuID+4YVD9hYWlVHdM++4s+7QKI8PfgxiGx1NQZeXneTnKKqymp0uGptUyz/vTEnrg0WBNdSklG9V42Fy0hpWI7AkEfv9GMCroBraPtK7cao57ndi7j18w9DAmO4aOBE5tMkMuSD/L4nKX0iAzli9sn4tLM9C3btqfz1DNzGX5pHM88dXzN94LyWu75Yj0f3jGYEF/LgIWiCh33fLGet6YMINLfg5cnvcOW33fw5b53qXN349nZ2/n2/ksbzeG1cFsGB3PLefzqHk3GoDTvQmieCgOyGzzPAU4cFlFfRkppFEKUA35Ao2XDhBDTgekAkZG2hxUqF6bbXprMYyNe5PdPV3DNw+PtPq5XzyjGje3O3HnbGDyoA3Fxls5ZJ40DU4d3YurwTo3miaoz6vlm/U4ifQr5dsaVBHpr0emNfLBkLx8v28ejV3bnhna9iHD34YHNvzJh5Te80/8qLglp94/XFkKQcTiMKeFPExWawfrC35h95G3c/b0J6RzB2nR/hrXrjUY07hvpGxvIit3ZPDJrE2N7RlKrN7JweyYT+0WTlFXMyHjLMFY3F0devakfh/PKeXXBLiYPbsfo7paFiszSzNHaNA5UbGdf+WYK647ipvFkSMDV9PO7DB/npu892FKQxdPbF3OkqpQHuwzh3rjBaBxsXzksTNzPs/NX0CMylE9vu7rZhJGdU8J//ruQmOhAHnloTKN9mw8eY2DHoPqEAeDv5crwbmFsSMkjtrqKdb9s5raXJhMSHURyVjH+nq7/mPQx0NuN7WnN39ejtLyWThq2xuSdeAVhTxmklDOBmWC50jjz0JTzRY9Lu9JrVDw/vDyPETcPwSeg6ZlnTzTjrkvZmZjBCy//xqcfTcHPr/Ff1w2bZh4ZM4RlSZkcKctl7rZd3DtyAK7Ojtx9WRdu/XA1d18Wh7uLE4ODY1gwciozNszj9nWzGRfRmad7jCTErfF66G4uTpRXm+nvP5a+fqM5XJnEnzl/EBiTzOqavWza50aMRzeiPboQ5BLF1j2SxdsLKKnUWaYT2Z9HkI+WR6/sTnxbPyprDezOLK4fuQUQ5KOl0lBOcFgR6wq2k11zmKyaA1QbyxE4EOUex5CAq4n3GYyTQ9NTdeTVVPBa0p/8cWQ/4e7e/HjpzZhLXXlh7k4qa/TEt/VjYv9ofNxdMJrMvLNsPd9uSKRfuwg+vOVK3F2avgI8ll/OY0/MRqNx4KUXJto9o60AaoorefPuT4jsHMZ1j1muTtoHe3OkqIrckur6ddoB1uw9Srxqmmp1LZ00coCG6ziGA7lNlMmxNk95AyUtHJdynrnnvanc1f1RvnnmZx6eOcPu4zzcXfnPi9dw/0M/8OwL83n3rRsb9W805OAgiPSKoGuEH5+u3sqx8iqeu3oEnlontM4aqmoN9eP2ozzbsHD07cw8sJlPUzaxJjeV+7oMZkpsH7SOljIjuoXy+44sekb70yPaj9qSSDatHES1MZ6nb/UlW7eXtKok9ldstQYLcSN88HUJwKBz49ARA/Ed2pLv4s6f+RqCO+hZsSeN8kRX2nhJiusKKK47Rofhdcyx/q/xcw4h1qMH7T160MGzJ+5OXrZ+1XoFtZXMPLCFH1N3IoTggS5DuKvTAH7fdoSlu1K4eWgsAd5a1u49ykPfbOLFyb14eeEqNqce4aYBPXjs8qE4aWyvNwJQVFTJo4//THV1He+8dYPNdU4GdAzm+3WHuWFwTf3VRnGljj+TsglcuIGailpeX/kczta6d3NxZMqwDjz5w1auG9iOAC9X1uzNJauwigcv79bs76u0vJbu03DE0hE+AjiKpSP8RinlvgZl7gW6NegInyilvL6586o+jYvTzMe+45e3f+e/S56mz5iep3Tsho2HeP7FBST0jublF69p8oayd/9Ixs/DhUpjCZ/8uYUuYYHcNWwQ365O55v7LrXZD5FdVcZ/dq9k1dFD+DhrubF9L25tn4CvsxsPfL2RnOJqDEYTnlpnjCYzd42Oq1/zWkpJYU0hj85ZxE2jfaiSeVQYSqg0llFcW4RR6nBwkJixzPbrJFwx6J2oq3MEgydhHuEkRMQS6BpOuFssZRUavliZwvbUAhw1DgzpHEK4nzsFFbVE+nswMj4cdxdH9pTk8VNaIguz9mKUZiZGdeP+LkMId/ehWmfg1g9X8+n0oQR6a+vjvH/WSrZmHsZgMvH81SOYkND0MrhgWff7yWfmUlGh483XJtU3D9qyeGcWs9YcZEicpSP8r315hG7Zw775m3l81n2MuvWSfxyzO6Oovl+qe5Q/43tH4m7j5kXFfud9RziAEGIc8B6WIbdfSylfEUK8BOyQUi4SQrgC3wM9sVxhTJZSpjd3TpU0Lk51tXU8MOAZinNL+Gz3W/iHNj2Pki1LlyXx1jtLm00ceaU1PDJrEyO6heHgqOOT1RupM5q4sV9vnrxyULN3Oe8ozObLg1tYdfQQTg4axkZ05qrILphLtexOL8bN1ZGR3cJpF9z4r/8jhZW8OHcnX907rNH21Lxy3lqUxGd3DcUszYDEQWgwmSW/78hkxe4cavRGekb7c9OQWFycNMyYuY6r+0QxPqEtmQWVPPHDVlydNNw0pD07svPZVJKKQ2gV6VXFuGocuSYqnjs69aethy86g4m0Y+XklVSzODGbd6dahiAXVFTx0m9/siYlHR+tO99Mn0iHYP9m6zp5TzbPPj8fR0cNr/7nOjp0CD7p+3OstIb1B/KQEmrW7+HHp37k2keu4K63bj3pscrZcUEkjZagksbF68iBo9yb8AQx3dvyxqrncNHaP6U2HE8cXeLCeemFifj4/HOFv4LyWn7dmsHB3DLcXAQHizLYn5tP76gwnr7yUjqFND+JXWZlCbMObWdh1l4qDDrauLgxKqwDQ4Jj6B/YFl+Xxq9Zqzdy8/urmTljaKMZaxduy2B/ThlPTWx8VfXBkj1kFlRy26Ud8XFzZkVSDutS8hjbM5KswkqenGAp/+Lc7bj7m1madRCnwDoOV1nWuPDHmwd7D+SKyDg8nS2vt3x3Nl+uSiHY143C8loqaw28d8cAlian8N3GRMxmM8M7dSLA3Z8nru7V5O9uNkvmzd/GF1/9RWioD6+9cv1Jl9490Z8/rueNKR/Sb3xvnp//KJpmmr+Us0slDeWitH7+Fl667m2GTRrIUz8+iEMTo3uasvavFF57YzF+bdx56cVraBfT/MR3ZrNk/o69vL9iI+U1OiYkdGHG8H6E+jTfX1BnMrI2L5Ul2SmsyjmMzmwACQEaLwaHRZMQFEacbxAdvAKYvT6d3ZlF3D+2KxH+Hmw6kM8ny/fxyo19iW1wo1x+WQ33frmB7+4fjpvL8Sul135L5FBpEW2jXPDwl+wszGZbfg7SwdKsFe3qz4TYLgzyb8ezX+3m96fG1h+7P6eUV+Yl8upNfYkM8KRSp+fadxeQV1mASZoY060DV/eM59PlB/n3tb2JC7c9zLi8opbX3/iDLVvTGDyoA4/9axyenqe2ZOrK7//irakfE39JHC8tehKtu1py9VxSSUO5aM1+/Te+eupHrnnocu56e8opL8mZciCX515YQFWVjrvvGsEV43uc9BzltTo+WbWFOVuTAbiyV2duH5JAVIDtL9G/zduczuJdmVzSz49sYyFrc9M5oivG7HB8VcIAV3e0ZleqKyQmnQOBHu4MjAkh2t+7flp2KSX78krYe7SIvh39KdRVc6y2gvyaSo5Wl2OyDirUCEFnnyCOZZl5cHAfFq/J599X9qVzuC8F5bXcPXM98x8bXf/aby9KIjrQk/4d/fl5SxLztu+horYON0d3ArSBhPr4UKUzMm1kJ0bE/3PmWikl6zcc5MOPVlFRWcuM6cO5+qpep/ye/P7ZCj6890u6X9qFlxc9iavbqV1FKmdOJQ3loiWl5JMHv+G3j5Zy9f1juee9qaf8JVVSUsVrbyxmx84M+vVtx6OPjP3HkFxbcssq+HLtdn7duQ+90UT/dhFc27cbI+La4ezYuJ9Epzdy8werG924BvDVqhQK9JX07ObF4YpCjlaXk1NdTkFtJcV1NVQYdP9YFa8hN40T/loPgrWeBGk9KS404oMHR3MMXBHXnol92/H5in3szy4jyEfLazf3QwLvLEpG66Lh3jGWySDrDEbu+WoltaZK9hy1DMEa2aU9tw7uxU9/ZTGuVyRtAzyJ8Peov9mwoYKCCt7/cAWbt6TSLiaQxx4dR4fYk/dfNGQ2m/nmmZ+Z/fpv9Lu8F/+e84hKGK1EJQ3loial5PN/fcv89xYz7s4RPPDJNDQ2JhJsjtksWbgokc+/WIOTk4Y7pg7livE969cob0pFjZ4luzPZeDiNvbk5FFRU4euuZVSX9ozqGkufmHCcNJpGndkN7csu4YuVKbx3+yDbcUlJtaGOOrMJKSVmJAJwc3TmxdmJtPX3ZOqlHdG6OLLlYD7vLd7Du1MHonEQfLP6IFsP5+Pk6ICzxgEnRw1dI9qwL6eEAC8tT1zdnaTsXNakpLFybyqVujq0Ts7cOCCeyQO6E+rjRX5ZDfd8sZ7v7h9uc0RSba2eeQu2M3vOVsxmM7dNGcK1E/uctN7+cZ5qHe9M+4y1szdy+fRR3P/RHaf8Hipnj0oaykVPSsmsZ2fz038X0GdMD56Z/TDuXv/s3D6Z7JwS3nt/Obt2ZxEdFcA9d4+gd68om2W3pxbw+m+76R0TgKfWsnpe+zAXakwVrDuYSa3egJfWhcEdougSFsz8jUeZ8/AY3BrcH7Ik8QiJ6YX8+9repxxrRa2ej5fuY+vhfDQOgkBvN+6+LM7mjW1SSvYcKWFLag6ltZVkFBayNT0bvdGEu4szI+LaMbprB2avyyYq0Ivh3UIprqxjzsZUruoTxcT+MY3OZzCYWLI0ie9+2EhpaTWDBsVyz10jTrmzGyD74FFeuvZtsvbncPt/b2TS41ed8tWicnappKH831jyxSrev+cL2saF89LCJ05rVTcpJRs2HuKzz1eTd6ycHj0imXLzYLp3Pz4tjc5g4pb3/+TFyX3qO4Qraw088PUGHhjXjc7hPmw6nMXKvYfZlJpFUWUNAG5OzvSJCSc+MhgPZzd+25rDsxMT6B5tGYlVpTOwZm8uRRW1dAzzoV9sYJPTd/ytps6I3mjC2825/su2Rm8gq6iUg3mFHLD+7M0+Rq3BstZ1pJ8Pl3SKZlinGHpFhdVP8V6tM/DHziPszizC09WJy3pG0CvaMqxWCEFtrZ6ly5KZO28bBQUVxHeLYNqdw+jSzL0XzVn903remzETZ1cnnvrxQXqP6n5a51HOLpU0lP8rO1cm8fL17yCE4OGZdzH02gEnP8gGvd7IH4t38+PPmyktraZb13CumZjAwAGx7Egv4tetGbx+S/9Gx8zfkk52URV3juyMm4sjDtaO64zCUjYeymLulhSyS0sxmI8vG+vsqCGijTe+bu6kH6si1NeTUF8vcopqcHbUMG1kXKPpOcxSUqs3UGswUFNnoKS6huIqy8+x8kqyi8sprKyuL+/q5EhskD/dIoLpHRVKr6gwAr1O3mdTUaPnyz9TWLsvD2O1jkCdjuLDeVRX19Gtazg33TiQPgnRp3VVUFZYzkf3f8VfczcTN7Aj/579MAHhauqP84VKGsr/nbz0fP5743sc2JbK5dNGctc7U0572GZdnYElS5OZO28r+fkV+Pl50L1fe0rdtbw9/fgdylJKXvplJzvTCtE4OODm6sgNg9sz/oS1Hap1Bo6VVVNaW01GYQlZxaUcKSpja2oeDg5mqurqmu38tsXN2Qk/DzeCvD2IaONDpJ8PkX7edAgOoK2/z0mvVk5klpL7Z67Do0ZHbXYRe/dkIwS4BvvyyqNj6RF/epOBSilZM3sjnzz4NTUVtdz07LVMfuJq1X9xnlFJQ/m/YjJLNA4Co8HIrGdnM+eNhYTEBPHgp9POqPnDZDKzdVsaCxclsn1HBgAdOoUyfmw8lwzpxPI9R5m19hAzRscxPqEtqXnlvPrrLiYPas+o7o2HqB4rrWHNvlzqDCb6tA/Az9OFe7/YyAd3DCLYR0tZjY7qOj17s4v5Yd3BRnMpCQFaJye0zk64OTvh467FzfnsTJtRV2dg67Z0fl28m+TdWUiTmZAQH8ZeFs9ll3Xj4z8P0r9DIGN6nnrSyNyXzaePzCJxZTKd+rbnX1/dQ1SXiJMfqJxzKmkoFz0pJQu3ZzJ/SwaF5bVEBXpyyyUdGNQpmOR1+3ln2mccPZzHsEkDuevtKac89ciJcvPK+Gr2Fv76KwVzdR3CQYCnG9EdQ3n6jiFERwcghCAps5hPl+9rNGpq9Z6jfLp8H8O6huLh4sTSXUfQGUzoDCZ83FwI9tXy+FU9CG3jzp6sYj5bsZ+Ppw050yqySUpJdnYJ23eks31HBknJR6irM6J1dyG4XTD33zqQ+G6ROFjn2pq7KY2y6jqmn8Ia2qUF5Xz3/ByWfLEKraeW216ezBV3j1Z3eJ/HLoT1NBTljMzbks7avbk8f11vYoK92JVexDu/J+Ps6ECfoXHMTHqLOa8v5OfXfmXr4kQmPX41Ex4ch5un9rReLzTEh2cfHsNdtw9l3qr9HEg+wr6kI6RvO8yd2w6jcXXCJ8SXAQnRZB8pw2g04eiooUpn4ONle3nntoG0DfAkv6yGP3Zm4eHiSICXK+N6RQKCf/+8nU+nD2bupjQu6RJ61upJrzeSkVFIyoFckpKzSd6TTWmppf8jIqINl4/tTv/+7cHbna9WH6R7fGSjPou9R0roHO5L2rEKogI9bU7c+LeKkkoWvLeYX99fgq6mjivuvoxbnr8Ob//m76BXLg7qSkM5b5nMZm56bzVv3NqfSP/jHbzr9ufx+45M3rz1eEf40dQ8vnj8ezb+th1vf08mPzmBK+4efcpzV9ly+8drKCutppO7I+bSavbty6G6ohYAB40DUVH++AR6U2KS3Dm+O+HhbVh9qIBao5lAby0Hc8s4kFNGmJ87GfmVaATEhHjz7LW96kc32UNKSXV1Hfn55eQcLSU7u4TsnGLS0wvJzCrCZLLcgR4Y4EV8fATx8REk9IoiOPj4cFmzlDwyaxNtAzy5aUgszo4OfLv2ECuTcvByc0Lr7IjBaObB8d3oHdN4Dq6ywnLmv7uYhR8tpbZKx5Br+nHbyzcQ2en0Rlgp55660lAuatU6IwaTqVHCAOgc7sOny6sbbQtrH8ILCx4nZethZj03m88ftUyzPvHByxl/10jcvd05XcE+bpRU1TFuTHc0DoKUX3fjVq3DVFlDjLszqan55OaVoavR8+9tqfXHad1ccPfWonF1Ir59EJVZVciiasKCvOjr4cjaNSnWm+UkUlrunK7VGajTGdDpDFRU1FJeUUt5eS3FxVXkF5RTU6NvFJu/vycx0QH069uO2NggOnYIJijIu8mRTw5C8J8b+vLN6gPcPXM9JrMZKeGmobFMGtQOByHYlVHEf+cn8vG0IQR6a8lKyeHX9xaz8vu/MNQZuWTSQG58eiLRXdUKmv+P1JWGct4ymSW3fPAnr9zQl+ig400fq/ccZWVyDq/edOLKwccl/bWPn16ZT+KqPbh5ahl75wiuum8MIdFBpxzHvV+sZ3jXMDYdyiclp5TwNu7MuKwLHy3dy/PX9yYps5htqQWkZBRx+6AYnPRGNidnszc1n6qKWgK0Tuhr9JRX1FBXZ7T7dd3dXPDy1uLj7UabNu4EBXoREOhFUKAXYWG+hIe1sXuVvKZsPZzPnI1pvHPbwEbbP/ojmYqkDKo27WP70l04uTgx8uahXPuvK9SVxQVMXWkoFzWNg2DyoPb8d8EuHri8G+2DvdiZVsjMlSk8OaFHs8d2v6QL3S/pQuquDOa+tZBfP1jCgvcW02tUPJdPG8mAKxNwbGbN64baeLri4+7MG7f0Y/x/l/HJ9CHojWbKa+rwcXdhWNdQvll9kKeuS+CNhbvpEeWPR2wo1TpJeBt37h3ThRq9kdkb0ojyd+fOSztSpzeirzNiMlualIQQODgItK5OuLg44erqdMpTdpyO0qq6+jmzpJRk7DnCyu/+YsU3a6gtraJNiC9TXpzE+BmjTmkZXuXipa40lPOalJIVSTnM35LOsbJa2gV5cfPQ2EbraNujILuIZV+tZtnXqynMKcbLz5MhE/txyaSBxF8S1+yIn+2pBXy4dC8vTUrgX99u5u0pA/llcxpms+SJCT1JzSvn5Xk7+fb+4VTU6tl8MB+d3kjXyDZsSy1k2+ECnJ0cGN41jFHdw3E4j6bSOFJYyb/eXsY4FzMb5m3mSMpRNI4a3OOjGXPHcG6fNlzda3ERUUNuFeUUmUwmdixP4s8f17F50Q501XX4BHrTb1wvBlyZQK9R8TZvFlySeIRZaw5iMktq9UYGdQzikSu7YzJLXpy7g4R2AUwa1L4VfqNTp68zsHfDATYv2s62JYnkpuWDgMje7eg5vg95IQHUOjnyxi39cTwHVzvKuaOShqKcAV1NHduWJLJ+/ha2L9tNdXkNzq5OdBsaR49hXeh+aVc69I6p/0tbbzRxpKiKuZvSSEwvItLfg6zCSi7tGsbdl3VpdphqazLoDaQnHyF57T4S/0xmz7oU6mr1OLs60XNEN/qM7Yk5NpzthTXoDSb6dQjkioQoXJ3UFcbF5rxNGkKIN4ErAD2QBkyVUpbZKJcJVAImwGjvLBYg3QAAEAZJREFUL6OShnK2GQ1G9qxPYfOiHez6cw+Z+7IBcHV3oUNCOzomtKNjn/Z06NOO4KhAiivryCurIbyNO74eZ2dtiANHy1iz9ygGk5kBHYJIaBdwyvM/mUwmcg7mcmhnOmm7MkjZlkpqYjp6nQGAyM5h9BoRT8+R3eg5optaOe//zPmcNEYDq6WURiHE6wBSyidslMsEEqSURadyfpU0lJZWml9G8l/72bM+hYM70kjblYFBbxn55O7tRrseUUR1iSC8QyjhHUIIiw3BP9wPZ5fTm/bjl01p/LY9k8t7ReLqpGHZ7mw6hvrwyBXxNhNHdUUN+ZmFHMssIOdgLlkpORzZn0Pmvmx01XUAOLs60b5XDJ37xdK5XyxdBnXEP0xNHvj/7LxNGo1eQIgJwLVSypts7MtEJQ3lAvB3E09qYjqpuzJI3Z3Jkf051FTWNirnG+RNQIQ/vkHeeAd44e3niYevB26eWrSermg9XHF0dsTRyRFHZ0eEsIxgev/3ZO4f2wVXAfpaPVVVOr5fsY+EMG88kFQUV1JyrIzSY2WU5JVSWdr4PpU2Ib60jQunbVw4HXq3I7Z3DBEdQ1UnttLIhZI0fgfmSCl/sLEvAygFJPC5lHJmM+eZDkwHiIyM7J2VldVCESuKfaSUlBWUk3Moj6OpxyjMLqIwu5jCnCLKCysoK6ygvLCivmnotAiBu5cWzzYetAnxpU2wD75BPgRHBRAUFUhQW3/CYkPw9D35lOiK0qpJQwixCrC1WPAzUsqF1jLPAAnARGnjhYQQoVLKXCFEILASuF9Kue5kr62uNJQLiV6np7ZKR01lLboqHQa9EaPBhFFvRErJ7sxidmUWM/2yLji7OuGidcZF68y8XTloPVyZOqJza/8KykWiVW/uk1KObG6/EGIKMB4YYSthWM+Ra/23QAjxK9AXOGnSUJQLibOrM86uzk1O6Bfb38gfH67GGOJHnHVJ16Ml1axNLeLNW/vbPEZRWkuL3BEuhBgDPAFcIqWsaaKMO+Agpay0Ph4NvNQS8SjK+czNxZGnr+nFf+Yl0i7YC1cnDUmZxUwb1Zm2AZ6tHZ6iNNJSo6dSAReg2Lppi5RyhhAiFPhSSjlOCBED/Grd7wj8JKV8xZ7zq+Yp5WKkM5jYmVaI3miid0wAXm5nNq+UopzovJ17Skpp89ZYa3PUOOvjdECtNq8oVq5OGgZ1stVNqCjnDzVHgKIoimI3Ncutopwms5TM35LO4p1HKKuuo2tkG6YM60hsiJoNVrl4qSsNRTlNX65KYfPBfJ65phffPzCCgR2DeeanbWQXVbV2aIrSYlTSUJTTUFGrZ/nubJ6/PoHYEG88tU6M6xXJlX2i+HVbRmuHpygtRiUNRTkNuSU1hPi6433CCKfubduQWVDZSlEpSstTSUNRTkOwj5a80mqqTpgiJOVoGeF+p78euaKc71TSUJTT4OPuwtC4UF5dsIvckmpMZjN/7ctl3uZ0ru4b3drhKUqLUaOnFOU03TumC9//dYgHv95Ilc5IxzBv/n1tL2KCbE8XoigXA5U0FOU0OWocmDq8E7dd2hGzlGgc1IW7cvFTSUNRzpAQAs0prrCnKBcq9aeRoigtTkqJwWSmpdfvUVqeutJQFKVFLd11hDkb08gvqyXIR8sNg9tzWY+I1g5LOU0qaSiK0mKW785m3uZ0npzQg46hPhw4WsabC5NwEIJR3cNbOzzlNKjmKUVRWszcTWk8PD6eTmG+CCHoHO7Lw+O7MXdTWmuHppwmlTQURWkRUkqOFlfTOdyn0faOYT4cLalupaiUM6WShqIoLUIIQVSgJ0mZJY22J2eVEKVWJLxgqaShKEqLuXFILO/+kcy2wwVU1xnYejif9/5I5sYhNtdpUy4AqiNcUZQWMzQuBI2D4Pt1h8guqiLC34N7LuvCQLVC4QWrxZKGEOIFYBpQaN30tJRyiY1yY4D3AQ2W9cNfa6mYFEU59wZ1ClbL2F5EWvpK410p5VtN7RRCaICPgVFADrBdCLFISrm/heNSFEVRTkNr92n0BVKllOlSSj0wG7iqlWNSFEVRmtDSSeM+IUSyEOJrIYSvjf1hQHaD5znWbf8ghJguhNghhNhRWFhoq4iiKIrSws4oaQghVgkh9tr4uQr4FGgH9ADygLdtncLGNpuT00gpZ0opE6SUCQEBAWcStqIoinKazqhPQ0o50p5yQogvgD9s7MoBGk5CEw7knklMiqIoSstpseYpIURIg6cTgL02im0HYoUQ0UIIZ2AysKilYlIURVHOTEuOnnpDCNEDS3NTJnAXgBAiFMvQ2nFSSqMQ4j5gOZYht19LKfe1YEyKoijKGWixpCGlvKWJ7bnAuAbPlwD/uH9DURRFOf+09pBbRVEU5QKikoaiKIpiN5U0FEVRFLuppKEoiqLYTSUNRVEUxW4qaSiKoih2U0lDURRFsZtKGoqiKIrdVNJQFEVR7KaShqIoimI3lTQURVEUu6mkoSiKothNJQ1FURTFbippKIqiKHZTSUNRFEWxm0oaiqIoit1U0lAURVHsppKGoiiKYrcWWe5VCDEH6Gh96gOUSSl72CiXCVQCJsAopUxoiXgURVGUs6NFkoaUctLfj4UQbwPlzRS/VEpZ1BJxKIqiKGdXiySNvwkhBHA9MLwlX0dRFEU5N1q6T2MIkC+lPNzEfgmsEELsFEJMb+FYFEVRlDN02lcaQohVQLCNXc9IKRdaH98A/NzMaQZJKXOFEIHASiHEASnluiZebzowHSAyMvJ0w1YURVHOgJBStsyJhXAEjgK9pZQ5dpR/AaiSUr51srIJCQlyx44dZx6koijK/xEhxM4zHXDUks1TI4EDTSUMIYS7EMLz78fAaGBvC8ajKIqinKGWTBqTOaFpSggRKoRYYn0aBGwQQiQB24DFUsplLRiPoiiKcoZabPSUlPI2G9tygXHWx+lA95Z6fUVRFOXsU3eEK4qiKHZTSUNRFEWxm0oaiqIoit1U0lAURVHsppKGoiiKYjeVNBRFURS7qaShKIqi2E0lDUVRFMVuKmkoiqIodlNJQ1EURbGbShqKoiiK3VTSUBRFUeymkoaiKIpiN5U0FEVRFLuppKEoiqLYTSUNRVEUxW4qaSiKoih2U0lDURRFsZtKGoqiKIrdzihpCCGuE0LsE0KYhRAJJ+x7SgiRKoQ4KIS4rInjo4UQW4UQh4UQc4QQzmcSj6IoitKyzvRKYy8wEVjXcKMQIg6YDHQBxgCfCCE0No5/HXhXShkLlAJ3nGE8iqIoSgs6o6QhpUyRUh60sesqYLaUsk5KmQGkAn0bFhBCCGA4MM+66Vvg6jOJR1EURWlZji103jBgS4PnOdZtDfkBZVJKYzNl6gkhpgPTrU/rhBB7z1KsLckfKGrtIE7iQogRVJxnm4rz7LpQ4ux4pic4adIQQqwCgm3sekZKubCpw2xsk6dR5vgOKWcCM60x7ZBSJjRV9nxxIcR5IcQIKs6zTcV5dl1IcZ7pOU6aNKSUI0/jvDlARIPn4UDuCWWKAB8hhKP1asNWGUVRFOU80lJDbhcBk4UQLkKIaCAW2NawgJRSAmuAa62bpgBNXbkoiqIo54EzHXI7QQiRAwwAFgshlgNIKfcBc4H9wDLgXimlyXrMEiFEqPUUTwCPCCFSsfRxfGXnS888k7jPoQshzgshRlBxnm0qzrPr/yZOYfmDX1EURVFOTt0RriiKothNJQ1FURTFbudt0rjQpiixvsZu60+mEGJ3E+UyhRB7rOXOePjbacT5ghDiaINYxzVRboy1flOFEE+2QpxvCiEOCCGShRC/CiF8mijXKvV5svqxDgKZY92/VQgRda5iaxBDhBBijRAixfp/6UEbZYYJIcobfB6eO9dxWuNo9n0UFh9Y6zNZCNHrHMfXsUEd7RZCVAghHjqhTKvVpRDiayFEQcP714QQbYQQK63fgSuFEL5NHDvFWuawEGLKSV9MSnle/gCdsdyIshZIaLA9DkgCXIBoIA3Q2Dh+LjDZ+vgz4O5zGPvbwHNN7MsE/FuxXl8AHj1JGY21XmMAZ2t9x53jOEcDjtbHrwOvny/1aU/9APcAn1kfTwbmtMJ7HQL0sj72BA7ZiHMY8Me5ju1U30dgHLAUy/1d/YGtrRirBjgGtD1f6hIYCvQC9jbY9gbwpPXxk7b+DwFtgHTrv77Wx77NvdZ5e6UhL9ApSqyvfT3w87l4vRbSF0iVUqZLKfXAbCz1fs5IKVfI47MFbMFyH8/5wp76uQrL5w4sn8MR1s/GOSOlzJNSJlofVwIpNDPrwnnuKuA7abEFyz1eIa0UywggTUqZ1Uqv/w9SynVAyQmbG34Gm/oOvAxYKaUskVKWAiuxzBfYpPM2aTQjDMhu8PyMpyg5y4YA+VLKw03sl8AKIcRO69QoreE+6yX+101cstpTx+fS7Vj+yrSlNerTnvqpL2P9HJZj+Vy2CmvzWE9gq43dA4QQSUKIpUKILuc0sONO9j6eT5/JyTT9R+H5UJd/C5JS5oHlDwgg0EaZU67Xlpp7yi7iPJmixF52xnsDzV9lDJJS5gohAoGVQogD1r8Szprm4gQ+BV7GUh8vY2lKu/3EU9g49qyPzbanPoUQzwBG4McmTtPi9WlDq30GT4cQwgOYDzwkpaw4YXcilmaWKmv/1m9YbsY91072Pp4X9WntG70SeMrG7vOlLk/FKddrqyYNeYFNUXKyeIUQjlimiu/dzDlyrf8WCCF+xdLUcVa/5OytVyHEF8AfNnbZU8dnzI76nAKMB0ZIawOsjXO0eH3aYE/9/F0mx/q58OafzQctTgjhhCVh/CilXHDi/oZJREq5RAjxiRDCX0p5Tiffs+N9PCefSTuMBRKllPkn7jhf6rKBfCFEiJQyz9qUV2CjTA6Wvpi/hWPpR27Shdg8dT5PUTISOCClzLG1UwjhLoTw/Psxls7eczpb7wntwBOaeP3tQKywjEBzxnI5vuhcxPc3IcQYLDMGXCmlrGmiTGvVpz31swjL5w4sn8PVTSW+lmLtQ/kKSJFSvtNEmeC/+1qEEH2xfCcUn7so7X4fFwG3WkdR9QfK/256OceabEk4H+ryBA0/g019By4HRgshfK1N1aOt25rWGj39do4GmIAlC9YB+cDyBvuewTJ65SAwtsH2JUCo9XEMlmSSCvwCuJyDmGcBM07YFgosaRBTkvVnH5ZmmHNdr98De4Bk64cq5MQ4rc/HYRltk9ZKcaZiaWvdbf357MQ4W7M+bdUP8BKWJAfgav3cpVo/hzGtUIeDsTQ1JDeox3HAjL8/p8B91rpLwjLgYGArxGnzfTwhTgF8bK3vPTQYUXkO43TDkgS8G2w7L+oSSyLLAwzW7807sPSh/Qkctv7bxlo2AfiywbG3Wz+nqcDUk72WmkZEURRFsduF2DylKIqitBKVNBRFURS7qaShKIqi2E0lDUVRFMVuKmkoiqIodlNJQ1EURbGbShqKoiiK3f4Hge/ozR/1HfUAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "X = np.random.normal(loc=1., scale=2., size=(100, 2))\n", + "gaussian = MultivariateGaussian()\n", + "gaussian.fit(X)\n", + "print(gaussian)\n", + "\n", + "x, y = np.meshgrid(\n", + " np.linspace(-10, 10, 100), np.linspace(-10, 10, 100))\n", + "p = gaussian.pdf(\n", + " np.array([x, y]).reshape(2, -1).T).reshape(100, 100)\n", + "plt.scatter(X[:, 0], X[:, 1], facecolor=\"none\", edgecolor=\"steelblue\")\n", + "plt.contour(x, y, p)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.3.6 Bayesian inference for the Gaussian" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mu = Gaussian(0, 0.1)\n", + "model = Gaussian(mu, 0.1)\n", + "\n", + "x = np.linspace(-1, 1, 100)\n", + "plt.plot(x, model.mu.pdf(x), label=\"N=0\")\n", + "\n", + "model.fit(np.random.normal(loc=0.8, scale=0.1, size=1))\n", + "plt.plot(x, model.mu.pdf(x), label=\"N=1\")\n", + "\n", + "model.fit(np.random.normal(loc=0.8, scale=0.1, size=1))\n", + "plt.plot(x, model.mu.pdf(x), label=\"N=2\")\n", + "\n", + "model.fit(np.random.normal(loc=0.8, scale=0.1, size=8))\n", + "plt.plot(x, model.mu.pdf(x), label=\"N=10\")\n", + "\n", + "plt.xlim(-1, 1)\n", + "plt.ylim(0, 5)\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.linspace(0, 2, 100)\n", + "for i, [a, b] in enumerate([[0.1, 0.1], [1, 1], [2, 3], [4, 6]]):\n", + " plt.subplot(2, 2, i + 1)\n", + " gamma = Gamma(a, b)\n", + " plt.xlim(0, 2)\n", + " plt.ylim(0, 2)\n", + " plt.plot(x, gamma.pdf(x))\n", + " plt.annotate(\"a={}\".format(a), (1, 1.6))\n", + " plt.annotate(\"b={}\".format(b), (1, 1.3))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gaussian(\n", + " mu=0\n", + " tau=Gamma(\n", + " a=1\n", + " b=1\n", + " )\n", + " var=None\n", + ")\n", + "Gaussian(\n", + " mu=0\n", + " tau=Gamma(\n", + " a=51.0\n", + " b=94.73272357871433\n", + " )\n", + " var=None\n", + ")\n" + ] + } + ], + "source": [ + "tau = Gamma(a=1, b=1)\n", + "model = Gaussian(mu=0, tau=tau)\n", + "print(model)\n", + "\n", + "model.fit(np.random.normal(scale=1.414, size=100))\n", + "print(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "### 2.3.7 Student's t-distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gaussian(\n", + " mu=2.2695020512383577\n", + " var=46.95748684941486\n", + " tau=0.02129585859666723\n", + ")\n", + "StudentsT(\n", + " mu=-0.1946342109447806\n", + " tau=1.4665461746068318\n", + " dof=0.9028354354811657\n", + ")\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "X = np.random.normal(size=20)\n", + "X = np.concatenate([X, np.random.normal(loc=20., size=3)])\n", + "plt.hist(X.ravel(), bins=50, normed=1., label=\"samples\")\n", + "\n", + "students_t = StudentsT()\n", + "gaussian = Gaussian()\n", + "\n", + "gaussian.fit(X)\n", + "students_t.fit(X)\n", + "\n", + "print(gaussian)\n", + "print(students_t)\n", + "\n", + "x = np.linspace(-5, 25, 1000)\n", + "plt.plot(x, students_t.pdf(x), label=\"student's t\", linewidth=2)\n", + "plt.plot(x, gaussian.pdf(x), label=\"gaussian\", linewidth=2)\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "### 2.3.9 Mixture of Gaussians" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MultivariateGaussianMixture(\n", + " mu=[[ 5.06087392 -5.07813706]\n", + " [-4.9724865 -5.09928156]\n", + " [-0.05584106 4.99523381]]\n", + " cov=[[[ 1.11567912 -0.01717074]\n", + " [-0.01717074 1.04457722]]\n", + "\n", + " [[ 0.89251355 -0.0138146 ]\n", + " [-0.0138146 1.07986159]]\n", + "\n", + " [[ 0.81797404 0.03778106]\n", + " [ 0.03778106 0.93690783]]]\n", + " coef=[0.33333333 0.33333333 0.33333333]\n", + ")\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x1 = np.random.normal(size=(100, 2))\n", + "x1 += np.array([-5, -5])\n", + "x2 = np.random.normal(size=(100, 2))\n", + "x2 += np.array([5, -5])\n", + "x3 = np.random.normal(size=(100, 2))\n", + "x3 += np.array([0, 5])\n", + "X = np.vstack((x1, x2, x3))\n", + "\n", + "model = MultivariateGaussianMixture(n_components=3)\n", + "model.fit(X)\n", + "print(model)\n", + "\n", + "x_test, y_test = np.meshgrid(np.linspace(-10, 10, 100), np.linspace(-10, 10, 100))\n", + "X_test = np.array([x_test, y_test]).reshape(2, -1).transpose()\n", + "probs = model.pdf(X_test)\n", + "Probs = probs.reshape(100, 100)\n", + "plt.scatter(X[:, 0], X[:, 1])\n", + "plt.contour(x_test, y_test, Probs)\n", + "plt.xlim(-10, 10)\n", + "plt.ylim(-10, 10)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/books/PRML/PRML-master-Python/notebooks/ch03_Linear_Models_for_Regression.ipynb b/books/PRML/PRML-master-Python/notebooks/ch03_Linear_Models_for_Regression.ipynb new file mode 100755 index 0000000..c393d63 --- /dev/null +++ b/books/PRML/PRML-master-Python/notebooks/ch03_Linear_Models_for_Regression.ipynb @@ -0,0 +1,570 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 3. Linear Models for Regression" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from scipy.stats import multivariate_normal\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from prml.preprocess import GaussianFeature, PolynomialFeature, SigmoidalFeature\n", + "from prml.linear import (\n", + " BayesianRegression,\n", + " EmpiricalBayesRegression,\n", + " LinearRegression,\n", + " RidgeRegression\n", + ")\n", + "\n", + "np.random.seed(1234)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def create_toy_data(func, sample_size, std, domain=[0, 1]):\n", + " x = np.linspace(domain[0], domain[1], sample_size)\n", + " np.random.shuffle(x)\n", + " t = func(x) + np.random.normal(scale=std, size=x.shape)\n", + " return x, t" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3.1 Linear Basis Function Models" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.linspace(-1, 1, 100)\n", + "X_polynomial = PolynomialFeature(11).transform(x[:, None])\n", + "X_gaussian = GaussianFeature(np.linspace(-1, 1, 11), 0.1).transform(x)\n", + "X_sigmoidal = SigmoidalFeature(np.linspace(-1, 1, 11), 10).transform(x)\n", + "\n", + "plt.figure(figsize=(20, 5))\n", + "for i, X in enumerate([X_polynomial, X_gaussian, X_sigmoidal]):\n", + " plt.subplot(1, 3, i + 1)\n", + " for j in range(12):\n", + " plt.plot(x, X[:, j])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.1.1 Maximum likelihood and least squares" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def sinusoidal(x):\n", + " return np.sin(2 * np.pi * x)\n", + "\n", + "x_train, y_train = create_toy_data(sinusoidal, 10, 0.25)\n", + "x_test = np.linspace(0, 1, 100)\n", + "y_test = sinusoidal(x_test)\n", + "\n", + "# Pick one of the three features below\n", + "# feature = PolynomialFeature(8)\n", + "feature = GaussianFeature(np.linspace(0, 1, 8), 0.1)\n", + "# feature = SigmoidalFeature(np.linspace(0, 1, 8), 10)\n", + "\n", + "X_train = feature.transform(x_train)\n", + "X_test = feature.transform(x_test)\n", + "model = LinearRegression()\n", + "model.fit(X_train, y_train)\n", + "y, y_std = model.predict(X_test, return_std=True)\n", + "\n", + "plt.scatter(x_train, y_train, facecolor=\"none\", edgecolor=\"b\", s=50, label=\"training data\")\n", + "plt.plot(x_test, y_test, label=\"$\\sin(2\\pi x)$\")\n", + "plt.plot(x_test, y, label=\"prediction\")\n", + "plt.fill_between(\n", + " x_test, y - y_std, y + y_std,\n", + " color=\"orange\", alpha=0.5, label=\"std.\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.1.4 Regularized least squares" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model = RidgeRegression(alpha=1e-3)\n", + "model.fit(X_train, y_train)\n", + "y = model.predict(X_test)\n", + "\n", + "plt.scatter(x_train, y_train, facecolor=\"none\", edgecolor=\"b\", s=50, label=\"training data\")\n", + "plt.plot(x_test, y_test, label=\"$\\sin(2\\pi x)$\")\n", + "plt.plot(x_test, y, label=\"prediction\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3.2 The Bias-Variance Decomposition" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAAEzCAYAAAC8MPOWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzs3Xd4XOWZNvD7PdObepfcm9xtLNuAqUsKsKElQOglBAglyZdv8202u5uyye4mu2FTaQHi0BMILaQtaSQE0yz33otkW8Xq0vSZ8/3xnNGckUaybEsaSXP/rutcZ6Q5mvPOGMzLred9XqXrOoiIiIiIiIiIiMy0TA+AiIiIiIiIiIjGHoZGRERERERERETUD0MjIiIiIiIiIiLqh6ERERERERERERH1w9CIiIiIiIiIiIj6YWhERERERERERET9DEtopJRarZRqUkptHeD5C5RSHUqpjcbx1eG4LxEREVG24vyLiIiIRpp1mF7nSQAPAnh6kGv+puv6x4bpfkRERETZ7klw/kVEREQjaFgqjXRdfwtA63C8FhERERGdGOdfRERENNJGs6fRWUqpTUqp3yml5o/ifYmIiIiyFedfREREdMqGa3naiawHMEXX9W6l1KUAXgMwK92FSqm7ANwFAB6PZ1l1dfUoDZGIiIhG27p1647rul6c6XFMUJx/ERERUVpDnYMpXdeH5YZKqakAfq3r+oIhXHsQQI2u68cHu66mpkavra0dlvERERHR2KOUWqfrek2mxzFecf5FREREp2Koc7BRWZ6mlCpTSinj8Qrjvi2jcW8iIiKibMT5FxEREZ2uYVmeppT6GYALABQppeoBfA2ADQB0XX8UwNUA7lFKRQEEAFynD1eJExEREVEW4vyLiIiIRtqwhEa6rl9/gucfhGwJS0RERETDgPMvIiIiGmmjuXsaERERERERERGNEwyNiIiIiIiIiIioH4ZGRERERERERETUD0MjIiIiIiIiIiLqh6ERERERERERERH1w9CIiIiIiIiIiIj6YWhERERERERERET9MDQiIiIiIiIiIqJ+GBoREREREREREVE/DI2IiIiIiIiIiKgfhkZERERERERERNQPQyMiIiIiIiIiIuqHoREREREREREREfXD0IiIiIiIiIiIiPphaERERERERERERP0wNCIiIiIiIiIion4YGhERERERERERUT8MjYiIiIiIiIiIqB+GRkRERERERERE1A9DIyIiIiIiIiIi6oehERERERERERER9cPQiIiIiIiIiIiI+mFoRERERERERERE/TA0IiIiIiIiIiKifhgaERERERERERFRPwyNiIiIiIiIiIioH4ZGRERERERERETUD0MjIiIiIiIiIiLqh6ERERERERERERH1w9CIiIiIiIiIiIj6YWhERERERERERET9MDQiIiIiIiIiIqJ+GBoREREREREREVE/DI2IiIiIiIiIiKgfhkZERERERERERNQPQyMiIiIiIiIiIupnWEIjpdRqpVSTUmrrAM8rpdQPlVJ7lVKblVJnDMd9iYiIiLIZ52BEREQ0koar0uhJABcP8vwlAGYZx10AHhmm+xIRERFlsyfBORgRERGNkGEJjXRdfwtA6yCXXAHgaV28ByBPKVU+HPcmIiIiylacgxEREdFIso7SfSoB1Jm+rje+d2yU7k9ERESUjTgHo1MWi+to6Q6hqSuEpq4gOgIRRGI6ojEdsXgckZgOh02Dz2mDz2lFjtOKXJcNlXluuOyWTA+fiIiGwWiFRirN9/S0Fyp1F6R8GpMnTx7JMRERERFNdEOag3H+ld2CkRh2NXRhV0MXdjZ0YVdjJ/Y2daO5K4R42hn7iZX4HJhS6MbkAg9mlnixeFIuFlXlwesYrf/9ICKi4TBaf2vXA5hk+roKwNF0F+q6/hiAxwCgpqbmFP8zRUREREQY4hyM86/sEozEsP5QG97d34L39rdgY107IjH5Y3faNMwu9eGcmcWoyHOixOdAsc+JkhwH8lw22CwabBYNFk3BZlEIRePoCkbQEYiiKxhBuz+CulY/DrX6cbjFj7f3NuPl9fUAAKWAWSVeLJmUh7NnFOG82cUo8Ngz+VEQEdEJjFZo9DqA+5VSPwewEkCHrussiyYiIiIaWZyDEQCgtSeMP2xvwG+3NODdfS0Ix+LQFLCwMhefOmcalk7Kw5yyHEwucMOipStQG1hpjnPQ59t6wthU346NdXL8fnsjXqyth1LA0kl5uHBOCf5ubgnmledAqZO7NxERjaxhCY2UUj8DcAGAIqVUPYCvAbABgK7rjwL4LYBLAewF4Adw+3Dcl4iIiCibcQ5Gg+kMRvDrTcfw2y3H8O7+FsTiOiYVuHDzWVOwamYhlk8tgM9pG/Fx5HvsuGBOCS6YUwIAiMd1bD7SgTd3NuHNXU34nz/sxv/8YTdmFHvw8TOqcOXSSlTmuUZ8XEREdGJK18duBXJNTY1eW1ub6WEQERHRCFFKrdN1vSbT46Akzr/GN13Xsbm+A8+9fwi/2nQMgUgMUwvduHRhOS5dWI75FWOvmqe5K4Q/bG/EqxvqsfZgG5QCzpxWiGuXV+HvF1bAbh2WDZ+JiMhkqHMwdqIjIiIiIhrnQtEYXttwBE+/ewjbjnbCZbPgiiUVuH7FZCyqyh1zQZFZsc+BG1ZOxg0rJ+Nwix+vbjiCVzbU4wsvbMJ//nYnbjlzCm48cwr7HxERZQArjYiIiChjWGk09nD+Nb74w1E8//5hPP63/WjsDKG6zIcbV07GFUsrkTMKS89Giq7reGvPcfzk7QN4a3czHFYNVy2txF3nTcf0Ym+mh0dENO6x0oiIiIiIaILqDEbw1JqDWL3mANr8EZw5vQAPXLMY58wsGtNVRUOllML5s4tx/uxi7Gnswuo1B/HK+nq8WFuHj59Rhc9fNAuTCtyZHiYR0YTH0IiIiIiIaJwIRWN49r3D+NGf96DdH8FF1SW498IZWDalINNDGzGzSn341scX4v9+eDYe/es+PPPeIby24QiuXT4Jn/27mSjPZdNsIqKRwtCIiIiIiGiM03Udv958DP/9xk7UtQZwzswi/NMl1VhQmZvpoY2aYp8DX/nYPNx57nQ89OZe/HztYby0rh53njsN914wEx4H/9eGiGi48W9WIiIiIqIxbFNdO776+jZsqmtHdZkPT39qBc6bXZzpYWVMWa4T37xyAe4+fzoeeGMXHnpzH15edwRfvrQaly+umBDL84iIxgruX0lERERENAZ1BCL4ymtbceXDa3CsPYAHrlmM33zu3KwOjMyq8t34/nVL8fI9Z6HY58Dnf74R1zz6LrYe6cj00IiIJgxWGhERERERjSG6ruP1TUfxzV/vQGtPCLeeNRX/8JHZ8I3j3dBG0rIpBXjtvlX4RW0dvvPGLlzx0Brcee50/J8PzYLTZsn08IiIxjWGRkREREREY8TR9gC+9PJm/G3PcSyqysVPb1uOhVXZ07foVFk0hetWTMYlC8vxn7/ZgUf/ug+/39aAb39iEVZMm7hNwomIRhqXpxERERERZZiu63hlfT0++v23sO5QG75+2Ty8eu8qBkYnKddlw39dvQjP3rES4Vgc1/74XXzlta3oDkUzPTQionGJlUZERERERBl0vDuEf3l1C97Y1oiaKfn4n2sXY0qhJ9PDGtfOmVWE33/hPHznjV148p2DeGtPM35w3VIsmZSX6aEREY0rrDQiIiIiIsqQP+1oxEe/9xbe3NmML19SjRfuPouB0TBx26342mXz8cJdZyEa03H1I+/goTf3IhbXMz00IqJxg6EREREREdEoi8Ti+I/fbMcdT9WiJMeJX332HNx9/gxYNG4XP9xWTCvAbz9/Li5eUIbvvLELNzz+Ho62BzI9LCKicYGhERERERHRKKpv8+OaR9/F4387gJvPnIJX7z0bc8p8mR7WhJbrsuFH1y/FA9csxpYjHbj4+2/hTzsaMz0sIqIxj6EREREREdEo+f22Blz6g79hX1M3HrrhDHzzygXcFn6UKKVw9bIq/PZz52JSgRt3PFWL//n9Li5XIyIaBEMjIiIiIqIRFovr+M4bO3HXM+swpdCDX3/uHPz9ovJMDysrTS3y4OV7zsY1y6rwoz/vxW0//QCtPeFMD4uIaExiaERERERENII6gxHc+XQtHnpzH65bPgkv3cNm15nmtFnw31cvwrc+vhDv72/FZT96G5vq2jM9LCKiMYehERERERHRCNnb1I0rH1yDt3Y345tXLsC3Pr4QDiuXo40FSilcv2IyXrrnLADAtT9+F69vOprhURERjS0MjYiIiIiIRsCfdzbiqofWoCMQwXOfXombz5wCpbg72lizqCoPv/rsOVhclYfP/WwDvvuH3YizzxEREQCGRkREREREw+7JNQdwx1O1mFzoxuufPQcrpxdmekg0iAKPHc98egWuXlaFH/5pDz778w0IhGOZHhYRUcZZMz0AIiIiIqKJIhbX8R+/2YHVaw7gw/NK8YPrlsBt55R7PHBYLfjO1Yswq8SLb//vTtS1+vHELTUoyXFmemhERBnDSiMiIiIiomEQCMdwz7PrsHrNAdy+aioevWkZA6NxRimFu8+fgcdursHepm5c9fA72NvUnelhERFlDEMjIiIiIqLT1NwVwnWPvYs/7GjE1y6bh69dNh8Wjf2LxqsPzyvFC3edhVA0hqsffQfrDrVmekhERBnB0IiIiIiI6DTUtfpx9aPvYFdjF3580zLcvmpapodEw2BhVS5euWcV8lw23PD4+/j9toZMD4mIaNQxNCIiIiIiOkU7GzrxiUfeQbs/gufvPBMfmV+W6SHRMJpc6MbL95yN6vIcfObZdXju/UOZHhIR0ahiaEREREREdApqD7bi2kffhaYUfvGZs3DG5PxMD4lGQKHXgZ/duRLnzy7Gv7y6FQ+9uTfTQyIiGjUMjYiIiIiITtKbO5tw00/eR5HXgZfuOQuzS32ZHhKNILfdisduqcGVSyrwnTd24du/2wld1zM9LCKiEcftHIiIiIiITsJvNh/D53++AdXlPjx5+woUeR2ZHhKNAptFw3evXQKPw4pH/7oP3aEIvnH5AmhseE5EExhDIyIiIiKiIXp1Qz3+4cVNWDYlH6tvWw6f05bpIdEo0jSFf79yAbwOK3781n74QzH899WLYLVwAQcRTUwMjYiIiIiIhuDFtXX40iubcdb0Qjxxaw3cdk6ls5FSCv90STV8Tise+P1u+MMx/OiGpbAxOCKiCYh/sxERERERncAz7x3CP768GefNKsbq25YzMMpySinc/3ez8JWPzcP/bmvA/c+vRzgaz/SwiIiGHUMjIiIiIqJB/OTtA/jKa1vxobkleOyWZXDaLJkeEo0Rd5wzDV+/bB7e2NaI+xgcEdEExNCIiIiIiGgAP11zAN/89XZcsqAMD9+4DA4rAyNKdduqafi3y+fjD9sbce9zDI6IaGJhaERERERElMbT7x7Ev/1qOz46vxQ/vH4p7FZOnSm9W8+eim9cMR9/3NGIe59bh1A0lukhERENC/6Xj4iIiIioj+ffP4yv/nIbPjS3FD+6/gw2OaYTuuWsqfjmlQvwxx1NuP/5DYjEWHFEROMf/+tHRERERGTy4to6/POrW/B31SV46EZWGNHQ3XzmFHzjClmq9oUXNiIW1zM9JCKi08JtH4iIiIiIDK+sr8eXXtmM82YX4+Ebz2APIzppt5w1FcFIDP/5252wWzU8cPViaJrK9LCIiE7JsPzaRCl1sVJql1Jqr1Lqn9I8f5tSqlkptdE4Pj0c9yUiIiLKZpyDDa//3XoMX/zFJpw1vRCP3cxd0ujU3XXeDHzhQ7Pxyvoj+NdfboWus+KIiMan0640UkpZADwE4MMA6gGsVUq9ruv69j6XvqDr+v2nez8iIiIi4hxsuP11dzM++7MNWDwpD4/fUsPAiE7b5y6aiWA0hkf+sg9OqwVf+dhcKMWKIyIaX4ZjedoKAHt1Xd8PAEqpnwO4AkDfCQsRERERDR/OwYbJ2oOtuPuZWsws8eHJ21bA42AHBzp9Sin840fnIBiJYfWaA/A5rfjCh2dnelhERCdlOJanVQKoM31db3yvr08opTYrpV5SSk0ahvsSERERZTPOwYbB1iMd+NRP16Iiz4Vn7liBXLct00OiCUQpha9+bB6uXlaFH/xpD3665kCmh0REdFKGIzRKV2PZd9HurwBM1XV9EYA/AnhqwBdT6i6lVK1Sqra5uXkYhkdEREQ0IQ3bHCxb5197m7pxy+oPkOOy4dk7VqLI68j0kGgCUkrh2x9fiI/MK8W//Wo7Xt1Qn+khEREN2XCERvUAzL+1qgJw1HyBrustuq6HjC8fB7BsoBfTdf0xXddrdF2vKS4uHobhEREREU1IwzYHy8b517GOAG5d/QE0BTz36ZWoyHNlekg0gVktGn54/VKcPaMQX/zFZvxpR2Omh0RENCTDERqtBTBLKTVNKWUHcB2A180XKKXKTV9eDmDHMNyXiIiIKJtxDnaK2v1h3PKTD9ARiODJ21dgapEn00OiLOC0WfDYLTWYX5GDe59bj/f3t2R6SEREJ3TaoZGu61EA9wN4AzIReVHX9W1KqW8opS43LvucUmqbUmoTgM8BuO1070tERESUzTgHOzWBcAx3PFWLQy1+PHbLMiyozM30kCiLeB1WPHn7ClTlu/Dpp2uxs6Ez00MiIhqU0vW+S9/HjpqaGr22tjbTwyAiIqIRopRap+t6TabHQUkTef4VicVx9zPr8OauJjx8wxm4ZGH5iX+IaAQcaQ/gEw+/Ax06Xrl3FSq5PJKIRtlQ52DDsTyNiIiIiGhM03UdX35lC/68swn/fuUCBkaUUZV5Ljz5qeXwh2O45Sfvo60nnOkhERGlxdCIiIiIiCa87/5hN15aV48vfGg2blw5JdPDIUJ1WQ4ev6UGda0B3PHUWgTCsUwPiYioH4ZGRERERDShPff+Ifzoz3tx/YpJ+NxFMzM9HKJeZ04vxPevW4INde347M82IBqLZ3pIREQpGBoRERER0YT1px2N+MprW3HhnGJ884oFUEplekhEKS5dWI6vXzYff9zRiK+9vg1juecsEWUfa6YHQEREREQ0EjbWteP+5zdgQWUuHrzhDFgt/H0pjU23nj0VRzsC+PFf92NSgRufOX9GpodERASAoRERERERTUAHj/fgjifXoshnx09uXQ6Pg9NeGtu+9NFqHGkL4Nu/24mKPBcuX1yR6SERETE0IiIiIqKJpa0njNufXIuYruOp21eg2OfI9JCITkjTFB64ZjGaOkP44oubUJbjxIppBZkeFhFlOdboEhEREdGEEYrGcPcz63CkLYDHb6nB9GJvpodENGROmwWP3bIMVQUu3Pl0LfY2dWd6SESU5RgaEREREdGEoOs6/vGlzfjgYCu+c80iLJ/KKg0af/Lcdjx52wrYLAq3P/kBjneHMj0kIspiDI2IiIiIaEL43h/34Jcbj+KLH5mNK5ZUZno4RKdscqEbT9y6HM1dIdz5dC2CkVimh0REWYo9jcaCeAyIB4FYEIiFjMchIB42jojpHAH0GKBH5YjH5GvEAd04MMA2nUoDoMlZaYCyGIcV0KzyWLObDhugOQCLE7A4AM1pPHbK9URERERjxEvr6vHDP+3BtTVVuO/CmZkeDtFpWzIpD9+7dgnueW49vviLTfjhdUuhaSrTwyKiLMP/8z9ZkW4gcBQIHAMCDUDoOBBuAcLtckQ7gEgPEO0GYn4gFpAwKB5Khj7xiBH6xAYPecYyzQZY3IDVDVhcgNULWD2msw+w+QBbjpytOYA9F7DlAvY8wJYnX9sL5GcU/wNIREREp+a9/S348iubsWpmIf7jqoVQnFfQBHHJwnJ86eJq/Nf/7sS0Ig/+4SNzMj0kIsoy2RcaxWNA4AjQcxDoOQz4jwDBY0CwCQi1AJF2INxhhD6BZMVPoprnlA02eUk8N47Co3gEiHcCkS6jgkmZKpkA6DqAOBCP4oSfm7IC9nzAUSAhkr0QcBbJ2VEEOIsBRzHgLJHDUSLBFCeEREREWe/A8R585tl1mFzgxsM3LoPNwu4LNLF85vzpOHi8Bz/6815MLfTgE8uqMj0kIsoi2RcaNf8N+NOFQ7hQmc6nExYljKNAaMh0OfR48suTZnzOkS6pzAo0yNeJJXt6NP2PWdyAs1QOVxngLANcFYCrPHl2V0ropDh5JCIimog6/BHc8eRaKACrb1uOXJct00MiGnZKKXzzygWoa/Pjn17ZjMp8F86cXpjpYRFRlsi+0KjrwBAv1PucJ6qhVOuM5Gegm/ozncSPxcNSHRZuATq2GT2f0uwsoawSHrkqAXcV4J4kh8c4uydL9RKrloiIiMaVSCyOe55bh/q2AJ67cyWmFHoyPSSiEWO3anjkxmW46pE1+Myz6/DL+1bxn3kiGhXZFxoFm0bpRgqABmhGs2n0bT5t/trUoFpXycoYpSSvUebXTEfv/1hPVAH1Ofc2zI6ht0ooHgNgNNRO9FkaluV45vEm7j9M9CgQiwIn2khCjxpLEJuAtg0SLOl93pfmkPDIOxXwTE2ePdMA7zSpZmKoRERENGbouo6vvLYV7+xrwf9csxjLpxZkekhEIy7XbcPqW5fjyofX4FNPrsWr961CjpPVdUQ0srIvNCpYkuabCoDF2EHMKk2elSW5o5jSjLwj0afHtHtZLALoxpFCBxAzApmJYoDgKyUg0pOhk/kYUmBkvI5KXD4cywKRDJigGeFP7w1EPAR07wX8hwD9L/3/LDWHhEe+WYB3BuCdDvhmAt6ZEjBp/I81ERHRsIpFZWORcA8Q9gPhbiASACJ+IOLHX7YeAjYewBPVufhQYA/wlyAQDQLRkHEOS1/KaEjmarGwcSQ2JTHmBnHj0GNA3Ji/xE0blaT88s0k8csk8y8ANYt8X7OaDouxeYgNsNhNZztgdQJWR/Jsc8njxNnuAWxuwO4G7F557PACdp+crU7+UisLTS3y4JEbl+Hmn7yP+5/fgNW31sDKPl5ENIKyLzRylqb5pg7AmDQAfapXTrVJdSKgSDSJ7vsf9b6VQKOxi5qWGvT0VjiZQx9zoJIIgBIhUDwZlp3QyX5uKllZpQ+1KknDyVUwxQe5VJc/f80KKLtMKBMXx0NA506ga3eaMEuTHkq51UBONeCbLeFSzmzAPUUmi0RERAQc2wTs+h0Q6gJCncY5cXRLMBTulsexNEvOTS4EcKENwEHjACScSQli7IDF0SeosQMWb59Qx3icCIA081xJpZ4BpFR1p8yTdCNwiiXDqEQwlQisEsFWLGwEXCF5r5EgEA30r4YejLIADh/gzAEcucY5B3DmAq48OTvz5LErH3AVAO4C43E+5yjj2FkzCvEfVy3Al17egn//zQ58/fL5mR4SEU1g2RcaRXsGeMJcgZJmudegNGPbeZecLW6ZpGgOOSubTGQ0W7KaSZmqmJRpotIb6hi/rTIHO7p58gL5GgBUYg2b+UieJPwBJDSJSSCiR43ftIWSO8TFgsbXAXkcC0pz6lgAiPoH+ewG+Dw1K3qDHT2ephrLfLlVPjvNbvycLuOLBeRIaygTqz5VRYOKy+cwoET1GVJ31AvUy9Hwp9R7KYv0TcqdD+QtklApp1oCJlvOEMdEREQ0QTRsAf7yLcDmMQIOnxx2L+AplrPdY1TTeE2VNsmKm8NdwBde3YOCvFz88Oaz4HJ5AZtTQqLxHoLougRLEX9KVVWy0sqfDNdCXclzsFNCuGAn0FkPNG0DAh1AqGOQmykJk9xFgLsQ8BQZRzHgKZHH3hLAWypnRw6rmsaYTy6fjD2N3Xji7QOYUeLFzWdOyfSQiGiCyr7QyOqRShKLzQhzrOgNaAD0r/6JJ8uU9Tik90/c9LzxM7EeOcadRAiV+I2asfRMsyTDLYsDcPqSIZiWCMTsRshjl6+VlvyMEsv24oky8W45wh1ApL1/gKRHgGjie4NUECk7YMsF7LkSvGgOuS7x2tEOCbf0RLnYcPZRSrcMMTEuq3wOyiLXxIIyhp6Dchz9Ter1tjypSMpbDBQslWApdx7gLB6+8RIREY0liz4JLL7+lMOd1p4wbnp5DQL2GXjwU6vgynUN8wAzTCmphLLaJdA5XfEYEOwAgu1AoA3wt8k50Ar4W+ToOS7n1v1A3fvyOF21k9WVDJF8ZYCvPHnOKQdyKoGcCgn4aNR8+dK52H+8B19/fRumF3mwamZRpodERBNQ9oVGwUZAD8ta9xFnWqKWUuas9TmbloYp0+Ne5ubWgFQM9Qm2ekOtOE5uqVviteNGNZOxBC2eCM+Gqa+QmbJK8GNxS4hndScDFxhjiEekyinaBUS65AzIn124WY6BWNyAo0iWIjpLAXuhvI9wKxA4BgQbgHC7BDvD1jcpJuNN+35tgMUp7y8elusi7UDrWjn2m8fukf5JeYuB4rOBvIUSKDnY4JOIiMY5y6n3AAxH47jn2XVo6AzihbvORPlEC4xGgmaR5Wjuk5hDxGOAvxXoaQZ6moDuJqC7UY6uRqC7AWjeBez/a/pKJmeuESBVArlVQG4lkDvJeDxJvm/Jvv/9GCkWTeEH1y3BJx55B/c+tx6/vG8VphYxuCOi4ZV9f2tb+k4yjCbY5mVfAPrvOnYqu38leujERr5d0SkxN7W2JIMt6Mba/Ghqb59+lLEszw1oTqk8QuK3h0a1UdxY6hbtSb6OHgUiHXL0vpQl9d6DsbgBq9dY+meRCU48mFzKFvMD/sNyDPTzzhLZMc03E3BXAroGhJqArp1A90Eg1CxL8oYcKg3wGSmrvJ9E6JX6pLGc0Sk/H/VLtVrHVjkOPZe81OqVBtz5S4Dic4GCZUDuXONniYiIJi5d1/G117fi/QOt+MF1S7B0cn6mhzRxaRbAWywH5g1+bbgH6GoAOo8ax5HkuaMeOLpeKpfMlEUqknInAXmTgfwpQP5UIG+KPPZVSE8pGjKf04YnblmOKx56G3c8xR3ViGj4ZV9o1HOozzeMJtim3s/ZI1Gh1HfJlakCSlmM4CxdkKMbPY8GqLDpy+IErD5ZVmbLkcdWrwQniSqcSDsQbJKKsHBL+tdJVOvEI0Z/oaixHGyApWOaXfpJ6ZDAKhZMLhtrfiugDBITAAAgAElEQVT1WmUD7PnGTmkzJZhxlktzyta1QMcWwF9vBF5D+IclbdNwzRhPfODPT3PKZ6OUUXHVDbRvluPA08nr7IUSfBUsA0ovAopWSmNu9h0gIqIJ4ql3DuJnH9Thvgtn4IollZkeDiXYPUDhDDkGEvZLkNRxGGivAzrq5Nx+GDj4N2DzC0iZT1nsEiAVTAPyp8m5YDpQMENCJqt9xN/WeDS50I1HblqGm554H5/72Qb85NblsGicCxLR8Mi+0CineogXWiRs6Nu3R7Mnm1tbbKaG1okmyeaqnUSTa9Xne1qfx6YG1onHvf/9NHoqJXZ3i4eNnjnhZCPr3rPxvURj697nokZ/IeN1TmiwXcaGSFnQW8GVCJ0SzbVDgywtS1Tf2HxAzjzAXgA4CuVsy5HgKeqX5WmBY0DgqJzTBUYWj7xOYmmYbowh0jVA/ykl14SapeqobQNQZ37eKoGSdxrgmyNhjatMdj5peQdo2wj01AP64Du+yJ9pmms0V7InUjwIhIPpr7H55HON+mXJXcv7cux52LjGBjgrpEdS8Sqg/GIgf5F8n4iIaBx5e89xfPM3O/DheaX4hw/PyfRw6GTZ3UDRTDnSiYakKqntYJ/jAHDoXSBsqtRWmlQoFc4ACmcah/E4d9L4b4R+ms6cXoh/u2I+/uXVrfiv/92Jf750bqaHREQTRPaFRs4iIGeusfwqlgxUencTSwQzUVlaFR9o567RpEy7r9lTG1JbHEZVihuwFEpAktjBzWr0DOrtHeQxKnvcEoYpu9Hw2lgaFgsCoRYjNDkugUSoFYi0GU2mE/2Feoyd1ozPKV3CpMdw0svylFXGEQ8DwWapNhrsWqtXAqW8JbJLmascsHmNLW+DQKQT8B8B/HWyu1mob+WSAhzFEkhZvRIC6nF5b+FWuX/KbmrRZD+ltg2pL6XZpeqnaIX88+WulM+1ax/Quh7o2iVjGkzaf9as0nwSFvn84wEglOY6a468B8SASDfgPyTHsd8Bm/9V3qs9D/BMk6qksg8BFZdIAEVERDQGHTjeg/ueX4+ZxV5875NLoLFyYuKxOgauVtL1ZJPu1v1Ayz6gdZ+c636WGihZjNcpmgUUzgKKZsvjotmyG1+WuHHlFOxq6MJjb+3H7FIfrl5WlekhEdEEkH2hkdUry3csjj4BjLmiyBTQKKtRQWRLU01k7V811LsTmSGxTKhvj6S+DawTIZZuVBT1hliJXcgSlUVho5IoZJyDco4FgHCbUc0TMPrj+CXgGXQb+T5sOdKkuneHsjwJVnyzpcrGnm9U/xRISOIoAKz5Mkb/QaD7kIQ0/nogeEzCn3CLNJ6Odsl2sQNVO6Us5RpsYmg0y44YO7F17xvk/eTJn3fhmYBnilGlY5PPPuqXUMx/SJaq+ev67BiiSd8jZ6m8b4vTqPAJAoEjqcvU4mHj/R4Dmv+WOgarF/BMls/QO0vW6vvrgLZNQNdepF/6lxBN3w/JYvSRigWBuB+IdsrR93OyF8k/37GALHFrWy/HvseNt+iUgCt3AVB6PlB1pVRSERERZVBnMII7n66FpoAnbq2B15F9U9aspxTgKZJj0orU53RdmnW37AWO7wFa9gDH9wKN24Adv07tj5lTBRTPBoqrgeI5ci6afXINwseRr3xsHvY2deOfX9mCaUUeLJvCHmBEdHqUro/dJj41NTV6bW1tpocx/sWjyQAp0i3hQbRLHkc6jcedxmE0qA4nzm0S+ITbTtDHR0mA5CiWncscxdJs2lkCOIyzs1SWc9kLJewIHAW69wJde4DuA6ag6bjcK90SrnT3PZ21dMomVUreqXK2F0jIosclaAk2G/2P9kuvJTNHMeCdIRVO9jwJIKPd0ki754BUaw32HjS7hDqeSYBrktw3cBRo3wKEj5/8e9GMqjPEZRy9n0ufz8jikRBMjxr/LPSkPq8s8t5y5gBFZwOVHwMKV0hgSkQ0zJRS63Rdr8n0OCgp0/OvWFzHnU/X4q3dzXjmjpU4a0ZhxsZC41A0LMvbmncBx3fL0bxTwqWIqY+kt1QCpJK5xnkeUFItO8CNc+3+MK54aA384Rh+df85KMvlxilE1N9Q52AMjWjo4rFkkBRqMZavtUglUei4HEFjaVuoKfk4XaijOSRAcpZL6OIql4ogV4VUvrgqJdiIdkuY1HMY6NotAVPPQan0CR4fuPl1iqEESxbjsj5VP5pNqo280+Vs80l4EotIlZP/sFQL+etSf85ZYlQWzZTQDFHAf9QY/yH52bRNsiGhjS1XQjZbnow/cMTYDe5k/321AFan7A4X8yNZ1dS7TWDyOmex3DvqlyCx7/hs+YBvBlC4UvoklZwr1WhERKeBodHYk+n517d+twM//ut+fPPKBbj5zCkZGwdNMPG4NOJu3iUhUvNOoGmHnM1hUk4VUDpPQqTS+XIumj3umnDvbuzCVQ+twYwSL168+yw4bdnd84mI+mNoRGNDPCahUmJHtECDnIMNxmNTM+twW/+ft3oAdxXgqjIqcoyze7IcVrcEUz2HpLqna5/0D+o+IEFLvG+odJKVScqSXJqoR/tXDjmKpNrIM81YwmaXe0Y6ZUxdu1IrlJRVgpecagmUNCsQaAa6d0n4FDreP7jqpclSN3uuUdXkl88R8QGuH+x9GU3c42GkBEmJ95nQu7wtaPRU6rPU0eKR5WwFy4Dyj0jjbfdk7t5GREPG0GjsyeT867UNR/B/XtiIG1ZOxn9etTAjY6AsE4/L7m5NO4Cm7XJu3C4VSol5pGYFiuZImFQ6HyhdCJQtkGqlMTzn+cP2Rtz1TC2uWFyB731yCdQYHisRjT6GRjT+JJas+Y/IEUic64GeOqnmCR7r03cI0gzbPUWWmHnMx2Tp/RNsBLr3S++j7n1ApxHQRNpTX0cZjbAH7TFkojmM3kJG+BLpSH3eXiDVRp4pEvQoq/SfCjUnl+WZQy1XBeCrlnFbXbJEsGMX0L07fV8jM4tLei7F40Zvo1P999oKef+Jn9dkGZ25ibc1Ryqu4mEJx/oGaZpd/jwKzgDKLpLKpNy53L2NiNJiaDT2ZGr+tbm+Hdc8+i4WT8rDs3eshN2qnfiHiEZKLCJL2pq2S6+kxNFZn7zGXQiULgDKFiaPotmyucoY8eCf9+CB3+/Gly+pxt3np2k4TkRZi6ERTUzxqARLPYdluVbPYaPKyGhm3XNQehGZOYpleZl3mlQFeWdItY+9yOhBZAQ4XXuAzt1A587UkEZZJCCKRwF9CE3FlQWw+qQqSLPIjnPh1tRr3JMA3yzAWSbVVIhLSNR9EOjaafQkMjhLpIG2o0heO9QmlUmBo0MYixWABdCH0h9qwBdBas8jq3weMX/y+5pbgjHdqLLq13xdk2WH+UuB0guBwuVA3mLZ7Y6IshpDo7EnE/Ovpq4grnhwDTSl8Mv7V6HI6xjV+xMNWaBNwqOGrUDjFjk37ZBfDAJSdV4y1wiRFgPliyRYytAubrqu4/6fbcBvtxzD6luX48LqkoyMg4jGHoZGlJ103ajkOSABUvcBqTLqSZwPpS7/sriMEGmmhDi+mRLQ2AukEqlrj4RInbvk3LPfVOmkjMBHkyqpoQRKVp+EP5oDiAekL1Osx/S8B/DNSe70BiWhk78O6NzRJ0wqk6V7Vq9UAvmPpPZWUhZjrKf673jfpXyDLO1L7EQY8yc/X+UAHEbD7XBH+v5TzjIgfwlQch6QfwZQsFRCMiLKGgyNxp7Rnn+FojHc8Pj72Ha0Ay/fczbmV7BfHo0zsajs4NawxTg2A8c2A4HELw0VUDgDKF8MlC2Sc/niUdvBzR+O4upH3kVdmx+v3bcKM4r5SzsiYmhElF48ItVJiaVqXXuNY498ba6QsXpkeZlvtuwkllMty96UJlVOHTuAju0S5nTuSl2mZc0xGmaHUityBmJxGVVHLqloCrcaTcQNymo01p4qr62UBEg9dVKZFEssH1PJJuLQjWbkjcnX0Yyd4YbUQDydvlVHNqMHUrpm5075bVs0YLqfDXAWJPs+pWsGbs+XiqSis2SJW/5S43PnOnyiiYih0dgzmvMvXdfxTy9vwQu1dXjwhqX42KKKUbkv0YjTdaDzaDJASpw7DievyZ1kBEhLkkGSr3REhnOkPYDLf/Q2ct02vHbfKuQ4x84SOiLKDIZGRCcrHpP+SYllal27jfMuqVoy91JyVwE5c+XInSvVSVajf1LHNuPYaoRJiSBKk13RlFGZlDZM6hPKaA7pdWT1AogB4XZpGp64RlmkobZnirw2dKNC6oBURfUuH3PILm6aJg3HI53J+9lyJbwxVzGdMiV9nvRImiVqMHpA2WQJYeJ5ZZNd4vSI0Rcqzd9JVi+QvxgoWCHVSPlLJcTTrMMwZiLKJIZGY89ozr+efvcgvvrLbbj/wpn44kfnjMo9iTLK32oESJskRDq2EWjZm3zeWwZULJEgKXHOKR+WW7+/vwU3PvE+zptdjMdvqYFF4y/kiLIZQyOi4RQLSkVSYpla77EDiJqWlzkKgZx5QK5x+OZIFVGwQUKk9q1A+xapauoNdOyybE2PS5DUt7G0XISUXdIsLqkosnplOVi4TRqH976mTZbbuaokzIpHZdle567UBuC2XAltoqY+RJpTluchJsvnhtoYfCCaU6q24iHjs+qz5K03SPL3CZJyjZ/pSr3e/LnlLUwua8tfCuQtkvdLROMGQ6OxZ7TmX+/ua8FNP3kfFxj/A6vxf2ApWwU7ZVnbsY0SJh3dKLu3JeY8iSCpYqkRJi095YqkZ987hH99bSvuvWAG/vHi6uF7D0Q07gx1DsZf0xMNhcUJ5C2Qw0zXAX+9hEcdO4DO7bJk7fCLEuQkOAqB3PlylH9Y+igpi1QwtW8B2jcDbZvSL3GL+lN3LwOkUqd7n1QtmXs02XKNMMkFxMLyusEG02t6pIeQo0SCmmiPjD/cYnpPMSDaIfdNTFbsRYCjQHYSCR4dINgaQDwIhPuM314gwVfUL4GVua8TlARCejT1Psoq4Vo8lAyYWtcBbRuBfYnPQJOwLLGsrWApkLcEcBYNfbxERDTi6lr9uO/59ZhW5MH3r1vCwIiymzMHmLpKjoRQdzJIOrpRzrvfQO/czFch4VHvsQTwnHi+c9OZU7D9WCce/ss+zC3PwWWLuSSUiAY3LJVGSqmLAfwAgAXAE7quf7vP8w4ATwNYBqAFwCd1XT94otdlpRGNW7qeulStfatUGnVsMy0NgwQ8eQulQiZ3AeAqkyClc7uESO2bZJlcYmmc5pCwJRYYOLhRFmMMpjDJVWEERXYJaPxHgYgp1HKWSt8gW478XKgF6NwDxP2m17UmexApK+CZLMvKYkFpOB7vs2vdyVAOee+aVZaohdv79DtS8r77LW2zAhaP0Yg88Xlo8jrm5XHuKgmP8pcYVUlLAM809kkiGgNYaXR6RmIONtLzL384ik888i6OtPnxy/vPwbQiz4jdi2hCSQmSNshxfA96g6TcyUClKUgqXwK48vq9TDgax41PvIctRzrw0mfOxoJKNp8nykajtjxNKWUBsBvAhwHUA1gL4Hpd17ebrrkXwCJd1z+jlLoOwFW6rn/yRK/N0IgmnERlUoexTK19ixEmbU8NQnLnSpCUt1gaYFscsjNa20Y52jcll8UpixEkhfo0uO7bH8kuDah7l3c5JfixG5OJUJuxu1w4+bre6bKbmTKqknoOpDboNt/DlpcMniId0hsqZgqdTpa9SIIkPQ6EjwPBFvRbKtfbbNufGmhZXNKAG6bvaXYJnHrHmyOfb/4S6ZeUv0QqwSzOUx8zEZ00hkanbqTmYCM5/9J1Hfc/vwG/23oMq29bjgvmcMdMotMS7DSWtBkh0tH1QNvB5PMFMyRAqjzDCJIWA3YPmrtCuPzBt6EphdfvX4VCryNjb4GIMmM0Q6OzAHxd1/WPGl9/GQB0Xf+W6Zo3jGveVUpZATQAKNZPcHOGRpQ14hFput2+RQKhxNlfn7zGWWqEHIslULLnS0VO+2agbYMc5kBHcxrVSKaQCCq1IkgZO2eYwyZnmVQmWZwSRAWPAYGjyeft+YB7svRTiodkjOYlcMkXlwof9xQJaAJHZAmfnqZB9pBY5LVcZVItFTgqfZr63dYmIVs0iGRoZJH3b24+3lu1Ze6lZJEG272fs3F2lZ3imInoRBganbqRmoON5PzroTf34jtv7MKXL6nG3efPGJF7EGU9f6spRDKOziPynNKA4mqg4gwccVfj828p2KsW4qk7z4XNomV23ESUIhSNwWG1jNjrj2ZPo0oAdaav6wGsHOgaXdejSqkOAIUAjoOIZNlV3nw5cF3y+6HWZL+j9k1SZbTrB8mQw+IymkEvAaqulJAmFpLlba3rgNb1RoNsSG8hZf5XXgNsPjmH29BbxRNskjDKHDhZXLKcy54vxUWhNnntRAClLBIkOQql6XawUYIkf50cvbd0A76ZUuGkOSQc6zmIlCbfA4oB/v1yJFjc0h/KWSZ9mXoOyHuJRlJ/VI8b78WC3iApHpGJk3kZm+YEgs3A0V8Dh55Pft9Zkqz8ylskQVJOtYRTRESZM67mYH/e2YgHfr8LVyypwF3nTR/t2xNlD3cBMPMiORK6GpOVSEfWA7t/h0r/s3jJCoSPWdD0wExUzl8FVBgVScXVgIXtb4kyZWdDJ25bvRY/vH4pVkwryOhYhuNvgnRNQdLtI36ia+RCpe4CcBcATJ48+fRGRjTeOQqA0gvkSIhHZOe2xFK1tg3A4V8Aex+T55Umu7YVnAFUfwHwTpPQpGu3BEkta40gJw6EW5GyxMziMZajWSU8inbI92MBoGc/0B0zlrgZ3JMBV3myqXXgSDKkAiRkcpbJvUJtRq+k7XLIYAF7oYzRVSk7u7VvNsaVjpKASo/JmGN+oGOLHAm2fMA7FXCUA6EG2TEu1pNmqVzceB0reoOkmLHMzRwkWX3Sc6l9G9D412RVlrIaVUlGT6rE2V3FXklENFqGbQ42GvOvIq8DF1WX4r8+sQiKf08SjS5fKTDnYjkAaZnQUQccWY/at/8IvX49ije+CHvtanne5gbKFiWXtVWcARRMBzRWIxGNtLaeMO58uhY6dEwtzPzO0FyeRjQR6DrgPwy0bkguVTNXGQHSnyh/KVCwDPDOlO917wNaa4Hj76Ve20uTpWqucgmj/MeAwGHT03YJT8yBjD3f6G2UCyAOBI8DXXtNvZJsgKtUXjvaDYQ7kNKrSFklaPJMkzDKf1CqkeIDLGvTHPKa8b49nUzvwV4AeKoAezEQbpJlcr2v16f3EzTje6YxaTapoEpcZ/VJY3GlJOgyLwu05Rk77S2UI3ehfG3v34iSiLg87XSMx+VpRDT2xOI6bvvpB3h/fzNe+WQZFmC/VCMdXQ8c22z0iQTgyAUqFpt2bDsDyJvMX5YRDaNoLI5bVn+A2oNteOHuM7F0cv6I3Ws0expZIU0YLwJwBNKE8QZd17eZrrkPwEJTE8aP67p+7Ylem5MWotMUbDIFSeul0qjbtLzLPcnYnn6ZbFUPBfTsA5rfkYqkUFP/17TlAJ4ZUlEDI6zq2N6nEbXT2NEs8T0b4Jth7OBmBSJd8nPBxtTX1Rzyc9Fu9Gvi7ahI9jPy10lYk46yy7I7pQGR7vS7uimLhDvOUgmUwi1SkZRYJqfZpTorZQc3DSnL6JTFtOwNUqXlrjLeewAIHAOiXcnrXZUSHuUukIbbufOB3HmAzZv+fRBlCYZGp26k5mCcfxFlnw5/BJc/9DZ6QjH86rOrUJ7rkidiUaB5pwRIRzdImNS4LVl57i40hUjG4StnkER0ir7xq+1YveYAHrhmMa5eVjWi9xq10Mi42aUAvg9pGLJa1/X/UEp9A0CtruuvK6WcAJ4BsBRAK4DrdF3fP/ArCk5aiEZAuD1ZidS6HmhbJ024E+GHqwIoqJGKJN9MABrQtQto/Issh+sb1ihNGlTnVMtZj8j1rRsk4AHkNaweCWFiphDHPUkOq8dout0oVUmJKp/ETmjxsNFjyXxfq9Gw2y3L3sItSN8bSZOqJ3u+hDzBJiCeblc3o8eTo0gqicLtUuWUYPFIUBTtHuA+QHIViPFZKrv0b3IUJj97/yEJxhI8U4CcedLPKmeeBEm5cyVEI8oCDI1Oz0jMwTj/IspOuxu7cNVDazCjxIsX7z4LTtsADXijIQmOEj2Sjm4EmnYYy/4BeEuNndqWGEHSEsDHTUWITuSldfX44i824fZVU/G1y+aP+P1GNTQaKZy0EI2SSJcRJK1LHp27kAySKoHCGqlI8hrNS1vXA01/kf5KffsFWXMk+MhfIkFSpC3Zf8m8lMvqk7O5ssiWI82t7QUANPnZ7v2pfY40u0xMdNMSMnkCsBUkl42lXa4GqWhylgL2Igmx/PVArCv9tRaXBE5WLxDulD5JCbYcQDN2YIsO8PMA+i2Bc02SqiSrR5btBZvlPZqDMXcVkDNXwrjcucbjuUbPKf72jiYOhkZjD+dfRNnr99sacNcz63DV0kp899rFQ+8/FvYDjVuTu7UdWQ8cN/1S0leeGiKVL5E+S0QEANhwuA2ffOw91EzJx9OfWgHrKOxmyNCIiE6POUhqqTUqknYln3dPTgZJnqkSvjS/Jf2Reg6kNsxWGuCskKVwhWdK9U33XuP1N8hStQSrV3oIRbuTr6EsEiQlmm7HAoD/qDTn7g2O+vYmMlFOALGBQ6TEfd1T5B6hZumjFOkY4GKjKsnqlbGYAy17vix9i0fk+/0acA/A4gVyZkpAp9nldYONQNceI1Qz2PIkSMqZYzrPkc+Hu7nROMTQaOzh/Isou/3wT3vw3T/sxr/+/Vx8+tzT2Okw1AU0bJFKpESY1LIX/YOkJUD5Yjm4tI2yUFNnEJc9+DbsVg2v33cO8j32UbkvQyMiGn7hDiPoqZUgqXWdhD8JnmlA4XIJktyVgP8I0PxXqTIKNCBlWZfFLVVLxauA0oskhGnfkuy/ZA6oLK7kEjZzRY+jRHZes+dLM/DwcaBzDxDtHIY3qySg8U4HnOVAsEGCpHALBg6nLBIkAamBkzVHltJpNhlbsCl1md5gnGUSCiV+vncZ324gcNR0b03CO99s45glR84sCcO0AUrMiTKModHYw/kXUXaLx3Xc9/x6vLGtAU/evgLnzS4evhc3B0nHNsrZXJHkKU4GSIkjbwqDJJqwgpEYrnvsPexu7MLL95yNueWj16KCoRERjY5wmyxVa1lrLG2rlXAlIWeO9EjKP0OWc3VsB46/K8vaUvojKVmSljsPKL0QKL9EeiC1bzJ6L20AOrYmq480u7FDmy69ghJNqzUb4J1lVCU5JLzpPmTsDjcMf9/ZCwDfHDmHmo2G3s1I2W2tL2UxqoeCyTEoB+CdCtgLAcRl2V7gmKkP1GA06QWVOzfZfDselUCra2//6iTNJuGXd4bsnOebKY99MyRoYoUSZRBDo7GH8y8i6glF8YlH3sHR9gBev/8cTC3yjNzNwj1Aw9ZkiNSwObVHkjMXKFskR7lxLpoNWKwjNyaiUaDrOv7fS5vx0rp6PHrTGbh4Qfmo3p+hERFlTvC4ESCZgiR/vTynNOnNU1AD5C+VipuObXJN90EgbmoSrSwS/uQvBco/CpRcKH1/Ev2R2jbK0Vt9pKTptGaX0CRiqjhyFEtwYsszdmA7BgSPpVk+1qeZ9VDYcuU92fMkwAock0MPp3ltvc/XCikVWM5yqdiyF8jOb8FGWYoXacWJKalIypkL5Mw2QjUl79FfL1VhXXtTAyUoCZ6806VqyzMt9ewqlz8zohHC0Gjs4fyLiACgrtWPyx98G4VeB16992z4nLbRu3kkCDRtA45tBo5tkiCpcRsQNeaJFgdQOg8oW2gESguB0vmAwzd6YyQ6TavfPoBv/Ho7Pn/RLHzhw7NH/f4MjYhobAk0GMva1iYDpWCTPKessh19QY1UwoSaJEhq32wsazP9PaVssuNY4Qqg4mI5Q5NrzUFS4EjyZ2y5UuUUj8oStt5+S0oqbpxlUqkUapGKn0hbmjcwSM+kdDQH4KsGnMVA1A+EGuX99muYrSSU6dfU23yJVZaYeaYCrjKpWAo2AD2HJZxC9MTjsfrkveYtlDDI6pX3E+mWyrDufdKLKnCsz/uwS/8q71S5v2eKfO2ZLI9dlYBldNZd08TE0Gjs4fyLiBLe2XscN6/+ABfOKcZjN9dA0zK4TCwWBVr2SJDUsFmWuTVsAQKmX6zlTwVKFxgh0gIJkvKmABp/AUZjy9t7juPWn36Ai6pL8OhNyzLy7xZDIyIa23Rdgh3zsraWtcmm0ppdAo78pYC9GAgelSCpc1f/4EWzS9hUvAoouQAoXCZBUfsWCZDaN8m5c2cynNEcUn2k2YBojyw1S4RCFqcEIppDngu3SgXRcCxvc1VJAKPrsrQvdFzCqr7L25RFDj2eXHrXl+aQ0MY73QhvnMkwyX/Y+CxPNGZjWaBvJpC3SCqUrDkSZCV2lus5CPQcklApEfSZf95ZKsvl3FWmc5X0tXJVytniPJVPi7IAQ6Oxh/MvIjJ76p2D+Nrr23DfhTPw/z5anenhpNJ1oPOohEeNW2SZW+NWoGUfeudAdi9QMk8CpNL5xuN5gCs/o0On7HWopQeXP7gGpTkOvHLvKngdmVlqydCIiMYfXZdwIrGsLdFsO9H7SLMDeYtl+ZXFKVUxnTskzOhbqaPZZXexolVA0QoJn7zTJXRq3wS0bUqezU2rHcWpvZLCLcnnLG7AUSTPRbqMnxuGv0M1h4Q2Vp8svwu1yn1TlpEZlE2CLujSFNu8tK33Gqss03NPkfDLUSrXB48CXfsAf50x9jQ/25c1R0Kf3PlA/hJ5TYtTGlJGOuS1/HVAT13ycbpx2wtkqZurwjiXy1I8V5lUeiXOthw2u8wyDI3GHs6/iMhM13V8+ZUt+PnaOvzo+qW4bHFFpod0YuEe6YvUuM10bAWCpvgjIRQAACAASURBVH6avgoJj0rmSpBUMhcomgPY3ZkbN014XcEIPv7wO2jqCuFX95+DyYWZ++eNoRERTQy6DnTvl0qkREVS67pkvyLNAeQukKVTmlV2bOvaZVQO9aGs0pi76ExpzJ2/RKprwi1A22YJkdo3S5DUtQe9gZDmkEDD6gH0iFQGhU2l0JpDnotHjMBkmP5etXqM9+WUqp9wq1QnxUNp3pvNaGitSWVSLIi0oZDFJcGXe5L0LXIUyfdDTclAKdwCxPv2Y0pDWSRgc1XIjm35S2THNnuh/FnEQ1L55D8iO70Fjhln43G6CirNAThL5HAYZ2exhHmOItO5UA5bHneGG+cYGo09nH8RUV/haBw3PP4eth7twEufORsLKnMzPaSTl6hKatouR+N26ZvUvNv4RRwAKCB/ClA8FyipBoqrgeI50njbPoLNwCkrxOM67nqmFm/uasbTn1qBVTOLMjoehkZENHHpcQk4WtcBbUZFUtt6U5BkVBk5ywBosgyue69pm3tzfyIlFUgFNRJ65C+WszVHqpjaN5uOLbKcLMGeJ1U8FpdRIXS8T1ilSVVQupDnpPTpp2RxSeijOWSSE20Hwh0D3EdJhZRm9B2Kh6XZeLoeSppdQhhXmYRV7koJrCLdxrK3gxL2RDuHFiolxmrPA5wVgG86kLdElsC5Koy+SnEJ4QINco9gkzT/TpxDzXLEggPcQAH2fOMokLPDONty5d62PONs9LYyH1avBFyUMQyNxh7Ov4goneauEK548G0AwC/vPwfFvgmy+2osCrQdlCCpeadx3gUc32PqgwkgdzJQPFsCJPPhKWKVNA3Jd97YiYfe3Id/u3w+bj17aqaHw9CIiLJMIkhqWw+0rjcCpfVSmQMA0GSLeUex/KYpeEx6/ySqcZQlNUhxFBmVSIslSMpbDPjmyFK5ji0SILVvkT5LHduk91HvzxZLnx+LSyYb4Raprhms2fUp0ZBaTaTJsi+bD4jHpOop3AHE++4QZ7re6kkNlGJBqaZKe7ldgpfeHkaVRt8nvwQ/wQYJlSKtxusM8f0qK2B1S7jjKJYm2znVQO48eWwvBmzeZCPzUItR7dWS7AkVbjMOoxor3C7ngfpBmVmcsjTQ6pX7WDxytnrksdUtf5aJs8UlP2NxSqhmcUqVl+aQz0izG1/bkssJNavx2JrsV6USjzVjhzqVPMsHYxqknjzrunGOA4gbfa9icsSjxuOoHPGo/DOoR4zHYfk6Hk4esZAEjvFQ8nEsmHqUXQRMumpof54niaHR2MP5FxENZOuRDlz96DuYX5GL5+9cCYd1Alf7xiJA6wGgeYeESM27gOO7gON7gWggeZ0zV8KjwllA0Uyg0DgKpgM2V+bGT2PKLzcewed/vhHXr5iE/7xqIdQYCBoZGhER6bpUx7RtkCCpbYOEScHG5DWuymSfokCj7HKWoDmM3zAlgiUrkDtXlrT1Hgulosl/ODVE6tgulUrmChlHiYQ6Vo/8j364xajcSdMD6LSk2ektsexLs0tQEO0Gwp3o14DbzGKEJInd3WJBo1prkP9uJKqVnCXSDNtZAkADYn6pBEuEPKE2IB5I/XyH9NasxnJAtwRYjiKpjHJPMnZ3myy7uzmLAGuujCfaJWFfpFNCtGin6XG38bxxjnZLAGg+Yn6ZHMb8Q6+wmgiUlgzIZn8OWPjVkbkNQ6Mxh/MvIhrMrzcfxf3Pb8A1y6rw31cvGhP/8zuq4nGg47CERy17gOO7pSrp+B6guyH12pwqoHC6BEgFM4DCGUD+NNnljb2TssaWeglbF1fl4dlPr4TdOjZ28xvqHIw1+UQ0cSkl28t7pwGTPp78fuAY0LpBQqTE0b0/+bwtL9nrJ9gMRI1G2XoM6D4IdO0HDj6XvN6eL32V8hbIeeZd0jjalidNuju2J0Okju2yk1vMVP1jy5Wgw54nQVekXZZnhVtPXCmjrEbliTn8SRPqxEPSryjta9jkPVhccr9ojzT6jvlTx9mXZlTdJKq04iEJlUJNcnRsHWTclmTo4yyTpWVKSUVMNGiEOm1GkOM3KpeM6plYFIgZO9517x3885GbJSt7LA6jMsgjFVk2nxFyFRkBYomxvK1Azo5iYxmbW0I0aLK8r281TjxkqtoJG19Hkkei0qe3CsioCuqtFDJVDQHGn2mCbrwHUwVSb3WSlnysTFVMvRVNiUonmxG42QGLPVkRpdmSFVKJsDEelfFHuyRYC7dJlR4RERGAjy2qwO6GLvzwz3sxp8yHT587PdNDGl2aJqFP/lRg1odSnwt1Aa37gZa9soNby175evvrQKA19VpvqQRIBdOAvCnGa06Rx75yuQ+Ne01dQdz5dC2KvA48ctMZYyYwOhkMjYgo+7jKgcpyoPLS5PfCHcZuahuNY4MEPInKEs0G2Ivkf8Qjpp03EkuIOncCLWslUEhwlhlB0nxZajXjTjnb82Qr+86dQMcOCZM6d8nXQfNvqLT/396dx1dZ3Xkc/567ZA8JEMK+ryIICgKKaxVrrXW3aotVRGl1dKx1bO2r044z7XRzWmtrK+6idWndKrZWpzouRVEWEVmUfQ/IErJv9+ae+eM8ITcLJBByn+Tm8369ntd9kvvk3l+e5IXHb875HdesOq23e99oubfsaq+3HM4eJFTyAgTJe76FmTw24kKegwmmu9lRJuQ1+67wZgl5x6EEvCVcgfhgyVu6VlPojtK1h34NSZJx4U1d36JQhhdWyQtpKuvDpdrKuPAmKil+uVZVw93yjphRg+Vk8cvMDiw/O9jhXdMg8DHu4wbhkMdauZ+hdX/dlK1fjnbgiDX8WDG3RLHu3Na617G1ql/aFrfkrSXp/aSLdxyF+wYASAbfPnuU1nxeqp+++qmG52fpzNH5fpfUMaRmS30nuKOxyv0uQCrcJO3fJBVudo8b35FKd6ph/8oUKWeAlDtIyhnogqScAfVHt/5SKCVR3xWOUFWkVnOeWKriyoheuPFk9czqnH3AWJ4GAAcTi7ggZ78XJhV5O6xVxQUsoSwXqkQr3OyXOik9vd5CUbckq0GY1FvqdozXt+cYd55zjJvpEimpD5BK17md4ErWumClNi6gCaS6pVihbi4AiBS5ACZaduheQiYoydTPbDkaTNALhsLu41hNy8vYGgukuO9JQVfXoXaAc1/gBTb20N9vfI0HehSlu/c7cC9sff8fG42bFRSNC17qgpm4WUFHa5c838T3TqoLq+LP467pNV066432qYLlaR0O4y8ArVFeHdVlcxdqe2GFXvqX6RqRn+V3SZ1XtFoq2iYVbXZNuYu2eh9vlYq3SWWfN/oCI2Xlu/CoW7+Gj9l93Eyl7D5SKj8Tv1hr9e0/fayXPy7Q3JmTdO64Pn6X1ATL0wCgrQJh17Mod7w0dGb95yt3uQBp/3Kvj9EKNyvpAOOCk6o9DYOkUDcpvbcLRyq2u/5K0dK45zPd1vXdRnuB0rGu+XD2SPdcZYEXJK33Hr3zsg0NAyUTkFLypZRst9Srrk+PrWmHZtzy+h2VH7I9UoMlYjJyM2Hi+hnVNWWOv76lUMYE3PKrusbQsYikgyzns7UukIuUesu0vJk+B96nbvZOtH6J2FF3qHCmrk4bV0/cebvwXteYuJlPjZpvW29WUm1bdwAEACSbzNSQHvrGJF1433u6ft5i/eVfpis3g9kvRySU6ppo541o/vlIpVRS4AKk4u3esc19bt96adO7UnVJ069L7ebCpaw+7jHbe8zM9x7z3HlmnqsBR80f3t6glz8u0L+dM6pDBkaHg5lGAHA0xCIuxCla6Xr5FK1w5w167hjXU6e2RvUzaIJS5kDXOycQdrNrqndLFTvUICxI7+vCo+yRUtYI73yElDXcC5R2uvCobIPrz1S2USrb5B6rGjVlNGG3vMvauLCmvYKSI1W3XEvy1qC1cL0386hJf6eW1AVHXlhiWjlzqdW8YMg2Dovinj/ANjptvHwsEUHSQYRzpcv3t3zdEWCmUcfD+AvA4ViyuVBfe+hDTR7SXfOum6JwsPP1bEkKVSVS6S631K10l1Ra4D3uksp2u9lKZZ9LNQfZgCUlW8rsKWXkuRApvYeU0UNK7+499pDSc6W03PrH1G70XmrG66t26ZtPLtUFE/rp3isnHl6zeGvdH32rS92R3UdKyWyXOplpBACJFAi7fkU5YyV9tf7z0Qq31KxoZf3OakUrpYot3gW1UvkWN/Movj9RIF3KGuZ2BgumuVCqZr+0468Nd3+T3A5lWcPd9XWPvc/yvr6f6yNUvsXtJFe2yTXnLt8ilW91j41DJcmbeaJDBCim/pomPXIORyDuvepeo+7xcMKbuCbSh6XR11jpQGBlTFx4Y5u/vkV1QY8a3p6O+/ea5sUiflcAAOigJg/poZ9eMl7/9txy/ejlVfrpxeO63o5qHUFaN3f0GnXo62rKXYhUvscdZbul8r1SxV6pYp87L9kh7VrpmndHDrEpiowLjtK6SWk57jw12y2LS8nyzrOlcIYLPlIyvfMM9xhKc4/hNNc+IJTqjmBqxw2jYt4M7Gi1+0NwtMqdRyqlaJU279qnl15Zpht7Gd02ar/MkqXuuZoKF9hFKtzPoKZMqi5rdO4FRbG4/yf4xsvSsDP8+m4lERoBQPsKZUg9TnBHvGi5611U/KlUsto9Fq+SSjdIqnWNnUtWuecaNEbMcMvWMoZIqd3d7JpopdtJbPc/pc1PN7w+EJYyBkuZg6WsIe48Z7zU73zXEym9v6SYVL7N7a4Wf5Rvkyp3uPOaxrNMDtaEO44J1TfkPrAcrXFacjhhT1zj6AOzg+qWcnmvdVRm43iBVWcLdo6agNt9LX53tb7n+l0UAKADu2zSAK3fXaa572zQqN5ZmjV9qN8l4WBSMt2ObT1a+TOKVLnwqHK/VFnkHquK3HlVsVsWV1VSf172uVsyVxeERMpbfo/mBMJegBR2jcGDKd74JO4IhuI2IWm8wYjiZnnH/xGvbuxYt2mIt2FIrO6INjxqa7wj4h5jhx7/DpE0NyCpVNIrjZ6sC8lSslxwlpLlAras/IYhW2pWfQCXN/rI7t9RRGgEAH4IZTYfJsUibklZ8aeu+XXJGrfcreQz15OntqJ+xlI8E3RL2PLPkLKGuu3sTcD9JaR6t5tRtONvzcwqMq4xd+YgKWOAlD7APeaf4X3cz72ujAuQKgukigKpaqc7L9/qZi9VbpeqC92spjp1O5YdkqnfKj6+r9DBHGhE7cMSrQNLyfxOk+p2bYvbqS3g9YsKhOvDOhN0AyoTlBT0ehcZKVbX+DtS37Q8VuXCR3m77TXuMdVgmSUAAE1994ujtXFPmX7819UampepM9hRLTmE06RwP9do+0jEar3ZNd5Mm5pyN/MmUuFm6UQqvFk63uydupk70aqGoU20Ji7MibjXrY003Kik7og1/kNiXJuAusegF0rVBU6BYKNQKlgfWAXC3nnYBT/BFC/Q8h5D6aoxKfrZG5u1oTCqH108WSP692o4oyol0+up2fkQGgFARxIIe42wm/mrQnVhXANsr39SyWoXCNVWuiVuFdul3W81es1Ut8yt2xip/4UuDAqlu/+GRkvrZxYVfyrt/F/XOLuxcE59gJTeV0rr414zd4ILndLy3RHKkSKFboe5yl1e0+41bmlc+TY3IypS6kKKA9u/R9zRopgabHMvtaL/kBeo1IUmkg5sYX9ge/rWhkCHui5uBlT8bKj4PkbNNb6ue90Df/Wy9XXZWjW/HK6u71Jt/X1rh/7mDZSsbec3AAB0doGA0T1XTNRlcxfqlqeX6cWbTtbI3tl+lwW/BYL1M2jU2+9q2kUsZnXbs8v06u6Q7v/6JI3o5I2vGyM0AoDOIrWHlDpVypva9LnqQm8ntfVxgdJnLkSKFHk9jLZIu99u9IUBKSXXBUJZw6V+X5KyRrrPybgwqm5WUcUON1Npz/vuc7VVzdeZ0kNK6yWl5tUfueOl/NOl1J7u+dSerrmySXGvVb5VKt/oLYvb4hp7Vxe6UKu2SvXhyeE2qvamGh91jbakN/FL5RrXeLAG1/Hnfs9eOhTjfoYAALQgMzWkh6+ZrAvve0/XzVusl26arrwsduVCcvvNm+v0t0926s4vjen0O6U1h9AIAJJBag8pdYqUN6Xpc7XVXiiz2QVLRcvdsreKba6pdk2hO4pXSgWNvzgghbOklJ5uhlHGYCn/TDdrKWuIa9Jd11OperebYVT1uVS9T6re65ba7f1Qqtl36GbKJuhmM4VzpJQcFzplj5BC2VI4282WMsZbex71llVVuUbjkWIXjNUUuVlM0dKGy+RadCTLzhqFPR058zkSwQwXHIa7u8fBV/pdEQCgk+ifm66Hr5msKx5YqDlPLNHTN0xTWrhzLssBWvKXZTv02zfX6fJJA/TN04b5XU67IDQCgGQXTJW6jXRH3xlNn49F6pe2lazxGnKvkyq2uhAoUuztuLZJ0vvNvIFx4VEoW0rp7gKfNG/pWuYQqdsIKWuUm10ULXUBVfU+F/LU7K8PfGr2u75NkRL3nhXb6kOgSJnr53SkTLhho8QGjbSlBjvAxT/amA5/x7QEM2Fv7b2320gwXQpmur5ZKXVBXHcplOU+Z0L133qsxvuZFHuhW1H9Y6TEBX+xGve1o2/2+zsFAHQSEwfm6p4rJuqmpz7SHc9/ot8e7rbjQCewdMt+ffeFTzR1aA/998Xjk/Z3nNAIALq6QNg1z84aKuWf2vw1sahbmla21fVRKlnjQqSK7W6WUU2RC3qq97geRgdl3K5cwTQXYNQFTak9pNS4sCm9n5TR3/VfSs13s51szPVbqq1wu89FvcfaCreMrrbSzT6qe4zVuFlWsWr3eKD5s9dDKRZp2D/I1sYFRnFLzYxpuNOGjcX1JqpLX+J36zBxAVWjhtSBFBfy1DVVDKR5QU+aC3sCae57DWW7x0C6d613fSzqvp9Y1PteK1wAV7XLm+W1x83qqil0IVzZRhcKRSu8e9Ca3lFxvxfBTNezKmds678OAABJ543vq++dO0a/eO0zDc3L1HdmtLAVPNCJbNlXrhueWKJ+OWmaO3OSUkIBv0tqN4RGAICWBUIuwMkYIOWffPDrrHUzVMo3u+bJZRvdeeVOL1wq9JaTlbuwo3KXWj+TJ1AfwARSGs2sSaufYRPOdMurQhneozfrJpjuHRmuEXgwPe41Ur0lcHVNrOOaWTf9JutnINn4rVqjccFUtbd8rjIu0Kr0Qq5Gj9EKLwirqN/FLFZVH3zVHYfVyymeF9SFMt2MoZQct+wsLc8FchkDpMzBUsZArxdVT9fDKBA+wvcDAMD51unDtGlvmX775joN6ZmhS04Y4HdJQJsVVdRo1uOLFbNWj82aou6ZKX6X1K4IjQAAR48xLpRImSB1n9C6r4nFpOrPpdKNUuUO13S76nM3c6am0C2dipS4WUbRci9QqZGiJVJN9DB3QOtMjJupFAhL4W4NQ69wdv2ys9QeXvNxb0e71Dzvudz6ZWlJOl0aANCxGWP0k4vGa1thpb73wifqn5uuqcN6+l0WcMSqo7Wa8+RSbS+s1FM3TNXQvEy/S2p3hEYAAH8FAq7JdnrfI38NG6tfrhYtq+/TEylx4VKkbolWZdxsnmpvCVvdcrWahjOHDixXk5rseGaCcrORjHsMeOGOCdX3GKqbvRRM9ZahpbvZPuEsF+TEz3iKP0Le7Chm+gAAkkBKKKC5Myfpkvvf05wnl+qFG0/WiPwsv8sCDpu1Vne+sEKLNhXq3isn6sQhPfwuKSEIjQAAnZ/xdnkLZ0nq7Xc1AAAgTk5GWI/PmqKL//C+rn1skV66abp6Zaf6XRZwWH7zxjq9tGyHbp8xShdO7O93OQmTvN2aAAAAAAAdwsAeGXr02snaV1aj2fMWq6Im6ndJQKs9t2Sb7n1znS6bNEA3f2GE3+UkFKERAAAAAKDdHTcgV7+76nit3FGsf31mmWpjydiTEMnmnbV79P0XV+iUEXn66cXjZbpYr0hCIwAAAABAQpw9trf+84Jj9canu3XX/FWyluAIHdfKHcW66Y9LNbJ3tu6feYJSQl0vQqGnEQAAAAAgYa4+aYi276/UA+9uVN/cNN10Rtda7oPOYVthhWY9vli5GSl6fNaJyk7rmpuUEBoBAAAAABLqe+eO0a6SKv3ytTXqlZWqyycP9Lsk4ICiihpd+9giVUdq9fT1U9W7W5rfJfmG0AgAAAAAkFCBgNHdl03QvrIa3fniCuVlp+rM0fl+lwWosqZW189bom2FlXpy9hSN7J3td0m+6noL8gAAAAAAvksJBXT/zBM0pk+2bvrjR/p4W5HfJaGLi9bGdPPTH2np1v2654qJmjqsp98l+Y7QCAAAAADgi+y0sB6bdaLyslN03eOLtXFPmd8loYuy1ur7L67Qm5/t1n9dOE5fPq6v3yV1CG0KjYwxPYwx/zDGrPMeux/kulpjzMfeMb8t7wkAANDVMQYDkEzys9P0xHVTJUlXP7JIu4qrfK4IXdEvXluj55Zu161njdTV0wb7XU6H0daZRndKetNaO1LSm97Hzam01k70jgva+J4AAABdHWMwAEllaF6m5s2aouLKiK5+5EPtL6/xuyR0IQ//c6PmvrNBM6cN0rfPHul3OR1KW0OjCyXN887nSbqoja8HAACAljEGA5B0xg/I0UPfmKwthRW69vHFKq+O+l0SuoAXlm7XT/72qc4b30f/ecE4GWP8LqlDaWto1Ntau1OSvMeDtbtPM8YsMcZ8YIxhUAMAANA2jMEAJKWThvfUfVcdr5U7ijXnySWqjtb6XRKS2Gsrd+qO55dr+oieuueKiQoGCIwaC7V0gTHmDUl9mnnqB4fxPoOstQXGmGGS/s8Ys8Jau+Eg7zdH0hxJGjRo0GG8BQAAQPJI5BiM8ReAjuScY/vol5cep9ufW65bn/lY933teIWC7OGEo+udtXt0yzPLNHFgrh68erJSQ0G/S+qQWgyNrLVnH+w5Y8znxpi+1tqdxpi+knYf5DUKvMeNxpi3JR0vqdnQyFr7oKQHJWny5Mm2xe8AAAAgCSVyDMb4C0BHc+mkASqqjOjHf12t772wQndfdpwCzALBUbJ4c6G++eQSjczP1mOzpigztcVopMtqa1w7X9I13vk1kl5ufIExprsxJtU7z5M0XdLqNr4vAABAV8YYDEDSm33KUH1nxii98NF2/fDllbKWTBttt3JHsa57bLH65abridlTlJMe9rukDq2tcdrPJf3ZGDNb0lZJl0uSMWaypG9Za6+XdIykB4wxMbmQ6ufWWgYsAAAAR44xGIAu4ZYvjFBVpFZ/eHuDUkNB/fD8Y2hUjCO29vNSfePRReqWHtYfZ09VXlaq3yV1eG0Kjay1+ySd1cznl0i63jt/X9L4trwPAAAA6jEGA9BVGGN0xxdHqzJSq0ff26T0lIDu+OIYv8tCJ7R+d6m+9tAHCgeNnrp+qvrlpvtdUqfAwj0AAAAAQIdljNGPzh+r6mhMv3/LzTj617NG+l0WOpENe8p01UMfyhijp2+YpiF5mX6X1GkQGgEAAAAAOjRjjH5y4ThVRWr163+slZF0C8ERWmHT3nJd9eAHstbq2TnTNLxXlt8ldSqERgAAAACADi8QMLr7sgmSlX71j7WyEjOOcEhb9rnAKBpzgdGI/Gy/S+p0CI0AAAAAAJ1CMGB09+UTJCP9+h9rFbNW3z57lN9loQPatLdcX3/oA1VFa/XMDdM0qjeB0ZEgNAIAAAAAdBpBb8ZRwBj95o11sla6bQbBEeq5ptcfKhqzeur6qTqmbze/S+q0CI0AAAAAAJ1KMGD0i0uPk5F075vrVBuzuv2cUTLG+F0afPbpzhLNfNg1vX52DjOM2orQCAAAAADQ6dQFR8GA0X1vrVdZdVQ/On+sAgGCo65q5Y5izXzkQ6WFgnr6hqkaRtPrNiM0AgAAAAB0SoGA0c8uGa/M1JAeWbBJ5dVR/dwLktC1fLR1v655dJG6pYX19A1TNbhnpt8lJQVCIwAAAABAp2WM0b9/+RhlpYZ075vrVFFTq3uumKiUUMDv0pAg76zdo289uVT53VL11PVTNaB7ht8lJQ1CIwAAAABAp2aM0W0zRikrNaT/fvVTlddEdf/XJyk9Jeh3aWhn85cX6PY/f6wR+dmad92Jys9O87ukpEL0CgAAAABICjecNkw/vXi83lm7R19/+APtL6/xuyS0oycXbtatzy7T8QO769k50wiM2gGhEQAAAAAgaXxt6iD94WsnaGVBiS6d+762FVb4XRKOMmut7n1jnX748iqdNSZfT8yeopz0sN9lJSVCIwAAAABAUvnS+L764+yp2ltarUvuf1+rCor9LglHSaQ2pu+/uEL3vLFWl54wQHNnTlJamGWI7YXQCAAAAACQdKYM7aHnbzxZoYDRFQ98oAXr9vpdEtqotCqi6x5frGcXb9MtXxih/7n8OIWCxBrtibsLAAAAAEhKo3pn68WbTlb/3HRd+9giPbtoq98l4QgVFFXq8rkLtXDDPv3y0uN0+zmjZYzxu6ykR2gEAAAAAEhafXPS9dyNJ+nkEXm688UV+vFfV6s2Zv0uC4dh5Y5iXfyH97Rjf6UenzVFXz1xoN8ldRmERgAAAACApNYtLaxHr5msa08eokcWbNL18xartCrid1lohVeWF+iyue8raIyev/FknTIyz++SuhRCIwAAAABA0gsFA7rrgmP1k4vG6d11e3XZ/QvZWa0Dq41Z/eK1z3TLM8t0bL8c/eXm6RrdJ9vvsrocQiMAAAAAQJcxc9pgPXHdFO0srtRX7lugt9fs9rskNFJcGdHseYt1/9sbdNWUgXr6hqnKz07zu6wuidAIAAAAANClTB+Rp1duOUV9c9I16/HF+s0baxWjz1GHsO7zUl38+/e0YN1e/eSicfrZJccpNRT0u6wui9AIAAAAANDlDO6ZqRdvPFkXH99f1rW/iAAAD9BJREFUv3ljna6bt1hFFTV+l9WlPbdkm75y3wKVVEX09A3TNHPaYL9L6vIIjQAAAAAAXVJ6SlC/unyCfnLROL23fq/O/90CfbR1v99ldTkVNVF9588f647nP9HEgbl69V9P1ZShPfwuCyI0AgAAAAB0YcYYzZw2WM9962RZK10+d6F+9+Y61bJcLSHW7CrVV363QC8t26Fbzxqpp66fpvxu9C/qKAiNAAAAAABd3sSBuXr11lP15fF99at/rNVVD36gHUWVfpeVtGIxq8fe26QL7lug4sqo/jh7qm6bMUrBgPG7NMQhNAIAAAAAQFJOelj3XjlRv/7qBK3eWaIv/eZdvbK8QNYy6+ho2r6/Ql9/+EP95yurddLwnnr11lM0fUSe32WhGSG/CwAAAAAAoKMwxuiSEwZo8uAeuvVPy3TLM8v0108K9OMLx7Fsqo2stXpu6Xb91yurZa3Vzy8ZrytOHChjmF3UUTHTCAAAAACARgb1zNBz3zxJ3//SGL29Zo/O/vU7+vOSbcw6OkLbCis0e94Sfff5TzS2Xze99u3TdOWUQQRGHRwzjQAAAAAAaEYoGNA3Tx+uGWN7684XVui7z3+iV5YX6L8vGq9BPTP8Lq9TiNTG9PA/N+neN9cqYIx+eP5YzTp5iAL0LuoUCI0AAAAAADiEYb2y9OycaXpq0Vb9/NVPdfY972jOqcN04xnDlZnK/1YfzKJNhfr3v6zQ2s/L9MVje+s/vnKs+uWm+10WDgO/3QAAAAAAtCAQMLp62mDNOKa3fvHaZ7rvrfV6ful2ff+8MbpgQj+WWcXZVlihu19fo/nLC9Q/N10Pf2Oyzh7b2++ycAQIjQAAAAAAaKU+OWm654qJmjltkO6av1q3Pvuxnly4Rd/70hidOKSH3+X5qqiiRvf933o9sXCLAgHp5jNH6KYzhysjheihs+InBwAAAADAYZo0uIde/pfpem7pNt39+lpdPnehThvVS9+ZMUoTB+b6XV5CVdRE9eTCLfr9W+tVWh3V5ZMG6LYZo9Q3h6VonR2hEQAAAAAARyAQMLrixEG6YEJ/PfnBZt3/9gZd9Pv3dPYx+fr22aM0rn+O3yW2q+KKiJ5YuFmPvrdJ+ysiOn1UL33/vDEa06eb36XhKCE0AgAAAACgDdJTgppz2nB9bepgPf7eJj347kad/7sFmjash2afMkxfGJOvYBLtFra7tEqPLtisP36wRWXVUZ01Jl83nTlckwZ37eV5yYjQCAAAAACAoyArNaSbvzBSV580RM8u2qp572/WDU8s0eCeGZp18hBdOmmAstPCfpd5RGIxq4Ub9+mpD7fof1d9rpi1+vJx/XTj6cM1th8zi5IVoREAAAAAAEdRTnpY3zx9uGafMlSvrdqlRxZs0l2vrNbP/v6Zzjm2jy45ob9OHZGnUDDgd6kt+rykSn9ZtkPPLNqqzfsq1D0jrFnTh+jrUwdrSF6m3+WhnREaAQAAAADQDkLBgM4/rp/OP66fPt5WpBeWbtf85QV6ZXmB8rJSdeHEfpoxtrcmDe6ucAcKkAqKKvX3lbv09xU7tWTLfknSlCE9dNuMUfrisX2UFg76XCESpU2hkTHmckl3STpG0hRr7ZKDXHeupHslBSU9bK39eVveFwAAoCtjDAYAnc/EgbmaODBX/37+MXrrsz168aPtemLhZj2yYJOyU0M6dVSezhydr1NH9lKfnLSE1lZRE9WSzfu1cOM+vb9+r5ZvL5YkHdO3m26fMUrnHddXw3tlJbQmdAxtnWm0UtIlkh442AXGmKCk30uaIWm7pMXGmPnW2tVtfG8AAICuijEYAHRSqaGgzh3XR+eO66PSqojeW79Pb322W2+t2a1XV+ySJPXNSTsQMk0YmKtRvbPVPSMsY9reTLsqUqv1u8v02a5SrdlVoo+2Fmn5tiJFY1ahgNGEgbm644ujdd74vhrK8rMur02hkbX2U0kt/eJOkbTeWrvRu/ZZSRdKYsACAABwBBiDAUByyE4LHwiQrLVaVVCiRZsK9fG2In28rUh/X7mr/trUkAb1zNDgnhka0D1DOelhZaeF3JEaVkoooGgspkitVbTWKlIb077yGu0urdKekmrtLq1WQVGlNu8rV8y610wJBTS2bzfdcNowTRvWU5MHd1dmKl1sUC8Rvw39JW2L+3i7pKkHu9gYM0fSHEkaNGhQ+1YGAACQvFo9BmP8BQD+M8ZoXP8cjeufc+Bz+8qq9cmOYm3cU66t+8q1pbBCn+0s1Ruf7lZNNNaq1w0HjfKz09QrO1Wj+2Tr/An9NKZPtkb1ztaQnhmdohk3/NNiaGSMeUNSn2ae+oG19uVWvEdzfwKzB7vYWvugpAclafLkyQe9DgAAIJklcgzG+AsAOqaeWak6c3S+zhzd9LmqSK1Kq6IqrYqotCqqSG1MoWBAoYBROBhQKGjUIyNFuUdpWRu6phZDI2vt2W18j+2SBsZ9PEBSQRtfEwAAIKkxBgMAHEpaOKi0cFC9slP9LgVJLBHz0BZLGmmMGWqMSZF0paT5CXhfAACArowxGAAAaJM2hUbGmIuNMdslnSTpb8aY173P9zPGvCpJ1tqopJslvS7pU0l/ttaualvZAAAAXRdjMAAAkAht3T3tJUkvNfP5AknnxX38qqRX2/JeAAAAcBiDAQCARKBNOgAAAAAAAJogNAIAAAAAAEAThEYAAAAAAABogtAIAAAAAAAATRAaAQAAAAAAoAlCIwAAAAAAADRBaAQAAAAAAIAmCI0AAAAAAADQBKERAAAAAAAAmiA0AgAAAAAAQBOERgAAAAAAAGiC0AgAAAAAAABNEBoBAAAAAACgCUIjAAAAAAAANEFoBAAAAAAAgCYIjQAAAAAAANAEoREAAAAAAACaIDQCAAAAAABAE4RGAAAAAAAAaILQCAAAAAAAAE0QGgEAAAAAAKAJQiMAAAAAAAA0QWgEAAAAAACAJgiNAAAAAAAA0AShEQAAAAAAAJogNAIAAAAAAEAThEYAAAAAAABogtAIAAAAAAAATRAaAQAAAAAAoAlCIwAAAAAAADRBaAQAAAAAAIAmCI0AAAAAAADQBKERAAAAAAAAmiA0AgAAAAAAQBOERgAAAAAAAGiC0AgAAAAAAABNtCk0MsZcboxZZYyJGWMmH+K6zcaYFcaYj40xS9ryngAAAF0dYzAAAJAIoTZ+/UpJl0h6oBXXnmmt3dvG9wMAAABjMAAAkABtCo2stZ9KkjHm6FQDAACAFjEGAwAAiZConkZW0v8aY5YaY+Yk6D0BAAC6OsZgAADgiLU408gY84akPs089QNr7cutfJ/p1toCY0y+pH8YYz6z1r57kPebI6luUFNmjFnTyvc4XHmSmKqdONzvxOJ+Jxb3O/G454nVnvd7cDu9bqeXyDEY46+kxj1PLO53YnG/E4v7nXi+j8GMtbbN72SMeVvSv1lrW2ywaIy5S1KZtfZ/2vzGbWCMWWKtPWjjSBxd3O/E4n4nFvc78bjnicX97rg62xiM36XE454nFvc7sbjficX9TryOcM/bfXmaMSbTGJNddy7pHLnmjQAAAGgnjMEAAEBbtSk0MsZcbIzZLukkSX8zxrzufb6fMeZV77LekhYYY5ZLWiTpb9ba19ryvgAAAF0ZYzAAAJAIbd097SVJLzXz+QJJ53nnGyVNaMv7tJMH/S6gi+F+Jxb3O7G434nHPU8s7ncH04nHYPwuJR73PLG434nF/U4s7nfi+X7Pj0pPIwAAAAAAACSXdu9pBAAAAAAAgM4nqUMjY8y5xpg1xpj1xpg7m3k+1RjzJ+/5D40xQxJfZXJpxT3/jjFmtTHmE2PMm8YYtlpug5bud9x1lxljrDGG3Q7aoDX32xjzVe93fJUx5ulE15hMWvHvySBjzFvGmGXevynn+VFnsjDGPGqM2W2MabZRsnF+6/08PjHGnJDoGtF5MAZLLMZficcYLLEYgyUWY7DE6vBjMGttUh6SgpI2SBomKUXSckljG11zk6S53vmVkv7kd92d+WjlPT9TUoZ3fiP3vH3vt3ddtqR3JX0gabLfdXfWo5W/3yMlLZPU3fs43++6O+vRyvv9oKQbvfOxkjb7XXdnPiSdJukESSsP8vx5kv4uyUiaJulDv2vm6JgHY7AOeb8ZfyX4nnvXMQZL0P1mDJbw+80Y7Oje8w49BkvmmUZTJK231m601tZIelbShY2uuVDSPO/8eUlnGWNMAmtMNi3ec2vtW9baCu/DDyQNSHCNyaQ1v+OS9GNJv5RUlcjiklBr7vcNkn5vrd0vSdba3QmuMZm05n5bSd288xxJBQmsL+lYa9+VVHiISy6U9IR1PpCUa4zpm5jq0MkwBkssxl+JxxgssRiDJRZjsATr6GOwZA6N+kvaFvfxdu9zzV5jrY1KKpbUMyHVJafW3PN4s+USUxyZFu+3MeZ4SQOttX9NZGFJqjW/36MkjTLGvGeM+cAYc27Cqks+rbnfd0ma6W07/qqkWxJTWpd1uP/Go+tiDJZYjL8SjzFYYjEGSyzGYB2Pr2OwUKLeyAfN/bWq8VZxrbkGrdfq+2mMmSlpsqTT27Wi5HbI+22MCUi6R9K1iSooybXm9zskNz36DLm/4v7TGDPOWlvUzrUlo9bc76skPW6t/ZUx5iRJT3r3O9b+5XVJ/DcTrcUYLLEYfyUeY7DEYgyWWIzBOh5f/5uZzDONtksaGPfxADWdNnfgGmNMSG5q3aGmheHQWnPPZYw5W9IPJF1gra1OUG3JqKX7nS1pnKS3jTGb5da/zqcR4xFr7b8pL1trI9baTZLWyA1gcPhac79nS/qzJFlrF0pKk5SXkOq6plb9Gw+IMViiMf5KPMZgicUYLLEYg3U8vo7Bkjk0WixppDFmqDEmRa7J4vxG18yXdI13fpmk/7NepykckRbvuTdV9wG5AQtrjdvmkPfbWltsrc2z1g6x1g6R62FwgbV2iT/ldnqt+TflL3LNRmWMyZObKr0xoVUmj9bc762SzpIkY8wxcgOWPQmtsmuZL+kb3g4e0yQVW2t3+l0UOiTGYInF+CvxGIMlFmOwxGIM1vH4OgZL2uVp1tqoMeZmSa/LdYB/1Fq7yhjzX5KWWGvnS3pEbirderm/bl3pX8WdXyvv+d2SsiQ95/W73GqtvcC3ojuxVt5vHCWtvN+vSzrHGLNaUq2kO6y1+/yruvNq5f2+XdJDxpjb5KboXsv/dB45Y8wzctP687weBf8hKSxJ1tq5cj0LzpO0XlKFpFn+VIqOjjFYYjH+SjzGYInFGCyxGIMlXkcfgxl+tgAAAAAAAGgsmZenAQAAAAAA4AgRGgEAAAAAAKAJQiMAAAAAAAA0QWgEAAAAAACAJgiNAAAAAAAA0AShEQAAAAAAAJogNAIAAAAAAEAThEYAAAAAAABo4v8Bm3d7xZxmeosAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# feature = PolynomialFeature(24)\n", + "feature = GaussianFeature(np.linspace(0, 1, 24), 0.1)\n", + "# feature = SigmoidalFeature(np.linspace(0, 1, 24), 10)\n", + "\n", + "for a in [1e2, 1., 1e-9]:\n", + " y_list = []\n", + " plt.figure(figsize=(20, 5))\n", + " plt.subplot(1, 2, 1)\n", + " for i in range(100):\n", + " x_train, y_train = create_toy_data(sinusoidal, 25, 0.25)\n", + " X_train = feature.transform(x_train)\n", + " X_test = feature.transform(x_test)\n", + " model = BayesianRegression(alpha=a, beta=1.)\n", + " model.fit(X_train, y_train)\n", + " y = model.predict(X_test)\n", + " y_list.append(y)\n", + " if i < 20:\n", + " plt.plot(x_test, y, c=\"orange\")\n", + " plt.ylim(-1.5, 1.5)\n", + " \n", + " plt.subplot(1, 2, 2)\n", + " plt.plot(x_test, y_test)\n", + " plt.plot(x_test, np.asarray(y_list).mean(axis=0))\n", + " plt.ylim(-1.5, 1.5)\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3.3 Bayesian Linear Regression" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.3.1 Parameter distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def linear(x):\n", + " return -0.3 + 0.5 * x\n", + "\n", + "\n", + "x_train, y_train = create_toy_data(linear, 20, 0.1, [-1, 1])\n", + "x = np.linspace(-1, 1, 100)\n", + "w0, w1 = np.meshgrid(\n", + " np.linspace(-1, 1, 100),\n", + " np.linspace(-1, 1, 100))\n", + "w = np.array([w0, w1]).transpose(1, 2, 0)\n", + "\n", + "feature = PolynomialFeature(degree=1)\n", + "X_train = feature.transform(x_train)\n", + "X = feature.transform(x)\n", + "model = BayesianRegression(alpha=1., beta=100.)\n", + "\n", + "for begin, end in [[0, 0], [0, 1], [1, 2], [2, 3], [3, 20]]:\n", + " model.fit(X_train[begin: end], y_train[begin: end])\n", + " plt.subplot(1, 2, 1)\n", + " plt.scatter(-0.3, 0.5, s=200, marker=\"x\")\n", + " plt.contour(w0, w1, multivariate_normal.pdf(w, mean=model.w_mean, cov=model.w_cov))\n", + " plt.gca().set_aspect('equal')\n", + " plt.xlabel(\"$w_0$\")\n", + " plt.ylabel(\"$w_1$\")\n", + " plt.title(\"prior/posterior\")\n", + "\n", + " plt.subplot(1, 2, 2)\n", + " plt.scatter(x_train[:end], y_train[:end], s=100, facecolor=\"none\", edgecolor=\"steelblue\", lw=1)\n", + " plt.plot(x, model.predict(X, sample_size=6), c=\"orange\")\n", + " plt.xlim(-1, 1)\n", + " plt.ylim(-1, 1)\n", + " plt.gca().set_aspect('equal', adjustable='box')\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.3.2 Predictive distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_train, y_train = create_toy_data(sinusoidal, 25, 0.25)\n", + "x_test = np.linspace(0, 1, 100)\n", + "y_test = sinusoidal(x_test)\n", + "\n", + "feature = GaussianFeature(np.linspace(0, 1, 9), 0.1)\n", + "X_train = feature.transform(x_train)\n", + "X_test = feature.transform(x_test)\n", + "\n", + "model = BayesianRegression(alpha=1e-3, beta=2.)\n", + "\n", + "for begin, end in [[0, 1], [1, 2], [2, 4], [4, 8], [8, 25]]:\n", + " model.fit(X_train[begin: end], y_train[begin: end])\n", + " y, y_std = model.predict(X_test, return_std=True)\n", + " plt.scatter(x_train[:end], y_train[:end], s=100, facecolor=\"none\", edgecolor=\"steelblue\", lw=2)\n", + " plt.plot(x_test, y_test)\n", + " plt.plot(x_test, y)\n", + " plt.fill_between(x_test, y - y_std, y + y_std, color=\"orange\", alpha=0.5)\n", + " plt.xlim(0, 1)\n", + " plt.ylim(-2, 2)\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3.5 The Evidence Approximation" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def cubic(x):\n", + " return x * (x - 5) * (x + 5)\n", + "\n", + "x_train, y_train = create_toy_data(cubic, 30, 10, [-5, 5])\n", + "x_test = np.linspace(-5, 5, 100)\n", + "evidences = []\n", + "models = []\n", + "for i in range(8):\n", + " feature = PolynomialFeature(degree=i)\n", + " X_train = feature.transform(x_train)\n", + " model = EmpiricalBayesRegression(alpha=100., beta=100.)\n", + " model.fit(X_train, y_train, max_iter=100)\n", + " evidences.append(model.log_evidence(X_train, y_train))\n", + " models.append(model)\n", + "\n", + "degree = np.nanargmax(evidences)\n", + "regression = models[degree]\n", + "\n", + "X_test = PolynomialFeature(degree=int(degree)).transform(x_test)\n", + "y, y_std = regression.predict(X_test, return_std=True)\n", + "\n", + "plt.scatter(x_train, y_train, s=50, facecolor=\"none\", edgecolor=\"steelblue\", label=\"observation\")\n", + "plt.plot(x_test, cubic(x_test), label=\"x(x-5)(x+5)\")\n", + "plt.plot(x_test, y, label=\"prediction\")\n", + "plt.fill_between(x_test, y - y_std, y + y_std, alpha=0.5, label=\"std\", color=\"orange\")\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "plt.plot(evidences)\n", + "plt.title(\"Model evidence\")\n", + "plt.xlabel(\"degree\")\n", + "plt.ylabel(\"log evidence\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/books/PRML/PRML-master-Python/notebooks/ch04_Linear_Models_for_Classfication.ipynb b/books/PRML/PRML-master-Python/notebooks/ch04_Linear_Models_for_Classfication.ipynb new file mode 100755 index 0000000..7bed676 --- /dev/null +++ b/books/PRML/PRML-master-Python/notebooks/ch04_Linear_Models_for_Classfication.ipynb @@ -0,0 +1,429 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 4. Linear Models for Classification" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from prml.preprocess import PolynomialFeature\n", + "from prml.linear import (\n", + " BayesianLogisticRegression,\n", + " LeastSquaresClassifier,\n", + " FishersLinearDiscriminant,\n", + " LogisticRegression,\n", + " Perceptron,\n", + " SoftmaxRegression\n", + ")\n", + "\n", + "np.random.seed(1234)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def create_toy_data(add_outliers=False, add_class=False):\n", + " x0 = np.random.normal(size=50).reshape(-1, 2) - 1\n", + " x1 = np.random.normal(size=50).reshape(-1, 2) + 1.\n", + " if add_outliers:\n", + " x_1 = np.random.normal(size=10).reshape(-1, 2) + np.array([5., 10.])\n", + " return np.concatenate([x0, x1, x_1]), np.concatenate([np.zeros(25), np.ones(30)]).astype(np.int)\n", + " if add_class:\n", + " x2 = np.random.normal(size=50).reshape(-1, 2) + 3.\n", + " return np.concatenate([x0, x1, x2]), np.concatenate([np.zeros(25), np.ones(25), 2 + np.zeros(25)]).astype(np.int)\n", + " return np.concatenate([x0, x1]), np.concatenate([np.zeros(25), np.ones(25)]).astype(np.int)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4.1 Discriminant Functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.1.3 Least squares for classification" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_train, y_train = create_toy_data()\n", + "x1_test, x2_test = np.meshgrid(np.linspace(-5, 5, 100), np.linspace(-5, 5, 100))\n", + "x_test = np.array([x1_test, x2_test]).reshape(2, -1).T\n", + "\n", + "feature = PolynomialFeature(1)\n", + "X_train = feature.transform(x_train)\n", + "X_test = feature.transform(x_test)\n", + "\n", + "model = LeastSquaresClassifier()\n", + "model.fit(X_train, y_train)\n", + "y = model.classify(X_test)\n", + "\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train)\n", + "plt.contourf(x1_test, x2_test, y.reshape(100, 100), alpha=0.2, levels=np.linspace(0, 1, 3))\n", + "plt.xlim(-5, 5)\n", + "plt.ylim(-5, 5)\n", + "plt.gca().set_aspect('equal', adjustable='box')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_train, y_train = create_toy_data(add_outliers=True)\n", + "x1_test, x2_test = np.meshgrid(np.linspace(-5, 15, 100), np.linspace(-5, 15, 100))\n", + "x_test = np.array([x1_test, x2_test]).reshape(2, -1).T\n", + "\n", + "feature = PolynomialFeature(1)\n", + "X_train = feature.transform(x_train)\n", + "X_test = feature.transform(x_test)\n", + "\n", + "least_squares = LeastSquaresClassifier()\n", + "least_squares.fit(X_train, y_train)\n", + "y_ls = least_squares.classify(X_test)\n", + "\n", + "logistic_regression = LogisticRegression()\n", + "logistic_regression.fit(X_train, y_train)\n", + "y_lr = logistic_regression.classify(X_test)\n", + "\n", + "plt.subplot(1, 2, 1)\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train)\n", + "plt.contourf(x1_test, x2_test, y_ls.reshape(100, 100), alpha=0.2, levels=np.linspace(0, 1, 3))\n", + "plt.xlim(-5, 15)\n", + "plt.ylim(-5, 15)\n", + "plt.gca().set_aspect('equal', adjustable='box')\n", + "plt.title(\"Least Squares\")\n", + "plt.subplot(1, 2, 2)\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train)\n", + "plt.contourf(x1_test, x2_test, y_lr.reshape(100, 100), alpha=0.2, levels=np.linspace(0, 1, 3))\n", + "plt.xlim(-5, 15)\n", + "plt.ylim(-5, 15)\n", + "plt.gca().set_aspect('equal', adjustable='box')\n", + "plt.title(\"Logistic Regression\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_train, y_train = create_toy_data(add_class=True)\n", + "x1_test, x2_test = np.meshgrid(np.linspace(-5, 10, 100), np.linspace(-5, 10, 100))\n", + "x_test = np.array([x1_test, x2_test]).reshape(2, -1).T\n", + "\n", + "feature = PolynomialFeature(1)\n", + "X_train = feature.transform(x_train)\n", + "X_test = feature.transform(x_test)\n", + "\n", + "least_squares = LeastSquaresClassifier()\n", + "least_squares.fit(X_train, y_train)\n", + "y_ls = least_squares.classify(X_test)\n", + "\n", + "logistic_regression = SoftmaxRegression()\n", + "logistic_regression.fit(X_train, y_train, max_iter=1000, learning_rate=0.01)\n", + "y_lr = logistic_regression.classify(X_test)\n", + "\n", + "plt.subplot(1, 2, 1)\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train)\n", + "plt.contourf(x1_test, x2_test, y_ls.reshape(100, 100), alpha=0.2, levels=np.array([0., 0.5, 1.5, 2.]))\n", + "plt.xlim(-5, 10)\n", + "plt.ylim(-5, 10)\n", + "plt.gca().set_aspect('equal', adjustable='box')\n", + "plt.title(\"Least squares\")\n", + "plt.subplot(1, 2, 2)\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train)\n", + "plt.contourf(x1_test, x2_test, y_lr.reshape(100, 100), alpha=0.2, levels=np.array([0., 0.5, 1.5, 2.]))\n", + "plt.xlim(-5, 10)\n", + "plt.ylim(-5, 10)\n", + "plt.gca().set_aspect('equal', adjustable='box')\n", + "plt.title(\"Softmax Regression\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.1.4 Fisher's linear discriminant" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_train, y_train = create_toy_data()\n", + "x1_test, x2_test = np.meshgrid(np.linspace(-5, 5, 100), np.linspace(-5, 5, 100))\n", + "x_test = np.array([x1_test, x2_test]).reshape(2, -1).T\n", + "\n", + "model = FishersLinearDiscriminant()\n", + "model.fit(x_train, y_train)\n", + "y = model.classify(x_test)\n", + "\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train)\n", + "plt.contourf(x1_test, x2_test, y.reshape(100, 100), alpha=0.2, levels=np.linspace(0, 1, 3))\n", + "plt.xlim(-5, 5)\n", + "plt.ylim(-5, 5)\n", + "plt.gca().set_aspect('equal', adjustable='box')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4.3 Probabilistic Discriminative Models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.3.2 Logistic Regression" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_train, y_train = create_toy_data()\n", + "x1_test, x2_test = np.meshgrid(np.linspace(-5, 5, 100), np.linspace(-5, 5, 100))\n", + "x_test = np.array([x1_test, x2_test]).reshape(2, -1).T\n", + "\n", + "feature = PolynomialFeature(degree=1)\n", + "X_train = feature.transform(x_train)\n", + "X_test = feature.transform(x_test)\n", + "\n", + "model = LogisticRegression()\n", + "model.fit(X_train, y_train)\n", + "y = model.proba(X_test)\n", + "\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train)\n", + "plt.contourf(x1_test, x2_test, y.reshape(100, 100), np.linspace(0, 1, 5), alpha=0.2)\n", + "plt.colorbar()\n", + "plt.xlim(-5, 5)\n", + "plt.ylim(-5, 5)\n", + "plt.gca().set_aspect('equal', adjustable='box')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.3.4 Multiclass logistic regression" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_train, y_train = create_toy_data(add_class=True)\n", + "x1, x2 = np.meshgrid(np.linspace(-5, 10, 100), np.linspace(-5, 10, 100))\n", + "x = np.array([x1, x2]).reshape(2, -1).T\n", + "\n", + "feature = PolynomialFeature(1)\n", + "X_train = feature.transform(x_train)\n", + "X = feature.transform(x)\n", + "\n", + "model = SoftmaxRegression()\n", + "model.fit(X_train, y_train, max_iter=1000, learning_rate=0.01)\n", + "y = model.classify(X)\n", + "\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train)\n", + "plt.contourf(x1, x2, y.reshape(100, 100), alpha=0.2, levels=np.array([0., 0.5, 1.5, 2.]))\n", + "plt.xlim(-5, 10)\n", + "plt.ylim(-5, 10)\n", + "plt.gca().set_aspect('equal', adjustable='box')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.5 Bayesian Logistic Regression" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_train, y_train = create_toy_data()\n", + "x1_test, x2_test = np.meshgrid(np.linspace(-5, 5, 100), np.linspace(-5, 5, 100))\n", + "x_test = np.array([x1_test, x2_test]).reshape(2, -1).T\n", + "\n", + "feature = PolynomialFeature(degree=1)\n", + "X_train = feature.transform(x_train)\n", + "X_test = feature.transform(x_test)\n", + "\n", + "model = BayesianLogisticRegression(alpha=1.)\n", + "model.fit(X_train, y_train, max_iter=1000)\n", + "y = model.proba(X_test)\n", + "\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train)\n", + "plt.contourf(x1_test, x2_test, y.reshape(100, 100), np.linspace(0, 1, 5), alpha=0.2)\n", + "plt.colorbar()\n", + "plt.xlim(-5, 5)\n", + "plt.ylim(-5, 5)\n", + "plt.gca().set_aspect('equal', adjustable='box')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/books/PRML/PRML-master-Python/notebooks/ch05_Neural_Networks.ipynb b/books/PRML/PRML-master-Python/notebooks/ch05_Neural_Networks.ipynb new file mode 100755 index 0000000..c6ba220 --- /dev/null +++ b/books/PRML/PRML-master-Python/notebooks/ch05_Neural_Networks.ipynb @@ -0,0 +1,763 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 5. Neural Networks" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import scipy.stats as st\n", + "from sklearn.datasets import fetch_mldata, make_moons\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import LabelBinarizer\n", + "from sklearn.metrics import accuracy_score\n", + "\n", + "from prml import nn\n", + "\n", + "np.random.seed(1234)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5.1 Feed-forward Network Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "class RegressionNetwork(nn.Network):\n", + " \n", + " def __init__(self, n_input, n_hidden, n_output):\n", + " truncnorm = st.truncnorm(a=-2, b=2, scale=1)\n", + " super().__init__(\n", + " w1=truncnorm.rvs((n_input, n_hidden)),\n", + " b1=np.zeros(n_hidden),\n", + " w2=truncnorm.rvs((n_hidden, n_output)),\n", + " b2=np.zeros(n_output)\n", + " )\n", + "\n", + " def __call__(self, x, y=None):\n", + " h = nn.tanh(x @ self.w1 + self.b1)\n", + " self.py = nn.random.Gaussian(h @ self.w2 + self.b2, std=1., data=y)\n", + " return self.py.mu.value" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIQAAAJCCAYAAACxsxylAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nCAAAAKAxGkIAAAAAjdEQAgAAAGjML6KHTVToo8hoAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def create_toy_data(func, n=50):\n", + " x = np.linspace(-1, 1, n)[:, None]\n", + " return x, func(x)\n", + "\n", + "def sinusoidal(x):\n", + " return np.sin(np.pi * x)\n", + "\n", + "def heaviside(x):\n", + " return 0.5 * (np.sign(x) + 1)\n", + "\n", + "func_list = [np.square, sinusoidal, np.abs, heaviside]\n", + "plt.figure(figsize=(20, 10))\n", + "x = np.linspace(-1, 1, 1000)[:, None]\n", + "for i, func, n_iter, decay_step in zip(range(1, 5), func_list, [1000, 10000, 10000, 10000], [100, 100, 1000, 1000]):\n", + " plt.subplot(2, 2, i)\n", + " x_train, y_train = create_toy_data(func)\n", + " model = RegressionNetwork(1, 3, 1)\n", + " optimizer = nn.optimizer.Adam(model, 0.1)\n", + " optimizer.set_decay(0.9, decay_step)\n", + " for _ in range(n_iter):\n", + " model.clear()\n", + " model(x_train, y_train)\n", + " log_likelihood = model.log_pdf()\n", + " log_likelihood.backward()\n", + " optimizer.update()\n", + " y = model(x)\n", + " plt.scatter(x_train, y_train, s=10)\n", + " plt.plot(x, y, color=\"r\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5.3 Error Backpropagation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "class ClassificationNetwork(nn.Network):\n", + " \n", + " def __init__(self, n_input, n_hidden, n_output):\n", + " truncnorm = st.truncnorm(a=-2, b=2, scale=1)\n", + " super().__init__(\n", + " w1=truncnorm.rvs((n_input, n_hidden)),\n", + " b1=np.zeros(n_hidden),\n", + " w2=truncnorm.rvs((n_hidden, n_output)),\n", + " b2=np.zeros(n_output)\n", + " )\n", + "\n", + " def __call__(self, x, y=None):\n", + " h = nn.tanh(x @ self.w1 + self.b1)\n", + " self.py = nn.random.Bernoulli(logit=h @ self.w2 + self.b2, data=y)\n", + " return self.py.mu.value" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEKCAYAAAAMzhLIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nXAoKERGJS0EhIiJxKShERCSu/w8dtSY0aqZoRwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUAAAAD8CAYAAAAG730QAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def create_toy_data():\n", + " x = np.random.uniform(-1., 1., size=(100, 2))\n", + " labels = np.prod(x, axis=1) > 0\n", + " return x, labels.reshape(-1, 1)\n", + "\n", + "\n", + "x_train, y_train = create_toy_data()\n", + "model = ClassificationNetwork(2, 4, 1)\n", + "optimizer = nn.optimizer.Adam(model, 1e-3)\n", + "history = []\n", + "for i in range(10000):\n", + " model.clear()\n", + " model(x_train, y_train)\n", + " log_likelihood = model.log_pdf()\n", + " log_likelihood.backward()\n", + " optimizer.update()\n", + " history.append(log_likelihood.value)\n", + " \n", + "plt.plot(history)\n", + "plt.xlabel(\"iteration\")\n", + "plt.ylabel(\"Log Likelihood\")\n", + "plt.show()\n", + " \n", + "x0, x1 = np.meshgrid(np.linspace(-1, 1, 100), np.linspace(-1, 1, 100))\n", + "x = np.array([x0, x1]).reshape(2, -1).T\n", + "y = model(x).reshape(100, 100)\n", + "\n", + "levels = np.linspace(0, 1, 11)\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train)\n", + "plt.contourf(x0, x1, y, levels, alpha=0.2)\n", + "plt.colorbar()\n", + "plt.xlim(-1, 1)\n", + "plt.ylim(-1, 1)\n", + "plt.gca().set_aspect('equal')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5.5 Regularization in Neural Networks" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAAEyCAYAAAB3bCAzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def create_toy_data(n=10):\n", + " x = np.linspace(0, 1, n)[:, None]\n", + " return x, np.sin(2 * np.pi * x) + np.random.normal(scale=0.25, size=(10, 1))\n", + "\n", + "\n", + "x_train, y_train = create_toy_data()\n", + "x = np.linspace(0, 1, 100)[:, None]\n", + "\n", + "plt.figure(figsize=(20, 5))\n", + "for i, m in enumerate([1, 3, 30]):\n", + " plt.subplot(1, 3, i + 1)\n", + " model = RegressionNetwork(1, m, 1)\n", + " optimizer = nn.optimizer.Adam(model, 0.1)\n", + " optimizer.set_decay(0.9, 1000)\n", + " for j in range(10000):\n", + " model.clear()\n", + " model(x_train, y_train)\n", + " log_posterior = model.log_pdf()\n", + " log_posterior.backward()\n", + " optimizer.update()\n", + " y = model(x)\n", + " plt.scatter(x_train, y_train, marker=\"x\", color=\"k\")\n", + " plt.plot(x, y, color=\"k\")\n", + " plt.annotate(\"M={}\".format(m), (0.7, 0.5))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "class RegularizedRegressionNetwork(nn.Network):\n", + " \n", + " def __init__(self, n_input, n_hidden, n_output):\n", + " truncnorm = st.truncnorm(a=-2, b=2, scale=1)\n", + " super().__init__(\n", + " w1=truncnorm.rvs((n_input, n_hidden)),\n", + " b1=np.zeros(n_hidden),\n", + " w2=truncnorm.rvs((n_hidden, n_output)),\n", + " b2=np.zeros(n_output)\n", + " )\n", + "\n", + " def __call__(self, x, y=None):\n", + " self.pw1 = nn.random.Gaussian(0., 1., data=self.w1)\n", + " self.pb1 = nn.random.Gaussian(0., 1., data=self.b1)\n", + " self.pw2 = nn.random.Gaussian(0., 1., data=self.w2)\n", + " self.pb2 = nn.random.Gaussian(0., 1., data=self.b2)\n", + " h = nn.tanh(x @ self.w1 + self.b1)\n", + " self.py = nn.random.Gaussian(h @ self.w2 + self.b2, std=0.1, data=y)\n", + " return self.py.mu.value" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD8CAYAAAB+UHOxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nARBCCD/1f9js1I+IIHMzAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = RegularizedRegressionNetwork(1, 30, 1)\n", + "optimizer = nn.optimizer.Adam(model, 0.1)\n", + "optimizer.set_decay(0.9, 1000)\n", + "for i in range(10000):\n", + " model.clear()\n", + " model(x_train, y_train)\n", + " log_posterior = model.log_pdf()\n", + " log_posterior.backward()\n", + " optimizer.update()\n", + "y = model(x)\n", + "plt.scatter(x_train, y_train, marker=\"x\", color=\"k\")\n", + "plt.plot(x, y, color=\"k\")\n", + "plt.annotate(\"M=30\", (0.7, 0.5))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def load_mnist():\n", + " mnist = fetch_mldata(\"MNIST original\")\n", + " x = mnist.data\n", + " label = mnist.target\n", + "\n", + " x = x / np.max(x, axis=1, keepdims=True)\n", + " x = x.reshape(-1, 28, 28, 1)\n", + "\n", + " x_train, x_test, label_train, label_test = train_test_split(x, label, test_size=0.1)\n", + " y_train = LabelBinarizer().fit_transform(label_train)\n", + " return x_train, x_test, y_train, label_test\n", + "x_train, x_test, y_train, label_test = load_mnist()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step 0000, accuracy 0.14, Log Likelihood -133.503\n", + "step 0100, accuracy 0.88, Log Likelihood -19.0089\n", + "step 0200, accuracy 0.96, Log Likelihood -9.46796\n", + "step 0300, accuracy 0.90, Log Likelihood -15.0645\n", + "step 0400, accuracy 1.00, Log Likelihood -2.39944\n", + "step 0500, accuracy 0.92, Log Likelihood -4.48378\n", + "step 0600, accuracy 0.96, Log Likelihood -4.88767\n", + "step 0700, accuracy 0.94, Log Likelihood -7.86324\n", + "step 0800, accuracy 0.98, Log Likelihood -2.44538\n", + "step 0900, accuracy 0.98, Log Likelihood -2.71264\n" + ] + } + ], + "source": [ + "class ConvolutionalNeuralNetwork(nn.Network):\n", + " \n", + " def __init__(self):\n", + " truncnorm = st.truncnorm(a=-2, b=2, scale=0.1)\n", + " super().__init__(\n", + " w1=truncnorm.rvs((5, 5, 1, 20)),\n", + " b1=np.zeros(20) + 0.1,\n", + " w2=truncnorm.rvs((5, 5, 20, 20)),\n", + " b2=np.zeros(20) + 0.1,\n", + " w3=truncnorm.rvs((4 * 4 * 20, 500)),\n", + " b3=np.zeros(500) + 0.1,\n", + " w4=truncnorm.rvs((500, 10)),\n", + " b4=np.zeros(10) + 0.1\n", + " )\n", + " \n", + " def __call__(self, x, y=None):\n", + " h = nn.relu(nn.convolve2d(x, self.w1) + self.b1)\n", + " h = nn.max_pooling2d(h, (2, 2), (2, 2))\n", + " \n", + " h = nn.relu(nn.convolve2d(h, self.w2) + self.b2)\n", + " h = nn.max_pooling2d(h, (2, 2), (2, 2))\n", + " \n", + " h = h.reshape(-1, 4 * 4 * 20)\n", + " h = nn.relu(h @ self.w3 + self.b3)\n", + " \n", + " self.py = nn.random.Categorical(logit=h @ self.w4 + self.b4, data=y)\n", + " return self.py.mu.value\n", + "\n", + "model = ConvolutionalNeuralNetwork()\n", + "optimizer = nn.optimizer.Adam(model, 1e-3)\n", + "\n", + "while True:\n", + " indices = np.random.permutation(len(x_train))\n", + " for index in range(0, len(x_train), 50):\n", + " model.clear()\n", + " x_batch = x_train[indices[index: index + 50]]\n", + " y_batch = y_train[indices[index: index + 50]]\n", + " prob = model(x_batch, y_batch)\n", + " log_likelihood = model.log_pdf()\n", + " if optimizer.n_iter % 100 == 0:\n", + " accuracy = accuracy_score(\n", + " np.argmax(y_batch, axis=-1), np.argmax(prob, axis=-1)\n", + " )\n", + " print(\"step {:04d}\".format(optimizer.n_iter), end=\", \")\n", + " print(\"accuracy {:.2f}\".format(accuracy), end=\", \")\n", + " print(\"Log Likelihood {:g}\".format(log_likelihood.value))\n", + " log_likelihood.backward()\n", + " optimizer.update()\n", + " if optimizer.n_iter == 1000:\n", + " break\n", + " else:\n", + " continue\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "accuracy (test): 0.969571428571\n" + ] + } + ], + "source": [ + "label_pred = []\n", + "for i in range(0, len(x_test), 50):\n", + " label_pred.append(np.argmax(model(x_test[i: i + 50]), axis=-1))\n", + "label_pred = np.asarray(label_pred).ravel()\n", + "print(\"accuracy (test):\", accuracy_score(label_test, label_pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5.6 Mixture Density Networks" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def create_toy_data(func, n=300):\n", + " t = np.random.uniform(size=(n, 1))\n", + " x = func(t) + np.random.uniform(-0.05, 0.05, size=(n, 1))\n", + " return x, t\n", + "\n", + "def func(x):\n", + " return x + 0.3 * np.sin(2 * np.pi * x)\n", + "\n", + "def sample(x, t, n=None):\n", + " assert len(x) == len(t)\n", + " N = len(x)\n", + " if n is None:\n", + " n = N\n", + " indices = np.random.choice(N, n, replace=False)\n", + " return x[indices], t[indices]\n", + "\n", + "x_train, y_train = create_toy_data(func)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "class MixtureDensityNetwork(nn.Network):\n", + " \n", + " def __init__(self, n_components):\n", + " truncnorm = st.truncnorm(a=-0.2, b=0.2, scale=0.1)\n", + " self.n_components = n_components\n", + " super().__init__(\n", + " w1=truncnorm.rvs((1, 5)),\n", + " b1=np.zeros(5),\n", + " w2_c=truncnorm.rvs((5, n_components)),\n", + " b2_c=np.zeros(n_components),\n", + " w2_m=truncnorm.rvs((5, n_components)),\n", + " b2_m=np.zeros(n_components),\n", + " w2_s=truncnorm.rvs((5, n_components)),\n", + " b2_s=np.zeros(n_components)\n", + " )\n", + "\n", + " def __call__(self, x, y=None):\n", + " h = nn.tanh(x @ self.w1 + self.b1)\n", + " coef = nn.softmax(h @ self.w2_c + self.b2_c)\n", + " mean = h @ self.w2_m + self.b2_m\n", + " std = nn.exp(h @ self.w2_s + self.b2_s)\n", + " self.py = nn.random.GaussianMixture(coef, mean, std, data=y)\n", + " return self.py" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [], + "source": [ + "model = MixtureDensityNetwork(3)\n", + "optimizer = nn.optimizer.Adam(model, 1e-4)\n", + "\n", + "for i in range(30000):\n", + " model.clear()\n", + " batch = sample(x_train, y_train, n=100)\n", + " model(x_train, y_train)\n", + " log_likelihood = model.log_pdf()\n", + " log_likelihood.backward()\n", + " optimizer.update()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false, + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIQAAANeCAYAAABj0NXxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nCCGEEEIIIYQQ3cz/BybjBYqfyZMMAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x, y = np.meshgrid(\n", + " np.linspace(x_train.min(), x_train.max(), 100),\n", + " np.linspace(y_train.min(), y_train.max(), 100))\n", + "xy = np.array([x, y]).reshape(2, -1).T\n", + "\n", + "p = model(xy[:, 0].reshape(-1, 1), xy[:, 1].reshape(-1, 1))\n", + "\n", + "plt.figure(figsize=(20, 15))\n", + "plt.subplot(2, 2, 1)\n", + "plt.plot(x[0], p.coef.value[:100, 0], color=\"blue\")\n", + "plt.plot(x[0], p.coef.value[:100, 1], color=\"red\")\n", + "plt.plot(x[0], p.coef.value[:100, 2], color=\"green\")\n", + "plt.title(\"weights\")\n", + "\n", + "plt.subplot(2, 2, 2)\n", + "plt.plot(x[0], p.mu.value[:100, 0], color=\"blue\")\n", + "plt.plot(x[0], p.mu.value[:100, 1], color=\"red\")\n", + "plt.plot(x[0], p.mu.value[:100, 2], color=\"green\")\n", + "plt.title(\"means\")\n", + "\n", + "plt.subplot(2, 2, 3)\n", + "prob = p.pdf().value\n", + "levels_log = np.linspace(0, np.log(prob.max()), 21)\n", + "levels = np.exp(levels_log)\n", + "levels[0] = 0\n", + "plt.contour(x, y, prob.reshape(100, 100), levels)\n", + "plt.xlim(x_train.min(), x_train.max())\n", + "plt.ylim(y_train.min(), y_train.max())\n", + "\n", + "plt.subplot(2, 2, 4)\n", + "argmax = np.argmax(p.coef.value[:100], axis=1)\n", + "for i in range(3):\n", + " indices = np.where(argmax == i)[0]\n", + " plt.plot(x[0, indices], p.mu.value[(indices, np.zeros_like(indices) + i)], color=\"r\", linewidth=2)\n", + "plt.scatter(x_train, y_train, facecolor=\"none\", edgecolor=\"b\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5.7 Bayesian Neural Networks" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "x_train, y_train = make_moons(n_samples=500, noise=0.2)\n", + "y_train = y_train[:, None]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "class BayesianNetwork(nn.Network):\n", + " \n", + " def __init__(self, n_input, n_hidden, n_output=1):\n", + " super().__init__(\n", + " w1_m=np.zeros((n_input, n_hidden)),\n", + " w1_s=np.zeros((n_input, n_hidden)),\n", + " b1_m=np.zeros(n_hidden),\n", + " b1_s=np.zeros(n_hidden),\n", + " w2_m=np.zeros((n_hidden, n_hidden)),\n", + " w2_s=np.zeros((n_hidden, n_hidden)),\n", + " b2_m=np.zeros(n_hidden),\n", + " b2_s=np.zeros(n_hidden),\n", + " w3_m=np.zeros((n_hidden, n_output)),\n", + " w3_s=np.zeros((n_hidden, n_output)),\n", + " b3_m=np.zeros(n_output),\n", + " b3_s=np.zeros(n_output)\n", + " )\n", + "\n", + " def __call__(self, x, y=None):\n", + " self.qw1 = nn.random.Gaussian(\n", + " self.w1_m, nn.softplus(self.w1_s),\n", + " p=nn.random.Gaussian(0, 1)\n", + " )\n", + " self.qb1 = nn.random.Gaussian(\n", + " self.b1_m, nn.softplus(self.b1_s),\n", + " p=nn.random.Gaussian(0, 1)\n", + " )\n", + " self.qw2 = nn.random.Gaussian(\n", + " self.w2_m, nn.softplus(self.w2_s),\n", + " p=nn.random.Gaussian(0, 1)\n", + " )\n", + " self.qb2 = nn.random.Gaussian(\n", + " self.b2_m, nn.softplus(self.b2_s),\n", + " p=nn.random.Gaussian(0, 1)\n", + " )\n", + " self.qw3 = nn.random.Gaussian(\n", + " self.w3_m, nn.softplus(self.w3_s),\n", + " p=nn.random.Gaussian(0, 1)\n", + " )\n", + " self.qb3 = nn.random.Gaussian(\n", + " self.b3_m, nn.softplus(self.b3_s),\n", + " p=nn.random.Gaussian(0, 1)\n", + " )\n", + " h = nn.tanh(x @ self.qw1.draw() + self.qb1.draw())\n", + " h = nn.tanh(h @ self.qw2.draw() + self.qb2.draw())\n", + " self.py = nn.random.Bernoulli(logit=h @ self.qw3.draw() + self.qb3.draw(), data=y)\n", + " return self.py.mu.value" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "model = BayesianNetwork(2, 5, 1)\n", + "optimizer = nn.optimizer.Adam(model, 0.1)\n", + "optimizer.set_decay(0.9, 100)\n", + "\n", + "for i in range(2000):\n", + " model.clear()\n", + " model(x_train, y_train)\n", + " elbo = model.elbo()\n", + " elbo.backward()\n", + " optimizer.update()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAATAAAAD8CAYAAADwpviIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nUbU4A+ZwOKoWZ8AcDkfV4gyYw+GoWv4/6Q+G4JKlFHEAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x_grid = np.mgrid[-2:3:100j, -2:3:100j]\n", + "x1, x2 = x_grid[0], x_grid[1]\n", + "x_grid = x_grid.reshape(2, -1).T\n", + "\n", + "y = np.mean([model(x_grid).reshape(100, 100) for _ in range(10)], axis=0)\n", + "\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train, s=5)\n", + "plt.contourf(x1, x2, y, np.linspace(0, 1, 11), alpha=0.2)\n", + "plt.colorbar()\n", + "plt.xlim(-2, 3)\n", + "plt.ylim(-2, 3)\n", + "plt.gca().set_aspect('equal', adjustable='box')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.0" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/books/PRML/PRML-master-Python/notebooks/ch06_Kernel_Methods.ipynb b/books/PRML/PRML-master-Python/notebooks/ch06_Kernel_Methods.ipynb new file mode 100755 index 0000000..9ec7786 --- /dev/null +++ b/books/PRML/PRML-master-Python/notebooks/ch06_Kernel_Methods.ipynb @@ -0,0 +1,329 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 6. Kernel Methods" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from prml.kernel import (\n", + " PolynomialKernel,\n", + " RBF,\n", + " GaussianProcessClassifier,\n", + " GaussianProcessRegressor\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def create_toy_data(func, n=10, std=1., domain=[0., 1.]):\n", + " x = np.linspace(domain[0], domain[1], n)\n", + " t = func(x) + np.random.normal(scale=std, size=n)\n", + " return x, t\n", + "\n", + "def sinusoidal(x):\n", + " return np.sin(2 * np.pi * x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6.1 Dual Representation" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_train, y_train = create_toy_data(sinusoidal, n=10, std=0.1)\n", + "x = np.linspace(0, 1, 100)\n", + "\n", + "model = GaussianProcessRegressor(kernel=PolynomialKernel(3, 1.), beta=int(1e10))\n", + "model.fit(x_train, y_train)\n", + "\n", + "y = model.predict(x)\n", + "plt.scatter(x_train, y_train, facecolor=\"none\", edgecolor=\"b\", color=\"blue\", label=\"training\")\n", + "plt.plot(x, sinusoidal(x), color=\"g\", label=\"sin$(2\\pi x)$\")\n", + "plt.plot(x, y, color=\"r\", label=\"gpr\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6.4 Gaussian Processes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 6.4.2 Gaussian processes for regression" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_train, y_train = create_toy_data(sinusoidal, n=7, std=0.1, domain=[0., 0.7])\n", + "x = np.linspace(0, 1, 100)\n", + "\n", + "model = GaussianProcessRegressor(kernel=RBF(np.array([1., 15.])), beta=100)\n", + "model.fit(x_train, y_train)\n", + "\n", + "y, y_std = model.predict(x, with_error=True)\n", + "plt.scatter(x_train, y_train, facecolor=\"none\", edgecolor=\"b\", color=\"blue\", label=\"training\")\n", + "plt.plot(x, sinusoidal(x), color=\"g\", label=\"sin$(2\\pi x)$\")\n", + "plt.plot(x, y, color=\"r\", label=\"gpr\")\n", + "plt.fill_between(x, y - y_std, y + y_std, alpha=0.5, color=\"pink\", label=\"std\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 6.4.3 Learning the hyperparameters" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_train, y_train = create_toy_data(sinusoidal, n=7, std=0.1, domain=[0., 0.7])\n", + "x = np.linspace(0, 1, 100)\n", + "\n", + "plt.figure(figsize=(20, 5))\n", + "plt.subplot(1, 2, 1)\n", + "model = GaussianProcessRegressor(kernel=RBF(np.array([1., 1.])), beta=100)\n", + "model.fit(x_train, y_train)\n", + "y, y_std = model.predict(x, with_error=True)\n", + "plt.scatter(x_train, y_train, facecolor=\"none\", edgecolor=\"b\", color=\"blue\", label=\"training\")\n", + "plt.plot(x, sinusoidal(x), color=\"g\", label=\"sin$(2\\pi x)$\")\n", + "plt.plot(x, y, color=\"r\", label=\"gpr {}\".format(model.kernel.params))\n", + "plt.fill_between(x, y - y_std, y + y_std, alpha=0.5, color=\"pink\", label=\"std\")\n", + "plt.legend()\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "model.fit(x_train, y_train, iter_max=100)\n", + "y, y_std = model.predict(x, with_error=True)\n", + "plt.scatter(x_train, y_train, facecolor=\"none\", edgecolor=\"b\", color=\"blue\", label=\"training\")\n", + "plt.plot(x, sinusoidal(x), color=\"g\", label=\"sin$(2\\pi x)$\")\n", + "plt.plot(x, y, color=\"r\", label=\"gpr {}\".format(np.round(model.kernel.params, 2)))\n", + "plt.fill_between(x, y - y_std, y + y_std, alpha=0.5, color=\"pink\", label=\"std\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 6.4.4 Automatic relevance determination" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def create_toy_data_3d(func, n=10, std=1.):\n", + " x0 = np.linspace(0, 1, n)\n", + " x1 = x0 + np.random.normal(scale=std, size=n)\n", + " x2 = np.random.normal(scale=std, size=n)\n", + " t = func(x0) + np.random.normal(scale=std, size=n)\n", + " return np.vstack((x0, x1, x2)).T, t" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_train, y_train = create_toy_data_3d(sinusoidal, n=20, std=0.1)\n", + "x0 = np.linspace(0, 1, 100)\n", + "x1 = x0 + np.random.normal(scale=0.1, size=100)\n", + "x2 = np.random.normal(scale=0.1, size=100)\n", + "x = np.vstack((x0, x1, x2)).T\n", + "\n", + "model = GaussianProcessRegressor(kernel=RBF(np.array([1., 1., 1., 1.])), beta=100)\n", + "model.fit(x_train, y_train)\n", + "y, y_std = model.predict(x, with_error=True)\n", + "plt.figure(figsize=(20, 5))\n", + "plt.subplot(1, 2, 1)\n", + "plt.scatter(x_train[:, 0], y_train, facecolor=\"none\", edgecolor=\"b\", label=\"training\")\n", + "plt.plot(x[:, 0], sinusoidal(x[:, 0]), color=\"g\", label=\"$\\sin(2\\pi x)$\")\n", + "plt.plot(x[:, 0], y, color=\"r\", label=\"gpr {}\".format(model.kernel.params))\n", + "plt.fill_between(x[:, 0], y - y_std, y + y_std, color=\"pink\", alpha=0.5, label=\"gpr std.\")\n", + "plt.legend()\n", + "plt.ylim(-1.5, 1.5)\n", + "\n", + "model.fit(x_train, y_train, iter_max=100, learning_rate=0.001)\n", + "y, y_std = model.predict(x, with_error=True)\n", + "plt.subplot(1, 2, 2)\n", + "plt.scatter(x_train[:, 0], y_train, facecolor=\"none\", edgecolor=\"b\", label=\"training\")\n", + "plt.plot(x[:, 0], sinusoidal(x[:, 0]), color=\"g\", label=\"$\\sin(2\\pi x)$\")\n", + "plt.plot(x[:, 0], y, color=\"r\", label=\"gpr {}\".format(np.round(model.kernel.params, 2)))\n", + "plt.fill_between(x[:, 0], y - y_std, y + y_std, color=\"pink\", alpha=0.2, label=\"gpr std.\")\n", + "plt.legend()\n", + "plt.ylim(-1.5, 1.5)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "### 6.4.5 Gaussian processes for classification" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def create_toy_data():\n", + " x0 = np.random.normal(size=50).reshape(-1, 2)\n", + " x1 = np.random.normal(size=50).reshape(-1, 2) + 2.\n", + " return np.concatenate([x0, x1]), np.concatenate([np.zeros(25), np.ones(25)]).astype(np.int)[:, None]\n", + "\n", + "x_train, y_train = create_toy_data()\n", + "x0, x1 = np.meshgrid(np.linspace(-4, 6, 100), np.linspace(-4, 6, 100))\n", + "x = np.array([x0, x1]).reshape(2, -1).T\n", + "\n", + "model = GaussianProcessClassifier(RBF(np.array([1., 7., 7.])))\n", + "model.fit(x_train, y_train)\n", + "y = model.predict(x)\n", + "\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train.ravel())\n", + "plt.contourf(x0, x1, y.reshape(100, 100), levels=np.linspace(0,1,3), alpha=0.2)\n", + "plt.colorbar()\n", + "plt.xlim(-4, 6)\n", + "plt.ylim(-4, 6)\n", + "plt.gca().set_aspect('equal', adjustable='box')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/books/PRML/PRML-master-Python/notebooks/ch07_Sparse_Kernel_Machines.ipynb b/books/PRML/PRML-master-Python/notebooks/ch07_Sparse_Kernel_Machines.ipynb new file mode 100755 index 0000000..35abc9b --- /dev/null +++ b/books/PRML/PRML-master-Python/notebooks/ch07_Sparse_Kernel_Machines.ipynb @@ -0,0 +1,305 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 7. Sparse Kernel Machines" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from prml.kernel import (\n", + " RBF,\n", + " PolynomialKernel,\n", + " SupportVectorClassifier,\n", + " RelevanceVectorRegressor,\n", + " RelevanceVectorClassifier\n", + ")\n", + "\n", + "np.random.seed(1234)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7.1 Maximum Margin Classifiers" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_train = np.array([\n", + " [0., 2.],\n", + " [2., 0.],\n", + " [-1., -1.]])\n", + "y_train = np.array([1., 1., -1.])\n", + "\n", + "model = SupportVectorClassifier(PolynomialKernel(degree=1))\n", + "model.fit(x_train, y_train)\n", + "x0, x1 = np.meshgrid(np.linspace(-3, 3, 100), np.linspace(-3, 3, 100))\n", + "x = np.array([x0, x1]).reshape(2, -1).T\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], s=40, c=y_train, marker=\"x\")\n", + "plt.scatter(model.X[:, 0], model.X[:, 1], s=100, facecolor=\"none\", edgecolor=\"g\")\n", + "cp = plt.contour(x0, x1, model.distance(x).reshape(100, 100), np.array([-1, 0, 1]), colors=\"k\", linestyles=(\"dashed\", \"solid\", \"dashed\"))\n", + "plt.clabel(cp, fmt='y=%.f', inline=True, fontsize=15)\n", + "plt.xlim(-3, 3)\n", + "plt.ylim(-3, 3)\n", + "plt.gca().set_aspect(\"equal\", adjustable=\"box\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def create_toy_data():\n", + " x = np.random.uniform(-1, 1, 100).reshape(-1, 2)\n", + " y = x < 0\n", + " y = (y[:, 0] * y[:, 1]).astype(np.float)\n", + " return x, 1 - 2 * y\n", + "\n", + "x_train, y_train = create_toy_data()\n", + "\n", + "model = SupportVectorClassifier(RBF(np.ones(3)))\n", + "model.fit(x_train, y_train)\n", + "\n", + "x0, x1 = np.meshgrid(np.linspace(-1, 1, 100), np.linspace(-1, 1, 100))\n", + "x = np.array([x0, x1]).reshape(2, -1).T\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], s=40, c=y_train, marker=\"x\")\n", + "plt.scatter(model.X[:, 0], model.X[:, 1], s=100, facecolor=\"none\", edgecolor=\"g\")\n", + "plt.contour(\n", + " x0, x1, model.distance(x).reshape(100, 100),\n", + " np.arange(-1, 2), colors=\"k\", linestyles=(\"dashed\", \"solid\", \"dashed\"))\n", + "plt.xlim(-1, 1)\n", + "plt.ylim(-1, 1)\n", + "plt.gca().set_aspect(\"equal\", adjustable=\"box\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 7.1.1 Overlapping class distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def create_toy_data():\n", + " x0 = np.random.normal(size=100).reshape(-1, 2) - 1.\n", + " x1 = np.random.normal(size=100).reshape(-1, 2) + 1.\n", + " x = np.concatenate([x0, x1])\n", + " y = np.concatenate([-np.ones(50), np.ones(50)]).astype(np.int)\n", + " return x, y\n", + "\n", + "x_train, y_train = create_toy_data()\n", + "\n", + "model = SupportVectorClassifier(RBF(np.array([1., 0.5, 0.5])), C=1.)\n", + "model.fit(x_train, y_train)\n", + "\n", + "x0, x1 = np.meshgrid(np.linspace(-4, 4, 100), np.linspace(-4, 4, 100))\n", + "x = np.array([x0, x1]).reshape(2, -1).T\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], s=40, c=y_train, marker=\"x\")\n", + "plt.scatter(model.X[:, 0], model.X[:, 1], s=100, facecolor=\"none\", edgecolor=\"g\")\n", + "plt.contour(x0, x1, model.distance(x).reshape(100, 100), np.arange(-1, 2), colors=\"k\", linestyles=(\"dashed\", \"solid\", \"dashed\"))\n", + "plt.xlim(-4, 4)\n", + "plt.ylim(-4, 4)\n", + "plt.gca().set_aspect(\"equal\", adjustable=\"box\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7.2 Relevance Vector Machines" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "### 7.2.1 RVM for regression" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def create_toy_data(n=10):\n", + " x = np.linspace(0, 1, n)\n", + " t = np.sin(2 * np.pi * x) + np.random.normal(scale=0.1, size=n)\n", + " return x, t\n", + "\n", + "x_train, y_train = create_toy_data(n=10)\n", + "x = np.linspace(0, 1, 100)\n", + "\n", + "model = RelevanceVectorRegressor(RBF(np.array([1., 20.])))\n", + "model.fit(x_train, y_train)\n", + "\n", + "y, y_std = model.predict(x)\n", + "\n", + "plt.scatter(x_train, y_train, facecolor=\"none\", edgecolor=\"g\", label=\"training\")\n", + "plt.scatter(model.X.ravel(), model.t, s=100, facecolor=\"none\", edgecolor=\"b\", label=\"relevance vector\")\n", + "plt.plot(x, y, color=\"r\", label=\"predict mean\")\n", + "plt.fill_between(x, y - y_std, y + y_std, color=\"pink\", alpha=0.2, label=\"predict std.\")\n", + "plt.legend(loc=\"best\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 7.2.3 RVM for classification" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def create_toy_data():\n", + " x0 = np.random.normal(size=100).reshape(-1, 2) - 1.\n", + " x1 = np.random.normal(size=100).reshape(-1, 2) + 1.\n", + " x = np.concatenate([x0, x1])\n", + " y = np.concatenate([np.zeros(50), np.ones(50)]).astype(np.int)\n", + " return x, y\n", + "\n", + "x_train, y_train = create_toy_data()\n", + "\n", + "model = RelevanceVectorClassifier(RBF(np.array([1., 0.5, 0.5])))\n", + "model.fit(x_train, y_train)\n", + "\n", + "x0, x1 = np.meshgrid(np.linspace(-4, 4, 100), np.linspace(-4, 4, 100))\n", + "x = np.array([x0, x1]).reshape(2, -1).T\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], s=40, c=y_train, marker=\"x\")\n", + "plt.scatter(model.X[:, 0], model.X[:, 1], s=100, facecolor=\"none\", edgecolor=\"g\")\n", + "plt.contourf(x0, x1, model.predict_proba(x).reshape(100, 100), np.linspace(0, 1, 5), alpha=0.2)\n", + "plt.colorbar()\n", + "plt.xlim(-4, 4)\n", + "plt.ylim(-4, 4)\n", + "plt.gca().set_aspect(\"equal\", adjustable=\"box\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/books/PRML/PRML-master-Python/notebooks/ch08_Graphical_Models.ipynb b/books/PRML/PRML-master-Python/notebooks/ch08_Graphical_Models.ipynb new file mode 100755 index 0000000..9e4f5e8 --- /dev/null +++ b/books/PRML/PRML-master-Python/notebooks/ch08_Graphical_Models.ipynb @@ -0,0 +1,286 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 8. Graphical Models" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import itertools\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from sklearn.datasets import fetch_mldata\n", + "from prml import bayesnet as bn\n", + "\n", + "\n", + "np.random.seed(1234)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "b = bn.discrete([0.1, 0.9])\n", + "f = bn.discrete([0.1, 0.9])\n", + "\n", + "g = bn.discrete([[[0.9, 0.8], [0.8, 0.2]], [[0.1, 0.2], [0.2, 0.8]]], b, f)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b: DiscreteVariable(proba=[0.1 0.9])\n", + "f: DiscreteVariable(proba=[0.1 0.9])\n", + "g: DiscreteVariable(proba=[0.315 0.685])\n" + ] + } + ], + "source": [ + "print(\"b:\", b)\n", + "print(\"f:\", f)\n", + "print(\"g:\", g)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "g.observe(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b: DiscreteVariable(proba=[0.25714286 0.74285714])\n", + "f: DiscreteVariable(proba=[0.25714286 0.74285714])\n", + "g: DiscreteVariable(observed=[1. 0.])\n" + ] + } + ], + "source": [ + "print(\"b:\", b)\n", + "print(\"f:\", f)\n", + "print(\"g:\", g)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "b.observe(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b: DiscreteVariable(observed=[1. 0.])\n", + "f: DiscreteVariable(proba=[0.11111111 0.88888889])\n", + "g: DiscreteVariable(observed=[1. 0.])\n" + ] + } + ], + "source": [ + "print(\"b:\", b)\n", + "print(\"f:\", f)\n", + "print(\"g:\", g)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 8.3.3 Illustration: Image de-noising" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mnist = fetch_mldata(\"MNIST original\")\n", + "x = mnist.data[0]\n", + "binarized_img = (x > 127).astype(np.int).reshape(28, 28)\n", + "plt.imshow(binarized_img, cmap=\"gray\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "indices = np.random.choice(binarized_img.size, size=int(binarized_img.size * 0.1), replace=False)\n", + "noisy_img = np.copy(binarized_img)\n", + "noisy_img.ravel()[indices] = 1 - noisy_img.ravel()[indices]\n", + "plt.imshow(noisy_img, cmap=\"gray\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "markov_random_field = np.array([\n", + " [[bn.discrete([0.5, 0.5], name=f\"p(z_({i},{j}))\") for j in range(28)] for i in range(28)], \n", + " [[bn.DiscreteVariable(2) for _ in range(28)] for _ in range(28)]])\n", + "a = 0.9\n", + "b = 0.9\n", + "pa = [[a, 1 - a], [1 - a, a]]\n", + "pb = [[b, 1 - b], [1 - b, b]]\n", + "for i, j in itertools.product(range(28), range(28)):\n", + " bn.discrete(pb, markov_random_field[0, i, j], out=markov_random_field[1, i, j], name=f\"p(x_({i},{j})|z_({i},{j}))\")\n", + " if i != 27:\n", + " bn.discrete(pa, out=[markov_random_field[0, i, j], markov_random_field[0, i + 1, j]], name=f\"p(z_({i},{j}), z_({i+1},{j}))\")\n", + " if j != 27:\n", + " bn.discrete(pa, out=[markov_random_field[0, i, j], markov_random_field[0, i, j + 1]], name=f\"p(z_({i},{j}), z_({i},{j+1}))\")\n", + " markov_random_field[1, i, j].observe(noisy_img[i, j], proprange=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for _ in range(10000):\n", + " i, j = np.random.choice(28, 2)\n", + " markov_random_field[1, i, j].send_message(proprange=3)\n", + "restored_img = np.zeros_like(noisy_img)\n", + "for i, j in itertools.product(range(28), range(28)):\n", + " restored_img[i, j] = np.argmax(markov_random_field[0, i, j].proba)\n", + "plt.imshow(restored_img, cmap=\"gray\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/books/PRML/PRML-master-Python/notebooks/ch09_Mixture_Models_and_EM.ipynb b/books/PRML/PRML-master-Python/notebooks/ch09_Mixture_Models_and_EM.ipynb new file mode 100755 index 0000000..e93c4b6 --- /dev/null +++ b/books/PRML/PRML-master-Python/notebooks/ch09_Mixture_Models_and_EM.ipynb @@ -0,0 +1,214 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 9. Mixture Models and EM" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from sklearn.datasets import fetch_mldata\n", + "%matplotlib inline\n", + "\n", + "from prml.clustering import KMeans\n", + "from prml.rv import (\n", + " MultivariateGaussianMixture,\n", + " BernoulliMixture\n", + ")\n", + "\n", + "np.random.seed(1111)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9.1 K-means Clustering" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# training data\n", + "x1 = np.random.normal(size=(100, 2))\n", + "x1 += np.array([-5, -5])\n", + "x2 = np.random.normal(size=(100, 2))\n", + "x2 += np.array([5, -5])\n", + "x3 = np.random.normal(size=(100, 2))\n", + "x3 += np.array([0, 5])\n", + "x_train = np.vstack((x1, x2, x3))\n", + "\n", + "x0, x1 = np.meshgrid(np.linspace(-10, 10, 100), np.linspace(-10, 10, 100))\n", + "x = np.array([x0, x1]).reshape(2, -1).T" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "kmeans = KMeans(n_clusters=3)\n", + "kmeans.fit(x_train)\n", + "cluster = kmeans.predict(x_train)\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], c=cluster)\n", + "plt.scatter(kmeans.centers[:, 0], kmeans.centers[:, 1], s=200, marker='X', lw=2, c=['purple', 'cyan', 'yellow'], edgecolor=\"white\")\n", + "plt.contourf(x0, x1, kmeans.predict(x).reshape(100, 100), alpha=0.1)\n", + "plt.xlim(-10, 10)\n", + "plt.ylim(-10, 10)\n", + "plt.gca().set_aspect('equal', adjustable='box')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## 9.2 Mixture of Gaussians" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "gmm = MultivariateGaussianMixture(n_components=3)\n", + "gmm.fit(x_train)\n", + "p = gmm.classify_proba(x_train)\n", + "\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], c=p)\n", + "plt.scatter(gmm.mu[:, 0], gmm.mu[:, 1], s=200, marker='X', lw=2, c=['red', 'green', 'blue'], edgecolor=\"white\")\n", + "plt.xlim(-10, 10)\n", + "plt.ylim(-10, 10)\n", + "plt.gca().set_aspect(\"equal\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "### 9.3.3 Mixtures of Bernoulli distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "mnist = fetch_mldata(\"MNIST original\")\n", + "x = mnist.data\n", + "y = mnist.target\n", + "x_train = []\n", + "for i in [0, 1, 2, 3, 4]:\n", + " x_train.append(x[np.random.choice(np.where(y == i)[0], 200)])\n", + "x_train = np.concatenate(x_train, axis=0)\n", + "x_train = (x_train > 127).astype(np.float)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "bmm = BernoulliMixture(n_components=5)\n", + "bmm.fit(x_train)\n", + "\n", + "plt.figure(figsize=(20, 5))\n", + "for i, mean in enumerate(bmm.mu):\n", + " plt.subplot(1, 5, i + 1)\n", + " plt.imshow(mean.reshape(28, 28), cmap=\"gray\")\n", + " plt.axis('off')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/books/PRML/PRML-master-Python/notebooks/ch10_Approximate_Inference.ipynb b/books/PRML/PRML-master-Python/notebooks/ch10_Approximate_Inference.ipynb new file mode 100755 index 0000000..00b874b --- /dev/null +++ b/books/PRML/PRML-master-Python/notebooks/ch10_Approximate_Inference.ipynb @@ -0,0 +1,558 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 10. Approximate Inference" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.animation as animation\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "%matplotlib inline\n", + "\n", + "from prml.rv import VariationalGaussianMixture\n", + "from prml.preprocess import PolynomialFeature\n", + "from prml.linear import (\n", + " VariationalLinearRegression,\n", + " VariationalLogisticRegression\n", + ")\n", + "\n", + "np.random.seed(1234)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10.2 Illustration: Variational Mixture of Gaussians" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "x1 = np.random.normal(size=(100, 2))\n", + "x1 += np.array([-5, -5])\n", + "x2 = np.random.normal(size=(100, 2))\n", + "x2 += np.array([5, -5])\n", + "x3 = np.random.normal(size=(100, 2))\n", + "x3 += np.array([0, 5])\n", + "x_train = np.vstack((x1, x2, x3))\n", + "\n", + "x0, x1 = np.meshgrid(np.linspace(-10, 10, 100), np.linspace(-10, 10, 100))\n", + "x = np.array([x0, x1]).reshape(2, -1).T" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "vgmm = VariationalGaussianMixture(n_components=6)\n", + "vgmm.fit(x_train)\n", + "\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], c=vgmm.classify(x_train))\n", + "plt.contour(x0, x1, vgmm.pdf(x).reshape(100, 100))\n", + "plt.xlim(-10, 10, 100)\n", + "plt.ylim(-10, 10, 100)\n", + "plt.gca().set_aspect('equal', adjustable='box')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vgmm = VariationalGaussianMixture(n_components=6)\n", + "vgmm._init_params(x_train)\n", + "params = np.hstack([param.flatten() for param in vgmm.get_params()])\n", + "fig = plt.figure()\n", + "colors = np.array([\"r\", \"orange\", \"y\", \"g\", \"b\", \"purple\"])\n", + "frames = []\n", + "for _ in range(100):\n", + " plt.xlim(-10, 10)\n", + " plt.ylim(-10, 10)\n", + " plt.gca().set_aspect('equal', adjustable='box')\n", + " r = vgmm._variational_expectation(x_train)\n", + " imgs = [plt.scatter(x_train[:, 0], x_train[:, 1], c=colors[np.argmax(r, -1)])]\n", + " for i in range(vgmm.n_components):\n", + " if vgmm.component_size[i] > 1:\n", + " imgs.append(plt.scatter(vgmm.mu[i, 0], vgmm.mu[i, 1], 100, colors[i], \"X\", lw=2, edgecolors=\"white\"))\n", + " frames.append(imgs)\n", + " vgmm._variational_maximization(x_train, r)\n", + " new_params = np.hstack([param.flatten() for param in vgmm.get_params()])\n", + " if np.allclose(new_params, params):\n", + " break\n", + " else:\n", + " params = np.copy(new_params)\n", + "plt.close()\n", + "plt.rcParams['animation.html'] = 'html5'\n", + "anim = animation.ArtistAnimation(fig, frames)\n", + "anim" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10.3 Variational Linear Regression" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def create_toy_data(func, sample_size, std, domain=[0, 1]):\n", + " x = np.linspace(domain[0], domain[1], sample_size)\n", + " np.random.shuffle(x)\n", + " t = func(x) + np.random.normal(scale=std, size=x.shape)\n", + " return x, t\n", + "\n", + "def cubic(x):\n", + " return x * (x - 5) * (x + 5)\n", + "\n", + "x_train, y_train = create_toy_data(cubic, 10, 10., [-5, 5])\n", + "x = np.linspace(-5, 5, 100)\n", + "y = cubic(x)\n", + "\n", + "feature = PolynomialFeature(degree=3)\n", + "X_train = feature.transform(x_train)\n", + "X = feature.transform(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "vlr = VariationalLinearRegression(beta=0.01)\n", + "vlr.fit(X_train, y_train)\n", + "y_mean, y_std = vlr.predict(X, return_std=True)\n", + "plt.scatter(x_train, y_train, s=100, facecolor=\"none\", edgecolor=\"b\")\n", + "plt.plot(x, y, c=\"g\", label=\"$\\sin(2\\pi x)$\")\n", + "plt.plot(x, y_mean, c=\"r\", label=\"prediction\") \n", + "plt.fill_between(x, y_mean - y_std, y_mean + y_std, alpha=0.2, color=\"pink\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10.6 Variational Logistic Regression" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def create_toy_data(add_outliers=False, add_class=False):\n", + " x0 = np.random.normal(size=50).reshape(-1, 2) - 3.\n", + " x1 = np.random.normal(size=50).reshape(-1, 2) + 3.\n", + " return np.concatenate([x0, x1]), np.concatenate([np.zeros(25), np.ones(25)]).astype(np.int)\n", + "x_train, y_train = create_toy_data()\n", + "x0, x1 = np.meshgrid(np.linspace(-7, 7, 100), np.linspace(-7, 7, 100))\n", + "x = np.array([x0, x1]).reshape(2, -1).T\n", + "feature = PolynomialFeature(degree=1)\n", + "X_train = feature.transform(x_train)\n", + "X = feature.transform(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "vlr = VariationalLogisticRegression()\n", + "vlr.fit(X_train, y_train)\n", + "y = vlr.proba(X).reshape(100, 100)\n", + "\n", + "plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train)\n", + "plt.contourf(x0, x1, y, np.array([0., 0.01, 0.1, 0.25, 0.5, 0.75, 0.9, 0.99, 1.]), alpha=0.2)\n", + "plt.colorbar()\n", + "plt.xlim(-7, 7)\n", + "plt.ylim(-7, 7)\n", + "plt.gca().set_aspect('equal', adjustable='box')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/books/PRML/PRML-master-Python/notebooks/ch11_Sampling_Methods.ipynb b/books/PRML/PRML-master-Python/notebooks/ch11_Sampling_Methods.ipynb new file mode 100755 index 0000000..03102a8 --- /dev/null +++ b/books/PRML/PRML-master-Python/notebooks/ch11_Sampling_Methods.ipynb @@ -0,0 +1,228 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 11. Sampling Methods" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "%matplotlib inline\n", + "\n", + "from prml.rv import Gaussian, Uniform\n", + "from prml.sampling import metropolis, metropolis_hastings, rejection_sampling, sir\n", + "\n", + "np.random.seed(1234)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 11.1.2 Rejection sampling" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAD8CAYAAABXe05zAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhVsIIcKMFG4hhAgz/z+i8FHoqCRn6AAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def func(x):\n", + " return np.exp(-x ** 2) + 3 * np.exp(-(x - 3) ** 2)\n", + "x = np.linspace(-5, 10, 100)\n", + "rv = Gaussian(mu=np.array([2.]), var=np.array([2.]))\n", + "plt.plot(x, func(x), label=r\"$\\tilde{p}(z)$\")\n", + "plt.plot(x, 15 * rv.pdf(x), label=r\"$kq(z)$\")\n", + "plt.fill_between(x, func(x), 15 * rv.pdf(x), color=\"gray\")\n", + "plt.legend(fontsize=15)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xd0XNW1+PHvntGo92JLVrFccAUb2woYgwmBkEczhkCI\nIc+hJcQJ5CU/WkKyHiSQXt5LSHh0HuRBDBgSQkI1vRiwLdty77Z6s3ovM+f3x8zIkqwykqZptD9r\nzZJm5sy9WyNp3zPn7nuOGGNQSikVWiyBDkAppZT3aXJXSqkQpMldKaVCkCZ3pZQKQZrclVIqBGly\nV0qpEKTJXSmlQpAmd6WUCkGa3JVSKgSFBWrHqampJjc3N1C7V0qpcSk/P/+YMSZtuHYBS+65ubls\n3rw5ULtXSqlxSUQKPWmnwzJKKRWCNLkrpVQI0uSulFIhSJO7UkqFoGGTu4hEishGESkQkV0i8tMB\n2oiI3C8iB0Vku4gs9k24SimlPOFJtUwHcK4xpllEbMBHIvKaMebTXm0uBE5y3U4HHnR9VUopFQDD\nJnfjXKqp2XXX5rr1X75pJfAXV9tPRSRRRDKMMeVejVYpNaDGxkaqqqro6uoKdChqDGw2G5MmTSI+\nPn7M2/Kozl1ErEA+MBN4wBjzWb8mmUBxr/slrsc0uauQVd7QxscHa/jyokwsFglYHI2NjVRWVpKZ\nmUlUVBQigYtFjZ4xhra2NkpLSwHGnOA9Su7GGDtwqogkAn8XkZONMTtHujMRuQm4CSAnJ2ekL1cq\naGwvqefGpzZT3dRBlM3KxQsyAhZLVVUVmZmZREdHBywGNXYiQnR0NJmZmZSVlY05uY+oWsYYUw+8\nC1zQ76lSILvX/SzXY/1f/4gxJs8Yk5eWNuzVs0oFpdd3lnPVw58QbrUwNSWaP7y1H7sjcAvNd3V1\nERUVFbD9K++KioryyvCaJ9Uyaa4eOyISBZwP7O3X7GXg666qmaVAg463q1C0fncl335mC3Mz4nnp\n5jO57UuzOVDVzCs7AvvnrkMxocNbv0tPeu4ZwLsish3YBKw3xvxLRNaIyBpXm1eBw8BB4FHgO16J\nTqkg82J+CZPjIln7zaWkxUVw8SkZzJocyx8D3HtXqj9PqmW2A4sGePyhXt8b4GbvhqZUcOmyO/j4\n4DEuWZhBpM0KgNUifP+Ls/jOM1v4Z0EZly3KDHCUSjnpFapKeWhrUT1NHd2cfVLf80UXzE9nTnoc\n9799gG67I0DRKdWXJnelPPT+/iqsFmHZzNQ+j1sswne+MJPDx1rIL6wLUHSh49prryUpKYk//vGP\nrF27luuuu67P88YYTj31VJ566imPt3nLLbdw4403ejnS4KbJXSkPvb+/msU5iSRE2U547swZKQBs\nLa73d1ghpa6ujjfeeIPHHnuMp59+mptvvpkbbrihT5vnn3+e2tparrnmGo+3e/vtt/PMM89w8OBB\nb4cctDS5K+WBY80d7Cxt5POzBi7hTYmNIDclmq1F2nMfi6SkJCoqKrjiiivYtGkTtbW1nH322X3a\n3H///axevRqb7cSD7GByc3M566yzePDBB70dctDS5K6UBz48UA3A52dNGrTNopwkthTV46wvUKOR\nnJzMf/7nf/K1r32NlJQUkpOT+da3vkVHRwcABw8eZMOGDVx55ZV9Xvfcc88hIgPeGhsbAbjiiit4\n5plncDgmxnkRTe5KeeD9fdWkxIQzf8rgVw0uykmkuqmD0vo2P0YWOoqKiqirq+O///u/SU5OZt26\ndXz/+9/nkUce4YEHHgDg7bffJiYmhoULF/Z57dlnn80nn3zSc3vllVdITk7moosu6rnSc9myZVRW\nVrJjxw6//2yBELA1VJUaLxwOwwcHjnH2SalDziGzOCcJcFbVZCXpVAAjVVBQADhPfv7qV78C4Nxz\nz+WDDz7g9ddf59ZbbyU/P5+5c+disfTtl2ZkZJCR4ZwCorGxkfPOO4+TTz6ZdevW9bSZP38+VquV\njRs3nnBwCEWa3JUaxs6yBmpbOvn87KGnzJidHkekzcKWojpWLJzip+gG9tN/7mJ3WWNA9j1vSjz3\nrJg/4tcVFBQQHR3NHXfc0efxWbNmsXHjRgAqKipITU0d6OUAtLS0cNFFF2GxWPjXv/7VZ76dsLAw\nEhMTqaioGHFs45Emd6WG8eGBYwAsP2no5G6zWliQmcjWIq2YGY2CggLOPvtsUlJS+jxeUVHBlCnO\ng2V7e/ugE6S1t7dz6aWX0tLSwjvvvENcXNwJbSIiImhvb/d+8EFIk7tSw9hV1kBuSjSpsRHDtl00\nNZH//egoHd12IsKsfohuYKPpOQdaQUEBy5cv7/NYU1MT77zzDj/9qXMBuOTk5AF73l1dXVxxxRWU\nl5fz/vvvk5SUNOA+6uvrSU5O9n7wQUhPqCo1jL0VTcxOP7EXOJBF2Ul02h3sLA3MkMh41dLSwqFD\nhzh06FCfx++//37AeWETwOzZszly5EifNna7nauvvpp9+/bx1ltvMdiMs9XV1bS2tjJr1iwf/ATB\nR3vuSg2hvcvO0WMtXHKKZ/O1L85JBGBrUR1Lpg7ce1Qn2rFjBw6Hg0OHDnHvvfeyfPly3nzzTX7/\n+9/z9NNPk5jofF/PPPNM7r33Xqqrq3uS+Le//W1effVVnnzySYqKiigqKgIgJiaGU045pWcfmzdv\nRkRYtmyZ/3/AANDkrtQQDlU34zAwy8Oe+6T4SDITo/RK1REqKCggPj6eV155heuvv56f//znzJ49\nm3Xr1rFy5cqedueccw7Jycm8/vrrrF69GmMMzz77LG1tbXz1q1/ts80VK1bw8ssv99x//fXX+fzn\nP3/CmH6o0uSu1BD2VzYBMHuyZ8kdnPXuW3SOmREpKCjglFNOYcGCBeTn5w/aLjw8nH//93/n2Wef\nZfXq1X0uUhqK3W7nxRdf7CmxnAh0zF2pIeyraMZmFXJTYzx+zaKcJMoa2qlomBhVGd5QUFDgce35\nHXfcwbvvvsv+/fs93v66deuIiopi1apVow1x3NHkrtQQ9lc2MSMtFpvV83+VU7MTANhZ2uCrsEKK\nMYYdO3awYMECj9pnZWXxxBNPUF7u+epXxhgef/xxwsImzmDFxPlJlRqFfRVNIz4xOiMtFoDDx5qB\nyT6IKrR4OrTS20h74FdfffWI2ocC7bkrNYim9i5K69s8LoN0S4wOJyUmnMPVLT6KTKnhaXJXahD7\nK5uBkZ1MdZueFqPJXQWUJnelBtFTKTPCnjvA9NRYDlU3ezskpTymyV2pQeyraCI63EpmYtSIXztj\nUgw1LZ00tHb5IDKlhqfJXalB7K9s4qTJcUNO8zuY6anOk6qHjmnvXQWGJnelBrGvoonZk2NH9drp\nac66eB13V4EybHIXkWwReVdEdovILhH53gBtzhGRBhHZ5rrd7ZtwlfKPY80d1LR0MmsUJ1MBspOj\nCbOIjrurgPGkzr0buM0Ys0VE4oB8EVlvjNndr92HxphLvB+iUv63v8J5MnVO+uDL6g3FZrUwNSWa\nw5rcVYAM23M3xpQbY7a4vm8C9gCZvg5MqUDa56qUmZU+umEZgOlpsTosowJmRGPuIpILLAI+G+Dp\nZSKyXUReE5Hxt1KAUr3sr2wmMdpGmgcLdAxmeloMhTWtdNsdXoxMKc94nNxFJBZ4Efi+Mab/tcJb\ngBxjzALgT8BLg2zjJhHZLCKbq6urRxuzUj539FgL01JjEBl5pYzbjNRYOu0OSuravBiZCpT33nsP\nEWHnzp2BDsUjHiV3EbHhTOzPGGP+1v95Y0yjMabZ9f2rgE1ETljF1hjziDEmzxiTN9hqKUoFg6La\nVqYmD7xWp6dmTHJVzGg5pAoAT6plBHgc2GOM+a9B2qS72iEip7m2W+PNQJXyl45uO2UNbeSkeD7N\n70Dcte467q4CwZOe+5nAauDcXqWOF4nIGhFZ42pzJbBTRAqA+4FVxhjjo5iV8qmSujaMYcw996SY\ncJKibRzS5O6RXbt2ccEFF5CcnExMTAxz587lgQceAOCVV17h/PPPZ9KkScTHx7N06VLefPPNPq//\nyU9+QmpqKp999hl5eXlERUVx1llnceTIEaqqqrjsssuIjY1l7ty5vPPOO31em5uby+233859991H\neno6sbGxfO1rX6OhYehpmx0OB7/61a+YOXMmERERzJo1i6eeeqpPm48++ojly5cTHx9PfHw8p556\nKuvWrfPCOza0YUshjTEfAUMOPBpj/gz82VtBKRVIRTWtAExNGVtyB2fFjNa6e2bFihXMnTuXp59+\nmoiICPbt29czFfCRI0e46KKLuO2227Barbz22mtceOGFfPDBB5x55pk922htbeWmm27izjvvJCYm\nhv/4j/9g9erVREREcOGFF/Kd73yH3/zmN3zlK1+huLiY6Ojjv+O1a9cyc+ZMHn30UcrLy7nzzjv5\nxje+MWQi/u53v8tTTz3F3XffzeLFi1m/fj033HADKSkpXHLJJTQ2NnLJJZewcuVK7r777p656+vr\n/bAMozEmILclS5YYpYLR/3502Ez9wb9MZWPbmLd1x7ptZsl9670Q1eB2797t1e3Z7Q5T1dhuHA6H\nV7c7lOrqagOY7du3D9vWbrebrq4u86Uvfclcf/31PY/fc889BjDvvfdez2MPPPCAAcxPf/rTnsd2\n7dplAPPqq6/2PDZ16lSTlJRkmpqaeh57+umnjYj0vL/vvvuuAcyOHTuMMcYcOHDAiIh58skn+8S3\nevVqk5eXZ4wxZtOmTQYwjY2NI3k7hvydApuNBzlWpx9Qqp/C2laiw61jKoN0m54Wy7HmDhrbx8cE\nYg6H4epHP+WMX77Nqkc+xeHwz+hqcnIy2dnZrFmzhueee46qqqo+z5eUlHDttdeSmZlJWFgYNpuN\nN99884Sl9sLDw1m+fHnP/ZkzZwJw7rnnnvBYaWlpn9eef/75xMYev67h8ssvxxjDpk2bBoz57bff\nxmKxcPnll9Pd3d1zO++889i2bRt2u50ZM2YQGxvLNddcwz/+8Q//9NhdNLkr1U9RTSs5ydFjKoN0\nm546vuaYqWnpJL+wjm6HIb+wjpqWTr/s12Kx8Oabb5Kens4NN9xAeno6y5cvZ+vWrTgcDi699FI2\nbNjAvffey7vvvsumTZu48MILaW/vu05tXFwcFsvxtBYeHg5AYmLiCY/1f+2kSZP63I+OjiY2NnbQ\n5fyOHTuG3W4nISEBm83Wc7vuuuvo7u6mvLycpKQk1q9fT1dXF1dddRVpaWlcfPHFHD58ePRvlod0\nmT2l+imsbe1JymM13bXk3pFjzZyanThM68BLjQ1nydQk8gvrWDI1idTYcL/te86cObz44ot0dXXx\n4Ycf8oMf/ICLL76Y9957j61bt/Laa69xwQUX9LRva/Pu9QP9Py20trbS3NxMRkbGgO2Tk5MJCwvj\n448/7nNAcXMfLJYuXcrrr79OW1sbb731FrfeeivXXHMNn376qVfj70+Tu1K9OByGotpWvjDbO9dh\nZCU554Ivrh0fFzKJCGu/uZSalk5SY8O98ullpGw2G+eee25PEnT3nCMijg+TFRYW8vHHH3u8qLYn\n1q9fT3Nzc8/QzN///ndEhLy8vAHbn3vuudjtdhoaGjj//POH3X5UVBQrVqxg586d/PKXv/Ra3IPR\n5K5UL5VN7XR2O8Zc4+4WabMyKS6C4tpWr2zPHywWIS1u7OcbRmL79u3cfvvtfPWrX2X69OnU1dXx\n61//moULF7J06VKysrK47bbbuO+++2hqauKee+4hM9O7U1xFRUVx8cUXc8cdd1BeXs4dd9zB5Zdf\nzrx58wZsP3v2bNasWcOqVau48847ycvLo729nV27drF//34ee+wxXnnlFZ544gkuu+wycnJyKC0t\n5eGHH+5zDsBXNLkr1UuhuwxyjDXuveUkR1NcN36SeyCkp6czefJkfv7zn1NWVkZiYiJf+MIX+PWv\nf01ERAR/+9vfuPnmm7nyyivJysrixz/+Me+9955XpwJYtWoVcXFx3HjjjTQ3N3PppZfy4IMPDvma\nBx54gFmzZvHoo49y9913Ex8fz7x587jxxhsB58lbEeFHP/oRVVVVpKWlcckll/CLX/zCa3EPRkyA\nrjXKy8szmzdvDsi+lRrM85uKufPF7bx/xzlM9VLv/f89t42NR2r5+Ie+6a3t2bOHuXPn+mTbE0Vu\nbi5XXnklv/vd7wIdCjD071RE8o0xA48V9aLVMkr1UljbgtUiTBnFuqmDyU6KoryhjS6dHVL5kSZ3\npXoprGklKykKm9V7/xpZydE4DJTVj4+Tqio06Ji7Ur0U1Tpr3L0pO8m5veLaNq8N9SjvOnr0aKBD\n8DrtuSvVS2FNq1fmlOktO9lVDqknVZUfaXJXyqWhtYuGti6mJnu3d52REEWYRXxaDhmowgjlfd76\nXWpyV8qlsNY5RUCOl3vuVouQmRRFkY+Su81m8/rVmipw2trasNlsY96OJnelXAq9ONVvf9lJ0RT7\naLm9SZMmUVpaSmtrq/bgxzFjDK2trZSWlp4wz81o6AlVpVzcPWtvn1AF57j7m7sqvb5dgPj4eADK\nysro6hofs0+qgdlsNiZPntzzOx0LTe5KuRTWtJAWF0F0uPf/LbKSoqlp6aSlo5uYCO9v373Kj1Ju\nOiyjlEtxbZtPeu0A2a7tlvhoaEap/jS5K+VSUt9KdpL3rkztzX3Q8NVJVaX60+SuFNBtd1Be305W\nko967j1T/2pyV/6hyV0poLKpg26H6Zl/3duSY8KJDrfqhUzKbzS5KwWUuHrUvuq5i4izHHKcLNqh\nxj9N7kpx/ESnr3ru4CyHLNGeu/KTYZO7iGSLyLsisltEdonI9wZoIyJyv4gcFJHtIrLYN+Eq5Rsl\ndW2IQEZipM/2kZUUTXGtXmik/MOTnns3cJsxZh6wFLhZRPqvO3UhcJLrdhMw9PIlSgWZkrpWJsdF\nEhFm9dk+cpKjaem0U9vS6bN9KOU2bHI3xpQbY7a4vm8C9gD9Fy9cCfzFOH0KJIrIwEuGKxWESura\nfDokA8dr3X01DYFSvY1ozF1EcoFFwGf9nsoEinvdL+HEA4BSQaukvtUPyV3LIZX/eJzcRSQWeBH4\nvjGmcTQ7E5GbRGSziGyurq4ezSaU8jpf17i7uRft0KtUlT94lNxFxIYzsT9jjPnbAE1Kgexe97Nc\nj/VhjHnEGJNnjMlLS0sbTbxKeV1FY7tPa9zdYiLCSIy2acWM8gtPqmUEeBzYY4z5r0GavQx83VU1\nsxRoMMaUezFOpXzmeBmkb3vuzn1EUaprqSo/8GR6ujOB1cAOEdnmeuxHQA6AMeYh4FXgIuAg0Apc\n7/1QlfINf9S4u2UlRnOwutnn+1Fq2ORujPkIkGHaGOBmbwWllD+V1LX6vMbdLTMpivf2V2GMwfmh\nWCnf0CtU1YRXUtfm8xp3t6ykKNq7HFrrrnxOk7ua8ErqfF8G6ZalFTPKTzS5qwnPHxcwuWUmRvXs\nUylf0uSuJrRuu4PyBt/XuLtlug4ipfVaDql8S5O7mtAqGtux+6HG3S0hykZcZJj23JXPaXJXE5o/\na9zdspKiKdXkrnxMk7ua0PxZ4+6WlRSlPXflc5rc1YTmzxp3t8xE56IdOq+78iVN7mpC82eNu1tW\nUhQtnXYa2rr8tk818WhyVxNaca3/atzdtNZd+YMmdzWhldS19Syi4S/ug4nODql8SZO7mrC67A7K\nG/x3AZPb8eSuPXflO5rc1YRVXt+OwxxfRMNfEqJsxIRbNbkrn9LkriYs97BIVrJ/e+4i4qx113nd\nlQ9pclcTVrErufu75w5a6658T5O7mrCKa9uwWoSMBP/VuLtlJkXpCVXlU5rc1YRVUtdKRkIkYVb/\n/xtkJUXR1N6tte7KZzS5qwmr2I9T/fbnrnXXOWaUr2hyVxNWcW1rQMbbofe87jo0o3xDk7uakNq7\n7FQ1dfj9AiY3rXVXvqbJXU1I7jLEQA3LJMeEE6217sqHNLmrCcmdVAPVc3fWukf1lGMq5W2a3NWE\nVFwbuBp3t+yk6J44lPI2Te5qQiquayXcamFSXETAYshOjqakrk3ndVc+MWxyF5EnRKRKRHYO8vw5\nItIgIttct7u9H6ZS3lVS10ZmUhQWiwQshqykKJo7uqlv1Vp35X2e9NyfBC4Yps2HxphTXbd7xx6W\nUr5VEoB53Ptzj/fruLvyhWGTuzHmA6DWD7Eo5TfOC5gCN94Ox8f7i3TcXfmAt8bcl4nIdhF5TUTm\nD9ZIRG4Skc0isrm6utpLu1ZqZFo6uqlt6STbz7NB9ufef3GtlkMq7/NGct8C5BhjFgB/Al4arKEx\n5hFjTJ4xJi8tLc0Lu1Zq5HrKIAPcc4+LtJEYbdNhGeUTY07uxphGY0yz6/tXAZuIpI45MqV8xF1+\nGOgxd4CcZC2HVL4x5uQuIukiIq7vT3Nts2as21XKV9zzuQTqAqbespOi9SpV5RNhwzUQkbXAOUCq\niJQA9wA2AGPMQ8CVwLdFpBtoA1YZLdxVQay4ro0om5WUmPBAh0JWchTrd1ficJiAlmWq0DNscjfG\nXD3M838G/uy1iJTysWJXGaTrA2dAZSdF02l3UNnUTkZC4IeJVOjQK1TVhFNS1xYUQzLQq9ZdK2aU\nl2lyVxOKMYbCmhZygiW5J7nLIfWkqvIuTe5qQjnW3ElLp53clOBI7plJUYjoVarK+zS5qwmlsKYF\ngNzUmABH4hQRZmVyXKRepaq8TpO7mlCOHHMl95TgSO7gvFK1RMfclZdpclcTSmFNK1aLkBkEFzC5\nZSdF67CM8jpN7mpCOVrTQlZSFDZr8PzpZyVHU9HYTke3PdChqBASPH/hSvnB0ZqWoBqSAWfFjDFQ\nVt8e6FBUCNHkriYMYwyFx1qDplLG7Xituw7NKO/R5K4mjNqWTpo6upkabD13XbRD+YAmdzVhHO0p\ngwyunnt6fCQ2q2g5pPIqTe5qwjh6zJk8g23M3WoRspOjKTymyV15jyZ3NWEU1rRgEQK+vN5ApqXE\n9HyyUMobNLmrCeNITSuZSVGEhwXfn31uqjO5Oxw6W7byjuD7K1fKRwqDsAzSbVpqDO1dDioatRxS\neYcmdzUhGGM4ciy4kzvA0WM6NKO8Q5O7mhDqW7toau9mapDVuLu5k/thTe7KSzS5qwnhSE3wTRjW\nW3p8JBFhFu25K6/R5K4mhGCb6rc/i0XI1YoZ5UWa3NWEcPRYKyLO6XWD1bTUGB2WUV6jyV1NCEdr\nWpiSEEVEmDXQoQwqNzWG4tpWuu2OQIeiQoAmdzUhHK1pDbppB/qblhpNl93o7JDKKzS5q5BnjOFI\ndXPQnkx1m5YaC8DhY80BjkSFgmGTu4g8ISJVIrJzkOdFRO4XkYMisl1EFns/TKVGr6qpg8b2bmZN\njgt0KENyf7LQihnlDZ703J8ELhji+QuBk1y3m4AHxx6WUt6zr6IJIOiTe1psBLERYRyt0QnE1NgN\nm9yNMR8AtUM0WQn8xTh9CiSKSIa3AlTBr7G9iyc/PsI/tpXSFYQnA/dXupN7bIAjGZqIkJsarRUz\nyivCvLCNTKC41/0S12Pl/RuKyE04e/fk5OR4YdcqkGqaO3ji4yP8ZUMhTR3dAPzm9X3ceNY0Vp2W\nTXS4N/68xm5fRROpsRGkxEYEOpRh5abEsL2kIdBhqBDg1xOqxphHjDF5xpi8tLQ0f+5aeVlFQzv/\n9ocP+J/3DrF8Vir/vOUsHr82j8zEKO79126uefQzOruDoxe/v7KJ2enB3Wt3m54aQ0lda9C8d2r8\n8kbXqhTI7nU/y/WYClF2h+F7z26ltdPOP285i5MzE1zPJHDe3Mn8Y1sp33t2G796bS93r5gX0Fgd\nDsP+ymZWnZY9fOMgkJsag8NAUW0rMyeNjwOSCk7e6Lm/DHzdVTWzFGgwxpwwJKNCx5/eOcBnR2r5\n2WUn90rsx608NZPrluXyxMdHeGNXRQAiPK6kro22Ljuzg/xkqpvODqm8Zdieu4isBc4BUkWkBLgH\nsAEYYx4CXgUuAg4CrcD1vgpWBd6nh2u4/+0DfHlxJl9enDVou7sumsOWojpuX1fAvIz4nkWg/W2f\n+2Rq+jhL7jrHjBqjYZO7MebqYZ43wM1ei0gFrdbObr7/7DZyU2O4b+XJQ7aNCLPy56sXc/GfPuT2\ndQU8e9NSRMRPkR7nrpQ5aZwMcSRGh5MYbeNQtSZ3NTZ6hary2NqNxVQ0tvPrKxYQEzH86ZqclGhu\n/9JsPjtSyyeHavwQ4Yn2VzaRmRhFXKQtIPsfjZMmxXLAdVBSarQ0uSuPtHfZefj9Q5wxPYXP5SZ7\n/Lqvfi6byfER/OGtAzg/5PnXvoomZo+TIRm32elx7KtsCsj7pUKHJnflkXX5JVQ1dfDdc2eO6HWR\nNivfOWcmG4/W8slh//beu+wODle3BP2Vqf3NTo+nqb2bsgadQEyNniZ3Nawuu4OH3jvEkqlJnDEj\nZcSvd/fe//jWAR9EN7jCmhY67Y5xU+PuNtf1SWNfRWOAI1HjmSZ3Nay/bymltL6NW86dOaqTopE2\nK9/+/Ay/j73vq3DOrjjeeu7uyp69FTrurkZPk7sakt1h+J/3DnJyZjznzBr9VcWrTsthUlwE97/t\nv977vsomLAIz0sZXzz0+0kZmYhR7yzW5q9HT5K6G9N6+Ko7WtPLtz4+u1+4WabNy41nT+ORwTc8s\njb62v6KJ3NQYIm3Bu/rSYGanx/ntfVKhSZO7GtLajcWkxkbwpfmTx7ytq/KyCQ+z8PSnhV6IbHj7\nK5vGzZWp/c1Oj+NQdbPOMaNGTZO7GlRFQzvv7K3kqrwsbNax/6kkxYSzYsEU/ralhGbXLJK+0tzR\nzdGalnFXBuk2Jz2ObofRVZnUqGlyV4N6fnMxDuOsdvGW1WdMpaXTzt+3lHhtmwPZVlSPw8DinCSf\n7sdX5qTHA+i4uxo1Te5qQHaH4blNxZw1M5WpXlx7dGFWAqdkJvB/nxb69CKd/MI6RODUnESf7cOX\npqfFYLOKVsyoUdPkrgb04YFqSuvbuPo07y6qIiKsPmMq+yub2XhkqAW+xmZzYS2zJ8cRP46mHejN\nZrUwIy0B/cVAAAAYIElEQVRWa93VqGlyVwNau7GIlJhwzp839hOp/a1YMIWEKBt/8dGJVbvDsLWo\nnrzc8Tkk46YVM2osNLmrE1Q1tfPWniquXJJFeJj3/0Siwq18ZUkWb+ysoLqpw+vb31/ZRHNHN0um\njv/kXtbQTkNbV6BDUeOQJnd1gpe2lmJ3GK7y4onU/q4+PYduh2FdfvHwjUdoc2EdAHlTPZ/gLBjN\ndZ1U1d67Gg1N7qoPYwwv5peyKCfRp1d2zkiLZen0ZJ7dWIzD4d0Tq1sK60iLiyArKcqr2/W32TrH\njBoDTe6qj11ljeyrbBpylSVvueb0qRTVtvLRwWNe3e7mwlrypiYFZHEQb8pIiCQuMkwrZtSoaHJX\nfbyQX0K41cKKBRk+39e/zZ9Mckw4f/2syGvbrGpsp7i2bdyPt4OzsmheRjw7SxsCHYoahzS5qx5d\ndgcvF5TxxXmTSIwO9/n+IsKcJ1bX76mkqtE7c5fnu8bbQyG5AyyemsSuskbaOu2BDkWNM5rcVY/3\n9lVT29LJFX4YknFbdVoOdodhXb53rljdXFhHRJiF+VMSvLK9QMubmkS3w7C9pD7QoahxRpO76vFi\nfgmpseGcPYapfUdqWmoMy2ak8NfPirB74cRqfmEdC7MSfVLCGQiLXNMn5BfVBTgSNd6Exn+AGrO6\nlk7e3lvJylMzvTJJ2Eh8/YyplNa3sX53xZi209LRza6yBhaHyJAMQHJMONPTYthSqMldjYwmdwXA\nP7aV0mU3fh2ScTt/XjrZyVE89uGRMW3nrT2VdNkNX5jtv08e/rAkJ4n8wjpdMFuNiEfJXUQuEJF9\nInJQRH44wPPniEiDiGxz3e72fqjKl9bll3ByZjzzpsT7fd9Wi3DDmdPYXFjH1jEMP7y8rYyMhEg+\nlzu+L17qLy83ibrWLg4fawl0KGocGTa5i4gVeAC4EJgHXC0i8wZo+qEx5lTX7V4vx6l8aGdpA7vK\nGrkqz3dXpA7nqrxs4iLDeOyj0fXe61s7+eBANSsWTsFiGd/17f25K3/ydWhGjYAnPffTgIPGmMPG\nmE7gWWClb8NS/vRCfgnhYRYuXTglYDHERIRxzek5vLajnOLa1hG//rWdFXTZTUB/Bl+ZnhpLQpRN\nx93ViHiS3DOB3hOAlLge62+ZiGwXkddEZP5AGxKRm0Rks4hsrq6uHkW4yts6uu28tK2Uf5uf7pfa\n9qFctywXiwhPbTg64te+vK2M6akxzA/AsJKvWSzC4pxE7bmrEfHWCdUtQI4xZgHwJ+ClgRoZYx4x\nxuQZY/LS0kLrpNd49dbuKupbu7gqz/8nUvvLSIji4gUZPLupmNqWTo9fV9nYzqdHalixcMq4n3Jg\nMHm5yRyoaqa+1fP3RU1sniT3UqD3YGyW67EexphGY0yz6/tXAZuIpHotSuUzz28uZkpCJMtmBMev\n65YvzKSty85v39jn8Wv+WVCGMXDpqaE3JOPmXi5wa5FezKQ840ly3wScJCLTRCQcWAW83LuBiKSL\nq8skIqe5tlvj7WCVd5U3tPHBgWquXJKFNUhOQp40OY7rluXy7KYidpR4NqfKPwvKODkz3qezWAba\nwuwErBbRoRnlsWGTuzGmG7gFeAPYAzxvjNklImtEZI2r2ZXAThEpAO4HVhktyg16azc6T6VcuSRw\nVTID+d4XTyIlJoK7X9457HTA+YW1FJQ0hOSJ1N6iw8OYlxHPxqO+W5pQhRaPxtyNMa8aY2YZY2YY\nY37ueuwhY8xDru//bIyZb4xZaIxZaozZ4Mug1dh1djv462dFfGH2JHJSogMdTh/xkTbuunAOW4vq\neXHL4HPOtHR0c+vzBWQlRXl9rddgdPasVPIL63TcXXkkLNABqMB4dUc5x5o7uHZZbqBDGdDlizJ5\n5rNCfv36XpZOTyE7+cQD0C9f20NRbStrv7mUuEAuhF22deSvmbJoxC85f146D7x7iHf3VXH5osCf\nAFfBTZP7BPXUJ0eZnhrD8pnBcSK1P4tF+MWXT+Gqhz7h8v/ZwOPX5rEwO7Hn+ff2VfH0p0V8c/k0\nlk5P8d6OR5Oo/WRBZgKT4yN4c1elJnc1LJ1bZgLaXlLP1qJ6vn7G1KC+mnNOejx/+84yIm0WvvrI\nJ/xjWynv7K3kT28f4I4XtjNrciy3fWl2oMP0G4tF+OLcyby/v5r2Lp3fXQ1Nk/sE9OSGo8SEW7li\nSfD3/mZOiuPv3zmT2enxfO/Zbdzw5GZ+v34/iVE2/vDVRUTarIEO0a++ND+d1k47Gw55d2lCFXp0\nWGaCOdbcwb8Kyll1WnZgx6lHIC0ugme/uZS39lSSnhDJnPS4cRO7ty2dnkxsRBhv7qrk3DmTAx2O\nCmKa3CeYv2w4SqfdwdfPyA10KCMSFW5lRYiXO3oiIszKObPTeGtPJXaHCZrrE1Tw0WGZCaSupZMn\nPj7KRaekM3NS6F7wE+rOnzeZY82dbCvWC5rU4DS5TyCPfniYls5uvnferECHosbgnNmTCLMIb+6q\nDHQoKohpcp8gals6eXLDUS5ZMIXZ6XGBDkeNQUKUjTNmpPDqznKvrDurQpMm9wni4Q8O0d5l53vn\nnRToUJQXrPpcDsW1bazfrb13NTBN7hNAdVMHf9lQyKULp+hYe4j4t/mTyUqK4rEPDwc6FBWktFpm\nAviv9fvo6LbzHxOt1x7EV5uOVZjVwg1nTuPef+1ma1Edi1xTAivlpj33EPfJoRrWbizmG8unMz2E\np8SdiK76nGvd2Q9Ht+6sCm2a3ENYe5edu/62nakp0fy/L2qFTKiJda87u3N0686q0KbJPYT991v7\nOVrTyi+/fApR4RPrMv2Jwr3u7BMfa+9d9aXJPUTtKGng0Q8Os+pz2UGzhJ7yvoyEKC5dOIW1G4s4\nXN0c6HBUENETqiGoqrGdNU/nkxYXwV0XzQ10OGogXpwD/s4L5vDWnkpuW1fAum+dQZhV+2xKe+4h\np6Wjmxue2kRdayePX/s5EqIm5gRbE0l6QiT3XXYyW4vqefgDLY1UTprcQ0i33cEtf93CnvImHrhm\nMSdnJgQ6JOUnly6cwsWnZPCHt/azu6wx0OGoIKDJPUS0ddr5/nPbeHdfNfeunM8X5kwKdEjjhsMB\nda1djOcl3UWE+y47mYSocL7/3FZqW3Sd1YlOx9xDQEldK9/6v3x2lzfygwvm8LXTpzqf8NPann7b\njw84HPCjl3awp7yRuRnx/OKyU7B4ucvjcEBDexeJUTbEhzP0JseE84evnsqNT23iyoc28JcbTiMr\nKbgWP1f+o8l9nHt3XxW3PV9AV7eDx6/NG/sCDh4m6v4Ja8QJzA8HhKFicj9njGFPeSN2h/NrXWsn\nFosQHxlGY3s3iVE2jBn6ZxtuP74+ePR21kmp/N+Np3PjU5u44sEN/OWG03WiuAlKk/s4ta24nt+8\nvpcNh2qYOSmWh1cvYcYIrkB1DkV0IgJJ0eGDJj9PEtbPVp7Mj1/awd7yRuZkxPPLyxeMKIH5omfr\ncJhBk2rv+OdkxDMnPY69FU3MSY/nN2/sZW95I5HhYbR32ZmTHg+YnufvvGA2yb3er97bmjkplt9c\nsQCrRfoePMoasBvYU9ZAQ3sXSdEnnuT25ntw2rRk1q05g68/vpErHtzAt8+ZwfVn5hIdrv/uE4lH\nv20RuQD4I2AFHjPG/Krf8+J6/iKgFbjOGLPFy7FOeA2tXbyxu4J/FpTx4YFjpMSEc8+KeVxzeg4R\nYZ5fpORwwF1/38GusgYA5k/pm5CH6202tHf16e0W1bawy3USb1dZI3VtnaTEhHsciy96tjUtnX1i\nbGjvIiHSRl1bJ42tx5/bW97IE9fmYbFYMMZw/ZObsBtn1RHA3opGjDE4DOwqa+C6JzYyPzOBn608\nmaaObrq67Owua8BhYF9FE7euK+B3VyzgP1/exZ7yRmZPiiE8zEpbl53I8DDiI/v+yzkcUNfWyW/e\n2MdeL74H7sXFf/LyLn77xj6e2nCUW86dyYoFU0jy8Hejxrdhk7uIWIEHgPOBEmCTiLxsjNndq9mF\nwEmu2+nAg66vapSaO7opr29jT0UTu0ob2F7SwObCWrrshqykKG49fxY3nDWN2IiBf4UOh6GhdeCe\nYF1bJ3vKG3ru73UlP3ePsn/ydidGd88yMcrG3Ix4Z893gI/8ja2dfXq3A8c38LBIYU0zuamxo+69\nOhyGmpZOUmJcMZY1cNKkWOIirNz19+09ByH36nR2h+E3r+/lzgvnkhRlY056XE8bgFmTYjhc3UKH\n3Xm21QA7Sxu4/YUCDlc303869UNVzdz+4naOVjdjN7C74viFRa0d3Rw91kJitK3n5O1v39jHnorG\nnu0M1bsfqaykaB679nNsOlrLr1/by93/2MVPXt7FkqlJnDN7EvOmxDMzLZbMxCgsulxfyBEzTImA\niJwB/MQY82+u+3cBGGN+2avNw8B7xpi1rvv7gHOMMeWDbTcvL89s3rx5xAEfrGriDT+vQDPce+Rs\n0+t7132DcX3F1fsz2B1gdzjoshs67Q46uhx0dNtp7uimqb2bxrYuKhvbaWzv7tleuNXCnIw4zpie\nwkWnZLAgKwEZIvs5HIarH/2U9qL8AYck7nppB7tKjyf3+VPi+dWXF/QkVGOcPXt3b/rnl53Mj1/a\n2ad3DX17nOFWCx3ddqLCw2jv7GbulIQT9us+OBjTa1hkcixHatpo7ezuE89Ih3bc++j9KeC+FfP5\n4Us7OFjVzMxJsRyoaMIxyGstwNwpCdx09jRufb6gZxGMyDAL7d2DvWpwsybHsr9y5FeMRoVbWfuN\n071yIZLDATUJ80iNdfbUt5c08PaeSt7aU8Xu8uMHsEibhdTYCFJiwkmKCScmIozIMCtR4RZsVgth\nFiHMasEqgkWclTkiILi/HufpQXmov9+JYFFO4qivHBeRfGNM3nDtPBmWyQSKe90v4cRe+UBtMoE+\nyV1EbgJuAsjJyfFg1yfaV9HMb9/YN6rXBpL7n8JqEcIszq8RYVYiwixEhFmIjQwjPtLGpLgIls1I\nIT0hiimJkcxIi2XW5DjCwzz/Z69p6SS/sI5uxzR2lQm3JcwjLS7C+VxTBy+WldNtUnrah1kScKQv\nxOpKKAL8bM1CDlY3M2tyLNVNnawrq8DuSOmzPUdTBy+U1WB3pIAd5qTHsrOy2TWE0aud62CTX1jH\nkqlJ3H/1Il4oK6fbkcLOcnC4DoBue8rg9l4xe/xzN3X0bHdXmXBd+En8o7KSbkcaOyuFBVkz2V7s\nPKjFhltp7rT3ef32Unh+bSPR4TNpsbue6xpRCD12V4LDjKIctQMuf6mVl75zZs/vYzSOv+dvs2Rq\nEmu/uZSF2YkszE7k1i/Npralk4NVzRysaubIsWaONXdS29JJTXMnxbWttHc5aOuy02V30G03dDsc\nOAw4jBnXJaPBYs3nZ/h8WhC/nmExxjwCPALOnvtotnHhyens/9mFXo3LE550NPr2YARxvc7fvZTU\n2HCWTE3qSabunlvv5zYX1vX0TrcVN/CVhz/hhTXLsFgEh8Pwtcc/I7+wjsU5SRjj6Gm7OOf49lJj\nw1mQlcDWonoA9lc0szAnkR0lDX32e/xgY8gvrEOgJ77FOYkYYNPR44s99495tD/3rMmxfe7/9Run\nc6ylEwGSomxsLKxl9eMb+wytGKCl087JU+LZXd5IdLiV5g47kVZotw+25xP1H66JCbfS0unZBnaU\nNvb5fYxG//e8pqWzz8EyOSac06Ylc9q05BFv25i+n0h7Hvf49SPeZcjxxyiYJ8m9FMjudT/L9dhI\n23iFxSKE6/jgkESEtd9cSk1LJ6mx4X0OLu7njjV3cNP/bWabqydbUFzfkwD6JIaiup7/RqvAn69Z\n1LM9EeGFb53BVx7+hILievJyk/nrN06ntrWrz377J920uIg+8RkD1c0dYAwiQlpcxKgOiAP93P3v\nT46P7OnVbi6sIyYijJaObiJtVlp7Jd/Hrs0DA1/8r/cBCAsL46PbzuK7a7exvbSh5ySrm1UE+xBZ\n67lvLSUtNhKDQYBjzZ1c+sDHg66B2vv3MRpDHeDHyj0s47rnte0q7/IkuW8CThKRaTgT9irgmn5t\nXgZuEZFncQ7ZNAw13q58z2KRQRODxSJMio/kxTXL+iTm3j3ynp711CQwhi1F9T2JuTer1cILa5b1\nSaD92wyUZEXoaScCk+MjffJzD/Q+uA9edoehtdPOMzeezjWPfdbzfEy4lbTYCA5UNfcM3TR3dNPc\nYefFbzt/1oQIK5c/tIHdZU3kTU3kT1cv4tzfv09r1/Hx+agwoa3bEBthZV5GPJZeJxEmxUeS5/oE\nFWmz0NZpZ8nUJLrtDraXNPT5fYzGUAd4NTEMm9yNMd0icgvwBs5SyCeMMbtEZI3r+YeAV3GWQR7E\nWQp5ve9CVt4yUGKGExODMQyZJIY6kIykjb/079WePj2ZRTmJbHENL7V3O6ht7WLW5FjiIsNoau8m\nLjKMWZNj+/wc/7xlec/7cqy5s8+J11OzE7BZLWwprGdeRjz9e7i93+PkaFvPp53h3uuRCKb3XPnf\nsNUyvjLaahmlvMFdMulOona7gysf/sTZa56axLM3LUVE6O529JxYtgxRvmOMYdUjn7L5aC0LsxN5\n8GuLOfPX79LtMIRZhE/uOk8TrfIKb1bLKBVy+vdqrVYLLw7wKSYszMKcjPhht9f/0w7gszFvpTyh\nyV0pl7EOY/R/vY55q0DS5K6Uj+iYtwoknc9dKaVCkCZ3pZQKQZrclVIqBGlyV0qpEKTJXSmlQpAm\nd6WUCkGa3JVSKgQFbPoBEakGCgOy84GlAscCHcQQgj0+CP4Ygz0+0Bi9Idjjg7HFONUYkzZco4Al\n92AjIps9ma8hUII9Pgj+GIM9PtAYvSHY4wP/xKjDMkopFYI0uSulVAjS5H7cI4EOYBjBHh8Ef4zB\nHh9ojN4Q7PGBH2LUMXellApB2nNXSqkQpMm9HxG5TUSMiKQGOpb+ROS3IrJXRLaLyN9FJDHQMQGI\nyAUisk9EDorIDwMdT38iki0i74rIbhHZJSLfC3RMAxERq4hsFZF/BTqWgYhIooi84Pob3CMiZwQ6\npv5E5P+5fsc7RWStiHhncd6xxfSEiFSJyM5ejyWLyHoROeD6muTt/Wpy70VEsoEvAUWBjmUQ64GT\njTELgP3AXQGOBxGxAg8AFwLzgKtFZF5gozpBN3CbMWYesBS4OQhjBPgesCfQQQzhj8Drxpg5wEKC\nLFYRyQT+A8gzxpyMc83nVYGNCoAngQv6PfZD4G1jzEnA2677XqXJva//Bu4EgvJEhDHmTWNMt+vu\np0BWIONxOQ04aIw5bIzpBJ4FVgY4pj6MMeXGmC2u75twJqXMwEbVl4hkARcDjwU6loGISAJwNvA4\ngDGm0xhTH9ioBhQGRIlIGBANlAU4HowxHwC1/R5eCTzl+v4p4DJv71eTu4uIrARKjTEFgY7FQzcA\nrwU6CJxJsrjX/RKCLHH2JiK5wCLgs8BGcoI/4OxYOAIdyCCmAdXA/7qGjh4TkZhAB9WbMaYU+B3O\nT97lQIMx5s3ARjWoycaYctf3FcBkb+9gQiV3EXnLNRbX/7YS+BFwd5DH6G7zY5xDDc8ELtLxR0Ri\ngReB7xtjGgMdj5uIXAJUGWPyAx3LEMKAxcCDxphFQAs+GEoYC9e49UqcB6IpQIyI/HtgoxqecZYs\nen20YEKtoWqM+eJAj4vIKTj/IApcCxlnAVtE5DRjTIUfQxw0RjcRuQ64BDjPBEcdaymQ3et+luux\noCIiNpyJ/RljzN8CHU8/ZwKXishFQCQQLyJPG2OCKTGVACXGGPcnnhcIsuQOfBE4YoypBhCRvwHL\ngKcDGtXAKkUkwxhTLiIZQJW3dzCheu6DMcbsMMZMMsbkGmNycf4hL/Z3Yh+OiFyA86P7pcaY1kDH\n47IJOElEpolIOM4TWC8HOKY+xHnEfhzYY4z5r0DH058x5i5jTJbrb28V8E6QJXZc/wvFIjLb9dB5\nwO4AhjSQImCpiES7fufnEWQnfXt5GbjW9f21wD+8vYMJ1XMPAX8GIoD1rk8Ynxpj1gQyIGNMt4jc\nAryBszrhCWPMrkDGNIAzgdXADhHZ5nrsR8aYVwMY03j0XeAZ10H8MHB9gOPpwxjzmYi8AGzBOWy5\nlSC4WlVE1gLnAKkiUgLcA/wKeF5EbsQ5O+5VXt9vcHyyV0op5U06LKOUUiFIk7tSSoUgTe5KKRWC\nNLkrpVQI0uSulFIhSJO7UkqFIE3uSikVgjS5K6VUCPr/6nj9msyhp5oAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "samples = rejection_sampling(func, rv, k=15, n=100)\n", + "plt.plot(x, func(x), label=r\"$\\tilde{p}(z)$\")\n", + "plt.hist(samples, normed=True, alpha=0.2)\n", + "plt.scatter(samples, np.random.normal(scale=.03, size=(100, 1)), s=5, label=\"samples\")\n", + "plt.legend(fontsize=15)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 11.1.5 Sampling-importance-resampling" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nV0qpIPT/AfxM7TcvoPpeAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "samples = sir(func, rv, n=100)\n", + "plt.plot(x, func(x), label=r\"$\\tilde{p}(z)$\")\n", + "plt.hist(samples, normed=True, alpha=0.2)\n", + "plt.scatter(samples, np.random.normal(scale=.03, size=(100, 1)), s=5, label=\"samples\")\n", + "plt.legend(fontsize=15)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 11.2 Markov Chain Monte Carlo" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "samples = metropolis(func, Gaussian(mu=np.zeros(1), var=np.ones(1)), n=100, downsample=10)\n", + "plt.plot(x, func(x), label=r\"$\\tilde{p}(z)$\")\n", + "plt.hist(samples, normed=True, alpha=0.2)\n", + "plt.scatter(samples, np.random.normal(scale=.03, size=(100, 1)), s=5, label=\"samples\")\n", + "plt.legend(fontsize=15)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "### 11.2.2 The Metropolis-Hastings algorithm" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "samples = metropolis_hastings(func, Gaussian(mu=np.ones(1), var=np.ones(1)), n=100, downsample=10)\n", + "plt.plot(x, func(x), label=r\"$\\tilde{p}(z)$\")\n", + "plt.hist(samples, normed=True, alpha=0.2)\n", + "plt.scatter(samples, np.random.normal(scale=.03, size=(100, 1)), s=5, label=\"samples\")\n", + "plt.legend(fontsize=15)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.0" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/books/PRML/PRML-master-Python/notebooks/ch12_Continuous_Latent_Variables.ipynb b/books/PRML/PRML-master-Python/notebooks/ch12_Continuous_Latent_Variables.ipynb new file mode 100755 index 0000000..63135ee --- /dev/null +++ b/books/PRML/PRML-master-Python/notebooks/ch12_Continuous_Latent_Variables.ipynb @@ -0,0 +1,283 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 12. Continuous Latent Variables" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from sklearn import datasets\n", + "%matplotlib inline\n", + "\n", + "from prml.dimreduction import Autoencoder, BayesianPCA, PCA\n", + "\n", + "np.random.seed(1234)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "iris = datasets.load_iris()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 12.1 Principal Component Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pca = PCA(n_components=2)\n", + "Z = pca.fit_transform(iris.data)\n", + "plt.scatter(Z[:, 0], Z[:, 1], c=iris.target)\n", + "plt.gca().set_aspect('equal', adjustable='box')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 12.1.4 PCA for high-dimensional data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mnist = datasets.fetch_mldata(\"MNIST original\")\n", + "mnist3 = mnist.data[np.random.choice(np.where(mnist.target == 3)[0], 200)]\n", + "pca = PCA(n_components=4)\n", + "pca.fit(mnist3)\n", + "plt.subplot(1, 5, 1)\n", + "plt.imshow(pca.mean.reshape(28, 28))\n", + "plt.axis('off')\n", + "for i, w in enumerate(pca.W.T[::-1]):\n", + " plt.subplot(1, 5, i + 2)\n", + " plt.imshow(w.reshape(28, 28))\n", + " plt.axis('off')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 12.2.2 EM algorithm for PCA" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAANwAAAD8CAYAAAAc9sq3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJztnXd4VFX6xz/nTp90ktB774ggoBQRRMEuKva6Fuy6dldXXXVd17527Ch2RKQqKP7AhnSl9yolpCfT557fHxNCkplJz5TkfJ6HB3LvnXPfCfOdc+455/2+QkqJQqGIDFq0A1AomhJKcApFBFGCUygiiBKcQhFBlOAUigiiBKdQRBAlOIUigijBKRQRRAlOoYggxmjcNCMjQ3bs2DEat1YoGoQVK1YcllJmVnVdVATXsWNHli9fHo1bKxQNghBiV3WuU0NKhSKCKMEpFBFECU6hiCBKcApFBFGCUygiSFRmKZsKxQUO5r61kOXfriazbTrn3HoaXQd2inZYiiiiBNdAFOYWcdOg+8g9mIfb6UHTBD9+/gt3v3MToy8cHu3wFFFCDSkbiOkvzCZ7fy5upwcAXZe4HR5evHEKPq8vytEpooUSXAPxy9fL8Lq9Qcd1v87OtXuiEJEiFlCCayAS0xJCHvf7dBJS7RGORhErKME1EOfefjrWBEu5Y5pBo2OfdrTq1CJKUSmijRJcAzHi3CFMvON0TBYT9mQb1gQL7Xq05rEZ90Q7NEUUEdHwpRw8eLBsKpuX87Ly2bRsG2ktUuh2bGeEENEOSdEACCFWSCkHV3WdWhZoYFIzUxh62rHRDkMRI6ghpUIRQVQPVweK8oqZM2UBqxeto3XXlpxzy3ja9WgT7bAUMYwSXC3JPZjHjYPupSi3GLfTg+F7jW/f+4HHZtzLoHEDoh2eIkZRQ8pa8tHjX5KfVVC6k8Tv03E7PDx7zWuoAimKcCjB1ZJfZy3H5/UHHS/MKeLgrqwoRKSIB5TgaklCcujdIrquY0+yRTgaRbygBFdLzrl1AhZ7+Z0kBpOBviN6kZyeFKWoFLGOElwtmXDtWMZcPByDyYAlwYLFbqZjn3Y8+PHt0Q5NEcMowdWSZfNWsfjL3zBbTEi/jjXByt/fmkxqZkq0Q1PEMEpwteDQ7iwev/B5ivMdOItceFxe8rMKuG/c47id7miHp4hhlOBqwXcf/B+6Tw86rvv9LJ2zMgoRKeIFJbhakHcoD68nOGvb59PJP1wYhYgU8YISXC0YdMoxWBOtwSek5JiT+kQ+IEXcoARXC4acNpAegzpjLbMsYE2wMO7KE9VeSkWlqL2UtcBgMPDUtw+xYOpivp+2GLPFxGnXncyIiUOjHZoixlEJqApFPVDdBFQ1pFQoIogSnEIRQer8DCeEaAdMBVoCOjBFSvlSXdtVKKKFlDp4fkK6FoJIQNgmIkzd6qXt+pg08QF3SSlXCiGSgBVCiAVSyvX10LZCEVGk1JF5t4DnF5AOwIB0TEMm/wPNfmGd26/zkFJKuV9KubLk34XABkDNjSviE/eiMmID8AMuKHgCqefXufl6fYYTQnQEBgJL67NdhSJSSNfcMmIrgzAGhFhH6k1wQohEYDpwh5SyIMT564UQy4UQy7OyVEa0IkYRNiCcd2iI3UU1pF4EJ4QwERDbNCnlV6GukVJOkVIOllIOzszMrI/bKhT1jrCdR2hhCbCcUOf26yw4EbASfgfYIKV8vs4RKRRRRJgHQuINgBmEHURCYKYy7U2EsFT5+qqoj1nK4cDlwJ9CiNUlxx6UUs6th7bjBikl63/dzM61u2nbozX9R/VWtuZxipZ4E9I2Edy/gGYHy4kIUT8+NXUWnJTyJ8IPepsEjkIn953yODvX7kFKHU3TaNWlBc/+8ChJaYnRDk9RC4ShJdgn1nu7aqdJFUgpWfXDn7x5z1Q+/c8MHEXOoGvevu8jtq3eiavYhdvhwVnkYveGfbx8yztRiFgRy6jNy5XgcXm4c9TDbFmxo9TcVQjBnVMmM+FvY0qvOzvlChyFwUI0mo3MdX6shpZNALV5uR74/JmZbF6+vZyTspSSF65/o5zZa7ia3X6fX7kwK8qhBFcJs95YEPK4lJKvXppT+vNxEwaiGcr/KoUmGDC6D5qmfsWKo6hPQyX4Q1iZHyF7X07pv2968WpSMpJKSwxb7GYSUxO4443rGzxGRXyhMr4r4cQLT+CbV+cHHRdCcMI5Q0p/bt4ug/c3v8z3Hy1m88rtdO7XnnFXjCYxNSGS4SriADVpUgnOYheXdbyJguzyTlxturfirT+ew2Q2RSkyRaSQUgckQhgqvU5NmtQDtgQrn/41hfPuPIP0Ns3IaNuMyx+ZxOsr/ovRZGT1orXMfnMB637ZpCZHGhlSL0DPuwt5sB/yYB/07EuRvu11blf1cLWgILuQu056hIM7s9B1HSE0OvVrx9PfPYwtUVXOiXeklMjsieDbDHhLjgoQSYjMhQgtNeg1qodrQF666S32bvoLZ1FgodtV7GLrqh288+DH0Q5NUR94V4F/B0fFBiBBepCO6XVqWgmuhvj9fn7++vegYoxet4+FHy6OUlSKesW3A0KO/Fzg21inppXgaooEqYcehodbAFfEGWH9S2xg6lenppXgaojBaKDfyF5B27U0g8bQ0wdFKSpFvWLsB6begLnMQQ2EDWE7t05NK8FVwZ9LNvD4pOf4+4n/5IvnvsFR6OSON28gMS0Biz3wH2JNsJCamcyNz18Z5WgV9YEQApH2DtguBJEIWMAyBpExHaHVrbqtmqWshJmvzuOt+z7C4/QgJVhsZjLapvPa8qfR/ToLpv7IjrV76D6oC2MvHaFmKJsw1Z2lVDtNwnB4Xw5T7vkQj+voTJXb6SFrbzaz3/yOSXefzbm3nR7FCBXxiBpSVuDQnsPcPeZRLut0YzmxHcHj9PDLzNjvnRWxierhyuD3+blz5MMc3peD7g+ucHqE1ObJEYxK0ZhQPVwZfp+3isLcokrFZrFbOPfW0yIYlaIxoQRXhgM7DuHzhE/JMZmNXPPvixkwWlU5VdQOJbgydBvUGU0Lb4fQd2QvJqqJEkUdUIIrQ58TetC2e6uw53MP5EUwGkVjRAmuDEIILnnovJCmP0azkUGnDIhCVIrGhJqlLMO0J77kk//MCMptM5gMJKTYmXTPWVGKTNFYUD1cCbmH8pn25HTcDk/QueT0JN5c/SzNWqZFITJFY0IJroT1v2wKct46Qv6hfAoOBxUEUihqjBJcCUnNEoNy3EoRgjU/qoKuirqjBFdC3xE9sdjMIc+ZLEaS01WNAEXdUYIrQdM07nzzhpDnjCZjOVs8haK2KMGVsGXldp6/7o0gp+SUzGT+u/CfWO0W9m3dz461u9H18Fu/FIrKUMsCJbx627s4i1xBx22JVoSm8bc+d3BwVxZC07AnWnlg2u0cc1LfKEQam0gp+W3vHr7dtgWbycTEnn3olp4e7bBiDpWAWsKppgvDbloOrIOLcutz1gQL7254icy26kMlpeTOb+eycPs2HD4vBiEwGQw8OOJELut/TLTDiwgRtckTQrwrhDgkhFhbH+1FA2ti+HKyUhK0GO73+fnu/UUNHVZc8NPuXSzcERAbgF9KXD4fTy75kWyHI6KxSPfP6IfPQj/QFz1rLLrj64jevyrq6xnufWB8PbUVcdb+vBFRwyKuXrePrL3ZDRRRfDF362Yc3uBkXaOmsWT3rojFId2/IHNvLLGy84B/DxQ8gl48LWIxVEW9CE5KuRjIqfLCGKMwt4i9W/fzwPgnKM6v2TexLdHKwDF1s0xrLFgMBrQwRSfNhso9+esTWfgcUPE53AlFL5XUCIg+EZs0EUJcD1wP0L59+0jdNiRbVm7nmatfZfeGffj9/hr3bmabiTbdWjH8XLVUADCxVx8+X78Wl6+8L6cERnfsFLlA/GG8/2UxyCIQ0c/Uj9iygJRyipRysJRycGZmZqRuG0TOgVzuOukRdvy5G7/PHzB2rcHEkcVu5vJ/TuKFJY9jNKlJXoD+LVpy63HDsBgM2IwmEkwmbEYjr592FnZTBCsMGdqGPi6sIGKjdFiT+8TMfft7PM7gDcrVwZpg4dZXruWUK0fXb1CNgBuPG8o5PXuzeNcOrCYTYzt1IdEceudOQyES70Tm3UH5YaUNEm6ostxUpGhygtuzcR9+X+XjeYvdTK+h3dm8fBu6LvG6vZgsgXy4sZeNjFCk8UerpCQu7Ns/avcX1jHIlKeg8L+gHwSRBImTEfZrohZTRepFcEKIT4DRQIYQYi/wiJTynfpouz5xFDopyiuu/CIBf3vqUs668VRcDjdLvvyN/MOF9D+xNz2HdA2ZnKqIHTTb6WA7Hd1/EDzLEMIGeIDwyz6RpMksfHtcHm4afB9/bTuI1x08hX0Ee7KNmXlTIxiZor7Ri6dC4TMgjIAABCJtCsLccLUfVH24Cvz42S8c3JVVqdgA9XwW50jveih8FnAfnZ2Uhcjc65AyeOtepGkyglv5/R+4it2VXtO+VxsmP6cKcsQz0vElgSFkCNw/RTSWUDQZwTVvl4HRHHqmSjNoJKcn8tiMezEYY2M2S1FbioEQk2JSB+mMeDQVaTKCO+26kzEYQ88R6X6dwpxiHj776RqtyTV2DhYVcf/Cbxn29huc/OG7TPtzDXqY348uJfO3buGG2V9z05xvWLRze1R+l8JyKmAPccYP5hMiHU4QTUZwLTs2519f30tai5SQZq9SSg7vyWb3xn1RiC72yHU6OeOTD/lqwzoOOYrZnpvLv5f8yMOLFgZdK6XktvmzuXvBPBZs38b8bVu4de5s/rno+8gHbhkNlmEcFZ0GWCHpToQh+pkdcS+4Q3sO8/z1b3BZp5u4ZdgDLP7y17DXHntyfz7dN4W2PduEPO/1Bup0FxdEdod7LPLxn2so8rjxlemlnD4fX21Yx4GiwnLXLvtrH4t27Ci3gdnh8zJ94zo2Zx+ul3ik/zB60SvoebejF72D1EObOgmhIVJfQ6Q+B9azwXYRIn0aWkJsrMXF9cJ39v5cJh97D458B36fzsFdWfz36lfZs+kvLv3HeSFfk7M/F1tC6DUZv9fPjP/NZc6UBbz40xO0DyPMpsBv+/bg9gebKpkNBtZnZdEy8Wgl0MW7duL0Bc/+6rpkye5ddE/PqFMs0rsRmXMJSA+BCZFFyOK3IOMrhKF10PVCaGAdi7COrdN9G4K47uG+eHYmzkJnuZ0j7mI3n/z7KxyFwQ/IeVn53HjsvWxZuSNsm26Hm6LcYp69+tUGiTle6JiahiHEIr9P12mVVL7sbrLFEjIrwKhpJNXD9i5Z8FBger909tEFMg9Z8J86tx1p4lpwq35YG7LajcFkYOe6PUHHv35lPsUFzkrLUUHgmWTzyu0hRdtUuGrAwCARmTSNbukZ9EjPwOn1lk6KnNWjZ9j0nPFdu9UpDik94A2V16yDZ3Gd2o4GcS24lh2bhzzu8/jIaF3eJVlKyW+zlle58F2WcMawTYEuzdJ584xzaJ2UhMVgwGwwcELb9pzQtj3HvPkK/d54mRHvvcW8LZtomZjE/8afjt1kItFsJtFsJsls4a0zzyHZYq1jJBoQbqkmNrZr1YS4foabdM/ZrFiwppw9uclspM/wnjRvfzQF6MDOQ9x/6hMc2HGwWu1qBo3+o3pjtcfff2h9MqJ9B5ZcdR0Hi4uwm0y8tXI5765agbMk721/USF3LZiP3WTm5M5dWX7djSzduxdNEwxt065ekk+FMCKt48C1ACj7ZWkB+/nVakN6NyOLXwPvBjB2RyTeiDD1rnNstSHu91L+8MkSXrnlHbweH36fn0HjBnD/h7disVv4fd4qDu/N5vNnv+HQ7sNIver3arIYSWuRyos/PaEMgsrg8fsZ+OarISdH+rdoydcXXlrne0jpQxa/DY6PAtuyzEMRSfeDlobMubokwVSA9IN5MCLtdYSo/EtRelYjc64E3AQWxAVgRTR7G2E+rs4xH6G6eynjuocDGHPxSE684AT2bz9IUrNEUjKS2bd1P38/8RFcRS48Hi8+t6/qhkqwJlh5+ruHm7TYdCnJd7lIMJtLe6k8lxNJ6C+s3flV182T/v3gmovUHQjraIQp2J5C5j8IrvmU5rO5FyE9yxAZcxHp08H7B/h3gbEHwtSjWu9FFj4BlH0Wl4ATWfAYImN2tdqoT+JecAAGo4G23Y9ODz9+wfPkHsir1U6Hotwibhh4D3e8cT3jLj+xPsOMC2Zt3sgTixeR53KhCcElfQdw/4hRNLPZMWlakGMIQI8qpv1152zIf4DAh92HLH4LaTsHkfxYabqT9B8A11zK74OUIF1Ix1S0pHvAPACoYY0+b5iaEL7NSKkHlhAiSKObFTi05zB7Nu2rUmwikLURhJTgcXp4cfKUqnPnGhlLdu/k3gXzyXI48Oo6br+f99as5NZ5szFqGrcPPQFbhe1xVqORu08YEbZNqRdA/oMEhnQeAsM6F7hmgue3oxf6tkDI4aEXPKtr/6bC+ZiIxIiLDRqh4HweH6KSOt0AFpuZlp1b0K5HawzG0L8Cg1FjxXdrGiLEmOV/S38Nudj93fat7MrL5ZqBg/jX6JNpn5KC1Wikf/OWvH/2eQxqVckGAfdPEMreQLqQrjJDOkP7koXtihjAWIelhYSrAFuFg1awX177NutAoxhSlqVV5xakZqZwcFdWueNGs4HWXVqSmJrAqAuO57Rrx2JNsPL4pOdYMn1pUDsCgcHUtDIHtuWEdzqc9ucaHhw5mvN69+G83n2q32jYXkSCcw66loFIuAFh7IA0HweeZQR6wyOYEQlXVf9+FW+fcD1SzwLH5yBMIL1gOxuReGut26wLja6HE0Lw4Me3Y0u0YrYGHKOsCRbMFjP7th5g6+qdfPHMN/zxf+sRQjDxjjOwhJj+13W9ydX0bpWYFPbcrM0bWfbX3po3ah4RSI0JiQOK30XmXIKUfkj+V0lvpgX+GLoimr2LMHas+X1LEEILiMt+CYi0wISL5QTCr+01LI1OcAC9j+/BB1te5orHJnHmTafSokMmHpcHv9ePx+khe38uj1/4PFtX76Dv8J5MvP00zFYTZqsJa4IFi93Cw5/fhS2hrou28cXNQ4aGPXewuJirvp7O/K2ba9Sm0BIh5VnACoTa5uUG/06k40PIPjPwLIdOYFHbDcbONbpfRaRehDx8Ljimgb4HfH8g8+9HFj5fp3ZrS9yvw1XFvq37uX7A3UHWeJomOOniEdz/4W2l1y2bvxprgpXh5xxHUlrTLMB46Vefs3TvnlApnAA0T0jg12tuqLGZkvRnIwseBvcPhEwQJRmomAFgAvtFaMkPH21Hzwc9CwztqlyDA9CL3oGilwh2ZLYgMn+st5Qd5WlSQtaebEzm4EdVXZfs23qg9Oc2XVtxzi0TGH/1SU1WbABTzzmfR0ePDetFnedykeMsv8d0d34eK/bvo9Ad3sJCGNIR1tMCpqwhCZVu4wXnnMCCuHSh5/0deWg4MvsC5KGh6MXvVf2GPEsIFhuB5znvH1W/vp5pdJMmFenUr33I/ZMmi5H+J/bC7/MrW4UyaEKQ7w5vtuPz+7l4+mf0a9GSy/oN4D8/L+aPgwcxGzQ8fp1bhwzjpuPCDE2t46DgyEJ0NUdWMgd5aCgYOh8t0nFkNrPweaShNcJ6avjXG1oR6Fcq9KpSB0PovbgNSaMfUgK8ec9UZr3+HW5H4BtYaAKjyYhmEHicXjr2a89tr15L3+E9IxZTLCClZNqfa5iyYhm5LifHtGzFwJateWfV8tL9kuEwCIEkIFBfmYqwNqOJF06dwCldQk/lS98OZN6d4AuzIF1jrIjMhYgw4pHe9cjsiyjfyxnA2BmRPrvefEarO6RsdIL7ddZyvnpxNvlZhQw7cxDn33UmSWmJfPveIr58YRaFOcWYLEZyD+ThcR3t+Sx2C6/+/hQderdrkLhikf/+vIQP1qwsJy5BtfueUppZnNzZdxnj2uzA5Tey+NAwLh32EkKEryugHzgWKKpV3EEYe6NlhK8DpzvnQ8HDgA+kD0w9EamvIAwt6uf+NFHBTXviSz59+utSOzyTxUhq8xSmrHmOxNRAMYfs/blc3vnmoGGmZtAYe9lI7n3vlnqPKxY5VFTEqA/exhNiobsm2I1e5o//jAyLE7Mh0NO5/Eas9tFoaa+FfZ2eewu4FxJ6AqWm2BAZ0xHGrmGvkNILvm2gJSEM9Z/J3+QmTQpzi/j431+V8570un0c3pfDCze8UXps//aDmK0hJlH8Ojv+2B2RWKOJlJJXfv+1xmILN/A6t8MmUs3uUrEBWA0+cP+E9G0N317SPSUVbephSCcMoOdWfokwIUw9G0RsNaHRCG7T8q0hJz+kLln8xW+MN13Irg17adOtFR5X8POJwajRfXCXSIQaVWZt3sjry5dVKraK2dtWo5GTO3fBWmEfpUkIhmQewG4M8bwnNPCuC3sPYeyAyJgDWnWH8DYwjyb0BlgfGHtVs53o0igEt3TOCv590Ys4i8LPrvn9OjcOupe05imcfPkoLPbyi7Bmq5lJ95zV0KFGnTdXLAuZ03YEq9HIf8aewokdOtI8IYGhbdry7lkTeWXCmZzWtTsWg4EksxmLwcAl/Y9hYNsT8OhhJrsrGPxI6UG6FiGdM5H+AwhDS0TSHQTvdayAsTci/RNE6rOgtaLcArqwQdLfAwvscUDcLwvs2rCXxy98vlzWdzi8Li871+/h9tevo0WHTL5+eS7F+Q56H9+Dyc9fSZuurSIQcXSprMh9q8QknhwzjtEdO3F+775B5589ZQIPjjyRvQUFdEhJJcVqRfr7IA9PD/QypRhBNEd6tyHdPyNMA5BaBuT+DfARSLvxIROuCWy7cn4JnuWEtSg39jiaoZ0xE1k8FdyLQMtAJFxVslUrPoj7SZOXb3mb2W8uqNIY6AipzZO594NbOe7UY+rl/vHG7fPnMGfLpiAH5TSrlaV/m4yxFrYI0rMGmX9foIg9gLEv+LcEMrNxgrCDdAMVh7E2RNprYB6GLHoJit8mIMiyGMB+OVrygzWOK5I0mUmTgzuzqi02gLxDBTx23rNsXR3eKq8x8/dhw0kwmTCWeU6zGY38a/TJtRIbgDAPQMucj2i+BNF8KciCElu7kh0p0kGw2ACcyOL3EcKASLwlTFlgE8J2Qa3iikXiXnDHjusf9DxWFR6Xh8+f+aaBIoptOqSmMveSK5nUpx9dm6VzUsdOfHDO+ZzevXqWBZUhtGYBoflrkFXgWYyedycgEM3eCezoFwkgEgELJD+CMNXNai+WqK8KqOOBlwjkPLwtpYyYQ+f4a8bw1YtzyNmfi9dTPe8SqUv2bmq6NQTaJCfzxJhxQccX79rJs7/+xM68XDqkpHLPCSMZ1aFjDVuv6dK5BNdCpPYSWvLd0PznQE6cdIH5uLiZDKkude7hRKBa+avABKA3cLEQImIeZBabmVEXHI+ogYek0WSg9wl1/0aPJ7x+P1uys8lyhLaN+H77NibPmcnaQwcp8nhYl3WIyXNm8v32bTW6j3R9R+jhY2W4wfkJELDFE5bjEdaT6l1sUi9CL3oHPfty9Lx7kHG6eXkIsFVKuR1ACPEpcDZQX5vlKuWZq19lyfTfym3TqgwhBBa7hUl3N/4lgCPM2LieR3/8AV3qeHWdoW3a8r/xZ5BiPbpz/98//R+uCvsnXT4fT/70I2M7V299Us+9HdzzahekbNgCKlIvQGafA/7DgAu8GtL1LTL5X2j2cxr03mWpj2e4NkBZX/G9JcfKIYS4XgixXAixPCsrq+LpWnF4X3aNxAYw7MxBvLL0qXJGsY2Z5X/t46EfFlDocVPs9eLx+/lt7x4mz5lZ7rqdeaF3auzKq9wCT0oP0vEVes7fai82ANPA2r+2GsjiD8CfxdFNzCVmRoWPBezUI0R9CC7U3pygQbyUcoqUcrCUcnBmZv182Hdv2FcjO3KDUeO+qbeWs9Rr7Ly1cnlQz+XVdVYfOMCe/PzSY80TQs0QQoY99HEAKV3I7EnIwsdK8s5qgxGEHZH8UC1fX03cCynvlXIEEXBkjhD1Ibi9QNn9OW2Bv+qh3Spp061VtSdKANr1bENCcqjqmI2XvwoLQk5hmA1auee5W44bFmSBZzMauXXIsLBtS8eX4Nteu1K+WkswHVNSv21Ww1uPa6mhj0sfaCkNe+8y1Mcz3DKgmxCiE7APuAi4pB7arZIWHTLpf2JvVi38s9LrNIOG2WrizimTIxFWVPDpOot2bGdjdhYdUlI5tUs3LEYjw9u1Z3P2Ybx6+bVKr66TarXi9vmwGI1c0m8ALr+fl3//FafXi81k4pbjhnFpv0qMlFzzCJlNHYSR8gvaVkTqywhz5EyahP0qpHd1hS+Hkry4OpgU1TiO+thpIoQ4DXiRwLLAu1LKJyu7vj53mnhcHq7pcwcHd4R+LkxtkcLJl43inFsm0KJD43xuy3e5OP+LTzhQVIjD6y2tYvPlpEswGwxMmPYBBW53aaKoSdPQhChNvjzirmzUNPy6TpHHQ6LZjEGrfACk594I7irKCpvGgnUYFE8J7Og3dkMkPYiwhDcsaij0oleh6A0QZsAHWpuAK5ihZZ3bbpT5cFJKVi78g++nLUEIwdjLRjFgdG++eOYb3nnw46DrLXYLT85+gAGja+CjGIc8+P13TN+wrlwvZhCC49u1Z+o553OwqIjXli9l8a6dGIRgb0E+nnJZ2kYu638MD4yombW7dP+EzL2Z8t79FbCehZb6bE3fUoMh9Tzw/glaOhh7qYzvynhh8pv8MG1Jac6bNcFC2x6t2bPxr1L7hCOYrCZueOZyzr55Qr3EHMsMeONlCj3BM20GIVh30+3lykaNn/Y+m7Ozg661GY2suuGWGpeY0otegaJXCb/2ZkA0X9boFrAr0uj2Um5esY3vP1pSLsHUVexm68odQWID6Du8R5MQW4DQ39J+KTnv84/ZW3B0NvJAUWhbA7+UFHnCu26FQ0u8Bew3VnKFEfz7a9xuYyVuBLds/uoaVS/du6np/Cef3q07pjDPWxsOZ3HRl5/hLxlC9skMbbZjMRhY/tc+ikL0lFUhEi4m/EdJljhnKSCOBGdLsGKsgdd/hz5tGzCBUiYXAAAaLUlEQVSa2OK+4aNon5IaUnS6lOS73fyyJ2Afce/wUUHT/xAouHj3d/MZ8vbrzNq0sUb3F4ZMSP5niDMWsF/c6IeTNSFuBDdq0vEhH3ANRg2zrXy2gMVm5opHL4xUaFEnxWpl3qVXMrh1aL8OXUr2FxUCMKBFSz49/yJGtOtAisVSOhh1+/0UeT24fD7u+/7bcovi1UGzXwJpH4ChQ8mRZEi8EZH0QMjrpZRI7yakd12grkATIW4El9G6GfdNDZQStifbsCfbsNotPPzFXVz52CRSMpIQmqBTv/Y8MfsBeg1tPCkd1cGoaZzXqw92U7A1nUQysOXR3TU7cnNYm3UQh9cXYlFckmEpYP6W32scg2Y5Hi1zAaLFJrSWy9ESbypXg01KWSK0jcisscicScicy5BZw5Hu3yppufEQV7OUAI5CJysX/oEQgmPH9W9yBTcqw+3zcfonU9lbUFBqEmQzGhnTqTP/GDmadYcOke108Nj//RDS6HVI5l/8d8giMixOjJrAaB2MSHkuMGSsA9K3F1nwKHh+JvAdH6iEWg5hQ2QsCGvoGus0ymUBRTAbDmdxqKiIPs1bkGG3U+B2M2XF78zZshmr0cjFffuzOfsw0zesw2Qw4PB6g+wVANomFDD31C8qOHAZwdARkTGn1utVUi9GHj65xMaussx8MyTejpZ4Xa3uE22qK7i4NxFqbPy+by//WryIjYezSLFY+dvAQUwePCTIuu6ww8HVM6ezPTcHo6bh8fu5vP9AHhgxirtPGMndJ4wE4NO1fzBj43rcfn/I6qYA7RIKuH/AL5hExfM+8O9GuuYibKfX7g255oDupGrDVw/oh2p3jzgibgTn9/kpyC4kMS0Bkzm8hXY8s/bQQa6eOb10uJfrcvLqst/IcTp5aNToctfeOm8Wm7IPl/P1n/bnavo0b87ZPY56NL5fwcq8LEbh57mhPzC2zS4MQsekhRrteCD/XnT3j4iUp2tcF1t6NwPVyXWzI8zH16jteCTmJk12rN3Nc9e+zt9H/5MPHv2MvKx8Zrw8l/Myr+GyTjcxMeMa3vvnp+h6fVhkxxYv//5rUCqN0+dj2p9ryq2PZRUXs+rA/nJiO3Ltu6tWlDtW6A6/rja512rGtN6F1eAPI7YjeMH1HdL5ZfXfTAnC1AuoKkPDCqaeYKnZ1rJ4JKZ6uGXzV/HY+c/idfvQ/Tobl27ly+dnI/067tKCil6mPz8bk8nAZQ83HjcngI2HD4dMpTFqgv2FhXRLT2dfQQH//WUx3jDDw3xX+d37Yzp15rN1fwaJE+CSLuuxGas7Je8Exydgn1TN60uwnQZFL4Be1ibPBFpGIEUHX6Dmtv0iAm4djZuY6eGklDx33Ru4HZ5S2zuv24uryFVGbAHcDjdfPDer0fVyPdIzQm7S8uk6rZKS2J6bw4SPP2Duls1hhKkF2SHcNvR4Ui2hZ3Ltxurv3AECxj41RAgbIv1LsJwMmANOybazEBmz0DI+Q8uYjpZwBULUzHktXokZwWXtzaYwp/rli1zF7hpt9YoHbh16PJYQSaCX9huAzWjkicWLcHi9+EPMMpo1jXSbjRsHl097ybQn8N1lV5FsDi7P+/PBtujVnqS2gPW06l5cDmFoiZb2MlrLtWgt1qClPIXQkmvVVrwTM4KzJ9mQNeixmrVKxWxtXN+K/Zq34N2zJtIrIxMBpFqs3Dh4KJ3SmjH4rdf4cdfOkFP6AEkWKx9PnESGPfh5KdVm4/XTz8JmNJYawFoMBt7YdFKgx6kSa6CmdsLV5Y5K3x70nOvQD/RCP9APPf9+pF5Y07fdpIipdbiHznyKFQv+wFfGNsFsMaHrEp/36DGL3czd797E6EnDIxJvQ7Jq/1/M27oZo2bgrB496ZkRWGSWUiKEYN7Wzdz93bwqK5IahWBw67Z8fF74Z6ydebl8sGYVO3JzGdq2LRf37U+yKQeyxhPa76ME82hE2isIYUbqReD5OWC8k/84gdrcR74ozWDsikifUW95ZvFCXK7D3Tf1Vh4+8z9sXb0Do8mIx+VlwnVjGT3pBN79xyds/3MXrTq14OonLmbIhIZ1eYoE//q/RXy27g9cPh+aELy/ZiW3Dz2eGwYNKf3A/m/pr1WKDcAnJSsP/EWWo5jMMMY/HVPTeOTEMRWOtkGmf4nMuRrk4dCNG1ohhBndOQvy/xGoxya9BBff8IBvB9KzDGEZUmXMTZGYElxSWiIv/vQEuzbsJWtPNl0GdCCtRSrffrCInev24PP42bV+L4s++YkBo3tjsQU/l8QLaw4e4LN1f5SKyS8lfp+PF3/7hTO69aRNcuAZ58im4+pgEBpFHk9YwYVDmHog06fD4XEEiUjYEdZxSN/egNhwVWGs7ITc69CTn0Kz1+6ZrzETM89wZenQqy2DTxlAWotUVixYw8s3v01hThFuR2CiZPGXv/LctW9U3VAMs2DbVtwhei4hBD/s3F76c9/M6tehTjCb6JASxp2qCoRmKfGGLPOREHYwDwfzcKRrNtV3VHZCwR3oxdNqFUtjJiYFV5ZPnpoRVPvN4/Ly84ylFOTE7wO6UdPQQuSvCQIzjke4Z/jIKm0PBIFCincfP4IpK5bxv6W/sj6r+tukpP8AMus08K4i8DwmCJSJuibgriVEiTNy9S0JASh8AilrnkXemIl5wR3cGdqNy2AykHuwZjlbscRZPXpiDCE4CYzrcrQ4/IAWLXllwhmVttUxNY3Jxw7hkR9/4IXffuZ/v//K+V98wpOLf6xWLLLolUCJqdLhpAT84Py89BphOREItZ5X2eSIH1nwuJq5LEPMC67PiJ6h3ZUltOoUn6kcAJ3TmnHf8JFYDAZsRhN2kwmr0ciz48bTzFZ+at/p84UUJwR6ylHtO/L6iqW4/T68uo4uJS6fj6l/rOKdVctD7jKBwBaxm+fO4mDOHEL2XnoB6AcC/zYdC9ZTA8NMICA0G9iuIOCOGAbnDGTWyUjfnvDXNCFiatIkFJc9fD6/zFyGq9iFLFmltdgtXPX4hXG/DnflgGMZ36U7i3ZuD+wS6dSFNFv5dbHlf+3jvoXfhhWNUdNokZiIQWhUfMby6jr//XkJU1Ys55PzJtE5rVnpObfPx7mfTeNgcRG3djHTwhaqqo5eWiRRCAEpT4PnDKTzGxAmhO1chHkIuswG1+ww79ILMh9Z8Bii2dvV/dU0WmK+h2vbrRWvLfsPI88bRrNWaXQb1Jn7pt7KxNsrH2bFCy0SE7mob3/O7903SGwAbyz/PWhD8xESTWZeOvV0MsPUBYCA6A47irlh9kzKrrl+u20L+W4Xfil5b3M/HL6K370mMJ+AKGMDLoRAWEahpT4b2C1iLpn6T34GjD0IP7zUS9buIr/mG2vEfA8H0LZ7ax7+7O/RDiMqlLW4K4vNaOS9sycyqHUbvtqwDqcv/DY3SaDGwI683NJebktONsXewGu+2NGT7ik5XNJlA26/AZsRTJY+iNT/VitGTTMg02eC+wdk3i2Ezn0zNrnF8FDEfA/X1BnSpm3YyZWeGZnM2rSRhxYtrLLmqCZEuZ6yS1o6CaX+J4InVw9n1OyLeW3DEPb4LkAk3gGi+vsdhdAQ1pPBdi5QcahvCmQNKJTgYp3Jg4dgN5nKZXzbjEZuPm4oCWYz//l5cdghZ1ksRiM90jNKf57QtRtJFguGknatBi+vDV/I7X2W0sk8HZl3E/Lw6Ug9p0bxiqR/gLFbyeSKNfC3sRsiqYHLUcUJSnAxTuukZGZddDln9+hFi4RE+mQ25+mTT+Xm44bh03UOVLETxaQZsBmNPH/KaeWKc1iMRr6adAljOnXGqGnc3W85/Zodxmb0InCBLAb/LmR+KL/J8AgtEZH+FSLtbUTyg4i0twJ7K7WkWr3/xkZcPMM1ddqlpPDcKRPYlpPNYYeD3iXuyfkuFzajCUeI57dmNhsndexMq8REJvXpR9vk4BpomhBk2O2k2+xM7LgZs1axp/QFnsukFyGqb2shhADz4MAfRTmU4OKALEcx134zg6052SWGQTpn9ejJ7M0bQy4X2IxGHho5mnN6hi9ymOdycuYnH5HrcuLTdbQgA6EjSKo2AFJUFzWkjANunD2TDVmHcPp8FHo8uP0+vli/FqfPF1RoMcls5uFRJ1UqNoBpf64pVzPu+7864NUrziIKMB2DEPG7STzWUIKLYbx+Px+uWc2agwfwVXMN6/i27bmob/8qr1u6dy9u/9Eh5NNrhpHtspVZj7OCSEKkPFGb0BVhqNOQUghxAfAo0AsYIqVU7q51oMDtYn1WFhl2O80TErngi0/YU5Af0lIhHLLKBYIAHVJT+XXv7tK2D7kSGDfvIs7rtJ07jk0iNalfYCdJBOtfNwXq+gy3FpgIvFkPsTRpXl32G6/8/htmgwGvrpNoNpPvdOGV1X9+shtNnNeretVerxowsGTB/Ggv55MW1hSMolnLy2ocv6J61ElwUsoNgNpBUEcWbt/Ka8t+L+eOXNnamlkzkGA24fR6QQg8fj8Wg4FxXboyrnNX/iosYMH2rUgJ4zp3LU1mLUuXZum8ccbZ3LfwW/JcLnRdMqxtO54/takUsYwOEZulFEJcD1wP0L59+0jdNi54e9WKSrdmVeSagcdy/aDj8OuSOVs2UehxM6J9Rwa0aMm0P1bzxJIfS699+ufF3Dd8FFcdc2xQOyPbd+Tnq69nf1EhCSYzKdby6TdS+gC9yVjYRYIqBSeEWAi0DHHqH1LKmdW9kZRyCjAFAiZC1Y6wCZDjrI4VeGDdbECLltw7fFTpsSsGHPV22VdYwBNLfgyqIfD0z4s5qWNnOqQGZ4MLIWidVL4HlHo+suARcC0A/EhTP0TykwhT9xq8K0UoqhSclPLkSATSlBnTsQu78/Lx6OWFogmBxWDAp0vMBo1Es5kXTw1fVOPbrVtCHtelZN7WzUweHN7YR/p2g289UmsNBf8E3xagpNf1rkHmXAwZ3yEM6TV+f4qjqIXvCLOvsIDP1/3JXwUFDG/fkQldu3H9oMHM3LSBPJcTt99fapnw+Ekn0zY5hT8PHaRNUjJjOnWu1G5Bl6HnKGXJuVBI6Ufm3xPozYSpjBtXheulB+n8HJF4Yy3fuQLqvixwLvAykAnMEUKsllKeWi+RNUJ+3rOL62d9jU+XeHU/87Zt4Y0VvzP9gouZd+kVTF2zmv/btYPWSUlcc8wgBrYKVC0d0qZ69cpP6dKV5379Kei4UdM4tYxtg+7bCfmPgm8DYAKZB3igUv8RN/g2V/u9KkJT11nKGcCMeoolLthbkM8jP37Pkt27MGoaZ3bvyUMjR5NkqXw3hi4ld347t9w0vMPrZWduLm+vXM7tw07gjO49KPZ4yHY62F9USD9dD2utEIr2KancOWw4L/z2C36pI6XEYhD8Z6SZToYX0QvTwNQH8m6jCq+7ENjAVPWCuqJyYsp5OdYpdLsZM/Udcl2u0iGa2WCge3oGMy+8tNLlkS3Z2Zz7+TQc3uDZSE0Irh4wkGlr/8Dn9+OTErvJRK+MTD469wIW79rJ26uWk+N0MrpjJ24YNCSkpfkRtufmMG/LZsDPlR1exS7XE6jRZqTGzluBCEGkIjK/a7I1AaoiLp2Xj+D3+TEYY6900YyN63F4feWehzx+P9tzc1i+fx/HtQ4/9LMYDWGfo3QpeWf1ynLHHF4v67MOcdu82fy0Z3fpssHu/DxmbdrI3EuvCDIbOkLntGbcPGQY0vk1Mn8d4Cw5UxOxJQUclvGAeRQi+X4ltnogpvZSLvzo/7io7fWMN1/EBS2vZdYb38aUD8aGrKyQ62VSSrbmVJ6o2T4llQ4pqZWaylXE6fOxcMe2cvf06jp5bhfvr15V5eulcxZHxVZdjAG35WZvorX4Ha3FarS0/yEMrWvYjiIUMSO4Hz/7mRcnv0X2X7kA5B3K5827P2T2m99FObKj9MzMxGYMHhQIIehSxhErHK+ffhap1tC12sKhhSjx6/H7WbJ7Z9UvFjW5VwJYxoD9CkT6LITKZWsQYkZw7z38KW5H+Vkyt8PN1Ee/iFJEwZzbsze2CnYHJs1Ap9Q0jmvdpsrXd0xNY+4lV6JVs5+zGIzl7nUEAbRKrDqDWtgvDFOOqmKbNsj4Bi3tDbTk+xHGdtWKT1FzYkZwh3aFdljOz8ovV6oqmiRbLMyYdCkj23fAULIofVaPHkybOKna+0lbJCYyvF34rW1mgwG7yYTFYOCKAcfQJzMzaKbSajRy7bHV6IHMI8F2MWABbAGPSZGMSP8C0j6ChBsg5UW0lmvQlMgiQsxMmrTq0pI9G/cFHW/WKg2jKWbCpF1KCu+dfV5p/bba8OwpExjx7pSgTACzZuDRE8dgNhgY2rYdbZKSyXY4uGXeLFYf2B+oRyAEj44ey7Gtqn6mEkIgku9H2i8Fz2+gJYNlNEJYAn2cKikVcWLmk3zd05fx5EUvlKvnbbGb+dtTl0YxqvDUJUMiMyGBF8efxl3fzUfTAu34dJ1HTxwTlDyabrfzyXkXsr+wkDy3iy5pzaos7hEUq7EdqB4sJoipdbhfvlnG2/dPY/+2g2S2T+fqxy/mpIviv8ppOPJdLn7YsR2/1BndsXOla2uK2Ka663AxJbimTIHbjcVgwBJiFlQR+8T1wndTYunePTz4wwL2FOSjCcFpXbvz+Eknk2BWOWiNESW4KLItJ5trvvmq3P7KuVs3c9jhYOq559e5fenbjSx8Cjy/BByQbRchEm+qkcekon6JmWWBpsi7q1fiqZAs6vH7Wb5/HzvzcuvUtvRnI7MngvsHkE7Qs6H4TWTubXVqV1E3lOCiyJac7JCOXCZNY29BQZ3alo5pAaGVywrwged7dM/KcC9TNDBKcFHk2JatMYVIv/H4/XRrVsfMau9qSjO2K1L4XN3aVtQaJbgocvUxxwZtFbMZjYHCHYmJdWvc2Dn8Oe/aurWtqDVKcFGkRWIiMy+8jHGdu5BkNtM6KYk7hw3nyTHj6t64vRJvyZD7KxWRQM1S1gApJasP7CfH6eSYlq1Ir4eF6g6pqbx++tn1EF15NGNHdNMQ8P5e4YwZ7HWfAVXUDiW4arK3IJ/LZ3zJweIi/LqOX9eZ1Kcf/x57SrRDC4tI+x8y53Lw7T160DQAkXhL9IJq4ijBVZNrZ33Nrvy8csc+XfcnxV4PL40/I0pRVY7QmkH6bPAuB99uMPVAmPpGO6wmjXqGqwbbcrLZFWZdbM6WzWzPrVlZ3kgihECYj0PYz1NiiwGU4KpBoccT1uNKl5Lvd2yLaDyK+EUJrhr0ysgM6ypnEAKTFnuGR4rYRAmuGliMRu4bMTLkOaOmMb5rtwhHpIhXlOCqydXHDOLW44aiCYEmBCZNw2Iw8MRJJ9OyGv4iCgWoWcoacefxI7hswEB+2L4NhGBspy4qaVRRI5TgakimPYELq1FDW6EIhRpSKhQRRAlOoYggSnAKRQRRglMoIogSnEIRQeokOCHEM0KIjUKIP4QQM4QQwVXbFQpFKXXt4RYAfaWU/YHNwAN1D0mhaLzUSXBSyu+klEc83n4DqleMWqFootTnM9w1wLxwJ4UQ1wshlgshlmdlha6Uo1A0dqrcaSKEWAi0DHHqH1LKmSXX/INAPdtp4dqRUk4BpkDA6rxW0SoUcU6VgpNSnlzZeSHElcAZwFgZS/WBG4Bij4ef9uxCShjRvgOJ9WRHLqUT/FlgaI6oUdVSRbxRp72UQojxwH3AiVJKR/2EFJt8v30bt82fjUHTQIJP6jw3bjwTuvWodZtS6sjC58DxIQgNpEQmXINIvK1O5bAUsUtdn+FeAZKABUKI1UKIN+ohppjjsMPBrfNn4/T5KPJ4KPJ6cPl8/P27+RwoKqx1u7L4TXB8BLhAOgAnON5FOqbWW+yK2KKus5RdpZTtpJTHlPyZXF+BxRLztm4Ok/EtmbNlc+0bLn4HcFZo0gnFU2rfpiKmUTtNqoHT68VfoTwwgNev4/B6QryiaqTUQYapH6DXrZCHInZRgqsGozt2Cjy7VcBiNHBSx0osxStBCA0MnUKfNHavVZuK2EcJrhp0T8/goj79sZWpTmozmjinZy/6Nm9R63ZF8sNAxVlJKyL5wVq3qYhtVMZ3NXl41GjGde7CjI3rkVJyds/eDG/Xvk5tCssIaPYesuhl8G0DY/fADKV5QD1FrYg1lOCqiRCC49u15/g6iiyoXfMgRLP367VNReyihpQKRQRRglMoIogSnEIRQZTgFIoIogSnUEQQJTiFIoKIaGTUCCEKgU0Rv3HNyAAORzuIKlAx1g/1EWMHKWVmVRdFax1uk5RycJTuXS2EEMtVjHVHxVgeNaRUKCKIEpxCEUGiJbh4SPhSMdYPKsYyRGXSRKFoqqghpUIRQaImuHiwSRdCXCCEWCeE0IUQMTPTJoQYL4TYJITYKoS4P9rxhEII8a4Q4pAQYm20YwmFEKKdEGKREGJDyf/x7ZG4bzR7uHiwSV8LTAQWRzuQIwghDMCrwASgN3CxEKJ3dKMKyfvA+GgHUQk+4C4pZS9gGHBzJH6PURNcPNikSyk3SCljbYF+CLBVSrldSukBPgXOjnJMQUgpFwM50Y4jHFLK/VLKlSX/LgQ2AG0a+r6x8gxXqU26ohxtgD1lft5LBD4ojRkhREdgILC0oe/VoDtN6ssmvSGpTowxRiiHWDXVXEuEEInAdOAOKcPZqNUfDSq4eLBJryrGGGQv0K7Mz22Bv6IUS1wjhDARENs0KeVXkbhnNGcpj9ikn9XYbdLrmWVANyFEJyGEGbgI+CbKMcUdIuAl/w6wQUr5fKTuG81nuJi3SRdCnCuE2AscD8wRQnwb7ZhKJppuAb4l8KD/uZRyXXSjCkYI8QnwK9BDCLFXCPG3aMdUgeHA5cCYks/faiHEaQ19U7XTRKGIILEyS6lQNAmU4BSKCKIEp1BEECU4hSKCKMEpFBFECU6hiCBKcApFBFGCUygiyP8DRz6TCQKrefgAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pca = PCA(n_components=2)\n", + "Z = pca.fit_transform(iris.data, method=\"em\")\n", + "plt.scatter(Z[:, 0], Z[:, 1], c=iris.target)\n", + "plt.gca().set_aspect('equal', adjustable='box')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 12.2.3 Bayesian PCA" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def create_toy_data(sample_size=100, ndim_hidden=1, ndim_observe=2, std=1.):\n", + " Z = np.random.normal(size=(sample_size, ndim_hidden))\n", + " mu = np.random.uniform(-5, 5, size=(ndim_observe))\n", + " W = np.random.uniform(-5, 5, (ndim_hidden, ndim_observe))\n", + "\n", + " X = Z.dot(W) + mu + np.random.normal(scale=std, size=(sample_size, ndim_observe))\n", + " return X\n", + "\n", + "def hinton(matrix, max_weight=None, ax=None):\n", + " \"\"\"Draw Hinton diagram for visualizing a weight matrix.\"\"\"\n", + " ax = ax if ax is not None else plt.gca()\n", + "\n", + " if not max_weight:\n", + " max_weight = 2 ** np.ceil(np.log(np.abs(matrix).max()) / np.log(2))\n", + "\n", + " ax.patch.set_facecolor('gray')\n", + " ax.set_aspect('equal', 'box')\n", + " ax.xaxis.set_major_locator(plt.NullLocator())\n", + " ax.yaxis.set_major_locator(plt.NullLocator())\n", + "\n", + " for (x, y), w in np.ndenumerate(matrix):\n", + " color = 'white' if w > 0 else 'black'\n", + " size = np.sqrt(np.abs(w) / max_weight)\n", + " rect = plt.Rectangle([y - size / 2, x - size / 2], size, size,\n", + " facecolor=color, edgecolor=color)\n", + " ax.add_patch(rect)\n", + "\n", + " ax.autoscale_view()\n", + " ax.invert_yaxis()\n", + " plt.xlim(-0.5, np.size(matrix, 1) - 0.5)\n", + " plt.ylim(-0.5, len(matrix) - 0.5)\n", + "\n", + "X = create_toy_data(sample_size=100, ndim_hidden=3, ndim_observe=10, std=1.)\n", + "pca = PCA(n_components=9)\n", + "pca.fit(X)\n", + "bpca = BayesianPCA(n_components=9)\n", + "bpca.fit(X, initial=\"eigen\")\n", + "plt.subplot(1, 2, 1)\n", + "plt.title(\"PCA\")\n", + "hinton(pca.W)\n", + "plt.subplot(1, 2, 2)\n", + "plt.title(\"Bayesian PCA\")\n", + "hinton(bpca.W)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "### 12.4.2 Autoassociative neural networks" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "autoencoder = Autoencoder(4, 3, 2)\n", + "autoencoder.fit(iris.data, 10000, 1e-3)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX8AAAD8CAYAAACfF6SlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzs3Xd4VFX6wPHve+/0VEKX3kSwC4pYUAQLFhALNhRd/GFZ3aKubW2rq4u667rr6q7YwLUrFhRWBCvSO0jvNRAIIXX6Pb8/bghJZkKGdJLzeR4fkpk7974J8s6dc97zHlFKoWmapjUtRn0HoGmaptU9nfw1TdOaIJ38NU3TmiCd/DVN05ognfw1TdOaIJ38NU3TmiCd/DVN05qgGkn+InKRiKwRkfUi8mCc5+8RkZUiskxEvhWRTjVxXU3TNK1qqp38RcQEXgaGAL2B60Skd7nDFgN9lVInAJ8Az1X3upqmaVrVOWrgHKcB65VSGwFE5ANgGLDywAFKqe9LHT8HGFnZSVu0aKE6d+5cA+FpmqY1HQsXLtyrlGpZ2XE1kfzbAdtKfb8d6HeI40cD/6vspJ07d2bBggXVDE3TNK1pEZEtiRxXE8lf4jwWt2GQiIwE+gLnVPD8GGAMQMeOHWsgNE3TNC2empjw3Q50KPV9e2Bn+YNEZDDwR2CoUioY70RKqXFKqb5Kqb4tW1b6qUXTNE2roppI/vOBHiLSRURcwLXApNIHiMjJwKvYiT+rBq6paZqmVUO1k79SKgLcBUwFVgEfKaVWiMiTIjK0+LDngWTgYxFZIiKTKjidpmmaVgdqYswfpdQUYEq5xx4r9fXgmriOpmmaVjP0Cl9N07QmSCd/TdO0Jkgnf03TtCaoRsb8NU3TtMNnWRaLpi9n/eJNtO3Siv7DTsXldtbJtXXy1zRNqwdF+X7uHfg4O9ZmEvSHcPtceH8/nn/M/DNtOreq9evrYR9N07R68PYTH7JlxTb8BQGsqIU/P8D+rFyev+XlOrm+Tv6apmn14Nt3fyYcjJR5zIparJi1Bn+Bv9avr5O/pmlaPVBW3BZo9nMVP1VjdPLXNE2rB+dccwZOV9lpVzGEnqd2w5firfXr6+SvaZpWD2556lradmuNN9kDgCfZQ2pGCn946646ub6u9tE0TasHyelJjFv6N2Z/uYANSzbTpksrBlzdH2+Sp06ur5O/pmlaPTEdJmcN78dZww+1/1Xt0MM+mqZpTZBO/pqmaU2QHvbRqk2pKETWAA5w9EAk3s6emqY1JDr5a9WignNRub8DFQAskAxo9gri7FXfoWlagzb/68W88fB77FiXyVHd2vCrp6+j3yV96uz6ethHqzIV3YPaPwasbFCFoPxg7UDtuwmlAvUdnqY1WLO/XMCfrvorG5ZsJlAYZOOyLTw14gVmfDq3zmLQyV+rMuWfBMqK80wEAtPrPB5NO1KMu/+/BItCZR4L+kO8dv9/6ywGnfy1qrOygGDs4yoC1r46D0fTjhQ71++K+3jmxt2ouujtQA0lfxG5SETWiMh6EXkwzvMDRGSRiERE5KqauKZW/8R1Oogv3jPg6lvn8WjakSKjbXrcx5u1Tq+zgolqJ38RMYGXgSFAb+A6Eeld7rCtwM3Ae9W9ntaAuAeAoxdQekWiF9znIc7y/wtomnbAjY9djdvnLvOY2+dm5GN1d29cE9U+pwHrlVIbAUTkA2AYsPLAAUqpzcXPxRsg1o5QIiZkTEAVfQj+z0EciPca8F5e36FpWoM2ZPQgQoEw//3TRxTm+fElexj52FVcdvsFdRZDTST/dsC2Ut9vB6q0VllExgBjADp27Fj9yLRaJ+JCkm6EpBvrOxRNa7ACRUEmPP4h30z4gUgoSv+hfRnz3EiG3nkh/oIA3mQPhlG3U7A1kfzjDVBVacZCKTUOGAfQt2/fupn10DRNq0VKKR4e8jSr568nHAgD8MMHM1n6/S+8ufofJKXGmzerfTXxVrMd6FDq+/bAzho4r6Zp2hFv1dx1rFu0sSTxA0QjUQr2F/LduzPqLa6aSP7zgR4i0kVEXMC1wKQaOK+madoRb9OyLXF35goUBlmzYEPdB1Ss2slfKRUB7gKmAquAj5RSK0TkSREZCiAip4rIduBq4FURWVHd62qaph0J2nZrg2HEjo67fS469W5fDxHZaqS3j1JqCjCl3GOPlfp6PvZwkKZpWpNy0sBjadG+OZkbdhEJRwEQAafLyfk3nVNvcekVvpqmabXIMAxe+PFPnDrkZEyniWEaHNPvaF78+SlSM1LqLS7d1VPTNK2WpbdM48nPHyAcCmNFLdxed+UvqmU6+WuaptURp8tZ3yGU0MM+mqZpTZC+82/klLIgsgJUFJzHIaL/yjVN08m/UVPh5aicO0AVYC/EdkD6i4j7zPoOTdO0eqaHfRopZRWh9t1s99xXRcU7beWicu5ERXfXd3iaptUznfwbq+C3QLwmqlF7By5N05o0nfwbKysHVDjOEyG9y5amaTr5N1qu04j71ys+xN2/zsPRNK1h0cm/kRLnMeC5CPCWetQLzhPBdVZ9haVpWgOhq30aMUkbC+4BqKKPgAjivRy8wxHR7/ma1tTp5N+IiRjgvRTxXlrfoWia1sDoW0BN07QmSCd/TdO0JkgP+2iapsVRsL+Qbyb8wPrFm+jRpysX3HQOSWlJ9R1WjREVb3+xBqBv375qwYIF9R2GpmlN0M4Nu7j79IcI+kMEi0K4fW48PjcvzX2Gtl1a13d4hyQiC5VSfSs7Tg/7aJqmlfPPO18jP6eQYFEIgGBRkPx9+bz8mzdLjgkFw7z95Mdc1/E2rmo9mr/f9ir79+TWV8iHrUaSv4hcJCJrRGS9iDwY53m3iHxY/PxcEelcE9fVNE2raUopFn/3C8oqOypiWYqF05aVfP/4sGf58NnP2bt9H7l78pg6/nt+feqDBIqCdR1ylVQ7+YuICbwMDAF6A9eJSO9yh40GcpRS3YG/A89W97qapmm1xXSYcR93OO3H1y/exPKfVxPyh0qei4aj5GXn8927M+okxuqqiTv/04D1SqmNSqkQ8AEwrNwxw4AJxV9/AgwSkdjt7DVN0+qZiHDutWfgdJWth3G6HQy64WwA1i3aSLwMFigMsmL2mroIs9pqIvm3A7aV+n578WNxj1FKRYBcoHkNXFvTNK3G/frFW+h8fEe8yR48SW48SW66ntiZMc/fxK7NWXz1n28IFMYO77g8Tjr0LJ/+GqaaKPWMdwdfvoQokWMQkTHAGICOHTtWPzJN07QqSEpL4uV5Y1k5ey1bV22nU+/29Dr9aAKFAe4+/SFy9+TFfZ3D5eDCWwbWcbRVUxPJfzvQodT37YGdFRyzXex9BNOAmL7CSqlxwDiwSz1rIDZN07QqERGOPaMnx57Rs+Sx79+fSaAwSLwK+TZdWvH4J/fRrFVaHUZZdTUx7DMf6CEiXUTEBVwLlN8tZBIwqvjrq4DvVENdYKBpmlaBTb9sjTvc43A5uPJ3l9L95C71EFXVVDv5F4/h3wVMBVYBHymlVojIkyIytPiwN4DmIrIeuAeIKQfVNE1r6Lqd1AVPkjvmcafLQadj29dDRFWnV/hqmqYlKFAU5Oaj7yZndy5W1N4m1ely0KFXO/6z6HkaQhGjXuGraZp2GLat2cG7T0/kv09+zKblW+Ie4/G5+dfcv3Dm8NNweZx4kz0MvukcXvjhTw0i8R8OfeevaVqT98nfv+KtR94nGo6ilMLpcnD1H4Yy6olr6ju0w6bv/DVN0xKwe8se3vrje4T8IaKRKFbUIugP8fHzk9j0y9b6Dq/W6OSvaVqTNuuL+XEfD4cizJg4p46jqTs6+Wua1qQZpkG8Xg0iUmGPn8ZAJ39N05q0M4efRrxVW6bT5Jyr+9dDRHVDJ39N05q0FkdlcPfLt+LyOHF6nDicJqbDYMjo82jXo219h1drdPLXNK3Ju+iW8/jHzD/jS/YghoFhGkx963t+e9Yj+AsD9R1erdDJX9M0DXjzkQ8o2F9IOBgmHIwQKAyyYfEmJjz+YX2HVit08tc0rckLBUIsmraMaMQq93iY6f/9qZ6iql06+Wua1uRZliJOl3nA3qGrMdLJX9O0Js/jc9OjT7e4z5147rF1HE3dqIl+/pqmaUcsy7KY9MpUdq7fFff5tQs2oJQ64nr3VEbf+Wua1qT9+/fjef3Bd8nLzo/7fMH+QtYt2ljHUdU+feevaVqTtX9PLlNem04oEK7wGDGEYFGoDqOqGzr5N0HK2geB6UAE3AMRs/EuZNG0Q9mycjtOt/OQyV8pRc9T488HHMl08m9iLP9kyH0QxChe0v4XVMrvMZJ+Vd+hNSiBSJiFmTtxGiZ92h6FaegR0saoTedWhIMVJH4Bt8fFva/dgcvjqtvA6oBO/k2IsvbZiZ9g2aq2/BdR7gGIo3t9hdagfL1uLfdN/xqjeILPbZq8ftlwTmyjPyE1Nq07teTEgcex5LtfyrwJGKbBedefxXUPXUHHY9rVY4S1p1q3MyKSISLTRGRd8Z/NKjjuaxHZLyJfVed6WjUFptt3/DHCKL/+qwHYmrufe6b9j6JwmIJQiIJQiGy/n5s+n0ggUvHQgHZkCRQF+fxf/+Pu0x9i95YsWnZojsPlwOFy0KZzK56Z8jAPTLi70SZ+qP6d/4PAt0qpsSLyYPH3D8Q57nnAB9xWzetp1RKN273Q/hgQqetgGqSJq1YQtayYxy1l8d2mjVzco2c9RKXVJH+Bn7v6PcSOdZllVvQapsHoZ67n6vuGNrqyzniqO5A5DJhQ/PUE4PJ4BymlvgXi11Fpdcc9kPirGN2I58K6jqZByvEHCMdJ/lGlyA0G6yEiraZNHjedzI1ZMa0crKjF+Mc+YN+u/fUUWd2qbvJvrZTKBCj+s1X1Q9IOhwqvxMp/CVXwKiqy7ZDHitkGUu4FPICJ/dfvBd+1iPP4Ooi24Tu3cxd8TmfM40rBGe071kNEWk37+bN5FU/yIsz5smnsHV7psI+ITAfaxHnqjzUdjIiMAcYAdOyo/6FVxsp7Boo+AEIoTCj4Fyr1UQzfiApfYyTdjHKfhfJPBsKI50Kd+Es5t3MXTmlzFAszd+IvHuP3OZyMOPZ4OqWn13N0Wk1Ia5FS4XMiNOrdu0qrNPkrpQZX9JyI7BaRtkqpTBFpC2RVJxil1DhgHEDfvn3jd1nSAFChxVD0IXCg13jxR9i8p1DuQYjZvMLXiqM7kvLbWo/xSGSI8OawK/hyzWq+WLMKt8PBtccdz7mdutR3aFoNGXbXEBZMXRK3tl8pRf+hfeshqrpX3WGfScCo4q9HAV9U83xaglRgCgcTfyliQvDHOo+nMXEYBsN79Wb85Vfy6qXDGNi5a5OYAGwqThl0PDc9MaLsHb6A0+Xgvrd+TVqL1PoLrg5Vt9pnLPCRiIwGtgJXA4hIX+B2pdStxd/PAI4BkkVkOzBaKTW1mtdu4kxAiJnAVVRQzqlp2gHX3H85F//fYGZ+Po8tK7bTtltrzr6iH81aN52hPVFxS//qX9++fdWCBU1j4qUqVPgXVPb1xN79u5FWMxCj6fxPrGkA6xdv4qdPZmOYBueMOIMuxx2cN7QsiwVTl7JqzlpatMvg3GvOICktqR6jrT0islApVenYlU7+RzCr4CUoGId9u2/Yf6Y9i+G9+LDOo1TYHiqK7gBnb3D21cMc2hHljYfe5bOXphAOhEEEp8vBjY9fzTX3X07QH+QPg/7E5l+24S8I4Pa5cThN/vr9E3Q/qfHN5ejk3wApFQWMGk2sKrIFgt+DuMB9AWK2OLzXRzNR2deAygcVBnGA4xgkYzwinhqLU9Nqy8ZlW/hN/4cJ+st23nR5nLy+4u98//7PvPv0REL+shO87Y9uy5ur/tHobnQSTf66t08dUOGVqLzHILwccKG8VyCpDyLirfa5xdEJHDdXPbb9fwAri5JqIRWC8ApUwb+RlN9XOz5Nq20/fzaXcCh2hXooEObmHnfj9LhiEj9A1rZssrbupXWnlnURZoOjZwZrmYruQO27HsLLsIdnguD/FJVzV32HhrIKILyYksRfIgj+ifURkqYdNoer4ntYy1IEiypYma0Ujeym/7Do5F/LVOF/7bvpMoIQmoeKbK6PkEo51MbUjXPTaq3xGXBVf5R1eMPXItC2a2tadWyad/2gh31qX2QVcZumiRMim8DRua4jOhiCkYZyHA2RlZQtGXWC5/AmjRuC7Xm5PDvzJ2Zs3UKyy8VNJ5zM6JP76F78jVz7Hm1JbpZE/r6ChF+TlJ7EIx/eU4tRNXz6X0Vtc54AxNkIQoXBUf+7A0nacyApwIH5Bx+Y7ZHk39RnWIdtb1ERQz94h/+tW0teMMjO/Hz+MXcWD0zXy0magkE3nI3pSDydDb5hAB17Nd52zYnQyb8GqMgGVGghyiqKeU58N9iVOJQeXHSD+xzEUf/9i8TZA2n5PaTcD75bkLQ/Iy2+BEnBKngVa/fpWLt6Y2VfZbeUaKDeXrqYonC4zOyFPxJh8ro17MzPq/b5o5ZFQ62M0+D6P15Js9bpOD2xTfnimfLGt/zr7jdqOaqGTZd6VoOK7kLljIHIZrtEUkUh5X6MpBvKHhdZj8p7GkLzQHzguwZJ/g0iDXdrOCvv6XK9gwC8SPOPEGfD62l/w6cfMXt7bFfTFJeLFy+6hIGdu1bpvKv37uGR76axeFcmTtNkWM9jeHTAeSS7Gu7fXVNVmFvI5HHTmT91Cdk797FjbSbWIeYCXB4n7239T6Nr55Boqae+868GlfN/EFkHBEAVAH7Ifw4Vml/mOHF0x8h4C6PNCozW8zFS7mvQiV9Z+cXdQsuvHg6iCl6pj5Aq1T2jOY44pRthy6JDalqVzplVWMCITz5g0a5MFBCKRvli9WpunfRpNaPVakNSWhIj/jCM56c/zu/H3R5354rSnG4n21bvqJPYGiKd/KtIhddCZCuxVTEBVOGEeC85ckS32xPSMaziCeyG5+aTTsFplm3F6zJNTmjdhu4ZFXc4PZR3li0lFC379xuyoizP2s2qPdVqYKvVsv/cM6HSCqBwMEybLk13CxKd/KtK7bc7aMY+AdaeOg+nRpnt7AnpGAKOo+s8nER0SW/GW8OupGt6MxyGgdMwuaBrd167NO7mcglZvXdPTPIHMMVg0/6c6oSr1bKtq7Yf8nnDNOh3ySm0aFe1G4PGQJd6VpWjdwUJ0l28XeKRS4xUlHc4+D+n7NCPG0m+s77CqtRp7doz/aZfkRcM4DYduB3V+9/7hNatmbF1M8FybwARZdEj4/DaaGh1y+1zEyiseNvNc689k3tfu70OI2p49J1/FYmRDCn3cLBEEsANZku7wucIJ6mPQdKvistAAcfRSMbriLN3/QaWgFS3pyTxByMRXpg9k/5vvMqpr73CI99NJ8fvT+g81x13Ih6HE6PUXILbNOnXrj09mjfdO8YjwZBbB1X43D/nPM1D//0NLk/DnXerC7rap5pUcJY9xm9lg+c8xDcSMRpX9YBSFnIE7hGglOKGzz5mcWYmwai90M5hGLRNTuGbkTcn9Mlg8/4cnvrpe2Zu24rH4WBE7+O4t/9Z1f5UodW8dYs2snDaMpLSfJw4sDe39r4npjzX6XZw81PXMeK+ofUUZe3Tjd3qiLjPQNxn1Mq5lZULwRn23ILrbMRIRkV3QHAmSBK4ByKGr1auXdqRmPgBlu7exdJdu0oSP0DEssj2FzF53Rqu6HVspefonN6MN4ZeUZthatWklOKvv3qFHz+eTSQUweFyoCwLl9dJsKhsa5VwMMKMiXMadfJPlE7+DZRV9AXkPWKvHwBQUZT7HAj+ABgHd+tqNg5xnVpfYTZov2TtRsUp+CsKh1m8KzOh5K81fLO+mM9Pn8wuaeAWjRy6L1Vys8a5icvhOjJv6Ro5Fd1hJ36CoArt/whAcKr9GP6Sx1XO7aiYxnEaQPvUNMw4tf8e00GX9Gb1EJFWG76Z8EPcyV0xJKZXvyfJzeV3Damr0Bo0nfwbIv8UYtssV0RBaG5tRnPEOrtjJ5p5vTFvAE7T5IpesRPX4WiU7KIiolaiv3utIaho3tLtc9GsdRreFA++VC8uj5Or7h1Kv4tPqeMIG6ZqDfuISAbwIdAZ2AyMUErllDvmJODfQCr2iqinlVIfVue6jZ1SRRxWS2VVcUlb5dcKASYSd83CIV4X2QyhA3MPg+3qp5hj1qMKXrMXhjl7I0ljEEfV2ixUhWkYfHTVtdz3zdfM27kdAXo0b87z5w8h3XOwSkspxUvz5vDaovmELQuP6eC3p5/BLSfpJHEk6HdJHxZ8s9TewrEUwzB4e+PLrF+0idy9efQ6/Wiataraau/GqFrVPiLyHLBPKTVWRB4EmimlHih3zNGAUkqtE5GjgIVAL6XU/kOd+0ip9qkNKrwclT0SSKQk0YO0mlWSfFV0J6rwTQgvBUd3JGk04uge5xorUbmPFLdzdoDnEiT10bhJvDwr71koege7WZ0BApL+KuLud/D8oSWofaOwh6kswARxIxlvI84TEvi5alZBKETUskjzlN2ackd+Hr/7ejKLd2Vilfq34HU4+NO5g7iq93F1HaqWIMuy+Mcdr/HNhB9QlioZ63d6nBiG8Pgn93HqRSfHvC4UDJO5cTfNWqWR2jylrsOudXVV7TMMOLf46wnAD0CZ5K+UWlvq650ikgW0BA6Z/JsycR6P8g6DwBeg/NhJ1g1GK1B7QRVh/9U5IPXJg4k/sgGVfTWoABCB8C8o/xTIeL3MpLCK7kLtu6F4LgEgBIHJqOh2yHgbgj9BdAOY3cA9oMynAhWcBf73sJP6gQdB7b8DWs0p6Vmk8v5E2TevKKgiVN6fkeYf1fjvrDLxGrGtyd7LlR++R1EkdrGePxLhn3Nn6+TfgEQjUdYs2IBhCD36dGXKa9P57t0ZREpt4SiG0LZzK/76w5/i3uV/9tIU3vrj+yAQCUc5Y9ip3PfGnXh87rr8URqE6ib/1kqpTAClVKaIHLJRhoicht3cfkM1r9voSeqfwHMxKvAVYCLeoeA8GUKzUIHpYKQi3uGIo0vJa1Te2OKEfuAONgr4UbmPIy2nHDyu6N04q5NDEF6O2jMIVK49lCTFbzjN30eMDPu1/onFb0hxhOaC+2x7DDayMv4x4eVV+XXUiqd+/D5u4j8gq6iwwue0urXk+194asQLREIRFAqPz43L4yJQbotGZSkyN+7G4Ywdxpz5+TzeeOi9Mts6zv5iPi8Y/+Hhd39b6z9DQ1Np8heR6UCbOE/98XAuJCJtgf8Co5RScWfURGQMMAagY8f673Vfn0QE3Kcj7tPLPuE+C3GfFf9F4XkQr5dhdBNK+Q9uGB9eA8SrEAqDtZuS+QYVgeg2VN7TSPrfih+rOFkeeE5EUJJU3Om0/A9W+bBSTYlYFtM3buDnrZtpmZTEVb2Po13KwQV4CzIP3dGxqg3htJq1f08ujw4dW6aix58fKLtFRiliCIHCICnNyv6/9sHYz2L28w0Fwvz86VwKcwtJSmtaJaCVJn+l1OCKnhOR3SLStviuvy0Qt9WhiKQCk4FHlFJzDnGtccA4sMf8K4utMiqyHuWfBMqPuAeD67SY0q9GRVIquCt3AKW6dDqPh9BsygzdAPEnmSMQmArYyV+8l6KCPxIzH6Ei4Do45o/3eih6m7K9gTzguzGxn6UCmfn5rNybRfvUNHo2r7i/TjAS4fpPP2JN9l6KwmGchsGrC+fzn0uGMaBTZwCSnM64jdsAPA4HD591TrVi1WrG9+/PxIrG3i8ahhH38bSWqbRolxHz+N6d8ZvxmQ6DvOyCJpf8q1vqOQkYVfz1KOCL8geIPQj8GfC2Uurjal4vYVbhB6i9V0Dh61D0Nmr/GFTu/Y17NybfTYCn3INu8A5D5OD7vCTdAOKh7F+/mwpvpUp/mnAPBvfZ9qY0CPabigfS/oIYB//xSMpvwTMEcBX3B3KB99K4jeGilsW/5s3m1Nde4ZiXX+SGTz9i1d49Mcc8MH0qA99+g3umTuGKD9/lyo/eIzdQfs8B2/u/LGPlniyKwvankbBlEYhE+N3UyUSKSzlHnnASnjhtGlr6khg/7ErO6NC0P302FDs37CIUiP3EGfcNwWFw3xt3xr3JO2FALwwj9nGH00HLDk3vU151k/9Y4HwRWQecX/w9ItJXRF4vPmYEMAC4WUSWFP93UjWve0jK2gf5T2PfdUawZyT9EPgGQrNq89L1SpJGg+d87Dv9ZOwOo2ciqY+UPc7IQJpPLO4+6gFpBkm3FH9ffqzULNOlVMRA0l9C0v8Dvpsh6U6kxWQM7yVlryFOjPRnkZY/IM1eR1r9hJH2TJk3oQMe/m4aryyYR7bfTygaZfb2bVz98ftszT1YE/DfZUv4au1qQtEo+aEQ/kiEX7J2c//0r+P+Lj5csTymGyfYnwhWFPfiv+vU07mwa3fcpkmKy43bNBnctRs/3Xwrp7VrX8FvWatrG5ZsSvhY0zDodlLnuM/d9MQIPMkeDPNg2nP73Nz2t5twOJtes4Nq/cRKqWwgpn2eUmoBcGvx1+8A71TnOoctOBP7Rys/rOFHBaYg7jPrNJy6oFQQlfsABKbbewarEPhuRFLut8fgrf2o/Och8D9AwHMxkvZsmSZ0Krq7uFooz64oEh9IKpL6aJlrVTgfEYeYLcCseHhmT1EhX6xZFbtpSiTCa4sW8NRAe9Rx/NJF+CORMseELYsfNm+iMBQiqVw1T0X79gajUVzFm744TZO/X3QJ9+fnsyFnH53T02lfxV2/tNqzZsHGhI+NhCO8++eJ3PH3m2Pu/tt1b8u/Fz7HO099wvIZq2jdqSXXPTScPuefWNMhHxEa59udOO0RiZgRHgO72KjxUXlPQOBbIGQnfrBLMp29UJ4hqOxrILoN+5MQ4P8UFVoILb4sKeUUszW0nAaBr1GR9YijB3guRKT2yuA25eTgNh0xyT+iFMt27yr5viAUv4WFiOCPRMokf6VUhcdbSnFMubmCtikptE1pfPXeR6LlM1bx7p8/Ycf6XfTq14ORj12Ny+Mk5E+shYlSMHncdFKaJ3Pjo1fHPH9UtzbcP/6umg77iNQ4k7/rbOJWveBCfMPrOppap5Qf/F8SU8FLjjuEAAAgAElEQVSj/KjCV+3kbe2mJPEDdmVPpl3T7yk9rFM8R1AbcYbXoQpehPAyMI9Ckn9Nx7STCUUjMceaIhzT4mCSPqdTFyatWUW03JxNm6Rkmnu95V+O23QQiHNer8PZuCf9j2AzJs7h2VEvlXTizNqyh9lfLeSs4afx48ezy6zgNR0mSqm44/6hQIiPnvuCa/4wrMn37D+URtnbR4wkJP0l7I1WfMV/uiH59npZXVrrrHwqnKyN7oXI2uKFYeUoP0RWl30omoWK1vw2lCq8BrXvaghOt9+IwotROXfTypjGoC7dYiZeXabJmFMOLky7r/9ZpHk8uIuHbEwRvA4Hfxl0QUwyFxEuP6ZXyfDOAW7TZESpRVtLdmXy0Lff8NuvJzN1wzrd06ceKaX412/eKNOC2bIUwcIAOVm59D79aNw+N54kN95kD12O78jD7/8u7gTuAdmZeqvNQ2mcd/6AuM+GVj9D8Ds7ybkHIOZR9R1W7TBagJECVvk5DgFXXzA72eP35d8AxAuOzkBxct5/D0S32N87uiPpL9RYLx6V/0JxGWrpO3c/5D/L387/ibGzZtqTtJEIPZu34MmBg+lWqs6+bYq9Acu7y5cyb8d2ujbLYNSJJ9O1WWxJH8Afzz6XjTn7WJ61G1MMIsrilDZH8cBZZwPw6sJ5/GPubELRKJZSfLNhHSe0bsN7V4zANBrlPVGDlpedT/6+2HUhSsGq2Ws5bcjJNGuVRnrrNIbddRGDrj8bEWHS2V+z7MfYBYXKUjRrnV4XoR+x9E5ejYTl/xpy7+dgXb0B4kWafwJme9Se8+zdxkq6hRpgtEJaTgcVQu05157oLSEg6UirHxEpXz5ahfh29wMV707Mg7SchpitUUoRsSyc5uE1mTuUVXuy2JCzj+4ZzTmmRUsA9hQWMmD8a3GrgVr4fLx/xYgybzxa7QsFwwxvNipuSaeIgNgJ3TAEp8fFc9Mfo/fpR7Psp5U8fPHTZT4xuH1uhv36Qv7v2eqtKTlSJdrbR9/iNBKG9yIk4w17vsPsZI/bN/8ccXRDxG3303H1xy7lNMF1JtL8I7sXT2BKnJW7Cgja1UM1wWxdwRMKDLvCRkRqNPED9GrZikuPPqYk8QPM3LYVRwV393uLirjh04/1EFAdc7mdXDDqXNzesmP0IoJSCmXZN6mWpQgWBXnld28BcMKA3jz60b0c1a0NIpCU5uPaB4Yx+i9H/j7ata3RDvs0ReI6FcmIv6uXmO2QjLdKNn450IAN7E6gcTuIqiBEd9ZMbMm/RuXeX24Fsge8w2vkk8Xh8Dkdh5z0LQyHmb19G2d17FSHUWl3vHgLQX+IHz+ahek0saIqph3DAesWHiz/7HfxKfS7+BQi4Qimw9QT+gnSyb8JUFau3cwt+CMYbZCkW8B1cJ2dOE9ExZ0TcEPxBLlSUQh+g/J/BeJBvFcnVOdfcirPhajobih4EVQUsMB7GZJ6WC2iasQ5nbpUUs2kyAkk0k5bq65oJMrMz+cx56uFpLVM5doHh3PH329mX2YOrTu34tp2YyjMjS1WSE6PbcXQFBdqVYf+bTVyyspB7R0GVg72ojdBBb9Hpf4J40DZq3sAmF0gsp6DC+M84OgFrn4oZaFybofw/JI3CBWYjkoahZFyT8KxGEk3oXzXQnQXGBkJ7R1QG9wOB28Ou4IbP/uEQCS2HDRiWfRt264eImtawqEw9w9+kvVLNhMoCGA6TL58ZSr3vH47511nT8wPu2sIE//+ZcyY/vDfXlLRabUE6TH/Rk4VvgnWPg4mdQUEIP+pUkNAJpLxLiTdCkZ7MDtA8hgkY7z9ETr0U5nEb/ND4Vv2fsOHQcSFODrWW+I/oE/bdswdfRsdU9Nwlhr/9zqcjDrxFL3oqw58+84M1i/eRKDALlKIRqIE/SH+PubVklbNNz1+NYNuGIDL4yzZivH8m87huocur8/QGwV959/YBb8nfvtmhQqvhOhmVPAHkOaI71q7IVv5IwPfx18ngAHBWeCLXUlZW8LRKJPXreXr9WtJdbu57rgTOLlt1Up4U9wevh45ig9+Wc5Xa1eT7HJz4wkncV6Xuttqsin77v2f4268bpgGK2ev5ZRBx2M6TH7/6m2M/sv17NqURduurWNaNWtVo5N/Y2fEr4NHRSD3EVR0G/Zkr4nyf4xKexrDe1m5c6RhVwmVK40UA+rwDj4cjTLys49ZkZVFUSSMAJPXreGe/mcx+uQ+VTqnx+Hk5pNO4Wa9X2+d8ybHn+hXSpWp+lFKkblhN3nZ+RzVLd7WIlpV6OTfyInvFlR4abkqG4e9MKwk8YOd2KOQ9yjKcz5YuShrv93Lv2gicXv9Kwtl5UN4FeLsVes/y5T1a0sSP9gDWP5IhL/OmsEVx/SmWZw2D1rDdentF7Bo+rKYu/9IKMq9Ax9HWYqOvdrhLwyQuycfwxAioQijnryWEfcNraeoGw+d/Bs58QxERe6AgpfthncqAo5ugAOs+OP1as8QsLKAQ+zaBUAU8p+xJ4RdJyPNXq3Vss2p69fF3XbRYZjM3bGdi7r3qPQcUcvigxXLeX/5UsKWxdCex/Crk/rgdTorfa1Ws/pecCKX3zWEiS9OxnSaGIZQlOcnHDz4d7z5l20xr3v7iY/ocUoXTj7v+LoMt9HRE75NgJF8O9JqJpL+CtLiU4wWn4HRLP7Bqqj4TaGyxA92B9EiIAChRaj8f9Rg1LFS3W6MCmq4k1yJJe+7//cVz8z4gZV797BuXzb/mjeXEZ98ULLBi1Z3RITRf7mB8Wv/yW9evpVLxlS4aWAZwaIgn7/0v1qOrvHTyb+JECMVcZ+OOLrb3yddb/f2iT2yilcIgn9ileNLxHXHnRDTrA3A7TDp377yXbdW7snihy2byuwLEIxG2Lw/h2kb19dorFpi9mzPJhqJMnjkAFbNTfzvIHdv/P0atMTpYZ8mStznonyjoPBNezgI7C5axKvqSVT81Zg15cQ2bbn/jLN5duZPOE0TpcDjMBk/7MoK2zWUtjAz/mrlwnCYudu3MaT70TUdslaBHeszeWrEC2xbvQMRIaNtM9p0aVn5CwGHy8FZw/tVfqB2SDr5N2FGyj0o3w0QWgBGOsoKQN69FZR1Vnq24n0UatfNJ53C5cf0Yu6O7XgdDpbu3sXoLz/DHw5zZodOPHTWOXRIi78bV0tfEqbEvkm4TZOjUlLjvEKrDeFQmHsGPEbO7tySPbUzN+5m367EWzAnOkSkVaxawz4ikiEi00RkXfGfMQPJItJJRBYW7927QkRur841tZolZmvEewniPhPxnGuv9KX8zl2lh4KSwHs1JXsEA/Y+wOlI6sN1EDGke7xc2K0HE1et4N8L5pFVWEh+KMQ3G9cz7IN32FsU/83rvC5d8TjMmIEt0zAY3qt37QeuATBvymL8hUHKdxQOFoUSGnWMRqJ4k3VlV3VVd8z/QeBbpVQP4Nvi78vLBM5QSp0E9AMeFJFG2lj/yBa70rcjeEdC2vNI868w2qzFaLMYI+1ppOU0SL4TPBdDyu+Rlt/U6X4J2/Ny+WbD+jLtGSyl8EfCvLNsSdzXuEyTD668hm7NMvA4HHgdTtokJ/PWsCto6bN7xRSEQszZvo3Ve/fEJCetZuzdsY9oOLatBlCy3YNhGkgFG7W0aKfbbdeE6g77DAPOLf56AvAD8EDpA9SBHgI2N3qSuVJKKVTRBCh8A6z94DwOSX2oZBcypcIQ/A4VXoWYHcE7BIk7eXv4xPDZq3zjrPQtc5zZHEm+o0auWRWr9+7BZZoxPfmD0SiLd1XcibRbRnO+ufEWtubuJxyN0rVZRkkXyPFLFvHcrBk4DYOIpeiQmsqbw67QQ0I1rOep3YiE46wbKcWKWhimgcvrJOgv29fnpifqbkV5Y1bdRNxaKZUJUPxnq3gHiUgHEVkGbAOeVUrVTJ/gRkrl/xXy/168724QwgtR2TeiwmvtDp17L0PlPgCFr6DynkRlDURFttZ32HWqY1o64TjlmU7DoEcCG7F0TEunW0bzksQ/Z/s2np81g0AkQn4ohD8SZkPOPn71xaf6E0ANWzhtWUK/U9NhcNmdF5CSkYzpMEltkcKY52/kolvOq4MoG79K7/xFZDoQb011wr14lVLbgBOKh3s+F5FPlFK741xrDDAGoGPHykv3GiNlFUDR28RWzgRRBS/b9fnRbRyswy8CFUDlPog0f69ug61HRzdvwQmtWrNk9y5Cpe7+HYbJqBMPv1XDW0sWlSkBBYgqxba8XNbuy6Zn8xYVvFI7XJ/9c0rJ5iyHEg5GSGuRyidZbxAoDOJJcmPoLTZrTKXJXylV4bS6iOwWkbZKqUwRaQtkVXKunSKyAjgb+CTO8+OAcWBv41hZbI1SdAeIw95IpQwLIivByiV2AZYF4SUoqwgxfHUUaM1SSvHxyl8Yt2g+OX4//dp14OIeR/PWkkWs3JNFhtfLbX1O48YTTiq5W3/tsuE8+v10vl6/jqhSdMtoxl/Ou6DCap89hYWMX7qIuTu20yUtndGn9C3Z4SvbH3+S2DQM9vt1b/+aVLg/8WqyD8Z+zlX3XIYvRU/w1rTqjvlPAkYBY4v//KL8ASLSHshWSvmLq4HOBF6o5nUbL7NtnC0VAcRuyxBaXPFr63EHIxXda38yCX4PRgriuxm8VyS8q9JfZ/3M+KUH776nbljH1xvWlTyfWVDAszN/Itvv5/ennwFAitvNixddQigaJRyNkuRyxT03wI68PC774L8UhcKErChLdmUyef1a/n3xUM7p3IXBXbqxIiuLYLTs3X/EsjiuVUVbUGpV0fPUbqyYtSahYyOhCPuzcvUkby2o7meoscD5IrIOOL/4e0Skr4i8XnxML2CuiCwFfgT+qpRaXs3rNlpipIL3cqB8jxw3knwneC8Dyic5A1x9a2zS93ApKxeVPQz8H4K1EyJrUPlPovL/XPK8lfso1u5T7P9yH0JZB2u684JB3lyysMywS7yPff5IhNcXzccfLvvm6DLNQyZ+gL/N/pm8YJCQZQ8RWUoRiER4+LtpKKW44fgTaZOcjMc8eD/kdTh44MyzKz23dnj+77mRCR8rhpDaQk+414Zq3fkrpbKBQXEeXwDcWvz1NOCE6lynqZHUJ1CSBv53QQXA7ISkPmZX+5hdUaH5EN0CKmRvtSjJSNrYeotXFb0PVh5Q6q5Z+aHoQyzfrZAz2o73wHCV/wtUaAG0mIKIk405++JW7sQTtiyW7d5FVCm6NmtGm+TENl35eesWrDiTjPv8RewpKqRVUjKTrh3Je8uXMm3TBlr6fNxyUh9Oa9c+ofNricvamo3b565wf94DXF4Xw39zMS63brpXG/QK3wZIxIGk/gGVch8QLrPZuhjJ0PwzCM2E8GpwtAf3oDLHlKaUgtDPqKKPgSDiGQqeixCJ7ZFTZaE5xG3tIC7wfwxWJmXnKSJg7YXgt+C5iLbJKWUmbQ8lYlnc9PlEPA77zeKibj14/vyLcMbp+VNaqsfN3jjj+kqBz2n/7lLcbm7rexq39T0toVi0qtm2ZgehQLwNhg7yJLm5+r6hjHz0qjqKqunRyb8Bs8fLY5O6iAHus+3/KqHyx4L/g5J+/io0FwKTIP3f9nlqgtmBuJu9qKj9iUAF4gRWiCqYAI6etE7uwoBOnflpy+YE7/6jhEP2cd9sWE/71Fncd8ahfxe/OqkPT8/4oczQkmBPk9w/7Wvu6X8m3RMoEdWqZ/W8dXz0/KS41T6eJDcjH7uKIaMHkZyepCt7apn+7TZiKrIZit4ru5GLKoLQXAjNrrHriO8moPxHcwc4uoLZggrX7EcWo/YOwyr6ghcvvISLe/TEZZq4TJNkpxMjgbX+gWiEd5YvrfS46447gWuOPR63aeIu/pSgsBeFfbNxPZd/+C7r92VXeh6t6izL4rHLn6twuCdQFOTdP09kZJc7mfb2j3UcXdOjk38DpSKbUUWfooI/olQFS+ErE5pN3MSriux9e2uKozuk3AeShj1R7QLXqeDqZ28iQ0XxW0AA8h7FY4b42wVDWDzm18y45f/48robKx3KOaAwdOghBLA/RT12znn8MGo0Zrk7ygOTv3+fMyuh62lVs3bBBgKFcT4FHqDAnx/Anx/gpbveYOWctXUXXBOkh30aGKUUKu+P4P8SxAQExAcZ7yCOLmWPtfJQhW/aWy0aKYjvRvBcerC8UpLtc8R8wnZAeBPWnoH2ugHXqUjKH0p6/R9WvJGNqJxbwdoHSgAFyQ8ingGovZeQUJtncUBoHngG4nU67V21fEk8ee55PPbDtyXtmovC4bhVQCe3SbynUChqEW9xqaUUiypo+azVjGjESrj0N+QP8ek/JtP7dN1mu7bo5N/QBCZBYDIQPJi0VREq5w5o8T9EBGXloArftnv/EAIsiILKXQPhpUjqI/br3OcBj8W5iILwXEoSc/AHu4Ko+STEkXh1i1JR1L6bi9tQlMqoBc+h1K7D+7mlfCdRuPrY4xnctTs/btmMwxBa+HzcOulzQtEIEaVwGAYu0+SJcxNf7t/M68VS8Xftaptg5RDYb9Lzd+5g3o7tZHi9XNKjJ2me2tvCsjHoeWo3DDOxwQalFHu362G42qSTfwOjyo/R249CdCdEN6PEi9p7OahypZUA+KHoA1TSrYjZBjGSoNnrqJzbKZmMVZHi1wXLnl8FUIWvI2lPJB5saAGofGI/WoQgtITERxVNe5gojmZeL5cfc3Bz+K+uv5E3Fi9k5Z4sjm3ZiltP6UvHtPSEQ052ubj06J58tnpVmdJPAUadeFJC54hYFmO++px5O7YTCIdxOxz85ecfGX/5lfRp2y7hWJoah9PBH9//PU9c8TxW1CIcDONOchPyh2ImgF0eF/0uPvw2HVridPJvaOJVxgCIYSfogn+DyiWmsqbkOBeEl4LZpvjbPtBqlp2oCaNwwv67ipN2aREIx2+FXHGs+yt4woIKN3I3sCuDHPbPhCDNxiGSWC135/RmPDUwsY08lFJ8svIXxi1awD6/n9Pbd+C+M86iuddHvLGfz9esZtgxlff1n7hqBXO3b8dfvJn8gQqiOyd/yezRt1W4z7Bmb9o+fu0/+fbdGeTuyeOUwSewduF63n/mMwKF9g2J0+0gvVUql91xYT1H27jp5N/QeC6Ggo3EjpW7wXE0BH+kwsQPgAKj7HZ4Ik5w97e/ie6ibJftAwy7OicBKroLVfAPCHwHqjD2APEiniGQNBK1/7eUfAJQEUh9AnH1syejjWRwn1trK5P/NvvnMg3bpm5Yxzcb1hONM+yjgBlbNrN0VyYntml7yPN+vPKXksRfWlE4xKo9WRyr20EcUoujMrjmD8NKvu97wYl0O6EzE1+cTO6ePPoP7csVv7uE5PSkeoyy8dPJv4ER342owGSIbMXeT9cJOJD0vyJioowkiFa03Z3Yid95csXnN9ug3AMg+BNl32DcSNKtlcanrP2o7OH2PgPFb0JKlW4r5AGzM3gvRcQNLWdBaIad+N1nIUbxEI2jdnuy5wWDvLF4YZl1A/YwT8X9Ai0U1038kHevGMHJbQ9/Y5qm2YmwZvS7pA/9LulT32E0KbrUs4ERw4c0/wRJewq8wyHpVqTFZOTAgi7vSCDenbIBjt5IxoRKKyok/W+legQ5wOyANHsFcVY+5KGKPgCrkNKfPkQgqmBZdkvm51+HNP/QTvyAGEmI5yLEe+nBxF8HNubsS7hUtLRANMpjP3x7yGOu7n0cXkfsfVOyy0WvlnG3tNC0Bkff+TdAIi7wXoZ4L4t9LmkUKrIaAv8DcdqraM0OkP5XDOcxCZ7fg6Q9g0p9wp5jkJSES/AIzQdi5yWKwk5eWXUyP2f5mNtRSIkt3qnUjrw88oIBumc0j0ncWYUFLN6VSQufj1PaHFVpvG2TUwhFqrY+YuWeLCylKhy7v7LXsby2cD4b9x/8BCbAnwcO1uP9h6CUYvW89RTkFNDr9KP1sE4908n/CCNiIunPoaK/tXv7mEchzl6VvzDuuVz2BPHhcHQpXjxWNrGahmJHUQpOw2BR5k7O6dwl/uvjyCos4PavvmDV3j04DAPTMHjmvPO5uEdPlFKMnfkTE5YuxmWYKBTNfT7eHT6CdqkVd3tsnZxMm5QUtubmHt7PB/iczkMm8Z+3biGzoOyEuSHCP+fNYXDXw18r0RTs3LCLBy/8M/uzchFDiIQijHryGpLTk5n08tf4CwKcOfw0rn3wclIzEi+51apOJ/8jlJjtwKz7skLx3VjcJO5g8g9FDdblNWPV/hYkORUp7sRv+5VSjPp8Iuv3ZRNVqmSM/r5pX9MpLZ0tubm8s2wpoWi0pPmbPy+PMV99zuTrbzrkefcUHnrTEAPBKjdS7zEd3HD8oUs+y7efBnvXr/X7stm8P4fO6c0O+fqmRinFwxc/za7NWWVKOt98+D0Mh0k4YE+ef/7PKcyYOIdxy/6GN0mvmahtesxfA0ApCxWchSp4FeX/ChWzk5hNHJ2QjNcJqKMIRk1CUYOfdnXgVz9djACpbg8nVVItU9rKPVlszc0lWq70MhSN8tqiBYz9+ceYyhpLKTbtz2Hz/oomvu1kHIhTkQP2XXq/du25+aRTuKS4n1CKy4XLNLmwew/u7X/mIWPeV8HOXg7DIDdwiPYFTdT6xZvI3pkTU8sfjVgliR8gHIqwf3cu0ybovj51Qd/5ayjlR+27CSLr7O0jxQP5T5OXNJ5n52xhyvq1CHDp0cfwhzPOJtV9Kt423/POkm95cd4iwsqLUopWSW7GD7vysMa99xQV4TBij7eUYuqGdRW2ejbFoOAQPX0chkEzrzduom7u9fL+ldeUfL+3qIjN+3PolJZOy6TKx6EHdenKhn3ZMR1IlVIl20JqBxXsL0x4ZW+gKMji75Yz9E5d41/bdPJvhJRSiU/gAqrgP/b8wYHST1WIUn52bBvDxFWXE7bsuviPV/7C/J07mHzdjZiGwY0nD+ayXmeyYOcOUt0e+h7V7rAnPI9v1TpugncYBhGr/KDMQaYhlW6qXtEbx/5AoMzvqIXPRwtf4nsf/+qkPny6aiXZRUUEohEE8DgcPDZgIO44VUBN3TGndScaTmy/BofTpHVn/QZaF/SwTyOhlMIqfBsrqz9qd0+sPYOw/NMSe7H/M8ovKhMsuqbsJslxcNw8FI2yIy+Xn7ZuLnks3eNlcNfunNaufZUqXZr7fIw+uQ9ex8EVvi7TRCBmKKj082PPu6DSUs6Kkn/Esio8dyLSPB4mX38Td/c7nb5tj+LiHj15Z/jVXH3s8VU+Z2Oyb1cOU17/lv+98S05Wbl4k73c/sIo3D5XyRuu2+fC4XIg5T71mU4HQ/XK3jqhb1MaCVX4JhT8Eyge5ohug9x7UcZLiPucKp9Xyt17ByIRVu3Zw8DOia0GTsS9/c/i2FateWvxQnICAS7s1p3lu3czY9uWmGNNEV4acinnJ1BVc1q79szcuiXm08NxrVqXdAqtqlS3mzv69uOOvv2qdZ7GZvJr03jlt2/ZG7EI/OvuN/jdq7dx6W0X0PWETnzx8lT2Z+3njMtPo+8FJ/LsqH+xftEmDNMgOc3HH8b/mqO6tanvH6NJqFbyF5EM4EOgM7AZGKGUijsLJyKpwCrgM6XUXdW5rlaWUlEofIWSxF8igMp/sfLk770MCidgdwg9cE5hfX5zckJlF5R5HA46p9fsYi0RYUj3oxnS/WD73ukbNzBnx7aSISewE3+P5i3KJP6icLiku2d5jw0YyBUfvVdSKeQ0DJymmXBvIO3wZG7azSu/G08oUHai/cXbXuXkQcfTu39PevfvWea5f858mr079xEoDHJUt9Z69646VN07/weBb5VSY0XkweLvH6jg2KcAPY1fG1R+xQ3horF3z+VJ0h2o4AyIbrV3+sIHhpMnlwzBECnpfmmIkOxy13ot+478PB7+7puYxzumpvHGZcMBWLork4e+/YZ1+7Ixit88nho4uEyZafeM5nwz8mYmLF3M0t276NWiJbecdArtU9NqNf6m6qeP52BF47fL/nniXC6/e0jc51oclVGbYWkVqG7yHwacW/z1BOAH4iR/EekDtAa+BvpW85paeZIC4gUVp7TRrHyxVcmm8MEfUOHliNke8QzhhYsjPDB9KvN2bAegf4eOjB10Qdy77Jr0+Pffsq/IX6YG3xChS7MM2qaksCMvjxs++5iisP3zRpVi0trVTN2wjrGDL2RYz4OL3tokp/DAmQNqNV7NFglHUFZs8rcsRSRcxd3otFpT3eTfWimVCaCUyhSRmMYmYu8S/jfgRmDQoU4mImOAMQAdO3asZmhNh4iJSr4bCl4otxeAB0m5J+Fz4BmEeA7+FbVPhXevGEGweEFTopUsWYUFZPv9dE1vVqXql5+2bo5ZfGUpVTLRPGHpYsJxJnOD0SgPTp9KIBzhmuP05GtdO2PYqbz/zKdEI2VLcA3ToP9Qfc/X0FT6L1NEpgPxZmD+mOA17gSmKKW2VVZ+qJQaB4wD6Nu3r26SeBjEdxNKPPaeudYeMDsjqQ8g7kMvWEpEogk8NxDgN19/xbwd23EY9qeDh88+h+uOO+GwrmeKxN311yz+/2fdvr1l5gJKC0ajPD97BiOOPQ4RYf2+bDbl5NCjeXO98raWdTmuI8N/ezGf/XMKoUAYEcHpcnDNg5fTrnviC/+0ulHpv2qlVIWzYyKyW0TaFt/1twWy4hzWHzhbRO4EkgGXiBQopR6sctRaDBFBfNeA75rKD64lv/7fl8zfsZ2wZZUsgPrzT9/TKS2dMzok/knukh49+XLt6jIJ3mkYXNLDniw8uc1RzNm+LWaR1QG5gSB7i4r4/dQpLNq1E4dhEI5anN2pEy9ddKmuxa9Fo5+5gbOvPJ0fP56NiDDw2jPpdmLn+g5Li6O6/womAaOAscV/flH+AKXUDQe+FpGbgb468dc/y7LA/wEEvwYjA5J/h+HoXOXz7czPY+HOHVMchzcAABFxSURBVDF35P5IhHGL5h9W8n/snIGs3JPFtrxcIpaFaRh0SE3j0QEDAbjh+BMZv3RRhck/yeXkhTkzWZi5o8wxP2/ZwotzZ+k5gFp2dJ9uHN2nW32HoVWiusl/LPCRiIwGtgJXA4hIX+B2pVTlu4NotUYpBeHFqOD3ID7EcxniaI9lhWDvQHt46IDAFKyUP2IkjarStbL9fpymGTch78ovv2XkoaW67UVUs7dvY/2+bLpnNKd/+w4lC4Sa+3x8cc1Ifjd1Mot3ZZZ5rdfh4M4+p/HC3Fkxi7wC0f9v786DpCrPPY5/n9Pd07Mww+KwbyOIC0ERGUABY4wIShRcULmIwk3UEnM1GkNhldate3NNMJYxlURj4jUpcblBRRRFVjUuKMgSEUTDGsIyMCCLMvQM08tz/+gDztKzMXT3mennU9XVp/u80+fH0PP06XPe874RZn++zoq/MTSz+KvqARKcxFXV1UCtwq+qzwLPNmebpnFUFf16BlQsJj7+vh8tewoteBjCq6oX/uOO/JJYzk04TtNHVDyjfQeisdqnaQKOw8heRU1+PRFheM9edX5j6Nm2La/eOIl5G7/kkWXvsz8UoiAY5K7iYUwdOIhfffxhwp+rORqnMZnKDn62VpUfuoX/eO+fcPz2zYPEZ/BKRKF8HuTdhIY3xq8ajmyDrAuQvH9HfHVfeZkTCPCz4SN57OMPTxRYv+OQHwxyx+DG9fRYunULT61eyf5QGcO69+Qnw4bTs239ffLHn3UO4848m8poND4shPvtYGDnLqwt3VutrQDDuvdg+c4dKFDcrXvSu60a41WizRjjJJmKi4t19erV6Y7RYsUOz4CK12qvkDzQGLWvBnYVPIz4uqOHphG/4jcGBECykdPmIv7e9W73ve3/5Ok1q9h3tIyRvYuYNngondu0aTDvXz5dw6+XLzvxweGI0CaQxVuTbq130pa6fLF/HzfNmU1lNEY4Fv9g8IsTPzHudjoT4ImxV3PxSXwzMcarRGSNqja4x2V7/q2V+ImXtwQf7lnF8W8GtX8IguPRg2OpPlVjGDSKHnkMaf/7ejf7vaLT+V4TZvECqIiEeXzFR9UOycRUORqu5IlVK5h52ehq7Q+Vl/PblctZuHkTWT4fE79zLrcPHlJtL74wN5fbLijm4507iMZiDOrajRfXf0ZFuPqFcHfOn8cHU2/ntCaM6mlMa2DFv5WSnGvQ8vnU3sNXaPs4HLgKYqXVV+U/hEg5Gt1LbTGoXJGUrNsPH8ah9jUgUdUTVxcfVxEJc+3LL7LnyJETPYueXP0Jq/bs5tnx1wOweMtm7luyAFUlEouR5fPhq2PMGFV4a/NGbh046BT/q4zxNiv+rZRkDUFzJ0PoOfeZePGTdr9DfG2JFb4PFXOhYoHb1fMnOP6e7gxedVyM5yRnbtXC3DwqY4m7bXbLr77N+Zs28lUoVK1LaUUkwqrdu/h8Xymnt2vPT5csoKLKt4jySIS1e/ckHMa5Mhrlm2OJZy0zpjWz4t+KOQXT0dwb4NgHILlo1mD06B/Rw/cBfsi5Fmn3BOJ8e8hDJIhmXwEVi6g6yifkQO7UpOQszM3lkt5FvP+v7dW6Z+b4/dxZPLRa2zV7Sk6M6VNVVJXb33ydfUfLEk4AE47FTlwhXFXQ72dkr/rPYxjTGlnxb+XEXwT+IlQrYP8Yt4unu1ccehENfwodZleb+UsK/huNHYLKlSBZ8akdc65DcicnLefjo8cyfeki3t2+Db/j4HccHhx5CSN6Vi/MRW3bEUxwPUFlNErp0bJ6t9EtP58DoXJC7ty+uYEA3z+9DwM7N2/8+JW7d/H7lcvZfvgQ53bqwj3DLrLpHI3nWW+fDKGhueiRn7tDNlchuUj7PyNZg2v/TGQXxErAfwbipGbY3cMV5RyqqKBHfkHCmboOhEJcOuvPlIXrnr83kdxAgD+MHUcoHGbOF5+jKBP6D2BM334nNQPZcUu2bubexd8eZnJECPp8vDRhIgM6dT7p1zXmZFlvHwOAagwql6Gh2bULP4BGIfIPSFD8xd8D6JH8kFW0y86hXXZOnetPy83l/66/kfuXLGT74cOAIkid5wx8IgR8Pq49uz8X9+qNiHDFGf1OSVZV5b/ef7fa+YWYKuWRCDOXvc+L1914SrZjTDJY8W/FNFaGHpwUn9IxUeGHeJdQnzeHz9526CBr9+6hU14bLurR80SPnQGdOrN48lQOhEIEfA73LHyr2rzCx/kdh/8YciGj+vSlf8dao403W1llJV+FEv9e15WWJnzeGK+w4t+KadlvILKV+NW9ifjBKYSs4amM1aCYKtOXLmLB5k34HEGIT5o++/qbqs3Cdbxv/r0XDmdlya5qe+A5fj+3DhzEPcMuSlrOnEAAv+MQSTC8dKFdN2A8zibMbM3K36Tewp81Eunw1/hELh7y8ob1LNqyiWPRCKFwmKPhMHvLyrhrwZsJ25/fpSvPXH0tZ51WiADts3O4e+hFTB9+cVJz+h2HSQPOI7vGENE5fj/TavRSaglUlc+Xfcn/znieFx6eQ8nWRNd7mNbC9vxbtbpO5jvQaTmO4825bJ9ft7bWAGwxVTYf+IqSI9/QLb/2cA/De/Zi4c0nNyJpc8wY8V3KIxHmfrkBv+MQU7hryFBu6D8g5VmaQ1V5dOoTLJv7CRWhY/j9Pv468zXu+cNtjJlyabrjmSSw4t+aZV8J5a9Sfe/fgcBgzxZ+oNrhm6ockTrXpUvA5+MX37+cB0Z8l/2ho3TLzyfbH0h3rCZbveSzeOE/Gr/gLRKOQjjK76Y9w4jxQ2nTLi/NCc2pZod9WjHJvx98PUDc48+SC9IOaTszvcEa8IN+ZyYcbTM/GPTsVIz5wSB92ndokYUf4L3ZH50o/FX5Ag5rlnyWhkQm2WzPvxUTpy0Uzodj76LhfyD+npB9JSJ1d6X0gtsvGMKCLZvYe6SMUCRMwPHhd4THR49tVp98U7dA0I+IUPO6H0HwBbx1TsicGlb8WzmRAGSPQbLHpDtKo+UHg8z/t1uYv2kjH+3cQY/8AiYOOO+khnY2jTPqlkt4+4UPOBaqfvFcLBZj8OiBaUplksmKv/GkbH+ACf0HMCEFJ05D4TC7v/maFbt30SaQxag+fckPBpO+XS8ZMOJsrr/vKub8Ot6jyvE5qMJ/vnI/OXlNn9nNeF+zhncQkQ7AS0ARsB24UVUPJWgXBda7D3eo6riGXtuGdzDJtvHAV8x4ezHrS/eixE8oZ/t8IMLTV13TpEnnW4uSrXtZtWgt2XlBRlxjJ3pbosYO79Dc4v8ocFBVHxGRB4D2qjojQbsyVW14OqcqrPibZDpYHuLSWX/hSGXi4ZzbZGWx6rZpBP325di0LI0t/s3t7TMemOUuzwKuaebrGZMSr36xgXAd4wEd99HOHSlKY0zqNbf4d1bVPQDufV0DqGSLyGoRWSEi9gFh0m7LoQMNXjMQaeDDwZiWrMHvtCLyNpBowPMHm7CdXqpaIiJ9gHdFZL2qbk2wrTuAOwB69cq8460mdQZ27sr8TZsojyQe/iISi3FRD3sPmtarwT1/VR2lqgMS3OYBpSLSFcC931fHa5S499uA94CEE6aq6tOqWqyqxR072mQYJnnGn3UOBcEg/hrXDQiQ7fcz87LRGdfjx2SW5h72eQM4PqDKFGBezQYi0l5Egu5yITAC+KKZ2zWmWfKysnhj4mTGnXUO+VlBCoJBzuvchR8PGcaim6cw/qxz0h3RmKRqbleGR4CXReRHwA7gBgARKQbuVNXbgHOAP4lIjPiHzSOqasXfpF3HvDweG31lumMYkxbNKv6qegC4LMHzq4Hb3OWPgXObsx3jDRotgdgR8PdFxLpAGtOS2V+waZBGS9HDd0P4SxAfEEALHsbJaTlDRhhjqrPib+qlquihH0JkGxD9doqAr6ej/t5I4Oy0Zfvn4UOsL91L1/x8irt2R2zQN2MazYq/qV9kA0R3AzX7vFeioeeRtr9IeaRoLMbPli5k0ZbN+B0fitK1TT4vXncDnfKadCG5MRnLxvM39YvuJ/HbJAbRklSnAeCF9Z+xZOsWjkWjHA1XEgqH2X74EPcuWpCWPMa0RFb8Tf0C54JWJliRDVkjUx4H4Pl1n9aa5jGqyt/3lnCwPJSWTMa0NFb8Tb3EVwi5t0K1CWCywOmA5N6Ulkzl4cTDMgjem+bRGK+y4m8aJPnTkYKZELgAfH0h74dI4euIk57j66P7nkHAqf3W7ZiXS9c2+WlIZEzLYyd8TYNEBHLGIjlj0x0FgLuHXsjSbVs4VF5OeSRCwHEI+Hw8dvmV1uPHmEay4m9anA45uSy+eSpzv9zAit27KGrXjkkDBto0j8Y0gRV/0yLlZWVxy8BB3DIw4RiBxpgG2DF/Y4zJQFb8jTEmA1nxN8aYDGTF3xhjMpAVf2OMyUBW/I0xJgNZ8TfGmAxkxd8YYzKQFX9jjMlAoqoNt0oDEdkP/CvdOYBC4Kt0h6iDV7N5NRd4N5tXc4F3s3k1F6Q3W29V7dhQI88Wf68QkdWqWpzuHIl4NZtXc4F3s3k1F3g3m1dzgbezHWeHfYwxJgNZ8TfGmAxkxb9hT6c7QD28ms2rucC72byaC7ybzau5wNvZADvmb4wxGcn2/I0xJgNZ8U9ARDqIyFIR2ezet0/QpreIrBGRtSKyQUTu9Eiu80VkuZtpnYgkfZb1xuRy2y0SkcMiMj8Fma4QkY0iskVEHkiwPigiL7nrPxGRomRnamSu74rI30UkIiITUpGpkbl+KiJfuO+pd0Skt4ey3Ski692/xWUi0t8Luaq0myAiKiLe6v2jqnarcQMeBR5wlx8AfpWgTRYQdJfbANuBbh7IdSbQz13uBuwB2qU7l7vuMuBqYH6S8/iArUAf9//pM6B/jTZ3AX90lycCL6XgfdWYXEXAecBzwIRkZ2pCrkuBXHd5Wip+X03IVlBleRywyAu53Hb5wAfACqA4Fb+zxt5szz+x8cAsd3kWcE3NBqpaqarH3IdBUvMtqjG5NqnqZne5BNgHNHjBR7JzuXneAY4kOQvAUGCLqm5T1UpgtpuxqqqZ5wCXSfJnf28wl6puV9V1QCzJWZqa62+qGnIfrgB6eCjbN1Ue5gGpOJHZmPcYwP8Q3zmqSEGmJrHin1hnVd0D4N53StRIRHqKyDpgJ/G93RIv5KqSbyjxvZKtXsqVAt2J/58ct8t9LmEbVY0AXwOneSBXOjQ114+AhUlN9K1GZRORH4vIVuKF9h4v5BKRQUBPVU36Yc6TkbETuIvI20CXBKsebOxrqOpO4DwR6Qa8LiJzVLU03bnc1+kKPA9MUdVm70WeqlwpkmgPvubeYGPanGrp2GZjNDqXiEwGioFLkpqoyiYTPFcrm6o+CTwpIpOAh4Ap6cwlIg7wG2BqknOctIwt/qo6qq51IlIqIl1VdY9bRPc18FolIrIBuJj4IYS05hKRAuAt4CFVXdGcPKcyVwrtAnpWedwDqPmt7HibXSLiB9oCBz2QKx0alUtERhH/sL+kyiFPT2SrYjbwVFITxTWUKx8YALznHk3sArwhIuNUdXUK8jXIDvsk9gbf7jlMAebVbCAiPUQkx11uD4wANnogVxbwGvCcqr6S5DyNzpViq4B+InK6+/uYSDxjVVUzTwDeVfcMXZpzpUODudxDGH8CxqlqKj/cG5OtX5WHPwA2pzuXqn6tqoWqWqSqRcTPk3im8APW2yfRjfix33eIv4neATq4zxcDz7jLlwPriJ/lXwfc4ZFck4EwsLbK7fx053IffwjsB8qJ7zmNSWKmscAm4uc7HnSf+znxP0CAbOAVYAuwEuiTovdWQ7mGuL+bo8ABYINHcr0NlFZ5T72RilyNzPZbYIOb62/Ad7yQq0bb9/BYbx+7wtcYYzKQHfYxxpgMZMXfGGMykBV/Y4zJQFb8jTEmA1nxN8aYDGTF3xhjMpAVf2OMyUBW/I0xJgP9P4pB20he5+f2AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "Z = autoencoder.transform(iris.data)\n", + "plt.scatter(Z[:, 0], Z[:, 1], c=iris.target)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/books/PRML/PRML-master-Python/notebooks/ch13_Sequential_Data.ipynb b/books/PRML/PRML-master-Python/notebooks/ch13_Sequential_Data.ipynb new file mode 100755 index 0000000..8c511b5 --- /dev/null +++ b/books/PRML/PRML-master-Python/notebooks/ch13_Sequential_Data.ipynb @@ -0,0 +1,615 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 13. Sequential Data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "np.random.seed(1234)\n", + "\n", + "from prml.markov import CategoricalHMM, GaussianHMM, Kalman, Particle" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "gaussian_hmm = GaussianHMM(\n", + " initial_proba=np.ones(3) / 3,\n", + " transition_proba=np.array([[0.9, 0.05, 0.05], [0.05, 0.9, 0.05], [0.05, 0.05, 0.9]]),\n", + " means=np.array([[0, 0], [2, 10], [10, 5]]),\n", + " covs=np.asarray([np.eye(2) for _ in range(3)]))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "seq = gaussian_hmm.draw(100)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 10))\n", + "plt.scatter(seq[:, 0], seq[:, 1])\n", + "plt.plot(seq[:, 0], seq[:, 1], \"k\", linewidth=0.1)\n", + "for i, p in enumerate(seq):\n", + " plt.annotate(str(i), p)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "posterior = gaussian_hmm.fit(seq)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 10))\n", + "plt.scatter(seq[:, 0], seq[:, 1], c=np.argmax(posterior, axis=-1))\n", + "plt.plot(seq[:, 0], seq[:, 1], \"k\", linewidth=0.1)\n", + "for i, p in enumerate(seq):\n", + " plt.annotate(str(i), p)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "categorical_hmm = CategoricalHMM(\n", + " initial_proba=np.ones(2) / 2,\n", + " transition_proba=np.array([[0.95, 0.05], [0.05, 0.95]]),\n", + " means=np.array([[0.8, 0.2], [0.2, 0.8]]))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "seq = categorical_hmm.draw(100)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "posterior = categorical_hmm.forward_backward(seq)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "hidden = categorical_hmm.viterbi(seq)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAD8CAYAAACb4nSYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJztnXd4XMXZt+/Zot4sq1i2JNuy3BvYBkzvAQMxCZBg3gQCIZBGki+NkkISwhsICR9JvvASCClvCKFDMMaY3gIGXHBv2HKRbDVb1Wpbznx/7K68Wm3T6kir1T73dfny7tk5c56dPfrt7G+emVFaawRBEITkwBLvAARBEIThQ0RfEAQhiRDRFwRBSCJE9AVBEJIIEX1BEIQkQkRfEAQhiRDRFwRBSCJE9AVBEJIIEX1BEIQkwhavCxcUFOhJkybF6/KCIAgJybp16w5rrQtjPT9uoj9p0iTWrl0br8sLgiAkJEqp/YM5X+wdQRCEJEJEXxAEIYkQ0RcEQUgiRPQFQRCSCBF9QRCEJEJEXxAEIYkQ0RcEQUgiRPQFQRCSCBF9QRCEJEJEXxAEIYkQ0RcEQUgiRPQFQRCSCBF9QRCEJCKi6Cul/qqUalBKbQnxulJK/UEptVsptUkptcD8MAVBEAQziKan/3fgwjCvLwGmev/dCDww+LAEQRCEoSDievpa63eUUpPCFLkU+IfWWgMfKKXylFIlWuvaqCJor4OGbVEV7YM1BcpOAqt94OcKgjD6adoLzXvjHYU5FM+FrJj3TemDGZuoTACq/Z7XeI/1E32l1I14fg1QXl7uOVj1Njx3Y2xXvuzPMO/zsZ0rCMLo5h9LoeVAvKMwh2X/ghkXm1KVGaKvghzTwQpqrR8CHgJYtGiRp8yUc+DLLw/sit2t8K/Pe/4XBEEIRlcrzLoUFn8j3pEMnoJpplVlhujXAGV+z0uBQ1GfnVXY+7PF4TJ4dVs9eRl2FpSPIT3FGvycrmbP/4YrpoAFQUgCDBfklkH54nhHMqIwQ/SXAzcppR4HTgJao/bzvWiteWlLHfes2sG+I50A2K2KeaV5XHvKJD49f3zfEyxeH9/tHHz0giCMTgwnWOK2DfiIJWKLKKUeA84CCpRSNcDPADuA1vpPwErgImA30AlcN5AANte08rPlW1h/oIXpxdk8fM0irBbFB3uP8Nq2er735AZmluRQWZR17CTfB2mI6AuCEAK3iH4wosneuSrC6xr4ZqwBNHc6qGnu4teXz+WKhWVYLZ4hgrNnFHHD6RWce+/b/Oi5zTxx42KU8g4f+DJ2DHeslxUEYTRjGIA2Nbtv1ZY66lq7yEy1kZVqY+HEMRTlpEV9/v4jHfzPm3s41NpFY3sPHQ4XP714Fp+aPa5POa01TrcmxTY0c2fj/jV4xrRC3rn5bNLs/f37gqxUblsyg1uf3cxT62r4/CLv0IHFCiixdwRBCI7PBTCpp//cxzV894mNfY4V56Ty6vfOJCct8heLYWi+8/gGdta1M604i7L8DPYd7uA7j2/g2W+cwsySHABcboObn97Eik21nDuziM8cP4GzpheSagsxvhkDI2IZhmCC7+Pzi8o4YdIYfrVyO0eO9hx7wWoXe0cQhOD4OoQD6Onvqm/na4+s47q/fURr1zFtOXCkk5/+eyuLJo5h7U/O492bz+YvX1pEQ3sP9768M6q6n1hbzYbqFv77s3N4/qbT+PM1i3j0KyeRk27jhn+spanDgdNt8O3HP+bZjw9y5vRC1uxr4quPrOPE/36dN3bUD+jth2NEiH44LBbFrz47l44eF79aucPvBZtk7wiCEByfNkTR069p7uT7T27kgt+9w3u7D/Pe7iNc+eBqGtq6e4VYKfjdsuMoyEqlLD+Dc2cWc83iifzjg/1srG7prau108ldK7ezbn9z77GmDge/XrWDEyfn89njJ/QeL8pJ46GrPV8e33h0Hd94dD0rN9fxk4tn8udrFvHBbefy9+tO4OzphVQWZpvWNCNe9AGmFmfz5dMm88z6Ghrbvb19ix3cIvqCIAShV/TD9/R7XG4+c/97vLDpEDecXsE7N5/NX689geqmTi574H1+8twWNlS3cNdlcykdk9Hn3O9fMJ3CrFR+9NxmXG6DT+rbufT+//DgO1Vc+eBqHn63Cq0196zaQXu3i19eOufYuKSX+WV53H3ZXD6oauLVbfXccelsvnJ6BQA2q4Wzphfxu2XHUz6277UHQ9w9/Wg5vbKQB9+uYnfDUQqzU8FqE3tHEITg9No74SXu/d1HOHzUwcPXLOK8WcUAnDa1gMduXMy1f1vDE2ur+fyiUi6ZN77fuTlpdn6+dDbfeHQ9P3hqI69uqyc9xcbfrjuBxz86wJ0vbuf17Q2srjrCDadPZvq44L31yxaU0uV0k5eewsXzSgb3vqMgYUS/ojATgKrDRzl5yljPzzYZyBUEIRhRDuS+sq2OrFQbp08r6HN8XmkeT3/tZJ5df5CvnzUl5PlL5ozj7OmF/HvDIeaV5vLg1QspyU3nrGmF/OU/e7n7pR0U56TynfPCz6j9wkkTo3tfJpAwoj8uJ410u5Wqxg7PAYtdUjYFQQhOFPaO29C8uq0+ZHZMRWEWP7hgetjLKKW454r5rNxcy5UnlPUmpSil+MrpFZwxrRC71UJW6siR2pETSQQsFsWkgkyqGo96Doi9IwhCKHzjfWGyd9YfaObwUUe/PPmBUpidypdOmRT0tWnF5g3AmkVCDOT6qCjMpOqwr6cv9o4gCCHotXdCp4O/srUOu1Vx9nRzlixOFBJK9KcUZFLd1EmPy+21dyR7RxCEIESwd7TWvLy1nlOmFJAdxeSq0URCiX5FYRaG9kyW8Ng7IvqCIAQhgr2zs76dA02dXDBIaycRSTDR92Tw7GnsEHtHEITQRLB3Xt5Sj1Jw3qyiYQxqZJBQoj+54Fjaptg7giCEJIK98/LWOhaUj6EoO/oF00YLCSX62Wl2irJT2dvY4V17R0RfEIQghFl7p7qpk221bVwwu3iYgxoZJJTog18Gj8Uq9o4gCMEJs/bO1kNtACyuGDucEY0YEk70JxdkeXL1xd4RBCEUYUS/pdMBeJZuT0YSTvSnFGbS3OnEgVUmZwmCEJww9k6TV/THZKQMZ0QjhoQTfV8GT4cTWWVTEITghFl7p7nDQZrdQnqKeRuTJBKJJ/oFnr1yjzqV2DuCIATHty5XkOyd5k4n+Unay4cEWnvHR+mYdOxWRZsD0GLvCIIQhDBLKzd3OBiTmbyin3A9fZvVwsSxmbT2GGLvCIIQnDD2TlOnI2n9fEhA0QeoKMikpQexdwRBCE6YyVktnU7p6ScaFYVZtHRrtGTvCIIQjDBr7zR1OMjPSK5F1vxJTNEvyKRHWzFcIvqCIAQhhL3jchu0dTvJE3snsagozMSNBS0zcgVBCEaIyVmtXU60hnyxdxKLsvwMXMjSyoIghCCEvdPsm5glop9YpKdYcWLFokX0BUEIQgh7p7nTc3yMePrhUUpdqJTaqZTarZS6Ncjr5UqpN5VSHyulNimlLjI/1GOk2624sWDRbtB6KC8lCEIi4naCsoJSfQ43dST3EgwQhegrpazA/cASYBZwlVJqVkCxnwBPaq2PB5YB/2N2oP7YrRbcvnllYvEIghCI4QqaudPcIfZOND39E4HdWusqrbUDeBy4NKCMBnK8j3OBQ+aFGALfByqDuYIgBGK4Qi7BAMgyDBGYAFT7Pa8BTgoo83PgFaXUt4BM4DxToguDxWoDA1lpUxCE/ridQbdKbO5M7sXWILqevgpyLNBIvwr4u9a6FLgIeEQp1a9updSNSqm1Sqm1jY2NA4/Wvy5fT9+3sJIgCIKPMPZOMvv5EJ3o1wBlfs9L6W/fXA88CaC1Xg2kAQWBFWmtH9JaL9JaLyosLIwtYi9K7B1BEEJhOEPYOyL60Yj+GmCqUmqyUioFz0Dt8oAyB4BzAZRSM/GI/uC68hGw2Hw9fRF9QRACcLuCL7bW4UjqiVkQhehrrV3ATcDLwHY8WTpblVJ3KKWWeot9H7hBKbUReAy4VuuhzaW09No7kr0jCEIAhivossotnU7ykjhHH6JcT19rvRJYGXDsdr/H24BTzQ0tPBab99tallcWBCGQEPZOU6f09BNyRi6A1ebL0xd7RxCEAILYO25D09rlFE8/3gHEitXX0xd7RxCEQILYO77F1pJ5CQZIaNGX7B1BEEIQxN5pktm4QAKLvk16+oIghMLt7GfvtHTKujuQyKKfIqIvCEIIDHe/yVm+nr4M5I4gvvzlL1NUVMScOXMiPr75hz8C4Lof/LL3tWjrNqPcYN/TUF4zltjCvWZGuVhiiKVcrAzX527G+42lDjPen5n371C2N+C1d2x9Xrt+6ZlAX3snls8plnLhjg+0HDA7pkbyMqJE/9prr2XVqlVRPVbeJVO/sPS83teirduMctES6n0M5TWjJdx1o4l7IOViiSGWcrEyXJ+7Ge83ljrMeH9m3r9D2d5AH3vH95rb8Ewd8h/IjeVziqVcuOODLTdQRpTon3HGGeTn50f12Cf6J8yb3vtatHWbUS5aQr2PobxmtIS7bjRxD6RcLDHEUi5WhutzN+P9xlKHGe/PzPt3KNsb6GPv+F5za02qzUK63Rr0PLPv+Wjba7DlBsqIEv0B4RV9p6MnzoEIgjDiMPoP5LoNTX5mSm+HMVlJWNH3fXBOpyPOkQiCMOJwO/sN5LoNTV6SZ+7AqBB9ydMXBCEAo/+MXMPQ5Gcm98QsSGjR94TudIq9IwhCAEF2znIbOulz9AHQWsfl38KFC3Ugy5Yt0+PGjdM2m02np6fr3NzcsI8nZCs9d9rE3nMmTJigH3744X71BtZtRrloCfWe/Os2+5qxxBZ43WjiHki5WGKIpVysDNfnHm0bRfvZRFtHLJ9NtDHF0nZD2d4TJkzQD19RpPXyb/d5DYtVZ48tiur+NeOej7a9TjzxxAGVw7NnYA1wvY5Be5Ue2hWQQ7Jo0SK9du3amM/fuXsX0/95AlsX/JzZS79rYmSCICQ8v54Ecy6Hi+8FPL38yh+v5FvnTOV750+Lb2yDRCm1Tmu9KNbzE9beSUlJA8DtEk9fEIQADHcfe6fNu9hafpIvtgYJLPppqakAuCV7RxCEQNzOPqtsNnXKYms+Elf0vWvvuF0i+oIgBBCQp9/cIYut+Uhc0U/z2Tuy4JogCH5o3S97p7nTYwOL6Cew6Kd6e/qGePqCIPhjuD3/+03O6u3pS55+4oq+xWrFrRWGW+wdQRD88G2hajm2xk5zpyyr7CNhRR/ApWwYYu8IguCPb48NP3unqdNBSsBia8lKYos+VrT09AVB8Me3haqfvbOzrp2S3LSkX2wNElz0DawYbunpC4LgR29P35O909DWzbufHObiuSVxDGrkkNCi71Y2tIi+IAj+BIj+cx8fxG1orlhYGsegRg4JL/q9gzaCIAjQx97RWvP0uhoWThxDRWFWfOMaISS06GtlPfYBC4IgQJ+e/qaaVj5pOCq9fD8SWvQ9PX2xdwRB8MNP9J9eV0OqzcLF88TP9xGV6CulLlRK7VRK7VZK3RqizOeVUtuUUluVUv8yN8zgaIvYO4IgBOD99e/AyvKNh7hwzjhy0mRSlg9bpAJKKStwP3A+njWc1yillmutt/mVmQrcBpyqtW5WShUNVcD+GMqGRXr6giD44+0IbjzYSWtXilg7AUTT0z8R2K21rtJaO4DHgUsDytwA3K+1bgbQWjeYG2YILLZjU64FQRCgVxP+U9VESW4ap0wpiHNAI4toRH8CUO33vMZ7zJ9pwDSl1HtKqQ+UUheaFWA4tMWGRUtPXxAEP7z2zvb6bs6dWYTVIhOy/Ilo7wDBWixwuy0bMBU4CygF3lVKzdFat/SpSKkbgRsBysvLBxxsPyx2lHZ6tgCTmXaCIECvvdPmhLnZaXEOZuQRTU+/Bijze14KHApS5nmttVNrvRfYiedLoA9a64e01ou01osKCwtjjfkYFhs2DBxuY/B1CYIwOvCO87m0RTZNCUI0or8GmKqUmqyUSgGWAcsDyvwbOBtAKVWAx+6pMjPQoFht2HDT7RDRFwTBi3eWvgubrKoZhIiir7V2ATcBLwPbgSe11luVUncopZZ6i70MHFFKbQPeBH6otT4yVEH7UFY7Nlx0OWUwVxAEL157x4lVNk0JQjSePlrrlcDKgGO3+z3WwPe8/4YNZbVhx023iL4gCD68A7lurNLTD0JCz8hVVjtWDOnpC4JwDK+n78QqO2UFIcFFPwW72DuCIPjjG8gVeycoCS36Ft9Aroi+IAg+vPZOWmoKdmtCS9yQkNAtYrWlYFWGiL4gCMfw9vSz0tPjHMjIJKFF32Kze+wdSdkUBMGHT/QzRPSDkdCib7XZxd4RBKEvXnsnJ0Nm4wZjVIi+DOQKgtCLt6efnZER50BGJlHl6Y9UrPYUtPT0BUHwxzs5KydLevrBSOievk3sHUEQAnA6HADkZoqnH4yEFn2rLUXsHUEQ+tDt6AFgjIh+UBJa9LHYsSpNV4+sqS8Igofu7h4c2sqYrNR4hzIiSXDRtwLgdPbEORBBEEYK3T09su5OGBJb9K2edTV8Hp4gCILD4ZAVNsOQ2KJv8Yi+Q0RfEAQvDkcPLunphySxRd/b03eJvSMIghen04ELG7npssJmMBJb9L2evsMpPX1BEDw4nQ4MZZUN0UOQ4KLv9fSdzjgHIgjCSMHtdGKohJ53OqQktuh77R1DevqCIHhxOR1oi4h+KBJb9L0frMsloj8UrNnXxBNrDsQ7DEEYEIbbgRLRD0lit4z3gxV7x3wOH+3hq4+so7XLyfmzxkkmhJAwuF0uSJVB3FAkdk/fZ+9IT99UtNb85LkttHY5cRuaVVvq4h2SIESF1hrtdqKsIvqhSGzR9/b0DZf09M1k+cZDrNpaxw8+NZ2KgkxWbDoU75AEISqO9riwahcWa2KbGEPJ6BB9twu3oeMczOigvq2b25/fyvHledx4RgWXzCvhg6ojNLbLXAhh5NPc4cSGgcUmdmQoElv0vT/h7LK8smnc/vwWup1ufvu5+Vgtikvmj8fQsGpLbZ9yWw620topv7CEkUVTpwObcmG1ib0TisQWfW9P36ZcsryyCWiteXNnI1edWM6UwiwAphVnM604ixc2HRP9j/Y2sfSP/+Gel3fEK1RBCEpzhwM7bmx2Ef1QJLjoez5YGwZdDhH9wdLc6cThMijP77vN3MVzx7NmXxP1bd00dzj4zuMfY2h4eWud2GrCiKKpw4EVNzabLKscisQWfe9gjQ0XPS4R/cFS29oFQElu323mLplfgtawYlMtP3x6E4eP9vC1M6dw+KiDtfua4hGqIASludOBDTf2FPH0Q5HYou+zd3DT5TDiHEziU9/WDcC4ANGfUpjFzJIc7nt1F69tr+fWJTP51jmVpNgsvCTpnMIIoqnDgV2JvROOqERfKXWhUmqnUmq3UurWMOWuUEpppdQi80IMg5+90y09/UFT2xpc9AEumVfC0R4X584o4sunTiIz1cYZUwt5eWsdhlg8wgihudNBijJQFhH9UEQUfaWUFbgfWALMAq5SSs0KUi4b+DbwodlBhsTqE32XePomUNfajUVBYZBt5padUMY1J0/kN5+bj1Ke1QuXzBlHbWs3G2tahjtUQQhKU4dH9JHJWSGJpqd/IrBba12ltXYAjwOXBin3S+AeoNvE+MLjXVrZrmRzdDOoa+2mKDsNm7X/bTE2K5U7Lp3TZzmG82YWY7MombEbBK019726ix11bfEOJalo7nCSoty92iD0JxrRnwBU+z2v8R7rRSl1PFCmtV4RriKl1I1KqbVKqbWNjY0DDrYf3p9wVgzJ0zeBurZuioNYO6HIzbBzSmUBL22pQ2uxePz5uLqF37/+CV//53o6Ha54h5M0ePL0jV5tEPoTjegH24mg9y9cKWUB7gO+H6kirfVDWutFWutFhYWF0UcZit7JWS4RfROobe2mJCd60QePxXOgqZPtte1DFFVi8uKmWmwWxb4jHdz54vZ4h5M0NHc4sOESeycM0Yh+DVDm97wU8F+MJRuYA7yllNoHLAaWD8tgbp/sHRH9wVLf2h10EDcc588qxqL6z9hNZgxDs3JzLWdNL+TG0yv414cHeH17fbzDGvUYhvakbGp3rzYI/YlG9NcAU5VSk5VSKcAyYLnvRa11q9a6QGs9SWs9CfgAWKq1XjskEfvj/WCtuOl2ScrmYGjvdtLe4xqw6BdkpbJoUj5v7GwYosgSj4+rm6lt7eaSeeP53qemMbMkh1ue8cxvEIaOtm4nhgYLIvrhiCj6WmsXcBPwMrAdeFJrvVUpdYdSaulQBxgWv7V3pKc/OHw5+oETs6JhSmEm9W0iaD5e2FhLis3CuTOLSLVZ+d2Vx9HW7eJXYvMMKU0dniXWLVrsnXBE9XWotV4JrAw4dnuIsmcNPqwo8Q7WpFkMyd4ZJHWtHtEeN0BPHyAn3U5rpxOtdW86Z7LSa+1MKyQ7zXN/Th+XzXkzi9ggqa1DSnVzF6CxaLcM5IYhwWfketKy0qxaBnIHiW8JhoHaOwB56Sk43PLFC7B2fzMN7T1cPK+kz/GS3HRqW7oly2kIWb7hEHmp3k6H2DshSWzRVwosNtKsIjiDpc47G7c4hp5+brqnV9XaJUstv7jpEKk2C+fOLO5zvCQ3jS6nm7YuSd8cCjp6XLy0pZZLZnuzAmUTlZAktugDWOxee0cGcgdDXVs3+ZkppNkHPqklL8Mj+i1Jvr6+29Cs3FLHOTOKyErtKzoluekA1LZ1xSO0Uc+qLXV0Otx8dn6R54DYOyEZBaJvI9Uik7MGS11rd0y9fIA86ekDsHZfE41BrB04Zpv51jcSzOXpdTWU52ewoNSzD4TYO6FJfNG32siwaRpkO79BUdfWHVPmDngGckF6+nsaOwBYNDG/32u+tq1tEdE3m5rmTlZXHeHyBaUow9v5E3snJIkv+hY7Y9IUVY1HZZBsENTFMDHLh8/eaUvynn5Llydl0Nce/hRlp2JRUNcq9o7ZPLf+IACXLZgAhvceFHsnJKNA9G3kpSrau10cPuqIdzQJSY/LzZEOR0zpmnBsINcneslKS6eTNLsl6LiIzWqhKDtN7B2T0VrzzPoaTpqcT1l+Brh9oi89/VAkvuhbbeR607T2NB6NczCJSYN3YlWsPf2sVBtWi0p6e6el00Feeugdm8blplHXJqJvJuv2N7PvSCdXLCz1HOi1d6SnH4rEF32LnWzv35mIfmz4ep+xevpKKXLT7Uk/kNvS6Qxq7fgoyU3jUIvYO2by2vYG7FbFkrnewXNDevqRGAWibyPdYpCRYmVPQ0e8o0lIeidmxWjvgCeDpyXZRb/L2Wt1BWNcrsfekbEn82hs76EwK/VYiqzYOxFJfNG32lHazeSCTOnpx0iovXEHQm6GPekHcluj6Ol3Oty098gELbNo6XQwxm9jHwxv24q9E5LEF32LDdxOphRmiejHSG1rN1mptt61YmIhN90unn6XgzEZoT193wStOhnMNY2mzoA294m+ZO+EZHSIvuER/YMtXbLaZgx4Jmb13xd3IHjsHcneyY3Q0weZoGUmLZ3Ovj39XntHtksMReKLvtUOhospRZloDXsPi68/UDwTs9IHVUeud6XNZKXL4abHZUTM3gGolcFc02jqcDDG/4tW7J2IJL7oW2zgdjGl0DP9WiyegTOYiVk+cjNSaOt24TaSc5Ay3MQsH8U5aSglPX2zcLkN2rqdAfaOTM6KxOgQfcPJ5IJMlBLRHyhuw7OExWAyd+DY+jvt3cnZ2/eNZ+SFyd6xWy0UZqWKp28SrV1OtKZvT9/t8/QleycUiS/6XnsnzW6ldEx67/onQnQcPtqD29CD7+kn+fo7vvcdztMHj69fKxO0TKG50/PrKnj2joh+KBJf9C323m/3KYVZ7GmQnv5A2FXfDsQ+McuHz9ZI1glarT57J4ynD95cffH0TaHZ+0Wbnyn2zkAYBaJv7f2gpxRmsfdwB0aS+soDxTA0976yi6LsVBZXjB1UXcfW30lO0ff19MdkRurpp4u9YxK+PXH7ePpi70Qk8UXfa++AR/S7nG75+RwlyzceYkN1CzdfOIPM1MH9kRzbSCU50zZ9X3bR9PTbe1xJO/ZhJi1i78RE4ou+xd6bm1tRmAkgFk8UdDpc3P3SDuZOyOWy4ycMuj7fmvrJOiu3pdNJis1Cmj38n5TPRquXjsmgaerw/rrqk7Ip9k4kEl/0rbY+PX2QDJ5oeOidKuraurn907OwWNSg65OBXAd56XaUCt+WvvkQh2QzlUHT0ukg1WYh3X8pa9/kLMnTD0nii77lmOgXZKWQk2YT0Y9AbWsXf3p7DxfPK+GESf13eYqFVJuVjBRr0g7kRlph04evpy++/uDxTMxK6ftF61taWTz9kIwC0T9m7yilyGrcwh++dgmVlZVcd911TJ8+ncrKSu6+++4+p61atar3tVDl/MvcfffdIc8JPD/wvFCEKmfGdcOV++kf/0nV/9zAiz/5XNjrDjTu3ICVNsO1cSzvfbBtZEYMoepb/dzDdFetj9h+Rd7lLnwTtKK5DyN9NtHWEc05sbZRtPGY2eZvPflnXAc+7luf195Z9dpbMbVlNO0Vy9+GWXWYgtY6Lv8WLlyoTeGlW7X+VanWWmuXy6Vzi0v13O/9Q3d2duqUlBS9atUq3dPTo+fNm6e3bt3aW66iokLv2bMnZDn/Mj09PXru3Lm6rKys3zmB5/uXC7yuP4H1m3ndSOWy8ov1opv/Gfa6A41ba60vuO9tff3f10Rs41BtFO69D7aNzIghXH2ZJRU6M784YvtprfXCX76ib31mY1T3YaQ2j7aOUJ+hGW0UbTxmt3nO+Ck6Y0xR3/r+cYt2/TRbV0yeHDG+SJ9TNPd8tOXMqMMHsFYPQntHQU/f2tvT/+ijjyibOJk2ez4/+NO/KS8vZ/369aSkpLBs2TKef/753nKVlZVUVFSwYcMGJk6c2K+cf5mUlBROPfVU0tLS+p0TeL5/ucDr+hNYv5nXjVQOm53Jk8Nfd6Bxg6en7xvIDdfGodoo3HsfbBuZEUO4+jLLZmFPSY3YfuDx9Q954lhaAAAd8klEQVS1dEd1H0Zq82jrCPUZmtFG0cZjdptnlQdp83c38tFBN5WVUyLGF+lziuaej7acGXWYxSgQ/WMpmwcPHuSEOVO56sQynnx7E132XKpragAoLS3l4MGDveXKysp6H48fP773NV85/zIANpsNm83W75zA8/3LBV7Xn8D6zbxupHIGll6bIdR1Bxo3eNI2fWvQhGvjUG0U7r0Pto3MiCFcfQ5DYbfb+9UXjHG5adS1dkd1H0Zq82jr8CfUObG2UbTxmN7mOkibN7ZwsF1TVlYeMb5wbRSqvaJt11ivG0t8AyUq0VdKXaiU2qmU2q2UujXI699TSm1TSm1SSr2ulJpoapThsNo9Pp7vp4tS/Oqzc7lkXgmHj/bwxo6G3uWWfQM+2m/nIt9j/8EgpVTQ3Y0Cz/cvF3h+sPP8CVW/GdcNV05rjcvou0tWpOtGEzd4ctR9A7nRtHFgHdHEEGsbmRFDqPq6nW5chsZqify5g3cphtauqNsompgi1eFPqHPMbKNo44m1zd2Gpsdp9Ms8U1qjURDibzDa+9wfM/42zKjDLCKKvlLKCtwPLAFmAVcppWYFFPsYWKS1ngc8DdxjapTh8I3SG25KS0uprq5GKcWNS04gj6PUuzJ4aUstNTU1jB8/HqC3nO/xoUOHel/zlfMvA+ByuXA6nf3OCTzfv5x/fYEE1m/mdcOV6+xxYLidFHtFP9R1Bxo3eNad8aVshmvjUG0U7r0Pto3MiCFUfa1dTjDcaMPVr75gjMtNo63bRW5BccT7MFKbR3MvBxLqnFjbKNp4zGzzti4n2nAfy9bx1ZefQWmuPar4wrVRqPaKtl1jvW4s8Q2YSKY/cDLwst/z24DbwpQ/HngvUr2mDeS+c6/WP8vR2tGlnU6nnjx5sq6qqtIdHR3anpKix115h77rhU163rx5esuWLVpr3a9c4ODXli1b+pTxDS6Vlpb2OyfwfP9y/vUFEli/mdcNV27azNnamjVWP7ji/bDXHWjcWmv9xzc+0RNvWaG7HK6wbRyqjcK998G2kRkxhKpv0/7D2lYwUY8tKonYflprvbmmRU+8ZYX+9cotQduou7s75P0aWHc093K4z9CMNoo2HjPbfFvNkeBt/qcbtPMX46KKL9LnFM09H205M+rwwSAHcqMR/SuAh/2eXw38MUz5PwI/CfHajcBaYG15eXnYho6a9/7gEf3uNq211i+++KKeOnWqrqio0FdffbVOLyjVOUUT9J133tnntMByvsf+5fzL3HnnnSHPCTw/8LxQhCpnxnVDlbvhu7fpoit+pssmVUS87kDjfmT1Pj3xlhW6rrUrYhvH8t4H20ZmxBCsvgnlk3Te6Vfr3/z5X1G1n9Za3/Sv9Xr6T1bqfz71XO85//WFL+rsojKdV1wa9n6N5V4O9xma0UbRxmN2m9/9UECbv/hDre8qizq+SJ/TQM8x47qRyg2H6H8uiOj/vxBlvwh8AKRGqte0nv7q//GIfseRoC9f85cP9UW/f8eca40Cnl5brSfeskLvbTxqet0vbDyoJ96yQu+obTO97pHMqi21euItK/Tmmpaoz9l/uENX/uhFfcvTG3uP3frMJj3xlhV68q0r9MHmzqEIddTwytY6PfGWFXpTdUCbv/B/tP715PgENUwMVvSjGcitAcr8npcChwILKaXOA34MLNVa90RRrzn4efrBmFyQyb7DHUEHSJKROu+aL8WD3DQlGL7FxpJtVm5r7wqb4Rdb86d8bAZXL57Ek2ur2VXfzpNrq3nsowNcvqAUDTz20YEhinZ00NwRYqcywyXr7kQgGtFfA0xVSk1WSqUAy4Dl/gWUUscDD+IR/AbzwwyDb40NI7jQTBqbQYfDTePR4fseGsk0tHWTk2YjPcX8jaOPrb+TXCtt9m6VGGbXrGB865xKMlNt/OCpjfz031s4tXIsv758LudML+Kxj6pxuIyhCHdU4NtAJT/wi9btknV3IhBR9LXWLuAm4GVgO/Ck1nqrUuoOpdRSb7HfAFnAU0qpDUqp5SGqMx9fT98dQvQLPCtv7j/SOVwRjWjq23qGpJcPybuRSkunE7tVkTHAL9IxmSl846xKNtW0kp+Zwh+WHY/NauGLJ0/k8NEeXt5aN0QRJz5NnQ5SrJb+bW44PRM2hZBEtSqR1nolsDLg2O1+j88zOa7o8f2U80uX82eyV/T3Hu4wbXGxRKaurXvIRN+3vHKyiX5zp5Pc9JSY8qmvO3US9W3dXLGwlLFZnglzZ04tpCw/nUc+2M+n5x9L1zvY0sX43DTT87YTkZYOJ2Myg6xqKvZORBJ/Rq5vs4QQoj8hLx2bRbHvsOydCx57Z6hEPzvVhkUln+i3djmiWmEzGGl2Kz9fOps5E3J7j1ksii+cNJGP9jaxq76d5g4H337sY069+w2Wb+w3nNaH2tYuPnP/ezz+0YFRPY7V1Onou2OWD7dT7J0IJL7oR7B3bFYLZfkZ7Dsiom8Ymob2Hoq9SzCYjcWiyEm3J92a+i2dzgH7+ZH4/KIyUmwWfvb8Vs6/7x1Wbq4lO9XG8xvCi/6z6w+yobqFW5/dzFcfWde7peBoo7kjhOgbLrF3IjAKRD+8vQOewdy9h+Pj6RuG5s0dDb0ZHvHkSIcDl6GHrKcPnsHMZNsnN9q19AdCfmYKl8wtYXXVEYqyU1l+02lceUIZ//nkMG1htlpcubmW+WV5/Piimby1s5ELfvcOG6tbTI1tJNDc6eg/iAti70RB4ou+NQrRL8hk/5HhT9vccrCVyx54n+v+vobfvrJzWK8djPohTNf0kZuRkoT2jpO8YL3OQXLbRTO593Pzef6mU5k1Poclc0twuA3e2B48QW7v4Q62Hmrj0/NKuOGMCv79zVNxG5qH3qkyPbZ40xzqi1bsnYgkvuhHsHfAM5jb6XDT0D48aZtOt8HPl29l6R//Q01zJzPGZfPSljrcRnw91oZ2n+gPjb0DnrTN1mRL2fRulWg2hdmpXL6wFLvV82d6fFkexTmpvLSlNmj5lZs9xy+aWwLArPE5LCgfw676dtNjiyeGoWmRnn7MjB7RD2vveDJ4hmswd+XmWv7+/j6WnVjO698/i5vOqeTw0R7W7GsaluuHoq7V86U31PZOMvX0HS6DDofbdHsnGBaLYsmcEt7a2UhHT//7fcWmWhaU5zE+L7332LTiLPYe7sDpHj05/23dTgxN8F9X4ulHJPFFP8LkLDiWtjlcg7lbD7WRYrNwx9LZ5KbbOWdGEWl2S29PLF7Ut3WjlKcHOVQEbpk42vF9weUOgb0TjAvnjKPHZfDWzsY+x6saj7K9to2L5/VdkXFacTYuQ4+q7LVm7/hYfqbYO7GQ+KLv+ynnDt3TL8lNw25VwzaYu6OunalFWdi8P8szUmycPb2Il7bUYcTR4mlo72ZsZmqvXTAU5GV4evrxfJ/DiW/28VDYO8E4YVI+BVkprAyweI5ZO+P6HK8sygJgV/3RYYlvOPBlJAXP3nGKvROBUSD63p9yYeyd3rTNYert7KhtY/q47D7HlswtobG9h7X7m4clhmDUtXYPqZ8Pnp6+1tAexH4Yjfh+1QyHvQNgtSg+NXscb+5ooNt5bL2pFZtqWThxDCW56X3KVxZloRR80jB6fH3fF21w0XeLvROBxBf9KOwdgMljM4fF3mnqcNDQ3sPMcTl9jp8zo4hUW3wtnvq2nj47Zg0FvvV3mkdpfnggvjkJvsXmhoOL5pTQ6XDz6rZ6uhxudtW3s6OunYu9A7j+pNmtlOdn8Mko7OkHHcgVeyciUS3DMKLptXfCi/6kgkze23MYw9D9tlgzkx11bQD9evpZqTbOnFbIS1tquf2SWUMaQyga2ruZX5Y3pNeYVux53xtrWnrXPRrN9No7w9TTBzipIp8xGXa+9djHfY4vCbB2fEwtyh5VGTzN4dpc7J2IjALRj2zvgEf0u50GDe09jMsdut7ujlrPH9eMkux+r108r4RXttWz/kAzi4Z5HSCHy+DwUceQ2ztzJ+SSn5nC2zsbufS4CUN6rZFA6zDbOwB2q4WHrlnExuoWnG6Ny20wsSCzn7XjY1pxFm/tbMDpNoZ0PGe4aPYucJeVGkS+3K5jGX1CUBK/daKYnAUeewc8E1iGUvR31rWTn5lCYVZ/cT1nRhEpNgt/fW8vLkMzLieNcblppNmH3oP0LS091PaOxaI4rbKAdz4Z+l9VI4GWTidWSwgBGkJOmJQf9QKCU4uzejN4phb374wkGs0dDvIyQixwZ7iOrcclBCXxv/ajtncygKFP29xR18aMcdlBb8jsNDufmlXMys11LHvoA8767VssuvM1Dg/DWv/DMRvXx5nTCjl8tIdttW1Dfq1409LlmZg1kle+nFrkEfrRksHT3OkgP1SKrNg7ERkFoh95chZASW46KVbLkGbwuA3Nrvqj/fx8f3535XG89r0zefQrJ/Gji2ZwtMfFfz45PGQx+ahvHT7RP31aAQBv72qMUDLxOdzuIHcYrZ1YGG0ZPM3eZZWDIvZORBJf9CMsrdxbzKKYNi6LV7fV90l1M5MDTZ10Od39Mnf8sVktVBZlcWplAdefVkFehp33dg+D6LcN/RIMPoqy05g9Pod3RrnoG4Zmzb4m5vktizwSGW0ZPIc7eoKna4LX3hnZX8LxJvFFP0p7B+DmC2ZQdbiD+9/cPSSh7AyRuRMKq0VxcsVY3tt9eMgXg6tv78FuVaH/WEzmjGmFrNvfTHuYFSETnc0HWznS4eCs6UXxDiUioyWDp6Gtm6rGDmaPD9GxMpzS04/AKBB9X08/sricMa2QyxZM4IG39vSmVprJ9tp2lDqWthgNp1YWcKi1m71DPHGsvrWbouy0YRtYPXNaIS5Ds3rPkWG5Xjx4a2cjSnnuq5HOaFmD5zXvCqPnzwqenopbRD8SiS/6vdk70Vk2P714Frnpdm55ZnPvqpeGoalt7Rp0KDvr2pk0NnNAm46fWunxv98bYnGsbx/62bj+LCgfQ1aqbVT7+m/tamBeaV7wSUIjDP8MnkTm1W11lOdnMK04q/+LhgFosXcikPiib7ECKip7BzybUd/+6VlsrG7hFy9s5dZnNnHSXa9z8l1v8Nq2+kGF4svcGQiTxmYwIS+d94ZwMFdrTXVT17AM4vpIsVk4ecpY3t7VOCq37WvucLChuoWzEqCXD6Mjg6ejx8V7e45w/qziEOmaXg2Qnn5YEl/0wfMhR2Hv+Fg6fzznzCjiH6v38+KmWk6cnE9xTip/fW9vzCF0Olzsb+qM2s/3oZTilCljWV11ZMjW219/oJkDTZ2cPnV4BerMaYXUNHcNuXUVD975pBGt4azpiSH6UwoTP4Pn3U8acbgMzptZHLyAW0Q/GkaH6FvtEbN3/FFK8ftlx/HM109m/e3nc/9/LeCakyfx/p4j7I7xj2JX/VG0hhlhMndCcdrUAlq7nGw91BrTtSPxyOr9ZKfauPS48ZELm8iZ3l7wPat29lljv9vp5s4V2zjn3rc42DJ4Wy0evL2zkTEZduaVDu2yFmaRnpL4GTyvbKsnL8POCZPGBC/g0wCxd8IyOkTfYg+7tHIwstPsLJyY3zstfdkJZaRYLTyyen9MIfgydwZq7wCcPGUsAO/tNt/XP3K0h5Wb67h8YSmZwzxrtCw/gx9eMJ1Xt9dzwX3v8PauRtbtb+ai37/Lw//ZS3VTJz9+bnPC2T+GoXl7VyNnTCvEmkAzjqcWZbO9rm1A7d3U4eD+N3fT4E359Wd7bRvbDg3PBDyX2+CNHQ2cM72od8nyfvhEXyZnhWWUiL51QPZOMMZmpXLxvBKeWX+QozEsC7yxppV0bz70QCnKTmN6cfaQ5Os/ubYGh9vgi4vLTa87Gr55diXPfeMUstJsfOmvH3HFn96nx2Xw6FdO4rYlns27n99wKC6xxcqWQ75UzcSwdnycPrWAqsYOlm+Mrr211vzgqY385uWdnHvv2zyyeh9uQ1Pf1s33n9zIkt+/y+cfXD0sv9bW7W+mpdPJebNCWDvgZ+/I0srhGB2iP0B7JxRfXDyRoz0unvv44IDO21TTwpNrqvnU7OKYUyJPqRzLmn1Npk4ccxuaRz/cz+KKfCqL4rfmyrzSPFZ86zS+efYUrjtlMi9/9wxOrSzgS6dM4riyPH7xwlaOhFiKosflprppeDa/iZbeVM1hHiMZLF9cPJEF5Xn89N9beifrheOJNdW8saOBr505hXllufz0+a1c/Id3Ofu3b/HCxkNce8okDK257dmh/7X26rZ6UqyW8OmxYu9ExegQ/RjsnWAsKM9j9vgc/rl6f9Q3cUePi28/9jFF2ancsXROzNc+rbKAHpfB2n3mbbLy9q4Gapq7uHrxJNPqjJU0u5UfXjCD2z89q3dxMqtFcc8V8zja4+KOFdv6nfNh1RGW/P5dzvzNm7yytW64Qw7JWzsbmDshl7FBFtUbyVgtit9+bj4Ot8Etz2wKe48fONLJL1ds49TKsdx8wXT+ef1J/H7ZcThcBmdOK+S1753Jz5fO5rYlM3hnVyNPrq2OKga3oYNaReHQWvPq9npOqRwbfmG73uwdEf1wjA7Rtw4seycUSimuOXkiO+vb+WhvdJuY/3z5VvY3dXLflccNag2WkyrGeucPbDItl/qR1fspzE7lU7PD/CSOM9OKs/nm2ZU8v+EQN/xjLQ+8tYf3dh/mtmc3ceVDH+BwGcwYl8O3HvuYdfvN3Vh+zb4mrv3bR7wfpa1mGJq7XtrO+gMtXDA7xOSgEU5FYRa3XjiDt3Y28sSa4ELtNjTff2oDFoviN1fMx2JRKKW49LgJvPGDs3jgiwspH+uxMb9w0kQWV+Rz54rtHIpg8zS0dXPVnz9g8V2v8/C7VVF1rLTWPPD2HvYf6eT8cNYOHOv4SU8/LFGJvlLqQqXUTqXUbqXUrUFeT1VKPeF9/UOl1CSzAw2LxWaKvQOwdP4ExmTY+fqj63n0w/1h0yhf2HiIp9bVcNPZlZxUMXZQ181KtfHoV06iy+nmcw+uZmdd7Kl1TrfBw+9W8dauRq46sXzEr6H+jbMquXrxRHbVt/PrVTv4wsMf8sSaam48o4JXvnsGj1x/IiW5aVz/v2vZ3TD47BOtNf/7/j6ueugD3tnVyBf+8iH3rNoRdrZqt9PNTY+t58G3q/ji4nK+ekbFoOOIF9ecPImTK8byyxXbuGfVDj6sOoLTbdDU4WD5xkN849F1rNnXzC+WzmZ8XvA1+n1YLIp7Lp+Py9Dc/PQmGtqD9+Lf33OYi/7wHzbXtHLS5LHc+eJ2vv/UxrB2ZqfDxU2Pfcw9q3Zy8bwSLl9QGv6N9Q7kiqcfDhXp21YpZQV2AecDNcAa4Cqt9Ta/Mt8A5mmtv6aUWgZ8Vmt9Zbh6Fy1apNeuXTvY+D3cvxgKpsKVj5hS3Y66Nn72/FY+3NvEjHHZfP2sKRTnpJGTZsfQnsyNV7bVs7G6hQXleTz51ZNDZxQMkN0N7Xzh4Q/pcRnc+7n5nDKlYEAzfD+oOsLtz29hV/1Rzp5eyO+uPH7ErwLpT3OHg401LUzIS++z9vuBI51c9sB7pNqs3P7pWZwyZSzZaQN/X61dTn7xwlaeXX+Qc2cU8d+fnct9r+7iibXVHF+ex9fPnEL52AzKxmRgUYrdDUfZWd/OPz/Yz8aaFn580UyuP23yiF5KORoOtnTxgyc38tG+JtyGJiPFSpfTjdaeLS+XnVjGrRfOiPp9/vOD/fzk31tQyrPW/wWzx5FiVdS39VDd3MkLGw8xuSCTB764kMrCLP7fG7u577VdzC/L49pTJjKlMIuKwizchmbv4Q6qGo/y0DtV7Kpv55YLZ3DjGRWRY6ndCA+eAVc+CjMvMaGVRiZKqXVa60Uxnx+F6J8M/FxrfYH3+W0AWuu7/Mq87C2zWillA+qAQh2mclNF/0+nQVYxXPZnc+oDNPDa9nrufWUXta39ey9zxudw9owiLl9QyhiTRfVgSxc3PrKOmuYubBbFjJIcZpfkkJNmIz3VSrrdiqHBbRi9O2LtP9LB/qZODrV0U5Kbxi0XzuCs6YUktjT1Zduhdr7+6FpaulzYLIp5ZXlML8oiJ81GdrqdzBQbFqXwvelup5sup5vOHhf7mjrZUdvGgSaPBfG1Myv46hlT8I27r9paxy9XbO+TuaUU+O7grFQbd1w6i3NnjFyrLBbaelys2dvER3ubyM9M4ZTKAmaV5GCN4cbZ3XiUV7fV89q2enY3eixKq0UxNtPOKVMKuPnCGWT6dWBe39HA7c9vDZktNybDzl2XzeXkaH9F126ERz4D//UkTLtg4G8gQRgO0b8CuFBr/RXv86uBk7TWN/mV2eItU+N9vsdbJqRZaqroP3w+1HxkTl2CICQ21yyHijPjHcWQMVjRj2a2TrDv/MBvimjKoJS6EbgRoLzcxLzxi34DBz4wr74RikbjMjQOl4FSYFUKq8XzT42qPv3AMLSmx+X51aOhd4DQbrOQYlXYLBbPLwBh9JOSCeUnxzuKEU00ol8DlPk9LwUCZ3f4ytR47Z1coF+qhdb6IeAh8PT0Ywk4KOOP8/wb5SjA7v0nHMMCpHv/CYIQnmhGH9cAU5VSk5VSKcAyYHlAmeXAl7yPrwDeCOfnC4IgCPEhYk9fa+1SSt0EvAxYgb9qrbcqpe4A1mqtlwN/AR5RSu3G08NfNpRBC4IgCLER1QpcWuuVwMqAY7f7Pe4GPmduaIIgCILZjOxZO4IgCIKpiOgLgiAkESL6giAISYSIviAIQhIhoi8IgpBEiOgLgiAkESL6giAISYSIviAIQhIhoi8IgpBEiOgLgiAkESL6giAISYSIviAIQhIhoi8IgpBERNwuccgurFQjsN/7tAAIubVikiFt4UHawYO0wzGkLTxM11pnx3pyVEsrDwVa60LfY6XU2sHs+TiakLbwIO3gQdrhGNIWHpRSg9pcXOwdQRCEJEJEXxAEIYkYKaL/ULwDGEFIW3iQdvAg7XAMaQsPg2qHuA3kCoIgCMPPSOnpC4IgCMNA3EVfKXWhUmqnUmq3UurWeMczXCilypRSbyqltiultiqlvuM9nq+UelUp9Yn3/zHxjnU4UEpZlVIfK6VWeJ9PVkp96G2HJ5RSKfGOcThQSuUppZ5WSu3w3hsnJ+M9oZT6rvfvYotS6jGlVFqy3BNKqb8qpRqUUlv8jgW9B5SHP3j1c5NSakGk+uMq+kopK3A/sASYBVyllJoVz5iGERfwfa31TGAx8E3ve78VeF1rPRV43fs8GfgOsN3v+a+B+7zt0AxcH5eohp/fA6u01jOA+XjaJKnuCaXUBODbwCKt9RzACiwjee6JvwMXBhwLdQ8sAaZ6/90IPBCp8nj39E8Edmutq7TWDuBx4NI4xzQsaK1rtdbrvY/b8fxxT8Dz/v/XW+x/gc/EJ8LhQylVClwMPOx9roBzgKe9RZKlHXKAM4C/AGitHVrrFpLwnsAzhyhdKWUDMoBakuSe0Fq/AzQFHA51D1wK/EN7+ADIU0qVhKs/3qI/Aaj2e17jPZZUKKUmAccDHwLFWuta8HwxAEXxi2zY+B1wM2B4n48FWrTWLu/zZLkvKoBG4G9eq+thpVQmSXZPaK0PAr8FDuAR+1ZgHcl5T/gIdQ8MWEPjLfoqyLGkSidSSmUBzwD/R2vdFu94hhul1CVAg9Z6nf/hIEWT4b6wAQuAB7TWxwMdjHIrJxhev/pSYDIwHsjEY2MEkgz3RCQG/LcSb9GvAcr8npcCh+IUy7CjlLLjEfxHtdbPeg/X+36eef9viFd8w8SpwFKl1D489t45eHr+ed6f9pA890UNUKO1/tD7/Gk8XwLJdk+cB+zVWjdqrZ3As8ApJOc94SPUPTBgDY236K8BpnpH5VPwDNYsj3NMw4LXt/4LsF1r/X/9XloOfMn7+EvA88Md23Citb5Na12qtZ6E5/N/Q2v9BeBN4ApvsVHfDgBa6zqgWik13XvoXGAbSXZP4LF1FiulMrx/J752SLp7wo9Q98By4BpvFs9ioNVnA4VEax3Xf8BFwC5gD/DjeMczjO/7NDw/wzYBG7z/LsLjZ78OfOL9Pz/esQ5jm5wFrPA+rgA+AnYDTwGp8Y5vmNrgOGCt9774NzAmGe8J4BfADmAL8AiQmiz3BPAYnrEMJ56e/PWh7gE89s79Xv3cjCfjKWz9MiNXEAQhiYi3vSMIgiAMIyL6giAISYSIviAIQhIhoi8IgpBEiOgLgiAkESL6giAISYSIviAIQhIhoi8IgpBE/H9pn/d1zbojWwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(posterior[:, 1])\n", + "plt.plot(hidden)\n", + "for i in range(0, len(seq)):\n", + " plt.annotate(str(seq[i]), (i, seq[i] / 2. + 0.2))\n", + "plt.xlim(-1, len(seq))\n", + "plt.ylim(-0.1, np.max(seq) + 0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 13.3 Linear Dynamical Systems" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "observed_sequence = np.concatenate(\n", + " (np.arange(50)[:, None] * 0.1 + np.random.normal(size=(50, 1)),\n", + " np.random.normal(loc=5., size=(50, 1)),\n", + " 5 - 0.1 * np.arange(50)[:, None] + np.random.normal(size=(50, 1))), axis=0)\n", + "plt.plot(observed_sequence)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "kalman = Kalman(\n", + " system=np.array([[1., 1.], [0., 1.]]),\n", + " cov_system=np.eye(2) * 0.001,\n", + " measure=np.array([[1., 0.]]),\n", + " cov_measure=np.eye(1) * 10,\n", + " mu0=np.zeros(2), P0=np.eye(2) * 100\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "mean, cov = kalman.filtering(observed_sequence)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mean = mean[:, 0]\n", + "std = np.sqrt(cov[:, 0, 0])\n", + "plt.plot(observed_sequence, label=\"observation\")\n", + "plt.plot(mean, label=\"estimate\")\n", + "plt.fill_between(np.arange(len(mean)), mean - std, mean + std, color=\"orange\", alpha=0.5, label=\"std\")\n", + "plt.legend(bbox_to_anchor=(1, 1))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mean, cov = kalman.smoothing()\n", + "mean = mean[:, 0]\n", + "std = np.sqrt(cov[:, 0, 0])\n", + "plt.plot(observed_sequence, label=\"observation\")\n", + "plt.plot(mean, label=\"estimate\")\n", + "plt.fill_between(np.arange(len(mean)), mean - std, mean + std, color=\"orange\", alpha=0.5, label=\"std\")\n", + "plt.legend(bbox_to_anchor=(1, 1))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "observed_sequence = [None if 50 < i < 90 else obs for i, obs in enumerate(observed_sequence)]\n", + "plt.plot(observed_sequence)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "kalman = Kalman(\n", + " system=np.array([[1., 1.], [0., 1.]]),\n", + " cov_system=np.eye(2) * 0.001,\n", + " measure=np.array([[1., 0.]]),\n", + " cov_measure=np.eye(1) * 10,\n", + " mu0=np.zeros(2), P0=np.eye(2) * 100\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "mean = []\n", + "std = []\n", + "for obs in observed_sequence:\n", + " m, s = kalman.predict()\n", + " if obs is not None:\n", + " m, s = kalman.filter(obs)\n", + " mean.append(m[0])\n", + " std.append(np.sqrt(s[0, 0]))\n", + "mean = np.asarray(mean)\n", + "std = np.asarray(std)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(observed_sequence, label=\"observation\")\n", + "plt.plot(mean, label=\"estimate\")\n", + "plt.fill_between(np.arange(len(mean)), mean - std, mean + std, color=\"orange\", alpha=0.5, label=\"std\")\n", + "plt.legend(bbox_to_anchor=(1, 1))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAc4AAAD8CAYAAAD+I0SiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsnXl8XGW9/9/nnNlnsjRbkzZt0y1N23SjpUDLYkFWBYTiRVbhXgSBiyioXATvFRQ3FgF/giCIoqCoCLKJLLJUC4UUujdtuiRp0+zLZPblnPP745mZTLamabO06fN+veaVZObMmedkZs7nfHfFNE0kEolEIpEcGOpoL0AikUgkkiMJKZwSiUQikQwCKZwSiUQikQwCKZwSiUQikQwCKZwSiUQikQwCKZwSiUQikQwCKZwSiUQikQwCKZwSiUQikQwCKZwSiUQikQwCy3DsNC8vzywpKRmOXUskEsmYZO3atS2maeaP9jokAzMswllSUkJFRcVw7FoikUjGJIqi1Iz2GiQHhnTVSiQSiUQyCKRwSiQSiUQyCKRwSiQSiUQyCIYlximRSCSSQ2ft2rUFFovlCaAcaeiMFAawKR6PX7N48eKmvjaQwimRSCSHKRaL5YnCwsLZ+fn57aqqyuHJI4BhGEpzc/OchoaGJ4Dz+tpGXsFIJBLJ4Ut5fn5+pxTNkUNVVTM/P9+LsPL73mYE1yORSCSSwaFK0Rx5Ev/zfvVRCqdEcpjzcXUbW+s7R3sZEokkgRROieQw57svbuIHr24Z7WVIJCm2bdtmmzlz5tzRXsfq1audzz33XFby72eeeSbrO9/5TuFwv65MDpJIDnP8kThtgehoL0MiGVZisRhWq3VQz6moqHBVVFS4L774Yi/AZZdd5gW8w7G+dKTFKZEc5oSiOk2+CN5QbLSXIjlK+d73vjd+5syZc2fOnDn37rvvLgCIx+NceOGFJaWlpXPOOuusaT6fTwW44YYbJk6fPn1uaWnpnGuvvbYYYN++fZYzzzxzenl5+ezy8vLZb7zxhhvglltumXDJJZdMWb58+cwLL7xw6vz588sqKiocydddunTprFWrVrneeecd16JFi8pmz549Z9GiRWXr16+3h8Nh5Uc/+tGEl19+eVxZWdmcX/3qV+Mefvjh3CuvvHIywPbt220nnHBCaWlp6ZwTTjihtKqqygawcuXKkquuumrSokWLyoqLi+c99dRT4wb7/5AWp0RymBOK6QDsaPKzeMqgv+OSMcK3/rJ+0vYGn2so91lamBG896IFe/a3zapVq1zPPvts7tq1a7eapsnixYtnn3baab7q6mrHY489Vn3GGWcEvvjFL5bce++9+TfeeGPLa6+9Nm7Xrl2bVFWlpaVFA7juuusm3XLLLY1nnnmmv6qqynbmmWfO3LVr12aADRs2uNasWVPp8XjMu+66q+CZZ57JWbJkyb6amhprU1OT9aSTTgq2tbWpH330UaXVauXFF1/M+Pa3v138j3/8Y+ftt9++r6Kiwv3000/XAjz88MO5yXV/9atfnXzppZe23nTTTa0PPvhg7vXXXz/prbfe2gnQ2NhoraioqFy3bp3jggsumHH11Ve3D+b/Ji1OieQwxjTNNOH0jfJqJEcj7777ruecc87pyMzMNLKysozPfe5z7e+8805GYWFh9IwzzggAXHHFFa2rV6/25OTk6Ha73fjSl7405be//W22x+MxAP79739n3nzzzZPLysrmnHvuuTP8fr/W3t6uApx11lkdHo/HBLjyyivbX3rppXEATz/99Lhzzz23HaCtrU0755xzps+cOXPut7/97Unbt2939L3aLj799FP3tdde2wZw/fXXt61du9aTfOy8887r0DSNxYsXh1tbWwfnH0ZanBLJYU04ZmAmihGqGv2juxjJqDKQZThcmGbf1TCKovT622q1sm7duq0vvfRS5h//+Mdxjz76aMGHH3643TRNKioqtiYFMh23220kf586dWosOzs7vmbNGudf//rXnMcee6wG4Lbbbpt4yimn+N58882d27Zts5166qmzDuWYHA5Hah39Hd/+kBan5MjHNCEehFAjBGrBtwN8O8G/G0L1EO0A0xh4P4chwWg89fuOZimckpHn1FNP9b/22mvZPp9P7ezsVF977bVxK1as8NXX19veeustN8Czzz6bs2zZMr/X61Xb2tq0iy++2PvLX/5yz9atW10AJ554YudPfvKTguQ+V69e7ezv9S666KK2H/7wh4U+n09bunRpCKCzs1MrLi6OAjz22GN5yW0zMzN1v9/fp44tWrQo8MQTT4xLPCdnyZIlQ/YFkhan5MjCNCHSCsEa6KwCXxWE6kCPgJL8/iSvhM20nwrY88AzDTJmgqcEnMWg2Ub8EAZD0k2rKtLilIwOJ554YvDSSy9tPeaYY2YDXHHFFc15eXn6tGnTwr/+9a9zb7jhhilTp06NfPOb32xua2vTPv/5z8+IRCIKwA9+8IM9AI8//viea665ZnJpaekcXdeV4447zrds2bLavl7v8ssvb//ud787+eabb96XvO+2225ruOaaa6Y+/PDDhSeddFKqqPnss8/23XfffUVlZWVzbr311vr0/Tz66KO1X/7yl0seeuihwtzc3PjTTz9dPVT/E+VgzNSBWLJkiSkHWUuGDNOEQA20fwrNqyHaCpigWMHiAc0F6gDXgKYBehjiAdCDoCigaJA1D/KOh+y5YHGPyOEMhqpGH6f/7H3KCjOobPCx5e4zcdnk9e5YRFGUtaZpLkm/b/369dULFixoGa01Hc2sX78+b8GCBSV9PSa/gZLDl5gfWtZAwz8g3CwsSlsOOCcJ4RsMigoWl7glMeLQuU0IsqJCzmIYfypklqZZr6NLMCosznkTs6hs8LGzKcC84qwBniWRSIYTKZySw49IK9S/AQ1vg6mDLRfcU4b+dVQLOPLF74YO7Rug9SNwFMDE8yD3WNDsQ/+6gyApnPOLs/jz2r1UNfmkcEoko4wUTsnhQ7QD9r0G9W8Ji9JRCOqgM8UPDlUDZ6JTV8wHO5+Amudg0oWQv3zUYqHhRIxzdlEmFlVhR5OMc0oko40UTsnoo0eFdbn3ryIW6ZwwcMxyOLFmiFs8CLt/C3V/gymXCAt0hF24SYsz02mlJM8thVMiOQyQwikZXbyVsOvXEG4CR9Gou0a7YXGBpUTEWrf/P5GNO/UK8EwdsSUky1GcVo08j40O2XZPIhl1pHBKRod4AGqfh4a3RMKPu2S0V9Q/Vo/IuA01wsbvQdGZUHz+iGThJstRnDYNp1WjVTZ7l0hGncMjdVBydNFZBeu/C03viqQfW/Zor2hgFEUkEjknQ/2bsP4O6NgMw1DOlU4o4ap12TScNi31t0RyOPLwww/nVldXpxITLr744ilr164dsD3eQGzbts32y1/+MudQ9zNUSOGUjByGDntfgs0/ELFM12RRS3kkoWqJDF8Vtv4Udj8N8dCwvVwyxumwaDisWupvieRw5Pe//31ebW1tSjife+65msWLF4cPdb9VVVX25557Tgqn5Cgj1gnbHoTav4iOPUeClbk/rJlC+JveE+5bf/WwvEwopuOwqqiqgsumpbJsJZKR5JFHHsmZN2/e7LKysjmXXnrplHg8zsqVK0tmzpw5t7S0dM5dd91V8NRTT43btGmT68orr5xWVlY2x+/3K0uXLp31/vvvuwBcLtei66+/fuLcuXNnL1u2rPSdd95xLV26dFZxcfG8Z555JguEZbl48eJZc+bMmT1nzpzZb775phvgjjvumFhRUeEpKyubc9dddxXE43Guu+664vLy8tmlpaVz7r333rz9rX+okTFOyfATqBWiGesE99TBNy84XFE0IZ6RNth4F5RcBoWnDmnmbTAaT3UKclq1VMxTchTy4o2TaNoypGPFKJgT5Au/2G/z+E8++cTxl7/8JaeioqLSbrebl19++eTbbrutqL6+3lpVVbUZoKWlRcvLy9MfffTRgvvuu2/PySefHOy5n1AopK5YscL36KOP1p1++unT77zzzomrVq3a/sknnziuvvrqqZdddpl3woQJ8VWrVm13uVzmxo0b7Zdccsm0TZs2bb3nnnvq7r///vHvvPPODoD77rsvLysrS9+0adPWUCikHHvssWXnnntuZ1lZ2YgkAUjhPEowTZPnPt7D2fOKyHKOUG0kQOtaqHpUtMVzFo/c644k9hyRKLT7aejcCtP/c8gSh4JRHadVuLOTwmmaZq/JFBLJcPH6669nbNq0ybVgwYLZAOFwWF2xYoV3z5499i9/+cuTzj33XO8FF1zQOdB+rFaredFFF3UCzJ07N2S32w273W4uXbo0VFdXZwOIRqPKf/3Xf03ZsmWLU1VVampq+kyzf+uttzIrKytdyRFkPp9P27Jli0MKp2RI2dMW4n/+uhFVUfiPYycN/wuaJtT/A6qfFY0MLEN7oXzYodmFNd2+DjbcBWVfA9ehXyiEYzpOmxBOh00TPe7jBg7rERYblhw6A1iGw4VpmsoXv/jF1l/84hd16fd7vd66F154IfORRx4peO6553L+/Oc/V+9vPxaLxVRV4Y1RVRW73W4CaJqGrusKwD333DO+oKAg9vzzz+82DAOn07m4vzXdf//9tStXrhxQsIcDGeM8SvAm6v/8kfgAWw4Bhg7Vz4ibq3jsi2YSRQHXJNFEfuNdwto+RIJRHZety+IEZGatZEQ566yzOl955ZVxdXV1FoDGxkZt+/btNl3Xueqqqzp+8IMf1G3cuNEF4PF4dK/Xe9BXdV6vVysqKoppmsYjjzySq+vis56VlaX7/f7Ufk8//XTvo48+mp+cwrJhwwZ7Z2fniOnZAVmciqJkA08A5YgZTf9pmuYHw7kwydDiiwjhHPYYmR6FnU9CyweiNvNIy5odCux5ouvQtgdh0kooPu+g457prtqkgIZiOuOGbLESyf5ZvHhx+M4776w77bTTSg3DwGq1mj/96U/3fOELX5huGIYCcPfdd+8FuPLKK1tuuummKd/61reMioqKrYN9ra9//etNK1eunP7iiy+OO/HEE31Op9MAWLp0achisZizZs2ac+mll7bceeedTdXV1fZ58+bNNk1TycnJib322ms7h/bI++eAxoopivJbYJVpmk8oimIDXKZpdvS3vRwrdvjxj80NXPe7tfz3ihl888xDGp7eP/EQbP8FeDeBa8rYSQI6WIw4BGsh7wSYdhVY+p3d2y/n/vxf5HlsPHX1Uv62ro6b/7iOt289hen5nqFfr2RUkWPFDi8OaayYoiiZwMnAVQCmaUYB2b7kCMMfFi7aYbM44wGofAh8O6RoJlEtIu7Z+hFEGqH0ayKRaBCE0mKc0lUrkRweHIj/aBrQDDylKMqniqI8oSjK4TfxV7JfkrHNYSmgj/lh630Q2CVifFI0u1AU0TAhWA+b7halOYMgFNVxWhPlKAkBlbWcEsnociDCaQGOAR41TXMREAD+p+dGiqJcqyhKhaIoFc3NzUO8TMmh4guLGOeQn3Rjfqi8HwJ7RLmJFM2+cRaBYcCm70P7xgN+mqjj7G5xyu5BEsnociDCuRfYa5rmmsTff0EIaTdM03zcNM0lpmkuyc/PH8o1SoYAX8riHMKs2nigSzSHoPRizGPPAUsWVN4Hje8dUJ/bblm1aclBEolk9BhQOE3TbAD2KIqSzCg5DdgyrKuSDDm+VIzTGJodxoNQ+SAEpWgOCqsHHBPEoOw9L4ievf1gGGa3ms2kxSldtRLJ6HKgDRBuAp5JZNTuAq4eviVJhoNUctBQWJx6GLb/HPw7wTkCzRTGGppdJFDtfQGibTD1StBsvTZLWpa9LE7pqpVIRpUDEk7TNNcBSwbcUHLYkkwOOmQ3nxGDqsegs1KM2JIxzUFhmol/WTLjtnkVRNuh9IZebfqC0R7CKWOckrU3TyCwt/dV1sHiLo6y+KF9g33a3XffXfCNb3yjJSMjo5fL5OGHH86tqKhwP/3004PLhDuCkC33jhKSyUGHdNI1dNj5a2j/VJacDJI9fhvn/H0uPzi2hvNL2sSdigquEnERsvnHUPZ1sOemnpO0LJ2JJu9Jl62McR7FBPbacE8ZunLAQM1BifBjjz02/itf+UpbX8J5NCCF8yghGeMMH6xwmibU/BGa/53oCCRFczDkOuL4YhbqAj3OU8k2feEGkXE7+5upmHFSIJOWpt2ioioyxikZWTo7O9XzzjtvWn19vc0wDOW8885ra2pqsp5yyiml48aNi69Zs2b7Qw89lPuzn/2sKD8/PzZ9+vSwzWYb3gnvo4wUzqOEVB3nwZx0TRPqXob61xOiKVscDxaXxWCcPca+YJ/DHkQj/EgrbLwbym6BrLJUBnTSVasoipiQIl21khHkr3/9a2ZhYWHs3Xff3QHQ2tqq/fGPf8x77733thcVFcVramqsP/7xjyesXbt2a05Ojr5s2bJZ5eXlvcaKjSXkGfAoIZVVezAn3ab3ofbPYvbk0dh7doiY4Iqyr6fFmY49FywZsOXH0PxBmqu263/utMmZnJKR5ZhjjgmtWrUq8/rrr5/4+uuve3Jzc7t9AN9//3338ccf75swYULc4XCYF154YdtorXWkkBbnUYBpmimLMxI30A0TTT1AV2vbOtG03VkM6gjO8RyDTHBH2ePvx+JMYs0QiUNVjxA0LgaUlMUJIs4pLU7JSDJ//vzIJ598suX555/PuuOOOya+9dZbvUZ5HW3zYaXFeRQQiunohkmOW1g7Bxwj8+0UZSeO8aKEQnJITHRFe8c4+0JzgmsywXoxgMiZZuQnh1mPFHvbgxzIIAjJ2KW6utqakZFh3HDDDW1f//rXG9etW+dyu9261+tVAU4++eTAhx9+mNHQ0KBFIhHlhRdeGPPDe6TFeRSQrOEsyLDTFogSjOq47QO89aEGqHwALJm9yiQOO+IxCPkgGoZYFOIR8dPokfCnaWC1J242sLvA4QZ1ZNzPE9xRfDELnVGNTNsA4qdaCWsiw9a593eQfw1YnLhG0FVb1ejjjAff5/f/dRzLZ+SNyGtKBsBdHD3YTNh+9zcAa9eudd5+++3FqqpisVjMRx55pGbVqlWes88+e2ZBQUFszZo122+77bZ9xx9//Oz8/PzY/Pnzg8nB1GMVKZxHAcl2e/kZdiobfANbnFEvbL1f/G7LGubVHSCmAQEveFvErbMFgp0Q9EE0dAg7VsDpBmcGeLIhMxcy88TN6RnS7OEJrggA9UEbmbaB1xzUE3M4g5th609g1s0j6qpds7sN04QmX3hEXk9yABxEzeWhsnLlys6VK1d26xZ38sknB++4446m5N8333xz680339w60msbLaRwjkFqWgNMye2yEn0pi9MBDFAHmOgKZEQ6+PKaFZxY2Ml1cxqGdb19Eo9BewO01EFrHbTWgx5LPKgIkXNnwbjx4MwElwdsLmFJWm1gsfewJE3Q410WaTQCkaCwVIM+8bNpD9Smzd61OSCnCHIniNu4QtAO/iszwS0u7vcFbMzKPgDhjItIiiujCIL7YNP3cWoX0B4emYv5T2vFyN3wULVplEjGCFI4xxib6rx8/uf/4pWbTqR8orAWk67a/AwRp+y3CYKhw44nwb+Tl5sWsaohC7d1BBNRgp1Qv0vcWvaK9QBk5cOUOZA9HrJyISMXLMOUqBQNC2vW2wodjdBWDw27xWOqBnnFUFgC40vAM25QFulElxDOuuCBedpCcQ0FE7tmgqUIIi04g9uoi04Z5EEdHOv2tIt1yGQkiaQbUjjHGM0+4Q7c1xFKCWeya1BBQjj7PBGaJuz5C7SuIeacxgMbJwLgjw1z/C/YCbWVULdNuGBBCNK0BZA/SVh6NsfwriEdm0OIY15a4/pICNr2QfNeaKyGDe8B7wmLd+JMKJ4lxH0AEc13xrCqxv5LUtII6SpOi9G1W3seTiuEOtqh9WPIPfagDvFA8IZi7GwOABCOS+EcRQzDMBRVVWWG1ghiGIYC9OtqkcI5xki6YZPlJ9AV4yzITAhnrI9G743vQt0r4CrhuZ351PgdZFrj+IZDOONR2LtduEVb9or7cifAvJOhcBpkHGZJeXYnFE0XN04RsdbGamEZV62F7RVC7ItLhWXszu5zN6oC4537aYLQg2BcxWXp/t11WjXCuhW2/RxKLoWiM4eli9OGvR2p36WrdlTZ1NzcPCc/P98rxXNkMAxDaW5uzgI29beNFM4xRtINmy6c/p4xzmiPE2H7Rtj1m0StpsaTlYUck+enyBWlssM5dIvzd8CudVC9WYinJxtmnwCTZwvr7UjBnSUs4mkLhDW6r0pcCFR+BJVrhKU8dZ4Q2h4x0QnuSMrifKk6h+MKfIx3xfp6FUJxFafW3dpzWgxCuiba8lU/A5EWmPIlUfs5hKxLxDc1VSEiGy6MGvF4/JqGhoYnGhoaypHlgyOFAWyKx+PX9LeBFM4xRtLiTCYEpf/eFeNMszgDexK1mvmpWs2mkJVTJ3QQjKtDY3E274WqChErVFTh3py+AHImHPk9b+1OmDpf3II+qNkM1Zvgo9fA5hQCOn2hKHtBxDk/as5gY5uLr62ezq3z93JTeX2fuw7GNZw9LU7NIKSrmIoNxV0C9W+I0WTTvwKWobvI+XRPBzMKPLT4I7I37iiyePHiJuC80V6HpDtSOMcY4b4szkgMp1UjwyHe7tSJMNoOlfeDageLBxChzqSLUFUOIcZpmtBcC1vXiKxYuwvKjhMC4/Qc/AEezrgyYPbxULYUmmph1wbY9pFw504qgxnHMME9kYYaG7/bXgBAR6T/r2AyxpmOw2JgmAoRQ8GhaWI0Wds6iIpyFWyH7uY2TZN1ezo4tayAf1W1SFetRNIDKZxjjKSrNpkQBEJEPQ5L93mOehi2PQzxEDiLUtuGdRUTBadFx6KaBOMaugHaYJxETbWwZbXISHV4YMEKKCk/pFKOIwpFFVm340vA3w47PhWWaM1mvpRRwbtczvO7SwDw7ufCJNRXjFMTf4fjKg5NFxa7ezIE62Hj92H2LanpKgfL3vYQbYEoCydlU1HdJnvjSiQ9OErOZIcvD7y5ndrWAA9+adGQ7C+VHJTmqu0Mx8lwWLrmOUbjYq5moBpcU6jyOihyRfFYjVTtoNtiEE+0WvPHNbIG6nQDooxj47+gcbdoKLDwVJgy9+gRzL7wjBP/h9knwK71FG7/lFftd/CGvpjHzC/QGc3p96nBuEqhs3v802UR70NIV8km7T1xFnVNV5n1NcguP+gl7+sQNaYluW4cVk26aiWSHhzFZ7TDg811Xna3BoZsf+E+smr94TgZdguaqmC3qIRaK8H9AbinEdYVzn19DjeV13Pj3PqUcKa7CH2xAYQzHICtH8DuTaL5QPlJIq53NAtmT+xOmH08NfnH87e393Cd9TXOYC0fdhwD/gUiUSoNw4T2iIWpGd279iTfl1C8DxeAPRdiPth6L0y9GsafclAx5NQcUJsmhDMuXbUSSTryzDbKRHWDmD50J6ZQtK/koBgZDtEwwGkxCXXshrIpoCjs7HQQ1jVawuKjEIwLq9Rt1VMpfP3GOU0Tdm+Ezf8SnX6mL4Cy44VISPqkOFvhZec5zCsvJbxtHaeH3oY318G0+d3+dy/X5LAvaOfWCXXdnu9IuGpDej++c2sGqDbY9SREGmDSFwfdizf5GXLZNBxWVVqcEkkPpHCOMjHdIDqEV/TBPrJq/ZG4KEXx7cClBAiSAaooN9je4QIgkBDHVJs3zcCSKBvrUzi9zfDp2yKOmVcMi06DjP7djhKBw2Ly7nkbAbil8Sx+FTmDl6c8CbvWQ80WKDuOcMkx/HRdMXPHBbhgavf2n10W537EULODqwTqXoNQI8z4ClhcB7zGlMVpFRZne2DAPuASyVGFFM5RJho3iOlDV9cc6qeO02ONQ+WDOCwnEzK6Otds8woLJxDvLpxOi4E9Yd10K0nR47D1Q1FeYnXA4jNFHeaRXlYyCmRadapjubDoszB9EWxaBZtWEdpeSUnYxY0nWOk5NjWZHNSnqzYdNZFx27EBNt0DZV8XJUcHQDDd4rTIwdkSSU+kcI4yMd0cUouzrxinLxwjI7gRzDguS/eT7vZEg4NATNyX7qpNnqR90YRwdjRDxesiCWjKXBHLlG7ZgybLFscXs4is5cxcWPYFqN+F/4MPeMb2I9g9AzI+I8pcEqQszv5ctekoCrgmQbgBNn4Pyr4BGTMGfFry4suZctXKGKdEko7sRDHKxHSD6FDGOHtk1RrxOP5InAylAxyFic4zXW97vxanZpCRaPAeiCHqEd95VkwUOeF8WHyGFM1DJDmTM92ijxZM57Phn/Lv3LNEW7+3fgs714t4MgMkB/WHoxAUm7A8m/6d2ld/9HTVyhinRNIdaXGOMsJVa2CaJsoQuDuTbraobhCO6cRqXsLEjsfpBvw4LQbehAXpi6nUBUS3oEA8aXEmylGsOh6rThGtrNjxJISqRcefhadJwRwiMm3i4qYzZiHbLt63prCVCDb2TDwJlkyAT9+C9f+EvdvgmNNxauMBUW87KGxZIva545cQqoNJK/tNGgpGdWyaikVTpXBKJH0gLc5RJqobmCbEjaGJc6af5Pz7PsZf8zoAGQnrxqkZhBPiWJWwNjOs8bTkoMTwZIuBq2Unr9pvJydcD0vOgqWfk6I5hCRLfDqjXQLWmBg5Nt4VEz1xl18orPvOFnj7d2TXfIhCV73toNAciaShVxLNL/ougwrHdBxWsX9ZjiKR9EYK5yiTLEUZqpKUUMJaAPBXPUOnKsaDJd2uLoueOukm45sLcwPdXLUaOp5t76N88CLNjOOxwltkAtAwkJl4T7xpwtkQEmVDhc5EJquiiHjyZ6+E8SW4Kt/j99YfoYY6D+5Fk0lD3k2w6Qci67YHwWgcl004oxxWlWjcwBiiCzuJZCwghXOUSSYGDVWCUCimk58hTr5+M4vmmEgsyXMIt6AjOV0DEd90ajqzskP4E8lBZiTEM7YfolV9BCXlfFW9kxqlcEjWJulOVtJVG+2KmNQnLM5CV48SEKcHjj8Xc9HpLFR3cHH1g1BXdXAvnEwainlh4/+Bt7Lbw8GojssmPiPJblNyJqdE0oUUzlEmWYoyVAmVIUMYAAAgAElEQVRCoWicfEsbAJ2MoylhwYxPWDAuzUgllmzvcFKaFcJj1QnrGnp7M1fsfYiFyg5YciYcczo2mzb8w6yPUpLJQd4erlqbapDdV6cmRUGZWs5F+g9os+TBmldY98a/xYi2g8FeAJoLtvwIGv6ZShoSrtqEcFrUxH3SXSuRJJHCOcoMpcUZj+tEdZN8i2hu4I9pNCaEsyDR8zSZVWuasM3rYmZ2CI9F53S1AvX951BNnRvU22HyHAA8Vl0K5zCRlZYclKQhZKXQFd2vV7xJK+CBnFv4lXEu8/0fwz+fgfaGXttFdSXVEapfrJngmAC7noLq34ER69vilAlCEkkKKZyjiGmaKUtzKJoghPe9A0CBR5ws/TGNppAVt0XHbRWv40yMpaoL2mgJWynLDHJs+9v8yvYAMU8ePxn3LaqtU1L79Fj1oZnJKemF22KgKmav5KCejd174rAY/H1vHvdEL+Hy6Hcw9Ti8+xzsXNet1OSpbeM549XygapPRLatuwQa3obKBwhFozgTwpn8KYVTIulCCucokp5Je8gWp7eS0M4/AVDgFJaMEE5bytqErs4zHzZmoKFzXvufWNDwJi/oy9mz6DLqzRxcWtdaMqRwDhuKIhKEeiYH9Ypv9sCpGalkrtXGXFqXXQXjp8D6d8QA7Zh4/s5OB20Ra6rUKEmt386dH0+h20dO0UTGra+KUGc9TlV8ZuyWpHBKV61EkkQK5yiSLpaHlFUbboJtDxFS8wDITwilL6bRHLJS4Ow6ESfHUq1tsPNL688oaPyU3RNO4huxG/CbDjHE2tplXWRIV+2wkmWLp5KDTBMagrYBhTM5o3Nxng+ABj1LNKWYu1wkDL3zLHhbaA4LN3168hHAa7Xj+H1VAbt9ju47VhRwFhOMqzgDm6BjU6osRSYHSSRdSOEcRdLF8qCTg+Ih2PZzAEJKFiBOxjbVwJdw1XazOC0G2fi4tOGXnKZ9CgtOpXHqCkAhEFMJxrVuFqfHakjhHEYybV0WZ0dUI2qojB/QVatjUQxumFsPQEPQKkRv1lI46SKIReDdPzDP9zHQPfkIoMYvml4kE8d6EtItuKwabLkXh289AOHowQnnp7Xt7Gz2H9RzJZLDFSmco0i6WB6Uq9Y0YNdvIFgHjvGpbFmnZojYZFSjKWylwNF1Is42OviL7S5KzVqezbkKpi/Ak2ytF9cIxtVUPBREjDMY1xjCroCSNLJs8VRyUEN/pSg9OH1iB9fPaWDuuCAAjaGupv3kF8Npl0NOEbfEnuLHlsfxhbu/ebW+pHDa6ItQXMNpU8E5EUfjKwCEo/sX8/749l82cM+rWw/quRLJ4YoUzlHkkF21+/4OLatFTR5djb+dFiGcjSErwbjWZXEGO1m69deMV9q5Ivo/aMWi4XfSfZu0OJ2WLusiKar+/Y2xkhw0mVY9lRyUEs4BLM6vzG7k1gV15DliqIqZypxO4XBjLL+QX8TP50uWdylb/xvwt6cervELF21fFqdpis+R02KAZsPhSbT4q3kF4sEBj+d3H9bwSW3Xa3lDMWlxSsYcUjhHkfRM2kFbnO0boOY5cE1OdfQJ9WjQvqtTnCDHO6Pg74D3/oRVD3F59HY+MmezIFe0XPMkLEx/wuLsmRwEyAShYSLLFk+5UpNdg8YPYHEmsaiQ54ilBDed9qiNe+MXc1X0W9gjXvjns7BvJzFDYV9i+76EM2oo6KaSiqM6LeKzFfbVweYfQaS113OSmKbJ91/Zwp8+3pO6LxjV2dMWJCJjpJIxhBTOUSTdyhzI4nx7ayMXPvJvIbCheqj6BTgKQO06+fW0OJOWxWTq4f0/gx6jZuGlrDdn4NB0SrNCALhTFqdGKK7isvYWThnnTGAaoEdEn9eoVwhJuEm8J8E6CO6F4J60W514LNwE0XaI+cGIpcpGMm16L1dtumt9IAqdsd4WJ12i+K6xiBem3QyebPjwJfwbPsJMvHZTuPfzkhdfjsTFU/Jn2JIPkWbYeDcEavtcS1sgSjRupEbamaZJIBrHMKG2dWBrVSI5UpDTUUaRdCszMoDF+eqGej6p7WBjbQOLO38OigUsnm7bhNKGUGdYdXRTYZqyj/mbfwuKASd9EVUpAKA8J0iiKUxqVJU3kZzi0vpw1Y5l4TR10KNgJG8RcZ+iAMlOBKYQO0UDqwc0D9hzwOIW3Xc0J6g2cSGjJL9WBhhx0EPiFuuEaAdEW4XbU1HIxElELyIc8tIYmkyeI4ZNO/Ca3vGuKHsSyT7pNKeJ4j4zF065GD59m3G7/sXj1iC36V+luQ/BTV58Jd33jsRnIxxXxXiySJvocTvra5Bd3u259d4wAIGEcAajeqqGdGdzgJnjM5BIxgIHLJyKomhABVBnmubnh29JRw/Rbhbn/k+W6/aIbkAfrn2bxZOaUnHNdFIWp6bjsRoUK008Y/shKkI0yczFGRSvuSCnazKGqgirM3mydfVIDoK0YdZHCqYJZrxLDPWI+IkJSpqjxTRAtYA1G5zjhRja8sRPawZobiGUSYFUbUPT7F4PQ6SNzOAu2OqlU5tIg99kvN0vLDrbOHFhNMBrjXfG+LiptyCli2Jn1AKaBRafwZrYdD6z7zVetnyXO0P/3et5yek4yXpfu9ZjcLY9R1jNW++D6ddAwYmp5zYkhDNpcQbShqnvbul7EotEciQyGIvzZmArkDlMaznqiB1gclBHMMquxIlnTW2EG0uL+9wulDzpWQwmKi3cYn0EJxGUE1dCZi4gYmLnTWnlgqndY1Vuq5462SbjW3AYxThNU4icGRWuztQtChgJMexhHVrcYMsGZ1F3QbR4EmKYIX7XHCM/+UVzgGsCmTkmsI7OydfRoHxCcQEw6UKR9BWqBVMBez5Y+h7nVuiM0hG1EI4rOCxdF1/Ji6Ace6yrM5Gi8KZ9BQ/rC3hMe5D/F70H6k6HiTNSz0v3WgDYVRMFk4ie9v+xesTFxo7H6Ohsx1NyDhaLRr1XuP79kYTrP62EZZdMEJKMIQ5IOBVFKQY+B9wD3DKsKzqKONBylKS1OTPDy9r2AuLmXix9nOdT8amYj/9seRqb4udWyzd5PLvrpGVR4eHlu3o915NucWrdGyDAMGXVmmaaezTW9btiIkQwXQgNYe1ZM4U1ZssCW07ilpWwCNOtQ3e/g5oPJ7Kc4n/e6o9S1xFm8ZQJUHwKTPwchBugdS00vAmBRiHyttxuIp9MJGoK25jsiaTubw5ZcVl0Cl1ROtMuemr9dprdJfxl4tdYuOM5Fq55GWYdB3OOB0VNfYaSF0+KIqzOXoOzNQeGczIrno5x4+LnuebcC3u5atMtzl3S4pSMIQ7U4nwQ+DYggxRDyIEmB63btRcFk2tm1XNbRRmb2twszOt9IgrpKnmqD8sHfyUz7uWS6O2QORGo7L3THrgsRipZpC9X7UHFOA29K75nhBNxw6RlmLCOLBnCKrTlJKzC3DQhdImfqThi33WHRzKZCeF8+sMafOE4n50tyj9EF58iKP48TDgLOrfC3pfBt13EU+0FoCipZgkNQWt34QxbyXfEyLLpeNM6B9X67Uz2RHBnurg4+l3WTnsAz7Y10NEEx55FMC4cSs40r4PT0jX8PJ2gYac9amd9bSNUPUZDx/FAl6s2+XNKrktanJIxxYDCqSjK54Em0zTXKorymf1sdy1wLcDkyZOHbIFjmWi8y7XWb3JQPMi67ZuZmWllxaQQVMCapow+hTMejfO49X7wtfPulKuoqCzjHEfbAa3FbdVp7XAB3V21rkQj8v3GOE1DZJnG/SKxRlERwmgRJ/+M6eCaIE72tixhNVozjxircDjJdAjhfHVDPbOLMvnMrPzeG6kWyJ4HWeXg3wV7XgDvRrBkUOgUmdM9S1Kaw1bynTEyrTrViYYHpimEc9n4TgocMSLY2Dr1PI4tyIP178J7z6GUXA7QrZbXoZm9LU5EFjbAzkAutP2d+vo8wJMSzGBU/Jw3MYtXNtTTHogyzj32Ln4kRx8HYnEuB85TFOUcwAFkKorye9M0L0/fyDTNx4HHAZYsWSLHxR8A0YEsTtPA3Pkb1rUUcubkTgqccaZlhvioKYPr5vQYI2UYfKHl98xRqmDJOfhiUwG6tdvbHx6LgW4KF6Ar7aSpKMKN2y3GacQh1gF6gJQ71VkMOQvBM12UydjzwJo18rHDI4ykqxbgxhXTUfb3/1IUcREy+1bw7YCaPzA+WAXMozFkZY/fRn3QxtICP80hKzOzQmRYdbxRNwDNYQvBuMYUTyT1uWiK2GDaAsjIhTUvc/yWX3GCmpFKDgJRkhLqQziT7vtdPuG2bUgYldG4kShLEZ+jpHDuagmwWAqnZAwwoHCapnk7cDtAwuL8Zk/RlBwc6clBfcY4971Odc1GOmJTWJgrzkrH5ft4pTYH3QAteS4zTVj3NuXhTTykXsbNxQVk7BUnrfQG7/sjvbF7usUJiUbvUVPUJZIoyciaC+MWiHFUzgliNJVk0GQ6xVdwap6bs8uLDuxJigKZM6H8TjJb1+J4o57ajihX7ZxJfdDOJys/pSlkZXlhJ1bVTDVYqE3W9WakCWcy+za/GFZcQvDdV/md9UcE9p0GmaLcpM8YJ6LTFEBY16gL2tkXdmFTdaKGRqCzIRXjnDdR9FDe1exn8ZRxB/FfkkgOL2Qd5wjR1BnGoqnkpF1x79fi7NgMtc/xaWARAIsSrtmlBX7+sLOAqk4nZdkii5GtH0D1Jl51nsnr5gpuZnMqNnngFmcfwmnEINKIRyvFH1NErC17IXhKujVekBw8dovGfywp5ux5RWjqIK1zRUXJO5bC7H/yXM10ooZ4/nv7MumMWch3xDCBkK4R1RVqE/WeUzxhxtnjWBSje79adzZ/K7mBSVte5NQtb4qmDfM/g0PrO8aZnjD2SYuHiK5Slh2kssOFf9PDBOJfAqCsKBOLqsgEIcmYYVDCaZrmu8C7w7KSMc6Nz35CUZaThy9ZlLov1l9WbbgZtv+CffGJ3LdxMuOdUWZmCpFMWp7rWtxCOHdvhMo1MGUuf+g4H5cuBHBaRpjxzijzcw7sZJXe2N1leiHQILJYCz7DDy+cjyd7EhRlHfTxS/rnpxctOKTnj890Ut0a4ry5WbxZ2caftovGGPnOWErwOmMaNT47CiYT3VFUBfKd8V5t9zpNF9fEvklV6c/Qdq4Ffzu56mR8uqfX6wZjXWL6rwaRVDQjM0Rlh4tAFAL73gFKyXRYmJzrYlOd95COUyI5XJAt90aIJl+E1kCk231JsXRYVaLJBgh6GLb/nLaIhStWHYMvpvHkKVUpt2xJRoRsW5x1rR5oqoF1b8P4Elj0WYK6JZUNOd4VY80F6ynNDh/Q+tLjmi6rDtP/CxY/CFMvZ/HscmZJ0TxsmZbvYXymne+vPI7lpYW80zQBgHy1hSybcJd2RjVq/XYmuKLYE52JChzRXsIZiquoCmgLTobFZ0DzXu4O3EtGrJ2eBNIszn81iM/HzKxESYqSRyBmxa7qWELVnL9gIquqWvi4+sCS1SSSwxkpnCNEIBIn1GOmYdJV67FbhPVpmlD9ewjs4dfV86j2OXjilCrKc7r6fCoKLMj109rkhTWviqSOpeeAKmrwHFr/ZS39Eg/gMVtSfzqO+SEUnAQW18EdrGRE+b9z5/DG108hy2XltNmFGIlrsPwsB5nGPgC8UQs1fgeTM7ou3vKdsW6t+YDEdJzEZ2jKXDjxQsaZXn4a/hG0N3bbNlmiVOyOUJ/I6p2R6H/si6n4TbcIGWz6EV9ZqFOY6eD7r2zBMGTuoOTIRgrnCBGI6AR7CGcsUY7islmE9dn4DjS+B65JtISt5DpiHFfQu/7thKxG/jfycwxVg2Xng1XErsLJcVAHihGHQA3oIdxFJyTWoqFaZPzySMJh1chyifdsxayC1P0FC28ka8JxAHQGw9T67UxJq/UscMZ6WZy9PkP5k3g49+tEsYhBAfVdzTOSFmdyyo6mmJRkhFOPBeOaCAFYM3DtuI9vn5zJhr1eXlxXN4RHL5GMPFI4RwDdMAnFdMKxHsKpG2iqgsOqEgt3wu6nRVmHouKPqd0Sdrp2FueSlifJU7xsmnUJuLo6IIbiaq+M2H6JtEBoL0w8Bxb9BE9eKSCEU3LkUpjloHxiJooCORluMks+C0B9yEFL2Mokd5frvsAZoy1iJZrWTi8YV7uVogB47eO5mu9Cxjj44CXYtR7oyqotT8TRC5yi4YJ4TMMfU3FbjETdbhZf0B5ldoGV366uHrbjl0hGAimcI0AgUQgeivV21do0FatqEvXuAuu4VFmHP6Z1S9gBhCt37T/I9O/l67Eb+FektNvDfZ30emHEIbBbdOuZ9z2Y/EWwuHHZRJ5Y8qfkyOWy46ZwSmk+Vk1N1Ylu0k4DYIp1j2h4T1fGdUuauzYY7+21sGsmdXoOnPxFKCyBdf+ETasIxBRcFj2VuFbkiqYu9nwxjUBcw50sc7JmoNrGcXLmJrbs88r5nJIjGimcI0AwUQjeK8YZN7BqCtZYE1ED0VUnQSCupUpKUmxZDXu3o5SfxHb3fJEglEZYV1NjoPok1gnBWph4LpT/rygrSeC2C0tTWpxHPpcsncxvrl4KdLX027hPxMmnzDwFIg0QbWd6QvA2tXfFssN6b6+F02IQ0VWw2OD482DqfNheweeb/kCWJcL0TGHFFrmiqYu9QEwlGFNTs14BsGawID9GzIBtVeuG5+AlkhFACucIkGxBFo51PyHFdAObEsVmBoji6P6cmNb9pFO7BbZ9BCXlMHMxC3P9fNriTs07jBsQNfqxOE1TDFM2IjD3dph8Ua++rx67sDSdUjjHFA6rhs2isrXBB8DkWSug/LugaCx0bseh6axu6HL3B+MaTq37BZtDM4gaKroBqCosPBXmLGdhaC0PKg8yyeHHZdGZ5IlgVU3smkEgruGPa3h6eE3m5Yt9r//079CxaXgPXiIZJqRwjgDJnp1R3SCeXrvpb8BGCJvFRszo/lb4Y2pqMgltDfDJW5A/SZy0FIVj8vw0h21s6RDjpsI9BhCnMA0I1oCrGObfDVmz+1xj0kXrlq7aMUeW00o0bpDtsgrXrWcazL8Le04Zx+Y0sbqxa3ZDqA9XbTJTO5L8jCoKlC3lKddlLDE3Y/n3X3hxxVqun1MPdLVoDMS0Xp/HYneUHHuMDZ2FUPkAdGwZxiOXSIYHKZwjgD9tvFI42eggUEPMuwOrpmLT6JagASTiQwaEA/Dhy+Bww9LPpZqin1fSRpYtzk/WiYHWweRIsfSTnhET8cz85TDn22DP7XeN0uIcu2Q6xHs7OSetvMiaAbNuZtmMArZ7XTT5RLxzf8IZiqs8vyuX9oj4jLxuOYkHnNeCt5nSdU+TFRfj79xWnUBMIxBPJAeloSgwPyfAxo4sEdOvvB86tw3LcUskw4UUzhEgGeOERJwz1gmVDxEzbVhVsKomMaO7cPpjGhlaBNa8ArEwHH8u2LuGGWfZdG6au4/367NYVZ9JWE8MsU66avWwiGdO/qJoZjBAL9lkjNMthXPMkUwQ6iacAKrG8sUnA/BBgx0izQT7iHEmL8bWtni49cNpvFgtLsACMY2tzgWw/AII+eG956CzFbfFIBBX+47TA/NzA2z3OgkqWWDNhi33QmfVUB+2RDJsSOEcAZJZtQDhSASqHod4JxHs2DQDm2Z0E86orhA1VM5pfwFa94kOLtkFvfZ7RWkTk9xhfvjpJPyJ0gCnJTHiK1wPM66F4vMSY772T9JV65Su2jFHMkFoSm7vhhZzJ2SR6bCwOn4GWDMJxegzxgnwjz2iQXtrIgs3lTWbP0lk3Bo6vP8nFqo7aA5bMUylK6s2jfk5AQxTYXObS1i+1kzY+lPw7RzS45ZIhgspnCNAIN3i3PsmdGwAx0RihoJVNbGqZlf8CAjEVS7R3mae90MoXQLFs/rcr10z+Z9Fe9na4eL/KqYA4CIAkVaY9Q3R/ecA0VSF/Aw7BRlyyslYI2lxTslx93pMUxWOn5bL6poglN9JSLfiNNpE2VKCpHC+XZcNQGtEXFx1qzXOLoBTLgaLjf8NPkhRcDdAL1ctCIsTYH1bYj3WTGJKBuGN94J/9xAcsUQyvEjhHAECaTHOYN374JoMikLMULGpJna1h8XZVM9dlt9QnzET5i7f774/N7mdr86p5+NmkeDhML1iXmPOwkGv88Ubl3PdKdMG/TzJ4U1yWPbkPixOgOUz8tjTFmJHm0ncVHDlzBQJZXFRrpIUzo6oEMy2hMUZjGvd3bqebDjlYrxaJg8YD7Bc3dg9MzxBgTNOkSvKxtYuIb9v6xwuXnUybPkJBGoP/aD7wTBM7nhhI5UNncP2GpKxjxTOESDdVRvSCkAVJ6CooWBTDdEAITnvMOQnd/2L1Jl5bJp+0QG5WW9bsJcLp4iMxqyyyyF77kGtc2K2UzZAGIP0G+NMcNpsEQb4U8UeAJx586D0Rog0Q7SjW8KZy6LTHrFgmHRvcJDE6eHJ/JuoMQv4tfU+SgJb+3zNueMCbO3oitlvbHOzN+gCxSbEMzg8bfk6QjGeWVPLqu0tA28skfSDFM4RIBAKpX4Pm10nr5guXLU2LZEcpMfhw5dQ9BjXxm7F7rT1tbteKHEfP13wIX++YiKzZ5QP+folRzanzMrn/IUTKMx09Pl48TgXx0/L6RJOuwXyjofy74AZxxEXIuO26Cwv7KQ1Ykllcfes0wQwHW4uid7JdnMii3b8Aep6J/5M8UTY47en6pD3+G2ipMqeA6iw+ccQahiCo+9OciJRtOf8W4lkEEjhHG4MHX/z5tSfIb3rXx41VKyaiHFGDeDTt6G9kS3TL6DKLO7TzdWLeABi7VjmfpNj5y5EUQY5DFky5jm2JIeHvrQIdT+DslceU0xHUJSkOK2JzOqMGTDv/3A4hEt12fhOxjtjtEcsBBKTUfr6jLotOh1kcFn0DoIZE+CjV2FPZbdtJnkihHSNlrCFuAH1QRuRZEmWPRcwYcuPxTDtISQlnHEpnJKDRwrncLPvFYKBDlRFXFqH4unCqWBTTWyqwWXKm6I7UNnx1GQIV2tGHxmJ3YiHhDut9GbIKhu2Q5CMfc6eV5QSzG5tFx35jJt/Awomp+XvIMcWpT1iwbcf4UyWoHTipn7hf0DuRPj471DddQE5OTGlpdZvpzFkI26q4pbUM3seGNGEeB6aW/X97c29LM2YtDglh4AUzuGkbR3UPk/AzCDHnmj0nmZxxhIxzqmRKu60/B69cDrMPj4157BXk/d09IgoOZl5A+QsGNbDkIx9PHYLZ5cXAr1Lkgpycnn9a8v4jyWTyFEaMVGoC4gwQl+f0fTaTZfTCsu+AAWT4ZM3oEaI56SEcO4N2Nkb6ApJhNO+H9gLIB4UMc/IwQ3A3tMW5Mpff8RbW8UsUWlxSoYCKZzDRageqh4Bx3gCuoU8h3CDhdMtTl2lwGjhrH2/Z7dZRGjh2aAo+BNzDvsqHgdEqUBoL0y7CvKWDveRSI4SLj1uMhZVYWK2s9djsybkoE6/mpwJ4iKt1pe8uOvLVWuk/a6DxQonnC/Ec+0bULuVYndU7MdvZ6+/qwQqovc4JTkKIe6DLT+FaEfqbsMw2d0SGPCYOsPie+cPd7W9BGlxSg4NKZzDQTwI2x4G1QoWN4GYlhLOdItTM6J8uf1JVNPg2tgtxDSRvLG/+FGq9+ykC2H8iuE/FslRw5KSHDbddSYzCjx9b6Co5ExaBsBerxCivmbGpl/wpSxSzSImq+RPgop/4KzfQoEzKoQz0CWc4Z7CCUI8o+2iw1DUC8AbWxo47f53afCGe2+fRnKwQqSHYEZ1c7/Pk0j2hxTOocY0YOeTIqnBng+IhgZZNh2ranTFOE2T/zF/Q1FsH/+edDG7zaJUSYo/puHQdCw93x3TFKI5/lQoPl80/pRIhhCHdf8tF3PcQuRqVVEn7DK9vbZJCmey1CpF0vLMmwgfv87Ftn8lhLMfV206ziIRz996H8Q6qW4NYpjQ2Ll/4UzO/ezpopWuWsmhIIVzqKl7FVo/Amdx6q5AYkSYQzO6LM6d6zhXXc2q7DNpGTcTEMlCAP642meaP6G9kD0fpl5+QPWdEslQk+sRIrcnIXYezS86VaWRdN/25cbFYoVl50PuBL4e+TUzfBu6WZwRfT8Xg84JEG6Aygdo9ooxad5QbL/rjfQjmNJVKzkU5Nl3KGlbD3v+nOoMlCQQV3FbdZwWQ8Q4m/fCxvd4Uz+Gj3NOxZa4Ko8m2u4FYlpvF1i4UZw4Zl4vXMASySiQ7RKfvT1tojbZPf8WcREXbkxt40nEOPtqtweIgdjLvkCDYzLfMx5jkncz2bbEzNr+LM4kzokQ2EvLvg3AAQhnrIfFqUuLU3LoSOEcKkL1UPULkQmYJmxmssOKxcCpGVgjnfDRq5jubG6J3YBVIyWcybZ7/liPjizRdlAsMOtmsPTd/UUiGQnsFo0MuyUlWO6syVB+p2jWHtoHdLlq+01uA7Da+Gjm5Wwwp3GP+QiXuD4ADkA4AVzFNPvFvr0B/343TVmcencBlRan5FCQwjkUxANQ+VAiGah7YkVEV1JTIjK1CFd3PAl6jMix5+PDhU0zsarJL3e6qzZx0okHIe6H2beAI29ED0si6YuchLvWZdNEUwVHPsz9DjgLIbgXt0VYjwM18JiQpXBV9DY2myXcGn6cU9VPiMQP7JTUEhPfM2/te+L71w+RWN+uWtk5SHIoSOE8VAwddjwhEhcSyUDpJEtL3BaDm/RnmBqvgcVnEXELEUy23AOIGV3JQR6LIcpOwg0w86vgmTpCBySR7J9xrqRwptV72rJh9rfBMxV7uBaLYvSa69mTSe4oPlxcGf0f2h1FPGp9kIz2Axst1pxoNN/p90Plg/2KZzjet6UpXbWSQ0EK56Gy92/QvrZbMlA6ydKS8o4POSP+L/5qOxsmzki5ZdMzD5PJQYGYhscaFxm0ky+bsnYAACAASURBVFdC7rEjcCASyYGR604kBtl7ZOBaPVB2C8q4Obgt8f27aoHxzig21aATN5Xll7HDnMiiqj9AU81+nxczFNojQji9Zjb4d0Hlz/oUz5TFqXf/KV21kkNBCueh0Pox7H0BnJP7LQ0JxFUWKVUsrHuFjdY5/Eb9AkCq9MSmiZZ74r6EcMY13Eon5B4PE88dgQORSA6cnIRwuu19TNKxOKH0JkqyDCbbm0h1ce8DTYVidwQFk8njFC6LfgefPRc+eAma9/T7vNZw1+t6oxZx0Rqohq33Q6x7zDNZjtIru1YKp+QQkMJ5sARqoeoxcBSlxoSls7PTQVvYQiQQ4lHbg0RsmTyd9WUChtg2aXF2d9WK+3xRFY/DAdP/U5adSA479iucAJqdP/7357h1uUsImtm/SE3yRCh0xfBYRWP4f0y5BlyZsPpv0FJHVFeo9nUfrt4S7kq+80Yt4qLVWQyBGqi8H2K+1OP9CWYsLhsgSA4eeVY+GKJe2PYgaM5+s1yv/GcpP/m0kKlbnyeLALvnXIRhdaZa7qULpzWtHCUe8RExNDxFx4qrd4nkMCMlnLb+myU4HQ5ss74CBSfuVzy/Vl7P/y2u6RqWrWTCSReB0wOrX+Tn78PZr81NeWMAmkNCOLNtcbxRsQZvVON7W5bj9zYk2vOJxgzhnuUoMqtWMgSMKeH82ZvbuejR1cP7IkZM9KCN+RPjj3oTjivUBe0sa3qVbF8tt8WuRRuXj8uipxogRNJinElXbSyuEwiKL7zbnTW8xyGRHCTjBrI4k6gWmPafojVkP+K5ON/PWZM6UsIZ1lVwuOGkiwhqHr7S9ktmGDU0pVmZycSgGVkhYXEC/27I5Dfbx/NW62xRU7rlxxBpTStH6S6YEZkcJDkExpRw7mz2s+sAGj8fNKYJ1c9CZ6Vw0fZDXdDOher7nK//k615J/KSsSzVACHZci+WjHGmWZyRcAe+oi8BfSReSCSHCV3JQQMIJ4CqwdQrRZvI/ViemgpW1Uh1DvJqWfxH5A68uPmd7Ud4m7qmoySFc3pmmM6ExdmYsEI/aMoUjUKi7bD5h0TC4nwgLU7JUDKmhDMU1QlG48P3Ag1vQ8NbGM4pfOfjEt6p69sq9Da28kPrk6zW5/Cs/QKAtJZ7GqaZ5qrVTOzJGKenjECGmHbiscvuQJLDkwFjnD1RNZh2JRSetl/xtKtmqgHC09sL2BwuZMvcKwngYOaGZ8Ar5nK2hC14LDrjnVF8MQ3DhKaQWNOHjRliZ45C0EOEW0SHISmckqFkTAnn/2/vzMPkuMs7//lVVVdfc0ozo5E0uiVLlmWDjGzLxhgvpw0Ek2AMxMbecJgEEmyuADnIE47sJuwSlo0hccxCwoKxcQzmWAIEAgTiA3wfkm3Z1q3RPVdfdf32j19VdffMSBpZx7Q07+d59Mx09THvlKb62+9d8gKqfkQUnYDE/9BjsPmrkF/AQc/l65v6ePvPV3Dzhv7mwsFahZUbb2c/Hfyh/z5+vd+Ia9GJyDv1cJTX2I7iDQLgdZ7HWCz8RfE4hRZlKjnOCSgLlrztsOKZc6JUOPdUMnRlAy5cqnir92f4yoFf3gEj+9lbydCb9+lwQzSKUd9OPc4tYzl2JkPjs33UQmOj55XN13grivRxCsfCaSWcFc8UAiRNz8eN8g546n+D2wO2SzkOt/YXfP7qwQXc9kw80SeK4L7vkw3GeK9/I8OqnaeG82SsCNfW5OM8TiWw0rm0mWgM1zEi6muLsZqxvT03xU/zgnCS6W3PknUsejtyR/dEZcHiaw4Zts3aUbqP0yxGiGjPhOy3e/hy33sABf9xB5nSAXpyPp3xfNthz2FPJUN7xty+O/E6gRqmItcr7Ya99zR4nIf+cP2ZH27kh48PHt3vJswoTivhLMXCmQjoccEfMZNJVMbM46Q+T/NP1m5jcVuVf9vRZR77+C9h7zZub38z+/IDLG6vmnF7saeZeJyV0EqrBDPhQTKr3mN+VKgp1RKPU4RTaE0KrsMPbngJV62bfOjHYbFs43lOUjCUtese51hg05YJUQr6Cx5P+AOm2hbNn5Q+x5mZnXS68bxaz2Z3xWX9nFG6sz737GkQzrQYz4Wnb8IbNf2hXhihJ+kx1VrzpV8+xw8e3XX0v5swYzithDMRzPLxEs7Qg6duAn8IsvU5seWgvmj6/L5RfrO3nWjbk/D0/bD0BdypL2F+scaqrkr6OCCtHKwEFvFAE7ILXkumayVgKv2STfVFV4RTaF2W9raRdZ5nOiEpGOq7xEzHigUsZ9eLg0q+lV43cwseu8oudMyGi6/E0T4fGP48vZHJeSYe59y8xwV9o9y9uyP9UYkQe5ENhYX4Y9vT+ybzOofKPlU/OuLWFWFmc1oJZynOD1b84yCcOoLn/hlGnoTcvKa7klBtzok4v2+Uuf4OuP/HMHsenPNSdpSyDBQ9VnaavEqy6aQxx+lXDwKQmXMRSilc28IPI8Zij1NCtcJpjWXD0v8KPRdB6TnQmpytUw9xLLApxjtp+wseg3HxT62tl6u9PyGnq5z12FeZy372VDIMew5zCj7r+0bZXsqybSx+fCzEtcgCK4On6ksY/NJuxrNz2HzYHamewCJD4ZTniMKplFqglPp3pdQGpdTjSqkbToZhz4fy8QzV7vg+7Pn5hN2aQDrEoGBHXNi1m390/ycVKw/nvxYfh92VDPOLNVbGHmcy7DrNcZaH8GzTA5rJmE/trmPhBZGEaoWZg+XAsndAz3oobyZr1UO1jTtp5+Z99lQyBBHsr2Z4Qi/m50v/K05Q4evup9i53wOgL+9x9izzYXXTiBkekghxkhpJagsAvEc+DQceajJpcLgKwIh4nMJhmIrHGQAf1FqfCawH3quUWn1izTo82w6U2Xag3HQsCKM08X/Modq9d8PW22PRnHiKyvHFmLd85j32LXrVEDe1Xw/5NgbLGSKtGCh6aai2bZzHWQltvJ7/AoBrx0VCtko9TtexyNinVTBAECbHcmD5u2DWi8ipUj3H2bCTtr/gEWrFvmom7eG0ZvXjXfhGetQIb9z+D/QyRF/OT6+1JCpUD9Wqpq8AvtUBGz8Lz30VQiOYO2PhlFCtcDiO+O6std6ltX4g/n4U2ADMP9GGHY4/+/ZjfOzOR5uOlRvCs9VjCdWOPAWbbjZN1NbkvZTJEIP5m36E2red2zp+l38ZWoPWsK1kqvjmF2ssaKtRcMK0OChnmU/Glb7X4VsmZFQXTuNxDpV9OnLSwynMIKwMLP99crk2qn4AWlMKrPS6mVsw182ussu+eMB7b84n2zOHdwUfojMa4mvup5nnDFGIvdRkK1FtnKfpNSzKrqk2KC6C3T+Fh/8cRp5k11ASqhXhFA7NUbk1SqnFwFrg3hNhzFQZqfocKHlNx8q1ulg+b4+zvAM2fpaS1cMtTy1OBXI8lcDid+2f0Lb9QVjxIqxFq9hdcdk6lmVH3EM2UPSwFLxj5W4uW3AQtKbgm8KEanYgHQGWiVtRXMfCCyM2DI5wxpy2SX+uIJy22C7ZrhXUdB5d2koprqoF43ECDJZddpbN9dWb91EKNmWW83bvQyxQe1ny8Ndoi8x2lFJ87Sah2kgrgmicxxkpUDYUFkHkwWOfZtf2xwCo+lG6WUUQxjNl4VRKtQH/AtyotR6Z5P7rlVK/UUr9Zu/evcfTxgl4QTTBq2ycGPS8pgd5B2Hj/0Tj8Mf3n8OnHlzYVNbeSMfIVv7S+QpB72JYczEX9JltDPfuaWdHKYtCp5+SP/iCHfz2kv1Q2U6+5yzA5GD9OKyceJyubVGuhWzcNcrZ82VOrTDzyLkZqqqNSmFl3MZVr6oF43H+fGcncwse8+JjHW7APdFZ/EHwAezSQTrvu41ZjKSV77XIQlFfouA35Dgbv8fthuIidh6sryUbGR0+ob+vcOoyJeFUSmUwovk1rfWdkz1Ga32z1nqd1npdb2/v8bRxAl4QTfAqG28fdag2KJteTb/Elzefxfe3zgJI52A2/6ARXrnjq2zVfVjnXw7KYnlHlYVtVW56fC5PD+fpy/vpqjAAavsg20N++dWAqfr1wwilwLbqHudjO4fxwog1IpzCDCSXsan6EWOL3g1Am94PQJcbkrUjnh3N8R+Dnbxq4GBar9cZe6WbcitRF12BKg1xq/spdLWE1sbjbI8f44UKL6wLcqP3CYCyGay14yjzoXbk/k/Btm9Bdc+J/tWFU4ypVNUq4EvABq31Z0+8SUfGC6MJXmVSjQpHGaoNPXjqC1DexrP+Yv7qwQHO7zUe5AThDHy4+ztYUch7w/djZc3kFKXgM+ufY+tYlu9vncVAsdbwnDJENVj5PnL59tS+Whjh2hZKJTNrLbYfNPkV8TiFmUg2Y1ELIkphPNKv2AGVHSgFc/Me390yi1po8eqBg+lzkulBfXkf+hahLryChWoPV+38e2plU0DY7iZCaeFHKi06alxVBqaddFfZZVlHXFlLD+z4Ljz4EXjir2HPr6C677DLuYWZwVQ8zhcDbwNeppR6KP73mhNs12HxgmhCr2ZjcdCU+zijEJ79Mgw/CvkFbBwqEGiLj60100VG/IaWEK3h/h/C8F6+Oftt7HbmNL3UBX1jXH+mGdM1vxjnX6MAqrtg+buhMJ+sY6GU8Yj9QKdhWjAeJ5j+zUWzJ9/xKQinM1nHbh4Csvi1Zlh7eQf9BY9hz6HTDTi/r76oOpkeNCcfX3N9C/mQ9X66goNkfvVNehlKPc5aqPAiK21zaQrVAvtrDl5kpW1kw0HOVNYXFkJpOzxzCzz4YXjgRvNhe/v3YN99MPSo6fce3mi+HmZxt3B6cMRmQa31LwF1pMedTLwgwg81fhilbRuNxUFT6uPUGrZ8A/b+CoqLQSkO1szpmFfwyNpRs8f55H2w42lYczEPH1hDwZ54cXzgnB08O5rjFfOHzOuXt8HAFTB7HQBKKfIZ2+Q4w4iMU79wM7Y5xWvmdaZeqCDMJHIZcz0cKBsRbCt2wMIPwRN/TX92BOjg5fOHaLhsUo9zTr5eBftk5gz+Lv8ebhy7iVvdT/E39o1spIAXWdRCRVsh3pQyLlS7Ky48WtlVgS0wEu/6RCmzezfZvxtWYehx2P8bAO7e18vWUpE3L46nIK39G8j1IJy+nJLNgpP1azaGbo/ocWptQjC7fmjK0eNezaH4QunKBnRkgrpw7tgET/wnLFgFK9ZRCWxyzkThzNqaf7xkE69ffACqO6BrDQy8oekx+YxNxQ/xgmicx2l+1tkDEqYVZia5+BrYP2ZSHcWsA24nrP4w/UVzvTWGaaHucfbl61X2xUzIQ9ZK9p77JvrVAT5R+R/M4QBeqJpCtf444Uy2qqzqMiHeEf8QIwXtHOR6obgQigv526fW8mePrOWgvXjCsBTh9OSUFM5a3MpR8Sa2oGQda0KO8/uP7OLy//UfhMm6sV0/hq3fhMICU44ec6DqUHRCsramww1NqPbAIPzmB9DdD+e+EpSiEljpNKDJDTwAmU5Y8W7T4N1ALhZO43HWLzI38TglvynMULKJxxm3mqWLst1u1q97FWd3j3JJ99NNz5nM4yw6EeXAYrRjEdd5H6FLD/MN95PoyhheVJ+B29jTCabdBaiHar0jT++qBoqH9hfxI4vvxUWFwunPKSecWusGj3NiQVBPW3ZCqPaR7UNs2DXCntEq7PkFlU1f51cjayYMODjoOXRl41mxmZBMdRjuvguyBbjw9WCbC6kcWOn4vAkEFQhLsPJ9kOmYcHfetan6IV5DmBnqOU4pDBJmKonHuW9snHACl65ZxndveAX5XBZq9SrXjiTHWagLZ8EJKfk21dDifr2Sr/a+mx41wtKHvkq/3p8OVhgfqt1ZdnGtiHkFD9eKJq+qH8cD+9vwIgvXivjWcxKenSm0tHB+9kdP8v1Hmtf7BA1LqhtDsmUvQCnoLmYmhGqTKSDbn/01bLqFOwbXcvXP1qTDChIO1hxmxcLZlxnjxtEvQBjARVdArlj/uYFF3pkkHByFUN1pRogVF036O+UzNrtHaoxWg6ZQbdaxac86LJolhUHCzCSXGR+qHSdcuR5Y/VGwXKiZXvEVnRWydsSyjkr6sLZMRCmw0uEHw+0Ludb7KI5f5vbsJ1igTBHf+FDtrrJLf8EMLul0g0OHahu4Z3c7ltK868xBHtjXxpZS8YjPEU59Wlo4b/31tgkLZRs3t48P1RZdh0LGmdCqMlIxt3c8/WPIz+OZMdMW8uxI8yLegzWHLjeAKOKG8j+yQO+CC14HHc2fJCuhlc6dTdEaylth/mth9gWH/J2W9Ra5f8tBfv7U3tTLBHj7i5fwmTedg2VJjkSYmWSd5lDtpKv1cn1GPJUDtX2s7Smx4ar7mTvO4ywHdjpurz0T8qBewS9XvJ0CVX5/7+c5Q21rGvgOdeEE48mOTCFUe8+edtZ0l7l6+V4Umm9vW/C8fnfh1KKlhbNcCyYMM2gUzvHFQXnXJufaVPxmURsZMZ9Od3hzwM6xbczMk90cf004WHPodn145Gec5W3gv+lrYc5Ez7Ec2BOraqs7oWs1LLjysAUCn73qhXz9XRfwlvMW8KZ19Yvs7IFOLlsz95DPE4TTncTj3FfyKLj2oT9E5vth9UfM97X9jH9Y0YkY8+seZ9LHuT2zgKu8jwNwm/tJOsZ2ND1vV9llXizAHZnwiKHaaqh4aF8bF/SNMq/osX7OKN/atnDSBdnC6UXLCmcUaUpeSDVoFqhkxiuMF86QomtTyNhUGj3OPb9iZNjs3dteNWGULbFgbhmd6HG+xvspPPsw93Zeyj/5r5i017k63uOsHYBMO6z4gwnFQOOxLMVFy3r47288h7etnzycKwgzkaQdZf9Y7chr9Qrz4KyPAZG5/hooZkKqoZ3Oq036OMd8m016gO8v+X1K5HjV5ltgnxHPcmCxs+yysM0MP+h0gyMK54P7TH5z/RwzgfSdqwa5Zsmzky7IFk4vWlY4kzxl7TAeZ8WvC2SpFpJ3HfKubQRVaxj8CWz6e0YCs5tvRylL1LDBZPNo3eMMIjgvfJhXD90Fc5dx/5xX40dWupaokXLQIJxBOS4GunHSYiBBEKZGPcfpNRUGHZLCfON5at/Mmo5JqmYPxqHWjox5n0g2plDs4sraX1ByOuBXd8LuLWw4WCDSijXxPs8ONzxiVW2S31zXa+bbvnz+MO9cvqkpBSOcnrTs/3Ap9hrHe5y1Q4RqK35A0bXTqlV2fBee/QrkFzDim+rZHSWXPZVMGsLZ3OBxju7dz+czf8f+3Dw473I6suZT4+i4AgGtidtRwubJQMWFx++XF4QZSJLjrPjhxMKgQ1FcaMQzrIJnhrIXM+Y94kC8uzMJ1SbXcsGJGGQ2t89/D7R1w913Mbz5OQDOnlUC4hznEYqDnhgqsKyjmvaSCjOH1hXO2hQ8zgbhNB6nTSGjKFdrcZ/mQrTlMhyHXHaU3DRMe2ZXma1jWcIIKI/S/ps7GaKN+1dcDU6Gjji8Mz5cUwsVGkXOjkwx0MAboOf84/77C8JMI/E44RCFQYeibTGs/mMIx8AfST3OA7XE44xDtXHoNmtHOCpiWLXDS66Ezl5euu3rXJP7Of1xP2gSqj1cunLYs5mVlb2dM5EWFk7jcdammOOseCHFDORH7qcSgC4sAStDJbQItEV/3qMa2jy0z+y6vGTuMF5kMTgK3H0XKvB4h/dhiu0mrNsRN1YPjxPOZF1RIdoP3WsnTAYSBOH5kQxAAKYWqm2kfRmc+WHwhyko4zWmwuk2L7d2rQjX1mZWrZuDi9/Io9YZfIKbUc89bJ6TCQm0RblhJ+/3tnTzr9u609ujnpPmT4WZRcsKZyKKh6uqbezXLNVqFEqPkw92o1HUInORJB7jmd0md/GfcV7iojkjWETkH/geDO/joaVXsVEvNO0o1C+2pkHvmFYUgEK+CCuuB2uKISVBEA5L1mnwOI9WOAE6zoBVH6SohwAzCQyai4MAXEuTsXQ6AKGqsvxu5SM8V1gFD/0UNtxNR8Z4ko3h2ls29nPLxvpyhxHfTt8nhJlFywpn4nEeVjiTIqD991Mpj1Kwq+TzxqNMBC4RztWxcP56bzvzCh4rOqv8mfN/mXXwaXjBpTydPxMgHYBwqFBtpWqq7nILXgmONDsLwvEi1+BxPi/hBOhaTXH5lQAcqNnYSpu0CvUcp2s3C+eGoQJlnWXT6jfBwtWw4R4uGrwLi6ipl7MaWk0FQ6Oenb5PCDOL1hXOpDjIHx+qbWhBqdVg89fhyc9RCh0KWTedIZuEVBOP8cx4cHM5sFnYVqN/8D7e7vwr93W8BJa9MK3A606EM/Y8R3ybaqj4yL2L2T6iKFdM6XmhKOO1BOF4YvbTmu/bplocNAnFnlUAHKhaZG2zMN61IkpBPVSbtaJ0ctBjB8y0rrNm1+BFr4Iz1rFo76/5u8znGak2TCoLrDR1E2kjxMn7hDCzaFnhTNaE1YKwqaG4aQDCnodh8N8Ic4uphjYFJ0pnyFaCZo9zoOjRHpelv9J5AOvhn3G39QJuyVwFmB7OrB2lbSZpqNZzePxAkdue6eVnWzWV3ssAM3NWEITjh1Iqrax93h5nw3MPeAWyVgBhjawdpaHaTBKqjaNSjx4o0p31mV/wzPCSNS9h57JX8Br7PpY9eiv4ZgRgpcHjLAUWGiU5zhlKywrnWByqjTRNDcW1mplJmbMDKj5QXERFm7LzglMXvvGh2k43YH7RY5XaytUHvgKdPXyt+1o2j5lioMY5teb1dTro+dkRU4m711lNuX0tIMIpCCeCpLL2qIuDGijEFbl+BDk3B5XtuJZmzDfvCa6tce26x/nogSJrustNA7/8peu4wXsPXaNb4RffhGqJSjz/thqqNIQrOc6ZScsKZ+O82WoQQuTD7p/jPXsbAF1uSFmbPsyk8q3ghKa/suHYcMMf+OrcXr7kfobIycKFVzC3XbFlLEekG+bUNpD0cm0+aI7vsc9IQ8cFEU5BOO4kG1KOyeNsuDaz2TwsejOu8huKgyIylsaPFFrDppFcWjyY0OEG3BVdzI8XXQdjQ/Dz2+gLzVaWEc9O86Xicc5MWlY4Sw2tJtWdv4SHPgLPfhkPI5Zd2TAVx7RFxInSQoA0VJv8gasqHyzdRBdjbDvnKii0s7i9Si202FFyY4+zuSerww0YqYY8VzarvvaOBWm1bz4jwikIx5ukQOhYhNOxrTTkm3VsmPdaXDeHxriUSVVtLbQoBRZ+ZDE72/yhORHEje5qeMmVaL/GNzKf4Cz1HCOek0ayxOOcmbSmcGpNaaw+Qqv23B2gLSguxsOETTvdIBXHZo8zEc6kHcWhYPu4D/w/5vo7+EDwXvrmml6sZFTWLwc7jMeZbb4IOhyfEc/iOd/MlN07WqUcV/lKqFYQjj9JS8qxFAdBXXhzGQuUws3Vx2GaPk4Tqk0iUp3jok2OBW1OPOh9Vj+lF7+VGi63uZ9E794iHucMp7WEM/Jhy23wwI2Udj+QHq65CyBj2kyShH6XGzYIZ93jzKdVtXWP808yt8KuZ4jWvJSPvcZNR2Sd0VlhfqHGT3d2cdAb53FGHh12iRFrgM0HzPG9ozWq4nEKwgkj9TiPZnLQJCQj+xIhbpwfm6ltxVUaL6pXyU42Nq/DDRiOBbKc6+F3an/JFj2HZY/dSveuh8xjMlJVOxNpLeGs7oEd3wcrR5n6J8TGQetJ71VXNqASxn/UsUgWnajuccbPOWf4bq7hX2HpC3BWvJDF7bX0tZSC/zJ/mF8NdjBUc9JWFHQE5W10dM3jmYOaih/SkXPYO1ZL22REOAXh+JNNioNyxyicsfAm04gahdPtWIpLpcnjnKytpC0TptOGqqHNHrq5yvs4e9uXc+7Wb/N+5460Ul+YWbSWcAJYGbDzaSIfxglnaKHQtGcm5jjzTkg+Lg6qBBbs3sJbxm7nAXsNnHPppHsyXzZviHJgo1F0uWF9IfWcl9HRPZBW956/ZBZ+qBkcruLaFo7deqdOEE51ktzksVTVQr14L3k9t+F6zZz5XjIZBz8IG6ruJ3qcBafewpJEt0rk+eGC63ii4zxucO6k+7EfQCTh2plGy777lwML1zLeY7LJHYzH6dqagmNCtVo3e5xJH2e+tAfu/R5b1Vxu6fg9sCb/VS+cM0o2fs6srG+2nXSshMVX05F308edv2QWAFv2lyW/KQgniKQd5ViKgxqfn3iwboOAKreDTOcZeJHNcMVEoMbnOMGsJ0veWyoNM2uHfJe7Zr2Zz4e/g73tcfjPb6e9nsLMoGWFsxTYaV/l+FCta5lcpkZRjSvjwHicjgVzrYP81s4vg+3wYetG3Kw76c8wz4m4KF5E22UdjBdSvwdsl458fPE5FmfP7wJgy/6StKIIwgniePRxQkOoNq2ubQ7Zutk8nt2VTgaarDq2mKlPG6o0vAcNew4jvsM/21eYSUN7t8MvbofK2DHZLJw6tK5w+laacxwfqnUtTcGuFwElFbRFJ4Iw4B8yn6UQjsFFV7DJn3PEBP7L5pmh0D2ZUVj1fnBN+0lHzgxWWDy7SH+naYPZNVKV/KYgnCCyjoVt1ScIPV9Sj3NccVCj5+lFFiPtF5nUj12Z+BoNHme1weMc9m1GfMfkRRedBRe9AUoj8LNbYXT4mOwWTg1aVjjLgU1PzlSzNv7RJqHaxurZUjwRJG+HcP8POUc9w61db0N39U9pg8FVS3bxuXPv4azzrobCQHq8Ix8LZ0+B3nbTBqO1tKIIwomiLevQmc+gJqlHOBqSqtqkSjfJcWbsuJfTsfDDiGFm0Z5VWJXtpiiwgYITpfUTicfpqMh4nJ5db0WZswgueZN5c/j1L8ArHZPtQuvTssJZCqw0VFuLxnucDaP1AotKaJG3Q6yNd8P2p7jZeiP3ZdZSCiwirQ4vnDoiW9vCG168HjV7bdNdHXFl35KeNtqyThqiFY9TEE4M11+yKf6SZQAAEcJJREFUlC9efe4xv07BPbzHmbEt/FAzXPHpLORhzktNUWDDXOxiJkw/lCc5zr68z3A8OahpM0pXH1z6VjjrReDK1qTTnZYUziAy5d+zDuNxJqP1KqFNybd5o/MfsPFeWHQW33ZfTTW00nmSkyX+U8rboO8SmHf5hLsSj3NJj9mekHid4nEKwolhXleeC5bOPubXacuOq6odV13rOhZeEMXCmYHF10D7cqgOpq9RcCIqoU0Y1T3OOXnfTA6aLJJVaIc5847ZdqH1aUnhTMIjs9McZ0NV7TiPsxxY9Jef4+Pq/0DPAKx9OYWMphzY6bi9Q+7Mqw5C2yJY8jZQE0/F6rkdXHvhIl5xplle2xcLpxQHCUJrUxjfx2nHm1HsusfphUY4O3IZsLNwxnvBcsEzecpi+uHcSj+89xc8M6vWs2X4wQymRYXTmDVpcVCkmoqD9NgQ1x38EnvVLFj/W2DZ5O2oaXfepDvzvGFQDpzxR2DnJrUjl7H5xBVrmN1mBDP1OCVUKwgtTZrjHBeqrfd1mg/jB0oenXFkCbcbVr4P/IMQek27fRs9zqSqtl3m1M5YWlI4k6bjtkyIa0XUGoSzFilcO6LghHRQ4uwnb0VrzT/3XA+uEcC8E1FpCNVOCKmENXNxrLwBslMPC/W1x69/jOPABEE4sdT7OCfmNhtv7xtrEE6AjhUmbFvdnnqcJd+iEveVd2cDSoFNLbQOHckSTntaUjjrAw1CcnazcCbtKHnL5+8yn6dQPcC7vfcza3Z7+hhTDWfVNxg0/oHrCCrbYcl15iI5CsTjFIRTg+K44qDxuc5EQMdqQbNwAvS/HGavpxDtBUxPeSW0yNlRU72EDHifubSkcCZNx8VMRNaOJoRqs1ZI71M/5hL7UW7teAv3RKs5o7Peh5W3Q4ZqDs+MGA+xKVRb3gZzLjX/jpJeyXEKwilB03YUJikSaugT7RgvnErBkmsp5sz1XgpMjjPvRE2j+WSl2MylNYXTb/Y4xw9AeHXt38ltfZgvBr/FzeWXA7C8QTgvnjtCKbD5whOmwi39ZFjdDcWFJhTzPPrE+qSqVhBOCeZ15XAsxbyuPDDR08zYhxFOgEwbhaW/DUDZ01RCUzvR7HFKcdBMpSWTdaXGxdSObppV+6LgYd7o3Ymet5zPPHsV0ZhNwQmZX/TSx7x24UHO6n6Umx6fSzmwcSwgGAO0qZyzs8/LLgnVCsKpwUB3gQc//kra4+lf7rjcZuPQ9wmh2phi10JgM6XSEJWgn5x4nEJMSwpnkuNsy4zzOIf28hfRN9mZGWBg3WXktkI5gBUdFaxxDuTi9hqfWb/Z3IgCs7Js1Qch1/e87Vo4q8Csosuyvrbn/RqCIJwcEtGEhqpae5JQ7SFWmCUpmbK7gIoXTOJxinDOVFo0VFv3ONMcZ2UM7v42I7rI13rfCU4m3YSyvLN66BfTGirbYP7rYNYLjsmu9lyGB/78lbz0jN5jeh1BEE4uhwvVHtLjjAuMSp0XUw1t8rbfVC8hHufMpTWFMw3VGo8z8n24+zvg1Xhv+AFqGVNBmwxBaCwMmkBtN7SvgAW/fcLtFgShNZkQqnWOLJyFuBe0rHNUnD7yqtw09EA8zpnLlIRTKXWZUupJpdQmpdRHT7RR5cAiZ5sVYXkr4I+qX4ah3XDe5TwaLca1zTzJZOzeIYUzKAEalr/bLMgWBGFGMtHjrOd2DiWcWccmYytKtYCKzpPLd5LzdpC1IxSaNhHOGcsRhVMpZQM3AZcDq4G3KqVWn0ijxnzbrAgDrqx+l4ujB+DsS9Bzl+FF9QXXice5omsS4dSRqaJd9k7ISWhVEGYyk60VS5i0qjam4DqUvZCKF5LvXgKWQ2fGpy0TTqirEGYOU/E4zwc2aa2f1Vp7wDeAK06kUeXAMt7klsd5dflH3MVLYfm5eFG8EshKPE4zQWhewZvkRbabXs1Z606kqYIgnAIcqo+z4NpN+c7xFF2bUi2g6ofkswVYci2dmarkN2c4UxHO+cC2htvb42MnjFJgs97eAA/8G5uyZ/BX+lpQqi6ccah2UVuN83pHJ37y8w5CdhYsesvz6tcUBOH0IhnynsyoTcTyUGHahEI29jj90PRv91xAZy5Du32YgkThtGcq7SiTKY+e8CClrgeuB1i4cOExGdVW3cfHvS9AWyd3dl1LabMLmOEHQBqq/fR5mwn1OPOiALwhOPvPwSkckx2CIJweTAjVOlMTzqJrM1YLqPghuYwNyuI1L1pFecsPzMzr59kTLpzaTMXj3A4saLg9AOwc/yCt9c1a63Va63W9vceQU/Q8Plj6gpHri94Abi5dK+aP8zhtq/59SmU7DLze7NYTBEFgkn2c8deO3BE8TtdhqOyhdX3wydsvPZs/fNVaqE54GxRmCFMRzl8DK5RSS5RSLvAW4DsnxJrQg4fupk/v4+aOd0FbF1lbE2iLIAIvavY4J1DbD/l5MP+3Toh5giCcmiSil8007+U8XGEQmPVk+8a8+DUa3i7nXAqFAfOeI8w4jiicWusA+EPgh8AG4Hat9ePH3RKt4UefhAN7+e/q99hZWApALh5yUA0tvLC5OKiJKIBgFJa/E2z3uJsnCMKpS39njr+58hxes2YuMPVQbcF12DdWA8bNqLYysPT3wB8BLYVCM40p9XFqrf+f1voMrfUyrfWnT4gllYOw7T5Yuorbg0vS5uJEOGuhRS0N1U7icVa2w/zXQtvSE2KeIAinNletW0BnwQhl0sd5xBxn1qYWmPeb3PgZ1e3LjedZkZDtTKN1JgcVZsG136S85BxGfYe+vAmP5JxGjzOeNzne4/SGINsjIVpBEKZE1rGxFHQXjuxxJky63GHBb4NyIJQq25lE6wgnQK6DwZqphO0v+ABkrQbhnMzj1BF4B2DZO8DOnVx7BUE4JXEdi3942zreesHhOwCKDeHZSdcJul2w6M1Q3XW8TRRamNYSTmCwYvbn9RcSj9N4l9VQNbSjNHiclR3Q9xLoWHVyDRUE4ZTmlavn0NN2+HaSQvYIHieY95/8PNM/LswIWlA4jdfYH4dqsw05zvEDEAgqJkm/8E0y6EAQhONOo8c5IceZYGVg8TWxcE5SuCicdrSecFYTj9OEapurase1o9R2melAbtfJN1QQhNOephznZKHahM7V0P1C8MdOglXCdNNywrm7kqc9E1CIi4JSjzMY53HW9kNhEfRePG22CoJwelPMNuQ4D+Vxgol4LXoz5OacBKuE6ablhHOwmku9TWj2OGuJx6kCCEZg6XVgTWVqoCAIwtFTnEqOM6EwH1a8WyJgM4AWFM58mt+Exj7OhiHv3qDxNGWsniAIJ5Aph2oTutbIh/kZQOsJZyWfVtQC5OykqrYhx2lHsOB3psU+QRBmDo2h2mQ1mSC01F9CEGn2VnP05+uh2qw9SR/nwGWQnT0tNgqCMHMoxh5nPmOjpHJfiGkp4dw35hOhmFOYLFRr4fkBAO78l0+LfYIgzCwKcXh2SmFaYcbQUsH4wVHjaU6W46yGFr5fQQGOK3s2BUE48STFQUcsDBJmFK0pnA1VtbYFGSui6nmEVgeuY0nIRBCEk0LWsbAU5DItFZwTppmW+msYHDGCOafB4wQz1L3q+3jFVek6IEEQhBONUoqi60ioVmiipVRocMQnoyJm54Km4zk7oGbPomZ3S2WbIAgnlULWllCt0ERLhWp3j/r05SpYjZFYrclaAdXcUlSgcW0RTkEQTh5F1zn0nFphRtJSKjQ46tOfH7fXrraHvOswEuTww0hCtYIgnFRW9rezvK9tus0QWoiW8zjPzFXqB3QEQZkLlvVzxyP7WLuwS4RTEISTyhevedF0myC0GC2jQlprBkd85uQbhLO2G2av45qXrKEWRNzz7AERTkEQBGFaaRkV0ho+9zuLeOOCrfGBCMIqDFzBmXM7OG9xN4DkOAVBEIRppWVUyLIUr1rZyVldw+ZAbTfMWgfFhQBcs34RgHicgiAIwrTSmirU4G0mXLamn542N50dKQiCIAjTQWuqUG0PdL8o9TYBso7NV37vfJngIQiCIEwrLSicOvY2Xz/hnjXzO6fBHkEQBEGo03rumz8MnWuguGi6LREEQRCECbSecGa6TW5TBrkLgiAILUhrCadTgL5LoH35dFsiCIIgCJPSWjlOtxuWXjvdVgiCIAjCIWktj1MQBEEQWhwRTkEQBEE4CkQ4BUEQBOEoEOEUBEEQhKNAhFMQBEEQjgIRTkEQBEE4CkQ4BUEQBOEoEOEUBEEQhKNAaa2P/4sqtRfY8jyf3gPsO47mnAjExmOn1e0DsfF4ITZOjUVa695ptkGYAidEOI8FpdRvtNbrptuOwyE2Hjutbh+IjccLsVE43ZBQrSAIgiAcBSKcgiAIgnAUtKJw3jzdBkwBsfHYaXX7QGw8XoiNwmlFy+U4BUEQBKGVaUWPUxAEQRBalpYRTqXUZUqpJ5VSm5RSH51uewCUUguUUv+ulNqglHpcKXVDfHyWUurHSqmn46/dLWCrrZR6UCn1vfj2EqXUvbGNtyml3Gm2r0spdYdSamN8Pi9stfOolHp//P/8mFLqVqVUbrrPo1Lq/yil9iilHms4Nul5U4bPx9fQI0qpc6fRxs/E/9ePKKW+pZTqarjvY7GNTyqlXj0d9jXc9yGllFZK9cS3p+UcCqcWLSGcSikbuAm4HFgNvFUptXp6rQIgAD6otT4TWA+8N7bro8BPtNYrgJ/Et6ebG4ANDbf/Gvjb2MaDwDumxao6/wv4V631KuAFGFtb5jwqpeYD7wPWaa3XADbwFqb/PH4FuGzcsUOdt8uBFfG/64EvTqONPwbWaK3PAZ4CPgYQXz9vAc6Kn/OF+Po/2fahlFoAvBLY2nB4us6hcArREsIJnA9s0lo/q7X2gG8AV0yzTWitd2mtH4i/H8W82c/H2PZP8cP+CXjD9FhoUEoNAK8FbolvK+BlwB3xQ6bVRqVUB3AJ8CUArbWntR6ixc4j4AB5pZQDFIBdTPN51Fr/Ajgw7vChztsVwD9rwz1Al1Jq7nTYqLX+kdY6iG/eAww02PgNrXVNa/0csAlz/Z9U+2L+FvhjoLHQY1rOoXBq0SrCOR/Y1nB7e3ysZVBKLQbWAvcCc7TWu8CIK9A3fZYB8DnMG0AU354NDDW8cU33+VwK7AW+HIeTb1FKFWmh86i13gH8D4z3sQsYBu6ntc5jwqHOW6teR28HfhB/3xI2KqVeD+zQWj887q6WsE9obVpFONUkx1qm3Fcp1Qb8C3Cj1npkuu1pRCn1OmCP1vr+xsOTPHQ6z6cDnAt8UWu9FijRGuHtlDhPeAWwBJgHFDFhu/G0zN/lJLTa/ztKqT/FpDy+lhya5GEn1UalVAH4U+Djk909ybFW/j8XpoFWEc7twIKG2wPAzmmypQmlVAYjml/TWt8ZH96dhG/ir3umyz7gxcDrlVKbMSHul2E80K445AjTfz63A9u11vfGt+/ACGkrncdXAM9prfdqrX3gTuAiWus8JhzqvLXUdaSUug54HXC1rve9tYKNyzAfkB6Or5sB4AGlVH+L2Ce0OK0inL8GVsQVjC6meOA702xTkiv8ErBBa/3Zhru+A1wXf38dcNfJti1Ba/0xrfWA1nox5rz9VGt9NfDvwJXxw6bbxkFgm1JqZXzo5cATtNB5xIRo1yulCvH/e2Jjy5zHBg513r4DXBtXhq4HhpOQ7slGKXUZ8BHg9VrrcsNd3wHeopTKKqWWYIpw7juZtmmtH9Va92mtF8fXzXbg3PjvtGXOodDCaK1b4h/wGkz13TPAn063PbFNF2PCNI8AD8X/XoPJIf4EeDr+Omu6bY3tvRT4Xvz9Uswb0ibgm0B2mm17IfCb+Fx+G+hutfMI/CWwEXgM+CqQne7zCNyKybn6mDf4dxzqvGHCjDfF19CjmArh6bJxEyZXmFw3f9/w+D+NbXwSuHw67Bt3/2agZzrPofw7tf7J5CBBEARBOApaJVQrCIIgCKcEIpyCIAiCcBSIcAqCIAjCUSDCKQiCIAhHgQinIAiCIBwFIpyCIAiCcBSIcAqCIAjCUSDCKQiCIAhHwf8HR6HzyzOYwisAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mean, cov = kalman.smoothing()\n", + "mean = mean[:, 0]\n", + "std = np.sqrt(cov[:, 0, 0])\n", + "plt.plot(observed_sequence, label=\"observation\")\n", + "plt.plot(mean, label=\"estimate\")\n", + "plt.fill_between(np.arange(len(mean)), mean - std, mean + std, color=\"orange\", alpha=0.5, label=\"std\")\n", + "plt.legend(bbox_to_anchor=(1, 1))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 13.3.4 Particle Filters" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "observed_sequence = np.concatenate(\n", + " (np.arange(50)[:, None] * 0.1 + np.random.normal(size=(50, 1)),\n", + " np.random.normal(loc=5., size=(50, 1)),\n", + " 5 - 0.1 * np.arange(50)[:, None] + np.random.normal(size=(50, 1))), axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "def nll(observed, particle):\n", + " diff = observed - particle @ np.array([1., 0.])\n", + " return 0.1 * (diff ** 2)\n", + "\n", + "particle = Particle(np.random.normal(0, 1, (1000, 2)), system=np.array([[1, 1], [0, 1]]), cov_system=np.eye(2) * 0.001, nll=nll)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "mean, cov = particle.filtering(observed_sequence)\n", + "mean = mean[:, 0]\n", + "std = np.sqrt(cov[:, 0, 0])" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(observed_sequence, label=\"observation\")\n", + "plt.plot(mean, label=\"estimate\")\n", + "plt.fill_between(np.arange(len(mean)), mean - std, mean + std, color=\"orange\", alpha=0.5, label=\"std\")\n", + "plt.legend(bbox_to_anchor=(1, 1))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mean, cov = particle.smoothing()\n", + "mean = mean[:, 0]\n", + "std = np.sqrt(cov[:, 0, 0])\n", + "plt.plot(observed_sequence, label=\"observation\")\n", + "plt.plot(mean, label=\"estimate\")\n", + "plt.fill_between(np.arange(len(mean)), mean - std, mean + std, color=\"orange\", alpha=0.5, label=\"std\")\n", + "plt.legend(bbox_to_anchor=(1, 1))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "observed_sequence = [None if 50 < i < 90 else obs for i, obs in enumerate(observed_sequence)]" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "particle = Particle(np.random.normal(0, 1, (1000, 2)), system=np.array([[1, 1], [0, 1]]), cov_system=np.eye(2) * 0.001, nll=nll)\n", + "mean = []\n", + "std = []\n", + "for obs in observed_sequence:\n", + " p, w = particle.predict()\n", + " if obs is not None:\n", + " p, w = particle.filter(obs)\n", + " mean.append(np.average(p, axis=0, weights=w)[0])\n", + " std.append(np.cov(p, rowvar=False, aweights=w)[0, 0])\n", + "mean = np.asarray(mean)\n", + "std = np.asarray(std)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(observed_sequence, label=\"observation\")\n", + "plt.plot(mean, label=\"estimate\")\n", + "plt.ylim(-2, 8)\n", + "plt.fill_between(np.arange(len(mean)), mean - std, mean + std, color=\"orange\", alpha=0.5, label=\"std\")\n", + "plt.legend(bbox_to_anchor=(1, 1))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mean, cov = particle.smoothing()\n", + "mean = mean[:, 0]\n", + "std = np.sqrt(cov[:, 0, 0])\n", + "plt.plot(observed_sequence, label=\"observation\")\n", + "plt.plot(mean, label=\"estimate\")\n", + "plt.fill_between(np.arange(len(mean)), mean - std, mean + std, color=\"orange\", alpha=0.5, label=\"std\")\n", + "plt.legend(bbox_to_anchor=(1, 1))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/books/PRML/PRML-master-Python/prml/__init__.py b/books/PRML/PRML-master-Python/prml/__init__.py new file mode 100755 index 0000000..6b61a86 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/__init__.py @@ -0,0 +1,24 @@ +from prml import ( + bayesnet, + clustering, + dimreduction, + kernel, + linear, + markov, + nn, + rv, + sampling +) + + +__all__ = [ + "bayesnet", + "clustering", + "dimreduction", + "kernel", + "linear", + "markov", + "nn", + "rv", + "sampling" +] diff --git a/books/PRML/PRML-master-Python/prml/bayesnet/__init__.py b/books/PRML/PRML-master-Python/prml/bayesnet/__init__.py new file mode 100755 index 0000000..7edc9bd --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/bayesnet/__init__.py @@ -0,0 +1,7 @@ +from prml.bayesnet.discrete import discrete, DiscreteVariable + + +__all__ = [ + "DiscreteVariable", + "discrete" +] diff --git a/books/PRML/PRML-master-Python/prml/bayesnet/discrete.py b/books/PRML/PRML-master-Python/prml/bayesnet/discrete.py new file mode 100755 index 0000000..c74cb6b --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/bayesnet/discrete.py @@ -0,0 +1,242 @@ +import numpy as np +from prml.bayesnet.probability_function import ProbabilityFunction +from prml.bayesnet.random_variable import RandomVariable + + +class DiscreteVariable(RandomVariable): + """ + Discrete random variable + """ + + def __init__(self, n_class:int): + """ + intialize a discrete random variable + + parameters + ---------- + n_class : int + number of classes + + Attributes + ---------- + parent : DiscreteProbability, optional + parent node this variable came out from + message_from : dict + dictionary of message from neighbor node and itself + child : list of DiscreteProbability + probability function this variable is conditioning + proba : np.ndarray + current estimate + """ + self.n_class = n_class + self.parent = [] + self.message_from = {self: np.ones(n_class)} + self.child = [] + self.is_observed = False + + def __repr__(self): + string = f"DiscreteVariable(" + if self.is_observed: + string += f"observed={self.proba})" + else: + string += f"proba={self.proba})" + return string + + def add_parent(self, parent): + self.parent.append(parent) + + def add_child(self, child): + self.child.append(child) + self.message_from[child] = np.ones(self.n_class) + + @property + def proba(self): + return self.posterior + + def receive_message(self, message, giver, proprange): + self.message_from[giver] = message + self.summarize_message() + self.send_message(proprange, exclude=giver) + + def summarize_message(self): + if self.is_observed: + self.prior = self.message_from[self] + self.likelihood = self.prior + self.posterior = self.prior + return + + self.prior = np.ones(self.n_class) + for func in self.parent: + self.prior *= self.message_from[func] + self.prior /= np.sum(self.prior, keepdims=True) + + self.likelihood = np.copy(self.message_from[self]) + for func in self.child: + self.likelihood *= self.message_from[func] + + self.posterior = self.prior * self.likelihood + self.posterior /= self.posterior.sum() + + def send_message(self, proprange=-1, exclude=None): + for func in self.parent: + if func is not exclude: + func.receive_message(self.likelihood, self, proprange) + for func in self.child: + if func is not exclude: + func.receive_message(self.prior, self, proprange) + + def observe(self, data:int, proprange=-1): + """ + set observed data of this variable + + Parameters + ---------- + data : int + observed data of this variable + This must be smaller than n_class and must be non-negative + propagate : int, optional + Range to propagate the observation effect to the other random variable using belief propagation alg. + If proprange=1, the effect only propagate to the neighboring random variables. + Default is -1, which is infinite range. + """ + assert(0 <= data < self.n_class) + self.is_observed = True + self.receive_message(np.eye(self.n_class)[data], self, proprange=proprange) + + +class DiscreteProbability(ProbabilityFunction): + """ + Discrete probability function + """ + + def __init__(self, table, *condition, out=None, name=None): + """ + initialize discrete probability function + + Parameters + ---------- + table : (K, ...) np.ndarray or array-like + probability table + If a discrete variable A is conditioned with B and C, + table[a,b,c] give probability of A=a when B=b and C=c. + Thus, the sum along the first axis should equal to 1. + If a table is 1 dimensional, the variable is not conditioned. + condition : tuple of DiscreteVariable, optional + parent node, discrete variable this function is conidtioned by + len(condition) should equal to (table.ndim - 1) + (Default is (), which means no condition) + out : DiscreteVariable or list of DiscreteVariable, optional + output of this discrete probability function + Default is None which construct a new output instance + name : str + name of this discrete probability function + """ + self.table = np.asarray(table) + self.condition = condition + if condition: + for var in condition: + var.add_child(self) + self.message_from = {var: var.prior for var in condition} + + if out is None: + self.out = [DiscreteVariable(len(table))] + elif isinstance(out, DiscreteVariable): + self.out = [out] + else: + self.out = out + + for i, random_variable in enumerate(self.out): + random_variable.add_parent(self) + self.message_from[random_variable] = np.ones(np.size(self.table, i)) + + for random_variable in self.out: + self.send_message_to(random_variable, proprange=0) + + self.name = name + + def __repr__(self): + if self.name is not None: + return self.name + else: + return super().__repr__() + + def receive_message(self, message, giver, proprange): + self.message_from[giver] = message + if proprange: + self.send_message(proprange, exclude=giver) + + @staticmethod + def expand_dims(x, ndim, axis): + shape = [-1 if i == axis else 1 for i in range(ndim)] + return x.reshape(*shape) + + def compute_message_to(self, destination): + proba = np.copy(self.table) + for i, random_variable in enumerate(self.out): + if random_variable is destination: + index = i + continue + message = self.message_from[random_variable] + proba *= self.expand_dims(message, proba.ndim, i) + for i, random_variable in enumerate(self.condition, len(self.out)): + if random_variable is destination: + index = i + continue + message = self.message_from[random_variable] + proba *= self.expand_dims(message, proba.ndim, i) + axis = list(range(proba.ndim)) + axis.remove(index) + message = np.sum(proba, axis=tuple(axis)) + message /= np.sum(message, keepdims=True) + return message + + def send_message_to(self, destination, proprange=-1): + message = self.compute_message_to(destination) + destination.receive_message(message, self, proprange) + + def send_message(self, proprange, exclude=None): + proprange = proprange - 1 + + for random_variable in self.out: + if random_variable is not exclude: + self.send_message_to(random_variable, proprange) + + if proprange == 0: return + + for random_variable in self.condition: + if random_variable is not exclude: + self.send_message_to(random_variable, proprange - 1) + + +def discrete(table, *condition, out=None, name=None): + """ + discrete probability function + + Parameters + ---------- + table : (K, ...) np.ndarray or array-like + probability table + If a discrete variable A is conditioned with B and C, + table[a,b,c] give probability of A=a when B=b and C=c. + Thus, the sum along the first axis should equal to 1. + If a table is 1 dimensional, the variable is not conditioned. + condition : tuple of DiscreteVariable, optional + parent node, discrete variable this function is conidtioned by + len(condition) should equal to (table.ndim - 1) + (Default is (), which means no condition) + out : DiscreteVariable, optional + output of this discrete probability function + Default is None which construct a new output instance + name : str + name of the discrete probability function + + Returns + ------- + DiscreteVariable + output discrete random variable of discrete probability function + """ + function = DiscreteProbability(table, *condition, out=out, name=name) + if len(function.out) == 1: + return function.out[0] + else: + return function.out diff --git a/books/PRML/PRML-master-Python/prml/bayesnet/probability_function.py b/books/PRML/PRML-master-Python/prml/bayesnet/probability_function.py new file mode 100755 index 0000000..e064169 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/bayesnet/probability_function.py @@ -0,0 +1,2 @@ +class ProbabilityFunction(object): + pass diff --git a/books/PRML/PRML-master-Python/prml/bayesnet/random_variable.py b/books/PRML/PRML-master-Python/prml/bayesnet/random_variable.py new file mode 100755 index 0000000..c33337f --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/bayesnet/random_variable.py @@ -0,0 +1,4 @@ +class RandomVariable(object): + """ + Base class for random variable + """ diff --git a/books/PRML/PRML-master-Python/prml/clustering/__init__.py b/books/PRML/PRML-master-Python/prml/clustering/__init__.py new file mode 100755 index 0000000..169827c --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/clustering/__init__.py @@ -0,0 +1,6 @@ +from .k_means import KMeans + + +__all__ = [ + "KMeans" +] diff --git a/books/PRML/PRML-master-Python/prml/clustering/k_means.py b/books/PRML/PRML-master-Python/prml/clustering/k_means.py new file mode 100755 index 0000000..d3f890b --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/clustering/k_means.py @@ -0,0 +1,53 @@ +import numpy as np +from scipy.spatial.distance import cdist + + +class KMeans(object): + + def __init__(self, n_clusters): + self.n_clusters = n_clusters + + def fit(self, X, iter_max=100): + """ + perform k-means algorithm + + Parameters + ---------- + X : (sample_size, n_features) ndarray + input data + iter_max : int + maximum number of iterations + + Returns + ------- + centers : (n_clusters, n_features) ndarray + center of each cluster + """ + I = np.eye(self.n_clusters) + centers = X[np.random.choice(len(X), self.n_clusters, replace=False)] + for _ in range(iter_max): + prev_centers = np.copy(centers) + D = cdist(X, centers) + cluster_index = np.argmin(D, axis=1) + cluster_index = I[cluster_index] + centers = np.sum(X[:, None, :] * cluster_index[:, :, None], axis=0) / np.sum(cluster_index, axis=0)[:, None] + if np.allclose(prev_centers, centers): + break + self.centers = centers + + def predict(self, X): + """ + calculate closest cluster center index + + Parameters + ---------- + X : (sample_size, n_features) ndarray + input data + + Returns + ------- + index : (sample_size,) ndarray + indicates which cluster they belong + """ + D = cdist(X, self.centers) + return np.argmin(D, axis=1) diff --git a/books/PRML/PRML-master-Python/prml/dimreduction/__init__.py b/books/PRML/PRML-master-Python/prml/dimreduction/__init__.py new file mode 100755 index 0000000..16e942e --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/dimreduction/__init__.py @@ -0,0 +1,10 @@ +from prml.dimreduction.autoencoder import Autoencoder +from prml.dimreduction.bayesian_pca import BayesianPCA +from prml.dimreduction.pca import PCA + + +__all__ = [ + "Autoencoder", + "BayesianPCA", + "PCA", +] diff --git a/books/PRML/PRML-master-Python/prml/dimreduction/autoencoder.py b/books/PRML/PRML-master-Python/prml/dimreduction/autoencoder.py new file mode 100755 index 0000000..4f5bae6 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/dimreduction/autoencoder.py @@ -0,0 +1,38 @@ +import numpy as np +from prml import nn + + +class Autoencoder(nn.Network): + + def __init__(self, *args): + self.n_unit = len(args) + super().__init__() + for i in range(self.n_unit - 1): + self.parameter[f"w_encode{i}"] = nn.Parameter(np.random.randn(args[i], args[i + 1])) + self.parameter[f"b_encode{i}"] = nn.Parameter(np.zeros(args[i + 1])) + self.parameter[f"w_decode{i}"] = nn.Parameter(np.random.randn(args[i + 1], args[i])) + self.parameter[f"b_decode{i}"] = nn.Parameter(np.zeros(args[i])) + + def transform(self, x): + h = x + for i in range(self.n_unit - 1): + h = nn.tanh(h @ self.parameter[f"w_encode{i}"] + self.parameter[f"b_encode{i}"]) + return h.value + + def forward(self, x): + h = x + for i in range(self.n_unit - 1): + h = nn.tanh(h @ self.parameter[f"w_encode{i}"] + self.parameter[f"b_encode{i}"]) + for i in range(self.n_unit - 2, 0, -1): + h = nn.tanh(h @ self.parameter[f"w_decode{i}"] + self.parameter[f"b_decode{i}"]) + x_ = h @ self.parameter["w_decode0"] + self.parameter["b_decode0"] + self.px = nn.random.Gaussian(x_, 1., data=x) + + def fit(self, x, n_iter=100, learning_rate=1e-3): + optimizer = nn.optimizer.Adam(self.parameter, learning_rate) + for _ in range(n_iter): + self.clear() + self.forward(x) + log_likelihood = self.log_pdf() + log_likelihood.backward() + optimizer.update() diff --git a/books/PRML/PRML-master-Python/prml/dimreduction/bayesian_pca.py b/books/PRML/PRML-master-Python/prml/dimreduction/bayesian_pca.py new file mode 100755 index 0000000..9e9e280 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/dimreduction/bayesian_pca.py @@ -0,0 +1,59 @@ +import numpy as np +from prml.dimreduction.pca import PCA + + +class BayesianPCA(PCA): + + def fit(self, X, iter_max=100, initial="random"): + """ + empirical bayes estimation of pca parameters + + Parameters + ---------- + X : (sample_size, n_features) ndarray + input data + iter_max : int + maximum number of em steps + + Returns + ------- + mean : (n_features,) ndarray + sample mean fo the input data + W : (n_features, n_components) ndarray + projection matrix + var : float + variance of observation noise + """ + initial_list = ["random", "eigen"] + self.mean = np.mean(X, axis=0) + self.I = np.eye(self.n_components) + if initial not in initial_list: + print("availabel initializations are {}".format(initial_list)) + if initial == "random": + self.W = np.eye(np.size(X, 1), self.n_components) + self.var = 1. + elif initial == "eigen": + self.eigen(X) + self.alpha = len(self.mean) / np.sum(self.W ** 2, axis=0).clip(min=1e-10) + for i in range(iter_max): + W = np.copy(self.W) + stats = self._expectation(X - self.mean) + self._maximization(X - self.mean, *stats) + self.alpha = len(self.mean) / np.sum(self.W ** 2, axis=0).clip(min=1e-10) + if np.allclose(W, self.W): + break + self.n_iter = i + 1 + + def _maximization(self, X, Ez, Ezz): + self.W = X.T @ Ez @ np.linalg.inv(np.sum(Ezz, axis=0) + self.var * np.diag(self.alpha)) + self.var = np.mean( + np.mean(X ** 2, axis=-1) + - 2 * np.mean(Ez @ self.W.T * X, axis=-1) + + np.trace((Ezz @ self.W.T @ self.W).T) / len(self.mean)) + + def maximize(self, D, Ez, Ezz): + self.W = D.T.dot(Ez).dot(np.linalg.inv(np.sum(Ezz, axis=0) + self.var * np.diag(self.alpha))) + self.var = np.mean( + np.mean(D ** 2, axis=-1) + - 2 * np.mean(Ez.dot(self.W.T) * D, axis=-1) + + np.trace(Ezz.dot(self.W.T).dot(self.W).T) / self.ndim) diff --git a/books/PRML/PRML-master-Python/prml/dimreduction/pca.py b/books/PRML/PRML-master-Python/prml/dimreduction/pca.py new file mode 100755 index 0000000..55d7b7f --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/dimreduction/pca.py @@ -0,0 +1,156 @@ +import numpy as np + + +class PCA(object): + + def __init__(self, n_components): + """ + construct principal component analysis + + Parameters + ---------- + n_components : int + number of components + """ + assert isinstance(n_components, int) + self.n_components = n_components + + def fit(self, X, method="eigen", iter_max=100): + """ + maximum likelihood estimate of pca parameters + x ~ \int_z N(x|Wz+mu,sigma^2)N(z|0,I)dz + + Parameters + ---------- + X : (sample_size, n_features) ndarray + input data + method : str + method to estimate the parameters + ["eigen", "em"] + iter_max : int + maximum number of iterations for em algorithm + + Attributes + ---------- + mean : (n_features,) ndarray + sample mean of the data + W : (n_features, n_components) ndarray + projection matrix + var : float + variance of observation noise + C : (n_features, n_features) ndarray + variance of the marginal dist N(x|mean,C) + Cinv : (n_features, n_features) ndarray + precision of the marginal dist N(x|mean, C) + """ + method_list = ["eigen", "em"] + if method not in method_list: + print("availabel methods are {}".format(method_list)) + self.mean = np.mean(X, axis=0) + getattr(self, method)(X - self.mean, iter_max) + + def eigen(self, X, *arg): + sample_size, n_features = X.shape + if sample_size >= n_features: + cov = np.cov(X, rowvar=False) + values, vectors = np.linalg.eigh(cov) + index = n_features - self.n_components + else: + cov = np.cov(X) + values, vectors = np.linalg.eigh(cov) + vectors = (X.T @ vectors) / np.sqrt(sample_size * values) + index = sample_size - self.n_components + self.I = np.eye(self.n_components) + if index == 0: + self.var = 0 + else: + self.var = np.mean(values[:index]) + + self.W = vectors[:, index:].dot(np.sqrt(np.diag(values[index:]) - self.var * self.I)) + self.__M = self.W.T @ self.W + self.var * self.I + self.C = self.W @ self.W.T + self.var * np.eye(n_features) + if index == 0: + self.Cinv = np.linalg.inv(self.C) + else: + self.Cinv = np.eye(n_features) / np.sqrt(self.var) - self.W @ np.linalg.inv(self.__M) @ self.W.T / self.var + + def em(self, X, iter_max): + self.I = np.eye(self.n_components) + self.W = np.eye(np.size(X, 1), self.n_components) + self.var = 1. + for i in range(iter_max): + W = np.copy(self.W) + stats = self._expectation(X) + self._maximization(X, *stats) + if np.allclose(W, self.W): + break + self.C = self.W @ self.W.T + self.var * np.eye(np.size(X, 1)) + self.Cinv = np.linalg.inv(self.C) + + def _expectation(self, X): + self.__M = self.W.T @ self.W + self.var * self.I + Minv = np.linalg.inv(self.__M) + Ez = X @ self.W @ Minv + Ezz = self.var * Minv + Ez[:, :, None] * Ez[:, None, :] + return Ez, Ezz + + def _maximization(self, X, Ez, Ezz): + self.W = X.T @ Ez @ np.linalg.inv(np.sum(Ezz, axis=0)) + self.var = np.mean( + np.mean(X ** 2, axis=1) + - 2 * np.mean(Ez @ self.W.T * X, axis=1) + + np.trace((Ezz @ self.W.T @ self.W).T) / np.size(X, 1)) + + def transform(self, X): + """ + project input data into latent space + p(Z|X) = N(Z|(X-mu)WMinv, sigma^-2M) + + Parameters + ---------- + X : (sample_size, n_features) ndarray + input data + + Returns + ------- + Z : (sample_size, n_components) ndarray + projected input data + """ + return np.linalg.solve(self.__M, ((X - self.mean) @ self.W).T).T + + def fit_transform(self, X, method="eigen"): + """ + perform pca and whiten the input data + + Parameters + ---------- + X : (sample_size, n_features) ndarray + input data + + Returns + ------- + Z : (sample_size, n_components) ndarray + projected input data + """ + self.fit(X, method) + return self.transform(X) + + def proba(self, X): + """ + the marginal distribution of the observed variable + + Parameters + ---------- + X : (sample_size, n_features) ndarray + input data + + Returns + ------- + p : (sample_size,) ndarray + value of the marginal distribution + """ + d = X - self.mean + return ( + np.exp(-0.5 * np.sum(d @ self.Cinv * d, axis=-1)) + / np.sqrt(np.linalg.det(self.C)) + / np.power(2 * np.pi, 0.5 * np.size(X, 1))) diff --git a/books/PRML/PRML-master-Python/prml/kernel/__init__.py b/books/PRML/PRML-master-Python/prml/kernel/__init__.py new file mode 100755 index 0000000..01b72f0 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/kernel/__init__.py @@ -0,0 +1,19 @@ +from prml.kernel.polynomial import PolynomialKernel +from prml.kernel.rbf import RBF + +from prml.kernel.gaussian_process_classifier import GaussianProcessClassifier +from prml.kernel.gaussian_process_regressor import GaussianProcessRegressor +from prml.kernel.relevance_vector_classifier import RelevanceVectorClassifier +from prml.kernel.relevance_vector_regressor import RelevanceVectorRegressor +from prml.kernel.support_vector_classifier import SupportVectorClassifier + + +__all__ = [ + "PolynomialKernel", + "RBF", + "GaussianProcessClassifier", + "GaussianProcessRegressor", + "RelevanceVectorClassifier", + "RelevanceVectorRegressor", + "SupportVectorClassifier" +] diff --git a/books/PRML/PRML-master-Python/prml/kernel/gaussian_process_classifier.py b/books/PRML/PRML-master-Python/prml/kernel/gaussian_process_classifier.py new file mode 100755 index 0000000..5fa1500 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/kernel/gaussian_process_classifier.py @@ -0,0 +1,37 @@ +import numpy as np + + +class GaussianProcessClassifier(object): + + def __init__(self, kernel, noise_level=1e-4): + """ + construct gaussian process classifier + + Parameters + ---------- + kernel + kernel function to be used to compute Gram matrix + noise_level : float + parameter to ensure the matrix to be positive + """ + self.kernel = kernel + self.noise_level = noise_level + + def _sigmoid(self, a): + return np.tanh(a * 0.5) * 0.5 + 0.5 + + def fit(self, X, t): + if X.ndim == 1: + X = X[:, None] + self.X = X + self.t = t + Gram = self.kernel(X, X) + self.covariance = Gram + np.eye(len(Gram)) * self.noise_level + self.precision = np.linalg.inv(self.covariance) + + def predict(self, X): + if X.ndim == 1: + X = X[:, None] + K = self.kernel(X, self.X) + a_mean = K @ self.precision @ self.t + return self._sigmoid(a_mean) diff --git a/books/PRML/PRML-master-Python/prml/kernel/gaussian_process_regressor.py b/books/PRML/PRML-master-Python/prml/kernel/gaussian_process_regressor.py new file mode 100755 index 0000000..981d26b --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/kernel/gaussian_process_regressor.py @@ -0,0 +1,105 @@ +import numpy as np + + +class GaussianProcessRegressor(object): + + def __init__(self, kernel, beta=1.): + """ + construct gaussian process regressor + + Parameters + ---------- + kernel + kernel function + beta : float + precision parameter of observation noise + """ + self.kernel = kernel + self.beta = beta + + def fit(self, X, t, iter_max=0, learning_rate=0.1): + """ + maximum likelihood estimation of parameters in kernel function + + Parameters + ---------- + X : ndarray (sample_size, n_features) + input + t : ndarray (sample_size,) + corresponding target + iter_max : int + maximum number of iterations updating hyperparameters + learning_rate : float + updation coefficient + + Attributes + ---------- + covariance : ndarray (sample_size, sample_size) + variance covariance matrix of gaussian process + precision : ndarray (sample_size, sample_size) + precision matrix of gaussian process + + Returns + ------- + log_likelihood_list : list + list of log likelihood value at each iteration + """ + if X.ndim == 1: + X = X[:, None] + log_likelihood_list = [-np.Inf] + self.X = X + self.t = t + I = np.eye(len(X)) + Gram = self.kernel(X, X) + self.covariance = Gram + I / self.beta + self.precision = np.linalg.inv(self.covariance) + for i in range(iter_max): + gradients = self.kernel.derivatives(X, X) + updates = np.array( + [-np.trace(self.precision.dot(grad)) + t.dot(self.precision.dot(grad).dot(self.precision).dot(t)) for grad in gradients]) + for j in range(iter_max): + self.kernel.update_parameters(learning_rate * updates) + Gram = self.kernel(X, X) + self.covariance = Gram + I / self.beta + self.precision = np.linalg.inv(self.covariance) + log_like = self.log_likelihood() + if log_like > log_likelihood_list[-1]: + log_likelihood_list.append(log_like) + break + else: + self.kernel.update_parameters(-learning_rate * updates) + learning_rate *= 0.9 + log_likelihood_list.pop(0) + return log_likelihood_list + + def log_likelihood(self): + return -0.5 * ( + np.linalg.slogdet(self.covariance)[1] + + self.t @ self.precision @ self.t + + len(self.t) * np.log(2 * np.pi)) + + def predict(self, X, with_error=False): + """ + mean of the gaussian process + + Parameters + ---------- + X : ndarray (sample_size, n_features) + input + + Returns + ------- + mean : ndarray (sample_size,) + predictions of corresponding inputs + """ + if X.ndim == 1: + X = X[:, None] + K = self.kernel(X, self.X) + mean = K @ self.precision @ self.t + if with_error: + var = ( + self.kernel(X, X, False) + + 1 / self.beta + - np.sum(K @ self.precision * K, axis=1)) + return mean.ravel(), np.sqrt(var.ravel()) + return mean diff --git a/books/PRML/PRML-master-Python/prml/kernel/kernel.py b/books/PRML/PRML-master-Python/prml/kernel/kernel.py new file mode 100755 index 0000000..5d1848e --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/kernel/kernel.py @@ -0,0 +1,28 @@ +import numpy as np + + +class Kernel(object): + """ + Base class for kernel function + """ + + def _pairwise(self, x, y): + """ + all pairs of x and y + + Parameters + ---------- + x : (sample_size, n_features) + input + y : (sample_size, n_features) + another input + + Returns + ------- + output : tuple + two array with shape (sample_size, sample_size, n_features) + """ + return ( + np.tile(x, (len(y), 1, 1)).transpose(1, 0, 2), + np.tile(y, (len(x), 1, 1)) + ) \ No newline at end of file diff --git a/books/PRML/PRML-master-Python/prml/kernel/polynomial.py b/books/PRML/PRML-master-Python/prml/kernel/polynomial.py new file mode 100755 index 0000000..9e3bb08 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/kernel/polynomial.py @@ -0,0 +1,43 @@ +import numpy as np +from prml.kernel.kernel import Kernel + + +class PolynomialKernel(Kernel): + """ + Polynomial kernel + k(x,y) = (x @ y + c)^M + """ + + def __init__(self, degree=2, const=0.): + """ + construct Polynomial kernel + + Parameters + ---------- + const : float + a constant to be added + degree : int + degree of polynomial order + """ + self.const = const + self.degree = degree + + def __call__(self, x, y, pairwise=True): + """ + calculate pairwise polynomial kernel + + Parameters + ---------- + x : (..., ndim) ndarray + input + y : (..., ndim) ndarray + another input with the same shape + + Returns + ------- + output : ndarray + polynomial kernel + """ + if pairwise: + x, y = self._pairwise(x, y) + return (np.sum(x * y, axis=-1) + self.const) ** self.degree diff --git a/books/PRML/PRML-master-Python/prml/kernel/rbf.py b/books/PRML/PRML-master-Python/prml/kernel/rbf.py new file mode 100755 index 0000000..4115eb3 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/kernel/rbf.py @@ -0,0 +1,58 @@ +import numpy as np +from prml.kernel.kernel import Kernel + + +class RBF(Kernel): + + def __init__(self, params): + """ + construct Radial basis kernel function + + Parameters + ---------- + params : (ndim + 1,) ndarray + parameters of radial basis function + + Attributes + ---------- + ndim : int + dimension of expected input data + """ + assert params.ndim == 1 + self.params = params + self.ndim = len(params) - 1 + + def __call__(self, x, y, pairwise=True): + """ + calculate radial basis function + k(x, y) = c0 * exp(-0.5 * c1 * (x1 - y1) ** 2 ...) + + Parameters + ---------- + x : ndarray [..., ndim] + input of this kernel function + y : ndarray [..., ndim] + another input + + Returns + ------- + output : ndarray + output of this radial basis function + """ + assert x.shape[-1] == self.ndim + assert y.shape[-1] == self.ndim + if pairwise: + x, y = self._pairwise(x, y) + d = self.params[1:] * (x - y) ** 2 + return self.params[0] * np.exp(-0.5 * np.sum(d, axis=-1)) + + def derivatives(self, x, y, pairwise=True): + if pairwise: + x, y = self._pairwise(x, y) + d = self.params[1:] * (x - y) ** 2 + delta = np.exp(-0.5 * np.sum(d, axis=-1)) + deltas = -0.5 * (x - y) ** 2 * (delta * self.params[0])[:, :, None] + return np.concatenate((np.expand_dims(delta, 0), deltas.T)) + + def update_parameters(self, updates): + self.params += updates diff --git a/books/PRML/PRML-master-Python/prml/kernel/relevance_vector_classifier.py b/books/PRML/PRML-master-Python/prml/kernel/relevance_vector_classifier.py new file mode 100755 index 0000000..4139ac2 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/kernel/relevance_vector_classifier.py @@ -0,0 +1,122 @@ +import numpy as np + + +class RelevanceVectorClassifier(object): + + def __init__(self, kernel, alpha=1.): + """ + construct relevance vector classifier + + Parameters + ---------- + kernel : Kernel + kernel function to compute components of feature vectors + alpha : float + initial precision of prior weight distribution + """ + self.kernel = kernel + self.alpha = alpha + + def _sigmoid(self, a): + return np.tanh(a * 0.5) * 0.5 + 0.5 + + def _map_estimate(self, X, t, w, n_iter=10): + for _ in range(n_iter): + y = self._sigmoid(X @ w) + g = X.T @ (y - t) + self.alpha * w + H = (X.T * y * (1 - y)) @ X + np.diag(self.alpha) + w -= np.linalg.solve(H, g) + return w, np.linalg.inv(H) + + def fit(self, X, t, iter_max=100): + """ + maximize evidence with respect ot hyperparameter + + Parameters + ---------- + X : (sample_size, n_features) ndarray + input + t : (sample_size,) ndarray + corresponding target + iter_max : int + maximum number of iterations + + Attributes + ---------- + X : (N, n_features) ndarray + relevance vector + t : (N,) ndarray + corresponding target + alpha : (N,) ndarray + hyperparameter for each weight or training sample + cov : (N, N) ndarray + covariance matrix of weight + mean : (N,) ndarray + mean of each weight + """ + if X.ndim == 1: + X = X[:, None] + assert X.ndim == 2 + assert t.ndim == 1 + Phi = self.kernel(X, X) + N = len(t) + self.alpha = np.zeros(N) + self.alpha + mean = np.zeros(N) + for _ in range(iter_max): + param = np.copy(self.alpha) + mean, cov = self._map_estimate(Phi, t, mean, 10) + gamma = 1 - self.alpha * np.diag(cov) + self.alpha = gamma / np.square(mean) + np.clip(self.alpha, 0, 1e10, out=self.alpha) + if np.allclose(param, self.alpha): + break + mask = self.alpha < 1e8 + self.X = X[mask] + self.t = t[mask] + self.alpha = self.alpha[mask] + Phi = self.kernel(self.X, self.X) + mean = mean[mask] + self.mean, self.covariance = self._map_estimate(Phi, self.t, mean, 100) + + def predict(self, X): + """ + predict class label + + Parameters + ---------- + X : (sample_size, n_features) + input + + Returns + ------- + label : (sample_size,) ndarray + predicted label + """ + if X.ndim == 1: + X = X[:, None] + assert X.ndim == 2 + phi = self.kernel(X, self.X) + label = (phi @ self.mean > 0).astype(np.int) + return label + + def predict_proba(self, X): + """ + probability of input belonging class one + + Parameters + ---------- + X : (sample_size, n_features) ndarray + input + + Returns + ------- + proba : (sample_size,) ndarray + probability of predictive distribution p(C1|x) + """ + if X.ndim == 1: + X = X[:, None] + assert X.ndim == 2 + phi = self.kernel(X, self.X) + mu_a = phi @ self.mean + var_a = np.sum(phi @ self.covariance * phi, axis=1) + return self._sigmoid(mu_a / np.sqrt(1 + np.pi * var_a / 8)) diff --git a/books/PRML/PRML-master-Python/prml/kernel/relevance_vector_regressor.py b/books/PRML/PRML-master-Python/prml/kernel/relevance_vector_regressor.py new file mode 100755 index 0000000..236d956 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/kernel/relevance_vector_regressor.py @@ -0,0 +1,102 @@ +import numpy as np + + +class RelevanceVectorRegressor(object): + + def __init__(self, kernel, alpha=1., beta=1.): + """ + construct relevance vector regressor + + Parameters + ---------- + kernel : Kernel + kernel function to compute components of feature vectors + alpha : float + initial precision of prior weight distribution + beta : float + precision of observation + """ + self.kernel = kernel + self.alpha = alpha + self.beta = beta + + def fit(self, X, t, iter_max=1000): + """ + maximize evidence with respect to hyperparameter + + Parameters + ---------- + X : (sample_size, n_features) ndarray + input + t : (sample_size,) ndarray + corresponding target + iter_max : int + maximum number of iterations + + Attributes + ------- + X : (N, n_features) ndarray + relevance vector + t : (N,) ndarray + corresponding target + alpha : (N,) ndarray + hyperparameter for each weight or training sample + cov : (N, N) ndarray + covariance matrix of weight + mean : (N,) ndarray + mean of each weight + """ + if X.ndim == 1: + X = X[:, None] + assert X.ndim == 2 + assert t.ndim == 1 + N = len(t) + Phi = self.kernel(X, X) + self.alpha = np.zeros(N) + self.alpha + for _ in range(iter_max): + params = np.hstack([self.alpha, self.beta]) + precision = np.diag(self.alpha) + self.beta * Phi.T @ Phi + covariance = np.linalg.inv(precision) + mean = self.beta * covariance @ Phi.T @ t + gamma = 1 - self.alpha * np.diag(covariance) + self.alpha = gamma / np.square(mean) + np.clip(self.alpha, 0, 1e10, out=self.alpha) + self.beta = (N - np.sum(gamma)) / np.sum((t - Phi.dot(mean)) ** 2) + if np.allclose(params, np.hstack([self.alpha, self.beta])): + break + mask = self.alpha < 1e9 + self.X = X[mask] + self.t = t[mask] + self.alpha = self.alpha[mask] + Phi = self.kernel(self.X, self.X) + precision = np.diag(self.alpha) + self.beta * Phi.T @ Phi + self.covariance = np.linalg.inv(precision) + self.mean = self.beta * self.covariance @ Phi.T @ self.t + + def predict(self, X, with_error=True): + """ + predict output with this model + + Parameters + ---------- + X : (sample_size, n_features) + input + with_error : bool + if True, predict with standard deviation of the outputs + + Returns + ------- + mean : (sample_size,) ndarray + mean of predictive distribution + std : (sample_size,) ndarray + standard deviation of predictive distribution + """ + if X.ndim == 1: + X = X[:, None] + assert X.ndim == 2 + phi = self.kernel(X, self.X) + mean = phi @ self.mean + if with_error: + var = 1 / self.beta + np.sum(phi @ self.covariance * phi, axis=1) + return mean, np.sqrt(var) + return mean diff --git a/books/PRML/PRML-master-Python/prml/kernel/support_vector_classifier.py b/books/PRML/PRML-master-Python/prml/kernel/support_vector_classifier.py new file mode 100755 index 0000000..4a6c721 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/kernel/support_vector_classifier.py @@ -0,0 +1,107 @@ +import numpy as np + + +class SupportVectorClassifier(object): + + def __init__(self, kernel, C=np.Inf): + """ + construct support vector classifier + + Parameters + ---------- + kernel : Kernel + kernel function to compute inner products + C : float + penalty of misclassification + """ + self.kernel = kernel + self.C = C + + def fit(self, X:np.ndarray, t:np.ndarray, tol:float=1e-8): + """ + estimate support vectors and their parameters + + Parameters + ---------- + X : (N, D) np.ndarray + training independent variable + t : (N,) np.ndarray + training dependent variable + binary -1 or 1 + tol : float, optional + numerical tolerance (the default is 1e-8) + """ + + N = len(t) + coef = np.zeros(N) + grad = np.ones(N) + Gram = self.kernel(X, X) + + while True: + tg = t * grad + mask_up = (t == 1) & (coef < self.C - tol) + mask_up |= (t == -1) & (coef > tol) + mask_down = (t == -1) & (coef < self.C - tol) + mask_down |= (t == 1) & (coef > tol) + i = np.where(mask_up)[0][np.argmax(tg[mask_up])] + j = np.where(mask_down)[0][np.argmin(tg[mask_down])] + if tg[i] < tg[j] + tol: + self.b = 0.5 * (tg[i] + tg[j]) + break + else: + A = self.C - coef[i] if t[i] == 1 else coef[i] + B = coef[j] if t[j] == 1 else self.C - coef[j] + direction = (tg[i] - tg[j]) / (Gram[i, i] - 2 * Gram[i, j] + Gram[j, j]) + direction = min(A, B, direction) + coef[i] += direction * t[i] + coef[j] -= direction * t[j] + grad -= direction * t * (Gram[i] - Gram[j]) + support_mask = coef > tol + self.a = coef[support_mask] + self.X = X[support_mask] + self.t = t[support_mask] + + def lagrangian_function(self): + return ( + np.sum(self.a) + - self.a + @ (self.t * self.t[:, None] * self.kernel(self.X, self.X)) + @ self.a) + + def predict(self, x): + """ + predict labels of the input + + Parameters + ---------- + x : (sample_size, n_features) ndarray + input + + Returns + ------- + label : (sample_size,) ndarray + predicted labels + """ + y = self.distance(x) + label = np.sign(y) + return label + + def distance(self, x): + """ + calculate distance from the decision boundary + + Parameters + ---------- + x : (sample_size, n_features) ndarray + input + + Returns + ------- + distance : (sample_size,) ndarray + distance from the boundary + """ + distance = np.sum( + self.a * self.t + * self.kernel(x, self.X), + axis=-1) + self.b + return distance diff --git a/books/PRML/PRML-master-Python/prml/linear/__init__.py b/books/PRML/PRML-master-Python/prml/linear/__init__.py new file mode 100755 index 0000000..88b538a --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/linear/__init__.py @@ -0,0 +1,28 @@ +from prml.linear.bayesian_logistic_regression import BayesianLogisticRegression +from prml.linear.bayesian_regression import BayesianRegression +from prml.linear.emprical_bayes_regression import EmpiricalBayesRegression +from prml.linear.least_squares_classifier import LeastSquaresClassifier +from prml.linear.linear_regression import LinearRegression +from prml.linear.fishers_linear_discriminant import FishersLinearDiscriminant +from prml.linear.logistic_regression import LogisticRegression +from prml.linear.perceptron import Perceptron +from prml.linear.ridge_regression import RidgeRegression +from prml.linear.softmax_regression import SoftmaxRegression +from prml.linear.variational_linear_regression import VariationalLinearRegression +from prml.linear.variational_logistic_regression import VariationalLogisticRegression + + +__all__ = [ + "BayesianLogisticRegression", + "BayesianRegression", + "EmpiricalBayesRegression", + "LeastSquaresClassifier", + "LinearRegression", + "FishersLinearDiscriminant", + "LogisticRegression", + "Perceptron", + "RidgeRegression", + "SoftmaxRegression", + "VariationalLinearRegression", + "VariationalLogisticRegression" +] diff --git a/books/PRML/PRML-master-Python/prml/linear/bayesian_logistic_regression.py b/books/PRML/PRML-master-Python/prml/linear/bayesian_logistic_regression.py new file mode 100755 index 0000000..77aee86 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/linear/bayesian_logistic_regression.py @@ -0,0 +1,66 @@ +import numpy as np +from prml.linear.logistic_regression import LogisticRegression + + +class BayesianLogisticRegression(LogisticRegression): + """ + Logistic regression model + + w ~ Gaussian(0, alpha^(-1)I) + y = sigmoid(X @ w) + t ~ Bernoulli(t|y) + """ + + def __init__(self, alpha:float=1.): + self.alpha = alpha + + def fit(self, X:np.ndarray, t:np.ndarray, max_iter:int=100): + """ + bayesian estimation of logistic regression model + using Laplace approximation + + Parameters + ---------- + X : (N, D) np.ndarray + training data independent variable + t : (N,) np.ndarray + training data dependent variable + binary 0 or 1 + max_iter : int, optional + maximum number of paramter update iteration (the default is 100) + """ + w = np.zeros(np.size(X, 1)) + eye = np.eye(np.size(X, 1)) + self.w_mean = np.copy(w) + self.w_precision = self.alpha * eye + for _ in range(max_iter): + w_prev = np.copy(w) + y = self._sigmoid(X @ w) + grad = X.T @ (y - t) + self.w_precision @ (w - self.w_mean) + hessian = (X.T * y * (1 - y)) @ X + self.w_precision + try: + w -= np.linalg.solve(hessian, grad) + except np.linalg.LinAlgError: + break + if np.allclose(w, w_prev): + break + self.w_mean = w + self.w_precision = hessian + + def proba(self, X:np.ndarray): + """ + compute probability of input belonging class 1 + + Parameters + ---------- + X : (N, D) np.ndarray + training data independent variable + + Returns + ------- + (N,) np.ndarray + probability of positive + """ + mu_a = X @ self.w_mean + var_a = np.sum(np.linalg.solve(self.w_precision, X.T).T * X, axis=1) + return self._sigmoid(mu_a / np.sqrt(1 + np.pi * var_a / 8)) diff --git a/books/PRML/PRML-master-Python/prml/linear/bayesian_regression.py b/books/PRML/PRML-master-Python/prml/linear/bayesian_regression.py new file mode 100755 index 0000000..295e23a --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/linear/bayesian_regression.py @@ -0,0 +1,87 @@ +import numpy as np +from prml.linear.regression import Regression + + +class BayesianRegression(Regression): + """ + Bayesian regression model + + w ~ N(w|0, alpha^(-1)I) + y = X @ w + t ~ N(t|X @ w, beta^(-1)) + """ + + def __init__(self, alpha:float=1., beta:float=1.): + self.alpha = alpha + self.beta = beta + self.w_mean = None + self.w_precision = None + + def _is_prior_defined(self) -> bool: + return self.w_mean is not None and self.w_precision is not None + + def _get_prior(self, ndim:int) -> tuple: + if self._is_prior_defined(): + return self.w_mean, self.w_precision + else: + return np.zeros(ndim), self.alpha * np.eye(ndim) + + def fit(self, X:np.ndarray, t:np.ndarray): + """ + bayesian update of parameters given training dataset + + Parameters + ---------- + X : (N, n_features) np.ndarray + training data independent variable + t : (N,) np.ndarray + training data dependent variable + """ + + mean_prev, precision_prev = self._get_prior(np.size(X, 1)) + + w_precision = precision_prev + self.beta * X.T @ X + w_mean = np.linalg.solve( + w_precision, + precision_prev @ mean_prev + self.beta * X.T @ t + ) + self.w_mean = w_mean + self.w_precision = w_precision + self.w_cov = np.linalg.inv(self.w_precision) + + def predict(self, X:np.ndarray, return_std:bool=False, sample_size:int=None): + """ + return mean (and standard deviation) of predictive distribution + + Parameters + ---------- + X : (N, n_features) np.ndarray + independent variable + return_std : bool, optional + flag to return standard deviation (the default is False) + sample_size : int, optional + number of samples to draw from the predictive distribution + (the default is None, no sampling from the distribution) + + Returns + ------- + y : (N,) np.ndarray + mean of the predictive distribution + y_std : (N,) np.ndarray + standard deviation of the predictive distribution + y_sample : (N, sample_size) np.ndarray + samples from the predictive distribution + """ + + if sample_size is not None: + w_sample = np.random.multivariate_normal( + self.w_mean, self.w_cov, size=sample_size + ) + y_sample = X @ w_sample.T + return y_sample + y = X @ self.w_mean + if return_std: + y_var = 1 / self.beta + np.sum(X @ self.w_cov * X, axis=1) + y_std = np.sqrt(y_var) + return y, y_std + return y diff --git a/books/PRML/PRML-master-Python/prml/linear/classifier.py b/books/PRML/PRML-master-Python/prml/linear/classifier.py new file mode 100755 index 0000000..f722bab --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/linear/classifier.py @@ -0,0 +1,5 @@ +class Classifier(object): + """ + Base class for classifiers + """ + pass diff --git a/books/PRML/PRML-master-Python/prml/linear/emprical_bayes_regression.py b/books/PRML/PRML-master-Python/prml/linear/emprical_bayes_regression.py new file mode 100755 index 0000000..cc1d3ed --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/linear/emprical_bayes_regression.py @@ -0,0 +1,86 @@ +import numpy as np +from prml.linear.bayesian_regression import BayesianRegression + + +class EmpiricalBayesRegression(BayesianRegression): + """ + Empirical Bayes Regression model + a.k.a. + type 2 maximum likelihood, + generalized maximum likelihood, + evidence approximation + + w ~ N(w|0, alpha^(-1)I) + y = X @ w + t ~ N(t|X @ w, beta^(-1)) + evidence function p(t|X,alpha,beta) = S p(t|w;X,beta)p(w|0;alpha) dw + """ + + def __init__(self, alpha:float=1., beta:float=1.): + super().__init__(alpha, beta) + + def fit(self, X:np.ndarray, t:np.ndarray, max_iter:int=100): + """ + maximization of evidence function with respect to + the hyperparameters alpha and beta given training dataset + + Parameters + ---------- + X : (N, D) np.ndarray + training independent variable + t : (N,) np.ndarray + training dependent variable + max_iter : int + maximum number of iteration + """ + M = X.T @ X + eigenvalues = np.linalg.eigvalsh(M) + eye = np.eye(np.size(X, 1)) + N = len(t) + for _ in range(max_iter): + params = [self.alpha, self.beta] + + w_precision = self.alpha * eye + self.beta * X.T @ X + w_mean = self.beta * np.linalg.solve(w_precision, X.T @ t) + + gamma = np.sum(eigenvalues / (self.alpha + eigenvalues)) + self.alpha = float(gamma / np.sum(w_mean ** 2).clip(min=1e-10)) + self.beta = float( + (N - gamma) / np.sum(np.square(t - X @ w_mean)) + ) + if np.allclose(params, [self.alpha, self.beta]): + break + self.w_mean = w_mean + self.w_precision = w_precision + self.w_cov = np.linalg.inv(w_precision) + + def _log_prior(self, w): + return -0.5 * self.alpha * np.sum(w ** 2) + + def _log_likelihood(self, X, t, w): + return -0.5 * self.beta * np.square(t - X @ w).sum() + + def _log_posterior(self, X, t, w): + return self._log_likelihood(X, t, w) + self._log_prior(w) + + def log_evidence(self, X:np.ndarray, t:np.ndarray): + """ + logarithm or the evidence function + + Parameters + ---------- + X : (N, D) np.ndarray + indenpendent variable + t : (N,) np.ndarray + dependent variable + Returns + ------- + float + log evidence + """ + N = len(t) + D = np.size(X, 1) + return 0.5 * ( + D * np.log(self.alpha) + N * np.log(self.beta) + - np.linalg.slogdet(self.w_precision)[1] - D * np.log(2 * np.pi) + ) + self._log_posterior(X, t, self.w_mean) diff --git a/books/PRML/PRML-master-Python/prml/linear/fishers_linear_discriminant.py b/books/PRML/PRML-master-Python/prml/linear/fishers_linear_discriminant.py new file mode 100755 index 0000000..fbd6d99 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/linear/fishers_linear_discriminant.py @@ -0,0 +1,80 @@ +import numpy as np +from prml.linear.classifier import Classifier +from prml.rv.gaussian import Gaussian + + +class FishersLinearDiscriminant(Classifier): + """ + Fisher's Linear discriminant model + """ + + def __init__(self, w:np.ndarray=None, threshold:float=None): + self.w = w + self.threshold = threshold + + def fit(self, X:np.ndarray, t:np.ndarray): + """ + estimate parameter given training dataset + + Parameters + ---------- + X : (N, D) np.ndarray + training dataset independent variable + t : (N,) np.ndarray + training dataset dependent variable + binary 0 or 1 + """ + X0 = X[t == 0] + X1 = X[t == 1] + m0 = np.mean(X0, axis=0) + m1 = np.mean(X1, axis=0) + cov_inclass = np.cov(X0, rowvar=False) + np.cov(X1, rowvar=False) + self.w = np.linalg.solve(cov_inclass, m1 - m0) + self.w /= np.linalg.norm(self.w).clip(min=1e-10) + + g0 = Gaussian() + g0.fit((X0 @ self.w)) + g1 = Gaussian() + g1.fit((X1 @ self.w)) + root = np.roots([ + g1.var - g0.var, + 2 * (g0.var * g1.mu - g1.var * g0.mu), + g1.var * g0.mu ** 2 - g0.var * g1.mu ** 2 + - g1.var * g0.var * np.log(g1.var / g0.var) + ]) + if g0.mu < root[0] < g1.mu or g1.mu < root[0] < g0.mu: + self.threshold = root[0] + else: + self.threshold = root[1] + + def transform(self, X:np.ndarray): + """ + project data + + Parameters + ---------- + X : (N, D) np.ndarray + independent variable + + Returns + ------- + y : (N,) np.ndarray + projected data + """ + return X @ self.w + + def classify(self, X:np.ndarray): + """ + classify input data + + Parameters + ---------- + X : (N, D) np.ndarray + independent variable to be classified + + Returns + ------- + (N,) np.ndarray + binary class for each input + """ + return (X @ self.w > self.threshold).astype(np.int) diff --git a/books/PRML/PRML-master-Python/prml/linear/least_squares_classifier.py b/books/PRML/PRML-master-Python/prml/linear/least_squares_classifier.py new file mode 100755 index 0000000..7edfa25 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/linear/least_squares_classifier.py @@ -0,0 +1,48 @@ +import numpy as np +from prml.linear.classifier import Classifier +from prml.preprocess.label_transformer import LabelTransformer + + +class LeastSquaresClassifier(Classifier): + """ + Least squares classifier model + + X : (N, D) + W : (D, K) + y = argmax_k X @ W + """ + + def __init__(self, W:np.ndarray=None): + self.W = W + + def fit(self, X:np.ndarray, t:np.ndarray): + """ + least squares fitting for classification + + Parameters + ---------- + X : (N, D) np.ndarray + training independent variable + t : (N,) or (N, K) np.ndarray + training dependent variable + in class index (N,) or one-of-k coding (N,K) + """ + if t.ndim == 1: + t = LabelTransformer().encode(t) + self.W = np.linalg.pinv(X) @ t + + def classify(self, X:np.ndarray): + """ + classify input data + + Parameters + ---------- + X : (N, D) np.ndarray + independent variable to be classified + + Returns + ------- + (N,) np.ndarray + class index for each input + """ + return np.argmax(X @ self.W, axis=-1) diff --git a/books/PRML/PRML-master-Python/prml/linear/linear_regression.py b/books/PRML/PRML-master-Python/prml/linear/linear_regression.py new file mode 100755 index 0000000..61f8752 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/linear/linear_regression.py @@ -0,0 +1,48 @@ +import numpy as np +from prml.linear.regression import Regression + + +class LinearRegression(Regression): + """ + Linear regression model + y = X @ w + t ~ N(t|X @ w, var) + """ + + def fit(self, X:np.ndarray, t:np.ndarray): + """ + perform least squares fitting + + Parameters + ---------- + X : (N, D) np.ndarray + training independent variable + t : (N,) np.ndarray + training dependent variable + """ + self.w = np.linalg.pinv(X) @ t + self.var = np.mean(np.square(X @ self.w - t)) + + def predict(self, X:np.ndarray, return_std:bool=False): + """ + make prediction given input + + Parameters + ---------- + X : (N, D) np.ndarray + samples to predict their output + return_std : bool, optional + returns standard deviation of each predition if True + + Returns + ------- + y : (N,) np.ndarray + prediction of each sample + y_std : (N,) np.ndarray + standard deviation of each predition + """ + y = X @ self.w + if return_std: + y_std = np.sqrt(self.var) + np.zeros_like(y) + return y, y_std + return y diff --git a/books/PRML/PRML-master-Python/prml/linear/logistic_regression.py b/books/PRML/PRML-master-Python/prml/linear/logistic_regression.py new file mode 100755 index 0000000..023c2c2 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/linear/logistic_regression.py @@ -0,0 +1,77 @@ +import numpy as np +from prml.linear.classifier import Classifier + + +class LogisticRegression(Classifier): + """ + Logistic regression model + + y = sigmoid(X @ w) + t ~ Bernoulli(t|y) + """ + + @staticmethod + def _sigmoid(a): + return np.tanh(a * 0.5) * 0.5 + 0.5 + + def fit(self, X:np.ndarray, t:np.ndarray, max_iter:int=100): + """ + maximum likelihood estimation of logistic regression model + + Parameters + ---------- + X : (N, D) np.ndarray + training data independent variable + t : (N,) np.ndarray + training data dependent variable + binary 0 or 1 + max_iter : int, optional + maximum number of paramter update iteration (the default is 100) + """ + w = np.zeros(np.size(X, 1)) + for _ in range(max_iter): + w_prev = np.copy(w) + y = self._sigmoid(X @ w) + grad = X.T @ (y - t) + hessian = (X.T * y * (1 - y)) @ X + try: + w -= np.linalg.solve(hessian, grad) + except np.linalg.LinAlgError: + break + if np.allclose(w, w_prev): + break + self.w = w + + def proba(self, X:np.ndarray): + """ + compute probability of input belonging class 1 + + Parameters + ---------- + X : (N, D) np.ndarray + training data independent variable + + Returns + ------- + (N,) np.ndarray + probability of positive + """ + return self._sigmoid(X @ self.w) + + def classify(self, X:np.ndarray, threshold:float=0.5): + """ + classify input data + + Parameters + ---------- + X : (N, D) np.ndarray + independent variable to be classified + threshold : float, optional + threshold of binary classification (default is 0.5) + + Returns + ------- + (N,) np.ndarray + binary class for each input + """ + return (self.proba(X) > threshold).astype(np.int) diff --git a/books/PRML/PRML-master-Python/prml/linear/perceptron.py b/books/PRML/PRML-master-Python/prml/linear/perceptron.py new file mode 100755 index 0000000..10fc7f0 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/linear/perceptron.py @@ -0,0 +1,52 @@ +import numpy as np +from prml.linear.classifier import Classifier + + +class Perceptron(Classifier): + """ + Perceptron model + """ + + def fit(self, X, t, max_epoch=100): + """ + fit perceptron model on given input pair + + Parameters + ---------- + X : (N, D) np.ndarray + training independent variable + t : (N,) + training dependent variable + binary -1 or 1 + max_epoch : int, optional + maximum number of epoch (the default is 100) + """ + self.w = np.zeros(np.size(X, 1)) + for _ in range(max_epoch): + N = len(t) + index = np.random.permutation(N) + X = X[index] + t = t[index] + for x, label in zip(X, t): + self.w += x * label + if (X @ self.w * t > 0).all(): + break + else: + continue + break + + def classify(self, X): + """ + classify input data + + Parameters + ---------- + X : (N, D) np.ndarray + independent variable to be classified + + Returns + ------- + (N,) np.ndarray + binary class (-1 or 1) for each input + """ + return np.sign(X @ self.w).astype(np.int) diff --git a/books/PRML/PRML-master-Python/prml/linear/regression.py b/books/PRML/PRML-master-Python/prml/linear/regression.py new file mode 100755 index 0000000..78453c7 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/linear/regression.py @@ -0,0 +1,5 @@ +class Regression(object): + """ + Base class for regressors + """ + pass diff --git a/books/PRML/PRML-master-Python/prml/linear/ridge_regression.py b/books/PRML/PRML-master-Python/prml/linear/ridge_regression.py new file mode 100755 index 0000000..862d76a --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/linear/ridge_regression.py @@ -0,0 +1,44 @@ +import numpy as np +from prml.linear.regression import Regression + + +class RidgeRegression(Regression): + """ + Ridge regression model + + w* = argmin |t - X @ w| + alpha * |w|_2^2 + """ + + def __init__(self, alpha:float=1.): + self.alpha = alpha + + def fit(self, X:np.ndarray, t:np.ndarray): + """ + maximum a posteriori estimation of parameter + + Parameters + ---------- + X : (N, D) np.ndarray + training data independent variable + t : (N,) np.ndarray + training data dependent variable + """ + + eye = np.eye(np.size(X, 1)) + self.w = np.linalg.solve(self.alpha * eye + X.T @ X, X.T @ t) + + def predict(self, X:np.ndarray): + """ + make prediction given input + + Parameters + ---------- + X : (N, D) np.ndarray + samples to predict their output + + Returns + ------- + (N,) np.ndarray + prediction of each input + """ + return X @ self.w diff --git a/books/PRML/PRML-master-Python/prml/linear/softmax_regression.py b/books/PRML/PRML-master-Python/prml/linear/softmax_regression.py new file mode 100755 index 0000000..2632bef --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/linear/softmax_regression.py @@ -0,0 +1,83 @@ +import numpy as np +from prml.linear.classifier import Classifier +from prml.preprocess.label_transformer import LabelTransformer + + +class SoftmaxRegression(Classifier): + """ + Softmax regression model + aka + multinomial logistic regression, + multiclass logistic regression, + maximum entropy classifier. + + y = softmax(X @ W) + t ~ Categorical(t|y) + """ + + @staticmethod + def _softmax(a): + a_max = np.max(a, axis=-1, keepdims=True) + exp_a = np.exp(a - a_max) + return exp_a / np.sum(exp_a, axis=-1, keepdims=True) + + def fit(self, X:np.ndarray, t:np.ndarray, max_iter:int=100, learning_rate:float=0.1): + """ + maximum likelihood estimation of the parameter + + Parameters + ---------- + X : (N, D) np.ndarray + training independent variable + t : (N,) or (N, K) np.ndarray + training dependent variable + in class index or one-of-k encoding + max_iter : int, optional + maximum number of iteration (the default is 100) + learning_rate : float, optional + learning rate of gradient descent (the default is 0.1) + """ + if t.ndim == 1: + t = LabelTransformer().encode(t) + self.n_classes = np.size(t, 1) + W = np.zeros((np.size(X, 1), self.n_classes)) + for _ in range(max_iter): + W_prev = np.copy(W) + y = self._softmax(X @ W) + grad = X.T @ (y - t) + W -= learning_rate * grad + if np.allclose(W, W_prev): + break + self.W = W + + def proba(self, X:np.ndarray): + """ + compute probability of input belonging each class + + Parameters + ---------- + X : (N, D) np.ndarray + independent variable + + Returns + ------- + (N, K) np.ndarray + probability of each class + """ + return self._softmax(X @ self.W) + + def classify(self, X:np.ndarray): + """ + classify input data + + Parameters + ---------- + X : (N, D) np.ndarray + independent variable to be classified + + Returns + ------- + (N,) np.ndarray + class index for each input + """ + return np.argmax(self.proba(X), axis=-1) diff --git a/books/PRML/PRML-master-Python/prml/linear/variational_linear_regression.py b/books/PRML/PRML-master-Python/prml/linear/variational_linear_regression.py new file mode 100755 index 0000000..2666840 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/linear/variational_linear_regression.py @@ -0,0 +1,93 @@ +import numpy as np +from prml.linear.regression import Regression + + +class VariationalLinearRegression(Regression): + """ + variational bayesian estimation of linear regression model + p(w,alpha|X,t) + ~ q(w)q(alpha) + = N(w|w_mean, w_var)Gamma(alpha|a,b) + + Attributes + ---------- + a : float + a parameter of variational posterior gamma distribution + b : float + another parameter of variational posterior gamma distribution + w_mean : (n_features,) ndarray + mean of variational posterior gaussian distribution + w_var : (n_features, n_feautures) ndarray + variance of variational posterior gaussian distribution + n_iter : int + number of iterations performed + """ + + def __init__(self, beta:float=1., a0:float=1., b0:float=1.): + """ + construct variational linear regressor + Parameters + ---------- + beta : float + precision of observation noise + a0 : float + a parameter of prior gamma distribution + Gamma(alpha|a0,b0) + b0 : float + another parameter of prior gamma distribution + Gamma(alpha|a0,b0) + """ + self.beta = beta + self.a0 = a0 + self.b0 = b0 + + def fit(self, X:np.ndarray, t:np.ndarray, iter_max:int=100): + """ + variational bayesian estimation of parameter + + Parameters + ---------- + X : (N, D) np.ndarray + training independent variable + t : (N,) np.ndarray + training dependent variable + iter_max : int, optional + maximum number of iteration (the default is 100) + """ + D = np.size(X, 1) + self.a = self.a0 + 0.5 * D + self.b = self.b0 + I = np.eye(D) + for _ in range(iter_max): + param = self.b + self.w_var = np.linalg.inv(self.a * I / self.b + self.beta * X.T @ X) + self.w_mean = self.beta * self.w_var @ X.T @ t + self.b = self.b0 + 0.5 * (np.sum(self.w_mean ** 2) + np.trace(self.w_var)) + if np.allclose(self.b, param): + break + + def predict(self, X:np.ndarray, return_std:bool=False): + """ + make prediction of input + + Parameters + ---------- + X : (N, D) np.ndarray + independent variable + return_std : bool, optional + return standard deviation of predictive distribution if True + (the default is False) + + Returns + ------- + y : (N,) np.ndarray + mean of predictive distribution + y_std : (N,) np.ndarray + standard deviation of predictive distribution + """ + y = X @ self.w_mean + if return_std: + y_var = 1 / self.beta + np.sum(X @ self.w_var * X, axis=1) + y_std = np.sqrt(y_var) + return y, y_std + return y diff --git a/books/PRML/PRML-master-Python/prml/linear/variational_logistic_regression.py b/books/PRML/PRML-master-Python/prml/linear/variational_logistic_regression.py new file mode 100755 index 0000000..fbcaa28 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/linear/variational_logistic_regression.py @@ -0,0 +1,88 @@ +import numpy as np +from prml.linear.logistic_regression import LogisticRegression + + +class VariationalLogisticRegression(LogisticRegression): + + def __init__(self, alpha:float=None, a0:float=1., b0:float=1.): + """ + construct variational logistic regressor + + Parameters + ---------- + alpha : float + precision parameter of the prior + if None, this is also the subject to estimate + a0 : float + a parameter of hyper prior Gamma dist. + Gamma(alpha|a0,b0) + if alpha is not None, this argument will be ignored + b0 : float + another parameter of hyper prior Gamma dist. + Gamma(alpha|a0,b0) + if alpha is not None, this argument will be ignored + """ + if alpha is not None: + self.__alpha = alpha + else: + self.a0 = a0 + self.b0 = b0 + + def fit(self, X:np.ndarray, t:np.ndarray, iter_max:int=1000): + """ + variational bayesian estimation of the parameter + + Parameters + ---------- + X : (N, D) np.ndarray + training independent variable + t : (N,) np.ndarray + training dependent variable + iter_max : int, optional + maximum number of iteration (the default is 1000) + """ + N, D = X.shape + if hasattr(self, "a0"): + self.a = self.a0 + 0.5 * D + xi = np.random.uniform(-1, 1, size=N) + I = np.eye(D) + param = np.copy(xi) + for _ in range(iter_max): + lambda_ = np.tanh(xi) * 0.25 / xi + self.w_var = np.linalg.inv(I / self.alpha + 2 * (lambda_ * X.T) @ X) + self.w_mean = self.w_var @ np.sum(X.T * (t - 0.5), axis=1) + xi = np.sqrt(np.sum(X @ (self.w_var + self.w_mean * self.w_mean[:, None]) * X, axis=-1)) + if np.allclose(xi, param): + break + else: + param = np.copy(xi) + + @property + def alpha(self): + if hasattr(self, "__alpha"): + return self.__alpha + else: + try: + self.b = self.b0 + 0.5 * (np.sum(self.w_mean ** 2) + np.trace(self.w_var)) + except AttributeError: + self.b = self.b0 + return self.a / self.b + + def proba(self, X:np.ndarray): + """ + compute probability of input belonging class 1 + + Parameters + ---------- + X : (N, D) np.ndarray + training data independent variable + + Returns + ------- + (N,) np.ndarray + probability of positive + """ + mu_a = X @ self.w_mean + var_a = np.sum(X @ self.w_var * X, axis=1) + y = self._sigmoid(mu_a / np.sqrt(1 + np.pi * var_a / 8)) + return y diff --git a/books/PRML/PRML-master-Python/prml/markov/__init__.py b/books/PRML/PRML-master-Python/prml/markov/__init__.py new file mode 100755 index 0000000..6fd3ea7 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/markov/__init__.py @@ -0,0 +1,14 @@ +from .categorical_hmm import CategoricalHMM +from .gaussian_hmm import GaussianHMM +from prml.markov.kalman import Kalman, kalman_filter, kalman_smoother +from .particle import Particle + + +__all__ = [ + "GaussianHMM", + "CategoricalHMM", + "Kalman", + "kalman_filter", + "kalman_smoother", + "Particle" +] diff --git a/books/PRML/PRML-master-Python/prml/markov/categorical_hmm.py b/books/PRML/PRML-master-Python/prml/markov/categorical_hmm.py new file mode 100755 index 0000000..3f18aef --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/markov/categorical_hmm.py @@ -0,0 +1,65 @@ +import numpy as np +from .hmm import HiddenMarkovModel + + +class CategoricalHMM(HiddenMarkovModel): + """ + Hidden Markov Model with categorical emission model + """ + + def __init__(self, initial_proba, transition_proba, means): + """ + construct hidden markov model with categorical emission model + + Parameters + ---------- + initial_proba : (n_hidden,) np.ndarray + probability of initial latent state + transition_proba : (n_hidden, n_hidden) np.ndarray + transition probability matrix + (i, j) component denotes the transition probability from i-th to j-th hidden state + means : (n_hidden, ndim) np.ndarray + mean parameters of categorical distribution + + Returns + ------- + ndim : int + number of observation categories + n_hidden : int + number of hidden states + """ + assert initial_proba.size == transition_proba.shape[0] == transition_proba.shape[1] == means.shape[0] + assert np.allclose(means.sum(axis=1), 1) + super().__init__(initial_proba, transition_proba) + self.ndim = means.shape[1] + self.means = means + + def draw(self, n=100): + """ + draw random sequence from this model + + Parameters + ---------- + n : int + length of the random sequence + + Returns + ------- + seq : (n,) np.ndarray + generated random sequence + """ + hidden_state = np.random.choice(self.n_hidden, p=self.initial_proba) + seq = [] + while len(seq) < n: + seq.append(np.random.choice(self.ndim, p=self.means[hidden_state])) + hidden_state = np.random.choice(self.n_hidden, p=self.transition_proba[hidden_state]) + return np.asarray(seq) + + def likelihood(self, X): + return self.means[X] + + def maximize(self, seq, p_hidden, p_transition): + self.initial_proba = p_hidden[0] / np.sum(p_hidden[0]) + self.transition_proba = np.sum(p_transition, axis=0) / np.sum(p_transition, axis=(0, 2)) + x = p_hidden[:, None, :] * (np.eye(self.ndim)[seq])[:, :, None] + self.means = np.sum(x, axis=0) / np.sum(p_hidden, axis=0) diff --git a/books/PRML/PRML-master-Python/prml/markov/gaussian_hmm.py b/books/PRML/PRML-master-Python/prml/markov/gaussian_hmm.py new file mode 100755 index 0000000..9cdd609 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/markov/gaussian_hmm.py @@ -0,0 +1,76 @@ +import numpy as np +from prml.rv import MultivariateGaussian +from .hmm import HiddenMarkovModel + + +class GaussianHMM(HiddenMarkovModel): + """ + Hidden Markov Model with Gaussian emission model + """ + + def __init__(self, initial_proba, transition_proba, means, covs): + """ + construct hidden markov model with Gaussian emission model + + Parameters + ---------- + initial_proba : (n_hidden,) np.ndarray or None + probability of initial states + transition_proba : (n_hidden, n_hidden) np.ndarray or None + transition probability matrix + (i, j) component denotes the transition probability from i-th to j-th hidden state + means : (n_hidden, ndim) np.ndarray + mean of each gaussian component + covs : (n_hidden, ndim, ndim) np.ndarray + covariance matrix of each gaussian component + + Attributes + ---------- + ndim : int + dimensionality of observation space + n_hidden : int + number of hidden states + """ + assert initial_proba.size == transition_proba.shape[0] == transition_proba.shape[1] == means.shape[0] == covs.shape[0] + assert means.shape[1] == covs.shape[1] == covs.shape[2] + super().__init__(initial_proba, transition_proba) + self.ndim = means.shape[1] + self.means = means + self.covs = covs + self.precisions = np.linalg.inv(self.covs) + self.gaussians = [MultivariateGaussian(m, cov) for m, cov in zip(means, covs)] + + def draw(self, n=100): + """ + draw random sequence from this model + + Parameters + ---------- + n : int + length of the random sequence + + Returns + ------- + seq : (n, ndim) np.ndarray + generated random sequence + """ + hidden_state = np.random.choice(self.n_hidden, p=self.initial_proba) + seq = [] + while len(seq) < n: + seq.extend(self.gaussians[hidden_state].draw()) + hidden_state = np.random.choice(self.n_hidden, p=self.transition_proba[hidden_state]) + return np.asarray(seq) + + def likelihood(self, X): + diff = X[:, None, :] - self.means + exponents = np.sum( + np.einsum('nki,kij->nkj', diff, self.precisions) * diff, axis=-1) + return np.exp(-0.5 * exponents) / np.sqrt(np.linalg.det(self.covs) * (2 * np.pi) ** self.ndim) + + def maximize(self, seq, p_hidden, p_transition): + self.initial_proba = p_hidden[0] / np.sum(p_hidden[0]) + self.transition_proba = np.sum(p_transition, axis=0) / np.sum(p_transition, axis=(0, 2)) + Nk = np.sum(p_hidden, axis=0) + self.means = (seq.T @ p_hidden / Nk).T + diffs = seq[:, None, :] - self.means + self.covs = np.einsum('nki,nkj->kij', diffs, diffs * p_hidden[:, :, None]) / Nk[:, None, None] diff --git a/books/PRML/PRML-master-Python/prml/markov/hmm.py b/books/PRML/PRML-master-Python/prml/markov/hmm.py new file mode 100755 index 0000000..35ed3ea --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/markov/hmm.py @@ -0,0 +1,178 @@ +import numpy as np + + +class HiddenMarkovModel(object): + """ + Base class of Hidden Markov models + """ + + def __init__(self, initial_proba, transition_proba): + """ + construct hidden markov model + + Parameters + ---------- + initial_proba : (n_hidden,) np.ndarray + initial probability of each hidden state + transition_proba : (n_hidden, n_hidden) np.ndarray + transition probability matrix + (i, j) component denotes the transition probability from i-th to j-th hidden state + + Attribute + --------- + n_hidden : int + number of hidden state + """ + self.n_hidden = initial_proba.size + self.initial_proba = initial_proba + self.transition_proba = transition_proba + + def fit(self, seq, iter_max=100): + """ + perform EM algorithm to estimate parameter of emission model and hidden variables + + Parameters + ---------- + seq : (N, ndim) np.ndarray + observed sequence + iter_max : int + maximum number of EM steps + + Returns + ------- + posterior : (N, n_hidden) np.ndarray + posterior distribution of each latent variable + """ + params = np.hstack( + (self.initial_proba.ravel(), self.transition_proba.ravel())) + for i in range(iter_max): + p_hidden, p_transition = self.expect(seq) + self.maximize(seq, p_hidden, p_transition) + params_new = np.hstack( + (self.initial_proba.ravel(), self.transition_proba.ravel())) + if np.allclose(params, params_new): + break + else: + params = params_new + return self.forward_backward(seq) + + def expect(self, seq): + """ + estimate posterior distributions of hidden states and + transition probability between adjacent latent variables + + Parameters + ---------- + seq : (N, ndim) np.ndarray + observed sequence + + Returns + ------- + p_hidden : (N, n_hidden) np.ndarray + posterior distribution of each hidden variable + p_transition : (N - 1, n_hidden, n_hidden) np.ndarray + posterior transition probability between adjacent latent variables + """ + likelihood = self.likelihood(seq) + + f = self.initial_proba * likelihood[0] + constant = [f.sum()] + forward = [f / f.sum()] + for like in likelihood[1:]: + f = forward[-1] @ self.transition_proba * like + constant.append(f.sum()) + forward.append(f / f.sum()) + forward = np.asarray(forward) + constant = np.asarray(constant) + + backward = [np.ones(self.n_hidden)] + for like, c in zip(likelihood[-1:0:-1], constant[-1:0:-1]): + backward.insert(0, self.transition_proba @ (like * backward[0]) / c) + backward = np.asarray(backward) + + p_hidden = forward * backward + p_transition = self.transition_proba * likelihood[1:, None, :] * backward[1:, None, :] * forward[:-1, :, None] + return p_hidden, p_transition + + def forward_backward(self, seq): + """ + estimate posterior distributions of hidden states + + Parameters + ---------- + seq : (N, ndim) np.ndarray + observed sequence + + Returns + ------- + posterior : (N, n_hidden) np.ndarray + posterior distribution of hidden states + """ + likelihood = self.likelihood(seq) + + f = self.initial_proba * likelihood[0] + constant = [f.sum()] + forward = [f / f.sum()] + for like in likelihood[1:]: + f = forward[-1] @ self.transition_proba * like + constant.append(f.sum()) + forward.append(f / f.sum()) + + backward = [np.ones(self.n_hidden)] + for like, c in zip(likelihood[-1:0:-1], constant[-1:0:-1]): + backward.insert(0, self.transition_proba @ (like * backward[0]) / c) + + forward = np.asarray(forward) + backward = np.asarray(backward) + posterior = forward * backward + return posterior + + def filtering(self, seq): + """ + bayesian filtering + + Parameters + ---------- + seq : (N, ndim) np.ndarray + observed sequence + + Returns + ------- + posterior : (N, n_hidden) np.ndarray + posterior distributions of each latent variables + """ + likelihood = self.likelihood(seq) + p = self.initial_proba * likelihood[0] + posterior = [p / np.sum(p)] + for like in likelihood[1:]: + p = posterior[-1] @ self.transition_proba * like + posterior.append(p / np.sum(p)) + posterior = np.asarray(posterior) + return posterior + + def viterbi(self, seq): + """ + viterbi algorithm (a.k.a. max-sum algorithm) + + Parameters + ---------- + seq : (N, ndim) np.ndarray + observed sequence + + Returns + ------- + seq_hid : (N,) np.ndarray + the most probable sequence of hidden variables + """ + nll = -np.log(self.likelihood(seq)) + cost_total = nll[0] + from_list = [] + for i in range(1, len(seq)): + cost_temp = cost_total[:, None] - np.log(self.transition_proba) + nll[i] + cost_total = np.min(cost_temp, axis=0) + index = np.argmin(cost_temp, axis=0) + from_list.append(index) + seq_hid = [np.argmin(cost_total)] + for source in from_list[::-1]: + seq_hid.insert(0, source[seq_hid[0]]) + return seq_hid diff --git a/books/PRML/PRML-master-Python/prml/markov/kalman.py b/books/PRML/PRML-master-Python/prml/markov/kalman.py new file mode 100755 index 0000000..99a15ce --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/markov/kalman.py @@ -0,0 +1,268 @@ +import numpy as np +from prml.rv.multivariate_gaussian import MultivariateGaussian as Gaussian +from prml.markov.state_space_model import StateSpaceModel + + +class Kalman(StateSpaceModel): + """ + A class to perform kalman filtering or smoothing + z : internal state + x : observation + + z_1 ~ N(z_1|mu_0, P_0)\n + z_n ~ N(z_n|A z_n-1, P)\n + x_n ~ N(x_n|C z_n, S) + + Parameters + ---------- + system : (Dz, Dz) np.ndarray + system matrix aka transition matrix (A) + cov_system : (Dz, Dz) np.ndarray + covariance matrix of process noise + measure : (Dx, Dz) np.ndarray + measurement matrix aka observation matrix (C) + cov_measure : (Dx, Dx) np.ndarray + covariance matrix of measurement noise + mu0 : (Dz,) np.ndarray + mean parameter of initial hidden variable + P0 : (Dz, Dz) np.ndarray + covariance parameter of initial hidden variable + + Attributes + ---------- + Dz : int + dimensionality of hidden variable + Dx : int + dimensionality of observed variable + """ + + + def __init__(self, system, cov_system, measure, cov_measure, mu0, P0): + """ + construct Kalman model + + z_1 ~ N(z_1|mu_0, P_0)\n + z_n ~ N(z_n|A z_n-1, P)\n + x_n ~ N(x_n|C z_n, S) + + Parameters + ---------- + system : (Dz, Dz) np.ndarray + system matrix aka transition matrix (A) + cov_system : (Dz, Dz) np.ndarray + covariance matrix of process noise + measure : (Dx, Dz) np.ndarray + measurement matrix aka observation matrix (C) + cov_measure : (Dx, Dx) np.ndarray + covariance matrix of measurement noise + mu0 : (Dz,) np.ndarray + mean parameter of initial hidden variable + P0 : (Dz, Dz) np.ndarray + covariance parameter of initial hidden variable + + Attributes + ---------- + hidden_mean : list of (Dz,) np.ndarray + list of mean of hidden state starting from the given hidden state + hidden_cov : list of (Dz, Dz) np.ndarray + list of covariance of hidden state starting from the given hidden state + """ + self.system = system + self.cov_system = cov_system + self.measure = measure + self.cov_measure = cov_measure + + self.hidden_mean = [mu0] + self.hidden_cov = [P0] + self.hidden_cov_predicted = [None] + + self.smoothed_until = -1 + self.smoothing_gain = [None] + + def predict(self): + """ + predict hidden state at current step given estimate at previous step + + Returns + ------- + tuple ((Dz,) np.ndarray, (Dz, Dz) np.ndarray) + tuple of mean and covariance of the estimate at current step + """ + mu_prev, cov_prev = self.hidden_mean[-1], self.hidden_cov[-1] + mu = self.system @ mu_prev + cov = self.system @ cov_prev @ self.system.T + self.cov_system + self.hidden_mean.append(mu) + self.hidden_cov.append(cov) + self.hidden_cov_predicted.append(np.copy(cov)) + return mu, cov + + def filter(self, observed): + """ + bayesian update of current estimate given current observation + + Parameters + ---------- + observed : (Dx,) np.ndarray + current observation + + Returns + ------- + tuple ((Dz,) np.ndarray, (Dz, Dz) np.ndarray) + tuple of mean and covariance of the updated estimate + """ + mu, cov = self.hidden_mean[-1], self.hidden_cov[-1] + innovation = observed - self.measure @ mu + cov_innovation = self.cov_measure + self.measure @ cov @ self.measure.T + kalman_gain = np.linalg.solve(cov_innovation, self.measure @ cov).T + mu += kalman_gain @ innovation + cov -= kalman_gain @ self.measure @ cov + return mu, cov + + def filtering(self, observed_sequence): + """ + perform kalman filtering given observed sequence + + Parameters + ---------- + observed_sequence : (T, Dx) np.ndarray + sequence of observations + + Returns + ------- + tuple ((T, Dz) np.ndarray, (T, Dz, Dz) np.ndarray) + seuquence of mean and covariance of hidden variable at each time step + """ + for obs in observed_sequence: + self.predict() + self.filter(obs) + mean_sequence = np.asarray(self.hidden_mean[1:]) + cov_sequence = np.asarray(self.hidden_cov[1:]) + return mean_sequence, cov_sequence + + def smooth(self): + """ + bayesian update of current estimate with future observations + """ + mean_smoothed_next = self.hidden_mean[self.smoothed_until] + cov_smoothed_next = self.hidden_cov[self.smoothed_until] + cov_pred_next = self.hidden_cov_predicted[self.smoothed_until] + + self.smoothed_until -= 1 + mean = self.hidden_mean[self.smoothed_until] + cov = self.hidden_cov[self.smoothed_until] + gain = np.linalg.solve(cov_pred_next, self.system @ cov).T + mean += gain @ (mean_smoothed_next - self.system @ mean) + cov += gain @ (cov_smoothed_next - cov_pred_next) @ gain.T + self.smoothing_gain.insert(0, gain) + + def smoothing(self, observed_sequence:np.ndarray=None): + """ + perform Kalman smoothing (given observed sequence) + + Parameters + ---------- + observed_sequence : (T, Dx) np.ndarray, optional + sequence of observation + run Kalman filter if given (the default is None) + + Returns + ------- + tuple ((T, Dz) np.ndarray, (T, Dz, Dz) np.ndarray) + sequence of mean and covariance of hidden variable at each time step + """ + if observed_sequence is not None: + self.filtering(observed_sequence) + while self.smoothed_until != -len(self.hidden_mean): + self.smooth() + mean_sequence = np.asarray(self.hidden_mean[1:]) + cov_sequence = np.asarray(self.hidden_cov[1:]) + return mean_sequence, cov_sequence + + def update_parameter(self, observation_sequence): + """ + maximization step of EM algorithm + """ + mu0 = self.hidden_mean[1] + P0 = self.hidden_cov[1] + + Ezn = np.asarray(self.hidden_mean) + Eznzn = np.asarray(self.hidden_cov) + Ezn[..., None] * Ezn[:, None, :] + Eznzn_1 = np.einsum("nij,nkj->nik", self.hidden_cov[2:], self.smoothing_gain[1:-1]) + Ezn[2:, :, None] * Ezn[1:-1, None, :] + self.system = np.linalg.solve(np.sum(Eznzn[2:], axis=0), np.sum(Eznzn_1, axis=0).T).T + self.cov_system = np.mean( + Eznzn[2:] + - np.einsum("ij,nkj->nik", self.system, Eznzn_1) + - np.einsum("nij,kj->nik", Eznzn_1, self.system) + + np.einsum("ij,njk,lk->nil", self.system, Eznzn[1:-1], self.system), + axis=0 + ) + self.measure = np.linalg.solve( + np.sum(Eznzn[1:], axis=0), + np.sum(np.einsum("ni,nj->nij", Ezn[1:], observation_sequence), axis=0) + ).T + self.cov_measure = np.mean( + np.einsum("ni,nj->nij", observation_sequence, observation_sequence) + - np.einsum("ij,nj,nk->nik", self.measure, Ezn[1:], observation_sequence) + - np.einsum("ni,nj,kj->nik", observation_sequence, Ezn[1:], self.measure) + + np.einsum("ij,njk,lk->nil", self.measure, Eznzn[1:], self.measure), + axis=0 + ) + return self.system, self.cov_system, self.measure, self.cov_measure, mu0, P0 + + def fit(self, sequence, max_iter=10): + for _ in range(max_iter): + kalman_smoother(self, sequence) + param = self.update_parameter(sequence) + self.__init__(*param) + return kalman_smoother(self, sequence) + + +def kalman_filter(kalman:Kalman, observed_sequence:np.ndarray)->tuple: + """ + perform kalman filtering given Kalman model and observed sequence + + Parameters + ---------- + kalman : Kalman + Kalman model + observed_sequence : (T, Dx) np.ndarray + sequence of observations + + Returns + ------- + tuple ((T, Dz) np.ndarray, (T, Dz, Dz) np.ndarray) + seuquence of mean and covariance of hidden variable at each time step + """ + for obs in observed_sequence: + kalman.predict() + kalman.filter(obs) + mean_sequence = np.asarray(kalman.hidden_mean[1:]) + cov_sequence = np.asarray(kalman.hidden_cov[1:]) + return mean_sequence, cov_sequence + + +def kalman_smoother(kalman:Kalman, observed_sequence:np.ndarray=None): + """ + perform Kalman smoothing given Kalman model (and observed sequence) + + Parameters + ---------- + kalman : Kalman + Kalman model + observed_sequence : (T, Dx) np.ndarray, optional + sequence of observation + run Kalman filter if given (the default is None) + + Returns + ------- + tuple ((T, Dz) np.ndarray, (T, Dz, Dz) np.ndarray) + seuqnce of mean and covariance of hidden variable at each time step + """ + + if observed_sequence is not None: + kalman_filter(kalman, observed_sequence) + while kalman.smoothed_until != -len(kalman.hidden_mean): + kalman.smooth() + mean_sequence = np.asarray(kalman.hidden_mean[1:]) + cov_sequence = np.asarray(kalman.hidden_cov[1:]) + return mean_sequence, cov_sequence diff --git a/books/PRML/PRML-master-Python/prml/markov/particle.py b/books/PRML/PRML-master-Python/prml/markov/particle.py new file mode 100755 index 0000000..1f8cc4d --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/markov/particle.py @@ -0,0 +1,124 @@ +import numpy as np +from scipy.misc import logsumexp +from scipy.spatial.distance import cdist +from .state_space_model import StateSpaceModel + + +class Particle(StateSpaceModel): + """ + A class to perform particle filtering, smoothing + + z_1 ~ p(z_1)\n + z_n ~ p(z_n|z_n-1)\n + x_n ~ p(x_n|z_n) + + Parameters + ---------- + init_particle : (n_particle, ndim_hidden) + initial hidden state + sampler : callable (particles) + function to sample particles at current step given previous state + nll : callable (observation, particles) + function to compute negative log likelihood for each particle + + Attribute + --------- + hidden_state : list of (n_paticle, ndim_hidden) np.ndarray + list of particles + """ + + def __init__(self, init_particle, system, cov_system, nll, pdf=None): + """ + construct state space model to perform particle filtering or smoothing + + Parameters + ---------- + init_particle : (n_particle, ndim_hidden) np.ndarray + initial hidden state + system : (ndim_hidden, ndim_hidden) np.ndarray + system matrix aka transition matrix + cov_system : (ndim_hidden, ndim_hidden) np.ndarray + covariance matrix of process noise + nll : callable (observation, particles) + function to compute negative log likelihood for each particle + + Attribute + --------- + particle : list of (n_paticle, ndim_hidden) np.ndarray + list of particles at each step + weight : list of (n_particle,) np.ndarray + list of importance of each particle at each step + n_particle : int + number of particles at each step + """ + self.particle = [init_particle] + self.n_particle, self.ndim_hidden = init_particle.shape + self.weight = [np.ones(self.n_particle) / self.n_particle] + self.system = system + self.cov_system = cov_system + self.nll = nll + self.smoothed_until = -1 + + def resample(self): + index = np.random.choice(self.n_particle, self.n_particle, p=self.weight[-1]) + return self.particle[-1][index] + + def predict(self): + predicted = self.resample() @ self.system.T + predicted += np.random.multivariate_normal(np.zeros(self.ndim_hidden), self.cov_system, self.n_particle) + self.particle.append(predicted) + self.weight.append(np.ones(self.n_particle) / self.n_particle) + return predicted, self.weight[-1] + + def weigh(self, observed): + logit = -self.nll(observed, self.particle[-1]) + logit -= logsumexp(logit) + self.weight[-1] = np.exp(logit) + + def filter(self, observed): + self.weigh(observed) + return self.particle[-1], self.weight[-1] + + def filtering(self, observed_sequence): + mean = [] + cov = [] + for obs in observed_sequence: + self.predict() + p, w = self.filter(obs) + mean.append(np.average(p, axis=0, weights=w)) + cov.append(np.cov(p, rowvar=False, aweights=w)) + return np.asarray(mean), np.asarray(cov) + + def transition_probability(self, particle, particle_prev): + dist = cdist( + particle, + particle_prev @ self.system.T, + "mahalanobis", + VI=np.linalg.inv(self.cov_system)) + matrix = np.exp(-0.5 * np.square(dist)) + matrix /= np.sum(matrix, axis=1, keepdims=True) + matrix[np.isnan(matrix)] = 1 / self.n_particle + return matrix + + def smooth(self): + particle_next = self.particle[self.smoothed_until] + weight_next = self.weight[self.smoothed_until] + + self.smoothed_until -= 1 + particle = self.particle[self.smoothed_until] + weight = self.weight[self.smoothed_until] + matrix = self.transition_probability(particle_next, particle).T + weight *= matrix @ weight_next / (weight @ matrix) + weight /= np.sum(weight, keepdims=True) + + def smoothing(self, observed_sequence:np.ndarray=None): + if observed_sequence is not None: + self.filtering(observed_sequence) + while self.smoothed_until != -len(self.particle): + self.smooth() + mean = [] + cov = [] + for p, w in zip(self.particle, self.weight): + mean.append(np.average(p, axis=0, weights=w)) + cov.append(np.cov(p, rowvar=False, aweights=w)) + return np.asarray(mean), np.asarray(cov) diff --git a/books/PRML/PRML-master-Python/prml/markov/state_space_model.py b/books/PRML/PRML-master-Python/prml/markov/state_space_model.py new file mode 100755 index 0000000..b4f5500 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/markov/state_space_model.py @@ -0,0 +1,5 @@ +class StateSpaceModel(object): + """ + Base class for state-space models + """ + pass diff --git a/books/PRML/PRML-master-Python/prml/nn/__init__.py b/books/PRML/PRML-master-Python/prml/nn/__init__.py new file mode 100755 index 0000000..9489c79 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/__init__.py @@ -0,0 +1,34 @@ +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.parameter import Parameter +from prml.nn.tensor.tensor import Tensor +from prml.nn.array.flatten import flatten +from prml.nn.array.reshape import reshape +from prml.nn.array.split import split +from prml.nn.array.transpose import transpose +from prml.nn import linalg +from prml.nn.image.convolve2d import convolve2d +from prml.nn.image.max_pooling2d import max_pooling2d +from prml.nn.math.abs import abs +from prml.nn.math.exp import exp +from prml.nn.math.gamma import gamma +from prml.nn.math.log import log +from prml.nn.math.mean import mean +from prml.nn.math.power import power +from prml.nn.math.product import prod +from prml.nn.math.sqrt import sqrt +from prml.nn.math.square import square +from prml.nn.math.sum import sum +from prml.nn.nonlinear.relu import relu +from prml.nn.nonlinear.sigmoid import sigmoid +from prml.nn.nonlinear.softmax import softmax +from prml.nn.nonlinear.softplus import softplus +from prml.nn.nonlinear.tanh import tanh +from prml.nn import optimizer +from prml.nn import random +from prml.nn.network import Network + + +__all__ = [ + "optimizer", + "Network" +] diff --git a/books/PRML/PRML-master-Python/prml/nn/array/__init__.py b/books/PRML/PRML-master-Python/prml/nn/array/__init__.py new file mode 100755 index 0000000..55d754f --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/array/__init__.py @@ -0,0 +1,19 @@ +from prml.nn.array.broadcast import broadcast_to +from prml.nn.array.flatten import flatten +from prml.nn.array.reshape import reshape, reshape_method +from prml.nn.array.split import split +from prml.nn.array.transpose import transpose, transpose_method +from prml.nn.tensor.tensor import Tensor + + +Tensor.flatten = flatten +Tensor.reshape = reshape_method +Tensor.transpose = transpose_method + +__all__ = [ + "broadcast_to", + "flatten", + "reshape", + "split", + "transpose" +] diff --git a/books/PRML/PRML-master-Python/prml/nn/array/broadcast.py b/books/PRML/PRML-master-Python/prml/nn/array/broadcast.py new file mode 100755 index 0000000..39f8def --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/array/broadcast.py @@ -0,0 +1,36 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class BroadcastTo(Function): + """ + Broadcast a tensor to an new shape + """ + + def forward(self, x, shape): + x = self._convert2tensor(x) + self.x = x + output = np.broadcast_to(x.value, shape) + if isinstance(self.x, Constant): + return Constant(output) + return Tensor(output, function=self) + + def backward(self, delta): + dx = delta + if delta.ndim != self.x.ndim: + dx = dx.sum(axis=tuple(range(dx.ndim - self.x.ndim))) + if isinstance(dx, np.number): + dx = np.array(dx) + axis = tuple(i for i, len_ in enumerate(self.x.shape) if len_ == 1) + if axis: + dx = dx.sum(axis=axis, keepdims=True) + self.x.backward(dx) + + +def broadcast_to(x, shape): + """ + Broadcast a tensor to an new shape + """ + return BroadcastTo().forward(x, shape) diff --git a/books/PRML/PRML-master-Python/prml/nn/array/flatten.py b/books/PRML/PRML-master-Python/prml/nn/array/flatten.py new file mode 100755 index 0000000..db0eebf --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/array/flatten.py @@ -0,0 +1,28 @@ +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Flatten(Function): + """ + flatten array + """ + + def forward(self, x): + x = self._convert2tensor(x) + self._atleast_ndim(x, 2) + self.x = x + if isinstance(self.x, Constant): + return Constant(x.value.flatten()) + return Tensor(x.value.flatten(), function=self) + + def backward(self, delta): + dx = delta.reshape(*self.x.shape) + self.x.backward(dx) + + +def flatten(x): + """ + flatten N-dimensional array (N >= 2) + """ + return Flatten().forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/array/reshape.py b/books/PRML/PRML-master-Python/prml/nn/array/reshape.py new file mode 100755 index 0000000..cca385f --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/array/reshape.py @@ -0,0 +1,32 @@ +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Reshape(Function): + """ + reshape array + """ + + def forward(self, x, shape): + x = self._convert2tensor(x) + self._atleast_ndim(x, 1) + self.x = x + if isinstance(self.x, Constant): + return Constant(x.value.reshape(*shape)) + return Tensor(x.value.reshape(*shape), function=self) + + def backward(self, delta): + dx = delta.reshape(*self.x.shape) + self.x.backward(dx) + + +def reshape(x, shape): + """ + reshape N-dimensional array (N >= 1) + """ + return Reshape().forward(x, shape) + + +def reshape_method(x, *args): + return Reshape().forward(x, args) diff --git a/books/PRML/PRML-master-Python/prml/nn/array/split.py b/books/PRML/PRML-master-Python/prml/nn/array/split.py new file mode 100755 index 0000000..bb78929 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/array/split.py @@ -0,0 +1,48 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Nth(Function): + + def __init__(self, n): + self.n = n + + def forward(self, x): + self.x = x + if isinstance(self.x, Constant): + return Constant(x.value) + return Tensor(x.value, function=self) + + def backward(self, delta): + self.x.backward(delta, n=self.n) + + +class Split(Function): + + def __init__(self, indices_or_sections, axis=-1): + self.indices_or_sections = indices_or_sections + self.axis = axis + + def forward(self, x): + x = self._convert2tensor(x) + self._atleast_ndim(x, 1) + self.x = x + output = np.split(x.value, self.indices_or_sections, self.axis) + if isinstance(self.x, Constant): + return tuple([Constant(out) for out in output]) + self.n_output = len(output) + self.delta = [None for _ in output] + return tuple([Tensor(out, function=self) for out in output]) + + def backward(self, delta, n): + self.delta[n] = delta + if all([d is not None for d in self.delta]): + dx = np.concatenate(self.delta, axis=self.axis) + self.x.backward(dx) + + +def split(x, indices_or_sections, axis=-1): + output = Split(indices_or_sections, axis).forward(x) + return tuple([Nth(i).forward(out) for i, out in enumerate(output)]) diff --git a/books/PRML/PRML-master-Python/prml/nn/array/transpose.py b/books/PRML/PRML-master-Python/prml/nn/array/transpose.py new file mode 100755 index 0000000..d352a14 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/array/transpose.py @@ -0,0 +1,36 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Transpose(Function): + + def __init__(self, axes=None): + self.axes = axes + + def forward(self, x): + x = self._convert2tensor(x) + if self.axes is not None: + self._equal_ndim(x, len(self.axes)) + self.x = x + if isinstance(self.x, Constant): + return Constant(np.transpose(x.value, self.axes)) + return Tensor(np.transpose(x.value, self.axes), function=self) + + def backward(self, delta): + if self.axes is None: + dx = np.transpose(delta) + else: + dx = np.transpose(delta, np.argsort(self.axes)) + self.x.backward(dx) + + +def transpose(x, axes=None): + return Transpose(axes).forward(x) + + +def transpose_method(x, *args): + if args == (): + args = None + return Transpose(args).forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/function.py b/books/PRML/PRML-master-Python/prml/nn/function.py new file mode 100755 index 0000000..70a86c4 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/function.py @@ -0,0 +1,33 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor + + +class Function(object): + """ + Base class for differentiable functions + """ + + def _convert2tensor(self, x): + if isinstance(x, (int, float, np.number, np.ndarray)): + x = Constant(x) + elif not isinstance(x, Tensor): + raise TypeError( + "Unsupported class for input: {}".format(type(x)) + ) + return x + + def _equal_ndim(self, x, ndim): + if x.ndim != ndim: + raise ValueError( + "dimensionality of the input must be {}, not {}" + .format(ndim, x.ndim) + ) + + def _atleast_ndim(self, x, ndim): + if x.ndim < ndim: + raise ValueError( + "dimensionality of the input must be" + " larger or equal to {}, not {}" + .format(ndim, x.ndim) + ) diff --git a/books/PRML/PRML-master-Python/prml/nn/image/__init__.py b/books/PRML/PRML-master-Python/prml/nn/image/__init__.py new file mode 100755 index 0000000..ef0e741 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/image/__init__.py @@ -0,0 +1,8 @@ +from prml.nn.image.convolve2d import convolve2d +from prml.nn.image.max_pooling2d import max_pooling2d + + +__all__ = [ + "convolve2d", + "max_pooling2d" +] diff --git a/books/PRML/PRML-master-Python/prml/nn/image/convolve2d.py b/books/PRML/PRML-master-Python/prml/nn/image/convolve2d.py new file mode 100755 index 0000000..c6d27f4 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/image/convolve2d.py @@ -0,0 +1,100 @@ +import numpy as np +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function +from prml.nn.image.util import img2patch, patch2img + + +class Convolve2d(Function): + + def __init__(self, stride, pad): + """ + construct 2 dimensional convolution function + + Parameters + ---------- + stride : int or tuple of ints + stride of kernel application + pad : int or tuple of ints + padding image + """ + self.stride = self._check_tuple(stride, "stride") + self.pad = self._check_tuple(pad, "pad") + self.pad = (0,) + self.pad + (0,) + + def _check_tuple(self, tup, name): + if isinstance(tup, int): + tup = (tup,) * 2 + if not isinstance(tup, tuple): + raise TypeError( + "Unsupported type for {}: {}".format(name, type(tup)) + ) + if len(tup) != 2: + raise ValueError( + "the length of {} must be 2, not {}".format(name, len(tup)) + ) + if not all([isinstance(n, int) for n in tup]): + raise TypeError( + "Unsuported type for {}".format(name) + ) + if not all([n >= 0 for n in tup]): + raise ValueError( + "{} must be non-negative values".format(name) + ) + return tup + + def _check_input(self, x, y): + x = self._convert2tensor(x) + y = self._convert2tensor(y) + self._equal_ndim(x, 4) + self._equal_ndim(y, 4) + if x.shape[3] != y.shape[2]: + raise ValueError( + "shapes {} and {} not aligned: {} (dim 3) != {} (dim 2)" + .format(x.shape, y.shape, x.shape[3], y.shape[2]) + ) + return x, y + + def forward(self, x, y): + x, y = self._check_input(x, y) + self.x = x + self.y = y + img = np.pad(x.value, [(p,) for p in self.pad], "constant") + self.shape = img.shape + self.patch = img2patch(img, y.shape[:2], self.stride) + return Tensor(np.tensordot(self.patch, y.value, axes=((3, 4, 5), (0, 1, 2))), function=self) + + def backward(self, delta): + dx = patch2img( + np.tensordot(delta, self.y.value, (3, 3)), + self.stride, + self.shape + ) + slices = [slice(p, len_ - p) for p, len_ in zip(self.pad, self.shape)] + dx = dx[slices] + dy = np.tensordot(self.patch, delta, axes=((0, 1, 2),) * 2) + self.x.backward(dx) + self.y.backward(dy) + + +def convolve2d(x, y, stride=1, pad=0): + """ + returns convolution of two tensors + + Parameters + ---------- + x : (n_batch, xlen, ylen, in_channel) Tensor + input tensor to be convolved + y : (kx, ky, in_channel, out_channel) Tensor + convolution kernel + stride : int or tuple of ints (sx, sy) + stride of kernel application + pad : int or tuple of ints (px, py) + padding image + + Returns + ------- + output : (n_batch, xlen', ylen', out_channel) Tensor + input convolved with kernel + len' = (len + p - k) // s + 1 + """ + return Convolve2d(stride, pad).forward(x, y) diff --git a/books/PRML/PRML-master-Python/prml/nn/image/max_pooling2d.py b/books/PRML/PRML-master-Python/prml/nn/image/max_pooling2d.py new file mode 100755 index 0000000..f59d8fe --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/image/max_pooling2d.py @@ -0,0 +1,93 @@ +import numpy as np +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function +from prml.nn.image.util import img2patch, patch2img + + +class MaxPooling2d(Function): + + def __init__(self, pool_size, stride, pad): + """ + construct 2 dimensional max-pooling function + + Parameters + ---------- + pool_size : int or tuple of ints + pooling size + stride : int or tuple of ints + stride of kernel application + pad : int or tuple of ints + padding image + """ + self.pool_size = self._check_tuple(pool_size, "pool_size") + self.stride = self._check_tuple(stride, "stride") + self.pad = self._check_tuple(pad, "pad") + self.pad = (0,) + self.pad + (0,) + + def _check_tuple(self, tup, name): + if isinstance(tup, int): + tup = (tup,) * 2 + if not isinstance(tup, tuple): + raise TypeError( + "Unsupported type for {}: {}".format(name, type(tup)) + ) + if len(tup) != 2: + raise ValueError( + "the length of {} must be 2, not {}".format(name, len(tup)) + ) + if not all([isinstance(n, int) for n in tup]): + raise TypeError( + "Unsuported type for {}".format(name) + ) + if not all([n >= 0 for n in tup]): + raise ValueError( + "{} must be non-negative values".format(name) + ) + return tup + + def forward(self, x): + x = self._convert2tensor(x) + self._equal_ndim(x, 4) + self.x = x + img = np.pad(x.value, [(p,) for p in self.pad], "constant") + patch = img2patch(img, self.pool_size, self.stride) + n_batch, xlen_out, ylen_out, _, _, in_channels = patch.shape + patch = patch.reshape(n_batch, xlen_out, ylen_out, -1, in_channels) + self.shape = img.shape + self.index = patch.argmax(axis=3) + return Tensor(patch.max(axis=3), function=self) + + def backward(self, delta): + delta_patch = np.zeros(delta.shape + (np.prod(self.pool_size),)) + index = np.where(delta == delta) + (self.index.ravel(),) + delta_patch[index] = delta.ravel() + delta_patch = np.reshape(delta_patch, delta.shape + self.pool_size) + delta_patch = delta_patch.transpose(0, 1, 2, 4, 5, 3) + dx = patch2img(delta_patch, self.stride, self.shape) + slices = [slice(p, len_ - p) for p, len_ in zip(self.pad, self.shape)] + dx = dx[slices] + self.x.backward(dx) + + +def max_pooling2d(x, pool_size, stride=1, pad=0): + """ + spatial max pooling + + Parameters + ---------- + x : (n_batch, xlen, ylen, in_channel) Tensor + input tensor + pool_size : int or tuple of ints (kx, ky) + pooling size + stride : int or tuple of ints (sx, sy) + stride of pooling application + pad : int or tuple of ints (px, py) + padding input + + Returns + ------- + output : (n_batch, xlen', ylen', out_channel) Tensor + max pooled image + len' = (len + p - k) // s + 1 + """ + return MaxPooling2d(pool_size, stride, pad).forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/image/util.py b/books/PRML/PRML-master-Python/prml/nn/image/util.py new file mode 100755 index 0000000..a5d6b79 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/image/util.py @@ -0,0 +1,62 @@ +import itertools +import numpy as np +from numpy.lib.stride_tricks import as_strided + + +def img2patch(img, size, step=1): + """ + convert batch of image array into patches + Parameters + ---------- + img : (n_batch, xlen_in, ylen_in, in_channels) ndarray + batch of images + size : tuple or int + patch size + step : tuple or int + stride of patches + Returns + ------- + patch : (n_batch, xlen_out, ylen_out, size, size, in_channels) ndarray + batch of patches at all points + len_out = (len_in - size) // step + 1 + """ + ndim = img.ndim + if isinstance(size, int): + size = (size,) * (ndim - 2) + if isinstance(step, int): + step = (step,) * (ndim - 2) + + slices = [slice(None, None, s) for s in step] + window_strides = img.strides[1:] + index_strides = img[[slice(None)] + slices].strides[:-1] + + out_shape = tuple( + np.subtract(img.shape[1: -1], size) // np.array(step) + 1) + out_shape = (len(img),) + out_shape + size + (np.size(img, -1),) + strides = index_strides + window_strides + patch = as_strided(img, shape=out_shape, strides=strides) + return patch + + +def patch2img(x, stride, shape): + """ + sum up patches and form an image + Parameters + ---------- + x : (n_batch, xlen_in, ylen_in, kx, ky, in_channels) ndarray + batch of patches at all points + stride : tuple + applied stride to take patches + shape : (n_batch, xlen_out, ylen_out, in_channels) tuple + output image shape + Returns + ------- + img : (n_batch, len_out, ylen_out, in_channels) ndarray + image + """ + img = np.zeros(shape, dtype=np.float32) + kx, ky = x.shape[3: 5] + for i, j in itertools.product(range(kx), range(ky)): + slices = [slice(b, b + s * len_, s) for b, s, len_ in zip([i, j], stride, x.shape[1: 3])] + img[[slice(None)] + slices] += x[..., i, j, :] + return img diff --git a/books/PRML/PRML-master-Python/prml/nn/linalg/__init__.py b/books/PRML/PRML-master-Python/prml/nn/linalg/__init__.py new file mode 100755 index 0000000..51b9152 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/linalg/__init__.py @@ -0,0 +1,16 @@ +from prml.nn.linalg.cholesky import cholesky +from prml.nn.linalg.det import det +from prml.nn.linalg.inv import inv +from prml.nn.linalg.logdet import logdet +from prml.nn.linalg.solve import solve +from prml.nn.linalg.trace import trace + + +__all__ = [ + "cholesky", + "det", + "inv", + "logdet", + "solve", + "trace" +] diff --git a/books/PRML/PRML-master-Python/prml/nn/linalg/cholesky.py b/books/PRML/PRML-master-Python/prml/nn/linalg/cholesky.py new file mode 100755 index 0000000..673f523 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/linalg/cholesky.py @@ -0,0 +1,45 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Cholesky(Function): + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + self.output = np.linalg.cholesky(x.value) + if isinstance(self.x, Constant): + return Constant(self.output) + return Tensor(self.output, function=self) + + def backward(self, delta): + delta_lower = np.tril(delta) + P = phi(self.output.T @ delta_lower) + S = np.linalg.solve( + self.output.T, + P @ np.linalg.inv(self.output) + ) + dx = S + S.T + np.diag(np.diag(S)) + self.x.backward(dx) + + +def phi(x): + return 0.5 * (np.tril(x) + np.tril(x, -1)) + + +def cholesky(x): + """ + cholesky decomposition of positive-definite matrix + x = LL^T + Parameters + ---------- + x : (d, d) tensor_like + positive-definite matrix + Returns + ------- + L : (d, d) + cholesky decomposition + """ + return Cholesky().forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/linalg/det.py b/books/PRML/PRML-master-Python/prml/nn/linalg/det.py new file mode 100755 index 0000000..a606e2d --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/linalg/det.py @@ -0,0 +1,35 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Determinant(Function): + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + self._equal_ndim(x, 2) + self.output = np.linalg.det(x.value) + if isinstance(self.x, Constant): + return Constant(self.output) + return Tensor(self.output, function=self) + + def backward(self, delta): + dx = delta * self.output * np.linalg.inv(self.x.value.T) + self.x.backward(dx) + + +def det(x): + """ + determinant of a matrix + Parameters + ---------- + x : (d, d) tensor_like + a matrix to compute its determinant + Returns + ------- + output : (d, d) tensor_like + determinant of the input matrix + """ + return Determinant().forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/linalg/inv.py b/books/PRML/PRML-master-Python/prml/nn/linalg/inv.py new file mode 100755 index 0000000..f7bfb06 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/linalg/inv.py @@ -0,0 +1,35 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Inverse(Function): + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + self._equal_ndim(x, 2) + self.output = np.linalg.inv(x.value) + if isinstance(self.x, Constant): + return Constant(self.output) + return Tensor(self.output, function=self) + + def backward(self, delta): + dx = -self.output.T @ delta @ self.output.T + self.x.backward(dx) + + +def inv(x): + """ + inverse of a matrix + Parameters + ---------- + x : (d, d) tensor_like + a matrix to be inverted + Returns + ------- + output : (d, d) tensor_like + inverse of the input + """ + return Inverse().forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/linalg/logdet.py b/books/PRML/PRML-master-Python/prml/nn/linalg/logdet.py new file mode 100755 index 0000000..c50b7f7 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/linalg/logdet.py @@ -0,0 +1,37 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class LogDeterminant(Function): + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + self._equal_ndim(x, 2) + sign, self.output = np.linalg.slogdet(x.value) + if sign != 1: + raise ValueError("matrix has to be positive-definite") + if isinstance(self.x, Constant): + return Constant(self.output) + return Tensor(self.output, function=self) + + def backward(self, delta): + dx = delta * np.linalg.inv(self.x.value.T) + self.x.backward(dx) + + +def logdet(x): + """ + log determinant of a matrix + Parameters + ---------- + x : (d, d) tensor_like + a matrix to compute its log determinant + Returns + ------- + output : (d, d) tensor_like + determinant of the input matrix + """ + return LogDeterminant().forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/linalg/solve.py b/books/PRML/PRML-master-Python/prml/nn/linalg/solve.py new file mode 100755 index 0000000..de920c2 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/linalg/solve.py @@ -0,0 +1,43 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Solve(Function): + + def forward(self, a, b): + a = self._convert2tensor(a) + b = self._convert2tensor(b) + self._equal_ndim(a, 2) + self._equal_ndim(b, 2) + self.a = a + self.b = b + self.output = np.linalg.solve(a.value, b.value) + if isinstance(self.a, Constant) and isinstance(self.b, Constant): + return Constant(self.output) + return Tensor(self.output, function=self) + + def backward(self, delta): + db = np.linalg.solve(self.a.value.T, delta) + da = -db @ self.output.T + self.a.backward(da) + self.b.backward(db) + + +def solve(a, b): + """ + solve a linear matrix equation + ax = b + Parameters + ---------- + a : (d, d) tensor_like + coefficient matrix + b : (d, k) tensor_like + dependent variable + Returns + ------- + output : (d, k) tensor_like + solution of the equation + """ + return Solve().forward(a, b) diff --git a/books/PRML/PRML-master-Python/prml/nn/linalg/trace.py b/books/PRML/PRML-master-Python/prml/nn/linalg/trace.py new file mode 100755 index 0000000..944d7dc --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/linalg/trace.py @@ -0,0 +1,24 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Trace(Function): + + def forward(self, x): + x = self._convert2tensor(x) + self._equal_ndim(x, 2) + self.x = x + output = np.trace(x.value) + if isinstance(self.x, Constant): + return Constant(output) + return Tensor(output, function=self) + + def backward(self, delta): + dx = np.eye(self.x.shape[0], self.x.shape[1]) * delta + self.x.backward(dx) + + +def trace(x): + return Trace().forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/math/__init__.py b/books/PRML/PRML-master-Python/prml/nn/math/__init__.py new file mode 100755 index 0000000..5e2e3dd --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/math/__init__.py @@ -0,0 +1,50 @@ +from prml.nn.math.add import add +from prml.nn.math.divide import divide, rdivide +from prml.nn.math.exp import exp +from prml.nn.math.log import log +from prml.nn.math.matmul import matmul, rmatmul +from prml.nn.math.mean import mean +from prml.nn.math.multiply import multiply +from prml.nn.math.negative import negative +from prml.nn.math.power import power, rpower +from prml.nn.math.product import prod +from prml.nn.math.sqrt import sqrt +from prml.nn.math.square import square +from prml.nn.math.subtract import subtract, rsubtract +from prml.nn.math.sum import sum + + +from prml.nn.tensor.tensor import Tensor +Tensor.__add__ = add +Tensor.__radd__ = add +Tensor.__truediv__ = divide +Tensor.__rtruediv__ = rdivide +Tensor.mean = mean +Tensor.__matmul__ = matmul +Tensor.__rmatmul__ = rmatmul +Tensor.__mul__ = multiply +Tensor.__rmul__ = multiply +Tensor.__neg__ = negative +Tensor.__pow__ = power +Tensor.__rpow__ = rpower +Tensor.prod = prod +Tensor.__sub__ = subtract +Tensor.__rsub__ = rsubtract +Tensor.sum = sum + + +__all__ = [ + "add", + "divide", + "exp", + "log", + "matmul", + "mean", + "multiply", + "power", + "prod", + "sqrt", + "square", + "subtract", + "sum" +] diff --git a/books/PRML/PRML-master-Python/prml/nn/math/abs.py b/books/PRML/PRML-master-Python/prml/nn/math/abs.py new file mode 100755 index 0000000..563bc6e --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/math/abs.py @@ -0,0 +1,27 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Abs(Function): + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + self.output = np.abs(x.value) + if isinstance(x, Constant): + return Constant(self.output) + self.sign = np.sign(x.value) + return Tensor(self.output, function=self) + + def backward(self, delta): + dx = self.sign * delta + self.x.backward(dx) + + +def abs(x): + """ + element-wise absolute function + """ + return Abs().forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/math/add.py b/books/PRML/PRML-master-Python/prml/nn/math/add.py new file mode 100755 index 0000000..6779668 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/math/add.py @@ -0,0 +1,40 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function +from prml.nn.array.broadcast import broadcast_to + + +class Add(Function): + """ + add arguments element-wise + """ + + def _check_input(self, x, y): + x = self._convert2tensor(x) + y = self._convert2tensor(y) + if x.shape != y.shape: + shape = np.broadcast(x.value, y.value).shape + if x.shape != shape: + x = broadcast_to(x, shape) + if y.shape != shape: + y = broadcast_to(y, shape) + return x, y + + def forward(self, x, y): + x, y = self._check_input(x, y) + self.x = x + self.y = y + if isinstance(self.x, Constant) and isinstance(self.y, Constant): + return Constant(x.value + y.value) + return Tensor(x.value + y.value, function=self) + + def backward(self, delta): + dx = delta + dy = delta + self.x.backward(dx) + self.y.backward(dy) + + +def add(x, y): + return Add().forward(x, y) diff --git a/books/PRML/PRML-master-Python/prml/nn/math/divide.py b/books/PRML/PRML-master-Python/prml/nn/math/divide.py new file mode 100755 index 0000000..e9ec694 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/math/divide.py @@ -0,0 +1,44 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function +from prml.nn.array.broadcast import broadcast_to + + +class Divide(Function): + """ + divide arguments element-wise + """ + + def _check_input(self, x, y): + x = self._convert2tensor(x) + y = self._convert2tensor(y) + if x.shape != y.shape: + shape = np.broadcast(x.value, y.value).shape + if x.shape != shape: + x = broadcast_to(x, shape) + if y.shape != shape: + y = broadcast_to(y, shape) + return x, y + + def forward(self, x, y): + x, y = self._check_input(x, y) + self.x = x + self.y = y + if isinstance(self.x, Constant) and isinstance(self.y, Constant): + return Constant(x.value / y.value) + return Tensor(x.value / y.value, function=self) + + def backward(self, delta): + dx = delta / self.y.value + dy = - delta * self.x.value / self.y.value ** 2 + self.x.backward(dx) + self.y.backward(dy) + + +def divide(x, y): + return Divide().forward(x, y) + + +def rdivide(x, y): + return Divide().forward(y, x) diff --git a/books/PRML/PRML-master-Python/prml/nn/math/exp.py b/books/PRML/PRML-master-Python/prml/nn/math/exp.py new file mode 100755 index 0000000..8496f7b --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/math/exp.py @@ -0,0 +1,26 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Exp(Function): + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + self.output = np.exp(x.value) + if isinstance(self.x, Constant): + return Constant(self.output) + return Tensor(self.output, function=self) + + def backward(self, delta): + dx = self.output * delta + self.x.backward(dx) + + +def exp(x): + """ + element-wise exponential function + """ + return Exp().forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/math/gamma.py b/books/PRML/PRML-master-Python/prml/nn/math/gamma.py new file mode 100755 index 0000000..24c72bb --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/math/gamma.py @@ -0,0 +1,26 @@ +import scipy.special as sp +from prml.nn.function import Function +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor + + +class Gamma(Function): + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + self.output = sp.gamma(x.value) + if isinstance(x, Constant): + return Constant(self.output) + return Tensor(self.output, function=self) + + def backward(self, delta): + dx = delta * self.output * sp.digamma(self.x.value) + self.x.backward(dx) + + +def gamma(x): + """ + element-wise gamma function + """ + return Gamma().forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/math/log.py b/books/PRML/PRML-master-Python/prml/nn/math/log.py new file mode 100755 index 0000000..c96fec2 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/math/log.py @@ -0,0 +1,31 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Log(Function): + """ + element-wise natural logarithm of the input + y = log(x) + """ + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + output = np.log(self.x.value) + if isinstance(self.x, Constant): + return Constant(output) + return Tensor(output, function=self) + + def backward(self, delta): + dx = delta / self.x.value + self.x.backward(dx) + + +def log(x): + """ + element-wise natural logarithm of the input + y = log(x) + """ + return Log().forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/math/matmul.py b/books/PRML/PRML-master-Python/prml/nn/math/matmul.py new file mode 100755 index 0000000..c364d64 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/math/matmul.py @@ -0,0 +1,43 @@ +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class MatMul(Function): + """ + Matrix multiplication function + """ + + def _check_input(self, x, y): + x = self._convert2tensor(x) + y = self._convert2tensor(y) + self._equal_ndim(x, 2) + self._equal_ndim(y, 2) + if x.shape[1] != y.shape[0]: + raise ValueError( + "shapes {} and {} not aligned: {} (dim 1) != {} (dim 0)" + .format(x.shape, y.shape, x.shape[1], y.shape[0]) + ) + return x, y + + def forward(self, x, y): + x, y = self._check_input(x, y) + self.x = x + self.y = y + if isinstance(self.x, Constant) and isinstance(self.y, Constant): + return Constant(x.value @ y.value) + return Tensor(x.value @ y.value, function=self) + + def backward(self, delta): + dx = delta @ self.y.value.T + dy = self.x.value.T @ delta + self.x.backward(dx) + self.y.backward(dy) + + +def matmul(x, y): + return MatMul().forward(x, y) + + +def rmatmul(x, y): + return MatMul().forward(y, x) diff --git a/books/PRML/PRML-master-Python/prml/nn/math/mean.py b/books/PRML/PRML-master-Python/prml/nn/math/mean.py new file mode 100755 index 0000000..f6aca80 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/math/mean.py @@ -0,0 +1,21 @@ +from prml.nn.math.sum import sum + + +def mean(x, axis=None, keepdims=False): + """ + returns arithmetic mean of the elements along given axis + """ + if axis is None: + return sum(x, axis=None, keepdims=keepdims) / x.size + elif isinstance(axis, int): + N = x.shape[axis] + return sum(x, axis=axis, keepdims=keepdims) / N + elif isinstance(axis, tuple): + N = 1 + for ax in axis: + N *= x.shape[ax] + return sum(x, axis=axis, keepdims=keepdims) / N + else: + raise TypeError( + "Unsupported type for axis: {}".format(type(axis)) + ) diff --git a/books/PRML/PRML-master-Python/prml/nn/math/multiply.py b/books/PRML/PRML-master-Python/prml/nn/math/multiply.py new file mode 100755 index 0000000..213e778 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/math/multiply.py @@ -0,0 +1,40 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function +from prml.nn.array.broadcast import broadcast_to + + +class Multiply(Function): + """ + multiply arguments element-wise + """ + + def _check_input(self, x, y): + x = self._convert2tensor(x) + y = self._convert2tensor(y) + if x.shape != y.shape: + shape = np.broadcast(x.value, y.value).shape + if x.shape != shape: + x = broadcast_to(x, shape) + if y.shape != shape: + y = broadcast_to(y, shape) + return x, y + + def forward(self, x, y): + x, y = self._check_input(x, y) + self.x = x + self.y = y + if isinstance(self.x, Constant) and isinstance(self.y, Constant): + return Constant(x.value * y.value) + return Tensor(x.value * y.value, function=self) + + def backward(self, delta): + dx = self.y.value * delta + dy = self.x.value * delta + self.x.backward(dx) + self.y.backward(dy) + + +def multiply(x, y): + return Multiply().forward(x, y) diff --git a/books/PRML/PRML-master-Python/prml/nn/math/negative.py b/books/PRML/PRML-master-Python/prml/nn/math/negative.py new file mode 100755 index 0000000..05ce66f --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/math/negative.py @@ -0,0 +1,28 @@ +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Negative(Function): + """ + element-wise negative + y = -x + """ + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + if isinstance(self.x, Constant): + return Constant(-x.value) + return Tensor(-x.value, function=self) + + def backward(self, delta): + dx = -delta + self.x.backward(dx) + + +def negative(x): + """ + element-wise negative + """ + return Negative().forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/math/power.py b/books/PRML/PRML-master-Python/prml/nn/math/power.py new file mode 100755 index 0000000..087932c --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/math/power.py @@ -0,0 +1,57 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function +from prml.nn.array.broadcast import broadcast_to + + +class Power(Function): + """ + First array elements raised to powers from second array + """ + + def _check_input(self, x, y): + x = self._convert2tensor(x) + y = self._convert2tensor(y) + if x.shape != y.shape: + shape = np.broadcast(x.value, y.value).shape + if x.shape != shape: + x = broadcast_to(x, shape) + if y.shape != shape: + y = broadcast_to(y, shape) + return x, y + + def forward(self, x, y): + x, y = self._check_input(x, y) + self.x = x + self.y = y + self.output = np.power(x.value, y.value) + if isinstance(self.x, Constant) and isinstance(self.y, Constant): + return Constant(self.output) + return Tensor(self.output, function=self) + + def backward(self, delta): + dx = self.y.value * np.power(self.x.value, self.y.value - 1) * delta + if self.x.size == 1: + if self.x.value > 0: + dy = self.output * np.log(self.x.value) * delta + else: + dy = None + else: + if (self.x.value > 0).all(): + dy = self.output * np.log(self.x.value) * delta + else: + dy = None + self.x.backward(dx) + self.y.backward(dy) + + +def power(x, y): + """ + First array elements raised to powers from second array + """ + return Power().forward(x, y) + + +def rpower(x, y): + return Power().forward(y, x) diff --git a/books/PRML/PRML-master-Python/prml/nn/math/product.py b/books/PRML/PRML-master-Python/prml/nn/math/product.py new file mode 100755 index 0000000..c9e5f46 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/math/product.py @@ -0,0 +1,55 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Product(Function): + + def __init__(self, axis=None, keepdims=False): + if isinstance(axis, int): + axis = (axis,) + elif isinstance(axis, tuple): + axis = tuple(sorted(axis)) + self.axis = axis + self.keepdims = keepdims + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + self.output = np.prod(self.x.value, axis=self.axis, keepdims=True) + if not self.keepdims: + output = np.squeeze(self.output) + if output.size == 1: + output = output.item() + else: + output = self.output + if isinstance(self.x, Constant): + return Constant(output) + return Tensor(output, function=self) + + def backward(self, delta): + if not self.keepdims and self.axis is not None: + for ax in self.axis: + delta = np.expand_dims(delta, ax) + dx = delta * self.output / self.x.value + self.x.backward(dx) + + +def prod(x, axis=None, keepdims=False): + """ + product of all element in the array + Parameters + ---------- + x : tensor_like + input array + axis : int, tuple of ints + axis or axes along which a product is performed + keepdims : bool + keep dimensionality or not + Returns + ------- + product : tensor_like + product of all element + """ + return Product(axis=axis, keepdims=keepdims).forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/math/sqrt.py b/books/PRML/PRML-master-Python/prml/nn/math/sqrt.py new file mode 100755 index 0000000..072a538 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/math/sqrt.py @@ -0,0 +1,31 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Sqrt(Function): + """ + element-wise square root of the input + y = sqrt(x) + """ + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + self.output = np.sqrt(x.value) + if isinstance(self.x, Constant): + return Constant(self.output) + return Tensor(self.output, function=self) + + def backward(self, delta): + dx = 0.5 * delta / self.output + self.x.backward(dx) + + +def sqrt(x): + """ + element-wise square root of the input + y = sqrt(x) + """ + return Sqrt().forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/math/square.py b/books/PRML/PRML-master-Python/prml/nn/math/square.py new file mode 100755 index 0000000..b3f7055 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/math/square.py @@ -0,0 +1,30 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Square(Function): + """ + element-wise square of the input + y = x * x + """ + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + if isinstance(self.x, Constant): + return Constant(np.square(x.value)) + return Tensor(np.square(x.value), function=self) + + def backward(self, delta): + dx = 2 * self.x.value * delta + self.x.backward(dx) + + +def square(x): + """ + element-wise square of the input + y = x * x + """ + return Square().forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/math/subtract.py b/books/PRML/PRML-master-Python/prml/nn/math/subtract.py new file mode 100755 index 0000000..a115322 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/math/subtract.py @@ -0,0 +1,44 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function +from prml.nn.array.broadcast import broadcast_to + + +class Subtract(Function): + """ + subtract arguments element-wise + """ + + def _check_input(self, x, y): + x = self._convert2tensor(x) + y = self._convert2tensor(y) + if x.shape != y.shape: + shape = np.broadcast(x.value, y.value).shape + if x.shape != shape: + x = broadcast_to(x, shape) + if y.shape != shape: + y = broadcast_to(y, shape) + return x, y + + def forward(self, x, y): + x, y = self._check_input(x, y) + self.x = x + self.y = y + if isinstance(self.x, Constant) and isinstance(self.y, Constant): + return Constant(x.value - y.value) + return Tensor(x.value - y.value, function=self) + + def backward(self, delta): + dx = delta + dy = -delta + self.x.backward(dx) + self.y.backward(dy) + + +def subtract(x, y): + return Subtract().forward(x, y) + + +def rsubtract(x, y): + return Subtract().forward(y, x) diff --git a/books/PRML/PRML-master-Python/prml/nn/math/sum.py b/books/PRML/PRML-master-Python/prml/nn/math/sum.py new file mode 100755 index 0000000..de62b6e --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/math/sum.py @@ -0,0 +1,46 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Sum(Function): + """ + summation along given axis + y = sum_i=1^N x_i + """ + + def __init__(self, axis=None, keepdims=False): + if isinstance(axis, int): + axis = (axis,) + self.axis = axis + self.keepdims = keepdims + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + output = x.value.sum(axis=self.axis, keepdims=self.keepdims) + if isinstance(self.x, Constant): + return Constant(output) + return Tensor(output, function=self) + + def backward(self, delta): + if isinstance(delta, np.ndarray) and (not self.keepdims) and (self.axis is not None): + axis_positive = [] + for axis in self.axis: + if axis < 0: + axis_positive.append(self.x.ndim + axis) + else: + axis_positive.append(axis) + for axis in sorted(axis_positive): + delta = np.expand_dims(delta, axis) + dx = np.broadcast_to(delta, self.x.shape) + self.x.backward(dx) + + +def sum(x, axis=None, keepdims=False): + """ + returns summation of the elements along given axis + y = sum_i=1^N x_i + """ + return Sum(axis=axis, keepdims=keepdims).forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/network.py b/books/PRML/PRML-master-Python/prml/nn/network.py new file mode 100755 index 0000000..af5be43 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/network.py @@ -0,0 +1,90 @@ +from prml.nn.random.random import RandomVariable +from prml.nn.tensor.parameter import Parameter + + +class Network(object): + """ + a base class for network building + + Parameters + ---------- + kwargs : tensor_like + parameters to be optimized + + Attributes + ---------- + parameter : dict + dictionary of parameters to be optimized + random_variable : dict + dictionary of random varibles + """ + + def __init__(self, **kwargs): + self.random_variable = {} + self.parameter = {} + for key, value in kwargs.items(): + if isinstance(value, Parameter): + self.parameter[key] = value + else: + try: + value = Parameter(value) + except TypeError: + raise TypeError(f"invalid type argument: {type(value)}") + self.parameter[key] = value + object.__setattr__(self, key, value) + + def __setattr__(self, key, value): + if isinstance(value, RandomVariable): + self.random_variable[key] = value + object.__setattr__(self, key, value) + + def clear(self): + """ + clear gradient and constructed bayesian network + """ + for p in self.parameter.values(): + p.cleargrad() + self.random_variable = {} + + def log_pdf(self, coef=1.): + """ + compute logarithm of probabilty density function + Parameters + ---------- + coef : float + coefficient to balance likelihood and prior + assuming mini-batch size / whole data size for mini-batch training + Returns + ------- + logp : tensor_like + logarithm of probability density function + """ + logp = 0 + for rv in self.random_variable.values(): + if rv.observed: + logp += rv.log_pdf().sum() + else: + logp += coef * rv.log_pdf().sum() + return logp + + def elbo(self, coef=1.): + """ + compute evidence lower bound of this model + ln p(output) >= elbo + Parameters + ---------- + coef : float + coefficient to balance likelihood and prior + assuming mini-batch size / whole data size for mini-batch training + Returns + ------- + evidence : tensor_like + evidence lower bound + """ + evidence = 0 + for rv in self.random_variable.values(): + if rv.observed: + evidence += rv.log_pdf().sum() + else: + evidence += -coef * rv.KLqp().sum() + return evidence diff --git a/books/PRML/PRML-master-Python/prml/nn/nonlinear/__init__.py b/books/PRML/PRML-master-Python/prml/nn/nonlinear/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/books/PRML/PRML-master-Python/prml/nn/nonlinear/log_softmax.py b/books/PRML/PRML-master-Python/prml/nn/nonlinear/log_softmax.py new file mode 100755 index 0000000..e3c1170 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/nonlinear/log_softmax.py @@ -0,0 +1,32 @@ +import numpy as np +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class LogSoftmax(Function): + + def __init__(self, axis=-1): + self.axis = axis + + def _logsumexp(self, x): + x_max = np.max(x, axis=self.axis, keepdims=True) + y = x - x_max + np.exp(y, out=y) + np.log(y.sum(axis=self.axis, keepdims=True), out=y) + y += x_max + return y + + def _forward(self, x): + x = self._convert2tensor(x) + self.x = x + self.output = x.value - self._logsumexp(x.value) + return Tensor(self.output, function=self) + + def _backward(self, delta): + dx = delta + dx -= np.exp(self.output) * dx.sum(axis=self.axis, keepdims=True) + self.x.backward(dx) + + +def log_softmax(x, axis=-1): + return LogSoftmax(axis=axis).forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/nonlinear/relu.py b/books/PRML/PRML-master-Python/prml/nn/nonlinear/relu.py new file mode 100755 index 0000000..b5b8856 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/nonlinear/relu.py @@ -0,0 +1,32 @@ +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class ReLU(Function): + """ + Rectified Linear Unit + + y = max(x, 0) + """ + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + output = x.value.clip(min=0) + if isinstance(x, Constant): + return Constant(output) + return Tensor(output, function=self) + + def backward(self, delta): + dx = (self.x.value > 0) * delta + self.x.backward(dx) + + +def relu(x): + """ + Rectified Linear Unit + + y = max(x, 0) + """ + return ReLU().forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/nonlinear/sigmoid.py b/books/PRML/PRML-master-Python/prml/nn/nonlinear/sigmoid.py new file mode 100755 index 0000000..5026833 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/nonlinear/sigmoid.py @@ -0,0 +1,31 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Sigmoid(Function): + """ + logistic sigmoid function + y = 1 / (1 + exp(-x)) + """ + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + self.output = np.tanh(x.value * 0.5) * 0.5 + 0.5 + if isinstance(self.x, Constant): + return Constant(self.output) + return Tensor(self.output, function=self) + + def backward(self, delta): + dx = self.output * (1 - self.output) * delta + self.x.backward(dx) + + +def sigmoid(x): + """ + logistic sigmoid function + y = 1 / (1 + exp(-x)) + """ + return Sigmoid().forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/nonlinear/softmax.py b/books/PRML/PRML-master-Python/prml/nn/nonlinear/softmax.py new file mode 100755 index 0000000..28d0f98 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/nonlinear/softmax.py @@ -0,0 +1,39 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Softmax(Function): + + def __init__(self, axis=-1): + if not isinstance(axis, int): + raise TypeError("axis must be int") + self.axis = axis + + def _softmax(self, array): + y = array - np.max(array, self.axis, keepdims=True) + np.exp(y, out=y) + y /= y.sum(self.axis, keepdims=True) + return y + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + self.output = self._softmax(x.value) + if isinstance(x, Constant): + return Constant(self.output) + return Tensor(self.output, function=self) + + def backward(self, delta): + dx = self.output * delta + dx -= self.output * dx.sum(self.axis, keepdims=True) + self.x.backward(dx) + + +def softmax(x, axis=-1): + """ + softmax function along specified axis + y_k = exp(x_k) / sum_i(exp(x_i)) + """ + return Softmax(axis=axis).forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/nonlinear/softplus.py b/books/PRML/PRML-master-Python/prml/nn/nonlinear/softplus.py new file mode 100755 index 0000000..3539696 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/nonlinear/softplus.py @@ -0,0 +1,27 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Softplus(Function): + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + output = np.maximum(x.value, 0) + np.log1p(np.exp(-np.abs(x.value))) + if isinstance(x, Constant): + return Constant(output) + return Tensor(output, function=self) + + def backward(self, delta): + dx = (np.tanh(0.5 * self.x.value) * 0.5 + 0.5) * delta + self.x.backward(dx) + + +def softplus(x): + """ + smoothed rectified linear unit + log(1 + exp(x)) + """ + return Softplus().forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/nonlinear/tanh.py b/books/PRML/PRML-master-Python/prml/nn/nonlinear/tanh.py new file mode 100755 index 0000000..4caacd3 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/nonlinear/tanh.py @@ -0,0 +1,27 @@ +import numpy as np +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Tanh(Function): + + def forward(self, x): + x = self._convert2tensor(x) + self.x = x + self.output = np.tanh(x.value) + if isinstance(self.x, Constant): + return Constant(self.output) + return Tensor(self.output, function=self) + + def backward(self, delta): + dx = (1 - np.square(self.output)) * delta + self.x.backward(dx) + + +def tanh(x): + """ + hyperbolic tangent function + y = (exp(x) - exp(-x)) / (exp(x) + exp(-x)) + """ + return Tanh().forward(x) diff --git a/books/PRML/PRML-master-Python/prml/nn/optimizer/__init__.py b/books/PRML/PRML-master-Python/prml/nn/optimizer/__init__.py new file mode 100755 index 0000000..bf74852 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/optimizer/__init__.py @@ -0,0 +1,16 @@ +from prml.nn.optimizer.ada_delta import AdaDelta +from prml.nn.optimizer.ada_grad import AdaGrad +from prml.nn.optimizer.adam import Adam +from prml.nn.optimizer.gradient_ascent import GradientAscent +from prml.nn.optimizer.momentum import Momentum +from prml.nn.optimizer.rmsprop import RMSProp + + +__all__ = [ + "AdaDelta", + "AdaGrad", + "Adam", + "GradientAscent", + "Momentum", + "RMSProp" +] diff --git a/books/PRML/PRML-master-Python/prml/nn/optimizer/ada_delta.py b/books/PRML/PRML-master-Python/prml/nn/optimizer/ada_delta.py new file mode 100755 index 0000000..f709fa3 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/optimizer/ada_delta.py @@ -0,0 +1,31 @@ +import numpy as np +from prml.nn.optimizer.optimizer import Optimizer + + +class AdaDelta(Optimizer): + """ + AdaDelta optimizer + """ + + def __init__(self, parameter, rho=0.95, epsilon=1e-8): + super().__init__(parameter, None) + self.rho = rho + self.epsilon = epsilon + self.mean_squared_deriv = [] + self.mean_squared_update = [] + for p in self.parameter: + self.mean_squared_deriv.append(np.zeros(p.shape)) + self.mean_squared_update.append(np.zeros(p.shape)) + + def update(self): + self.increment_iteration() + for p, msd, msu in zip(self.parameter, self.mean_squared_deriv, self.mean_squared_update): + if p.grad is None: + continue + grad = p.grad + msd *= self.rho + msd += (1 - self.rho) * grad ** 2 + delta = np.sqrt((msu + self.epsilon) / (msd + self.epsilon)) * grad + msu *= self.rho + msu *= (1 - self.rho) * delta ** 2 + p.value += delta diff --git a/books/PRML/PRML-master-Python/prml/nn/optimizer/ada_grad.py b/books/PRML/PRML-master-Python/prml/nn/optimizer/ada_grad.py new file mode 100755 index 0000000..a06dce7 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/optimizer/ada_grad.py @@ -0,0 +1,32 @@ +import numpy as np +from prml.nn.optimizer.optimizer import Optimizer + + +class AdaGrad(Optimizer): + """ + AdaGrad optimizer + initialization + G = 0 + update rule + G += gradient ** 2 + param -= learning_rate * gradient / sqrt(G + eps) + """ + + def __init__(self, parameter, learning_rate=0.001, epsilon=1e-8): + super().__init__(parameter, learning_rate) + self.epsilon = epsilon + self.G = [] + for p in self.parameter: + self.G.append(np.zeros(p.shape)) + + def update(self): + """ + update parameters + """ + self.increment_iteration() + for p, G in zip(self.parameter, self.G): + if p.grad is None: + continue + grad = p.grad + G += grad ** 2 + p.value += self.learning_rate * grad / (np.sqrt(G) + self.epsilon) diff --git a/books/PRML/PRML-master-Python/prml/nn/optimizer/adam.py b/books/PRML/PRML-master-Python/prml/nn/optimizer/adam.py new file mode 100755 index 0000000..fcf3779 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/optimizer/adam.py @@ -0,0 +1,67 @@ +import numpy as np +from prml.nn.optimizer.optimizer import Optimizer + + +class Adam(Optimizer): + """ + Adam optimizer + initialization + m1 = 0 (Initial 1st moment of gradient) + m2 = 0 (Initial 2nd moment of gradient) + n_iter = 0 + update rule + n_iter += 1 + learning_rate *= sqrt(1 - beta2^n) / (1 - beta1^n) + m1 = beta1 * m1 + (1 - beta1) * gradient + m2 = beta2 * m2 + (1 - beta2) * gradient^2 + param += learning_rate * m1 / (sqrt(m2) + epsilon) + """ + + def __init__(self, parameter, learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-8): + """ + construct Adam optimizer + Parameters + ---------- + parameters : list + list of parameters to be optimized + learning_rate : float + beta1 : float + exponential decay rate for the 1st moment + beta2 : float + exponential decay rate for the 2nd moment + epsilon : float + small constant to be added to denominator for numerical stability + Attributes + ---------- + n_iter : int + number of iterations performed + moment1 : dict + 1st moment of each learnable parameter + moment2 : dict + 2nd moment of each learnable parameter + """ + super().__init__(parameter, learning_rate) + self.beta1 = beta1 + self.beta2 = beta2 + self.epsilon = epsilon + self.moment1 = [] + self.moment2 = [] + for p in self.parameter: + self.moment1.append(np.zeros(p.shape)) + self.moment2.append(np.zeros(p.shape)) + + def update(self): + """ + update parameter of the neural network + """ + self.increment_iteration() + lr = ( + self.learning_rate + * (1 - self.beta2 ** self.n_iter) ** 0.5 + / (1 - self.beta1 ** self.n_iter)) + for p, m1, m2 in zip(self.parameter, self.moment1, self.moment2): + if p.grad is None: + continue + m1 += (1 - self.beta1) * (p.grad - m1) + m2 += (1 - self.beta2) * (p.grad ** 2 - m2) + p.value += lr * m1 / (np.sqrt(m2) + self.epsilon) diff --git a/books/PRML/PRML-master-Python/prml/nn/optimizer/eve.py b/books/PRML/PRML-master-Python/prml/nn/optimizer/eve.py new file mode 100755 index 0000000..7da02a5 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/optimizer/eve.py @@ -0,0 +1,101 @@ +import numpy as np +from prml.nn.optimizer.optimizer import Optimizer + + +class Eve(Optimizer): + """ + Eve optimizer + + initialization + m1 = 0 (initial 1st moment of gradient) + m2 = 0 (initial 2nd moment of gradient) + n_iter = 0 + + update rule + n_iter += 1 + learning + """ + + def __init__(self, + network, + learning_rate=0.001, + beta1=0.9, + beta2=0.999, + beta3=0.999, + lower_threshold=0.1, + upper_threshold=10., + epsilon=1e-8): + """ + construct Eve optimizer + + Parameters + ---------- + network : Network + neural network to be optmized + learning_rate : float + beta1 : float + exponential decay rate for the 1st moment + beta2 : float + exponential decay rate for the 2nd moment + beta3 : float + exponential decay rate for computing relative change + lower_threshold : float + lower threshold for relative change + upper_threshold : float + upper threshold for relative change + epsilon : float + small constant to be added to denominator for numerical stability + + Attributes + ---------- + n_iter : int + number of iterations performed + moment1 : dict + 1st moment of each parameter + moment2 : dict + 2nd moment of each parameter + """ + super().__init__(network, learning_rate) + self.beta1 = beta1 + self.beta2 = beta2 + self.beta3 = beta3 + self.lower_threshold = lower_threshold + self.upper_threshold = upper_threshold + self.epsilon = epsilon + self.moment1 = {} + self.moment2 = {} + self.f = 1. + self.d = 1. + for key, param in self.params.items(): + self.moment1[key] = np.zeros(param.shape) + self.moment2[key] = np.zeros(param.shape) + + def update(self, loss): + loss = float(loss) + self.increment_iteration() + if self.n_iter > 1: + if loss > self.f: + delta = self.lower_threshold + 1 + Delta = self.upper_threshold + 1 + else: + delta = 1 / (self.upper_threshold + 1) + Delta = 1 / (self.lower_threshold + 1) + c = min(max(delta, loss / self.f), Delta) + f = c * self.f + r = abs(f - self.f) / min(f, self.f) + self.d = self.beta3 * self.d * (1 - self.beta3) * r + self.f = f + else: + self.f = loss + self.d = 1 + lr = ( + self.learning_rate + * (1 - self.beta2 ** self.n_iter) ** 0.5 + / (1 - self.beta1 ** self.n_iter) + ) + for key, param in self.params.items(): + m1 = self.moment1[key] + m2 = self.moment2[key] + m1 += (1 - self.beta1) * (param.grad - m1) + m2 += (1 - self.beta2) * (param.grad ** 2 - m2) + param.value -= lr * m1 / (self.d * np.sqrt(m2) + self.epsilon) diff --git a/books/PRML/PRML-master-Python/prml/nn/optimizer/gradient_ascent.py b/books/PRML/PRML-master-Python/prml/nn/optimizer/gradient_ascent.py new file mode 100755 index 0000000..b75ba9b --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/optimizer/gradient_ascent.py @@ -0,0 +1,18 @@ +from prml.nn.optimizer.optimizer import Optimizer + + +class GradientAscent(Optimizer): + """ + gradient ascent optimizer + parameter += learning_rate * gradient + """ + + def update(self): + """ + update parameters to be optimized + """ + self.increment_iteration() + for p in self.parameter: + if p.grad is None: + continue + p.value += self.learning_rate * p.grad diff --git a/books/PRML/PRML-master-Python/prml/nn/optimizer/momentum.py b/books/PRML/PRML-master-Python/prml/nn/optimizer/momentum.py new file mode 100755 index 0000000..9b93cc7 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/optimizer/momentum.py @@ -0,0 +1,29 @@ +import numpy as np +from prml.nn.optimizer.optimizer import Optimizer + + +class Momentum(Optimizer): + """ + Momentum optimizer + initialization + v = 0 + update rule + v = v * momentum - learning_rate * gradient + param += v + """ + + def __init__(self, parameter, learning_rate, momentum=0.9): + super().__init__(parameter, learning_rate) + self.momentum = momentum + self.inertia = [] + for p in self.parameter: + self.inertia.append(np.zeros(p.shape)) + + def update(self): + self.increment_iteration() + for p, inertia in zip(self.parameter, self.inertia): + if p.grad is None: + continue + inertia *= self.momentum + inertia -= self.learning_rate * p.grad + p.value += inertia diff --git a/books/PRML/PRML-master-Python/prml/nn/optimizer/optimizer.py b/books/PRML/PRML-master-Python/prml/nn/optimizer/optimizer.py new file mode 100755 index 0000000..f2ac74e --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/optimizer/optimizer.py @@ -0,0 +1,52 @@ +from prml.nn.network import Network + + +class Optimizer(object): + """ + Optimizer to train neural network + """ + + def __init__(self, parameter, learning_rate): + """ + construct optimizer + Parameters + ---------- + parameter : list, dict, Network + list of parameter to be optimized + learning_rate : float + update rate of parameter to be optimized + Attributes + ---------- + n_iter : int + number of iterations performed + """ + if isinstance(parameter, Network): + parameter = parameter.parameter + if isinstance(parameter, dict): + parameter = list(parameter.values()) + self.parameter = parameter + self.learning_rate = learning_rate + self.n_iter = 0 + + def cleargrad(self): + for p in self.parameter: + p.cleargrad() + + def set_decay(self, decay_rate, decay_step): + """ + set exponential decay parameters + Parameters + ---------- + decay_rate : float + dacay rate of the learning rate + decay_step : int + steps to decay the learning rate + """ + self.decay_rate = decay_rate + self.decay_step = decay_step + + def increment_iteration(self): + self.n_iter += 1 + if hasattr(self, "decay_rate"): + if self.n_iter % self.decay_step == 0: + self.learning_rate *= self.decay_rate diff --git a/books/PRML/PRML-master-Python/prml/nn/optimizer/rmsprop.py b/books/PRML/PRML-master-Python/prml/nn/optimizer/rmsprop.py new file mode 100755 index 0000000..459c4f6 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/optimizer/rmsprop.py @@ -0,0 +1,36 @@ +import numpy as np +from prml.nn.optimizer.optimizer import Optimizer + + +class RMSProp(Optimizer): + """ + RMSProp optimizer + initial + msg = 0 + update rule + msg = rho * msg + (1 - rho) * gradient ** 2 + param -= learning_rate * gradient / (sqrt(msg) + eps) + """ + + def __init__(self, parameter, learning_rate=1e-3, rho=0.9, epsilon=1e-8): + super().__init__(parameter, learning_rate) + self.rho = rho + self.epsilon = epsilon + self.mean_squared_grad = [] + for p in self.parameter: + self.mean_squared_grad.append(np.zeros(p.shape)) + + def update(self): + """ + update parameters + """ + self.increment_iteration() + for p, msg in zip(self.parameter, self.mean_squared_grad): + if p.grad is None: + continue + grad = p.grad + msg *= self.rho + msg += (1 - self.rho) * grad ** 2 + p.value -= ( + self.learning_rate * grad / (np.sqrt(msg) + self.epsilon) + ) diff --git a/books/PRML/PRML-master-Python/prml/nn/random/__init__.py b/books/PRML/PRML-master-Python/prml/nn/random/__init__.py new file mode 100755 index 0000000..abe1868 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/random/__init__.py @@ -0,0 +1,25 @@ +from prml.nn.random.bernoulli import Bernoulli +from prml.nn.random.categorical import Categorical +from prml.nn.random.cauchy import Cauchy +from prml.nn.random.dirichlet import Dirichlet +from prml.nn.random.dropout import dropout +from prml.nn.random.exponential import Exponential +from prml.nn.random.gamma import Gamma +from prml.nn.random.gaussian import Gaussian +from prml.nn.random.gaussian_mixture import GaussianMixture +from prml.nn.random.laplace import Laplace +from prml.nn.random.multivariate_gaussian import MultivariateGaussian + + +__all__ = [ + "Bernoulli", + "Categorical", + "Cauchy", + "Dirichlet", + "Exponential", + "Gamma", + "Gaussian", + "GaussianMixture", + "Laplace", + "MultivariateGaussian" +] diff --git a/books/PRML/PRML-master-Python/prml/nn/random/bernoulli.py b/books/PRML/PRML-master-Python/prml/nn/random/bernoulli.py new file mode 100755 index 0000000..6b194c9 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/random/bernoulli.py @@ -0,0 +1,126 @@ +import numpy as np +from prml.nn.array.broadcast import broadcast_to +from prml.nn.function import Function +from prml.nn.math.log import log +from prml.nn.nonlinear.sigmoid import sigmoid +from prml.nn.random.random import RandomVariable +from prml.nn.tensor.tensor import Tensor + + +class Bernoulli(RandomVariable): + """ + Bernoulli distribution + p(x|mu) = mu^x (1 - mu)^(1 - x) + Parameters + ---------- + mu : tensor_like + probability of value 1 + logit : tensor_like + log-odd of value 1 + data : tensor_like + observed data + p : RandomVariable + original distribution of a model + """ + + def __init__(self, mu=None, logit=None, data=None, p=None): + super().__init__(data, p) + if mu is not None and logit is None: + mu = self._convert2tensor(mu) + self.mu = mu + elif mu is None and logit is not None: + logit = self._convert2tensor(logit) + self.logit = logit + elif mu is None and logit is None: + raise ValueError("Either mu or logit must not be None") + else: + raise ValueError("Cannot assign both mu and logit") + + @property + def mu(self): + try: + return self.parameter["mu"] + except KeyError: + return sigmoid(self.logit) + + @mu.setter + def mu(self, mu): + try: + inrange = (0 <= mu.value <= 1) + except ValueError: + inrange = ((mu.value >= 0).all() and (mu.value <= 1).all()) + + if not inrange: + raise ValueError("value of mu must all be positive") + self.parameter["mu"] = mu + + @property + def logit(self): + try: + return self.parameter["logit"] + except KeyError: + raise AttributeError("no attribute named logit") + + @logit.setter + def logit(self, logit): + self.parameter["logit"] = logit + + def forward(self): + return (np.random.uniform(size=self.mu.shape) < self.mu.value).astype(np.int) + + def _pdf(self, x): + return self.mu ** x * (1 - self.mu) ** (1 - x) + + def _log_pdf(self, x): + try: + return -SigmoidCrossEntropy().forward(self.logit, x) + except AttributeError: + return x * log(self.mu) + (1 - x) * log(1 - self.mu) + + +class SigmoidCrossEntropy(Function): + """ + sum of cross entropies for binary data + logistic sigmoid + y_i = 1 / (1 + exp(-x_i)) + cross_entropy_i = -t_i * log(y_i) - (1 - t_i) * log(1 - y_i) + Parameters + ---------- + x : ndarary + input logit + y : ndarray + corresponding target binaries + """ + + def _check_input(self, x, t): + x = self._convert2tensor(x) + t = self._convert2tensor(t) + if x.shape != t.shape: + shape = np.broadcast(x.value, t.value).shape + if x.shape != shape: + x = broadcast_to(x, shape) + if t.shape != shape: + t = broadcast_to(t, shape) + return x, t + + + def forward(self, x, t): + x, t = self._check_input(x, t) + self.x = x + self.t = t + # y = self.forward(x) + # np.clip(y, 1e-10, 1 - 1e-10, out=y) + # return np.sum(-t * np.log(y) - (1 - t) * np.log(1 - y)) + loss = ( + np.maximum(x.value, 0) + - t.value * x.value + + np.log1p(np.exp(-np.abs(x.value))) + ) + return Tensor(loss, function=self) + + def backward(self, delta): + y = np.tanh(self.x.value * 0.5) * 0.5 + 0.5 + dx = delta * (y - self.t.value) + dt = - delta * self.x.value + self.x.backward(dx) + self.t.backward(dt) diff --git a/books/PRML/PRML-master-Python/prml/nn/random/categorical.py b/books/PRML/PRML-master-Python/prml/nn/random/categorical.py new file mode 100755 index 0000000..0cc8401 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/random/categorical.py @@ -0,0 +1,131 @@ +import numpy as np +from prml.nn.array.broadcast import broadcast_to +from prml.nn.function import Function +from prml.nn.math.log import log +from prml.nn.math.product import prod +from prml.nn.nonlinear.softmax import softmax +from prml.nn.random.random import RandomVariable +from prml.nn.tensor.tensor import Tensor + + +class Categorical(RandomVariable): + """ + Categorical distribution + Parameters + ---------- + mu : (..., K) tensor_like + probability of each index + logit : (..., K) tensor_like + log-odd of each index + axis : int + axis along which represents each outcome + data : tensor_like + realization + p : RandomVariable + original distribution of a model + Attributes + ---------- + n_category : int + number of categories + """ + + def __init__(self, mu=None, logit=None, axis=-1, data=None, p=None): + super().__init__(data, p) + assert axis == -1 + self.axis = axis + if mu is not None and logit is None: + self.mu = self._convert2tensor(mu) + elif mu is None and logit is not None: + self.logit = self._convert2tensor(logit) + elif mu is None and logit is None: + raise ValueError("Either mu or logit must not be None") + else: + raise ValueError("Cannot assign both mu and logit") + + @property + def mu(self): + try: + return self.parameter["mu"] + except KeyError: + return softmax(self.parameter["logit"]) + + @mu.setter + def mu(self, mu): + self._atleast_ndim(mu, 1) + if not ((mu.value >= 0).all() and (mu.value <= 1).all()): + raise ValueError("values of mu must be in [0, 1]") + if not np.allclose(mu.value.sum(axis=self.axis), 1): + raise ValueError(f"mu must be normalized along axis {self.axis}") + self.parameter["mu"] = mu + self.n_category = mu.shape[self.axis] + + @property + def logit(self): + try: + return self.parameter["logit"] + except KeyError: + raise AttributeError("no attribute named logit") + + @logit.setter + def logit(self, logit): + self._atleast_ndim(logit, 1) + self.parameter["logit"] = logit + self.n_category = logit.shape[self.axis] + + def forward(self): + if self.mu.ndim == 1: + index = np.random.choice(self.n_category, p=self.mu.value) + return np.eye(self.n_category)[index] + elif self.mu.ndim == 2: + indices = np.array( + [np.random.choice(self.n_category, p=p.value) for p in self.mu.value] + ) + return np.eye(self.n_category)[indices] + else: + raise NotImplementedError + + def _pdf(self, x): + return prod(self.mu ** x, axis=self.axis) + + def _log_pdf(self, x): + try: + return -SoftmaxCrossEntropy(axis=self.axis).forward(self.logit, x) + except (KeyError, AttributeError): + return (x * log(self.mu)).sum(axis=self.axis) + + +class SoftmaxCrossEntropy(Function): + + def __init__(self, axis=-1): + self.axis = axis + + def _check_input(self, x, t): + x = self._convert2tensor(x) + t = self._convert2tensor(t) + if x.shape != t.shape: + shape = np.broadcast(x.value, t.value).shape + if x.shape != shape: + x = broadcast_to(x, shape) + if t.shape != shape: + t = broadcast_to(t, shape) + return x, t + + def _softmax(self, array): + y = np.exp(array - np.max(array, self.axis, keepdims=True)) + y /= np.sum(y, self.axis, keepdims=True) + return y + + def forward(self, x, t): + x, t = self._check_input(x, t) + self.x = x + self.t = t + self.y = self._softmax(x.value) + np.clip(self.y, 1e-10, 1, out=self.y) + loss = -t.value * np.log(self.y) + return Tensor(loss, function=self) + + def backward(self, delta): + dx = delta * (self.y - self.t.value) + dt = - delta * np.log(self.y) + self.x.backward(dx) + self.t.backward(dt) diff --git a/books/PRML/PRML-master-Python/prml/nn/random/cauchy.py b/books/PRML/PRML-master-Python/prml/nn/random/cauchy.py new file mode 100755 index 0000000..98a7118 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/random/cauchy.py @@ -0,0 +1,88 @@ +import numpy as np +from prml.nn.array.broadcast import broadcast_to +from prml.nn.math.log import log +from prml.nn.math.square import square +from prml.nn.random.random import RandomVariable +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor + + +class Cauchy(RandomVariable): + """ + Cauchy distribution aka Lorentz distribution + p(x|x0(loc), scale) + = 1 / [pi*scale * {1 + (x - x0)^2 / scale^2}] + Parameters + ---------- + loc : tensor_like + location parameter + scale : tensor_like + scale parameter + data : tensor_like + realization + p : RandomVariable + original distribution of a model + """ + + def __init__(self, loc, scale, data=None, p=None): + super().__init__(data, p) + self.loc, self.scale = self._check_input(loc, scale) + + def _check_input(self, loc, scale): + loc = self._convert2tensor(loc) + scale = self._convert2tensor(scale) + if loc.shape != scale.shape: + shape = np.broadcast(loc.value, scale.value).shape + if loc.shape != shape: + loc = broadcast_to(loc, shape) + if scale.shape != shape: + scale = broadcast_to(scale, shape) + return loc, scale + + @property + def loc(self): + return self.parameter["loc"] + + @loc.setter + def loc(self, loc): + self.parameter["loc"] = loc + + @property + def scale(self): + return self.parameter["scale"] + + @scale.setter + def scale(self, scale): + try: + ispositive = (scale.value > 0).all() + except AttributeError: + ispositive = (scale.value > 0) + + if not ispositive: + raise ValueError("value of scale must be positive") + self.parameter["scale"] = scale + + def forward(self): + self.eps = np.random.standard_cauchy(size=self.loc.shape) + self.output = self.scale.value * self.eps + self.loc.value + if isinstance(self.loc, Constant): + return Constant(self.output) + return Tensor(self.output, function=self) + + def backward(self, delta): + dloc = delta + dscale = delta * self.eps + self.loc.backward(dloc) + self.scale.backward(dscale) + + def _pdf(self, x): + return ( + 1 / (np.pi * self.scale * (1 + square((x - self.loc) / self.scale))) + ) + + def _log_pdf(self, x): + return ( + -np.log(np.pi) + - log(self.scale) + - log(1 + square((x - self.loc) / self.scale)) + ) diff --git a/books/PRML/PRML-master-Python/prml/nn/random/dirichlet.py b/books/PRML/PRML-master-Python/prml/nn/random/dirichlet.py new file mode 100755 index 0000000..3fafa5c --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/random/dirichlet.py @@ -0,0 +1,72 @@ +import numpy as np +from prml.nn.math.gamma import gamma +from prml.nn.math.log import log +from prml.nn.math.product import prod +from prml.nn.math.sum import sum +from prml.nn.random.random import RandomVariable +from prml.nn.tensor.tensor import Tensor + + +class Dirichlet(RandomVariable): + """ + Dirichlet distribution + Parameters + ---------- + alpha : (..., K) tensor_like + pseudo-count of each outcome + axis : int + axis along which represents each outcome + data : tensor_like + realization + p : RandomVariable + original distribution of a model + Attributes + ---------- + n_category : int + number of categories + """ + + def __init__(self, alpha, axis=-1, data=None, p=None): + super().__init__(data, p) + assert axis == -1 + self.axis = axis + self.alpha = self._convert2tensor(alpha) + + @property + def alpha(self): + return self.parameter["alpha"] + + @alpha.setter + def alpha(self, alpha): + self._atleast_ndim(alpha, 1) + if (alpha.value <= 0).any(): + raise ValueError("alpha must all be positive") + self.parameter["alpha"] = alpha + + def forward(self): + if self.alpha.ndim == 1: + return Tensor(np.random.dirichlet(self.alpha.value), function=self) + else: + raise NotImplementedError + + def backward(self): + raise NotImplementedError + + def _pdf(self, x): + return ( + gamma(self.alpha.sum(axis=self.axis)) + * prod( + x ** (self.alpha - 1) + / gamma(self.alpha), + axis=self.axis + ) + ) + + def _log_pdf(self, x): + return ( + log(gamma(self.alpha.sum(axis=self.axis))) + + sum( + (self.alpha - 1) * log(x) - log(gamma(self.alpha)), + axis=self.axis + ) + ) diff --git a/books/PRML/PRML-master-Python/prml/nn/random/dropout.py b/books/PRML/PRML-master-Python/prml/nn/random/dropout.py new file mode 100755 index 0000000..ba9e478 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/random/dropout.py @@ -0,0 +1,39 @@ +import numpy as np +from prml.nn.tensor.tensor import Tensor +from prml.nn.function import Function + + +class Dropout(Function): + + def __init__(self, prob): + """ + construct dropout function + + Parameters + ---------- + prob : float + probability of dropping the input value + """ + if not isinstance(prob, float): + raise TypeError(f"prob must be float value, not {type(prob)}") + if prob < 0 or prob > 1: + raise ValueError(f"{prob} is out of the range [0, 1]") + self.prob = prob + self.coef = 1 / (1 - prob) + + def _forward(self, x, istraining=False): + x = self._convert2tensor(x) + if istraining: + self.x = x + self.mask = (np.random.rand(*x.shape) > self.prob) * self.coef + return Tensor(x.value * self.mask, function=self) + else: + return x + + def _backward(self, delta): + dx = delta * self.mask + self.x.backward(dx) + + +def dropout(x, prob, istraining): + return Dropout(prob).forward(x, istraining) diff --git a/books/PRML/PRML-master-Python/prml/nn/random/exponential.py b/books/PRML/PRML-master-Python/prml/nn/random/exponential.py new file mode 100755 index 0000000..92e9e61 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/random/exponential.py @@ -0,0 +1,59 @@ +import numpy as np +from prml.nn.math.exp import exp +from prml.nn.math.log import log +from prml.nn.random.random import RandomVariable +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor + + +class Exponential(RandomVariable): + """ + Exponential distribution aka negative exponential distribution + p(x|rate) = rate * exp(-rate * x) + rate > 0 + Parameters + ---------- + rate : tensor_like + rate parameter + data : tensor_like + realization of this distribution + p : RandomVariable + original distribution of a model + """ + + def __init__(self, rate, data=None, p=None): + super().__init__(data, p) + rate = self._convert2tensor(rate) + self.rate = rate + + @property + def rate(self): + return self.parameter["rate"] + + @rate.setter + def rate(self, rate): + try: + ispositive = (rate.value > 0).all() + except AttributeError: + ispositive = (rate.value > 0) + + if not ispositive: + raise ValueError("value of rate must be positive") + self.parameter["rate"] = rate + + def forward(self): + eps = np.random.standard_exponential(size=self.rate.shape) + self.output = eps / self.rate.value + if isinstance(self.rate, Constant): + return Constant(self.output) + return Tensor(self.output, self) + + def backward(self, delta): + drate = -delta * self.output / self.rate.value + self.rate.backward(drate) + + def _pdf(self, x): + return self.rate * exp(-self.rate * x) + + def _log_pdf(self, x): + return -self.rate * x + log(self.rate) diff --git a/books/PRML/PRML-master-Python/prml/nn/random/gamma.py b/books/PRML/PRML-master-Python/prml/nn/random/gamma.py new file mode 100755 index 0000000..4b64fd2 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/random/gamma.py @@ -0,0 +1,109 @@ +import numpy as np +import scipy.special as sp +from prml.nn.array.broadcast import broadcast_to +from prml.nn.math.exp import exp +from prml.nn.math.gamma import gamma +from prml.nn.math.log import log +from prml.nn.random.random import RandomVariable +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor + + +class Gamma(RandomVariable): + """ + Gamma distribution + p(x|a(shape), b(rate)) + = b^a * x^(a - 1) * e^(-bx) / Gamma(a) + Parameters + ---------- + shape : tensor_like + shape parameter + rate : tensor_like + rate parameter + data : tensor_like + realization + p : RandomVariable + original distribution of a model + """ + + def __init__(self, shape, rate, data=None, p=None): + super().__init__(data, p) + shape, rate = self._check_input(shape, rate) + self.shape = shape + self.rate = rate + + def _check_input(self, shape, rate): + shape = self._convert2tensor(shape) + rate = self._convert2tensor(rate) + if shape.shape != rate.shape: + shape_ = np.broadcast(shape.value, rate.value).shape + if shape.shape != shape_: + shape = broadcast_to(shape, shape_) + if rate.shape != shape_: + rate = broadcast_to(rate, shape_) + return shape, rate + + @property + def shape(self): + return self.parameter["shape"] + + @shape.setter + def shape(self, shape): + try: + ispositive = (shape.value > 0).all() + except AttributeError: + ispositive = (shape.value > 0) + + if not ispositive: + raise ValueError("value of shape must be positive") + self.parameter["shape"] = shape + + @property + def rate(self): + return self.parameter["rate"] + + @rate.setter + def rate(self, rate): + try: + ispositive = (rate.value > 0).all() + except AttributeError: + ispositive = (rate.value > 0) + + if not ispositive: + raise ValueError("value of rate must be positive") + self.parameter["rate"] = rate + + def forward(self): + self.output = np.random.gamma(self.shape.value, 1 / self.rate.value) + if isinstance(self.shape, Constant) and isinstance(self.rate, Constant): + return Constant(self.output) + return Tensor(self.output, function=self) + + def backward(self, delta): + a = self.shape.value + psia = sp.digamma(a) + psi1a = sp.polygamma(1, a) + sqrtpsi1a = np.sqrt(psi1a) + psi2a = sp.polygamma(2, a) + b = self.rate.value + eps = (np.log(self.output) - psia + np.log(b)) / sqrtpsi1a + dshape = self.output * (0.5 * eps * psi2a / sqrtpsi1a + psi1a) * delta + drate = -delta * self.output / b + self.shape.backward(dshape) + self.rate.backward(drate) + + def _pdf(self, x): + return ( + self.rate ** self.shape + * x ** (self.shape - 1) + * exp(-self.rate * x) + / gamma(self.shape) + ) + + def _log_pdf(self, x): + return ( + self.shape * log(self.rate) + + (self.shape - 1) * log(x) + - self.rate * x + - log(gamma(self.shape)) + ) diff --git a/books/PRML/PRML-master-Python/prml/nn/random/gaussian.py b/books/PRML/PRML-master-Python/prml/nn/random/gaussian.py new file mode 100755 index 0000000..19e69e7 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/random/gaussian.py @@ -0,0 +1,179 @@ +import numpy as np +from prml.nn.array.broadcast import broadcast_to +from prml.nn.function import Function +from prml.nn.math.exp import exp +from prml.nn.math.log import log +from prml.nn.math.sqrt import sqrt +from prml.nn.math.square import square +from prml.nn.random.random import RandomVariable +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor + + +class Gaussian(RandomVariable): + """ + The Gaussian distribution + p(x|mu(mean), sigma(std)) + = exp{-0.5 * (x - mu)^2 / sigma^2} / sqrt(2pi * sigma^2) + Parameters + ---------- + mu : tensor_like + mean parameter + std : tensor_like + std parameter + var : tensor_like + variance parameter + tau : tensor_like + precision parameter + data : tensor_like + observed data + p : RandomVariable + original distribution of a model + """ + + def __init__(self, mu, std=None, var=None, tau=None, data=None, p=None): + super().__init__(data, p) + if std is not None and var is None and tau is None: + self.mu, self.std = self._check_input(mu, std) + elif std is None and var is not None and tau is None: + self.mu, self.var = self._check_input(mu, var) + elif std is None and var is None and tau is not None: + self.mu, self.tau = self._check_input(mu, tau) + elif std is None and var is None and tau is None: + raise ValueError("Either std, var, or tau must be assigned") + else: + raise ValueError("Cannot assign more than two of these: std, var, tau") + + def _check_input(self, x, y): + x = self._convert2tensor(x) + y = self._convert2tensor(y) + if x.shape != y.shape: + shape = np.broadcast(x.value, y.value).shape + if x.shape != shape: + x = broadcast_to(x, shape) + if y.shape != shape: + y = broadcast_to(y, shape) + return x, y + + @property + def mu(self): + return self.parameter["mu"] + + @mu.setter + def mu(self, mu): + self.parameter["mu"] = mu + + @property + def std(self): + return self.parameter["std"] + + @std.setter + def std(self, std): + try: + ispositive = (std.value > 0).all() + except AttributeError: + ispositive = (std.value > 0) + + if not ispositive: + raise ValueError("value of std must all be positive") + self.parameter["std"] = std + + @property + def var(self): + try: + return self._var + except AttributeError: + return square(self.std) + + @var.setter + def var(self, var): + try: + ispositive = (var.value > 0).all() + except AttributeError: + ispositive = (var.value > 0) + + if not ispositive: + raise ValueError("value of var must all be positive") + self._var = var + self.parameter["std"] = sqrt(var) + + @property + def tau(self): + try: + return self._tau + except AttributeError: + return 1 / square(self.std) + + @tau.setter + def tau(self, tau): + try: + ispositive = (tau.value > 0).all() + except AttributeError: + ispositive = (tau.value > 0) + + if not ispositive: + raise ValueError("value of tau must be positive") + self._tau = tau + self.parameter["std"] = 1 / sqrt(tau) + + def forward(self): + self.eps = np.random.normal(size=self.mu.shape) + output = self.mu.value + self.std.value * self.eps + if isinstance(self.mu, Constant) and isinstance(self.var, Constant): + return Constant(output) + return Tensor(output, self) + + def backward(self, delta): + dmu = delta + dstd = delta * self.eps + self.mu.backward(dmu) + self.std.backward(dstd) + + def _pdf(self, x): + return ( + exp(-0.5 * square((x - self.mu) / self.std)) + / sqrt(2 * np.pi) / self.std + ) + + def _log_pdf(self, x): + return GaussianLogPDF().forward(x, self.mu, self.tau) + + +class GaussianLogPDF(Function): + + def _check_input(self, x, mu, tau): + x = self._convert2tensor(x) + mu = self._convert2tensor(mu) + tau = self._convert2tensor(tau) + if not x.shape == mu.shape == tau.shape: + shape = np.broadcast(x.value, mu.value, tau.value).shape + if x.shape != shape: + x = broadcast_to(x, shape) + if mu.shape != shape: + mu = broadcast_to(mu, shape) + if tau.shape != shape: + tau = broadcast_to(tau, shape) + return x, mu, tau + + def forward(self, x, mu, tau): + x, mu, tau = self._check_input(x, mu, tau) + self.x = x + self.mu = mu + self.tau = tau + output = ( + -0.5 * np.square(x.value - mu.value) * tau.value + + 0.5 * np.log(tau.value) + - 0.5 * np.log(2 * np.pi) + ) + return Tensor(output, function=self) + + def backward(self, delta): + dx = -0.5 * delta * (self.x.value - self.mu.value) * self.tau.value + dmu = -0.5 * delta * (self.mu.value - self.x.value) * self.tau.value + dtau = 0.5 * delta * ( + 1 / self.tau.value + - (self.x.value - self.mu.value) ** 2 + ) + self.x.backward(dx) + self.mu.backward(dmu) + self.tau.backward(dtau) diff --git a/books/PRML/PRML-master-Python/prml/nn/random/gaussian_mixture.py b/books/PRML/PRML-master-Python/prml/nn/random/gaussian_mixture.py new file mode 100755 index 0000000..a6f332f --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/random/gaussian_mixture.py @@ -0,0 +1,132 @@ +import numpy as np +from prml.nn.array.broadcast import broadcast_to +from prml.nn.math.exp import exp +from prml.nn.math.log import log +from prml.nn.math.sqrt import sqrt +from prml.nn.math.square import square +from prml.nn.random.random import RandomVariable +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor + + +class GaussianMixture(RandomVariable): + """ + Mixture of the Gaussian distribution + p(x|w, mu, std) + = w_1 * N(x|mu_1, std_1) + ... + w_K * N(x|mu_K, std_K) + Parameters + ---------- + coef : tensor_like + mixing coefficient whose sum along specified axis should equal to 1 + mu : tensor_like + mean parameter along specified axis for each component + std : tensor_like + std parameter along specified axis for each component + axis : int + axis along which represents each component + data : tensor_like + realization + p : RandomVariable + original distribution of a model + """ + + def __init__(self, coef, mu, std, axis=-1, data=None, p=None): + super().__init__(data, p) + assert axis == -1 + self.axis = axis + self.coef, self.mu, self.std = self._check_input(coef, mu, std) + + def _check_input(self, coef, mu, std): + coef = self._convert2tensor(coef) + mu = self._convert2tensor(mu) + std = self._convert2tensor(std) + + if not coef.shape == mu.shape == std.shape: + shape = np.broadcast(coef.value, mu.value, std.value).shape + if coef.shape != shape: + coef = broadcast_to(coef, shape) + if mu.shape != shape: + mu = broadcast_to(mu, shape) + if std.shape != shape: + std = broadcast_to(std, shape) + self.n_component = coef.shape[self.axis] + + return coef, mu, std + + @property + def axis(self): + return self.parameter["axis"] + + @axis.setter + def axis(self, axis): + if not isinstance(axis, int): + raise TypeError("axis must be int") + self.parameter["axis"] = axis + + @property + def coef(self): + return self.parameter["coef"] + + @coef.setter + def coef(self, coef): + self._atleast_ndim(coef, 1) + if (coef.value < 0).any(): + raise ValueError("value of mixing coefficient must all be positive") + + if not np.allclose(coef.value.sum(axis=self.axis), 1): + raise ValueError("sum of mixing coefficients must be 1") + self.parameter["coef"] = coef + + @property + def mu(self): + return self.parameter["mu"] + + @mu.setter + def mu(self, mu): + self.parameter["mu"] = mu + + @property + def std(self): + return self.parameter["std"] + + @std.setter + def std(self, std): + self._atleast_ndim(std, 1) + if (std.value < 0).any(): + raise ValueError("value of std must all be positive") + self.parameter["std"] = std + + @property + def var(self): + return square(self.parameter["std"]) + + def forward(self): + if self.coef.ndim != 1: + raise NotImplementedError + indices = np.array( + [np.random.choice(self.n_component, p=c) for c in self.coef.value] + ) + output = np.random.normal( + loc=self.mu.value[indices], + scale=self.std.value[indices] + ) + if ( + isinstance(self.coef, Constant) + and isinstance(self.mu, Constant) + and isinstance(self.std, Constant) + ): + return Constant(output) + return Tensor(output, function=self) + + def backward(self): + raise NotImplementedError + + def _pdf(self, x): + gauss = ( + exp(-0.5 * square((x - self.mu) / self.std)) + / sqrt(2 * np.pi) / self.std + ) + return (self.coef * gauss).sum(axis=self.axis) + + def _log_pdf(self, x): + return log(self.pdf(x)) diff --git a/books/PRML/PRML-master-Python/prml/nn/random/laplace.py b/books/PRML/PRML-master-Python/prml/nn/random/laplace.py new file mode 100755 index 0000000..e4069e6 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/random/laplace.py @@ -0,0 +1,84 @@ +import numpy as np +from prml.nn.array.broadcast import broadcast_to +from prml.nn.math.abs import abs +from prml.nn.math.exp import exp +from prml.nn.math.log import log +from prml.nn.random.random import RandomVariable +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor + + +class Laplace(RandomVariable): + """ + Laplace distribution + p(x|loc, scale) + = exp(-|x - loc|/scale) / (2 * scale) + Parameters + ---------- + loc : tensor_like + location parameter + scale : tensor_like + scale parameter + data : tensor_like + realization + p : RandomVariable + original distribution of a model + """ + + def __init__(self, loc, scale, data=None, p=None): + super().__init__(data, p) + self.loc, self.scale = self._check_input(loc, scale) + + def _check_input(self, loc, scale): + loc = self._convert2tensor(loc) + scale = self._convert2tensor(scale) + if loc.shape != scale.shape: + shape = np.broadcast(loc.value, scale.value).shape + if loc.shape != shape: + loc = broadcast_to(loc, shape) + if scale.shape != shape: + scale = broadcast_to(scale, shape) + return loc, scale + + @property + def loc(self): + return self.parameter["loc"] + + @loc.setter + def loc(self, loc): + self.parameter["loc"] = loc + + @property + def scale(self): + return self.parameter["scale"] + + @scale.setter + def scale(self, scale): + try: + ispositive = (scale.value > 0).all() + except AttributeError: + ispositive = (scale.value > 0) + + if not ispositive: + raise ValueError("value of scale must be positive") + self.parameter["scale"] = scale + + def forward(self): + eps = 0.5 - np.random.uniform(size=self.loc.shape) + self.eps = np.sign(eps) * np.log(1 - 2 * np.abs(eps)) + self.output = self.loc.value - self.scale.value * self.eps + if isinstance(self.loc, Constant) and isinstance(self.scale, Constant): + return Constant(self.output) + return Tensor(self.output, function=self) + + def backward(self, delta): + dloc = delta + dscale = -delta * self.eps + self.loc.backward(dloc) + self.scale.backward(dscale) + + def _pdf(self, x): + return 0.5 * exp(-abs(x - self.loc) / self.scale) / self.scale + + def _log_pdf(self, x): + return np.log(0.5) - abs(x - self.loc) / self.scale - log(self.scale) diff --git a/books/PRML/PRML-master-Python/prml/nn/random/multivariate_gaussian.py b/books/PRML/PRML-master-Python/prml/nn/random/multivariate_gaussian.py new file mode 100755 index 0000000..77a37c4 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/random/multivariate_gaussian.py @@ -0,0 +1,119 @@ +import numpy as np +from prml.nn.array.broadcast import broadcast_to +from prml.nn.linalg.cholesky import cholesky +from prml.nn.linalg.det import det +from prml.nn.linalg.logdet import logdet +from prml.nn.linalg.solve import solve +from prml.nn.linalg.trace import trace +from prml.nn.math.exp import exp +from prml.nn.math.log import log +from prml.nn.math.sqrt import sqrt +from prml.nn.random.random import RandomVariable +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.tensor import Tensor + + +class MultivariateGaussian(RandomVariable): + """ + Multivariate Gaussian distribution + p(x|mu, cov) + = exp{-0.5 * (x - mu)^T cov^-1 (x - mu)} * (1 / 2pi) ** (d / 2) * |cov^-1| ** 0.5 + where d = dimensionality + Parameters + ---------- + mu : (d,) tensor_like + mean parameter + cov : (d, d) tensor_like + variance-covariance matrix + data : (..., d) tensor_like + observed data + p : RandomVariable + original distribution of a model + """ + + def __init__(self, mu, cov, data=None, p=None): + super().__init__(data, p) + self.mu, self.cov = self._check_input(mu, cov) + + def _check_input(self, mu, cov): + mu = self._convert2tensor(mu) + cov = self._convert2tensor(cov) + self._equal_ndim(mu, 1) + self._equal_ndim(cov, 2) + if cov.shape != (mu.size, mu.size): + raise ValueError("Mismatching dimensionality of mu and cov") + return mu, cov + + @property + def mu(self): + return self.parameter["mu"] + + @mu.setter + def mu(self, mu): + self.parameter["mu"] = mu + + @property + def cov(self): + return self.parameter["cov"] + + @cov.setter + def cov(self, cov): + try: + self.L = cholesky(cov) + except np.linalg.LinAlgError: + raise ValueError("cov must be positive-difinite matrix") + self.parameter["cov"] = cov + + def forward(self): + self.eps = np.random.normal(size=self.mu.size) + output = self.mu.value + self.L.value @ self.eps + if isinstance(self.mu, Constant) and isinstance(self.cov, Constant): + return Constant(output) + return Tensor(output, self) + + def backward(self, delta): + dmu = delta + dL = delta * self.eps[:, None] + self.mu.backward(dmu) + self.L.backward(dL) + + def _pdf(self, x): + assert x.shape[-1] == self.mu.size + if x.ndim == 1: + squeeze = True + x = broadcast_to(x, (1, self.mu.size)) + else: + squeeze = False + assert x.ndim == 2 + d = x - self.mu + d = d.transpose() + p = ( + exp(-0.5 * (solve(self.cov, d) * d).sum(axis=0)) + / (2 * np.pi) ** (self.mu.size * 0.5) + / sqrt(det(self.cov)) + ) + if squeeze: + p = p.sum() + + return p + + def _log_pdf(self, x): + assert x.shape[-1] == self.mu.size + if x.ndim == 1: + squeeze = True + x = broadcast_to(x, (1, self.mu.size)) + else: + squeeze = False + assert x.ndim == 2 + d = x - self.mu + d = d.transpose() + + logp = ( + -0.5 * (solve(self.cov, d) * d).sum(axis=0) + - (self.mu.size * 0.5) * log(2 * np.pi) + - 0.5 * logdet(self.cov) + ) + if squeeze: + logp = logp.sum() + + return logp diff --git a/books/PRML/PRML-master-Python/prml/nn/random/random.py b/books/PRML/PRML-master-Python/prml/nn/random/random.py new file mode 100755 index 0000000..b01f02a --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/random/random.py @@ -0,0 +1,120 @@ +from prml.nn.function import Function +from prml.nn.tensor.constant import Constant + + +class RandomVariable(Function): + """ + base class for random variables + """ + + def __init__(self, data=None, p=None): + """ + construct a random variable + Parameters + ---------- + data : tensor_like + observed data + p : RandomVariable + original distribution of a model + Returns + ------- + parameter : dict + dictionary of parameters + observed : bool + flag of observed or not + """ + if data is not None and p is not None: + raise ValueError("Cannot assign both data and p at a time") + if data is not None: + data = self._convert2tensor(data) + self.data = data + self.observed = isinstance(data, Constant) + self.p = p + self.parameter = dict() + + @property + def p(self): + return self._p + + @p.setter + def p(self, p): + if p is not None and not isinstance(p, RandomVariable): + raise TypeError("p must be RandomVariable") + self._p = p + + def __repr__(self): + string = f"{self.__class__.__name__}(\n" + for key, value in self.parameter.items(): + string += (" " * 4) + string += f"{key}={value}" + string += "\n" + string += ")" + return string + + def draw(self): + """ + generate a sample + Returns + ------- + sample : tensor + sample generated from this random variable + """ + if self.observed: + raise ValueError("draw method cannot be used for observed random variable") + self.data = self.forward() + return self.data + + def pdf(self, x=None): + """ + compute probability density function + Parameters + ---------- + x : tensor_like + observed data + Returns + ------- + p : Tensor + value of probability density function for each input + """ + if not hasattr(self, "_pdf"): + raise NotImplementedError + if x is None: + if self.data is None: + raise ValueError("There is no given or sampled data") + return self._pdf(self.data) + return self._pdf(x) + + def log_pdf(self, x=None): + """ + logarithm of probability density function + Parameters + ---------- + x : tensor_like + observed data + Returns + ------- + output : Tensor + logarithm of probability density function + """ + if not hasattr(self, "_log_pdf"): + raise NotImplementedError + if x is None: + if self.data is None: + raise ValueError("No given or sampled data") + return self._log_pdf(self.data) + return self._log_pdf(x) + + def KLqp(self): + r""" + compute Kullback Leibler Divergence + KL(q(self)||p) = \int q(x) ln(q(x) / p(x)) dx + Returns + ------- + kl : Tensor + KL divergence + """ + if self.p is None: + raise ValueError("There is no assigned distribution p") + if self.data is None: + raise ValueError("There is no sampled data") + return self.log_pdf() - self.p.log_pdf(self.data) diff --git a/books/PRML/PRML-master-Python/prml/nn/tensor/__init__.py b/books/PRML/PRML-master-Python/prml/nn/tensor/__init__.py new file mode 100755 index 0000000..c66cb53 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/tensor/__init__.py @@ -0,0 +1,10 @@ +from prml.nn.tensor.constant import Constant +from prml.nn.tensor.parameter import Parameter +from prml.nn.tensor.tensor import Tensor + + +__all__ = [ + "Constant", + "Parameter", + "Tensor" +] diff --git a/books/PRML/PRML-master-Python/prml/nn/tensor/constant.py b/books/PRML/PRML-master-Python/prml/nn/tensor/constant.py new file mode 100755 index 0000000..71e0d24 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/tensor/constant.py @@ -0,0 +1,10 @@ +from prml.nn.tensor.tensor import Tensor + + +class Constant(Tensor): + """ + constant tensor class + """ + + def __init__(self, value): + super().__init__(value) diff --git a/books/PRML/PRML-master-Python/prml/nn/tensor/parameter.py b/books/PRML/PRML-master-Python/prml/nn/tensor/parameter.py new file mode 100755 index 0000000..c637a72 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/tensor/parameter.py @@ -0,0 +1,24 @@ +from prml.nn.tensor.tensor import Tensor + + +class Parameter(Tensor): + """ + parameter to be optimized + """ + + def __init__(self, value, prior=None): + super().__init__(value, function=None) + self.grad = None + self.prior = prior + + def _backward(self, delta, **kwargs): + if self.grad is None: + self.grad = delta + else: + self.grad += delta + + def cleargrad(self): + self.grad = None + if self.prior is not None: + loss = -self.prior.log_pdf(self).sum() + loss.backward() diff --git a/books/PRML/PRML-master-Python/prml/nn/tensor/tensor.py b/books/PRML/PRML-master-Python/prml/nn/tensor/tensor.py new file mode 100755 index 0000000..9c16257 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/nn/tensor/tensor.py @@ -0,0 +1,89 @@ +import numpy as np + + +class Tensor(object): + """ + a base class for tensor object + """ + __array_ufunc__ = None + + def __init__(self, value, function=None): + """ + construct Tensor object + Parameters + ---------- + value : array_like + value of this tensor + function : Function + function output this tensor + """ + if not isinstance(value, (int, float, np.number, np.ndarray)): + raise TypeError( + "Unsupported class for Tensor: {}".format(type(value)) + ) + self.value = value + self.function = function + + def __format__(self, *args, **kwargs): + return self.__repr__() + + def __repr__(self): + if isinstance(self.value, np.ndarray): + return ( + "{0}(shape={1.shape}, dtype={1.dtype})" + .format(self.__class__.__name__, self.value) + ) + else: + return ( + "{0}(value={1})".format(self.__class__.__name__, self.value) + ) + + @property + def ndim(self): + if hasattr(self.value, "ndim"): + return self.value.ndim + else: + return 0 + + @property + def shape(self): + if hasattr(self.value, "shape"): + return self.value.shape + else: + return () + + @property + def size(self): + if hasattr(self.value, "size"): + return self.value.size + else: + return 1 + + def backward(self, delta=1, **kwargs): + """ + back-propagate error + Parameters + ---------- + delta : array_like + derivative with respect to this array + """ + if isinstance(delta, np.ndarray): + if delta.shape != self.shape: + raise ValueError( + "shapes {} and {} not aligned" + .format(delta.shape, self.shape) + ) + elif isinstance(delta, (int, float, np.number)): + if self.shape != (): + raise ValueError( + "delta must be np.ndarray" + ) + else: + raise TypeError( + "unsupported class for delta" + ) + self._backward(delta, **kwargs) + + def _backward(self, delta, **kwargs): + if hasattr(self.function, "backward"): + self.function.backward(delta, **kwargs) diff --git a/books/PRML/PRML-master-Python/prml/preprocess/__init__.py b/books/PRML/PRML-master-Python/prml/preprocess/__init__.py new file mode 100755 index 0000000..9374ed7 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/preprocess/__init__.py @@ -0,0 +1,12 @@ +from prml.preprocess.gaussian import GaussianFeature +from prml.preprocess.label_transformer import LabelTransformer +from prml.preprocess.polynomial import PolynomialFeature +from prml.preprocess.sigmoidal import SigmoidalFeature + + +__all__ = [ + "GaussianFeature", + "LabelTransformer", + "PolynomialFeature", + "SigmoidalFeature" +] diff --git a/books/PRML/PRML-master-Python/prml/preprocess/gaussian.py b/books/PRML/PRML-master-Python/prml/preprocess/gaussian.py new file mode 100755 index 0000000..a80cd33 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/preprocess/gaussian.py @@ -0,0 +1,55 @@ +import numpy as np + + +class GaussianFeature(object): + """ + Gaussian feature + + gaussian function = exp(-0.5 * (x - m) / v) + """ + + def __init__(self, mean, var): + """ + construct gaussian features + + Parameters + ---------- + mean : (n_features, ndim) or (n_features,) ndarray + places to locate gaussian function at + var : float + variance of the gaussian function + """ + if mean.ndim == 1: + mean = mean[:, None] + else: + assert mean.ndim == 2 + assert isinstance(var, float) or isinstance(var, int) + self.mean = mean + self.var = var + + def _gauss(self, x, mean): + return np.exp(-0.5 * np.sum(np.square(x - mean), axis=-1) / self.var) + + def transform(self, x): + """ + transform input array with gaussian features + + Parameters + ---------- + x : (sample_size, ndim) or (sample_size,) + input array + + Returns + ------- + output : (sample_size, n_features) + gaussian features + """ + if x.ndim == 1: + x = x[:, None] + else: + assert x.ndim == 2 + assert np.size(x, 1) == np.size(self.mean, 1) + basis = [np.ones(len(x))] + for m in self.mean: + basis.append(self._gauss(x, m)) + return np.asarray(basis).transpose() diff --git a/books/PRML/PRML-master-Python/prml/preprocess/label_transformer.py b/books/PRML/PRML-master-Python/prml/preprocess/label_transformer.py new file mode 100755 index 0000000..746f34f --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/preprocess/label_transformer.py @@ -0,0 +1,65 @@ +import numpy as np + + +class LabelTransformer(object): + """ + Label encoder decoder + + Attributes + ---------- + n_classes : int + number of classes, K + """ + + def __init__(self, n_classes:int=None): + self.n_classes = n_classes + + @property + def n_classes(self): + return self.__n_classes + + @n_classes.setter + def n_classes(self, K): + self.__n_classes = K + self.__encoder = None if K is None else np.eye(K) + + @property + def encoder(self): + return self.__encoder + + def encode(self, class_indices:np.ndarray): + """ + encode class index into one-of-k code + + Parameters + ---------- + class_indices : (N,) np.ndarray + non-negative class index + elements must be integer in [0, n_classes) + + Returns + ------- + (N, K) np.ndarray + one-of-k encoding of input + """ + if self.n_classes is None: + self.n_classes = np.max(class_indices) + 1 + + return self.encoder[class_indices] + + def decode(self, onehot:np.ndarray): + """ + decode one-of-k code into class index + + Parameters + ---------- + onehot : (N, K) np.ndarray + one-of-k code + + Returns + ------- + (N,) np.ndarray + class index + """ + + return np.argmax(onehot, axis=1) diff --git a/books/PRML/PRML-master-Python/prml/preprocess/polynomial.py b/books/PRML/PRML-master-Python/prml/preprocess/polynomial.py new file mode 100755 index 0000000..5549478 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/preprocess/polynomial.py @@ -0,0 +1,57 @@ +import itertools +import functools +import numpy as np + + +class PolynomialFeature(object): + """ + polynomial features + + transforms input array with polynomial features + + Example + ======= + x = + [[a, b], + [c, d]] + + y = PolynomialFeatures(degree=2).transform(x) + y = + [[1, a, b, a^2, a * b, b^2], + [1, c, d, c^2, c * d, d^2]] + """ + + def __init__(self, degree=2): + """ + construct polynomial features + + Parameters + ---------- + degree : int + degree of polynomial + """ + assert isinstance(degree, int) + self.degree = degree + + def transform(self, x): + """ + transforms input array with polynomial features + + Parameters + ---------- + x : (sample_size, n) ndarray + input array + + Returns + ------- + output : (sample_size, 1 + nC1 + ... + nCd) ndarray + polynomial features + """ + if x.ndim == 1: + x = x[:, None] + x_t = x.transpose() + features = [np.ones(len(x))] + for degree in range(1, self.degree + 1): + for items in itertools.combinations_with_replacement(x_t, degree): + features.append(functools.reduce(lambda x, y: x * y, items)) + return np.asarray(features).transpose() diff --git a/books/PRML/PRML-master-Python/prml/preprocess/sigmoidal.py b/books/PRML/PRML-master-Python/prml/preprocess/sigmoidal.py new file mode 100755 index 0000000..0d926ff --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/preprocess/sigmoidal.py @@ -0,0 +1,62 @@ +import numpy as np + + +class SigmoidalFeature(object): + """ + Sigmoidal features + + 1 / (1 + exp((m - x) @ c) + """ + + def __init__(self, mean, coef=1): + """ + construct sigmoidal features + + Parameters + ---------- + mean : (n_features, ndim) or (n_features,) ndarray + center of sigmoid function + coef : (ndim,) ndarray or int or float + coefficient to be multplied with the distance + """ + if mean.ndim == 1: + mean = mean[:, None] + else: + assert mean.ndim == 2 + if isinstance(coef, int) or isinstance(coef, float): + if np.size(mean, 1) == 1: + coef = np.array([coef]) + else: + raise ValueError("mismatch of dimension") + else: + assert coef.ndim == 1 + assert np.size(mean, 1) == len(coef) + self.mean = mean + self.coef = coef + + def _sigmoid(self, x, mean): + return np.tanh((x - mean) @ self.coef * 0.5) * 0.5 + 0.5 + + def transform(self, x): + """ + transform input array with sigmoidal features + + Parameters + ---------- + x : (sample_size, ndim) or (sample_size,) ndarray + input array + + Returns + ------- + output : (sample_size, n_features) ndarray + sigmoidal features + """ + if x.ndim == 1: + x = x[:, None] + else: + assert x.ndim == 2 + assert np.size(x, 1) == np.size(self.mean, 1) + basis = [np.ones(len(x))] + for m in self.mean: + basis.append(self._sigmoid(x, m)) + return np.asarray(basis).transpose() diff --git a/books/PRML/PRML-master-Python/prml/rv/__init__.py b/books/PRML/PRML-master-Python/prml/rv/__init__.py new file mode 100755 index 0000000..6de2a13 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/rv/__init__.py @@ -0,0 +1,28 @@ +from prml.rv.bernoulli import Bernoulli +from prml.rv.bernoulli_mixture import BernoulliMixture +from prml.rv.beta import Beta +from prml.rv.categorical import Categorical +from prml.rv.dirichlet import Dirichlet +from prml.rv.gamma import Gamma +from prml.rv.gaussian import Gaussian +from prml.rv.multivariate_gaussian import MultivariateGaussian +from prml.rv.multivariate_gaussian_mixture import MultivariateGaussianMixture +from prml.rv.students_t import StudentsT +from prml.rv.uniform import Uniform +from prml.rv.variational_gaussian_mixture import VariationalGaussianMixture + + +__all__ = [ + "Bernoulli", + "BernoulliMixture", + "Beta", + "Categorical", + "Dirichlet", + "Gamma", + "Gaussian", + "MultivariateGaussian", + "MultivariateGaussianMixture", + "StudentsT", + "Uniform", + "VariationalGaussianMixture" +] diff --git a/books/PRML/PRML-master-Python/prml/rv/bernoulli.py b/books/PRML/PRML-master-Python/prml/rv/bernoulli.py new file mode 100755 index 0000000..f362066 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/rv/bernoulli.py @@ -0,0 +1,125 @@ +import numpy as np +from prml.rv.rv import RandomVariable +from prml.rv.beta import Beta + + +class Bernoulli(RandomVariable): + """ + Bernoulli distribution + p(x|mu) = mu^x (1 - mu)^(1 - x) + """ + + def __init__(self, mu=None): + """ + construct Bernoulli distribution + + Parameters + ---------- + mu : np.ndarray or Beta + probability of value 1 for each element + """ + super().__init__() + self.mu = mu + + @property + def mu(self): + return self.parameter["mu"] + + @mu.setter + def mu(self, mu): + if isinstance(mu, (int, float, np.number)): + if mu > 1 or mu < 0: + raise ValueError(f"mu must be in [0, 1], not {mu}") + self.parameter["mu"] = np.asarray(mu) + elif isinstance(mu, np.ndarray): + if (mu > 1).any() or (mu < 0).any(): + raise ValueError("mu must be in [0, 1]") + self.parameter["mu"] = mu + elif isinstance(mu, Beta): + self.parameter["mu"] = mu + else: + if mu is not None: + raise TypeError(f"{type(mu)} is not supported for mu") + self.parameter["mu"] = None + + @property + def ndim(self): + if hasattr(self.mu, "ndim"): + return self.mu.ndim + else: + return None + + @property + def size(self): + if hasattr(self.mu, "size"): + return self.mu.size + else: + return None + + @property + def shape(self): + if hasattr(self.mu, "shape"): + return self.mu.shape + else: + return None + + def _fit(self, X): + if isinstance(self.mu, Beta): + self._bayes(X) + elif isinstance(self.mu, RandomVariable): + raise NotImplementedError + else: + self._ml(X) + + def _ml(self, X): + n_zeros = np.count_nonzero((X == 0).astype(np.int)) + n_ones = np.count_nonzero((X == 1).astype(np.int)) + assert X.size == n_zeros + n_ones, ( + "{X.size} is not equal to {n_zeros} plus {n_ones}" + ) + self.mu = np.mean(X, axis=0) + + def _map(self, X): + assert isinstance(self.mu, Beta) + assert X.shape[1:] == self.mu.shape + n_ones = (X == 1).sum(axis=0) + n_zeros = (X == 0).sum(axis=0) + assert X.size == n_zeros.sum() + n_ones.sum(), ( + f"{X.size} is not equal to {n_zeros} plus {n_ones}" + ) + n_ones = n_ones + self.mu.n_ones + n_zeros = n_zeros + self.mu.n_zeros + self.prob = (n_ones - 1) / (n_ones + n_zeros - 2) + + def _bayes(self, X): + assert isinstance(self.mu, Beta) + assert X.shape[1:] == self.mu.shape + n_ones = (X == 1).sum(axis=0) + n_zeros = (X == 0).sum(axis=0) + assert X.size == n_zeros.sum() + n_ones.sum(), ( + "input X must only has 0 or 1" + ) + self.mu.n_zeros += n_zeros + self.mu.n_ones += n_ones + + def _pdf(self, X): + assert isinstance(mu, np.ndarray) + return np.prod( + self.mu ** X * (1 - self.mu) ** (1 - X) + ) + + def _draw(self, sample_size=1): + if isinstance(self.mu, np.ndarray): + return ( + self.mu > np.random.uniform(size=(sample_size,) + self.shape) + ).astype(np.int) + elif isinstance(self.mu, Beta): + return ( + self.mu.n_ones / (self.mu.n_ones + self.mu.n_zeros) + > np.random.uniform(size=(sample_size,) + self.shape) + ).astype(np.int) + elif isinstance(self.mu, RandomVariable): + return ( + self.mu.draw(sample_size) + > np.random.uniform(size=(sample_size,) + self.shape) + ) diff --git a/books/PRML/PRML-master-Python/prml/rv/bernoulli_mixture.py b/books/PRML/PRML-master-Python/prml/rv/bernoulli_mixture.py new file mode 100755 index 0000000..cef80c0 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/rv/bernoulli_mixture.py @@ -0,0 +1,123 @@ +import numpy as np +from scipy.misc import logsumexp +from prml.rv.rv import RandomVariable + + +class BernoulliMixture(RandomVariable): + """ + p(x|pi,mu) + = sum_k pi_k mu_k^x (1 - mu_k)^(1 - x) + """ + + def __init__(self, n_components=3, mu=None, coef=None): + """ + construct mixture of Bernoulli + + Parameters + ---------- + n_components : int + number of bernoulli component + mu : (n_components, ndim) np.ndarray + probability of value 1 for each component + coef : (n_components,) np.ndarray + mixing coefficients + """ + super().__init__() + assert isinstance(n_components, int) + self.n_components = n_components + self.mu = mu + self.coef = coef + + @property + def mu(self): + return self.parameter["mu"] + + @mu.setter + def mu(self, mu): + if isinstance(mu, np.ndarray): + assert mu.ndim == 2 + assert np.size(mu, 0) == self.n_components + assert (mu >= 0.).all() and (mu <= 1.).all() + self.ndim = np.size(mu, 1) + self.parameter["mu"] = mu + else: + assert mu is None + self.parameter["mu"] = None + + @property + def coef(self): + return self.parameter["coef"] + + @coef.setter + def coef(self, coef): + if isinstance(coef, np.ndarray): + assert coef.ndim == 1 + assert np.allclose(coef.sum(), 1) + self.parameter["coef"] = coef + else: + assert coef is None + self.parameter["coef"] = np.ones(self.n_components) / self.n_components + + def _log_bernoulli(self, X): + np.clip(self.mu, 1e-10, 1 - 1e-10, out=self.mu) + return ( + X[:, None, :] * np.log(self.mu) + + (1 - X[:, None, :]) * np.log(1 - self.mu) + ).sum(axis=-1) + + def _fit(self, X): + self.mu = np.random.uniform(0.25, 0.75, size=(self.n_components, np.size(X, 1))) + params = np.hstack((self.mu.ravel(), self.coef.ravel())) + while True: + resp = self._expectation(X) + self._maximization(X, resp) + new_params = np.hstack((self.mu.ravel(), self.coef.ravel())) + if np.allclose(params, new_params): + break + else: + params = new_params + + def _expectation(self, X): + log_resps = np.log(self.coef) + self._log_bernoulli(X) + log_resps -= logsumexp(log_resps, axis=-1)[:, None] + resps = np.exp(log_resps) + return resps + + def _maximization(self, X, resp): + Nk = np.sum(resp, axis=0) + self.coef = Nk / len(X) + self.mu = (X.T @ resp / Nk).T + + def classify(self, X): + """ + classify input + max_z p(z|x, theta) + + Parameters + ---------- + X : (sample_size, ndim) ndarray + input + + Returns + ------- + output : (sample_size,) ndarray + corresponding cluster index + """ + return np.argmax(self.classify_proba(X), axis=1) + + def classfiy_proba(self, X): + """ + posterior probability of cluster + p(z|x,theta) + + Parameters + ---------- + X : (sample_size, ndim) ndarray + input + + Returns + ------- + output : (sample_size, n_components) ndarray + posterior probability of cluster + """ + return self._expectation(X) diff --git a/books/PRML/PRML-master-Python/prml/rv/beta.py b/books/PRML/PRML-master-Python/prml/rv/beta.py new file mode 100755 index 0000000..ce7854a --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/rv/beta.py @@ -0,0 +1,74 @@ +import numpy as np +from scipy.special import gamma +from prml.rv.rv import RandomVariable + + +np.seterr(all="ignore") + + +class Beta(RandomVariable): + """ + Beta distribution + p(mu|n_ones, n_zeros) + = gamma(n_ones + n_zeros) + * mu^(n_ones - 1) * (1 - mu)^(n_zeros - 1) + / gamma(n_ones) / gamma(n_zeros) + """ + + def __init__(self, n_zeros, n_ones): + """ + construct beta distribution + + Parameters + ---------- + n_zeros : int, float, or np.ndarray + pseudo count of zeros + n_ones : int, float, or np.ndarray + pseudo count of ones + """ + super().__init__() + if not isinstance(n_ones, (int, float, np.number, np.ndarray)): + raise ValueError( + "{} is not supported for n_ones" + .format(type(n_ones)) + ) + if not isinstance(n_zeros, (int, float, np.number, np.ndarray)): + raise ValueError( + "{} is not supported for n_zeros" + .format(type(n_zeros)) + ) + n_ones = np.asarray(n_ones) + n_zeros = np.asarray(n_zeros) + if n_ones.shape != n_zeros.shape: + raise ValueError( + "the sizes of the arrays don't match: {}, {}" + .format(n_ones.shape, n_zeros.shape) + ) + self.n_ones = n_ones + self.n_zeros = n_zeros + + @property + def ndim(self): + return self.n_ones.ndim + + @property + def size(self): + return self.n_ones.size + + @property + def shape(self): + return self.n_ones.shape + + def _pdf(self, mu): + return ( + gamma(self.n_ones + self.n_zeros) + * np.power(mu, self.n_ones - 1) + * np.power(1 - mu, self.n_zeros - 1) + / gamma(self.n_ones) + / gamma(self.n_zeros) + ) + + def _draw(self, sample_size=1): + return np.random.beta( + self.n_ones, self.n_zeros, size=(sample_size,) + self.shape + ) diff --git a/books/PRML/PRML-master-Python/prml/rv/categorical.py b/books/PRML/PRML-master-Python/prml/rv/categorical.py new file mode 100755 index 0000000..81a47ac --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/rv/categorical.py @@ -0,0 +1,105 @@ +import numpy as np +from prml.rv.rv import RandomVariable +from prml.rv.dirichlet import Dirichlet + + +class Categorical(RandomVariable): + """ + Categorical distribution + p(x|mu) = prod_k mu_k^x_k + """ + + def __init__(self, mu=None): + """ + construct categorical distribution + + Parameters + ---------- + mu : (n_classes,) np.ndarray or Dirichlet + probability of each class + """ + super().__init__() + self.mu = mu + + @property + def mu(self): + return self.parameter["mu"] + + @mu.setter + def mu(self, mu): + if isinstance(mu, np.ndarray): + if mu.ndim != 1: + raise ValueError("dimensionality of mu must be 1") + if (mu < 0).any(): + raise ValueError("mu must be non-negative") + if not np.allclose(mu.sum(), 1): + raise ValueError("sum of mu must be 1") + self.n_classes = mu.size + self.parameter["mu"] = mu + elif isinstance(mu, Dirichlet): + self.n_classes = mu.size + self.parameter["mu"] = mu + else: + if mu is not None: + raise TypeError(f"{type(mu)} is not supported for mu") + self.parameter["mu"] = None + + @property + def ndim(self): + if hasattr(self.mu, "ndim"): + return self.mu.ndim + else: + return None + + @property + def size(self): + if hasattr(self.mu, "size"): + return self.mu.size + else: + return None + + @property + def shape(self): + if hasattr(self.mu, "shape"): + return self.mu.shape + else: + return None + + def _check_input(self, X): + assert X.ndim == 2 + assert (X >= 0).all() + assert (X.sum(axis=-1) == 1).all() + + def _fit(self, X): + if isinstance(self.mu, Dirichlet): + self._bayes(X) + elif isinstance(self.mu, RandomVariable): + raise NotImplementedError + else: + self._ml(X) + + def _ml(self, X): + self._check_input(X) + self.mu = np.mean(X, axis=0) + + def _map(self, X): + self._check_input(X) + assert isinstance(self.mu, Dirichlet) + alpha = self.mu.alpha + X.sum(axis=0) + self.mu = (alpha - 1) / (alpha - 1).sum() + + def _bayes(self, X): + self._check_input(X) + assert isinstance(self.mu, Dirichlet) + self.mu.alpha += X.sum(axis=0) + + def _pdf(self, X): + self._check_input(X) + assert isinstance(self.mu, np.ndarray) + return np.prod(self.mu ** X, axis=-1) + + def _draw(self, sample_size=1): + assert isinstance(self.mu, np.ndarray) + return np.eye(self.n_classes)[ + np.random.choice(self.n_classes, sample_size, p=self.mu) + ] diff --git a/books/PRML/PRML-master-Python/prml/rv/dirichlet.py b/books/PRML/PRML-master-Python/prml/rv/dirichlet.py new file mode 100755 index 0000000..baae6f9 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/rv/dirichlet.py @@ -0,0 +1,58 @@ +import numpy as np +from scipy.special import gamma +from prml.rv.rv import RandomVariable + + +class Dirichlet(RandomVariable): + """ + Dirichlet distribution + p(mu|alpha) + = gamma(sum(alpha)) + * prod_k mu_k ^ (alpha_k - 1) + / gamma(alpha_1) / ... / gamma(alpha_K) + """ + + def __init__(self, alpha): + """ + construct dirichlet distribution + + Parameters + ---------- + alpha : (size,) np.ndarray + pseudo count of each outcome, aka concentration parameter + """ + super().__init__() + self.alpha = alpha + + @property + def alpha(self): + return self.parameter["alpha"] + + @alpha.setter + def alpha(self, alpha): + assert isinstance(alpha, np.ndarray) + assert alpha.ndim == 1 + assert (alpha >= 0).all() + self.parameter["alpha"] = alpha + + @property + def ndim(self): + return self.alpha.ndim + + @property + def size(self): + return self.alpha.size + + @property + def shape(self): + return self.alpha.shape + + def _pdf(self, mu): + return ( + gamma(self.alpha.sum()) + * np.prod(mu ** (self.alpha - 1), axis=-1) + / np.prod(gamma(self.alpha), axis=-1) + ) + + def _draw(self, sample_size=1): + return np.random.dirichlet(self.alpha, sample_size) diff --git a/books/PRML/PRML-master-Python/prml/rv/gamma.py b/books/PRML/PRML-master-Python/prml/rv/gamma.py new file mode 100755 index 0000000..9898b0a --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/rv/gamma.py @@ -0,0 +1,96 @@ +import numpy as np +from scipy.special import gamma +from prml.rv.rv import RandomVariable + + +np.seterr(all="ignore") + + +class Gamma(RandomVariable): + """ + Gamma distribution + p(x|a, b) + = b^a x^(a-1) exp(-bx) / gamma(a) + """ + + def __init__(self, a, b): + """ + construct Gamma distribution + + Parameters + ---------- + a : int, float, or np.ndarray + shape parameter + b : int, float, or np.ndarray + rate parameter + """ + super().__init__() + a = np.asarray(a) + b = np.asarray(b) + assert a.shape == b.shape + self.a = a + self.b = b + + @property + def a(self): + return self.parameter["a"] + + @a.setter + def a(self, a): + if isinstance(a, (int, float, np.number)): + if a <= 0: + raise ValueError("a must be positive") + self.parameter["a"] = np.asarray(a) + elif isinstance(a, np.ndarray): + if (a <= 0).any(): + raise ValueError("a must be positive") + self.parameter["a"] = a + else: + if a is not None: + raise TypeError(f"{type(a)} is not supported for a") + self.parameter["a"] = None + + @property + def b(self): + return self.parameter["b"] + + @b.setter + def b(self, b): + if isinstance(b, (int, float, np.number)): + if b <= 0: + raise ValueError("b must be positive") + self.parameter["b"] = np.asarray(b) + elif isinstance(b, np.ndarray): + if (b <= 0).any(): + raise ValueError("b must be positive") + self.parameter["b"] = b + else: + if b is not None: + raise TypeError(f"{type(b)} is not supported for b") + self.parameter["b"] = None + + @property + def ndim(self): + return self.a.ndim + + @property + def shape(self): + return self.a.shape + + @property + def size(self): + return self.a.size + + def _pdf(self, X): + return ( + self.b ** self.a + * X ** (self.a - 1) + * np.exp(-self.b * X) + / gamma(self.a)) + + def _draw(self, sample_size=1): + return np.random.gamma( + shape=self.a, + scale=1 / self.b, + size=(sample_size,) + self.shape + ) diff --git a/books/PRML/PRML-master-Python/prml/rv/gaussian.py b/books/PRML/PRML-master-Python/prml/rv/gaussian.py new file mode 100755 index 0000000..d400169 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/rv/gaussian.py @@ -0,0 +1,184 @@ +import numpy as np +from prml.rv.rv import RandomVariable +from prml.rv.gamma import Gamma + + +class Gaussian(RandomVariable): + """ + The Gaussian distribution + p(x|mu, var) + = exp{-0.5 * (x - mu)^2 / var} / sqrt(2pi * var) + """ + + def __init__(self, mu=None, var=None, tau=None): + super().__init__() + self.mu = mu + if var is not None: + self.var = var + elif tau is not None: + self.tau = tau + else: + self.var = None + self.tau = None + + @property + def mu(self): + return self.parameter["mu"] + + @mu.setter + def mu(self, mu): + if isinstance(mu, (int, float, np.number)): + self.parameter["mu"] = np.array(mu) + elif isinstance(mu, np.ndarray): + self.parameter["mu"] = mu + elif isinstance(mu, Gaussian): + self.parameter["mu"] = mu + else: + if mu is not None: + raise TypeError(f"{type(mu)} is not supported for mu") + self.parameter["mu"] = None + + @property + def var(self): + return self.parameter["var"] + + @var.setter + def var(self, var): + if isinstance(var, (int, float, np.number)): + assert var > 0 + var = np.array(var) + assert var.shape == self.shape + self.parameter["var"] = var + self.parameter["tau"] = 1 / var + elif isinstance(var, np.ndarray): + assert (var > 0).all() + assert var.shape == self.shape + self.parameter["var"] = var + self.parameter["tau"] = 1 / var + else: + assert var is None + self.parameter["var"] = None + self.parameter["tau"] = None + + @property + def tau(self): + return self.parameter["tau"] + + @tau.setter + def tau(self, tau): + if isinstance(tau, (int, float, np.number)): + assert tau > 0 + tau = np.array(tau) + assert tau.shape == self.shape + self.parameter["tau"] = tau + self.parameter["var"] = 1 / tau + elif isinstance(tau, np.ndarray): + assert (tau > 0).all() + assert tau.shape == self.shape + self.parameter["tau"] = tau + self.parameter["var"] = 1 / tau + elif isinstance(tau, Gamma): + assert tau.shape == self.shape + self.parameter["tau"] = tau + self.parameter["var"] = None + else: + assert tau is None + self.parameter["tau"] = None + self.parameter["var"] = None + + @property + def ndim(self): + if hasattr(self.mu, "ndim"): + return self.mu.ndim + else: + return None + + @property + def size(self): + if hasattr(self.mu, "size"): + return self.mu.size + else: + return None + + @property + def shape(self): + if hasattr(self.mu, "shape"): + return self.mu.shape + else: + return None + + def _fit(self, X): + mu_is_gaussian = isinstance(self.mu, Gaussian) + tau_is_gamma = isinstance(self.tau, Gamma) + if mu_is_gaussian and tau_is_gamma: + raise NotImplementedError + elif mu_is_gaussian: + self._bayes_mu(X) + elif tau_is_gamma: + self._bayes_tau(X) + else: + self._ml(X) + + def _ml(self, X): + self.mu = np.mean(X, axis=0) + self.var = np.var(X, axis=0) + + def _map(self, X): + assert isinstance(self.mu, Gaussian) + assert isinstance(self.var, np.ndarray) + N = len(X) + mu = np.mean(X, 0) + self.mu = ( + (self.tau * self.mu.mu + N * self.mu.tau * mu) + / (N * self.mu.tau + self.tau) + ) + + def _bayes_mu(self, X): + N = len(X) + mu = np.mean(X, 0) + tau = self.mu.tau + N * self.tau + self.mu = Gaussian( + mu=(self.mu.mu * self.mu.tau + N * mu * self.tau) / tau, + tau=tau + ) + + def _bayes_tau(self, X): + N = len(X) + var = np.var(X, axis=0) + a = self.tau.a + 0.5 * N + b = self.tau.b + 0.5 * N * var + self.tau = Gamma(a, b) + + def _bayes(self, X): + N = len(X) + mu_is_gaussian = isinstance(self.mu, Gaussian) + tau_is_gamma = isinstance(self.tau, Gamma) + if mu_is_gaussian and not tau_is_gamma: + mu = np.mean(X, 0) + tau = self.mu.tau + N * self.tau + self.mu = Gaussian( + mu=(self.mu.mu * self.mu.tau + N * mu * self.tau) / tau, + tau=tau + ) + elif not mu_is_gaussian and tau_is_gamma: + var = np.var(X, axis=0) + a = self.tau.a + 0.5 * N + b = self.tau.b + 0.5 * N * var + self.tau = Gamma(a, b) + elif mu_is_gaussian and tau_is_gamma: + raise NotImplementedError + else: + raise NotImplementedError + + def _pdf(self, X): + d = X - self.mu + return ( + np.exp(-0.5 * self.tau * d ** 2) / np.sqrt(2 * np.pi * self.var) + ) + + def _draw(self, sample_size=1): + return np.random.normal( + loc=self.mu, + scale=np.sqrt(self.var), + size=(sample_size,) + self.shape + ) diff --git a/books/PRML/PRML-master-Python/prml/rv/multivariate_gaussian.py b/books/PRML/PRML-master-Python/prml/rv/multivariate_gaussian.py new file mode 100755 index 0000000..0d55bdd --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/rv/multivariate_gaussian.py @@ -0,0 +1,100 @@ +import numpy as np +from prml.rv.rv import RandomVariable + + +class MultivariateGaussian(RandomVariable): + """ + The multivariate Gaussian distribution + p(x|mu, cov) + = exp{-0.5 * (x - mu)^T @ cov^-1 @ (x - mu)} + / (2pi)^(D/2) / |cov|^0.5 + """ + + def __init__(self, mu=None, cov=None, tau=None): + super().__init__() + self.mu = mu + if cov is not None: + self.cov = cov + elif tau is not None: + self.tau = tau + else: + self.cov = None + self.tau = None + + @property + def mu(self): + return self.parameter["mu"] + + @mu.setter + def mu(self, mu): + if isinstance(mu, np.ndarray): + assert mu.ndim == 1 + self.parameter["mu"] = mu + else: + assert mu is None + self.parameter["mu"] = None + + @property + def cov(self): + return self.parameter["cov"] + + @cov.setter + def cov(self, cov): + if isinstance(cov, np.ndarray): + assert cov.ndim == 2 + self.tau_ = np.linalg.inv(cov) + self.parameter["cov"] = cov + else: + assert cov is None + self.tau_ = None + self.parameter["cov"] = None + + @property + def tau(self): + return self.tau_ + + @tau.setter + def tau(self, tau): + if isinstance(tau, np.ndarray): + assert tau.ndim == 2 + self.parameter["cov"] = np.linalg.inv(tau) + self.tau_ = tau + else: + assert tau is None + self.tau_ = None + self.parameter["cov"] = None + + @property + def ndim(self): + if hasattr(self.mu, "ndim"): + return self.mu.ndim + else: + return None + + @property + def size(self): + if hasattr(self.mu, "size"): + return self.mu.size + else: + return None + + @property + def shape(self): + if hasattr(self.mu, "shape"): + return self.mu.shape + else: + return None + + def _fit(self, X): + self.mu = np.mean(X, axis=0) + self.cov = np.atleast_2d(np.cov(X.T, bias=True)) + + def _pdf(self, X): + d = X - self.mu + return ( + np.exp(-0.5 * np.sum(d @ self.tau * d, axis=-1)) + * np.sqrt(np.linalg.det(self.tau)) + / np.power(2 * np.pi, 0.5 * self.size)) + + def _draw(self, sample_size=1): + return np.random.multivariate_normal(self.mu, self.cov, sample_size) diff --git a/books/PRML/PRML-master-Python/prml/rv/multivariate_gaussian_mixture.py b/books/PRML/PRML-master-Python/prml/rv/multivariate_gaussian_mixture.py new file mode 100755 index 0000000..6b70dbb --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/rv/multivariate_gaussian_mixture.py @@ -0,0 +1,222 @@ +import numpy as np +from prml.clustering import KMeans +from prml.rv.rv import RandomVariable + + +class MultivariateGaussianMixture(RandomVariable): + """ + p(x|mu, L, pi(coef)) + = sum_k pi_k N(x|mu_k, L_k^-1) + """ + + def __init__(self, + n_components, + mu=None, + cov=None, + tau=None, + coef=None): + """ + construct mixture of Gaussians + + Parameters + ---------- + n_components : int + number of gaussian component + mu : (n_components, ndim) np.ndarray + mean parameter of each gaussian component + cov : (n_components, ndim, ndim) np.ndarray + variance parameter of each gaussian component + tau : (n_components, ndim, ndim) np.ndarray + precision parameter of each gaussian component + coef : (n_components,) np.ndarray + mixing coefficients + """ + super().__init__() + assert isinstance(n_components, int) + self.n_components = n_components + self.mu = mu + if cov is not None and tau is not None: + raise ValueError("Cannot assign both cov and tau at a time") + elif cov is not None: + self.cov = cov + elif tau is not None: + self.tau = tau + else: + self.cov = None + self.tau = None + self.coef = coef + + @property + def mu(self): + return self.parameter["mu"] + + @mu.setter + def mu(self, mu): + if isinstance(mu, np.ndarray): + assert mu.ndim == 2 + assert np.size(mu, 0) == self.n_components + self.ndim = np.size(mu, 1) + self.parameter["mu"] = mu + elif mu is None: + self.parameter["mu"] = None + else: + raise TypeError("mu must be either np.ndarray or None") + + @property + def cov(self): + return self.parameter["cov"] + + @cov.setter + def cov(self, cov): + if isinstance(cov, np.ndarray): + assert cov.shape == (self.n_components, self.ndim, self.ndim) + self._tau = np.linalg.inv(cov) + self.parameter["cov"] = cov + elif cov is None: + self.parameter["cov"] = None + self._tau = None + else: + raise TypeError("cov must be either np.ndarray or None") + + @property + def tau(self): + return self._tau + + @tau.setter + def tau(self, tau): + if isinstance(tau, np.ndarray): + assert tau.shape == (self.n_components, self.ndim, self.ndim) + self.parameter["cov"] = np.linalg.inv(tau) + self._tau = tau + elif tau is None: + self.parameter["cov"] = None + self._tau = None + else: + raise TypeError("tau must be either np.ndarray or None") + + @property + def coef(self): + return self.parameter["coef"] + + @coef.setter + def coef(self, coef): + if isinstance(coef, np.ndarray): + assert coef.ndim == 1 + if np.isnan(coef).any(): + self.parameter["coef"] = np.ones(self.n_components) / self.n_components + elif not np.allclose(coef.sum(), 1): + raise ValueError(f"sum of coef must be equal to 1 {coef}") + self.parameter["coef"] = coef + elif coef is None: + self.parameter["coef"] = None + else: + raise TypeError("coef must be either np.ndarray or None") + + @property + def shape(self): + if hasattr(self.mu, "shape"): + return self.mu.shape[1:] + else: + return None + + def _gauss(self, X): + d = X[:, None, :] - self.mu + D_sq = np.sum(np.einsum('nki,kij->nkj', d, self.cov) * d, -1) + return ( + np.exp(-0.5 * D_sq) + / np.sqrt( + np.linalg.det(self.cov) * (2 * np.pi) ** self.ndim + ) + ) + + def _fit(self, X): + cov = np.cov(X.T) + kmeans = KMeans(self.n_components) + kmeans.fit(X) + self.mu = kmeans.centers + self.cov = np.array([cov for _ in range(self.n_components)]) + self.coef = np.ones(self.n_components) / self.n_components + params = np.hstack( + (self.mu.ravel(), + self.cov.ravel(), + self.coef.ravel()) + ) + while True: + stats = self._expectation(X) + self._maximization(X, stats) + new_params = np.hstack( + (self.mu.ravel(), + self.cov.ravel(), + self.coef.ravel()) + ) + if np.allclose(params, new_params): + break + else: + params = new_params + + def _expectation(self, X): + resps = self.coef * self._gauss(X) + resps /= resps.sum(axis=-1, keepdims=True) + return resps + + def _maximization(self, X, resps): + Nk = np.sum(resps, axis=0) + self.coef = Nk / len(X) + self.mu = (X.T @ resps / Nk).T + d = X[:, None, :] - self.mu + self.cov = np.einsum( + 'nki,nkj->kij', d, d * resps[:, :, None]) / Nk[:, None, None] + + def joint_proba(self, X): + """ + calculate joint probability p(X, Z) + + Parameters + ---------- + X : (sample_size, n_features) ndarray + input data + + Returns + ------- + joint_prob : (sample_size, n_components) ndarray + joint probability of input and component + """ + return self.coef * self._gauss(X) + + def _pdf(self, X): + joint_prob = self.coef * self._gauss(X) + return np.sum(joint_prob, axis=-1) + + def classify(self, X): + """ + classify input + max_z p(z|x, theta) + + Parameters + ---------- + X : (sample_size, ndim) ndarray + input + + Returns + ------- + output : (sample_size,) ndarray + corresponding cluster index + """ + return np.argmax(self.classify_proba(X), axis=1) + + def classify_proba(self, X): + """ + posterior probability of cluster + p(z|x,theta) + + Parameters + ---------- + X : (sample_size, ndim) ndarray + input + + Returns + ------- + output : (sample_size, n_components) ndarray + posterior probability of cluster + """ + return self._expectation(X) diff --git a/books/PRML/PRML-master-Python/prml/rv/rv.py b/books/PRML/PRML-master-Python/prml/rv/rv.py new file mode 100755 index 0000000..5d794c8 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/rv/rv.py @@ -0,0 +1,142 @@ +import numpy as np + + +class RandomVariable(object): + """ + base class for random variables + """ + + def __init__(self): + self.parameter = {} + + def __repr__(self): + string = f"{self.__class__.__name__}(\n" + for key, value in self.parameter.items(): + string += (" " * 4) + if isinstance(value, RandomVariable): + string += f"{key}={value:8}" + else: + string += f"{key}={value}" + string += "\n" + string += ")" + return string + + def __format__(self, indent="4"): + indent = int(indent) + string = f"{self.__class__.__name__}(\n" + for key, value in self.parameter.items(): + string += (" " * indent) + if isinstance(value, RandomVariable): + string += f"{key}=" + value.__format__(str(indent + 4)) + else: + string += f"{key}={value}" + string += "\n" + string += (" " * (indent - 4)) + ")" + return string + + def fit(self, X, **kwargs): + """ + estimate parameter(s) of the distribution + + Parameters + ---------- + X : np.ndarray + observed data + """ + self._check_input(X) + if hasattr(self, "_fit"): + self._fit(X, **kwargs) + else: + raise NotImplementedError + + # def ml(self, X, **kwargs): + # """ + # maximum likelihood estimation of the parameter(s) + # of the distribution given data + + # Parameters + # ---------- + # X : (sample_size, ndim) np.ndarray + # observed data + # """ + # self._check_input(X) + # if hasattr(self, "_ml"): + # self._ml(X, **kwargs) + # else: + # raise NotImplementedError + + # def map(self, X, **kwargs): + # """ + # maximum a posteriori estimation of the parameter(s) + # of the distribution given data + + # Parameters + # ---------- + # X : (sample_size, ndim) np.ndarray + # observed data + # """ + # self._check_input(X) + # if hasattr(self, "_map"): + # self._map(X, **kwargs) + # else: + # raise NotImplementedError + + # def bayes(self, X, **kwargs): + # """ + # bayesian estimation of the parameter(s) + # of the distribution given data + + # Parameters + # ---------- + # X : (sample_size, ndim) np.ndarray + # observed data + # """ + # self._check_input(X) + # if hasattr(self, "_bayes"): + # self._bayes(X, **kwargs) + # else: + # raise NotImplementedError + + def pdf(self, X): + """ + compute probability density function + p(X|parameter) + + Parameters + ---------- + X : (sample_size, ndim) np.ndarray + input of the function + + Returns + ------- + p : (sample_size,) np.ndarray + value of probability density function for each input + """ + self._check_input(X) + if hasattr(self, "_pdf"): + return self._pdf(X) + else: + raise NotImplementedError + + def draw(self, sample_size=1): + """ + draw samples from the distribution + + Parameters + ---------- + sample_size : int + sample size + + Returns + ------- + sample : (sample_size, ndim) np.ndarray + generated samples from the distribution + """ + assert isinstance(sample_size, int) + if hasattr(self, "_draw"): + return self._draw(sample_size) + else: + raise NotImplementedError + + def _check_input(self, X): + assert isinstance(X, np.ndarray) diff --git a/books/PRML/PRML-master-Python/prml/rv/students_t.py b/books/PRML/PRML-master-Python/prml/rv/students_t.py new file mode 100755 index 0000000..8e61a48 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/rv/students_t.py @@ -0,0 +1,133 @@ +import numpy as np +from scipy.special import gamma, digamma +from prml.rv.rv import RandomVariable + + +class StudentsT(RandomVariable): + """ + Student's t-distribution + p(x|mu, tau, dof) + = (1 + tau * (x - mu)^2 / dof)^-(D + dof)/2 / const. + """ + + def __init__(self, mu=None, tau=None, dof=None): + super().__init__() + self.mu = mu + self.tau = tau + self.dof = dof + + @property + def mu(self): + return self.parameter["mu"] + + @mu.setter + def mu(self, mu): + if isinstance(mu, (int, float, np.number)): + self.parameter["mu"] = np.array(mu) + elif isinstance(mu, np.ndarray): + self.parameter["mu"] = mu + else: + assert mu is None + self.parameter["mu"] = None + + @property + def tau(self): + return self.parameter["tau"] + + @tau.setter + def tau(self, tau): + if isinstance(tau, (int, float, np.number)): + tau = np.array(tau) + assert tau.shape == self.shape + self.parameter["tau"] = tau + elif isinstance(tau, np.ndarray): + assert tau.shape == self.shape + self.parameter["tau"] = tau + else: + assert tau is None + self.parameter["tau"] = None + + @property + def dof(self): + return self.parameter["dof"] + + @dof.setter + def dof(self, dof): + if isinstance(dof, (int, float, np.number)): + self.parameter["dof"] = dof + else: + assert dof is None + self.parameter["dof"] = None + + @property + def ndim(self): + if hasattr(self.mu, "ndim"): + return self.mu.ndim + else: + return None + + @property + def size(self): + if hasattr(self.mu, "size"): + return self.mu.size + else: + return None + + @property + def shape(self): + if hasattr(self.mu, "shape"): + return self.mu.shape + else: + return None + + def _fit(self, X, learning_rate=0.01): + self.mu = np.mean(X, axis=0) + self.tau = 1 / np.var(X, axis=0) + self.dof = 1 + params = np.hstack( + (self.mu.ravel(), + self.tau.ravel(), + self.dof) + ) + while True: + E_eta, E_lneta = self._expectation(X) + self._maximization(X, E_eta, E_lneta, learning_rate) + new_params = np.hstack( + (self.mu.ravel(), + self.tau.ravel(), + self.dof) + ) + if np.allclose(params, new_params): + break + else: + params = new_params + + def _expectation(self, X): + d = X - self.mu + a = 0.5 * (self.dof + 1) + b = 0.5 * (self.dof + self.tau * d ** 2) + E_eta = a / b + E_lneta = digamma(a) - np.log(b) + return E_eta, E_lneta + + def _maximization(self, X, E_eta, E_lneta, learning_rate): + self.mu = np.sum(E_eta * X, axis=0) / np.sum(E_eta, axis=0) + d = X - self.mu + self.tau = 1 / np.mean(E_eta * d ** 2, axis=0) + N = len(X) + self.dof += learning_rate * 0.5 * ( + N * np.log(0.5 * self.dof) + N + - N * digamma(0.5 * self.dof) + + np.sum(E_lneta - E_eta, axis=0) + ) + + def _pdf(self, X): + d = X - self.mu + D_sq = self.tau * d ** 2 + return ( + gamma(0.5 * (self.dof + 1)) + * self.tau ** 0.5 + * (1 + D_sq / self.dof) ** (-0.5 * (1 + self.dof)) + / gamma(self.dof * 0.5) + / (np.pi * self.dof) ** 0.5 + ) diff --git a/books/PRML/PRML-master-Python/prml/rv/uniform.py b/books/PRML/PRML-master-Python/prml/rv/uniform.py new file mode 100755 index 0000000..ca5173e --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/rv/uniform.py @@ -0,0 +1,71 @@ +import numpy as np +from prml.rv.rv import RandomVariable + + +class Uniform(RandomVariable): + """ + Uniform distribution + p(x|a, b) + = 1 / ((b_0 - a_0) * (b_1 - a_1)) if a <= x <= b else 0 + """ + + def __init__(self, low, high): + """ + construct uniform distribution + + Parameters + ---------- + low : int, float, or np.ndarray + lower boundary + high : int, float, or np.ndarray + higher boundary + """ + super().__init__() + low = np.asarray(low) + high = np.asarray(high) + assert low.shape == high.shape + assert (low <= high).all() + self.low = low + self.high = high + self.value = 1 / np.prod(high - low) + + @property + def low(self): + return self.parameter["low"] + + @low.setter + def low(self, low): + self.parameter["low"] = low + + @property + def high(self): + return self.parameter["high"] + + @high.setter + def high(self, high): + self.parameter["high"] = high + + @property + def ndim(self): + return self.low.ndim + + @property + def size(self): + return self.low.size + + @property + def shape(self): + return self.low.shape + + @property + def mean(self): + return 0.5 * (self.low + self.high) + + def _pdf(self, X): + higher = np.logical_and.reduce(X >= self.low, 1) + lower = np.logical_and.reduce(X <= self.high, 1) + return self.value * np.logical_and(higher, lower) + + def _draw(self, sample_size=1): + u01 = np.random.uniform(size=(sample_size,) + self.shape) + return u01 * (self.high - self.low) + self.low diff --git a/books/PRML/PRML-master-Python/prml/rv/variational_gaussian_mixture.py b/books/PRML/PRML-master-Python/prml/rv/variational_gaussian_mixture.py new file mode 100755 index 0000000..568b927 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/rv/variational_gaussian_mixture.py @@ -0,0 +1,177 @@ +import numpy as np +from scipy.misc import logsumexp +from scipy.special import digamma, gamma +from prml.rv.rv import RandomVariable + + +class VariationalGaussianMixture(RandomVariable): + + def __init__(self, n_components=1, alpha0=None, m0=None, W0=1., dof0=None, beta0=1.): + """ + construct variational gaussian mixture model + Parameters + ---------- + n_components : int + maximum numnber of gaussian components + alpha0 : float + parameter of prior dirichlet distribution + m0 : float + mean parameter of prior gaussian distribution + W0 : float + mean of the prior Wishart distribution + dof0 : float + number of degrees of freedom of the prior Wishart distribution + beta0 : float + prior on the precision distribution + """ + super().__init__() + self.n_components = n_components + if alpha0 is None: + self.alpha0 = 1 / n_components + else: + self.alpha0 = alpha0 + self.m0 = m0 + self.W0 = W0 + self.dof0 = dof0 + self.beta0 = beta0 + + def _init_params(self, X): + sample_size, self.ndim = X.shape + self.alpha0 = np.ones(self.n_components) * self.alpha0 + if self.m0 is None: + self.m0 = np.mean(X, axis=0) + else: + self.m0 = np.zeros(self.ndim) + self.m0 + self.W0 = np.eye(self.ndim) * self.W0 + if self.dof0 is None: + self.dof0 = self.ndim + + self.component_size = sample_size / self.n_components + np.zeros(self.n_components) + self.alpha = self.alpha0 + self.component_size + self.beta = self.beta0 + self.component_size + indices = np.random.choice(sample_size, self.n_components, replace=False) + self.mu = X[indices] + self.W = np.tile(self.W0, (self.n_components, 1, 1)) + self.dof = self.dof0 + self.component_size + + @property + def alpha(self): + return self.parameter["alpha"] + + @alpha.setter + def alpha(self, alpha): + self.parameter["alpha"] = alpha + + @property + def beta(self): + return self.parameter["beta"] + + @beta.setter + def beta(self, beta): + self.parameter["beta"] = beta + + @property + def mu(self): + return self.parameter["mu"] + + @mu.setter + def mu(self, mu): + self.parameter["mu"] = mu + + @property + def W(self): + return self.parameter["W"] + + @W.setter + def W(self, W): + self.parameter["W"] = W + + @property + def dof(self): + return self.parameter["dof"] + + @dof.setter + def dof(self, dof): + self.parameter["dof"] = dof + + def get_params(self): + return self.alpha, self.beta, self.mu, self.W, self.dof + + def _fit(self, X, iter_max=100): + self._init_params(X) + for _ in range(iter_max): + params = np.hstack([p.flatten() for p in self.get_params()]) + r = self._variational_expectation(X) + self._variational_maximization(X, r) + if np.allclose(params, np.hstack([p.flatten() for p in self.get_params()])): + break + + def _variational_expectation(self, X): + d = X[:, None, :] - self.mu + maha_sq = -0.5 * ( + self.ndim / self.beta + + self.dof * np.sum( + np.einsum("kij,nkj->nki", self.W, d) * d, axis=-1)) + ln_pi = digamma(self.alpha) - digamma(self.alpha.sum()) + ln_Lambda = digamma(0.5 * (self.dof - np.arange(self.ndim)[:, None])).sum(axis=0) + self.ndim * np.log(2) + np.linalg.slogdet(self.W)[1] + ln_r = ln_pi + 0.5 * ln_Lambda + maha_sq + ln_r -= logsumexp(ln_r, axis=-1)[:, None] + r = np.exp(ln_r) + return r + + def _variational_maximization(self, X, r): + self.component_size = r.sum(axis=0) + Xm = (X.T.dot(r) / self.component_size).T + d = X[:, None, :] - Xm + S = np.einsum('nki,nkj->kij', d, r[:, :, None] * d) / self.component_size[:, None, None] + self.alpha = self.alpha0 + self.component_size + self.beta = self.beta0 + self.component_size + self.mu = (self.beta0 * self.m0 + self.component_size[:, None] * Xm) / self.beta[:, None] + d = Xm - self.m0 + self.W = np.linalg.inv( + np.linalg.inv(self.W0) + + (self.component_size * S.T).T + + (self.beta0 * self.component_size * np.einsum('ki,kj->kij', d, d).T / (self.beta0 + self.component_size)).T) + self.dof = self.dof0 + self.component_size + + def classify(self, X): + """ + index of highest posterior of the latent variable + Parameters + ---------- + X : (sample_size, ndim) ndarray + input + Returns + ------- + output : (sample_size, n_components) ndarray + index of maximum posterior of the latent variable + """ + return np.argmax(self._variational_expectation(X), 1) + + def classify_proba(self, X): + """ + compute posterior of the latent variable + Parameters + ---------- + X : (sample_size, ndim) ndarray + input + Returns + ------- + output : (sample_size, n_components) ndarray + posterior of the latent variable + """ + return self._variational_expectation(X) + + def student_t(self, X): + nu = self.dof + 1 - self.ndim + L = (nu * self.beta * self.W.T / (1 + self.beta)).T + d = X[:, None, :] - self.mu + maha_sq = np.sum(np.einsum('nki,kij->nkj', d, L) * d, axis=-1) + return ( + gamma(0.5 * (nu + self.ndim)) + * np.sqrt(np.linalg.det(L)) + * (1 + maha_sq / nu) ** (-0.5 * (nu + self.ndim)) + / (gamma(0.5 * nu) * (nu * np.pi) ** (0.5 * self.ndim))) + + def _pdf(self, X): + return (self.alpha * self.student_t(X)).sum(axis=-1) / self.alpha.sum() diff --git a/books/PRML/PRML-master-Python/prml/sampling/__init__.py b/books/PRML/PRML-master-Python/prml/sampling/__init__.py new file mode 100755 index 0000000..ab2394d --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/sampling/__init__.py @@ -0,0 +1,12 @@ +from prml.sampling.metropolis import metropolis +from prml.sampling.metropolis_hastings import metropolis_hastings +from prml.sampling.rejection_sampling import rejection_sampling +from prml.sampling.sir import sir + + +__all__ = [ + "metropolis", + "metropolis_hastings", + "rejection_sampling", + "sir" +] diff --git a/books/PRML/PRML-master-Python/prml/sampling/metropolis.py b/books/PRML/PRML-master-Python/prml/sampling/metropolis.py new file mode 100755 index 0000000..9eebd08 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/sampling/metropolis.py @@ -0,0 +1,36 @@ +import random +import numpy as np + + +def metropolis(func, rv, n, downsample=1): + """ + Metropolis algorithm + + Parameters + ---------- + func : callable + (un)normalized distribution to be sampled from + rv : RandomVariable + proposal distribution which is symmetric at the origin + n : int + number of samples to draw + downsample : int + downsampling factor + + Returns + ------- + sample : (n, ndim) ndarray + generated sample + """ + x = np.zeros((1, rv.ndim)) + sample = [] + for i in range(n * downsample): + x_new = x + rv.draw() + accept_proba = func(x_new) / func(x) + if random.random() < accept_proba: + x = x_new + if i % downsample == 0: + sample.append(x[0]) + sample = np.asarray(sample) + assert sample.shape == (n, rv.ndim), sample.shape + return sample diff --git a/books/PRML/PRML-master-Python/prml/sampling/metropolis_hastings.py b/books/PRML/PRML-master-Python/prml/sampling/metropolis_hastings.py new file mode 100755 index 0000000..ce20a13 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/sampling/metropolis_hastings.py @@ -0,0 +1,36 @@ +import random +import numpy as np + + +def metropolis_hastings(func, rv, n, downsample=1): + """ + Metropolis Hastings algorith + + Parameters + ---------- + func : callable + (un)normalized distribution to be sampled from + rv : RandomVariable + proposal distribution + n : int + number of samples to draw + downsample : int + downsampling factor + + Returns + ------- + sample : (n, ndim) ndarray + generated sample + """ + x = np.zeros((1, rv.ndim)) + sample = [] + for i in range(n * downsample): + x_new = x + rv.draw() + accept_proba = func(x_new) * rv.pdf(x - x_new) / (func(x) * rv.pdf(x_new - x)) + if random.random() < accept_proba: + x = x_new + if i % downsample == 0: + sample.append(x[0]) + sample = np.asarray(sample) + assert sample.shape == (n, rv.ndim), sample.shape + return sample diff --git a/books/PRML/PRML-master-Python/prml/sampling/rejection_sampling.py b/books/PRML/PRML-master-Python/prml/sampling/rejection_sampling.py new file mode 100755 index 0000000..5a5dccd --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/sampling/rejection_sampling.py @@ -0,0 +1,34 @@ +import random +import numpy as np + + +def rejection_sampling(func, rv, k, n): + """ + perform rejection sampling n times + + Parameters + ---------- + func : callable + (un)normalized distribution to be sampled from + rv : RandomVariable + distribution to generate sample + k : float + constant to be multiplied with the distribution + n : int + number of samples to draw + + Returns + ------- + sample : (n, ndim) ndarray + generated sample + """ + assert hasattr(rv, "draw"), "the distribution has no method to draw random samples" + sample = [] + while len(sample) < n: + sample_candidate = rv.draw() + accept_proba = func(sample_candidate) / (k * rv.pdf(sample_candidate)) + if random.random() < accept_proba: + sample.append(sample_candidate[0]) + sample = np.asarray(sample) + assert sample.shape == (n, rv.ndim), sample.shape + return sample diff --git a/books/PRML/PRML-master-Python/prml/sampling/sir.py b/books/PRML/PRML-master-Python/prml/sampling/sir.py new file mode 100755 index 0000000..1ccd0a7 --- /dev/null +++ b/books/PRML/PRML-master-Python/prml/sampling/sir.py @@ -0,0 +1,29 @@ +import numpy as np + + +def sir(func, rv, n): + """ + sampling-importance-resampling + + Parameters + ---------- + func : callable + (un)normalized distribution to be sampled from + rv : RandomVariable + distribution to generate sample + n : int + number of samples to draw + + Returns + ------- + sample : (n, ndim) ndarray + generated sample + """ + assert hasattr(rv, "draw"), "the distribution has no method to draw random samples" + sample_candidate = rv.draw(n * 10) + weight = np.squeeze(func(sample_candidate) / rv.pdf(sample_candidate)) + assert weight.shape == (n * 10,), weight.shape + weight /= np.sum(weight) + index = np.random.choice(n * 10, n, p=weight) + sample = sample_candidate[index] + return sample diff --git a/books/PRML/PRML-master-Python/setup.py b/books/PRML/PRML-master-Python/setup.py new file mode 100755 index 0000000..242ddf9 --- /dev/null +++ b/books/PRML/PRML-master-Python/setup.py @@ -0,0 +1,13 @@ +from setuptools import setup, find_packages + + +setup( + name="prml", + version="0.0.1", + description="Collection of PRML algorithms", + author="ctgk", + python_requires=">=3.6", + install_requires=["numpy", "scipy"], + packages=find_packages(exclude=["test", "test.*"]), + test_suite="test" +) diff --git a/books/PRML/PRML-master-Python/test/__init__.py b/books/PRML/PRML-master-Python/test/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/books/PRML/PRML-master-Python/test/nn/__init__.py b/books/PRML/PRML-master-Python/test/nn/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/books/PRML/PRML-master-Python/test/nn/array/__init__.py b/books/PRML/PRML-master-Python/test/nn/array/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/books/PRML/PRML-master-Python/test/nn/array/broadcast.py b/books/PRML/PRML-master-Python/test/nn/array/broadcast.py new file mode 100755 index 0000000..e8d53da --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/array/broadcast.py @@ -0,0 +1,19 @@ +import unittest +import numpy as np +from prml import nn +from prml.nn.array.broadcast import broadcast_to + + +class TestBroadcastTo(unittest.TestCase): + + def test_broadcast(self): + x = nn.Parameter(np.ones((1, 1))) + shape = (5, 2, 3) + y = broadcast_to(x, shape) + self.assertEqual(y.shape, shape) + y.backward(np.ones(shape)) + self.assertTrue((x.grad == np.ones((1, 1)) * 30).all()) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/array/flatten.py b/books/PRML/PRML-master-Python/test/nn/array/flatten.py new file mode 100755 index 0000000..4b3f95b --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/array/flatten.py @@ -0,0 +1,21 @@ +import unittest +import numpy as np +from prml import nn + + +class TestFlatten(unittest.TestCase): + + def test_flatten(self): + self.assertRaises(TypeError, nn.flatten, "abc") + self.assertRaises(ValueError, nn.flatten, np.ones(1)) + + x = np.random.rand(5, 4) + p = nn.Parameter(x) + y = p.flatten() + self.assertTrue((y.value == x.flatten()).all()) + y.backward(np.ones(20)) + self.assertTrue((p.grad == np.ones((5, 4))).all()) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/array/reshape.py b/books/PRML/PRML-master-Python/test/nn/array/reshape.py new file mode 100755 index 0000000..ca8ee38 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/array/reshape.py @@ -0,0 +1,20 @@ +import unittest +import numpy as np +from prml import nn + + +class TestReshape(unittest.TestCase): + + def test_reshape(self): + self.assertRaises(ValueError, nn.reshape, 1, (2, 3)) + + x = np.random.rand(2, 6) + p = nn.Parameter(x) + y = p.reshape(3, 4) + self.assertTrue((x.reshape(3, 4) == y.value).all()) + y.backward(np.ones((3, 4))) + self.assertTrue((p.grad == np.ones((2, 6))).all()) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/array/split.py b/books/PRML/PRML-master-Python/test/nn/array/split.py new file mode 100755 index 0000000..ea5d329 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/array/split.py @@ -0,0 +1,21 @@ +import unittest +import numpy as np +from prml import nn + + +class TestSplit(unittest.TestCase): + + def test_split(self): + x = np.random.rand(10, 7) + a = nn.Parameter(x) + b, c = nn.split(a, (3,), axis=-1) + self.assertTrue((b.value == x[:, :3]).all()) + self.assertTrue((c.value == x[:, 3:]).all()) + b.backward(np.ones((10, 3))) + self.assertIs(a.grad, None) + c.backward(np.ones((10, 4))) + self.assertTrue((a.grad == np.ones((10, 7))).all()) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/array/transpose.py b/books/PRML/PRML-master-Python/test/nn/array/transpose.py new file mode 100755 index 0000000..377be65 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/array/transpose.py @@ -0,0 +1,28 @@ +import unittest +import numpy as np +from prml import nn + + +class TestTranspose(unittest.TestCase): + + def test_transpose(self): + arrays = [ + np.random.normal(size=(2, 3)), + np.random.normal(size=(2, 3, 4)) + ] + axes = [ + None, + (2, 0, 1) + ] + + for arr, ax in zip(arrays, axes): + arr = nn.Parameter(arr) + arr_t = nn.transpose(arr, ax) + self.assertEqual(arr_t.shape, np.transpose(arr.value, ax).shape) + da = np.random.normal(size=arr_t.shape) + arr_t.backward(da) + self.assertEqual(arr.grad.shape, arr.shape) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/linalg/__init__.py b/books/PRML/PRML-master-Python/test/nn/linalg/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/books/PRML/PRML-master-Python/test/nn/linalg/cholesky.py b/books/PRML/PRML-master-Python/test/nn/linalg/cholesky.py new file mode 100755 index 0000000..88034d0 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/linalg/cholesky.py @@ -0,0 +1,33 @@ +import unittest +import numpy as np +from prml import nn + + +class TestCholesky(unittest.TestCase): + + def test_cholesky(self): + A = np.array([ + [2., -1], + [-1., 5.] + ]) + L = np.linalg.cholesky(A) + Ap = nn.Parameter(A) + L_test = nn.linalg.cholesky(Ap) + self.assertTrue((L == L_test.value).all()) + + T = np.array([ + [1., 0.], + [-1., 2.] + ]) + for _ in range(1000): + Ap.cleargrad() + L_ = nn.linalg.cholesky(Ap) + loss = nn.square(T - L_).sum() + loss.backward() + Ap.value -= 0.1 * Ap.grad + + self.assertTrue(np.allclose(Ap.value, T @ T.T)) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/linalg/det.py b/books/PRML/PRML-master-Python/test/nn/linalg/det.py new file mode 100755 index 0000000..8fb05dd --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/linalg/det.py @@ -0,0 +1,27 @@ +import unittest +import numpy as np +from prml import nn + + +class TestDeterminant(unittest.TestCase): + + def test_determinant(self): + A = np.array([ + [2., 1.], + [1., 3.] + ]) + detA = np.linalg.det(A) + self.assertTrue((detA == nn.linalg.det(A).value).all()) + + A = nn.Parameter(A) + for _ in range(100): + A.cleargrad() + detA = nn.linalg.det(A) + loss = nn.square(detA - 1) + loss.backward() + A.value -= 0.1 * A.grad + self.assertAlmostEqual(detA.value, 1.) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/linalg/inv.py b/books/PRML/PRML-master-Python/test/nn/linalg/inv.py new file mode 100755 index 0000000..23c11fe --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/linalg/inv.py @@ -0,0 +1,35 @@ +import unittest +import numpy as np +from prml import nn + + +class TestInverse(unittest.TestCase): + + def test_inverse(self): + A = np.array([ + [2., 1.], + [1., 3.] + ]) + Ainv = np.linalg.inv(A) + self.assertTrue((Ainv == nn.linalg.inv(A).value).all()) + + B = np.array([ + [-1., 1.], + [1., 0.5] + ]) + A = nn.Parameter(np.array([ + [-0.4, 0.7], + [0.7, 0.7] + ])) + for _ in range(100): + A.cleargrad() + Ainv = nn.linalg.inv(A) + loss = nn.square(Ainv - B).sum() + loss.backward() + A.value -= 0.1 * A.grad + + self.assertTrue(np.allclose(A.value, np.linalg.inv(B))) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/linalg/logdet.py b/books/PRML/PRML-master-Python/test/nn/linalg/logdet.py new file mode 100755 index 0000000..4b9eb01 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/linalg/logdet.py @@ -0,0 +1,27 @@ +import unittest +import numpy as np +from prml import nn + + +class TestLogdet(unittest.TestCase): + + def test_logdet(self): + A = np.array([ + [2., 1.], + [1., 3.] + ]) + logdetA = np.linalg.slogdet(A)[1] + self.assertTrue((logdetA == nn.linalg.logdet(A).value).all()) + + A = nn.Parameter(A) + for _ in range(100): + A.cleargrad() + logdetA = nn.linalg.logdet(A) + loss = nn.square(logdetA - 1) + loss.backward() + A.value -= 0.1 * A.grad + self.assertAlmostEqual(logdetA.value, 1) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/linalg/solve.py b/books/PRML/PRML-master-Python/test/nn/linalg/solve.py new file mode 100755 index 0000000..21c22c2 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/linalg/solve.py @@ -0,0 +1,31 @@ +import unittest +import numpy as np +from prml import nn + + +class TestSolve(unittest.TestCase): + + def test_solve(self): + A = np.array([ + [2., 1.], + [1., 3.] + ]) + B = np.array([1., 2.])[:, None] + AinvB = np.linalg.solve(A, B) + self.assertTrue((AinvB == nn.linalg.solve(A, B).value).all()) + + A = nn.Parameter(A) + B = nn.Parameter(B) + for _ in range(100): + A.cleargrad() + B.cleargrad() + AinvB = nn.linalg.solve(A, B) + loss = nn.square(AinvB - 1).sum() + loss.backward() + A.value -= A.grad + B.value -= B.grad + self.assertTrue(np.allclose(AinvB.value, 1)) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/linalg/trace.py b/books/PRML/PRML-master-Python/test/nn/linalg/trace.py new file mode 100755 index 0000000..81f1a72 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/linalg/trace.py @@ -0,0 +1,33 @@ +import unittest +import numpy as np +from prml import nn + + +class TestTrace(unittest.TestCase): + + def test_trace(self): + arrays = [ + np.random.normal(size=(2, 2)), + np.random.normal(size=(3, 4)) + ] + + for arr in arrays: + arr = nn.Parameter(arr) + tr_arr = nn.linalg.trace(arr) + self.assertEqual(tr_arr.value, np.trace(arr.value)) + + a = np.array([ + [1.5, 0], + [-0.1, 1.1] + ]) + a = nn.Parameter(a) + for _ in range(100): + a.cleargrad() + loss = nn.square(nn.linalg.trace(a) - 2) + loss.backward() + a.value -= 0.1 * a.grad + self.assertEqual(nn.linalg.trace(a).value, 2) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/math/__init__.py b/books/PRML/PRML-master-Python/test/nn/math/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/books/PRML/PRML-master-Python/test/nn/math/abs.py b/books/PRML/PRML-master-Python/test/nn/math/abs.py new file mode 100755 index 0000000..99653c4 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/math/abs.py @@ -0,0 +1,24 @@ +import unittest +import numpy as np +from prml import nn + + +class TestAbs(unittest.TestCase): + + def test_abs(self): + np.random.seed(1234) + x = nn.Parameter(np.random.randn(5, 7)) + sign = np.sign(x.value) + y = nn.abs(x) + self.assertTrue((y.value == np.abs(x.value)).all()) + + for _ in range(10000): + x.cleargrad() + y = nn.abs(x) + nn.square(y - 0.01).sum().backward() + x.value -= x.grad * 0.001 + self.assertTrue(np.allclose(x.value, 0.01 * sign)) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/math/add.py b/books/PRML/PRML-master-Python/test/nn/math/add.py new file mode 100755 index 0000000..8ab3561 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/math/add.py @@ -0,0 +1,25 @@ +import unittest +import numpy as np +from prml import nn + + +class TestAdd(unittest.TestCase): + + def test_add(self): + x = nn.Parameter(2) + z = x + 5 + self.assertEqual(z.value, 7) + z.backward() + self.assertEqual(x.grad, 1) + + x = np.random.rand(5, 4) + y = np.random.rand(4) + p = nn.Parameter(y) + z = x + p + self.assertTrue((z.value == x + y).all()) + z.backward(np.ones((5, 4))) + self.assertTrue((p.grad == np.ones(4) * 5).all()) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/math/divide.py b/books/PRML/PRML-master-Python/test/nn/math/divide.py new file mode 100755 index 0000000..626d43c --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/math/divide.py @@ -0,0 +1,26 @@ +import unittest +import numpy as np +from prml import nn + + +class TestDivide(unittest.TestCase): + + def test_divide(self): + x = nn.Parameter(10.) + z = x / 2 + self.assertEqual(z.value, 5) + z.backward() + self.assertEqual(x.grad, 0.5) + + x = np.random.rand(5, 10, 3) + y = np.random.rand(10, 1) + p = nn.Parameter(y) + z = x / p + self.assertTrue((z.value == x / y).all()) + z.backward(np.ones((5, 10, 3))) + d = np.sum(-x / y ** 2, axis=0).sum(axis=1, keepdims=True) + self.assertTrue((p.grad == d).all()) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/math/exp.py b/books/PRML/PRML-master-Python/test/nn/math/exp.py new file mode 100755 index 0000000..f17708d --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/math/exp.py @@ -0,0 +1,24 @@ +import unittest +import numpy as np +from prml import nn + + +class TestExp(unittest.TestCase): + + def test_exp(self): + x = nn.Parameter(2.) + y = nn.exp(x) + self.assertEqual(y.value, np.exp(2)) + y.backward() + self.assertEqual(x.grad, np.exp(2)) + + x = np.random.rand(5, 3) + p = nn.Parameter(x) + y = nn.exp(p) + self.assertTrue((y.value == np.exp(x)).all()) + y.backward(np.ones((5, 3))) + self.assertTrue((p.grad == np.exp(x)).all()) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/math/gamma.py b/books/PRML/PRML-master-Python/test/nn/math/gamma.py new file mode 100755 index 0000000..3dc8b9d --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/math/gamma.py @@ -0,0 +1,18 @@ +import unittest +from prml import nn + + +class TestGamma(unittest.TestCase): + + def test_gamma(self): + self.assertEqual(24, nn.gamma(5).value) + a = nn.Parameter(2.5) + eps = 1e-5 + b = nn.gamma(a) + b.backward() + num_grad = ((nn.gamma(a + eps) - nn.gamma(a - eps)) / (2 * eps)).value + self.assertAlmostEqual(a.grad, num_grad) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/math/log.py b/books/PRML/PRML-master-Python/test/nn/math/log.py new file mode 100755 index 0000000..ab4fc77 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/math/log.py @@ -0,0 +1,24 @@ +import unittest +import numpy as np +from prml import nn + + +class TestLog(unittest.TestCase): + + def test_log(self): + x = nn.Parameter(2.) + y = nn.log(x) + self.assertEqual(y.value, np.log(2)) + y.backward() + self.assertEqual(x.grad, 0.5) + + x = np.random.rand(4, 6) + p = nn.Parameter(x) + y = nn.log(p) + self.assertTrue((y.value == np.log(x)).all()) + y.backward(np.ones((4, 6))) + self.assertTrue((p.grad == 1 / x).all()) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/math/matmul.py b/books/PRML/PRML-master-Python/test/nn/math/matmul.py new file mode 100755 index 0000000..ddbc41b --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/math/matmul.py @@ -0,0 +1,26 @@ +import unittest +import numpy as np +from prml import nn + + +class TestMatMul(unittest.TestCase): + + def test_matmul(self): + x = np.random.rand(10, 3) + y = np.random.rand(3, 5) + g = np.random.rand(10, 5) + xp = nn.Parameter(x) + z = xp @ y + self.assertTrue((z.value == x @ y).all()) + z.backward(g) + self.assertTrue((xp.grad == g @ y.T).all()) + + yp = nn.Parameter(y) + z = x @ yp + self.assertTrue((z.value == x @ y).all()) + z.backward(g) + self.assertTrue((yp.grad == x.T @ g).all()) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/math/mean.py b/books/PRML/PRML-master-Python/test/nn/math/mean.py new file mode 100755 index 0000000..ca862e6 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/math/mean.py @@ -0,0 +1,25 @@ +import unittest +import numpy as np +from prml import nn + + +class TestMean(unittest.TestCase): + + def test_mean(self): + x = np.random.rand(5, 1, 2) + xp = nn.Parameter(x) + z = xp.mean() + self.assertEqual(z.value, x.mean()) + z.backward() + self.assertTrue((xp.grad == np.ones((5, 1, 2)) / 10).all()) + xp.cleargrad() + + z = xp.mean(axis=0, keepdims=True) + self.assertEqual(z.shape, (1, 1, 2)) + self.assertTrue((z.value == x.mean(axis=0, keepdims=True)).all()) + z.backward(np.ones((1, 1, 2))) + self.assertTrue((xp.grad == np.ones((5, 1, 2)) / 5).all()) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/math/multiply.py b/books/PRML/PRML-master-Python/test/nn/math/multiply.py new file mode 100755 index 0000000..06a7632 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/math/multiply.py @@ -0,0 +1,25 @@ +import unittest +import numpy as np +from prml import nn + + +class TestMultiply(unittest.TestCase): + + def test_multiply(self): + x = nn.Parameter(2) + y = x * 5 + self.assertEqual(y.value, 10) + y.backward() + self.assertEqual(x.grad, 5) + + x = np.random.rand(5, 4) + y = np.random.rand(4) + yp = nn.Parameter(y) + z = x * yp + self.assertTrue((z.value == x * y).all()) + z.backward(np.ones((5, 4))) + self.assertTrue((yp.grad == x.sum(axis=0)).all()) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/math/negative.py b/books/PRML/PRML-master-Python/test/nn/math/negative.py new file mode 100755 index 0000000..196d268 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/math/negative.py @@ -0,0 +1,24 @@ +import unittest +import numpy as np +from prml import nn + + +class TestNegative(unittest.TestCase): + + def test_negative(self): + x = nn.Parameter(2.) + y = -x + self.assertEqual(y.value, -2) + y.backward() + self.assertEqual(x.grad, -1) + + x = np.random.rand(2, 3) + xp = nn.Parameter(x) + y = -xp + self.assertTrue((y.value == -x).all()) + y.backward(np.ones((2, 3))) + self.assertTrue((xp.grad == -np.ones((2, 3))).all()) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/math/power.py b/books/PRML/PRML-master-Python/test/nn/math/power.py new file mode 100755 index 0000000..1b5f379 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/math/power.py @@ -0,0 +1,24 @@ +import unittest +import numpy as np +from prml import nn + + +class TestPower(unittest.TestCase): + + def test_power(self): + x = nn.Parameter(2.) + y = 2 ** x + self.assertEqual(y.value, 4) + y.backward() + self.assertEqual(x.grad, 4 * np.log(2)) + + x = np.random.rand(10, 2) + xp = nn.Parameter(x) + y = xp ** 3 + self.assertTrue((y.value == x ** 3).all()) + y.backward(np.ones((10, 2))) + self.assertTrue(np.allclose(xp.grad, 3 * x ** 2)) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/math/sqrt.py b/books/PRML/PRML-master-Python/test/nn/math/sqrt.py new file mode 100755 index 0000000..472cc8f --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/math/sqrt.py @@ -0,0 +1,17 @@ +import unittest +import numpy as np +from prml import nn + + +class TestSqrt(unittest.TestCase): + + def test_sqrt(self): + x = nn.Parameter(2.) + y = nn.sqrt(x) + self.assertEqual(y.value, np.sqrt(2)) + y.backward() + self.assertEqual(x.grad, 0.5 / np.sqrt(2)) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/math/square.py b/books/PRML/PRML-master-Python/test/nn/math/square.py new file mode 100755 index 0000000..66806a3 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/math/square.py @@ -0,0 +1,17 @@ +import unittest +import numpy as np +from prml import nn + + +class TestSqrt(unittest.TestCase): + + def test_sqrt(self): + x = nn.Parameter(2.) + y = nn.square(x) + self.assertEqual(y.value, 4) + y.backward() + self.assertEqual(x.grad, 4) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/math/subtract.py b/books/PRML/PRML-master-Python/test/nn/math/subtract.py new file mode 100755 index 0000000..9b09213 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/math/subtract.py @@ -0,0 +1,25 @@ +import unittest +import numpy as np +from prml import nn + + +class TestSubtract(unittest.TestCase): + + def test_forward_backward(self): + x = nn.Parameter(2) + z = x - 5 + self.assertEqual(z.value, -3) + z.backward() + self.assertEqual(x.grad, 1) + + x = np.random.rand(5, 4) + y = np.random.rand(4) + p = nn.Parameter(y) + z = x - p + self.assertTrue((z.value == x - y).all()) + z.backward(np.ones((5, 4))) + self.assertTrue((p.grad == -np.ones(4) * 5).all()) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/math/sum.py b/books/PRML/PRML-master-Python/test/nn/math/sum.py new file mode 100755 index 0000000..7c7b2ea --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/math/sum.py @@ -0,0 +1,25 @@ +import unittest +import numpy as np +from prml import nn + + +class TestSum(unittest.TestCase): + + def test_sum(self): + x = np.random.rand(5, 1, 2) + xp = nn.Parameter(x) + z = xp.sum() + self.assertEqual(z.value, x.sum()) + z.backward() + self.assertTrue((xp.grad == np.ones((5, 1, 2))).all()) + xp.cleargrad() + + z = xp.sum(axis=0, keepdims=True) + self.assertEqual(z.shape, (1, 1, 2)) + self.assertTrue((z.value == x.sum(axis=0, keepdims=True)).all()) + z.backward(np.ones((1, 1, 2))) + self.assertTrue((xp.grad == np.ones((5, 1, 2))).all()) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/nonlinear/__init__.py b/books/PRML/PRML-master-Python/test/nn/nonlinear/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/books/PRML/PRML-master-Python/test/nn/nonlinear/sigmoid.py b/books/PRML/PRML-master-Python/test/nn/nonlinear/sigmoid.py new file mode 100755 index 0000000..2ddfddc --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/nonlinear/sigmoid.py @@ -0,0 +1,12 @@ +import unittest +from prml import nn + + +class TestSigmoid(unittest.TestCase): + + def test_sigmoid(self): + self.assertEqual(nn.sigmoid(0).value, 0.5) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/nonlinear/softmax.py b/books/PRML/PRML-master-Python/test/nn/nonlinear/softmax.py new file mode 100755 index 0000000..cd1439b --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/nonlinear/softmax.py @@ -0,0 +1,13 @@ +import unittest +import numpy as np +from prml import nn + + +class TestSoftmax(unittest.TestCase): + + def test_softmax(self): + self.assertTrue(np.allclose(nn.softmax(np.ones(4)).value, 0.25)) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/nonlinear/softplus.py b/books/PRML/PRML-master-Python/test/nn/nonlinear/softplus.py new file mode 100755 index 0000000..7f8671f --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/nonlinear/softplus.py @@ -0,0 +1,13 @@ +import unittest +import numpy as np +from prml import nn + + +class TestSoftplus(unittest.TestCase): + + def test_softplus(self): + self.assertEqual(nn.softplus(0).value, np.log(2)) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/nonlinear/tanh.py b/books/PRML/PRML-master-Python/test/nn/nonlinear/tanh.py new file mode 100755 index 0000000..d4b2c68 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/nonlinear/tanh.py @@ -0,0 +1,12 @@ +import unittest +from prml import nn + + +class TestTanh(unittest.TestCase): + + def test_tanh(self): + self.assertEqual(nn.tanh(0).value, 0) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/random/__init__.py b/books/PRML/PRML-master-Python/test/nn/random/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/books/PRML/PRML-master-Python/test/nn/random/bernoulli.py b/books/PRML/PRML-master-Python/test/nn/random/bernoulli.py new file mode 100755 index 0000000..3fc285d --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/random/bernoulli.py @@ -0,0 +1,21 @@ +import unittest +import numpy as np +from prml import nn + + +class TestBernoulli(unittest.TestCase): + + def test_bernoulli(self): + np.random.seed(1234) + obs = np.random.choice(2, 1000, p=[0.1, 0.9]) + a = nn.Parameter(0) + for _ in range(100): + a.cleargrad() + x = nn.random.Bernoulli(logit=a, data=obs) + x.log_pdf().sum().backward() + a.value += a.grad * 0.01 + self.assertAlmostEqual(x.mu.value, np.mean(obs)) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/random/categorical.py b/books/PRML/PRML-master-Python/test/nn/random/categorical.py new file mode 100755 index 0000000..e6b1ddd --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/random/categorical.py @@ -0,0 +1,22 @@ +import unittest +import numpy as np +from prml import nn + + +class TestCategorical(unittest.TestCase): + + def test_categorical(self): + np.random.seed(1234) + obs = np.random.choice(3, 100, p=[0.2, 0.3, 0.5]) + obs = np.eye(3)[obs] + a = nn.Parameter(np.zeros(3)) + for _ in range(100): + a.cleargrad() + x = nn.random.Categorical(logit=a, data=obs) + x.log_pdf().sum().backward() + a.value += 0.01 * a.grad + self.assertTrue(np.allclose(np.mean(obs, 0), x.mu.value)) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/random/cauchy.py b/books/PRML/PRML-master-Python/test/nn/random/cauchy.py new file mode 100755 index 0000000..18d0648 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/random/cauchy.py @@ -0,0 +1,26 @@ +import unittest +import numpy as np +from prml import nn + + +class TestCauchy(unittest.TestCase): + + def test_cauchy(self): + np.random.seed(1234) + obs = np.random.standard_cauchy(size=10000) + obs = 2 * obs + 1 + loc = nn.Parameter(0) + s = nn.Parameter(1) + for _ in range(100): + loc.cleargrad() + s.cleargrad() + x = nn.random.Cauchy(loc, nn.softplus(s), data=obs) + x.log_pdf().sum().backward() + loc.value += loc.grad * 0.001 + s.value += s.grad * 0.001 + self.assertAlmostEqual(x.loc.value, 1, places=1) + self.assertAlmostEqual(x.scale.value, 2, places=1) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/random/dirichlet.py b/books/PRML/PRML-master-Python/test/nn/random/dirichlet.py new file mode 100755 index 0000000..c85c82f --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/random/dirichlet.py @@ -0,0 +1,28 @@ +import unittest +import numpy as np +from prml import nn + + +class TestDirichlet(unittest.TestCase): + + def test_dirichlet(self): + np.random.seed(1234) + obs = np.random.choice(3, 100, p=[0.2, 0.3, 0.5]) + obs = np.eye(3)[obs] + a = nn.Parameter(np.zeros(3)) + for _ in range(100): + a.cleargrad() + mu = nn.softmax(a) + d = nn.random.Dirichlet(np.ones(3) * 10, data=mu) + x = nn.random.Categorical(mu, data=obs) + log_posterior = x.log_pdf().sum() + d.log_pdf().sum() + log_posterior.backward() + a.value += 0.01 * a.grad + + count = np.sum(obs, 0) + 10 + p = count / count.sum(keepdims=True) + self.assertTrue(np.allclose(p, mu.value, 1e-2, 1e-2)) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/random/exponential.py b/books/PRML/PRML-master-Python/test/nn/random/exponential.py new file mode 100755 index 0000000..362fe05 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/random/exponential.py @@ -0,0 +1,21 @@ +import unittest +import numpy as np +from prml import nn + + +class TestExponential(unittest.TestCase): + + def test_exponential(self): + np.random.seed(1234) + obs = np.random.gamma(1, 1 / 0.5, size=1000) + a = nn.Parameter(0) + for _ in range(100): + a.cleargrad() + x = nn.random.Exponential(nn.softplus(a), data=obs) + x.log_pdf().sum().backward() + a.value += a.grad * 0.001 + self.assertAlmostEqual(x.rate.value, 0.475135117) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/random/gaussian.py b/books/PRML/PRML-master-Python/test/nn/random/gaussian.py new file mode 100755 index 0000000..fcff796 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/random/gaussian.py @@ -0,0 +1,14 @@ +import unittest +import numpy as np +from prml import nn + + +class TestGaussian(unittest.TestCase): + + def test_gaussian(self): + self.assertRaises(ValueError, nn.random.Gaussian, 0, -1) + self.assertRaises(ValueError, nn.random.Gaussian, 0, np.array([1, -1])) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/random/laplace.py b/books/PRML/PRML-master-Python/test/nn/random/laplace.py new file mode 100755 index 0000000..e99536a --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/random/laplace.py @@ -0,0 +1,24 @@ +import unittest +import numpy as np +from prml import nn + + +class TestLaplace(unittest.TestCase): + + def test_laplace(self): + obs = np.arange(3) + loc = nn.Parameter(0) + s = nn.Parameter(1) + for _ in range(1000): + loc.cleargrad() + s.cleargrad() + x = nn.random.Laplace(loc, nn.softplus(s), data=obs) + x.log_pdf().sum().backward() + loc.value += loc.grad * 0.01 + s.value += s.grad * 0.01 + self.assertAlmostEqual(x.loc.value, np.median(obs), places=1) + self.assertAlmostEqual(x.scale.value, np.mean(np.abs(obs - x.loc.value)), places=1) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/nn/random/multivariate_gaussian.py b/books/PRML/PRML-master-Python/test/nn/random/multivariate_gaussian.py new file mode 100755 index 0000000..4d9499f --- /dev/null +++ b/books/PRML/PRML-master-Python/test/nn/random/multivariate_gaussian.py @@ -0,0 +1,33 @@ +import unittest +import numpy as np +from prml import nn + + +class TestMultivariateGaussian(unittest.TestCase): + + def test_multivariate_gaussian(self): + self.assertRaises(ValueError, nn.random.MultivariateGaussian, np.zeros(2), np.eye(3)) + self.assertRaises(ValueError, nn.random.MultivariateGaussian, np.zeros(2), np.eye(2) * -1) + + x_train = np.array([ + [1., 1.], + [1., -1], + [-1., 1.], + [-1., -2.] + ]) + mu = nn.Parameter(np.ones(2)) + cov = nn.Parameter(np.eye(2) * 2) + for _ in range(1000): + mu.cleargrad() + cov.cleargrad() + x = nn.random.MultivariateGaussian(mu, cov + cov.transpose(), data=x_train) + log_likelihood = x.log_pdf().sum() + log_likelihood.backward() + mu.value += 0.1 * mu.grad + cov.value += 0.1 * cov.grad + self.assertTrue(np.allclose(mu.value, x_train.mean(axis=0))) + self.assertTrue(np.allclose(np.cov(x_train, rowvar=False, bias=True), x.cov.value)) + + +if __name__ == '__main__': + unittest.main() diff --git a/books/PRML/PRML-master-Python/test/test_bayesnet/__init__.py b/books/PRML/PRML-master-Python/test/test_bayesnet/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/books/PRML/PRML-master-Python/test/test_bayesnet/test_discrete.py b/books/PRML/PRML-master-Python/test/test_bayesnet/test_discrete.py new file mode 100755 index 0000000..7b0e3b8 --- /dev/null +++ b/books/PRML/PRML-master-Python/test/test_bayesnet/test_discrete.py @@ -0,0 +1,82 @@ +import unittest +import numpy as np +from prml import bayesnet as bn + + +class TestDiscrete(unittest.TestCase): + + def test_discrete(self): + a = bn.discrete([0.2, 0.8]) + b = bn.discrete([[0.1, 0.2], [0.9, 0.8]], a) + self.assertTrue(np.allclose(b.proba, [0.18, 0.82])) + a.observe(0) + self.assertTrue(np.allclose(b.proba, [0.1, 0.9])) + + a = bn.discrete([0.1, 0.9]) + b = bn.discrete([[0.7, 0.2], [0.3, 0.8]], a) + c = bn.discrete([[0.8, 0.4], [0.2, 0.6]], b) + self.assertTrue(np.allclose(a.proba, [0.1, 0.9])) + self.assertTrue(np.allclose(b.proba, [0.25, 0.75])) + self.assertTrue(np.allclose(c.proba, [0.5, 0.5])) + c.observe(0) + self.assertTrue(np.allclose(a.proba, [0.136, 0.864])) + self.assertTrue(np.allclose(b.proba, [0.4, 0.6])) + self.assertTrue(np.allclose(c.proba, [1, 0])) + + a = bn.discrete([0.1, 0.9], name="p(a)") + b = bn.discrete([0.1, 0.9], name="p(b)") + c = bn.discrete( + [[[0.9, 0.8], + [0.8, 0.2]], + [[0.1, 0.2], + [0.2, 0.8]]], + a, b, name="p(c|a,b)" + ) + c.observe(0) + self.assertTrue(np.allclose(a.proba, [0.25714286, 0.74285714])) + b.observe(0) + self.assertTrue(np.allclose(a.proba, [0.11111111, 0.88888888])) + + a = bn.discrete([0.1, 0.9], name="p(a)") + b = bn.discrete([0.1, 0.9], name="p(b)") + c = bn.discrete( + [[[0.9, 0.8], + [0.8, 0.2]], + [[0.1, 0.2], + [0.2, 0.8]]], + a, b, name="p(c|a,b)" + ) + c.observe(0, proprange=0) + self.assertTrue(np.allclose(a.proba, [0.1, 0.9])) + b.observe(0, proprange=1) + self.assertTrue(np.allclose(a.proba, [0.1, 0.9])) + b.send_message(proprange=2) + self.assertTrue(np.allclose(a.proba, [0.11111111, 0.88888888])) + a.send_message() + c.send_message() + self.assertTrue(np.allclose(a.proba, [0.11111111, 0.88888888]), a.message_from) + + a = bn.discrete([0.1, 0.9], name="p(a)") + b = bn.discrete([0.1, 0.9], name="p(b)") + c = bn.discrete( + [[[0.9, 0.8], + [0.8, 0.2]], + [[0.1, 0.2], + [0.2, 0.8]]], + a, b, name="p(c|a,b)" + ) + b.observe(0) + self.assertTrue(np.allclose(a.proba, [0.1, 0.9])) + c.send_message() + self.assertTrue(np.allclose(a.proba, [0.1, 0.9]), a.message_from) + + def test_joint_discrete(self): + a = bn.DiscreteVariable(2) + b = bn.DiscreteVariable(2) + bn.discrete([[0.1, 0.2], [0.3, 0.4]], out=[a, b]) + b.observe(1) + self.assertTrue(np.allclose(a.proba, [1/3, 2/3])) + + +if __name__ == "__main__": + unittest.main() diff --git a/books/PRML/PRMLT-master-MATLAB/.gitignore b/books/PRML/PRMLT-master-MATLAB/.gitignore new file mode 100755 index 0000000..78a5b54 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/.gitignore @@ -0,0 +1,3 @@ +reference/* +*.m~ +*.asv \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/README.md b/books/PRML/PRMLT-master-MATLAB/README.md new file mode 100755 index 0000000..73840b2 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/README.md @@ -0,0 +1,37 @@ +Introduction +------- +This package is a Matlab implementation of the algorithms described in the classical machine learning textbook: +Pattern Recognition and Machine Learning by C. Bishop ([PRML](http://research.microsoft.com/en-us/um/people/cmbishop/prml/)). + +Note: this package requires Matlab **R2016b** or latter, since it utilizes a new syntax of Matlab called [Implicit expansion](https://cn.mathworks.com/help/matlab/release-notes.html?rntext=implicit+expansion&startrelease=R2016b&endrelease=R2016b&groupby=release&sortby=descending) (a.k.a. broadcasting in Python). + +Description +------- +While developing this package, I stick to following principles + +* Succinct: The code is extremely terse. Minimizing the number of lines is one of the primal goals. As a result, the core of the algorithms can be easily spot. +* Efficient: Many tricks for making Matlab scripts fast were applied (eg. vectorization and matrix factorization). Many functions are even comparable with C implementations. Usually, functions in this package are orders faster than Matlab builtin ones which provide the same functionality (eg. kmeans). If anyone have found any Matlab implementation that is faster than mine, I am happy to further optimize. +* Robust: Many tricks for numerical stability are applied, such as probability computation in log scale and square root matrix update to enforce matrix symmetry, etc. +* Readable: The code is heavily commented. Reference formulas in PRML book are indicated for corresponding code lines. Symbols are in sync with the book. +* Practical: The package is designed not only to be easily read, but also to be easily used to facilitate ML research. Many functions in this package are already widely used (see [Matlab file exchange](http://www.mathworks.com/matlabcentral/fileexchange/?term=authorid%3A49739)). + +Installation +------- +1. Download the package to your local path (e.g. PRMLT/) by running: `git clone https://github.com/PRML/PRMLT.git`. + +2. Run Matlab and navigate to PRMLT/, then run the init.m script. + +3. Try demos in PRMLT/demo directory to verify installation correctness. Enjoy! + +FeedBack +------- +If you found any bug or have any suggestion, please do file issues. I am graceful for any feedback and will do my best to improve this package. + +License +------- +Currently Released Under GPLv3 + + +Contact +------- +sth4nth at gmail dot com diff --git a/books/PRML/PRMLT-master-MATLAB/chapter01/condEntropy.m b/books/PRML/PRMLT-master-MATLAB/chapter01/condEntropy.m new file mode 100755 index 0000000..a3469de --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter01/condEntropy.m @@ -0,0 +1,29 @@ +function z = condEntropy (x, y) +% Compute conditional entropy z=H(x|y) of two discrete variables x and y. +% Input: +% x, y: two integer vector of the same length +% Output: +% z: conditional entropy z=H(x|y) +% Written by Mo Chen (sth4nth@gmail.com). +assert(numel(x) == numel(y)); +n = numel(x); +x = reshape(x,1,n); +y = reshape(y,1,n); + +l = min(min(x),min(y)); +x = x-l+1; +y = y-l+1; +k = max(max(x),max(y)); + +idx = 1:n; +Mx = sparse(idx,x,1,n,k,n); +My = sparse(idx,y,1,n,k,n); +Pxy = nonzeros(Mx'*My/n); %joint distribution of x and y +Hxy = -dot(Pxy,log2(Pxy)); + +Py = nonzeros(mean(My,1)); +Hy = -dot(Py,log2(Py)); + +% conditional entropy H(x|y) +z = Hxy-Hy; +z = max(0,z); diff --git a/books/PRML/PRMLT-master-MATLAB/chapter01/entropy.m b/books/PRML/PRMLT-master-MATLAB/chapter01/entropy.m new file mode 100755 index 0000000..c59c7bd --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter01/entropy.m @@ -0,0 +1,12 @@ +function z = entropy(x) +% Compute entropy z=H(x) of a discrete variable x. +% Input: +% x: a integer vectors +% Output: +% z: entropy z=H(x) +% Written by Mo Chen (sth4nth@gmail.com). +n = numel(x); +[~,~,x] = unique(x); +Px = accumarray(x, 1)/n; +Hx = -dot(Px,log2(Px)); +z = max(0,Hx); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter01/jointEntropy.m b/books/PRML/PRMLT-master-MATLAB/chapter01/jointEntropy.m new file mode 100755 index 0000000..5f780fb --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter01/jointEntropy.m @@ -0,0 +1,22 @@ +function z = jointEntropy(x, y) +% Compute joint entropy z=H(x,y) of two discrete variables x and y. +% Input: +% x, y: two integer vector of the same length +% Output: +% z: joint entroy z=H(x,y) +% Written by Mo Chen (sth4nth@gmail.com). +assert(numel(x) == numel(y)); +n = numel(x); +x = reshape(x,1,n); +y = reshape(y,1,n); + +l = min(min(x),min(y)); +x = x-l+1; +y = y-l+1; +k = max(max(x),max(y)); + +idx = 1:n; +p = nonzeros(sparse(idx,x,1,n,k,n)'*sparse(idx,y,1,n,k,n)/n); %joint distribution of x and y + +z = -dot(p,log2(p)); +z = max(0,z); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter01/mutInfo.m b/books/PRML/PRMLT-master-MATLAB/chapter01/mutInfo.m new file mode 100755 index 0000000..8adb344 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter01/mutInfo.m @@ -0,0 +1,32 @@ +function z = mutInfo(x, y) +% Compute mutual information I(x,y) of two discrete variables x and y. +% Input: +% x, y: two integer vector of the same length +% Output: +% z: mutual information z=I(x,y) +% Written by Mo Chen (sth4nth@gmail.com). +assert(numel(x) == numel(y)); +n = numel(x); +x = reshape(x,1,n); +y = reshape(y,1,n); + +l = min(min(x),min(y)); +x = x-l+1; +y = y-l+1; +k = max(max(x),max(y)); + +idx = 1:n; +Mx = sparse(idx,x,1,n,k,n); +My = sparse(idx,y,1,n,k,n); +Pxy = nonzeros(Mx'*My/n); %joint distribution of x and y +Hxy = -dot(Pxy,log2(Pxy)); + +Px = nonzeros(mean(Mx,1)); +Py = nonzeros(mean(My,1)); + +% entropy of Py and Px +Hx = -dot(Px,log2(Px)); +Hy = -dot(Py,log2(Py)); +% mutual information +z = Hx+Hy-Hxy; +z = max(0,z); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter01/nmi.m b/books/PRML/PRMLT-master-MATLAB/chapter01/nmi.m new file mode 100755 index 0000000..ba49871 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter01/nmi.m @@ -0,0 +1,39 @@ +function z = nmi(x, y) +% Compute normalized mutual information I(x,y)/sqrt(H(x)*H(y)) of two discrete variables x and y. +% Input: +% x, y: two integer vector of the same length +% Ouput: +% z: normalized mutual information z=I(x,y)/sqrt(H(x)*H(y)) +% Written by Mo Chen (sth4nth@gmail.com). +assert(numel(x) == numel(y)); +n = numel(x); +x = reshape(x,1,n); +y = reshape(y,1,n); + +l = min(min(x),min(y)); +x = x-l+1; +y = y-l+1; +k = max(max(x),max(y)); + +idx = 1:n; +Mx = sparse(idx,x,1,n,k,n); +My = sparse(idx,y,1,n,k,n); +Pxy = nonzeros(Mx'*My/n); %joint distribution of x and y +Hxy = -dot(Pxy,log2(Pxy)); + + +% hacking, to elimative the 0log0 issue +Px = nonzeros(mean(Mx,1)); +Py = nonzeros(mean(My,1)); + +% entropy of Py and Px +Hx = -dot(Px,log2(Px)); +Hy = -dot(Py,log2(Py)); + +% mutual information +MI = Hx + Hy - Hxy; + +% normalized mutual information +z = sqrt((MI/Hx)*(MI/Hy)); +z = max(0,z); + diff --git a/books/PRML/PRMLT-master-MATLAB/chapter01/nvi.m b/books/PRML/PRMLT-master-MATLAB/chapter01/nvi.m new file mode 100755 index 0000000..1373b9d --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter01/nvi.m @@ -0,0 +1,33 @@ +function z = nvi(x, y) +% Compute normalized variation information z=(1-I(x,y)/H(x,y)) of two discrete variables x and y. +% Input: +% x, y: two integer vector of the same length +% Output: +% z: normalized variation information z=(1-I(x,y)/H(x,y)) +% Written by Mo Chen (sth4nth@gmail.com). +assert(numel(x) == numel(y)); +n = numel(x); +x = reshape(x,1,n); +y = reshape(y,1,n); + +l = min(min(x),min(y)); +x = x-l+1; +y = y-l+1; +k = max(max(x),max(y)); + +idx = 1:n; +Mx = sparse(idx,x,1,n,k,n); +My = sparse(idx,y,1,n,k,n); +Pxy = nonzeros(Mx'*My/n); %joint distribution of x and y +Hxy = -dot(Pxy,log2(Pxy)); + +Px = nonzeros(mean(Mx,1)); +Py = nonzeros(mean(My,1)); + +% entropy of Py and Px +Hx = -dot(Px,log2(Px)); +Hy = -dot(Py,log2(Py)); + +% nvi +z = 2-(Hx+Hy)/Hxy; +z = max(0,z); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter01/relatEntropy.m b/books/PRML/PRMLT-master-MATLAB/chapter01/relatEntropy.m new file mode 100755 index 0000000..b6e2997 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter01/relatEntropy.m @@ -0,0 +1,25 @@ +function z = relatEntropy (x, y) +% Compute relative entropy (a.k.a KL divergence) z=KL(p(x)||p(y)) of two discrete variables x and y. +% Input: +% x, y: two integer vector of the same length +% Output: +% z: relative entropy (a.k.a KL divergence) z=KL(p(x)||p(y)) +% Written by Mo Chen (sth4nth@gmail.com). +assert(numel(x) == numel(y)); +n = numel(x); +x = reshape(x,1,n); +y = reshape(y,1,n); + +l = min(min(x),min(y)); +x = x-l+1; +y = y-l+1; +k = max(max(x),max(y)); + +idx = 1:n; +Mx = sparse(idx,x,1,n,k,n); +My = sparse(idx,y,1,n,k,n); +Px = nonzeros(mean(Mx,1)); +Py = nonzeros(mean(My,1)); + +z = -dot(Px,log2(Py)-log2(Px)); +z = max(0,z); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter02/logDirichlet.m b/books/PRML/PRMLT-master-MATLAB/chapter02/logDirichlet.m new file mode 100755 index 0000000..9f5dab9 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter02/logDirichlet.m @@ -0,0 +1,16 @@ +function y = logDirichlet(X, a) +% Compute log pdf of a Dirichlet distribution. +% Input: +% X: d x n data matrix, each column sums to one (sum(X,1)==ones(1,n) && X>=0) +% a: d x k parameter of Dirichlet +% y: k x n probability density +% Output: +% y: k x n probability density in logrithm scale y=log p(x) +% Written by Mo Chen (sth4nth@gmail.com). +X = bsxfun(@times,X,1./sum(X,1)); +if size(a,1) == 1 + a = repmat(a,size(X,1),1); +end +c = gammaln(sum(a,1))-sum(gammaln(a),1); +g = (a-1)'*log(X); +y = bsxfun(@plus,g,c'); diff --git a/books/PRML/PRMLT-master-MATLAB/chapter02/logGauss.m b/books/PRML/PRMLT-master-MATLAB/chapter02/logGauss.m new file mode 100755 index 0000000..912e1c2 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter02/logGauss.m @@ -0,0 +1,19 @@ +function y = logGauss(X, mu, sigma) +% Compute log pdf of a Gaussian distribution. +% Input: +% X: d x n data matrix +% mu: d x 1 mean vector of Gaussian +% sigma: d x d covariance matrix of Gaussian +% Output: +% y: 1 x n probability density in logrithm scale y=log p(x) +% Written by Mo Chen (sth4nth@gmail.com). +d = size(X,1); +X = X-mu; +[U,p]= chol(sigma); +if p ~= 0 + error('ERROR: sigma is not PD.'); +end +Q = U'\X; +q = dot(Q,Q,1); % quadratic term (M distance) +c = d*log(2*pi)+2*sum(log(diag(U))); % normalization constant +y = -(c+q)/2; diff --git a/books/PRML/PRMLT-master-MATLAB/chapter02/logKde.m b/books/PRML/PRMLT-master-MATLAB/chapter02/logKde.m new file mode 100755 index 0000000..98c6079 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter02/logKde.m @@ -0,0 +1,10 @@ +function z = logKde (X, Y, sigma) +% Compute log pdf of kernel density estimator. +% Input: +% X: d x n data matrix to be evaluate +% Y: d x k data matrix served as database +% Output: +% z: probability density in logrithm scale z=log p(x|y) +% Written by Mo Chen (sth4nth@gmail.com). +D = dot(X,X,1)+dot(Y,Y,1)'-2*(Y'*X); +z = logsumexp(D/(-2*sigma^2),1)-0.5*log(2*pi)-log(sigma*size(Y,2),1); diff --git a/books/PRML/PRMLT-master-MATLAB/chapter02/logMn.m b/books/PRML/PRMLT-master-MATLAB/chapter02/logMn.m new file mode 100755 index 0000000..cb1db8f --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter02/logMn.m @@ -0,0 +1,9 @@ +function z = logMn(x, p) +% Compute log pdf of a multinomial distribution. +% Input: +% x: d x 1 integer vector +% p: d x 1 probability +% Output: +% z: probability density in logrithm scale z=log p(x) +% Written by Mo Chen (sth4nth@gmail.com). +z = gammaln(sum(x)+1)-sum(gammaln(x+1))+dot(x,log(p)); diff --git a/books/PRML/PRMLT-master-MATLAB/chapter02/logMvGamma.m b/books/PRML/PRMLT-master-MATLAB/chapter02/logMvGamma.m new file mode 100755 index 0000000..d33ed47 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter02/logMvGamma.m @@ -0,0 +1,13 @@ +function y = logMvGamma(x, d) +% Compute logarithm multivariate Gamma function +% which is used in the probability density function of the Wishart and inverse Wishart distributions. +% Gamma_d(x) = pi^(d(d-1)/4) \prod_(j=1)^d Gamma(x+(1-j)/2) +% log(Gamma_d(x)) = d(d-1)/4 log(pi) + \sum_(j=1)^d log(Gamma(x+(1-j)/2)) +% Input: +% x: m x n data matrix +% d: dimension +% Output: +% y: m x n logarithm multivariate Gamma +% Written by Michael Chen (sth4nth@gmail.com). +y = d*(d-1)/4*log(pi)+sum(gammaln(x(:)+(1-(1:d))/2),2); +y = reshape(y,size(x)); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter02/logSt.m b/books/PRML/PRMLT-master-MATLAB/chapter02/logSt.m new file mode 100755 index 0000000..aa8d82a --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter02/logSt.m @@ -0,0 +1,40 @@ +function y = logSt(X, mu, sigma, v) +% Compute log pdf of a Student's t distribution. +% Input: +% X: d x n data matrix +% mu: mean +% sigma: variance +% v: degree of freedom +% Output: +% y: probability density in logrithm scale y=log p(x) +% Written by mo Chen (sth4nth@gmail.com). +[d,k] = size(mu); + +if size(sigma,1)==d && size(sigma,2)==d && k==1 + [R,p]= chol(sigma); + if p ~= 0 + error('ERROR: sigma is not SPD.'); + end + X = bsxfun(@minus,X,mu); + Q = R'\X; + q = dot(Q,Q,1); % quadratic term (M distance) + o = -log(1+q/v)*((v+d)/2); + c = gammaln((v+d)/2)-gammaln(v/2)-(d*log(v*pi)+2*sum(log(diag(R))))/2; + y = c+o; +elseif size(sigma,1)==d && size(sigma,2)==k + lambda = 1./sigma; + ml = mu.*lambda; + q = bsxfun(@plus,X'.^2*lambda-2*X'*ml,dot(mu,ml,1)); % M distance + o = bsxfun(@times,log(1+bsxfun(@times,q,1./v)),-(v+d)/2); + c = gammaln((v+d)/2)-gammaln(v/2)-(d*log(pi*v)+sum(log(sigma),1))/2; + y = bsxfun(@plus,o,c); +elseif size(sigma,1)==1 && size(sigma,2)==k + X2 = repmat(dot(X,X,1)',1,k); + D = bsxfun(@plus,X2-2*X'*mu,dot(mu,mu,1)); + q = bsxfun(@times,D,1./sigma); % M distance + o = bsxfun(@times,log(1+bsxfun(@times,q,1./v)),-(v+d)/2); + c = gammaln((v+d)/2)-gammaln(v/2)-d*log(pi*v.*sigma)/2; + y = bsxfun(@plus,o,c); +else + error('Parameters are mismatched.'); +end diff --git a/books/PRML/PRMLT-master-MATLAB/chapter02/logVmf.m b/books/PRML/PRMLT-master-MATLAB/chapter02/logVmf.m new file mode 100755 index 0000000..987362b --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter02/logVmf.m @@ -0,0 +1,13 @@ +function y = logVmf(X, mu, kappa) +% Compute log pdf of a von Mises-Fisher distribution. +% Input: +% X: d x n data matrix +% mu: d x k mean +% kappa: 1 x k variance +% Output: +% y: k x n probability density in logrithm scale y=log p(x) +% Written by Mo Chen (sth4nth@gmail.com). +d = size(X,1); +c = (d/2-1)*log(kappa)-(d/2)*log(2*pi)-logbesseli(d/2-1,kappa); +q = bsxfun(@times,mu,kappa)'*X; +y = bsxfun(@plus,q,c'); diff --git a/books/PRML/PRMLT-master-MATLAB/chapter02/logWishart.m b/books/PRML/PRMLT-master-MATLAB/chapter02/logWishart.m new file mode 100755 index 0000000..06b5323 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter02/logWishart.m @@ -0,0 +1,12 @@ +function y = logWishart(Sigma, W, v) +% Compute log pdf of a Wishart distribution. +% Input: +% Sigma: d x d covariance matrix +% W: d x d covariance parameter +% v: degree of freedom +% Output: +% y: probability density in logrithm scale y=log p(Sigma) +% Written by Mo Chen (sth4nth@gmail.com). +d = length(Sigma); +B = -0.5*v*logdet(W)-0.5*v*d*log(2)-logmvgamma(0.5*v,d); +y = B+0.5*(v-d-1)*logdet(Sigma)-0.5*trace(W\Sigma); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter03/linReg.m b/books/PRML/PRMLT-master-MATLAB/chapter03/linReg.m new file mode 100755 index 0000000..821f5af --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter03/linReg.m @@ -0,0 +1,37 @@ +function model = linReg(X, t, lambda) +% Fit linear regression model y=w'x+w0 +% Input: +% X: d x n data +% t: 1 x n response +% lambda: regularization parameter +% Output: +% model: trained model structure +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 3 + lambda = 0; +end +d = size(X,1); +idx = (1:d)'; +dg = sub2ind([d,d],idx,idx); + +xbar = mean(X,2); +tbar = mean(t,2); +X = bsxfun(@minus,X,xbar); +t = bsxfun(@minus,t,tbar); + +XX = X*X'; +XX(dg) = XX(dg)+lambda; % 3.54 XX=inv(S)/beta +% w = XX\(X*t'); +U = chol(XX); +w = U\(U'\(X*t')); % 3.15 & 3.28 +w0 = tbar-dot(w,xbar); % 3.19 + +model.w = w; +model.w0 = w0; +model.xbar = xbar; +%% for probability prediction +beta = 1/mean((t-w'*X).^2); % 3.21 +% alpha = lambda*beta; % lambda=a/b P.153 3.55 +% model.alpha = alpha; +model.beta = beta; +model.U = U; diff --git a/books/PRML/PRMLT-master-MATLAB/chapter03/linRegFp.m b/books/PRML/PRMLT-master-MATLAB/chapter03/linRegFp.m new file mode 100755 index 0000000..1a797b1 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter03/linRegFp.m @@ -0,0 +1,59 @@ +function [model, llh] = linRegFp(X, t, alpha, beta) +% Fit empirical Bayesian linear model with Mackay fixed point method (p.168) +% Input: +% X: d x n data +% t: 1 x n response +% alpha: prior parameter +% beta: prior parameter +% Output: +% model: trained model structure +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 3 + alpha = 0.02; + beta = 0.5; +end +[d,n] = size(X); + +xbar = mean(X,2); +tbar = mean(t,2); + +X = bsxfun(@minus,X,xbar); +t = bsxfun(@minus,t,tbar); + +XX = X*X'; +Xt = X*t'; + + +tol = 1e-4; +maxiter = 200; +llh = -inf(1,maxiter); +for iter = 2:maxiter + A = beta*XX+diag(alpha); % 3.81 3.54 + U = chol(A); + + m = beta*(U\(U'\Xt)); % 3.84 + m2 = dot(m,m); + e = sum((t-m'*X).^2); + + logdetA = 2*sum(log(diag(U))); + llh(iter) = 0.5*(d*log(alpha)+n*log(beta)-alpha*m2-beta*e-logdetA-n*log(2*pi)); % 3.86 + if abs(llh(iter)-llh(iter-1)) < tol*abs(llh(iter-1)); break; end + + V = inv(U); % A=inv(S) + trS = dot(V(:),V(:)); + gamma = d-alpha*trS; % 3.91 9.64 + alpha = gamma/m2; % 3.92 + beta = (n-gamma)/e; % 3.95 + +end +w0 = tbar-dot(m,xbar); + +llh = llh(2:iter); +model.w0 = w0; +model.w = m; +%% optional for bayesian probabilistic prediction purpose +model.alpha = alpha; +model.beta = beta; +model.xbar = xbar; +model.U = U; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter03/linRegPred.m b/books/PRML/PRMLT-master-MATLAB/chapter03/linRegPred.m new file mode 100755 index 0000000..9ddf650 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter03/linRegPred.m @@ -0,0 +1,31 @@ +function [y, sigma, p] = linRegPred(model, X, t) +% Compute linear regression model reponse y = w'*X+w0 and likelihood +% Input: +% model: trained model structure +% X: d x n testing data +% t (optional): 1 x n testing response +% Output: +% y: 1 x n prediction +% sigma: variance +% p: 1 x n likelihood of t +% Written by Mo Chen (sth4nth@gmail.com). +w = model.w; +w0 = model.w0; +y = w'*X+w0; +%% probability prediction +if nargout > 1 + beta = model.beta; + if isfield(model,'U') + U = model.U; % 3.54 + Xo = bsxfun(@minus,X,model.xbar); + XU = U'\Xo; + sigma = sqrt((1+dot(XU,XU,1))/beta); % 3.59 + else + sigma = sqrt(1/beta)*ones(1,size(X,2)); + end +end + +if nargin == 3 && nargout == 3 + p = exp(-0.5*(((t-y)./sigma).^2+log(2*pi))-log(sigma)); +end + diff --git a/books/PRML/PRMLT-master-MATLAB/chapter03/linRnd.m b/books/PRML/PRMLT-master-MATLAB/chapter03/linRnd.m new file mode 100755 index 0000000..fadeaf5 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter03/linRnd.m @@ -0,0 +1,16 @@ +function [X, t] = linRnd(d, n) +% Generate data from a linear model p(t|w,x)=G(w'x+w0,sigma), sigma=sqrt(1/beta) +% where w and w0 are generated from Gauss(0,1), beta is generated from +% Gamma(1,1), X is generated form [0,1]. +% Input: +% d: dimension of data +% n: number of data +% Output: +% X: d x n data matrix +% t: 1 x n response variable +% Written by Mo Chen (sth4nth@gmail.com). +beta = randg; % need statistcs toolbox +X = rand(d,n); +w = randn(d,1); +w0 = randn(1,1); +t = w'*X+w0+randn(1,n)/sqrt(beta); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter04/binPlot.m b/books/PRML/PRMLT-master-MATLAB/chapter04/binPlot.m new file mode 100755 index 0000000..aebfa02 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter04/binPlot.m @@ -0,0 +1,27 @@ +function binPlot(model, X, t) +% Plot binary classification result for 2d data +% Input: +% model: trained model structure +% X: 2 x n data matrix +% t: 1 x n label +% Written by Mo Chen (sth4nth@gmail.com). +assert(size(X,1) == 2); +w = model.w; +xi = min(X,[],2); +xa = max(X,[],2); +[x1,x2] = meshgrid(linspace(xi(1),xa(1)), linspace(xi(2),xa(2))); + +color = 'brgmcyk'; +m = length(color); +figure(gcf); +axis equal +clf; +hold on; +view(2); +for i = 1:max(t) + idc = t==i; + scatter(X(1,idc),X(2,idc),36,color(mod(i-1,m)+1)); +end +y = w(1)*x1+w(2)*x2+w(3); +contour(x1,x2,y,[-0 0]); +hold off; diff --git a/books/PRML/PRMLT-master-MATLAB/chapter04/fda.m b/books/PRML/PRMLT-master-MATLAB/chapter04/fda.m new file mode 100755 index 0000000..8d86f78 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter04/fda.m @@ -0,0 +1,28 @@ +function U = fda(X, t, q) +% Fisher (linear) discriminant analysis +% Input: +% X: d x n data matrix +% t: 1 x n class label +% d: target dimension +% Output: +% U: projection matrix y=U'*x +% Written by Mo Chen (sth4nth@gmail.com). +n = size(X,2); +k = max(t); + +E = sparse(1:n,t,true,n,k,n); % transform label into indicator matrix +nk = full(sum(E)); + +m = mean(X,2); +Xo = bsxfun(@minus,X,m); +St = (Xo*Xo')/n; % 4.43 + +mk = bsxfun(@times,X*E,1./nk); +mo = bsxfun(@minus,mk,m); +mo = bsxfun(@times,mo,sqrt(nk/n)); +Sb = mo*mo'; % 4.46 +% Sw = St-Sb; % 4.45 + +[U,A] = eig(Sb,St,'chol'); +[~,idx] = sort(diag(A),'descend'); +U = U(:,idx(1:q)); diff --git a/books/PRML/PRMLT-master-MATLAB/chapter04/logitBin.m b/books/PRML/PRMLT-master-MATLAB/chapter04/logitBin.m new file mode 100755 index 0000000..80584a9 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter04/logitBin.m @@ -0,0 +1,37 @@ +function [model, llh] = logitBin(X, y, lambda, eta) +% Logistic regression for binary classification optimized by Newton-Raphson method. +% Input: +% X: d x n data matrix +% z: 1 x n label (0/1) +% lambda: regularization parameter +% eta: step size +% Output: +% model: trained model structure +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 4 + eta = 1e-1; +end +if nargin < 3 + lambda = 1e-4; +end +X = [X; ones(1,size(X,2))]; +[d,n] = size(X); +tol = 1e-4; +epoch = 200; +llh = -inf(1,epoch); +h = 2*y-1; +w = rand(d,1); +for t = 2:epoch + a = w'*X; + llh(t) = -(sum(log1pexp(-h.*a))+0.5*lambda*dot(w,w))/n; % 4.89 + if llh(t)-llh(t-1) < tol; break; end + z = sigmoid(a); % 4.87 + g = X*(z-y)'+lambda*w; % 4.96 + r = z.*(1-z); % 4.98 + Xw = bsxfun(@times, X, sqrt(r)); + H = Xw*Xw'+lambda*eye(d); % 4.97 + w = w-eta*(H\g); +end +llh = llh(2:t); +model.w = w; diff --git a/books/PRML/PRMLT-master-MATLAB/chapter04/logitBinPred.m b/books/PRML/PRMLT-master-MATLAB/chapter04/logitBinPred.m new file mode 100755 index 0000000..14cbed9 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter04/logitBinPred.m @@ -0,0 +1,14 @@ +function [y, p] = logitBinPred(model, X) +% Prediction of binary logistic regression model +% Input: +% model: trained model structure +% X: d x n testing data +% Output: +% y: 1 x n predict label (0/1) +% p: 1 x n predict probability [0,1] +% Written by Mo Chen (sth4nth@gmail.com). +X = [X;ones(1,size(X,2))]; +w = model.w; +p = sigmoid(w'*X); +y = round(p); + diff --git a/books/PRML/PRMLT-master-MATLAB/chapter04/logitMn.m b/books/PRML/PRMLT-master-MATLAB/chapter04/logitMn.m new file mode 100755 index 0000000..99ee41f --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter04/logitMn.m @@ -0,0 +1,76 @@ +function [model, llh] = logitMn(X, t, lambda) +% Multinomial regression for multiclass problem (Multinomial likelihood) +% Input: +% X: d x n data matrix +% t: 1 x n label (1~k) +% lambda: regularization parameter +% Output: +% model: trained model structure +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 3 + lambda = 1e-4; +end +X = [X; ones(1,size(X,2))]; +[W, llh] = newtonRaphson(X, t, lambda); +% [W, llh] = newtonBlock(X, t, lambda); +model.W = W; + +function [W, llh] = newtonRaphson(X, t, lambda) +[d,n] = size(X); +k = max(t); +tol = 1e-4; +maxiter = 100; +llh = -inf(1,maxiter); +dk = d*k; +idx = (1:dk)'; +dg = sub2ind([dk,dk],idx,idx); +T = sparse(t,1:n,1,k,n,n); +W = zeros(d,k); +HT = zeros(d,k,d,k); +for iter = 2:maxiter + A = W'*X; % 4.105 + logY = bsxfun(@minus,A,logsumexp(A,1)); % 4.104 + llh(iter) = dot(T(:),logY(:))-0.5*lambda*dot(W(:),W(:)); % 4.108 + if abs(llh(iter)-llh(iter-1)) < tol; break; end + Y = exp(logY); + for i = 1:k + for j = 1:k + r = Y(i,:).*((i==j)-Y(j,:)); % r has negative value, so cannot use sqrt + HT(:,i,:,j) = bsxfun(@times,X,r)*X'; % 4.110 + end + end + G = X*(Y-T)'+lambda*W; % 4.96 + H = reshape(HT,dk,dk); + H(dg) = H(dg)+lambda; + W(:) = W(:)-H\G(:); % 4.92 +end +llh = llh(2:iter); + +function [W, llh] = newtonBlock(X, t, lambda) +[d,n] = size(X); +k = max(t); +idx = (1:d)'; +dg = sub2ind([d,d],idx,idx); +tol = 1e-4; +maxiter = 100; +llh = -inf(1,maxiter); +T = sparse(t,1:n,1,k,n,n); +W = zeros(d,k); +A = W'*X; +logY = bsxfun(@minus,A,logsumexp(A,1)); +for iter = 2:maxiter + for j = 1:k + Y = exp(logY); + Xw = bsxfun(@times,X,sqrt(Y(j,:).*(1-Y(j,:)))); + H = Xw*Xw'; + H(dg) = H(dg)+lambda; + g = X*(Y(j,:)-T(j,:))'+lambda*W(:,j); + W(:,j) = W(:,j)-H\g; + A(j,:) = W(:,j)'*X; + logY = bsxfun(@minus,A,logsumexp(A,1)); % must be here to renormalize + end + llh(iter) = dot(T(:),logY(:))-0.5*lambda*dot(W(:),W(:)); + if abs(llh(iter)-llh(iter-1)) < tol; break; end +end +llh = llh(2:iter); diff --git a/books/PRML/PRMLT-master-MATLAB/chapter04/logitMnPred.m b/books/PRML/PRMLT-master-MATLAB/chapter04/logitMnPred.m new file mode 100755 index 0000000..f30db00 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter04/logitMnPred.m @@ -0,0 +1,13 @@ +function [y, P] = logitMnPred(model, X) +% Prediction of multiclass (multinomial) logistic regression model +% Input: +% model: trained model structure +% X: d x n testing data +% Output: +% y: 1 x n predict label (1~k) +% P: k x n predict probability for each class +% Written by Mo Chen (sth4nth@gmail.com). +W = model.W; +X = [X; ones(1,size(X,2))]; +P = softmax(W'*X); +[~, y] = max(P,[],1); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter04/sigmoid.m b/books/PRML/PRMLT-master-MATLAB/chapter04/sigmoid.m new file mode 100755 index 0000000..9c82831 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter04/sigmoid.m @@ -0,0 +1,4 @@ +function y = sigmoid(x) +% Sigmod function +% Written by Mo Chen (sth4nth@gmail.com). +y = exp(-log1pexp(-x)); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter04/softmax.m b/books/PRML/PRMLT-master-MATLAB/chapter04/softmax.m new file mode 100755 index 0000000..3f82baf --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter04/softmax.m @@ -0,0 +1,10 @@ +function [Y,s] = softmax(X, dim) +% Softmax function +% By default dim = 1 (columns). +% Written by Mo Chen (sth4nth@gmail.com). +if nargin == 1 + dim = find(size(X)~=1,1); + if isempty(dim), dim = 1; end +end +s = logsumexp(X,dim); +Y = exp(X-s); diff --git a/books/PRML/PRMLT-master-MATLAB/chapter05/mlp.m b/books/PRML/PRMLT-master-MATLAB/chapter05/mlp.m new file mode 100755 index 0000000..df987b1 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter05/mlp.m @@ -0,0 +1,39 @@ +function [model, mse] = mlp(X, T, h) +% Train a multilayer perceptron neural network +% Input: +% X: d x n data matrix +% T: p x n response matrix +% h: L x 1 vector specify number of hidden nodes in each layer l +% Ouput: +% model: model structure +% mse: mean square error +% Written by Mo Chen (sth4nth@gmail.com). +eta = 1/size(X,2); +h = [size(X,1);h(:);size(T,1)]; +L = numel(h); +W = cell(L-1,1); +for l = 1:L-1 + W{l} = randn(h(l),h(l+1)); +end +Z = cell(L,1); +Z{1} = X; +maxiter = 200; +mse = zeros(1,maxiter); +for iter = 1:maxiter +% forward + for l = 2:L + Z{l} = sigmoid(W{l-1}'*Z{l-1}); % 5.10, 5.49 + end +% backward + E = T-Z{L}; + mse(iter) = mean(dot(E,E),1); + for l = L-1:-1:1 + df = Z{l+1}.*(1-Z{l+1}); + dG = df.*E; + dW = Z{l}*dG'; + W{l} = W{l}+eta*dW; + E = W{l}*dG; + end +end +mse = mse(1:iter); +model.W = W; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter05/mlpPred.m b/books/PRML/PRMLT-master-MATLAB/chapter05/mlpPred.m new file mode 100755 index 0000000..0ce5fb1 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter05/mlpPred.m @@ -0,0 +1,13 @@ +function Y = mlpPred(model, X) +% Multilayer perceptron prediction +% Input: +% model: model structure +% X: d x n data matrix +% Ouput: +% Y: p x n response matrix +% Written by Mo Chen (sth4nth@gmail.com). +W = model.W; +Y = X; +for l = 1:length(W) + Y = sigmoid(W{l}'*Y); +end \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter06/kn2sd.m b/books/PRML/PRMLT-master-MATLAB/chapter06/kn2sd.m new file mode 100755 index 0000000..7d40c50 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter06/kn2sd.m @@ -0,0 +1,9 @@ +function D = kn2sd(K) +% Transform a kernel matrix (or inner product matrix) to a squared distance matrix +% Input: +% K: n x n kernel matrix +% Ouput: +% D: n x n squared distance matrix +% Written by Mo Chen (sth4nth@gmail.com). +d = diag(K); +D = -2*K+bsxfun(@plus,d,d'); diff --git a/books/PRML/PRMLT-master-MATLAB/chapter06/knCenter.m b/books/PRML/PRMLT-master-MATLAB/chapter06/knCenter.m new file mode 100755 index 0000000..82cd81d --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter06/knCenter.m @@ -0,0 +1,21 @@ +function Kc = knCenter(kn, X, X1, X2) +% Centerize the data in the kernel space +% Input: +% kn: kernel function +% X: d x n data matrix of which the center in the kernel space is computed +% X1, X2: d x n1 and d x n2 data matrix. the kernel k(x1,x2) is computed +% where the origin of the kernel space is the center of phi(X) +% Ouput: +% Kc: n1 x n2 kernel matrix between X1 and X2 in kernel space centered by +% center of phi(X) +% Written by Mo Chen (sth4nth@gmail.com). +K = kn(X,X); +mK = mean(K); +mmK = mean(mK); +if nargin == 2 % compute the pairwise centerized version of the kernel of X. eq knCenter(kn,X,X,X) + Kc = K+mmK-bsxfun(@plus,mK',mK); % Kc = K-M*K-K*M+M*K*M; where M = ones(n,n)/n; +elseif nargin == 3 % compute the norms (k(x,x)) of X1 w.r.t. the center of X as the origin. eq diag(knCenter(kn,X,X1,X1)) + Kc = kn(X1)+mmK-2*mean(kn(X,X1)); +elseif nargin == 4 % compute the kernel of X1 and X2 w.r.t. the center of X as the origin + Kc = kn(X1,X2)+mmK-bsxfun(@plus,mean(kn(X,X1))',mean(kn(X,X2))); +end diff --git a/books/PRML/PRMLT-master-MATLAB/chapter06/knGauss.m b/books/PRML/PRMLT-master-MATLAB/chapter06/knGauss.m new file mode 100755 index 0000000..d19820b --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter06/knGauss.m @@ -0,0 +1,20 @@ +function K = knGauss(X, Y, s) +% Gaussian (RBF) kernel K = exp(-|x-y|/(2s)); +% Input: +% X: d x nx data matrix +% Y: d x ny data matrix +% s: sigma of gaussian +% Ouput: +% K: nx x ny kernel matrix +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 3 + s = 1; +end + +if nargin < 2 || isempty(Y) + K = ones(1,size(X,2)); % norm in kernel space +else + D = bsxfun(@plus,dot(X,X,1)',dot(Y,Y,1))-2*(X'*Y); + K = exp(D/(-2*s^2)); +end + diff --git a/books/PRML/PRMLT-master-MATLAB/chapter06/knKmeans.m b/books/PRML/PRMLT-master-MATLAB/chapter06/knKmeans.m new file mode 100755 index 0000000..49c6c15 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter06/knKmeans.m @@ -0,0 +1,37 @@ +function [label, model, energy] = knKmeans(X, init, kn) +% Perform kernel kmeans clustering. +% Input: +% K: n x n kernel matrix +% init: either number of clusters (k) or initial label (1xn) +% Output: +% label: 1 x n sample labels +% model: trained model structure +% energy: optimization target value +% Reference: Kernel Methods for Pattern Analysis +% by John Shawe-Taylor, Nello Cristianini +% Written by Mo Chen (sth4nth@gmail.com). +n = size(X,2); +if numel(init)==1 + k = init; + label = ceil(k*rand(1,n)); +elseif numel(init)==n + label = init; +end +if nargin < 3 + kn = @knGauss; +end +K = kn(X,X); +last = zeros(1,n); +while any(label ~= last) + [~,~,last(:)] = unique(label); % remove empty clusters + E = sparse(last,1:n,1); + E = E./sum(E,2); + T = E*K; + [val, label] = max(T-dot(T,E,2)/2,[],1); +end +energy = trace(K)-2*sum(val); +if nargout == 3 + model.X = X; + model.label = label; + model.kn = kn; +end diff --git a/books/PRML/PRMLT-master-MATLAB/chapter06/knKmeansPred.m b/books/PRML/PRMLT-master-MATLAB/chapter06/knKmeansPred.m new file mode 100755 index 0000000..30dc653 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter06/knKmeansPred.m @@ -0,0 +1,20 @@ +function [label, energy] = knKmeansPred(model, Xt) +% Prediction for kernel kmeans clusterng +% Input: +% model: trained model structure +% Xt: d x n testing data +% Ouput: +% label: 1 x n predict label +% engery: optimization target value +% Written by Mo Chen (sth4nth@gmail.com). +X = model.X; +t = model.label; +kn = model.kn; + +n = size(X,2); +k = max(t); +E = sparse(t,1:n,1,k,n,n); +E = E./sum(E,2); +Z = E*kn(X,Xt)-dot(E*kn(X,X),E,2)/2; +[val, label] = max(Z,[],1); +energy = sum(kn(Xt))-2*sum(val); diff --git a/books/PRML/PRMLT-master-MATLAB/chapter06/knLin.m b/books/PRML/PRMLT-master-MATLAB/chapter06/knLin.m new file mode 100755 index 0000000..9806c9b --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter06/knLin.m @@ -0,0 +1,13 @@ +function K = knLin(X, Y) +% Linear kernel (inner product) +% Input: +% X: d x nx data matrix +% Y: d x ny data matrix +% Ouput: +% K: nx x ny kernel matrix +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 2 || isempty(Y) + K = dot(X,X,1); % norm in kernel space +else + K = X'*Y; +end diff --git a/books/PRML/PRMLT-master-MATLAB/chapter06/knPca.m b/books/PRML/PRMLT-master-MATLAB/chapter06/knPca.m new file mode 100755 index 0000000..058ca50 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter06/knPca.m @@ -0,0 +1,22 @@ +function model = knPca(X, q, kn) +% Kernel PCA +% Input: +% X: d x n data matrix +% q: target dimension +% kn: kernel function +% Ouput: +% model: trained model structure +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 3 + kn = @knGauss; +end +K = knCenter(kn,X); +[V,L] = eig(K); +[L,idx] = sort(diag(L),'descend'); +V = V(:,idx(1:q)); +L = L(1:q); + +model.kn = kn; +model.V = V; +model.L = L; +model.X = X; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter06/knPcaPred.m b/books/PRML/PRMLT-master-MATLAB/chapter06/knPcaPred.m new file mode 100755 index 0000000..d986bd1 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter06/knPcaPred.m @@ -0,0 +1,18 @@ +function Y = knPcaPred(model, Xt, opt) +% Prediction for kernel PCA +% Input: +% model: trained model structure +% X: d x n testing data +% t (optional): 1 x n testing response +% Output: +% Y: prejection result of Xt +% Written by Mo Chen (sth4nth@gmail.com). +kn = model.kn; +V = model.V; +L = model.L; +X = model.X; +Y = bsxfun(@times,V'*knCenter(kn,X,X,Xt),1./sqrt(L)); +if nargin == 3 && opt.whiten + Y = bsxfun(@times,Y,1./sqrt(L)); +end + diff --git a/books/PRML/PRMLT-master-MATLAB/chapter06/knPoly.m b/books/PRML/PRMLT-master-MATLAB/chapter06/knPoly.m new file mode 100755 index 0000000..ae3cc0c --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter06/knPoly.m @@ -0,0 +1,24 @@ +function K = knPoly(X, Y, o, c) +% Polynomial kernel k(x,y)=(x'y+c)^o +% Input: +% X: d x nx data matrix +% Y: d x ny data matrix +% o: order of polynomial +% c: constant +% Ouput: +% K: nx x ny kernel matrix +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 4 + c = 0; +end + +if nargin < 3 + o = 3; +end + +if nargin < 2 || isempty(Y) + K = (dot(X,X,1)+c).^o; % norm in kernel space +else + K = (X'*Y+c).^o; +end + diff --git a/books/PRML/PRMLT-master-MATLAB/chapter06/knReg.m b/books/PRML/PRMLT-master-MATLAB/chapter06/knReg.m new file mode 100755 index 0000000..8fdbff2 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter06/knReg.m @@ -0,0 +1,31 @@ +function model = knReg(X, t, lambda, kn) +% Gaussian process (kernel) regression +% Input: +% X: d x n data +% t: 1 x n response +% lambda: regularization parameter +% Output: +% model: trained model structure +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 4 + kn = @knGauss; +end +if nargin < 3 + lambda = 1e-2; +end +K = knCenter(kn,X); +tbar = mean(t); +U = chol(K+lambda*eye(size(X,2))); % 6.62 +a = U\(U'\(t(:)-tbar)); % 6.68 + +model.kn = kn; +model.a = a; +model.X = X; +model.tbar = tbar; +%% for probability prediction +y = a'*K+tbar; +beta = 1/mean((t-y).^2); % 3.21 +alpha = lambda*beta; % lambda=a/b P.153 3.55 +model.alpha = alpha; +model.beta = beta; +model.U = U; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter06/knRegPred.m b/books/PRML/PRMLT-master-MATLAB/chapter06/knRegPred.m new file mode 100755 index 0000000..6910657 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter06/knRegPred.m @@ -0,0 +1,29 @@ +function [y, sigma, p] = knRegPred(model, Xt, t) +% Prediction for Gaussian Process (kernel) regression model +% Input: +% model: trained model structure +% Xt: d x n testing data +% t (optional): 1 x n testing response +% Output: +% y: 1 x n prediction +% sigma: variance +% p: 1 x n likelihood of t +% Written by Mo Chen (sth4nth@gmail.com). +kn = model.kn; +a = model.a; +X = model.X; +tbar = model.tbar; +Kt = knCenter(kn,X,X,Xt); +y = a'*Kt+tbar; +%% probability prediction +if nargout > 1 + alpha = model.alpha; + beta = model.beta; + U = model.U; + XU = U'\Kt; + sigma = sqrt(1/beta+(knCenter(kn,X,Xt)-dot(XU,XU,1))/alpha); +end + +if nargin == 3 && nargout == 3 + p = exp(-0.5*(((t-y)./sigma).^2+log(2*pi))-log(sigma)); +end \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter06/sd2kn.m b/books/PRML/PRMLT-master-MATLAB/chapter06/sd2kn.m new file mode 100755 index 0000000..0347c79 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter06/sd2kn.m @@ -0,0 +1,11 @@ +function K = sd2kn(D) +% Transform a squared distance matrix to a kernel matrix. +% The data are assumed to be centered, i.e., H=eye(n)-ones(n)/n; K=-(H*D*H)/2. +% Input: +% D: n x n squared distance matrix +% Ouput: +% K: n x n kernel matrix +% Written by Mo Chen (sth4nth@gmail.com). +D = bsxfun(@minus,D,mean(D,1)); +D = bsxfun(@minus,D,mean(D,2)); +K = (D+D')/(-4); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter07/rvmBinFp.m b/books/PRML/PRMLT-master-MATLAB/chapter07/rvmBinFp.m new file mode 100755 index 0000000..c90d922 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter07/rvmBinFp.m @@ -0,0 +1,87 @@ +function [model, llh] = rvmBinFp(X, t, alpha) +% Relevance Vector Machine (ARD sparse prior) for binary classification. +% trained by empirical bayesian (type II ML) using Mackay fix point update. +% Input: +% X: d x n data matrix +% t: 1 x n label (0/1) +% alpha: prior parameter +% Output: +% model: trained model structure +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 3 + alpha = 1; +end +n = size(X,2); +X = [X;ones(1,n)]; +d = size(X,1); +alpha = alpha*ones(d,1); +m = zeros(d,1); + +tol = 1e-4; +maxiter = 100; +llh = -inf(1,maxiter); +index = 1:d; +for iter = 2:maxiter + % remove zeros + nz = 1./alpha > tol; % nonzeros + index = index(nz); + alpha = alpha(nz); + X = X(nz,:); + m = m(nz); + + [m,e,U] = logitBin(X,t,alpha,m); % 7.110 ~ 7.113 + + m2 = m.^2; + llh(iter) = e(end)+0.5*(sum(log(alpha))-2*sum(log(diag(U)))-dot(alpha,m2)-n*log(2*pi)); % 7.114 & 7.118 + if abs(llh(iter)-llh(iter-1)) < tol*abs(llh(iter-1)); break; end + + V = inv(U); + dgS = dot(V,V,2); + alpha = (1-alpha.*dgS)./m2; % 7.89 & 7.87 & 7.116 +end +llh = llh(2:iter); + +model.index = index; +model.w = m; +model.alpha = alpha; + + +function [w, llh, U] = logitBin(X, t, lambda, w) +% Logistic regression +[d,n] = size(X); +tol = 1e-4; +maxiter = 100; +llh = -inf(1,maxiter); +idx = (1:d)'; +dg = sub2ind([d,d],idx,idx); +h = ones(1,n); +h(t==0) = -1; +a = w'*X; +for iter = 2:maxiter + y = sigmoid(a); % 4.87 + r = y.*(1-y); % 4.98 + Xw = bsxfun(@times, X, sqrt(r)); + H = Xw*Xw'; % 4.97 + H(dg) = H(dg)+lambda; + U = chol(H); + g = X*(y-t)'+lambda.*w; % 4.96 + p = -U\(U'\g); + wo = w; % 4.92 + w = wo+p; + a = w'*X; + llh(iter) = -sum(log1pexp(-h.*a))-0.5*sum(lambda.*w.^2); % 4.89 + incr = llh(iter)-llh(iter-1); + while incr < 0 % line search + p = p/2; + w = wo+p; + a = w'*X; + llh(iter) = -sum(log1pexp(-h.*a))-0.5*sum(lambda.*w.^2); + incr = llh(iter)-llh(iter-1); + end + if incr < tol; break; end +end +llh = llh(2:iter); + + + diff --git a/books/PRML/PRMLT-master-MATLAB/chapter07/rvmBinPred.m b/books/PRML/PRMLT-master-MATLAB/chapter07/rvmBinPred.m new file mode 100755 index 0000000..1bb97f5 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter07/rvmBinPred.m @@ -0,0 +1,15 @@ +function [y, p] = rvmBinPred(model, X) +% Prodict the label for binary logistic regression model +% Input: +% model: trained model structure +% X: d x n testing data +% Output: +% y: 1 x n predict label (0/1) +% p: 1 x n predict probability [0,1] +% Written by Mo Chen (sth4nth@gmail.com). +index = model.index; +X = [X;ones(1,size(X,2))]; +X = X(index,:); +w = model.w; +p = sigmoid(w'*X); +y = round(p); diff --git a/books/PRML/PRMLT-master-MATLAB/chapter07/rvmRegFp.m b/books/PRML/PRMLT-master-MATLAB/chapter07/rvmRegFp.m new file mode 100755 index 0000000..c19bdfc --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter07/rvmRegFp.m @@ -0,0 +1,63 @@ +function [model, llh] = rvmRegFp(X, t, alpha, beta) +% Relevance Vector Machine (ARD sparse prior) for regression +% training by empirical bayesian (type II ML) using Mackay fix point update. +% Input: +% X: d x n data +% t: 1 x n response +% alpha: prior parameter +% beta: prior parameter +% Output: +% model: trained model structure +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 3 + alpha = 0.02; + beta = 0.5; +end +[d,n] = size(X); +xbar = mean(X,2); +tbar = mean(t,2); +X = bsxfun(@minus,X,xbar); +t = bsxfun(@minus,t,tbar); +XX = X*X'; +Xt = X*t'; + +tol = 1e-3; +maxiter = 500; +llh = -inf(1,maxiter); +index = 1:d; +alpha = alpha*ones(d,1); +for iter = 2:maxiter + % remove zeros + nz = 1./alpha > tol; % nonzeros + index = index(nz); + alpha = alpha(nz); + XX = XX(nz,nz); + Xt = Xt(nz); + X = X(nz,:); + + U = chol(beta*XX+diag(alpha)); % 7.83 + m = beta*(U\(U'\Xt)); % 7.82 + m2 = m.^2; + e = sum((t-m'*X).^2); + + logdetS = 2*sum(log(diag(U))); + llh(iter) = 0.5*(sum(log(alpha))+n*log(beta)-beta*e-logdetS-dot(alpha,m2)-n*log(2*pi)); % 3.86 + if abs(llh(iter)-llh(iter-1)) < tol*abs(llh(iter-1)); break; end + + V = inv(U); + dgSigma = dot(V,V,2); + gamma = 1-alpha.*dgSigma; % 7.89 + alpha = gamma./m2; % 7.87 + beta = (n-sum(gamma))/e; % 7.88 +end +llh = llh(2:iter); + +model.index = index; +model.w0 = tbar-dot(m,xbar(nz)); +model.w = m; +model.alpha = alpha; +model.beta = beta; +%% optional for bayesian probabilistic prediction purpose +model.xbar = xbar(index); +model.U = U; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter07/rvmRegPred.m b/books/PRML/PRMLT-master-MATLAB/chapter07/rvmRegPred.m new file mode 100755 index 0000000..8c80bd0 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter07/rvmRegPred.m @@ -0,0 +1,29 @@ +function [y, sigma, p] = rvmRegPred(model, X, t) +% Compute RVM regression model reponse y = w'*X+w0 and likelihood +% Input: +% model: trained model structure +% X: d x n testing data +% t (optional): 1 x n testing response +% Output: +% y: 1 x n prediction +% sigma: variance +% p: 1 x n likelihood of t +% Written by Mo Chen (sth4nth@gmail.com). +index = model.index; +w = model.w; +w0 = model.w0; + +X = X(index,:); +y = w'*X+w0; +%% probability prediction +if nargout > 1 + beta = model.beta; + U = model.U; % 3.54 + Xo = bsxfun(@minus,X,model.xbar); + XU = U'\Xo; + sigma = sqrt((1+dot(XU,XU,1))/beta); %3.59 +end + +if nargin == 3 && nargout == 3 + p = exp(-0.5*(((t-y)./sigma).^2+log(2*pi))-log(sigma)); +end diff --git a/books/PRML/PRMLT-master-MATLAB/chapter07/rvmRegSeq.m b/books/PRML/PRMLT-master-MATLAB/chapter07/rvmRegSeq.m new file mode 100755 index 0000000..97b93db --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter07/rvmRegSeq.m @@ -0,0 +1,132 @@ +function [model, llh] = rvmRegSeq(X, t) +% TODO: beta is not updated. +% Sparse Bayesian Regression (RVM) using sequential algorithm +% Input: +% X: d x n data +% t: 1 x n response +% Output: +% model: trained model structure +% llh: loglikelihood +% reference: +% Tipping and Faul. Fast marginal likelihood maximisation for sparse Bayesian models. AISTATS 2003. +% Written by Mo Chen (sth4nth@gmail.com). +maxiter = 1000; +llh = -inf(1,maxiter); +tol = 1e-4; + +[d,n] = size(X); +xbar = mean(X,2); +tbar = mean(t,2); +X = bsxfun(@minus,X,xbar); +t = bsxfun(@minus,t,tbar); + +beta = 1/mean(t.^2); % beta = 1/sigma^2 +alpha = inf(d,1); +S = beta*dot(X,X,2); % eq.(22) +Q = beta*(X*t'); % eq.(22) +Sigma = zeros(0,0); +mu = zeros(0,1); +index = zeros(0,1); +Phi = zeros(0,n); +iAct = zeros(d,3); +for iter = 2:maxiter + s = S; q = Q; % p.353 Execrcies 7.17 + s(index) = alpha(index).*S(index)./(alpha(index)-S(index)); % 7.104 + q(index) = alpha(index).*Q(index)./(alpha(index)-S(index)); % 7.105 + + theta = q.^2-s; + iNew = theta>0; + + iUse = false(d,1); + iUse(index) = true; + + iUpd = (iNew & iUse); % update + iAdd = (iNew ~= iUpd); % add + iDel = (iUse ~= iUpd); % del + + dllh = -inf(d,1); % delta likelihood (likelihood improvement of each step, eventually approches 0.) + if any(iUpd) + alpha_ = s(iUpd).^2./theta(iUpd); % eq.(20) + delta = 1./alpha_-1./alpha(iUpd); + dllh(iUpd) = Q(iUpd).^2.*delta./(S(iUpd).*delta+1)-log1p(S(iUpd).*delta); % eq.(32) + end + if any(iAdd) + dllh(iAdd) = (Q(iAdd).^2-S(iAdd))./S(iAdd)+log(S(iAdd)./(Q(iAdd).^2)); % eq.(27) + end + if any(iDel) + dllh(iDel) = Q(iDel).^2./(S(iDel)-alpha(iDel))-log1p(-S(iDel)./alpha(iDel)); % eq.(37) + end + + [llh(iter),j] = max(dllh); + if llh(iter) < tol; break; end + + iAct(:,1) = iUpd; + iAct(:,2) = iAdd; + iAct(:,3) = iDel; + + % update parameters + switch find(iAct(j,:)) + case 1 % update: + idx = (index==j); + alpha_ = s(j)^2/theta(j); + + Sigma_j = Sigma(:,idx); + Sigma_jj = Sigma(idx,idx); + mu_j = mu(idx); + + kappa = 1/(Sigma_jj+1/(alpha_-alpha(j))); + Sigma = Sigma-kappa*(Sigma_j*Sigma_j'); % eq.(33) + mu = mu-kappa*mu_j*Sigma_j; % eq.(34) + + v = beta*X*(Phi'*Sigma_j); + S = S+kappa*v.^2; % eq.(35) + Q = Q+kappa*mu_j*v; % eq.(36) + alpha(j) = alpha_; + case 2 % Add + alpha_ = s(j)^2/theta(j); + Sigma_jj = 1/(alpha_+S(j)); + mu_j = Sigma_jj*Q(j); + phi_j = X(j,:); + + v = beta*Sigma*(Phi*phi_j'); + off = -Sigma_jj*v; % eq.(28) has error? + Sigma = [Sigma+Sigma_jj*(v*v'), off; off', Sigma_jj]; % eq.(28) + mu = [mu-mu_j*v; mu_j]; % eq.(29) + + e_j = phi_j-v'*Phi; + v = beta*X*e_j'; + S = S-Sigma_jj*v.^2; % eq.(30) + Q = Q-mu_j*v; % eq.(31) + + index = [index;j]; %#ok + alpha(j) = alpha_; + case 3 % del + idx = (index==j); + Sigma_j = Sigma(:,idx); + Sigma_jj = Sigma(idx,idx); + mu_j = mu(idx); + + Sigma = Sigma-(Sigma_j*Sigma_j')/Sigma_jj; % eq.(38) + mu = mu-mu_j*Sigma_j/Sigma_jj; % eq.(39) + + v = beta*X*(Phi'*Sigma_j); + S = S+v.^2/Sigma_jj; % eq.(40) + Q = Q+mu_j*v/Sigma_jj; % eq.(41) + + mu(idx) = []; + Sigma(:,idx) = []; + Sigma(idx,:) = []; + index(idx) = []; + alpha(j) = inf; + end + Phi = X(index,:); +% beta = ; +end +llh = cumsum(llh(2:iter)); +w0 = tbar-dot(mu,xbar(index)); + +model.index = index; +model.w0 = w0; +model.w = mu; +model.alpha = alpha(index); +model.beta = beta; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter08/betheEnergy.m b/books/PRML/PRMLT-master-MATLAB/chapter08/betheEnergy.m new file mode 100755 index 0000000..d663e8b --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter08/betheEnergy.m @@ -0,0 +1,11 @@ +function lnZ = betheEnergy(A, nodePot, edgePot, nodeBel, edgeBel) +% Compute Bethe free energy +% TBD: deal with log(0) for entropy +edgePot = reshape(edgePot,[],size(edgePot,3)); +edgeBel = reshape(edgeBel,[],size(edgeBel,3)); +Ex = dot(nodeBel,nodePot,1); +Exy = dot(edgeBel,edgePot,1); +Hx = -dot(nodeBel,log(nodeBel),1); +Hxy = -dot(edgeBel,log(edgeBel),1); +d = full(sum(logical(A),1)); +lnZ = -sum(Ex)-sum(Exy)-sum((d-1).*Hx)+sum(Hxy); diff --git a/books/PRML/PRMLT-master-MATLAB/chapter08/gibbsEnergy.m b/books/PRML/PRMLT-master-MATLAB/chapter08/gibbsEnergy.m new file mode 100755 index 0000000..b4c0aec --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter08/gibbsEnergy.m @@ -0,0 +1,9 @@ +function lnZ = gibbsEnergy(nodePot, edgePot, nodeBel, edgeBel) +% Compute Gibbs free energy +% TBD: deal with log(0) for entropy +edgePot = reshape(edgePot,[],size(edgePot,3)); +edgeBel = reshape(edgeBel,[],size(edgeBel,3)); +Ex = dot(nodeBel,nodePot,1); +Exy = dot(edgeBel,edgePot,1); +Hx = dot(nodeBel,log(nodeBel),1); +lnZ = -(sum(Ex)+sum(Exy)+sum(Hx)); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter08/im2mrf.m b/books/PRML/PRMLT-master-MATLAB/chapter08/im2mrf.m new file mode 100755 index 0000000..3d9e173 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter08/im2mrf.m @@ -0,0 +1,20 @@ +function [A, nodePot, edgePot] = im2mrf(im, J, sigma) +% Convert a image to Ising MRF with distribution p(x)=exp(-sum(nodePot)-sum(edgePot)-lnZ) +% Input: +% im: row x col image +% sigma: variance of Gaussian node potential +% J: parameter of Ising edge +% Output: +% nodePot: 2 x n node potential +% edgePot: 2 x 2 x m edge potential + +A = lattice(size(im)); +[s,t,e] = find(tril(A)); +nEdge = numel(e); +e(:) = 1:nEdge; +A = sparse([s;t],[t;s],[e;e]); + +z = [1;-1]; +y = reshape(im,1,[]); +nodePot = (y-z).^2/(2*sigma^2); +edgePot = repmat(-J*(z*z'),[1, 1, nEdge]); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter08/isingMeanField.m b/books/PRML/PRMLT-master-MATLAB/chapter08/isingMeanField.m new file mode 100755 index 0000000..ad7d286 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter08/isingMeanField.m @@ -0,0 +1,30 @@ +function mu = isingMeanField(J, h, epoch) +% Mean field for 2d Ising model +% Input: +% J: scalar edge potential +% h: M X N image size node potential +% edgePot: k x k x m edge potential +% Output: +% mu: M x N image size expectation +% Written by Mo Chen (sth4nth@gmail.com) +tol = 0; +if nargin < 3 + epoch = 50; + tol = 1e-8; +end +[M,N] = size(h); +mu = tanh(h); +stride = [-1,1,-M,M]; +for t = 1:epoch + mu0 = mu; + for j = 1:N + for i = 1:M + pos = i + M*(j-1); + ne = pos + stride; + ne([i,i,j,j] == [1,M,1,N]) = []; + mu(i,j) = tanh(J*sum(mu(ne)) + h(i,j)); + end + end + if max(abs(mu(:)-mu0(:))) < tol; break; end +end + diff --git a/books/PRML/PRMLT-master-MATLAB/chapter08/mrfBelProp.m b/books/PRML/PRMLT-master-MATLAB/chapter08/mrfBelProp.m new file mode 100755 index 0000000..a556d9c --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter08/mrfBelProp.m @@ -0,0 +1,62 @@ +function [nodeBel, edgeBel] = mrfBelProp(A, nodePot, edgePot, epoch) +% Belief propagation for MRF (Assuming that egdePot is symmetric) +% Input: +% A: n x n adjacent matrix of undirected graph, where value is edge index +% nodePot: k x n node potential +% edgePot: k x k x m edge potential +% Output: +% nodeBel: k x n node belief +% edgeBel: k x k x m edge belief +% Written by Mo Chen (sth4nth@gmail.com) +tol = 0; +if nargin < 4 + epoch = 50; + tol = 1e-8; +end + +nodePot = exp(-nodePot); +edgePot = exp(-edgePot); + +[k,n] = size(nodePot); +m = size(edgePot,3); + +[s,t,e] = find(tril(A)); +A = sparse([s;t],[t;s],[e;e+m]); % digraph adjacent matrix, where value is message index +mu = ones(k,2*m)/k; % message +for iter = 1:epoch + mu0 = mu; + for i = 1:n + in = nonzeros(A(:,i)); % incoming message index + nb = nodePot(:,i).*prod(mu(:,in),2); % product of incoming message + for l = in' + ep = edgePot(:,:,ud(l,m)); + mu(:,rd(l,m)) = normalize(ep*(nb./mu(:,l))); + end + end + if max(abs(mu(:)-mu0(:))) < tol; break; end +end + +nodeBel = zeros(k,n); +for i = 1:n + nodeBel(:,i) = nodePot(:,i).*prod(mu(:,nonzeros(A(:,i))),2); +end +nodeBel = normalize(nodeBel,1); + +edgeBel = zeros(k,k,m); +for l = 1:m + eij = e(l); + eji = eij+m; + ep = edgePot(:,:,eij); + nbt = nodeBel(:,t(l))./mu(:,eij); + nbs = nodeBel(:,s(l))./mu(:,eji); + eb = (nbt*nbs').*ep; + edgeBel(:,:,eij) = eb./sum(eb(:)); +end + +function i = rd(i, m) +% reverse direction edge index +i = mod(i+m-1,2*m)+1; + +function i = ud(i, m) +% undirected edge index +i = mod(i-1,m)+1; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter08/mrfExpProp.m b/books/PRML/PRMLT-master-MATLAB/chapter08/mrfExpProp.m new file mode 100755 index 0000000..26969f2 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter08/mrfExpProp.m @@ -0,0 +1,55 @@ +function [nodeBel, edgeBel] = mrfExpProp(A, nodePot, edgePot, epoch) +% Expectation propagation for MRF (Assuming that egdePot is symmetric) +% Input: +% A: n x n adjacent matrix of undirected graph, where value is edge index +% nodePot: k x n node potential +% edgePot: k x k x m edge potential +% Output: +% nodeBel: k x n node belief +% edgeBel: k x k x m edge belief +% Written by Mo Chen (sth4nth@gmail.com) +tol = 0; +if nargin < 4 + epoch = 50; + tol = 1e-8; +end + +nodePot = exp(-nodePot); +edgePot = exp(-edgePot); + +k = size(nodePot,1); +m = size(edgePot,3); + +[s,t,e] = find(tril(A)); +mu = ones(k,2*m)/k; % message +nodeBel = normalize(nodePot,1); +for iter = 1:epoch + mu0 = mu; + for l = 1:m + i = s(l); + j = t(l); + eij = e(l); + eji = eij+m; + ep = edgePot(:,:,eij); + + nodeBel(:,j) = nodeBel(:,j)./mu(:,eij); + mu(:,eij) = normalize(ep*(nodeBel(:,i)./mu(:,eji))); + nodeBel(:,j) = normalize(nodeBel(:,j).*mu(:,eij)); + + nodeBel(:,i) = nodeBel(:,i)./mu(:,eji); + mu(:,eji) = normalize(ep*(nodeBel(:,j)./mu(:,eij))); + nodeBel(:,i) = normalize(nodeBel(:,i).*mu(:,eji)); + end + if max(abs(mu(:)-mu0(:))) < tol; break; end +end + +edgeBel = zeros(k,k,m); +for l = 1:m + eij = e(l); + eji = eij+m; + ep = edgePot(:,:,eij); + nbt = nodeBel(:,t(l))./mu(:,eij); + nbs = nodeBel(:,s(l))./mu(:,eji); + eb = (nbt*nbs').*ep; + edgeBel(:,:,eij) = eb./sum(eb(:)); +end diff --git a/books/PRML/PRMLT-master-MATLAB/chapter08/mrfMeanField.m b/books/PRML/PRMLT-master-MATLAB/chapter08/mrfMeanField.m new file mode 100755 index 0000000..2f767cd --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter08/mrfMeanField.m @@ -0,0 +1,31 @@ +function [nodeBel, edgeBel] = mrfMeanField(A, nodePot, edgePot, epoch) +% Mean field for MRF (Assuming that egdePot is symmetric) +% p(x)=exp(-E(x))/Z, E(x)=\sum(edgePot)+sum(nodePot) +% Input: +% A: n x n adjacent matrix of undirected graph, where value is edge index +% nodePot: k x n node potential +% edgePot: k x k x m edge potential +% Output: +% nodeBel: k x n node belief q(x_i) +% edgeBel: k x k x m edge belief q(x_i,x_j) +% Written by Mo Chen (sth4nth@gmail.com) +tol = 0; +if nargin < 4 + epoch = 50; + tol = 1e-8; +end +[nodeBel,L] = softmax(-nodePot,1); % init nodeBel +for iter = 1:epoch + nodeBel0 = nodeBel; + for i = 1:numel(L) + [~,j,e] = find(A(i,:)); % neighbors + nodeBel(:,i) = softmax(-nodePot(:,i)-reshape(edgePot(:,:,e),2,[])*reshape(nodeBel(:,j),[],1)); + end + if max(abs(nodeBel(:)-nodeBel0(:))) < tol; break; end +end + +[s,t,e] = find(tril(A)); +edgeBel = zeros(size(edgePot)); +for l = 1:numel(e) + edgeBel(:,:,e(l)) = nodeBel(:,s(l))*nodeBel(:,t(l))'; +end \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter08/nbBern.m b/books/PRML/PRMLT-master-MATLAB/chapter08/nbBern.m new file mode 100755 index 0000000..f260b34 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter08/nbBern.m @@ -0,0 +1,16 @@ +function model = nbBern(X, t) +% Naive bayes classifier with indepenet Bernoulli. +% Input: +% X: d x n data matrix +% t: 1 x n label (1~k) +% Output: +% model: trained model structure +% Written by Mo Chen (sth4nth@gmail.com). +n = size(X,2); +E = sparse(1:n,t,1); +nk = sum(E,1); +w = full(nk)/n; +mu = X*(E./nk); + +model.mu = mu; % d x k means +model.w = w; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter08/nbBernPred.m b/books/PRML/PRMLT-master-MATLAB/chapter08/nbBernPred.m new file mode 100755 index 0000000..525a890 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter08/nbBernPred.m @@ -0,0 +1,12 @@ +function y = nbBernPred(model, X) +% Prediction of naive Bayes classifier with independent Bernoulli. +% input: +% model: trained model structure +% X: d x n data matrix +% output: +% y: 1 x n predicted class label +% Written by Mo Chen (sth4nth@gmail.com). +mu = model.mu; +w = model.w; +[~,y] = max(log(mu)'*X+log(1-mu)'*(1-X)+log(w(:)),[],1); + diff --git a/books/PRML/PRMLT-master-MATLAB/chapter08/nbGauss.m b/books/PRML/PRMLT-master-MATLAB/chapter08/nbGauss.m new file mode 100755 index 0000000..6b4e8b2 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter08/nbGauss.m @@ -0,0 +1,21 @@ +function model = nbGauss(X, t) +% Naive bayes classifier with indepenet Gaussian, each dimension of data is +% assumed from a 1d Gaussian distribution with independent mean and variance. +% Input: +% X: d x n data matrix +% t: 1 x n label (1~k) +% Output: +% model: trained model structure +% Written by Mo Chen (sth4nth@gmail.com). +n = size(X,2); +k = max(t); +E = sparse(t,1:n,1,k,n,n); +nk = full(sum(E,2)); +w = nk/n; +R = E'*spdiags(1./nk,0,k,k); +mu = X*R; +var = X.^2*R-mu.^2; + +model.mu = mu; % d x k means +model.var = var; % d x k variances +model.w = w; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter08/nbGaussPred.m b/books/PRML/PRMLT-master-MATLAB/chapter08/nbGaussPred.m new file mode 100755 index 0000000..69f304b --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter08/nbGaussPred.m @@ -0,0 +1,20 @@ +function y = nbGaussPred(model, X) +% Prediction of naive Bayes classifier with independent Gaussian. +% input: +% model: trained model structure +% X: d x n data matrix +% output: +% y: 1 x n predicted class label +% Written by Mo Chen (sth4nth@gmail.com). +mu = model.mu; +var = model.var; +w = model.w; +assert(all(size(mu)==size(var))); +d = size(mu,1); + +lambda = 1./var; +ml = mu.*lambda; +M = bsxfun(@plus,lambda'*X.^2-2*ml'*X,dot(mu,ml,1)'); % M distance +c = d*log(2*pi)+2*sum(log(var),1)'; % normalization constant +R = -0.5*bsxfun(@plus,M,c); +[~,y] = max(bsxfun(@times,exp(R),w),[],1); diff --git a/books/PRML/PRMLT-master-MATLAB/chapter09/kmeans.m b/books/PRML/PRMLT-master-MATLAB/chapter09/kmeans.m new file mode 100755 index 0000000..74fd82c --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter09/kmeans.m @@ -0,0 +1,31 @@ +function [label, mu, energy] = kmeans(X, m) +% Perform kmeans clustering. +% Input: +% X: d x n data matrix +% m: initialization parameter +% Output: +% label: 1 x n sample labels +% mu: d x k center of clusters +% energy: optimization target value +% Written by Mo Chen (sth4nth@gmail.com). +label = init(X, m); +n = numel(label); +idx = 1:n; +last = zeros(1,n); +while any(label ~= last) + [~,~,last(:)] = unique(label); % remove empty clusters + mu = X*normalize(sparse(idx,last,1),1); % compute cluster centers + [val,label] = min(dot(mu,mu,1)'/2-mu'*X,[],1); % assign sample labels +end +energy = dot(X(:),X(:),1)+2*sum(val); + +function label = init(X, m) +[d,n] = size(X); +if numel(m) == 1 % random initialization + mu = X(:,randperm(n,m)); + [~,label] = min(dot(mu,mu,1)'/2-mu'*X,[],1); +elseif all(size(m) == [1,n]) % init with labels + label = m; +elseif size(m,1) == d % init with seeds (centers) + [~,label] = min(dot(m,m,1)'/2-m'*X,[],1); +end \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter09/kmeansPred.m b/books/PRML/PRMLT-master-MATLAB/chapter09/kmeansPred.m new file mode 100755 index 0000000..7ed1278 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter09/kmeansPred.m @@ -0,0 +1,11 @@ +function [label, energy] = kmeansPred(mu, X) +% Prediction for kmeans clusterng +% Input: +% model: dx k cluster center matrix +% X: d x n testing data +% Output: +% label: 1 x n cluster label +% energy: optimization target value +% Written by Mo Chen (sth4nth@gmail.com). +[val,label] = min(dot(X,X,1)+dot(mu,mu,1)'-2*mu'*X,[],1); % assign labels +energy = sum(val); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter09/kmeansRnd.m b/books/PRML/PRMLT-master-MATLAB/chapter09/kmeansRnd.m new file mode 100755 index 0000000..d48013f --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter09/kmeansRnd.m @@ -0,0 +1,20 @@ +function [X, z, mu] = kmeansRnd(d, k, n) +% Generate samples from a Gaussian mixture distribution with common variances (kmeans model). +% Input: +% d: dimension of data +% k: number of components +% n: number of data +% Output: +% X: d x n data matrix +% z: 1 x n response variable +% mu: d x k centers of clusters +% Written by Mo Chen (sth4nth@gmail.com). +alpha = 1; +beta = nthroot(k,d); % in volume x^d there is k points: x^d=k + +X = randn(d,n); +w = dirichletRnd(alpha,ones(1,k)/k); +z = discreteRnd(w,n); +E = full(sparse(z,1:n,1,k,n,n)); +mu = randn(d,k)*beta; +X = X+mu*E; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter09/kmedoids.m b/books/PRML/PRMLT-master-MATLAB/chapter09/kmedoids.m new file mode 100755 index 0000000..ff94a60 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter09/kmedoids.m @@ -0,0 +1,28 @@ +function [label, index, energy] = kmedoids(X, init) +% Perform k-medoids clustering. +% Input: +% X: d x n data matrix +% init: k number of clusters or label (1 x n vector) +% Output: +% label: 1 x n sample labels +% index: index of medoids +% energy: optimization target value +% Written by Mo Chen (sth4nth@gmail.com). +[d,n] = size(X); +if numel(init)==1 + k = init; + label = ceil(k*rand(1,n)); +elseif numel(init)==n + label = init; +end +X = X-mean(X,2); % reduce chance of numerical problems +v = dot(X,X,1); +D = v+v'-2*(X'*X); % Euclidean distance matrix +D(sub2ind([d,d],1:d,1:d)) = 0; % reduce chance of numerical problems +last = zeros(1,n); +while any(label ~= last) + [~,~,last(:)] = unique(label); % remove empty clusters + [~, index] = min(D*sparse(1:n,last,1),[],1); % find k medoids + [val, label] = min(D(index,:),[],1); % assign labels +end +energy = sum(val); diff --git a/books/PRML/PRMLT-master-MATLAB/chapter09/kseeds.m b/books/PRML/PRMLT-master-MATLAB/chapter09/kseeds.m new file mode 100755 index 0000000..ad37a4f --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter09/kseeds.m @@ -0,0 +1,15 @@ +function mu = kseeds(X, k) +% Perform kmeans++ seeding +% Input: +% X: d x n data matrix +% k: number of seeds +% Output: +% mu: d x k seeds +% Written by Mo Chen (sth4nth@gmail.com). +n = size(X,2); +D = inf(1,n); +mu = X(:,ceil(n*rand)); +for i = 2:k + D = min(D,sum((X-mu(:,i-1)).^2,1)); + mu(:,i) = X(:,randp(D)); +end diff --git a/books/PRML/PRMLT-master-MATLAB/chapter09/linRegEm.m b/books/PRML/PRMLT-master-MATLAB/chapter09/linRegEm.m new file mode 100755 index 0000000..5534bfa --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter09/linRegEm.m @@ -0,0 +1,59 @@ +function [model, llh] = linRegEm(X, t, alpha, beta) +% Fit empirical Bayesian linear regression model with EM (p.448 chapter 9.3.4) +% Input: +% X: d x n data +% t: 1 x n response +% alpha: prior parameter +% beta: prior parameter +% Output: +% model: trained model structure +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 3 + alpha = 0.02; + beta = 0.5; +end +[d,n] = size(X); +I = eye(d); +xbar = mean(X,2); +tbar = mean(t,2); + +X = bsxfun(@minus,X,xbar); +t = bsxfun(@minus,t,tbar); + +XX = X*X'; +Xt = X*t'; + +tol = 1e-4; +maxiter = 100; +llh = -inf(1,maxiter+1); +for iter = 2:maxiter + A = beta*XX+alpha*eye(d); + U = chol(A); + + m = beta*(U\(U'\Xt)); + m2 = dot(m,m); + e2 = sum((t-m'*X).^2); + + logdetA = 2*sum(log(diag(U))); + llh(iter) = 0.5*(d*log(alpha)+n*log(beta)-alpha*m2-beta*e2-logdetA-n*log(2*pi)); % 3.86 + if abs(llh(iter)-llh(iter-1)) < tol*abs(llh(iter-1)); break; end + + invU = U'\I; + trS = dot(invU(:),invU(:)); % A=inv(S) + alpha = d/(m2+trS); % 9.63 + + invUX = U'\X; + trXSX = dot(invUX(:),invUX(:)); + beta = n/(e2+trXSX); % 9.68 is wrong +end +w0 = tbar-dot(m,xbar); + +llh = llh(2:iter); +model.w0 = w0; +model.w = m; +%% optional for bayesian probabilistic inference purpose +model.alpha = alpha; +model.beta = beta; +model.xbar = xbar; +model.U = U; diff --git a/books/PRML/PRMLT-master-MATLAB/chapter09/mixBernEm.m b/books/PRML/PRMLT-master-MATLAB/chapter09/mixBernEm.m new file mode 100755 index 0000000..4c1f36d --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter09/mixBernEm.m @@ -0,0 +1,41 @@ +function [label, model, llh] = mixBernEm(X, k) +% Perform EM algorithm for fitting the Bernoulli mixture model. +% Input: +% X: d x n binary (0/1) data matrix +% k: number of cluster +% Output: +% label: 1 x n cluster label +% model: trained model structure +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +%% initialization +fprintf('EM for mixture model: running ... \n'); +X = sparse(X); +n = size(X,2); +label = ceil(k*rand(1,n)); % random initialization +R = full(sparse(1:n,label,1)); +tol = 1e-8; +maxiter = 500; +llh = -inf(1,maxiter); +for iter = 2:maxiter + model = maximization(X,R); + [R, llh(iter)] = expectation(X,model); + if abs(llh(iter)-llh(iter-1)) < tol*abs(llh(iter)); break; end; +end +[~,label(:)] = max(R,[],2); +llh = llh(2:iter); + +function [R, llh] = expectation(X, model) +mu = model.mu; +w = model.w; +R = X'*log(mu)+(1-X)'*log(1-mu)+log(w); +T = logsumexp(R,2); +llh = mean(T); % loglikelihood +R = exp(R-T); + +function model = maximization(X, R) +nk = sum(R,1); +w = nk/sum(nk); +mu = (X*R)./nk; +model.mu = mu; +model.w = w; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter09/mixBernRnd.m b/books/PRML/PRMLT-master-MATLAB/chapter09/mixBernRnd.m new file mode 100755 index 0000000..fb8f5ec --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter09/mixBernRnd.m @@ -0,0 +1,21 @@ +function [X, z, mu] = mixBernRnd(d, k, n) +% Generate samples from a Bernoulli mixture distribution. +% Input: +% d: dimension of data +% k: number of components +% n: number of data +% Output: +% X: d x n data matrix +% z: 1 x n response variable +% mu: d x k parameters of each Bernoulli component +% Written by Mo Chen (sth4nth@gmail.com). + +% w = dirichletRnd(1,ones(1,k)/k); +w = ones(1,k)/k; +z = discreteRnd(w,n); +mu = rand(d,k); +X = zeros(d,n); +for i = 1:k + idx = z==i; + X(:,idx) = bsxfun(@le,rand(d,sum(idx)), mu(:,i)); +end diff --git a/books/PRML/PRMLT-master-MATLAB/chapter09/mixGaussEm.m b/books/PRML/PRMLT-master-MATLAB/chapter09/mixGaussEm.m new file mode 100755 index 0000000..53bb4b4 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter09/mixGaussEm.m @@ -0,0 +1,87 @@ +function [label, model, llh] = mixGaussEm(X, init) +% Perform EM algorithm for fitting the Gaussian mixture model. +% Input: +% X: d x n data matrix +% init: k (1 x 1) number of components or label (1 x n, 1<=label(i)<=k) or model structure +% Output: +% label: 1 x n cluster label +% model: trained model structure +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +%% init +fprintf('EM for Gaussian mixture: running ... \n'); +tol = 1e-6; +maxiter = 500; +llh = -inf(1,maxiter); +R = initialization(X,init); +for iter = 2:maxiter + [~,label(1,:)] = max(R,[],2); + R = R(:,unique(label)); % remove empty clusters + model = maximization(X,R); + [R, llh(iter)] = expectation(X,model); + if abs(llh(iter)-llh(iter-1)) < tol*abs(llh(iter)); break; end; +end +llh = llh(2:iter); + +function R = initialization(X, init) +n = size(X,2); +if isstruct(init) % init with a model + R = expectation(X,init); +elseif numel(init) == 1 % random init k + k = init; + label = ceil(k*rand(1,n)); + R = full(sparse(1:n,label,1,n,k,n)); +elseif all(size(init)==[1,n]) % init with labels + label = init; + k = max(label); + R = full(sparse(1:n,label,1,n,k,n)); +else + error('ERROR: init is not valid.'); +end + +function [R, llh] = expectation(X, model) +mu = model.mu; +Sigma = model.Sigma; +w = model.w; + +n = size(X,2); +k = size(mu,2); +R = zeros(n,k); +for i = 1:k + R(:,i) = loggausspdf(X,mu(:,i),Sigma(:,:,i)); +end +R = bsxfun(@plus,R,log(w)); +T = logsumexp(R,2); +llh = sum(T)/n; % loglikelihood +R = exp(bsxfun(@minus,R,T)); + +function model = maximization(X, R) +[d,n] = size(X); +k = size(R,2); +nk = sum(R,1); +w = nk/n; +mu = bsxfun(@times, X*R, 1./nk); + +Sigma = zeros(d,d,k); +r = sqrt(R); +for i = 1:k + Xo = bsxfun(@minus,X,mu(:,i)); + Xo = bsxfun(@times,Xo,r(:,i)'); + Sigma(:,:,i) = Xo*Xo'/nk(i)+eye(d)*(1e-6); +end + +model.mu = mu; +model.Sigma = Sigma; +model.w = w; + +function y = loggausspdf(X, mu, Sigma) +d = size(X,1); +X = bsxfun(@minus,X,mu); +[U,p]= chol(Sigma); +if p ~= 0 + error('ERROR: Sigma is not PD.'); +end +Q = U'\X; +q = dot(Q,Q,1); % quadratic term (M distance) +c = d*log(2*pi)+2*sum(log(diag(U))); % normalization constant +y = -(c+q)/2; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter09/mixGaussPred.m b/books/PRML/PRMLT-master-MATLAB/chapter09/mixGaussPred.m new file mode 100755 index 0000000..f614081 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter09/mixGaussPred.m @@ -0,0 +1,37 @@ +function [label, R] = mixGaussPred(model, X) +% Predict label and responsibility for Gaussian mixture model. +% Input: +% X: d x n data matrix +% model: trained model structure outputed by the EM algirthm +% Output: +% label: 1 x n cluster label +% R: k x n responsibility +% Written by Mo Chen (sth4nth@gmail.com). +mu = model.mu; +Sigma = model.Sigma; +w = model.w; + +n = size(X,2); +k = size(mu,2); +logRho = zeros(n,k); + +for i = 1:k + logRho(:,i) = loggausspdf(X,mu(:,i),Sigma(:,:,i)); +end +logRho = bsxfun(@plus,logRho,log(w)); +T = logsumexp(logRho,2); +logR = bsxfun(@minus,logRho,T); +R = exp(logR); +[~,label(1,:)] = max(R,[],2); + +function y = loggausspdf(X, mu, Sigma) +d = size(X,1); +X = bsxfun(@minus,X,mu); +[U,p]= chol(Sigma); +if p ~= 0 + error('ERROR: Sigma is not PD.'); +end +Q = U'\X; +q = dot(Q,Q,1); % quadratic term (M distance) +c = d*log(2*pi)+2*sum(log(diag(U))); % normalization constant +y = -(c+q)/2; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter09/mixGaussRnd.m b/books/PRML/PRMLT-master-MATLAB/chapter09/mixGaussRnd.m new file mode 100755 index 0000000..569b89b --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter09/mixGaussRnd.m @@ -0,0 +1,33 @@ +function [X, z, model] = mixGaussRnd(d, k, n) +% Genarate samples form a Gaussian mixture model. +% Input: +% d: dimension of data +% k: number of components +% n: number of data +% Output: +% X: d x n data matrix +% z: 1 x n response variable +% model: model structure +% Written by Mo Chen (sth4nth@gmail.com). +alpha0 = 1; % hyperparameter of Dirichlet prior +W0 = eye(d); % hyperparameter of inverse Wishart prior of covariances +v0 = d+1; % hyperparameter of inverse Wishart prior of covariances +mu0 = zeros(d,1); % hyperparameter of Guassian prior of means +beta0 = nthroot(k,d); % hyperparameter of Guassian prior of means % in volume x^d there is k points: x^d=k + + +w = dirichletRnd(alpha0,ones(1,k)/k); +z = discreteRnd(w,n); + +mu = zeros(d,k); +Sigma = zeros(d,d,k); +X = zeros(d,n); +for i = 1:k + idx = z==i; + Sigma(:,:,i) = iwishrnd(W0,v0); % invpd(wishrnd(W0,v0)); + mu(:,i) = gaussRnd(mu0,beta0*Sigma(:,:,i)); + X(:,idx) = gaussRnd(mu(:,i),Sigma(:,:,i),sum(idx)); +end +model.mu = mu; +model.Sigma = Sigma; +model.weight = w; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter09/rvmBinEm.m b/books/PRML/PRMLT-master-MATLAB/chapter09/rvmBinEm.m new file mode 100755 index 0000000..16b0305 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter09/rvmBinEm.m @@ -0,0 +1,83 @@ +function [model, llh] = rvmBinEm(X, t, alpha) +% Relevance Vector Machine (ARD sparse prior) for binary classification. +% trained by empirical bayesian (type II ML) using EM. +% Input: +% X: d x n data matrix +% t: 1 x n label (0/1) +% alpha: prior parameter +% Output: +% model: trained model structure +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 3 + alpha = 1; +end +n = size(X,2); +X = [X;ones(1,n)]; +d = size(X,1); +alpha = alpha*ones(d,1); +m = zeros(d,1); + +tol = 1e-4; +maxiter = 100; +llh = -inf(1,maxiter); +index = 1:d; +for iter = 2:maxiter + % remove zeros + nz = 1./alpha > tol; % nonzeros + index = index(nz); + alpha = alpha(nz); + X = X(nz,:); + m = m(nz); + + [m,e,U] = logitBin(X,t,alpha,m); % 7.110 ~ 7.113 + + m2 = m.^2; + llh(iter) = e(end)+0.5*(sum(log(alpha))-2*sum(log(diag(U)))-dot(alpha,m2)-n*log(2*pi)); % 7.114 & 7.118 + if abs(llh(iter)-llh(iter-1)) < tol*abs(llh(iter-1)); break; end + + V = inv(U); + dgS = dot(V,V,2); + alpha = 1./(m2+dgS); % 9.67 +end +llh = llh(2:iter); + +model.index = index; +model.w = m; +model.alpha = alpha; + +function [w, llh, U] = logitBin(X, t, lambda, w) +% Logistic regression +[d,n] = size(X); +tol = 1e-4; +maxiter = 100; +llh = -inf(1,maxiter); +idx = (1:d)'; +dg = sub2ind([d,d],idx,idx); +h = ones(1,n); +h(t==0) = -1; +a = w'*X; +for iter = 2:maxiter + y = sigmoid(a); % 4.87 + r = y.*(1-y); % 4.98 + Xw = bsxfun(@times, X, sqrt(r)); + H = Xw*Xw'; % 4.97 + H(dg) = H(dg)+lambda; + U = chol(H); + g = X*(y-t)'+lambda.*w; % 4.96 + p = -U\(U'\g); + wo = w; % 4.92 + w = wo+p; + a = w'*X; + llh(iter) = -sum(log1pexp(-h.*a))-0.5*sum(lambda.*w.^2); % 4.89 + incr = llh(iter)-llh(iter-1); + while incr < 0 % line search + p = p/2; + w = wo+p; + a = w'*X; + llh(iter) = -sum(log1pexp(-h.*a))-0.5*sum(lambda.*w.^2); + incr = llh(iter)-llh(iter-1); + end + if incr < tol; break; end +end +llh = llh(2:iter); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter09/rvmRegEm.m b/books/PRML/PRMLT-master-MATLAB/chapter09/rvmRegEm.m new file mode 100755 index 0000000..0bf0d2e --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter09/rvmRegEm.m @@ -0,0 +1,63 @@ +function [model, llh] = rvmRegEm(X, t, alpha, beta) +% Relevance Vector Machine (ARD sparse prior) for regression +% trained by empirical bayesian (type II ML) using EM +% Input: +% X: d x n data +% t: 1 x n response +% alpha: prior parameter +% beta: prior parameter +% Output: +% model: trained model structure +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 3 + alpha = 0.02; + beta = 0.5; +end +[d,n] = size(X); +xbar = mean(X,2); +tbar = mean(t,2); +X = bsxfun(@minus,X,xbar); +t = bsxfun(@minus,t,tbar); +XX = X*X'; +Xt = X*t'; + +tol = 1e-3; +maxiter = 500; +llh = -inf(1,maxiter+1); +index = 1:d; +alpha = alpha*ones(d,1); +for iter = 2 : maxiter + nz = 1./alpha > tol ; % nonzeros + index = index(nz); + alpha = alpha(nz); + XX = XX(nz,nz); + Xt = Xt(nz); + X = X(nz,:); + % E-step + U = chol(beta*(XX)+diag(alpha)); % 7.83 + m = beta*(U\(U'\(X*t'))); % E[m] % 7.82 + m2 = m.^2; + e2 = sum((t-m'*X).^2); + + logdetS = 2*sum(log(diag(U))); + llh(iter) = 0.5*(sum(log(alpha))+n*log(beta)-beta*e2-logdetS-dot(alpha,m2)-n*log(2*pi)); % 3.86 + if abs(llh(iter)-llh(iter-1)) < tol*abs(llh(iter-1)); break; end + % M-step + V = inv(U); + dgS = dot(V,V,2); + alpha = 1./(m2+dgS); % 9.67 + UX = U'\X; + trXSX = dot(UX(:),UX(:)); + beta = n/(e2+trXSX); % 9.68 is wrong +end +llh = llh(2:iter); + +model.index = index; +model.w0 = tbar-dot(m,xbar(nz)); +model.w = m; +model.alpha = alpha; +model.beta = beta; +%% optional for bayesian probabilistic prediction purpose +model.xbar = xbar; +model.U = U; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter10/linRegVb.m b/books/PRML/PRMLT-master-MATLAB/chapter10/linRegVb.m new file mode 100755 index 0000000..809c3fa --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter10/linRegVb.m @@ -0,0 +1,77 @@ +function [model, energy] = linRegVb(X, t, prior) +% Variational Bayesian inference for linear regression. +% Input: +% X: d x n data +% t: 1 x n response +% prior: prior parameter +% Output: +% model: trained model structure +% energy: variational lower bound +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 3 + a0 = 1e-4; + b0 = 1e-4; + c0 = 1e-4; + d0 = 1e-4; +else + a0 = prior.a; + b0 = prior.b; + c0 = prior.c; + d0 = prior.d; +end +[m,n] = size(X); +I = eye(m); +xbar = mean(X,2); +tbar = mean(t,2); + +X = bsxfun(@minus,X,xbar); +t = bsxfun(@minus,t,tbar); + +XX = X*X'; +Xt = X*t'; + +maxiter = 100; +energy = -inf(1,maxiter+1); +tol = 1e-8; + +a = a0+m/2; % 10.94 +c = c0+n/2; +Ealpha = 1e-4; +Ebeta = 1e-4; +for iter = 2:maxiter +% q(w) + invS = diag(Ealpha)+Ebeta*XX; % 10.101 + U = chol(invS); + Ew = Ebeta*(U\(U'\Xt)); % 10.100 + KLw = -sum(log(diag(U))); +% q(alpha) + w2 = dot(Ew,Ew); + invU = U'\I; + trS = dot(invU(:),invU(:)); + b = b0+0.5*(w2+trS); % 10.95 + Ealpha = a/b; % 10.102 + KLalpha = -a*log(b); +% q(beta) + e2 = sum((t-Ew'*X).^2); + invUX = U'\X; + trXSX = dot(invUX(:),invUX(:)); + d = d0+0.5*(e2+trXSX); + Ebeta = c/d; + KLbeta = -c*log(d); +% lower bound + energy(iter) = KLalpha+KLbeta+KLw; + if energy(iter)-energy(iter-1) < tol*abs(energy(iter-1)); break; end +end +const = gammaln(a)-gammaln(a0)+gammaln(c)-gammaln(c0)+a0*log(b0)+c0*log(d0)+0.5*(m-n*log(2*pi)); +energy = energy(2:iter)+const; +w0 = tbar-dot(Ew,xbar); + +model.w0 = w0; +model.w = Ew; +model.alpha = Ealpha; +model.beta = Ebeta; +model.a = a; +model.b = b; +model.c = c; +model.d = d; +model.xbar = xbar; diff --git a/books/PRML/PRMLT-master-MATLAB/chapter10/mixGaussEvidence.m b/books/PRML/PRMLT-master-MATLAB/chapter10/mixGaussEvidence.m new file mode 100755 index 0000000..046dd56 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter10/mixGaussEvidence.m @@ -0,0 +1,68 @@ +function L = mixGaussEvidence(X, model, prior) +% Variational lower bound of the model evidence (log of marginal likelihood) +% This function implements the method in the book PRML. It is equivalent to the bound inside mixGaussVb function. +% Reference: Pattern Recognition and Machine Learning by Christopher M. Bishop (P.474) +% Written by Mo Chen (sth4nth@gmail.com). +alpha0 = prior.alpha; +kappa0 = prior.kappa; +m0 = prior.m; +v0 = prior.v; +M0 = prior.M; + +alpha = model.alpha; % Dirichlet +kappa = model.kappa; % Gaussian +m = model.m; % Gasusian +v = model.v; % Whishart +% M = model.M; % Whishart: inv(W) = V'*V +U = model.U; +R = model.R; +logR = model.logR; + +[d,k] = size(m); +nk = sum(R,1); % 10.51 + +Elogpi = psi(0,alpha)-psi(0,sum(alpha)); +Epz = dot(nk,Elogpi); +Eqz = dot(R(:),logR(:)); +logCalpha0 = gammaln(k*alpha0)-k*gammaln(alpha0); +Eppi = logCalpha0+(alpha0-1)*sum(Elogpi); +logCalpha = gammaln(sum(alpha))-sum(gammaln(alpha)); +Eqpi = dot(alpha-1,Elogpi)+logCalpha; + +U0 = chol(M0); +sqrtR = sqrt(R); +xbar = bsxfun(@times,X*R,1./nk); % 10.52 + +logW = zeros(1,k); +trSW = zeros(1,k); +trM0W = zeros(1,k); +xbarmWxbarm = zeros(1,k); +mm0Wmm0 = zeros(1,k); +for i = 1:k + Ui = U(:,:,i); + logW(i) = -2*sum(log(diag(Ui))); + + Xs = bsxfun(@times,bsxfun(@minus,X,xbar(:,i)),sqrtR(:,i)'); + V = chol(Xs*Xs'/nk(i)); + Q = V/Ui; + trSW(i) = dot(Q(:),Q(:)); % equivalent to tr(SW)=trace(S/M) + Q = U0/Ui; + trM0W(i) = dot(Q(:),Q(:)); + + q = Ui'\(xbar(:,i)-m(:,i)); + xbarmWxbarm(i) = dot(q,q); + q = Ui'\(m(:,i)-m0); + mm0Wmm0(i) = dot(q,q); +end +ElogLambda = sum(psi(0,bsxfun(@minus,v+1,(1:d)')/2),1)+d*log(2)+logW; % 10.65 +Epmu = sum(d*log(kappa0/(2*pi))+ElogLambda-d*kappa0./kappa-kappa0*(v.*mm0Wmm0))/2; +logB0 = v0*sum(log(diag(U0)))-0.5*v0*d*log(2)-logMvGamma(0.5*v0,d); +EpLambda = k*logB0+0.5*(v0-d-1)*sum(ElogLambda)-0.5*dot(v,trM0W); + +Eqmu = 0.5*sum(ElogLambda+d*log(kappa/(2*pi)))-0.5*d*k; +logB = -v.*(logW+d*log(2))/2-logMvGamma(0.5*v,d); +EqLambda = 0.5*sum((v-d-1).*ElogLambda-v*d)+sum(logB); + +EpX = 0.5*dot(nk,ElogLambda-d./kappa-v.*trSW-v.*xbarmWxbarm-d*log(2*pi)); + +L = Epz-Eqz+Eppi-Eqpi+Epmu-Eqmu+EpLambda-EqLambda+EpX; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter10/mixGaussVb.m b/books/PRML/PRMLT-master-MATLAB/chapter10/mixGaussVb.m new file mode 100755 index 0000000..1daf32a --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter10/mixGaussVb.m @@ -0,0 +1,145 @@ +function [label, model, L] = mixGaussVb(X, m, prior) +% Variational Bayesian inference for Gaussian mixture. +% Input: +% X: d x n data matrix +% m: k (1 x 1) or label (1 x n, 1<=label(i)<=k) or model structure +% Output: +% label: 1 x n cluster label +% model: trained model structure +% L: variational lower bound +% Reference: Pattern Recognition and Machine Learning by Christopher M. Bishop (P.474) +% Written by Mo Chen (sth4nth@gmail.com). +fprintf('Variational Bayesian Gaussian mixture: running ... \n'); +[d,n] = size(X); +if nargin < 3 + prior.alpha = 1; + prior.kappa = 1; + prior.m = mean(X,2); + prior.v = d+1; + prior.M = eye(d); % M = inv(W) +end +prior.logW = -2*sum(log(diag(chol(prior.M)))); + +tol = 1e-8; +maxiter = 2000; +L = -inf(1,maxiter); +model = init(X,m,prior); +for iter = 2:maxiter + model = expect(X,model); + model = maximize(X,model,prior); + L(iter) = bound(X,model,prior); + if abs(L(iter)-L(iter-1)) < tol*abs(L(iter)); break; end +end +L = L(2:iter); +label = zeros(1,n); +[~,label(:)] = max(model.R,[],2); +[~,~,label(:)] = unique(label); + +function model = init(X, m, prior) +n = size(X,2); +if isstruct(m) % init with a model + model = m; +elseif numel(m) == 1 % random init k + k = m; + label = ceil(k*rand(1,n)); + model.R = full(sparse(1:n,label,1,n,k,n)); +elseif all(size(m)==[1,n]) % init with labels + label = m; + k = max(label); + model.R = full(sparse(1:n,label,1,n,k,n)); +else + error('ERROR: init is not valid.'); +end +model = maximize(X,model,prior); + +% Done +function model = maximize(X, model, prior) +alpha0 = prior.alpha; +kappa0 = prior.kappa; +m0 = prior.m; +v0 = prior.v; +M0 = prior.M; +R = model.R; + +nk = sum(R,1); % 10.51 +alpha = alpha0+nk; % 10.58 +kappa = kappa0+nk; % 10.60 +v = v0+nk; % 10.63 +m = bsxfun(@plus,kappa0*m0,X*R); +m = bsxfun(@times,m,1./kappa); % 10.61 + +[d,k] = size(m); +U = zeros(d,d,k); +logW = zeros(1,k); +r = sqrt(R'); +for i = 1:k + Xm = bsxfun(@minus,X,m(:,i)); + Xm = bsxfun(@times,Xm,r(i,:)); + m0m = m0-m(:,i); + M = M0+Xm*Xm'+kappa0*(m0m*m0m'); % equivalent to 10.62 + U(:,:,i) = chol(M); + logW(i) = -2*sum(log(diag(U(:,:,i)))); +end + +model.alpha = alpha; +model.kappa = kappa; +model.m = m; +model.v = v; +model.U = U; +model.logW = logW; + +% Done +function model = expect(X, model) +alpha = model.alpha; % Dirichlet +kappa = model.kappa; % Gaussian +m = model.m; % Gasusian +v = model.v; % Whishart +U = model.U; % Whishart +logW = model.logW; +n = size(X,2); +[d,k] = size(m); + +EQ = zeros(n,k); +for i = 1:k + Q = (U(:,:,i)'\bsxfun(@minus,X,m(:,i))); + EQ(:,i) = d/kappa(i)+v(i)*dot(Q,Q,1); % 10.64 +end +ElogLambda = sum(psi(0,0.5*bsxfun(@minus,v+1,(1:d)')),1)+d*log(2)+logW; % 10.65 +Elogpi = psi(0,alpha)-psi(0,sum(alpha)); % 10.66 +logRho = -0.5*bsxfun(@minus,EQ,ElogLambda-d*log(2*pi)); % 10.46 +logRho = bsxfun(@plus,logRho,Elogpi); % 10.46 +logR = bsxfun(@minus,logRho,logsumexp(logRho,2)); % 10.49 +R = exp(logR); + +model.logR = logR; +model.R = R; + +% Done +function L = bound(X, model, prior) +alpha0 = prior.alpha; +kappa0 = prior.kappa; +v0 = prior.v; +logW0 = prior.logW; +alpha = model.alpha; +kappa = model.kappa; +v = model.v; +logW = model.logW; +R = model.R; +logR = model.logR; +[d,n] = size(X); +k = size(R,2); + +Epz = 0; +Eqz = dot(R(:),logR(:)); +logCalpha0 = gammaln(k*alpha0)-k*gammaln(alpha0); +Eppi = logCalpha0; +logCalpha = gammaln(sum(alpha))-sum(gammaln(alpha)); +Eqpi = logCalpha; +Epmu = 0.5*d*k*log(kappa0); +Eqmu = 0.5*d*sum(log(kappa)); +logB0 = -0.5*v0*(logW0+d*log(2))-logMvGamma(0.5*v0,d); +EpLambda = k*logB0; +logB = -0.5*v.*(logW+d*log(2))-logMvGamma(0.5*v,d); +EqLambda = sum(logB); +EpX = -0.5*d*n*log(2*pi); +L = Epz-Eqz+Eppi-Eqpi+Epmu-Eqmu+EpLambda-EqLambda+EpX; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter10/mixGaussVbPred.m b/books/PRML/PRMLT-master-MATLAB/chapter10/mixGaussVbPred.m new file mode 100755 index 0000000..5aa4b9d --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter10/mixGaussVbPred.m @@ -0,0 +1,33 @@ +function [z, R] = mixGaussVbPred(model, X) +% Predict label and responsibility for Gaussian mixture model trained by VB. +% Input: +% X: d x n data matrix +% model: trained model structure outputed by the EM algirthm +% Output: +% label: 1 x n cluster label +% R: k x n responsibility +% Written by Mo Chen (sth4nth@gmail.com). +alpha = model.alpha; % Dirichlet +kappa = model.kappa; % Gaussian +m = model.m; % Gasusian +v = model.v; % Whishart +U = model.U; % Whishart +logW = model.logW; +n = size(X,2); +[d,k] = size(m); + +EQ = zeros(n,k); +for i = 1:k + Q = (U(:,:,i)'\bsxfun(@minus,X,m(:,i))); + EQ(:,i) = d/kappa(i)+v(i)*dot(Q,Q,1); % 10.64 +end +ElogLambda = sum(psi(0,0.5*bsxfun(@minus,v+1,(1:d)')),1)+d*log(2)+logW; % 10.65 +Elogpi = psi(0,alpha)-psi(0,sum(alpha)); % 10.66 +logRho = -0.5*bsxfun(@minus,EQ,ElogLambda-d*log(2*pi)); % 10.46 +logRho = bsxfun(@plus,logRho,Elogpi); % 10.46 +logR = bsxfun(@minus,logRho,logsumexp(logRho,2)); % 10.49 +R = exp(logR); +z = zeros(1,n); +[~,z(:)] = max(R,[],2); +[~,~,z(:)] = unique(z); + diff --git a/books/PRML/PRMLT-master-MATLAB/chapter10/rvmRegVb.m b/books/PRML/PRMLT-master-MATLAB/chapter10/rvmRegVb.m new file mode 100755 index 0000000..91d073b --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter10/rvmRegVb.m @@ -0,0 +1,80 @@ +function [model, energy] = rvmRegVb(X, t, prior) +% Variational Bayesian inference for RVM regression. +% Input: +% X: d x n data +% t: 1 x n response +% prior: prior parameter +% Output: +% model: trained model structure +% energy: variational lower bound +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 3 + a0 = 1e-4; + b0 = 1e-4; + c0 = 1e-4; + d0 = 1e-4; +else + a0 = prior.a; + b0 = prior.b; + c0 = prior.c; + d0 = prior.d; +end +[m,n] = size(X); +idx = (1:m)'; +dg = sub2ind([m,m],idx,idx); +I = eye(m); +xbar = mean(X,2); +tbar = mean(t,2); + +X = bsxfun(@minus,X,xbar); +t = bsxfun(@minus,t,tbar); + +XX = X*X'; +Xt = X*t'; + +maxiter = 100; +energy = -inf(1,maxiter+1); +tol = 1e-8; + +a = a0+1/2; +c = c0+n/2; +Ealpha = 1e-2; +Ebeta = 1e-2; +for iter = 2:maxiter +% q(w) + invS = Ebeta*XX; + invS(dg) = invS(dg)+Ealpha; + U = chol(invS); + Ew = Ebeta*(U\(U'\Xt)); + KLw = -sum(log(diag(U))); +% q(alpha) + w2 = Ew.*Ew; + invU = U'\I; + dgS = dot(invU,invU,2); + b = b0+0.5*(w2+dgS); + Ealpha = a./b; + KLalpha = -sum(a*log(b)); +% q(beta) + e2 = sum((t-Ew'*X).^2); + invUX = U'\X; + trXSX = dot(invUX(:),invUX(:)); + d = d0+0.5*(e2+trXSX); + Ebeta = c/d; + KLbeta = -c*log(d); +% lower bound + energy(iter) = KLalpha+KLbeta+KLw; + if energy(iter)-energy(iter-1) < tol*abs(energy(iter-1)); break; end +end +const = m*(gammaln(a)-gammaln(a0)+a0*log(b0))+gammaln(c)-gammaln(c0)+c0*log(d0)+0.5*(m-n*log(2*pi)); +energy = energy(2:iter)+const; +w0 = tbar-dot(Ew,xbar); + +model.w0 = w0; +model.w = Ew; +model.alpha = Ealpha; +model.beta = Ebeta; +model.a = a; +model.b = b; +model.c = c; +model.d = d; +model.xbar = xbar; diff --git a/books/PRML/PRMLT-master-MATLAB/chapter11/Gauss.m b/books/PRML/PRMLT-master-MATLAB/chapter11/Gauss.m new file mode 100755 index 0000000..cb89aa8 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter11/Gauss.m @@ -0,0 +1,64 @@ +% Class for Gaussian distribution used by Dirichlet process +classdef Gauss + properties + n_ + mu_ + U_ + end + + methods + function obj = Gauss(X) + n = size(X,2); + mu = mean(X,2); + U = chol(X*X'); + + obj.n_ = n; + obj.mu_ = mu; + obj.U_ = U; + end + + function obj = clone(obj) + end + + function obj = addSample(obj, x) + n = obj.n_; + mu = obj.mu_; + U = obj.U_; + + n = n+1; + mu = mu+(x-mu)/n; + U = cholupdate(U,x,'+'); + + obj.n_ = n; + obj.mu_ = mu; + obj.U_ = U; + end + + function obj = delSample(obj, x) + n = obj.n_; + mu = obj.mu_; + U = obj.U_; + + n = n-1; + mu = mu-(x-mu)/n; + U = cholupdate(U,x,'-'); + + obj.n_ = n; + obj.mu_ = mu; + obj.U_ = U; + end + + function y = logPdf(obj,X) + n = obj.n_; + mu = obj.mu_; + U = obj.U_; + d = size(X,1); + + U = cholupdate(U/sqrt(n),mu,'-'); % Sigma=X*X'/n-mu*mu' + Q = U'\bsxfun(@minus,X,mu); + q = dot(Q,Q,1); % quadratic term (M distance) + c = d*log(2*pi)+2*sum(log(diag(U))); % normalization constant + y = -0.5*(c+q); + end + end +end \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter11/GaussWishart.m b/books/PRML/PRMLT-master-MATLAB/chapter11/GaussWishart.m new file mode 100755 index 0000000..a867735 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter11/GaussWishart.m @@ -0,0 +1,108 @@ +% Class for Gaussian-Wishart distribution used by Dirichlet process + +classdef GaussWishart + properties + kappa_ + m_ + nu_ + U_ + end + + methods + function obj = GaussWishart(kappa,m,nu,S) + U = chol(S+kappa*(m*m')); + obj.kappa_ = kappa; + obj.m_ = m; + obj.nu_ = nu; + obj.U_ = U; + end + + function obj = clone(obj) + end + + function d = dim(obj) + d = numel(obj.m_); + end + + function obj = addData(obj, X) + kappa0 = obj.kappa_; + m0 = obj.m_; + nu0 = obj.nu_; + U0 = obj.U_; + + n = size(X,2); + kappa = kappa0+n; + m = (kappa0*m0+sum(X,2))/kappa; + nu = nu0+n; + U = chol(U0'*U0+X*X'); + + obj.kappa_ = kappa; + obj.m_ = m; + obj.nu_ = nu; + obj.U_ = U; + end + + function obj = addSample(obj, x) + kappa = obj.kappa_; + m = obj.m_; + nu = obj.nu_; + U = obj.U_; + + kappa = kappa+1; + m = m+(x-m)/kappa; + nu = nu+1; + U = cholupdate(U,x,'+'); + + obj.kappa_ = kappa; + obj.m_ = m; + obj.nu_ = nu; + obj.U_ = U; + end + + function obj = delSample(obj, x) + kappa = obj.kappa_; + m = obj.m_; + nu = obj.nu_; + U = obj.U_; + + kappa = kappa-1; + m = m-(x-m)/kappa; + nu = nu-1; + U = cholupdate(U,x,'-'); + + obj.kappa_ = kappa; + obj.m_ = m; + obj.nu_ = nu; + obj.U_ = U; + end + + function y = logPredPdf(obj,X) + kappa = obj.kappa_; + m = obj.m_; + nu = obj.nu_; + U = obj.U_; + + d = size(X,1); + v = (nu-d+1); + U = sqrt((1+1/kappa)/v)*cholupdate(U,sqrt(kappa)*m,'-'); + + X = bsxfun(@minus,X,m); + Q = U'\X; + q = dot(Q,Q,1); % quadratic term (M distance) + o = -log(1+q/v)*((v+d)/2); + c = gammaln((v+d)/2)-gammaln(v/2)-(d*log(v*pi)+2*sum(log(diag(U))))/2; + y = c+o; + end + + function [mu, Sigma] = sample(obj) +% Sample a Gaussian distribution from GaussianWishart prior + kappa = obj.kappa_; + m = obj.m_; + nu = obj.nu_; + U = obj.U_; + + Sigma = iwishrnd(U'*U,nu); + mu = gaussRnd(m,Sigma/kappa); + end + end +end diff --git a/books/PRML/PRMLT-master-MATLAB/chapter11/dirichletRnd.m b/books/PRML/PRMLT-master-MATLAB/chapter11/dirichletRnd.m new file mode 100755 index 0000000..07dbd12 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter11/dirichletRnd.m @@ -0,0 +1,13 @@ +function x = dirichletRnd(a, m) +% Generate samples from a Dirichlet distribution. +% Input: +% a: k dimensional vector +% m: k dimensional mean vector +% Outpet: +% x: generated sample x~Dir(a,m) +% Written by Mo Chen (sth4nth@gmail.com). +if nargin == 2 + a = a*m; +end +x = gamrnd(a,1); +x = x/sum(x); diff --git a/books/PRML/PRMLT-master-MATLAB/chapter11/discreteRnd.m b/books/PRML/PRMLT-master-MATLAB/chapter11/discreteRnd.m new file mode 100755 index 0000000..d942783 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter11/discreteRnd.m @@ -0,0 +1,14 @@ +function x = discreteRnd(p, n) +% Generate samples from a discrete distribution (multinomial). +% Input: +% p: k dimensional probability vector +% n: number of samples +% Ouput: +% x: k x n generated samples x~Mul(p) +% Written by Mo Chen (sth4nth@gmail.com). +if nargin == 1 + n = 1; +end +r = rand(1,n); +p = cumsum(p(:)); +[~,x] = histc(r,[0;p/p(end)]); diff --git a/books/PRML/PRMLT-master-MATLAB/chapter11/gaussRnd.m b/books/PRML/PRMLT-master-MATLAB/chapter11/gaussRnd.m new file mode 100755 index 0000000..20ef570 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter11/gaussRnd.m @@ -0,0 +1,17 @@ +function x = gaussRnd(mu, Sigma, n) +% Generate samples from a Gaussian distribution. +% Input: +% mu: d x 1 mean vector +% Sigma: d x d covariance matrix +% n: number of samples +% Outpet: +% x: d x n generated sample x~Gauss(mu,Sigma) +% Written by Mo Chen (sth4nth@gmail.com). +if nargin == 2 + n = 1; +end +[V,err] = chol(Sigma); +if err ~= 0 + error('ERROR: sigma must be a symmetric positive definite matrix.'); +end +x = V'*randn(size(V,1),n)+repmat(mu,1,n); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter11/mixDpGb.m b/books/PRML/PRMLT-master-MATLAB/chapter11/mixDpGb.m new file mode 100755 index 0000000..e0e3ba2 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter11/mixDpGb.m @@ -0,0 +1,47 @@ +function [label, Theta, w, llh] = mixDpGb(X, alpha, theta) +% Collapsed Gibbs sampling for Dirichlet process (infinite) mixture model. +% Any component model can be used, such as Gaussian. +% Input: +% X: d x n data matrix +% alpha: parameter for Dirichlet process prior +% theta: class object for prior of component distribution (such as Gauss) +% Output: +% label: 1 x n cluster label +% Theta: 1 x k structure of trained components +% w: 1 x k component weight vector +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +n = size(X,2); +[label,Theta,w] = mixDpGbOl(X,alpha,theta); +nk = n*w; +maxIter = 50; +llh = zeros(1,maxIter); +for iter = 1:maxIter + for i = randperm(n) + x = X(:,i); + k = label(i); + Theta{k} = Theta{k}.delSample(x); + nk(k) = nk(k)-1; + if nk(k) == 0 % remove empty cluster + Theta(k) = []; + nk(k) = []; + which = label>k; + label(which) = label(which)-1; + end + Pk = log(nk)+cellfun(@(t) t.logPredPdf(x), Theta); + P0 = log(alpha)+theta.logPredPdf(x); + p = [Pk,P0]; + llh(iter) = llh(iter)+sum(p-log(n)); + k = discreteRnd(exp(p-logsumexp(p))); + if k == numel(Theta)+1 % add extra cluster + Theta{k} = theta.clone().addSample(x); + nk = [nk,1]; + else + Theta{k} = Theta{k}.addSample(x); + nk(k) = nk(k)+1; + end + label(i) = k; + end +end +w = nk/n; + diff --git a/books/PRML/PRMLT-master-MATLAB/chapter11/mixDpGbOl.m b/books/PRML/PRMLT-master-MATLAB/chapter11/mixDpGbOl.m new file mode 100755 index 0000000..2850513 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter11/mixDpGbOl.m @@ -0,0 +1,34 @@ +function [label, Theta, w, llh] = mixDpGbOl(X, alpha, theta) +% Online collapsed Gibbs sampling for Dirichlet process (infinite) mixture model. +% Input: +% X: d x n data matrix +% alpha: parameter for Dirichlet process prior +% theta: class object for prior of component distribution (such as Gauss) +% Output: +% label: 1 x n cluster label +% Theta: 1 x k structure of trained components +% w: 1 x k component weight vector +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +n = size(X,2); +Theta = {}; +nk = []; +label = zeros(1,n); +llh = 0; +for i = randperm(n) + x = X(:,i); + Pk = log(nk)+cellfun(@(t) t.logPredPdf(x), Theta); + P0 = log(alpha)+theta.logPredPdf(x); + p = [Pk,P0]; + llh = llh+sum(p-log(n)); + k = discreteRnd(exp(p-logsumexp(p))); + if k == numel(Theta)+1 + Theta{k} = theta.clone().addSample(x); + nk = [nk,1]; + else + Theta{k} = Theta{k}.addSample(x); + nk(k) = nk(k)+1; + end + label(i) = k; +end +w = nk/n; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter11/mixGaussGb.m b/books/PRML/PRMLT-master-MATLAB/chapter11/mixGaussGb.m new file mode 100755 index 0000000..8d1ae90 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter11/mixGaussGb.m @@ -0,0 +1,31 @@ +function [label, Theta, w, llh] = mixGaussGb(X, opt) +% Collapsed Gibbs sampling for Dirichlet process (infinite) Gaussian mixture model (a.k.a. DPGM). +% This is a wrapper function which calls underlying Dirichlet process mixture model. +% Input: +% X: d x n data matrix +% opt(optional): prior parameters +% Output: +% label: 1 x n cluster label +% Theta: 1 x k structure of trained Gaussian components +% w: 1 x k component weight vector +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +[d,n] = size(X); +mu = mean(X,2); +Xo = bsxfun(@minus,X,mu); +s = sum(Xo(:).^2)/(d*n); +if nargin == 1 + kappa0 = 1; + m0 = mean(X,2); + nu0 = d; + S0 = s*eye(d); + alpha0 = 1; +else + kappa0 = opt.kappa; + m0 = opt.m; + nu0 = opt.nu; + S0 = opt.S; + alpha0 = opt.alpha; +end +prior = GaussWishart(kappa0,m0,nu0,S0); +[label, Theta, w, llh] = mixDpGb(X,alpha0,prior); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter11/mixGaussSample.m b/books/PRML/PRMLT-master-MATLAB/chapter11/mixGaussSample.m new file mode 100755 index 0000000..44d9aa5 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter11/mixGaussSample.m @@ -0,0 +1,18 @@ +function [X, z] = mixGaussSample(Theta, w, n ) +% Genarate samples form a Gaussian mixture model with GaussianWishart prior. +% Input: +% Theta: cell of GaussianWishart priors of components +% w: weight of components +% n: number of data +% Output: +% X: d x n data matrix +% z: 1 x n response variable +% Written by Mo Chen (sth4nth@gmail.com). +z = discreteRnd(w,n); +d = Theta{1}.dim(); +X = zeros(d,n); +for i = 1:numel(w) + idx = z==i; + [mu,Sigma] = Theta{i}.sample(); % invpd(wishrnd(W0,v0)); + X(:,idx) = gaussRnd(mu,Sigma,sum(idx)); +end diff --git a/books/PRML/PRMLT-master-MATLAB/chapter12/fa.m b/books/PRML/PRMLT-master-MATLAB/chapter12/fa.m new file mode 100755 index 0000000..4cee1af --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter12/fa.m @@ -0,0 +1,51 @@ +function [W, mu, psi, llh] = fa(X, m) +% Perform EM algorithm for factor analysis model +% Input: +% X: d x n data matrix +% m: dimension of target space +% Output: +% W: d x m weight matrix +% mu: d x 1 mean vector +% psi: d x 1 variance vector +% llh: loglikelihood +% Reference: Pattern Recognition and Machine Learning by Christopher M. Bishop +% Written by Mo Chen (sth4nth@gmail.com). +[d,n] = size(X); +mu = mean(X,2); +X = bsxfun(@minus,X,mu); + +tol = 1e-4; +maxiter = 500; +llh = -inf(1,maxiter); + +I = eye(m); +r = dot(X,X,2); + +W = randn(d,m); +lambda = 1./rand(d,1); +for iter = 2:maxiter + T = bsxfun(@times,W,sqrt(lambda)); + M = T'*T+I; % M = W'*inv(Psi)*W+I + U = chol(M); + WInvPsiX = bsxfun(@times,W,lambda)'*X; % WInvPsiX = W'*inv(Psi)*X + + % likelihood + logdetC = 2*sum(log(diag(U)))-sum(log(lambda)); % log(det(C)) + Q = U'\WInvPsiX; + trInvCS = (r'*lambda-dot(Q(:),Q(:)))/n; % trace(inv(C)*S) + llh(iter) = -n*(d*log(2*pi)+logdetC+trInvCS)/2; + if abs(llh(iter)-llh(iter-1)) < tol*abs(llh(iter-1)); break; end % check likelihood for convergence + + % E step + Ez = M\WInvPsiX; % 12.66 + V = inv(U); + Ezz = n*(V*V')+Ez*Ez'; % 12.67 + + % M step + U = chol(Ezz); + XEz = X*Ez'; + W = (XEz/U)/U'; % 12.69 + lambda = n./(r-dot(W,XEz,2)); % 12.70 +end +llh = llh(2:iter); +psi = 1./lambda; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter12/pca.m b/books/PRML/PRMLT-master-MATLAB/chapter12/pca.m new file mode 100755 index 0000000..6e8f3ca --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter12/pca.m @@ -0,0 +1,21 @@ +function [U, L, mu, mse] = pca(X, m) +% Principal component analysis +% Input: +% X: d x n data matrix +% m: target dimension +% Output: +% U: d x m Projection matrix +% L: m x 1 Eigen values +% mu: d x 1 mean +% mse: mean square error +% Written by Mo Chen (sth4nth@gmail.com). +n = size(X,2); +mu = mean(X,2); +Xo = bsxfun(@minus,X,mu); +S = Xo*Xo'/n; % 12.3 +[U,L] = eig(S); % 12.5 +[L,idx] = sort(diag(L),'descend'); +mse = sum(L)-sum(L(1:m)); +U = U(:,idx(1:m)); +L = L(1:m); + diff --git a/books/PRML/PRMLT-master-MATLAB/chapter12/pcaEm.m b/books/PRML/PRMLT-master-MATLAB/chapter12/pcaEm.m new file mode 100755 index 0000000..38f9118 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter12/pcaEm.m @@ -0,0 +1,33 @@ +function [W, Z, mu, mse] = pcaEm(X, m) +% Perform EM-like algorithm for PCA (by Sam Roweis). +% Input: +% X: d x n data matrix +% m: dimension of target space +% Output: +% W: d x m weight matrix +% Z: m x n projected data matrix +% mu: d x 1 mean vector +% mse: mean square error +% Reference: +% Pattern Recognition and Machine Learning by Christopher M. Bishop +% EM algorithms for PCA and SPCA by Sam Roweis +% Written by Mo Chen (sth4nth@gmail.com). +d = size(X,1); +mu = mean(X,2); +X = bsxfun(@minus,X,mu); +W = rand(d,m); + +tol = 1e-6; +mse = inf; +maxIter = 200; +for iter = 1:maxIter + Z = (W'*W)\(W'*X); % 12.58 + W = (X*Z')/(Z*Z'); % 12.59 + + last = mse; + E = X-W*Z; + mse = mean(dot(E(:),E(:))); + if abs(last-mse)0))); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter13/HMM/hmmRnd.m b/books/PRML/PRMLT-master-MATLAB/chapter13/HMM/hmmRnd.m new file mode 100755 index 0000000..792c35f --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter13/HMM/hmmRnd.m @@ -0,0 +1,25 @@ +function [x, model] = hmmRnd(d, k, n) +% Generate a data sequence from a hidden Markov model. +% Input: +% d: dimension of data +% k: dimension of latent variable +% n: number of data +% Output: +% X: d x n data matrix +% model: model structure +% Written by Mo Chen (sth4nth@gmail.com). +A = normalize(rand(k,k),2); +E = normalize(rand(k,d),2); +s = normalize(rand(k,1),1); + +x = zeros(1,n); +z = discreteRnd(s); +x(1) = discreteRnd(E(z,:)); +for i = 2:n + z = discreteRnd(A(z,:)); + x(i) = discreteRnd(E(z,:)); +end + +model.A = A; +model.E = E; +model.s = s; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter13/HMM/hmmSmoother.m b/books/PRML/PRMLT-master-MATLAB/chapter13/HMM/hmmSmoother.m new file mode 100755 index 0000000..fb97ec5 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter13/HMM/hmmSmoother.m @@ -0,0 +1,37 @@ +function [gamma, alpha, beta, c] = hmmSmoother(model, x) +% HMM smoothing alogrithm (normalized forward-backward or normalized alpha-beta algorithm). +% The alpha and beta returned by this function are the normalized version. +% Input: +% x: 1 x n integer vector which is the sequence of observations +% model: model structure which contains +% model.s: k x 1 start probability vector +% model.A: k x k transition matrix +% model.E: k x d emission matrix +% Output: +% gamma: k x n matrix of posterior gamma(t)=p(z_t,x_{1:T}) +% alpha: k x n matrix of posterior alpha(t)=p(z_t|x_{1:T}) +% beta: k x n matrix of posterior beta(t)=gamma(t)/alpha(t) +% c: 1 x n normalization constant vector +% Written by Mo Chen (sth4nth@gmail.com). +s = model.s; +A = model.A; +E = model.E; + +n = size(x,2); +X = sparse(x,1:n,1); +M = E*X; + +[K,T] = size(M); +At = A'; +c = zeros(1,T); % normalization constant +alpha = zeros(K,T); +[alpha(:,1),c(1)] = normalize(s.*M(:,1),1); +for t = 2:T + [alpha(:,t),c(t)] = normalize((At*alpha(:,t-1)).*M(:,t),1); % 13.59 +end +beta = ones(K,T); +for t = T-1:-1:1 + beta(:,t) = A*(beta(:,t+1).*M(:,t+1))/c(t+1); % 13.62 +end +gamma = alpha.*beta; % 13.64 + diff --git a/books/PRML/PRMLT-master-MATLAB/chapter13/HMM/hmmViterbi.m b/books/PRML/PRMLT-master-MATLAB/chapter13/HMM/hmmViterbi.m new file mode 100755 index 0000000..44ae94b --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter13/HMM/hmmViterbi.m @@ -0,0 +1,31 @@ +function [z, llh] = hmmViterbi(model, x) +% Viterbi algorithm (calculated in log scale to improve numerical stability). +% Input: +% x: 1 x n integer vector which is the sequence of observations +% model: model structure which contains +% model.s: k x 1 start probability vector +% model.A: k x k transition matrix +% model.E: k x d emission matrix +% Output: +% z: 1 x n latent state +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +n = size(x,2); +X = sparse(x,1:n,1); +s = log(model.s); +A = log(model.A); +M = log(model.E*X); + +k = numel(s); +Z = zeros(k,n); +Z(:,1) = 1:k; +v = s(:)+M(:,1); +for t = 2:n + [v,idx] = max(bsxfun(@plus,A,v),[],1); % 13.68 + v = v(:)+M(:,t); + Z = Z(idx,:); + Z(:,t) = 1:k; +end +[llh,idx] = max(v); +z = Z(idx,:); + diff --git a/books/PRML/PRMLT-master-MATLAB/chapter13/LDS/kalmanFilter.m b/books/PRML/PRMLT-master-MATLAB/chapter13/LDS/kalmanFilter.m new file mode 100755 index 0000000..0005ee6 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter13/LDS/kalmanFilter.m @@ -0,0 +1,48 @@ +function [mu, V, llh] = kalmanFilter(model, X) +% Kalman filter (forward algorithm for linear dynamic system) +% NOTE: This is the exact implementation of the Kalman filter algorithm in PRML. +% However, this algorithm is not practical. It is numerical unstable. +% Input: +% X: d x n data matrix +% model: model structure +% Output: +% mu: q x n matrix of latent mean mu_t=E[z_t] w.r.t p(z_t|x_{1:t}) +% V: q x q x n latent covariance U_t=cov[z_t] w.r.t p(z_t|x_{1:t}) +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +A = model.A; % transition matrix +G = model.G; % transition covariance +C = model.C; % emission matrix +S = model.S; % emision covariance +mu0 = model.mu0; % prior mean +P = model.P0; % prior covairance + +n = size(X,2); +k = size(mu0,1); +mu = zeros(k,n); +V = zeros(k,k,n); +llh = zeros(1,n); +I = eye(k); + +PC = P*C'; +R = C*PC+S; +K = PC/R; % 13.97 +mu(:,1) = mu0+K*(X(:,1)-C*mu0); % 13.94 +V(:,:,1) = (I-K*C)*P; % 13.95 +llh(1) = logGauss(X(:,1),C*mu0,R); +for i = 2:n + [mu(:,i), V(:,:,i), llh(i)] = ... + forwardStep(X(:,i), mu(:,i-1), V(:,:,i-1), A, G, C, S, I); +end +llh = sum(llh); + +function [mu, V, llh] = forwardStep(x, mu, V, A, G, C, S, I) +P = A*V*A'+G; % 13.88 +PC = P*C'; +R = C*PC+S; +K = PC/R; % 13.92 +Amu = A*mu; +CAmu = C*Amu; +mu = Amu+K*(x-CAmu); % 13.89 +V = (I-K*C)*P; % 13.90 +llh = logGauss(x,CAmu,R); % 13.91 \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter13/LDS/kalmanSmoother.m b/books/PRML/PRMLT-master-MATLAB/chapter13/LDS/kalmanSmoother.m new file mode 100755 index 0000000..8254230 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter13/LDS/kalmanSmoother.m @@ -0,0 +1,76 @@ +function [nu, U, Ezz, Ezy, llh] = kalmanSmoother(model, X) +% Kalman smoother (forward-backward algorithm for linear dynamic system) +% NOTE: This is the exact implementation of the Kalman smoother algorithm in PRML. +% However, this algorithm is not practical. It is numerical unstable. +% Input: +% X: d x n data matrix +% model: model structure +% Output: +% nu: q x n matrix of latent mean mu_t=E[z_t] w.r.t p(z_t|x_{1:T}) +% U: q x q x n latent covariance U_t=cov[z_t] w.r.t p(z_t|x_{1:T}) +% Ezz: q x q matrix E[z_tz_t^T] +% Ezy: q x q matrix E[z_tz_{t-1}^T] +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +A = model.A; % transition matrix +G = model.G; % transition covariance +C = model.C; % emission matrix +S = model.S; % emision covariance +mu0 = model.mu0; % prior mean +P0 = model.P0; % prior covairance + +n = size(X,2); +q = size(mu0,1); +mu = zeros(q,n); +V = zeros(q,q,n); +P = zeros(q,q,n); % C_{t+1|t} +Amu = zeros(q,n); % u_{t+1|t} +llh = zeros(1,n); +I = eye(q); + +% forward +PC = P0*C'; +R = C*PC+S; +K = PC/R; +mu(:,1) = mu0+K*(X(:,1)-C*mu0); +V(:,:,1) = (I-K*C)*P0; +P(:,:,1) = P0; % useless, just make a point +Amu(:,1) = mu0; % useless, just make a point +llh(1) = logGauss(X(:,1),C*mu0,R); +for i = 2:n + [mu(:,i), V(:,:,i), Amu(:,i), P(:,:,i), llh(i)] = ... + forwardStep(X(:,i), mu(:,i-1), V(:,:,i-1), A, G, C, S, I); +end +llh = sum(llh); +% backward +nu = zeros(q,n); +U = zeros(q,q,n); +Ezz = zeros(q,q,n); +Ezy = zeros(q,q,n-1); + +nu(:,n) = mu(:,n); +U(:,:,n) = V(:,:,n); +Ezz(:,:,n) = U(:,:,n)+nu(:,n)*nu(:,n)'; +for i = n-1:-1:1 + [nu(:,i), U(:,:,i), Ezz(:,:,i), Ezy(:,:,i)] = ... + backwardStep(nu(:,i+1), U(:,:,i+1), mu(:,i), V(:,:,i), Amu(:,i+1), P(:,:,i+1), A); +end + +function [mu, V, Amu, P, llh] = forwardStep(x, mu0, V0, A, G, C, S, I) +P = A*V0*A'+G; % 13.88 +PC = P*C'; +R = C*PC+S; +K = PC/R; % 13.92 +Amu = A*mu0; +CAmu = C*Amu; +mu = Amu+K*(x-CAmu); % 13.89 +V = (I-K*C)*P; % 13.90 +llh = logGauss(x,CAmu,R); % 13.91 + + +function [nu, U, Ezz, Ezy] = backwardStep(nu0, U0, mu, V, Amu, P, A) +J = V*A'/P; % 13.102 +nu = mu+J*(nu0-Amu); % 13.100 +U = V+J*(U0-P)*J'; % 13.101 +Ezy = J*U0+nu0*nu'; % 13.106 +Ezz = U+nu*nu'; % 13.107 \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter13/LDS/ldsEm.m b/books/PRML/PRMLT-master-MATLAB/chapter13/LDS/ldsEm.m new file mode 100755 index 0000000..7f283e4 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter13/LDS/ldsEm.m @@ -0,0 +1,60 @@ +function [model, llh] = ldsEm(X, init) +% EM algorithm for parameter estimation of linear dynamic system. +% NOTE: This is the exact implementation of the EM algorithm in PRML. +% However, this algorithm is not practical. It is numerical unstable and +% there is too much redundant degree of freedom. +% Input: +% X: d x n data matrix +% model: prior model structure +% Output: +% model: trained model structure +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +d = size(X,1); +if isstruct(init) % init with a model + model = init; +elseif numel(init) == 1 % random init with latent k + k = init; + model.A = randn(k,k); + model.G = iwishrnd(eye(k),k); + model.C = randn(d,k); + model.S = iwishrnd(eye(d),d); + model.mu0 = randn(k,1); + model.P0 = iwishrnd(eye(k),k); +end +tol = 1e-2; +maxIter = 100; +llh = -inf(1,maxIter); +for iter = 2:maxIter +% E-step + [nu, U, Ezz, Ezy, llh(iter)] = kalmanSmoother(model,X); + if llh(iter)-llh(iter-1) < tol*abs(llh(iter-1)); break; end % check likelihood for convergence +% M-step + model = maximization(X, nu, U, Ezz, Ezy); +end +llh = llh(2:iter); + +function model = maximization(X ,nu, U, Ezz, Ezy) +n = size(X,2); +mu0 = nu(:,1); +P0 = U(:,:,1); + +Ezzn = sum(Ezz,3); +Ezz1 = Ezzn-Ezz(:,:,n); +Ezz2 = Ezzn-Ezz(:,:,1); +Ezy = sum(Ezy,3); + +A = Ezy/Ezz1; % 13.113 +EzyA = Ezy*A'; +G = (Ezz2-(EzyA+EzyA')+A*Ezz1*A')/(n-1); % 13.114 +Xnu = X*nu'; +C = Xnu/Ezzn; % 13.115 +XnuC = Xnu*C'; +S = (X*X'-(XnuC+XnuC')+C*Ezzn*C')/n; % 13.116 + +model.A = A; +model.G = G; +model.C = C; +model.S = S; +model.mu0 = mu0; +model.P0 = P0; diff --git a/books/PRML/PRMLT-master-MATLAB/chapter13/LDS/ldsRnd.m b/books/PRML/PRMLT-master-MATLAB/chapter13/LDS/ldsRnd.m new file mode 100755 index 0000000..1f4cb12 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter13/LDS/ldsRnd.m @@ -0,0 +1,32 @@ +function [X, Z, model] = ldsRnd(d, k, n) +% Generate a data sequence from linear dynamic system. +% Input: +% d: dimension of data +% k: dimension of latent variable +% n: number of data +% Output: +% X: d x n data matrix +% model: model structure +% Written by Mo Chen (sth4nth@gmail.com). +A = randn(k,k); +G = iwishrnd(eye(k),k); +C = randn(d,k); +S = iwishrnd(eye(d),d); +mu0 = randn(k,1); +P0 = iwishrnd(eye(k),k); + +X = zeros(d,n); +Z = zeros(k,n); +Z(:,1) = gaussRnd(mu0,P0); % 13.80 +X(:,1) = gaussRnd(C*Z(:,1),S); +for i = 2:n + Z(:,i) = gaussRnd(A*Z(:,i-1),G); % 13.75, 13.78 + X(:,i) = gaussRnd(C*Z(:,i),S); % 13.76, 13.79 +end + +model.A = A; % transition matrix +model.G = G; % transition covariance +model.C = C; % emission matrix +model.S = S; % emision covariance +model.mu0 = mu0; % prior mean +model.P0 = P0; % prior covairance diff --git a/books/PRML/PRMLT-master-MATLAB/chapter14/adaboostBin.m b/books/PRML/PRMLT-master-MATLAB/chapter14/adaboostBin.m new file mode 100755 index 0000000..b496cb1 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter14/adaboostBin.m @@ -0,0 +1,33 @@ +function model = adaboostBin(X, t) +% Adaboost for binary classification (weak learner: kmeans) +% Input: +% X: d x n data matrix +% t: 1 x n label (0/1) +% Output: +% model: trained model structure +% Written by Mo Chen (sth4nth@gmail.com). +t = t+1; +k = 2; +[d,n] = size(X); +w = ones(1,n)/n; +M = 100; +Alpha = zeros(1,M); +Theta = zeros(d,k,M); +T = sparse(1:n,t,1,n,k,n); % transform label into indicator matrix +for m = 1:M + % weak learner + E = spdiags(w',0,n,n)*T; + E = E*spdiags(1./sum(E,1)',0,k,k); + c = X*E; + [~,y] = min(sqdist(c,X),[],1); + Theta(:,:,m) = c; + % adaboost + I = y~=t; + e = dot(w,I); + alpha = log((1-e)/e); + w = w.*exp(alpha*I); + w = w/sum(w); + Alpha(m) = alpha; +end +model.alpha = Alpha; +model.theta = Theta; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter14/adaboostBinPred.m b/books/PRML/PRMLT-master-MATLAB/chapter14/adaboostBinPred.m new file mode 100755 index 0000000..861c0c4 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter14/adaboostBinPred.m @@ -0,0 +1,21 @@ +function t = adaboostBinPred(model, X) +% Prediction of binary Adaboost +% input: +% model: trained model structure +% X: d x n data matrix +% output: +% t: 1 x n prediction +% Written by Mo Chen (sth4nth@gmail.com). +Alpha = model.alpha; +Theta = model.theta; +M = size(Alpha,2); +t = zeros(1,size(X,2)); +for m = 1:M + c = Theta(:,:,m); + [~,y] = min(sqdist(c,X),[],1); + y(y==1) = -1; + y(y==2) = 1; + t = t+Alpha(m)*y; +end +t = sign(t); +t(t==-1) = 0; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/chapter14/mixLinPred.m b/books/PRML/PRMLT-master-MATLAB/chapter14/mixLinPred.m new file mode 100755 index 0000000..d747ee4 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter14/mixLinPred.m @@ -0,0 +1,25 @@ +function [y, z, p] = mixLinPred(model, X, t) +% Prediction function for mxiture of linear regression +% input: +% model: trained model structure +% X: d x n data matrix +% t:(optional) 1 x n responding vector +% output: +% y: 1 x n prediction +% z: 1 x n cluster label +% p: 1 x n predict probability for t +% Written by Mo Chen (sth4nth@gmail.com). +W = model.W; +alpha = model.alpha; +beta = model.beta; + +X = [X;ones(1,size(X,2))]; % adding the bias term +y = W'*X; +D = bsxfun(@minus,y,t).^2; +logRho = (-0.5)*beta*D; +logRho = bsxfun(@plus,logRho,log(alpha)); +T = logsumexp(logRho,1); +p = exp(T); +logR = bsxfun(@minus,logRho,T); +R = exp(logR); +z = max(R,[],1); diff --git a/books/PRML/PRMLT-master-MATLAB/chapter14/mixLinReg.m b/books/PRML/PRMLT-master-MATLAB/chapter14/mixLinReg.m new file mode 100755 index 0000000..7bf90cb --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter14/mixLinReg.m @@ -0,0 +1,52 @@ +function [label, model, llh] = mixLinReg(X, y, k, lambda) +% Mixture of linear regression +% input: +% X: d x n data matrix +% y: 1 x n responding vector +% k: number of mixture component +% lambda: regularization parameter +% output: +% label: 1 x n cluster label +% model: trained model structure +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 4 + lambda = 1; +end +n = size(X,2); +X = [X;ones(1,n)]; % adding the bias term +d = size(X,1); +label = ceil(k*rand(1,n)); % random initialization +R = full(sparse(label,1:n,1,k,n,n)); +tol = 1e-6; +maxiter = 500; +llh = -inf(1,maxiter); +Lambda = lambda*eye(d); +W = zeros(d,k); +Xy = bsxfun(@times,X,y); +beta = 1; +for iter = 2:maxiter + % maximization + nk = sum(R,2); + alpha = nk/n; + for j = 1:k + Xw = bsxfun(@times,X,sqrt(R(j,:))); + U = chol(Xw*Xw'+Lambda); + W(:,j) = U\(U'\(Xy*R(j,:)')); % 3.15 & 3.28 + end + D = bsxfun(@minus,W'*X,y).^2; + % expectation + logRho = (-0.5)*beta*D; + logRho = bsxfun(@plus,logRho,log(alpha)); + T = logsumexp(logRho,1); + logR = bsxfun(@minus,logRho,T); + R = exp(logR); + llh(iter) = sum(T)/n; + if abs(llh(iter)-llh(iter-1)) < tol*abs(llh(iter)); break; end +end +llh = llh(2:iter); +model.alpha = alpha; % mixing coefficient +model.beta = beta; % mixture component precision +model.W = W; % linear model coefficent +[~,label] = max(R,[],1); +model.label = label; diff --git a/books/PRML/PRMLT-master-MATLAB/chapter14/mixLinRnd.m b/books/PRML/PRMLT-master-MATLAB/chapter14/mixLinRnd.m new file mode 100755 index 0000000..9d3bd34 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter14/mixLinRnd.m @@ -0,0 +1,20 @@ +function [X, y, W ] = mixLinRnd(d, k, n) +% Generate data from mixture of linear model +% Input: +% d: dimension of data +% k: number of components +% n: number of data +% Output: +% X: d x n data matrix +% y: 1 x n response variable +% W: d+1 x k weight matrix +% Written by Mo Chen (sth4nth@gmail.com). +W = randn(d+1,k); +[X, z] = kmeansRnd(d, k, n); +y = zeros(1,n); +for j = 1:k + idx = (z == j); + y(idx) = W(1:(end-1),j)'*X(:,idx)+W(end,j); +end + + diff --git a/books/PRML/PRMLT-master-MATLAB/chapter14/mixLogitBin.m b/books/PRML/PRMLT-master-MATLAB/chapter14/mixLogitBin.m new file mode 100755 index 0000000..9cd65bd --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter14/mixLogitBin.m @@ -0,0 +1,57 @@ +function [model, llh] = mixLogitBin(X, t, k) +% Mixture of logistic regression model for binary classification optimized by Newton-Raphson method +% Input: +% X: d x n data matrix +% t: 1 x n label (0/1) +% k: number of mixture component +% Output: +% model: trained model structure +% llh: loglikelihood +% Written by Mo Chen (sth4nth@gmail.com). +n = size(X,2); +X = [X; ones(1,n)]; +d = size(X,1); +z = ceil(k*rand(1,n)); +R = full(sparse(1:n,z,1,n,k,n)); % n x k + +W = zeros(d,k); +tol = 1e-4; +maxiter = 100; +llh = -inf(1,maxiter); + +t = t(:); +h = ones(n,1); +h(t==0) = -1; +A = X'*W; +for iter = 2:maxiter + % maximization + nk = sum(R,1); + alpha = nk/n; + Y = sigmoid(A); + for j = 1:k + W(:,j) = newtonStep(X, t, Y(:,j), W(:,j), R(:,j)); + end + % expectation + A = X'*W; + logRho = -log1pexp(-bsxfun(@times,A,h)); + logRho = bsxfun(@plus,logRho,log(alpha)); + T = logsumexp(logRho,2); + llh(iter) = sum(T)/n; % loglikelihood + logR = bsxfun(@minus,logRho,T); + R = exp(logR); + + if abs(llh(iter)-llh(iter-1)) < tol*abs(llh(iter)); break; end +end +llh = llh(2:iter); +model.alpha = alpha; % mixing coefficient +model.W = W; % logistic model coefficent + + +function w = newtonStep(X, t, y, w, r) +lambda = 1e-6; +v = y.*(1-y).*r; +H = bsxfun(@times,X,v')*X'+lambda*eye(size(X,1)); +s = (y-t).*r; +g = X*s; +w = w-H\g; + diff --git a/books/PRML/PRMLT-master-MATLAB/chapter14/mixLogitBinPred.m b/books/PRML/PRMLT-master-MATLAB/chapter14/mixLogitBinPred.m new file mode 100755 index 0000000..1f4d10b --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/chapter14/mixLogitBinPred.m @@ -0,0 +1,14 @@ +function t = mixLogitBinPred(model, X) +% Prediction function for mixture of logistic regression +% input: +% model: trained model structure +% X: d x n data matrix +% output: +% t: 1 x n cluster label +% Written by Mo Chen (sth4nth@gmail.com). +alpha = model.alpha; % mixing coefficient +W = model.W ; % logistic model coefficentalpha +n = size(X,2); +X = [X; ones(1,n)]; +t = round(alpha*sigmoid(W'*X)); + diff --git a/books/PRML/PRMLT-master-MATLAB/common/besseliLn.m b/books/PRML/PRMLT-master-MATLAB/common/besseliLn.m new file mode 100755 index 0000000..b489938 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/besseliLn.m @@ -0,0 +1,10 @@ +function y = besseliLn(nu,x) +% Compute logarithm of besseli function (modified Bessel function of first kind). +% Written by Mo Chen (mochen80@gmail.com). +% TODO: improve precision using the method in +% Clustering on the Unit Hypersphere using von Mises-Fisher Distributions. A. Banerjee, I. S. Dhillon, J. Ghosh, and S. Sra +[v,ierr] = besseli(nu,x); +if any(ierr ~= 0) || any(v == Inf) + error('ERROR: logbesseli'); +end +y = log(v); diff --git a/books/PRML/PRMLT-master-MATLAB/common/gson.m b/books/PRML/PRMLT-master-MATLAB/common/gson.m new file mode 100755 index 0000000..66e4c46 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/gson.m @@ -0,0 +1,14 @@ +function [Q, R] = gson(X) +% Gram-Schmidt orthonormalization which produces the same result as [Q,R]=qr(X,0) +% Written by Mo Chen (sth4nth@gmail.com). +[d,n] = size(X); +m = min(d,n); +R = zeros(m,n); +Q = zeros(d,0); +for i = 1:m + R(1:i-1,i) = Q'*X(:,i); + v = X(:,i)-Q*R(1:i-1,i); + R(i,i) = norm(v); + Q(:,i) = v/R(i,i); +end +R(:,m+1:n) = Q'*X(:,m+1:n); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/common/invpd.m b/books/PRML/PRMLT-master-MATLAB/common/invpd.m new file mode 100755 index 0000000..572666c --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/invpd.m @@ -0,0 +1,11 @@ +function W = invpd(M) +% Compute A\B where A is a positive definite matrix +% Input: +% M: a positive difinie matrix +% Written by Michael Chen (sth4nth@gmail.com). +[U,p] = chol(M); +if p > 0 + error('ERROR: the matrix is not positive definite.'); +end +V = inv(U); +W = V*V'; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/common/isequalf.m b/books/PRML/PRMLT-master-MATLAB/common/isequalf.m new file mode 100755 index 0000000..c7300c6 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/isequalf.m @@ -0,0 +1,9 @@ +function z = isequalf(x, y, tol) +% Determine whether two float number x and y are equal up to precision tol +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 3 + tol = 1e-8; +end +assert(all(size(x)==size(y))); +z = max(abs(x(:)-y(:))) 18; +j = i & (x <= 33.3); +y(~i) = log1p(exp(x(~i))); +y(j) = x(j)+exp(-x(j)); diff --git a/books/PRML/PRMLT-master-MATLAB/common/logdet.m b/books/PRML/PRMLT-master-MATLAB/common/logdet.m new file mode 100755 index 0000000..0f280da --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/logdet.m @@ -0,0 +1,9 @@ +function y = logdet(A) +% Compute log(det(A)) where A is positive definite. +% Written by Michael Chen (sth4nth@gmail.com). +[U,p] = chol(A); +if p > 0 + y = -inf; +else + y = 2*sum(log(diag(U))); +end \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/common/loggmpdf.m b/books/PRML/PRMLT-master-MATLAB/common/loggmpdf.m new file mode 100755 index 0000000..01c2c25 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/loggmpdf.m @@ -0,0 +1,28 @@ +function r = loggmpdf(X, model) +% Compute log pdf of a Gaussian mixture model. +% Written by Mo Chen (sth4nth@gmail.com). +mu = model.mu; +Sigma = model.Sigma; +w = model.weight; + +n = size(X,2); +k = size(mu,2); +logRho = zeros(k,n); + +for i = 1:k + logRho(i,:) = loggausspdf(X,mu(:,i),Sigma(:,:,i)); +end +r = logsumexp(bsxfun(@plus,logRho,log(w)'),1); + + +function y = loggausspdf(X, mu, Sigma) +d = size(X,1); +X = bsxfun(@minus,X,mu); +[U,p]= chol(Sigma); +if p ~= 0 + error('ERROR: Sigma is not PD.'); +end +Q = U'\X; +q = dot(Q,Q,1); % quadratic term (M distance) +c = d*log(2*pi)+2*sum(log(diag(U))); % normalization constant +y = -(c+q)/2; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/common/lognormexp.m b/books/PRML/PRMLT-master-MATLAB/common/lognormexp.m new file mode 100755 index 0000000..8db9c78 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/lognormexp.m @@ -0,0 +1,10 @@ +function [Y,s] = lognormexp(X, dim) +% Compute log(normalize(exp(x),dim)) while avoiding numerical underflow. +% By default dim = 1 (columns). +% Written by Mo Chen (sth4nth@gmail.com). +if nargin == 1 + dim = find(size(X)~=1,1); + if isempty(dim), dim = 1; end +end +s = logsumexp(X,dim); +Y = X-s; diff --git a/books/PRML/PRMLT-master-MATLAB/common/logsumexp.m b/books/PRML/PRMLT-master-MATLAB/common/logsumexp.m new file mode 100755 index 0000000..67b36bc --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/logsumexp.m @@ -0,0 +1,12 @@ +function s = logsumexp(X, dim) +% Compute log(sum(exp(X),dim)) while avoiding numerical underflow. +% By default dim = 1 (columns). +% Written by Mo Chen (sth4nth@gmail.com). +if nargin == 1 + dim = find(size(X)~=1,1); + if isempty(dim), dim = 1; end +end +a = max(X,[],dim); +s = a+log(sum(exp(X-a),dim)); % TODO: use log1p +i = isinf(a); +s(i) = a(i); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/common/maxdiff.m b/books/PRML/PRMLT-master-MATLAB/common/maxdiff.m new file mode 100755 index 0000000..d620287 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/maxdiff.m @@ -0,0 +1,5 @@ +function z = maxdiff(x, y) +% Written by Mo Chen (sth4nth@gmail.com). +assert(all(size(x)==size(y))); +z = max(abs(x(:)-y(:))); + diff --git a/books/PRML/PRMLT-master-MATLAB/common/mgson.m b/books/PRML/PRMLT-master-MATLAB/common/mgson.m new file mode 100755 index 0000000..ecea8b3 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/mgson.m @@ -0,0 +1,18 @@ +function [Q, R] = mgson(X) +% Modified Gram-Schmidt orthonormalization (numerical stable version of Gram-Schmidt algorithm) +% which produces the same result as [Q,R]=qr(X,0) +% Written by Mo Chen (sth4nth@gmail.com). +[d,n] = size(X); +m = min(d,n); +R = zeros(m,n); +Q = zeros(d,m); +for i = 1:m + v = X(:,i); + for j = 1:i-1 + R(j,i) = Q(:,j)'*v; + v = v-R(j,i)*Q(:,j); + end + R(i,i) = norm(v); + Q(:,i) = v/R(i,i); +end +R(:,m+1:n) = Q'*X(:,m+1:n); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/common/normalize.m b/books/PRML/PRMLT-master-MATLAB/common/normalize.m new file mode 100755 index 0000000..9bca004 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/normalize.m @@ -0,0 +1,11 @@ +function [Y, s] = normalize(X, dim) +% Normalize the vectors to be summing to one +% By default dim = 1 (columns). +% Written by Michael Chen (sth4nth@gmail.com). +if nargin == 1 + % Determine which dimension sum will use + dim = find(size(X)~=1,1); + if isempty(dim), dim = 1; end +end +s = sum(X,dim); +Y = X./s; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/common/plotClass.m b/books/PRML/PRMLT-master-MATLAB/common/plotClass.m new file mode 100755 index 0000000..a8c4514 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/plotClass.m @@ -0,0 +1,37 @@ +function plotClass(X, label) +% Plot 2d/3d samples of different classes with different colors. +% Written by Mo Chen (sth4nth@gmail.com). +[d,n] = size(X); +if nargin == 1 + label = ones(n,1); +end +assert(n == length(label)); + +color = 'brgmcyk'; +m = length(color); +c = max(label); + +figure(gcf); +clf; +hold on; +switch d + case 2 + view(2); + for i = 1:c + idc = label==i; +% plot(X(1,label==i),X(2,label==i),['.' color(i)],'MarkerSize',15); + scatter(X(1,idc),X(2,idc),36,color(mod(i-1,m)+1)); + end + case 3 + view(3); + for i = 1:c + idc = label==i; +% plot3(X(1,idc),X(2,idci),X(3,idc),['.' idc],'MarkerSize',15); + scatter3(X(1,idc),X(2,idc),X(3,idc),36,color(mod(i-1,m)+1)); + end + otherwise + error('ERROR: only support data of 2D or 3D.'); +end +axis equal +grid on +hold off \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/common/plotCurveBar.m b/books/PRML/PRMLT-master-MATLAB/common/plotCurveBar.m new file mode 100755 index 0000000..835fefe --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/plotCurveBar.m @@ -0,0 +1,18 @@ +function plotCurveBar( x, y, sigma ) +% Plot 1d curve and variance +% Input: +% x: 1 x n +% y: 1 x n +% sigma: 1 x n or scaler +% Written by Mo Chen (sth4nth@gmail.com). +color = [255,228,225]/255; %pink +[x,idx] = sort(x); +y = y(idx); +sigma = sigma(idx); + +fill([x,fliplr(x)],[y+sigma,fliplr(y-sigma)],color); +hold on; +plot(x,y,'r-'); +hold off +axis([x(1),x(end),-inf,inf]) + diff --git a/books/PRML/PRMLT-master-MATLAB/common/plotgm.m b/books/PRML/PRMLT-master-MATLAB/common/plotgm.m new file mode 100755 index 0000000..5915b4e --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/plotgm.m @@ -0,0 +1,27 @@ +function plotgm(X, model) +% Plot 2d Gaussian mixture model. +% Written by Mo Chen (sth4nth@gmail.com). +level = 64; +n = 256; + +spread(X); +x_range = xlim; +y_range = ylim; + +x = linspace(x_range(1),x_range(2), n); +y = linspace(y_range(2),y_range(1), n); + +[a,b] = meshgrid(x,y); +z = exp(loggmpdf([a(:)';b(:)'],model)); + +z = z-min(z); +z = floor(z/max(z)*(level-1)); + +figure; +image(reshape(z,n,n)); +colormap(jet(level)); +set(gca, 'XTick', [1 256]); +set(gca, 'XTickLabel', [min(x) max(x)]); +set(gca, 'YTick', [1 256]); +set(gca, 'YTickLabel', [min(y) max(y)]); +axis off diff --git a/books/PRML/PRMLT-master-MATLAB/common/plotkde.m b/books/PRML/PRMLT-master-MATLAB/common/plotkde.m new file mode 100755 index 0000000..0b51a66 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/plotkde.m @@ -0,0 +1,33 @@ +function plotkde(X, sigma2) +% Plot 2d kernel density. +% Written by Mo Chen (sth4nth@gmail.com). +if nargin < 2 + sigma2 = 1e-1; +end +level = 64; +n = 256; + +X = standardize(X); + +spread(X); +x_range = xlim; +y_range = ylim; + +x = linspace(x_range(1),x_range(2), n); +y = linspace(y_range(2),y_range(1), n); + +[a,b] = meshgrid(x,y); + +z = exp(logkdepdf([a(:)';b(:)'],X,sigma2)); + +z = z-min(z); +z = floor(z/max(z)*(level-1)); + +figure; +image(reshape(z,n,n)); +colormap(jet(level)); +set(gca, 'XTick', [1 256]); +set(gca, 'XTickLabel', [min(x) max(x)]); +set(gca, 'YTick', [1 256]); +set(gca, 'YTickLabel', [min(y) max(y)]); +axis off diff --git a/books/PRML/PRMLT-master-MATLAB/common/randp.m b/books/PRML/PRMLT-master-MATLAB/common/randp.m new file mode 100755 index 0000000..731c97e --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/randp.m @@ -0,0 +1,3 @@ +function i = randp(p) +% Sample a integer in [1:k] with given probability p +i = find(rand 0 + error('ERROR: the matrix is not positive definite.'); +end +V = U\(U'\B); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/common/sqdist.m b/books/PRML/PRMLT-master-MATLAB/common/sqdist.m new file mode 100755 index 0000000..e836d50 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/sqdist.m @@ -0,0 +1,8 @@ +function D = sqdist(X1, X2) +% Pairwise square Euclidean distance between two sample sets +% Input: +% X1, X2: dxn1 dxn2 sample matrices +% Output: +% D: n1 x n2 square Euclidean distance matrix +% Written by Mo Chen (sth4nth@gmail.com). +D = dot(X1,X1,1)'+dot(X2,X2,1)-2*(X1'*X2); diff --git a/books/PRML/PRMLT-master-MATLAB/common/standardize.m b/books/PRML/PRMLT-master-MATLAB/common/standardize.m new file mode 100755 index 0000000..14321ab --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/standardize.m @@ -0,0 +1,7 @@ +function [Y, s] = standardize(X) +% Unitize the vectors to be unit length +% By default dim = 1 (columns). +% Written by Mo Chen (sth4nth@gmail.com). +X = bsxfun(@minux,X,mean(X,2)); +s = sqrt(mean(sum(X.^2,1))); +Y = X/s; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/common/sub.m b/books/PRML/PRMLT-master-MATLAB/common/sub.m new file mode 100755 index 0000000..8d7de28 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/sub.m @@ -0,0 +1,17 @@ +function B = sub(A, varargin) +% sub(A,i,j,k) = A(i;j;k) +% Written by Mo Chen (sth4nth@gmail.com). +assert(ndims(A)==numel(varargin)); +sz = cellfun(@numel,varargin); +IDX = cell(1,ndims(A)); +for i = 1:ndims(A) + idx = varargin{i}; + shape = ones(1,ndims(A)); + shape(i) = sz(i); + idx = reshape(idx,shape); + shape = sz; + shape(i) = 1; + idx = repmat(idx,shape); + IDX{i} = idx(:); +end +B = reshape(A(sub2ind(size(A),IDX{:})),sz); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/common/symeig.m b/books/PRML/PRMLT-master-MATLAB/common/symeig.m new file mode 100755 index 0000000..6800a45 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/symeig.m @@ -0,0 +1,16 @@ +function [V,A,flag] = symeig(S,d,m) +% Compute eigenvalues and eigenvectors of symmetric matrix +% m == 's' smallest (default) +% m == 'l' largest +% Written by Mo Chen (sth4nth@gmail.com). +if nargin == 2 + m = 's'; +end +opt.disp = 0; +opt.issym = 1; +opt.isreal = 1; +if any(m == 'ls') + [V,A,flag] = eigs(S,d,[m,'a'],opt); +else + error('The third parameter must be l or s.'); +end diff --git a/books/PRML/PRMLT-master-MATLAB/common/ud.m b/books/PRML/PRMLT-master-MATLAB/common/ud.m new file mode 100755 index 0000000..4f1ea34 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/ud.m @@ -0,0 +1,7 @@ +function [U, D] = ud(X) +% UD factorization U'*D*U=X'*X; +% Written by Mo Chen (sth4nth@gmail.com). +[~,R] = qr(X,0); +d = diag(R); +D = d.^2; +U = bsxfun(@times,R,1./d); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/common/unitize.m b/books/PRML/PRMLT-master-MATLAB/common/unitize.m new file mode 100755 index 0000000..22297be --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/common/unitize.m @@ -0,0 +1,11 @@ +function [Y, s] = unitize(X, dim) +% Unitize the vectors to be unit length +% By default dim = 1 (columns). +% Written by Mo Chen (sth4nth@gmail.com). +if nargin == 1 + % Determine which dimension sum will use + dim = find(size(X)~=1,1); + if isempty(dim), dim = 1; end +end +s = sqrt(dot(X,X,dim)); +Y = bsxfun(@times,X,1./s); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch01/info_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch01/info_demo.m new file mode 100755 index 0000000..404254a --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch01/info_demo.m @@ -0,0 +1,37 @@ + +% demos for ch01 +clear; +k = 10; % variable range +n = 100; % number of variables + +x = ceil(k*rand(1,n)); +y = ceil(k*rand(1,n)); + +%% Entropy H(x), H(y) +Hx = entropy(x); +Hy = entropy(y); +%% Joint entropy H(x,y) +Hxy = jointEntropy(x,y); +%% Conditional entropy H(x|y) +Hx_y = condEntropy(x,y); +%% Mutual information I(x,y) +Ixy = mutInfo(x,y); +%% Relative entropy (KL divergence) KL(p(x)|p(y)) +Dxy = relatEntropy(x,y); +%% Normalized mutual information I_n(x,y) +nIxy = nmi(x,y); +%% Nomalized variation information I_v(x,y) +vIxy = nvi(x,y); +%% H(x|y) = H(x,y)-H(y) +isequalf(Hx_y,Hxy-Hy) +%% I(x,y) = H(x)-H(x|y) +isequalf(Ixy,Hx-Hx_y) +%% I(x,y) = H(x)+H(y)-H(x,y) +isequalf(Ixy,Hx+Hy-Hxy) +%% I_n(x,y) = I(x,y)/sqrt(H(x)*H(y)) +isequalf(nIxy,Ixy/sqrt(Hx*Hy)) +%% I_v(x,y) = (1-I(x,y)/H(x,y)) +isequalf(vIxy,1-Ixy/Hxy) + + + diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch03/linRegEm_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch03/linRegEm_demo.m new file mode 100755 index 0000000..b635b49 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch03/linRegEm_demo.m @@ -0,0 +1,14 @@ +% demos for ch03 +clear; close all; +d = 1; +n = 200; +[x,t] = linRnd(d,n); +%% Empirical Bayesian linear regression via EM +[model,llh] = linRegEm(x,t); +plot(llh); +[y,sigma] = linRegPred(model,x,t); +figure +plotCurveBar(x,y,sigma); +hold on; +plot(x,t,'o'); +hold off; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch03/linRegFp_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch03/linRegFp_demo.m new file mode 100755 index 0000000..55110e8 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch03/linRegFp_demo.m @@ -0,0 +1,16 @@ +% demos for ch03 +clear; close all; +d = 1; +n = 200; +[x,t] = linRnd(d,n); +%% Empirical Bayesian linear regression via Mackay fix point iteration method +[model,llh] = linRegFp(x,t); +plot(llh); +[y,sigma] = linRegPred(model,x,t); +figure +plotCurveBar(x,y,sigma); +hold on; +plot(x,t,'o'); +hold off; +%% + diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch03/linReg_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch03/linReg_demo.m new file mode 100755 index 0000000..9093ae2 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch03/linReg_demo.m @@ -0,0 +1,12 @@ +% demos for ch03 +clear; close all; +d = 1; +n = 200; +[x,t] = linRnd(d,n); +%% Linear regression +model = linReg(x,t); +[y,sigma] = linRegPred(model,x,t); +plotCurveBar( x, y, sigma ); +hold on; +plot(x,t,'o'); +hold off; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch04/logitBin_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch04/logitBin_demo.m new file mode 100755 index 0000000..dd2c020 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch04/logitBin_demo.m @@ -0,0 +1,14 @@ +% demos for ch04 + +%% Logistic logistic regression for binary classification +close all; +clear; +d = 2; +k = 2; +n = 1000; +[X,y] = kmeansRnd(d,k,n); +[model, llh] = logitBin(X,y-1); +plot(llh); +t = logitBinPred(model,X)+1; +figure +binPlot(model,X,y) \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch04/logitMn_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch04/logitMn_demo.m new file mode 100755 index 0000000..30ea64b --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch04/logitMn_demo.m @@ -0,0 +1,8 @@ +%% Logistic logistic regression for multiclass classification +clear +k = 3; +n = 1000; +[X,t] = kmeansRnd(2,k,n); +[model, llh] = logitMn(X,t); +y = logitMnPred(model,X); +plotClass(X,y) diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch05/mlp_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch05/mlp_demo.m new file mode 100755 index 0000000..9e55c26 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch05/mlp_demo.m @@ -0,0 +1,9 @@ +clear; close all; +h = [4,5]; +X = [0 0 1 1;0 1 0 1]; +T = [0 1 1 0]; +[model,mse] = mlp(X,T,h); +plot(mse); +disp(['T = [' num2str(T) ']']); +Y = mlpPred(model,X); +disp(['Y = [' num2str(Y) ']']); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch06/knCenter_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch06/knCenter_demo.m new file mode 100755 index 0000000..eb258a9 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch06/knCenter_demo.m @@ -0,0 +1,9 @@ +%% demo for knCenter +clear; close all; +kn = @knGauss; +X=rand(2,100); +X1=rand(2,10); +X2=rand(2,5); + +maxdiff(knCenter(kn,X,X1),diag(knCenter(kn,X,X1,X1))') +maxdiff(knCenter(kn,X),knCenter(kn,X,X,X)) \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch06/knLin_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch06/knLin_demo.m new file mode 100755 index 0000000..9ae12b3 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch06/knLin_demo.m @@ -0,0 +1,61 @@ +%% Kernel regression with linear kernel is EQUIVALENT to linear regression +clear; close all; +n = 100; +x = linspace(0,2*pi,n); % test data +t = sin(x)+rand(1,n)/2; + +lambda = 1e-4; +model_kn = knReg(x,t,lambda,@knLin); +model_lin = linReg(x,t,lambda); + +idx = 1:2:n; +xt = x(:,idx); +tt = t(idx); + +[y_kn, sigma_kn,p_kn] = knRegPred(model_kn,xt,tt); +[y_lin, sigma_lin,p_lin] = linRegPred(model_lin,xt,tt); + +maxdiff(y_kn,y_lin) +maxdiff(sigma_kn,sigma_lin) +maxdiff(p_kn,p_lin) +%% Kernel kmeans with linear kernel is EQUIVALENT to kmeans +clear; close all; +d = 2; +k = 3; +n = 500; +[X,y] = kmeansRnd(d,k,n); +init = ceil(k*rand(1,n)); +[y_kn,model_kn,en_kn] = knKmeans(X,init,@knLin); +[y_lin,model_lin,en_lin] = kmeans(X,init); + +idx = 1:2:n; +Xt = X(:,idx); + +[t_kn,ent_kn] = knKmeansPred(model_kn, Xt); +[t_lin,ent_lin] = kmeansPred(model_lin, Xt); + +maxdiff(y_kn,y_lin) +maxdiff(en_kn,en_lin) + +maxdiff(t_kn,t_lin) +maxdiff(ent_kn,ent_lin) +%% Kernel PCA with linear kernel is EQUIVALENT TO PCA +clear; close all; +d = 10; +q = 2; +n = 500; +X = randn(d,n); + + +model_kn = knPca(X,q,@knLin); +idx = 1:2:n; +Xt = X(:,idx); + +Y_kn = knPcaPred(model_kn,Xt); + +[U,L,mu,mse] = pca(X,q); +Y_lin = U'*bsxfun(@minus,Xt,mu); % projection + + +R = Y_lin/Y_kn; % the results are equivalent up to a rotation. +maxdiff(R*R', eye(q)) diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch06/knReg_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch06/knReg_demo.m new file mode 100755 index 0000000..edcdb7b --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch06/knReg_demo.m @@ -0,0 +1,14 @@ +% demos for ch06 + + +%% Kernel regression with gaussian kernel +clear; close all; +n = 100; +x = linspace(0,2*pi,n); % test data +t = sin(x)+rand(1,n)/2; +model = knReg(x,t,1e-4,@knGauss); +[y,s] = knRegPred(model,x); +plotCurveBar(x,y,s); +hold on; +plot(x,t,'o'); +hold off; \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmBinEm_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmBinEm_demo.m new file mode 100755 index 0000000..039e856 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmBinEm_demo.m @@ -0,0 +1,12 @@ +%% RVM for classification +clear; close all +k = 2; +d = 2; +n = 1000; +[X,t] = kmeansRnd(d,k,n); + +[model, llh] = rvmBinEm(X,t-1); +plot(llh); +y = rvmBinPred(model,X)+1; +figure; +binPlot(model,X,y); diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmBinFp_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmBinFp_demo.m new file mode 100755 index 0000000..2dcb2ae --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmBinFp_demo.m @@ -0,0 +1,12 @@ +%% RVM for classification +clear; close all +k = 2; +d = 2; +n = 1000; +[X,t] = kmeansRnd(d,k,n); + +[model, llh] = rvmBinFp(X,t-1); +plot(llh); +y = rvmBinPred(model,X)+1; +figure; +binPlot(model,X,y); diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegEm_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegEm_demo.m new file mode 100755 index 0000000..951e3fe --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegEm_demo.m @@ -0,0 +1,18 @@ +%% regression +d = 100; +beta = 1e-1; +X = rand(1,d); +w = randn; +b = randn; +t = w'*X+b+beta*randn(1,d); +x = linspace(min(X),max(X),d); % test data + +%% RVM regression by EM +[model,llh] = rvmRegEm(X,t); +plot(llh); +[y, sigma] = linRegPred(model,x,t); +figure +plotCurveBar(x,y,sigma); +hold on; +plot(X,t,'o'); +hold off \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegEm_spSignal_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegEm_spSignal_demo.m new file mode 100755 index 0000000..9f72777 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegEm_spSignal_demo.m @@ -0,0 +1,37 @@ +% demos for ch07 + +%% sparse signal recovery demo +clear; close all; + +d = 512; % signal length +k = 20; % number of spikes +n = 100; % number of measurements +% +% random +/- 1 signal +x = zeros(d,1); +q = randperm(d); +x(q(1:k)) = sign(randn(k,1)); + +% projection matrix +A = unitize(randn(d,n),1); +% noisy observations +sigma = 0.005; +e = sigma*randn(1,n); +y = x'*A + e; + +[model,llh] = rvmRegEm(A,y); +plot(llh); + +m = zeros(d,1); +m(model.index) = model.w; + +h = max(abs(x))+0.2; +x_range = [1,d]; +y_range = [-h,+h]; +figure; +subplot(2,1,1);plot(x); axis([x_range,y_range]); title('Original Signal'); +subplot(2,1,2);plot(m); axis([x_range,y_range]); title('Recovery Signal'); + + + + diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegFp_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegFp_demo.m new file mode 100755 index 0000000..6e2ce7c --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegFp_demo.m @@ -0,0 +1,19 @@ +%% regression +d = 100; +beta = 1e-1; +X = rand(1,d); +w = randn; +b = randn; +t = w'*X+b+beta*randn(1,d); +x = linspace(min(X),max(X),d); % test data + + +%% RVM regression by Mackay fix point update +[model,llh] = rvmRegFp(X,t); +plot(llh); +[y, sigma] = linRegPred(model,x,t); +figure +plotCurveBar(x,y,sigma); +hold on; +plot(X,t,'o'); +hold off \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegFp_spSignal_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegFp_spSignal_demo.m new file mode 100755 index 0000000..0166457 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegFp_spSignal_demo.m @@ -0,0 +1,37 @@ +% demos for ch07 + +%% sparse signal recovery demo +clear; close all; + +d = 512; % signal length +k = 20; % number of spikes +n = 100; % number of measurements +% +% random +/- 1 signal +x = zeros(d,1); +q = randperm(d); +x(q(1:k)) = sign(randn(k,1)); + +% projection matrix +A = unitize(randn(d,n),1); +% noisy observations +sigma = 0.005; +e = sigma*randn(1,n); +y = x'*A + e; + +[model,llh] = rvmRegFp(A,y); +plot(llh); + +m = zeros(d,1); +m(model.index) = model.w; + +h = max(abs(x))+0.2; +x_range = [1,d]; +y_range = [-h,+h]; +figure; +subplot(2,1,1);plot(x); axis([x_range,y_range]); title('Original Signal'); +subplot(2,1,2);plot(m); axis([x_range,y_range]); title('Recovery Signal'); + + + + diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegSeq_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegSeq_demo.m new file mode 100755 index 0000000..7967f38 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegSeq_demo.m @@ -0,0 +1,17 @@ +%% regression +d = 100; +beta = 1e-1; +X = rand(1,d); +w = randn; +b = randn; +t = w'*X+b+beta*randn(1,d); +x = linspace(min(X),max(X),d); % test data +%% RVM regression by sequential update +[model,llh] = rvmRegSeq(X,t); +plot(llh); +[y, sigma] = linRegPred(model,x,t); +figure +plotCurveBar(x,y,sigma); +hold on; +plot(X,t,'o'); +hold off \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegSeq_spSignal_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegSeq_spSignal_demo.m new file mode 100755 index 0000000..d129842 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch07/rvmRegSeq_spSignal_demo.m @@ -0,0 +1,37 @@ +% demos for ch07 + +%% sparse signal recovery demo +clear; close all; + +d = 512; % signal length +k = 20; % number of spikes +n = 100; % number of measurements +% +% random +/- 1 signal +x = zeros(d,1); +q = randperm(d); +x(q(1:k)) = sign(randn(k,1)); + +% projection matrix +A = unitize(randn(d,n),1); +% noisy observations +sigma = 0.005; +e = sigma*randn(1,n); +y = x'*A + e; + +[model,llh] = rvmRegSeq(A,y); +plot(llh); + +m = zeros(d,1); +m(model.index) = model.w; + +h = max(abs(x))+0.2; +x_range = [1,d]; +y_range = [-h,+h]; +figure; +subplot(2,1,1);plot(x); axis([x_range,y_range]); title('Original Signal'); +subplot(2,1,2);plot(m); axis([x_range,y_range]); title('Recovery Signal'); + + + + diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch08/letterX.mat b/books/PRML/PRMLT-master-MATLAB/demo/ch08/letterX.mat new file mode 100755 index 0000000..eab4464 Binary files /dev/null and b/books/PRML/PRMLT-master-MATLAB/demo/ch08/letterX.mat differ diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch08/mrf_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch08/mrf_demo.m new file mode 100755 index 0000000..5cede61 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch08/mrf_demo.m @@ -0,0 +1,65 @@ +clear; close all; +%% Original image +load letterX.mat +img = double(X); +img = sign(img-mean(img(:))); + +figure; +subplot(2,3,1); +imagesc(img); +title('Original image'); +axis image; +colormap gray; +%% Noisy image +y = img + sigma*randn(size(img)); % noisy signal + +subplot(2,3,2); +imagesc(y); +title('Noisy image'); +axis image; +colormap gray; +%% Parameters +epoch = 50; +J = 1; % Ising parameter +sigma = 1; % noise level +%% Mean Field +[A, nodePot, edgePot] = im2mrf(y, J, sigma); +[nodeBel, edgeBel] = mrfMeanField(A, nodePot, edgePot, epoch); +lnZ = gibbsEnergy(nodePot, edgePot, nodeBel, edgeBel); +lnZ0 = betheEnergy(A, nodePot, edgePot, nodeBel, edgeBel); +maxdiff(lnZ, lnZ0) + +subplot(2,3,4); +imagesc(reshape(nodeBel(1,:),size(img))); +title('Mean Field'); +axis image; +colormap gray; +%% Ising Mean Field +h = reshape(0.5*diff(nodePot),size(img)); +mu = isingMeanField(J, h, epoch); +maxdiff(reshape(mu,1,[]), [1,-1]*nodeBel) + +subplot(2,3,3); +imagesc(mu) +title('Ising Mean Field'); +axis image; +colormap gray; +%% Belief Propagation +[nodeBel,edgeBel] = mrfBelProp(A, nodePot, edgePot, epoch); +lnZ = betheEnergy(A, nodePot, edgePot, nodeBel, edgeBel); + +subplot(2,3,5); +imagesc(reshape(nodeBel(1,:),size(img))); +title('Belief propagation'); +axis image; +colormap gray; +%% Expectation Propagation +[nodeBel,edgeBel] = mrfExpProp(A, nodePot, edgePot, epoch); +lnZ0 = betheEnergy(A, nodePot, edgePot, nodeBel, edgeBel); +maxdiff(lnZ, lnZ0) + +subplot(2,3,6); +imagesc(reshape(nodeBel(1,:),size(img))); +title('Expectation Propagation'); +axis image; +colormap gray; diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch08/nbBern_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch08/nbBern_demo.m new file mode 100755 index 0000000..15f8784 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch08/nbBern_demo.m @@ -0,0 +1,14 @@ +%% Naive Bayes with independent Bernoulli +close all; clear; +d = 10; +k = 2; +n = 2000; +[X,t,mu] = mixBernRnd(d,k,n); +m = floor(n/2); +X1 = X(:,1:m); +X2 = X(:,(m+1):end); +t1 = t(1:m); +t2 = t((m+1):end); +model = nbBern(X1,t1); +y2 = nbBernPred(model,X2); +err = sum(t2~=y2)/numel(t2); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch08/nbGauss_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch08/nbGauss_demo.m new file mode 100755 index 0000000..34c2a0d --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch08/nbGauss_demo.m @@ -0,0 +1,13 @@ +d = 2; +k = 3; +n = 1000; +[X, t] = kmeansRnd(d,k,n); +plotClass(X,t); + +m = floor(n/2); +X1 = X(:,1:m); +X2 = X(:,(m+1):end); +t1 = t(1:m); +model = nbGauss(X1,t1); +y2 = nbGaussPred(model,X2); +plotClass(X2,y2); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch09/kmeans_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch09/kmeans_demo.m new file mode 100755 index 0000000..9a725f9 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch09/kmeans_demo.m @@ -0,0 +1,29 @@ +close all; clear; +d = 2; +k = 3; +n = 5000; +%% Generate data +[X,label] = kmeansRnd(d,k,n); +plotClass(X,label); +%% kmeans with random initialization +y = kmeans(X,k); +figure; +plotClass(X,y); +%% kmeans init with labels +y = kmeans(X,label); +figure; +plotClass(X,y); +%% kmeans init with centers +mu = rand(d,k); +y = kmeans(X,mu); +figure; +plotClass(X,y); +%% kmeans init with kmeans++ seeding +y = kmeans(X,kseeds(X,k)); +figure; +plotClass(X,y); +%% kmeans++ seeding +mu = kseeds(X,k); +[~,y] = min(dot(mu,mu,1)'/2-mu'*X,[],1); % assign sample labels +figure; +plotClass(X,y); diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch09/kmeans_mixGaussEm_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch09/kmeans_mixGaussEm_demo.m new file mode 100755 index 0000000..1b08b3f --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch09/kmeans_mixGaussEm_demo.m @@ -0,0 +1,17 @@ + +%% Gauss mixture initialized by kmeans +close all; clear; +d = 2; +k = 3; +n = 500; +[X,label] = mixGaussRnd(d,k,n); +init = kmeans(X,k); +[z,model,llh] = mixGaussEm(X,init); +plotClass(X,label); +figure; +plotClass(X,init); +figure; +plotClass(X,z); +figure; +plot(llh); + diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch09/kmedoids_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch09/kmedoids_demo.m new file mode 100755 index 0000000..1f36b16 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch09/kmedoids_demo.m @@ -0,0 +1,11 @@ +close all; clear; +d = 2; +k = 3; +n = 5000; +[X,label] = kmeansRnd(d,k,n); +init = ceil(k*rand(1,n)); +[y, idx, v] = kmedoids(X,init); +plotClass(X,label); +figure; +plotClass(X,y); + diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch09/linRegEm_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch09/linRegEm_demo.m new file mode 100755 index 0000000..5314239 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch09/linRegEm_demo.m @@ -0,0 +1,7 @@ +%% Empirical Bayesian linear regression via EM +close all; clear; +d = 5; +n = 200; +[x,t] = linRnd(d,n); +[model,llh] = linRegEm(x,t); +plot(llh); diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch09/mixBernEm_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch09/mixBernEm_demo.m new file mode 100755 index 0000000..737d8c0 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch09/mixBernEm_demo.m @@ -0,0 +1,8 @@ +%% Bernoulli Mixture via EM +close all; clear; +d = 2; +k = 3; +n = 5000; +[X,z,mu] = mixBernRnd(d,k,n); +[label,model,llh] = mixBernEm(X,k); +plot(llh); diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch09/mixGaussEm_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch09/mixGaussEm_demo.m new file mode 100755 index 0000000..a6ab295 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch09/mixGaussEm_demo.m @@ -0,0 +1,21 @@ +%% Gausssian Mixture via EM +close all; clear; +d = 2; +k = 3; +n = 1000; +[X,label] = mixGaussRnd(d,k,n); +plotClass(X,label); + +m = floor(n/2); +X1 = X(:,1:m); +X2 = X(:,(m+1):end); +% train +[z1,model,llh] = mixGaussEm(X1,k); +figure; +plot(llh); +figure; +plotClass(X1,z1); +% predict +z2 = mixGaussPred(model,X2); +figure; +plotClass(X2,z2); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch09/rvmBinEm_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch09/rvmBinEm_demo.m new file mode 100755 index 0000000..f15ae6e --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch09/rvmBinEm_demo.m @@ -0,0 +1,13 @@ +%% RVM classification via EM +clear; close all +k = 2; +d = 2; +n = 1000; +[X,t] = kmeansRnd(d,k,n); +[x1,x2] = meshgrid(linspace(min(X(1,:)),max(X(1,:)),n), linspace(min(X(2,:)),max(X(2,:)),n)); + +[model, llh] = rvmBinEm(X,t-1); +plot(llh); +y = rvmBinPred(model,X)+1; +figure; +binPlot(model,X,y); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch10/mixGaussVb_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch10/mixGaussVb_demo.m new file mode 100755 index 0000000..ee336d5 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch10/mixGaussVb_demo.m @@ -0,0 +1,30 @@ + +%% Variational Bayesian for Gaussian Mixture Model +close all; clear; +d = 2; +k = 3; +n = 2000; +[X,z] = mixGaussRnd(d,k,n); +plotClass(X,z); +m = floor(n/2); +X1 = X(:,1:m); +X2 = X(:,(m+1):end); +% VB fitting +[y1, model, L] = mixGaussVb(X1,10); +figure; +plotClass(X1,y1); +figure; +plot(L) +% Model Evidence +prior.alpha = 1; +prior.kappa = 1; +prior.m = mean(X1,2); +prior.v = d+1; +prior.M = eye(d); % M = inv(W) +L0 = mixGaussEvidence(X1, model, prior); +L0-L(end) +% Predict testing data +[y2, R] = mixGaussVbPred(model,X2); +figure; +plotClass(X2,y2); + diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch10/rvmRegVb_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch10/rvmRegVb_demo.m new file mode 100755 index 0000000..dbe913a --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch10/rvmRegVb_demo.m @@ -0,0 +1,19 @@ +clear; close all; + +d = 100; +beta = 1e-1; +X = rand(1,d); +w = randn; +b = randn; +t = w'*X+b+beta*randn(1,d); +x = linspace(min(X),max(X),d); % test data + +[model,llh] = linRegVb(X,t); +% [model,llh] = rvmRegVb(X,t); +plot(llh); +[y, sigma] = linRegPred(model,x,t); +figure +plotCurveBar(x,y,sigma); +hold on; +plot(X,t,'o'); +hold off \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch10/rvmRegVb_spSignal_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch10/rvmRegVb_spSignal_demo.m new file mode 100755 index 0000000..f330ca3 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch10/rvmRegVb_spSignal_demo.m @@ -0,0 +1,34 @@ +% demos for ch07 + +%% sparse signal recovery demo +clear; close all; + +d = 512; % signal length +k = 20; % number of spikes +n = 100; % number of measurements +% +% random +/- 1 signal +x = zeros(d,1); +q = randperm(d); +x(q(1:k)) = sign(randn(k,1)); + +% projection matrix +A = unitize(randn(d,n),1); +% noisy observations +sigma = 0.005; +e = sigma*randn(1,n); +y = x'*A + e; + +[model,llh] = rvmRegVb(A,y); +plot(llh); +m = model.w; + +h = max(abs(x))+0.2; +x_range = [1,d]; +y_range = [-h,+h]; +figure; +subplot(2,1,1);plot(x); axis([x_range,y_range]); title('Original Signal'); +subplot(2,1,2);plot(m); axis([x_range,y_range]); title('Recovery Signal'); + + + diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch11/gauss_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch11/gauss_demo.m new file mode 100755 index 0000000..bfd3002 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch11/gauss_demo.m @@ -0,0 +1,51 @@ + +%% Sequential update for Gaussian +close all; clear; +d = 2; +n = 100; +X = randn(d,n); +x = randn(d,1); + +mu = mean(X,2); +Xo = bsxfun(@minus,X,mu); +Sigma = Xo*Xo'/n; +p1 = logGauss(x,mu,Sigma); + +gauss = Gauss(X(:,3:end)).addSample(X(:,1)).addSample(X(:,2)).addSample(X(:,3)).delSample(X(:,3)); +p2 = gauss.logPdf(x); +maxdiff(p1,p2) +%% Sequential update for Gaussian-Wishart +close all; clear; +d = 2; +n = 100; +X = randn(d,n); +x = randn(d,1); + +kappa0 = 1; +m0 = zeros(d,1); +nu0 = d; +S0 = eye(d); + +xbar = mean(X,2); +kappa = kappa0+n; +nu = nu0+n; +m = (n*xbar+kappa0*m0)/kappa; +Xo = bsxfun(@minus,X,m); +X0 = m0-m; +S = S0+Xo*Xo'+kappa0*(X0*X0'); + +v = (nu-d+1); +r = (1+1/kappa)/v; +p1 = logSt(x,m,r*S,v); + +gw0 = GaussWishart(kappa0,m0,nu0,S0); +gw0 = gw0.addData(X); +p0 = gw0.logPredPdf(x); + +gw = GaussWishart(kappa0,m0,nu0,S0); +for i=1:n + gw = gw.addSample(X(:,i)); +end +p2 = gw.logPredPdf(x); +maxdiff(p1,p2) +% diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch11/mixGaussGb_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch11/mixGaussGb_demo.m new file mode 100755 index 0000000..9f8154f --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch11/mixGaussGb_demo.m @@ -0,0 +1,16 @@ +%% Collapse Gibbs sampling for Dirichelt process gaussian mixture model +close all; clear; +d = 2; +k = 3; +n = 500; +[X,z] = mixGaussRnd(d,k,n); +plotClass(X,z); + +[z,Theta,w,llh] = mixGaussGb(X); +figure +plotClass(X,z); + +[X,z] = mixGaussSample(Theta,w,n); +figure +plotClass(X,z); + diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch12/fa_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch12/fa_demo.m new file mode 100755 index 0000000..0f83522 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch12/fa_demo.m @@ -0,0 +1,13 @@ +% demos for ch12 + +clear; close all; +d = 3; +m = 2; +n = 1000; + +X = ppcaRnd(m,d,n); +plotClass(X); + +%% Factor analysis +[W, mu, psi, llh] = fa(X, m); +plot(llh); diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch12/pca_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch12/pca_demo.m new file mode 100755 index 0000000..0ed40f7 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch12/pca_demo.m @@ -0,0 +1,29 @@ +% demos for ch12 + +clear; close all; +d = 3; +m = 2; +n = 1000; + +X = ppcaRnd(m,d,n); +plotClass(X); +%% PCA , EM PCA and Constraint EM PCA produce the same result in the sense of reconstruction mseor +% classical PCA +[U,L,mu,mse1] = pca(X,m); +Y = U'*bsxfun(@minus,X,mu); % projection +Z1 = bsxfun(@times,Y,1./sqrt(L)); % whiten +figure; +plotClass(Y); +figure; +plotClass(Z1); +mse1 +% EM PCA +[W2,Z2,mu,mse2] = pcaEm(X,m); +figure; +plotClass(Z1); +mse2 +% Contrained EM PCA +[W3,Z3,mu,mse3] = pcaEmC(X,m); +figure; +plotClass(Z1); +mse3 diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch12/ppcaEm_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch12/ppcaEm_demo.m new file mode 100755 index 0000000..ce7082b --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch12/ppcaEm_demo.m @@ -0,0 +1,13 @@ +% demos for ch12 + +clear; close all; +d = 3; +m = 2; +n = 1000; + +X = ppcaRnd(m,d,n); +plotClass(X); + +%% EM probabilistic PCA +[W,mu,beta,llh] = ppcaEm(X,m); +plot(llh) diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch12/ppcaVb_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch12/ppcaVb_demo.m new file mode 100755 index 0000000..074fce3 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch12/ppcaVb_demo.m @@ -0,0 +1,13 @@ +% demos for ch12 + +clear; close all; +d = 3; +m = 2; +n = 1000; + +X = ppcaRnd(m,d,n); +plotClass(X); + +%% Variational Bayesian probabilistic PCA +[model, energy] = ppcaVb(X); +plot(energy); diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch13/hmm_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch13/hmm_demo.m new file mode 100755 index 0000000..025f009 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch13/hmm_demo.m @@ -0,0 +1,12 @@ +% demos for HMM in ch13 +d = 3; k = 2; n = 10000; +[x,model] = hmmRnd(d,k,n); +%% Viterbi algorithm +[z, llh] = hmmViterbi(model, x); +%% HMM filter (forward algorithm) +[alpha, llh] = hmmFilter(model, x); +%% HMM smoother (forward backward) +[gamma,alpha,beta,c] = hmmSmoother(model, x); +%% Baum-Welch algorithm +[model, llh] = hmmEm(x,k); +plot(llh) diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch13/lds_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch13/lds_demo.m new file mode 100755 index 0000000..8c0b30e --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch13/lds_demo.m @@ -0,0 +1,14 @@ +% demos for LDS in ch13 + +clear; close all; +d = 3; +k = 2; +n = 100; + +[X,Z,model] = ldsRnd(d,k,n); +[mu, V, llh] = kalmanFilter(model, X); + +[nu, U, Ezz, Ezy, llh] = kalmanSmoother(model, X); +% [model, llh] = ldsEm(X,k); +% plot(llh); +% diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch14/adaboostBin_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch14/adaboostBin_demo.m new file mode 100755 index 0000000..448f188 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch14/adaboostBin_demo.m @@ -0,0 +1,10 @@ + +%% adaboost +d = 2; +k = 2; +n = 500; +[X,t] = kmeansRnd(d,k,n); +model = adaboostBin(X,t-1); +y = adaboostBinPred(model,X); +plotClass(X,y+1) + diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch14/mixLinReg_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch14/mixLinReg_demo.m new file mode 100755 index 0000000..186ab68 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch14/mixLinReg_demo.m @@ -0,0 +1,14 @@ +%% Mixture of linear regression +close all; clear +d = 1; +k = 2; +n = 500; +[X,y] = mixLinRnd(d,k,n); +plot(X,y,'.'); +[label,model,llh] = mixLinReg(X, y, k); +plotClass([X;y],label); +figure +plot(llh); +[y_,z,p] = mixLinPred(model,X,y); +figure; +plotClass([X;y],label); \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/demo/ch14/mixLogitBin_demo.m b/books/PRML/PRMLT-master-MATLAB/demo/ch14/mixLogitBin_demo.m new file mode 100755 index 0000000..92d2a2f --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/demo/ch14/mixLogitBin_demo.m @@ -0,0 +1,10 @@ +%% Mixture of logistic regression +d = 2; +c = 4; +k = 4; +n = 500; +[X,t] = kmeansRnd(d,c,n); + +model = mixLogitBin(X,t-1,k); +y = mixLogitBinPred(model,X); +plotClass(X,y+1) \ No newline at end of file diff --git a/books/PRML/PRMLT-master-MATLAB/init.m b/books/PRML/PRMLT-master-MATLAB/init.m new file mode 100755 index 0000000..8cb5ff6 --- /dev/null +++ b/books/PRML/PRMLT-master-MATLAB/init.m @@ -0,0 +1 @@ +addpath(genpath(pwd)); \ No newline at end of file diff --git a/books/PRML/PRML最全资料集合/PRML_Pattern Recognition And Machine Learning - Springer 2006.pdf b/books/PRML/PRML最全资料集合/PRML_Pattern Recognition And Machine Learning - Springer 2006.pdf new file mode 100755 index 0000000..af7d777 Binary files /dev/null and b/books/PRML/PRML最全资料集合/PRML_Pattern Recognition And Machine Learning - Springer 2006.pdf differ diff --git a/books/PRML/PRML最全资料集合/PRML_Translation.pdf b/books/PRML/PRML最全资料集合/PRML_Translation.pdf new file mode 100755 index 0000000..b16b951 Binary files /dev/null and b/books/PRML/PRML最全资料集合/PRML_Translation.pdf differ diff --git a/books/PRML/PRML最全资料集合/PRML╢┴╩щ╗с║╧╝п┤Є╙б░ц.pdf b/books/PRML/PRML最全资料集合/PRML╢┴╩щ╗с║╧╝п┤Є╙б░ц.pdf new file mode 100755 index 0000000..7211d35 Binary files /dev/null and b/books/PRML/PRML最全资料集合/PRML╢┴╩щ╗с║╧╝п┤Є╙б░ц.pdf differ diff --git a/books/PRML/PRML最全资料集合/PRML╧░╠т┤Ё░╕═ъ╒√░ц.pdf b/books/PRML/PRML最全资料集合/PRML╧░╠т┤Ё░╕═ъ╒√░ц.pdf new file mode 100755 index 0000000..bcf5300 Binary files /dev/null and b/books/PRML/PRML最全资料集合/PRML╧░╠т┤Ё░╕═ъ╒√░ц.pdf differ diff --git a/books/PRML/PRML最全资料集合/PRML▒╩╝╟-Jian Xiao.pdf b/books/PRML/PRML最全资料集合/PRML▒╩╝╟-Jian Xiao.pdf new file mode 100755 index 0000000..5722306 Binary files /dev/null and b/books/PRML/PRML最全资料集合/PRML▒╩╝╟-Jian Xiao.pdf differ diff --git a/books/PRML/PRML最全资料集合/PRML▒╩╝╟-Yuandong Tian.pdf b/books/PRML/PRML最全资料集合/PRML▒╩╝╟-Yuandong Tian.pdf new file mode 100755 index 0000000..b116169 --- /dev/null +++ b/books/PRML/PRML最全资料集合/PRML▒╩╝╟-Yuandong Tian.pdf @@ -0,0 +1,6184 @@ +%PDF-1.4 +7 0 obj +[5 0 R /XYZ null 765.9246077 null] +endobj +8 0 obj +[5 0 R /XYZ null 741.0180075 null] +endobj +11 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F1 +/FontDescriptor 10 0 R +/BaseFont/FTCRYB+CMR17 +/FirstChar 33 +/LastChar 196 +/Widths[250 459 772 459 772 720 250 354 354 459 720 250 302 250 459 459 459 459 459 +459 459 459 459 459 459 250 250 250 720 432 432 720 693 654 668 707 628 602 726 693 +328 471 719 576 850 693 720 628 720 680 511 668 693 693 955 693 693 563 250 459 250 +459 250 250 459 511 406 511 406 276 459 511 250 276 485 250 772 511 459 511 485 354 +359 354 511 485 668 485 485 406 459 917 459 459 459 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 576 772 720 641 615 693 668 720 668 720 0 0 668 +525 499 499 749 749 250 276 459 459 459 459 459 693 406 459 668 720 459 837 942 720 +250 459] +>> +endobj +14 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F2 +/FontDescriptor 13 0 R +/BaseFont/LEMTTC+CMR12 +/FirstChar 33 +/LastChar 196 +/Widths[272 490 816 490 816 762 272 381 381 490 762 272 326 272 490 490 490 490 490 +490 490 490 490 490 490 272 272 272 762 462 462 762 734 693 707 748 666 639 768 734 +353 503 761 612 897 734 762 666 762 721 544 707 734 734 1006 734 734 598 272 490 +272 490 272 272 490 544 435 544 435 299 490 544 272 299 517 272 816 544 490 544 517 +381 386 381 544 517 707 517 517 435 490 979 490 490 490 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 612 816 762 680 653 734 707 762 707 762 0 +0 707 571 544 544 816 816 272 299 490 490 490 490 490 734 435 490 707 762 490 884 +993 762 272 490] +>> +endobj +15 0 obj +[5 0 R /XYZ null 590.2860417 null] +endobj +18 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F3 +/FontDescriptor 17 0 R +/BaseFont/RAYQXP+CMBX12 +/FirstChar 33 +/LastChar 196 +/Widths[343 581 938 563 938 875 313 438 438 563 875 313 375 313 563 563 563 563 563 +563 563 563 563 563 563 313 313 343 875 531 531 875 850 800 813 862 738 707 884 880 +419 581 881 676 1067 880 845 769 845 839 625 782 865 850 1162 850 850 688 313 581 +313 563 313 313 547 625 500 625 513 344 563 625 313 344 594 313 938 625 563 625 594 +459 444 438 625 594 813 594 594 500 563 1125 563 563 563 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 676 938 875 787 750 880 813 875 813 875 +0 0 813 656 625 625 938 938 313 344 563 563 563 563 563 850 500 574 813 875 563 1019 +1144 875 313 563] +>> +endobj +19 0 obj +[5 0 R /XYZ null 562.022599 null] +endobj +22 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F5 +/FontDescriptor 21 0 R +/BaseFont/MQUWXK+CMR10 +/FirstChar 33 +/LastChar 196 +/Widths[278 500 833 500 833 778 278 389 389 500 778 278 333 278 500 500 500 500 500 +500 500 500 500 500 500 278 278 278 778 472 472 778 750 708 722 764 681 653 785 750 +361 514 778 625 917 750 778 681 778 736 556 722 750 750 1028 750 750 611 278 500 +278 500 278 278 500 556 444 556 444 306 500 556 278 306 528 278 833 556 500 556 528 +392 394 389 556 528 722 528 528 444 500 1000 500 500 500 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 625 833 778 694 667 750 722 778 722 778 +0 0 722 583 556 556 833 833 278 306 500 500 500 500 500 750 444 500 722 778 500 903 +1014 778 278 500] +>> +endobj +25 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F6 +/FontDescriptor 24 0 R +/BaseFont/MTRMAJ+CMTI10 +/FirstChar 33 +/LastChar 196 +/Widths[307 514 818 769 818 767 307 409 409 511 767 307 358 307 511 511 511 511 511 +511 511 511 511 511 511 307 307 307 767 511 511 767 743 704 716 755 678 653 774 743 +386 525 769 627 897 743 767 678 767 729 562 716 743 743 999 743 743 613 307 514 307 +511 307 307 511 460 460 511 460 307 460 511 307 307 460 256 818 562 511 511 460 422 +409 332 537 460 664 464 486 409 511 1022 511 511 511 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 627 818 767 692 664 743 716 767 716 767 0 0 +716 613 562 588 882 894 307 332 511 511 511 511 511 831 460 537 716 716 511 883 985 +767 256 511] +>> +endobj +28 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F7 +/FontDescriptor 27 0 R +/BaseFont/HFSMZV+CMSY10 +/FirstChar 33 +/LastChar 196 +/Widths[1000 500 500 1000 1000 1000 778 1000 1000 611 611 1000 1000 1000 778 275 +1000 667 667 889 889 0 0 556 556 667 500 722 722 778 778 611 798 657 527 771 528 +719 595 845 545 678 762 690 1201 820 796 696 817 848 606 545 626 613 988 713 668 +725 667 667 667 667 667 611 611 444 444 444 444 500 500 389 389 278 500 500 611 500 +278 833 750 833 417 667 667 778 778 444 444 444 611 778 778 778 778 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 778 278 778 500 778 500 778 778 +778 778 0 0 778 778 778 1000 500 500 778 778 778 778 778 778 778 778 778 778 778 +778 1000 1000 778 778 1000 778] +>> +endobj +29 0 obj +[5 0 R /XYZ null 496.0667778 null] +endobj +30 0 obj +[5 0 R /XYZ null 413.0160507 null] +endobj +31 0 obj +[5 0 R /XYZ null 392.1360378 null] +endobj +34 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F9 +/FontDescriptor 33 0 R +/BaseFont/KLYSKM+CMBX10 +/FirstChar 33 +/LastChar 196 +/Widths[350 603 958 575 958 894 319 447 447 575 894 319 383 319 575 575 575 575 575 +575 575 575 575 575 575 319 319 350 894 543 543 894 869 818 831 882 756 724 904 900 +436 594 901 692 1092 900 864 786 864 862 639 800 885 869 1189 869 869 703 319 603 +319 575 319 319 559 639 511 639 527 351 575 639 319 351 607 319 958 639 575 639 607 +474 454 447 639 607 831 607 607 511 575 1150 575 575 575 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 692 958 894 806 767 900 831 894 831 894 +0 0 831 671 639 639 958 958 319 351 575 575 575 575 575 869 511 597 831 894 575 1042 +1169 894 319 575] +>> +endobj +35 0 obj +<< +/Rect[222.543 339.78 229.524 348.201] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(figure.1) +>> +endobj +36 0 obj +[5 0 R /XYZ null 345.1053107 null] +endobj +39 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F10 +/FontDescriptor 38 0 R +/BaseFont/ZPCGYT+CMMI10 +/FirstChar 33 +/LastChar 196 +/Widths[622 466 591 828 517 363 654 1000 1000 1000 1000 278 278 500 500 500 500 500 +500 500 500 500 500 500 500 278 278 778 500 778 500 531 750 759 715 828 738 643 786 +831 440 555 849 681 970 803 763 642 791 759 613 584 683 583 944 828 581 683 389 389 +389 1000 1000 417 529 429 433 520 466 490 477 576 345 412 521 298 878 600 485 503 +446 451 469 361 572 485 716 572 490 465 322 384 636 500 278 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 615 833 763 694 742 831 780 583 667 612 +0 0 772 640 566 518 444 406 438 497 469 354 576 583 603 494 438 570 517 571 437 540 +596 626 651 278] +>> +endobj +42 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F11 +/FontDescriptor 41 0 R +/BaseFont/CVJSKU+CMR7 +/FirstChar 33 +/LastChar 196 +/Widths[323 569 938 569 938 877 323 446 446 569 877 323 385 323 569 569 569 569 569 +569 569 569 569 569 569 323 323 323 877 539 539 877 843 799 815 860 768 737 884 843 +413 583 874 706 1028 843 877 768 877 829 631 815 843 843 1151 843 843 692 323 569 +323 569 323 323 569 631 508 631 508 354 569 631 323 354 600 323 938 631 569 631 600 +446 453 446 631 600 815 600 600 508 569 1139 569 569 569 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 706 938 877 782 754 843 815 877 815 877 +0 0 815 678 647 647 970 970 323 354 569 569 569 569 569 843 508 569 815 877 569 1014 +1137 877 323 569] +>> +endobj +43 0 obj +[5 0 R /XYZ null 314.1162037 null] +endobj +46 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F12 +/FontDescriptor 45 0 R +/BaseFont/BPRWWM+CMMI7 +/FirstChar 33 +/LastChar 196 +/Widths[720 540 690 950 593 439 751 1139 1139 1139 1139 339 339 585 585 585 585 585 +585 585 585 585 585 585 585 339 339 893 585 893 585 610 859 863 819 934 839 725 889 +936 506 632 960 784 1089 905 869 727 900 861 701 675 778 675 1074 937 672 778 462 +462 462 1139 1139 478 620 502 511 595 542 557 557 669 404 473 607 361 1014 706 564 +589 524 530 539 432 675 571 826 648 579 546 399 442 730 585 339 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 694 954 869 798 844 936 886 678 770 +717 0 0 880 743 648 600 519 476 520 589 544 423 669 678 695 573 520 668 593 662 527 +633 687 714 756 339] +>> +endobj +47 0 obj +[5 0 R /XYZ null 258.6033533 null] +endobj +50 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F13 +/FontDescriptor 49 0 R +/BaseFont/WKUHUU+CMEX10 +/FirstChar 33 +/LastChar 196 +/Widths[792 583 583 639 639 639 639 806 806 806 806 1278 1278 811 811 875 875 667 +667 667 667 667 667 889 889 889 889 889 889 889 667 875 875 875 875 611 611 833 1111 +472 556 1111 1511 1111 1511 1111 1511 1056 944 472 833 833 833 833 833 1444 1278 +556 1111 1111 1111 1111 1111 944 1278 556 1000 1444 556 1000 1444 472 472 528 528 +528 528 667 667 1000 1000 1000 1000 1056 1056 1056 778 667 667 450 450 450 450 778 +778 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 458 458 417 +417 472 472 472 472 583 583 0 0 472 472 333 556 578 578 597 597 736 736 528 528 583 +583 583 583 750 750 750 750 1044 1044 792 778] +>> +endobj +51 0 obj +<< +/Rect[235.494 180.028 242.476 188.448] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.2) +>> +endobj +53 0 obj +<< +/Filter[/FlateDecode] +/Length 1688 +>> +stream +xn6}_Ijw!]`Úa>(6%WRe_Ëlɖc'Es8&rÅb?W>|rN"%"$G<ш`$N˳ra$.vJ q4*,=%%$yAm%%",[KH` *j<8iY |"HKfS̊r2.xG3T"Ddc,^&`L?%03{,8OS.+;¯qsgT؛OSSLr灰->>&ʳQCLл#=Q`C،Amp?e DcieW_q2΋k@;v|Z +񬄎۞dlN0KmLf3vi(>֐Bx?̳TI +FyÂc/˙LvUq=]^L9k7ְ1 +)F]ܳ2L<N̞~.6|3tŴwؗb/ QZEg1n\~iaX.wZz8H ecǩy0aJ5H~Vg܌W CAV"Ayvd9yNʪ2uH`6A-" 񡴬+¬y?+_QpG0&DP@ťOy„7v CaM"4:tqLK*ZC|VrX@ZPG>RԤ~ 9q\rԖlR;N&Fq\3$mIC.G3wFD<hr] )L 8e}Y!ݳf> +endobj +6 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 56 0 R +>> +endobj +59 0 obj +[57 0 R /XYZ null 765.9246077 null] +endobj +60 0 obj +<< +/Length 1881 +/Filter/FlateDecode +/Name/Im1 +/Type/XObject +/Subtype/Form +/BBox[0 0 2384 3370] +/FormType 1 +/Matrix[1 0 0 1 0 0] +/Resources<< +/ProcSet[/PDF /Text] +/ExtGState 61 0 R +/Font 62 0 R +>> +>> +stream +xXd Wp")RF1wl`CIgjhÝ5*J:<$Iuʙzp{>~ˑOJ&^K?%Y5G9:Wlͧ:4CTѳ Mw{ԞNqMXN)֓\!(/+%pI{CR;֔TX[фe/pvg}{>xo ||ڤ51`lOǧҹГd~|%5Cj5.ԒgcL#ROu5I͡?VZð0÷q[v=Vg/{x;ׂ:ъZn I%PӔ?ƍ* 77se=rm|]{ U_36^ծ箙uB%/{ K=<A|Lޏ>7B +fz +/3rv|nG\!ZZ1HjВ|u5^2cg9c:ē_2vl-̥:n ;Z6vkyFj \f 枚5F *VH ' k/`:@%{\J왭>HSӰwg&+JLqԥ@zގ!ylp 5νY_GN۱7?N|,{ޏBu* +FVRAӥ{\j ')jk>h(hhtp lX3MQ! f~8.5K:\+kdz[h$#m2|A(3Z]qTPtag_CF1# BjEVnF1b vż$g`0FLh%_NRĞ +Vf=X~e3TG eR=JcSJbp45jU^cӴ0F4ci+ hla,S4N @'He sո&4BDؕACprdY~iJţ}y=W6($P%PTx (30c`I>صA8r qZ +ǵQ$ ՙ#{ mxZR[/T*DP;D8kP }vgւU?Q@!ztph^q/2ZRI(8dTTԦ 7/uѴrG42 Cxf|JiF_٦F>L8|]2\C'=Kz::h0g=; ,3 z;tND=0B]I~*26ȲیIi%Mr0 + ;tm5ƓrQDRM:' (و`zqxM:p^ *$h + R/!mE`a8 +H(巑8 +3)[+qZp{J6䴇AV ekMl-:ÍfnCIXHR\*Bl’ +$ V5AK*/j|Kxو +g|/~\F9i |\$@Hp"b,1K$fB'BX$ʣtCcq#Gg3eF;O%B]H>V4p'L3D2 VJ3q&fuqed q:WAꢝlYY^{Xd>`g@iqEfjWJ +endstream +endobj +61 0 obj +<< +/R8 63 0 R +>> +endobj +62 0 obj +<< +/R10 64 0 R +>> +endobj +63 0 obj +<< +/Type/ExtGState +/OPM 1 +/SA true +>> +endobj +64 0 obj +<< +/BaseFont/MKWZFF+Verdana +/FontDescriptor 65 0 R +/Type/Font +/FirstChar 49 +/LastChar 120 +/Widths[636 636 636 636 636 636 636 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +592] +/Encoding/WinAnsiEncoding +/Subtype/Type1 +>> +endobj +65 0 obj +<< +/Type/FontDescriptor +/FontName/MKWZFF+Verdana +/FontBBox[30 -15 875 750] +/Flags 4 +/Ascent 750 +/CapHeight 750 +/Descent -15 +/ItalicAngle 0 +/StemV 131 +/MissingWidth 1000 +/CharSet(/one/two/three/four/five/six/seven/x) +/FontFile3 66 0 R +>> +endobj +66 0 obj +<< +/Subtype/Type1C +/Filter/FlateDecode +/Length 1019 +>> +stream +xhǯ?r9umzu@l_Bqtkvk4ͯ^rw5I&IV0 L@? ^K׾/?}:Ntf~}B^8/9w9:}?:1 "G77EB!;vuޖwOgx{OC~&Wpռ*ʰrJ(*24^WC{ZŇ^St#fzvgOsN>OI;jQݨ6juIĴIdV2+Xx)X5tKsq`}am-WK/cpv`)8 +z6ͨEy4jS5+#3:q/bv3ZO*J|nAyHtʖǭ1KGz;Ž3v-:Zd 2Kl|&]frHar}JK 6F-Q"IH8g[S}#z \ON0Z`&m4µX-V|.#JBI(E*PoͲ9c@ĜQly4, QAϢg09 4bJ Rܗp.D/'Wƒۋ2Sfj woޖ55LyUNpyw/qHJlG ~!&_KRbpҁT FLK%W +&L [Z7l ׫yʿ5_jzP#B +endstream +endobj +67 0 obj +[57 0 R /XYZ null 568.1564878 null] +endobj +68 0 obj +<< +/Length 1798 +/Filter/FlateDecode +/Name/Im2 +/Type/XObject +/Subtype/Form +/BBox[0 0 2384 3370] +/FormType 1 +/Matrix[1 0 0 1 0 0] +/Resources<< +/ProcSet[/PDF /Text] +/ExtGState 69 0 R +/Font 70 0 R +>> +>> +stream +xYˎ\5߯˙E"FbX5 +H 9v$ 0&2SuzTy{ڊ8]Om7G\_6~;o9TnkO۷-/7{.4='QqK[u1Ǻ'KCӦSXuRR9m*crċ +/Ty㘍&֋;-w޽pJ\A,:`^ 05\ ++BrI0zA1CBD1hVH؉Ѫ^_/Ϛ @DypMBԺs c 7=r~Pzj ?VV +0׺([[qpj]eKR]Iqq [^¢a}B$h6N#"er"zKm(;6uXZuF^f`7% .!& $Da2]P&1 #T?I]댡Ɓ,dsAqhNFA1+U #!)G=dɱ"d CGd1rG[:F<ߺtao=g09&WM$=oMp@XMRh`%THnYU;KMnʓ +TBl*TWO-cEC ϖp}AK/*xMݍZX[1WOg@еX@lw!pPgڻ/4R&sʡR{zogxF@ޏS{O++<^d3 u3PcEH&pb1mF7 wƣ VTTfXZkmkRҬK+a)Ӱ" x" +RJCa8rria)aXJ?KKoP*"Zt0I"B8SBD3, 6> + %XW@# +LJ>x$1A/xƿK +endstream +endobj +69 0 obj +<< +/R8 71 0 R +>> +endobj +70 0 obj +<< +/R10 72 0 R +>> +endobj +71 0 obj +<< +/Type/ExtGState +/OPM 1 +/SA true +>> +endobj +72 0 obj +<< +/BaseFont/MQTXFO+Verdana +/FontDescriptor 73 0 R +/Type/Font +/FirstChar 45 +/LastChar 121 +/Widths[454 364 0 0 636 636 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 633 0 0 0 0 0 0 0 +0 0 592 592] +/Encoding/WinAnsiEncoding +/Subtype/Type1 +>> +endobj +73 0 obj +<< +/Type/FontDescriptor +/FontName/MQTXFO+Verdana +/FontBBox[30 -201 875 750] +/Flags 4 +/Ascent 750 +/CapHeight 750 +/Descent -201 +/ItalicAngle 0 +/StemV 131 +/MissingWidth 1000 +/CharSet(/y/n/one/two/hyphen/period/x) +/FontFile3 74 0 R +>> +endobj +74 0 obj +<< +/Subtype/Type1C +/Filter/FlateDecode +/Length 507 +>> +stream +xVerdana]  ~ynx-.12ZOY; |Cf=(;('m'w~ |ll^Okll~l~nxns/+}zuutqj .b-bfh/e.eZ4  ($?vz~|ytsuwI+|+AvaaPAgfdelt$vvmebetgtga[LOnnknimhninin$^} +endstream +endobj +75 0 obj +[57 0 R /XYZ null 437.2937532 null] +endobj +76 0 obj +[57 0 R /XYZ null 321.3012957 null] +endobj +77 0 obj +<< +/Rect[171.927 269.543 178.909 277.964] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(figure.2) +>> +endobj +78 0 obj +[57 0 R /XYZ null 277.6203878 null] +endobj +81 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F14 +/FontDescriptor 80 0 R +/BaseFont/VDKDEJ+CMSY7 +/FirstChar 33 +/LastChar 196 +/Widths[1139 585 585 1139 1139 1139 893 1139 1139 708 708 1139 1139 1139 893 329 +1139 770 770 1016 1016 0 0 647 647 770 585 831 831 893 893 708 918 753 620 889 616 +818 689 979 647 782 872 792 1343 936 906 809 936 981 702 648 718 720 1135 819 764 +823 770 770 770 770 770 708 708 524 524 524 524 585 585 462 462 339 585 585 708 585 +339 938 859 954 494 770 770 893 893 524 524 524 708 893 893 893 893 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 893 339 893 585 893 585 893 893 +893 893 0 0 893 893 893 1139 585 585 893 893 893 893 893 893 893 893 893 893 893 +893 1139 1139 893 893 1139 893] +>> +endobj +82 0 obj +[57 0 R /XYZ null 239.1499516 null] +endobj +83 0 obj +[57 0 R /XYZ null 221.0927273 null] +endobj +84 0 obj +<< +/Rect[225.864 168.073 232.845 176.493] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(figure.3) +>> +endobj +85 0 obj +<< +/Filter[/FlateDecode] +/Length 1129 +>> +stream +xWmo6_gP lmE= ü-;\mɳ4;-YVִ $y%ByT~ヺdzҷQ?D + EF%$,%^ѻ{5^ȀQ<"HM`&-:O^$DF͔5y*\-}q9«,aiKfo{;, F.0*`ɞK@#G S(Y(\5i DtY P46N'ާxk }ΉVl^╅-܅7[w5MfNY?.sg}x6 (C8r:Z|X t"jUɳ2|w`@b(#-O3 em~ ~gO`n0=Xi/lQm}vd]\`tF*ۍ- B(9Zcˊ_n?pyoպ} hm1y1ɟT +)9@f0gl!ki?sE@@u%Mv?v+ +uY?^"E1DΒ&i|i䊄`/ U#IH?6F;} ҹPaK4~q& )C<xcsi9JmMgysÈ헿(l]DzOΎaa8@b.&~䮁2mhiD[IJ̀@C*; 4Ϫix +X&0ϣV#?g!t6)>n6> +endobj +88 0 obj +<< +/Im1 60 0 R +/Im2 68 0 R +>> +endobj +58 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 87 0 R +/XObject 88 0 R +>> +endobj +91 0 obj +[89 0 R /XYZ null 765.9246077 null] +endobj +92 0 obj +<< +/Length 964 +/Filter/FlateDecode +/Name/Im3 +/Type/XObject +/Subtype/Form +/BBox[0 0 2384 3370] +/FormType 1 +/Matrix[1 0 0 1 0 0] +/Resources<< +/ProcSet[/PDF /Text] +/ExtGState 93 0 R +/Font 94 0 R +>> +>> +stream +xWˮk5 +2LLl'q2Eb.s糼ꠃYUUv#r!i¹sxM_~?OdFkW/i4%~I??R%mʒJ58z-7I +LUu +1vs &TU fu0oH\fIX'6B&#RϡFEEra18~!E񚿺 Aɗ!i4DeR˗/.]%p>[V H (YQ$68}L!?Fm;S7Ifuh m XG'|qq5ފ4nM oRɦn ^6p"8Y)XlHEpK}aUOnvv[sJ'\Ie0dPQ +>qՌQfUV%74LbWX +X:L\N' wQc9{58Zvky wyͩ3OW <ҙCDM.88=aA~ ;|p;?|ﻃy# ǯdYVن4* +UT,榏ԱPuI6 +6 tY8B~%w8N/& +^6p3{X9 bTD~)g4o)žc9U@xTo}cU= V%_T\ƹk¼pESx*~|YS3ےb%h|td;R}^ w\=2p_ixlbw|qAtדIr# +endstream +endobj +93 0 obj +<< +/R8 95 0 R +>> +endobj +94 0 obj +<< +/R10 96 0 R +>> +endobj +95 0 obj +<< +/Type/ExtGState +/OPM 1 +/SA true +>> +endobj +96 0 obj +<< +/BaseFont/MKWZFF+Verdana +/FontDescriptor 97 0 R +/Type/Font +/FirstChar 49 +/LastChar 120 +/Widths[636 636 636 636 636 636 636 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +592] +/Encoding/WinAnsiEncoding +/Subtype/Type1 +>> +endobj +97 0 obj +<< +/Type/FontDescriptor +/FontName/MKWZFF+Verdana +/FontBBox[30 -15 875 750] +/Flags 4 +/Ascent 750 +/CapHeight 750 +/Descent -15 +/ItalicAngle 0 +/StemV 131 +/MissingWidth 1000 +/CharSet(/one/two/three/four/five/six/seven/x) +/FontFile3 98 0 R +>> +endobj +98 0 obj +<< +/Subtype/Type1C +/Filter/FlateDecode +/Length 1019 +>> +stream +xhǯ?r9umzu@l_Bqtkvk4ͯ^rw5I&IV0 L@? ^K׾/?}:Ntf~}B^8/9w9:}?:1 "G77EB!;vuޖwOgx{OC~&Wpռ*ʰrJ(*24^WC{ZŇ^St#fzvgOsN>OI;jQݨ6juIĴIdV2+Xx)X5tKsq`}am-WK/cpv`)8 +z6ͨEy4jS5+#3:q/bv3ZO*J|nAyHtʖǭ1KGz;Ž3v-:Zd 2Kl|&]frHar}JK 6F-Q"IH8g[S}#z \ON0Z`&m4µX-V|.#JBI(E*PoͲ9c@ĜQly4, QAϢg09 4bJ Rܗp.D/'Wƒۋ2Sfj woޖ55LyUNpyw/qHJlG ~!&_KRbpҁT FLK%W +&L [Z7l ׫yʿ5_jzP#B +endstream +endobj +99 0 obj +[89 0 R /XYZ null 568.1564878 null] +endobj +100 0 obj +[89 0 R /XYZ null 484.2650717 null] +endobj +101 0 obj +[89 0 R /XYZ null 422.5979014 null] +endobj +102 0 obj +[89 0 R /XYZ null 380.2214432 null] +endobj +103 0 obj +<< +/Rect[293.113 312.569 315.592 320.99] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(ALC@rem.5) +>> +endobj +104 0 obj +[89 0 R /XYZ null 323.9512096 null] +endobj +105 0 obj +[89 0 R /XYZ null 321.1616674 null] +endobj +106 0 obj +[89 0 R /XYZ null 321.1616674 null] +endobj +107 0 obj +[89 0 R /XYZ null 311.1990273 null] +endobj +108 0 obj +[89 0 R /XYZ null 311.1990273 null] +endobj +109 0 obj +[89 0 R /XYZ null 301.7345192 null] +endobj +110 0 obj +[89 0 R /XYZ null 301.7345192 null] +endobj +111 0 obj +[89 0 R /XYZ null 289.779351 null] +endobj +112 0 obj +[89 0 R /XYZ null 289.779351 null] +endobj +113 0 obj +<< +/Rect[211.501 240.869 218.482 249.289] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.5) +>> +endobj +114 0 obj +[89 0 R /XYZ null 263.9318365 null] +endobj +115 0 obj +[89 0 R /XYZ null 263.9318365 null] +endobj +118 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F15 +/FontDescriptor 117 0 R +/BaseFont/WPIHAK+CMBX7 +/FirstChar 33 +/LastChar 196 +/Widths[397 668 1073 647 1073 1002 363 505 505 647 1002 363 434 363 647 647 647 647 +647 647 647 647 647 647 647 363 363 397 1002 612 612 1002 968 914 931 985 844 809 +1012 1002 479 665 1003 773 1215 1002 968 879 968 960 718 897 985 968 1323 968 968 +789 364 668 364 647 363 363 629 718 576 718 592 399 647 718 363 399 683 363 1073 +718 647 718 683 535 512 505 718 683 931 683 683 576 647 1294 647 647 647 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 773 1073 1002 897 860 1002 +931 1002 931 1002 0 0 931 762 726 726 1089 1089 363 399 647 647 647 647 647 968 576 +669 931 1002 647 1163 1305 1002 363 647] +>> +endobj +119 0 obj +<< +/Filter[/FlateDecode] +/Length 1681 +>> +stream +xYr6}WoL™<$&8:- o"Ȗb{,`q0 kos; M`O4R"d<}by^^@#-Y0 $AJF0)$Fl1!*dgFoD=񅛓%ۥo㺑޸i1L]{o$^* iN M>$}Fˋ_.ލ +݆!Aa -D&]X—f~4%3f0^t;F/B7l\ ,^TZ%;S)b'p>xTn݊`&kl:NIWlfI7d#qzB1F[ +AO\|sS CL4ӥp.Î!]q# D>a#Rr5Jiӊ'O+Nu\g\ǃVdk;4E8;Vq)h=Z">2*78ٖ4g&7 ;ٱ$_6c"{~{LjBN<`IPn!e1`x2bwin?; nVUD +*"*"qªI`'R$RY)eTQr֢s-je7 E "(8h +v܌PIܶ1AB6?k0aaхnp$$Ь ARGN$@П¥R.IDTk#q9cWw0#U! VХu2T5QĢ<*(-Py{7:&V?s'+^e*O +O25^%1Qɫ.Ru>]1i(ԭLRԴ8,Q`-QCҞ 0 ğR{wc;I +`lR(YIjvRD+Z김3S$~x߭^aD!W+]wY{@GS͓XoVet0ԓLa]fDң<܋8,PSY<-y>$8~zơk@e*4TT +% +e==0Ul =֣@":mi)ެ?ȟMV,7N)#}OvL//.Rde}PR;MUw0&6@ң=Hĥ^8?ȾݒNIXZN=~u_<+{|5IF!z({1*z$hT{F=}``oB. .I5]}̆Br>1XؔEV8l|5^!Y:L=R0Ig4*ݽ`JޡB?!iz `Q`"JQ*7z"Zݿe^ú":`#O҄_۟rǟ+9#31Yvt#NqnP`sl.]10:‡7 +ʀWbe~ޭ5 Ε+W~h]1'Ҳ0kTc!h%쀪DҀBաs;8M?T?[SSg(L7ÿa +endstream +endobj +120 0 obj +[103 0 R 113 0 R] +endobj +121 0 obj +<< +/F5 22 0 R +/F10 39 0 R +/F11 42 0 R +/F2 14 0 R +/F9 34 0 R +/F13 50 0 R +/F12 46 0 R +/F6 25 0 R +/F15 118 0 R +>> +endobj +122 0 obj +<< +/Im3 92 0 R +>> +endobj +90 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 121 0 R +/XObject 122 0 R +>> +endobj +125 0 obj +[123 0 R /XYZ null 765.9246077 null] +endobj +126 0 obj +<< +/Length 1892 +/Filter/FlateDecode +/Name/Im4 +/Type/XObject +/Subtype/Form +/BBox[0 0 2384 3370] +/FormType 1 +/Matrix[1 0 0 1 0 0] +/Resources<< +/ProcSet[/PDF /Text] +/ExtGState 127 0 R +/Font 128 0 R +>> +>> +stream +xYc7 Wrm4 R$6"H`7P"L&M<2E^^VK[t^^>/v1z^賗lRje}yDRp~g[k񡮩S U dWVMKۢiʹjq%@eBXCxcH /iO#6ЯEѴ֜aWȬg]o˓9EiؗL*b2ĵ`\ظb}ZS[Ud|9i᪩9V&;p!D>-h8G^pZ><$7W ńU /g 0$cU]^ LrȰgu*㘅hpͦY/PdgM,ggS܋|Z$H~`jAtN-(tOpZk]/t%otBmI7q6|H;*r#8 lyU#z;z4%+c]1ghzKm@Nڌ4=ʝ\֪g8z6rP"f/NOa/T +^{Pۦ@ĭ6lB8<{Zf.Ds֢>5Y,#^`xFs_[Jw(^پfsPT]ӆ[?m`Jq8:/;`K^n[-)5mkD0"OyfK##  W&P7Ί-6%_4!FX1;RLLWL +u9m*M`Gt-ȫpuN8vv0 D\ėWQdI]d]laQ5t?L^3"p|H~a`CvNt +0f;*DɸNC&xSSJ!hh4WY E*b9 DXg=V@`i%FF,`XVϺڔ&:J-vg$Y}i|V`|ƧIB#›zC# +hā0Bd"%# r8I.Q lnM4/&qz` zG/{ Nrۊ8 G&VfV`P.CV#W iCăcoKS4~Eܶ"f 0N:GLmRi7|'O԰|-&dzFD:gM)E49Ki8 H`7qaƈ`"YdQ$a#D-yP \c> +endobj +128 0 obj +<< +/R10 130 0 R +>> +endobj +129 0 obj +<< +/Type/ExtGState +/OPM 1 +/SA true +>> +endobj +130 0 obj +<< +/BaseFont/YKVWOR+Verdana +/FontDescriptor 131 0 R +/Type/Font +/FirstChar 44 +/LastChar 120 +/Widths[364 0 364 0 0 636 636 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 973 633 0 0 0 0 0 +0 0 0 0 592] +/Encoding/WinAnsiEncoding +/Subtype/Type1 +>> +endobj +131 0 obj +<< +/Type/FontDescriptor +/FontName/YKVWOR+Verdana +/FontBBox[30 -181 886 750] +/Flags 4 +/Ascent 750 +/CapHeight 750 +/Descent -181 +/ItalicAngle 0 +/StemV 132 +/MissingWidth 1000 +/CharSet(/n/one/two/comma/period/x/m) +/FontFile3 132 0 R +>> +endobj +132 0 obj +<< +/Subtype/Type1C +/Filter/FlateDecode +/Length 596 +>> +stream +x=KLaǿE05Dx"1V/&D-v[ iwRv-}@݅4 ތg/&\mCe2oPm ({n0 Jߖ#}z-@Ch k5'-QXms!zFԄZU{PAkԴ=kZB{=2jzX:gF«5%^8w}Zdu5J[ #a1,;a#ǧ 9#-t~rӄcF؂c(/žZwpCܛ>f9$Ar'VjJ(n`FqAax(ZPLɨicU_&.˓#NcsIa$L53d癒'fs⻷s-`+L~k7w +jf%ʤ6h66EsZ/p`X:ٝ͝t!/ +>ťv@lq:/aDۄ!=\GIf B* +endstream +endobj +133 0 obj +[123 0 R /XYZ null 597.856286 null] +endobj +134 0 obj +<< +/Length 868 +/Filter/FlateDecode +/Name/Im5 +/Type/XObject +/Subtype/Form +/BBox[0 0 2384 3370] +/FormType 1 +/Matrix[1 0 0 1 0 0] +/Resources<< +/ProcSet[/PDF /Text] +/ExtGState 135 0 R +/Font 136 0 R +>> +>> +stream +xV;7 +T)4$H) W8kHpnoA]1KO|}.$2p.M,O#GzJZՙ/Ωk#.wȜo.)VYIUd'##[#3e Neb5Aj +lJRA.I&Mmqo@;gBSxf A.)bNnX@.0p咿9`ĻҠ9,T|nE;6!~%ݱ~{J?~ v5$ UhX3nInTFmsL  P퇅4vbg  Qg2 $O4/ng^3f}f}fjE&M&T*m4 _2 Vba`'7fcP_Jp"Da6 /'WMk5. F>R0V>1BJrt 4p2 @64SX8ǒSٿBUt~zIEp"ʰpql re+Z3/RJRmRzYڇ:G.:~n|P="lI( 8 "dh"yqS!}/44Qk.C7e$'$`o+~;01R( +=ˑkp:;>d +:f k޾†na} .`ހm¦ZeNŅZk[q1c #F]Ї_~x> +endobj +136 0 obj +<< +/R10 138 0 R +>> +endobj +137 0 obj +<< +/Type/ExtGState +/OPM 1 +/SA true +>> +endobj +138 0 obj +<< +/BaseFont/SVPGGP+Verdana +/FontDescriptor 139 0 R +/Type/Font +/FirstChar 44 +/LastChar 121 +/Widths[364 0 364 0 0 636 636 0 0 0 0 0 0 0 0 0 0 818 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 454 0 454 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 973 633 0 0 +0 0 0 0 0 0 0 592 592] +/Encoding/WinAnsiEncoding +/Subtype/Type1 +>> +endobj +139 0 obj +<< +/Type/FontDescriptor +/FontName/SVPGGP+Verdana +/FontBBox[30 -201 886 760] +/Flags 4 +/Ascent 760 +/CapHeight 760 +/Descent -201 +/ItalicAngle 0 +/StemV 132 +/MissingWidth 1000 +/CharSet(/y/n/one/equal/two/bracketleft/comma/bracketright/period/x/m) +/FontFile3 140 0 R +>> +endobj +140 0 obj +<< +/Subtype/Type1C +/Filter/FlateDecode +/Length 703 +>> +stream +x=KLQ`g:  & HP.`5İqe"tS +郖W@@BKb"Q .l\;[i%޳s$?Ti Is~3f17w;9 pVղ +zjA x, rA7-]0n%v/!?e"|U(M2H[ &JpTBSȘndmtl>]Y9W:J’X]" 'qM'c?b4?V+(̠6L^pnP#i +[@PQ֓4q]<#=SZ`hguZW:!VL&Y/LPTGv%/5iN +A1RP*JzbJUB>$(Tɤ5X8tJ#HgE)ew:l΁Ai 黨4aåUeF~#H LH+Q8OoHI\"f$WAп<,;.h +0ֻX.W30܆>"XfPzsYWڹVc ת.JZIw|բ}H{IB +j# +endstream +endobj +141 0 obj +[123 0 R /XYZ null 480.9839798 null] +endobj +142 0 obj +[123 0 R /XYZ null 437.2037131 null] +endobj +143 0 obj +<< +/Rect[171.475 383.852 178.456 392.272] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(figure.4) +>> +endobj +144 0 obj +<< +/Rect[335.288 383.852 342.269 392.272] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(figure.5) +>> +endobj +145 0 obj +[123 0 R /XYZ null 382.7954698 null] +endobj +146 0 obj +[123 0 R /XYZ null 309.2794222 null] +endobj +147 0 obj +[123 0 R /XYZ null 238.862942 null] +endobj +148 0 obj +<< +/Filter[/FlateDecode] +/Length 1217 +>> +stream +xWo6~_Az0Kk2la[8JԖR[i(Jdɺe01ix9*ja~r(|u6(:zfWUfDG9#e$`hF2'\4[|R\nd&wѷCM + +4<6qP(~, Y&Irbm IH$Ŭ$cIN3'i*/lO!{:_mLy"E|S,Rl}ʟ'3-D|/K?%O_ywP.G94v,T3ePQN\Vp! +}91X}32Qzp>&l> ~*xYk`0G1;_w]oγbU >,VA6$TPlE+x-Kfp/%µxAcl> ӣbi1eNM茔T"J?)*$诗V!vQB +-IP܃ HCU Y#Sl]1[K2f;Z7n2hoˬh(f`y|2,>Ӿ$lLEX_oepZZhTph:ѧ腳M xu [R)wQQJ ˪r׷vGMA*qR+iza^aaQ}ǭ"3=J#Li9(}HMGh`2EEmrIK4l??v +endstream +endobj +149 0 obj +[143 0 R 144 0 R] +endobj +150 0 obj +<< +/F5 22 0 R +/F9 34 0 R +/F10 39 0 R +/F13 50 0 R +/F12 46 0 R +/F11 42 0 R +/F7 28 0 R +/F14 81 0 R +/F3 18 0 R +/F6 25 0 R +>> +endobj +151 0 obj +<< +/Im4 126 0 R +/Im5 134 0 R +>> +endobj +124 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 150 0 R +/XObject 151 0 R +>> +endobj +154 0 obj +[152 0 R /XYZ null 765.9246077 null] +endobj +155 0 obj +<< +/Rect[262.829 694.1 269.811 702.521] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.3) +>> +endobj +156 0 obj +[152 0 R /XYZ null 674.0333145 null] +endobj +159 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F16 +/FontDescriptor 158 0 R +/BaseFont/RCKZNF+CMMI5 +/FirstChar 33 +/LastChar 196 +/Widths[886 675 855 1145 726 578 918 1361 1361 1361 1361 458 458 736 736 736 736 +736 736 736 736 736 736 736 736 458 458 1083 736 1083 736 749 1036 1037 996 1110 +1007 867 1064 1110 627 773 1139 956 1284 1076 1048 875 1082 1030 856 832 944 828 +1279 1113 824 943 597 597 597 1361 1361 597 774 633 649 740 677 684 701 828 534 588 +758 480 1228 881 703 740 659 671 670 564 846 722 1009 792 731 689 534 553 889 736 +458 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 833 1153 1048 +967 1018 1110 1065 840 944 893 0 0 1061 913 791 747 654 614 667 744 677 550 828 840 +850 712 667 831 726 815 682 792 842 865 931 458] +>> +endobj +162 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F17 +/FontDescriptor 161 0 R +/BaseFont/USRWNS+CMSY5 +/FirstChar 33 +/LastChar 196 +/Widths[1361 736 736 1361 1361 1361 1083 1361 1361 875 875 1361 1361 1361 1083 441 +1361 944 944 1222 1222 0 0 806 806 944 736 1014 1014 1083 1083 875 1113 919 782 1084 +771 988 850 1195 820 958 1055 965 1568 1126 1089 998 1132 1196 868 822 874 899 1368 +997 929 991 944 944 944 944 944 875 875 667 667 667 667 736 736 597 597 458 736 736 +875 736 458 1097 1036 1153 632 944 944 1083 1083 667 667 667 875 1083 1083 1083 1083 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1083 458 1083 736 +1083 736 1083 1083 1083 1083 0 0 1083 1083 1083 1361 736 736 1083 1083 1083 1083 +1083 1083 1083 1083 1083 1083 1083 1083 1361 1361 1083 1083 1361 1083] +>> +endobj +165 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F18 +/FontDescriptor 164 0 R +/BaseFont/LNKJJZ+CMR5 +/FirstChar 33 +/LastChar 196 +/Widths[403 681 1097 681 1097 1028 403 542 542 681 1028 403 472 403 681 681 681 681 +681 681 681 681 681 681 681 403 403 1028 1028 1028 646 1028 981 935 958 1004 900 +865 1033 981 494 692 1015 831 1189 981 1028 900 1028 969 750 958 981 981 1328 981 +981 819 403 681 403 681 403 403 681 750 611 750 611 438 681 750 403 438 715 403 1097 +750 681 750 715 542 549 542 750 715 958 715 715 611 681 1361 681 681 681 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 831 1097 1028 911 889 981 +958 1028 958 1028 0 0 958 681 681 403 403 646 403 438 681 681 681 681 681 981 611 +681 958 1028 681 1178 1317 1028 403 681] +>> +endobj +166 0 obj +<< +/Rect[457.16 541.056 464.141 549.477] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.8) +>> +endobj +167 0 obj +[152 0 R /XYZ null 532.9446753 null] +endobj +168 0 obj +[152 0 R /XYZ null 370.5385615 null] +endobj +169 0 obj +<< +/Filter[/FlateDecode] +/Length 2768 +>> +stream +x[o_Ke`\?p P>(bK$o6wl){nbI$E7h$NPldK9*>ZL"IJNwtuMcyÔ(Ey}1_'_u[\M \(\ +Ak{^N ySV/i,$,W aY4ئyZoR-scIDoyҾ9-fn俦G fDzӟq3s}6ؤRbG*b(Mr55G[ONv7q3"J$qSX|oH}2ʩmj~.IBa +瘋X$׭Uj5y-7#E\zXT@:HK.MvZMg%hGz͒$)YmGѭ >^*&XhnE'Pht30!¨%H3w D4ŽDmҖ.K0)tY 6ٍ9 w.ȝ{б,}EcF `-Bj{"!! O AEwkǜɈ5 i6gF<lt@)(0ɸ'hEwT D-:4ZK"蒩3p&?/NƜHz˥-d=>^YZGA9yF) SIZ3kOv{Ar1gA6y-tNc0<Ko@"/|<~7/8liZF6;5=AXTn ń(s"=\fCh{|,FH#%>gG33:gl~O>aو GIp< +|TwBl؋h[):]m0Ţl #[Mh g|(:^bVňT(]n2Va%,9UdqzB6+_.|ǁl7юRkn{]W&e5yՖO>@4!JP̦1uΛ|.}k5w BC!gn2'l4F!I0{TL X @SS!3xGȧiŐ <9o+Yd嫆EKt+r&"g'@ PSCczDh!_A84q_wZ/ C(DL5'9Q r&xE<`g&x<`o췏-}!pEGrUZB\3n1rպK֡d<ѫEJ;dS㋓^'q|!W%Ms($D'lRcɘ|keQ9_i}K]K_0} +"=CĢ.DPy4ʢpE}`Pm 4}Grnli,^6Y]\ˢlںOh9eXTz]Ibj+|=EE_dr,܎K#0HPKEHۄhi*&&8|vVy._\D7yT\)i*'5pӆm*+?\HW3@',zT11iMc=meu*XsЍGlVYZjȇA6F.:SVPJB7ٲ[ɽA(:[l=qI+e +6dt9S`2-pmQZ2cUVѡa}$QR*}Hke,e1őEpFfVmlQس-FW$72r[K("% 2'yϱ6C1Z nPM)6tPx MQk&_uĀ9RF?g&.pŦǎؤ +ȁ9su[k/]Wy1ˬ-}8GfL`$QR>%޽:jTu& +8ІOqt[oN"D9&f\eu)6izqeYr҄N,0[o +xç߄g0_ߜJM0'Wj4@a9?d&tYG!兼h1ĀXn.82Y} ɊF:^T~t[Z[`;`.ř9C(x}?$W6&@CC#eԻD;kO6w.!)7n+n䠠~? +endstream +endobj +170 0 obj +[155 0 R 166 0 R] +endobj +171 0 obj +<< +/F5 22 0 R +/F2 14 0 R +/F6 25 0 R +/F10 39 0 R +/F9 34 0 R +/F14 81 0 R +/F15 118 0 R +/F12 46 0 R +/F13 50 0 R +/F11 42 0 R +/F7 28 0 R +/F16 159 0 R +/F17 162 0 R +/F18 165 0 R +/F3 18 0 R +>> +endobj +153 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 171 0 R +>> +endobj +174 0 obj +[172 0 R /XYZ null 765.9246077 null] +endobj +175 0 obj +<< +/Rect[293.665 654.25 300.646 662.67] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(figure.6) +>> +endobj +176 0 obj +<< +/Rect[215.045 610.414 222.026 618.834] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(figure.6) +>> +endobj +177 0 obj +[172 0 R /XYZ null 586.65239 null] +endobj +178 0 obj +[172 0 R /XYZ null 508.5008933 null] +endobj +179 0 obj +[172 0 R /XYZ null 434.555745 null] +endobj +180 0 obj +[172 0 R /XYZ null 395.1341181 null] +endobj +181 0 obj +[172 0 R /XYZ null 374.30947 null] +endobj +182 0 obj +[172 0 R /XYZ null 320.0546128 null] +endobj +183 0 obj +<< +/Filter[/FlateDecode] +/Length 2419 +>> +stream +xZm_ ]Jwh.M$WtKٖmeeɐP6e/lí)3<3(fqYehOc}NOazYTɫYN@컼,hMP_lj-,BiPm^!c\4DuQe[_-pg! z; zy,X+p"hHR2?lUsl)G݄&z_,?,J1mTsve8[-MX%{i%EV JYfM5̜sXKIY4YI>]e4 9?J) S;1ç}ʛ8쀳㫭vސnESiXJ稀^>m uTL82|ζؼ`[ 1g4NM 6Cը4j3.@cV;#,6-)MNj?#"$"$ɩ?7$ Ɠ`;yufUX?5 qY=ZFG753^5u\{pTz(aˑ6'"zr P ~^<͖ \;HK`f0#W.x Z E\H +8Y lP4,ʿ~:,mUkiB O/~ )ȇ1.b +A6~\)8dg_h&-IH30c"!"IohX%) -5\N!  pC.wE,M:J/>R:VdkKNx * ~܉% MC3= FF$NeH**R7C,^vPI8' +L Xn9 O¿8b¿.Nv-a~;pWS*oz'aI{s4j)55+P~T5DGq"6ٛHS='%EK^NFu<4J^ 3aSb,4S+1[[wC~a! [QxulV)x+X}Q8=pmyz/!æ`DW~ߣD1rS3/BHN18U\+Vu&W5۠:BԐ7'&^C^ōu.7#9xm~ژI;]m?9kJ&,29q7.jE&fxZ7TORo.{>ZM +S&M4ݡ9w>׳C`W\x{JQʅ~f:C#X&p "kpIxhP吩g?aYqmrin=Bj:B&7c +ַBԽrL>K/"$0/qc[,KSVEp:[H\[cc.$8Xx%9=Oy)CI_ʗ[qx$nMPf<ъ.B*}h_8 >x_T }bZq^ +|3^WXtKQT +&=ءCh? ]e `N< 89T0PB!uC3)asG3Q xy&Clw"@=`@?+8 9BIY}7.yz[K;qtUr_Hd9Fd#cf "OY +endstream +endobj +184 0 obj +[175 0 R 176 0 R] +endobj +185 0 obj +<< +/F5 22 0 R +/F2 14 0 R +/F10 39 0 R +/F9 34 0 R +/F13 50 0 R +/F12 46 0 R +/F14 81 0 R +/F15 118 0 R +/F16 159 0 R +/F11 42 0 R +/F3 18 0 R +/F6 25 0 R +>> +endobj +173 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 185 0 R +>> +endobj +188 0 obj +[186 0 R /XYZ null 765.9246077 null] +endobj +189 0 obj +<< +/Length 16987 +/Filter/FlateDecode +/Name/Im6 +/Type/XObject +/Subtype/Form +/BBox[0 0 2384 3370] +/FormType 1 +/Matrix[1 0 0 1 0 0] +/Resources<< +/ProcSet[/PDF /Text] +/ExtGState 190 0 R +/Font 191 0 R +>> +>> +stream +x}Md9ޯe1 `` /zfш;{{yIIq#2e?UdHEJIQt91;pk?qGה.-5=\ pu9BpaB| \/!rm֮ I܏21b56FooG(q0%\5+oan;YQ FoOҸv\s;!C? ޤDѮ4`>rq=Fks\ZLגUd|BzD!Na\ uC.Nl>5 +arM}қN+9/q$soSy5ZM2ZW)#\˸ȮEN3ňsj4ǵtERL 4l^ íߡkoa5ةK Sed^Q1"VũگҖdǀ1އIakoN(E*X^{LLi"r_e_b>ˈum]FLLQc&lM&F/pq +]eV{J,<:S/n }Lc S۵qe\#>\ j#%C& $"4f)RA&= ZkakΦ让7fL +g 3q씉t4<1YR[^&I@Ť .Ggl,GBjH2䴍a;L>P(dfЖc C'0CZ0" +@JYC'pi>~Q >?ЅI %Ӥ]0B&,0-+weL + 62aF]G66&VbriNx_20 #|\DK/de߬*@JS};1)teaMvJ7Ǽ(2'V1#qr.d +(Zp̓u RcJL9))obx&籐 +_)ktdAZ ,TjcR!ĉW"p7KH"4# ;ؚ 7ɠ>u4  +*J_$fo7t=j[D/瘯E>~iV + 4~C@ւµ'22i2_%˺Q"&GM4iEd&-HyETzuǤN@Tmksϼ?~/zE) s0=aXd%YKrR[fnCtL'T")hem< c G8N܋<~]V,_C>e>p:jPSp ^Y, >vش b i5dl‚ x`L3 += l`K8F܏K s0]@eYOn:O+0KN&"X!9EHI=q4ITDB*IHɤq~cl!Rm˷ֆ5v?y hR" H *Q1D9@9K2f$6 UoL ucK8Jԃw? iDP/>|ݩ5|IL 2 +^EKR,#5V:*GY J5 !E +^ +*$om2%&J܅oU!mbF&dTѳ{8 ,2+*9K4؉`H6>'"CS(ڤ6!+TScʣ֖%PHg]tEt䫓_ԮMQO,w^{oxfSŒ2y!1q-8 \VqK;>k+\f%{BiMPaJ9Π8w4>ɇDֱE뫽^+t=` E6 QRELzRjn#aJ@ڄTHK$P3l9 Y\+S/NsDBXU|(FJeE_f:>D66f9!'49Լus%rS%~4RɠK~/4k9K^C޾a&Fy}H×: --Qٷ}͇RRI# s*4'= Bu0'IaڄԘu(&Ҵ a1. 3TNL|O=_.}Èajm CPU9Z:seJii,JԢ-#Pl Li,)E0\΂Y| Ԑϔ؆0c `BTE'Q[ Y8NmZ>'L2/?9 +s +(sq{RD" QJ5]\-{q9MIF)dg;GN14KXMg#M+p +SV)MbJ۸<u|n#d\.Dui +z I`Kxar +>wLG#pi.~LeUl$@rAr(yV fTFP2aoyOFܒT=5LP'Ӥ0am53#uZemLZЏ9E/+"on <"Z[sC pMuEfn9Kk+m4Yܻ[GgM9+nI@f? ZSD?D"eLEojpVp9 NU.0zdۛ|n c FsLI0 ^`ν8_1k6-w ?; py0w  +)$@H#TbEYUvsk.ӉEXZZٶ&doq2WcQ +E%`%Ea Yy<Wz l *Д3ˮ)YS5 ۟XhNEi~ϱ7m:k;%K/_Q.\A«XthpfϳH4 [kEM~/ZFReNR90dO?/:+N)yâLv9ӿ+Ywlѯ6)xK "5 +9i|jwV qKM{ &zWb^9'8 c2+RcvJLA)Ɣrd\G&D~a|6twKR dK^v;Npإ7Ke] +cYLDJ ZőJ RL^ o0^gJ)H8O@>Y7L'%=ݕ4vLGe&”cX6o10z- IY<*s/N ‹>s}!dC?9+`$(%?e$ L#E.+<4U+Obwc*?~Jԭ!j|D2q~fT;Qa<ˇ6)Wdб!do-<,# z@?g ä`pQ:&igq$P~0s64鑺3Q/" ,!]n{iLRۛ0K8Ny \ b/`fɪ*XH݅{;1Nw~r-MO#y=0}8h-@tr]O&*sNџ;( 8tg&Ō "?#ޑQ^bй@dd7L)~ +zTkE_N TᄗPtHԌo0ˏ4bMLASy(v\56@`o@,H ظTɧ ؂bڜr +\6Ive2aGi~d%4utʱ.ECm &2&(}$^mDF(:~?p_&D@=pև:ж jx )gHKR>Lcc|F&wbre:5*O|njf@_,Ȍ_-D + t[&Io 0}f5&5rge7m$ܦiTj92 { hCtˠo +"\/ m>pQe^]iǤrxОZa!iDANdYE?yesMTx Hǻ5qʌfVLUF Zˣ:"L5B/SE#Q (:X$^L})OX{ 6@8!dPTF. /EJ=?LI&lѧ?xW,J`{%ˤє8HqC @BSc]{e2 P:s}؎!'.; oĉL"PX#݀z(`k-k*,^[ӹsYm^%ڃ4rrbA9h:`vۢw&Ȥb`74"$Sq.j1kDx#4*qx z"C}k0^D:S- +r;FJd`V8 uHBf5@MJK`Q~~aZI#x'_3:.5$@Z +<~޺Sǿ#~ ++b}n¤)珄χwVZ_v_oQ"WPu?dVoD] #6k"Fe?j*7 }Yz又cʒ7.|]_n*zϔz4'r,({Mْ)ȋԀw$*;y])g+{u7>n;'s,0 4UFKP9T'fe}Qo4FoMzb2$;ONL + {pZMHhg"#iL fGg $`bTȦ(8`q "@9.__N.f4a{ViQ6' s(ȍM1bp.c?nO3c8+-2B-I#g9yIC1"MA}D?K8ro"{ 1 ,Pu60S+3cKIҺ(8lm0͡FƙтQk6'}l[ e zqNPbqvG"<x\a&E]d~uO'#j7MSZF=4^([H.L: V1I*ږM򪋪@ވ%ֶEwaQPImm,'.kg4 )wbפ Ϝ6&3 fl0paTv8x*a"]Lʳxi~,'%2w?:gW}Rd{YtD f2wcDbJE`k5 -( 8[k[GsN8/z 7̡͊ 蠗?EZ .HΗHI~̯*|N<9Kc/ 4:(y&^5 \8Ufoc$}ݙT&Ȕgi)oXg Ĥ࢚M,x(!)L \):Z"`>-?'R@ۛ;^ԇ<x}W>dȢ"L'ex|R%r|P[ԷA3D 8h-0qbڢ'@cق1ߝA~z꘻a'a=i& ɣALȓ^N&sP|٩QPV^¥\N sarv&O܆&{58"FyvrTc[ D&mGi $ Z|Iy̎^¹t +~ܞǒo2%CjP<3nb4MJj'h!O&P1Ccp +fcZWɣ8|x£a)w&𜎼LqIAhՕg" +5HMJSj6Y)h_򜃆j4^oռE<1%Bq.&"Z)dc4 1T ft+CBxXY ܤْ4EVG贁TsQA#pi},&ّEx2y{,h]-Q/Ӏu TQ)2 c˦*f~Ϛ7)4BU?'Ksa' P؟2u Qp5v߮{.\ itBz@b 3d18}sx%ָafbZ`59^-=ABtb]]X<*TUS(E|_J=]+U0;B7R?k\:p5IsF[&Fg _"@2SKг +ʼn)"k`v~H%(|V]D|N9ZV)5aü1Vٓ!,E<4\z|tHD`D,ŲўJ\jhk]h)!٪P6nl`wqy j),ARϘmeRזã+q 5)"Rkp+9Щ`{0#UIJHO׶.8}lxW&]!|nXj+U͓ DY}hlq,T_8-Mw!+q 80Gy f43ikv4 (x%xs]&fk LU}T+;(@_ (nQ&"=Eƽ#Pg] Vum.vDD샙5ZeD$3\}.zdEܳg#1%Qv3JgdRH&<Nţ›H ^3020ZLG:xŇۛwsP1, +* d$?y| IoaΡ1D})MfmsEH{H\$'^1x'Loo*L*p9v}X<,saR(&qki39 JcMK0S{Vd1i]ڇB,arLR vOcqӗe6:Wpi)c>t}'%WAs9N1Cۚr91O]=M>}̻xq_xwS.>/ .w|Y/>Wx'l^%Yg L vT,[lc\؏{ɇs_$'#XիP!&&lb;Mh;Ma!&^$h Ig!TU RDi( ȚV U= gOm Ⱦ0!x}Fߤ&gR.<7}y!s +< ^efIlL1l6̊OSÂQ<0"x(X;s08{TwH%fPu̻xB(og,!)l8A [4ƣûX@kFsir!GnN,09%9R ++6&پI;jTZFF1X`F̹\npΪhjf j8dBd֖9eLX%IY[k_6*5lYcdzx<)ؓ–93jT$|S7%3IAkFjF#_TZMl@!+a,:.;h*M4BaSL98jeLh~'k)^=r> Sf &f['bIr +A^gƅp..l>Ow?הeJrP.Qxv+dχZ (ءm"=*q=kۛJF/R>u/Dzb:FӻR%G^Y"/_{7>gYL> +ɝDI/Bp +.لy0);<\ IS~!+0w P[FAe{ql,48%~Xϭ[{PC BPOOxVꋰ%㲐uLdZnIBަad!}+^DKC5}T 9I8C21xJ5w$V +fDfJXL0҆G6` rWZ9L +ݑP4 OAG_N#_HOBX^+%|UoRi7R{ZIrك%N_w]wWS[2GG9J<"1fѠy\x5\bNİ7XOCw dch}9GSBsqJ5,İJUKBi&xM<$Pu/45q˞,HjniT= tܵ_;kix1"y6+CBp d}^e4ϥ+҅DM8 [x0Eq?06yΣ8Q!zǬ99s_^FLM_NѠiZL"4EM:_dN1evcfO@*]-T,Ax}8%XtR@,|ernIp 0)XuҤ?Hd\y$,2cq%Ëq:l.'rZM$8xEkhg9Q}GJd4 zxcQ!&`o[t3%I؋y +~ۯUW~YcU.yanG +V (M^N)L@_`B]]oB{c\s?N_^0w~0ޭr89 6oyn>0hj U}>^q;8}6X/u3F&Z Z&lf43l,P_ٺ.0 +SV)Lb +۸<ʸ}qSt% !,6<l^*DMfp mM0d;q{zQ~UxxtQ4 ƾкAt0nc!0V١!4\)ΒNۛ7?K8wF)k|1 +,x_Vi0bO酻TKѣn"Rg&IpicXqt' 0I?I! /L%3kbDd1_YfSŔqy d_tEnOAc0R|*} ܄gC'ZF3yh>s7nOSC? }xVOfv'+'_۠=ճqm[y;;^DoOX-2 +u4݈D *y QatB~/Ēx]A +!ÂR>pe޲WAmt#Cm0HgW^_GvrGר#{e $nq'H*|#<'q(`W͔6%-4,-GA)aW`kc<ο|BSikk^1Vy]x<a^ }-Ky~-x+L OXXodp_fa/+OrA?߼$/y/}ws1%ẑ_w Uca{î!7?x.Tܨ9o3H;"y7@UBoעk}mo-bဢqFRaEњ>`K*z'A> +endobj +191 0 obj +<< +/R14 193 0 R +/R10 194 0 R +>> +endobj +192 0 obj +<< +/Type/ExtGState +/OPM 1 +>> +endobj +194 0 obj +<< +/BaseFont/JDUVXP+Verdana +/FontDescriptor 195 0 R +/Type/Font +/FirstChar 32 +/LastChar 121 +/Widths[352 0 0 0 0 0 0 0 454 454 0 0 364 0 0 0 0 636 636 636 636 636 636 636 0 0 +0 0 0 818 0 0 0 0 686 0 0 0 0 775 0 0 0 0 0 843 748 0 0 0 0 684 616 732 0 0 0 0 0 +454 0 454 0 0 0 601 0 521 623 596 352 0 633 274 0 592 274 973 633 607 623 0 427 521 +394 0 0 818 592 592] +/Encoding/WinAnsiEncoding +/Subtype/Type1 +>> +endobj +193 0 obj +<< +/BaseFont/CZNGAK+SimSun-GBK-EUC-H-Identity-H +/Type/Font +/Encoding/Identity-H +/DescendantFonts[196 0 R] +/Subtype/Type0 +>> +endobj +195 0 obj +<< +/Type/FontDescriptor +/FontName/JDUVXP+Verdana +/FontBBox[0 -201 886 765] +/Flags 4 +/Ascent 765 +/CapHeight 765 +/Descent -201 +/ItalicAngle 0 +/StemV 132 +/MissingWidth 1000 +/CharSet(/y/n/c/one/M/B/o/d/equal/two/N/p/e/three/parenleft/f/four/parenright/r/five/s/h/bracketleft/six/G/space/t/i/seven/S/comma/bracketright/T/k/U/w/l/a/x/m) +/FontFile3 197 0 R +>> +endobj +196 0 obj +<< +/BaseFont/CZNGAK+SimSun-GBK-EUC-H +/FontDescriptor 198 0 R +/Type/Font +/DW 500 +/CIDSystemInfo 199 0 R +/Subtype/CIDFontType0 +>> +endobj +199 0 obj +<< +/Registry(Adobe) +/Ordering(Identity) +/Supplement 0 +>> +endobj +197 0 obj +<< +/Subtype/Type1C +/Filter/FlateDecode +/Length 3588 +>> +stream +xWypo ˒%2,9:lٲn}iSsIOҜL=#ɶ–:Úv͑* G~#R?}mn6l@tw5/nnm怆+jقo&Uq%ke!aF6# +ήqQ8͊gp ފfK U P%SQ_P/qyHP(*nu ( +j EwC\f H;T;>Z|\qx1޿L'o \{W{S_f :NJ0e{Δ6 YDen{(pMXT@)Ogt)*0 *O)R]Һ"} +ңѤ=: X&i 6=q)IgRHRhJfBɎHέȝV=ճj1xNyL(̾ Zߔ+V2P^\%~V: zYaނW3p +Q $78"򪼲I:FQUUro췝侳mVWB[Åx.C){)52h1_p5R-'V +GΔ#m˚ *_SRڅ}W {{q拵{y&0#.flB );׌2>mX2=*@ʾ"X.9MgrLxλῴwx )ֵ'4nG M>E|0Eէ2`;@j|wPѽԽSxF~:we_W|0 0_oR}T/g Jҧbژ!eZ"T >~uҽ+sKighfb9I$5MhLJy8 }7O&p1PN$b`BbkEx<>Α m6n=Al$&p`]Fө\,d$-Bchx47aG*3)ä=BM!hbl( gob1US*(`:%VUi5AkU[ՎaPA(%O)f4F"L:QĜ6^=ĬVF`;F VKp9K50_ypVӌ ݍ?ÀKP8VQK4zEa;yPT Ƅuڑqd\e8Gl?E^&bqE3mpt8doZ!]:~9T*zK$$+#8>0au9O8;-CԐAɴ2x׌`fhQ &'7LE~8e Rf b&Y3P:t(KJ3Չ) sA#S"!fvp2}c7eyƙL/1urppY|F2w DaP'45iYLeBb%^X6 gYt+bؾG7P@P K>LXclChuqAi4zoik\+)O 򊼪̫M˦x ^^ ;O-2]s4/|J"hJKS μ.;5kr9EVJ ia?Օꎝ u:h |j:a:?>VˇD"Lk~]y~|ooXW31{wxo̽;h6 mm}vLZҩpF@`SCOo{¾sw4}ί>$W333 MOx* +ѓY(×^H<D?9zEi&zt56;5xJepv8$B;mU+:=$ ă +b+k7?FZ~gR4"7ь6"+ 'zЌVR +DT!##oDTңE=6 iȌ";tmQK4t~ Setf=e Ҧ\h]oo/4$b>g9gw&+K˗_om*FJJ}F|)*S]P+W7E?_6BO^&J6T!f-G ^o8c{NW8;:||cZV}?~a +endstream +endobj +198 0 obj +<< +/Type/FontDescriptor +/FontName/CZNGAK+SimSun-GBK-EUC-H +/FontBBox[0 -141 1000 855] +/Flags 4 +/Ascent 855 +/CapHeight 855 +/Descent -141 +/ItalicAngle 0 +/StemV 0 +/CIDSet 200 0 R +/FontFile3 201 0 R +>> +endobj +201 0 obj +<< +/Subtype/CIDFontType0C +/Filter/FlateDecode +/Length 131 +>> +stream +xcd`ab`dd .uwu u !#" !y_ Q£G1%?)3%5$APW ߏ>z{@&}fc`!6 +endstream +endobj +200 0 obj +<< +/Filter/FlateDecode +/Length 28 +>> +stream +x &m;_ +endstream +endobj +202 0 obj +[186 0 R /XYZ null 288.2703005 null] +endobj +203 0 obj +<< +/Filter[/FlateDecode] +/Length 250 +>> +stream +xڵQN0{v8~qDpBN uqq D[,f20laUzrzp_`K8Hi%7*=\RV pTJ&UOhm?Ǥ,Rµ;6rfSu>~߿4 +m6a >qa.igeE ~FOjK aEJEM9Vn1B̮3BpʅJ䞋oֈ9 +endstream +endobj +204 0 obj +<< +/F5 22 0 R +>> +endobj +205 0 obj +<< +/Im6 189 0 R +>> +endobj +187 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 204 0 R +/XObject 205 0 R +>> +endobj +208 0 obj +[206 0 R /XYZ null 765.9246077 null] +endobj +209 0 obj +<< +/Length 3327 +/Filter/FlateDecode +/Name/Im7 +/Type/XObject +/Subtype/Form +/BBox[0 0 2384 3370] +/FormType 1 +/Matrix[1 0 0 1 0 0] +/Resources<< +/ProcSet[/PDF /Text] +/ExtGState 210 0 R +/Font 211 0 R +>> +>> +stream +xZɮ\I߯%|Ɉ$E 'X 6]R/s"[Óm^SƜm5??.?,n-Q7/)9n\9..Y_;}a %oRʚ¦*p ֭ n)c.%s}XTV| as&4ˀԲDZh41ևep1 ˁZ TUE/a +x{Ǣ|=24@WP, +ʵiy\~mgJ".^.(Ikg ҖZ>#E$u.\ t.ҹ BlWxIrf^ED$c@0ab$`RO +m {o^ lB(c Ǻ~ұ.ȼ_iR8֍D2cmAc_aLqȤ4u'qX&za^;&7d\Kq_w)ݬnV ?4ۙL`~y%OtD^+;Ρ \BcXx>,}pu siR@CB+b44:2ݯl6JPYayrWtځqf֦1ՇЦ\Z怖S.Gm$pb@<*9spD<,!pvꐽ|$'j@8!iS;<%zHdN6+xvbҌ[qbɔ'@lPFKN7y*>s(= 9?IJr6utҥb䘣/l1kFm}e0%WLl)YG1mwFVZT01}b0吩i70f=ÕZXtt$XOYx9=vɆ\z7JdREm8A&9T- 1Bc 2e;@D%h 8l ,2F +- 8@]!*b xzWhFMfL qZ0ڐVLAC |6YX 0L3 b?b\ӕ8Ƴ1RD;ɞ0P͠b]npŶ7BAmE!> EL;tlt%䡦0F2b=s`LЬ5`>3\ aW|Ͼmh[B]3 ^펂WifTHfgpg٫~ʹM!gkc  +&D98Yշ~ԈW !x9XYisTTFH2Yq#Q]9Ne|t9rSÕ˃;df+@h;뽣0^j>ZwPV׏v> +endobj +211 0 obj +<< +/R11 214 0 R +>> +endobj +213 0 obj +<< +/Type/ExtGState +/OPM 1 +>> +endobj +212 0 obj +<< +/Type/ExtGState +/SA true +>> +endobj +214 0 obj +<< +/BaseFont/AKKHWY+Verdana +/FontDescriptor 215 0 R +/Type/Font +/FirstChar 32 +/LastChar 181 +/Widths[727 708 352 0 0 0 0 0 0 0 0 0 364 0 364 0 0 636 636 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 771 0 0 0 751 0 0 693 0 0 748 0 603 0 0 0 0 0 684 0 0 0 0 0 0 0 0 0 0 +601 623 0 623 596 0 0 0 274 0 0 274 973 633 0 0 0 427 521 394 0 0 0 592 0 525 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 642] +/Encoding 216 0 R +/Subtype/Type1 +>> +endobj +216 0 obj +<< +/Type/Encoding +/BaseEncoding/WinAnsiEncoding +/Differences[32 /summation /pi1 /space] +>> +endobj +215 0 obj +<< +/Type/FontDescriptor +/FontName/AKKHWY+Verdana +/FontBBox[0 -201 886 760] +/Flags 4 +/Ascent 760 +/CapHeight 760 +/Descent -201 +/ItalicAngle 0 +/StemV 132 +/MissingWidth 1000 +/CharSet(/pi1/summation/n/mu/one/z/d/two/N/e/D/P/r/s/space/t/i/comma/H/period/l/a/V/K/x/m/b) +/FontFile3 217 0 R +>> +endobj +217 0 obj +<< +/Subtype/Type1C +/Filter/FlateDecode +/Length 2117 +>> +stream +x={p` +n4 !ô<8M@ -MXYÒ}lYKZ[ڒmjt&45 2Ф30:!tXyk=Ν{ +eDAAuX~W:Ej9*GT1MzuI/3יp ^:ry0K6?޺+~zn*J(~MV3fyˌg&NFp+sVJMF U6tY)\M OsIta},uDGff&vueTy(v͕ϕ_U݁qFXSbj4kZP[PÆ>b8@7Wp&9; 0iN)SZ8; ^gh\tUz_Jس E{Kp;33ٗ~xj:s!s=WMS?nFYK{8P!SQǨ}Ěn9Qx PE,ƴ6r_}dA9J#Ìo gbGRth7 06n_khli*] Kh3r3GlQ k5ZΡշ; ew;- 0F"2K8 bK2}lζ)/(iuR۠cu<2H'$e[1f1iIMHn)ԃԥhU-ѤomnmvjAuAy)ӝ5SQW̕qm)k [}-xڬ62{HWֳ(3@9ɤ5me['p ލLN&N98iUh'iw[\-gK}-hgz}P:pS8J7IޣyF>cD ڙ=~/U\#-$mgLl4iy 📋,B'SxFP:N+ 3asbQwqoLC#c*(155ze*pŘtLre0z<1o)zP `tV)Et$c:g <wOuOz].J*VT-K09\-tubE"MIEEO&L$ ׈5KMtR)B`an/0$(!@ +%BUD P/pHTjPP#BYEΛ1w0}AbdM<PF}@ fƬ1jSpAqXkZUKӥcHe1!聞89,sZJ-a@@n13FRK!KZl)IkшoM\,5$;ᛆ3J9|!H A.W Sh^ !2ga0 I4a4HaU =MH.FhqɁhvc&R߬3jZ)94lgm,o-]0E=Ds&)G%‰p?-\vC4,;.[ n9o6/&\9:46<9:9:Kx_Pҟ<vbbbtPuPnlj+UgXh; ai9mX]]iQש*0RA^4ࠊy /=U$ @4.3"ϕpQ𑨄<ۈU?E._K/" E +endstream +endobj +218 0 obj +[206 0 R /XYZ null 573.2585252 null] +endobj +219 0 obj +[206 0 R /XYZ null 529.4782585 null] +endobj +220 0 obj +<< +/Rect[356.499 476.126 363.481 484.547] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(figure.7) +>> +endobj +221 0 obj +[206 0 R /XYZ null 458.0599352 null] +endobj +222 0 obj +[206 0 R /XYZ null 360.0688507 null] +endobj +223 0 obj +<< +/Filter[/FlateDecode] +/Length 1375 +>> +stream +xXmo6_oŰi 06,؊֖׭wxWo"H(vv̬NYk=!2|d3ƋTMF^=\0e %mB&pP~CEЫ}$`?\9Gg$ *c4>)%z [v1KfC4bORuXF -~1j|t Kjdz;\@gڒi(|7ra>LuI.7TΠ}:1bd4u2ztb~ӨtVk#ߢK}G|ZeV/P >0jKMV߀Nhxg#,8 Eum>！.Of<3||gZ ȻEYA/SAO#^^bӣlyVBVVvV:m@LWM=}\xR;੓m^|E~@"!IL!;:jXMe$ܦY׭ÔH#>)$4cޜGL͝nIŦҬҵKiN3ezWWDa ,:v[BqaVط.'Mpڦrl"ڙSS?^.y/zwV9Ri -1~,lÆQGz;N'CDJ\H<.sO'ݘ@?j~X{CKwv1&8Yq0 [\S/;t݄2z_b1؉@=]òFXG"4łoU;6_+֙%t@]fi A&Ui(B$[$#ltjf> +endobj +226 0 obj +<< +/Im7 209 0 R +>> +endobj +207 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 225 0 R +/XObject 226 0 R +>> +endobj +229 0 obj +[227 0 R /XYZ null 765.9246077 null] +endobj +230 0 obj +[227 0 R /XYZ null 697.1642097 null] +endobj +231 0 obj +[227 0 R /XYZ null 582.626882 null] +endobj +232 0 obj +[227 0 R /XYZ null 545.2311207 null] +endobj +233 0 obj +[227 0 R /XYZ null 521.6169455 null] +endobj +234 0 obj +[227 0 R /XYZ null 445.0583828 null] +endobj +235 0 obj +[227 0 R /XYZ null 377.8687545 null] +endobj +236 0 obj +[227 0 R /XYZ null 294.1771811 null] +endobj +239 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F19 +/FontDescriptor 238 0 R +/BaseFont/LVZEZH+MSBM10 +/FirstChar 0 +/LastChar 127 +/Widths[778 778 778 778 778 778 778 778 778 778 778 778 778 778 778 778 778 778 778 +778 778 778 778 778 778 778 778 778 778 778 889 889 778 778 778 778 778 778 778 778 +778 778 778 778 500 278 222 389 611 722 611 722 778 778 778 778 1000 1000 1000 1000 +1000 1000 778 778 556 722 667 722 722 667 611 778 778 389 500 778 667 944 722 778 +611 778 722 556 667 722 722 1000 722 722 667 1889 2333 1889 2333 0 556 639 0 0 0 +0 722 556 778 667 444 667 778 778 778 778 222 389 778 778 778 778 778 778 1000 1000 +778 667 556 540 540 429] +>> +endobj +240 0 obj +<< +/Filter[/FlateDecode] +/Length 2382 +>> +stream +xZKs6`퉪0x?<5le3Inm-3H؞_C(NRh4 #m~|]?չ 2eLI͆"%E6|4-CNMZ 'lV^-ۇ꼜E]-EPV'f魿ZW*/W|(&n(Xѷِpd8]G(i1ngK3q+"*u[W%HΨ_>M{> 2lvS S*lqc[:'8jȑ:îŝ#&,ټfH+^?t>s޾oFS):f`H0 Hp+ohCA8Q(1Q`bd%ؖ ,~>FNK= 2A#cb%i* q=5FC=3cmZ2)QQ]y k&e37$OPF2,n8'r^ vIF {h$ MJ1~*H 49j?Xݱ",@K]N a~8V]C[c퀢8#7Ce>02h2Q4wQ .^ͣY@<, q&Du@@M 55pD1;Zto3=v&vd?WilKѶr 4ʉo6 =ҡ1Ux'=ݕ:5zn/Mb7( l(i1kv=wl -j-kZt6 FT=$>!h{{W.ˮ!EN`ӈt)Q#+:IV;G/\cy1JT"$6OQM_w& O6D`SLE/PB,Nt9IО3kq2~V{KueiZ%耕16uU&_jweuiW5+Z70!;fvwNŧ4a +_ Yi<^\E٘#3nu*Ħ~|zĉ/,Bˍ~M| +YI|cc{yݏ#w? }eь]X= +O#R +W)G[Y}5b +*p,X+.ge5 Nt .Fѧ.]E^rUI.G׊l)(3-5ʥ A]zZ.E~q>ڻF{Jڕd ,{poP"E/R+sR㪞ƭfi-lU[7ƿ +c, 4XIhMbې?|Sz]ۍ͜6"h ں,.+WVk4*I 춈-aPTA6 %Jd ؇5aH(B 5p ؐB6EE;1R<&MwEě ɀ;ֆh"I26{gʑ.svHaMQWGds +[Sj_c+ߠjmyy8WVz1ZyK=B[Z✯9 +44n*6}L!27DЄݙ ?ЄX~o4кQ"R݁Y4u }P3K + @qm?~3JY 12vRp1_/Kw .Ǵg\X%L`+"kRmDg&ދU5 MY{l/-`{,4ޤ B&yvK"N5·D\}_9- Vͩ/0cAf+*4x@J6OXd-9b Ĝ br{(vtr@䤇bjcܿ݉ {.j04ؘ d> +endobj +228 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 241 0 R +>> +endobj +244 0 obj +[242 0 R /XYZ null 765.9246077 null] +endobj +245 0 obj +[242 0 R /XYZ null 661.9622935 null] +endobj +246 0 obj +[242 0 R /XYZ null 608.7131406 null] +endobj +247 0 obj +[242 0 R /XYZ null 551.2614397 null] +endobj +248 0 obj +[242 0 R /XYZ null 506.165033 null] +endobj +249 0 obj +[242 0 R /XYZ null 459.6481718 null] +endobj +250 0 obj +[242 0 R /XYZ null 441.2034692 null] +endobj +251 0 obj +[242 0 R /XYZ null 385.4381628 null] +endobj +252 0 obj +[242 0 R /XYZ null 327.7356933 null] +endobj +253 0 obj +[242 0 R /XYZ null 274.5326474 null] +endobj +256 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F20 +/FontDescriptor 255 0 R +/BaseFont/VJBKLQ+MSAM10 +/FirstChar 33 +/LastChar 196 +/Widths[1389 1000 1000 778 778 778 778 1111 667 667 778 778 778 778 778 778 778 778 +778 778 778 778 778 275 500 778 778 778 778 778 778 778 778 778 778 778 778 944 500 +722 778 778 500 500 722 722 722 778 778 778 778 778 750 1000 1000 833 611 611 611 +722 722 722 778 778 778 778 778 667 667 760 760 778 778 778 778 778 778 1333 1333 +500 500 947 902 667 778 778 778 500 500 833 500 556 778 778 778 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 778 778 778 778 778 278 667 667 778 +778 0 0 1000 1000 778 722 889 611 1000 1000 1000 1000 833 833 417 417 417 417 1111 +1111 1000 1000 500 500 1000 778] +>> +endobj +257 0 obj +<< +/Filter[/FlateDecode] +/Length 2498 +>> +stream +x[YsF~_%`lN0\[Z{SI*D~)HB4Yv~vcp V}IQ$CoE=~}KYb.#͈&*F~d9[K"Jtެ&Lp^Ҥ[# 1DI57mI9Qwy9Le:+WbN͒1Gc7laNbEyM1JՑ&Bj?9 v?̱0%҄UMɇo"`/"p6#t3O +$ +wIX'yZ'yYGiijT# )iJy0C}EXLFVMl NE3lp Gr`dr2mHD4,^}F&8Y?ےT6FG1{B!ȧf̌8/gMfDPPY_O[X=hآP;*K +au";OP[Qr"9;xKgɔszy!dH-8WqrC'U6Q-Y0[ ҕl +BU3Zۻ8U8ܣus]^ߛ,!&#cJ'^ɗ N! ׶YiO)QUY[ +y_TTmWfM M8h& 2jp0]dԀjIH{elM=6 wonvI"ͼ1I$sjzyH(mU,C%9ׁM>1çG\0$d` +byJ;5BmTڞv` o҈aC Ӝ0-bJ$&Q?h!,Xʟ|y"ڤ˫:P("6O*WX|UN4jj +w۴WgQ +}M) +u(QTz`aN E it%"אfK@D +D{O!*#J4QI>Á̫2np1O%!m%D'.m*$),0uÊ:\>+ +N6K45AQ5M(cW}v"$%0C*gyO6i\$I=RRu_@ +4\dQ'Lŷ5OqD{p\%>)DI D{L>@_ըI0΀_7t[om~b?@m_Cs%PQeI|x=j}֡"VEW}1TVz?Qeq* H; .],qS'cMf,/Ňg#PڃZRCމ9{2'*.{9-z +m@:` A{X%l>b\PkZz߫]ڳyVz +.مd=?gRg~٠WQSr4j2g8}]-'3mm- ] }e(|/]7Y9>/1xjkqa])ܗj˫x.zBP9&S6a!F=Yjk+[xyDBn a15 +MT&Up{L?v4G +=n>p˃J0G5K%K^I-Oj[qW]j̀2qBffo>6,稜fqN6ɨRe*ʺ<'pM5T'[̓P]=0:zK$r/?9ZkC%xN+>b ^JG~]LAW!~;dbm3[F>QǏvK +mrI)DGJؚ3p׼u"v8 Z$616X@ g![J؂n"D+o6aɖ6rNS'oIYJ!dh +a8E<.HC3/Aˆaaj7#+CDBlF)-scoH6&`Ő(MrTT-^ܙw dZj;0}nhǞ6/c((4:uI0XkM +endstream +endobj +258 0 obj +<< +/F5 22 0 R +/F10 39 0 R +/F9 34 0 R +/F13 50 0 R +/F12 46 0 R +/F11 42 0 R +/F7 28 0 R +/F16 159 0 R +/F14 81 0 R +/F19 239 0 R +/F3 18 0 R +/F6 25 0 R +/F15 118 0 R +/F20 256 0 R +>> +endobj +243 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 258 0 R +>> +endobj +261 0 obj +[259 0 R /XYZ null 765.9246077 null] +endobj +262 0 obj +[259 0 R /XYZ null 703.2222872 null] +endobj +263 0 obj +[259 0 R /XYZ null 562.0283757 null] +endobj +264 0 obj +[259 0 R /XYZ null 465.1818486 null] +endobj +265 0 obj +[259 0 R /XYZ null 342.3422955 null] +endobj +266 0 obj +<< +/Rect[297.512 283.469 309.475 291.89] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.27) +>> +endobj +267 0 obj +<< +/Rect[330.168 283.469 342.13 291.89] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.23) +>> +endobj +268 0 obj +[259 0 R /XYZ null 292.5914071 null] +endobj +269 0 obj +<< +/Filter[/FlateDecode] +/Length 2815 +>> +stream +xZs۸~_'jj# 0Jł"%R;nEH~ gO.'wt?G4lwً7fԪ +欟Z W39ۯYWTI|Jxoln\Ҭ4=;ƕsr͚jU|b]Κ*c:v<-:>]Q[wY"=O8S!Xjhq4h4LOw]wgajv.d0bz +cKYUS%b5f*/gyq +YҐgAz"%U54y@>bVl}IA +sӭ[fsvM s.+ iEOtDipQ`y|v s[*wθc*2ج6v\AS nFD2Ԏ)ȞT3iC%&>=5\& ]_Eʇ7ur*j@Tj]]P@YFdtCպ S02 ޭon@Qe\g;8lE ^kże\fUa31 ¶6FHa|lÙ64<\e¹d_;m1AgʹGʂ z +"G,TXMst{Qto t+Ȑ +K`S >ʣm厬h^j1'Ӭ:6?eMFeZ {Bx`O[ +p fP[d{ps+]_G7!r I}X{C>4s}> f]2h;3N"qyW?MLS)#q1YNB6wpI @3Js@A'`4&Ca)JAe:`z>>9TE|"=(4-y"!z- u/qo.x?ЅVX +&Mz^x&8 = 0!t)/}{ 9& CGYMv0 3]CuLdĢ12Y1u R}zLuzM^r=.qG _Rf4OoG4ɂM1 +:1czzD:&Nq7SSEM7|w +AwO2}5=_3ijᒬqmZX‡T + +Tu=Xf6 +cta~?.jZX{aR?2k˻{I +}/j\66mF-o)6?wFg,? +՗, hAϦ^z4Œ2'ȪH:HEid9L!X8'ӀlAr]SVa2cZq;Zgz6+jeZtXgI鏣)[.6a̖Enҵ82M$T x ~9esPb`nNvgMʡe\mr,92$Vh(W7M/tN_ۓX쿉"`{D€^7ka4oM-e,:|ͥJ6xNcR^͢rzA/P_ 9lQ)!`<↥'-ol;x8{؏ZgUYGsmVWHuiSM~jȠ?˘"Sn}r!UK6E֐Ql$(*' rk Nm9ƚCp+v$վZ].xO,q]ґ+(f:X)vQ! +xT-^1S+r>4%|Q߳FA$ ߾SX)ñ"_GTJ /};ۦz+1,kavy{|mG%92-y\20eXꦭQ ku9f #mq,=r3NA%d A<1 m^sG$xjo$I]*'F~Z}A\5Ȗ=]㚨.$e 8sô$[;0voMǀ +OcjHpP` v#$Ιtb}b+ְ( 5k|LEjzSmo*nϓjgy]gغZCW#QfgQXF]C8+dx|2!z6K1(k=c ^au#)BP~N.zfpsՖߢR%;W΢pĸp~ٌ[>zd;/H,h]Y8 -F0 l +endstream +endobj +270 0 obj +[266 0 R 267 0 R] +endobj +271 0 obj +<< +/F5 22 0 R +/F3 18 0 R +/F6 25 0 R +/F10 39 0 R +/F9 34 0 R +/F13 50 0 R +/F15 118 0 R +/F7 28 0 R +/F2 14 0 R +/F12 46 0 R +/F19 239 0 R +/F14 81 0 R +/F16 159 0 R +>> +endobj +260 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 271 0 R +>> +endobj +274 0 obj +[272 0 R /XYZ null 765.9246077 null] +endobj +275 0 obj +[272 0 R /XYZ null 741.0180075 null] +endobj +276 0 obj +[272 0 R /XYZ null 721.6323905 null] +endobj +279 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F21 +/FontDescriptor 278 0 R +/BaseFont/LXRMIR+CMMI12 +/FirstChar 33 +/LastChar 196 +/Widths[610 458 577 809 505 354 641 979 979 979 979 272 272 490 490 490 490 490 490 +490 490 490 490 490 490 272 272 762 490 762 490 517 734 744 701 813 725 634 772 811 +432 541 833 666 947 784 748 631 776 745 602 574 665 571 924 813 568 670 381 381 381 +979 979 411 514 416 421 509 454 483 469 564 334 405 509 292 856 584 471 491 434 441 +461 354 557 473 700 556 477 455 312 378 623 490 272 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 607 816 748 680 729 811 766 571 653 598 0 0 758 +623 553 508 434 395 428 483 456 346 564 571 589 484 428 555 505 557 425 528 580 613 +637 272] +>> +endobj +280 0 obj +[272 0 R /XYZ null 664.9283437 null] +endobj +281 0 obj +[272 0 R /XYZ null 579.6390325 null] +endobj +282 0 obj +[272 0 R /XYZ null 525.3841752 null] +endobj +283 0 obj +[272 0 R /XYZ null 522.594633 null] +endobj +284 0 obj +[272 0 R /XYZ null 522.594633 null] +endobj +285 0 obj +[272 0 R /XYZ null 525.2671215 null] +endobj +286 0 obj +[272 0 R /XYZ null 525.2671215 null] +endobj +287 0 obj +[272 0 R /XYZ null 499.4196069 null] +endobj +288 0 obj +[272 0 R /XYZ null 499.4196069 null] +endobj +289 0 obj +[272 0 R /XYZ null 489.4016172 null] +endobj +290 0 obj +[272 0 R /XYZ null 489.4016172 null] +endobj +291 0 obj +[272 0 R /XYZ null 489.4016172 null] +endobj +292 0 obj +[272 0 R /XYZ null 489.4016172 null] +endobj +293 0 obj +[272 0 R /XYZ null 455.9093543 null] +endobj +294 0 obj +[272 0 R /XYZ null 455.9093543 null] +endobj +295 0 obj +[272 0 R /XYZ null 447.9945919 null] +endobj +296 0 obj +[272 0 R /XYZ null 447.9945919 null] +endobj +297 0 obj +<< +/Filter[/FlateDecode] +/Length 2772 +>> +stream +xZK۸WhoReop|&NSLU*-Q3%r,i< $@B{N*"nt'0HM&Gw(K>}5ğ~w? $rr(J2bp'yʉ)erf6tZ.žjjmsS\./~Or+20P)Z" M0CUyRc +yN_}a&^nک])  l@bBz}9E0C$TIfǼwt^ 3H"uGkM2:Rgo7պ㻏^XV\sn3X`*:V:$o} rP$ȉ¿}H /!9|¢i5cޜ7~i1>-?Ɣ@hD nTGр1 :8,CjJ 1"BF2TnɣS(1SfbߘlTiTz nƔ#w4alniLRS:`X0Ate9X¿BK*$^ˏA8ʓ7]Y?UkX ҮZjbQCҏ.v +v&UB%F f}mEJo߸oM}UWbZevG6.M$L-焉:6uTlKbSdAۭq1wN647jSLL9r ]θػ>JJ2"T,[4BsmBtSV%92Zty/a>- b8f 9™`$@lⴙ1֦X +_ +s]`NwMsp}qlUYlD܄"}73!;"\EYèYk]Xe 6f"@,z(d!T +HHy%6cWXEsgLÿR'uʔ>oK_zhIuNA)Z%Fsc_AӺ(ot=y!bv0|]HC}3'^\ T8NYDfA:c' +3Ng/BpbT]Ġ; ((~@uĪgJW?*6PU2-I:Õw/}*sXgim-L.o 2fbP$:.e$>S:OGT',9Dkoj$')!A! an 'B l Z3KcIhJHKe~|@8B^&<$TCG `tҏٍ;&cj4Nx@A./q %>%+TtV= +MCZL>m6F |bJA+(Kr2 +endstream +endobj +298 0 obj +<< +/F3 18 0 R +/F9 34 0 R +/F5 22 0 R +/F2 14 0 R +/F21 279 0 R +/F7 28 0 R +/F10 39 0 R +/F12 46 0 R +/F13 50 0 R +/F11 42 0 R +/F14 81 0 R +/F16 159 0 R +/F15 118 0 R +/F17 162 0 R +/F19 239 0 R +>> +endobj +273 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 298 0 R +>> +endobj +301 0 obj +[299 0 R /XYZ null 765.9246077 null] +endobj +302 0 obj +[299 0 R /XYZ null 741.0180075 null] +endobj +303 0 obj +[299 0 R /XYZ null 702.6273198 null] +endobj +304 0 obj +[299 0 R /XYZ null 604.6545839 null] +endobj +305 0 obj +<< +/Rect[237.741 500.53 244.722 508.95] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(ALC@rem.7) +>> +endobj +306 0 obj +[299 0 R /XYZ null 450.3707369 null] +endobj +307 0 obj +[299 0 R /XYZ null 369.2447074 null] +endobj +308 0 obj +[299 0 R /XYZ null 306.8128114 null] +endobj +309 0 obj +<< +/Rect[178.846 197.982 190.808 206.402] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.32) +>> +endobj +310 0 obj +[299 0 R /XYZ null 209.5112798 null] +endobj +311 0 obj +<< +/Filter[/FlateDecode] +/Length 2763 +>> +stream +xZݏ۸_!Ibh&pAW֖Kl{gHʖ,c7܋%QԐ3O:d7as.Ix&X-i1:KƚU%O*&b4fLXd"pŋL\YZL|G&y])˩z3ߓWnI5\2c)|QכEYK!7,jMzy_HkFw0qPGt'tVV2^uGdFw5Ҵ&yoFcaj]uqˮt9/G\g])10I7&KlĪ <9(X̑*,g3&CeDZ٥L f݌.{.2E,Bníq&`$n3\_*"A#dI_tf~馚47jV}{H4_ռ` +T!d4V?T߁7FYusS׳u;J QN2 `1]NЗInYuςҏhx)M g#`ƀkaꗚ,7x +ȼYnf3 W98 ݯuN|!ƀ'i>i M#{yZ7|V_rek?s\rçr/ +n{?ٔMYOioomfR;L AdP0 Gpz`750i!4ċh"6cva H+_AXEށb ŇhZD[FP3'^fH0nOt_k٪i$R~h(3'Jd$$!LaD@$yyo1 =, f{(&F">rQy! 'c(Ӑk5:!]y SkHtDvaﻂ}g]tYgNd7=ε 2λx݇gt/c1#}YD S96xYRv`G QrK}8H[x'h_e&BH(v%MB~: ;$ca^ҜCf>xdLW +8fLq<RՖi[:Uq(Pm -H5e7SgUseqB?Oo#ww|M{"l+]*~Y*:Ζ'YjZjR0k>Qv~_#0\2imt)wd_ΫnL3n㤎9WeX)$P7*o + 8: {gFbkY{ O._ ̇ڿ\8 V1b\sP뒹C23~/5b]M9bN ~z@GoJ{⭿,rJFַ_pu73w "ìDNOyۀ9VsP;%.yGwϣ %o{\XCJ1Yd@˨%E. ="\0̓쾒@h;ҍSCADxd)~UU HHn AhO&~d4߇>QjEv(& "SVSͺhӄrc x{]۸Xu?(7ƶ/gjOwn<,y3f*0dbfuyXZ؁dR]);,$2nxεn3!uvHF+0'ZȊp'0ElOA͜e@fHΈ'QCS69O0{,2n(5Aw80c@vD,i 4CRDi~JwL +qBEBpb;; B\>A-o> ~CŅƋTTd'#Sv42/D72 Hd^YLg6!-(A.9ܚG>!wqH2b^31dv~Qoh?+5ĻF=tvAC3?TG +iɘXph <} rBi$Pԧ*N8K`W;_|12vk S.@|!wաZ/84ѽuEv]3޶.G^FsSccYa}yW#ڭ q1F`^h1xNLk=ھ +Se}U.H.  ](Wy(sYiuhhs-_w-XvvQ{\`v %KZzD#,w8=ZP9RO, 6 +endstream +endobj +312 0 obj +[305 0 R 309 0 R] +endobj +313 0 obj +<< +/F9 34 0 R +/F5 22 0 R +/F10 39 0 R +/F13 50 0 R +/F12 46 0 R +/F15 118 0 R +/F7 28 0 R +/F11 42 0 R +/F3 18 0 R +/F2 14 0 R +/F19 239 0 R +>> +endobj +300 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 313 0 R +>> +endobj +316 0 obj +[314 0 R /XYZ null 765.9246077 null] +endobj +317 0 obj +<< +/Rect[234.554 694.1 246.516 702.521] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.31) +>> +endobj +318 0 obj +[314 0 R /XYZ null 703.7133504 null] +endobj +319 0 obj +[314 0 R /XYZ null 623.0020559 null] +endobj +320 0 obj +[314 0 R /XYZ null 594.3511959 null] +endobj +321 0 obj +[314 0 R /XYZ null 493.3684311 null] +endobj +322 0 obj +[314 0 R /XYZ null 475.6091008 null] +endobj +323 0 obj +[314 0 R /XYZ null 432.2023114 null] +endobj +324 0 obj +[314 0 R /XYZ null 318.1471843 null] +endobj +325 0 obj +<< +/Filter[/FlateDecode] +/Length 2554 +>> +stream +xZ]sܶ}ؼq^$N6L& -NVʲ?s XIn/^pq?pϹ,gogWg??gG:>;yB[k1g^\7{Jվ٬wɡ9TZV1+ڝ$?6b.7GA@p= ֖^uZrsQbxbV43\CRIs5u8sTkE|q8Zn 4=`Bnwatn݌y|/]50%!P66N+0{X_BCP|W]\̡`ZZ;VG_hy:ƥN-8wYxϖTrׅTérS!.7HHEuvPZ}DI0r :xUPTX[,s»)v[. {F8!Z+Zusy +IwlY' >Ѝ(V4ZCP@GĴ)|;^ Y̸Vu&cu?(v>b .:WWٖBJfh;r 2Wo@5^nDL%xpq&@G7^GhE2]Oe1n嚻ot +ZhFQJ}ty_goqm^0]v> +`0 2п3*.$pH=!J} +Lq(44hXP K%%%^ ek~E@*kmiG+J(D$]" +z>~RxsJ}O=0VG!@3Qqsە=E"b~1V}Ϫr +He牗?BY@|THJL@~w`ix}5uB\nx9PY&w(N|FFɵKcDT(c)F/XL:??m(" +~N{ +yZܕu>%ꇟvhnm&bl/u&<˒0[@7Ţ=y_09~rkYeV/ iR)]t1mPAg۫ժގLh&D2FWWLHd."0}k}&ii <w2M@6pR` Bj;T@bNM9dT4@$};"}rtNߤxG$KOGVJcG9EO\O+OnuOn32O.u㜦G1 0)dGn)б2S^hX)GR Խ})~_|Hq6OjI-#{SÝ?]:i(5h8in3%e'u*h=&d(1"+roH ̫ +oh`Al~.rU爛cum'Ao۪<^}g2N27T6 _+ +endstream +endobj +326 0 obj +[317 0 R] +endobj +327 0 obj +<< +/F5 22 0 R +/F9 34 0 R +/F12 46 0 R +/F19 239 0 R +/F11 42 0 R +/F15 118 0 R +/F13 50 0 R +/F10 39 0 R +/F3 18 0 R +/F2 14 0 R +/F7 28 0 R +/F21 279 0 R +/F14 81 0 R +>> +endobj +315 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 327 0 R +>> +endobj +330 0 obj +[328 0 R /XYZ null 765.9246077 null] +endobj +331 0 obj +[328 0 R /XYZ null 741.0180075 null] +endobj +332 0 obj +[328 0 R /XYZ null 579.7270964 null] +endobj +333 0 obj +[328 0 R /XYZ null 490.9349753 null] +endobj +334 0 obj +[328 0 R /XYZ null 370.5866295 null] +endobj +335 0 obj +[328 0 R /XYZ null 351.3156797 null] +endobj +336 0 obj +[328 0 R /XYZ null 280.8619095 null] +endobj +337 0 obj +<< +/Rect[359.291 192.441 366.273 200.862] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(cite.MarkovChain) +>> +endobj +338 0 obj +<< +/Rect[340.244 180.486 347.226 188.907] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(cite.MarkovChain) +>> +endobj +339 0 obj +<< +/Filter[/FlateDecode] +/Length 2517 +>> +stream +xZ[s~@Rp\c oI3Zvj"! D*$[{ `E{..eY6 w_J'GϓF&G̍S'G^ &fsuIͥiOy/gFjQ.)٪9{(Hc3UrTlVofb&lz=. ?g۩d.¬ԡ'ZzRsO9c`2eXiY72񴼞iWEܜŗӫUK\56K9\9 g&,7aRDwnMARUӷeU7 +" zWxHbaʛ Z4d_jX%x̙r2ء׎m)2x0iqyYO;&e߸ݦݳYhna<|qJ*zY:Ŋ4x,]-CAjUjp?mp߽8ƻ]k9+Lc[?~|b:1ܙm٨.T&v1͗h`MU_z4pǞ"@%. 'efc_E m\IfL!GzisOs;vBv}5Gǔ[SѰu_^O9fBN7snL-1[ +C7ǴLGM&# 'Mqՙt.Mn/y0ѥdI-RR9HJ<_w!pz8fK7]ŋdµ/ca*WH#K \k]1Q{lz;n"].뢱&B(9eHMI-}CBKJ} +V,r_-jpO%OATGih +o<,.P-m#)bm-0Dtޔl@j/BK(RCz|,O UTxILC\f@IG:{>FzK;g~怪8TD ]3 ]BܲD*z9 Va1kI5:+1hɪE)BdPȏPq\ +f~9O^Q]r /agh0EWڽ}3WC [LxU 6ZjChoQ>Mڤg\W& 0U d<9o|hLϔA}ۊf:EjOr xw{@p3 Jؿu_AyODAGoSә#, +B")(R'aG8T7i M쉘ܵ>,kiqE(ڷ21Tn^x2vV^\{[/ >wV +1HY %}(uH׎6ʐ1F@|?fT\mj(A!3BF0h$Z<{m?u8o.w/(3L8` M+>a0DXVI2i mYD>6Z 鳒j2QVjV(A{%uSEH{,Tf(?kf?Ҙz&%BYn˧/zTNlݞT˲Lzd#Xa:vVt"aɆ ݧNy{rXE)77T#fЧͥ5m9'Iu^5~a.Xl7OFu^=)jAi?\zJ_w ڞm—VRMq&K/PÎC") kmc\,DNs&8ڢ e.zCC:PƐw=6MB/7$.aUfriV]<D\C5%u,U jקy&nW"Ӈ\;xb@ "/}b׶i?rup@ӂ@4@,,DuCn6fj \-] +ݢBR +3ϐ&'3SjXm&t( 1pvJ.b^D`3xR~"m}}vDKZQD nF/ȿhc F^PH{C9kW]sR`۠[-3%WTS~B.3qw5W5Xq +g5aDTPxNYń?Hw~s<{4N [}N!t 9]Mde}M`l3&*ȁDѵkѷ2i>cAW@k_a*P_.z;%:T(@ Fs=Y% +endstream +endobj +340 0 obj +[337 0 R 338 0 R] +endobj +341 0 obj +<< +/F9 34 0 R +/F5 22 0 R +/F10 39 0 R +/F2 14 0 R +/F21 279 0 R +/F7 28 0 R +/F19 239 0 R +/F13 50 0 R +/F12 46 0 R +/F11 42 0 R +/F3 18 0 R +/F14 81 0 R +/F15 118 0 R +/F6 25 0 R +>> +endobj +329 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 341 0 R +>> +endobj +344 0 obj +[342 0 R /XYZ null 765.9246077 null] +endobj +345 0 obj +[342 0 R /XYZ null 687.1271417 null] +endobj +346 0 obj +[342 0 R /XYZ null 454.3591373 null] +endobj +347 0 obj +[342 0 R /XYZ null 395.1034713 null] +endobj +348 0 obj +[342 0 R /XYZ null 377.3494161 null] +endobj +349 0 obj +<< +/Filter[/FlateDecode] +/Length 2170 +>> +stream +xZKsW 7cރڃvmUYrr ֲrowĀ)'Uļ_L#JPD>>Gh_?ͷ?(E}$DSA[ɿn8T"BEn܀&"I{HIWg@)B7GIJ`I-[Iy42av4 d["`zdTS"e~Da.q!/-g~@d^@?ffugD,uYvnx༆0C uVGJWҘI|ρ$Io dW]{ń/4PqSuM-SEa$K-&/z2*}5ҋ[62.]{^M 0p9Xq)\(T`S9R\ٱ ?D')TrB `J?.%m{Urڷ(C9J$vUےʊ޾-6^g aUbiTR|i帝#Ö:v E)0>ؠɔ΋2uo̝ +lgMja.ݗ+P<{S0zAC(Y8VE¬5p0])Մx(YN9]$ +bR!W4Ffh| P?Ǣ:(v9q|`{Iq\=ixآnt"HQSB LLabGW $@tr6 +Ca4-[.o1 9 a4˃(ɻZ.a[Zn0f)A|7M{yXv6U9f*o>@r"J疈Irf2@M+!# DNQd@D[g + Pu^%i06N2(T cRJ,B5b3?Mbn3vbsƩ(9#h9l2\GAh6ϻ>C$G3%$6rPi#ϗkV@d24:`DFI'. j9gZ8{S-~bPqGd!"Nq8vK8Wy=LUx|x^9v)B£6+wЕV ;FMfSt)EzS%消(8rȻ1#&$F{|k_Io6#i_H;P%Qp=d +7AMIy/b$Yp0PIJT4d1ÞPȈїYyޕh^;RDRX:n#|nAC7"P^^঄z9xnO|w*SZƻp+m Ƚ VHl2R6w#\ $MpڇLXŀ{0_1f+|K> +endobj +343 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 350 0 R +>> +endobj +353 0 obj +[351 0 R /XYZ null 765.9246077 null] +endobj +354 0 obj +[351 0 R /XYZ null 741.0180075 null] +endobj +355 0 obj +[351 0 R /XYZ null 648.2773298 null] +endobj +356 0 obj +[351 0 R /XYZ null 579.1395475 null] +endobj +357 0 obj +<< +/Rect[259.759 427.491 271.722 435.911] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.39) +>> +endobj +358 0 obj +[351 0 R /XYZ null 307.5966305 null] +endobj +359 0 obj +<< +/Filter[/FlateDecode] +/Length 2888 +>> +stream +xZ[۶~﯐DM-dNةNf:rL$Q!)ۛ_sEH+t:}I;h4 ~(m}5~uٷffQ|vu;ShSήDA|AL&Mj 䮨'_e͕]KN(RصM[W|t06ߔ|>-6nDS.ou-nպxz6՜- 6ܺ<\9Inwse< AB>V$38r2ð +OƥN^5WQ׸h*R&Gє9RIRmY7- + E\xG>K&p=Q6;MC L )'(I3F|W*iX, 7ѝ1~ +LF,ճEJQ1a)&1: {f$J-ُɘ eD>|%(Vj8Ks!A7~SnHdWWu.[˽*ߺkP d-IICx~WMSf0.2J лɉAh׻L\wn} d)r013w`-PfTjBaM O Ȍ*x7B 1c)H؉SDh2B/gw;~H@ ,{toM0~7m $^Ο˹qU u`( j2`~jKee[NXTJcƶ?Es-i2.o +G$34NqQ2մIP 5h=^pj(iAip.d줦KY6c,ccҫ iGsG04l獵GB~,f4#\r"-S$6$IԁZ0M =1O5q`?JقQ¨ H Ϣ}|VO1lE4dFD/(3Бf!C >x:8sr'zmw=ss#b ±X +6&(VAX>%.G"~#(:El ["R` +LI92/hq1 +B@5w'xqL!Q` PcRԘt`R 9;>hy4Wё|e"3eCk";=)=ɀl!^BZ4!u$\Giu[ꈵ|@{vI$3@4OdeL3p45ou^C.@} +>4ol*%2ot~QZb=%b|B_*r=(v:pxBS, rL`TKnlh 4 hi* =2l?>MXSrPA2rJ}l'wߵ+-sfg͡ۼ6:),W1Ʈ!,GO QذA;wcEխ{n*7܊Ypx`'Sfh%O!HClxȺٺHWtꣵu/>fm l*XUm\T eD^Oxj` ȌeǢW,WތYRvj /:4ş\'%"UG<|#/f H!0ðA $BC-"tCI]Yhbz9cSJr J^E'EL.J[=Mq"'m)RټN! @g^Νm>L]emֈdQ XCkN񦆰˜im`4;8hP J/m]!lEb7a~nG DJ1DM)FR2 خnxn+^6Ujo_o)-acwrXPxk~_\1=#'񹙄L@>scp]&_7UCo)̷]\k!Gc.뼻'uKqI>/z.7@Q+L^8%F׆*7Ţ.cz]\y+PBqJ`#`uׂYoɲ-LO^.Lv_{ހ6w ).2[FTuDA3vVIme(8f05#7վORuf/Wlmxq ++=]&?, cm,I=[zX[-Zu||_00_#ſpux +g\銰4pNJp&wkZunM##j) ü])J.N1z$tNHO9p wBYGa΁G|L遁?x-FWDw78@Yz`)}T(}Z֕b*@qfř=FHxo?m`vUȧSq56?x~7%ĭ6ߑ!I3s/VvvMd2$zūSzI4F' :iڻv]NdZX\Hs{ W<,YlWWQ)_81u؆^UY. !/M$ (~9R])bb +~DsĶi} R% T<+;:*?d +endstream +endobj +360 0 obj +[357 0 R] +endobj +361 0 obj +<< +/F9 34 0 R +/F5 22 0 R +/F7 28 0 R +/F6 25 0 R +/F10 39 0 R +/F12 46 0 R +/F11 42 0 R +/F16 159 0 R +/F13 50 0 R +/F15 118 0 R +/F2 14 0 R +/F14 81 0 R +>> +endobj +352 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 361 0 R +>> +endobj +364 0 obj +[362 0 R /XYZ null 765.9246077 null] +endobj +365 0 obj +[362 0 R /XYZ null 654.848133 null] +endobj +366 0 obj +[362 0 R /XYZ null 634.6323164 null] +endobj +367 0 obj +<< +/Rect[149.788 581.612 156.769 590.033] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(figure.2) +>> +endobj +368 0 obj +[362 0 R /XYZ null 544.2904344 null] +endobj +369 0 obj +[362 0 R /XYZ null 435.923571 null] +endobj +370 0 obj +<< +/Rect[349.678 383.369 356.659 391.789] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(figure.2) +>> +endobj +371 0 obj +[362 0 R /XYZ null 386.4507688 null] +endobj +372 0 obj +[362 0 R /XYZ null 275.8724261 null] +endobj +373 0 obj +<< +/Filter[/FlateDecode] +/Length 2806 +>> +stream +xZ[s۸~PRj6Wtv&nfKWڢm)Q%);98 dGn6@\s&! ǟ֟&N}' K^L"".&3#Xd_LH+|PAF/몜(bӂF6WiCUFM0lMU 独If%"]ghUY,j(+zdkz7b>}>W,Q +9K4m g߾vk6DZr>}1Ija&?;N®'lkE$M|:vE]R5)BD|~!B4G1[ڬq+W2[8"ԼXTPehKmDMZ@a&CQkk,3͢J %u;=+ݬ4/iUHrأuMm$Bq=o,4FF1ZfF$$0M0C vSe:)u Oo䇻q3)'dEI =,2_(?D__2?Z?)'d ޸PI*8AkL|D5 ^,Inq3b6׈rf6nG^y?b/bgc=F=FWb%6X#a*[~ +ԎsC8CyBRn^ɪ3`g Z0ƒ>^)O.;j"ZpXb|X$2H.$1ی}P׉|<$u +c"ϫɰ&'\Bh[켴f`OV5-z\ڲV M|(iL7i] +fp^3n2j]S7yu>.ùB.d6WjjGj˂? *cP;psWmycSn${rHjW'*'ETV0}rY?,Ӈo-% Z$qD(:v˚;l$UC!;dz +NԬ8:ēk|hꛩ֠;φ| :K{;O)l\X_n6E혪}.n%FFTfB$o3G%3\o#‘rl;WR.UAqJh^6d3H|-B.lOM3l:8Xzl T'ZtT HA5] +%՟ε%RaPzs'ܛ y12bi@]N#]Ns#l4d"!F#F:_l̵߃.@ԩ^~P|6!UZ|,,ކ[@Eh⤿XEv,P=S^m:͜$ asr*㗣?~UDcmI4:b/J(~̍ ƂTNp +ަ|=Ӏ|2+]ZKX' {qb¸xj/:Ob,@[[@»)/va bfWv/!CP֦C,+y[f2Sdof!Q@A +endstream +endobj +374 0 obj +[367 0 R 370 0 R] +endobj +375 0 obj +<< +/F5 22 0 R +/F10 39 0 R +/F9 34 0 R +/F3 18 0 R +/F12 46 0 R +/F7 28 0 R +/F11 42 0 R +/F14 81 0 R +/F13 50 0 R +/F2 14 0 R +/F19 239 0 R +>> +endobj +363 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 375 0 R +>> +endobj +378 0 obj +[376 0 R /XYZ null 765.9246077 null] +endobj +379 0 obj +[376 0 R /XYZ null 723.7991918 null] +endobj +380 0 obj +[376 0 R /XYZ null 606.0132736 null] +endobj +381 0 obj +[376 0 R /XYZ null 510.3774773 null] +endobj +382 0 obj +<< +/Rect[349.207 428.319 361.17 436.74] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.44) +>> +endobj +383 0 obj +<< +/Rect[167.672 379.115 174.653 387.535] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(cite.ParticleFilter) +>> +endobj +384 0 obj +[376 0 R /XYZ null 377.1467763 null] +endobj +385 0 obj +[376 0 R /XYZ null 349.348265 null] +endobj +386 0 obj +[376 0 R /XYZ null 295.0934077 null] +endobj +387 0 obj +<< +/Filter[/FlateDecode] +/Length 2524 +>> +stream +x[K80$1#b>;bVGR'~Hʖ,nIgEWů(%i:l~(j4W jGXGg#9ڌ&?wg~BnJ).OKM6#Z}1,!LsDhwFI H?@)Q&B{q h &n᫫kЁ 6eM^"CLa>F{/M7bvB Gc*qA͆ðDNsD)i1lh4cDH6Dhˆ5z;l)աPzb(>zF#@fDzA4$@C3NJiE\ +I"O +xJ,ew о$430!|gΪvjiE4t4{] W2(rTrSUU_KRO&Ә$_7_grV5t?rQ3nIj[uCw=DiX{AڦZZ~x:PbM2еw)3F|"*l5)Eqӂj:\z`" tyrY"ݸ MŐHbT=<]WPNNaDDy6Ź^z; vm.GeBd'8XCFG:F<: y0E48@U{N,zg*PJAx:t7%L7Q4:yPu?6Zqx)Iz-1>/HsL '|oUYgګ̽Y׮yYggW\Og2yrڛ5;{6=g3:StEퟗY5g[0:~4[lV^5ғj 3z,F+|1󔘂d{|m f5HE"Q}!mUclkCxW9xwhڧhtԸ m0p$ ugs'iqc0'=\f? [IXQnfD$@Р)w1 #bi1z30,e``©!:WKX^ʻ{y*d.dsHLi|Q4ƃmW%8*uSʳ +gTҧ\GiL0JVarK@9lr*`HUR 9 *@!T&\jr5Wx~?"_7>Aذ$ 97d-\fIzadUsd['|#mbbMP6; dżxjU07e ?6qT"a.|vP%:1oJV*nUb;Ҕ~SCXUr7HoߊYfMQ˯+a?/su:uR*pfi;f#<zЙ"n|K© j,.Z:;iR^7ev]ƚ5Ӽz0N_A 3Wwǂ7ok9H Tjlx=n躦ܺjִ>ۈƧ\h"'mv0~pԭ\#r20v@dKwRN̝5ΰ6D[)HTs0oj]>uB%NzO{ghs*~H&:==iM@ 4&1jح<8-GN!;m쪅Pk`0V7gAt>ng ƀ IsCC4r?Mqfm{a tv@AalC_(}CńCٝ۽T?}E哋]͕I.R.mte]|fYHϕs»Ϊ:nMoQ@b|AgsMxSG\[Y jp>,ɬrtLO~ YAVһYu 3MΫUVe˼ɫG1CT(4+Am4J: +endstream +endobj +388 0 obj +[382 0 R 383 0 R] +endobj +389 0 obj +<< +/F19 239 0 R +/F5 22 0 R +/F10 39 0 R +/F7 28 0 R +/F13 50 0 R +/F12 46 0 R +/F11 42 0 R +/F14 81 0 R +/F3 18 0 R +>> +endobj +377 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 389 0 R +>> +endobj +392 0 obj +[390 0 R /XYZ null 765.9246077 null] +endobj +393 0 obj +[390 0 R /XYZ null 741.0180075 null] +endobj +394 0 obj +[390 0 R /XYZ null 687.4273617 null] +endobj +395 0 obj +[390 0 R /XYZ null 599.7561288 null] +endobj +396 0 obj +[390 0 R /XYZ null 527.9214591 null] +endobj +397 0 obj +[390 0 R /XYZ null 496.5461052 null] +endobj +398 0 obj +[390 0 R /XYZ null 406.9861877 null] +endobj +399 0 obj +[390 0 R /XYZ null 365.1845698 null] +endobj +400 0 obj +<< +/Filter[/FlateDecode] +/Length 2702 +>> +stream +xZ[s۸~о$B;LgvK$Ӹ3Y-ItI*}B$EP,M/H;`0]{q4j;:iGW#j4#2`Lxp>4Ȣd5Pɂ?d,I1 5S< lre2.,quxC7WKF!D^ESy<0ʃ_1Ø ΓheFYMMӼEB'r,Ap45~2#_u/Cl \fHsrfv끂WtH*7iLj/llrFt#v ƄTgʴpcWGbs@3Wno|t\f]73v;6Fi`a- +.l%9@ѤgFTETܱu  JyFs3 q6$Hr3<9fe4gmpy!TV2|Z/uԘ6ؖ!|nl ~b|1~kB>At`Njv)C3:0 n͂g@~0%C'[K%v]ۦ0uk@'q}(J. >l)7U@ #KI|M?Gyܵ',W(K ]|!B6=C a)ᴣ ݷqGv|l}i; +m ~R=na.=8yB!:y㸺~X"~TpXƧ"V!sZں˛|*RQ6$lPہJk +h"yn<bFHj``\J `m?#%Z  ؆Ky" 4je5xyw)oiv *۸}#G'gY^l=mfPqܠ䜊&o. F%c1Hd O-1,ifm*M,GyMAJAzLOm0Xӝ5Nz +).Rq7vzGF&m["7kX^Vyqo!mZw2!"z0 \DŽإaDkt18%p=c׌CxL:Z^:NmgDk@غx>j촦gLNC$UeV{ 䏤[YbZl70+D'Kѯ&&"]7$sS cj=/x-Y 55S 6frqޕv"*)ܧkfŏF4 trp<6`QXyƾTF&&e6ϣ*S)y ^ٗ,"Y@'/n2VɡklHsgC;o Ptjiq; m vrmW1r2ɂ{B2WUs6F"%N?$\\!(dU62n|--ꕷ6^,.VaVa27Ye ua]K)qLjzgk:9&fU*௽W"`rYjM{ncF~}ps2_v3Λtݤ}>)QݎWw( +L&YL {4u'*$udR+$1A+L$Y|&p끹xW[gO;@&QO2iK0ژ%ٔeIUE'MBpJX><&^e0V¶.fP@'UIeQL&sML H\')N 8;8Cd>O׋6sgz^})lK˛Tgs6a.K]|hCOPD6 aiD3*[2L *6p}w4,]q#YV-+"uyӜbm`4տJ-$[zvFDdXڅËL|8ׅTk >I=k|Es畑+$Jifտxg5M-&D11 YMiTۦ0OOF;qEߒbm{FURvj@XX1hp\,R) + g7 - +endstream +endobj +401 0 obj +<< +/F3 18 0 R +/F2 14 0 R +/F7 28 0 R +/F5 22 0 R +/F10 39 0 R +/F9 34 0 R +/F14 81 0 R +/F11 42 0 R +/F12 46 0 R +/F13 50 0 R +>> +endobj +391 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 401 0 R +>> +endobj +404 0 obj +[402 0 R /XYZ null 765.9246077 null] +endobj +405 0 obj +[402 0 R /XYZ null 741.0180075 null] +endobj +406 0 obj +[402 0 R /XYZ null 721.1896082 null] +endobj +407 0 obj +[402 0 R /XYZ null 655.651608 null] +endobj +408 0 obj +[402 0 R /XYZ null 603.4704411 null] +endobj +409 0 obj +[402 0 R /XYZ null 550.9391467 null] +endobj +410 0 obj +[402 0 R /XYZ null 490.304375 null] +endobj +411 0 obj +[402 0 R /XYZ null 386.7308768 null] +endobj +412 0 obj +<< +/Rect[260.789 309.34 272.751 317.761] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.58) +>> +endobj +413 0 obj +<< +/Rect[317.105 309.34 324.087 317.761] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(figure.8) +>> +endobj +414 0 obj +[402 0 R /XYZ null 318.5781548 null] +endobj +415 0 obj +[402 0 R /XYZ null 259.6763103 null] +endobj +416 0 obj +<< +/Filter[/FlateDecode] +/Length 2887 +>> +stream +x[[s~`N/NLR7k&}(ȄE +Zv}^pYbIP6ݺ/\YhƓwy/b&GLW|MGD$\>g&3B~ȫrQMgLl\LɖC8du] čʼn8}N6 U47ݽCil-ht@bR +yx wlЃn"Sxۮär}]nEլLm MˋL,ߥ ("4.P/ͶjHU?;~N؋GӃBDc +e`UZ΋20sY6O;5GP6gx'10x[ iZZ7Pٳsix0j,RHz@XTZRE@L1H$I1%b騾l ֭{r74~|#l[]R=,H ,x{Bk}4~Z!&}|᥸wT UB4CtJ|L?p0EiU@vF6\|e0v3? &PCB&xS#-QWHq% +64쐰R<^'Y!CQTu u͇ClXN7tXHܿ.mQ=n$0F~W7%Ra0K߉qhX@u3#ix r:@2ڀ1 +e?kLHpH +*%Z7ƶt=HnA `ƪ7.rH;%H-q L9faZ~@ps ]bUږHТߧ“jjXCUhUUȑVžP5:Ⱥc@a/d]k/|iD(GNjpjW>gAԲ fm/F`-1ܟ:~jM\ 8{%MV09ܰ iY %*`:3UyRI55M7H>M|GԱ6Xk{`*i +c3v&fzC] +P)j25e)CmAgD_">@>hc'!Ծ! ; ȍDF V|DcxDt.ÚD08`SؠB eL}fW&&{Q Tdr70 uC"=j,Q\G*'iqȴAɮی@Dیm& qݱS8OP2rF{;%ܯ9z,ӪqH }U㪦ڵ*U{ zHC^;k'5׫Pr;{oG|e76e䵏-Vmr\B|'DC`L=RG^-&-p'$Mt:3WH|tlem=B*ȮTGȪ:L't] `Cn@z-m;b+ߤ?>Tm@` iSC L$s)A/ʷbu뇶Pbiq 㡙BQ"PʋIu}7 ,1O QCtoFI8 a?G~ ]˸}Y +ԭ9"*XFDש6o4R Ta8X!9rs?$) +cHg'# "h"{RoMzQ# X"zY'(,CbCzfr3q<۔xx{$ ;oa  4ݗY,SjSAvvܻ>=n) cWɻͦ5j_v=12Fp V %/ E8-G镉w[W媬 _B_庨›Uy +Jn?Yw}o\v`[b 5 #9ݻ޸ +K+|(rpn&uG4x7sw##ǫ|À-=KϚz$P7S(‘jdhDgE}l\Uit*v}cq"ib 'TP> +endobj +403 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 418 0 R +>> +endobj +421 0 obj +[419 0 R /XYZ null 765.9246077 null] +endobj +422 0 obj +<< +/Length 2087 +/Filter/FlateDecode +/Name/Im8 +/Type/XObject +/Subtype/Form +/BBox[0 0 2384 3370] +/FormType 1 +/Matrix[1 0 0 1 0 0] +/Resources<< +/ProcSet[/PDF /Text] +/ColorSpace 423 0 R +/ExtGState 424 0 R +/Pattern 425 0 R +/Shading 426 0 R +/Font 427 0 R +>> +>> +stream +xKo^ W(q~1EIN1qyuHE<"ERKJ8Bfv9Ks{ךg~KyXD.N֧![`C֋mOۖ&w[YזRss4LN(t@aK%sE`ڴ8 +n!3:.znyzV{4c58%[{4&hC3}R 8:|88掝NW }>*z!]itqX͒. 1O"sř-KO뮪J6זY9v'pd,Ow{\"BTOdﶫ߼⻳6S/ TI/`QpE\lO>W`!?ɹ `0ZLu[6vlhv  JgW'&2!ב9Q0`ũ+XحGzEoDj*~riXũb-fiޏ8=}ږs=5p|-c[Hը G]0R9ʹ +&v4aO -icHF K҅ЫGM&tOC-acHSpp +!A欋W*耚IV]D; ަ_j)p@U Jc,&nQaQi-M^:pww*VLG{θ 7Ŧx[A3=>^'ȴ HS`̡=z(GLXK.}Z,c4:eH8qXAm~9`IWYGNv/30h_u& +!c<ƌ1:N$1}-purNN[ZI0歐ᠹuf dSO =`Bl) Azl1Iՙ#]?N7/Kw޼"mr˷߼x)<?K#\~xRh+%qIӀ(ԳugV,!1$)1AqxA2?teqn\hcLb8'=x&.w|miޒƆ:^Lnך5~#P(!C~7czz OtoF5S5co +endstream +endobj +423 0 obj +<< +/R12 428 0 R +>> +endobj +424 0 obj +<< +/R9 429 0 R +/R8 430 0 R +>> +endobj +425 0 obj +<< +/R13 431 0 R +>> +endobj +426 0 obj +<< +/R14 432 0 R +>> +endobj +427 0 obj +<< +/R11 433 0 R +>> +endobj +430 0 obj +<< +/Type/ExtGState +/OPM 1 +>> +endobj +429 0 obj +<< +/Type/ExtGState +/SA true +>> +endobj +433 0 obj +<< +/BaseFont/LPFSIM+Verdana +/FontDescriptor 434 0 R +/Type/Font +/FirstChar 32 +/LastChar 120 +/Widths[623 352 0 0 0 0 0 0 0 0 0 0 0 0 0 0 636 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 698 771 0 0 775 0 0 0 0 0 0 748 0 603 0 695 0 0 0 0 0 0 0 0 0 0 0 0 0 0 601 0 521 +0 596 0 0 633 274 0 0 274 0 633 607 0 0 427 521 394 633 0 0 592] +/Encoding 435 0 R +/Subtype/Type1 +>> +endobj +428 0 obj +[/Pattern] +endobj +431 0 obj +<< +/PatternType 2 +/Shading 432 0 R +/Matrix[-68.6756 0 0 -73.2071 256.184 103.833] +>> +endobj +432 0 obj +<< +/ShadingType 2 +/ColorSpace/DeviceCMYK +/Coords[0 0 1 0] +/Function 436 0 R +/Extend[true true] +>> +endobj +436 0 obj +<< +/Functions[437 0 R 438 0 R 439 0 R] +/FunctionType 3 +/Domain[0 1] +/Bounds[0.005618 0.522472] +/Encode[0 1 0 1 0 1] +>> +endobj +437 0 obj +<< +/FunctionType 2 +/Domain[0 1] +/C0[0 0.1 1 0] +/C1[0 0.1 1 0] +/N 1 +>> +endobj +438 0 obj +<< +/FunctionType 2 +/Domain[0 1] +/C0[0 0.1 1 0] +/C1[0.2 0.9765 0.9255 0.0627] +/N 1.23268 +>> +endobj +439 0 obj +<< +/FunctionType 2 +/Domain[0 1] +/C0[0.2 0.9765 0.9255 0.0627] +/C1[0.0196 0.75 0.86 0] +/N 1 +>> +endobj +435 0 obj +<< +/Type/Encoding +/BaseEncoding/WinAnsiEncoding +/Differences[32 /alpha /space] +>> +endobj +434 0 obj +<< +/Type/FontDescriptor +/FontName/LPFSIM+Verdana +/FontBBox[0 -15 875 760] +/Flags 4 +/Ascent 760 +/CapHeight 760 +/Descent -15 +/ItalicAngle 0 +/StemV 131 +/MissingWidth 1000 +/CharSet(/zero/n/c/o/N/C/e/D/P/alpha/r/s/h/R/G/space/t/i/u/l/a/x) +/FontFile3 440 0 R +>> +endobj +440 0 obj +<< +/Subtype/Type1C +/Filter/FlateDecode +/Length 2241 +>> +stream +xUo'P JhBj!$$BH{_k=cֻ;{{x{IL)"IJRՆpAbv;UeF3kCvlCڰaЀlu= iN-oz[ozHA >3K*=1d@#"ȋȳKH'r?Cdryyy 1d҅@~t#mmm.~:]D|&lsn۵my_8v7TuGO1Mw_ܝM3xs)k.EIxEX$^w^_ .$y,@28 #9d }ZvJJj8nt;HFZxFcR] LIk:\w jr0c[2 UE }=GջQh=4YuXVleJ-ŰƗ SC8XxGѴ4G/(߇| +W5Wob]߆+DC^ᔼ7{cZLgᤱ86?ݰ|D.:M15CZ;-{P{ٛy6>H<~g8(H&y R4òe"5 +LW1Pxhf(037jQI$qՠad_77T`eNԉ7l dPQq*ABw Lf1B #Aׄ4.jL=oϻ`\0˱LcW၀a؞{u 3z}"YQfZ'6;guz=VOxӸﭮZ=&m$x#}5h3掟HcCs]ܮO]x>Hi-$ 55d`ٗ +}:co5+5ATWVERt>3eZ#Θ#Nz31b'&Eei +eHT)kN-m8,[Ζ#:" ʩ1p|qטK6A)Z +3j;'Rޔ7MGl̂.o瘻=h'*QiP:AGUqu|txҁL SCp, ءWqE0B>EQ &k.ZI2]Ƹڤ\e`pvmvrBaVa(;8oe;av'7bhUGռ^_zA݃ݑyhꁋ3{>qo:^)ϖ:ygSV't_rE tf| Ppe,iKBQEU!?2==Ҧ4u> -'PuTRZJ߈" VeXF-ݛKE, ]L3oø AE@俜 +endstream +endobj +441 0 obj +[419 0 R /XYZ null 574.9560626 null] +endobj +442 0 obj +[419 0 R /XYZ null 504.7193131 null] +endobj +443 0 obj +[419 0 R /XYZ null 465.297595 null] +endobj +444 0 obj +[419 0 R /XYZ null 444.472947 null] +endobj +445 0 obj +[419 0 R /XYZ null 390.2180897 null] +endobj +446 0 obj +[419 0 R /XYZ null 339.9137196 null] +endobj +447 0 obj +[419 0 R /XYZ null 274.2018262 null] +endobj +448 0 obj +[419 0 R /XYZ null 213.2027438 null] +endobj +449 0 obj +<< +/Filter[/FlateDecode] +/Length 1983 +>> +stream +xYn6}WI%CS;6HIAٕhq^4A`Rpf8琊(4 h1w콈/U&OQ©%)F*JIEtyiF0TPbY]72%\>5:ܞȨ$\n<-b<& +UjD>‡$sh-F\~*͊ō\3QjB%բn@8"R_89LE3_Uٺ̼Z\b!),$aJsYя?gDz +FcGFkIc`)nJD툏C%boȾUr%ڢ 獔bP4Cw̸C D ”֪cwJԣ~|74K (YI(IS2ݎR,*0WGotn$T#YuSN42ŧE]vtrz%;*7GMm9E 39(ڗ<F ; J -NQb2C: P?9o,$n;OJ1 ʣDEoه Y[ơBjC͆*Drnx!upfY*ƀ0(yZ֫˹`rQ5(L^i"͢ +KdhrgTI #@d96[0{f@U5 f)\u$U"6҅o 7ҥ-fU]z9-[^W!lUc."Or 1Jb|6ɃHQԺ&Cˍ߆+٭sU`[qP8@Bk2!v@?4ݙR +H%Äs5c 6E԰  p|` Tj~Խ.`c;dW (1SˁA~m҅d{roXKu( +FmEI`CJanOax/"%DMLzx-r,/(\~.&5bw8*yjo[^~) <⦊6l~LL4dd\ fUW U ,CmbX9QAVN nUh_hgy.:)V2s'a> +endobj +451 0 obj +<< +/Im8 422 0 R +>> +endobj +420 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 450 0 R +/XObject 451 0 R +>> +endobj +454 0 obj +[452 0 R /XYZ null 765.9246077 null] +endobj +455 0 obj +[452 0 R /XYZ null 681.6452421 null] +endobj +456 0 obj +[452 0 R /XYZ null 599.898083 null] +endobj +457 0 obj +[452 0 R /XYZ null 512.0778271 null] +endobj +458 0 obj +[452 0 R /XYZ null 445.943309 null] +endobj +459 0 obj +<< +/Rect[194.41 374.426 206.372 382.847] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.66) +>> +endobj +460 0 obj +<< +/Rect[259.7 374.426 271.662 382.847] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.66) +>> +endobj +461 0 obj +[452 0 R /XYZ null 343.9432865 null] +endobj +462 0 obj +<< +/Rect[225.892 272.426 237.854 280.847] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.66) +>> +endobj +463 0 obj +<< +/Rect[283.315 272.426 295.278 280.847] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.66) +>> +endobj +464 0 obj +[452 0 R /XYZ null 281.9446716 null] +endobj +465 0 obj +<< +/Rect[278.043 244.934 293.493 254.639] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.66) +>> +endobj +466 0 obj +<< +/Rect[355.053 244.934 370.502 254.639] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.66) +>> +endobj +467 0 obj +[452 0 R /XYZ null 208.0167621 null] +endobj +468 0 obj +<< +/Filter[/FlateDecode] +/Length 3081 +>> +stream +x[[s۸~PJFwl6vd&IgL蘱-y%I{@Rl_D +qs8ɇ/ßh/I'O_IJR-&'͈v2jr]2_'yѦ'tB]y0!VOۂX#&)cK#2UՇ5}$;柛DY5iY,?`DNh%Yθ1;CqF,KϳP Y]D.:(3,3D6&U3ulmپ9wXԚP7 􌢀m_QiMtJ剳puΌ$?\jXrf2IΗwse6:r唛-Kf*|/Z^f̿loj@dw2^,WN3EUH }ޙ'ZL BW,+ܻfFe{m7bK"ŞZK"?h,ڃҴ.VRl+U)(9e[N?f}W(\ 6uuQ9M@UoƬFjWM=[Я̩RY,5pNCq?4/Ho˱3zes\ޫ)Hd"ź\4nLfDX05ݎ|0rM??gwuL7Dr28Rk=X>ip)NdsJ8 Fb]zlYs.7A p=6;?G6o1-04Ϻ=,ҙV$X߿YNicb^ _D&u6ȷ pbŔSNY׀#=nnK՝䌓4_M*e ,n_,| lu-q +k04;xRࡂT냱H=@s{LcH+z |NwR#< Ms0C5HZ0it w*g +Z9H!t) +'K%O!wN@{uZe OArglh \)BY$ w@]$[A j亸)JH|͒2Mv}i1G:d +H% f,>e<a;  иxMy'-O O1%Ҽ~i*ImĉupBFCM}b!V#iObܬJ#X4[7&BTy֣fXsViO4Is7)8 G6 gKnm|gBgl+P&vQ; + RvܼAhz&axd84pf_fab¶w'Amˎ=v݉+5&fj +<YMT*m ҋ °kZud7/vR-"/n魕<Δr6yV`=WW-Nÿ Ml*[AE@?F4mY 6hlJGE k!*6'dBbzUY@k [ϱ:׳ ػٲ167|5^a*^~zKǬf&xP6&? .@HSFh)ah=QF Q:=7Kߣh) lcm-n#@0Q aBꞝRCc}iLc,kx.hĪxtUcUWB77pD os 3?~=|>f?3^bB\e~bG=x[!{zJmi; ZnӈbtoyA_屢ҷZM?>~ZxXngn,S<ӟk$%5a͗+t (f|R~5 Gq9KT4&=̳6e=6dʃJb>-nMtI  ;m2*uqvvSLBV)u{x<+bEkq#|kGT4Uޮz $F{WsmySqj8 yR=׌7'gCaیiugX{ABԨ&dv%U-vs}ZXaBT~`m <#:"USВMg- "' 4l},Sc~ŸS^F,/H*jr57|Ό>=M8?b3|'ua"l=v$VzReYA(/'-p>U+!kAiMXe+=Iv{rɚb,(3pM s靌;jfJ-~u_NKn8"ޅ=]XxȌGGF&GB16<}y/*aۂio0DZEnv##|ǔEq3NC2AiJNX]aP[3(;AߪA b[1NQRyd +endstream +endobj +469 0 obj +[459 0 R 460 0 R 462 0 R 463 0 R 465 0 R 466 0 R] +endobj +470 0 obj +<< +/F5 22 0 R +/F10 39 0 R +/F12 46 0 R +/F11 42 0 R +/F7 28 0 R +/F2 14 0 R +/F3 18 0 R +/F19 239 0 R +/F18 165 0 R +/F16 159 0 R +>> +endobj +453 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 470 0 R +>> +endobj +473 0 obj +[471 0 R /XYZ null 765.9246077 null] +endobj +474 0 obj +<< +/Rect[349.263 696.026 355.234 702.521] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(Hfootnote.1) +>> +endobj +475 0 obj +[471 0 R /XYZ null 710.275899 null] +endobj +476 0 obj +[471 0 R /XYZ null 662.9021893 null] +endobj +477 0 obj +[471 0 R /XYZ null 615.7726507 null] +endobj +480 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F25 +/FontDescriptor 479 0 R +/BaseFont/HOUSYG+TeX-cmex7 +/FirstChar 0 +/LastChar 127 +/Widths[539 539 493 493 555 555 555 555 678 678 555 555 401 647 640 640 693 693 847 +847 616 616 678 678 678 678 862 862 862 862 1156 1156 908 908 678 678 739 739 739 +739 924 924 924 924 1415 1415 898 898 1001 1001 770 770 770 770 770 770 1016 1016 +1016 1016 1016 1016 1016 770 1001 1001 1001 1001 708 708 954 1262 555 647 1262 1705 +1262 1705 1262 1705 1200 1077 555 954 954 954 954 954 1631 1446 647 1262 1262 1262 +1262 1262 1077 1446 647 1139 1631 647 1139 1631 555 555 616 616 616 616 770 770 1123 +1123 1123 1123 1185 1185 1185 893 770 770 482 482 482 482 893 893] +>> +endobj +481 0 obj +<< +/Rect[153.109 541.687 165.071 550.108] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.66) +>> +endobj +482 0 obj +[471 0 R /XYZ null 551.2964646 null] +endobj +483 0 obj +[471 0 R /XYZ null 451.656078 null] +endobj +484 0 obj +[471 0 R /XYZ null 388.1525475 null] +endobj +485 0 obj +[471 0 R /XYZ null 326.5635447 null] +endobj +486 0 obj +<< +/Rect[255.005 236.541 266.967 244.962] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.77) +>> +endobj +487 0 obj +[471 0 R /XYZ null 254.4064148 null] +endobj +490 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F26 +/FontDescriptor 489 0 R +/BaseFont/EWACGJ+CMR6 +/FirstChar 33 +/LastChar 196 +/Widths[352 611 1000 611 1000 935 352 481 481 611 935 352 417 352 611 611 611 611 +611 611 611 611 611 611 611 352 352 352 935 579 579 935 896 851 870 916 819 786 942 +896 443 624 929 754 1091 896 935 819 935 883 676 870 896 896 1220 896 896 741 352 +611 352 611 352 352 611 676 546 676 546 384 611 676 352 384 644 352 1000 676 611 +676 644 481 488 481 676 644 870 644 644 546 611 1222 611 611 611 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 754 1000 935 831 806 896 870 935 +870 935 0 0 870 736 704 704 1056 1056 352 384 611 611 611 611 611 896 546 611 870 +935 611 1078 1207 935 352 611] +>> +endobj +491 0 obj +[471 0 R /XYZ null 234.9247835 null] +endobj +494 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F27 +/FontDescriptor 493 0 R +/BaseFont/TFYUVN+CMR8 +/FirstChar 33 +/LastChar 196 +/Widths[295 531 885 531 885 826 295 413 413 531 826 295 354 295 531 531 531 531 531 +531 531 531 531 531 531 295 295 295 826 502 502 826 796 752 767 811 723 693 834 796 +383 545 825 664 973 796 826 723 826 782 590 767 796 796 1091 796 796 649 295 531 +295 531 295 295 531 590 472 590 472 325 531 590 295 325 561 295 885 590 531 590 561 +414 419 413 590 561 767 561 561 472 531 1063 531 531 531 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 664 885 826 737 708 796 767 826 767 826 +0 0 767 620 590 590 885 885 295 325 531 531 531 531 531 796 472 531 767 826 531 959 +1077 826 295 531] +>> +endobj +497 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F28 +/FontDescriptor 496 0 R +/BaseFont/DXCKTL+CMMI8 +/FirstChar 33 +/LastChar 196 +/Widths[661 491 632 882 544 389 692 1063 1063 1063 1063 295 295 531 531 531 531 531 +531 531 531 531 531 531 531 295 295 826 531 826 531 560 796 801 757 872 779 672 828 +873 461 580 896 723 1020 843 806 674 836 800 646 619 719 619 1002 874 616 720 413 +413 413 1063 1063 434 564 455 460 547 493 510 506 612 362 430 553 317 940 645 514 +535 474 479 491 384 615 517 762 598 525 494 350 400 673 531 295 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 643 885 806 737 783 873 823 620 708 +655 0 0 817 682 596 547 470 430 467 533 496 376 612 620 639 522 467 610 544 607 472 +576 632 660 694 295] +>> +endobj +500 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F29 +/FontDescriptor 499 0 R +/BaseFont/PMITJR+CMSY8 +/FirstChar 33 +/LastChar 196 +/Widths[1063 531 531 1063 1063 1063 826 1063 1063 649 649 1063 1063 1063 826 288 +1063 708 708 944 944 0 0 590 590 708 531 767 767 826 826 649 849 695 563 822 561 +758 631 904 585 720 807 731 1265 869 842 743 868 907 643 586 663 656 1055 756 706 +764 708 708 708 708 708 649 649 472 472 472 472 531 531 413 413 295 531 531 649 531 +295 885 796 885 444 708 708 826 826 472 472 472 649 826 826 826 826 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 826 295 826 531 826 531 826 826 +826 826 0 0 826 826 826 1063 531 531 826 826 826 826 826 826 826 826 826 826 826 +826 1063 1063 826 826 1063 826] +>> +endobj +503 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F30 +/FontDescriptor 502 0 R +/BaseFont/ICBYME+TeX-cmex8 +/FirstChar 0 +/LastChar 127 +/Widths[487 487 443 443 502 502 502 502 620 620 502 502 354 590 614 614 635 635 782 +782 561 561 620 620 620 620 797 797 797 797 1110 1110 841 841 620 620 679 679 679 +679 856 856 856 856 1358 1358 862 862 930 930 708 708 708 708 708 708 944 944 944 +944 944 944 944 708 930 930 930 930 649 649 885 1181 502 590 1181 1606 1181 1606 +1181 1606 1122 1003 502 885 885 885 885 885 1535 1358 590 1181 1181 1181 1181 1181 +1003 1358 590 1063 1535 590 1063 1535 502 502 561 561 561 561 708 708 1063 1063 1063 +1063 1122 1122 1122 826 708 708 450 450 450 450 826 826] +>> +endobj +504 0 obj +<< +/Filter[/FlateDecode] +/Length 3607 +>> +stream +x[o#ҟd4Hp@4h\E]{y}Jܵ}g%Ea( +jK3|3f!df>?V~;~qrfLFS6[(h%g_}}Yv'_S2dцΈk'<Wm-1]x,elA؆6zA4BϦ a +cb0 W EOMn43\?6lQ4H6RL,,h5uAk}GjPؒ_W Ok׹On@<^FA֍Z'vyvxA|ov믗w~6p Fxc9` ~ׅL>XPtN`M6NK.K4x7ҚIs/?M`z~_M[MƷwö}u>5 M`M"6NaA|@;öfZ1 [ 4I]@F2C7\1ͽ|W +#\W g4tZ޶iUA#L VqPZ3aLIfpi~V{62Y;r/7jEx.`S~oaPaoᰣ ΃ 3/dU/uvb]]tuQw1 b"D^NN7ƀ^Q^߆6"mC ֓ҫ89Z +o(@ D·z[E & +Ab%+lWbZMGԍiX&6&i8;Il5L4j}a{81U t˼1V%f N= #HjģP-a.QawJk~4C01 sdia*0hjb\LRS XLTt$^`ڞa4Rg=F;g#swps8E +u.hP)VjLg#s$k晨8{#cϻ۳P%M[q ohN +>|I(ߤ(rH5YV̸3wSJpl ZWvjktHR^RWp0h +R[oF;~j|vB*kE + +bf#t퇚- J4Y5hS%6"-$,O]?x~ەWT)KF)tI'9GBB#;?EHte;t3:XCz_Ig po*-ti8ܨ23v]. ϱ%|amR7(~~_1vプ)%X<*@oJnno,?yءp um9۬;_j7n퟽ |&1iwalr͛C76T^?43_0V cĄ. +1?+_̔?{q$ aw$[4~S#5`MM=&FM, =ƱDu;l"Л:@7.bOT8׸mQJĥil޽1<'Do/pQox߳+vĮb0ĔNqG s[ͫC锲:!9P\zbjZ]qwG8?YJpu [K6ۮʑ!,yج9[bF.Cv"A# j~x~X  +I3m{/ǁwwNe/nWM*/yCf/ٕ`$=PQ?ɵ-DŽ۞]+Mts@dBH/ݑP}S` B +FXž\hՍ F֨١.$-BUVu"kki--:.mM_9<neK҄?|!wzg $ +2 J+kyYvb6XS,y0ŊԈܧX#5[p1c$s ʹ7lH1.m_Kl|%u8z?6t@ u|E01U_7WS|rPvW- `THn[q} > +endobj +472 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 506 0 R +>> +endobj +509 0 obj +[507 0 R /XYZ null 765.9246077 null] +endobj +510 0 obj +<< +/Rect[434.122 598.459 446.085 606.879] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.77) +>> +endobj +511 0 obj +[507 0 R /XYZ null 599.5485181 null] +endobj +512 0 obj +[507 0 R /XYZ null 526.8489886 null] +endobj +513 0 obj +<< +/Rect[200.155 358.387 212.117 366.807] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/Dest(equation.36) +>> +endobj +514 0 obj +[507 0 R /XYZ null 340.575362 null] +endobj +515 0 obj +[507 0 R /XYZ null 344.560418 null] +endobj +516 0 obj +<< +/Type/Action +/S/URI +/URI(http://www.dartmouth.edu/~chance/teaching_aids/books_articles/probability_book/Chapter11.pdf\000) +>> +endobj +517 0 obj +<< +/Rect[148.266 301.13 581.672 313.092] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/A 516 0 R +>> +endobj +518 0 obj +[507 0 R /XYZ null 322.1444778 null] +endobj +519 0 obj +<< +/Type/Action +/S/URI +/URI(http://user.uni-frankfurt.de/~muehlich/sci/TalkBucurestiMar2003.pdf\000) +>> +endobj +520 0 obj +<< +/Rect[148.266 281.204 456.784 293.167] +/Type/Annot +/Subtype/Link +/C[0 1 1] +/A 519 0 R +>> +endobj +521 0 obj +<< +/Filter[/FlateDecode] +/Length 2780 +>> +stream +xZ[w۸~`R4;}Ivӓ(1%zIj.IŢ 3|3 BQO{ۿAӗ׳&( NęNC`ixθ%>}w[TyEת?-5y +5/ +j{*Puюb +Ƀ9.?ԁ`5i֘Yc7>Z>d܋đBEVE$I'[yR Uo[eˁ]K䁂"&>{}hq+EuAY3$4xȜ"+kUX;SQ0ӘuY t=dPgQvТI{`&X{/f1_̲#D!cC9ᘏQC9=H,B@"?sfF %/ +F2z LY~c1Lfӓ_< 2T83gZUv'II@+ʰ]vw N&S h=8Ėj^(@=gm9ڧC+qT<{bCC{N`O{' oQߏ¡pȎAFIkѫn&>Qbrj _mvGrQ4Uzh3ၕ){ʜb>2%`8:GawOaݓSCV +ͻ'O#SiC!; ؑ'ajHhќ{+&e~4moN/BVzt{\X9s 4h~bg|H_[ O$|"L4/2Hy7mngM٦v7-ˬNz?: Gsgj Bq,fC)ҭD!+;Wcѭj :=M` !4JmS7(mٍxߡQ]E|&JvT9sX`)Agi8s8w8D _5A8qz}J+υz>~U!Uo|إ+A$S==9%>Vz*3G{+O cq0k5 o[qlos"]М)0GEfnn.Ŷ +,J~@TSʄDDPo~$_eR'ǖ\*H} B/cӯ;giYR|iۖ +{AyY7Y)$[ƒ[@gPR~kؔ1̈q(NrmUC'Պ7/J.g}Z)9^BL ;Ǒ e)xb0-}>͐pP:nV~郎ctu_ +z&v;a[OܮZvI—^m<-kefzke?W-MYŷc#{P?Œ>ZC͠ն^3mhɦKp嶬"ָئ<Ulv/'| ήDE6<\ $!t*Z w: +endstream +endobj +522 0 obj +[510 0 R 513 0 R 517 0 R 520 0 R] +endobj +523 0 obj +<< +/F5 22 0 R +/F10 39 0 R +/F12 46 0 R +/F11 42 0 R +/F14 81 0 R +/F18 165 0 R +/F7 28 0 R +/F3 18 0 R +/F9 34 0 R +>> +endobj +508 0 obj +<< +/ProcSet[/PDF /Text /ImageC] +/Font 523 0 R +>> +endobj +10 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-33 -250 945 749] +/FontName/FTCRYB+CMR17 +/ItalicAngle 0 +/StemV 53 +/FontFile 9 0 R +/Flags 4 +>> +endobj +9 0 obj +<< +/Filter[/FlateDecode] +/Length1 1010 +/Length2 4042 +/Length3 533 +/Length 4735 +>> +stream +xy< ؍,we,1`5e 31d_S;IB(Y+ʮȖG,!%yy:s^:uܐs&P54Mpqad DA&Qp@2 +Rr +  xn$@XCW,($0B08 + PX _<=_[37A@p8ƢH3~yû?h-bd_0٧@v&=43&OÐm7)iU[FⰞ@y0DLGBzbQjxWO g뭍àM$4A`f6E$OKW !b; q 89|iQ4O + $ t ,0~d0q]Eq$9k)i}1TI_͢"?eOoׄٞ~Cg&.uC&)۹S M{qm8yw >IpUn~c~513#s3TĂ[ +^+ӝZba܎ 9yn\I3}JIjq[MܸmfgS8-+gKSw/.f*affتeQ1K 1v0)41-7/W #aCt N}>uqLǒƨc@߅D]S(bˑj~*~a>a`Hfwxz}u[ppd8>FӜ I\h_ܫķՇQ2t9"8˷Q꙱-ky=]!6Om;JN!+G V6)Vy2R(hQ%q%]yCI '-.zp }Be!Ky֎wҦsZzO論SA.|;t^Z0KSMX=Yr$M21*P<Y>}&Z^ N3t18 XTtY{tԀȪZd.E|h;Py'}U:^3:74mUnma5272ku"O}qXީm蜻PyZq&.@;cfj.qBg əTLT+g}~Yk ^uwFipmmʼ/O4[7 cw]R1҈ګa4Z?Q8vn4}(G| EC/qc[k[Pȟ+,`bB;A]Tg0J ++Ϳ>7-ٷ³$Q24nվ^Vb:6wҐWFT1b(u}WMD"&IA}D/!6am/u(c^Bv9BlTʈ֍{'2Û<e絣_vGEkxH-Nh#w,_E+|RUgwWX"ڜl7ʃelgf ^ $_!E0D\=O9h>WPd+7cD&ofX=z.d-!W`+ޜl\oO?ݔiI:zޚh)N݌_Aࡰ5O`XʽFO]a1Ta bǼEC{N^1iYqoN(HU 7j!$ t0v8ϴJפY(aiqB=VG|7>V2fD]Dj?Wz4ﯜ=mj7 A%/CY +m2\Lw k˯ς7pw]2z,vLVw5^L- 5P۾W<{󶈠qBt}RI+2xcJ,POFϗD|8.u o([l[$II +)Z2ai4[ʶwɺG_jIL˒r7{v7'^ǟ,-K[Ͷ6_pD дP ޫީ~{'e6lq%OlF\*˵ )JbegI9tl!ٍRg.9<BG),#PT(0{jBhwC1jVjjGyY?+o.=̤X41X˔,Cs։[anbfN+7 + '#(4'h_0ݙYiR2'P/pN@>83'^}76!LTD;̋'YTOzG5| ',r +Cm#+hD x&:|RB՝P,zQ%N3GsL\H54\{]߫x fԌ%0x GMn/6mDr,ymzΈH2y\Q -cSe/ )wg3,ԳrΦ)FҐ{ZlC a^=U P37=͈}6Wf 14wDy^M:&$Z1}6~nՔnfv$E2W`hU(#Q?n7Ϝʦnc4u!%W|3j̝#Y4B"g@Ĝ7(vz[3V2mWpНo۲rgAϸߘTexw?I?r~[Qv5mAN}`TIIUש[ٜ^_~Av +)u+qʞ9UjaM9(g4"M}'NZ#xXYOiGIW'wЌǮ1ї~irHO `UHbR6fǯt|m3𡺵Z Y* ଎-oѿflSIq}gt}<ѶKTZLO"X=%O<1H"C=@ ] +endstream +endobj +13 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-34 -251 988 750] +/FontName/LEMTTC+CMR12 +/ItalicAngle 0 +/StemV 65 +/FontFile 12 0 R +/Flags 4 +>> +endobj +12 0 obj +<< +/Filter[/FlateDecode] +/Length1 1790 +/Length2 10936 +/Length3 533 +/Length 11967 +>> +stream +xUT̶Kp'F'ơqw\;nIוּ3|k֬jjre5f $ޅ `cfEsXō]|6^^6{W ;++225@ dea=dejlP0vA@V@f཭-@g*4cFFfcYLV,=؛<\{ @\m=f@sdE$ .jkhl;:ac;+[spu:@f@'7ʸZX-Y9KZfV.sc[gt_X%}T6wQp'b? )/H&ao +247x̀` qlr,@09!>O6Nb.[<H<[c$NVhGe/= Y`G0Q ,=,$n*HHcζΖwO `a.Q?8! z۞-nƀG!!H`? *@lI!Hx? - C rAA w|AA2!H? / t/?ndjgn idH? m Mt&+dfc !}B|X!d<+!ē_1eB\ llW!/r 7_qnϿ/r !B+?`W!ĕ?d ' r m?i[A_FrXYy '[5uu\~s@fs+ȋ +V Inn(Z畑 OSr&.PlCCloўRhɄj|c z=9bxEJ f0ϯJ_-󃿑l=\uP[<;=];E~&;o(m|@ NBemvS(bhl0E8}Tt=!:mG_]풽~:*4]1 F3<>z%یےD$ڎbSovkr2{&oYaLwt2Xۭmf.#=jỷr K4jiUrEYXK>f<Jsjuyh?J)E?vit|N-v.Ft4F<"DrJ2 Q)}aJY]u~>kU3*s:؈^vդ-zcц`~zuO*AzL(U0cJ\p`@ ʦ\PW~N"cn;$I3q>TJŭTL,Vj +tU'wF4My12Vx^JuϾ{F1WoCT+ZjN?ydaUWz;~ ơH,  rTXO#IO@ "[3e U&KT c" Fgo9mX+5 +t'€|4,%8YNGO9?ǃϷo'B |yٵ|泄H&/*5[Jwq])4kk%{g̭T`p|o\\؈orb v|ֱCt^,z3Ⱦ=ElBaGc`xB ðGJ{|z3fV%C4+]U OO{IąSb^m׈j8 vy:'{WimAt +Cs)!zuc^[#8CYL&P8MK%-{uɴ/j3y?ά +IKs ",Cbtj/oq!S:OWN7T7VM*ϸp&L odÈ8x0F*1^EXͿ&L+4kح])+M1P7_n9A~l9AK 1*5D0Pnm9^WQ}ِ|o.g0;B>#owk,,4 +u ҬƋ2axZ~A +[x+)mȧԌ|GZu:"vkvnJ/WZ1dm?F׮trO{ +JH91Oc =Y8I,2PD!ա8QNqIګvY4Sy%LxVdF*OXl沢ˋl٭fbxH06W< Nb'KOnJ;W;:BkŖ`srѱ%rvkWHL.#U eSG)eԃX6 Ec<`)ϑ[d9-XRAv7nGXz'3f[bNo;&F'tiEs%NW樑Fbddjwa%ʖ1!vg0w +J˟hiR0x}eI6_t/m29iR_Uܗ{C8a)Ťɶx}JC:#󪤷]tb'}ho%w5)8= 2({\i@vzQ1܅K'TYuy|W4ɄW$>G(?ApcQ\${QhYvg*=]3ZQbᇹ>={᧳owVR/',eSπ"ݳY!nKyYg*oc g6xdБtU"9;۩{rec>ZudpRVi.XV`A>{oP:Op T8RP)ɪؽQ|4ԤŤm}62npSPZS3tc©Ux$UC gr:B#i>? VXokW+VqK|4ռ%\8Ž>.8.D_hnlVv-ވX>:/ +A|*R.=|R;%``*cT 39Eԕ60(_Q +b 11`w#{ Q6>6Nbx(9*-$9Xad Yw]cpAw~lkgFŵ/U`LRR'X.T<, +-BqĚcR }B=Mx*'t YϱvaQu%OL{5ah~,uҩuLpPSD}A|{\S0tc&ݡC9= o҆ї}u;udNbk) "yM}]i9Ul"M_tDv116wOjL3E 05 +c$rxEB!|{ln\T#puB`y-:'$3#=ٝ""I/6vBݬ*}]V!Y6p} #G9c)Sr 7tmM.4ֺmu! +;_"йuYxo)Ϯx2wd;-JVG +k-xz<! M+{cg3 =y<~er aiy0lNG aSծ[EQL3bKٹp:VlϞE, -5A~-ףGWP,oszѨ髎\U8?%~˺?:Psw㐷R8KMa1/3*nH!Ůoxb \ۯfS5Jw@T1Lj!F  sxi国z+-M ?bs!=<`ֻ0rdQ.0n*,:0(LDR~ {wks5ެ4 +;H2 Oojy¸ξP_2%z*.&sK;U#0<]Όqjڏ)4WscCܛ^NKsn-~tv\]FMv=[,*fjꨦ.ߝU'6&-w{2XK,8d2[^oc&#ݥv 2M1 7P?vq P*VkQ=0v;JyJIإmǬ1R7{!:8 +*H <ݡzo^8;>ܺDH[M,xD(+C+#O֖ pыnh34e~[CxOyD +|1Setl6]o~5詸2S%J>z#5P۽%.!O ZQeTÇ}hKnޯ7t Ml/)Var5zlX?5T&nr݈O(Ctr^XWCR|QG\i̼3;y$ /!WSmKTfcW9;10'v . & qv|_v,D_Um!T͌]:<3e Q"XRb@/_%d/X1al(G[Vzo5Dъ='lt'd*܌xKaoFz+ɱ͈L\|%$w(;. +~|kEH"q|8] g't/UEߞW$%(c5žL^^M"g 8Q \!P?զᮋ۾ȲZVKc:@(}Odv% e((]Z`=?ՐfE#b⤽u쭺7}S&M,]^Wd``gAiؿHy[_Hoq7A')SMv%IfP)Sǽihy_BXCt) YO48msimKXٜPo@xӦ~g=iۈnrwwXYLp1>(ܣfRS*NzQkx $N:~֪|DT7!)\j5ThM<960|[JQiH?BА5'H9/;Y ! (8z +}`FU5bg;n:wF"P7=aMr6QƁ؝P8sTΞa^;V_#N%IK`{c*VV{2I\75Sn|o{FopG+\?j1)a 67yJ;Ҭ<`r%)H[ۉ5+ؠ|i@bګ F7/*fwc,{TFp68$ywմ)ł@ޢ΀&I!"˔Wi] +bdHS ?NϗY{FTm/cTrcmra 176[0 m?NEL3>Su\;uK' lnƾ'@ůse1+RzgҰY; +˜Otk,gۃ7)T!p$[DU|T2oj=D !IOALӁmvSl= vJZ-3T$|N~R(+G(WRk rDfRZp]BF)Xvkn͢5YzUWNح#QY6Fx%+ Y|c6Wu-O\ 7@c>][*[nͯuDWF#RGXڢԑ_O5"Z#?dyKjG-` cEqy|c-G /]L^!]/5$ tR\a,=$64b.P VA?dwc|Sk숻3J`ZiKޭ Koh8AZP)Uɷ` +3kDD DxoU tZǶrh ޶<;bh}|0f]TaHKآ?DIheZӔaLuj˩݁A+8vy@Qϩܺ'c޹0|uKV]jиRXy4tvPO CQ!T_uں [n$cuGA^5wOEHP6>TFE,98bJ.lX>} +)^0ѻFZ}#1X8[j7`ta@lՆxr+/+_8ܵk՗-C\ !Oo"3?]оT{6PC3#vgyZ SS 6tnӯ}lGq:KqZCih˪,L՛YXhS׆Z|O49nl̢PpxZ#¢0 Y" dJ +";őټF`{[*aJ}ѾALi ;*o|/A~?\ԙvX-=5h_N&ʬgG| ]F,AKQE)O+y—Du] ^(Sj3U{(z~,sO8̧/k~wX# +w65_դ"˩ΠUcƴ~bFxjԤzo#4]K"VMc,^d.nr Znn^V6}T!Drscs&f25튞/\8^B7I`$-TO=,]6ֵkuS(Hס/N1N$m@Mfʰ;xAsq{;zEGvaKÛV켯ш<ٖN湭j ˫RjYױ7&bi>ΕW| Vo^b\+ + %~6.y3[+(~3cQ%#nq8۹*зm]kTp׿\J CU_5DO6 e\٩1y +9G)sI,[v zk([KlF,XB5b뙡 ;ძ=}NzBl +n`)R:qBئO +\%*9 +]̋DWB;c7t3xz0cs>@gUgjmu"X:|E;>["9:lU(H5`S}+* )Q"g׌3וeqa|k7kp:BxLf`9/#Rd E+}t1!玻dwKޙv! +d.Ff +*_uɃq/k'qK=n8?d7>̮1^ss4X_XI|ͨ&$E#:X~5*>](Sv"ϥH%@c' 2 +endstream +endobj +17 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-53 -251 1139 750] +/FontName/RAYQXP+CMBX12 +/ItalicAngle 0 +/StemV 109 +/FontFile 16 0 R +/Flags 4 +>> +endobj +16 0 obj +<< +/Filter[/FlateDecode] +/Length1 1667 +/Length2 10021 +/Length3 533 +/Length 10983 +>> +stream +xUX\֠S4pp  $8 ܭksN7]?M5sIC"adurpr%u98H44R@S)(H[8\܂l +:4m oV@+nuh1̀V6HlI;Z:pw# @d--@K$Nn@ukW<7uw; +Pv:w_rN<\`WM hj2Xڻ-[l K2{KTOݿf ^W/;+;;8#PL]]ML<_ +::ktrEk?9l<`l6(7;hr;]' hl tg%lNA֮?28N\{ 0 xV X` ?la5~#Xk8` ?_'[`+?l6V>L$%|Y|ƤѓE( %|1&Xci3غ2ݠ llP}#ȹ㼏qn cɢBchn'jB|NS1)q\B!Ë֥8VL̩*C7{gF5G5)uXOa ˤc2o}:yBfS}Ӣf#_u .9SO9*=+Y.i6 U8'4جi;w ]"'QSx&4GmtAGm{ >ZvQ|JR7(< Ǣn52 m)k&t0UG԰WABG7UI}9g&&0fm#/s:(K䃪Ө]com V;ċPB1"sJL R,ڽEv__iăsaG}GY^ݕ؊.vx1:Xҟ&y_I4X-)G7.u~Il`9abbt@vtM\}Au&.PNj}ka֙qAScJErs+Nd!AH㸋Hz(O2tC7}9#']Ob\yM+Np!fv ) ]رy"=#3|&UMXߝn u%Ρ¹՞^A.\8GO.)#R]%f`4Gr-;'RLHV#|Z풶\,Ϸ=Rj#^YX1R_>r\k-n4ryG* dJ +d: n-s!K,\mt/1;⮁PpIB3Nx$cPTY~! ( ^ѫWs#l c,%CR#p}3[Mޖ>3o6)7,V9T/뻓op{=zeH+6Ww%<+lz.6ȳ%6@ƢT!l? +8ˈV v^<1C6 D˕G1&p|}Mk{ FѭWc ʍ3Jlf|y#8+Ql2N$ KOPW_ЦW4u(SoPvB'J FU[Am<6^KjQ0Hrc%lZTܾJp΄i89/_$X|2wfv-Y=SKCI_H@-dۜm}Z4Z|Yi{bUd zT|!u-r# "eMP˟Od˃PG=,Q*S-{'zX`3'2O GzUx/F7yl9i$'9=R/'JTn6{ѡRIEui+i6JVf^R)qe@V=>˰AoAMal>xuI5J›s&g8?_hV&P607HYĪ ͘}p}~ +wn( +,~S'M[F̢uc7.̛/pwz=h;:8?I?AR/}TtZ%ݚvMgTA'B4y7™p)]٦5o?-,$(VKܽ̇|lOL׈@L/if=,O>?Dp)B9}n19b:'+]eXrnýrˎv`0_f*8CОLqݺ@n3%FC5~RWe9(Hꍷ lx%ӽ FqO22!_U +}>-ё[ "FpΈYQIRLfj¶ؾ㎞"6=ez,Mri,|L,ңSEJ:eEPt  Ľ'ak.͠x 7F1STxw(±i$mxYL+fm,Y]ZY8ݭ>pb#Ͼޤ | Y!":%AH+d_4V*K,Ӕ +l`(YuYO2#v|> +C,zirE絛a1ۘ'~:RLq^™ϼ ޘu^^N ǡWe59)xQ5IlO>oM |ܼBZF\/}8u|+5h.#+[:b$չ͍GS8ut{v2T}^- nyaׅ3ϡ(ؙ/HRb< ٢qIO{.N5\ϓKL0C0H*oЉ0Tr:r[}nd(BR2Re1g A):hHs)3j̽{E} +8rP! pA90C0H/ ((J/G]kΰI!BP!wp~ +Im|HuF-7TF$ CW?uﾨED#51g7bdyfWWD+$y?gi. +NUFnyTcJ"YPhbR>;'r~3JrJT t7tc]3_YoDe5wZ@ _l $M%'JCZIeX>IFn~ײE{ZIj'}9M|N%䎋X>z!A]@JUwgSz TL?*%-C1@9Wv*I\aWAOGKn W𷃙%Йcݍ_$$8!{M#dzÛ2I +#@RBe^exTLG4dvJ!/ \/&%o40gBA~WF\%M ĥ_g!]6I*afMy'ڭrcz]6(N:h +#4ΪYʥ-'{-rʀ8!ŚRf9HЊ;l$V 'HPh3o"Lyx5uQ2L}al{$}uO[4bOjr*b\;"WcbB~L^|o+P%'hִg-}4VW8I0IN-{J RP?I68z[[MmwvI XgĩYj L[2Y|ACzwe7 `YktYv"1zx*uJf&)4Dȉ zhBa^\$>[6T3D~x/a`w,(~hj/FkTU!fF0gDg]B_&C)6aFMV~F1 FѝؖGuSt}5vwKk + \/Nۅ*"-Ch Bըo o(V/~آ.Yze1dV9`Fz69s >64wDWzvr?ºY޾!(QruZs -sS=b=8~U>'u|+#x#9FC?W<{p8^2c =0-]mR;`#,OW2E`PIJDp=ැ0 jm+":w_ X'F;DwVP9s)(<5EֱoF}$[ebg{spFNFBK +o7F2Xݥ[@K9t4i˦; d-}.@b]%󰚆?s|L4D%~zn4/Q?_Q5-+O"*gh<"=͚Cg cP_^Z{-@OQIsӛU@! H  ~`f(ARxl +# +g?B 6/l`$gֲGoٶm춖H2cXapn2V>Ļ}}[pKq3j_fI]Z#|Ǯ] +N+)t4ى^*~Ӱ\:ayu5u@`!l3LȲyfe[Z*B_l ޟ`(_K(Dl) bWրeks?#9NA U 0d?\c,^[Y?kvPkHtrǰm ?~fEHc\+u;ؙtp*GN[yzouؽ$BމL{LhxxBo %R#㕠8T8XB/gPt ()Ldg{\toQhs +Db&w훪Mt@T'"zzNBhk4e57=$+7 7xQ&:ߋԶ:X&EJ)vt+v4q_TRHN6Aī +J_oymCּh>>bia;bk$ sKL\YV +ᅱqFp5~X}M8LAֈ⊽-hۊɣ;6D%A@yĥ1NIDR,59Bu8)sikaU~18Aoka[W4a r¦ jkrb̖mPw\#{d㓮 ji +X"$+/fw$91*v^[ +nCݡ'\ޟٳ]^d)@-ӿƧQ5;`řpH!= |I2LKp9SB%%Oxn}.'C;^+ؒGC𻥴9J^6.Nin +SKqWDڴ̹ vL~mHM` #Q Ud0ֆn,L+"m6 +I`A`!&c=!P:inCO2pM4>c5|F͝N 154$ϲɽ,hžύt94suR@ )fr d_[_)Jb:]4fn&U&Qʪ_4iJ ~{͊sxJ;Nj׼O@`ȕTH5!+)Bғ;x$CX\O%NxTflyjY@IƘg-4)PTA+H缔Ugچi:"|C{9ؘW\ty786u%ہ tC34b&(2؀6Vem w=8>?^4Wϙ:A*{_`wRtC|җR0>w5kDRJ[ Я'[ߣyx5{L8~&:CYDS==KE Z)@y؈ HݾۥghNØ̟m)(vfl)w+Yz% +PE-st#8)T~b<:Yva%- d.:wrMwȒ#.(^=E+F)ݖ(q;= Zt~#*FgbT<CyeVU-Cu!6!'eCi {xZzj%&Ȣ (<…3,-۠(>-DpS>AnN(e@ȍ Ӭ;*|Q!EE1Oa[uI4~ENN)D!4Ք #7$ka}:0Q:1: hD.08CE^\^RU,ob= +ӗmյ^ 粖G ,`ͯU~âA79>[ +C+iԌfQEjp&MrY`Z,i`|}r1Y`0$I! aCm%E ~ġ(y6AZm 4Z*KfI6k::nϮ?5AGt [wfq%ācNyr%SBYkZێ֧ sܲ:xg^иgkoSi桂?•kDY[2SX]l? @Ecaӷ%&AC Ve +i ̙sl,rou`k0%)즺W!A^/Q,i[NOo|dE1D~1G]2N^fc7 6t%~Ow\#1},"Bz!?3&R5xW5^}&왼Ui=,|z911aߔVje9 KY8tKF2D6F$1gLkyB+0:׾Ry1vy73zav,'fp=8J /E +lGi +z_o_[agl=`8(?Dh@H2wD !aƵ뽦wOB@DUغ}׵G_4˵% +"&MWtA0pxw+b{!6E`QaJ07׬=`j +endstream +endobj +21 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-251 -250 1009 969] +/FontName/MQUWXK+CMR10 +/ItalicAngle 0 +/StemV 69 +/FontFile 20 0 R +/Flags 4 +>> +endobj +20 0 obj +<< +/Filter[/FlateDecode] +/Length1 2160 +/Length2 15495 +/Length3 533 +/Length 16693 +>> +stream +xeT^Ͷpk@pwwwww {p{Ͻ'9?=_㙫jך{ڵ@^FXƉ_HF^DXFXɘ_C/dk`njO.D,6|kcsC}|}'3ck"VJNVV\∯hhblD odno`ljnC->ۿFv3b'/S +|; - 1^\JV1omnl휝ellT5;[Q '}+sCS+c|E݌͝ M+nlc%/:5u)mm?0<neL|'L_AAbd712v7v:.e`eħ6r'!6|:%sSBlt&&1 b +&X:bLLt+}?!ζNFVjpmM2wM$rv3Ƙfvf4YW JOOkkcof:g(:95Px[g?j # YGc\[NgP1[{kX8Y?Ac{g?[`'pC[ !@R:Z"P?pC?pC?p7\ dWC]!@v?ȧoܭ41tL?v6w0t62&1#['}CCc&=  h٥T/3/ؙ'ש@_p RV!Q8AlB_ ݿ` +`\BdX+`_?_n4`ϙ*6RBpӳ㟨s75?lbx))Ȑ_ңV,p}XzՑ=7[x 5U~NJO.xsIu'yR}Bd[Mg~ˆGliSK֤VSs +bUxk k#F_m[+5TH$ k^XEY u|bO]Bl!c7o~ gƥMׇ&c\^U9-V̊ͳ)B*-•oW! g (Gˏ(͎.IGڠ]CxxB/ K_E8Q|hX@Ƙ19:r™YҲcjvɅ׉mgu }G; լ+yFZ6?e~g),VS| tŷci7[]'hA\Ѯ-B0#RF}UCtD*AM)>ФES.|̴4 ͲёV0"ՇH "ixgBg]rGzjuϗIP?"Enni~HOoܕʺ*~dϔAֵ"؝|&C K!+kz`3:bEp% Ҏ\!xc$? +S8 ^F"-ieq9Σ_,V80B_ ըPu|"0㾘4;FzԤԯ<31iD!ͷ_]Ŧ\)¥ء}@6_+P0Paq [8]N(IIZ'<_./" +=yS߅' ?tPP9w5DrḊ N'>#ݩ.{ؼV1"TKST; Wv#`*VKV qwj1zaދ݅0rzav&6:^L>HDІV, g;!0ګI&q.8yLV2ivE. ]=8ni@])1h¬ Ƭ6' +[Om5 +QxY:Pd;=ͨjWp G`aeiv)VP&Aʳbi*#2H h<xv댚 PApf})>r?g +_T=f<<(Vjab@8/,GYIs+5>_oej&,KV(Z4>;N@XfVhI tgDw/\FdչaxQ_~ḃqەju!Gu6$5k{Oku -:U41iL-9+M\䲾MG}7X g~B<ϐ _Ffo:X։) +;|eEj 7 +J`%Őo =d+NM!`FʋTzz_8; Cm 7zّޮZ.# -nV~GBP]hUCȰ7eIM姌[NfhG!bg,ml+qyA6Πt!|g`*ܶvHS6|Ev,ug[y91;[\]ewܝH Kr Mg60^+bj#e}]uC TJ-F߲]b:&Ygc)vZQW)'VsDh*rr?? H\!؂ǢIGnWVxx9% ϘœiU}7ǯՖyIM`N%Ls(S<xj75T|Ov n8]~t@gg(='7}iM<'g$ k1w܈D:<5PknTS[9fGҝN!!ua"3kF)i͡Z9ۄ*lŹ%a6?8td<u,.Oj' h\Vf&)v\fCՠ٬3P&܂Zi1u]>r$MppҸFN).~8 +`.ŠG )#s?!%kjkMf7%fTR+eImlj@&}ʈĸ͚V HK \s,Dq + + QDj$^֊SmYmtǒW\SkzrÄm|G7ge``*}i۩`@w Zz|$m?ʓ)`a$ƣo(<#q-]5vQv8;ГuZ|k*bX1:uK}(UƸhgV"q.n&tR pe褻7V-Dӱl]7e) +L41",;!YAҾl #/,%_쬝1fe< +JWZ[nKy]$:>R +Rsӳ~}Ζp˝&P.iMW"-y_H<"2b?& E:M~}1u$*Q]BXF)=UfÅz P8hݖze*!{\;Ӯ@W 4 Kv`0\Kmљy-;n'X,Xdht9<#OLw*&ۆ8"e[F5 fbAHKJ05nQg$x㵻eHc.e6hXH/=GK7>:9)p*_)"TWxV%D9D눾uٯј鏓 @X};&j앎1zc+lU[mGgdK shIo\e"KcV!oRI>_8CyDko>mq&"N.Lݝ8S,2Y6nyS62WL)9o0+{ީ0@`֞Tܰj? ^r c*gH5y@*O9YI[1]NbqDS镞9̭ $T5'-ū/ͭRFxOnQiJÜ-J7Ъ'Gdݽ5~9sܻx>sINkw4;WG_XIM(ezիYy[%"[\ [8oqr:-~O\J/'|.ac>Qx4j/K )mLlW[3i?l4݋{7s[[_r.zWG۰.΍|hYpܸ9 !ysuw|):Nu7y`3V;\Ƚ?*bNB",˻ywyQkIa 1[Pq5Y\?ɩz.>TMvz>%2=ڵrl l(ɂ,{{ ++hl$t!qͤ}!αJ ">a.ip*Ɉu*\Bs/w.b>9sQf=m1P{#8kucxHw-ݗ_pP +G×nnᓮ>ccgBƝIESCg\ۿC"&tXbsfoyoF )=q&ѡjwx._'ņMե;9#LJS|P^`xC7>>lfFXaEA(fV&x ZEիdFCHK)㭬1.C(ŋ )^/K-P%g>Bɺ%i-|_2m@ D*lz9I"=* +s0]"BHc`KƵ o}8زhAgPfwL;A,b3L+/Hb~$w焭< H#l/ab`+HХ{,IoQ`CiWNԕFC}X}驀,u\O@Z=/YmNv扱2s/8KW'hAJ{aIUN|CLoOC!΃w:AjNmD-,S ȱ5M[IpD^ܸYG)s3v &Es\98|Ó|N] \TN-r7H6?0~~,d!&ԛ*q3%=*e$|jzq?AX٥p +A=gv[ͯưe|ʌЕ#}Ž`Hu Gv=ΙfX"sp6BS[S%TK /%ܷa6`}&4 [\fZ\0ō? +.u^\nW3q1=aV?3ǚੳKdqjf;c(`pȥ^s1-U ZSRЂ!fQKKEYwꉟݻP.K"R: +G*s$7oj֏6g%dcVCxI:? ٳ!5\OqQ(?ȓ NFT/\#@: #4 +ɯc΢['3F(}_YcdIq=Ac@҄+kI4x*ZrAFguE3 ΒnbĬFe>)L.ȐD~i7v+5J ~]xM6P>I=; %ҏv{q0-ȹmAKd%ZdO *yKPi0HH5ܼ:{Ffa 4/7/ +R\Dž* "zLylfRކ|# y˷x W,#_!]iar.\#e`_{NBr()YJ̙D8,A>rko0Pbyӹ.rs#ʳ׊vtej%J&h|CU wb7dC,eփD|?jZi4բ\~.M/,ݛ7fNțñvtC瓋=}ftG6BE +j|K[ ZCs<6%Ή3/o:^Z92<",ѭ.ɺWە߸DfkO<=apc7ՕajMWL.?LWk !^aGx* ,Xi fg$=7WJt>ą1ۻͶT$7VHj^;SsRYAqSk܍֪Fq$yxmA6ȓ*ĭ1Mq;svE^Ȯ@P"lGlwG(&AsJF@)%, Cj1!(I™$ݔV_ߧ~aIOi|9o;y5?"Oё{dz]>V0 NQ;%[pt5[l~< +1M|0g|w=()K;!~ҫQpfe_s*z";T$U"1'a;*c#r ҏS[X`3=EpY5Z)6Ԛ[}`T^.S'3DLAf +{Tj@7hɢ\d0_'Fh ^$Z+^su\#$ 3A5) +c/9;Z CWLg ŏ9-^N a3E}g=kB@vCW瀷naK0 M >n!vhqzqf%yٴ]-FdXmVɦ +¯2JUN 8ڂol8`h0Nl~f8m"\CGzi޼o]Y]<%YZou] U jؓL&۞ sԙVAc 'TJvsh:8!1m+MʕlNH34,iTN,}EaP;"}'* }<=>A(^ϲ~;ח*?tBD!l:*hخ>V=AI +`5{{>O-dͦ >@V~zkYx2+ɧNNMWk>=H襐҇ *69mN_zFç@ݕ5 Y#S+^ʼ`s$O]|Oo13^﶐94L[.]7ND9Ħ! )lpe>/!|͹QDJdx+NEIbҮak%r<UoA'eaUACF& owAҕ2.MwypcZ"CAiQ+/]8&U39C X1fc.stA Ku2,GV729_ +<^r ;ߛ38#Ekh٩ҖUq[y>$Z*wW*0ܟ6_ L(ayvԆu1gڸ̕כLU?Q(*R!2(F@wy'd-wVo1԰HQ|OxF*nN|51?wXy*(Ğ-WA&fOV_r tl+oJ4?םU#@od;MNaVP֭Jvx$.EvϩZRy̨F8AHǍpOtoFE 9BIhn>#_jb< sAlU.8T&г!]rBU"qkEwa)$TرL#w@$=2tiH5sCqpPBP6 7sKp7ijL,|1^J na*E"2< +?A|XJ+mR ˵},kVel+q!%m&-O1Y Y9:()4S'oovM7|{xq] +fJŴ`RkƆ6_dk")v0')WijϽ,BمZ&H$&UB0PLBDurg΄q]ƕohw~(nb!B~ qdCD4[1j~/ct(Qv]mvVI/ŐN a58sF#=N"4;[ pJ2~2gi}(0.ȧ'AH 9vgv|ݮCH"!bF^>Vi6,= pF/JmNUQ @{ޖew{jdIsɻ|9C+k܋izY)س\l9ḓ@bw3<0-_3n +%TPT=wAHd8r7P*gP9x ƶ /kBloq5&3\IJqؒ~TV)l?8-U/'XHGN=7*4Aq NjCZS!Vf7~h26u#{c-9_Z]$&@OaǷ. TR'}#3 ? bz4Wڷذޏp@y6UCl4{R3t(?Lo|.@UT[uiQJ\zW-3,7 +(KqCrb!6hxb?:88gu xo~:3:jzD72b7MC0_C9-=l+uDyﴦQ\k^1᳼!Aƺﵕw|:EDԨ%%TIJ1%WNU.40SIŞxFNF.׻ekIPwy_pu#}8:K + K G +Ec"Ť)ZV1X|aqR'Tc=tfDhM +P~z+:ԱF4N^h)-z|S=Д,y;6OW^vm%rCѪg WEgT%ƈ ӐV G8[?=_spD% ,Xnn6eJ+-IZDfl{آ̀}&4$vwI n@#cÓ; 1Q~kHjoS}t7#! X8]oe +67GdHzнkӝ1V\^q.DAāaU{d(xеHtŌ8o!; γ@YHm/jϸA'mn;!sJZa:e(+>~QY!qֶhZ5 Xhf7(+s`GfQ}ǰ+-XVHmBs-j41@ZKiW{]MdPrk['&o{WƵ#/8:/T2qdN9~Iݼyzccd(`sX*^']\Kw Lk:U4nRHhNO׃!x۹Xɸ2H wJ%Ib1e 0gkh:_aBIg_kl<}aV{bNTJK%A^1xs` kepmtmfhdPx$Ht|,7yRg{|H0}l 2IcEP 6~0ZsXC0)@ B& NPo X"F"t +d Bl艵~sSQp&>WxEJ1W^n Jk&jD[hn Rh"x(^,؄O_2Q`LjCe^Ќ)-Z}Lxb S]Z +M2kK9P-kwb]uϚƖ[ʖrJ2ȟEDm,mfhxlǫ$_5jL_$}{mʛ0\8Uib4jLz"Зbyp}#e[;QLr +58 +:93c0bv>R9p޹/gKz 2^K$Lk:E).HfvOϢ2N~{qAu0~q¯۸`;V#4U+F+#<@ԐV2HU˗|CUqdFO =%so!E$(Rڵ wgt/? +trA y +wճ~˘ P YdA5'5+7z(xj` N0˯Rӫ:~'?ipjx54_Md:>9bvIө>ͽ/ZԤeFgۚw b~xpO9Dyvd!x%bV@pE \&G>|[E{ nN8A2W-d -`}F%)gO׬cs ;Oz?,= L"-K u[Y=Q2DTgϊp`r"Օ蝸)(7_,dڗ]]nxVO7K~>H }7SFY +ћjQ/'.kMӉPYJgA6>?c;5gMiI;ZXb0u|Kۣy[]ַ$Qp7Dyb2J;F^=aK ?CHr筙)j qBtcI4.qaX#s1C`zv;b~voMi=0to< KWVovR݈Ir:k.MlyGTry&=A iTokj&T=5S, +NAYPSgGr"Pn%1'Mb8uV앏)uh\M "S8"m5_mb\VVڑ eNK|k/c Ec%E?xD@bn8=~1H5r>=G5;?8 Bcdt|b>+b4v*=> +endobj +23 0 obj +<< +/Filter[/FlateDecode] +/Length1 1397 +/Length2 9941 +/Length3 533 +/Length 10807 +>> +stream +xUT֨ + @*pw.!xHNpw}ף}\Ң&WVclmXY견,Vf1$jjqF `eH_^|\|\HHq[;wN_YQkhd~-bbdP5ܙQ++^q.`3++1q 6Hiژ9O @)=dkcMJ_mxwq)g++%#gv#kΰsv;mA`N[N 8[wD + `b`fw(q!N&S#+G?q M^^*Al?0~%#4&~Iz1All\##w׍JOVv^6N^`jeMM!`m c/pZ[pv`?!.umA qf(x@7 (X@?ך!Ы$gtV`?{ݣ?}2CZ&!VU `fᫍ_:5U/| _5᫆_aj8:V᫕_j^W+?'+;_\^.^k ,+daaa'jqz=æ# MTpYp h^&ai= 5ͯ!ϩ_Big"S&~}$e:t'mJ–.kzЛh0r, EȰ>̏2KaXgzߍ + _wo?b]hVx鹃7|dKهU'8K%>* qGg*7Ov, ̺Re:v݆^db/mZYyo`$3o"UVuϩ XwO ^7kIaOdQ}9Pxary7a{:~(!xJ[{zS9"SWzNM"og_=I?CLFA篏 kbOJ[‰:]_TKGf4&хw=Z(5_FQ' oorL[UuÄ-wuҮ4>4M͉_z>P4I>Cx3KaS"M:YNbџmXtQx"7}l3 k u3k$?8!e:h?$3!kg2G?[Tp%_K.?u$V,ŜC=x"n/}bZ[@\ }v.׵a0|z##%O5h0G0BCf/ﮪ#\<E0J:eihv]Vyg;H(o7דNJR,~?eܙXRTtw;(0 H&\VL~S~n9E|A߰ʐier97Es/1}"Ӹlca~'EQRb:eeZML7S286</es\!4 fhF@sg P՗qm oZ1M☻O\Urf,{갉xP\懑c4G9L1RL +D-B(P[T)9?i2a2|ٶ0- /FНksW52Dڬemd.$$iCC:tJ4[ś#M*S8%]癒f7z7-OxE=(nQ21*Cc~%D7cAM]q?7OkԢM.f3&#}R_Gaa)c~P֫=:9 +(r7]0 LmԲDj#ǝ-t&Wm'vߪ(5eBok+ڥdCn,P`"J>p>ʩtXO>EpQBPArZ#󅖇ns1=lCwlx)"*y)s7]ﾯ<&}}6`0Jmr y8[W t7lH^P$}OZ*)J_=8qC=8Ӧ`F=xE? ,Oh3`{(,\`x9z@>S|Tfȋ w׾6.+,6>AGV&cf;+َ0[l'^\_Qf׌;Uiҍ~KD_ێGu*xSw[ kg8ͦ +'{4X^w8˚̽8 l3E-9!:C_bsbckINd\:[#p˅@T[k䝙dx艩^z&DcDD~=J#G4O + ' 4T)!E<F}ǖ=is8=Mˑmd|TH6 bN|[ͣ煭}WLbv86lM'U8K R;t`2a9<\;܃%$NUBy{̕ g9&)ūw{[A_pk@.w :U]R:әҹ&K)5GŏP2Ҭre]Ex;2\7}gU#<;T8:R6Rn=^cXGZ9^s3|H^psO[BҠ::GDuCieK } d?A"gDHµOKN؅*ksSYoS?Obݿb6 珀!TfGIEylNT}@@i&%8W\?yk}FVr!U zLnxB>Wڑ#u,{mt1& 5n[cAFu3OY r!v@K.M還CU~iG/8BKf2/3;2v簊%ʂCITB{o~K=Buo +@;^Ww)1ݹNsq4 +e,@'ƫnA'&NtABYpVw5Ayh 9vy+'~·({g4}cZ:|1O!c*Ϊ>_Dx>x漷#TZgCl^٥A.Xz'_1Ѵ Ņҿ]¹u=_ii_Tvmp64Ao!g<}c2 ./aTCEY\-BXzzDY)%w3َJ#h3-?4of]u8=A13㫝= +(8}N>-j3%j4[$QYs9%`,|`#;ȮOW7.a_)W +4K jڷ*u v\ߢ|k%OGOr[%x_4gI!)з5ip4 K xp:1 œh;7~MBLpo5.\/G+a4có\[O0̓c{X3zSE]"+Os,)mJ+EG5dg)|,:ʆPA|+2f3D%/__/q3/2TTmߏF_aҒ%W2fU~#];hFL{U#Yɋ\=kҌwPm1,zmnJ?&'Xx5aC!>i76nVdY?m` 4SYI#=vЛ'ƚI(GPqjQ</P hDpυμ6y[(dy +0X$ ulj 1rtIMޝWP?OX`)%).JJI)O8 ui?#ZkB} %MKq~JK($ W; PDn >Q~Fe@VEЃ:89B<#I7nXpyj?8>lwx2_Ԙp`'SgYB$KxczEs ƍ*&22Df noGP喴ƃI.d,~hy!ywRz+0t5[{0.*ٲVf,_`Iӛa"ƴ HTcMKTvjbLGP&3_G0=b|Nxór]S`R0B<$xn!~gyaM ʄ~ Jqu'ͨc5}EZQsT^@Oq7m MN +A̱D}I]؋&ΪkK (sPqD21T}Њ|Ś8Pj|uti5_3[d#}pxSfq"<ެPQx7lBaԊ]fSS4`e826Pg+bNLkRywv]iU>|Z~ jB}9HuSŲtwfB9IH50cvky&%&.C"i +DFqDǖj=G7xKC`sIym$8&ucC҃z}gTHH"rC.LZLј uAΆ€ta="f@,Z"i fSViF4Տ.;ɪ.ҩRncg ㏢#œiBO@w?5Mn4=6b+*-Ju{@к OCVŪ.eE:&h`Ia "g%3Wkɸ>e v4j8MWaR7* UKCNnL/L?|\e=| y(%M%1Ł%Sku 8fcm -$Ӳ+Ѥ+e?1σ曻kPV8!I<{M JhO 5;pd퇒A!tFXAQh)[O$#Y$0xrR:8Bv jΙ +ӥFi{/o߆~ImQS1{d}*A!P.ڰDE$<|{96:#=:3㤍9Ȝ__I1 șq0\;{Je/R_ҷ̇/fD]I`z|{˄7!@͊B̛*$ε`61IvKTX/cbؠ dz]ﾺ?Y$ʭ'cVSaj/x~vkvtQ!=s!d0Z<;ާtm7_h\؎#KM$M/>zxyJΧ3IRߘM.yC&K\O +d9 +OaJً-ĭ-+u70`Dͻ>L^3nh$9!paEOa*&ݻQܳr#V|ĉ耀 |uUؔ l]/!vws/*:os["A,&&c_ҷ0!CN?izS~,.]ߨjbO$xc#%T-[q@Rt9YhtL5VTNn<|.Ț6 sÇ~rłK5}kn;(3Z*R¬mb8Z*Y nkE^+S_mJCv`N53cc;hW~ɦJFUkC6bp(Gm +SY7UQ%[,KPlˆwdC.> I&=~2GDl,/8.;{dV3dkL ?RslNUwp\zVo Ug\J!B!s&w1yMMm k ,ɒX>{Bw݌aq"*D `c%N&1iˀ{΋J+]Yb%]n2C2/ {tVOqBFtUs]R0K*S@!̓:) vn|lDoo8#I$p'y=/nB(>vc#9^F J`)T*Z-)\JP=Q]\@1\oWJފ1THQKJkC y2|M +-oȨ̥?Dԑf WjKUsw R,q|>Qw#uwۼ;6c"Bv喣2Kbcj -yGb& O3fcW̡b߬ EGб!cILe/={1œ{vxhK1I\u*z +}w#^USx@OwiXiaQ +ZC9V٬Wм9WY>0Yf=Ezb?t՜uH}? j׶[[>N3`FM^8l5UFHۥd8)?S 0%'%dH Vf\b^9k.n/Wq|y>z_QETi[r ISujz/9EÎPF|>⵲›w|@E_qN6ͮ}J"܀9j1y.о4Mr` W,3ށgR:dξX7G|LN>͸yNX/L۩?sk-J1C=Pޮr:6=)RrdtfP-D(cF ʩ^`n-SkIk%-IncCj yVF$ ʕsO)Uu&$H7Y|+-9?TLY}\vf P\ 8 +}x *GdO[Ү:& +@f/i>nc3j-}GY1FMEp>oN,z28Ni,e4[ʡw=йl߻/9+iYHJHeE"RG4޼&Au֪Y9Vd >7+-|tS*/=,WcG}m= :?㢢({ P{sҒ)]Q߉8p$wuHA{7`@SwD"qPLmf%r"z$`7Iڰ7}ba7ߗ79{bBXD8Md{/%c{7F_ן$j*VKCҩn~ nKDk;sP%Y gPI + 7a\01FĘjFَI EgO39w LEY2GrzԚd6p#((OV4[?,SUUA!.9kP, +d5Q:guR )?PϘYvJ[nu`î:-O假 얏?bojt|GI= ~bȁ&Qe6!<8/:뾃BVXKBA!OGDo\ ┨@ +vbJXGn+r #5J=4KظF$wfn~Bֱ'!Zc1SyGnC]0-ۊEzE%d*s:t6ù\f %!(& &lp%!k ֒DÇEϽQp*_LFNFHH #nx +endstream +endobj +27 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-29 -960 1116 775] +/FontName/HFSMZV+CMSY10 +/ItalicAngle -14.035 +/StemV 85 +/FontFile 26 0 R +/Flags 68 +>> +endobj +26 0 obj +<< +/Filter[/FlateDecode] +/Length1 1269 +/Length2 4078 +/Length3 533 +/Length 4922 +>> +stream +xTi<&س-;E +ܘ3ؕle_"KB{2*"kd?S?o;3^w+9]0aIr0y:X qq}$qX$ P``]o0L +@Օ 8X'=GU덍c4$OUX7I11l.W--N7Oѽ\"5glaĵ^5c(;!Kl'lxm3}!qJmWVzpY8a\}׋ngc؂+֣v8rCS~c{™`ercdOH|ŗ3: 1*SE2} v(ʏK:VqZLne-I_l"(c9F-q#jת {g|WlcD\RWF"DŊUѕ/5%}hϕZw*z]9^wT95_FfhFX +-r%vx=Ed"^+5puRj"mOTqC# *f87?unH2O٨ ؎$yL䡛ȟNVn˕jY&a_=1ݗbP[=K +U94D0!)aBj9:D99QZtLH5ݬ +$Z澥ir8Bw->!}fb0VNa<Ih8[sw;vCu^a׆UB[T$jя/mleNT}ow]6]|: IMeVUUg|Kzy^!3C*M"8{"3lIz))Q_ Ni191WDz$Ta_3v9di7úf/2l]AU6f1}I_ziأR3 "iyDdUśew0ۡ ;&tM<%q:9ZWFĻcm?2&ē>[D_ٲ4l.e]D~Alv>)i[NgoB[KXbJ9?J )wW,T$^ ڿ+lH8DR)aٳ=kqPPg9_: Q%&%>PM 36no<|mmLgr0>zaFu4ХWkДLuzʱ:rj 1] >qvJ HBZ,k]_G1kvw7N n_洎}8]s>lꩠ6D= .xt^`%72tE` K3pT{LC"=թFeljs/oۮwW%Avsdk׃NjWZk摅_9a3r;L;zM.ʼMMD : XW&JG={}qce:7)KYcslIGcy&gQ n<;ȿ(siua~\ٯxTnٙV@ y;ikw?SREvKB) /_t~j.O ux`0Lp-Po?.GLTzܹ cF3K*re +ݕja@_#I^ JźTYo\ Kƶ]Ysop_p9aAeD]ݸl" 6D)MyY7) *I\V v|pwP:3&~a]PԂoAr:eϩM.*N~Y;OcϖZ_UbL1l>Ǿ݈o͛ƭx˾YƏ74aȦ)RH+K\8o(h(bUexc&;^T氜(\4I]'kfjJS_]rw簻jS|,ݘ\jrH⃠.ޮ^׷dQv`t:7w+D_٦߈H7oldTAmZzmyөWY#`YMo#Dyok4T"uB^Wv!M}՗O|<7A x]L5ruޅd=Bֲ=舾y>#n4VxϕTx2M]ʃd!v1w +#_I+Rؤ<8MxEdV sUjjUej\Q +my,SqqݹEuG/2D)L~m|/P%O.$I13Tk@gu\>)Cf>_Zލa&u7*^[rz;|J떎g'd{ 잿D"1|Hz دȶd}8zi@kQl;[q$Y.y÷D#;Эl}N~j;><[3EP߭itf"3WajA˕7} oBq9 + BJ/FVOD6 t̓15UᏡgLf!u&-Que-{ +ħޫe5ߜSJm- ќ2V^D=2y0U;ْRO^ΥF-}N 4 +>xYF@_, +#]2N+v lꐙ.d(% &U|q&?ޕ +sy?N>a6SSTc0hDtx +֨`9r\[X,> +endobj +32 0 obj +<< +/Filter[/FlateDecode] +/Length1 1669 +/Length2 11668 +/Length3 533 +/Length 12656 +>> +stream +xeX֨ ݵ@qww).R+^h.];-Z;Z[\߾v33=IBG"ahutprRJHqSrK"I@Gis0@C@R`yy p "#QJ9:yml R⣔-(U{HKs%b(5+bEF࠴Z)-6@d)rsKW%ÿL)!V /J+52{G|g\ zonO\7G{'70R +߇-'(A@K !,`[RZ\p`SRTRyẂ`-/gC4dԗ2wm6KG+ %'/2 CA txR?A?AArj!HN?)A";A'۟.,AD,t;/,Q!D/B_?]9Tl!D/h8l_p !! !/X+? !V^!_r2wwIDRӛ RbNqS +p?Gj;!m 9F|6'jp KMu|v|rz٧ amʧm7Cbv>tO<؍?*_+>RXM x"j9) %VdNXr['o=_ +]px&{:fUZv\#~a4E7%@.݁IqflX3'{ĽqL&0V?$}I8΢nѮ&$6"#EQ<'2>'?uӛaCkҸ>iH'X |,sS]ީ=9{e|^\ CW?W/"H YwV(FiI{3ϊzы4k؀@&Ir +4t,ڸR0"}BPoh +- doO9/ɟcYV dm'0QS j'ИP2N]Y'ye)oZ K΁j.Eo(qCϛ\9) *,Bu(gIq#,iao&ɂsu?_:N赓~A,.H$Gh~8(Iq<`Pq 40Uv0E4PVP7NrD 4優aa Nt[f&jl|]]“f\uN;?*!6aMf#艫|c$q *}qV`{Uǯsj0Cṙ} +Wmm>=pm;sn'Jo M}0ZXN1㲀 4é/S +Dkv)?C߀;y1tcRK3^CP{%AnwL~ϓ.tsΟ4|X}afTvZ |2=JC>>X2/-Br9j]=.4%ע۫oemne3To+'0"5 פa6m]~QÐ<{2T~2A([WzϹ<^ c.\]B sl1Dk` -@!Qwڎ67A#HcNM|yrg59;3[::7a5 wl1T1z2(bB[)|KDT6+Ъ fm`ׇ\"(ʶ I?,XgvO;k5(h-#U1z +I޾JCN'x]\A>hTUo\`y( \/MX^-̴G= $_9˳'z-$cP 4I5!Iaa ddjȟ|DSXvFL0DT9+צƛ%{ڟQmv~Y'P.bY;mQ@cc~|M&.>)̒cQ]yj9엳m:w(O1ZC4랈,~@Hw2E!bV4#],m𾙑ݸ"cŶ2aV7QPR=+-HpBƫ +yc# XBYckJ"6LaeW_*2oAWEKyRkk&H~<j9f~%JIyL2] +rr|p41Q͟zY`q+9͂0eY` _TS6D$?2#;a6mJv +L߹G04s5J;=n:t*_apΤ.5T0S8EdqC9+*$i$֍%K{=GW@T֐q=ڰFcTV ],Qkڳz0t O\_3FKVv\7rܔ?V.QZZ,Hϼ۩mV~6u>hᖍ;'13GWZ|xD;u*GN;Fwߗ.EMgqY;GߤY%g\}u\k~ڲzFOS?XU6nFC vvf58зKϦ+hݢ|1(Gú!=UzӃybs8d!e t_JAmg J(dnwc 7P +o 9"?MHJUL%u/=㤣X[Bؤ@E +m ]TE$'줪3HP fQJ |1X~IM]-Sh!!}H1~z?eO)~"q'p~ՓW;AQg4&f,!~R׏P?`['A|蔲)w>G_O^_Fu +Gi ;LdDRfq~ &l0[Z0+)KJ ^@y&![~ iTEw䪙r2쪬$bw쇜&u;B^ gYW08( h(c>u?UeKhe9Q*Uc3&C3`;VRw&R`i6r}B=l1EQ,HT8}6X3:-:0!`@$^kg+÷V O0}:@=ƆtmBc)8HL|DKkPw2jv+wŭuֻ*4xw>|t]5>xB eaNLLQjm?^*Ul<5*6d 5뱾iZ[}i=4zx\_ +1^$FiŢ. ew[~&8׳E1 /^riQ#wR57!P—7;c+X7i힏gP0 !E>^\^~o|PmV&m0y82+w#*e,h1‡WHn}f!(=z<ڟ0x}rȻk{rv~bnB)#&N4#$Nj}"C)!D ºxUПf2ihmZ9uXVH.,fHfq0+g"茗/=ZpD?I#k+DƓxɧjٱ_' ?'B[}y#6+#y3[h)xeՠ<s uQ8 +M|dVNm a 5$>exG͘ΣQ/m*uU-eYgَua/?`J6(.)OnKDazJ4ڸY~c%>&jֲCd7UTyʹAgNkYn+( bteyX+&oc(tAK-<d~F +ųܡ(.TTY))ZAڪy-`ۊ=->YDb˧nd.en0k(#Y{WGvsHW&T-mS}Spoa;ya~9|e{ovv Y D<6= "c㴜jQ!%&gǤ3 pD/$b$ΌQuS$1qN~*}O;y+s?d{f0lyJB_B ϣZD,ņ=I!MA@uSηՂVQLtxAxrjfTR9dx`ѵW00$WA/zU;G}<Z=7yUDj*]IZAWtJ^$8H!#w2+w~#&p`CE>.L>LVzhDT!ev$|df|巪W5F2_U LxsX6isiZ3w6,H+Y E2Fx&_`!馢gaW$'f|}C6F$8,HǐP¿c(tSv+Q \FiP*Q>w_}1g,P'l,wh-Fэ[@E4a=^,.4o% w^sP?CJ0ZZS-@TAÚ)p[1VK }L2LAUJeΑ:evK.ًmq&I Wb{8XzRo~eMOͪPA.x9|&M֕!a\,mJND]Ξ;uΉ1x.8<ڄ +z2-'pmnLjP*6(U&'zHV%ԳA}tЭѽ1A#wg|g%q"iXk+fNc| Y!%ݔ݋NSֽ7yyX}'c XN#im,1W4}}y º)Iq':&i@ҹ^2TTE4n*o\T8\\ &a,Tܽ).0f7/iZ,)G[fyi5*8(~&Ƴ/'Pdmn׶ +l<3[(fI?2̾3q,Sn|TI##Q pMJީaz4Tfl'wXݯGX}4::d]d_]@ Xd*G6_(-1:mgE?xڜ\ak*v-zu )/SDE&\` ;vJYY6@0\ҙ6~ + |lT_v>KrSEtgP-+'N`ndO"U}Z8B c~f,% =?pg|NReAٔެRaU0h;ݙ +wt}X6 6Z$BIE2'W0U@FU摯52ɜ*E'A?J7+FrM!L-h*.NwY+xIc@X;_LUi(2C}1,[ɰKaJ<9mO1y$L̍Vtzs)G DXLsfckgGD;9c/R󝄶42Y<d# <-EJ[vB֡kR<<$\ZGOr|w yE|rmys%ѧu1ΟoG(&TexuD9ÿ;ɣ5ILt~2_$v{ >͆0#[ e p] >V456鑈P4.` 褱d1 |H!\o}4Xu5~,s-:f4*IvdDj(^90pIM@N8-,u|qr9lju.Tl'vs-웈wx,0Hֲ2_GԚUˣn=z>rgi F&Ē›f +4XYg4u nnln_PP7W)$_ў8fc~}Scl'JI\ .]ՌOqV]1p&|"sm&̐g n&PQĀ,.[*#4" R{& uo_1&jxלJc"8R1V R1 /&r` IsX+"vذ~HYc/\h)&/{!*Fmg X"#j-*V8W"+P?J,i OWVb3=x(b4stzj45.>`Z0:f}/xYzFeAq*}#ST(GudmIt>5&"KYp@o՗(smH!لq$.#dQ5ʸTntY V4˳l͓}>՘6Hߩ1}²/XP^AUW72ڲ^ e:/ Օ420jrW@_o:wt cc$ev8u(:\j[-Ri7#`$wv +mOoz{90H?u̻?p ӈalhiG($f 9rv݇%AasJnNrCU39fAu0L 1Xp"oS]ҿa[Чn}`JQZ2$-Qi7#N2[ &jfYO0许SUO^DW`ɇ7Slk|~06J+W.q. 4vpA0oԭw')RQ x1ӕ )oǎ/&9F{ +r `E2v9~#?drK!mtP0imE/vM}RgJ'fٕmT +-2B0u +Ngpw +lEgX-܅h]S13Fګ!U̽{!Ю2e62;cJNw"OuWtt8?~U|tdwL4.qܾ${y#)pnØ -7j^isQ#4/$g>|w<2^ߊlJs6?b)Yp&-7b̝DzGÙ2=&ml+OJ}cG @I/0L?wa8WWA1M}VVm5}hzP1X!?-;-)t0ô' ?#>Wl9 iQdu{NQnlpQXle|[52 :p' ;5Q+} Ć%M]8. ZCQY.Au/p^yX-(xӺɋP[+yR{R[!N}pYBѥVIDs/i֯ A[ձ&9MH 0#M٘f([+ y\7fo_L^<0U-"w-f+'j8>lP>~lKPbk$ +ucu\`QK`r8ϝ؝UBDmywGoj765!*? |*Oz8?e=v&MwƒȔ 3D_TZF`ĤE, =P4K~?b_aܜlz΀.]:vL57YmP*HMTR; 1פ}`:IiTn2?7 ,As2K % +endstream +endobj +38 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-32 -250 1048 750] +/FontName/ZPCGYT+CMMI10 +/ItalicAngle -14.04 +/StemV 72 +/FontFile 37 0 R +/Flags 68 +>> +endobj +37 0 obj +<< +/Filter[/FlateDecode] +/Length1 1735 +/Length2 13859 +/Length3 533 +/Length 14867 +>> +stream +xUTM8wwiݝ`Cp~Kd}>k>UUw=5DA^(acHff|fb;X;yNV';+;'@@-J(NP h +(bo P14:1–8@{g33`41c' ?d#'z wWRGN#kK7QqK/.di)oOmzoef#ll9#UG89տ?vԷ436C7s0s)9-ҁFcQSAT +v?*Y;L.ٛ?~|ο[YX9np3k#+c +ck6p4 oik'h`!}TԷ20[c0Z9]b._`fbW 1$j|/?72-?oocMfFfu !XH'>7q~C$G?f?.>eЇpC_pPCVC~O}??jy1Ӿ? 8cg&Grӿ#_#_/Ha~İ0_/a~İ ?|߿N4_Y>|]p ?b -$"bAgaggk>jmf3qq~h/66@W!/)o"DD)fB{D\4)TǞzxuRW[1۹@J: ueV{&֗F D g0K̹VL1}Z1띟T1ɃooޗEfbk@\^Y#%01єer\]!0<̇wf e-Y۪I|a`}~ _I$N*4..eL=08e:giE|]ĿAR>( C=F`8C,蔾3Y ++2scN8X/H\+$p$"$]/>{#p8w *}/ Vhi,I-h }#DLn[)CbHYQdd~*xˢtY.vFR]6мb +040|zm:Ή!-衠TdCeӛ&Gw &RTQ_VW_zTPyKs|g[FJd +!$2=7?"]bO&bGdw/߱1pD,M6\k6v}F]60dW`p)#@X*|!xb Қw1pRTw9Ӓ97mKI"F}EidpW%/3+8rsqB3樕xj5aƔ|jmean49د V4J-nYBw)p q)aXiUByga z/Uvҳϩ%YyUv +kq +0wׂ,.<8>qq ' T+t[2e% x>cyՈiėJ?JZUވye:{V(N0@꬀L@Z)U`hX hEQ{ JqTB|Hڞe,#?|~_ufԜbe{>)$O]wnŰ>#; mHB0YTX좵q~fN $xszdk79+I)t"p +bF<8hQ]U}ZJ~O;. pSL- AIgd`@&_ItUʤ ˗oQ Z陃%٣0KGq^S71ۼ*Ir' _&%Bnf"<; Fyd"cd"WP(Do}3iv׼N|^2ZTkFbc 3cqŔukQO=P^c N-^+9 `f]}ȟ:b Z gEUaizQ?=XNTvEJpiϿiƫO .D/ғ\:*>'6,}Ia?:Ll #,*Z2eү 簍G泱~+9L₱{*]r߾0@W7="B3I.a]jG8cYmv!8/AP<AAg=<3:얿D0hFK$\;)ckU=_~:vXIo/c4YcPYc&1., jc @^Mʅѻ7Yf8BPU:&3ᚹ}iHIʊK2y8nRáկ"#[ YYxl/ m)'+OGw 㳂;"F?Lev` +`.B֎;a guiB;-@rK I@n ݷ`չ M)#)ob[clSn(':V <` F{r/~Jҏ=,sjnGD 6рk"P$iOY!D±=s=CsVD 1 +RwE-k c?6Hf܁I\:O?[-"rxnЂo'G%kP %-qjU@] +S'U[m9 '[]}4ͦf<,uBH|ՇЭʗl6-AYv)+Uˊq7 l^56bH+wƁ-]s`r"[ +8.rw T<2]OnaB12_ߦ\6VrBx'g\1N#ͰFGAg &A)T&B2DkwDZi6/ 0]!h aqMNW`QWD pCG @_z)>i-9.Oy2 )` RB{}~c-?4~43ʶЫH^&ɫjf'IR$o6̕(&2φqpoHKNT\wֵט$&bۣ(` 3dҟ _ڌZWl}6Y:?d}y9^Tî4&Qx5Y=alm3^ +5r}V00; ׭@(5wnsٱn̼`-vmC'Yi[#x}Z9%*Va\_+!ti&Q5;kcyrDh\^5rzrnJSW3W ́Sn {'G(f? @HBe&,%—0ANQ>1>VUPFwazT(~9EmhkFj,YbHA-#u 7O\iܗ;ٰN2k0RCuWR Y{O^okh'e>r1DU/T ;"9T㴾cHIoqyDvR{PĎP?h|K@~J7rXgջ)|$Q/J\ ljK;SY5)Vq]x +%>'(:-_1PS6{@4K/ƬAz%kއE3%V+=w6$1K3uL[zd{)m4#&^En|D) Fg&+G1EP%y`]PB33MCw9vӞku;2.ƲF};ŘsVHUO(j~i) &4 %j5E-q&$5 0Xxv y¢Dy΄3uz-wôzBR @-Kx>:FV퓋I4fg\PF%B[D6OI.i6H9.FcŽɞ#!KԅšY&(TCG ǔpo4TTߎaxJx}*:eg:s)fG]|;H<ץtVyT>QҨdk{]C9oa饪7P&64 _٠iډ&AAFJW+oז Br;;=^5]di㶆W)D!Mm'9$y2_סya釚 z `#ҜjT^]. £f/&y|U$^e]Fyi~Jysvߌҧ]^^Ԉ?MT]8RA3d"6ۢ̒GHJ(]K;}8! 24 j|kZά ^d,T)&`Ϲ+0uwh!$X#T-#[&ZDctе_YBؒރSHwdp.aaZ]P5->v"J:¦Eв)qb3C奐#m;VA%x]X0OO$PR$hOU̅w+GެWw4}x,B@0Fhd<n?TGkq'Nz[sF:9C;lD wVd`v6R^å+'}J7}tjǨDLA;rx9VW'O7jx/ ifR_~Xѥ/<ĺ-A}J&L6T<䵎 +xcot'hs0hx? v3Q(uSc\a~"gxIR`o!dXDyܺ!8.n5z^PkntkIiKGA"wo%\'ASDPB5Q ++~#8}OL9 & ݕ?I:Eިh*%I|M3UkB$ ,'@AI0Ck2L2޴u 3%LEe{HTr)](nu!JUQ|5%k cռ!<0c8wwGK;: +UЎ uj^/j2ͮXj% J- z˦ +H99i"L $0o}s"8ęn4{? Wo3Y4$X6y.c)>bWj(X*pԜsm\EB "ߓ-T/߉>ݲr_~J"l$/b#Cf|ۙ'Qi={UI 21EAhJ,W";H%FXݲ(tt B>YwK>kv4{֩E<Hdj|j-k jaV + ym?҅ AtwWҷBʨSִovuf@b E _ }~P][_U{ıqaQ@=&&<@2!"$R߷K(\?PMƃ!fQĵ->$(!+mOCj1V9v/- $+;8F9VO]sBݍאXr_`MEo|fg`OBL@2Q$F(C*P:4iq&!WNiJo)]amГRNBx8rMLt?ȿ7v1kKp|vɰY<,TW#qeDea벿å*V-45U:??HO*^52pIw ,XKp.BpUm}HwynAROJԥ^FѦDk{:M&ysu7bu=Foje hExkqAĥ6k0-1Έdo-`#0D8/{z>j|0PF&d 3.H92hWӴ<ݎ2 A-C񪢉uB~D$>4柈u4eE1MTmFӷ*ZHwi$R'qݯqW㫙 VK +O+'C\ocAUd9n|.@p!KĹ著JF}B :jf̞ܓgYcH#0Ju0jZZ7hSF\rwvu%}!VMMd;rޮƯrV2U{Y +-Κv[ $)t=cV6^.@y'/v!K7jq-[dOk.Q?K)T16A$s5T *g挳h9ȈoE,١]kGS{u5iG'J~xSBӇ5=]ҿC:K\ 02!琧P!{Ś| +(OhzG;HLBMK*mō}TwC*>ya/̸g=) ֤j!Y&Yb^)QoPbzƺ$}$ p_!Ѧs&?|ZxԸoXάf\wZwxH0Eyl"Ι7m8Al+P@HuSX_r`f-QjY;D^ snsD^;Kɹ)A;Gg;!Rrb]pd*hJDi"~|[͕CazQf{k7y)OQCczZ;663 \X} - 76!/.lH%jڞ +0XOt}%\X89R02399Ŭ RЂ=,]#˜ .G}>,KO A&[4kv n#ήw8* ~/{cNϫI}|ta>'SߑK*|׳Mh~5S3vRd%ϛ8M#^:TjC%21$]O75{UXu6=v̗D*-e K$] Y%|pPPtaV9UfeyR3Q]S3䧦7-䱵19 Nﭟx +&֍R-coyﻙF@iVm90N❣k7BeAp +]5c$#7C*`tـZ +04ֽMCj\f#u0E)WZ&3Q 4&PFfJ{yIYs~,ff~beiCx9),vavԒ{ÌkuњyO!->(&#F)[h]U#c w~ >ZشQc&ZW +^ +SR,w{,e4 +o$)hw0`4DiQ+aCF40[dG|7`B|-+_ҊkO7s9F]Vq,dQj,ѡR䳻~WȣcT/!ϟir ҶWhQFnz"ǿ k%V{DDYX-wTo="WFX{R*!^ZuMG+;p ƖU\4'B$Ah,UBrT,}Y +ͧd}^i]bQ»jnⰴFW}I6 :P/hW.awY=YO _1²S'jƍ:Z0{?j@I΢ڬs789~(J:E`"-d>5`[/>g:eL7P!_")_ksO#$c}DQ/.G6DQϾ <[Fk(x3G5bJRUg$΋gCS_fzM Ԁ\15sY͗xځ.g=7xu.Uj̿1uR9.hfum}.d.fWJhac+ 8g8;mJَhĖs- J06h)YmkY0[hܸh:K2#IRg i$U2irQ@&'dHYRF6C2vwJZfjԱt;^8A[to[yuY0RJLjI}R!`@ݨ+ aDt9Pd#XG7r;KѱZ@-IX|cHwa+PoN3ijvAyh=k zm}&PwU\Ett9dhr 6c:M$ ~rOCoX  J&:]Ie%mW-+8f߼r 4RH|YX] U<ɷ c+V;Ki[qjrIkapiiq$=6E5p9LcJ7OTO" +޷h{hR.3 Yț1O'm1QFE )11ȉ>oKڌYԝA)u^z"ƞh@o IFf^H4n֧t_bp2b,G \ 睯9$/1~u.r^DkmT;.j:dMf?G6RեnHNG@8s{\$ξ6Y(V$'>ǎW9'׷ba;3,$tWia4Q`Q1pܮŽ%kMR %ےވ|X)0dI/wEi@D0&8xcnnPrbcƉP9 ^'AY>Ƴy璤$>%a=>3ݼK,W3X)K7uXCU'|:xlp wd +Jw(=`n7GW+UQ~khv]FcKg2P: +"OAFp i-EGd+7}K+w̯5=tBx`.-? s;lpY7Y#)?W8Oa7Dn{VNcV XP&&+=x,d".қuy]k J䝥LO4i\D aćZz|=XC +kq(m(WaC)tcB"g=>FT*`2ޕzo*>61 ۃOkh!`:ljhՕCό+Σ%z] Aܨ,(̻NPg^AsUVvKZ;₉/(照)axH%hRrCڐ҆Fƭ/z-$bXW9EvL[d\,@begM_sXM{C5+Qݍ!j3Nb?Д] -q֮Ln˲7cE8aN6(-04و#]olT<Dש{yW^[F98k|vRg%LB'CQfۜX^.ab ِ v7*xjp\?Ay5PDW} 5AMIEc eu8F4p%hC}bjtAb 5`$𢃚IpgIuZ9 +~MokRU-WI X! R8o;V_o\tQrL('ohzhrtЍ͡}5rOYNoH#:RVئ+UB;Iy_N@P]/GbjЛX7;ie)©X6e$c5O6MsKiB] +\KӃ10a:$xw~BAI~έл*rڡ55B2FVcfGpT>(+ D(,Iv gݩ7Q6ܐaRlBj2uUɄ}Z]/ +/ +<)ΜԚQ;&<66g& +} 刄R!NBtTWJZa= Qic.Umg!Д1&th qd#3ڸmqomgle_{|.tTXWJs{97_ \u)KB] +5X }.bh"a-~s=sz4C>AYYیcĞǼwV?,aPqX4> +endobj +40 0 obj +<< +/Filter[/FlateDecode] +/Length1 1354 +/Length2 6489 +/Length3 533 +/Length 7347 +>> +stream +xwg8}.Q#}N}^(Qf 5z{х s's/~;י2k={fXtemVE8̝OX]GËtaq P g>x!v@쿲DTt8X[:uP(7 x@݁V;( ˒ +pWdCd\aN^@->HR?NNοʣߢP'Ý]nVBHh@Xzv>|@(B(  j&@[8i +A0g_i\,7_߇-<~@7MAp,*;.*n= -@jH`T'ngMlXÝ0br +!=e +# &#@m67B [F(Q/w?/?௾(A? g? e%D:|(] t](]? J5? yl},V>"@n~T"Bz@TQk+"=@ BQABA-8ϞM26 Mi7' gQ|=$pvxu:CxQh us// +ہ&ӵ3-Q&HDig96MKQ#U͏ɞ-6&-}3Uᛍh֓ +8η86&d^d΁'2~2 i N֓h/34nxaNjMgaqyB[>;`< _{Q˱2۴cG^LUFann[X œc&愞 +WXkm\8 ؠw.&G-dLqQY>5" X}A| k^Iii\]֛`"#Ljx#rTyKv~--Yd1%XMҽ9RyA˕4IPm#qe]8̌W)F|Pwzbs% pf\ܾN> a]1>gz$7Tthw,mΧ?mFR|{)h!R +H~j5Yc8\ք4X6fJ{n|osk~mr/ G'7"qp (T)&ق;肢M~|iĜ9hVpsLhʊwo-P|g vHPMzg0&}P7H98NHzMOftjAHA7OHkãXCl"_߿蛵s}=I`L֩-5&vf>/{ C^_xp^?D/օ1E$/[Cүh745BL*NF!2z/E +wpwΌbN'~Zv}ZnVOYcd}3ic^Zq~ Ҵr +$X)1FI҉$.h6?y|9?~(5-_YzºƼV`zfʱri&3'J¦ςƒe>#6䛮mS' p0@)Auz\lFg2 +vHTv'Xe/9Y@˾Vgzo4Zu"ﺿuk+{|절Ug!5C@n:gֽߒuw=,~ˆQ\ȟRq!,Ҙ 4ҡ0]qjsCOٟn} n."y jHa7=ճW&2~qZ[m"_|?r$y'(D5ШM7|Ic S?-Va̩'В p-wEM*VR*g,50=Zyna\y7ȦZ Gqbʨsé^{7.;5"ua~yJ欦R&׳iЎ̾utJ+JQRٝ)q?ѽJ}r(ѯ=t+6, ^_ҞLk4zw]IX ޗiJ +yj:JLL:jhEJ ٷO:޶ ! N`vLpŘ7C/OC +2R~ҁ@8 +OMd8/ۺή OO_$Q']iz^*tN8q j_oXH[@Wy` :QF]‹7vVʼX} +״ȅNKINx~Qåcnr(c@6,ojp@yשz] Kw߫ *]DP S SDDW +kqlhgAtЁǧ 3]!_6lVOͱ?܍.ĬKy&?઩AZ7$vYe^knum%CᬊS k{O󯋍ɺp%iĺ4? (r)=KҼXƎ&`PjkZD3C^u[lin{uBGN_Z^GE^5O` &:N|/pPGU=O$Y;}kgX,:,W 1J;;"P: ++*-SZgLJ-sYL+81k\,,830|&N ?~(N9*Q Aj!~}mGS-H^1! 0.C +DYL@v]d|ĚeȜG1;+B'ӏw ȋj (( :r8 ^uIPeyBwK\`=<4`Iĩ2 W7Il=%z(I#$6ٮH.p3O4SU]t1@ ůݪ4/Wt;F'^Am_EXΤY{a/M"׌?E8yN>Qw5ɊMaPmYCF.e7]fKjjӭȈrwq[!z9C6,,ܫj%:ܠ d >s ^}Q#8lda غlXT2^}7YIQANئ?~+35h8=~F7rbH >0Ԣ9.JkNVl0֮̅gT(jeO&@gRQl*w"peY~;,ևL꧁_RW/Epޙ'{}0gul PAp@;l'bZF â[>Rn[XWIs&\mt.3>xè"`ϗ-bl'4'KxRYKm:yNŝxa+<*ml̈cBpk[>qKF)rvomW_޾.,b^ASDRݱ_=]w54(\ Dώ4~r$d} PKܟ+'U%a u +zp%c#g Of?udSC-4ONyri͓_ +6xac% LCNR!څJ)иTŔ)EaBg$%4k`o|faئ]hǔz:OM߱Ti55L~y.3l_9l@aV{DQ%u3vKq OeM4v5/mB}h4ㅩ#*CH+s]01ZܻP0V *k[O(ɎZjk%NlJitLӡ$ȗM(gCBnw]xz4Yؚ#G[0 +Vbv&[2M–'jq}MC$qw}ܮsEV2+.[Y?Z{m+ u[r:N;ʒZ}aiݴw++w)1Gʚ=I;Y!|#>M + aLI: k''@c^'s]@o*`)l\6{>  qD׽z + HVC[+@Hz5G%{}| 鿌KDĉHv?̓"] c}늁xm* W6r5R 1C7 +ƭvM|nzPȷHΫhWfj4Rχ·RoV=AV +{Rhfy 3cKX "{.wRm65d]$(!3sg /EO6=f~2!W$aTR p$ dzOsJw9Pb> 堥^i''""4Zo;U|q|cu.F /kBJN(+mŻ'󱓇}R,E}tn'i|~DT +^[={*9 ΅Fj2 7ۺA>H 9tD6"vq͉|mؚ簊αJ? P/c6bߜ\4HhoC @ AvMEy=-`ϼD>wJE䰴2Y]rQ zy uaз57ksdf!*'u>G|(JBVe:q~Po-!d=C1sFK6QIXe{Ԥۨ_>44],>%ӽ_ݼS~݀A1Oџwd[)PS-5-g,r݄|OHI WmpQϋ*9 +ru?ldV*vI82cD}Iu,~ J-V"-&&S+:..( +Ļ=Wʶ6OF8NWL a KrZu@©.ް#Rc/41s&.L[I޿mO:3.4%,b NC{xwo7{fOK KM f"r\2%@rx̎ܥT*in!WjA$! cDaß}t¥NWfjmlMY+1,X^Oo`'au0 +!h{pc5URLwY`}rc9I<" Mͤ& +N#%ck :mTscɸ1t/禥AwVLsJDYՙëp};_̍g˛ ߷>{\ઞ,KWƴqٖ>%J}[9ޞW/0s]pޜ? m8>U`HaHBHNXͫ# #yj<vt|I;^ǒ%/,nvT:[Gm}͝7EkT{ߧHn]Қ㊘Ӥ-{5+GZjoBBÅ AQ&|a_i,!<Bь5,Dٿ$-)c)jh *H1`1Kâ:]6WꦵaOtQO[n+㿱rlbݍj3 H^y 3GʷlɟW cc'hB\h[=Lx^aq\Y*g>md[>SW?Wbe6zYg*\UfH/Ҧv9Vj!%C0[8%<$鞕yJ0B+&`&4N +o*¸}۠jg0!V(LE3-8B»ZPGg k2t a2GuN~RJnW%E bQfML-1p8 +F;ۿ%{xcyP$d\HJτ|o w%'z +endstream +endobj +45 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[0 -250 1171 750] +/FontName/BPRWWM+CMMI7 +/ItalicAngle -14.04 +/StemV 81 +/FontFile 44 0 R +/Flags 68 +>> +endobj +44 0 obj +<< +/Filter[/FlateDecode] +/Length1 1274 +/Length2 8116 +/Length3 533 +/Length 8932 +>> +stream +xUX\ݶ@ܭ +)]Cp \;]7]?]Uso|s̵VQ*}f5FV&V> 7Rhm% @>+//5CB@8_YQ oڼY>M@@ jm Pt:8MXY hEb˕ϰݿ4pJ xi +v͐no|_,ـ+lc:@Lӛ<d2#k58Q + +4UAL,fF֎āu|,!Oϳ碒f9\:,L,,]G3I[)0rp0rCbybx@@W13-Zx ױrs,Wl - +`~=00_)FNpM66JX@G?Gk#G?΢u赡b0KW?"x +&ͫx_ j~6g,6WW]᫰UZ6}}!Uo*7Ճz+뿧ق은2NnvDM3^I]&Hneb ,"TTiV"TB\&Li۔HWYt g>,- |7ЪO &aqk[<|pxFRNw-ڲǾKn/SώP(\_,_LDW@W?{)۲mnlkwm;2o먆md@ C`!,ƭoEpߪ'%Z5؄C?*hԼl<=Qv i#Wp-_a)R0*dr80ܽ9xL>>}ϥJ2,G2`aC< Ä|OK9$[C;tP/0_ tLO _cf~JaNII<7O-S JF)5,ײAjVH=ZF!c嫞`5>QLw̤w Ilw$.k'7U=|V7Yꅜ(j3V6@g4L:}_}!?rN:paBOdA3 Ɨ~YߩY6FLwHU/QwTasw3r-3紙GIca]V.]缳ک=ÉbYZMaVgUU4Pp6Cu[gOb>'(<ɱsdKjX:PÒcTv_$g9۠J3/%ȍ,Vŗ xzH:},ddFQb!އy17 U/IO|3V0Ȕ^ &(ճ4cX<  ;6(17UF,H.]C.2S8Tӫ#Tn#ogKI4TOiqYk=9#;T-aä4zU692rL)DRwRԚ/5^F?jpM5v UB6؝S.z}uY"U5։a=wr]wq,>Ga9=-PgYX:-m>0ose$ sƔGuP5 \.͞ XA8@O¢I;ug͆J#BǁW&[$3v, h(DI7m| +p:>O:7^A|y+&P3`\ZD +">jۺ SGv +Ȩ%&K:~ph/ScqsS =|P!=`^ 1@;Uߺ}ɀ8|(gcn70mR*BZ21%p4˔ P%k_NA߈ ^}=3=ONJ2w]ǯ.݀_W©?l G۵u.'5ʦ׿&q,L[]$B@~{wZ 5 Ṟ,.\egs%̍r"HAa'bS I3&{[5㌉!ԳV81, t^\\Ĕj)(*@0c9h3}ڼ_g4ن`X/^X*Ipu.@.>'ٍ'[&{,q:~Π㴂 lL+ +2M!Y̐dxaY`7%.: tEQȽIԄ9`,*K}E& c[#$F`,8KiE0bMJy(`sxݿ2;cs!g#@u8;igq_M80T/fēUFԺBM|c=S/\iDi%zip`{?u^<HZ<.CQZ̸>bp\@Z|){I*pQ QzG}WHDnqL# 﨔Zy%ֺ9Y}x0t.| x;j j1]zM/+-J]LGM@ίjI5"o6fEyN~`)Gw"TO4P +w[Cl1 +5J6P'z-[+:F9ưiGo;3H/kͱĢGQV⁞)_Z9Ggړ*b=E]cJ^Nr]doi|y&]ImVΤ3\7o6w$&(l)eQȵ&r6gwarm榋nBM',0T چw^D1(UW6c QKtE0vUPh$8lԃq [mjj(}%b["S^ +!!?2Q0%J]Ӛ>vJ$dde]1tKR1a%f2* w]=9M2<[X35Eqph Sn\۳Kg0JNk(uBf>lqc%.MŒ11PeEhTs(1+7O2#GɴvY ݒ(gSxom>c].cΓojI#ms,X-%*Ha= +mV\^SjK#(߫ +T&2{ aҟKpW0gg&eU:,iQiaǭt 뺷dts29[T5ԙHY>,i8ScerFC~<%(}$DrW7@Y'ū5\\j1ծ:$4?ɏ\ ~AD@7T+_|lٜN(OJ? Ib(Diir̥%f1+iN/[Gn_7,GX1sEӱ]ӄ: #\j֞@4sLEo؏?q'GI,e Ea]~ֿx5:٣l7ݼXD=ر^ݰ3uiiщ-OԿbbCǁ Ǝx V Ho ԟ8!ftRPXH//M Y0k8AZN;՟ϨG(ZOjG^207M_ '_Ɣn:#|cĭ{f/ym\u)|hSw/TEPN !WJ;pUT/q4z*$ JN$"rpLolxJT'a qH*O(*,*kY/⋼7"F+5.W-@*r{=kP9}D#c9"&?z0+tp>gpLS|5 [I{64Eȟ Â!c@o g.8 ZjTDGhA&=U;x*{q#wфڬv䷯mh: m&j途R|G*d%BgDBڇK x"GkQwQ~+YA,*P6 A Z[XTBa4"!aq+6  y# ygD9dMeSμ@*ћ1gxDv"k7 4ksچB*/nlv o>[1BW6 ug̫ ߣ{4m.u.Pnڤ.+a $橝EXfQl,6PE+Db7dk'݌ȩ5TV v o4;כ!,6`TSt,7)AnC@'<ѥxv 6M=QuyQ={gYR`qZ_՝~׺udIO 72  abJ|b9EԹoXrQ}E <ߣ)!<"0}(*RGU]\I +'#U'e6lGN-=t!U#^Zs:F(Dk̗PNjΠf(cM3ynJMTO9YK +c~$0#stQ-$lJa|1FiY^}q:A*հ1_ qj?Å۟|)+ԓSzYy&@Nb$d̓ۻ9Ϊ1<_vhA U/[)`o,ڟOcKsi 7No\`-]5<ĸ~"ǵ¿/Y!5>"g܋~cK%'ہ]ƞh߀ԾBbf~eܼ8@I'ϺH-~OR8*\iHL۪%aǥ4 oJJ/bb gy,EIR  ~l A3vY!A2*9gR!)@}D~߲c3V(5\+N1~4\1Eߝ+I$8 (sÞX8XO3`MdgQ +[E(@.b'꽆{kS媐ד_cO{iUZG +4hbn|7%s?KA +گ0vZ<3Gjy<݉a{_̗\`*Oaff.n0'L8j6J %h[ 2AZ+Qo0`,mmXRÆt =瀹fepRd /78դZU5mfzC H\^߿8݌T]|jzaF `1Q=6ߧeaa^9߁НR3]=x5Nd8{{/rm*eՖ`YÝN]bGˁP>g^o|~m3wdBWGPߺD}`ַ]6Fd+9tckb;0śhj=}"35AU@ez[|~tKWkM˻OtY'r߂[jϷ7Gk%v2N,zU GyzeW$ldg+M>O{ H~, $ Os?睡eF>{s\ L{p-B㶃,cNp 15䀼AИ2{?ܷUSyPyuobHմ;ś}GB`QyEt +#'WBB,v3˯k[\WDYZv-|l}̏Z~nY=Ǔ(2|} $:LlT&w8*q8K*?\c>jϪ^2v4.KAx˅( ͔8I-qV0?J޾=*@ة }q^(oesb6EM'[awŷ7Aݦa+꿳wtN{KIf_ɘ$qCMlI+mfEqYJ%V'rK461y4!ha4M_XX8:cDΈb$^Z$/%Q\Ϲ_Q{!eyK_֦{ZQЕ[O2)\Ȓsu$G ů]8Hr9ͲGBK4G7H=1FkYj&Ek=ĹI+:Et'C7hf͋܃垎٘[Y guj  tQ#0 L_`~2N g))˚靹4@,M]MwuE^S{òVl 5R1#rU>fYbvlIKs} f8AOX `#+$m#Ҳ +endstream +endobj +49 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-24 -2960 1454 772] +/FontName/WKUHUU+CMEX10 +/ItalicAngle 0 +/StemV 47 +/FontFile 48 0 R +/Flags 4 +>> +endobj +48 0 obj +<< +/Filter[/FlateDecode] +/Length1 1442 +/Length2 5044 +/Length3 534 +/Length 5863 +>> +stream +xgXS[E)$tT%BBPD. M J/"H*R_~|\'Okp +_Bo 5ЮXaDPQ7LãA±( 22P2P,*+.MJ|0({,z{pA]8r mQH\rv xH$!%@ @ڣ\IEvCR8'q ."p*vuH;RQ]됧buY69;]aտ8w Eb4q38$sjc(KHW塁F"PX[G"q W`Z0Ճ\F>n=s}j O &>mꮶhJHp Cz:A+ \Ho}*YT=-N]G +np i&пɏc70p[俊II=uٟH*I;CO2:!P?_;O$DvXq_$53.?wc=p..?$}Š8[SSOgi;i@y9}~Btɀ6A aW?LE+ 2c/.!HIAτqHm5@ KI0`mu:H7Җ4Pv(xMAau5H%n.GJmCz5L$%/}H0=tِ MٝTTcqŜP=2Bl5 %jme4F κn%t=k9Hp `QKhdIq޺'%um;<*Hn{E Z^sJ*iocQ}oĿH-$cX3_s|al͵ĜU.ţ#;cMj5v;fѿ+m=A2ybMYFg֥˪8/oQmi YW&1XsiLprܣLZO^(% fz%8Y& 嫃Ăw-e-B>7 hc 3qOn-G4uΫkk.~nDkZA4_,|uycӬ doU z)C܊G+.Rӓ6;jBZh'*&xӶ\0=wzϡ/x U+e*]ʮ;ql[RVgաኘɝEWدv(õ|7sK7{2]5uR8cCls8+*wFvjiavJjz@eZe]Ԗ4ݠ\\|_xz,n-nZg;H٥#9 -kXi^M|5QS3EoS97M$pMv~4!9M4\o$%?wnŋ ٝa| t.դLT7?M^hqRߴcx{#qbh~N9 {*ˆatj) ݉)7[&ek)}d6s<Nγ{? ˎ2z3F"ҳ! +3BdJERp~>%~ުjSqٯ%9`i#-|ts^t.!Mqԗ´40dT$E\>\cCy>۞qq6[wr`8^3'VBRȤ%.{I +F=}{|W5&˃Xd D*؝L6E7]oˣ^P7̾p L,}nZa"0+CvŻ`D;B sg{XLz9<~0o yЉ| _ێ"vh.G/[7$$N>^XB*7ˏ-9,5$+8j@;pʘkr}ӯ՚;Ƚ6+5>߯@{q5,y^+wT.~y9fF@V%.ш(Uj5S?إE:vP~Y_FVe~HnmIn6iywDLZHH'O5s?K& Q⢳Ƿg=Gj5w SJצ]K.?$*܀JGƨV@NQ+@ꆆQַ?|S.pRSz_E@`vE$O_bewcΒ<~AH?oOWg!ArlnM(޶!4u)&F٪¢ڸdP[}q0NSNn%1M*}㊞I ~9],B9d6NGWXH3n1-wp#=ةkݤ22)X] mZALP>laKz _p,+yukVZG!BR8Z^eN~%ZƦqV0G{~UؖRa`r;|41zy[l1y-{ su?"0_ Z7dxD^t.\gc /rº.Wvpx[/<I +jeVr?v_sD3ZX>\,/p`M4M=]IڹL2k>);& 4i;?H%O#0%0^ĮDCQ; +XJK/[\waCB@qatkhBsULb:q2ǽ-ӍLyP:Sp&ĸ:2k屶cUA}UOэJ|]lf1B]WX#fYoW33?¿XKK;p}N71쌐`rVsjocń3P7&lK+ /KYgRLY숩NًȺ$TdY"Z "T+BI UFx$_ byu.+7Lp+kGRC8Gq&NvnB_͟/'LӠOh>0EZSO<!אFq!>ԃ⽥$#FVf+%yT R^@T ++n[zixl+#; kupYM$ؒinDFƗHҢ1,_tNNEDJ1R̲xlDqmRIz7Jx sI5J0( Wg"d]5xHM4K^&+)HtN3~/ Qr,WV*u^vr͵79r=֣݈dh*G2L}Հ=8%S=ּ k0O.W7SN%MLx,x>td pRӈʻmuJ/;k.:G"P.ƇN]ݞ׻Dem)Y2{| Io۝mf49usՌ~Oy^QjPz>61oOu-xF?sV4 ǚVM%!˽;jDz|^`!qNSo`"G)> +endobj +79 0 obj +<< +/Filter[/FlateDecode] +/Length1 944 +/Length2 1782 +/Length3 533 +/Length 2457 +>> +stream +xS{o~^ElYRg@,ԄJanl* E8e2 + nDa `*05G&| .9hJa5va 4ߤAdPXsMaL6#C\MRc6g X_N| +"t&8 #`!D Ap}އ ;n7؏n +q E ~9CB`?ǃ}>#l+Be`f˥xԊ@$ #4H@B41ags[@#<7d +Sx`^)g%\v~M7.g0 CL!_Jh+<& 5u D(Ԁ/|0D̉ ԅ W^@Nh<~#HR\.]Gw{*C ^cOWu[{Jӿ*u*vI!6NڿؖaUmhNMKkӂM;-vFa^,8Rzu.=Rt,0tې(^t&+mzI 7Y|ۉ[_[Ž2{ Z9T.MPZ0StV5NS&W_VZ +hFM >L^@44+b'T4*v8pi] +V}pL@1do3-֚zpTHuT+gE[ycѼx@wJlus˳7{O)x95 A {c5[V۳ɱ\68ruIfފCsEd(A'UE=)nN;"iyRב54_M01<-=H(qզ3~.> 9r&[Uų2}IO{aVդ~lejN-#]yeE~[mzl&*z<}YGc|ҋ1EϪfbZ-ۚguGs8 źeY,&Q?6_H!T,vOK +7h\䛢^8h9CM/U<)6wt7#JMm5h +yW6Ｂݣ5٫u`њJ}&90:Ȯ)`aWXªTJFH%SA32#rG7)'\߁@R|@ȺNo=?9nvHyLpcM'g1!n#)ni1ys`TZfUL5h?|vBQ(5s?"&L0c,a|URKu=wxgT<j-V6~ )~ UeN4Wlɍ˜5I$+RU +zsp\Oq ɒ/:U/3Hi>XIDѹ{57ǺBFßm|wx6"UJnZt|V;7J'*#0uoa`ץU7r~JXrZ6f|;KC^3dJw$]y–ĵSMu/:Y1 =c/j\'l7atLN`&Bn `dӽ%y:IXؠ鹿Ͽ[њ1s&+3> +endobj +116 0 obj +<< +/Filter[/FlateDecode] +/Length1 806 +/Length2 1686 +/Length3 533 +/Length 2281 +>> +stream +xU{8T\ȝ``f0lJ ƥH.5ef ØadƭT.DTBֽa\#(MQa4a"=1!<,+[省_^{vC/&n\L+IǤe-(]g8,ֶoLϼim@NCIܫpO-|z{ܗϢؽ2j4q %6tyx%''xB?˂˱jۀwg%ۗjoxP~h~PEdzŴNؒ捳pŘ3aNO*j*W0ɸ'N冂;>f^22^lN$'r]LL_.ǀ#ץd]:y6h~IQ%N?>dI4%l҃L 3Hs1DbDܪÃٽZ'dfFzgewiu Չ/zY[ruTo^Yf)vWYq|'_~VYSׇMlK0-'+[:JC +is8+bշ.1 4 ,t_0~{xWw֢^,5|VXԈ7߃ySr͏C9ө"bYmJFld0r}"sJ _F^݌rZ-.z>_&voAR)QA<_VzEU?c.Zy0uap`K6b6.-cRjtmG)0nf:vLn}ƴ,^^=8xT3L6?XŭĜ> +endobj +157 0 obj +<< +/Filter[/FlateDecode] +/Length1 849 +/Length2 2574 +/Length3 533 +/Length 3198 +>> +stream +xy<ǭa0TTcf3)[7c1v",ٵKQA){۞dMI3չ}N>^)kB@j"++ "S,zzhȟ R@O0H&*] ҈X +`{d, zAz&H#~@&D8p D +ʂeϟ,NB +p Y4cp3K>{Vƒd:H8FdqD] :D0H D̈A ΖHXRp39~LlbC rȿ4+#1pFh"HܹrG-h`5J B0E פP#+pOA?+$OF B"PD"8_$/ ?FblL +Z(A!H! +?R?~EVj<@ z@"u_!&EG +r:^J0V="<]&c-qͩVT,'x$!9\L=fJ>kIZw'Z94R W&GFʛ&H&!ƀ,EYvE V|ALc1@+H/X8ߛC8bG=B4|UU-tuF FUX4n>inެ^TAOخU?>-vPn˚ޥܣUP} ܛȕlfޥlW7ӎ-s8o +M,v2$:L?2W8,oaC^ЯK幉W}Cٙ0yw"9#r2@^CA+uu +,\QLЛWn]X(PS~hflM51-}2XoA03 +0ڶy՝>r(*-?SqXiy*T(g^Y0&]irrxL^e\Zf`)4y[y6'NSYBZ~(-l^$(\4AYs$ԓ5yS#r0_DRfĖoLntQ!ʷD|]VPqØ~rx^7e >o_.gLx + <B|ӯkJzGRתIۈu{; &ļV#P#= +yJӼ N97+\pLrIqKW1<{9|wn\R7yO;VU D%/# +On%0d#L& +kۚ) dXrHOSoehDH)jpכ:S͂6_FԮt'y?*Ot >#+.֍c/'C8B^\Y?rS-FN~?4tCJ2.3S4Q  BH|Րhɴt~K0>tx%y a(Uc(h^HfѠtJzYm~L̂MV_\D$ τ,EMOQ׼xfƒ50v_i#텬Yp1 e[IO?e'knVכPr>߿5^O0[X8T.B?0|vlli|n%e /ZN #7c$@Mll&vIur|5Lkg}Qa6 +11A-8Q&=XOFJfSu,tc9 c+ rct1юp}K|/6>RL s"xM"~y7llPYa"ڹHA^36'yKޅrB"OܴfSd=rQ`{!XZq{"d=%2umpBFmO_Z5koUkGw{[r/`I{P@]}vĺBgM8W;ƍ©nRϗF~] ֪z)B)aٔ+{Nk뉦hWYzaSKz 1#}_ʝmq(6<(K<`bDAeumLʝ;S}́O%Q}O-^kތbF4F΍hY]u<3%ЭMŷQ;f;>v Ov8ċmdxGh +*ψ]5-m8Q|LnzםǔJ>_Ԯ4" G1nJy  D?vu|շw\zeRj'u:FDznP`b8Iz:;ص]bJiq[rDUX[fDE/??1bit*K@LV^\ +endstream +endobj +161 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[21 -944 1448 791] +/FontName/USRWNS+CMSY5 +/ItalicAngle -14.035 +/StemV 101 +/FontFile 160 0 R +/Flags 68 +>> +endobj +160 0 obj +<< +/Filter[/FlateDecode] +/Length1 795 +/Length2 698 +/Length3 533 +/Length 1276 +>> +stream +xkPW6 .^*V:( +$LDŽJDe,df7LFTe +TA(Z^ mѶJPVZݐ:N:?}{{G Th4\ & 2NT +0FH9(XXf=Ƀ09 ɰ9N (% q8gFބ)arV +-&M̈́Z`ВҠ)1@jkG5\xJ-CSV:Db jyTi1n$)Ƙa -d$bZl9p$ `k@bH ԪI0Npڑ(|z Ś$u'in5z^|H,iɨE1^ȯo)# FKz$ 8V孂R`Ik@ O, o|4Y@ǰV $m69qN(dn}J%ca 0L"D +daX_uirF)+F̲+>絎 x29zE[C꿙T^Y8{1lDzF+v1]TcMDgڃOߝy88hv18ʝQin#eoYr@q᭕>L]y)"iRt۬lF{44]a:Kw8۹ TrKVM+g7ZuWDֵiQn6|/7;;Rn~~2vy˷Uwblj'1%kNT* +4{zY=P "4LmO:j.4^M]8fdZhR־vT]݀W{8zyQV՝+oz7<~r(ǞOł3)̱7*}RgՎslÒOys=[O)m#! rƅžBǞϊW8B^}[N5\ޕw\OO+1\"ozn;T+{HM_4<[=`(7Bs$S1 lG*Y{tj»g/үuw4߿b^_VvjQy'6y]jy{_'sgNPN8XB\> +endobj +163 0 obj +<< +/Filter[/FlateDecode] +/Length1 799 +/Length2 1539 +/Length3 533 +/Length 2125 +>> +stream +xR{8T"'Xd:f&܇Bְ23Kkf0R=iK4%!JKڢU.9u}>g߻޵ #%G#\0X+ +y0¡y ڒw(J?T +J a0Xpt 0s5SYltM@l  8pf-\Bh<0"aa?ʃD}!+'59A }y<ܝbs~0K+<B9Kh߳<: f8sY@X`;00,.4C#xyz0Q8_: +~srP8#%ʅ*8 9(]!ȭH +L`%P<0Ax-!DP$$E#跙Bo$&[Z%I$ZȀF?AxkyGQÛ~pJQ[}e̴}f|HJ=XL +VFѬ:#rَM=ֵH߮3A8K4$omoti@M_rH?KV/y(Zre2r4#ʳ4tdWUPC^>.*qq{ R0s&M+hC7T]x ȹWoAjPlr@E㧷'C*kq׫ -/']< e y<`mgp򉔓p`~Cd_j9簡j kp~iEtg% 0]fMowmvzF}Ucme:Zϴm?;j6]BY{BwZO)LlB:]Fc^P 7^T*U4O6~_;5Dw9tRtFMj[wIJSoZPuCVzRc%bgs{u\@wW\c],$ FԢmZVhqrן'm )h{f8Jzq8([=FS=[vk%mA;W.斎lTt52[Ňngh5)[fPe^sO>$hgxCLsU(r0.mrF:i =[=)!zbh +"7<Ʌ:;0az.;!c xYl4ܛ.+KE&G+|- n?ZHPnn/8%&PY;zL옹KiCf-$3L=RIà02KO[vv쓽oذN/_yP߅qKzX%ug32ÊEVnXy6=«^Ԟ2O`e4}rIH +i23]+8]v!/UM1gϡuu[vw(Wgףp@W=(WCh%nzj9; V? .<}l@\hgXuop!/qe;˗9J9넑/SwvTk~ ^,ث==YW7@r|vw ^Ft\opXxsђptʁ (7jU lGcEyPdtJ#/5uHZV,)8*A[3pÄqӤ$ڈcs8$5UGvL8 }ט[lD}>0=SՄ?xao0` :Ct4-V> +endstream +endobj +238 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-55 -420 2343 920] +/FontName/LVZEZH+MSBM10 +/ItalicAngle 0 +/StemV 40 +/FontFile 237 0 R +/Flags 4 +>> +endobj +237 0 obj +<< +/Filter[/FlateDecode] +/Length1 827 +/Length2 1901 +/Length3 533 +/Length 2508 +>> +stream +xRgTS FAh@a@ 0& T 5J!y HqDA`@ E"3@H#E)PD4'Ygٳg{w}]U%90`6Vk 8X8b1jIl[ؠ10,1!#p @0   0LL?AL. 2:KF0 i4pS 8@f(HA X@'sp_NPP-ӸTډ! +Dzm84.It@׀CI п$D6i X6P8H!Blr@%X<S-Xhw/k/[Ϳė*lWny??Ă0p`@WӬa2!@b2I\F@k`Db.ցlA aG  S +WHm.&n0 VF7%sLf` x^TDbCҖ%=FKT[jo)Ǡhkۉj\Å;ԝaȨQ3mѥ3N}tNU2<iYO&6'?{p&vQ^FXz&fS(<S8.g +ã~4x9,6,^[VU;Ani@󲎐~+j,>J%WH4lKZ޽S%U݈;4)s]l@ՈnNSt~.~\!K,tN!ÝSE6OX؆gk_ffC.&WxiPћgٷzqrINxrF1XeB9]cFߚO$L%\UJwF/вyz71rؗ8}QRDg^,q*l_L`G'-| +KՊэ}Dց<Uʈ:&#?!sú,ENQUL*q{JCjY3rU>QZhkuSo-"(%4+k}V_p"s7\}{])9Ii`4[kmNNHǰI%D>`T}lOPWT3{2nPsIЖA(|rl\tBZNH܇.~R\j$jJC:>f BY _ujx+Tٱ`DS?0 HP8&68>|~ĵE( 1 +)ʠ$nB7.{0ƾzHJ{ȁ=X¤YaΧxj.yXz!b`%ds]|gǠocdC:5"ܰjb+ڕ|WA'NI:8oRHKiagSS2 jY w?^Vm._,"Ļ8!+4w0-]!<6Ǜؼښ!%+[] vS 2AI7;&#<"΋hgFՅ\u +Te.>Gx%#ل_tB'}Ƒn6~̯so޻]4e\+5[>>df:$EVRzI)OM)J>zcU?hߴi.kRLuNC2͞apטܣ0^pѴk_gs3=(J%P3tɯSOI?%F)5W] A4 ܳzA󾗥M-UBu=2V9a!;"έoymj:OެwƘ}򦇆%w +\ט #T>:}VtD?0F2!f)X#\L_oyM=U/S55.~F3tymJ-XW,Q47Ye9ʐʉߥEV&n5/"*r13bĞ#NV~վ٥mWv==D-pY7SrFpPGoo;m ,O?V?0~!`=6Y[]HglFwGzDͦDaoUnN$c/k/@W;Wr+r}]'YFjy$> +endobj +254 0 obj +<< +/Filter[/FlateDecode] +/Length1 832 +/Length2 1474 +/Length3 533 +/Length 2078 +>> +stream +xRiP tKf +!IH!HP9DBIzQc<`AUA9E4PPeܭujkkmm~}{Y[ٻK x3IG<em&82X092 hD9dgDOL)""!1x W2!FBA>H 1#\)7qB 24ʿW"|!)$xx@x0WCA9|4Fbɣ>!T4nybDHĚiF,_%8ΉE| $yB7ڮ~>miq^5+A+îL`N_9'#ɝܘjuz.)lVp\4~<9ZV!1SN!/[lGnp+eZx۪x0fϝ6 'Deg܎WϏ, g٘(C[z.a?/|V0yLFRaѬ!VX3ue+D4sm20B/@V#oV#l-ZR`S\L}g߹u(,/cy̥ÜX]WafGa1B\#36bw 艡"'+h9 q+a:-)h+[QT56r\Iz<`qmM'{o}mUJN?c6UPj\̵] +~n|M_V*fڤ:%yOl&9 ǖ[CV٦Կ{l< ^nihovz4rɟr_R 3:ήW=1aKIbeH %YSgMm~>H2X3tNyZp>X6rZ{yOp/Nr_9 }77Kܐg0p6R]U>Yr,peA(@vϓ6uY+*l)yq_-~;<ZD4->zUm +tw;=h9i&#j]MnoyRV*_Sb~=tq须9cl=\ŵ*0(G77z3 W祸dx4FӐb(;Mc{R*9ЭLwEM3WeRFV,q?[oJ\ HdH$ZKM +endstream +endobj +278 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-30 -250 1026 750] +/FontName/LXRMIR+CMMI12 +/ItalicAngle -14.04 +/StemV 65 +/FontFile 277 0 R +/Flags 68 +>> +endobj +277 0 obj +<< +/Filter[/FlateDecode] +/Length1 820 +/Length2 2912 +/Length3 533 +/Length 3525 +>> +stream +xy$ +˒h*Կ[ADZ6Cls(,@A#n1 ;gΰ#Yr :4VW/8[" ޵Ix#?õ 0_uR $Ht/$ԉ$ڸam-u8~E%;ޞ 0|۸:if|DHp,l; +DpD! P[ќh !NR<@#0ܑP!F a?sQ6v)3 )hAT Hl[{oHd-V]]A;-aa >G|Fd%#3\mᲫlJVD \Юҫ0ڿ*DhΣF?Z ZnpA[zjCåt:pӾ7JM)ߪRѱ[Ya2YJzx17`De.a$Ovf;d'OB7>M~vi nUnA>8ePԛnFԈvJ>sJƂw&oyUjUyE O#)PƏ9mh7ZR:YJf( Zڶ[ڿ<`*<|#'J֔[6˴y@楦I(-ӻdmjhyCVz]Wlf)S&oΏ"DzarPXdsMZ[C򦚪4<!.Kb:=rG+s߅sQI|*%ɤrq`L; \[4mo檭}N>ot:eGZ\4! x`WtV+$IGp?FP[xPp3qzkuKOYȿ)BtGMXmBI2A娮NҌԊߙ߆ c. p>ؚthlA:4NNhe>5ݳ-m&>hfΙRW丼lʇd NaUm_$ss SOKK0/W\HNSf}*aGm nt;$$ͶS?gzYm7]I<[ZU +@s'-h٣iM΁Й+'O.GŬ$p  [NbB+grAZL\ғuL h2A$mPmזJ@As㲌:ہdVƇ 8J1z[ $,W+2kcFW}݈4w&˲edl"tN:FvLҵCIL4"̋86`J {+`|hE<̺]yɁ\up8%g-]?' OXcnoCyRW@8h5.#R:ҶhE[LCWJw.U4kWgn){YQ,bTr.Skk/&a 61Xar|B }:/ݙr%ѱDJɭńrx1t_ <|}>V7MdOk+Z~Oς{un!!|VzF$~aǂ6Ox=h͟ᵬoGO=R$`2keGH/ ]{:t[e +JaQe[nS9r IizYڱ _[#CMusOh0l .6}(~X2X=dkϳ7SǖmyO['?K13~6}HVZ8P T2!Jx5UYWnX$> ]I7f;E = cI.ٺo=V7tkkC_LT|И_bIa.ɂ^,]JЛ{ZۃnRqbd-WYzl ÒG'Y9!Þ6VΈ#>o(uIr((IIeF|!6<{:nWNtF\"s+!śE#c& `ͬ}kKWan+.N F[ se*Lh0HC Þ{aq)>/kF/ȖB%Ry'G ǛU3oH +Z"@KW K8aR>vk:Wj=# +\* |9DtnJ`Lh~mw.cnIu?%!8c&ٓ$}>3.,y=;m*Lhe|koM"^>CF}FGМ8.gF͜!{JF[էĪ=M +ĸ)E\$˄QiW*#D ΐWA"u ? +Dgc'JjD6$r#7<,,/# dh |vKh9Ũ~7rJHQ܋WE7|RVȏ@])^Oz> +endobj +478 0 obj +<< +/Filter[/FlateDecode] +/Length1 777 +/Length2 899 +/Length3 532 +/Length 1494 +>> +stream +xR{TLyOF)IG$?ã3LE4ZFJI{f 6z/I؍T['$,.KR6y,{q|>& +Ens02vGfp&A@&YN ҐSZ\$;c99 AYlOb`$qa!$$`dh*0"!%}o Tjy0(aQ.U-De}aT5h0`BRy!4*sx)Hh!IbPL ECPJQ9I' id1AJPHq' F/\r9 @KaJ qZ$Tu`AQ$ΙuX9w'QÙ}6lٟ(MJ~$"ok? $$P a8<PP4N4St*pfߟT 8><.sJ/NBbOVdsl^_T(8nӠ/UCbFERL&bC ;[>MgftF֕&)}"a%EGXʝnkڃ7 mo{fJ-6Qr]9t^wgx¶m&O3Ӽ>?Zmv^/ǹgbo8?9W>XgL kdw4Cw>ձXjq(sbsVYgCLIyWTlïK2>E{jҵ=ՓR_|ÝjwiLqlhu*{+sJShfXarǐuSsecRgu=Z|zfOtnKY^qlwW{g-3O"Mߌ]g=2k'[GE7fE1z'Cj]i1DߵŠ=[84) 29GEQeT\VUY{Reuy +tbcjBKO`w߬(kM?u-bC\\J|ZNj#O˿}7]<7s^ͳq_3wy9Qg6u$d֌ӧM #oEmS9Foo#rLUUٝ_)ޣ-{G/'|쭰WëM*aOX +Q&e(e +endstream +endobj +489 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-20 -250 1193 750] +/FontName/EWACGJ+CMR6 +/ItalicAngle 0 +/StemV 83 +/FontFile 488 0 R +/Flags 4 +>> +endobj +488 0 obj +<< +/Filter[/FlateDecode] +/Length1 777 +/Length2 1318 +/Length3 533 +/Length 1897 +>> +stream +xRk_|;/?>yn,= 1QDLSրnQ_A1"sĐ5[Yс$ʚfB$*bp_ F, `/0A+Ġ#, Cb){ Px"N<+{!Rg-9#(\ID_Z , qFwC "u+^c[|qD 1P$CpEy̧\!,:9k @\Cps\>B:c@u`3sύ#R?TgsOaF8̻<Gp0#%ⳁ#3A0ƒRTx&Qň +PQ-a3C9ǟڼ G6t)0E+%fai5WJ0 BsSxq9'a_cmҘ6=_݈UYf+ -(FL斚9act%qtUӕUz.J%7x)Ro @Hf>eφybZSm7zn?}uW6PS M j04~cĎUYIn#e+YnF{#D㑅yI% u-m?-0J<_dqIACJࢤc{o(:uYRG?eS2X6Ґ}l(yMXKzeJA6+8ڜyX|>ŝ]jVҋYQtsLk`^ ,%Y_Ȭ~S!1hCgNtU"F ֛>qvt۾~7mEocء,Ɔ!}4e{ٻ<؏+PDEǸ'{R6 5FL%0esYGley|ձ/,2dvdZP15l ('HߞsJ!!JܑcF2I02b|v0a3`K +z>_@HS: kl8[#- 6?ziPZKg=hGG=%$_ԧ}@jwm^ۮZ:x5i]!9l4MTlZHcu1~bQ/ד.j%btHFz ' $\q>*c?<ͭt5hrR$ Z8;h(n|T,jV/H ݟpjy&9دige烫>Iq/&zj=JOԾ*u?}bVorv?l}=iKOҸ*k\VB]Nv/(;bt0%ڻŃUHg-&CJۗxhi/Pf5Lf`⁘W, K,dSWbhi~#ÇzQJk㔵X~ڕ 0];%K s܌/;V&hiQWƱ1eny0ӟvujFɛ!OxUy~%-Me1+wuf"J :88 +?NH9ۚeI+ R&|> +endobj +492 0 obj +<< +/Filter[/FlateDecode] +/Length1 1066 +/Length2 3935 +/Length3 533 +/Length 4661 +>> +stream +xgTkiU( $Cҋ!$R(@&EHGAHN<~|Ι3k͚O{g?~׊60a 2`U@ZCAbbxa`* "hY( **]U<Eu%~f)><`/' <U0hc0#5A $ tJdx_+? N)P]qXU@ 8m?`00m/Qs_qoppT{/kf8: Ea7@pK4 @0?uOԶir?+f Cc ]g,o6&NP0*CM~88K] EîA% X@c" R CXz$@Ӕ_ _̿_[ʘeP/Ez@_+M2П鿡,AP< ѿ! 7T >FsbC꽸ߐZR+R!OSiYJP@Imh=@ +*goŸub$ JAӺI rl8m{Td9U[oO*3x;&%˄OiV%5|smzUdWӖj9>jG:HWDs7Y +GYߺބ K׵Fs@?$CoGou\WeB}"m7mȹY]`OYsFF̄BJ|;Vf:+s7rx#b +0a4\X{.w&70,]9'V_[]/qӺGVߌt4FopQ-PB![;t6T剹_tjczU%Ђk!JY!<[aR֔h섺/MLWT;̍.ٵ>!k y]Zك&\IOur۟b|x\iېQg)gzTwĮ~ QJ*=Ӗ_4Eb\oYOJrd#7#kGS?tsR"E{e*uigɹȓmzs\6/w^GN=m\o:=a/H{DvQ"uң\[J֮]@D$_,tŖ1UFWʾ5"/fSfɽpS̡ vƟ9 B.Rz&1\XSa5q {1\ݞ'Ek@idiwIҹUw1)Bq|w[ 2O&B#l]IR(#|aq׬P ;J:&E !=-FbyƲW,U5-٬z)Ohg^tW 5}2YVt憱u| O `SZU Vr;fsov^KzD1į"W_f -gqzH*JTn-^$NrU`׍i3r|)q(wk╸a];nA/S?q}اŞ?AW쏉Ľ֑m?g!5I˳Z/W.yeG\ 2D͚{ն;rwO?#hRj`9B5|Ld-#6䗟=E +YxR4.^?gLȮQ=Ѽ_3Z=ag3k7-bbjٮ5i^O ߕPœ`U"yonhzN2nyבSk2;XK.Gx77AiFB_<]=c`p{_ȗOR6N"z& :6OehҰ.J2[v<ׁVo +BfbvJup܆M؏1.p83:k#k%R+w?~{L2f1q);- ^.ɂB% O2Ə'K==4y{ba6~׃ηռ7hC9f.WJ?]tnȱݎw?ps*iڅ +k a"fc1K6>;Mlm\P= nB4z̻1o>]s7hlf Xɽj<ܫgl˰L iW3x1jƢM6~-6bҦ0}CnM +tEkj6ĶD;2ծ B`(^,ȸJ~qt*(Hh'Ywڶ,z#ZͰHalYl5:,`#ԝO&֩kγF⸑J9nj,K=R,{TX{}.yLB!W-'Oj)ǻ|bd >FīPO|hfLHb53JI6U#-dg\4By9Ek|M^+Es w.jS𖡆(kSlch Id=MԹ/ +-hlֿ{"!ҤՐ߯70OY&U)|S +cy_ҺsjGLO|=2G|~1[s9{,>"R/bdS۱@fqrgb>e{3GT8[_'vM6;.KLrʘjK0$͇;fȝM;ھ4Ke4R,op^mkd,H:QT1u4=9*|awf-g?HyTyDgMC:ce}rܪβ )n2ml3\>K$} mO+,'cI{abHkN(2 I{]W2'gC#}1>R呁"u|#;Z_'W~fz{ p;YT*Tm4lHTKb1q4vk2abf潮jGe?JY8rMX_\yXɠxqOLzl7e,hWT6yT6 t|~>r) \ ],.ml0\"Ao gX\S&/_˙:/':eƼmn~g\Ȗ+0t)GaN2ɴu|ARGmeQJĒ^ *Zo +>ڵpI[ImV#aؙo%4 H㶹Ԗ5c9y XI|elZ?<pKktv08}evYXt d̈́`N4CniN_7=OwwP#ֵ=@=Gn'Xu$: glt|YՖ?ѷG1_Zm+4s.OpۀځF'悢$W^ל_'VPX-y):N;NUxuIqμ]$CO ;%D' +xb0<_aQ +endstream +endobj +496 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-24 -250 1110 750] +/FontName/DXCKTL+CMMI8 +/ItalicAngle -14.04 +/StemV 78 +/FontFile 495 0 R +/Flags 68 +>> +endobj +495 0 obj +<< +/Filter[/FlateDecode] +/Length1 844 +/Length2 2413 +/Length3 533 +/Length 3031 +>> +stream +xy8clMYR{Y0W-{2x03cfCT$"edyKʖIEBh3eBΨ=w<G_í#'lZڬƆ 1748A +W Gڵa xLm Z@g< a T{$Jwît42 ~kO͛ x#`g~2+"':(}K`c^ +БF`4#h#o2@][+o3pZ2?C!1MdI~/+}KfavHsE/ j۱zaf9駍,zar6R`IVM6t9Ň^+iWŪu9[Kc5jnؗF- tF.-[)CaWjM1?nfخ,FNC +%[rrϿYwrSzQ%i:DGnjT$x]t"U;[^5׾Iޣޚ*ry&1骆#gJلK찋z̧pJ;tFlJ rޮqR?DZ>rLP(gO= Ju.u;eikw\ +:gRqӵ W[b\[H¤qfBDᱝBHM).0 wp\kA`;Ƀ +oښ[6߉.6+E:NCD)Z䋋=>I}HJ\o7M*,gqO ȩ /%`bPqtRk?'@|ACؓD9O|0^!DZ^Ͷb&FTEN9׆^KgdoNJ,|p2Rrlxo**zȕʶO}zׄAѦZSmvT0…Kc] pgc1>;PE[f|\1T[ tYzը!?4Q7/#Qk۷9%0-L͜]"y+hcpOM_{zQ%'%3ʕvGTQK!ց_iٝ&'(v,u)i .KkZXwxyKC= _ :n.Ө .y')B!Dp'M뤢gN⛫_?8mҖ^=k݃sn/(G9zd=ӷTPGӌy͊f7wӷĝ*bMg :BwQ#g~~b##g6I\s@ yNN̋Θ|W)M;RבY_9 /xc]pݎ. ԛY.ujus1(% VR +svZ}B ](){ν2$Ggn.K?N^_ rR*%&::X3_}ddFlt2~*@^{DAp´ɳޫ:SbrXmkxCQWeWQlܥ$SeRH I$y&HAdɎɳ[ȧlM(mq墪+#"L26WDPJdO}L-H:aSOz﹟p&F\_'56fEpR1| s˜qͪF ՛^[l18>sHi@) Xuzs X:憮烅n/2Eި"#q]@3 /q??\>* k\ئY_ߪ`FW5uJ +s}.O$+ ]XǥdpUL=wd#{|< >sj9`KF Qs̿Jk%jJlC +onnp4-vD|)=#[X4<+I=$cjB;:}:~}Cr~LC_L|ޱ +ro.WE.gX['1"3SV2&_+5閍MOg>0| EZowZ~ Kߴ5R*VsHp3rdYhj!Ci74:v` O ˅Dܬ[7ZZf` ./;|r6oJFMd IQ.Kg?SOy>u^䄥iseZۋZ rlLL鍋~Ī񔔅> +endobj +498 0 obj +<< +/Filter[/FlateDecode] +/Length1 773 +/Length2 598 +/Length3 533 +/Length 1159 +>> +stream +xSU uLOJu+53Rp P03RUu.JM,sI,IR04Tp,MW04U002224RUp/,L(Qp2WpM-LNSM,HZRRZZTeh\ǥrg^Z9D8&UZT tН +@WT*qmKdgaqn99~ A!S U[PZZZ4<6Ԕ\tYϒĜdǼT]C=cSDf[fEjJ@fIrBZbNq*X<5/);D?3+Hɀ̼ʂTj0RQfB!P!Xh%d+)$%Vr225U6TKIPHX_//E4 +iE\X543T+-saz)Z@Ahe-мTOS C hriQQj^ 8 OljjEj29:_ĹfGm2;49)ozsǵu>/yM s9sﯼsekOryvO [y%ɾD}YQǚ{ׅ]Ւ=*]bqpA jSʂY ~ćHNJ#J,qTlggƸ7/;>SLJ9Ndz |s; _1A()R}uGzT2jϼ|Q]ے$jߔI.0}FN 싓3n._MuT?_Sw%Lenz+pvӼ?r*b23zWɆ3mo,v}> +endobj +501 0 obj +<< +/Filter[/FlateDecode] +/Length1 814 +/Length2 1107 +/Length3 532 +/Length 1735 +>> +stream +xRmTgFD Ђŷ4X&TD +C&F'30`UP*,q)"JEU+[@DD `{V=;̽ys0ԙ'!D?S,hC68e@X GbB" JTR<’Jx @.%~LrTL"Xgp)X`~D|QI 6$~;tK(cznOҜK Œ Nto` $Vl^cbfBBtB$*XJBoIt%7zH$!1GP,z CpD.Y(vQ%"8HaL^zj IGp XBXҬrzF]|#?jg0Sa}Y`D +E'Bk[q1!AX0II rp@ + ~%@Wv)A2+ +ZXa0DJM#% m9_86rvg8&(۝f뷒$Ioҳ|KQzD/7^Nl;f9] kr:ZYs{FEJjHTbr29'h;Bsǫo_lDkXyjKOF Z|XU?jVrT ,Qy->k,OYe?[Kn콼 ڕv㵶-$se?5G&uڗ7,)͑ o).)C1ft C+t0 + +ުI'&RdM׵}ua >l'Mhmԇty6wm2MbCF'zKǫBޫ paMxx73no~=e=NH"5|YZs1Lm^_1w [^d_0iKx=޲ wh N^)*nڵQW[]gIƲw$L9 N4]Oz:(o~S GsmwZM__U۱gƼuu`SNDKA y. +Z0nvOk?k>PQ s#zN5٨ۧ]YNEւ"gw~AdvnȹM_2O7:ʯD_d޸X}lix:7b t>QVW8ȪQS8cn6B*jXM*o ͻ|F^6fk~[ѫfVuqoLIFV$'> +endobj +5 0 obj +<< +/Type/Page +/Resources 6 0 R +/Contents[52 0 R 4 0 R 53 0 R 54 0 R] +/Annots 55 0 R +/Parent 524 0 R +>> +endobj +57 0 obj +<< +/Type/Page +/Resources 58 0 R +/Contents[52 0 R 4 0 R 85 0 R 54 0 R] +/Annots 86 0 R +/Parent 525 0 R +>> +endobj +89 0 obj +<< +/Type/Page +/Resources 90 0 R +/Contents[52 0 R 4 0 R 119 0 R 54 0 R] +/Annots 120 0 R +/Parent 525 0 R +>> +endobj +525 0 obj +<< +/Type/Pages +/Count 2 +/Kids[57 0 R 89 0 R] +/Parent 524 0 R +>> +endobj +123 0 obj +<< +/Type/Page +/Resources 124 0 R +/Contents[52 0 R 4 0 R 148 0 R 54 0 R] +/Annots 149 0 R +/Parent 524 0 R +>> +endobj +152 0 obj +<< +/Type/Page +/Resources 153 0 R +/Contents[52 0 R 4 0 R 169 0 R 54 0 R] +/Annots 170 0 R +/Parent 526 0 R +>> +endobj +172 0 obj +<< +/Type/Page +/Resources 173 0 R +/Contents[52 0 R 4 0 R 183 0 R 54 0 R] +/Annots 184 0 R +/Parent 526 0 R +>> +endobj +526 0 obj +<< +/Type/Pages +/Count 2 +/Kids[152 0 R 172 0 R] +/Parent 524 0 R +>> +endobj +524 0 obj +<< +/Type/Pages +/Count 6 +/Kids[5 0 R 525 0 R 123 0 R 526 0 R] +/Parent 3 0 R +>> +endobj +186 0 obj +<< +/Type/Page +/Resources 187 0 R +/Contents[52 0 R 4 0 R 203 0 R 54 0 R] +/Parent 527 0 R +>> +endobj +206 0 obj +<< +/Type/Page +/Resources 207 0 R +/Contents[52 0 R 4 0 R 223 0 R 54 0 R] +/Annots 224 0 R +/Parent 528 0 R +>> +endobj +227 0 obj +<< +/Type/Page +/Resources 228 0 R +/Contents[52 0 R 4 0 R 240 0 R 54 0 R] +/Parent 528 0 R +>> +endobj +528 0 obj +<< +/Type/Pages +/Count 2 +/Kids[206 0 R 227 0 R] +/Parent 527 0 R +>> +endobj +242 0 obj +<< +/Type/Page +/Resources 243 0 R +/Contents[52 0 R 4 0 R 257 0 R 54 0 R] +/Parent 527 0 R +>> +endobj +259 0 obj +<< +/Type/Page +/Resources 260 0 R +/Contents[52 0 R 4 0 R 269 0 R 54 0 R] +/Annots 270 0 R +/Parent 529 0 R +>> +endobj +272 0 obj +<< +/Type/Page +/Resources 273 0 R +/Contents[52 0 R 4 0 R 297 0 R 54 0 R] +/Parent 529 0 R +>> +endobj +529 0 obj +<< +/Type/Pages +/Count 2 +/Kids[259 0 R 272 0 R] +/Parent 527 0 R +>> +endobj +527 0 obj +<< +/Type/Pages +/Count 6 +/Kids[186 0 R 528 0 R 242 0 R 529 0 R] +/Parent 3 0 R +>> +endobj +299 0 obj +<< +/Type/Page +/Resources 300 0 R +/Contents[52 0 R 4 0 R 311 0 R 54 0 R] +/Annots 312 0 R +/Parent 530 0 R +>> +endobj +314 0 obj +<< +/Type/Page +/Resources 315 0 R +/Contents[52 0 R 4 0 R 325 0 R 54 0 R] +/Annots 326 0 R +/Parent 531 0 R +>> +endobj +328 0 obj +<< +/Type/Page +/Resources 329 0 R +/Contents[52 0 R 4 0 R 339 0 R 54 0 R] +/Annots 340 0 R +/Parent 531 0 R +>> +endobj +531 0 obj +<< +/Type/Pages +/Count 2 +/Kids[314 0 R 328 0 R] +/Parent 530 0 R +>> +endobj +342 0 obj +<< +/Type/Page +/Resources 343 0 R +/Contents[52 0 R 4 0 R 349 0 R 54 0 R] +/Parent 530 0 R +>> +endobj +351 0 obj +<< +/Type/Page +/Resources 352 0 R +/Contents[52 0 R 4 0 R 359 0 R 54 0 R] +/Annots 360 0 R +/Parent 532 0 R +>> +endobj +362 0 obj +<< +/Type/Page +/Resources 363 0 R +/Contents[52 0 R 4 0 R 373 0 R 54 0 R] +/Annots 374 0 R +/Parent 532 0 R +>> +endobj +532 0 obj +<< +/Type/Pages +/Count 2 +/Kids[351 0 R 362 0 R] +/Parent 530 0 R +>> +endobj +530 0 obj +<< +/Type/Pages +/Count 6 +/Kids[299 0 R 531 0 R 342 0 R 532 0 R] +/Parent 3 0 R +>> +endobj +376 0 obj +<< +/Type/Page +/Resources 377 0 R +/Contents[52 0 R 4 0 R 387 0 R 54 0 R] +/Annots 388 0 R +/Parent 533 0 R +>> +endobj +390 0 obj +<< +/Type/Page +/Resources 391 0 R +/Contents[52 0 R 4 0 R 400 0 R 54 0 R] +/Parent 534 0 R +>> +endobj +402 0 obj +<< +/Type/Page +/Resources 403 0 R +/Contents[52 0 R 4 0 R 416 0 R 54 0 R] +/Annots 417 0 R +/Parent 534 0 R +>> +endobj +534 0 obj +<< +/Type/Pages +/Count 2 +/Kids[390 0 R 402 0 R] +/Parent 533 0 R +>> +endobj +419 0 obj +<< +/Type/Page +/Resources 420 0 R +/Contents[52 0 R 4 0 R 449 0 R 54 0 R] +/Parent 535 0 R +>> +endobj +452 0 obj +<< +/Type/Page +/Resources 453 0 R +/Contents[52 0 R 4 0 R 468 0 R 54 0 R] +/Annots 469 0 R +/Parent 535 0 R +>> +endobj +535 0 obj +<< +/Type/Pages +/Count 2 +/Kids[419 0 R 452 0 R] +/Parent 533 0 R +>> +endobj +471 0 obj +<< +/Type/Page +/Resources 472 0 R +/Contents[52 0 R 4 0 R 504 0 R 54 0 R] +/Annots 505 0 R +/Parent 536 0 R +>> +endobj +507 0 obj +<< +/Type/Page +/Resources 508 0 R +/Contents[52 0 R 4 0 R 521 0 R 54 0 R] +/Annots 522 0 R +/Parent 536 0 R +>> +endobj +536 0 obj +<< +/Type/Pages +/Count 2 +/Kids[471 0 R 507 0 R] +/Parent 533 0 R +>> +endobj +533 0 obj +<< +/Type/Pages +/Count 7 +/Kids[376 0 R 534 0 R 535 0 R 536 0 R] +/Parent 3 0 R +>> +endobj +3 0 obj +<< +/Type/Pages +/Count 25 +/Kids[524 0 R 527 0 R 530 0 R 533 0 R] +/MediaBox[0 0 595.27 841.82] +>> +endobj +52 0 obj +<< +/Length 1 +>> +stream + +endstream +endobj +54 0 obj +<< +/Length 1 +>> +stream + +endstream +endobj +4 0 obj +<< +/Length 21 +>> +stream +1 0 0 1 72 769.82 cm +endstream +endobj +537 0 obj +<< +>> +endobj +538 0 obj +<< +/Limits[(ALC@line.1) (ALC@line.2)] +/Names[(ALC@line.1) 283 0 R (ALC@line.1) 105 0 R (ALC@line.2) 107 0 R] +>> +endobj +539 0 obj +<< +/Limits[(ALC@line.2) (ALC@line.3)] +/Names[(ALC@line.2) 285 0 R (ALC@line.3) 287 0 R (ALC@line.3) 109 0 R] +>> +endobj +540 0 obj +<< +/Limits[(ALC@line.4) (ALC@line.5)] +/Names[(ALC@line.4) 111 0 R (ALC@line.4) 289 0 R (ALC@line.5) 291 0 R] +>> +endobj +541 0 obj +<< +/Limits[(ALC@line.5) (ALC@line.7)] +/Names[(ALC@line.5) 114 0 R (ALC@line.6) 293 0 R (ALC@line.7) 295 0 R] +>> +endobj +542 0 obj +<< +/Limits[(ALC@line.1) (ALC@line.7)] +/Kids[538 0 R 539 0 R 540 0 R 541 0 R] +>> +endobj +543 0 obj +<< +/Limits[(ALC@rem.1) (ALC@rem.2)] +/Names[(ALC@rem.1) 284 0 R (ALC@rem.1) 106 0 R (ALC@rem.2) 286 0 R] +>> +endobj +544 0 obj +<< +/Limits[(ALC@rem.2) (ALC@rem.3)] +/Names[(ALC@rem.2) 108 0 R (ALC@rem.3) 288 0 R (ALC@rem.3) 110 0 R] +>> +endobj +545 0 obj +<< +/Limits[(ALC@rem.4) (ALC@rem.5)] +/Names[(ALC@rem.4) 290 0 R (ALC@rem.4) 112 0 R (ALC@rem.5) 115 0 R] +>> +endobj +546 0 obj +<< +/Limits[(ALC@rem.5) (ALC@rem.7)] +/Names[(ALC@rem.5) 104 0 R (ALC@rem.5) 292 0 R (ALC@rem.6) 294 0 R (ALC@rem.7) 296 0 R] +>> +endobj +547 0 obj +<< +/Limits[(ALC@rem.1) (ALC@rem.7)] +/Kids[543 0 R 544 0 R 545 0 R 546 0 R] +>> +endobj +548 0 obj +<< +/Limits[(ALC@rem.7) (Hfootnote.1)] +/Names[(ALC@rem.7) 282 0 R (Doc-Start) 8 0 R (Hfootnote.1) 491 0 R] +>> +endobj +549 0 obj +<< +/Limits[(cite.MarkovChain) (equation.1)] +/Names[(cite.MarkovChain) 515 0 R (cite.ParticleFilter) 518 0 R (equation.1) 36 0 R] +>> +endobj +550 0 obj +<< +/Limits[(equation.10) (equation.13)] +/Names[(equation.10) 177 0 R (equation.11) 178 0 R (equation.13) 179 0 R] +>> +endobj +551 0 obj +<< +/Limits[(equation.14) (equation.16)] +/Names[(equation.14) 182 0 R (equation.15) 221 0 R (equation.16) 230 0 R] +>> +endobj +552 0 obj +<< +/Limits[(ALC@rem.7) (equation.16)] +/Kids[548 0 R 549 0 R 550 0 R 551 0 R] +>> +endobj +553 0 obj +<< +/Limits[(equation.17) (equation.19)] +/Names[(equation.17) 231 0 R (equation.18) 235 0 R (equation.19) 236 0 R] +>> +endobj +554 0 obj +<< +/Limits[(equation.2) (equation.21)] +/Names[(equation.2) 47 0 R (equation.20) 245 0 R (equation.21) 246 0 R] +>> +endobj +555 0 obj +<< +/Limits[(equation.22) (equation.24)] +/Names[(equation.22) 247 0 R (equation.23) 248 0 R (equation.24) 253 0 R] +>> +endobj +556 0 obj +<< +/Limits[(equation.25) (equation.28)] +/Names[(equation.25) 263 0 R (equation.26) 264 0 R (equation.27) 265 0 R (equation.28) +280 0 R] +>> +endobj +557 0 obj +<< +/Limits[(equation.17) (equation.28)] +/Kids[553 0 R 554 0 R 555 0 R 556 0 R] +>> +endobj +558 0 obj +<< +/Limits[(ALC@line.1) (equation.28)] +/Kids[542 0 R 547 0 R 552 0 R 557 0 R] +>> +endobj +559 0 obj +<< +/Limits[(equation.29) (equation.30)] +/Names[(equation.29) 303 0 R (equation.3) 78 0 R (equation.30) 304 0 R] +>> +endobj +560 0 obj +<< +/Limits[(equation.31) (equation.33)] +/Names[(equation.31) 307 0 R (equation.32) 308 0 R (equation.33) 310 0 R] +>> +endobj +561 0 obj +<< +/Limits[(equation.34) (equation.36)] +/Names[(equation.34) 318 0 R (equation.35) 323 0 R (equation.36) 324 0 R] +>> +endobj +562 0 obj +<< +/Limits[(equation.37) (equation.39)] +/Names[(equation.37) 333 0 R (equation.38) 355 0 R (equation.39) 356 0 R] +>> +endobj +563 0 obj +<< +/Limits[(equation.29) (equation.39)] +/Kids[559 0 R 560 0 R 561 0 R 562 0 R] +>> +endobj +564 0 obj +<< +/Limits[(equation.4) (equation.42)] +/Names[(equation.4) 100 0 R (equation.40) 368 0 R (equation.42) 371 0 R] +>> +endobj +565 0 obj +<< +/Limits[(equation.44) (equation.47)] +/Names[(equation.44) 379 0 R (equation.45) 380 0 R (equation.47) 381 0 R] +>> +endobj +566 0 obj +<< +/Limits[(equation.49) (equation.50)] +/Names[(equation.49) 386 0 R (equation.5) 102 0 R (equation.50) 394 0 R] +>> +endobj +567 0 obj +<< +/Limits[(equation.51) (equation.56)] +/Names[(equation.51) 395 0 R (equation.53) 396 0 R (equation.55) 399 0 R (equation.56) +407 0 R] +>> +endobj +568 0 obj +<< +/Limits[(equation.4) (equation.56)] +/Kids[564 0 R 565 0 R 566 0 R 567 0 R] +>> +endobj +569 0 obj +<< +/Limits[(equation.57) (equation.59)] +/Names[(equation.57) 409 0 R (equation.58) 411 0 R (equation.59) 415 0 R] +>> +endobj +570 0 obj +<< +/Limits[(equation.6) (equation.61)] +/Names[(equation.6) 145 0 R (equation.60) 442 0 R (equation.61) 445 0 R] +>> +endobj +571 0 obj +<< +/Limits[(equation.62) (equation.64)] +/Names[(equation.62) 447 0 R (equation.63) 448 0 R (equation.64) 457 0 R] +>> +endobj +572 0 obj +<< +/Limits[(equation.66) (equation.7)] +/Names[(equation.66) 458 0 R (equation.68) 461 0 R (equation.7) 146 0 R] +>> +endobj +573 0 obj +<< +/Limits[(equation.57) (equation.7)] +/Kids[569 0 R 570 0 R 571 0 R 572 0 R] +>> +endobj +574 0 obj +<< +/Limits[(equation.70) (equation.73)] +/Names[(equation.70) 467 0 R (equation.72) 475 0 R (equation.73) 476 0 R] +>> +endobj +575 0 obj +<< +/Limits[(equation.74) (equation.76)] +/Names[(equation.74) 477 0 R (equation.75) 483 0 R (equation.76) 484 0 R] +>> +endobj +576 0 obj +<< +/Limits[(equation.77) (equation.79)] +/Names[(equation.77) 485 0 R (equation.78) 487 0 R (equation.79) 511 0 R] +>> +endobj +577 0 obj +<< +/Limits[(equation.8) (figure.2)] +/Names[(equation.8) 156 0 R (equation.9) 167 0 R (figure.1) 67 0 R (figure.2) 75 0 R] +>> +endobj +578 0 obj +<< +/Limits[(equation.70) (figure.2)] +/Kids[574 0 R 575 0 R 576 0 R 577 0 R] +>> +endobj +579 0 obj +<< +/Limits[(equation.29) (figure.2)] +/Kids[563 0 R 568 0 R 573 0 R 578 0 R] +>> +endobj +580 0 obj +<< +/Limits[(figure.3) (figure.5)] +/Names[(figure.3) 99 0 R (figure.4) 133 0 R (figure.5) 141 0 R] +>> +endobj +581 0 obj +<< +/Limits[(figure.6) (figure.8)] +/Names[(figure.6) 202 0 R (figure.7) 218 0 R (figure.8) 441 0 R] +>> +endobj +582 0 obj +<< +/Limits[(page.1) (page.11)] +/Names[(page.1) 7 0 R (page.10) 244 0 R (page.11) 261 0 R] +>> +endobj +583 0 obj +<< +/Limits[(page.12) (page.14)] +/Names[(page.12) 274 0 R (page.13) 301 0 R (page.14) 316 0 R] +>> +endobj +584 0 obj +<< +/Limits[(figure.3) (page.14)] +/Kids[580 0 R 581 0 R 582 0 R 583 0 R] +>> +endobj +585 0 obj +<< +/Limits[(page.15) (page.17)] +/Names[(page.15) 330 0 R (page.16) 344 0 R (page.17) 353 0 R] +>> +endobj +586 0 obj +<< +/Limits[(page.18) (page.2)] +/Names[(page.18) 364 0 R (page.19) 378 0 R (page.2) 59 0 R] +>> +endobj +587 0 obj +<< +/Limits[(page.20) (page.22)] +/Names[(page.20) 392 0 R (page.21) 404 0 R (page.22) 421 0 R] +>> +endobj +588 0 obj +<< +/Limits[(page.23) (page.3)] +/Names[(page.23) 454 0 R (page.24) 473 0 R (page.25) 509 0 R (page.3) 91 0 R] +>> +endobj +589 0 obj +<< +/Limits[(page.15) (page.3)] +/Kids[585 0 R 586 0 R 587 0 R 588 0 R] +>> +endobj +590 0 obj +<< +/Limits[(page.4) (page.6)] +/Names[(page.4) 125 0 R (page.5) 154 0 R (page.6) 174 0 R] +>> +endobj +591 0 obj +<< +/Limits[(page.7) (page.9)] +/Names[(page.7) 188 0 R (page.8) 208 0 R (page.9) 229 0 R] +>> +endobj +592 0 obj +<< +/Limits[(section*.1) (section*.3)] +/Names[(section*.1) 306 0 R (section*.2) 512 0 R (section*.3) 514 0 R] +>> +endobj +593 0 obj +<< +/Limits[(section.1) (section.3)] +/Names[(section.1) 15 0 R (section.2) 180 0 R (section.3) 232 0 R] +>> +endobj +594 0 obj +<< +/Limits[(page.4) (section.3)] +/Kids[590 0 R 591 0 R 592 0 R 593 0 R] +>> +endobj +595 0 obj +<< +/Limits[(section.4) (section.6)] +/Names[(section.4) 319 0 R (section.5) 384 0 R (section.6) 405 0 R] +>> +endobj +596 0 obj +<< +/Limits[(section.7) (subsection.1.2)] +/Names[(section.7) 443 0 R (subsection.1.1) 19 0 R (subsection.1.2) 29 0 R] +>> +endobj +597 0 obj +<< +/Limits[(subsection.1.3) (subsection.1.5)] +/Names[(subsection.1.3) 30 0 R (subsection.1.4) 82 0 R (subsection.1.5) 147 0 R] +>> +endobj +598 0 obj +<< +/Limits[(subsection.1.6) (subsection.2.3)] +/Names[(subsection.1.6) 168 0 R (subsection.2.1) 181 0 R (subsection.2.2) 219 0 R +(subsection.2.3) 222 0 R] +>> +endobj +599 0 obj +<< +/Limits[(section.4) (subsection.2.3)] +/Kids[595 0 R 596 0 R 597 0 R 598 0 R] +>> +endobj +600 0 obj +<< +/Limits[(figure.3) (subsection.2.3)] +/Kids[584 0 R 589 0 R 594 0 R 599 0 R] +>> +endobj +601 0 obj +<< +/Limits[(subsection.3.1) (subsection.3.3)] +/Names[(subsection.3.1) 233 0 R (subsection.3.2) 234 0 R (subsection.3.3) 249 0 R] +>> +endobj +602 0 obj +<< +/Limits[(subsection.3.4) (subsection.3.6)] +/Names[(subsection.3.4) 262 0 R (subsection.3.5) 268 0 R (subsection.3.6) 275 0 R] +>> +endobj +603 0 obj +<< +/Limits[(subsection.4.1) (subsection.4.3)] +/Names[(subsection.4.1) 320 0 R (subsection.4.2) 321 0 R (subsection.4.3) 334 0 R] +>> +endobj +604 0 obj +<< +/Limits[(subsection.4.4) (subsection.5.1)] +/Names[(subsection.4.4) 347 0 R (subsection.4.5) 365 0 R (subsection.5.1) 385 0 R] +>> +endobj +605 0 obj +<< +/Limits[(subsection.3.1) (subsection.5.1)] +/Kids[601 0 R 602 0 R 603 0 R 604 0 R] +>> +endobj +606 0 obj +<< +/Limits[(subsection.5.2) (subsection.5.4)] +/Names[(subsection.5.2) 393 0 R (subsection.5.3) 397 0 R (subsection.5.4) 398 0 R] +>> +endobj +607 0 obj +<< +/Limits[(subsection.6.1) (subsection.6.3)] +/Names[(subsection.6.1) 406 0 R (subsection.6.2) 408 0 R (subsection.6.3) 410 0 R] +>> +endobj +608 0 obj +<< +/Limits[(subsection.6.4) (subsection.7.2)] +/Names[(subsection.6.4) 414 0 R (subsection.7.1) 444 0 R (subsection.7.2) 446 0 R] +>> +endobj +609 0 obj +<< +/Limits[(subsection.7.3) (subsection.7.6)] +/Names[(subsection.7.3) 455 0 R (subsection.7.4) 456 0 R (subsection.7.5) 464 0 R +(subsection.7.6) 482 0 R] +>> +endobj +610 0 obj +<< +/Limits[(subsection.5.2) (subsection.7.6)] +/Kids[606 0 R 607 0 R 608 0 R 609 0 R] +>> +endobj +611 0 obj +<< +/Limits[(subsubsection.1.3.1) (subsubsection.1.3.3)] +/Names[(subsubsection.1.3.1) 31 0 R (subsubsection.1.3.2) 43 0 R (subsubsection.1.3.3) +76 0 R] +>> +endobj +612 0 obj +<< +/Limits[(subsubsection.1.4.1) (subsubsection.1.4.3)] +/Names[(subsubsection.1.4.1) 83 0 R (subsubsection.1.4.2) 101 0 R (subsubsection.1.4.3) +142 0 R] +>> +endobj +613 0 obj +<< +/Limits[(subsubsection.3.3.1) (subsubsection.3.3.3)] +/Names[(subsubsection.3.3.1) 250 0 R (subsubsection.3.3.2) 251 0 R (subsubsection.3.3.3) +252 0 R] +>> +endobj +614 0 obj +<< +/Limits[(subsubsection.3.6.1) (subsubsection.3.6.3)] +/Names[(subsubsection.3.6.1) 276 0 R (subsubsection.3.6.2) 281 0 R (subsubsection.3.6.3) +302 0 R] +>> +endobj +615 0 obj +<< +/Limits[(subsubsection.1.3.1) (subsubsection.3.6.3)] +/Kids[611 0 R 612 0 R 613 0 R 614 0 R] +>> +endobj +616 0 obj +<< +/Limits[(subsubsection.4.2.1) (subsubsection.4.2.3)] +/Names[(subsubsection.4.2.1) 322 0 R (subsubsection.4.2.2) 331 0 R (subsubsection.4.2.3) +332 0 R] +>> +endobj +617 0 obj +<< +/Limits[(subsubsection.4.3.1) (subsubsection.4.3.3)] +/Names[(subsubsection.4.3.1) 335 0 R (subsubsection.4.3.2) 336 0 R (subsubsection.4.3.3) +345 0 R] +>> +endobj +618 0 obj +<< +/Limits[(subsubsection.4.3.4) (subsubsection.4.4.2)] +/Names[(subsubsection.4.3.4) 346 0 R (subsubsection.4.4.1) 348 0 R (subsubsection.4.4.2) +354 0 R] +>> +endobj +619 0 obj +<< +/Limits[(subsubsection.4.4.3) (subsubsection.4.5.3)] +/Names[(subsubsection.4.4.3) 358 0 R (subsubsection.4.5.1) 366 0 R (subsubsection.4.5.2) +369 0 R (subsubsection.4.5.3) 372 0 R] +>> +endobj +620 0 obj +<< +/Limits[(subsubsection.4.2.1) (subsubsection.4.5.3)] +/Kids[616 0 R 617 0 R 618 0 R 619 0 R] +>> +endobj +621 0 obj +<< +/Limits[(subsection.3.1) (subsubsection.4.5.3)] +/Kids[605 0 R 610 0 R 615 0 R 620 0 R] +>> +endobj +622 0 obj +<< +/Kids[558 0 R 579 0 R 600 0 R 621 0 R] +>> +endobj +623 0 obj +[] +endobj +624 0 obj +<< +/Dests 622 0 R +>> +endobj +2 0 obj +<< +/Type/Catalog +/Pages 3 0 R +/Outlines 537 0 R +/Threads 623 0 R +/Names 624 0 R +>> +endobj +xref +0 625 +0000000000 65535 f +0000303808 00000 n +0000319478 00000 n +0000308147 00000 n +0000308358 00000 n +0000304040 00000 n +0000010756 00000 n +0000000009 00000 n +0000000059 00000 n +0000153133 00000 n +0000152948 00000 n +0000000109 00000 n +0000158168 00000 n +0000157982 00000 n +0000000835 00000 n +0000001562 00000 n +0000170441 00000 n +0000170252 00000 n +0000001613 00000 n +0000002345 00000 n +0000181729 00000 n +0000181541 00000 n +0000002395 00000 n +0000198734 00000 n +0000198539 00000 n +0000003124 00000 n +0000209852 00000 n +0000209657 00000 n +0000003852 00000 n +0000004590 00000 n +0000004641 00000 n +0000004692 00000 n +0000215079 00000 n +0000214889 00000 n +0000004743 00000 n +0000005475 00000 n +0000005587 00000 n +0000228046 00000 n +0000227852 00000 n +0000005638 00000 n +0000243216 00000 n +0000243030 00000 n +0000006372 00000 n +0000007103 00000 n +0000250869 00000 n +0000250678 00000 n +0000007154 00000 n +0000007890 00000 n +0000260105 00000 n +0000259916 00000 n +0000007941 00000 n +0000008700 00000 n +0000308258 00000 n +0000008815 00000 n +0000308308 00000 n +0000010577 00000 n +0000010609 00000 n +0000304158 00000 n +0000020800 00000 n +0000010819 00000 n +0000010871 00000 n +0000012984 00000 n +0000013017 00000 n +0000013051 00000 n +0000013105 00000 n +0000013424 00000 n +0000013677 00000 n +0000014784 00000 n +0000014836 00000 n +0000016866 00000 n +0000016899 00000 n +0000016933 00000 n +0000016987 00000 n +0000017314 00000 n +0000017561 00000 n +0000018155 00000 n +0000018207 00000 n +0000018259 00000 n +0000018372 00000 n +0000266277 00000 n +0000266083 00000 n +0000018424 00000 n +0000019165 00000 n +0000019217 00000 n +0000019269 00000 n +0000019382 00000 n +0000020585 00000 n +0000020617 00000 n +0000020754 00000 n +0000304278 00000 n +0000027657 00000 n +0000020880 00000 n +0000020932 00000 n +0000022127 00000 n +0000022160 00000 n +0000022194 00000 n +0000022248 00000 n +0000022567 00000 n +0000022820 00000 n +0000023927 00000 n +0000023979 00000 n +0000024032 00000 n +0000024085 00000 n +0000024138 00000 n +0000024252 00000 n +0000024305 00000 n +0000024358 00000 n +0000024411 00000 n +0000024464 00000 n +0000024517 00000 n +0000024570 00000 n +0000024623 00000 n +0000024675 00000 n +0000024727 00000 n +0000024843 00000 n +0000024896 00000 n +0000269038 00000 n +0000268848 00000 n +0000024949 00000 n +0000025703 00000 n +0000027459 00000 n +0000027494 00000 n +0000027622 00000 n +0000304481 00000 n +0000036010 00000 n +0000027739 00000 n +0000027793 00000 n +0000029920 00000 n +0000029955 00000 n +0000029991 00000 n +0000030046 00000 n +0000030375 00000 n +0000030623 00000 n +0000031307 00000 n +0000031360 00000 n +0000032462 00000 n +0000032497 00000 n +0000032533 00000 n +0000032588 00000 n +0000032927 00000 n +0000033208 00000 n +0000033999 00000 n +0000034053 00000 n +0000034107 00000 n +0000034221 00000 n +0000034335 00000 n +0000034389 00000 n +0000034443 00000 n +0000034496 00000 n +0000035788 00000 n +0000035823 00000 n +0000035961 00000 n +0000304605 00000 n +0000041921 00000 n +0000036093 00000 n +0000036147 00000 n +0000036261 00000 n +0000271628 00000 n +0000271434 00000 n +0000036315 00000 n +0000275137 00000 n +0000274941 00000 n +0000037075 00000 n +0000276716 00000 n +0000276527 00000 n +0000037866 00000 n +0000038619 00000 n +0000038734 00000 n +0000038788 00000 n +0000038842 00000 n +0000041685 00000 n +0000041720 00000 n +0000304729 00000 n +0000045279 00000 n +0000041987 00000 n +0000042041 00000 n +0000042153 00000 n +0000042267 00000 n +0000042319 00000 n +0000042373 00000 n +0000042426 00000 n +0000042480 00000 n +0000042532 00000 n +0000042586 00000 n +0000045080 00000 n +0000045115 00000 n +0000305031 00000 n +0000068567 00000 n +0000045345 00000 n +0000045399 00000 n +0000062622 00000 n +0000062657 00000 n +0000062706 00000 n +0000063173 00000 n +0000062752 00000 n +0000063314 00000 n +0000063684 00000 n +0000063903 00000 n +0000067580 00000 n +0000063829 00000 n +0000068020 00000 n +0000067794 00000 n +0000068119 00000 n +0000068173 00000 n +0000068497 00000 n +0000068531 00000 n +0000305139 00000 n +0000077561 00000 n +0000068650 00000 n +0000068704 00000 n +0000072266 00000 n +0000072313 00000 n +0000072395 00000 n +0000072349 00000 n +0000072443 00000 n +0000073058 00000 n +0000072950 00000 n +0000073360 00000 n +0000075566 00000 n +0000075620 00000 n +0000075674 00000 n +0000075788 00000 n +0000075842 00000 n +0000075896 00000 n +0000077346 00000 n +0000077373 00000 n +0000077525 00000 n +0000305263 00000 n +0000081343 00000 n +0000077644 00000 n +0000077698 00000 n +0000077752 00000 n +0000077805 00000 n +0000077859 00000 n +0000077913 00000 n +0000077967 00000 n +0000078021 00000 n +0000279146 00000 n +0000278956 00000 n +0000078075 00000 n +0000078733 00000 n +0000081190 00000 n +0000305454 00000 n +0000085460 00000 n +0000081409 00000 n +0000081463 00000 n +0000081517 00000 n +0000081571 00000 n +0000081625 00000 n +0000081678 00000 n +0000081732 00000 n +0000081786 00000 n +0000081840 00000 n +0000081894 00000 n +0000281958 00000 n +0000281769 00000 n +0000081948 00000 n +0000082697 00000 n +0000085270 00000 n +0000305562 00000 n +0000089182 00000 n +0000085526 00000 n +0000085580 00000 n +0000085634 00000 n +0000085688 00000 n +0000085742 00000 n +0000085796 00000 n +0000085912 00000 n +0000086027 00000 n +0000086081 00000 n +0000088971 00000 n +0000089006 00000 n +0000305686 00000 n +0000094106 00000 n +0000089248 00000 n +0000089302 00000 n +0000089356 00000 n +0000284347 00000 n +0000284151 00000 n +0000089410 00000 n +0000090140 00000 n +0000090194 00000 n +0000090248 00000 n +0000090302 00000 n +0000090355 00000 n +0000090408 00000 n +0000090462 00000 n +0000090516 00000 n +0000090570 00000 n +0000090624 00000 n +0000090678 00000 n +0000090732 00000 n +0000090786 00000 n +0000090840 00000 n +0000090894 00000 n +0000090948 00000 n +0000091002 00000 n +0000091056 00000 n +0000093903 00000 n +0000305974 00000 n +0000097859 00000 n +0000094172 00000 n +0000094226 00000 n +0000094280 00000 n +0000094334 00000 n +0000094388 00000 n +0000094501 00000 n +0000094555 00000 n +0000094609 00000 n +0000094663 00000 n +0000094780 00000 n +0000094834 00000 n +0000097672 00000 n +0000097707 00000 n +0000306098 00000 n +0000101305 00000 n +0000097925 00000 n +0000097979 00000 n +0000098094 00000 n +0000098148 00000 n +0000098202 00000 n +0000098256 00000 n +0000098310 00000 n +0000098364 00000 n +0000098418 00000 n +0000098472 00000 n +0000101101 00000 n +0000101128 00000 n +0000306222 00000 n +0000104808 00000 n +0000101371 00000 n +0000101425 00000 n +0000101479 00000 n +0000101533 00000 n +0000101587 00000 n +0000101641 00000 n +0000101695 00000 n +0000101749 00000 n +0000101871 00000 n +0000101993 00000 n +0000104585 00000 n +0000104620 00000 n +0000306429 00000 n +0000107538 00000 n +0000104874 00000 n +0000104928 00000 n +0000104982 00000 n +0000105036 00000 n +0000105090 00000 n +0000105144 00000 n +0000107389 00000 n +0000306537 00000 n +0000111145 00000 n +0000107604 00000 n +0000107658 00000 n +0000107712 00000 n +0000107766 00000 n +0000107820 00000 n +0000107937 00000 n +0000107991 00000 n +0000110954 00000 n +0000110981 00000 n +0000306661 00000 n +0000114882 00000 n +0000111211 00000 n +0000111265 00000 n +0000111318 00000 n +0000111372 00000 n +0000111486 00000 n +0000111540 00000 n +0000111593 00000 n +0000111707 00000 n +0000111761 00000 n +0000111815 00000 n +0000114696 00000 n +0000114731 00000 n +0000306965 00000 n +0000118328 00000 n +0000114948 00000 n +0000115002 00000 n +0000115056 00000 n +0000115110 00000 n +0000115164 00000 n +0000115279 00000 n +0000115404 00000 n +0000115458 00000 n +0000115511 00000 n +0000115565 00000 n +0000118164 00000 n +0000118199 00000 n +0000307089 00000 n +0000121741 00000 n +0000118394 00000 n +0000118448 00000 n +0000118502 00000 n +0000118556 00000 n +0000118610 00000 n +0000118664 00000 n +0000118718 00000 n +0000118772 00000 n +0000118826 00000 n +0000121603 00000 n +0000307197 00000 n +0000125711 00000 n +0000121807 00000 n +0000121861 00000 n +0000121915 00000 n +0000121969 00000 n +0000122022 00000 n +0000122076 00000 n +0000122130 00000 n +0000122183 00000 n +0000122237 00000 n +0000122353 00000 n +0000122466 00000 n +0000122520 00000 n +0000122574 00000 n +0000125536 00000 n +0000125571 00000 n +0000307404 00000 n +0000134922 00000 n +0000125777 00000 n +0000125831 00000 n +0000128207 00000 n +0000128243 00000 n +0000128290 00000 n +0000128326 00000 n +0000128362 00000 n +0000128867 00000 n +0000128444 00000 n +0000128398 00000 n +0000128895 00000 n +0000128997 00000 n +0000128492 00000 n +0000129653 00000 n +0000129554 00000 n +0000129112 00000 n +0000129248 00000 n +0000129335 00000 n +0000129443 00000 n +0000129926 00000 n +0000132256 00000 n +0000132310 00000 n +0000132364 00000 n +0000132417 00000 n +0000132470 00000 n +0000132524 00000 n +0000132578 00000 n +0000132632 00000 n +0000132686 00000 n +0000134744 00000 n +0000134886 00000 n +0000307512 00000 n +0000139499 00000 n +0000135005 00000 n +0000135059 00000 n +0000135113 00000 n +0000135166 00000 n +0000135220 00000 n +0000135273 00000 n +0000135389 00000 n +0000135504 00000 n +0000135558 00000 n +0000135675 00000 n +0000135792 00000 n +0000135846 00000 n +0000135963 00000 n +0000136080 00000 n +0000136134 00000 n +0000139290 00000 n +0000139357 00000 n +0000307719 00000 n +0000148742 00000 n +0000139565 00000 n +0000139619 00000 n +0000139736 00000 n +0000139789 00000 n +0000139843 00000 n +0000288181 00000 n +0000287987 00000 n +0000139897 00000 n +0000140601 00000 n +0000140718 00000 n +0000140772 00000 n +0000140825 00000 n +0000140879 00000 n +0000140933 00000 n +0000141050 00000 n +0000289977 00000 n +0000289789 00000 n +0000141104 00000 n +0000141843 00000 n +0000292177 00000 n +0000291989 00000 n +0000141897 00000 n +0000297149 00000 n +0000296954 00000 n +0000142628 00000 n +0000300491 00000 n +0000300295 00000 n +0000143365 00000 n +0000301958 00000 n +0000301764 00000 n +0000144106 00000 n +0000144797 00000 n +0000148479 00000 n +0000148522 00000 n +0000307843 00000 n +0000152882 00000 n +0000148808 00000 n +0000148862 00000 n +0000148979 00000 n +0000149033 00000 n +0000149087 00000 n +0000149204 00000 n +0000149257 00000 n +0000149310 00000 n +0000149456 00000 n +0000149564 00000 n +0000149618 00000 n +0000149739 00000 n +0000149848 00000 n +0000152703 00000 n +0000152754 00000 n +0000304936 00000 n +0000304400 00000 n +0000304853 00000 n +0000305877 00000 n +0000305371 00000 n +0000305794 00000 n +0000306868 00000 n +0000306346 00000 n +0000306785 00000 n +0000308050 00000 n +0000307321 00000 n +0000307636 00000 n +0000307967 00000 n +0000308428 00000 n +0000308451 00000 n +0000308580 00000 n +0000308709 00000 n +0000308838 00000 n +0000308967 00000 n +0000309064 00000 n +0000309188 00000 n +0000309312 00000 n +0000309436 00000 n +0000309580 00000 n +0000309675 00000 n +0000309801 00000 n +0000309950 00000 n +0000310084 00000 n +0000310218 00000 n +0000310315 00000 n +0000310449 00000 n +0000310580 00000 n +0000310714 00000 n +0000310870 00000 n +0000310969 00000 n +0000311067 00000 n +0000311199 00000 n +0000311333 00000 n +0000311467 00000 n +0000311601 00000 n +0000311700 00000 n +0000311832 00000 n +0000311966 00000 n +0000312099 00000 n +0000312255 00000 n +0000312353 00000 n +0000312487 00000 n +0000312619 00000 n +0000312753 00000 n +0000312885 00000 n +0000312983 00000 n +0000313117 00000 n +0000313251 00000 n +0000313385 00000 n +0000313527 00000 n +0000313623 00000 n +0000313719 00000 n +0000313837 00000 n +0000313956 00000 n +0000314066 00000 n +0000314180 00000 n +0000314272 00000 n +0000314386 00000 n +0000314497 00000 n +0000314611 00000 n +0000314740 00000 n +0000314830 00000 n +0000314939 00000 n +0000315048 00000 n +0000315177 00000 n +0000315300 00000 n +0000315392 00000 n +0000315516 00000 n +0000315653 00000 n +0000315800 00000 n +0000315974 00000 n +0000316074 00000 n +0000316173 00000 n +0000316322 00000 n +0000316471 00000 n +0000316620 00000 n +0000316769 00000 n +0000316874 00000 n +0000317023 00000 n +0000317172 00000 n +0000317321 00000 n +0000317495 00000 n +0000317600 00000 n +0000317771 00000 n +0000317944 00000 n +0000318118 00000 n +0000318292 00000 n +0000318407 00000 n +0000318581 00000 n +0000318755 00000 n +0000318929 00000 n +0000319133 00000 n +0000319248 00000 n +0000319358 00000 n +0000319420 00000 n +0000319440 00000 n +trailer +<< +/Size 625 +/Root 2 0 R +/Info 1 0 R +>> +startxref +319576 +%%EOF diff --git a/books/PRML/PRML最全资料集合/prml-errata-3rd-20110921.pdf b/books/PRML/PRML最全资料集合/prml-errata-3rd-20110921.pdf new file mode 100755 index 0000000..0d2882d Binary files /dev/null and b/books/PRML/PRML最全资料集合/prml-errata-3rd-20110921.pdf differ diff --git a/books/PRML/模式识别与机器学习PRML_Chinese_vision.pdf b/books/PRML/模式识别与机器学习PRML_Chinese_vision.pdf new file mode 100755 index 0000000..50f0048 Binary files /dev/null and b/books/PRML/模式识别与机器学习PRML_Chinese_vision.pdf differ diff --git a/books/Reinforcement Learning.Sutton.pdf b/books/Reinforcement Learning.Sutton.pdf new file mode 100755 index 0000000..3df0323 Binary files /dev/null and b/books/Reinforcement Learning.Sutton.pdf differ diff --git a/books/Semi-Supervised Learning with Graphs.pdf b/books/Semi-Supervised Learning with Graphs.pdf new file mode 100755 index 0000000..e1ecf06 Binary files /dev/null and b/books/Semi-Supervised Learning with Graphs.pdf differ diff --git a/books/Special Structure (v6).pdf b/books/Special Structure (v6).pdf new file mode 100755 index 0000000..9454487 Binary files /dev/null and b/books/Special Structure (v6).pdf differ diff --git a/books/Tensorflow 实战Google深度学习框架.pdf b/books/Tensorflow 实战Google深度学习框架.pdf new file mode 100755 index 0000000..621b5db Binary files /dev/null and b/books/Tensorflow 实战Google深度学习框架.pdf differ diff --git a/books/[201810]Deep Reinforcement Learning.pdf b/books/[201810]Deep Reinforcement Learning.pdf new file mode 100755 index 0000000..45d3a1b Binary files /dev/null and b/books/[201810]Deep Reinforcement Learning.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Assignment #1.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Assignment #1.pdf new file mode 100755 index 0000000..5555528 Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Assignment #1.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Assignment #2.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Assignment #2.pdf new file mode 100755 index 0000000..4478700 Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Assignment #2.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/CourseNotes.pdf b/books/[DL-CS231][2018][Fei-fei Li]/CourseNotes.pdf new file mode 100755 index 0000000..2198409 Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/CourseNotes.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Module 0_Preparation_0_Setup Instructions.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Module 0_Preparation_0_Setup Instructions.pdf new file mode 100755 index 0000000..72ebcd0 Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Module 0_Preparation_0_Setup Instructions.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Module 0_Preparation_1_Python Numpy Tutorial.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Module 0_Preparation_1_Python Numpy Tutorial.pdf new file mode 100755 index 0000000..932188f Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Module 0_Preparation_1_Python Numpy Tutorial.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Module 0_Preparation_2_IPython Tutorial.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Module 0_Preparation_2_IPython Tutorial.pdf new file mode 100755 index 0000000..46add38 Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Module 0_Preparation_2_IPython Tutorial.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Module 0_Preparation_3_Google Cloud Tutorial.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Module 0_Preparation_3_Google Cloud Tutorial.pdf new file mode 100755 index 0000000..5574fec Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Module 0_Preparation_3_Google Cloud Tutorial.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Module 0_Preparation_4_AWS Tutorial.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Module 0_Preparation_4_AWS Tutorial.pdf new file mode 100755 index 0000000..7b2ef74 Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Module 0_Preparation_4_AWS Tutorial.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_0_Image Classification.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_0_Image Classification.pdf new file mode 100755 index 0000000..1949fe3 Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_0_Image Classification.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_1_Linear Classification.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_1_Linear Classification.pdf new file mode 100755 index 0000000..0c9fc50 Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_1_Linear Classification.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_2_Backpropagation.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_2_Backpropagation.pdf new file mode 100755 index 0000000..6416e8e Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_2_Backpropagation.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_3_Optimization.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_3_Optimization.pdf new file mode 100755 index 0000000..b0c31f7 Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_3_Optimization.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_4_Neural Networks Part 1.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_4_Neural Networks Part 1.pdf new file mode 100755 index 0000000..ac6097d Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_4_Neural Networks Part 1.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_4_Neural Networks Part 2.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_4_Neural Networks Part 2.pdf new file mode 100755 index 0000000..9d3ba4f Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_4_Neural Networks Part 2.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_4_Neural Networks Part 3.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_4_Neural Networks Part 3.pdf new file mode 100755 index 0000000..75c0190 Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_4_Neural Networks Part 3.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_5_Putting it together.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_5_Putting it together.pdf new file mode 100755 index 0000000..80cc409 Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Module 1_Neural Networks_5_Putting it together.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Module 2_Convolutional Neural Networks_0_Convolutional Neural Networks.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Module 2_Convolutional Neural Networks_0_Convolutional Neural Networks.pdf new file mode 100755 index 0000000..838e38f Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Module 2_Convolutional Neural Networks_0_Convolutional Neural Networks.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Module 2_Convolutional Neural Networks_1_Understanding and Visualizing Convolutional Neural Networks.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Module 2_Convolutional Neural Networks_1_Understanding and Visualizing Convolutional Neural Networks.pdf new file mode 100755 index 0000000..a2563f8 Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Module 2_Convolutional Neural Networks_1_Understanding and Visualizing Convolutional Neural Networks.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/Module 2_Convolutional Neural Networks_2_Transfer Learning and Fine-tuning Convolutional Neural Networks.pdf b/books/[DL-CS231][2018][Fei-fei Li]/Module 2_Convolutional Neural Networks_2_Transfer Learning and Fine-tuning Convolutional Neural Networks.pdf new file mode 100755 index 0000000..fa8b00d Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/Module 2_Convolutional Neural Networks_2_Transfer Learning and Fine-tuning Convolutional Neural Networks.pdf differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/python_numpy_tutorial.ipynb.txt b/books/[DL-CS231][2018][Fei-fei Li]/python_numpy_tutorial.ipynb.txt new file mode 100755 index 0000000..8c149fd --- /dev/null +++ b/books/[DL-CS231][2018][Fei-fei Li]/python_numpy_tutorial.ipynb.txt @@ -0,0 +1,1503 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CS 231n Python & NumPy Tutorial" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Python 3 and NumPy will be used extensively throughout this course, so it's important to be familiar with them. \n", + "\n", + "A good amount of the material in this notebook comes from Justin Johnson's Python & NumPy Tutorial:\n", + "http://cs231n.github.io/python-numpy-tutorial/. At this moment, not everything from that tutorial is in this notebook and not everything from this notebook is in the tutorial." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Python 3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you're unfamiliar with Python 3, here are some of the most common changes from Python 2 to look out for." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Print is a function" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello!\n" + ] + } + ], + "source": [ + "print(\"Hello!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Without parentheses, printing will not work." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "Missing parentheses in call to 'print'. Did you mean print(\"Hello!\")? (, line 1)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m print \"Hello!\"\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m Missing parentheses in call to 'print'. Did you mean print(\"Hello!\")?\n" + ] + } + ], + "source": [ + "print \"Hello!\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Floating point division by default" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.5" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "5 / 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To do integer division, we use two backslashes:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "5 // 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### No xrange" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The xrange from Python 2 is now merged into \"range\" for Python 3 and there is no xrange in Python 3. In Python 3, range(3) does not create a list of 3 elements as it would in Python 2, rather just creates a more memory efficient iterator.\n", + "\n", + "Hence, \n", + "xrange in Python 3: Does not exist \n", + "range in Python 3: Has very similar behavior to Python 2's xrange" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n" + ] + } + ], + "source": [ + "for i in range(3):\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "range(0, 3)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "range(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2]\n" + ] + } + ], + "source": [ + "# If need be, can use the following to get a similar behavior to Python 2's range:\n", + "print(list(range(3)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# NumPy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"NumPy is the fundamental package for scientific computing in Python. It is a Python library that provides a multidimensional array object, various derived objects (such as masked arrays and matrices), and an assortment of routines for fast operations on arrays, including mathematical, logical, shape manipulation, sorting, selecting, I/O, discrete Fourier transforms, basic linear algebra, basic statistical operations, random simulation and much more\" \n", + "-https://docs.scipy.org/doc/numpy-1.10.1/user/whatisnumpy.html." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's run through an example showing how powerful NumPy is. Suppose we have two lists a and b, consisting of the first 100,000 non-negative numbers, and we want to create a new list c whose *i*th element is a[i] + 2 * b[i]. \n", + "\n", + "Without NumPy:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 13.6 ms, sys: 10.4 ms, total: 24 ms\n", + "Wall time: 23.4 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "a = [i for i in range(100000)]\n", + "b = [i for i in range(100000)]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 52 ms, sys: 7.44 ms, total: 59.4 ms\n", + "Wall time: 60.5 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "c = []\n", + "for i in range(len(a)):\n", + " c.append(a[i] + 2 * b[i])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With NumPy:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 3.62 ms, sys: 3.42 ms, total: 7.04 ms\n", + "Wall time: 4.85 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "a = np.arange(100000)\n", + "b = np.arange(100000)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 6.53 ms, sys: 6.13 ms, total: 12.7 ms\n", + "Wall time: 9.37 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "c = a + 2 * b" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The result is 10 to 15 times faster, and we could do it in fewer lines of code (and the code itself is more intuitive)!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Regular Python is much slower due to type checking and other overhead of needing to interpret code and support Python's abstractions.\n", + "\n", + "For example, if we are doing some addition in a loop, constantly type checking in a loop will lead to many more instructions than just performing a regular addition operation. NumPy, using optimized pre-compiled C code, is able to avoid a lot of the overhead introduced.\n", + "\n", + "The process we used above is **vectorization**. Vectorization refers to applying operations to arrays instead of just individual elements (i.e. no loops)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Why vectorize?\n", + "1. Much faster\n", + "2. Easier to read and fewer lines of code\n", + "3. More closely assembles mathematical notation\n", + "\n", + "Vectorization is one of the main reasons why NumPy is so powerful." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ndarray" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ndarrays, n-dimensional arrays of homogenous data type, are the fundamental datatype used in NumPy. As these arrays are of the same type and are fixed size at creation, they offer less flexibility than Python lists, but can be substantially more efficient runtime and memory-wise. (Python lists are arrays of pointers to objects, adding a layer of indirection.)\n", + "\n", + "The number of dimensions is the rank of the array; the shape of an array is a tuple of integers giving the size of the array along each dimension." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "(3,)\n", + "1 2 3\n", + "[5 2 3]\n", + "(2, 3)\n", + "1 2 4\n" + ] + } + ], + "source": [ + "# Can initialize ndarrays with Python lists, for example:\n", + "a = np.array([1, 2, 3]) # Create a rank 1 array\n", + "print(type(a)) # Prints \"\"\n", + "print(a.shape) # Prints \"(3,)\"\n", + "print(a[0], a[1], a[2]) # Prints \"1 2 3\"\n", + "a[0] = 5 # Change an element of the array\n", + "print(a) # Prints \"[5, 2, 3]\"\n", + "\n", + "b = np.array([[1, 2, 3],\n", + " [4, 5, 6]]) # Create a rank 2 array\n", + "print(b.shape) # Prints \"(2, 3)\"\n", + "print(b[0, 0], b[0, 1], b[1, 0]) # Prints \"1 2 4\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are many other initializations that NumPy provides:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0. 0.]\n", + " [0. 0.]]\n", + "[[7 7]\n", + " [7 7]]\n", + "[[1. 0.]\n", + " [0. 1.]]\n", + "[[0.17511952 0.67921684]\n", + " [0.04555329 0.08641358]]\n" + ] + } + ], + "source": [ + "a = np.zeros((2, 2)) # Create an array of all zeros\n", + "print(a) # Prints \"[[ 0. 0.]\n", + " # [ 0. 0.]]\"\n", + "\n", + "b = np.full((2, 2), 7) # Create a constant array\n", + "print(b) # Prints \"[[ 7. 7.]\n", + " # [ 7. 7.]]\"\n", + "\n", + "c = np.eye(2) # Create a 2 x 2 identity matrix\n", + "print(c) # Prints \"[[ 1. 0.]\n", + " # [ 0. 1.]]\"\n", + "\n", + "d = np.random.random((2, 2)) # Create an array filled with random values\n", + "print(d) # Might print \"[[ 0.91940167 0.08143941]\n", + " # [ 0.68744134 0.87236687]]\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "How do we create a 2 by 2 matrix of ones?" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1. 1.]\n", + " [1. 1.]]\n" + ] + } + ], + "source": [ + "a = np.ones((2, 2)) # Create an array of all ones\n", + "print(a) # Prints \"[[ 1. 1.]\n", + " # [ 1. 1.]]\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Useful to keep track of shape; helpful for debugging and knowing dimensions will be very useful when computing gradients, among other reasons." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0 1 2 3 4 5 6 7]\n", + "(8,)\n", + "Reshaped:\n", + " [[0 1 2 3]\n", + " [4 5 6 7]]\n", + "(2, 4)\n", + "Reshaped with -1:\n", + " [[0 1]\n", + " [2 3]\n", + " [4 5]\n", + " [6 7]]\n", + "(4, 2)\n" + ] + } + ], + "source": [ + "nums = np.arange(8)\n", + "print(nums)\n", + "print(nums.shape)\n", + "\n", + "nums = nums.reshape((2, 4))\n", + "print('Reshaped:\\n', nums)\n", + "print(nums.shape)\n", + "\n", + "# The -1 in reshape corresponds to an unknown dimension that numpy will figure out,\n", + "# based on all other dimensions and the array size.\n", + "# Can only specify one unknown dimension.\n", + "# For example, sometimes we might have an unknown number of data points, and\n", + "# so we can use -1 instead without worrying about the true number.\n", + "nums = nums.reshape((4, -1))\n", + "print('Reshaped with -1:\\n', nums)\n", + "print(nums.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "NumPy supports an object-oriented paradigm, such that ndarray has a number of methods and attributes, with functions similar to ones in the outermost NumPy namespace. For example, we can do both:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "0\n" + ] + } + ], + "source": [ + "nums = np.arange(8)\n", + "print(nums.min()) # Prints 0\n", + "print(np.min(nums)) # Prints 0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Array Operations/Math" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "NumPy supports many elementwise operations:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 6. 8.]\n", + " [10. 12.]]\n", + "[[ 6. 8.]\n", + " [10. 12.]]\n", + "[[-4. -4.]\n", + " [-4. -4.]]\n", + "[[-4. -4.]\n", + " [-4. -4.]]\n", + "[[ 5. 12.]\n", + " [21. 32.]]\n", + "[[ 5. 12.]\n", + " [21. 32.]]\n", + "[[1. 1.41421356]\n", + " [1.73205081 2. ]]\n" + ] + } + ], + "source": [ + "x = np.array([[1, 2],\n", + " [3, 4]], dtype=np.float64)\n", + "y = np.array([[5, 6],\n", + " [7, 8]], dtype=np.float64)\n", + "\n", + "# Elementwise sum; both produce the array\n", + "# [[ 6.0 8.0]\n", + "# [10.0 12.0]]\n", + "print(x + y)\n", + "print(np.add(x, y))\n", + "\n", + "# Elementwise difference; both produce the array\n", + "# [[-4.0 -4.0]\n", + "# [-4.0 -4.0]]\n", + "print(x - y)\n", + "print(np.subtract(x, y))\n", + "\n", + "# Elementwise product; both produce the array\n", + "# [[ 5.0 12.0]\n", + "# [21.0 32.0]]\n", + "print(x * y)\n", + "print(np.multiply(x, y))\n", + "\n", + "# Elementwise square root; produces the array\n", + "# [[ 1. 1.41421356]\n", + "# [ 1.73205081 2. ]]\n", + "print(np.sqrt(x))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "How do we elementwise divide between two arrays?" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0.2 0.33333333]\n", + " [0.42857143 0.5 ]]\n", + "[[0.2 0.33333333]\n", + " [0.42857143 0.5 ]]\n" + ] + } + ], + "source": [ + "x = np.array([[1, 2], [3, 4]], dtype=np.float64)\n", + "y = np.array([[5, 6], [7, 8]], dtype=np.float64)\n", + "\n", + "# Elementwise division; both produce the array\n", + "# [[ 0.2 0.33333333]\n", + "# [ 0.42857143 0.5 ]]\n", + "print(x / y)\n", + "print(np.divide(x, y))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note * is elementwise multiplication, not matrix multiplication. We instead use the dot function to compute inner products of vectors, to multiply a vector by a matrix, and to multiply matrices. dot is available both as a function in the numpy module and as an instance method of array objects:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "219\n", + "219\n", + "[29 67]\n", + "[29 67]\n", + "[[19 22]\n", + " [43 50]]\n", + "[[19 22]\n", + " [43 50]]\n" + ] + } + ], + "source": [ + "x = np.array([[1, 2], [3, 4]])\n", + "y = np.array([[5, 6], [7, 8]])\n", + "\n", + "v = np.array([9, 10])\n", + "w = np.array([11, 12])\n", + "\n", + "# Inner product of vectors; both produce 219\n", + "print(v.dot(w))\n", + "print(np.dot(v, w))\n", + "\n", + "# Matrix / vector product; both produce the rank 1 array [29 67]\n", + "print(x.dot(v))\n", + "print(np.dot(x, v))\n", + "\n", + "# Matrix / matrix product; both produce the rank 2 array\n", + "# [[19 22]\n", + "# [43 50]]\n", + "print(x.dot(y))\n", + "print(np.dot(x, y))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are many useful functions built into NumPy, and often we're able to express them across specific axes of the ndarray:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n", + "[5 7 9]\n", + "[ 6 15]\n", + "[3 6]\n" + ] + } + ], + "source": [ + "x = np.array([[1, 2, 3], \n", + " [4, 5, 6]])\n", + "\n", + "print(np.sum(x)) # Compute sum of all elements; prints \"21\"\n", + "print(np.sum(x, axis=0)) # Compute sum of each column; prints \"[5 7 9]\"\n", + "print(np.sum(x, axis=1)) # Compute sum of each row; prints \"[6 15]\"\n", + "\n", + "print(np.max(x, axis=1)) # Compute max of each row; prints \"[3 6]\" " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "How can we compute the index of the max value of each row? Useful, to say, find the class that corresponds to the maximum score for an input image." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2 2]\n" + ] + } + ], + "source": [ + "x = np.array([[1, 2, 3], \n", + " [4, 5, 6]])\n", + "\n", + "print(np.argmax(x, axis=1)) # Compute index of max of each row; prints \"[2 2]\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note the axis you apply the operation will have its dimension removed from the shape.\n", + "This is useful to keep in mind when you're trying to figure out what axis corresponds\n", + "to what.\n", + "\n", + "For example:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 3)\n", + "(3,)\n", + "[[[ 1 2 3]\n", + " [ 4 5 6]]\n", + "\n", + " [[10 23 33]\n", + " [43 52 16]]]\n", + "(2, 2, 3)\n", + "(2, 3)\n", + "[ 6 52]\n", + "(2,)\n" + ] + } + ], + "source": [ + "x = np.array([[1, 2, 3], \n", + " [4, 5, 6]])\n", + "\n", + "print(x.shape) # Has shape (2, 3)\n", + "print((x.max(axis=0)).shape) # Taking the max over axis 0 has shape (3,)\n", + " # corresponding to the 3 columns.\n", + "\n", + "# An array with rank 3\n", + "x = np.array([[[1, 2, 3], \n", + " [4, 5, 6]],\n", + " [[10, 23, 33], \n", + " [43, 52, 16]]\n", + " ])\n", + "\n", + "print(x)\n", + "print(x.shape) # Has shape (2, 2, 3)\n", + "print((x.max(axis=1)).shape) # Taking the max over axis 1 has shape (2, 3)\n", + "\n", + "print((x.max(axis=(1, 2)))) # Can take max over multiple axes; prints [6 52]\n", + "print((x.max(axis=(1, 2))).shape) # Taking the max over axes 1, 2 has shape (2,)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Indexing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "NumPy also provides powerful indexing schemes." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original:\n", + " [[ 1 2 3 4]\n", + " [ 5 6 7 8]\n", + " [ 9 10 11 12]]\n", + "Element (0, 0) (a[0][0]):\n", + " 1\n", + "Element (0, 0) (a[0, 0]) :\n", + " 1\n", + "Sliced (a[:2, 1:3]):\n", + " [[2 3]\n", + " [6 7]]\n", + "Reversing the first row (a[0, ::-1]) :\n", + " [4 3 2 1]\n" + ] + } + ], + "source": [ + "# Create the following rank 2 array with shape (3, 4)\n", + "# [[ 1 2 3 4]\n", + "# [ 5 6 7 8]\n", + "# [ 9 10 11 12]]\n", + "a = np.array([[1, 2, 3, 4],\n", + " [5, 6, 7, 8],\n", + " [9, 10, 11, 12]])\n", + "print('Original:\\n', a)\n", + "\n", + "# Can select an element as you would in a 2 dimensional Python list\n", + "print('Element (0, 0) (a[0][0]):\\n', a[0][0]) # Prints 1\n", + "# or as follows\n", + "print('Element (0, 0) (a[0, 0]) :\\n', a[0, 0]) # Prints 1\n", + "\n", + "# Use slicing to pull out the subarray consisting of the first 2 rows\n", + "# and columns 1 and 2; b is the following array of shape (2, 2):\n", + "# [[2 3]\n", + "# [6 7]]\n", + "b = a[:2, 1:3]\n", + "print('Sliced (a[:2, 1:3]):\\n', b)\n", + "\n", + "# Steps are also supported in indexing. The following reverses the first row:\n", + "print('Reversing the first row (a[0, ::-1]) :\\n', a[0, ::-1]) # Prints [4 3 2 1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Often, it's useful to select or modify one element from each row of a matrix. The following example employs **fancy indexing**, where we index into our array using an array of indices (say an array of integers or booleans):" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 1 2 3]\n", + " [ 4 5 6]\n", + " [ 7 8 9]\n", + " [10 11 12]]\n", + "[ 1 6 7 11]\n", + "[[11 2 3]\n", + " [ 4 5 16]\n", + " [17 8 9]\n", + " [10 21 12]]\n" + ] + } + ], + "source": [ + "# Create a new array from which we will select elements\n", + "a = np.array([[1, 2, 3],\n", + " [4, 5, 6],\n", + " [7, 8, 9],\n", + " [10, 11, 12]])\n", + "\n", + "print(a) # prints \"array([[ 1, 2, 3],\n", + " # [ 4, 5, 6],\n", + " # [ 7, 8, 9],\n", + " # [10, 11, 12]])\"\n", + "\n", + "# Create an array of indices\n", + "b = np.array([0, 2, 0, 1])\n", + "\n", + "# Select one element from each row of a using the indices in b\n", + "print(a[np.arange(4), b]) # Prints \"[ 1 6 7 11]\"\n", + "\n", + "# Mutate one element from each row of a using the indices in b\n", + "a[np.arange(4), b] += 10\n", + "\n", + "print(a) # prints \"array([[11, 2, 3],\n", + " # [ 4, 5, 16],\n", + " # [17, 8, 9],\n", + " # [10, 21, 12]])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also use boolean indexing/masks. Suppose we want to set all elements greater than MAX to MAX:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[False False True False True False False]\n", + "[ 1 4 5 -1 5 0 5]\n" + ] + } + ], + "source": [ + "MAX = 5\n", + "nums = np.array([1, 4, 10, -1, 15, 0, 5])\n", + "print(nums > MAX) # Prints [False, False, True, False, True, False, False]\n", + "\n", + "nums[nums > MAX] = MAX\n", + "print(nums) # Prints [1, 4, 5, -1, 5, 0, 5]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, note that the indices in fancy indexing can appear in any order and even multiple times:" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 4 10 -1 4 1]\n" + ] + } + ], + "source": [ + "nums = np.array([1, 4, 10, -1, 15, 0, 5])\n", + "print(nums[[1, 2, 3, 1, 0]]) # Prints [4 10 -1 4 1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Broadcasting" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Many of the operations we've looked at above involved arrays of the same rank. \n", + "However, many times we might have a smaller array and use that multiple times to update an array of a larger rank. \n", + "For example, consider the below example of shifting the mean of each column from the elements of the corresponding column:" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 3)\n", + "[2. 3.5 5. ]\n", + "(3,)\n", + "\n", + " [[-1. -1.5 -2. ]\n", + " [ 1. 1.5 2. ]]\n", + "(2, 3)\n" + ] + } + ], + "source": [ + "x = np.array([[1, 2, 3],\n", + " [3, 5, 7]])\n", + "print(x.shape) # Prints (2, 3)\n", + "\n", + "col_means = x.mean(axis=0)\n", + "print(col_means) # Prints [2. 3.5 5.]\n", + "print(col_means.shape) # Prints (3,)\n", + " # Has a smaller rank than x!\n", + "\n", + "mean_shifted = x - col_means\n", + "print('\\n', mean_shifted)\n", + "print(mean_shifted.shape) # Prints (2, 3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Or even just multiplying a matrix by 2:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 2 4 6]\n", + " [ 6 10 14]]\n" + ] + } + ], + "source": [ + "x = np.array([[1, 2, 3],\n", + " [3, 5, 7]])\n", + "print(x * 2) # Prints [[ 2 4 6]\n", + " # [ 6 10 14]]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Broadcasting two arrays together follows these rules:\n", + "\n", + "1. If the arrays do not have the same rank, prepend the shape of the lower rank array with 1s until both shapes have the same length.\n", + "2. The two arrays are said to be compatible in a dimension if they have the same size in the dimension, or if one of the arrays has size 1 in that dimension.\n", + "3. The arrays can be broadcast together if they are compatible in all dimensions.\n", + "4. After broadcasting, each array behaves as if it had shape equal to the elementwise maximum of shapes of the two input arrays.\n", + "5. In any dimension where one array had size 1 and the other array had size greater than 1, the first array behaves as if it were copied along that dimension." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For example, when subtracting the columns above, we had arrays of shape (2, 3) and (3,).\n", + "\n", + "1. These arrays do not have same rank, so we prepend the shape of the lower rank one to make it (1, 3).\n", + "2. (2, 3) and (1, 3) are compatible (have the same size in the dimension, or if one of the arrays has size 1 in that dimension).\n", + "3. Can be broadcast together!\n", + "4. After broadcasting, each array behaves as if it had shape equal to (2, 3).\n", + "5. The smaller array will behave as if it were copied along dimension 0." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's try to subtract the mean of each row!" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2. 5.]\n" + ] + }, + { + "ename": "ValueError", + "evalue": "operands could not be broadcast together with shapes (2,3) (2,) ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrow_means\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Prints [2. 5.]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mmean_shifted\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mrow_means\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (2,3) (2,) " + ] + } + ], + "source": [ + "x = np.array([[1, 2, 3],\n", + " [3, 5, 7]])\n", + "\n", + "row_means = x.mean(axis=1)\n", + "print(row_means) # Prints [2. 5.]\n", + "\n", + "mean_shifted = x - row_means" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To figure out what's wrong, we print some shapes:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 3)\n", + "[2. 5.]\n", + "(2,)\n" + ] + }, + { + "ename": "ValueError", + "evalue": "operands could not be broadcast together with shapes (2,3) (2,) ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;31m# Results in the following error: ValueError: operands could not be broadcast together with shapes (2,3) (2,)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mmean_shifted\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mrow_means\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (2,3) (2,) " + ] + } + ], + "source": [ + "x = np.array([[1, 2, 3],\n", + " [3, 5, 7]])\n", + "print(x.shape) # Prints (2, 3)\n", + "\n", + "row_means = x.mean(axis=1)\n", + "print(row_means) # Prints [2. 5.]\n", + "print(row_means.shape) # Prints (2,)\n", + "\n", + "# Results in the following error: ValueError: operands could not be broadcast together with shapes (2,3) (2,) \n", + "mean_shifted = x - row_means" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What happened?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Answer: If we following broadcasting rule 1, then we'd prepend a 1 to the smaller rank array ot get (1, 2). However, the last dimensions don't match now between (2, 3) and (1, 2), and so we can't broadcast." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Take 2, reshaping the row means to get the desired behavior:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 3)\n", + "[[2.]\n", + " [5.]]\n", + "(2, 1)\n", + "[[-1. 0. 1.]\n", + " [-2. 0. 2.]]\n", + "(2, 3)\n" + ] + } + ], + "source": [ + "x = np.array([[1, 2, 3],\n", + " [3, 5, 7]])\n", + "print(x.shape) # Prints (2, 3)\n", + "\n", + "row_means = x.mean(axis=1).reshape((-1, 1))\n", + "print(row_means) # Prints [[2.], [5.]]\n", + "print(row_means.shape) # Prints (2, 1)\n", + "\n", + "mean_shifted = x - row_means\n", + "print(mean_shifted)\n", + "print(mean_shifted.shape) # Prints (2, 3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "More broadcasting examples!" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 4 5]\n", + " [ 8 10]\n", + " [12 15]]\n", + "[[2 4 6]\n", + " [5 7 9]]\n", + "[[ 5 6 7]\n", + " [ 9 10 11]]\n", + "[[ 5 6 7]\n", + " [ 9 10 11]]\n" + ] + } + ], + "source": [ + "# Compute outer product of vectors\n", + "v = np.array([1, 2, 3]) # v has shape (3,)\n", + "w = np.array([4, 5]) # w has shape (2,)\n", + "# To compute an outer product, we first reshape v to be a column\n", + "# vector of shape (3, 1); we can then broadcast it against w to yield\n", + "# an output of shape (3, 2), which is the outer product of v and w:\n", + "# [[ 4 5]\n", + "# [ 8 10]\n", + "# [12 15]]\n", + "print(np.reshape(v, (3, 1)) * w)\n", + "\n", + "# Add a vector to each row of a matrix\n", + "x = np.array([[1, 2, 3], [4, 5, 6]])\n", + "# x has shape (2, 3) and v has shape (3,) so they broadcast to (2, 3),\n", + "# giving the following matrix:\n", + "# [[2 4 6]\n", + "# [5 7 9]]\n", + "print(x + v)\n", + "\n", + "# Add a vector to each column of a matrix\n", + "# x has shape (2, 3) and w has shape (2,).\n", + "# If we transpose x then it has shape (3, 2) and can be broadcast\n", + "# against w to yield a result of shape (3, 2); transposing this result\n", + "# yields the final result of shape (2, 3) which is the matrix x with\n", + "# the vector w added to each column. Gives the following matrix:\n", + "# [[ 5 6 7]\n", + "# [ 9 10 11]]\n", + "print((x.T + w).T)\n", + "# Another solution is to reshape w to be a column vector of shape (2, 1);\n", + "# we can then broadcast it directly against x to produce the same\n", + "# output.\n", + "print(x + np.reshape(w, (2, 1)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Views vs. Copies" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "Unlike a copy, in a **view** of an array, the data is shared between the view and the array. Sometimes, our results are copies of arrays, but other times they can be views. Understanding when each is generated is important to avoid any unforeseen issues.\n", + "\n", + "Views can be created from a slice of an array, changing the dtype of the same data area (using arr.view(dtype), not the result of arr.astype(dtype)), or even both." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original:\n", + " [0 1 2 3 4]\n", + "Array After Modified View:\n", + " [ 0 1 -1 3 4]\n" + ] + } + ], + "source": [ + "x = np.arange(5)\n", + "print('Original:\\n', x) # Prints [0 1 2 3 4]\n", + "\n", + "# Modifying the view will modify the array\n", + "view = x[1:3]\n", + "view[1] = -1\n", + "print('Array After Modified View:\\n', x) # Prints [0 1 -1 3 4]" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "View Before Array Modification:\n", + " [ 1 -1]\n", + "Array After Modifications:\n", + " [ 0 1 10 3 4]\n", + "View After Array Modification:\n", + " [ 1 10]\n" + ] + } + ], + "source": [ + "x = np.arange(5)\n", + "view = x[1:3]\n", + "view[1] = -1\n", + "\n", + "# Modifying the array will modify the view\n", + "print('View Before Array Modification:\\n', view) # Prints [1 -1]\n", + "x[2] = 10\n", + "print('Array After Modifications:\\n', x) # Prints [0 1 10 3 4]\n", + "print('View After Array Modification:\\n', view) # Prints [1 10]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "However, if we use fancy indexing, the result will actually be a copy and not a view:" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original:\n", + " [0 1 2 3 4]\n", + "Copy:\n", + " [ 1 -1]\n", + "Array After Modified Copy:\n", + " [0 1 2 3 4]\n" + ] + } + ], + "source": [ + "x = np.arange(5)\n", + "print('Original:\\n', x) # Prints [0 1 2 3 4]\n", + "\n", + "# Modifying the result of the selection due to fancy indexing\n", + "# will not modify the original array.\n", + "copy = x[[1, 2]]\n", + "copy[1] = -1\n", + "print('Copy:\\n', copy) # Prints [1 -1]\n", + "print('Array After Modified Copy:\\n', x) # Prints [0 1 2 3 4]" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original:\n", + " [0 1 2 3 4]\n", + "Copy:\n", + " [2 3 4]\n", + "Modified Array:\n", + " [ 0 1 2 10 4]\n", + "Copy After Modified Array:\n", + " [2 3 4]\n" + ] + } + ], + "source": [ + "# Another example involving fancy indexing\n", + "x = np.arange(5)\n", + "print('Original:\\n', x) # Prints [0 1 2 3 4]\n", + "\n", + "copy = x[x >= 2]\n", + "print('Copy:\\n', copy) # Prints [2 3 4]\n", + "x[3] = 10\n", + "print('Modified Array:\\n', x) # Prints [0 1 2 10 4]\n", + "print('Copy After Modified Array:\\n', copy) # Prints [2 3 4]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "1. NumPy is an incredibly powerful library for computation providing both massive efficiency gains and convenience.\n", + "2. Vectorize! Orders of magnitude faster.\n", + "3. Keeping track of the shape of your arrays is often useful.\n", + "4. Many useful math functions and operations built into NumPy.\n", + "5. Select and manipulate arbitrary pieces of data with powerful indexing schemes.\n", + "6. Broadcasting allows for computation across arrays of different shapes.\n", + "7. Watch out for views vs. copies." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.4" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/books/[DL-CS231][2018][Fei-fei Li]/spring1718_assignment1.zip b/books/[DL-CS231][2018][Fei-fei Li]/spring1718_assignment1.zip new file mode 100755 index 0000000..57db8f2 Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/spring1718_assignment1.zip differ diff --git a/books/[DL-CS231][2018][Fei-fei Li]/spring1718_assignment2_v2.zip b/books/[DL-CS231][2018][Fei-fei Li]/spring1718_assignment2_v2.zip new file mode 100755 index 0000000..04d62c9 Binary files /dev/null and b/books/[DL-CS231][2018][Fei-fei Li]/spring1718_assignment2_v2.zip differ diff --git a/books/[DL-网易][2017][Andrew Ng]/Deeplearning深度学习笔记v5.35.pdf b/books/[DL-网易][2017][Andrew Ng]/Deeplearning深度学习笔记v5.35.pdf new file mode 100755 index 0000000..e1c509f Binary files /dev/null and b/books/[DL-网易][2017][Andrew Ng]/Deeplearning深度学习笔记v5.35.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/[2011]斯坦福大学机器学习课程个人笔.pdf b/books/[ML-CS229][2011][Andrew NG]/[2011]斯坦福大学机器学习课程个人笔.pdf new file mode 100755 index 0000000..c4d5590 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/[2011]斯坦福大学机器学习课程个人笔.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/作业/作业1.pdf b/books/[ML-CS229][2011][Andrew NG]/作业/作业1.pdf new file mode 100755 index 0000000..1401655 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/作业/作业1.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/作业/作业1解答.pdf b/books/[ML-CS229][2011][Andrew NG]/作业/作业1解答.pdf new file mode 100755 index 0000000..e95fb69 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/作业/作业1解答.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/作业/作业2.pdf b/books/[ML-CS229][2011][Andrew NG]/作业/作业2.pdf new file mode 100755 index 0000000..ec0c20d Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/作业/作业2.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/作业/作业2解答.pdf b/books/[ML-CS229][2011][Andrew NG]/作业/作业2解答.pdf new file mode 100755 index 0000000..8bfd9bc Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/作业/作业2解答.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/作业/作业3.pdf b/books/[ML-CS229][2011][Andrew NG]/作业/作业3.pdf new file mode 100755 index 0000000..3982565 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/作业/作业3.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/作业/作业3解答.pdf b/books/[ML-CS229][2011][Andrew NG]/作业/作业3解答.pdf new file mode 100755 index 0000000..8c8cce1 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/作业/作业3解答.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/作业/作业4.pdf b/books/[ML-CS229][2011][Andrew NG]/作业/作业4.pdf new file mode 100755 index 0000000..035eeee Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/作业/作业4.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/作业/作业4解答.pdf b/books/[ML-CS229][2011][Andrew NG]/作业/作业4解答.pdf new file mode 100755 index 0000000..f66ff60 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/作业/作业4解答.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/notes1.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/notes1.pdf new file mode 100755 index 0000000..be7d475 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/notes1.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/notes10.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/notes10.pdf new file mode 100755 index 0000000..8104440 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/notes10.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/notes11.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/notes11.pdf new file mode 100755 index 0000000..cc96412 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/notes11.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/notes12.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/notes12.pdf new file mode 100755 index 0000000..86b47ce Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/notes12.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/notes2.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/notes2.pdf new file mode 100755 index 0000000..dd9209e Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/notes2.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/notes3.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/notes3.pdf new file mode 100755 index 0000000..a10c3c7 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/notes3.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/notes4.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/notes4.pdf new file mode 100755 index 0000000..f4ade66 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/notes4.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/notes5.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/notes5.pdf new file mode 100755 index 0000000..b1cd6ad Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/notes5.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/notes6.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/notes6.pdf new file mode 100755 index 0000000..097c747 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/notes6.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/notes7a.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/notes7a.pdf new file mode 100755 index 0000000..ecf7f96 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/notes7a.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/notes7b.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/notes7b.pdf new file mode 100755 index 0000000..70ab659 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/notes7b.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/notes8.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/notes8.pdf new file mode 100755 index 0000000..3393d9b Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/notes8.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/notes9.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/notes9.pdf new file mode 100755 index 0000000..ab92915 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/notes9.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/其他的人工智能课程.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/其他的人工智能课程.pdf new file mode 100755 index 0000000..9507857 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/其他的人工智能课程.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记1.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记1.pdf new file mode 100755 index 0000000..de5a444 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记1.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记2.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记2.pdf new file mode 100755 index 0000000..e8ecf08 --- /dev/null +++ b/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记2.pdf @@ -0,0 +1,1855 @@ +%PDF-1.2 +7 0 obj +<< +/Type/Encoding +/Differences[0/Gamma/Delta/Theta/Lambda/Xi/Pi/Sigma/Upsilon/Phi/Psi/Omega/ff/fi/fl/ffi/ffl/dotlessi/dotlessj/grave/acute/caron/breve/macron/ring/cedilla/germandbls/ae/oe/oslash/AE/OE/Oslash/suppress/exclam/quotedblright/numbersign/dollar/percent/ampersand/quoteright/parenleft/parenright/asterisk/plus/comma/hyphen/period/slash/zero/one/two/three/four/five/six/seven/eight/nine/colon/semicolon/exclamdown/equal/questiondown/question/at/A/B/C/D/E/F/G/H/I/J/K/L/M/N/O/P/Q/R/S/T/U/V/W/X/Y/Z/bracketleft/quotedblleft/bracketright/circumflex/dotaccent/quoteleft/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z/endash/emdash/hungarumlaut/tilde/dieresis/suppress +160/space/Gamma/Delta/Theta/Lambda/Xi/Pi/Sigma/Upsilon/Phi/Psi 173/Omega/ff/fi/fl/ffi/ffl/dotlessi/dotlessj/grave/acute/caron/breve/macron/ring/cedilla/germandbls/ae/oe/oslash/AE/OE/Oslash/suppress/dieresis] +>> +endobj +10 0 obj +<< +/Encoding 7 0 R +/Type/Font +/Subtype/Type1 +/Name/F1 +/FontDescriptor 9 0 R +/BaseFont/GVHGTI+CMR17 +/FirstChar 33 +/LastChar 196 +/Widths[249.6 458.6 772.1 458.6 772.1 719.8 249.6 354.1 354.1 458.6 719.8 249.6 301.9 +249.6 458.6 458.6 458.6 458.6 458.6 458.6 458.6 458.6 458.6 458.6 458.6 249.6 249.6 +249.6 719.8 432.5 432.5 719.8 693.3 654.3 667.6 706.6 628.2 602.1 726.3 693.3 327.6 +471.5 719.4 576 850 693.3 719.8 628.2 719.8 680.5 510.9 667.6 693.3 693.3 954.5 693.3 +693.3 563.1 249.6 458.6 249.6 458.6 249.6 249.6 458.6 510.9 406.4 510.9 406.4 275.8 +458.6 510.9 249.6 275.8 484.7 249.6 772.1 510.9 458.6 510.9 484.7 354.1 359.4 354.1 +510.9 484.7 667.6 484.7 484.7 406.4 458.6 917.2 458.6 458.6 458.6 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 576 772.1 719.8 641.1 615.3 693.3 +667.6 719.8 667.6 719.8 0 0 667.6 525.4 499.3 499.3 748.9 748.9 249.6 275.8 458.6 +458.6 458.6 458.6 458.6 693.3 406.4 458.6 667.6 719.8 458.6 837.2 941.7 719.8 249.6 +458.6] +>> +endobj +13 0 obj +<< +/Encoding 7 0 R +/Type/Font +/Subtype/Type1 +/Name/F2 +/FontDescriptor 12 0 R +/BaseFont/IKGCOS+CMR12 +/FirstChar 33 +/LastChar 196 +/Widths[272 489.6 816 489.6 816 761.6 272 380.8 380.8 489.6 761.6 272 326.4 272 489.6 +489.6 489.6 489.6 489.6 489.6 489.6 489.6 489.6 489.6 489.6 272 272 272 761.6 462.4 +462.4 761.6 734 693.4 707.2 747.8 666.2 639 768.3 734 353.2 503 761.2 611.8 897.2 +734 761.6 666.2 761.6 720.6 544 707.2 734 734 1006 734 734 598.4 272 489.6 272 489.6 +272 272 489.6 544 435.2 544 435.2 299.2 489.6 544 272 299.2 516.8 272 816 544 489.6 +544 516.8 380.8 386.2 380.8 544 516.8 707.2 516.8 516.8 435.2 489.6 979.2 489.6 489.6 +489.6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 611.8 816 +761.6 679.6 652.8 734 707.2 761.6 707.2 761.6 0 0 707.2 571.2 544 544 816 816 272 +299.2 489.6 489.6 489.6 489.6 489.6 734 435.2 489.6 707.2 761.6 489.6 883.8 992.6 +761.6 272 489.6] +>> +endobj +16 0 obj +<< +/Encoding 7 0 R +/Type/Font +/Subtype/Type1 +/Name/F3 +/FontDescriptor 15 0 R +/BaseFont/HSNKSH+CMBX12 +/FirstChar 33 +/LastChar 196 +/Widths[342.6 581 937.5 562.5 937.5 875 312.5 437.5 437.5 562.5 875 312.5 375 312.5 +562.5 562.5 562.5 562.5 562.5 562.5 562.5 562.5 562.5 562.5 562.5 312.5 312.5 342.6 +875 531.3 531.3 875 849.5 799.8 812.5 862.3 738.4 707.2 884.3 879.6 419 581 880.8 +675.9 1067.1 879.6 844.9 768.5 844.9 839.1 625 782.4 864.6 849.5 1162 849.5 849.5 +687.5 312.5 581 312.5 562.5 312.5 312.5 546.9 625 500 625 513.3 343.8 562.5 625 312.5 +343.8 593.8 312.5 937.5 625 562.5 625 593.8 459.5 443.8 437.5 625 593.8 812.5 593.8 +593.8 500 562.5 1125 562.5 562.5 562.5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 675.9 937.5 875 787 750 879.6 812.5 875 812.5 875 0 0 812.5 +656.3 625 625 937.5 937.5 312.5 343.8 562.5 562.5 562.5 562.5 562.5 849.5 500 574.1 +812.5 875 562.5 1018.5 1143.5 875 312.5 562.5] +>> +endobj +17 0 obj +<< +/Type/Encoding +/Differences[0/Gamma/Delta/Theta/Lambda/Xi/Pi/Sigma/Upsilon/Phi/Psi/Omega/ff/fi/fl/ffi/ffl/dotlessi/dotlessj/grave/acute/caron/breve/macron/ring/cedilla/germandbls/ae/oe/oslash/AE/OE/Oslash/suppress/exclam/quotedblright/numbersign/sterling/percent/ampersand/quoteright/parenleft/parenright/asterisk/plus/comma/hyphen/period/slash/zero/one/two/three/four/five/six/seven/eight/nine/colon/semicolon/exclamdown/equal/questiondown/question/at/A/B/C/D/E/F/G/H/I/J/K/L/M/N/O/P/Q/R/S/T/U/V/W/X/Y/Z/bracketleft/quotedblleft/bracketright/circumflex/dotaccent/quoteleft/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z/endash/emdash/hungarumlaut/tilde/dieresis/suppress +160/space/Gamma/Delta/Theta/Lambda/Xi/Pi/Sigma/Upsilon/Phi/Psi 173/Omega/ff/fi/fl/ffi/ffl/dotlessi/dotlessj/grave/acute/caron/breve/macron/ring/cedilla/germandbls/ae/oe/oslash/AE/OE/Oslash/suppress/dieresis] +>> +endobj +20 0 obj +<< +/Encoding 17 0 R +/Type/Font +/Subtype/Type1 +/Name/F4 +/FontDescriptor 19 0 R +/BaseFont/WNYMOS+CMTI12 +/FirstChar 33 +/LastChar 196 +/Widths[300 500 800 755.2 800 750 300 400 400 500 750 300 350 300 500 500 500 500 +500 500 500 500 500 500 500 300 300 300 750 500 500 750 726.9 688.4 700 738.4 663.4 +638.4 756.7 726.9 376.9 513.4 751.9 613.4 876.9 726.9 750 663.4 750 713.4 550 700 +726.9 726.9 976.9 726.9 726.9 600 300 500 300 500 300 300 500 450 450 500 450 300 +450 500 300 300 450 250 800 550 500 500 450 412.5 400 325 525 450 650 450 475 400 +500 1000 500 500 500 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 613.4 800 750 676.9 650 726.9 700 750 700 750 0 0 700 600 550 575 862.5 875 +300 325 500 500 500 500 500 814.8 450 525 700 700 500 863.4 963.4 750 250 500] +>> +endobj +21 0 obj +<< +/Type/Encoding +/Differences[0/Gamma/Delta/Theta/Lambda/Xi/Pi/Sigma/Upsilon/Phi/Psi/Omega/alpha/beta/gamma/delta/epsilon1/zeta/eta/theta/iota/kappa/lambda/mu/nu/xi/pi/rho/sigma/tau/upsilon/phi/chi/psi/omega/epsilon/theta1/pi1/rho1/sigma1/phi1/arrowlefttophalf/arrowleftbothalf/arrowrighttophalf/arrowrightbothalf/arrowhookleft/arrowhookright/triangleright/triangleleft/zerooldstyle/oneoldstyle/twooldstyle/threeoldstyle/fouroldstyle/fiveoldstyle/sixoldstyle/sevenoldstyle/eightoldstyle/nineoldstyle/period/comma/less/slash/greater/star/partialdiff/A/B/C/D/E/F/G/H/I/J/K/L/M/N/O/P/Q/R/S/T/U/V/W/X/Y/Z/flat/natural/sharp/slurbelow/slurabove/lscript/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z/dotlessi/dotlessj/weierstrass/vector/tie/psi +160/space/Gamma/Delta/Theta/Lambda/Xi/Pi/Sigma/Upsilon/Phi/Psi 173/Omega/alpha/beta/gamma/delta/epsilon1/zeta/eta/theta/iota/kappa/lambda/mu/nu/xi/pi/rho/sigma/tau/upsilon/phi/chi/psi/tie] +>> +endobj +24 0 obj +<< +/Encoding 21 0 R +/Type/Font +/Subtype/Type1 +/Name/F5 +/FontDescriptor 23 0 R +/BaseFont/JKIHRU+CMMI12 +/FirstChar 33 +/LastChar 196 +/Widths[609.7 458.2 577.1 808.9 505 354.2 641.4 979.2 979.2 979.2 979.2 272 272 489.6 +489.6 489.6 489.6 489.6 489.6 489.6 489.6 489.6 489.6 489.6 489.6 272 272 761.6 489.6 +761.6 489.6 516.9 734 743.9 700.5 813 724.8 633.9 772.4 811.3 431.9 541.2 833 666.2 +947.3 784.1 748.3 631.1 775.5 745.3 602.2 573.9 665 570.8 924.4 812.6 568.1 670.2 +380.8 380.8 380.8 979.2 979.2 410.9 514 416.3 421.4 508.8 453.8 482.6 468.9 563.7 +334 405.1 509.3 291.7 856.5 584.5 470.7 491.4 434.1 441.3 461.2 353.6 557.3 473.4 +699.9 556.4 477.4 454.9 312.5 377.9 623.4 489.6 272 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 606.7 816 748.3 679.6 728.7 811.3 765.8 571.2 +652.8 598 0 0 757.6 622.8 552.8 507.9 433.7 395.4 427.7 483.1 456.3 346.1 563.7 571.2 +589.1 483.8 427.7 555.4 505 556.5 425.2 527.8 579.5 613.4 636.6 272] +>> +endobj +25 0 obj +<< +/Type/Encoding +/Differences[0/minus/periodcentered/multiply/asteriskmath/divide/diamondmath/plusminus/minusplus/circleplus/circleminus/circlemultiply/circledivide/circledot/circlecopyrt/openbullet/bullet/equivasymptotic/equivalence/reflexsubset/reflexsuperset/lessequal/greaterequal/precedesequal/followsequal/similar/approxequal/propersubset/propersuperset/lessmuch/greatermuch/precedes/follows/arrowleft/arrowright/arrowup/arrowdown/arrowboth/arrownortheast/arrowsoutheast/similarequal/arrowdblleft/arrowdblright/arrowdblup/arrowdbldown/arrowdblboth/arrownorthwest/arrowsouthwest/proportional/prime/infinity/element/owner/triangle/triangleinv/negationslash/mapsto/universal/existential/logicalnot/emptyset/Rfractur/Ifractur/latticetop/perpendicular/aleph/A/B/C/D/E/F/G/H/I/J/K/L/M/N/O/P/Q/R/S/T/U/V/W/X/Y/Z/union/intersection/unionmulti/logicaland/logicalor/turnstileleft/turnstileright/floorleft/floorright/ceilingleft/ceilingright/braceleft/braceright/angbracketleft/angbracketright/bar/bardbl/arrowbothv/arrowdblbothv/backslash/wreathproduct/radical/coproduct/nabla/integral/unionsq/intersectionsq/subsetsqequal/supersetsqequal/section/dagger/daggerdbl/paragraph/club/diamond/heart/spade/arrowleft +161/minus/periodcentered/multiply/asteriskmath/divide/diamondmath/plusminus/minusplus/circleplus/circleminus +173/circlemultiply/circledivide/circledot/circlecopyrt/openbullet/bullet/equivasymptotic/equivalence/reflexsubset/reflexsuperset/lessequal/greaterequal/precedesequal/followsequal/similar/approxequal/propersubset/propersuperset/lessmuch/greatermuch/precedes/follows/arrowleft/spade] +>> +endobj +28 0 obj +<< +/Encoding 25 0 R +/Type/Font +/Subtype/Type1 +/Name/F6 +/FontDescriptor 27 0 R +/BaseFont/LLJPLN+CMSY10 +/FirstChar 33 +/LastChar 196 +/Widths[1000 500 500 1000 1000 1000 777.8 1000 1000 611.1 611.1 1000 1000 1000 777.8 +275 1000 666.7 666.7 888.9 888.9 0 0 555.6 555.6 666.7 500 722.2 722.2 777.8 777.8 +611.1 798.5 656.8 526.5 771.4 527.8 718.7 594.9 844.5 544.5 677.8 762 689.7 1200.9 +820.5 796.1 695.6 816.7 847.5 605.6 544.6 625.8 612.8 987.8 713.3 668.3 724.7 666.7 +666.7 666.7 666.7 666.7 611.1 611.1 444.4 444.4 444.4 444.4 500 500 388.9 388.9 277.8 +500 500 611.1 500 277.8 833.3 750 833.3 416.7 666.7 666.7 777.8 777.8 444.4 444.4 +444.4 611.1 777.8 777.8 777.8 777.8 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 777.8 277.8 777.8 500 777.8 500 777.8 777.8 777.8 777.8 0 0 777.8 +777.8 777.8 1000 500 500 777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 +777.8 777.8 1000 1000 777.8 777.8 1000 777.8] +>> +endobj +31 0 obj +<< +/Encoding 7 0 R +/Type/Font +/Subtype/Type1 +/Name/F7 +/FontDescriptor 30 0 R +/BaseFont/KXOIBV+CMR8 +/FirstChar 33 +/LastChar 196 +/Widths[295.1 531.3 885.4 531.3 885.4 826.4 295.1 413.2 413.2 531.3 826.4 295.1 354.2 +295.1 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 295.1 295.1 +295.1 826.4 501.7 501.7 826.4 795.8 752.1 767.4 811.1 722.6 693.1 833.5 795.8 382.6 +545.5 825.4 663.6 972.9 795.8 826.4 722.6 826.4 781.6 590.3 767.4 795.8 795.8 1091 +795.8 795.8 649.3 295.1 531.3 295.1 531.3 295.1 295.1 531.3 590.3 472.2 590.3 472.2 +324.7 531.3 590.3 295.1 324.7 560.8 295.1 885.4 590.3 531.3 590.3 560.8 414.1 419.1 +413.2 590.3 560.8 767.4 560.8 560.8 472.2 531.3 1062.5 531.3 531.3 531.3 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 663.6 885.4 826.4 736.8 +708.3 795.8 767.4 826.4 767.4 826.4 0 0 767.4 619.8 590.3 590.3 885.4 885.4 295.1 +324.7 531.3 531.3 531.3 531.3 531.3 795.8 472.2 531.3 767.4 826.4 531.3 958.7 1076.8 +826.4 295.1 531.3] +>> +endobj +33 0 obj +<< +/Filter[/FlateDecode] +/Length 2186 +>> +stream +xڵXKW(1Wć2$; `i`96[2${ߧ$[joOH*zi4]=J˜JЫI6r[UV&dL|X%ϕCntT=S×:>s>Ed"VLщZk 3 ӭ6@tʉ4jPr'zŀ/gfJZ$։J8Kz#ʓeWqO}7.QA@F(&6F8t'& 4KN35:Q@Tuv8veK]އOA/#޽ǷXo/=>%gILI&w9tVn=7hRM +u0)Xˤx/d1Q֏M[O.} h}]5at + @v=LӮ;N}ET:*/AAZcR;Lvg>}{נƞApڮ93@0Z3@B=:>Ip%RBm=oaC3UayW6Āsp| æ"~YJyT""~{",y!mx.ݜ{D05@Z@!O~Y 'Y|<[H@?+fR6순FwpFbjcٟ[)<y] =M ky86qe?&9r0ZEݢʻK!v2 yHoZͤ A' 8ݹcf`1sܭ `( `ʆS\T)WFǹ +9AJ'! Y-PTV&w  =hϠYlkrN6vvTh8u4B-80eHUԈC`|[VYqa6%'RTewn٭jOaRł\7M&-]^CQ2R_PAut0v_(/D5}3Atqh{ojTZUiUQy`߂s~Yg܀am"XF CzhC&6v/CP}|TJ*c2/̮V8-ep=@ʿ_s*Z0VMpsɊX9bPsSiIX Hr6qc )@;hz:,Q~ˏdF~ +" +oӾv19nUѩyFrꧻ?ʕ +endstream +endobj +35 0 obj +<< +/F1 10 0 R +/F2 13 0 R +/F3 16 0 R +/F4 20 0 R +/F5 24 0 R +/F6 28 0 R +/F7 31 0 R +>> +endobj +6 0 obj +<< +/ProcSet[/PDF/Text/ImageC] +/Font 35 0 R +>> +endobj +40 0 obj +<< +/Encoding 21 0 R +/Type/Font +/Subtype/Type1 +/Name/F8 +/FontDescriptor 39 0 R +/BaseFont/WEJCJR+CMMI8 +/FirstChar 33 +/LastChar 196 +/Widths[660.7 490.6 632.1 882.1 544.1 388.9 692.4 1062.5 1062.5 1062.5 1062.5 295.1 +295.1 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 295.1 +295.1 826.4 531.3 826.4 531.3 559.7 795.8 801.4 757.3 871.7 778.7 672.4 827.9 872.8 +460.7 580.4 896 722.6 1020.4 843.3 806.2 673.6 835.7 800.2 646.2 618.6 718.8 618.8 +1002.4 873.9 615.8 720 413.2 413.2 413.2 1062.5 1062.5 434 564.4 454.5 460.2 546.7 +492.9 510.4 505.6 612.3 361.7 429.7 553.2 317.1 939.8 644.7 513.5 534.8 474.4 479.5 +491.3 383.7 615.2 517.4 762.5 598.1 525.2 494.2 349.5 400.2 673.4 531.3 295.1 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 642.9 885.4 806.2 736.8 +783.4 872.8 823.4 619.8 708.3 654.8 0 0 816.7 682.4 596.2 547.3 470.1 429.5 467 533.2 +495.7 376.2 612.3 619.8 639.2 522.3 467 610.1 544.1 607.2 471.5 576.4 631.6 659.7 +694.5 295.1] +>> +endobj +41 0 obj +<< +/Filter[/FlateDecode] +/Length 2985 +>> +stream +xڽێ_a2V$"%Ei(Eo>hlX-Mt}υ(Km6bѼsx&dsכ?ؤi\dwYٹ>KNy[Et 9Cw7"˸SW}EyẠ>VVٟ/z +<5wkx? 48RTBUFq+LǮġ x'n*.MBh+gƍ ùD}/1WHfb)i1uٍsNgyS֖y<Q(JjZևŦBL&nZN͒5Iym.b%,.ϦWhI60]2>EYx'DvIF>ICpZ%9HEh  BX{6K"m]NH\zˍC߂ <u8q?Y^T7O܀u}u͎V{Bc!;2UXnTZ-zĝRxEyqJ|w[(B 0D'CKE?CՁpjꥌ,b.cjG^4]Z8"*+$ݰ?q@E^K*] _[9Ǣ8nnޗqpk/v%/ + +4O^ƒԓzi^H; E$gb*e2hQ~1M8jڟ[F=# +m=waƪ~5D }qw%[fKAN ǖlJ>zv11@4<&g~᪡Cd_K| ju4:eh)$[B uJS=}*z; ĕ˼~oU/ vW:g^$`p +@bť9ATUkq{@0`9f#;,I si@*TdKKdTY8_ +*rsL "+(=ta u6 7sY*ִϘc-Ua-jXW0]wPF3[^1PEg]yԲ*}9N&,T/C* sc%V/7KOc<,o}5`oT>*:2`Ɨj{<,zvUmg^“uLb&!>n 8ФC B"ijkAJҥURty +LFS(O:W3:?{,q@&( Tۑa/$,ncN6m̏phʏ0u%]Z\{z&)BjH`'etSqcTwX;#tI=+ +`<ǮG>s 6-ގ foOq{jr^垞sm= t)^HW1UjX,Ƭ)1ŧr[yPجV6A&tȁÁQ3Skc eTЯ$GVija4~E$(ǡ]x?3|'~cUYaK梃@/YpG<|;8^*èف{<{t-\ͳUe{<,_A#?+ BA)BT^$xZ햃nXһEncac&O"T2Da8"fV jZZaR(cM"yc,'0|_qM(_q{-OI%NSp𑨜<˥ˬ>|GЎ|J+KLģx?Tubeވ7jIꡘU]_8s$qU9LW@5vqHŸc?5|@/Sy`m0҃[rR2/+7iE wX~JJ96:΍3+))8tx P t>mr6t4M>0w > +endobj +37 0 obj +<< +/ProcSet[/PDF/Text/ImageC] +/Font 42 0 R +>> +endobj +45 0 obj +<< +/Filter[/FlateDecode] +/Length 3098 +>> +stream +xڵMo_d (,zh lAD}HrpHd'9CRao>VwUutC۵z^*ΓS_7"ۨ6\uƤșSr0w;l. P_f"ezdFy +! YvL2p aDS TyDfAlN-W11 +HtG%P5>SP)?KyE%o-^f8 "&*!ɷɩO<*>rW]?M@\`f~:tU.e3̧4H}6 SOb,U24`T7A3 ,CT 99L [ޭ1>|ɔ8yLP; jc >Ǒ̎l*Skʼq-Bgf0MdقFac$R߮Ѯ}7>'l0aFL&bijnd3)YwWc]hlO!3n,ۭL][qqcHycWҗgPB ZÄ~W@XG$|.*8'D2fHL0NeVuf=v݁{D$X_d^IB 3x̙`vst8|g8NS;Lk>r~ )\LB=r5AvZy戣L3 TVgI]t+D¡>VW=ɰL23gkqFܩ~qҡ. 9s1> \miu=O\ƭ"RXҬXy %z"GHԮX7R7aNܪe1=,X⥟ Qr8lyg=`z.Y<.!~q4yw4Qjd iO0$!QJ%>I7yL8Oj +4YĎiH4)s>yS<ߗ+7-`nr@/@m%#\*?W=ng[;9Wwg |젏]qCHnuC| OkzjhΣ݅r׳3]0o"8hP?V+CEimc$hǻxSû23Lɫ9_sXl:ҩ%G%"yaCV/`q%Mnk_ ㉒&b\/Sbx2t8p͕5cČ+`ye3,rHY@KlyF9?"/՜IVgt 鈮HW2~)lJ3XGe`y;z #+R 0K 22Bb\6,$ br* í$]@w4҈0DZ Ϥ+GR?Ų<ӝoFY^x[03f>2ڑo1Dn l{B>+9З8p9503V9X= kV'~<"> +endobj +44 0 obj +<< +/ProcSet[/PDF/Text/ImageC] +/Font 46 0 R +>> +endobj +51 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F9 +/FontDescriptor 50 0 R +/BaseFont/VTXFZI+CMEX10 +/FirstChar 33 +/LastChar 196 +/Widths[791.7 583.3 583.3 638.9 638.9 638.9 638.9 805.6 805.6 805.6 805.6 1277.8 +1277.8 811.1 811.1 875 875 666.7 666.7 666.7 666.7 666.7 666.7 888.9 888.9 888.9 +888.9 888.9 888.9 888.9 666.7 875 875 875 875 611.1 611.1 833.3 1111.1 472.2 555.6 +1111.1 1511.1 1111.1 1511.1 1111.1 1511.1 1055.6 944.4 472.2 833.3 833.3 833.3 833.3 +833.3 1444.4 1277.8 555.6 1111.1 1111.1 1111.1 1111.1 1111.1 944.4 1277.8 555.6 1000 +1444.4 555.6 1000 1444.4 472.2 472.2 527.8 527.8 527.8 527.8 666.7 666.7 1000 1000 +1000 1000 1055.6 1055.6 1055.6 777.8 666.7 666.7 450 450 450 450 777.8 777.8 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 458.3 458.3 416.7 416.7 +472.2 472.2 472.2 472.2 583.3 583.3 0 0 472.2 472.2 333.3 555.6 577.8 577.8 597.2 +597.2 736.1 736.1 527.8 527.8 583.3 583.3 583.3 583.3 750 750 750 750 1044.4 1044.4 +791.7 777.8] +>> +endobj +54 0 obj +<< +/Encoding 25 0 R +/Type/Font +/Subtype/Type1 +/Name/F10 +/FontDescriptor 53 0 R +/BaseFont/DKVEUL+CMSY8 +/FirstChar 33 +/LastChar 196 +/Widths[1062.5 531.3 531.3 1062.5 1062.5 1062.5 826.4 1062.5 1062.5 649.3 649.3 1062.5 +1062.5 1062.5 826.4 288.2 1062.5 708.3 708.3 944.5 944.5 0 0 590.3 590.3 708.3 531.3 +767.4 767.4 826.4 826.4 649.3 849.5 694.7 562.6 821.7 560.8 758.3 631 904.2 585.5 +720.1 807.4 730.7 1264.5 869.1 841.6 743.3 867.7 906.9 643.4 586.3 662.8 656.2 1054.6 +756.4 705.8 763.6 708.3 708.3 708.3 708.3 708.3 649.3 649.3 472.2 472.2 472.2 472.2 +531.3 531.3 413.2 413.2 295.1 531.3 531.3 649.3 531.3 295.1 885.4 795.8 885.4 443.6 +708.3 708.3 826.4 826.4 472.2 472.2 472.2 649.3 826.4 826.4 826.4 826.4 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 826.4 295.1 826.4 531.3 826.4 +531.3 826.4 826.4 826.4 826.4 0 0 826.4 826.4 826.4 1062.5 531.3 531.3 826.4 826.4 +826.4 826.4 826.4 826.4 826.4 826.4 826.4 826.4 826.4 826.4 1062.5 1062.5 826.4 826.4 +1062.5 826.4] +>> +endobj +55 0 obj +<< +/Filter[/FlateDecode] +/Length 2382 +>> +stream +xMs_鉚 ;M^u2mgIV9l3O"=$eXV! bw8^ݭWXqβdu}W?QވTEDEy]7{KFEБ]t/ޫH(엱SKÔb@IT !2nk*M[7J(nkã>IO8BzI$ŔrRF6/dpCo!N{v_m0($f[yt]}L􎠲Jd8Ca6*eg`x X `*陈΅nPCaBG࡮nPȍ'CPǡ6Xw=Vp`4<ݿ<]u{5 _z%drSUmIt 1~6L Z:<:c걵ppE C01/FR q@͸Pߪr_yNa=i*`-bو~$SՖUOLG'yOPT1R% +'uMUk!$egTl4 "# 6qk5$֯:> +_rv˄мN&GAEɉ.1,2ՋDzBƝK4o]RǪw5y8" :j*gh J)mE;zEwdk'En$id.ęD'ziBlG;m$gm4X[4of(qX 3) Tff<9ܷ`$iB48{K/^l_d@:W\C6=ޘ^Bhr7;sΐOIRAy{raoĈlDL8-Ul#&~,[/H,H ɐq +Wgd%?>8ߒff3 $}wzxX'dtv +ęFd_*A! +W+Ŧ08 7H;>u2:] ?PTmпЪ1w0#|W>Z&OjGFK)EBb޽(d|D$. +!%#CJMd%-NEn> x]P p.{9.=>J(Qi )NPa$ ƻ +:7V z&=|9O7CTwВMu|T4f#4cxnuE2е#Fu/QfR#/Ef˜ F1/X%YtI)PQ9(Ry֖9X+Cs:TOeQH@yqN W)hz!rPh|FYSv>Bi9A4w y ݂v"/XJAd9Ӝ[]4]S߆U1\A!W`VʌE|q-}e|ViAz!YRY,e_K,":wB,6/q.K &%qu%c2=tu=yB^Y[mzdVŒ)`^QJkg|ʜe]j=FȾ؊D!]%djՏKkPɩ0lx"mz%|(3?0[ȇB[>Q,bНIy <6{=J3(Qg߯~Ԟ͌ 7oX ޫH^޹&cJ`lk3O }Kˡ1;)Cs?(=pklޛsZ`"~P": QgCA{RfyӜ]+P'ʸNSͱǡA떊mWfi"L8pDaF BRK'@qɟm5 +endstream +endobj +56 0 obj +<< +/F2 13 0 R +/F4 20 0 R +/F5 24 0 R +/F9 51 0 R +/F8 40 0 R +/F10 54 0 R +/F7 31 0 R +/F3 16 0 R +/F6 28 0 R +>> +endobj +48 0 obj +<< +/ProcSet[/PDF/Text/ImageC] +/Font 56 0 R +>> +endobj +59 0 obj +<< +/Filter[/FlateDecode] +/Length 2540 +>> +stream +xYm_a ČDR(rMMEEvkkϺ-Goo;/$['Q|gg\"oݗ"ID.b3zXJ%IiRiqT7ŁۡǦzǦGTo9u+,ۨNKV_?nwtVT 2%7bMBc˒= ȨyMXL Кʔ_:<;6EաInDzNυ> "MO7nWaf2o[~=HKNIE˳,XIV̟(cr*0,`%84n!e"הaN;& 8VLpau>JȰ:Jd浒Fys¤qSvd<9ɂ~XxSJ^T]g3RjCxctGF2ڼ_z~>~T&:MeEBj +9IMؐ{0'+nK +oÖ k;`, h[Wo]s,X79n:z]J_C*)_vn$U[H tMƐזHA"_F"Z*k8ּu1ԓq`zԙHkFf#tYfE3KMvgoqڞDb~q=|UmZ +vb+\})_G_uG豿k,7e7j͂:3[Fd3&MK3:\`)O*6ѩ}і͢c1 dzJ؍{" +u*c]}DX=W s[ʇ@lŕNrOr4p/I:41fFQ'͓z1n\ @U+i./w @]'j;W2i9=ڥI [/uMexiSeI+r3۔SiB#8L~)?t  !{T=[#r(׽)E!tL!tڢxIL{H2YCeCۉ'St2z*+`!9Dzg@BB­G^cP7qzҀ-s?Ô+(5QvKEC]6";|)  kԜޔOH( ?&gC/=Fj>{ZqUQ>dnˇVi]dXGLeu'Oz"K3?ś!<ߝ⋘g\3˹*/ڙEF5F6*AVFj.Z~@XX\!` +eX` :vf`_)?}\@ \o:qsl'~>V vM7 xšG[9qzG9 1~m똮8kP0`j8\MOO@qZ5 XlܡpmMnLOy\y#I=½?k|J)(_Fa H d6~8Rcv-U ZQ kx`'n,ishw}I%| -X`Q`L3Ҧs #e@No_C*yD\ሆ8s&3xl2ejH!boH_zc [C.aiD?,>|'BoVr8M. ^ӆ;bE#YJ +i=: )@BL&`ްnG3$= fK&^vaڔ/!% ahd8 țfN|fWT*r5y4 +?WqF9Qϖ&|t$8jq|lǣ(ݕZ4E+x)5eNo?ĸ^@M?nW&9 ]7|C|V!T6yz|΃'96r~Ǯǖ^~!Dǚ"ܻt0K 6:S/-PO<ϗ-윮1Bg%P ?+.?X&!(܏y yrpHNxmJZ+k*#, Rw. +endstream +endobj +60 0 obj +<< +/F2 13 0 R +/F5 24 0 R +/F6 28 0 R +/F4 20 0 R +/F3 16 0 R +/F7 31 0 R +/F8 40 0 R +/F10 54 0 R +>> +endobj +58 0 obj +<< +/ProcSet[/PDF/Text/ImageC] +/Font 60 0 R +>> +endobj +63 0 obj +<< +/Filter[/FlateDecode] +/Length 2722 +>> +stream +xZ[6~_a@̊R,M,RE6;md%{)ɖ3x(^?+!! ~xWb9ˢ"\\ݵir%0(Z@'_$7WT#P7kPRāWKaPue4ڸenWo/H1vEގĎBS\]##_B\Wԥt[OkK}YE#ni-{"a2OXlb[Lq&5"np[@2WyU[,XjqYS#u\zFb$*"DY + ;`"AQgU M4@-}3Be-7%JʄxʽH~$ZBEWԕ.q4"LgO\E0U5c#Y[;*#̯mP$K>>poEX>C MX]L)TpKz["[V6- t^]I}┉)ɨ U>\!50SB4EE?L &Ī'c5[@`zi+l"KX6_KV,Bw2P,PiBPSL@96~S69xRZ;u.630`Yr6wN﫺#dWΌTHWoc@MXzdl7=2[װJD'Ku}e1=9&M'dI'b.1t+1¨.­#GG,V_AK }d<8d"Wq$:bvwnAߑzq|?HA= R ESEPzCy8tVwq/oX=?0NzŋO5< Ѻgt*&'vސѻzۛm5]54tM? a$XK}=UFG=֝ kp2 slz SG&(L(tagqX[ׄ`Ʋ+vcf,C*'13MQQaBEO3Zxwo)(N |߷EY] zŐ!?rݗkFMG rcQzظ:sԕJI;]iW/.he s]/<^Ɖ )~K6ܼwga\=B$BF a33ytk#WmA̅"M .ʞ@>k09`x8j}n!eir`Vմ5ܛY#UFQt&1Q)Uge=L}L:!fıGJۻv?r;M Ź0!rJP0T:,V9A g")\(ElwI@Y`x*ޣ_5mߙ6j{q U~v 0G řNɍc╉~wppYC01^`!tƋgCQ1B}O@@e##Og>E;Y98} Gɕ>!hz \8'7!GYw[Y*w +uReb}JS3ACⅼRh .Y\b^T@ًN<^>^'зhmbLAbS=Dk\$J%ltF;`=RMݸ ( [z'&vt[# N㽕*xqzME{[ /z3(/tQm)EFwgԘ?O]͑i +GE;j,P2 +C  +'K0d[b!FEۋ%" ֔6=l:>}nXcNޚL19n".U_ /2WѵD̬6Ei|6_T^^h; 4a޼n,&i%'ʠBcLl# P{ۺr?TM&$]a$TS>;I2;_(Z>ME>G[Nt*?ڔ._oz^kG,L1Ӯf +Bց3]8J9S4u1mw?jRQjI0n]>ñaFoXؾ3z:zop$ƪ}6{Jy۪} 7z㕦,$VW W37Ѷ?وlJ[wtn/=$%P؝t?Y +endstream +endobj +64 0 obj +<< +/F2 13 0 R +/F4 20 0 R +/F5 24 0 R +/F6 28 0 R +/F3 16 0 R +/F9 51 0 R +/F8 40 0 R +/F10 54 0 R +/F7 31 0 R +>> +endobj +62 0 obj +<< +/ProcSet[/PDF/Text/ImageC] +/Font 64 0 R +>> +endobj +67 0 obj +<< +/Filter[/FlateDecode] +/Length 2381 +>> +stream +xYKoW +q/6;;$$N2hDܡHQ~}M6E.ُz~%8IV+a7J871ݬ3l/ئY,W+Onf=yK2h;vEçp/|l|(N%4mxQ٨+}{X#^ckȕȣSjy܂@J&QYfWQ}5e7Zy+|QE`o~nZ}r˅[FVoZتUB8vkD-e\ŎF;=ޚH:07U,I#5| ڗn|oᦍr`mS{*j^Ype`.v ?+H70gLum#F&<iux/W2Ξ1P܂Xtf_Ne/<+nsnMNd1ZP@zmn"4Ƞj)Sv5I€ JDgm[oLDGK+_xeWR"%!B"5Td0' l_ %, 2nʢ NɏJxm?ƹ(`4.nY83XHSUC: +bP42[<G|Ձ>Xjϧ]{p;< +].]+&s+@gW (c~ʎWO>!C1Jh/iG[֗ J9".m6)_EH Jd+ yNb^v|jQ&%N`.hOU(cP<._zH=D5PÆzGTzw?x@=-_6%;L$, @0Rk_ǾcO:ް~K^{]J1jFh"/XS0zH5*ҁcF>2wZ':(==_fq9b 0]X7__ tz~Qq:'E Bc:sV(1rK)HP@-VP0k&Pq6FAyIk8JHbNop\c%r?HϊtwPl$8/Jm}$%wJbe_LF&Z>q8xvm SJ6)ۜ[uno{X2`N [X/\kyVq<U7 jL휽S9Uqp}޾Ln^ eIA*XILQݲ iM`ZJ~` 2o,/-k}؆Vr/ oTuцݭ]urT̋hàZDC(rʌl9C6WGc pk쀐xW&gc \(ΎIcڎlQUO#s>oY΢N|Gnx 㳉Ъ?X`>o9=k+h ԤEx]yNyКē6W(Ow'K*6X=`z'\ݒQJ<&̯R.&@w  EI,A_XdF&y1}B%tgEDPSջl2tZA`m𔽂zH eW]xs_ XvL(,YT=9vUqeD3tVehctH-%u "i&SHʚęZ c^Y[M` L`O(Xhk+ :t{33A)C&+)?硨歔H46yUKQkqKAtBd#RaSR 0l#NLBpϛ@:(!& $Ȉ&odܮPk')Š46 PSmd\CcYJbzݏMߓ_p4d<C 9"fsot!D 㑢_@./!D':#p鞙(hG_Q"1v= +]o \d@N]A/^A:N2_G)"%H SԄI"Rʑ$dxJO+ AƂ2a%90W13> +endobj +66 0 obj +<< +/ProcSet[/PDF/Text/ImageC] +/Font 68 0 R +>> +endobj +73 0 obj +<< +/Encoding 7 0 R +/Type/Font +/Subtype/Type1 +/Name/F11 +/FontDescriptor 72 0 R +/BaseFont/PMCILZ+CMR6 +/FirstChar 33 +/LastChar 196 +/Widths[351.8 611.1 1000 611.1 1000 935.2 351.8 481.5 481.5 611.1 935.2 351.8 416.7 +351.8 611.1 611.1 611.1 611.1 611.1 611.1 611.1 611.1 611.1 611.1 611.1 351.8 351.8 +351.8 935.2 578.7 578.7 935.2 896.3 850.9 870.4 915.7 818.5 786.1 941.7 896.3 442.6 +624.1 928.7 753.7 1090.7 896.3 935.2 818.5 935.2 883.3 675.9 870.4 896.3 896.3 1220.4 +896.3 896.3 740.7 351.8 611.1 351.8 611.1 351.8 351.8 611.1 675.9 546.3 675.9 546.3 +384.3 611.1 675.9 351.8 384.3 643.5 351.8 1000 675.9 611.1 675.9 643.5 481.5 488 +481.5 675.9 643.5 870.4 643.5 643.5 546.3 611.1 1222.2 611.1 611.1 611.1 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 753.7 1000 935.2 831.5 +805.5 896.3 870.4 935.2 870.4 935.2 0 0 870.4 736.1 703.7 703.7 1055.5 1055.5 351.8 +384.3 611.1 611.1 611.1 611.1 611.1 896.3 546.3 611.1 870.4 935.2 611.1 1077.8 1207.4 +935.2 351.8 611.1] +>> +endobj +76 0 obj +<< +/Encoding 21 0 R +/Type/Font +/Subtype/Type1 +/Name/F12 +/FontDescriptor 75 0 R +/BaseFont/KOCVLX+CMMI6 +/FirstChar 33 +/LastChar 196 +/Widths[779.9 586.7 750.7 1021.9 639 487.8 811.6 1222.2 1222.2 1222.2 1222.2 379.6 +379.6 638.9 638.9 638.9 638.9 638.9 638.9 638.9 638.9 638.9 638.9 638.9 638.9 379.6 +379.6 963 638.9 963 638.9 658.7 924.1 926.6 883.7 998.3 899.8 775 952.9 999.5 547.7 +681.6 1025.7 846.3 1161.6 967.1 934.1 780 966.5 922.1 756.7 731.1 838.1 729.6 1150.9 +1001.4 726.4 837.7 509.3 509.3 509.3 1222.2 1222.2 518.5 674.9 547.7 559.1 642.5 +589 600.7 607.7 725.7 445.6 511.6 660.9 401.6 1093.7 769.7 612.5 642.5 570.7 579.9 +584.5 476.8 737.3 625 893.2 697.9 633.1 596.1 445.6 479.2 787.2 638.9 379.6 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 742.6 1027.8 934.1 859.3 +907.4 999.5 951.6 736.1 833.3 781.2 0 0 946 804.5 698 652 566.2 523.3 571.8 644 590.3 +466.4 725.7 736.1 750 621.5 571.8 726.7 639 716.5 582.1 689.8 742.1 767.4 819.4 379.6] +>> +endobj +77 0 obj +<< +/Filter[/FlateDecode] +/Length 2725 +>> +stream +xZK۸WHU,,H8CRkJպv69p$ w)q"Q̿O7 f<7ģ_h4?bۅ/W߽ !ՋȘ֋OͶlmyXR%$%>sUZԇ˕̒\{4v. +c>nuVRɦ:V͎Zn{st"d*YW^Jee9(4uۻE4=k{WMuq]Uݏؘ% u/vfKϟ:M}U\%&U[qu]fD},*a?@V["I'}hVYc+y`w%Vg ˍX۔sry)wQId2+7| }i>譤I +km4?&w +^G3A %yɛX'Τ0ٳN3͕&W[2#_ +/ ƍFnJ1|F4SVBIJBHJq3{b3ӳ2!jѽgWLOO`7(r.#rZ J]/ˌrXXfAn ̬_nfsbFu|Y|8@D +BG]s}Q\2BflH 4Mʇtj :.bc 8 <96G`G_/T<6ٞ4t4XJwLpRܐ4(t+} Xor+j۲~DS`ƶ:.f&RErƁ~2},_|S#ͳ#JF" ䷵ K^)^޲}GI݌T@퓟ϥw[ 1Ma3J""[90x_ERI21 3_C"SFOz-$INʜncT#r/ϭ&Џ~"Ea&/ (aFc0 +y,̤q Dk'C+o"agU^+ V +N=NS#rçt!5ڸC9{\Q,J5>C9BE2PգyޕyUW/Tz=qȾ\nG&c{ߨlc,8G̃m"&M@hd6 ȡEݫߔte8Mt?Dtl]q +7J6Xֵt zj̳Ӣ kMʙTNM"۹|Iii0"lӁS3^CR_L1RɗIO1a#఺,˾>ueq+4ǐgs>e}7sk swOPP#uFȉϖA +g Dhnz|lቕbQ*wN>{slH Vywx &5 xMQiS_-D?c1[:P|&"wDlVJ }.&)^]icqSBqS,B8JqA!M"{a#[q9lQ~R̻aO0ƹW~WxarNKyu8vJ6Ur^7 +NVPCvOv¤`:amᯪˡ fB%Q0np9{pS 8ʻWBXO'˥ypy\'icq{ 1cyG |6ϓuQ B).4(DT KlqybnvӲ CYx0ҹBOE)C?g(Jw +endstream +endobj +78 0 obj +<< +/F2 13 0 R +/F4 20 0 R +/F5 24 0 R +/F6 28 0 R +/F9 51 0 R +/F8 40 0 R +/F10 54 0 R +/F7 31 0 R +/F11 73 0 R +/F12 76 0 R +/F3 16 0 R +>> +endobj +70 0 obj +<< +/ProcSet[/PDF/Text/ImageC] +/Font 78 0 R +>> +endobj +81 0 obj +<< +/Filter[/FlateDecode] +/Length 2491 +>> +stream +xZ[o~X2zV)^E')@4A|VJZ;ᐺQ^0`Io*dye[o*Y_uj2y[mGW\G9{‚,jeuGj SW>SQAC.uQծ>ÕL)͡߿FHM+%Du2kjZ۠*ot?&7W`<`=p t/b!lm}?um{b;,Ҩ凓kQ߆k&6y17ڮw1IŤ,_y]Y}=ݞ$*]ͻj?PZtfƵOȚ +W[5yYӨ8i9l!~ jT@u.ɠ.LOݛHq3IznB}Ov1P@Ghz6iKC`"+w:ք><*x2+!Wޜ-! uE1JC EO/=sa4Tžϲ%{pT! e~NX@ΗԐF}쉿N@5Pw[F%b" \YF_ȅ\B.&й+ۣlHEx7J3m +%o\YUӳР) *yѱɹ% ԌPng@(>0](]Nۮ"d_;g1DJAW+1q[(%kmnʢ]XZEU4.};^FEcw{7_3&x[ 1]p$Y&?ZF"$z$lIF#ę<.o ˖~ >\0nͽ/B>N.̻y8P~RW35EH<'6P"pkնMV1N=|AXC,홍}+57'M*X: 3榽o T +?͹t}_<n#T֌U)?55m4>йҼr1@ܲ[_]A FZ@s97O9aCf k!mt~w"w̄Q0vq<-CKTK-2o8uL `1Q43(0AB'ўRT"Jt @ ,&G'Ǎ7:s4^K6EǕObv` ZĬ7\Ye9abXC[;y(݊P*)M3IF܆`IH!*cr& *-fHYhd9G~ESN%Xf m[ +CiYshK@NSӱn߀n5?␻4/.7·>'ML 9G8b7$84ܶxJyW<6/,'lu\<0Vk<}ަY<ه ?b$ +JY92HFȀAwy|ڲmr۫[Hl9)K=_37?sg`]xK/=/ݯiǹͱ€<?j{%;Oա!&6/ %AtI#M *=U[[IWj[X%bǦ]y[ +t 9ݶXr\t_}1`]%i͂eltl\߆$VH/E_!Wà^N\@fǥ^>uthX?9kvn!>Ǟc#˖ȋ_Q~hldL}j7 x_[fd ޙ𳇞?-Bg# 4Jkp3ʚfe0wf9geMң"%I&Y !Ԗn%9=|A]>lPˆ\eC +K}1\H$Z}XJi^Ȟ~Ĕx ZȍOO_$^`c R. pjv@&6%[0уE|QWP +endstream +endobj +82 0 obj +<< +/F2 13 0 R +/F5 24 0 R +/F4 20 0 R +/F3 16 0 R +/F7 31 0 R +/F8 40 0 R +/F6 28 0 R +/F9 51 0 R +>> +endobj +80 0 obj +<< +/ProcSet[/PDF/Text/ImageC] +/Font 82 0 R +>> +endobj +85 0 obj +<< +/Filter[/FlateDecode] +/Length 2439 +>> +stream +xڭYKW89X#z&ab`Htlm -K${S/ayANbXMF氡7?>`6* <o" f2KC8SH}_W8vɆ(¨#>LE&̈ɜ'˝3j+I +>-ba'86'oLEg*Gdn?&Ōd@CV6$$ yus\c aw=B-2d?eK颡tM=H 7PQxl[QF+IE<?J{#ohv*THGǴURmx4LS, '!d-fLju7Z +z=u5_[˼*w]%DXFd5ɡM#/M +C{9(7d"eh< +4NgꑽEfM[OK% R\~dp՞Μrp |Bpliʙ]!"i_d"c,PX}L;Nu{fE:w 9և"xUHx̼8t9)pj+鴾bk0GՎ`~!pt0.Y,ڶii۪`ػg]Ѣ,\|!ĦWi)@u+1Kdv]%p9 +d4f5~KR/ùԔqLPy[$uca~RrgFl!N 0^ѯH)٣ji Q+`o'Y LrvĎ.ȠKZ\S^FyRa+t|bNVAͬm);9!Si!]$;f$M o[K -.O3@Y0G aWЍBacD W@,6~Y4̈́Q;"8Ac6q x|i)TGfj)_h&ؿJ=$]^^Ab o]O=WyX̉۟mMѦ< +5oG#T 0&4mE' +<ܲ 9#}~H +:]y,u5c6ي㟷u,4;9(4zI1xI3/0D9W(gv/<T˳kg;DP IcR=m̹{fW70*1gH74o#g{lfG(eg-QLuOw&)5q.!p2_E7mwTE~{qs +v/!IolQqOjз]82w^}[PQB+@j};q*7g_s u5> +endobj +84 0 obj +<< +/ProcSet[/PDF/Text/ImageC] +/Font 86 0 R +>> +endobj +89 0 obj +<< +/Length 16228 +/Filter/FlateDecode +/Name/Im1 +/Type/XObject +/Subtype/Form +/BBox[0 0 2384 3370] +/FormType 1 +/Matrix[1 0 0 1 -96 -238] +/Resources<< +/ProcSet[/PDF/Text] +/Font 90 0 R +>> +>> +stream +x͝K49rWdإL^[¬i@ CAI0A7-{Ԃ1}YY,&/q{}JyF9o_K;ƫ~n)y<:ڔħW?z<ﳝ׫|u}~zu3(N{qUHG/}VJqjDJsD +_׳׿ӟ/@?ݗ9|x~ۯ?ן_g*nu.%[B:ssvkG{~|KO*yzN>V_:_\Ez~W-c%Vٯ/W_v=vųz]m%Vٻ/]:R;sq7 >mg/fߢc?3lcnϵw͒e?1lx]+ۻ콳w*{cjݱ+Gl &w{_>v:ۻjHH>zw[_>vȯ['Rn;~nvV||ūmah>ӷַ!:f)9K~UbJ9f㧝W?_;3dIkTŒ:٦%mJ]$^/eo%78%0I26ǣhs`7bs:10MI$fl>gܔ.?yF8– + `7C~};D +z3xLI{C`9Ȗ<&o}},Oz< sMB=% 1Sw#^=2SduJONJï7EFg܉&-n3!xAAks::<ƩLۧ֞k6kfZ]))6G%ih=%` SrcSrX|C) NݤbLIDx?s?MIs(ܴ +~MΡc Ρ-NܶqAU⡛cTI}S?mJ5ǜdWĂ*{a-1'jnӵT3ww.U'MuZDJkAR5x%ɩo g3%C3ZZZG!ѽep͵s_]&y7-G?^@Fx^M +IJ-#qZSz;hds7scݒtn)=Ga̍%<'*ѼЃƅ +IӃqB\xFO`?\h1L秤n VΕz>h۸k5[>$,HN{U* +Uy<ѦD[msSr<0siC"nZO iJ=7c|JWw ))<$9:oiD$)yOA}s| +*)9prSrq[jǼ&~4{V~JTT!h uCzSrSsAcinu{{ܞ!4(?$ c9JȐ>S5$ل]>IC`Gl$p$~8oq?!4$Ist?y"/7t=USk&c˱{L{܂$ }M>779pXi;Cƴwؤ^^*|i% ޜŒmt\h3<}ьA_4SpƫM&5ǮMZr̾ὢ_ Mq#Vc|a&=Kڋfm7dگiرvOGȒ;ה +o\lxw {㍣z`+ks2i] Tz]xB(\\=]Tl \ts#hEF=b'|szsN S#sФn Pƿ2Kb]8?f=Mƫ.,$ LQtym..:( ZEcq͝NH(-RV *LQ)q6\slsD,!τ9G1g8!Q9B`16]}QQ:=Nott1 2REepׂ5] 1:lZN4+ʈ͜6r_*A騸*OtXM0DѦ;uU.)j;P?1TAKR5,e3^Ucz CMf?@M&*o +mt};|~H b0U!AWw:|HkLo}af }ሾw=lfBC2~cù݊RdXT"~J/Ip[2{xyMLC2zj7[GpTd#yRQwt3A@|mɠ`nr`!X燄)K=s1w 8-d~p)!aT*Itss,LO~{ +-]0(-ܧzדvL۰+[u_=w}<;q#0|:>nO8_Yq|ޒО~;ȳRԃVdX5Nr;%Ke87 V,)8<|ԕy9$ {粄35[esReѴs>fz NGdLv+AcF;qۃm8~M1g +$X?Ḅ3$_=NP~R" ~K!78d(ܶ"zpN1Eс̅[0J1I9N٥)}KcWU1z̗m166sP6{\%jtA8WmRY +^sn#^6Kf ҐAΣ<+5AVhh2u!9TZA+fM72LѩKTdG*^x ḆTZZvNii= )5 /Ưt;.٥4JkfRd.zДcgd"$sh"$E@NS8"z+ژ +ɜn1dV&KdVLKd"?2Kk ]e"~5?:*idߡ)-qOH / F?LSQ9PeLSQÇk4|3"xU %7Blx{%#$;Tσ'4r֧3!˴F +ҩqYם߁(456'N59 /x;<ʝ S;U%ӆi #|-xݟi?QrM~7ݦrj.Ɔ\HņF92i^a5N4=Fs0ϟLsQk4r=g|9~ s}X UWiN,`i`t9K&a +0Zpۂ/sdҫwYɛ6m3Ꙓjge +QDiq劅_E#=?u)t{w>fG~ >͵ H!tA_2A{941&X"GO67ܐ6hл(w9$tsO8y`ssd{3d*0=LX$"ߴKsM;2IK+^p'@;r%x#qRRmןLf(تDJ~˫=(చ&fM_hęAdpR +t@a C'ZiVoG$1AoiXB4a1"p7>1!pyZ`D1'An0xbD'~ OLwI+x'F7<ї`DgtKn0qP %1$EK'& $D`%B7i e݀>> Gp22Uݨyh,>cF7uSp{Ԋ@7Z t tܑ~E-n e 5Q1QF (#@7l0RSB7ne|V:o~`@>1 %`9@{\%32v6W;(%֣GB?lROܤB`Xh J!EyŇWI1V5Ҡ0v Yb [R r_X3eP2ąbW\PzzGQrcދFZ=hEKLn`Zyދiai&㹲< .j#F(Rn9!iBp }~Cw)gd?dz)"C^A|*z1-Xp%ߧ'ÕfY*Jf |` V nԹ vJ=C}T2%P 2•ܵfG#PU&Lr~Z╇i1LǧmZGm Iwsi:gAq'H4<ͳG^XG=ĕ餔xk7R$ RAg,}̤x PЊ! +|Z"lW-5*atJaCDup.Q b2!]~@-PDhMHQDh>%ٖ20f(@f(۲^ imY!h]}BaH4 Q PY EY#m+P("b  fQY"2!QD@v!a~ѶeHIDA4ڶ%-e۲Ŧn6=Fiz("2("Mf7yyڼ2HHH_ID@"*8ʼdFB}"x- L-{ +Do[Ju@%b [%(FV!)1kV[DŽ8DZ`0CS%GR !T,u ?aKA BLwB D%bdٗp;H皡HAо߽B1/;-} gFJ1HeRP%F7K/Et zjD/u Ϝ # sیʺD0D:w>b}r "I /@KEږ#iӈҶ/6((NDn-a3-L6H+n21avÅ21a|]1i5Z"|Rdbl;H{db2gS?S" #0Ax ZER+6|0+hDB!S1|T +p0HGH&HMP3PYvϕ E 'aY$YD +;ldO"'FAEa!v& E3̑EU3K#E䵘3xpls&UKD,"D"r9LX{h ,^G0w,^ہEG2w+a'xR+ޑj"+YyE"*݄x)xE^?4Y(^\\'W+"TVywޛpE^DlPbiqyILS+Bs;1=ԣhE(`EhYE{f *2IU*dXErY";YE͞Cb ?HZYEֆg*P {π*a +aOBɓ U$#TO"ٛDZ$޽IU"%D*z7s!A}H\1w9gp fip Cx :܆t1k1s:35sM341sM%3t3sMI3۴5sMm37s-3k9\ZZ5o-gے7om }ᶵ8v%p =N 76J^jpnn;ym6om ߼v@7Acp;v9܎=#hp;>nG6rNjanp;MnJMo0q"7ᦠ8ܔc;qSLn +M2q)^&78ܔ<"hpSM.}r8RRo8\*p%o Mpi.=x7\j4p.#xeoL 92y8L(xe8o ahpE4E~""-1Mb'd61D]$WALd+#.:=.EL.po Hs |T:[@/3!ejL/MAfGy3a!DcBEf)^|B]q@U_mY}6d3vz/a21vA) at1wq{'wѮ Fn/ y .oO0vӍ] u_@`<EKGD`%-0vM.hEKE`mʌir@ub/.`?1(exEKGIPEz.25A]# +s81挓3gk2u 1͢D.p_m D.|pZ \KjѣF0G(&\ v!{ak0rvQH*X^E}BI[E]݉ yňK n1b.H(Md.yo؅b6 $v1rfw1rfw1rjw1BJB](\޸ EwqEnJrW{]\&wqڣXT h&>~/ܹȍ+^ ~&aJJHW^;Y8> x̑.jnm]ԶhDž y,7]@ь /Ak(3mB1΢y/6/sм<^.%R]ԼA8 $1\.jiY1ToIHNv<%CJn@g h=kq^r(/fC|^3`/x>؋2^0\cj{Q3{>؋^0}Li)f^@1S@`i e yPfL`FoL,D/ы}O\0y(frOI^dfYmj8;>#1/n]5spw]ܱ%wqar#.F(r]`no"!/F\Cň{%a$y1*MbPC /szA@R'Ћ٢I^l#ȋ)9P@NY K&.IpvA^@pXR\ /.w S"/9髄^ 4{gn0@/ihZ\dVC1byQzĻL^@`<ykɋ +XP+KC/ +B$P(-L/T/ 1`^EY^cpp1wy]}A$}vH 73$1 Ā~(y?o΋kVk\<Qj0'NץErA~EQ;U*+/MH 7Q"")0eiU{V=BD0Gٍw + twk th{b$ԧD QdoJ+.X9? +DA]_Vi]4 +TRھ~ 8es .~Ujo=iVߓV $`/yI+g4#q]MTR |NK o=)_Bc8 p\$0WS./et w]q]kݏ u33^ul2M B uWsJЭV. +Q2$৾kZqa'DߵJ͓~#6O؄z$z6ZH€B0/b> 6WO=F44heI2;$ 5qE{J[P @ 9S0F#Pyo@ >O3ΨeX~Jڙ26Č01+J}Jti (djIY"? $SI3ߟ|34<L';䇁w}I^xcI :$xMBOt(QN4$N @idŏ Zfr m( _PՓ (]iÀ$5IDI4I n4擆iI# N$$@?B>H hHr@b`p$& 'NďkԢOI%vp&1 'o`.:)%A'(tRF :iNj5K OƓYsDr\ x , 5%Blv>>ĸ)vζv:S;nhlg1lm5vMl瀱0'v3v..c;qN?1;ifg;Dl笙,Nk#;ہt|#;N`68Bv6Φٴ#;cdgӆlM2i^v6ΦٴdrN0Dm\_ y(&X\_ YL?`T_kRgAuQ_,Sbpչ답,Z/V##Hb5S*0V#,j?sZ6W8ϷcMXdwDrXEQ`,/Ռc#* +$J^v*1 +хyTb%S\%7EV84au7ޣ4aޙfW,$J+"JQb 37&Tp"#a:;ʸfԼ}*Ee GS)x΂4ӗZ>=rܧ8";:xlfާ-EWkw` n׸װp'Oqa>=/;ғ-q32$:b>%߇<T]3r2%.KTI#8Ǚrsרq4n,ECpc۰YVy(T.蠌F8(qNPgݴcHEDQ][%Ga>u+U(wSAmj'L`xBģ`_ʺnhVd6gڣ'X3aBd{1&L0l  AYT`d\oVKK#X[~\6豆 ½|22P$M0-`x^j:t1H9(C75SiFYv]=|!aY[vKWv%.&DwWvY~2 +-I$.%0%j$RN1a;fz:G!Ug"ab0Y54~yTCv(輥,:zpi>FZe]3UːLDqgCgY=4QVH<ų^) +iQVNuS('u,'<\d]\G2Um[]:|p[e]lNfa=xT -*!gJV֫q}T֣_;ĕsQY57De=$Ω`փ/O¢^Ta.J!O\Z|JT5Bb:r9|!U 1.Ǣ& +ը枅x<1ȌT>֣zT([ƅ YXH(g$Bի\zEr]jztE~oUjѸtDQTHU7ztDZGm\UHyֲlU`-ը#ąK,ia!5VQT)|JՃ%\TVaԃߑFMԣQm%󨢄%6QTGsQ=skfE]=55o'CH.>z4 z- Ea=zũ1扊F:IՃQz|QWnE9hFvgѠ ѵ(ՅZt3-K6n ߢ+⹲^Yv5܉l1[K".D6 .k~kh}h@.FCuٕ>咁ۈdȠ,<>m8 ڦ"wU`p .Hmx lEfmx=m7ZEm'Amdj@O'cDr86 7# l>?= +e^6ݏ6{=T{mпuvPۆ;/oW|/N +l¶{"%mNI ]¶{/l޻¶{bmQ{Zƶ ;q ۆm^vW⽰힙ƶamDۆ ! @`=({PmI*ݓ +l5ՌvV`Lm係Ɉqݓ5 lwF9>{dY ln&S=ѷȌmݓ r'6jI/ ).^vOt0 a0mL3})+kj upy6܆ӳ%܆mGSb{WVN6}fj"rJ!m<6WJ MK"땸0tK? +ı +Qh2 +)KI]n_5"{Jz/tnCFwPd=(#n"{Qda6\d.tm)<^o#QF65nxAa6"+գmhx o#0mD|hR 6/5#.~RR{Wor5<ۼl.ۗ2:ދ߾^6rWWo#ɵ۬c1*( "]߆7=?p,/!ۢ?.p/pًp-1髍 a;t-(g--_"t*YύAV4ef շiVȰF^H,Ob# Θ9|o'(]9}3H{IpNao䝳"Vj:/tvg`l#6L#2PDڥo-=TK\tf+"JGkWu'#"A^=;̞"*}d U\IuAQDեO=?C%jl H {xWe.n7I4Y/QR3O?x|>@Jj;!In} `[tҊTu?XZ256HU0S1VҊTuyV*-ĕnuo$[@DҊT:R0Y%pቢAKdT޿ﭮ,7_p|ݸ?9*!yD t*>$[Qs63j~O_s\5lq}#`xouw~?WюLxh'ٟro}EW~;^1Sr$VYF?~GЁ#Cql\g ϯOG?s`/EѕGЉ[)Ф\2^^%ܰxEonk 6Y? _:^WnVbؽ%t;U?}4nl.HkS/ +endstream +endobj +90 0 obj +<< +/R7 91 0 R +>> +endobj +91 0 obj +<< +/BaseFont/Helvetica +/Type/Font +/Encoding 92 0 R +/Subtype/Type1 +>> +endobj +92 0 obj +<< +/Type/Encoding +/Differences[45/minus] +>> +endobj +95 0 obj +<< +/Type/Font +/Subtype/Type1 +/Name/F13 +/FontDescriptor 94 0 R +/BaseFont/ZLCOHJ+MSBM10 +/FirstChar 0 +/LastChar 127 +/Widths[777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 +777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 +777.8 777.8 777.8 888.9 888.9 777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 777.8 +777.8 777.8 777.8 500 277.8 222.2 388.9 611.1 722.2 611.1 722.2 777.8 777.8 777.8 +777.8 1000 1000 1000 1000 1000 1000 777.8 777.8 555.6 722.2 666.7 722.2 722.2 666.7 +611.1 777.8 777.8 388.9 500 777.8 666.7 944.4 722.2 777.8 611.1 777.8 722.2 555.6 +666.7 722.2 722.2 1000 722.2 722.2 666.7 1888.9 2333.3 1888.9 2333.3 0 555.6 638.9 +0 0 0 0 722.2 555.6 777.8 666.7 444.4 666.7 777.8 777.8 777.8 777.8 222.2 388.9 777.8 +777.8 777.8 777.8 777.8 777.8 1000 1000 777.8 666.7 555.6 540.3 540.3 429.2] +>> +endobj +96 0 obj +<< +/Filter[/FlateDecode] +/Length 2190 +>> +stream +xڵێ_GXsŻ ۦ(64}ؚؖ+;٠sxHxڗHܯd,˒|>LPIlqUdLd+fJvwG|$OpH8gNÙ,R }}xiV +oJuuy]oK_7/}ՆBNXt~IӞ>mJ^U9L,Wc׎'ChUvΟT}S0~ (/sٖG>sIoQRR[}D$Kj M6< +ʘ[+dS*0g +`eyĂ,10Ҟ#6}}{/)4E&}v$Z\^Ï'= + AD:1]?/fvdZ%9 +wtFKͤuFgwcl*K>J@ΒV}4w5ԠBtln`O3ay}C',dآL(D:;7^\ Tn\"A>qO~LHJqV3kY ouAw༹aݡ: ZiAi"p SQIkg\i/T;[v[#j![~* VHo+! +!i48oF"EBܚ2KN|6n_$$ox#6Ō#(ưc?lЈx<),|%ݧ +(銊;Io) +>U v}.@(@J:F)GwBHtE]!10.Q& Fy̞MvA쐵,~cc4A(Ϣ`FPr~0_u`<@)4 Dv.tA"a*$ˠ,dCɳ@bQ0`l +$no*-;"qiLFIbql jU2c|㚏.?B`oKIdQ=񿐄&6H+J>(VMpQfmu\9? +\H w YjASgp*{Hp@ҿ~Tk -|q(0A%F_o L[ƖՎ@/4^&sB [a#Ԅq6\ŭ6Df&Bs[C04 EMlQ+ +? :qMƗZܵ K-6zTHx%t +NG\:חLn|+}1fB͔eCn6vuZg)f'&Keu}XZ yLC^7PJ,թ(}0ntҸ:]afPjh㰨 Ŗ|VΚP6Z&fWݚ ګ^|3-Qbv^D_;L)-cќ늱k5F(Yk񣤟I,rZfZ>8T-D{EZ %i:Y171AZCzXmNދ!%L^vnӌHv|! #xq37C$CXMjj-!qj)_ ׫ 7rl&\wrh#<> +endobj +98 0 obj +<< +/Im1 89 0 R +>> +endobj +88 0 obj +<< +/ProcSet[/PDF/Text/ImageC] +/Font 97 0 R +/XObject 98 0 R +>> +endobj +101 0 obj +<< +/Filter[/FlateDecode] +/Length 2308 +>> +stream +xYKWikE}&b060ytmM,9zLwO(ɖ'hVX*V^Ea+|zu͛xP*Zm +tuA: >K4GWכ8OGpܻv $Mg.Hw,)q8AUųyZX 6,t!qzǃkjOUUoW?8Vn֛$J +ݙBU<8I$tӢ@3y8ȃޝ:fbtkdci 3s&dۂ0NĶqfPnvtg0+`rV~!Ja[nױ +>.)PCu2b} +E\myw7xdiokۚzFR釣IW쉭z+d۹;fE3fdFTY0&c4BkƦ!YɃAif SvTrB +Ñ4 ۞g}BwAeڽ[pm08".NpZ6PjneOJA(zwt?[0[D|o7x@x-tgN7$К,Gq઼5ؚ8Oia<-H`L1ǰ`0JLWH:xֈp&]m|q$ 3۔j2 ѡMKa +y " Q@@X z3wC37rN$omW +Z,->d bY $HZ%I/z#[3I%@\\5%-"_X2"t" E<۲LCl78˔ӜCWjj_HEXB9C2>_9u'< Ɠ a^&MY%Iצo`0d(ov4+$|⬜jٕfpyag[vf]e yAaMEn?_A-?UF*`ƣ'D?rl'XoD1gh]d|TŎ@Ϊ $-7:^!Axwg[ɧ>3[XD. rJ4}KdbPfe2Qpպ#~(PTÿL+M +endstream +endobj +102 0 obj +<< +/F3 16 0 R +/F2 13 0 R +/F5 24 0 R +/F8 40 0 R +/F9 51 0 R +/F7 31 0 R +/F11 73 0 R +/F12 76 0 R +/F6 28 0 R +/F10 54 0 R +>> +endobj +100 0 obj +<< +/ProcSet[/PDF/Text/ImageC] +/Font 102 0 R +>> +endobj +105 0 obj +<< +/Length 1348 +/Filter/FlateDecode +/Name/Im2 +/Type/XObject +/Subtype/Form +/BBox[0 0 2384 3370] +/FormType 1 +/Matrix[1 0 0 1 -96 -238] +/Resources<< +/ProcSet[/PDF/Text] +/Font 106 0 R +>> +>> +stream +xWnG +Lf8/AjR!p~ݕdđ{.<|~ZuMwqT5>\Iqɹ6@DS* }asɢ[_^t?[)۪U4g/%sIU<$˒Ɓ<@򩺛ԎP)rru 9~]Ϻ]*1RZ9=;:.3#y%'iWwe'z;pbA7r;pye/9ʉ؁؍ځ |RμvkNvMJ-(rVnl 1;sۑ3 ;qۑ7qik>yvv ofEr vp{GKo_'L9nRϼ͟5 \X2+8a7txiy P;n'אKk)#=gw\Mvg׳kՙR}!vw_G.Á@.y:yئiTt2:O:$`M2/(,}BE6dXDJCg9(kpde@j*=o@0mi"Jj$7SE0S4= <3i=Mi}VX\6˴#ī#k@XsD^aUd",3xUSܱǸ*|֙X}66Tb["JcKDg+Z2Z\;UDL-5v Ua& j ohY\m' jNSZ2Uze0=4ߠ{ 0la&1JB<AVke8bgKWFL:-k(mt[:k#oG䠮&6b$:ju +Z)]ECZKŅЬ}ĭK 5@9A"2qDdҐSj,f/?rd^OX?oG<ҽpHtw+ +endstream +endobj +106 0 obj +<< +/R7 107 0 R +>> +endobj +107 0 obj +<< +/BaseFont/Helvetica +/Type/Font +/Subtype/Type1 +>> +endobj +108 0 obj +<< +/Filter[/FlateDecode] +/Length 868 +>> +stream +xVK0+rÑ8`QJ ]&]3q@VN=Lf .Dx}KQZL&*VJZ^l{]U>d6W*W62Dgv]}WZLWF[n0~6rv$.C>no1ceZ_&wqi>ܓQK +EEћ3Uߜ wRܨ͉m.2B,$bg*&LT,&%P$uD>MxYӆW.- +.cȿ8F]{ +?;X1L=[BA 7f]PnQ(=eap;q,T+RP싳n>ջ77p/Bsړլ+J."JJzTj#҉[ozӑfɟbC{$3>'qQ7?mDT]!n=Ĺ[)prDMo՗`z-Mrfn{': # ]1N92>}w(~bγY[a |Uh/=^`T SJñG1/%Kn, !QƃT +0.0)A4}avB~Go(4Du?Gob> +endobj +110 0 obj +<< +/Im2 105 0 R +>> +endobj +104 0 obj +<< +/ProcSet[/PDF/Text/ImageC] +/Font 109 0 R +/XObject 110 0 R +>> +endobj +9 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-33 -250 945 749] +/FontName/GVHGTI+CMR17 +/ItalicAngle 0 +/StemV 53 +/FontFile 8 0 R +/Flags 4 +>> +endobj +8 0 obj +<< +/Filter[/FlateDecode] +/Length1 714 +/Length2 4312 +/Length3 533 +/Length 4862 +>> +stream +xgXS뚆QzF:HD!$R! !C@U ҋ"K/ҫ4E Js}\oYߟ>ﳞ޵rCk1Q1y]1( ϯG#X:ɉT1 qHLZ^BV^\zHHM H"8>vD8]X4KRqr7]Fbb I١1XgKFƻ D@(=j{7o1CpMw''g\] hx2{n1Gkm'rщς'~E& (+h9ˋp}_ҁ|502yYkkU~-}anڴqt˯i +Uh nꙬX_'Gk<֍RP@6RqsD2RY[F(SPrO9oI!}>wiyT%i+d]Ҡ?r*ݚyv%$țmŹY ,AC@+ٓF=7#Q1O9%0bay_NZI^]U^}ejk,:?4<zYҸ'bQ&;_Cs1eBk05c5f܆]Jz⡒o㕌 +9T]|gihA,sP' ʷRr4 Um%d'-;&)!ga(NaTײ3?&e>WdH$Fnh+=gaܭ WN-̀T-3_-H;3v5^+yȿ"9@2P,r:%TH]Cja}ȯ:h{g~4os{uVG`TĵSTu<(7Gi~C2-;l ~10c6+p\MN?'ɕlR3D Rp'$XP/{8~gWIAx7S5^P a[.`#NkykZ] Y#).${wwK25!VƓɒtHa|0*{p(}UI`jd~RنeCl3B ]u_Iգyq,UmLjx.%8}` >o$B0,+(UJzN[h/ׯr0ہ7?4li|F9e%F>$ Xy j ~O[!փ֢kwK TA\ϞW`RbQt.zEvɗL{9pfHg|TnH Po}N;#Akt/Xϻ;o}]JRtls): ̞Fkvy2wNy3Pq9!;vU]"<@K3bjFeܐP %(#@I9KW9&Iq42Je+0l ~aFuSW}P@ʃIE =WBoU#B_/mZiwe%TЄQ%ODž?o4 ,i>fDc"^iSۇA 5cvشl} /6lb{iW-Av>>G__˄wdI*,z*K{S>bEfYd +vjɇ, +Jp{礛.‰BYY7m|.N{\k@S4])GՖU2yUxY᥿EG)QO;T&ecVus+ʧA T s1Q݉0!:J)g"Eh"_ӥѻc=?h߫6bu'a3A.ޟ 1U_H)6d _&f peۅ?b0O5>G1+نȔZߧ,T[ۅhLfᘄy~G$1sߺ!6bkQKLu-.XLnyJ=!Ǜ.&yV0:/ w݊Zwlx.*pi!4DJۋ`4<֝ݩ{SC)*4r1Hb%b?j2 ^ƪ0eo*|.\p!X89KL*I84$!%Cݟ--vʢuhߖv&^W&,Ry+Z%RS*'le6JÙ"ƛ#Ls?+VS֞Zo3#;<^;^o=y#s|TQy̫~ʜd6꾒& Z=k=U}y˃ +"icEч8GUyu.ϑpRR +v &purõX9P08|pa1j"0?$'!W LYŧ!ji0Qjblĝ2؄FfD|<4Sifj e54fc-~X z#:axyl/k'c!af8 a2~uOb@ZpS+*r}O!=c4" JE)7VK6a2 {PioT)MɰX7;?J# RJnLݷuq4?讂 +{jJEH22ءq͎ʦ1~)1 m~7i}MVzO|jzo-ps6<m]wr y~"18tH;˥>ڹaHWICiI +TV\g䯠_L=EZ >H[:\$ȽΧch^ț(%$M`W3jFJ^'~6.r})+Ϥc[y +Hv9{p;kxfAw"+ $vh_in鑌T/q )Ƭ&V__m7/.xrwH/hO<^D'}-sk3=*\(!6q5֑D>ňBJsÈ]3J]^̴ͨe꺘=|m@#zW EW'Q8P/Aʧ/7*\Owy7/Df5^oͨU:/%;"iib{5q{tmkĎ~Zxx>3 ҈Y gzx̿"Q"q"mlFTd%e-pYK\v3 , ^d̙D0J67e_W%9-QJ +mSuzF"'g $w,#yg{d ;r_ًzn+,\"C:r~1!3ϲJ> +endobj +11 0 obj +<< +/Filter[/FlateDecode] +/Length1 714 +/Length2 13114 +/Length3 533 +/Length 13669 +>> +stream +xUT&ҦVCgsҫfMIFĝw\Od23-##@XV HGF&hjlig+bl`dl\\ ppda;{GKs g0տTASGKcC[?&Ɔ@ @Ԅ`bi 025?i*:: +-`bjG/gO7X_ (gh/)X=/#@KM&kjbb߫Ά@KcA[s)?)K'1KwSKgc !yS[@/)-.,LO13GKw6?zoDmL,mΆ&&3B ٹ{2hXvVNTRבּ_?15u75°OdطD1]|93z [ + Vx\E|PJ}${Ĥ6⪎>Ck6jnc҃D޺7s"iXY3Ң[m<82^uN6BcB dR}U[hh(jΛ{/;="J/-k i +Mv6`"u>e!%xRCWLޮ`*"A+41Cim)Pq5_V,.(b7i_@Y0$p MԢMW[ZE:Y:,XԸK1 8[)\ȹʴ(f~i/QU]2`|JY["*؜F4V.PMgŰ{F|_|c~̫]UB"M:bF^?X15 1[ h[켾>j'8r*!,,%[啹s,=.ys·N4R +\T}oM)u" @F|^^ڬ,v } _5-R.m=R0&6 U"ͺ($^ߕy1ǠL *%Y.Eq6\tLUU_iYyf˛n?_{Ȭ.#CoZ& +^ჼ3&bqխJA/JAʄél*2F=too12N\lR:ȶH?,/FӼ}\mz%[O;&G;JȗSd6їl -LږulGzEty􊳹'eܤC˘QQE/O"Eezż@Qa +`3a(m KoU뷋.~^LpH?Mn[/% Pe>?^mn迼3|U{aDY9`W4T=i +!!#ǽ +oNE|kA(獼4\D-(3!QpGy|f%,vSPLxܝ6Fq-)ʪy$f3{H7 Cx]R>B'y o %1}4"#V>0e΂DXx xa1nߑJz\Q⶞}xF.^Y4 Z7Q2.N3,D\>,qv|wܹG7sYhvK~_9|2 P!X,0 [rA +eJP)(f2 |5Dvgt 1<ި}t}P(u0Téei&1j47 bDO'Ȇ@KIPdDn4Hk>P`7GmR8;}:bۢo[, \v'׭x(Y=cV- )Cyn%o<`qx?jK,2,LO6B,{S-|Nnbm--E&C1hk^9,BRfBYڬTWDbk~N5Zn=:2weO(Еuo #SqV4<=~0IZuJ+(XE ^m{K-U{ExϬiRCj.Ħn/\Qie-pa2L&ZOY~lfe89ݏP36WܩGʤQǂoalD;²C$_ 5~HK +Z6 "I @M^ \@`}.| eeE*eZm8]kI]MB9m'U_?Ԓ:Si(GcK"#SRľ$~?/f7x +*]**=XHaݱ(g͏]}5\_ȉnPV^\E=%SL($m>jrC*o&a\{0jwj/ͥgW?U|lrߌdͼ&Y[<ΕP9AڱvT^ݕE #ry8|jDYB#@%rACf:CNjc+WYtj %՘Xh4P#<Ŭњ 1j:_e'Bp짹!Z-赇D1˺+ x.Io@ 'r 7G}&X"i!fX27?ATmEF3 ZO lg s)*rNrBvF_*5h4k9&NJ)!JccQJҽnx8-@'EHDI(̒x8cZZ +qO\.UCZ6[QiEzIw$/S0ܑlK A,9mKJ0U?!3;e3H+4Armcz27 +=e 3o'B3ܒ}u'ad /R0w6x3x:&z *Կ}_e1g0w]~>?.r)0K&U(Xﵓ+[L|2 +ߴܛ"cSڎo1ZP^#{EM,(%xG1FOlT`Vdb9·{;`J96!A e}҂E:ZXB-rT31[$aeJGyTnSZFkdnbVq4Tzxi~CVӤO>g; + 5?ךqus#-s#I/I'.)svġvXa| ygo+e+R.x9AiJ <ʘ`(AQĦWD?Hw~,x۠+&1 l] w9@%̘-Rn|Gq>>x5Ǘ]m{09rj +ƫeIn!}2Q@u/Y$sb0W,5AТWZQ':u07V&~GRB+=d;Cy眆hoA˃n A<|Ź] hלey|-ƌF~rF-F!%fb?7?AVBHؽ"ht{Iگ1Lh`",=uٳE˥rRm+udh∐{]zܓ:* D48eOo#L<8_GVK@Aou5K~a#Xx;Pw #bi˱z}K}M0RC #k %YLဓrF촧x R7*aM2|;-> `w]zRTa% Vע Cp&aMQa~^\wü{K/ܑ?͏ F!ԕ[3mWT*^o2[=4i: L}[M'%{LG/~: }&+02:8_wXO[Q9Ozߊpm̖Sܚ `9j.MD &Sz(Tw=/3OMCͩBTEɯ/ʜ_P܎< oE4JS#MT^dZ%+z%^IÀ\:cDLzͺ⁤GӖ mC3:']U(1"8i@mZ W A[KP0֘'8w(Y+|}C?QbQXTvi\ƏE9-p~ 0%ul-*~ Xyh]oJ|uwOǀado7 ӴpLF7aYL`2HR3l^#m,.ް)d?<='AۋI?ԉ'3P0o0q}åMHԒIc[*B%Na6A0UJKIJ͍f\Hw+}\ GlCyF,#0Urh| G1'Գy]$>A vm5Bt7}&0kpX"coKGt#׾ Myl;OrlVm" 5^6a+{c= x7({de%O;ZwR );t$֍^lpLN6o!#3+W_}{[en $ Q!1D5r}^fDi @cQD[;qUIJS%9}mkThpW=`{t۾&?? 1pYx)ֽKa mv3SCO"cZRyD1 DQkݧtN6=~T ++,@\^/A-60ByB ?rvЍQ$|6 ֪gQe Sw7k#6W˥oAg}uHI)~a)_׊݄ e:~#kiwSHf/3ui =ޠ!fJdQ>"QH=uתּ%5ۗ^7kqݮF~Dt12;f~*@i#ΈO.Q&:Af1p PDBr +WGZ{uW9-Úl ' ++Ik) +'rr)d48_Q)$ml}.n[Zn+*T*&$󆠭۞][: -lvԾA1lʖ\LAn\ R`f3uwkjbaǞnk|E_r1J#(10S͸okB +6j{jn j]1]: +RVbUaXqԹH}ݢ HIJаt> 2WRE@O:CBZ}mHYnA!KeRy/pW#Ci'ecWj1Ve.UfX%.V‹ت^#n|WQ74쾸.敛C_{햫:CddIR%.k,5+O^ ^i[NVQh>*p߫k*fDMUx1Ξ0hpjˤn[` +x~I)ڀ71k.a0 'FRpŔI6u8sN_E #@ׅJRUFTXmܕܵϿ'AܧQxִv0VVG5׈x +tVpfhs\+DŽ0k3]6} W!<mklWCꇓ{!Oˡʰ<AMp̊B݆Z+x^qwcɷ^g`Md/[.xڦ|hD(㑓1]gH |8oK*&~ʿ*:"˘0 ,Wʱ6cNz+zé.t/+WNs1Ҝܳ4A1yU-Hiw_+{W}jMfji!Z:|=p'ԉJ'zE(-7KAELSy/,VF'$-̀C#'6 b*&Rs ЖQnl |__/TU"[aImS1Gta>t45K+5LAy!Ze{ߊ Tq?|lCv؋=ʇ\u3_W%ӌER*E;i$j@0*iPMW-; +D =t17>'Z{m%3&5yw %VDEk7c@>㊍|X~CDܮjXH˩;=pS!jOD~cWWB/-pbC! C? F[Z=ȐEfF"3uf6 *Q LL6OA*; 5hWyHk=UXlSy!:68֣We*7)_q^]K=jzfٻ hd𒝠֎ +!!$}c:C~?J +qC0^4)/p:PVX?dIR'A2bBgʐ?6ðUxR_ 8k5&u^I$>]@ Gr-s )|ȘEc!'sr׈B'ԭ.McT;?I_*(Iũ*vQ +1DQ: +92 vdz~`z}fHf%m>dy E5/2IE(O&jLf$_޵юˑO/@,b2uA3.HwP":F`o ;ϟ)(E6<`4i27RN͢WٰL1;Ԅ~dD$' +?mEQh L]T<*5HD݇eDHgfY +~IR#lx4E zV:償C_D3/B¡5gs7=d+x_ùIi)Y?FSZ! L/k.,3PM;1 ݱ<[tQlhEo/Tev~jS_m>4قtAj2Xe¾X~ߌn{Z~1hL6PZt)Lm,knagABdд+*2-k^I{-A> I^; ?E>Q +Q:o?.c/k!ZzW :NU4a%^\M­YGb7LWWêa*2UqrX +/lZ $[R7uV򩽄Z_u+?B=>)_vI@bxKi9 b V&ҙmIŔΑ"_:~+hq]^9_TphwB]/t3)kT8Bz![xoHiq$j{gV[U +MDhQ()<ήP+?^sVZDZ :c9BsJ\+Q>)>۬0bm/<;>g t +̄*Rjuٳ޹)xv $$1`ߒv?KQŤ1FܗGut"eeckϒꊁ݆UrL,[۾]̯=ú +i`p/69ywUrDHӤ+2b̓C g 8ii')v7$mb)\S|5 ;mBrT#_}> MgrFCbuB!e]S2^#@$zGGl'~гP`[2NbfWܘSJ_'yMuIHMMb8V?G<ф-k;뉩ꎍװ.LݓoFewp)?ya-TZ 9"75RpPZj_+_rk%f j}w-ujea4xr  (€>4eΉ$"z͙kǵ(j + #ĥr,mG6}U=l._-E< iAG_ 8XߕL` fljj2 +[@DVnLFT$6fOO#^搼vV{M;$B:ǕG?ZW[gOUgl+-KD (~^moe>;I{{c??V)BeV:w]IH"\R#*F*嚂{=f)qcGoy8~Հd +^E:9B5la/<ȕ#M'N!:2a}Ty X^!_Iu)SDt/nkQnpqؤj<p%j[|d!SDZФ8*Tg\4/>#bW + tq,WVB~tlGL:?89]@eW4󣋞Rp-TXt@$N'NiC૵\EHM.A MP-~ +%PͽG؝%ŀ lAB/ 9= <[K½#\Ð@<+ op2K>Ӧ_zSEu@bs]~cYso7Jg);I1^mbэ!3šiڞJyxp]x6Mʯ8c`/RSшMbVwFrJ!wY1LVnq9᡹@T!;\-:0Fv$iTRsKCcpD]eeGH1q~F6T?_J{lFH +PAzץL8fA֗*q3uud7ԑ[օ=ȼ$5@S#У1SsC"I&s01!hig7Vc~8K_eiRS)b0\rZ)c3؜LJx[(>%# +lY-)?0VARBa9q1V90?h:f(=\ӅAIդMrrnGh)k{`y9 ҳ+&s+ɹg4+om}]-JLRt0AphB?PaIt">1lrU1L'񷩎L8ZMGMh)ZM돽!D.aFKbܘfc#j bm5V o U&!OgkiNev zo8zvo/~tN/7 G5c5\j-^\4 mR?}Wj$/y +565B׵k )/%{NGd_XSd,[QkeͣXu\cEMД_&s+;`j +uN;<\ogeY(ɿ$cЃKuDz;w!F^&u93gd%-7@ +#ƐM@p*4[ԯp2 iKPx,ǁ.Os wbbZkj8}BbBnԖ7 4)xjBqMn!((/RCΦqr<%sh||H a'0#˓z +\U :եx5ٷOȽj]aCGW$ tP14 WuԼ1rlBo7c +]*ÚZjP +5)M^v<A>R0d82,3i-}R< 1ek'H U8{T[4r50HBψ/o;ɖr?-ǟIbZ85q3|ǐ?n:7Kg ϴS?e񸁎yo4MC@TaK2p:8`fH>Ѐ9LH1'VƃGҤa:皡"3DMJ0)ݵlCD8\Ie5۵2iFSc}>?4@HTX1\ZW^ ';v$ ;Fm=$A."o嫌{{=#:h63WrtLLȽPKPӧyIϰʾkz]mgQS< l}װH6hULLtFCU~~֋4t*_Ohp3i_J7p[_Udm _ʈ$`aˇb̽o`{Ϳ"*"1ZJh3@痆ZŠC||򼕜dZ_y툎?NLIdb +_j͡fe$@uUSx0^p' v6ppw<~ +endstream +endobj +15 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-53 -251 1139 750] +/FontName/HSNKSH+CMBX12 +/ItalicAngle 0 +/StemV 109 +/FontFile 14 0 R +/Flags 4 +>> +endobj +14 0 obj +<< +/Filter[/FlateDecode] +/Length1 716 +/Length2 9220 +/Length3 533 +/Length 9775 +>> +stream +xUTѶ .qwwgn .ww9ۣ֣^j?5WQTIA,aoa`adʋhYN`c1dX.@Vf ';;@ wpiDi +ۂLK_Sc +U3P vr1,,@3+Slae`=_i3,rirRx&Y7Tn.bc`lՍml:@x&]2#/H?L }>.g5HUm yZ%^;ir!fRl;{eQX1,x +/f1}˶"kz#-fJW %^H,JP޶v_Li@!C,4)p!y-A +P l||u;δ4Ft7. + á_ʹ0| +KXRDC7l,G `yA4ݩ>giG ""&yjg!X% .1$v ?;yB4f\g1_{O.gf5b2݂yfVv^Nu+_@vgJηYY]bK?=|MnR!89%*5@ u/-C%2GuO 4|P~@E$cDXUO`譨933  w:L@Ƶ61kcт(:U{ +}C-M^)0  &ywIķGHy1 5#MuշXcЮ5ٔm紻'a[pK~Eՠsa9-92WxO13\lamu@ vTukpoZT|^a3(@33e9DRp`z'K՗5e):Q*V3֮:awDsH#1_A*,Yb{UCaTh:6$gv*[XTǃy_⻰?\,YݥuRH +HV76T?/W|sp*~~GWrAq(D|M-4fc,80C?ihk~Jݯ&>ncZ?m&BߓCFAI`kP٨qWW"_Wօ(bEob+: F!&Nd3-ݳ*RkZ֭hMe {ܨkg־ jLVYr-JŢ: UzU+U>iޔDV6ws}>*_˙;&ѓۊH8ÖɫV㧩j";8kf<$ Q#_|gyb%G;O9 " k`on:3$#aE 6;)3B&& H +IHY,[苖m!l$yr ` +3w4$>e |HuJťau]Wj5S\]`CinO3|o=^GJz9:" 3r?ΊA(yE~TP; !`;HeW"ƒPx+o?)H*>^\nESe5B&ߧjVnR*SoI9i}[.?J,"m؜i&T, U w9e_# ))/ +lJ0E8}]c]LSFB)绮nzz8SxzNRv7]k8S9tSOiLdÃ#H,' )SO=G$ 1NgT!} 'c26[' v8yi."y__uah3K]k{S WHzd?Y0QfmI8J%aqbb 4I" 3p$1H˗6MףeOж%[}+K# `^4.W93o~M"%jB|ej:#Gs./I Ū Kf!4@VA4v ɨfxc5?Uim~M茙/5lxm2?V?>@mȺ:"6艝 +ήbnj%NH˯>,.mzv;r*>*w*&\x/8LWoD<\-GѠ/SGvZh+7C`o GC%"]`LYP7edbH?=~tapиK;XŇ9 v^l"+ dSU.dԌv3?'FTFdӗ ” 휍`uU0~O׻]˶:;O{bMV ETEk/2|Kaز#ܰoaf46ܘH +¹*9PbYpC$3$̞^@_wl Q]=+!dnۛJqmDP7&ׂn0*yt&CbMҷ8G5 -7(Y,Ȯ8|`SF5?;Y'3-5-W_N{ ,C52\t&^}  +G?,Tb14AD ,9+#HLP9с͛SpIN-gbRDOb;@g W}_'RY?8%lPǸ!u71YDJ_+0Oa)T) F [R[a~I1NйT=[uK~]íQ|{{}K5 vċ10@V6%L+7ib,%C%e}2b4]InFǮ׆?BT,%-MۚO{+!{&Co  0YQJw]$.6?4v+\"ADÈadaSʅTy۴q%P&7M}]1Bg])beKyKQ@sG氙(uq3!YRҗg)0JBus rV뀼/9&tU/󪚟dGQ"'t<%tFYAUZ2P/Z( !5̦֨?^.#F,vJfKjL44%?mi{f msRWhN%jԄ9+kInf80dxSm3JNaׯAhy{&-dƦYMo%ߘU$.{gz>OIxdQ0lm6@(LV6Zʴz0󯻱JBX]I~y̵rxlG@4bܼ>CiE"*>o~;q)yA֛ BlTGK>Xմz|49 uw;Ż\ge0\fjI1h2WS#T^IՖ#T H*i;cI|)7' $o +ѢHZ2wq/huӒ-}-*yǑ9a ڛ{Fl ^~ERnK&17JG4&kp3O^pcGRX+q44&86MTc U4;fJBޖ5mWr4bw]1Zb + NץrÃG43i>ρ]/z_LV'+Vn1&(a'5/tؽ>%LS]P~I0*? R1܆3"Z HP/wZƐ' ghIv- ׅyZ,&kњTm*~W!㒴nІdrg;MawjFȖ@y/I+4rv.`ϊVX3LT:n>ZI܍RP>TwnZd +^[UvקV*Q옇-ٴOK\C;,oP_e7%rt:qpF/8L1XqKf˘r0m܇fX~F@X\#x&/Vq[),50pՙP_R!rJW<=)黻Xx6g}LdvsXȲIង(;`#0ۨͦ_m[6.Gow Hӌy1ģ!?B~1Us&'4UBgם4@D9w8ljysڔhds }[&/U5fig%7IUߘJ+靚~*S.YBݖMJNFJgdx_3CN!^B vPi\):,\mP-\"Q tgȀˁQ/b۲*$:X­ 04z+7-z 9C_tQ ڼxľ{jA5#VZmk&i +hGiϙ?ٽeL,k\:3:%yY9$]i Z cՀNx^2(0io +bFIU7qVԹJDİZgbQkc_*Ti0%[K)+#1x ,Y,W9Rd9]1q1ST_CCxfӃ@Tn3WN~(ny=DU9\Jy4ki9_>Ni3"yD[n.!dJm?7!דJ:q߹8\hςC4waйk`THTVW`^b$..gO7didp؄`3DHp7+a4f4KHqd|D-`*(%SzhUQ`*o~{vNT<(u)܈t +U7k ~oPt,Zy BQ6P8s=ard(g)v.3nhKA +Hj/$$. +[97WhJh= j)l{V'w9>3%PE&"&yQ#NUH$8}'drj +fP95ÂR +z+?CJ( <ҩqv$eU!Ǚp *%.@Ӱ@b0/ "a"ٟs3br\?I͡_'n{{]ϧxCI8uGʌ?t pk$W #KT)LR)۪tѹhLggq:Pۭ՗ZAy_ \g:poO1`&颭 i(u(_C4N# +2 \{$ES(mKXa,x#&&6ɭklseNNj1LDP@Tc71Rf>u˂mreBY$}=` ijVz~)|^`'7قgV|:FUINL4n XI1_qRیnKxPMe.賞c +/ܷWH1:2&td&# MK xޗgť:긎y /EX)70Г;O(.hԨ%දvEƞY1f*SAfݥ hbE ƊW.MvV/n.6?H CF'U5\ +Do99824$0?nn֚q7~"|V81|˹-fHV)b|ꓟ77.JSn:)T.>|v63m֋$uFUAybMRupHo~ ]{3ƈ!HbL~.9M>.-@9&8s#$XME\B-jXPÂL3rRaKJMQz1ڏ"lWh[mQ UwyxM7LTC?DP-W18`x϶2cjRF'kRrw5yx9ڨqE]o 5R@(c7> q8k; +͸O@%0?ղQ\]Z1ڗ8alNy6WXc'[5B@邸6n! +_Bǃh|+Y㓠KhD\K?=b1]b~jH8 '|/!r~^Ց/-u9:)`ٺJZo9A`cVBCQ/ +qo hṇp[tx _6*p7ovBSCZE?3B{Nf S+?]Fq +endstream +endobj +19 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-36 -251 1103 750] +/FontName/WNYMOS+CMTI12 +/ItalicAngle -14.04 +/StemV 63 +/FontFile 18 0 R +/Flags 68 +>> +endobj +18 0 obj +<< +/Filter[/FlateDecode] +/Length1 723 +/Length2 10822 +/Length3 533 +/Length 11383 +>> +stream +xUT]_w www,Hpw< ZsZ}U/ݷ/kg9֢&Wd[eN,Ie-yv; "5+$e=l|v6nNDDj$@'I.^# ln t'[}Xq[@7'Њ`eg9!5=.;aQq )@a mGu8.L$-WqxB wU#ae@T3̋IYP]#b=m~uGޟ"|;tOS#n`D?3h{3RXIwHïrY"WWs6vHzaE{ DB"Rdz]߱iO^Fzg8qՈs%L5>*DuDfKĘ^kG*HTbo/) ;٢ vMmX5(A왃PVT :4:+"YFulZ渫ĞY{-Y^%Rs ̮["֜Opo-{O$6#Ouf3\CM] +nBĩ0ӑ34K}8qZ28~9/ VYOZ0Ҡrc i8d;~qMqE73-ߧDvr%hµq@;[ 7VS #ab=QY;)܋D9,my!C }%FN1TJ#v|z6 v +elaI#"Ո +]/o{g2%ޝ*Oh7PH;־(kbWXďڔnkU]Sll|{->+gfk]-eRlƸWnDoJO;Fky\0ֈw*  󏞟87`8G_uMZk +ِ{~={hq r0u(N; +uaBA-QG`Jw'8X1lۓƮ{i7mFe!UU\e0 RvXHGE"֍N'?03yrciaե\h!riS )zU.t%<9ZaK,>ҵjuЪKpcfTAزA ɖvf?{!>9Hlt[@?vWxڧ{[x!b%@׫, +"pt/,qÝkJx0lrҠs*Ǫfu?pSwD?LT͚4-؄[ ckf`[yLWg>T2߽%4'׸3*RRHr8EJA&APt"&뚓<~9(5rtS(cpҶfLH˻p(C8xiF[z?;m{-»ۙ>wydWHT~v%]f( 7Dv>!;$u6[^4AZ~ 4g'"R A)O"*O9SjӟRL:)K4AX7$s

&!I(ɯEޫ1_s#&e/2 m#JIoZ +E<1[/<%Ch3khhJTwy]yـ~c$1| 1A@Vƒ(Y!/x;x_Ѧ[s\S/y@-@4 ئVy:3_=章7V怏?A;_仕RΡBYjѦ[^%=haǦgzX:)%cFJ9}w׹q ٻ[v +HT+qAlYHG1`G7Z KE"KC.qeSp˵(J'KASGITiu}蔺ڛr$5龩p>fU0CY0lKaԱNDzx v#/Ppƹuǖk +,idNo0 Z{@- Wg^E]((Np;-X\&-Yg_>MTv)s(ּEfZ۷/ ΢.fIh.=[(/wj\@2+p%aRTA0Xb4+ʷ~p7-ǥZeS5/|ǝv :(t)$(P(U{UwŦ1dRԨ:u8 Ŵ!w}oa쇘-?ADbJ@h^7nW ҍSZ~ݜR P7i5?67c#ztm^q~˸2V≞~ʊ;Oo9'N,:wm[b8NYب ;y,YƻJ>3p7sŦfR̩oe׮aS`^OyQ=LF4RZkx 3e1uaPG@v4$⌱bJZoœ#U#W =*P'=-f +UDB`_k'K n*p&Ǟfcڃ#PAj{7B!N/{Q淨 e:VBjn۪ ՝dуA(>7Z7Ge +y>H [DGe7*p'l0ߚNCޏ(٥˄bw-r/*l7u[5:íAx- [0G|x7ЏV&McP W̾.)3o0|td}ct;ćӰהYU"L02U9 +ٚ?ӊSp/zbaE6脲/aBs:19 yEedm =CKpٝy6xˮZn? !ŧtl5Y*|&5CW}WGrsi˼2O/rAsT|!E 0(<𳾓IԶrȸA &28aYhv+ION*Q/~fTD})/O.>(i2)qP]\kum4r5].v̀Xd +Y9)tq\PҋRj;r{zN} Js,qVO@;S8BșKj'B/Q0n5O3Jk]ji_"+XП#)xEȐ]8,"ʳz>i3}y*)~B\6t)3𮄀?-B_vίq7;DL>I1U5$ SM0NOo&{2T+GwT9}HѴV;l:4"4, 7'-/eĻC :opjR˲}YӼXB eWH^A}*,ʭ#c_꫗UnMKr9ޤH! c_ ;xI/퉊QET.3#{[$m֕m{wHŐՕ=gxv.w< Ie&c.Bs*ڭ"X نCܵqVjÛ^P{o̤0kdss58}_%nMaW`6smKI;,6t͖}INRٷnPؼ9_? +}Ҽ; A{j9R )>S&VxHN7I~X1Z1Ú.:*+^ϸw41#?9ń-v*C 85ITg:h3D TrKm>Kqm`݌4pwb|}BЌ6hsOj@}GxL7`\/ϑZ;|mQ¦2|Jϻ@Nf&厶h -C"gq'j8cV8kQA-`MeNOD7p%]ulzQIiU1ZphxzD,\<CC{JUr\Րí<@q vV`IoW`D+v&X( mh%2x$ahmucְUQM{4:V61hѱ%S 55O|)T%񅝤>H>}UR&Fr歽j!f_6od{ 4PEϯ +qTi~Sy{8p}Wm:2^GTW7*] ʃ6CcAXQ3L( .8AITslx ZHO(8kD <\ 6sJ@㏮ )mpR&#y{)F8%OlBF˸qNGT}E(``N/:AN6Yo(A53=9,:Wj7~(CLR:nxO./J!HMe a϶qS9Pvsj-58H8k$@~X[9T`5L/tXɐ4pa'ZEoi󝇇H*vR,[q G +8JٽcBS?fW*Ta눧s&.@8(9zwWۄymsBɾkਵIx[JSu+$Ԍ9h"#S+z*4B=NWnVjduwӆ$5=)iň](i.b+RIȹ@V\F^O猂a"[G._XEJZ]EsOe)s2fQt>/6M#8BtHDr݋<㭞^-Nt +h08apa*j™8Q(QWbNm2T=MX*}y] +&).,C촖Dj8cytgăeR)_γ[X@FM/:Vۗir6($@kTD.Ƨ 0y QBXM=G~VF$EwuPdYYd'%ǃdxvN0bzGPRHP{-N~aot"n3UNP|4eRg1n09llpK* ]'HdEMI}_z(neWl@*8zX}8+|=B7@QR:&(u1F LfZdջ짭 gU['l4kf,ܼǧ^:QYHy w2Raͺ?fsA ZOt!:Mn¯QΝذ +5Dʌ%k;vzk(Tjr +{Bώ-H2SioMjCIk`g|*pzysB\,ok5e ni^Nis<W'h9̔3amѺ8ăNx1Y.kӽ0g^Sqg\k|WD$hX.꺋QsZf"fb6S({zl.6C554zX!^Чe,paKJ(M+˳Y Jt®ldriY_)$Wg\}t1;@rUPH;O.a5W9x mي{/fGCn C DwG~7LeM\a @)}*`|/>[9F7o7HAjJIdkD$-h…Oȧlk ƹl{MINDĤ-080 Z$W}֡Ւv9 ɍz.6~ ƶΆg;CǍy/qT:WLkgU,#tڵoo=ca@iݤ6ZQ?)Tv#X%~Sŧ05IܹJʸa9v=LT))pxg,j"n?2b6ACsHPRSϱ("A%~KVUf p !2~9"y=6R_J"S8C6yUJ !`NvRb>;j~M}2ab. y^wAv )mL.bq;ȗvLc:jіB򓝬?z9_;Ur+a߻KztceoJ1(X"9M?`q^; DyC%w(028xY,YLD)I{3],|O+x,E }3 ې/ ?bDb n7~9A{RU]{h1ʜ3Tt?3Rݠ)]avW^X~18tx +- +wf +{&}GNALY%WafFճ7XT"EZlA~chTW΀=O/u p5н0 ]㽭mC-K1IL)˂l0WMK?'pBgS Nk;^reh+-E߈(Sl,68{mi5CeE;ȿ`:Cw rPr+%햸̲bk2Sj]ΐ?EHQRmneEh1Dg^ k:M˷mfgIbi&Qk͏]﬛c K,cs7zͧhIfװm m9rZVh V&H9K2WpU8];zU_ۡ +7tJf2A$I$'bt9*塂yEWFt+/CYs 9}\jn]swD0oPpY Y(C \>?3qRNLR>y' (92g'јiؽP/bŁO6_&Ҟ{Xxd1Z.3άY_6T&yWh%W8kՅ2"Vw'UbZ2wUKse>p8v(Ō2x{$ܲs!>cYEmT@ 0J~4xdaSسfV3@AĴVaA禸^NEjsNbAEkDxn;yg櫙9H(#.P+1T Өb8Sfa)Ex"UFh v\*ܷYG};8F8yҮsѮVEn]9IKeXbZe h󘃐$ tM!8PtaW$V!-h"~`jp2" p@T4 nwu_c骫Aʕ}>#fVKw4s?y9daLz._>Jb1fnXҬJqdEU⒮DHBNʽ!=>zYŃ)rhG? q̬|_ŘuJtihK];Ҍ_4 |BҙC:5;!%ó\V㸮2 [CZnMæiorw83XA?` ]XE +endstream +endobj +23 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-30 -250 1026 750] +/FontName/JKIHRU+CMMI12 +/ItalicAngle -14.04 +/StemV 65 +/FontFile 22 0 R +/Flags 68 +>> +endobj +22 0 obj +<< +/Filter[/FlateDecode] +/Length1 727 +/Length2 9551 +/Length3 533 +/Length 10115 +>> +stream +xUTѶqww6qwwlm<[ %!s;~o=˚soͪ*:* m6IkK )VUU(tt Xp + +<\/// + +@`f rT- v &VNm+{ėtrhfGAX[A [{0 +?6.=]r`')/ ` APsrNNj[?.ή;@w>_p k{O*B,$N ';_y{9{=`cgw'.<U5,_W_Ɯr]3n`+k{-@bpN%% q@.>?/0*bXƧP{xH yߐ[@K-k6Vm@3}I/г\S#NLÓ|]>Mrpnz>cr(Q09Jm6En\և?܆~M(\yr¼2Zho?`eC!N ƙso%uapw? ƥa; r8FNݸso+z>V\1#7~ a,"Y >f+9[˕zD)rn@ۡT 0=+2&B!@`ZԽ5%mZ9f3 =9I9Wᧅk/eV/rqfHXvkxef2[j;:])5pqlZf7]#_t;XJxvL⭿CΗ%OL( +(F8xTTGć> +_E^Ғ0;"вUgАJt I]x}b4w=l(G6dONrӞv%cg2ٟ}|{´Nةps癘;ky B}L2*&pTZnٔ&lkجʓG>PO_Y^Z]'ӘBlgHg{: 8:Ls9Dt1ܼUe +c)).%+dz>LmeN/.\IH$W*G A\;E ,:H.o_f3`](;YDNq4Ȇne.CQ5EӸDM8T( ]2yK?9gLÞeZOu)cq՘7!=s^.3g_knB,}i=$i~d{7hbH8zɛmA(8-j& WQi +~o9"=02\u)/ Q p_7_qО'F*m GB( +ͨ;DSsd}ҍ=#Eyכ~EaC CGQR1m?+`2HriC7g#8ot"+\lwCD[lSQ4)і7jS/Z +F0Bg.tb cfkܟM  0vXgGGM$EmlR%Wo\3dYwUquUUV[KS%7:\ mBu918v;=T`T@"@ [:/W1$ +{Л1򂳔ȟzCq11Y /)n:p e6sĨqM$|"< h_/RWDD/Y5GDjo?_gAK٢ }@!.;cS..!+bL +)0eyƴILZ3k +1^i[t#gR{t-ÐH`z,^zo[m\U﮿t9^6QBУtI&vlA[BgK' b=VR'Z=t;bnM=5Atn!Nk [Nued3x+qn׉*K1/bŎ0:){"Cğl3GP` E ?$LbqʇdwO1aP[s(;cRKm0WDBEv9  +O=lﭔ +KtKox{'`$x>p25 d[)=ެ?iF45Z .~:h:`QZh^]sa ix=~2|intJQ6ApB߃~&;>ǂ~h]M[h3K +[eÐ\2Z/af~[yGG"z6ht3&d ;X<+F;HQ,&GU,=;VQ2^m_ٙt'M_AlwW5\0DZDEW |0elm2E R&X.-@\D!Ѻ͉+.%J(b.:&kܽԝJw|ltIۆu3&lyҊ/yΫWܿEүզDB^i2YvnRh ^Rh(5Y {1zq2Zf@Z219VWqL&5 ټ&WOꐽ3ޟZrzcư:M"gȡFd`-5HfEdJbLw*'x]bdtZJ8o9͎CU1-T8T@r7M_w+rq0hV`zs[=-jy*ic?큦aJ][^gxR&Wĕ(fz TW{S&e}ԣ:EC +VszkT8(ZrҾ1\lZn02=;+FfmN`b I'cע1޺ڡ(ĔjQJ0\q4Ks;)=1ZS_^##‘0рFaRJ߇`auK᥊-Z:ߴ矧_G0}zXGлeIlƔ;NŇev6oZ/H(drfig'6n2Tt>}i!J$, ̗_,Q/*W[v|OI,z{P~cRAzƴNؾz59鋤G\ʙ.eUZ!dq5ժz)KKz k܉V:M;r{)mOIːn ]r1cV+8.뚳Q&T[@rz*VMr[QO{'d=b@0?_~PhaI巅y*f#jGf-0?zUN@6"e񾴹\l~1DO\E܂h'/wz,i^r]j3Pw>>8Ԛc(0@5u~Ey:zWH $ P-+hΩFY٢vL}ҹPރ*F޳dO7i] /0` lC1l)Sھ +.XD `%h"w#PH|aFb#{K~i g4Gmesb߯'/OKh3?l>nՌQ撑rNa[e搬*8&5͖a4W6y {5?m^Y޼ Լ6?be.5CTY;4IɱfxF5IWU$PMaI;iIuG$*۾0rVᄤ7VUDνvZ8A\,0`Id4Q&@aFBdggzSsEuõ0-2h%`mUt8ur6%W8'CG<6vLIRZ`!?TpDCXrm<g>71#J$oӥ=yitx>Qԧʔ.Tcsb1j #{L"gvJ(v/)#Yf:hvu{rpWOp3B1! ]* h]DVw9RP'HBs9&,r{Ojh-Č_ZYopCyŎP8(!EPov0u$NlxIѐi܌4]])7#~. ) Z*?F!9E~km6zrνc;Ync0ںN8҅ +N証>)Kym7g#9-J#3lx2;îV͙Οc s#jchZ"M_t9@BdfI䈊DekRw(nuI~)w!6;.#v/ 84 _I藥|Lb.n,$Z>@MPZx L4/^ErQrDz.=O~ҵL8[iJ @:VC0 +x 'Ɖ3[:" .g_s-0؋(E#}ЃusFd#B:$@IPosz=Ҹ} ^P{P9J-;&l:vqx0)jnMdzz w|/Zc;-J#E.z8{/'Yh\G1P< Cv7 *~ՏLBӊi]׭DCf˾Ş?I.^m/o#*[9!pCМ1 tljpxD·T( N\RQJ믯U]5 +S ."c$N +537 !(zn*Ąr@`QK"v9*:eP< Wy/v2'X?kC)1`_?.7¬J\sz_?7b05]~m4PdAQruX9u_% *0u[X^Eͩ!q~q-`w7OWI3b\񵞴ƃNT}&zVLAyx(=ݛPkTոS6l~Necku ˦NX!awGI(Ϸ|Wp.2|y}D,7 +.4+P0[E_j$:2iNLQg{NZ)IKMWۃR' +ih*H^xT~YR]J!Y+2 +"Rvwd晳i;ޮŒ+Bwzk Z6Bnbc=d"x,f8mbHZ`/^'K{ST.S,i"d:M>&6)#H&cbZ¬R14Ҙ}G ָ6'&0Sh3o65GjX)xrP޿}6[mɆgїzܪ["}ymQw-¸ FvN'|:J5RK͚pu/F4[PZG3\s=#n_ʎC͖>} ߦ)Q+f\+3ʒPj"aQ2dCS$,IQtSIeP&GJs? ,.wL-צ3.WxێD lsRkc줈EOJ RZEE϶{LXx^\牂BD~&zR-9R,Tp'Kl$.Dun w¶͚b@U 1+-s'R0;!h^MRiG룽e.AOi tySTrY%T-"/HJVi3%oA Θx>[%Ľ*+E'(G<;xj(ae!èM_VBsNng}8#pcɛ^U946CޤmАvʟp~5nU"ic{Gb.y&Hcj3>o&. @@*Xt8U +!! +Dg!ZBN3 lě-woyY=ky >,4x.rq!a(, ~*x:o1b1\;k%XIourAeOzWh)KCX ŏWBJ K;=la>70bsMXS1GօR/P`o9𸨪ov `n:ĀD#4Xy|PpJ\4hNʦv,NTigg|4I`m55yetb3 ނ"rL+;=1`=v$<ǒrxӅ'yPun#P+r[p1e7fE|8҅=(63b;7ח{̩A pZ]HU_%LDfXv*KV-[]O812zI$ZcAqy(mJZB AkkI1-9tvޛ<' mǖ+>hӵn +k"˄y']pY.&Z택lMgyeL&\jXlY?߆7Rҙ(eo+'C֦]$l瀧Ƥi鉽)c2raOYP|.jtT8= VÖTAZ[Əw@ǃgAgzp4JI>-Cڏ0hGXtx)=w%Un:A$1 4Y 5D*,Qˊny{#u7ʑ-nms,ʹvڻl)ƍHdH+PT#jD~eO7ismwMy%i,nkez@|9vhȼwV^oF1I܀V$rJS!K&VȵOWR`.,y¯!g ?<ګLg3J*V,:ABsE:HG߳o%yS&LWl :Պ苎'tf=PFgĢA$}d]Ga&=9u#ϿBQkuBȔ0 "a3#c[ x\g1x:|.\FLg9 ާ6Yzy;KFEt\H8G6~O#NR)dDARZᛳ!X~vP%&H pIDj%`>`jAѯ(BQLm_mreI#ur 0rYC\-QP˹ +endstream +endobj +27 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-29 -960 1116 775] +/FontName/LLJPLN+CMSY10 +/ItalicAngle -14.035 +/StemV 85 +/FontFile 26 0 R +/Flags 68 +>> +endobj +26 0 obj +<< +/Filter[/FlateDecode] +/Length1 724 +/Length2 2869 +/Length3 533 +/Length 3420 +>> +stream +xy8}mF-e+bitg -430c߅pk(ʖ%%QYJvFldD)z9x{u^ ccC.cID + + 육 +)(1H +D4DR0ZTS +c( !Z08|8P4P2$VHB; +`Ð*h\`qD_PfDOF-Q1d=.@qS أD@!H{aXXpc<$cP# 8|?$?CHh  +~U(H<G1zJ)q4 GAyHGCD7 j6ڟ G\{c"h D.EBX$d7J_D k`{[ += 5qW1f QI'1Dʏמ)a04 +-cwWTju|-}b%T f/ȸd)ꞔʉ>oeLY>E-PGup[p|d+$R. +Tym}:-(ƣ"VMѫ7T}o+,SWy:km3#x}g'_?ixpxGӡa7Q_~{XxYctayG;@k=anjh@O7S%^Qi& jG>Ӓ֋>q,0gS s(âXG.tL7₞U82=Px,lR" ^p \<\{'Y~Q+gRJ펜S6C/億i[V~^_5V9Jbz/ ok |6iYb8.=T!X}MZj9`v#W5K⁈=W f6s*2|<7І^v1ⴋa J$T&lIq5JiM$颺|bDM4W4l7kžqR>jE!N3X+aD +Q`ܘa0ܭ/gT*"ݕ[ɤy%.ˌ_[9.0fm`"=#<ĜW|,6$B UeRPdW6kQYű;I3yW5N^TYoTg(qjTZGuo3gLy;zrJ)t +wTCMv71Z4hllwoҴr}Dp=R&^ Z`.Bwu7(} sSzi ,* KlJH~|{!u;%V|VvCPa%/g%ԂWgꈠug h74z-}Dzk  \)mj3|kݣMq\MƽlXN;~2| + ~wQ#V1Yj<6|JzpWao}QhQ] ώ@LI&\|c= =1-c(q09Vv<=g˳a?ד]>-sӵ4&1/R&8<2eJ0ճۓ~{VҊssv:/z`!]sL)']¼XVF\ aZ|^8jM4~0OgA55ϳ _Dt5S[3C cVw[ߢ G__F&o߱W52KI?ݫr "^GQ3jr&.`F1ĥ6[Kѧ3RmB-y}-/kL- ;=<,OK;FeK|nQ5M趶kNGڠٗ.^KբWM/ЬN-%wT)]NG!36b+9*>>[hv*tYz\s G{\԰9z?+| :ϿP!hBJq5 +Ij%U2;Qz^~2oXZ5e//Dn S\PTL%v]iCV;Zw"ODžPq9J8;:,A1;*x<7'朄;*$;4KmѦ}&rY?u=kzbyMm+-Cf&T=Nda8ˉM2ۣkkG("[?x\$Cl*h=M2zdgǍ( Ls<뵶txVKw!T¬ !q GǢUF +aܞt7dc"ON-Wi]x0xk,\ Gίݵ[QXr~yy*5Lf` PHy +endstream +endobj +30 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-36 -250 1070 750] +/FontName/KXOIBV+CMR8 +/ItalicAngle 0 +/StemV 76 +/FontFile 29 0 R +/Flags 4 +>> +endobj +29 0 obj +<< +/Filter[/FlateDecode] +/Length1 712 +/Length2 2048 +/Length3 533 +/Length 2585 +>> +stream +xy8kǑulYz̘!ː,c 13 3Ccl!ˑ-:3DF0$%YlURG^o}}ݷ#Rh0$mt$QVFSA,H1@=B!_@ 4Qz2 }hեA*XHaIc "`L"_ ` + 8)HVB  S +\tSئRH$@WYcCcyd%T,HH +T6R)?Z]h BQaID1ŗ-b91i8?% #ؾ!`[8};=H9EF!r۸Zf\ HiX +K;I`x$LSihm_ BD$x:2;.J)o`{t@0A]'r{,^i8Rtxk*]0>t.~eXd}>-w z0⬭~f磈' n9ziXX+z;0˭Jɷ{l O1?k72Gj̎7߹pfa6nxSxW1r hr'`'c-05.B7QCҠn5hqi9^j~3hE>kx +Hkľ̸7*9r׭ yрFɅ}:O^6%M%|pS1e%Enٝ>k|Zugg_Pm!44ǣ[t$!gR\x$$S1vVm|'G}B̯q%wmbii #hKBdѨ~HWghWw`E*m;B@-%j՝qX0ftIaG c ֱ;SClI1#K1΃pwoW+d.}d2G`t)~)ԥ_)|Ru*Rzh9ޑ W^bZ<~Pe!ALvt`]ǣXO^}{,5Z.<jf,e${|̵ssIzS:+ӧD`RʎݱuE%}X0' **Tň0~|ib"f㪾1A1E^uG\JȱgaI(TE9, (N `\V6bwWLQUWFn:Ic"lSͲP~5^H]Iڻs-\7tKa8ydŖ|<CO餩ޗ'3.̞eʱĵY\^k0=8yHA|R۫*wXҮRn欪\O$pZGvȟ OV#[PqLэ*IFYCkY~葻-16MD'O-W'.We=p5.&obݪ.%f{iF8$@{;E -'X5]:Pn]߂,m*T/cSTMnL_'z+ѓфaߪVĢI=q%_v]f)) |$.<.D!o +_-/q=/x= U\EgJ4G 4իo9Wx33jofۗarL$hdKG;t"{ +:-#z +a4n}&*ű CwK x]k2ˏ r?M$/GE?ʩ4t/7؆9 Ea:]D8,v}Z;D.vo£LIĉǭzdZf0UoB_FG:IvA4uAٺ\Q!њ{{ulEyqK;V+g+NX ά7 +s3 *۰M;aj2rk->_xMz>~&v߽GĘ!SΘ9 ę<*&c.|| uܖ^fA_Cx=0s5W%#RO)MTl}|~zY@LJkg۵h- >%>GyCOj!Ʌn馓䙇S(V %P-GժˁKI W\e!3@?#X*-@ vfI] +endstream +endobj +39 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-24 -250 1110 750] +/FontName/WEJCJR+CMMI8 +/ItalicAngle -14.04 +/StemV 78 +/FontFile 38 0 R +/Flags 68 +>> +endobj +38 0 obj +<< +/Filter[/FlateDecode] +/Length1 724 +/Length2 4589 +/Length3 533 +/Length 5155 +>> +stream +xg8\m %e Fo#5cf0`DOD FD5J"D B.ADwc繯Zs{1FH@^N/A, Vj $`pHF VTye y%DJǺZ"PO BH+w +DxB$/%` "0.XTpP/ 7PORoN#8SIz p=\G6/Oo?4Bc[-1`X?ϿwŹx``YI_:WAc (W3N{|rHYL5X,g W{Fx?$ \m3\F);,PB`P +FsB@ +2 +2(?<#7~3`1(/5?.sD..+7 j-C{$FǒÌ`rjU_OƔFI-I1E&Iܰ .7/%ˁR _Xȹ-(]_U7KIJbLަSYwJH!]d h%꣰F)^5>P[K79{y!>3Z# ]s+w]Nѽ11[Zm^U5pҍ e?{k&5qC Eݥpe`QG)A'[S/DVJ1y{2mEiYH-jŀAP?* !L{R@,HXylbGc KB k7yjZUM~04zK8NIej*3?%u#p Y 7_}e, _1 /Ʊ[H!^`~[7^k9޸KNF +ݽIJԣ7 +W/Jj/ˬ W+ +o^<"RQia,{'H$ߥk_ܔy̴[Xvq* +-\z;ҋh`ja (Q-dANdJfV]P\ Bߨ"/ՍET4) WO4p Gʇi[#vbr|'Jo_,D=pn+jA$Q-ؿ\GٻgH~,܏*.*#g5ԔlwrM3F*B;~Eņ^A iO%tR f0ixeE $)&>Yǚ2z{L0DjssdF^ROf{E\Sf +ҋ o`oXU-VQiϮ?AĢGy&Jz;7jO{k>XKM(x2rӖE;jAg\4P F\Om^/K7h5SF={Yk(awXsMfoK +vɓ.WU9*0m̬I y=%tR箛B힮+ +" +nimkEy\fa0UbO:֓YK @]mx{a,[Ukk|O#f6 7Ţ?A$܃ %&;pϐ=Ee%ܞ*ttTdeƓ[vU94\;2Tt -#v߱IRX:|~MT'vm穅 +ޤȎdj/4Պ 3&>W`sf1i:Ej/v w )Қ+9? WNING"R xaLlu/~PyN|>JyO\G/o'!ţ~aK1 2v߲ya@ YΆʴ%ubZwƃ+TWg.V֒olGlnKV.(;Q`Iq*iαL0sJβ}3} [tz}02F}yP@LZԉ%`H_*q%jB@hVۻWc:ݶRaGvj-r:zlT'D.mD"E9=)>֦˫&XQEUvaFضcľS\e!}wŲ$}&if ];aMՔI{5k;3uhŶ +:]RM9 ~ANV-೯pQ.LklU&H2A(ia%E'-}WIZjM{b +#vQt~S|gB> {Kw?t:7!jvL'ֲ2(;s;H@+tGܴO̊3F$vg0 E+eaB<>,d'&΄z1Id/`EյSd8{W"H-ktǐWv k}bp5q+|8$unᬟ>π kB>_U8~bJR>Th?(a27n6׿WO=AG78krqNHoڼ]fv  Z@81N6v~F*فv~9l T1ǬkEҷ\ -K!`O3ؓe֜rviq5chIXNù` 8[BLE lāRC8}'-@?H +/KVRV!Qy4$eK«Gz|qn֙Wgw #X%8%쾺n5m"?zm)w[st_Cӈ^q +@*MDG!u$S&A6\N[ZξF.̾QL~yYZ +Y;L.f4tV.s>ly+e\)^Ώi76KhAlRW}5,prMpGGfG_HF=ء&N~V9P-_:2U-9_1'v/1dNS~>XF j YsA4k~БEc6]C3HSyx/ |0ѮvT3arsZ$n (8~Mz"ғtd{NYp)=Jߑo% /_)X쀝[UbcjGr9IB +Dr=.pCʩm#EI)qLMt!lPkǧ]'n n⭱CZցɊJwZR +T>^iդ4KzTEB†s5^ʝz+n?ZUEٷOy&Ԧ$/Afz*D+ngQ=!m]cnW3qq8~m;*Qȟ]b}`q)ml ]+BTo!$*[/MRLw֘#r4|SRLՓnS "գ0hACc4P9繉>̘%V^ev]k꼳\@V}IC";k#Kc +F1ެ:ǺcsF;#ޞdB]Zh6r !|/~.UHlK7ygPo纡Fٯ>DgW47#ˤmLԾaYvoEPET?B*N-5~2|)? GLt_i _ۄmeTJGF3m}2uip1li'?۱E<"oET hknxfqG{⸜*5['9lZvK\*j5YbUIF[>*"*K 9Vfba\'<-7QaTqOE5_Kᕌ(6ɨV;6n!\ZyθSJ:KoFq['Chۦo>’|2Gt@ 6(B\UFv&a(hCԍ+on&dW>w5V)[)n=-Ւi*ѩ?D> +endobj +49 0 obj +<< +/Filter[/FlateDecode] +/Length1 1021 +/Length2 2671 +/Length3 534 +/Length 3359 +>> +stream +xy<[cVdgfmid-kfg 05kY~SD$ ems~?羮|~NpT hN0a0$`bk0 (`B "bfH$aH8Ѓ@_0HfJ&[Q ҈X4E3A2MNPD( 8Bt4   *+ + +1F (m U82qT +)xodm/n$?FM& Rq =S-#2۩M"bQ tsbs 2M? ]gr?$h8RkR4p +[?lO3 1r r޿l`d|=G" +Jyu]~ub7]$_\ח OÞoz( Yz/FՀ1C|nг&{ʏl?Ԑn+C\JxnNyˋ'ϯeub]cmbw4 : -Veo d܋rC#O)ʛ^[VG~:\c+L8a\݄p7@r⸷_Y@dUb7dܸ(co;ZҞQ5eZg5J=|1m8jbXM2%]q6g# :֤Jޟ:!8!??ܻ&! }oTcFOz1e-?k'5)[/ %Y qwǽa,n }e+\^g9>3G|ÆCG͇|f2b`ȫCP')֯;{Jǘ pbࡵ9rxjl{́TY|51$nldch$JwbD0b}LhNot6H}k{F9Do+H``b d]^6w^Lyľ8ڠ%bo0:"~s)g<}ֱEbZn^+5|.;jCwT/V6. z{bXmN'vY((.]=f%n}͌4O޴~@r6Fn+RZ2$?/}G3ck1O2?^De~@Krg~%9r#<鲤U}:h&/5ϗڙK׮4npTOH)Dlr9 ȑiۦ%?n/]NS:OYMƢBUs0CjCǏSĕ2ZTvA( !z;QƭL effQl<9luЍ~0.Q[{SK=̄w%UAMAbtڮ(_kUQlIԽq͘:e fO(_>+r DX{#u' .)2Y>k1j򮋽`h{Q2?6d~㽶|Y*o~_ 5: "&47KO]í/KX'nUa#,c o@4A%i? +endstream +endobj +53 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[-30 -955 1185 779] +/FontName/DKVEUL+CMSY8 +/ItalicAngle -14.035 +/StemV 89 +/FontFile 52 0 R +/Flags 68 +>> +endobj +52 0 obj +<< +/Filter[/FlateDecode] +/Length1 721 +/Length2 1092 +/Length3 533 +/Length 1626 +>> +stream +x{XLiݲ\batBn1f4̪&P89ə9t&ӍtN%h-eMOX*qM "Sl}}}cj"r@O(+x""i<)-)X,pP C f +y0S9o^ 8HQ2Q6D〈`(l 8o \@ Bk Ph6L/0ۈBE +B@-`h)BKP-?| ai|a)a r3ldsFL! +($2? ;kЖ1(`|L".%|a<2d(vz 6W;u (`9 +_5Ĕz!Qy9Q&!L(X$g[(.PZق h`2Y5a[`9Aph+Q$*~텿ԾvH(D%Ó-=P?4w/n>WHB[)ʌ;xڸq/m{ ~mt#nO+`o^4@c 2%<&9i* :$|EVm`trʞl$^c]"0RB^w b7Yr@um̎z/փB|g~%GZ|\ʁOG,vD&mXJ ~7%~oљ='vXN[]9:G"84GU|Wy<+|lbk7D2ljjP3[7-i#Gru4jn7ූ*qmWo3:3\R>.ﳩ*JMr &LEp$,̍lSoՏfk2}s7!w7~z53="a3fT(n?O633{ה5F[E[nܰ*$Y݈Wڏ[G{>N(g)h_r7ZA]dwi癞t^}4MD "lSvxךyq])ч);j4 y1­-ORG@&O/,X ?fZ`[jS?J\=ehyѱm{t}vGha=ix/g%Fܹjqr+eF 2D=l!OWF)n?]gcDOc~Lz:Ws|(hB_Y3O> +endobj +71 0 obj +<< +/Filter[/FlateDecode] +/Length1 712 +/Length2 1546 +/Length3 533 +/Length 2080 +>> +stream +x{8TǷAQ$tYu3Sn0aH40fC.\()ՔKn\Pb3H[=t9y9k]g"L_Ў qH4\M4ƳA2Ƅv @[X)võ L"Jz^SμjXELq:9 ur fRsثo# 5˪jW~iJNBԷOKꘁ;dԉ7K0ʑgmܣE< ++;Q{G:pl˗+~P8^?!3%-4LHڞ(:Qv]uOݖI;]<1f}ѓ&!ivmzi7˾cvk`C<E"_K>am2v5V!Uq)/*95hvH!1& "`u#VpȑR+a¾Dj^04hX0y)|~zNDRF5!ч+Y^i[R9j?ƏPFdC埨id?{4lt~ަܣcq0IgMnMw>2P] _Ļ>:O#tF7Cy9=6vudu,&ƝYi\pjx+d]e>ʼneF{q*#EC-_|67Ƥ~I#Q/9>ouhds%\F]*t6ȩJ*}UٶOGӹQcǏ c^âުyX<Ƨ7Ӳ;$T"݅/nh"@crZwgm44g'>ӍZuY|`-.OP)g>3~-A1ʒ#5U>r 9dfSnyefSnwIS.-9l,nW70> B]Nߪqk{UذIa^nZHp-6ٸP,2)oUUF߼|! +=w)lJsow`q}"ks̒y0PzuǶH\ysZyMs6W?Nr8I!2v%P{l,ڵܾWsU7^u -W?aѽ aY Ƒ!9k5n$- 'g7z"۔[-3ͼyB&zeV] +a&Zg54+"'>V l u6-6 ez,'RS=CUtIaG@sd ɵCfH?1J͹cN?yA2dApo?Z +endstream +endobj +75 0 obj +<< +/Type/FontDescriptor +/CapHeight 850 +/Ascent 850 +/Descent -200 +/FontBBox[11 -250 1241 750] +/FontName/KOCVLX+CMMI6 +/ItalicAngle -14.04 +/StemV 85 +/FontFile 74 0 R +/Flags 68 +>> +endobj +74 0 obj +<< +/Filter[/FlateDecode] +/Length1 723 +/Length2 1459 +/Length3 533 +/Length 1997 +>> +stream +x{< 9c(%̼6L31.T̋7sk% HͦNNr!j$(ؕ&=t?s;?yz26cIa.<.jIpKS0"<. Ba2@tp܅lId[kk Py| +FT*@ q b><&b<PlPa0  a^8b ܸ<4f _Ka TBj(8Y<.[ @,8V`[s!q>՟a!qB  psl 9VP0) 6 Xm\ uAD0k32@ +\ַ$} xln3{۹f[|PĊ A*oeX7A!. 33OtP֖V @!$[пqB؍؂$k9(P Ϡ8QE0m#>| Fhj҉+{b5WM]йsRt줯oo3ׇ[TeJȰJ6SMJx6ҵO1|IG2nҸ9M[uO̶S6i\O +1P3o޺_ wEgɾ"ӲvE"% + “^,#h?=QN&x>Ug$z)2㘏&)+OLoz xG%9:\+2 /I=MVW\.7H;'_ޓ0C_)uZ;t6zZuEi\9~hIPnqwZORs<`']hr4K59Xߖwy{֛$UVTl⒖ +wmjFFK(ֳ.Vu4a*t3Nd_nKt4T5mY3VDcbWg40 r%do^ׯa9[t^z n Ȩ.UӜкz^Z6xbq&v߉=tKyX{:g]UYA,1@NvpE S uՎ\wڍcE|r@H~bݜH9 Li3 zcŮOک{#{SX党a/iI)~Xz ?@΢ ;t=dů ٓ=}-z]ymwEH xw;=mDهlFaC6}NEHHiwrՂOW3TF&˧Yw{ i-f wGHxKOXzfgJJak/1]畯Ռ[""%n^[7GXھqÝS˫HBd:9O"3FObl.ԧS'K,I/m瘆޷!et׼ 4ش˩t죋Y%> +endobj +93 0 obj +<< +/Filter[/FlateDecode] +/Length1 827 +/Length2 1887 +/Length3 533 +/Length 2493 +>> +stream +xRi4\ XBH%Ve-vT%U# hkVHC:M(hbIlAHұ}J2=s&=̙3{޽ `6Fc 8[:aЀ&DLpz;`cAaU ` @$HȀB`f(XPA:D$ OL$Pwl>ƦC!L@ܞ7=`An- d@`0 "2`0ms0`?IK "[ 3? ke U_۰(gOya͢/gIN bQ3 hP@91l( +1@a Lr4]9]4vfzλ cB?__L4N'h>L0/Ә Ōtv +G(6H[_zzN@O +gVZmg,:c2_'FDD>;r=a3V}0F7i؎VPF;hF96_n+m܎W +%k,3Y8aŸvV}Z8keFnnݒ8QtWB\qBj5FyrR412>UmYa/]{ⲺNh? PYGv7V$,8S6>ݩ+oF5~x06U?v/a.!~=!^Fa>Y%nקj[3lKYז'ВnhW]B42VoSgu/n8Fygj/0ԛ9;Sh>ɯP;r(I|My+CS6(}7$;Ϗ}yN&O^xlkmj7VV.=eo."R˦Rҿ~kaEQBU{ +qぎWr_+&!dh~5Aɉeւo]ZEN9tQrKiNlc'N:di]).zu:"Bg,P%;4Ȍ-ywZcMM]զ=3'q^#]tqvB."t*/h77 w,U="5M'\rwPsS䜺A%ŏw]!IObQC!EоNLžG t#Έqui8n96zQ˯9jN0^r_P~VZdYG7prk Ve'b3ѲAwшhU<4Y{J|؉#5,h>J#Bԛ`-~^J٪Msr,>3 o]'4ބgof`S_U\C.'ZJ};x8ˎKgy0!{a.pj ,/UCm,3bRyslsOaFiȠ>C}5^r+zĥ,#:\kB9#`Ӎtn[,Fw->I[ Ȗf^G eBS3p_>ko ҥ\2^>"ulbZv\IV~ib"lTSO ~-g jl5nGPᆒP$tPaߴc̸I>QXi!oК^O e:}sp V1qPGgWI"CCּXŷ乻`kѠ:ULT0l({UA~s{⛙.YNZTǴXWϩah\ܙ9*/!UrQr<Шgqy9!ʮ*N "Mv^N.r`!nak3KaxlXz`/$V+f(m*oJF0g͖r!PR)i1;HWsjM'1jX<&4uu@w]MMYKǛCO\XS!okrzC~Geaiyv^UmG]sxs5Uܸ2rCNN +*օSo*ty{fLp0`h[%$׽>e/ '@gҨIt1 +endstream +endobj +1 0 obj +<< +/Creator( TeX output 2006.11.08:1148) +/Producer(dvipdfm 0.13.2c, Copyright \251 1998, by Mark A. Wicks) +/CreationDate(D:20061108114949+00'00') +>> +endobj +5 0 obj +<< +/Type/Page +/Resources 6 0 R +/Contents[32 0 R 4 0 R 33 0 R 34 0 R] +/Parent 111 0 R +>> +endobj +36 0 obj +<< +/Type/Page +/Resources 37 0 R +/Contents[32 0 R 4 0 R 41 0 R 34 0 R] +/Parent 111 0 R +>> +endobj +43 0 obj +<< +/Type/Page +/Resources 44 0 R +/Contents[32 0 R 4 0 R 45 0 R 34 0 R] +/Parent 111 0 R +>> +endobj +111 0 obj +<< +/Type/Pages +/Count 3 +/Kids[5 0 R 36 0 R 43 0 R] +/Parent 3 0 R +>> +endobj +47 0 obj +<< +/Type/Page +/Resources 48 0 R +/Contents[32 0 R 4 0 R 55 0 R 34 0 R] +/Parent 112 0 R +>> +endobj +57 0 obj +<< +/Type/Page +/Resources 58 0 R +/Contents[32 0 R 4 0 R 59 0 R 34 0 R] +/Parent 112 0 R +>> +endobj +61 0 obj +<< +/Type/Page +/Resources 62 0 R +/Contents[32 0 R 4 0 R 63 0 R 34 0 R] +/Parent 112 0 R +>> +endobj +112 0 obj +<< +/Type/Pages +/Count 3 +/Kids[47 0 R 57 0 R 61 0 R] +/Parent 3 0 R +>> +endobj +65 0 obj +<< +/Type/Page +/Resources 66 0 R +/Contents[32 0 R 4 0 R 67 0 R 34 0 R] +/Parent 113 0 R +>> +endobj +69 0 obj +<< +/Type/Page +/Resources 70 0 R +/Contents[32 0 R 4 0 R 77 0 R 34 0 R] +/Parent 113 0 R +>> +endobj +79 0 obj +<< +/Type/Page +/Resources 80 0 R +/Contents[32 0 R 4 0 R 81 0 R 34 0 R] +/Parent 113 0 R +>> +endobj +113 0 obj +<< +/Type/Pages +/Count 3 +/Kids[65 0 R 69 0 R 79 0 R] +/Parent 3 0 R +>> +endobj +83 0 obj +<< +/Type/Page +/Resources 84 0 R +/Contents[32 0 R 4 0 R 85 0 R 34 0 R] +/Parent 114 0 R +>> +endobj +87 0 obj +<< +/Type/Page +/Resources 88 0 R +/Contents[32 0 R 4 0 R 96 0 R 34 0 R] +/Parent 114 0 R +>> +endobj +99 0 obj +<< +/Type/Page +/Resources 100 0 R +/Contents[32 0 R 4 0 R 101 0 R 34 0 R] +/Parent 114 0 R +>> +endobj +103 0 obj +<< +/Type/Page +/Resources 104 0 R +/Contents[32 0 R 4 0 R 108 0 R 34 0 R] +/Parent 114 0 R +>> +endobj +114 0 obj +<< +/Type/Pages +/Count 4 +/Kids[83 0 R 87 0 R 99 0 R 103 0 R] +/Parent 3 0 R +>> +endobj +3 0 obj +<< +/Type/Pages +/Count 13 +/Kids[111 0 R 112 0 R 113 0 R 114 0 R] +/MediaBox[0 0 612 792] +>> +endobj +32 0 obj +<< +/Length 1 +>> +stream + +endstream +endobj +34 0 obj +<< +/Length 1 +>> +stream + +endstream +endobj +4 0 obj +<< +/Length 30 +>> +stream +1.00028 0 0 1.00028 72 720 cm +endstream +endobj +115 0 obj +<< +>> +endobj +116 0 obj +null +endobj +117 0 obj +<< +>> +endobj +2 0 obj +<< +/Type/Catalog +/Pages 3 0 R +/Outlines 115 0 R +/Threads 116 0 R +/Names 117 0 R +>> +endobj +xref +0 118 +0000000000 65535 f +0000146264 00000 n +0000148499 00000 n +0000148147 00000 n +0000148352 00000 n +0000146428 00000 n +0000013329 00000 n +0000000009 00000 n +0000069972 00000 n +0000069788 00000 n +0000000913 00000 n +0000075133 00000 n +0000074947 00000 n +0000001906 00000 n +0000089107 00000 n +0000088918 00000 n +0000002823 00000 n +0000003769 00000 n +0000099190 00000 n +0000098996 00000 n +0000004676 00000 n +0000005479 00000 n +0000110883 00000 n +0000110689 00000 n +0000006433 00000 n +0000007403 00000 n +0000121308 00000 n +0000121113 00000 n +0000009019 00000 n +0000125028 00000 n +0000124842 00000 n +0000009970 00000 n +0000148252 00000 n +0000010970 00000 n +0000148302 00000 n +0000013230 00000 n +0000146531 00000 n +0000017547 00000 n +0000127920 00000 n +0000127727 00000 n +0000013390 00000 n +0000014389 00000 n +0000017448 00000 n +0000146636 00000 n +0000020869 00000 n +0000017609 00000 n +0000020781 00000 n +0000146826 00000 n +0000025493 00000 n +0000133378 00000 n +0000133189 00000 n +0000020931 00000 n +0000137046 00000 n +0000136852 00000 n +0000021907 00000 n +0000022915 00000 n +0000025371 00000 n +0000146931 00000 n +0000028280 00000 n +0000025555 00000 n +0000028169 00000 n +0000147036 00000 n +0000031260 00000 n +0000028342 00000 n +0000031138 00000 n +0000147227 00000 n +0000033899 00000 n +0000031322 00000 n +0000033777 00000 n +0000147332 00000 n +0000038896 00000 n +0000138972 00000 n +0000138786 00000 n +0000033961 00000 n +0000141358 00000 n +0000141166 00000 n +0000034962 00000 n +0000035951 00000 n +0000038750 00000 n +0000147437 00000 n +0000041633 00000 n +0000038958 00000 n +0000041523 00000 n +0000147628 00000 n +0000044319 00000 n +0000041695 00000 n +0000044208 00000 n +0000147733 00000 n +0000064318 00000 n +0000044381 00000 n +0000060828 00000 n +0000060861 00000 n +0000060946 00000 n +0000143657 00000 n +0000143469 00000 n +0000061006 00000 n +0000061886 00000 n +0000064150 00000 n +0000064284 00000 n +0000147838 00000 n +0000066915 00000 n +0000064396 00000 n +0000066779 00000 n +0000147945 00000 n +0000069707 00000 n +0000066979 00000 n +0000068547 00000 n +0000068582 00000 n +0000068651 00000 n +0000069593 00000 n +0000069671 00000 n +0000146741 00000 n +0000147141 00000 n +0000147542 00000 n +0000148053 00000 n +0000148431 00000 n +0000148454 00000 n +0000148476 00000 n +trailer +<< +/Size 118 +/Root 2 0 R +/Info 1 0 R +>> +startxref +148597 +%%EOF diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记3.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记3.pdf new file mode 100755 index 0000000..aaaea43 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记3.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记4.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记4.pdf new file mode 100755 index 0000000..5b396c1 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记4.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记5.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记5.pdf new file mode 100755 index 0000000..58b1361 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记5.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记6.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记6.pdf new file mode 100755 index 0000000..ae45953 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/复习笔记6.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/课程简介.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/课程简介.pdf new file mode 100755 index 0000000..e25fca0 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/课程简介.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/讲义/课程表.pdf b/books/[ML-CS229][2011][Andrew NG]/讲义/课程表.pdf new file mode 100755 index 0000000..006a91e Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/讲义/课程表.pdf differ diff --git a/books/[ML-CS229][2011][Andrew NG]/课程.txt b/books/[ML-CS229][2011][Andrew NG]/课程.txt new file mode 100755 index 0000000..7392f91 --- /dev/null +++ b/books/[ML-CS229][2011][Andrew NG]/课程.txt @@ -0,0 +1,9 @@ +This course provides a broad introduction to machine learning and statistical pattern recognition. + +Topics include: supervised learning (generative/discriminative learning, parametric/non-parametric learning, neural networks, support vector machines); unsupervised learning (clustering, dimensionality reduction, kernel methods); learning theory (bias/variance tradeoffs; VC theory; large margins); reinforcement learning and adaptive control. +The course will also discuss recent applications of machine learning, such as to robotic control, data mining, autonomous navigation, bioinformatics, speech recognition, and text and web data processing. +Students are expected to have the following background: + +Prerequisites: - Knowledge of basic computer science principles and skills, at a level sufficient to write a reasonably non-trivial computer program. +- Familiarity with the basic probability theory. (Stat 116 is sufficient but not necessary.) +- Familiarity with the basic linear algebra (any one of Math 51, Math 103, Math 113, or CS 205 would be much more than necessary.) \ No newline at end of file diff --git a/books/[ML-CS229][2011][Andrew NG]/课程表.pdf b/books/[ML-CS229][2011][Andrew NG]/课程表.pdf new file mode 100755 index 0000000..e25fca0 Binary files /dev/null and b/books/[ML-CS229][2011][Andrew NG]/课程表.pdf differ diff --git a/books/[ML-Coursera][2014][Andrew Ng]/[2014]机器学习个人笔记完整版v5.1.pdf b/books/[ML-Coursera][2014][Andrew Ng]/[2014]机器学习个人笔记完整版v5.1.pdf new file mode 100755 index 0000000..04b4cfd Binary files /dev/null and b/books/[ML-Coursera][2014][Andrew Ng]/[2014]机器学习个人笔记完整版v5.1.pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/BP (v2).pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/BP (v2).pdf new file mode 100755 index 0000000..334f099 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/BP (v2).pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Bias and Variance.pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Bias and Variance.pdf new file mode 100755 index 0000000..b959498 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Bias and Variance.pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/CNN.pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/CNN.pdf new file mode 100755 index 0000000..92b9fe1 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/CNN.pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Classification (v2).pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Classification (v2).pdf new file mode 100755 index 0000000..22219e9 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Classification (v2).pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/DL.pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/DL.pdf new file mode 100755 index 0000000..a3221d0 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/DL.pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/DNN tip.pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/DNN tip.pdf new file mode 100755 index 0000000..0745f73 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/DNN tip.pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Ensemble.pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Ensemble.pdf new file mode 100755 index 0000000..c788cf1 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Ensemble.pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/GAN (v3).pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/GAN (v3).pdf new file mode 100755 index 0000000..68c7fa7 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/GAN (v3).pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Gradient Descent.pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Gradient Descent.pdf new file mode 100755 index 0000000..f1a5031 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Gradient Descent.pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Hung-yi Lee RNN (v2).pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Hung-yi Lee RNN (v2).pdf new file mode 100755 index 0000000..1a8f713 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Hung-yi Lee RNN (v2).pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Keras.pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Keras.pdf new file mode 100755 index 0000000..18e875d Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Keras.pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Logistic Regression (v4).pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Logistic Regression (v4).pdf new file mode 100755 index 0000000..1a28105 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Logistic Regression (v4).pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/MF.pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/MF.pdf new file mode 100755 index 0000000..d478f7a Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/MF.pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Machine Learning (2017,Spring)目录.md b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Machine Learning (2017,Spring)目录.md new file mode 100755 index 0000000..540d742 --- /dev/null +++ b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Machine Learning (2017,Spring)目录.md @@ -0,0 +1,30 @@ +#李宏毅 《机器学习》 2017 Spring + +* Introduction of this course: [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/introduction.pdf, pptx (2017/02/23) +* HW0: link, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/HW0.mp4) (2017/02/23) +* Regression: [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/Regression.pdf, pptx,[video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/Linear%20Regression.mp4) (2017/03/02) +* Where does the error come from?: [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/Bias%20and%20Variance.pdf, pptx,[video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/Error.mp4) (2017/03/02, recorded at 2016/10/07) +* Gradient Descent: [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/Gradient%20Descent.pdf, pptx,[video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/Gradient%20Descent.mp4) (2017/03/09, recorded at 2016/10/07) +* HW1 - PM2.5 Prediction: [link](https://docs.google.com/presentation/d/1L1LwpKm5DxhHndiyyiZ3wJA2mKOJTQ2heKo45Me5yVg/edit#slide=id.g1eabbd760e_0_0) (2017/03/02) +* Classification: Probabilistic Generative Model [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/Classification%20(v2).pdf, pptx, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/Classification.mp4) (2017/03/16, recorded at 2016/10/07) +* Classification: Logistic Regression [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/Logistic%20Regression%20(v4).pdf, pptx, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/LR.mp4) (2017/03/23, part of the video recorded at 2016/10/14) +* HW2 - Income Prediction: [link](https://docs.google.com/presentation/d/12wP13zwBWSmmYq4DufsxiMjmXociERW7VnjPWscXZO8/edit#slide=id.g1ef9a0916d_0_0) (2017/03/23) +* Introduction of Deep Learning [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/DL.pdf, pptx, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/DL.mp4) (2017/03/23, recorded at 2016/10/14) +* Backpropagation [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/BP%20(v2).pdf, pptx, ]video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/BP.mp4) (2017/03/23) +* “Hello world” of Deep Learning [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/Keras.pdf, pptx, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/Keras.mp4) (2017/03/23) +* Tips for Deep Learning [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/DNN%20tip.pdf, pptx, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/DNN_tip.mp4) (2017/03/30) +* Convolutional Neural Network [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/CNN.pdf, pptx, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/CNN.mp4) (2017/04/06) +* HW3 - Image Sentiment Classification: [link](https://sunprinces.github.io/ML-Assignment3/index.html) (2017/04/06) +* Why Deep? [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/Why.pdf, pptx, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/Why.mp4) (2017/04/06, recorded at 2016/11/04) +* Semi-supervised Learning [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/semi.pdf, pptx, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/semi.mp4) (2017/04/13, recorded at 2016/11/11) +* Unsupervised Learning: Principle Component Analysis [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/PCA%20(v3).pdf, pptx, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/PCA.mp4) (2017/04/13, recorded at 2016/11/11) +* Unsupervised Learning: Neighbor Embedding [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/TSNE.pdf, pptx, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/graph.mp4) (2017/04/20) +* Unsupervised Learning: Deep Auto-encoder [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/auto.pdf, pptx, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/auto.mp4) (2017/04/20) +* Unsupervised Learning: Word Embedding [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/word2vec%20(v2).pdf, pptx, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/word2vec.mp4) (2017/04/27) +* Unsupervised Learning: Deep Generative Model [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/GAN%20(v3).pdf, pptx, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/GAN.mp4) (2017/04/27) +* Transfer Learning [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/transfer.pdf, pptx, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/TF.mp4) (2017/05/03) +* Recurrent Neural Network [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/Hung-yi%20Lee%20RNN%20(v2).pdf, pptx, [video (part 1)](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/RNN1.mp4), [video (part 2)](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/RNN2.mp4) (recorded at 2016/12/30) +* Matrix Factorization [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/MF.pdf, pptx, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/MF.mp4) (2017/05/25) +* Ensemble [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/Ensemble.pdf, pptx, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/Ensemble.mp4) (2017/05/25) +* Introduction of Structured Learning [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/Structured%20Introduction.pdf, pptx, [video (part 1)](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/Structured.mp4), [video (part 1)](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/Gibbs.mp4) (2017/06/01) +* Introduction of Reinforcement Learning [pdf]https://github.com/Mikoto10032/DeepLearning/blob/master/books/%5BMachine%20Learning%20(2017%2CSpring)%5D%5BHung-yi%20Lee%5D/RL%20(v4).pdf, pptx, [video](http://speech.ee.ntu.edu.tw/~tlkagk/courses/ML_2017/Lecture/RL.mp4) (2017/06/15) diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/PCA (v3).pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/PCA (v3).pdf new file mode 100755 index 0000000..5cf7561 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/PCA (v3).pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/RL (v4).pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/RL (v4).pdf new file mode 100755 index 0000000..7aac59f Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/RL (v4).pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Regression.pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Regression.pdf new file mode 100755 index 0000000..a5782e0 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Regression.pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Structured Introduction.pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Structured Introduction.pdf new file mode 100755 index 0000000..3370f32 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Structured Introduction.pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/TSNE.pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/TSNE.pdf new file mode 100755 index 0000000..1425c9f Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/TSNE.pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Why.pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Why.pdf new file mode 100755 index 0000000..5983f6b Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/Why.pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/auto.pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/auto.pdf new file mode 100755 index 0000000..1781772 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/auto.pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/introduction.pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/introduction.pdf new file mode 100755 index 0000000..288e1bf Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/introduction.pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/semi.pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/semi.pdf new file mode 100755 index 0000000..7e12bc3 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/semi.pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/transfer.pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/transfer.pdf new file mode 100755 index 0000000..5016317 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/transfer.pdf differ diff --git a/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/word2vec (v2).pdf b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/word2vec (v2).pdf new file mode 100755 index 0000000..34eb295 Binary files /dev/null and b/books/[Machine Learning (2017,Spring)][Hung-yi Lee]/word2vec (v2).pdf differ diff --git a/books/[Machine Learning and having it deep and structured (2018,Spring)][Hung-yi Lee]/README.txt b/books/[Machine Learning and having it deep and structured (2018,Spring)][Hung-yi Lee]/README.txt new file mode 100755 index 0000000..198a3b8 --- /dev/null +++ b/books/[Machine Learning and having it deep and structured (2018,Spring)][Hung-yi Lee]/README.txt @@ -0,0 +1,4 @@ +Special Deep Learning Structure (2017/03/17,2017/03/24) pdf, pptx, +video:Spatial Transformer Layer +video:Highway Network & Grid LSTM +video:Recursive Network \ No newline at end of file diff --git a/books/[深度强化学习][Hung-yi Lee]/AC.pdf b/books/[深度强化学习][Hung-yi Lee]/AC.pdf new file mode 100755 index 0000000..645450f Binary files /dev/null and b/books/[深度强化学习][Hung-yi Lee]/AC.pdf differ diff --git a/books/[深度强化学习][Hung-yi Lee]/IRL (v2).pdf b/books/[深度强化学习][Hung-yi Lee]/IRL (v2).pdf new file mode 100755 index 0000000..aacb6e9 Binary files /dev/null and b/books/[深度强化学习][Hung-yi Lee]/IRL (v2).pdf differ diff --git a/books/[深度强化学习][Hung-yi Lee]/PPO (v3).pdf b/books/[深度强化学习][Hung-yi Lee]/PPO (v3).pdf new file mode 100755 index 0000000..05501e5 Binary files /dev/null and b/books/[深度强化学习][Hung-yi Lee]/PPO (v3).pdf differ diff --git a/books/[深度强化学习][Hung-yi Lee]/QLearning (v2).pdf b/books/[深度强化学习][Hung-yi Lee]/QLearning (v2).pdf new file mode 100755 index 0000000..91e4ec3 Binary files /dev/null and b/books/[深度强化学习][Hung-yi Lee]/QLearning (v2).pdf differ diff --git a/books/[深度强化学习][Hung-yi Lee]/Reward (v3).pdf b/books/[深度强化学习][Hung-yi Lee]/Reward (v3).pdf new file mode 100755 index 0000000..1e0841e Binary files /dev/null and b/books/[深度强化学习][Hung-yi Lee]/Reward (v3).pdf differ diff --git a/books/[神经网络与深度学习][邱锡鹏]/nndl-book.pdf b/books/[神经网络与深度学习][邱锡鹏]/nndl-book.pdf new file mode 100755 index 0000000..7934e35 Binary files /dev/null and b/books/[神经网络与深度学习][邱锡鹏]/nndl-book.pdf differ diff --git a/books/[神经网络与深度学习][邱锡鹏]/神经网络与深度学习-3小时.pdf b/books/[神经网络与深度学习][邱锡鹏]/神经网络与深度学习-3小时.pdf new file mode 100755 index 0000000..ccf6dc2 Binary files /dev/null and b/books/[神经网络与深度学习][邱锡鹏]/神经网络与深度学习-3小时.pdf differ diff --git a/books/[神经网络与深度学习][邱锡鹏]/神经网络与深度学习-3小时.pptx b/books/[神经网络与深度学习][邱锡鹏]/神经网络与深度学习-3小时.pptx new file mode 100755 index 0000000..e915e81 Binary files /dev/null and b/books/[神经网络与深度学习][邱锡鹏]/神经网络与深度学习-3小时.pptx differ diff --git a/books/d2l-zh.pdf b/books/d2l-zh.pdf new file mode 100755 index 0000000..43d8c22 Binary files /dev/null and b/books/d2l-zh.pdf differ diff --git a/books/docker_practice .pdf b/books/docker_practice .pdf new file mode 100755 index 0000000..0c7349f Binary files /dev/null and b/books/docker_practice .pdf differ diff --git a/books/gluon_tutorials_zh（基于MXNet）.pdf b/books/gluon_tutorials_zh（基于MXNet）.pdf new file mode 100755 index 0000000..0a7f406 Binary files /dev/null and b/books/gluon_tutorials_zh（基于MXNet）.pdf differ diff --git a/books/支持向量机通俗导论（理解SVM的三层境界）LaTeX最新版_2015.1.9.pdf b/books/支持向量机通俗导论（理解SVM的三层境界）LaTeX最新版_2015.1.9.pdf new file mode 100755 index 0000000..80d9442 Binary files /dev/null and b/books/支持向量机通俗导论（理解SVM的三层境界）LaTeX最新版_2015.1.9.pdf differ diff --git a/books/斯坦福大学-深度学习基础教程.pdf b/books/斯坦福大学-深度学习基础教程.pdf new file mode 100755 index 0000000..1fee426 Binary files /dev/null and b/books/斯坦福大学-深度学习基础教程.pdf differ diff --git a/books/机器学习周志华.pdf b/books/机器学习周志华.pdf new file mode 100755 index 0000000..168843e Binary files /dev/null and b/books/机器学习周志华.pdf differ diff --git a/books/机器学习实战 中文双页版.pdf b/books/机器学习实战 中文双页版.pdf new file mode 100755 index 0000000..18d6918 Binary files /dev/null and b/books/机器学习实战 中文双页版.pdf differ diff --git a/books/李航-统计学习/machine_learning_algorithm-master/AdaBoost/AdaBoost.py b/books/李航-统计学习/machine_learning_algorithm-master/AdaBoost/AdaBoost.py new file mode 100755 index 0000000..c41f052 --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/AdaBoost/AdaBoost.py @@ -0,0 +1,85 @@ +""" + @ jetou + @ AdaBoost algorithm + @ date 2017 11 19 + +""" +from weaker_classifier import * +import math + +class adaBoost: + def __init__(self, feature, label, Epsilon = 0): + self.feature = np.array(feature) + self.label = np.array(label) + self.Epsilon = Epsilon + self.N = self.feature.shape[0] + self.error = 1 + self.count_error = 1 + + self.alpha = [] + self.classifier = [] + self.W = [1.0 / self.N for i in range(self.N)] + + + def sign(self, value): + if value > 0: + value = 1 + elif value < 0: + value = -1 + else: + value = 0 + + return value + + def update_W_(self): + update_W = [] + z = 0 + for i in range(self.N): + pe = np.array([self.feature[i]]) + z += self.W[i] * math.exp(-1 * self.alpha[-1] * self.label[i] * self.classifier[-1].prediction(pe)) + + for i in range(self.N): + kk = np.array([self.feature[i]]) + w = self.W[i] * math.exp(-1 * self.alpha[-1] * self.label[i] * self.classifier[-1].prediction(kk)) / z + update_W.append(w) + self.W = update_W + + def __alpha__(self): + self.alpha.append(math.log((1-self.error)/self.error)/2) + + + def prediction(self, label): + finaly_prediction = [] + classifier_offset = len(self.classifier) + + for i in range(len(label)): + result = 0 + for j in range(classifier_offset): + pe = np.array([label[i]]) + result += self.alpha[j] * self.classifier[j].prediction(pe) + finaly_prediction.append(self.sign(result)) + + return finaly_prediction + + def complute_error(self): + # compute error + result = self.prediction(self.feature) + count_error = 0 + for i in range(self.N): + if result[i] * self.label[i] < 0: + count_error+=1 + self.count_error = count_error / (self.N * 1.0) #compute error% + + + + def train(self): + while(self.count_error > self.Epsilon): + classifier = weake_classifier(self.feature, self.label, self.W) + self.classifier.append(classifier) + classifier.train() + self.error, self.W, dem = classifier.get_information() + self.__alpha__() + self.update_W_() + self.complute_error() + + diff --git a/books/李航-统计学习/machine_learning_algorithm-master/AdaBoost/AdaBoost_test.py b/books/李航-统计学习/machine_learning_algorithm-master/AdaBoost/AdaBoost_test.py new file mode 100755 index 0000000..7d34095 --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/AdaBoost/AdaBoost_test.py @@ -0,0 +1,39 @@ +from AdaBoost import * + + +feature = np.array([ + [0], + [1], + [2], + [3], + [4], + [5], + [6], + [7], + [8], + [9], +]) + +label = np.array([ + [1], + [1], + [1], + [-1], + [-1], + [-1], + [1], + [1], + [1], + [-1], +]) + +test = np.array([ + [2], + [2], + [6], + [4], +]) + +a = adaBoost(feature, label) +a.train() +print a.prediction(test) \ No newline at end of file diff --git a/books/李航-统计学习/machine_learning_algorithm-master/AdaBoost/weaker_classifier.py b/books/李航-统计学习/machine_learning_algorithm-master/AdaBoost/weaker_classifier.py new file mode 100755 index 0000000..d31a033 --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/AdaBoost/weaker_classifier.py @@ -0,0 +1,73 @@ +""" + @ jetou + @ weaker_classifier algorithm + @ date 2017 11 19 + +""" +import numpy as np +class weake_classifier: + def __init__(self, feature, label, W = None): + self.feature = np.array(feature) + self.label = np.array(label) + + self.setlable = np.unique(label) + self.feature_dem = self.feature.shape[1] + self.N = self.feature.shape[0] + + if W != None: + self.W = np.array(W) + else: + self.W = [1.0 / self.N for i in range(self.N)] + + + def prediction(self, feature): + test_feature = np.array(feature) + output = np.ones((test_feature.shape[0],1)) + output[test_feature[:, self.demention] * self.finaly_label < self.threshold * self.finaly_label] = -1 + + + return output + + def __str__(self): + string = "opt_threshold:" + str(self.threshold) + "\n" + string += "opt_demention:" + str(self.demention) + "\n" + string += "opt_errorRate:" + str(self.error) + "\n" + string += "opt_label :" + str(self.finaly_label) + "\n" + string += "weights :" + str(self.W) + "\n" + + return string + + def best_along_dem(self, demention, label): + feature_max = np.max(self.feature) + feature_min = np.min(self.feature) + step = (feature_max - feature_min) / (self.N * 1.0) + min_error = self.N * 1.0 + + for i in np.arange(feature_min, feature_max, step): + output = np.ones((self.N, 1)) + output[self.feature[:, demention] * label < i * label] = -1 + + errorRate = 0.0 + for j in range(self.N): + if output[j] * self.label[j] < 0: + errorRate += self.W[j] + + if errorRate < min_error: + min_error = errorRate + threshold = i + + return threshold, min_error + + def train(self): + self.error = self.N * 1.0 + for demention in range(self.feature_dem): + for label in self.label: + threshold, err = self.best_along_dem(demention, label) + if self.error > err: + self.error = err + self.finaly_label = label + self.threshold = threshold + self.demention = demention + + def get_information(self): + return self.error, self.W, self.demention diff --git a/books/李航-统计学习/machine_learning_algorithm-master/AdaBoost/weaker_test.py b/books/李航-统计学习/machine_learning_algorithm-master/AdaBoost/weaker_test.py new file mode 100755 index 0000000..aa7340f --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/AdaBoost/weaker_test.py @@ -0,0 +1,52 @@ +from weaker_classifier import * + +feature = np.array([ + [0], + [1], + [2], + [3], + [4], + [5], + [6], + [7], + [8], + [9], +]) + +label = np.array([ + [1], + [1], + [1], + [-1], + [-1], + [-1], + [1], + [1], + [1], + [-1], +]) + +test = np.array([ + [2], +]) + +d=np.array([ + [0.007143], + [0.07143], + [0.07143], + [0.07143], + [0.07143], + [0.07143], + [0.16667], + [0.16667], + [0.16667], + [0.07143], +]) +pp = [] +a = weake_classifier(feature, label) +b = weake_classifier(feature, label,d) +a.train() +print a.__str__() +print a.prediction(test) +b.train() +print b.__str__() diff --git a/books/李航-统计学习/machine_learning_algorithm-master/EM/Gmm.py b/books/李航-统计学习/machine_learning_algorithm-master/EM/Gmm.py new file mode 100755 index 0000000..c9768a0 --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/EM/Gmm.py @@ -0,0 +1,87 @@ +# -*- coding: utf-8 -*- + +""" + @ jetou + @ Gaussian misture model + @ date 2017 11 27 + +""" +# Reference http://blog.csdn.net/jinping_shi/article/details/59613054 + + +import numpy as np +import math +import copy + +class EmGMM: + def __init__(self, sigma, k, N, MU, epsilon): + """ + k is the number of Gaussian distribution + N is the number of feature + sigma is variance + """ + self.k = k + self.N = N + self.epsilon = epsilon + self.sigma = sigma + self.MU = np.matrix(MU) + self.alpha = [0.5, 0.5] + + def init_data(self): + self.X = np.matrix(np.zeros((self.N, 2))) + self.Mu = np.random.random(self.k) + self.Expectations = np.zeros((self.N, self.k)) + for i in xrange(self.N): + if np.random.random(1) > 0.5: + self.X[i,:] = np.random.multivariate_normal(self.MU.tolist()[0], self.sigma, 1) + else: + self.X[i,:] = np.random.multivariate_normal(self.MU.tolist()[1], self.sigma, 1) + + def e_step(self): + for i in range(self.N): + Denom = 0 + Numer = [0.0] * self.k + for j in range (self.k): + Numer[j] = self.alpha[j] * math.exp(-(self.X[i,:] - self.MU[j,:]) * self.sigma.I * np.transpose(self.X[i,:] - self.MU[j,:])) \ + / np.sqrt(np.linalg.det(self.sigma)) + Denom += Numer[j] + for j in range(0, self.k): + self.Expectations[i, j] = Numer[j] / Denom + + def m_step(self): + for j in xrange(0, self.k): + Numer = 0 + Denom = 0 + sabi = 0 + for i in xrange(0, self.N): + Numer += self.Expectations[i, j] * self.X[i, :] + Denom += self.Expectations[i, j] + self.MU[j, :] = Numer / Denom + self.alpha[j] = Denom / self.N + for i in xrange(0, self.N): + sabi += self.Expectations[i, j] * np.square((self.X[i, :] - self.MU[j, :])) + self.sigma[j, :]= sabi / Denom + + def train(self, inter=1000): + self.init_data() + for i in range(inter): + error = 0 + err_alpha = 0 + err_sigma = 0 + old_mu = copy.deepcopy(self.MU) + old_alpha = copy.deepcopy(self.alpha) + old_sigma = copy.deepcopy(self.sigma) + self.e_step() + self.m_step() + print "The number of iterations", i + print "Location parameters: mu", self.MU + print "variance: sigma", self.sigma + print "Selected probability: alpha", self.alpha + for j in range(self.k): + error += (abs(old_mu[j, 0] - self.MU[j, 0]) + abs(old_mu[j, 1] - self.MU[j, 1])) + err_sigma += (abs(old_sigma[j, 0] - self.sigma[j, 0]) + abs(old_sigma[j, 1] - self.sigma[j, 1])) + err_alpha += abs(old_alpha[j] - self.alpha[j]) + if (error <= self.epsilon) and (err_sigma <= self.epsilon) and (err_alpha <= self.epsilon): + print error, err_alpha, err_sigma + break + diff --git a/books/李航-统计学习/machine_learning_algorithm-master/EM/gmm_test.py b/books/李航-统计学习/machine_learning_algorithm-master/EM/gmm_test.py new file mode 100755 index 0000000..7c02cc7 --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/EM/gmm_test.py @@ -0,0 +1,7 @@ +from Gmm import * + +sigma = np.matrix([[30, 0], [0, 30]]) +MU = [[40, 20], [5, 35]] +a = EmGMM(sigma, 2, 1000, MU, 0.001) + +a.train() \ No newline at end of file diff --git a/books/李航-统计学习/machine_learning_algorithm-master/README.md b/books/李航-统计学习/machine_learning_algorithm-master/README.md new file mode 100755 index 0000000..c5c642c --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/README.md @@ -0,0 +1 @@ +machine learning algorithm in the <统计学习方法> diff --git a/books/李航-统计学习/machine_learning_algorithm-master/decision_tree/cart_Classification_tree.py b/books/李航-统计学习/machine_learning_algorithm-master/decision_tree/cart_Classification_tree.py new file mode 100755 index 0000000..8e1bfea --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/decision_tree/cart_Classification_tree.py @@ -0,0 +1,106 @@ +""" + @ jetou + @ cart decision_tree + @ date 2017 10 29 + +""" +import numpy as np + +class tree: + def __init__(self, feature, label): + self.feature = feature + self.label = label + + def Gini(self, dataset): + + data_set = set(dataset) + sum = 0.0 + data_length = dataset.shape[0] * 1.0 + for i in data_set: + sum += (np.count_nonzero(dataset == i) / data_length) ** 2 + + return 1.0 - sum + + def cmpgini(self, feature, label): + label = np.array(label).flatten(1) + unique = set(feature) + min = 1 + count_feature = np.shape(feature)[0] + for i in unique: + c1 = np.count_nonzero(feature == i) * self.Gini(label[feature == i]) / count_feature + c2 = np.count_nonzero(feature != i) * self.Gini(label[feature != i]) / count_feature + if min > (c1 + c2): + min = c1 + c2 + result = i + return result, min + + def maketree(self, feature, label): + label = label.flatten(1) + train_feature = feature.transpose() + + min = 1.0 + opt_feature = 0 + opt_feature_val = 0 + + if np.unique(label).size == 1: + return label[0] + + for i in range(len(train_feature)): + result, p = self.cmpgini(train_feature[i], label) + if p < min: + min = p + opt_feature = i + opt_feature_val = result + + if min == 1.0: + return label + + left = [] + right = [] + + left = self.maketree(train_feature.transpose()[train_feature.transpose()[:, opt_feature] != opt_feature_val], + label[train_feature.transpose()[:, opt_feature] != opt_feature_val]) + # + right = self.maketree(train_feature.transpose()[train_feature.transpose()[:, opt_feature] == opt_feature_val], + label[train_feature.transpose()[:, opt_feature] == opt_feature_val]) + + + return [(opt_feature, opt_feature_val), left, right] + + def train(self): + self.train_result = self.maketree(self.feature, self.label) + + def prediction(self, Mat): + Mat = np.array(Mat).transpose() + result = np.zeros((Mat.shape[0], 1)) + for i in range(Mat.shape[0]): + tree = self.train_result + while self.isLeaf(tree) == False: + feature, val = tree[0] + if Mat[i][feature] == val: + + tree = self.getRight(tree) + else: + tree = self.getLeft(tree) + + result[i] = tree + + return result + + def isLeaf(self, tree): + if isinstance(tree, list): + return False + else: + return True + + def getLeft(self, tree): + assert isinstance(tree, list) + return tree[1] + + def getRight(self, tree): + assert isinstance(tree, list) + return tree[2] + + + + diff --git a/books/李航-统计学习/machine_learning_algorithm-master/decision_tree/test.py b/books/李航-统计学习/machine_learning_algorithm-master/decision_tree/test.py new file mode 100755 index 0000000..641eba9 --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/decision_tree/test.py @@ -0,0 +1,45 @@ +import numpy +from cart_Classification_tree import * +train_feature = np.array([ +['teenager', 'no', 'no', 0.0], +['teenager', 'no', 'no', 1.0], +['teenager', 'yes', 'no', 1.0], +['teenager', 'yes', 'yes', 0.0], +['teenager', 'no', 'no', 0.0], +['senior citizen', 'no', 'no', 0.0], +['senior citizen', 'no', 'no', 1.0], +['senior citizen', 'yes', 'yes', 1.0], +['senior citizen', 'no', 'yes', 2.0], +['senior citizen', 'no', 'yes', 2.0], +['old pepple', 'no', 'yes', 2.0], +['old pepple', 'no', 'yes', 1.0], +['old pepple', 'yes', 'no', 1.0], +['old pepple', 'yes', 'no', 2.0], +['old pepple', 'no', 'no', 0.0], +]) + +Tag = np.array([ +[-1], +[-1], +[+1], +[+1], +[-1], +[-1], +[-1], +[+1], +[+1], +[+1], +[+1], +[+1], +[+1], +[+1], +[-1], +]).transpose() + +a = tree(train_feature, Tag) +a.train() +s = a.prediction(np.array([ + ['teenager', 'no', 'no', 0], + ['old pepple', 'yes', 'no', 2], + ]).transpose()) +print s \ No newline at end of file diff --git a/books/李航-统计学习/machine_learning_algorithm-master/k_nearest_neighbor/knn_kdtree.py b/books/李航-统计学习/machine_learning_algorithm-master/k_nearest_neighbor/knn_kdtree.py new file mode 100755 index 0000000..7161213 --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/k_nearest_neighbor/knn_kdtree.py @@ -0,0 +1,76 @@ +import numpy as np + + +import numpy as np + +class Node: + def __init__(self, data, lchild=None, rchild=None): + self.data = data + self.lchild = lchild + self.rchild = rchild + + def sort(self, dataSet, axis): + sortDataSet = dataSet[:] + m, n = np.shape(sortDataSet) + for i in range(m): + for j in range(0, m - i - 1): + if (sortDataSet[j][axis] > sortDataSet[j + 1][axis]): + temp = sortDataSet[j] + sortDataSet[j] = sortDataSet[j + 1] + sortDataSet[j + 1] = temp + return sortDataSet + + def create(self, dataSet, depth): + if len(dataSet) > 0: + m, n = np.shape(dataSet) + midIndex = len(dataSet)/2 + axis = depth % n + sortedDataSet = self.sort(dataSet, axis) + node = Node(sortedDataSet[midIndex]) + + leftDataSet = sortedDataSet[: midIndex] + rightDataSet = sortedDataSet[midIndex + 1:] + node.lchild = self.create(leftDataSet, depth + 1) + node.rchild = self.create(rightDataSet, depth + 1) + return node + else: + return None + + def preOrder(self, node): + if node != None: + self.preOrder(node.lchild) + self.preOrder(node.rchild) + + def search(self, tree, x): + self.nearestPoint = None + self.nearestValue = 0 + + def travel(node, depth=0): + if node != None: + n = len(x) + axis = depth % n + if x[axis] < node.data[axis]: + travel(node.lchild, depth + 1) + else: + travel(node.rchild, depth + 1) + + + distNodeAndX = self.dist(x, node.data) + if (self.nearestPoint == None): + self.nearestPoint = node.data + self.nearestValue = distNodeAndX + elif (self.nearestValue > distNodeAndX): + self.nearestPoint = node.data + self.nearestValue = distNodeAndX + + if (abs(x[axis] - node.data[axis]) <= self.nearestValue): + if x[axis] < node.data[axis]: + travel(node.rchild, depth + 1) + else: + travel(node.lchild, depth + 1) + + travel(tree) + return self.nearestPoint + + def dist(self, x1, x2): + return ((np.array(x1) - np.array(x2)) ** 2).sum() ** 0.5 diff --git a/books/李航-统计学习/machine_learning_algorithm-master/k_nearest_neighbor/test.py b/books/李航-统计学习/machine_learning_algorithm-master/k_nearest_neighbor/test.py new file mode 100755 index 0000000..32de896 --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/k_nearest_neighbor/test.py @@ -0,0 +1,14 @@ +import numpy as np +from knn_kdtree import * + +dataSet = [[2, 3], + [5, 4], + [9, 6], + [4, 7], + [8, 1], + [7, 2]] +x = [3, 4.5] +kdtree = Node(dataSet) +tree = kdtree.create(dataSet,0) +kdtree.preOrder(tree) +print kdtree.search(tree, x) \ No newline at end of file diff --git a/books/李航-统计学习/machine_learning_algorithm-master/logistic_regression/logistic_regression.py b/books/李航-统计学习/machine_learning_algorithm-master/logistic_regression/logistic_regression.py new file mode 100755 index 0000000..3432d04 --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/logistic_regression/logistic_regression.py @@ -0,0 +1,69 @@ +""" + @ jetou + @ logistic_regression binary + @ date 2017 11 03 + +""" + +import numpy as np +import random +import math + +class LogisticRegression: + def __init__(self, feature, label, step=0.4, max_iteration=5000): + self.feature = np.array(feature).transpose() + self.label = np.array(label).transpose() + self.learning_step = step + self.max_iteration = max_iteration + + def compute(self, x): + wx = sum([self.w[j] * x[j] for j in xrange(self.w.shape[0])]) + exp_wx = math.exp(wx) + + p1 = exp_wx / (1 + exp_wx) + p0 = 1 / (1 + exp_wx) + + if p1 > p0: + return 1 + else: + return 0 + + def train(self): + self.w = np.zeros((self.feature.shape[0],1)) + + correct = 0 + time = 0 + + while time < self.max_iteration: + index = random.randint(0, self.label.shape[1] - 1) + x = list(self.feature[:,index]) + x.append(1.0) + y = self.label[:,index] + + if y == self.compute(x): + correct += 1 + if correct > self.max_iteration: + break + continue + + time+=1 + correct = 0 + + wx = sum([self.w[j] * x[j] for j in xrange(self.w.shape[0])]) + exp_wx = math.exp(wx) + + for i in xrange(self.w.shape[0]): + self.w[i] -= self.learning_step * (-y * x[i] + float(x[i] * exp_wx) / float(1 + exp_wx)) + + def prediction(self,features): + labels = [] + + for feature in features: + x = list(feature) + x.append(1) + labels.append(self.compute(x)) + + return labels + + + diff --git a/books/李航-统计学习/machine_learning_algorithm-master/logistic_regression/test.py b/books/李航-统计学习/machine_learning_algorithm-master/logistic_regression/test.py new file mode 100755 index 0000000..0672bde --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/logistic_regression/test.py @@ -0,0 +1,26 @@ +import numpy as np +from logistic_regression import * + + + +feature = np.array([ + [3,3], + [4,3], + [1,1], +]) + +label = np.array([ + [1], + [1], + [0], +]) + +test_point = np.array([ + [+5,+5], + [-1,-1], +]) + +a = LogisticRegression(feature, label) +a.train() +f = a.prediction(test_point) +print f \ No newline at end of file diff --git a/books/李航-统计学习/machine_learning_algorithm-master/naive_bayes/naive_bayes.py b/books/李航-统计学习/machine_learning_algorithm-master/naive_bayes/naive_bayes.py new file mode 100755 index 0000000..de1dfa9 --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/naive_bayes/naive_bayes.py @@ -0,0 +1,42 @@ +""" + @ jetou + @ cart decision_tree + @ date 2017 10 31 + +""" + +import numpy as np + +class naive_bayes: + def __init__(self, feature, label): + self.feature = feature.transpose() + self.label = label.transpose().flatten(1) + self.positive = np.count_nonzero(self.label == 1) * 1.0 + self.negative = np.count_nonzero(self.label == -1) * 1.0 + + def train(self): + positive_dict = {} + negative_dict = {} + for i in self.feature: + unqiue = set(i) + for j in unqiue: + positive_dict[j] = np.count_nonzero(self.label[i==j]==1) / self.positive + negative_dict[j] = np.count_nonzero(self.label[i==j]==-1) / self.negative + + return positive_dict, negative_dict + + def prediction(self, pre_feature): + + positive_chance = self.positive / self.label.shape[0] + negative_chance = self.negative / self.label.shape[0] + positive_dict, negative_dict = self.train() + for i in pre_feature: + i = str(i) + positive_chance *= positive_dict[i] + negative_chance *= negative_dict[i] + + if positive_chance > negative_chance: + return 1 + else: + return -1 + diff --git a/books/李航-统计学习/machine_learning_algorithm-master/naive_bayes/test.py b/books/李航-统计学习/machine_learning_algorithm-master/naive_bayes/test.py new file mode 100755 index 0000000..d7293ca --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/naive_bayes/test.py @@ -0,0 +1,42 @@ +import numpy as np +from naive_bayes import * + +feature = np.array([ + [1, 'S'], + [1, 'M'], + [1, 'M'], + [1, 'S'], + [1, 'S'], + [2, 'S'], + [2, 'M'], + [2, 'M'], + [2, 'L'], + [2, 'L'], + [3, 'L'], + [3, 'M'], + [3, 'M'], + [3, 'L'], + [3, 'L'], +]) + +label = np.array([ + [-1], + [-1], + [1], + [1], + [-1], + [-1], + [-1], + [1], + [1], + [1], + [1], + [1], + [1], + [1], + [-1], +]) + +a = naive_bayes(feature, label) +print a.prediction([2,'S']) + diff --git a/books/李航-统计学习/machine_learning_algorithm-master/perceptron/perceptron.py b/books/李航-统计学习/machine_learning_algorithm-master/perceptron/perceptron.py new file mode 100755 index 0000000..42c3b54 --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/perceptron/perceptron.py @@ -0,0 +1,79 @@ +""" + @ jetou + @ perceptron Duality + @ date 2017 11 01 + +""" +import numpy as np + +class perceptron: + def __init__(self, feature, label, gama=1): + self.feature = feature.transpose() + self.label = label.transpose() + self.__feature = feature + + self.row = self.feature.shape[0] + self.col = self.feature.shape[1] + + self.alpha = [0] * self.col + self.b = 0 + self.gama = gama + + def gram(self): # compute gram matrix + self.gram_mat = np.empty(shape=(self.col, self.col)) + for i in range(self.col): + for j in range(self.col): + self.gram_mat[i][j] = self.inner(self.__feature[i], self.__feature[j]) + + def inner(self, a, b): + result = a[0] * b[0] + a[1] * b[1] + return result + + def misinterpreted(self, yi, index): + pa1 = self.alpha * self.label + pa2 = self.gram_mat[:,index] + num = yi * (np.dot(pa1, pa2) + self.b) + return num + + def fit(self, alpha, b): + label = self.label.flatten(1) + for i in range(self.col): + while self.misinterpreted(label[i],i) <= 0: + self.alpha[i] += self.gama + self.b += self.gama * label[i] + if alpha!=self.alpha or b != self.b: #To prevent the front of a bit not fit + self.fit(self.alpha, self.b) + return self.alpha + + def train(self): + self.gram() + self.w = sum((self.fit(1,2)*self.feature*self.label).transpose()) #self.fit(x,y) Any two numbers + + def dot_prediction(self, A, B): + assert len(A) == len(B) + summer = 0 + for i in range(len(A)): + summer += A[i] * B[i] + + return summer + + def prediction(self, feature): + Mat = np.array(feature).transpose() + col = Mat.shape[1] + + output = [] + for i in range(col): + if self.dot_prediction(self.w, Mat[:,i]) + self.b > 0: + output.append(+1) + else: + output.append(-1) + + return output + + def get_wandb(self): # plot w b + return self.w, self.b + + + + + diff --git a/books/李航-统计学习/machine_learning_algorithm-master/perceptron/test.py b/books/李航-统计学习/machine_learning_algorithm-master/perceptron/test.py new file mode 100755 index 0000000..775eba7 --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/perceptron/test.py @@ -0,0 +1,45 @@ +import numpy as np +from perceptron import * +import matplotlib.pyplot as plt + +feature = np.array([ + [3,3], + [4,3], + [1,1], +]) + +label = np.array([ + [1], + [1], + [-1], +]) + +a = perceptron(feature, label) +a.train() + +test_point = np.array([ + [+5,+5], + [-1,-1]]) +print a.prediction(test_point) + +w,b = a.get_wandb() + + +#########plot############################## +def plot_function(samples, labels, w, b): + index = 0 + for i in samples: + if labels[index] == 1: + s = 'x' + else: + s = 'o' + plt.scatter(i[0], i[1], marker=s) + index += 1 + xData = np.linspace(0, 5, 100) + yData = (-b - w[0] * xData)/pow(w[1],2) + plt.plot(xData, yData, color='r', label='sample data') + + plt.show() + +plot_function(feature, label, w, b) +plot_function(test_point, a.prediction(test_point), w, b) \ No newline at end of file diff --git a/books/李航-统计学习/machine_learning_algorithm-master/support_vector_machine/dual_algorithm_test.py b/books/李航-统计学习/machine_learning_algorithm-master/support_vector_machine/dual_algorithm_test.py new file mode 100755 index 0000000..e47a8c9 --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/support_vector_machine/dual_algorithm_test.py @@ -0,0 +1,32 @@ +import numpy as np +from support_vector_machine import * + + + +x = np.array([ + [3,3], + [4,3], + [1,1], + [7,7], + [10,10], +]) + +y = np.array([ + [1], + [1], + [-1], + [1], + [1], +]) + + +test = np.array([ + [1,2], + [7,6], + [-1,3], +]) + +a = supprot_vector_machine(x, y) +a.fit() +print a.prediction(x) +print a.prediction(test) \ No newline at end of file diff --git a/books/李航-统计学习/machine_learning_algorithm-master/support_vector_machine/support_vector_machine.py b/books/李航-统计学习/machine_learning_algorithm-master/support_vector_machine/support_vector_machine.py new file mode 100755 index 0000000..54a0f35 --- /dev/null +++ b/books/李航-统计学习/machine_learning_algorithm-master/support_vector_machine/support_vector_machine.py @@ -0,0 +1,156 @@ +""" + @ jetou + @ support_vector_machine dual algorithm + @ date 2017 11 12 + +""" + + +import numpy as np +from sympy import * + + +class supprot_vector_machine: + def __init__(self, feature, label): + self.feature = np.array(feature) + self.label = np.array(label) + self.N = len(self.feature) + self.n = -1 + self.alpha = symbols(["alpha" + str(i) for i in range(1, self.N + 1)]) + self.solution = [] + + #train + def transvection(self, a,b): # compute inner product + result = 0 # conpute inner product function most used gram marix + offset = len(a) + for i in range(offset): + result += a[i] * b[i] + return result + + def eval_function(self): # compute Master equation + c = 0 + s = 0 #Temporary variable + offset = self.N + for i in range(offset): + s += self.alpha[i] + for j in range(offset): + c += self.alpha[i] * self.alpha[j] * self.label[i][0] * self.label[j][0] * self.transvection(self.feature[i], self.feature[j]) + self.equation = c/2 - s + + def replace_x(self): # add the constraints use alpha * y and subject to [alpha1 + alpha2 + ... alphaN] = 0 + self.n+=1 + alpha_ = self.alpha[:] + for i in range(len(alpha_)): + alpha_[i] = alpha_[i] * self.label[i][0] + equation = Eq(sum(alpha_),0) + self.solve_equation = solve([equation], self.alpha[0]) + self.equation = self.equation.replace(self.solve_equation.keys()[0], + self.solve_equation.get(self.solve_equation.keys()[0])) + + def derivative(self): # conpute derivative + self.surplus_alpha = self.alpha[:] + self.equation_list = [] + self.surplus_alpha.remove(self.solve_equation.keys()[0]) + for i in self.surplus_alpha: + self.equation_list.append(diff(self.equation, i)) + self.solution = solve(self.equation_list) + + def boundary(self): # If the constraint conditions are violated + min = 10000 + self.surplus_alpha.reverse() + + s = solve(self.replace_model(self.equation_list[:])) + + finaly = [] + for i in range(len(s)): + m = self.equation + for j in range(len(s)): + if j!=i: + m = m.replace(symbols("alpha"+str(j+2)), 0) + finaly.append(m) + + for i in range(len(s)): + K = Eq(symbols("pp"), finaly[i]) + sad = solve([K, Eq(symbols("alpha" + str(i+2)), s.get(symbols("alpha" + str(i+2))))])[0].get(symbols("pp")) + if min > sad: + result = {} + min = sad + result[symbols("alpha" + str(i+2))] = s.get(symbols("alpha" + str(i+2))) + + for i in range(2, len(s)+2): + if symbols("alpha"+str(i)) not in result.keys(): + result[symbols("alpha"+str(i))] = 0 + + self.solution = result + + # auxiliary function + def replace_model(self, lists): + bound = lists + k=len(bound) + for i in range(k): + for j in range(k): + if j!=i: + bound[i] = bound[i].replace(symbols("alpha"+str(j+2)), 0) + return bound + + def get_origin(self, source): + value_list = [Eq(i, source.get(i)) for i in source.keys()] + value_list.append(Eq(self.solve_equation.keys()[0], self.solve_equation.get(self.solve_equation.keys()[0]))) + return solve(value_list) + + #enter + def fit(self): + self.eval_function() + self.replace_x() + self.derivative() + for i in self.solution: + if (self.solution.get(i)) < 0: + self.boundary() + break + if self.solution == []: + self.boundary() + self.solution = self.get_origin(self.solution) + + final_alpha = [self.solution.get(self.alpha[i]) for i in range(len(self.solution))] + final_alpha = [[i] for i in final_alpha] + + + #self.w + self.w = sum(final_alpha *self.feature*self.label) + + #self.b + for i in range(len(final_alpha)): #The presence of subscript j makes alpha_j>0 + if final_alpha[i] != 0: + alpha_j = i + break + kk = [] + for i in range(self.N): + kk.append(self.transvection(self.feature[i], self.feature[alpha_j])) + + self.b = [final_alpha[i] * self.label[i] * kk[i] for i in range(self.N)] + self.b = self.label[alpha_j] - sum(self.b) + + #prediction + def prediction(self, feature): + Mat = np.array(feature).transpose() + col = Mat.shape[1] + + output = [] + for i in range(col): + if sum(Mat[:,i] * self.w) + self.b > 0: + output.append(+1) + else: + output.append(-1) + + return output + + + + + + + + + + + diff --git a/books/李航-统计学习/统计学习方法.pdf b/books/李航-统计学习/统计学习方法.pdf new file mode 100755 index 0000000..e045eb3 Binary files /dev/null and b/books/李航-统计学习/统计学习方法.pdf differ diff --git a/books/模式识别与机器学习PRML_Chinese_vision.pdf b/books/模式识别与机器学习PRML_Chinese_vision.pdf new file mode 100755 index 0000000..90a073f Binary files /dev/null and b/books/模式识别与机器学习PRML_Chinese_vision.pdf differ diff --git a/books/深度学习.Yoshua Bengio+Ian GoodFellow.pdf b/books/深度学习.Yoshua Bengio+Ian GoodFellow.pdf new file mode 100755 index 0000000..2a49bdc Binary files /dev/null and b/books/深度学习.Yoshua Bengio+Ian GoodFellow.pdf differ diff --git a/books/神经网络和深度学习neural networks and deep-learning-中文_ALL.pdf b/books/神经网络和深度学习neural networks and deep-learning-中文_ALL.pdf new file mode 100755 index 0000000..fdc35dd Binary files /dev/null and b/books/神经网络和深度学习neural networks and deep-learning-中文_ALL.pdf differ diff --git a/books/自然语言处理.Jacob Eisenstein.pdf b/books/自然语言处理.Jacob Eisenstein.pdf new file mode 100755 index 0000000..034450d Binary files /dev/null and b/books/自然语言处理.Jacob Eisenstein.pdf differ diff --git a/books/解析卷积神经网络--深度学习实践手册.pdf b/books/解析卷积神经网络--深度学习实践手册.pdf new file mode 100755 index 0000000..c6e8624 Binary files /dev/null and b/books/解析卷积神经网络--深度学习实践手册.pdf differ diff --git a/notes/Images/MathematicalBasis.png b/notes/Images/MathematicalBasis.png new file mode 100755 index 0000000..194bdeb Binary files /dev/null and b/notes/Images/MathematicalBasis.png differ