├── README.md ├── Week 10- Change of basis- Orthonormal bases and the Gram-Schmidt process └── GSO.ipynb ├── Week 1- Vector ├── 1_basics.ipynb ├── norm_linear algebra with python3.ipynb └── vector_linear algebra with python3.ipynb ├── Week 12- Linear Algebra in ML ├── 2_Least+square+problem.ipynb ├── 3_decompostion .ipynb ├── 3_knn_pca.ipynb ├── FFN.ipynb ├── movies_w_imgurl.csv ├── pima_indians_diabetes.data.csv ├── ratings-9_1.csv ├── 추천시스템_svd.ipynb ├── 풀잎스쿨_LA_063018.pdf └── 풀잎스쿨_행렬분해_LA.pdf ├── Week 4- Matrices for solving systems by elimination- Null space and column space ├── 2_basic_linear system.ipynb ├── Matrices+for+solving+system.ipynb ├── marrix_linear algebra with python3.ipynb └── matrix ├── Week 8- Transpose of a matrix ├── marrix_transpose.ipynb └── transpose ├── Week 9- Orthogonal complements- Orthogonal projections ├── Orthogonal projection └── Orthogonal+projection.ipynb ├── [MAC]쥬피터노트북설치하기.pdf ├── [WINDOWS]쥬피터노트북설치하기.pdf ├── [Week 11] Eigen-everything ├── [Week 2] Linear combinations and spans, Linear dependence and independence ├── [Week 3] Subspaces and the basis for a subspace, Vector dot and cross products ├── [Week 5] Functions and linear transformations, Linear transformation examples ├── [Week 6] Transformations and matrix multiplication, Inverse functions and transformations └── [Week 7] Finding inverses and determinants, More determinant depth /README.md: -------------------------------------------------------------------------------- 1 | # Linear-Algebra-with-python 2 | 3 | Week 1. Vectors 4 | 5 | Week 2. Linear combination and spans, Linear dependence and independence 6 | 7 | Week 3. Subspaces and the basis for a subspace, vector dot and cross products 8 | 9 | Week 4. Matrices for solving systems by elimination, null space and column space 10 | 11 | Week 5. Functions and linear transformation, linear transformation examples 12 | 13 | Week 6. Transformations and matrix multiplication, inverse functions and transformation examples 14 | 15 | Week 7. Finding inverses and determinants, more determinant depth 16 | 17 | Week 8. Transpose of a matrix 18 | 19 | Week 9. Orthogonal complements, Orthogonal projections 20 | 21 | Week 10. Change of basis, Orthonormal bases and the Gram-Schmidt process 22 | 23 | Week 11. Eigen-everything 24 | 25 | Week 12. linear algebra in DL/ML 26 | -------------------------------------------------------------------------------- /Week 10- Change of basis- Orthonormal bases and the Gram-Schmidt process/GSO.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Gram Schmidt Process\n", 8 | "\n", 9 | "### 간단예제" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 1, 15 | "metadata": {}, 16 | "outputs": [ 17 | { 18 | "name": "stdout", 19 | "output_type": "stream", 20 | "text": [ 21 | "x1= [3 6 0]\n", 22 | "y2= [1 2 2]\n" 23 | ] 24 | }, 25 | { 26 | "data": { 27 | "text/plain": [ 28 | "15" 29 | ] 30 | }, 31 | "execution_count": 1, 32 | "metadata": {}, 33 | "output_type": "execute_result" 34 | } 35 | ], 36 | "source": [ 37 | "from numpy import array\n", 38 | "x1=array([3,6,0])\n", 39 | "y2=array([1,2,2])\n", 40 | "print('x1=',x1)\n", 41 | "print('y2=',y2)\n", 42 | "y2.dot(x1)" 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": 2, 48 | "metadata": {}, 49 | "outputs": [ 50 | { 51 | "name": "stdout", 52 | "output_type": "stream", 53 | "text": [ 54 | "[ 0. 0. 2.]\n" 55 | ] 56 | } 57 | ], 58 | "source": [ 59 | "from numpy import array\n", 60 | "x1=array([3,6,0])\n", 61 | "y2=array([1,2,2])\n", 62 | "a1=y2.dot(x1)\n", 63 | "aa=x1.dot(x1)\n", 64 | "x2=y2-(a1/aa)*x1\n", 65 | "print(x2)" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "### check the orthogonality" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": 3, 78 | "metadata": {}, 79 | "outputs": [ 80 | { 81 | "data": { 82 | "text/plain": [ 83 | "0.0" 84 | ] 85 | }, 86 | "execution_count": 3, 87 | "metadata": {}, 88 | "output_type": "execute_result" 89 | } 90 | ], 91 | "source": [ 92 | "x1.dot(x2)" 93 | ] 94 | } 95 | ], 96 | "metadata": { 97 | "kernelspec": { 98 | "display_name": "Python 3", 99 | "language": "python", 100 | "name": "python3" 101 | }, 102 | "language_info": { 103 | "codemirror_mode": { 104 | "name": "ipython", 105 | "version": 3 106 | }, 107 | "file_extension": ".py", 108 | "mimetype": "text/x-python", 109 | "name": "python", 110 | "nbconvert_exporter": "python", 111 | "pygments_lexer": "ipython3", 112 | "version": "3.6.3" 113 | } 114 | }, 115 | "nbformat": 4, 116 | "nbformat_minor": 2 117 | } 118 | -------------------------------------------------------------------------------- /Week 1- Vector/1_basics.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 21, 6 | "metadata": { 7 | "collapsed": true 8 | }, 9 | "outputs": [], 10 | "source": [ 11 | "import numpy as np" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 22, 17 | "metadata": {}, 18 | "outputs": [ 19 | { 20 | "name": "stdout", 21 | "output_type": "stream", 22 | "text": [ 23 | "(3,)\n", 24 | "1\n" 25 | ] 26 | } 27 | ], 28 | "source": [ 29 | "# column vector\n", 30 | "c = np.array([1,2,3])\n", 31 | "print(c.shape)\n", 32 | "\n", 33 | "# obtaining a particular entry\n", 34 | "print (c[0])" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": 23, 40 | "metadata": {}, 41 | "outputs": [ 42 | { 43 | "name": "stdout", 44 | "output_type": "stream", 45 | "text": [ 46 | "(1, 3)\n" 47 | ] 48 | } 49 | ], 50 | "source": [ 51 | "# row vector\n", 52 | "r = np.array([ [1,2,3] ])\n", 53 | "print (r.shape)" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": 24, 59 | "metadata": {}, 60 | "outputs": [ 61 | { 62 | "name": "stdout", 63 | "output_type": "stream", 64 | "text": [ 65 | "2\n" 66 | ] 67 | } 68 | ], 69 | "source": [ 70 | "# obtaining a particular entry\n", 71 | "print (r[0,1])" 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": 25, 77 | "metadata": {}, 78 | "outputs": [ 79 | { 80 | "name": "stdout", 81 | "output_type": "stream", 82 | "text": [ 83 | "[[ 0. 0.]\n", 84 | " [ 0. 0.]]\n", 85 | "[[ 1. 1.]\n", 86 | " [ 1. 1.]]\n", 87 | "[[7 7]\n", 88 | " [7 7]]\n", 89 | "[[ 0.93589863 0.19331487]\n", 90 | " [ 0.14309097 0.43003853]]\n" 91 | ] 92 | } 93 | ], 94 | "source": [ 95 | "# creating a matrix with all zeros\n", 96 | "a = np.zeros((2,2))\n", 97 | "print (a)\n", 98 | "# creating a matrix with all ones\n", 99 | "b = np.ones((2,2))\n", 100 | "print (b)\n", 101 | " \n", 102 | "# creating a matrix filled with the same constant\n", 103 | "c = np.full((2,2), 7)\n", 104 | "print (c)\n", 105 | " \n", 106 | "# creating a matrix with random values\n", 107 | "d = np.random.random((2,2))\n", 108 | "print (d)" 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": 26, 114 | "metadata": { 115 | "scrolled": true 116 | }, 117 | "outputs": [ 118 | { 119 | "name": "stdout", 120 | "output_type": "stream", 121 | "text": [ 122 | "[[1 2]\n", 123 | " [3 4]\n", 124 | " [5 6]]\n" 125 | ] 126 | } 127 | ], 128 | "source": [ 129 | "# creating a matrix\n", 130 | "A=np.array([[1,2],[3,4],[5,6]])\n", 131 | "print (A)\n" 132 | ] 133 | }, 134 | { 135 | "cell_type": "code", 136 | "execution_count": 27, 137 | "metadata": {}, 138 | "outputs": [ 139 | { 140 | "data": { 141 | "text/plain": [ 142 | "array([[11, 12, 13, 14],\n", 143 | " [15, 16, 17, 18]])" 144 | ] 145 | }, 146 | "execution_count": 27, 147 | "metadata": {}, 148 | "output_type": "execute_result" 149 | } 150 | ], 151 | "source": [ 152 | "# creating another matrix\n", 153 | "B=np.array([[11,12,13,14],[15,16,17,18]])\n", 154 | "B" 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": 28, 160 | "metadata": {}, 161 | "outputs": [ 162 | { 163 | "data": { 164 | "text/plain": [ 165 | "array([[1, 3, 5],\n", 166 | " [2, 4, 6]])" 167 | ] 168 | }, 169 | "execution_count": 28, 170 | "metadata": {}, 171 | "output_type": "execute_result" 172 | } 173 | ], 174 | "source": [ 175 | "# transpose a matrix\n", 176 | "A.T" 177 | ] 178 | }, 179 | { 180 | "cell_type": "code", 181 | "execution_count": 29, 182 | "metadata": { 183 | "scrolled": true 184 | }, 185 | "outputs": [ 186 | { 187 | "data": { 188 | "text/plain": [ 189 | "array([[ 41, 44, 47, 50],\n", 190 | " [ 93, 100, 107, 114],\n", 191 | " [145, 156, 167, 178]])" 192 | ] 193 | }, 194 | "execution_count": 29, 195 | "metadata": {}, 196 | "output_type": "execute_result" 197 | } 198 | ], 199 | "source": [ 200 | "# matrix-matrix multiplication\n", 201 | "np.dot(A,B)" 202 | ] 203 | }, 204 | { 205 | "cell_type": "code", 206 | "execution_count": 30, 207 | "metadata": {}, 208 | "outputs": [ 209 | { 210 | "ename": "ValueError", 211 | "evalue": "shapes (2,4) and (3,2) not aligned: 4 (dim 1) != 3 (dim 0)", 212 | "output_type": "error", 213 | "traceback": [ 214 | "\u001b[0;31m---------------------------------------------------------------\u001b[0m", 215 | "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", 216 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# matrix-matrix multiplication\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;31m# size should match!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mB\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 217 | "\u001b[0;31mValueError\u001b[0m: shapes (2,4) and (3,2) not aligned: 4 (dim 1) != 3 (dim 0)" 218 | ] 219 | } 220 | ], 221 | "source": [ 222 | "# matrix-matrix multiplication \n", 223 | "# size should match!\n", 224 | "np.dot(B,A)" 225 | ] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": 31, 230 | "metadata": { 231 | "collapsed": true 232 | }, 233 | "outputs": [], 234 | "source": [ 235 | "# coefficient matrix A and a vector b\n", 236 | "A=np.array([[60, 5.5, 1],[65, 5.0, 0],[55, 6.0, 1]])\n", 237 | "b=np.array([66, 70, 78])" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": 33, 243 | "metadata": {}, 244 | "outputs": [ 245 | { 246 | "data": { 247 | "text/plain": [ 248 | "array([[ 1., 0., 0.],\n", 249 | " [ 0., 1., 0.],\n", 250 | " [ 0., 0., 1.]])" 251 | ] 252 | }, 253 | "execution_count": 33, 254 | "metadata": {}, 255 | "output_type": "execute_result" 256 | } 257 | ], 258 | "source": [ 259 | "# identity matrix \n", 260 | "eye3 = np.eye(3)\n", 261 | "eye3" 262 | ] 263 | }, 264 | { 265 | "cell_type": "code", 266 | "execution_count": 35, 267 | "metadata": {}, 268 | "outputs": [ 269 | { 270 | "data": { 271 | "text/plain": [ 272 | "array([[ 0.08695652, 0.00869565, -0.08695652],\n", 273 | " [-1.13043478, 0.08695652, 1.13043478],\n", 274 | " [ 2. , -1. , -1. ]])" 275 | ] 276 | }, 277 | "execution_count": 35, 278 | "metadata": {}, 279 | "output_type": "execute_result" 280 | } 281 | ], 282 | "source": [ 283 | "# computing an inverse\n", 284 | "from numpy.linalg import inv\n", 285 | "A_inv = inv(A)\n", 286 | "A_inv" 287 | ] 288 | }, 289 | { 290 | "cell_type": "code", 291 | "execution_count": 36, 292 | "metadata": {}, 293 | "outputs": [ 294 | { 295 | "data": { 296 | "text/plain": [ 297 | "array([[ 5.21739130e+00, 4.78260870e-02, -8.69565217e-02],\n", 298 | " [ -7.34782609e+01, 4.34782609e-01, 0.00000000e+00],\n", 299 | " [ 1.10000000e+02, -6.00000000e+00, -1.00000000e+00]])" 300 | ] 301 | }, 302 | "execution_count": 36, 303 | "metadata": {}, 304 | "output_type": "execute_result" 305 | } 306 | ], 307 | "source": [ 308 | "# wrong matrix multiplication\n", 309 | "A*A_inv" 310 | ] 311 | }, 312 | { 313 | "cell_type": "code", 314 | "execution_count": 38, 315 | "metadata": {}, 316 | "outputs": [ 317 | { 318 | "data": { 319 | "text/plain": [ 320 | "array([[ 1., 0., 0.],\n", 321 | " [ 0., 1., 0.],\n", 322 | " [ 0., 0., 1.]])" 323 | ] 324 | }, 325 | "execution_count": 38, 326 | "metadata": {}, 327 | "output_type": "execute_result" 328 | } 329 | ], 330 | "source": [ 331 | "# correct matrix multiplication\n", 332 | "A.dot(A_inv)" 333 | ] 334 | }, 335 | { 336 | "cell_type": "code", 337 | "execution_count": 40, 338 | "metadata": {}, 339 | "outputs": [ 340 | { 341 | "data": { 342 | "text/plain": [ 343 | "array([ -0.43478261, 19.65217391, -16. ])" 344 | ] 345 | }, 346 | "execution_count": 40, 347 | "metadata": {}, 348 | "output_type": "execute_result" 349 | } 350 | ], 351 | "source": [ 352 | "# solution of a linear system\n", 353 | "x=A_inv.dot(b)\n", 354 | "x" 355 | ] 356 | }, 357 | { 358 | "cell_type": "code", 359 | "execution_count": 41, 360 | "metadata": {}, 361 | "outputs": [ 362 | { 363 | "data": { 364 | "text/plain": [ 365 | "array([ -0.43478261, 19.65217391, -16. ])" 366 | ] 367 | }, 368 | "execution_count": 41, 369 | "metadata": {}, 370 | "output_type": "execute_result" 371 | } 372 | ], 373 | "source": [ 374 | "# a better way to solve the same linear system\n", 375 | "from numpy.linalg import solve\n", 376 | "x = solve(A,b)\n", 377 | "x" 378 | ] 379 | }, 380 | { 381 | "cell_type": "code", 382 | "execution_count": null, 383 | "metadata": { 384 | "collapsed": true 385 | }, 386 | "outputs": [], 387 | "source": [] 388 | } 389 | ], 390 | "metadata": { 391 | "anaconda-cloud": {}, 392 | "kernelspec": { 393 | "display_name": "Python 3", 394 | "language": "python", 395 | "name": "python3" 396 | }, 397 | "language_info": { 398 | "codemirror_mode": { 399 | "name": "ipython", 400 | "version": 3 401 | }, 402 | "file_extension": ".py", 403 | "mimetype": "text/x-python", 404 | "name": "python", 405 | "nbconvert_exporter": "python", 406 | "pygments_lexer": "ipython3", 407 | "version": "3.6.1" 408 | } 409 | }, 410 | "nbformat": 4, 411 | "nbformat_minor": 1 412 | } 413 | -------------------------------------------------------------------------------- /Week 1- Vector/norm_linear algebra with python3.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Vector norm" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [ 15 | { 16 | "name": "stdout", 17 | "output_type": "stream", 18 | "text": [ 19 | "[[1 1 0]]\n" 20 | ] 21 | } 22 | ], 23 | "source": [ 24 | "from numpy import array\n", 25 | "from numpy.linalg import norm\n", 26 | "a = array([[1,1,0]])\n", 27 | "print(a)" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": 2, 33 | "metadata": {}, 34 | "outputs": [ 35 | { 36 | "name": "stdout", 37 | "output_type": "stream", 38 | "text": [ 39 | "1.0\n" 40 | ] 41 | } 42 | ], 43 | "source": [ 44 | "l1 = norm(a,1)\n", 45 | "print(l1)" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": 5, 51 | "metadata": {}, 52 | "outputs": [ 53 | { 54 | "name": "stdout", 55 | "output_type": "stream", 56 | "text": [ 57 | "1.41421356237\n" 58 | ] 59 | } 60 | ], 61 | "source": [ 62 | "l2 = norm(a)\n", 63 | "print(l2)" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 13, 69 | "metadata": {}, 70 | "outputs": [ 71 | { 72 | "name": "stdout", 73 | "output_type": "stream", 74 | "text": [ 75 | "2.0\n" 76 | ] 77 | } 78 | ], 79 | "source": [ 80 | "from numpy import inf\n", 81 | "linf = norm(a, inf)\n", 82 | "print(linf)" 83 | ] 84 | }, 85 | { 86 | "cell_type": "markdown", 87 | "metadata": {}, 88 | "source": [ 89 | "## Matrix norm" 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": 14, 95 | "metadata": {}, 96 | "outputs": [ 97 | { 98 | "name": "stdout", 99 | "output_type": "stream", 100 | "text": [ 101 | "[[ 1 4]\n", 102 | " [ 2 5]\n", 103 | " [-1 3]]\n" 104 | ] 105 | } 106 | ], 107 | "source": [ 108 | "A = array([[1,4],[2,5],[-1,3]])\n", 109 | "print(A)" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": 15, 115 | "metadata": {}, 116 | "outputs": [ 117 | { 118 | "name": "stdout", 119 | "output_type": "stream", 120 | "text": [ 121 | "7.0\n" 122 | ] 123 | } 124 | ], 125 | "source": [ 126 | "from numpy import inf\n", 127 | "Minf = norm(A, inf)\n", 128 | "print(Minf)" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": 22, 134 | "metadata": {}, 135 | "outputs": [ 136 | { 137 | "name": "stdout", 138 | "output_type": "stream", 139 | "text": [ 140 | "[[3 9]]\n" 141 | ] 142 | } 143 | ], 144 | "source": [ 145 | "C=a @ A\n", 146 | "print(C)" 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": 24, 152 | "metadata": {}, 153 | "outputs": [ 154 | { 155 | "name": "stdout", 156 | "output_type": "stream", 157 | "text": [ 158 | "9.0\n" 159 | ] 160 | } 161 | ], 162 | "source": [ 163 | "c1 =norm (C,1)\n", 164 | "print(c1)" 165 | ] 166 | }, 167 | { 168 | "cell_type": "code", 169 | "execution_count": 26, 170 | "metadata": {}, 171 | "outputs": [ 172 | { 173 | "data": { 174 | "text/plain": [ 175 | "7.4833147735478827" 176 | ] 177 | }, 178 | "execution_count": 26, 179 | "metadata": {}, 180 | "output_type": "execute_result" 181 | } 182 | ], 183 | "source": [ 184 | "norm(A)" 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": 28, 190 | "metadata": {}, 191 | "outputs": [ 192 | { 193 | "name": "stdout", 194 | "output_type": "stream", 195 | "text": [ 196 | "[[17 22 11]\n", 197 | " [22 29 13]\n", 198 | " [11 13 10]]\n" 199 | ] 200 | } 201 | ], 202 | "source": [ 203 | "A1 = A@A.T\n", 204 | "print(A1)" 205 | ] 206 | }, 207 | { 208 | "cell_type": "code", 209 | "execution_count": 32, 210 | "metadata": {}, 211 | "outputs": [ 212 | { 213 | "name": "stdout", 214 | "output_type": "stream", 215 | "text": [ 216 | "[[ -2.16566539e+15 1.37815071e+15 5.90636017e+14]\n", 217 | " [ 1.37815071e+15 -8.77004995e+14 -3.75859283e+14]\n", 218 | " [ 5.90636017e+14 -3.75859283e+14 -1.61082550e+14]]\n" 219 | ] 220 | }, 221 | { 222 | "data": { 223 | "text/plain": [ 224 | "4134452116930292.0" 225 | ] 226 | }, 227 | "execution_count": 32, 228 | "metadata": {}, 229 | "output_type": "execute_result" 230 | } 231 | ], 232 | "source": [ 233 | "from numpy.linalg import inv\n", 234 | "from numpy import inf\n", 235 | "A2 = inv(A1)\n", 236 | "print(A2)\n", 237 | "norm(A2, inf)" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": null, 243 | "metadata": { 244 | "collapsed": true 245 | }, 246 | "outputs": [], 247 | "source": [] 248 | } 249 | ], 250 | "metadata": { 251 | "kernelspec": { 252 | "display_name": "Python 3", 253 | "language": "python", 254 | "name": "python3" 255 | }, 256 | "language_info": { 257 | "codemirror_mode": { 258 | "name": "ipython", 259 | "version": 3 260 | }, 261 | "file_extension": ".py", 262 | "mimetype": "text/x-python", 263 | "name": "python", 264 | "nbconvert_exporter": "python", 265 | "pygments_lexer": "ipython3", 266 | "version": "3.6.3" 267 | } 268 | }, 269 | "nbformat": 4, 270 | "nbformat_minor": 2 271 | } 272 | -------------------------------------------------------------------------------- /Week 1- Vector/vector_linear algebra with python3.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Vector Addtion" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "1. Solve for x\n", 15 | "$$u=\\begin{pmatrix}\n", 16 | "2\\\\\n", 17 | "-1\\\\\n", 18 | "5\\\\\n", 19 | "0\\end{pmatrix} , v=\\begin{pmatrix}\n", 20 | "4\\\\\n", 21 | "-3\\\\\n", 22 | "1\\\\\n", 23 | "-1\n", 24 | "\\end{pmatrix}, \\ \\ \n", 25 | "w=\\begin{pmatrix}\n", 26 | "-6\\\\2\\\\0\\\\3\\end{pmatrix}$$\n", 27 | "\n", 28 | "(1) x=2u-(v+3w)" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 56, 34 | "metadata": {}, 35 | "outputs": [ 36 | { 37 | "name": "stdout", 38 | "output_type": "stream", 39 | "text": [ 40 | "[18 -5 9 -8]\n" 41 | ] 42 | } 43 | ], 44 | "source": [ 45 | "from numpy import array\n", 46 | "u = array([2,-1,5,0])\n", 47 | "v = array([4,-3,1,-1])\n", 48 | "w=array([-6,2,0,3])\n", 49 | "#3w\n", 50 | "c = 3\n", 51 | "a = c*w\n", 52 | "#2u\n", 53 | "d=2\n", 54 | "e = d*u\n", 55 | "x=d*u - (v+a)\n", 56 | "print(x) #[18 -5 9 -8]" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "(2) 3(x+w)=2u-v+x\n", 64 | " x=u-(1/2)v-(3/2)w" 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": 74, 70 | "metadata": {}, 71 | "outputs": [ 72 | { 73 | "name": "stdout", 74 | "output_type": "stream", 75 | "text": [ 76 | "[ 9. -2.5 4.5 -4. ]\n" 77 | ] 78 | } 79 | ], 80 | "source": [ 81 | "from numpy import array\n", 82 | "u = array([2,-1,5,0])\n", 83 | "v = array([4,-3,1,-1])\n", 84 | "w=array([-6,2,0,3])\n", 85 | "i= 1/2\n", 86 | "j=3/2\n", 87 | "x = u - i*v - j*w\n", 88 | "print(x) # [9. -2.5 4.5 -4. ]" 89 | ] 90 | }, 91 | { 92 | "cell_type": "markdown", 93 | "metadata": {}, 94 | "source": [ 95 | "## Operation (dot, tensor)" 96 | ] 97 | }, 98 | { 99 | "cell_type": "markdown", 100 | "metadata": {}, 101 | "source": [ 102 | "(3) x=u dot v" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": 75, 108 | "metadata": {}, 109 | "outputs": [ 110 | { 111 | "name": "stdout", 112 | "output_type": "stream", 113 | "text": [ 114 | "16\n" 115 | ] 116 | } 117 | ], 118 | "source": [ 119 | "x=u.dot(v)\n", 120 | "print(x) #16" 121 | ] 122 | }, 123 | { 124 | "cell_type": "markdown", 125 | "metadata": {}, 126 | "source": [ 127 | "2. Solve the A tensor B" 128 | ] 129 | }, 130 | { 131 | "cell_type": "code", 132 | "execution_count": 86, 133 | "metadata": {}, 134 | "outputs": [ 135 | { 136 | "name": "stdout", 137 | "output_type": "stream", 138 | "text": [ 139 | "[[[[ 2 10]\n", 140 | " [ 4 8]]]\n", 141 | "\n", 142 | "\n", 143 | " [[[ 3 15]\n", 144 | " [ 6 12]]]]\n" 145 | ] 146 | } 147 | ], 148 | "source": [ 149 | "from numpy import array\n", 150 | "from numpy import tensordot\n", 151 | "A = array([[2],[3]])\n", 152 | "B = array([[1,5],[2,4]])\n", 153 | "C=tensordot(A, B, axes=0)\n", 154 | "print(C) \n", 155 | "#[[[[ 2 10]\n", 156 | "# [ 4 8]]]\n", 157 | "\n", 158 | "\n", 159 | "# [[[ 3 15]\n", 160 | "# [ 6 12]]]]" 161 | ] 162 | }, 163 | { 164 | "cell_type": "markdown", 165 | "metadata": {}, 166 | "source": [ 167 | "3. Write x as a linear combination of u and w. if possible." 168 | ] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "metadata": {}, 173 | "source": [ 174 | "X=[0,3]^t\n", 175 | "u=[1.2]^T\n", 176 | "w=[1,-1]^T" 177 | ] 178 | }, 179 | { 180 | "cell_type": "code", 181 | "execution_count": 106, 182 | "metadata": {}, 183 | "outputs": [], 184 | "source": [ 185 | "x=array([[0,3]])\n", 186 | "X=x.T\n", 187 | "u=array([[1,2]])\n", 188 | "U=u.T\n", 189 | "w=array([[1,-1]])\n", 190 | "W=w.T\n", 191 | "a=1\n", 192 | "b=-1\n", 193 | "Y=a*u+b*w" 194 | ] 195 | }, 196 | { 197 | "cell_type": "markdown", 198 | "metadata": {}, 199 | "source": [ 200 | "5. Show that the vectors u,v are orthogonal" 201 | ] 202 | }, 203 | { 204 | "cell_type": "code", 205 | "execution_count": 119, 206 | "metadata": {}, 207 | "outputs": [ 208 | { 209 | "data": { 210 | "text/plain": [ 211 | "array([[0]])" 212 | ] 213 | }, 214 | "execution_count": 119, 215 | "metadata": {}, 216 | "output_type": "execute_result" 217 | } 218 | ], 219 | "source": [ 220 | "u=array([[3,2,-1,4]])\n", 221 | "v=array([[1,-1,1,0]])\n", 222 | "u.dot(v.T) #array([[0]])" 223 | ] 224 | } 225 | ], 226 | "metadata": { 227 | "kernelspec": { 228 | "display_name": "Python 3", 229 | "language": "python", 230 | "name": "python3" 231 | }, 232 | "language_info": { 233 | "codemirror_mode": { 234 | "name": "ipython", 235 | "version": 3 236 | }, 237 | "file_extension": ".py", 238 | "mimetype": "text/x-python", 239 | "name": "python", 240 | "nbconvert_exporter": "python", 241 | "pygments_lexer": "ipython3", 242 | "version": "3.6.4" 243 | } 244 | }, 245 | "nbformat": 4, 246 | "nbformat_minor": 2 247 | } 248 | -------------------------------------------------------------------------------- /Week 12- Linear Algebra in ML/2_Least+square+problem.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 2, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stdout", 10 | "output_type": "stream", 11 | "text": [ 12 | "[[ 0.05 0.12]\n", 13 | " [ 0.18 0.22]\n", 14 | " [ 0.31 0.35]\n", 15 | " [ 0.42 0.38]\n", 16 | " [ 0.5 0.49]]\n" 17 | ] 18 | }, 19 | { 20 | "data": { 21 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAD8CAYAAABw1c+bAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nahmDX5JaxuCXpJYx+CWpZQx+SWqZ/w/FrZFURaT6HQAAAABJRU5ErkJggg==\n", 22 | "text/plain": [ 23 | "" 24 | ] 25 | }, 26 | "metadata": {}, 27 | "output_type": "display_data" 28 | } 29 | ], 30 | "source": [ 31 | "# linear regression dataset\n", 32 | "from numpy import array\n", 33 | "from matplotlib import pyplot\n", 34 | "# define dataset\n", 35 | "data = array([\n", 36 | "[0.05, 0.12],\n", 37 | "[0.18, 0.22],\n", 38 | "[0.31, 0.35],\n", 39 | "[0.42, 0.38],\n", 40 | "[0.5, 0.49]])\n", 41 | "print(data)\n", 42 | "# split into inputs and outputs\n", 43 | "X, y = data[:,0], data[:,1]\n", 44 | "X = X.reshape((len(X), 1))\n", 45 | "# scatter plot\n", 46 | "pyplot.scatter(X, y)\n", 47 | "pyplot.show()" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": 3, 53 | "metadata": {}, 54 | "outputs": [ 55 | { 56 | "name": "stdout", 57 | "output_type": "stream", 58 | "text": [ 59 | "[ 1.00233226]\n" 60 | ] 61 | }, 62 | { 63 | "data": { 64 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYkjhLiISQwp3EZEY+l+fOyeKbuoQTwAAAABJRU5ErkJggg==\n", 65 | "text/plain": [ 66 | "" 67 | ] 68 | }, 69 | "metadata": {}, 70 | "output_type": "display_data" 71 | } 72 | ], 73 | "source": [ 74 | "# direct solution to linear least squares\n", 75 | "from numpy import array\n", 76 | "from numpy.linalg import inv\n", 77 | "from matplotlib import pyplot\n", 78 | "# define dataset\n", 79 | "data = array([\n", 80 | "[0.05, 0.12],\n", 81 | "[0.18, 0.22],\n", 82 | "[0.31, 0.35],\n", 83 | "[0.42, 0.38],\n", 84 | "[0.5, 0.49]])\n", 85 | "# split into inputs and outputs\n", 86 | "X, y = data[:,0], data[:,1]\n", 87 | "X = X.reshape((len(X), 1))\n", 88 | "# linear least squares\n", 89 | "b = inv(X.T.dot(X)).dot(X.T).dot(y)\n", 90 | "print(b)\n", 91 | "# predict using coefficients\n", 92 | "yhat = X.dot(b)\n", 93 | "# plot data and predictions\n", 94 | "pyplot.scatter(X, y)\n", 95 | "pyplot.plot(X, yhat, color='red')\n", 96 | "pyplot.show()" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": 6, 102 | "metadata": {}, 103 | "outputs": [ 104 | { 105 | "name": "stdout", 106 | "output_type": "stream", 107 | "text": [ 108 | "[[1 2]\n", 109 | " [2 1]\n", 110 | " [3 3]]\n" 111 | ] 112 | }, 113 | { 114 | "data": { 115 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAD8CAYAAABw1c+bAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\npI4x+CWpYwx+SeoYg1+SOub/A4QCZ+4YjgiSAAAAAElFTkSuQmCC\n", 116 | "text/plain": [ 117 | "" 118 | ] 119 | }, 120 | "metadata": {}, 121 | "output_type": "display_data" 122 | } 123 | ], 124 | "source": [ 125 | "# linear regression dataset\n", 126 | "from numpy import array\n", 127 | "from matplotlib import pyplot\n", 128 | "# define dataset\n", 129 | "data = array([\n", 130 | "[1, 2],\n", 131 | "[2, 1],\n", 132 | "[3, 3]])\n", 133 | "print(data)\n", 134 | "# split into inputs and outputs\n", 135 | "X, y = data[:,0], data[:,1]\n", 136 | "X = X.reshape((len(X), 1))\n", 137 | "# scatter plot\n", 138 | "pyplot.scatter(X, y)\n", 139 | "pyplot.show()" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 8, 145 | "metadata": {}, 146 | "outputs": [ 147 | { 148 | "name": "stdout", 149 | "output_type": "stream", 150 | "text": [ 151 | "[ 0.92857143]\n" 152 | ] 153 | }, 154 | { 155 | "data": { 156 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngVTuIiIRSOUuIhKB/h8oQNApM4pKowAAAABJRU5ErkJggg==\n", 157 | "text/plain": [ 158 | "" 159 | ] 160 | }, 161 | "metadata": {}, 162 | "output_type": "display_data" 163 | } 164 | ], 165 | "source": [ 166 | "# direct solution to linear least squares\n", 167 | "from numpy import array\n", 168 | "from numpy.linalg import inv\n", 169 | "from matplotlib import pyplot\n", 170 | "# define dataset\n", 171 | "data = array([\n", 172 | "[1, 2],\n", 173 | "[2, 1],\n", 174 | "[3, 3]])\n", 175 | "# split into inputs and outputs\n", 176 | "A, y = data[:,0], data[:,1]\n", 177 | "A = A.reshape((len(A), 1))\n", 178 | "# linear least squares\n", 179 | "b = inv(A.T.dot(A)).dot(A.T).dot(y)\n", 180 | "print(b)\n", 181 | "# predict using coefficients\n", 182 | "yhat = A.dot(b)\n", 183 | "# plot data and predictions\n", 184 | "pyplot.scatter(A, y)\n", 185 | "pyplot.plot(X, yhat, color='green')\n", 186 | "pyplot.show()" 187 | ] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": null, 192 | "metadata": { 193 | "collapsed": true 194 | }, 195 | "outputs": [], 196 | "source": [] 197 | } 198 | ], 199 | "metadata": { 200 | "kernelspec": { 201 | "display_name": "Python 3", 202 | "language": "python", 203 | "name": "python3" 204 | }, 205 | "language_info": { 206 | "codemirror_mode": { 207 | "name": "ipython", 208 | "version": 3 209 | }, 210 | "file_extension": ".py", 211 | "mimetype": "text/x-python", 212 | "name": "python", 213 | "nbconvert_exporter": "python", 214 | "pygments_lexer": "ipython3", 215 | "version": "3.6.3" 216 | } 217 | }, 218 | "nbformat": 4, 219 | "nbformat_minor": 2 220 | } 221 | -------------------------------------------------------------------------------- /Week 12- Linear Algebra in ML/3_decompostion .ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## LU decompostion" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": { 14 | "collapsed": true 15 | }, 16 | "outputs": [], 17 | "source": [ 18 | "from numpy import array\n", 19 | "from scipy.linalg import lu" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 3, 25 | "metadata": {}, 26 | "outputs": [ 27 | { 28 | "name": "stdout", 29 | "output_type": "stream", 30 | "text": [ 31 | "[[3 0]\n", 32 | " [4 5]]\n" 33 | ] 34 | } 35 | ], 36 | "source": [ 37 | "A = array([[3,0],[4,5]])\n", 38 | "print(A)" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": 4, 44 | "metadata": { 45 | "collapsed": true 46 | }, 47 | "outputs": [], 48 | "source": [ 49 | "P, L, U = lu(A)" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 7, 55 | "metadata": {}, 56 | "outputs": [ 57 | { 58 | "name": "stdout", 59 | "output_type": "stream", 60 | "text": [ 61 | "[[ 0. 1.]\n", 62 | " [ 1. 0.]]\n" 63 | ] 64 | } 65 | ], 66 | "source": [ 67 | "print(P)" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": 5, 73 | "metadata": {}, 74 | "outputs": [ 75 | { 76 | "name": "stdout", 77 | "output_type": "stream", 78 | "text": [ 79 | "[[ 1. 0. ]\n", 80 | " [ 0.75 1. ]]\n" 81 | ] 82 | } 83 | ], 84 | "source": [ 85 | "print(L)" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": 6, 91 | "metadata": {}, 92 | "outputs": [ 93 | { 94 | "name": "stdout", 95 | "output_type": "stream", 96 | "text": [ 97 | "[[ 4. 5. ]\n", 98 | " [ 0. -3.75]]\n" 99 | ] 100 | } 101 | ], 102 | "source": [ 103 | "print(U)" 104 | ] 105 | }, 106 | { 107 | "cell_type": "code", 108 | "execution_count": 11, 109 | "metadata": {}, 110 | "outputs": [ 111 | { 112 | "name": "stdout", 113 | "output_type": "stream", 114 | "text": [ 115 | "[[ 3. 0.]\n", 116 | " [ 4. 5.]]\n" 117 | ] 118 | } 119 | ], 120 | "source": [ 121 | "B=P.dot(L).dot(U)\n", 122 | "print(B)" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": 13, 128 | "metadata": {}, 129 | "outputs": [ 130 | { 131 | "name": "stdout", 132 | "output_type": "stream", 133 | "text": [ 134 | "[[ 4. 5.]\n", 135 | " [ 3. 0.]]\n" 136 | ] 137 | } 138 | ], 139 | "source": [ 140 | "C=L.dot(U)\n", 141 | "print(C)" 142 | ] 143 | }, 144 | { 145 | "cell_type": "markdown", 146 | "metadata": {}, 147 | "source": [ 148 | "## QR decomposition" 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": 14, 154 | "metadata": { 155 | "collapsed": true 156 | }, 157 | "outputs": [], 158 | "source": [ 159 | "from numpy import array\n", 160 | "from numpy.linalg import qr" 161 | ] 162 | }, 163 | { 164 | "cell_type": "code", 165 | "execution_count": 16, 166 | "metadata": {}, 167 | "outputs": [ 168 | { 169 | "name": "stdout", 170 | "output_type": "stream", 171 | "text": [ 172 | "[[3 0]\n", 173 | " [4 5]]\n" 174 | ] 175 | } 176 | ], 177 | "source": [ 178 | "A = array([[3,0],[4,5]])\n", 179 | "print(A)" 180 | ] 181 | }, 182 | { 183 | "cell_type": "code", 184 | "execution_count": 18, 185 | "metadata": {}, 186 | "outputs": [ 187 | { 188 | "name": "stdout", 189 | "output_type": "stream", 190 | "text": [ 191 | "[[-0.6 -0.8]\n", 192 | " [-0.8 0.6]]\n" 193 | ] 194 | } 195 | ], 196 | "source": [ 197 | "Q, R =qr(A, 'complete')\n", 198 | "print(Q)" 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": 19, 204 | "metadata": {}, 205 | "outputs": [ 206 | { 207 | "name": "stdout", 208 | "output_type": "stream", 209 | "text": [ 210 | "[[-5. -4.]\n", 211 | " [ 0. 3.]]\n" 212 | ] 213 | } 214 | ], 215 | "source": [ 216 | "print(R)" 217 | ] 218 | }, 219 | { 220 | "cell_type": "code", 221 | "execution_count": 20, 222 | "metadata": {}, 223 | "outputs": [ 224 | { 225 | "name": "stdout", 226 | "output_type": "stream", 227 | "text": [ 228 | "[[ 3. 0.]\n", 229 | " [ 4. 5.]]\n" 230 | ] 231 | } 232 | ], 233 | "source": [ 234 | "B=Q.dot(R)\n", 235 | "print(B)" 236 | ] 237 | }, 238 | { 239 | "cell_type": "markdown", 240 | "metadata": {}, 241 | "source": [ 242 | "## reconstruct matrix" 243 | ] 244 | }, 245 | { 246 | "cell_type": "code", 247 | "execution_count": 4, 248 | "metadata": {}, 249 | "outputs": [ 250 | { 251 | "name": "stdout", 252 | "output_type": "stream", 253 | "text": [ 254 | "[[1 2 3]\n", 255 | " [4 5 6]\n", 256 | " [7 8 9]]\n", 257 | "[[ 1. 2. 3.]\n", 258 | " [ 4. 5. 6.]\n", 259 | " [ 7. 8. 9.]]\n" 260 | ] 261 | } 262 | ], 263 | "source": [ 264 | "from numpy import diag\n", 265 | "from numpy.linalg import inv\n", 266 | "from numpy import array\n", 267 | "from numpy.linalg import eig\n", 268 | "# define matrix\n", 269 | "A = array([\n", 270 | "\t[1, 2, 3],\n", 271 | "\t[4, 5, 6],\n", 272 | "\t[7, 8, 9]])\n", 273 | "print(A)\n", 274 | "# factorize\n", 275 | "values, vectors = eig(A)\n", 276 | "# create matrix from eigenvectors\n", 277 | "Q = vectors\n", 278 | "# create inverse of eigenvectors matrix\n", 279 | "R = inv(Q)\n", 280 | "# create diagonal matrix from eigenvalues\n", 281 | "L = diag(values)\n", 282 | "# reconstruct the original matrix\n", 283 | "B = Q.dot(L).dot(R)\n", 284 | "print(B)" 285 | ] 286 | }, 287 | { 288 | "cell_type": "markdown", 289 | "metadata": {}, 290 | "source": [ 291 | "## Eigenvector" 292 | ] 293 | }, 294 | { 295 | "cell_type": "code", 296 | "execution_count": 5, 297 | "metadata": {}, 298 | "outputs": [ 299 | { 300 | "name": "stdout", 301 | "output_type": "stream", 302 | "text": [ 303 | "[ -3.73863537 -8.46653421 -13.19443305]\n", 304 | "[ -3.73863537 -8.46653421 -13.19443305]\n" 305 | ] 306 | } 307 | ], 308 | "source": [ 309 | "# confirm eigenvector\n", 310 | "from numpy import array\n", 311 | "from numpy.linalg import eig\n", 312 | "# define matrix\n", 313 | "A = array([\n", 314 | "\t[1, 2, 3],\n", 315 | "\t[4, 5, 6],\n", 316 | "\t[7, 8, 9]])\n", 317 | "# factorize\n", 318 | "values, vectors = eig(A)\n", 319 | "# confirm first eigenvector\n", 320 | "B = A.dot(vectors[:, 0])\n", 321 | "print(B)\n", 322 | "C = vectors[:, 0] * values[0]\n", 323 | "print(C)" 324 | ] 325 | }, 326 | { 327 | "cell_type": "markdown", 328 | "metadata": {}, 329 | "source": [ 330 | "## Eigendecomposition" 331 | ] 332 | }, 333 | { 334 | "cell_type": "code", 335 | "execution_count": 7, 336 | "metadata": { 337 | "collapsed": true 338 | }, 339 | "outputs": [], 340 | "source": [ 341 | "from numpy import array\n", 342 | "from numpy.linalg import eig" 343 | ] 344 | }, 345 | { 346 | "cell_type": "code", 347 | "execution_count": 8, 348 | "metadata": { 349 | "collapsed": true 350 | }, 351 | "outputs": [], 352 | "source": [ 353 | "B = ([[2,1],[0,3]])\n", 354 | "C = ([[5,3], [3,2]])" 355 | ] 356 | }, 357 | { 358 | "cell_type": "code", 359 | "execution_count": 9, 360 | "metadata": {}, 361 | "outputs": [ 362 | { 363 | "name": "stdout", 364 | "output_type": "stream", 365 | "text": [ 366 | "[ 2. 3.]\n" 367 | ] 368 | } 369 | ], 370 | "source": [ 371 | "values, vectors = eig(B)\n", 372 | "print(values)" 373 | ] 374 | }, 375 | { 376 | "cell_type": "code", 377 | "execution_count": 11, 378 | "metadata": {}, 379 | "outputs": [ 380 | { 381 | "name": "stdout", 382 | "output_type": "stream", 383 | "text": [ 384 | "[[3 0]\n", 385 | " [4 5]]\n" 386 | ] 387 | } 388 | ], 389 | "source": [ 390 | "A = array([[3,0],[4,5]])\n", 391 | "print(A)" 392 | ] 393 | }, 394 | { 395 | "cell_type": "code", 396 | "execution_count": 12, 397 | "metadata": {}, 398 | "outputs": [ 399 | { 400 | "name": "stdout", 401 | "output_type": "stream", 402 | "text": [ 403 | "[[-1 -2]\n", 404 | " [ 6 6]]\n" 405 | ] 406 | } 407 | ], 408 | "source": [ 409 | "B1 = array([[-1,-2],[6,6]])\n", 410 | "print(B1)" 411 | ] 412 | }, 413 | { 414 | "cell_type": "code", 415 | "execution_count": 16, 416 | "metadata": {}, 417 | "outputs": [ 418 | { 419 | "name": "stdout", 420 | "output_type": "stream", 421 | "text": [ 422 | "[[-0.5547002 0.4472136 ]\n", 423 | " [ 0.83205029 -0.89442719]]\n" 424 | ] 425 | } 426 | ], 427 | "source": [ 428 | "value, vectors =eig(B1)\n", 429 | "print(vectors)" 430 | ] 431 | }, 432 | { 433 | "cell_type": "code", 434 | "execution_count": 14, 435 | "metadata": {}, 436 | "outputs": [ 437 | { 438 | "name": "stdout", 439 | "output_type": "stream", 440 | "text": [ 441 | "[[2 3 1]\n", 442 | " [4 1 4]\n", 443 | " [3 4 6]]\n" 444 | ] 445 | } 446 | ], 447 | "source": [ 448 | "from numpy import array\n", 449 | "from scipy.linalg import lu\n", 450 | "F = array ([[2,3,1],[4,1,4],[3,4,6]])\n", 451 | "print(F)" 452 | ] 453 | }, 454 | { 455 | "cell_type": "code", 456 | "execution_count": 43, 457 | "metadata": {}, 458 | "outputs": [ 459 | { 460 | "name": "stdout", 461 | "output_type": "stream", 462 | "text": [ 463 | "[[ 0. 0. 1.]\n", 464 | " [ 1. 0. 0.]\n", 465 | " [ 0. 1. 0.]]\n" 466 | ] 467 | } 468 | ], 469 | "source": [ 470 | "P, L, U = lu(F)\n", 471 | "print(P)" 472 | ] 473 | }, 474 | { 475 | "cell_type": "code", 476 | "execution_count": 44, 477 | "metadata": {}, 478 | "outputs": [ 479 | { 480 | "name": "stdout", 481 | "output_type": "stream", 482 | "text": [ 483 | "[[ 1. 0. 0. ]\n", 484 | " [ 0.75 1. 0. ]\n", 485 | " [ 0.5 0.76923077 1. ]]\n" 486 | ] 487 | } 488 | ], 489 | "source": [ 490 | "print(L)" 491 | ] 492 | }, 493 | { 494 | "cell_type": "code", 495 | "execution_count": 45, 496 | "metadata": {}, 497 | "outputs": [ 498 | { 499 | "name": "stdout", 500 | "output_type": "stream", 501 | "text": [ 502 | "[[ 4. 1. 4. ]\n", 503 | " [ 0. 3.25 3. ]\n", 504 | " [ 0. 0. -3.30769231]]\n" 505 | ] 506 | } 507 | ], 508 | "source": [ 509 | "print(U)" 510 | ] 511 | }, 512 | { 513 | "cell_type": "code", 514 | "execution_count": 47, 515 | "metadata": {}, 516 | "outputs": [ 517 | { 518 | "name": "stdout", 519 | "output_type": "stream", 520 | "text": [ 521 | "[[ 4. 1. 4.]\n", 522 | " [ 3. 4. 6.]\n", 523 | " [ 2. 3. 1.]]\n" 524 | ] 525 | } 526 | ], 527 | "source": [ 528 | "F1=L.dot(U)\n", 529 | "print(F1)" 530 | ] 531 | }, 532 | { 533 | "cell_type": "code", 534 | "execution_count": 48, 535 | "metadata": {}, 536 | "outputs": [ 537 | { 538 | "name": "stdout", 539 | "output_type": "stream", 540 | "text": [ 541 | "[[ 2. 3. 1.]\n", 542 | " [ 4. 1. 4.]\n", 543 | " [ 3. 4. 6.]]\n" 544 | ] 545 | } 546 | ], 547 | "source": [ 548 | "F2=P.dot(F1)\n", 549 | "print(F2)" 550 | ] 551 | }, 552 | { 553 | "cell_type": "markdown", 554 | "metadata": {}, 555 | "source": [ 556 | "## SVD decomposition" 557 | ] 558 | }, 559 | { 560 | "cell_type": "code", 561 | "execution_count": 17, 562 | "metadata": { 563 | "collapsed": true 564 | }, 565 | "outputs": [], 566 | "source": [ 567 | "from numpy import array\n", 568 | "from numpy import diag\n", 569 | "from numpy import zeros\n", 570 | "from scipy.linalg import svd" 571 | ] 572 | }, 573 | { 574 | "cell_type": "code", 575 | "execution_count": 18, 576 | "metadata": {}, 577 | "outputs": [ 578 | { 579 | "name": "stdout", 580 | "output_type": "stream", 581 | "text": [ 582 | "[[3 0]\n", 583 | " [4 5]]\n" 584 | ] 585 | } 586 | ], 587 | "source": [ 588 | "A = array([[3,0],[4,5]])\n", 589 | "print(A)" 590 | ] 591 | }, 592 | { 593 | "cell_type": "code", 594 | "execution_count": 19, 595 | "metadata": {}, 596 | "outputs": [ 597 | { 598 | "name": "stdout", 599 | "output_type": "stream", 600 | "text": [ 601 | "[[ 6.70820393 0. ]\n", 602 | " [ 0. 2.23606798]]\n" 603 | ] 604 | } 605 | ], 606 | "source": [ 607 | "U, s, V =svd(A)\n", 608 | "Sigma = diag(s)\n", 609 | "print(Sigma)" 610 | ] 611 | }, 612 | { 613 | "cell_type": "code", 614 | "execution_count": 66, 615 | "metadata": {}, 616 | "outputs": [ 617 | { 618 | "name": "stdout", 619 | "output_type": "stream", 620 | "text": [ 621 | "[[ 3.00000000e+00 8.88178420e-16]\n", 622 | " [ 4.00000000e+00 5.00000000e+00]]\n" 623 | ] 624 | } 625 | ], 626 | "source": [ 627 | "B = U.dot(Sigma.dot(V))\n", 628 | "print(B)" 629 | ] 630 | }, 631 | { 632 | "cell_type": "code", 633 | "execution_count": 52, 634 | "metadata": {}, 635 | "outputs": [ 636 | { 637 | "name": "stdout", 638 | "output_type": "stream", 639 | "text": [ 640 | "[[-0.31622777 -0.9486833 ]\n", 641 | " [-0.9486833 0.31622777]]\n" 642 | ] 643 | } 644 | ], 645 | "source": [ 646 | "print(U)" 647 | ] 648 | }, 649 | { 650 | "cell_type": "code", 651 | "execution_count": 53, 652 | "metadata": {}, 653 | "outputs": [ 654 | { 655 | "name": "stdout", 656 | "output_type": "stream", 657 | "text": [ 658 | "[ 6.70820393 2.23606798]\n" 659 | ] 660 | } 661 | ], 662 | "source": [ 663 | "print(s)" 664 | ] 665 | }, 666 | { 667 | "cell_type": "code", 668 | "execution_count": 54, 669 | "metadata": {}, 670 | "outputs": [ 671 | { 672 | "name": "stdout", 673 | "output_type": "stream", 674 | "text": [ 675 | "[[-0.70710678 -0.70710678]\n", 676 | " [-0.70710678 0.70710678]]\n" 677 | ] 678 | } 679 | ], 680 | "source": [ 681 | "print(V)" 682 | ] 683 | }, 684 | { 685 | "cell_type": "code", 686 | "execution_count": 55, 687 | "metadata": {}, 688 | "outputs": [ 689 | { 690 | "name": "stdout", 691 | "output_type": "stream", 692 | "text": [ 693 | "[[ 0. 0.]\n", 694 | " [ 0. 0.]]\n" 695 | ] 696 | } 697 | ], 698 | "source": [ 699 | "print(Sigma)" 700 | ] 701 | }, 702 | { 703 | "cell_type": "code", 704 | "execution_count": 59, 705 | "metadata": {}, 706 | "outputs": [ 707 | { 708 | "name": "stdout", 709 | "output_type": "stream", 710 | "text": [ 711 | "[[ 6.70820393 0. ]\n", 712 | " [ 0. 2.23606798]]\n" 713 | ] 714 | } 715 | ], 716 | "source": [ 717 | "Sigma[:A.shape[1], :A.shape[1]] = diag(s)\n", 718 | "print(Sigma)" 719 | ] 720 | }, 721 | { 722 | "cell_type": "code", 723 | "execution_count": 61, 724 | "metadata": {}, 725 | "outputs": [ 726 | { 727 | "name": "stdout", 728 | "output_type": "stream", 729 | "text": [ 730 | "[[ 3.00000000e+00 8.88178420e-16]\n", 731 | " [ 4.00000000e+00 5.00000000e+00]]\n" 732 | ] 733 | } 734 | ], 735 | "source": [ 736 | "B = U. dot(Sigma.dot(V))\n", 737 | "print(B)" 738 | ] 739 | }, 740 | { 741 | "cell_type": "markdown", 742 | "metadata": {}, 743 | "source": [ 744 | "## ex.singular-value decomposition" 745 | ] 746 | }, 747 | { 748 | "cell_type": "code", 749 | "execution_count": 7, 750 | "metadata": {}, 751 | "outputs": [ 752 | { 753 | "name": "stdout", 754 | "output_type": "stream", 755 | "text": [ 756 | "[[1 2]\n", 757 | " [3 4]\n", 758 | " [5 6]]\n", 759 | "[[-0.2298477 0.88346102 0.40824829]\n", 760 | " [-0.52474482 0.24078249 -0.81649658]\n", 761 | " [-0.81964194 -0.40189603 0.40824829]]\n", 762 | "[ 9.52551809 0.51430058]\n", 763 | "[[-0.61962948 -0.78489445]\n", 764 | " [-0.78489445 0.61962948]]\n" 765 | ] 766 | } 767 | ], 768 | "source": [ 769 | "# singular-value decomposition\n", 770 | "from numpy import array\n", 771 | "from scipy.linalg import svd\n", 772 | "# define a matrix\n", 773 | "A = array([\n", 774 | "\t[1, 2],\n", 775 | "\t[3, 4],\n", 776 | "\t[5, 6]])\n", 777 | "print(A)\n", 778 | "# factorize\n", 779 | "U, s, V = svd(A)\n", 780 | "print(U)\n", 781 | "print(s)\n", 782 | "print(V)" 783 | ] 784 | }, 785 | { 786 | "cell_type": "markdown", 787 | "metadata": { 788 | "collapsed": true 789 | }, 790 | "source": [ 791 | "## Cholesky decomposition" 792 | ] 793 | }, 794 | { 795 | "cell_type": "code", 796 | "execution_count": 2, 797 | "metadata": {}, 798 | "outputs": [ 799 | { 800 | "name": "stdout", 801 | "output_type": "stream", 802 | "text": [ 803 | "[[2 1 1]\n", 804 | " [1 2 1]\n", 805 | " [1 1 2]]\n", 806 | "[[ 1.41421356 0. 0. ]\n", 807 | " [ 0.70710678 1.22474487 0. ]\n", 808 | " [ 0.70710678 0.40824829 1.15470054]]\n", 809 | "[[ 2. 1. 1.]\n", 810 | " [ 1. 2. 1.]\n", 811 | " [ 1. 1. 2.]]\n" 812 | ] 813 | } 814 | ], 815 | "source": [ 816 | "from numpy import array\n", 817 | "from numpy.linalg import cholesky\n", 818 | "# define symmetrical matrix\n", 819 | "A = array([\n", 820 | "\t[2, 1, 1],\n", 821 | "\t[1, 2, 1],\n", 822 | "\t[1, 1, 2]])\n", 823 | "print(A)\n", 824 | "# factorize\n", 825 | "L = cholesky(A)\n", 826 | "print(L)\n", 827 | "# reconstruct\n", 828 | "B = L.dot(L.T)\n", 829 | "print(B)" 830 | ] 831 | }, 832 | { 833 | "cell_type": "code", 834 | "execution_count": null, 835 | "metadata": { 836 | "collapsed": true 837 | }, 838 | "outputs": [], 839 | "source": [] 840 | } 841 | ], 842 | "metadata": { 843 | "kernelspec": { 844 | "display_name": "Python 3", 845 | "language": "python", 846 | "name": "python3" 847 | }, 848 | "language_info": { 849 | "codemirror_mode": { 850 | "name": "ipython", 851 | "version": 3 852 | }, 853 | "file_extension": ".py", 854 | "mimetype": "text/x-python", 855 | "name": "python", 856 | "nbconvert_exporter": "python", 857 | "pygments_lexer": "ipython3", 858 | "version": "3.6.3" 859 | } 860 | }, 861 | "nbformat": 4, 862 | "nbformat_minor": 2 863 | } 864 | -------------------------------------------------------------------------------- /Week 12- Linear Algebra in ML/FFN.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## 활성화함수 구현하기" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 16, 13 | "metadata": {}, 14 | "outputs": [ 15 | { 16 | "data": { 17 | "text/plain": [ 18 | "array([-1., 2., 2.])" 19 | ] 20 | }, 21 | "execution_count": 16, 22 | "metadata": {}, 23 | "output_type": "execute_result" 24 | } 25 | ], 26 | "source": [ 27 | "import numpy as np\n", 28 | "x=np.array([-1.0, 2.0, 2.0])\n", 29 | "x" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 17, 35 | "metadata": {}, 36 | "outputs": [ 37 | { 38 | "data": { 39 | "text/plain": [ 40 | "array([False, True, True], dtype=bool)" 41 | ] 42 | }, 43 | "execution_count": 17, 44 | "metadata": {}, 45 | "output_type": "execute_result" 46 | } 47 | ], 48 | "source": [ 49 | "y=x>0\n", 50 | "y" 51 | ] 52 | }, 53 | { 54 | "cell_type": "code", 55 | "execution_count": 18, 56 | "metadata": {}, 57 | "outputs": [ 58 | { 59 | "data": { 60 | "text/plain": [ 61 | "array([0, 1, 1])" 62 | ] 63 | }, 64 | "execution_count": 18, 65 | "metadata": {}, 66 | "output_type": "execute_result" 67 | } 68 | ], 69 | "source": [ 70 | "y= y.astype(np.int) #y의 원소를 bool에서 int형으로 변환\n", 71 | "y" 72 | ] 73 | }, 74 | { 75 | "cell_type": "markdown", 76 | "metadata": {}, 77 | "source": [ 78 | "그래프 그리기" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": 26, 84 | "metadata": {}, 85 | "outputs": [ 86 | { 87 | "data": { 88 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAEUpJREFUeJzt3X+MHOddx/HPx3sXmv5IE/BRUp+NLWQoJ9pAOdxIRUog\nUOwQsJD4Iw40amhlWYpRKhURQyX6R/9CERBVcXNYkRUKLRZSA3WrK24qAfmjBNkJ+VEnOBwuje0G\ncqFVi5oK38x8+WP3Ltvrzuzant3pM/d+SZFuZie731We/ejJd5951hEhAEC7bGq6AABA/Qh3AGgh\nwh0AWohwB4AWItwBoIUIdwBoIcIdAFqIcAeAFiLcAaCFppp64c2bN8f27dubenkASNITTzzxSkTM\nDLuusXDfvn27Tp061dTLA0CSbH91lOtoywBACxHuANBChDsAtBDhDgAtRLgDQAsR7gDQQoQ7ALQQ\n4Q4ALUS4A0ALEe4A0EKEOwC0EOEOAC1EuANACw0Nd9tHbb9s+8slj9v2x2wv2X7G9jvrLxMAcClG\nmbk/LGl3xeN7JO3s/bNf0oNXXhYA4EoM3c89Ih6zvb3ikr2SPhERIelx29favj4iXqqpRqBR37mY\n68kXv6EioulS0BKz171eOza/YayvUcePdWyRdK7v+Hzv3PeEu+396s7utW3bthpeGhi/P3/sP3T/\nF/+96TLQIgdu+jEd2vO2sb7GRH+JKSKOSDoiSfPz80yDkIRvfSfT1dMd/eX7dzVdClriLde8buyv\nUUe4X5C0te94tncOaIW8KPQD05s0v/0Hmy4FGFkdSyGPS7qzt2rmRknfpN+ONlkpQlOb3HQZwCUZ\nOnO3/deSbpa02fZ5SR+RNC1JEbEgaVHSrZKWJL0q6a5xFQs0Ic9DU5u4JQRpGWW1zL4hj4eku2ur\nCPg+s1IU6jBzR2KYjgBD5EVoqkO4Iy2EOzBERs8dCSLcgSGyvKDnjuQwYoEh8iLouSM5hDswRFaE\npum5IzGEOzBEljNzR3oId2CIrKDnjvQwYoEhWAqJFBHuwBArtGWQIMIdGCJnnTsSRLgDQ2RFaKrD\nRwVpYcQCQ3RvYmLmjrQQ7sAQ3MSEFBHuwBDdm5j4qCAtjFhgiCxny1+kh3AHhmBXSKSIcAeG4CYm\npIhwB4ZYYctfJIgRCwzBahmkiHAHhshoyyBBhDswBF+oIkWEO1AhInptGT4qSAsjFqiQFyFJmmbm\njsQQ7kCFrBfuHXruSAzhDlRYDXd67kgN4Q5UyPPVcOejgrQwYoEKK0UhSSyFRHJGCnfbu22fsb1k\n+9CAx99s+7O2n7Z92vZd9ZcKTF5eMHNHmoaOWNsdSYcl7ZE0J2mf7bl1l90t6bmIuEHSzZL+xPZV\nNdcKTNxK3pu503NHYkaZjuyStBQRZyPioqRjkvauuyYkvcm2Jb1R0tclZbVWCjRgdebO9gNIzSjh\nvkXSub7j871z/R6Q9JOSvibpWUn3RERRS4VAg9ZWy9BzR2LqaiT+iqSnJL1V0k9LesD2Nesvsr3f\n9inbp5aXl2t6aWB8MlbLIFGjjNgLkrb2Hc/2zvW7S9Ij0bUk6SuS3rb+iSLiSETMR8T8zMzM5dYM\nTEzWWy1DWwapGSXcT0raaXtH70vS2yUdX3fNi5JukSTbb5H0E5LO1lko0IS17QdoyyAxU8MuiIjM\n9kFJJyR1JB2NiNO2D/QeX5D0UUkP235WkiXdGxGvjLFuYCJWcr5QRZqGhrskRcSipMV15xb6/v6a\npPfUWxrQPNa5I1WMWKBCxh2qSBThDlR4bbUM4Y60EO5ABW5iQqoId6BCtrZaho8K0sKIBSpkOevc\nkSbCHajAj3UgVYQ7UGFtKSRtGSSGEQtUYMtfpIpwByqwWgapItyBCmz5i1QR7kCFbK0tw0cFaWHE\nAhUy2jJIFOEOVGDLX6SKcAcqMHNHqgh3oAI/s4dUMWKBCnlRyGbmjvQQ7kCFlSK4gQlJItyBCnkR\nzNqRJMIdqJDloWn67UgQoxaokBWFOiyDRIIId6BCVgQrZZAkRi1QIcsLvlBFkgh3oELGF6pIFOEO\nVMiLYOsBJIlwBypkOTN3pIlwBypkRcEXqkgSoxaokBfBD3UgSSOFu+3dts/YXrJ9qOSam20/Zfu0\n7X+qt0ygGSs52w8gTVPDLrDdkXRY0i9LOi/ppO3jEfFc3zXXSvq4pN0R8aLtHx5XwcAksf0AUjXK\nzH2XpKWIOBsRFyUdk7R33TV3SHokIl6UpIh4ud4ygWZkRaGpDt1LpGeUUbtF0rm+4/O9c/1+XNJ1\ntv/R9hO276yrQKBJGW0ZJGpoW+YSnudnJd0i6WpJ/2z78Yh4of8i2/sl7Zekbdu21fTSwPhkRehq\nwh0JGmXmfkHS1r7j2d65fuclnYiIb0fEK5Iek3TD+ieKiCMRMR8R8zMzM5dbMzAx3ZuYaMsgPaOM\n2pOSdtreYfsqSbdLOr7ums9I+nnbU7ZfL+ldkp6vt1Rg8lbygi9UkaShbZmIyGwflHRCUkfS0Yg4\nbftA7/GFiHje9t9LekZSIemhiPjyOAsHJiHnl5iQqJF67hGxKGlx3bmFdcf3SbqvvtKA5nVvYqIt\ng/QwaoEKKwVb/iJNhDtQIWfjMCSKcAcqZGz5i0QR7kAFfqwDqSLcgQrdn9njY4L0MGqBCiyFRKoI\nd6DCShHq0HNHggh3oAIzd6SKcAdKREQv3PmYID2MWqBEVoQkMXNHkgh3oETeC3d67kgR4Q6UWJ25\nT9OWQYIYtUCJLC8kiZuYkCTCHSix1nOnLYMEEe5AiXztC1U+JkgPoxYosdJry7BaBiki3IESOW0Z\nJIxwB0qs5L2lkMzckSDCHShBzx0pY9QCJbKi13OnLYMEEe5AiSxn+wGki3AHSqyuc6fnjhQR7kCJ\n1Z77dIePCdLDqAVKsP0AUka4AyXY8hcpI9yBEq/dxMTHBOlh1AIl2H4AKSPcgRI5q2WQsJHC3fZu\n22dsL9k+VHHdz9nObP9mfSUCzVj7sQ5uYkKChoa77Y6kw5L2SJqTtM/2XMl1fyzpC3UXCTRh9Q7V\nDtsPIEGjjNpdkpYi4mxEXJR0TNLeAdf9rqRPS3q5xvqAxnCHKlI2SrhvkXSu7/h879wa21sk/Yak\nB6ueyPZ+26dsn1peXr7UWoGJYstfpKyu/9+8X9K9EVFUXRQRRyJiPiLmZ2ZmanppYDxW+EIVCZsa\n4ZoLkrb2Hc/2zvWbl3TMtiRtlnSr7Swi/q6WKoEG5GtLIem5Iz2jhPtJSTtt71A31G+XdEf/BRGx\nY/Vv2w9L+hzBjtTxA9lI2dBwj4jM9kFJJyR1JB2NiNO2D/QeXxhzjUAj2H4AKRtl5q6IWJS0uO7c\nwFCPiPddeVlA87iJCSmjmQiUWF0KOU3PHQli1AIlsqKQLW1i5o4EEe5AiawI+u1IFuEOlMiLYBkk\nksXIBUqs5AUzdySLcAdK5EWowxp3JIpwB0pktGWQMEYuUCKjLYOEEe5AiawIth5Asgh3oESWsxQS\n6SLcgRJ5EWw9gGQR7kCJrCg03eEjgjQxcoESWc7MHeki3IESbD+AlBHuQIm8CE3RlkGiGLlAiZW8\noC2DZBHuQImctgwSRrgDJTLaMkgYIxcokRVsP4B0Ee5ACZZCImWEO1AiL0LT7C2DRBHuQImsCHXY\n8heJYuQCJei5I2WEO1AiZ1dIJIxwB0qssJ87Eka4AyXY8hcpI9yBEt2f2eMjgjSNNHJt77Z9xvaS\n7UMDHv8t28/Yftb2l2zfUH+pwGSxKyRSNjTcbXckHZa0R9KcpH2259Zd9hVJN0XE2yV9VNKRugsF\nJi0rQh167kjUKDP3XZKWIuJsRFyUdEzS3v4LIuJLEfGN3uHjkmbrLROYvLwITdOWQaJGGblbJJ3r\nOz7fO1fm/ZI+P+gB2/ttn7J9anl5efQqgQmLCL5QRdJqnZbY/gV1w/3eQY9HxJGImI+I+ZmZmTpf\nGqhVVoQk0XNHsqZGuOaCpK19x7O9c9/F9jskPSRpT0T8Tz3lAc3IV8OdLX+RqFFG7klJO23vsH2V\npNslHe+/wPY2SY9Iem9EvFB/mcBkreSFJGbuSNfQmXtEZLYPSjohqSPpaESctn2g9/iCpD+S9EOS\nPm5bkrKImB9f2cB4rc7c6bkjVaO0ZRQRi5IW151b6Pv7A5I+UG9pQHNWe+5s+YtU0VAEBsjy1Zk7\nHxGkiZELDJAVvZ47M3ckinAHBlidufOFKlJFuAMDZHyhisQR7sAA+doXqnxEkCZGLjDA6jp3Zu5I\nFeEODJCz/QASR7gDA2RsP4DEMXKBATK2H0DiCHdgALYfQOoId2AAth9A6gh3YIDVO1TZfgCpYuQC\nA3CHKlJHuAMDvPZjHYQ70kS4AwOssM4diSPcgQFyeu5IHCMXGICeO1JHuAMDZPTckTjCHRiALX+R\nOsIdGCDvbT8wTc8diWLkAgOszdxpyyBRhDswQMZSSCSOcAcGeG0/dz4iSBMjFxhghS1/kTjCHRgg\nL0K2tIlwR6IId2CArAhWyiBpjF5ggCwvWOOOpI0U7rZ32z5je8n2oQGP2/bHeo8/Y/ud9ZcKTE5W\nBP12JG1ouNvuSDosaY+kOUn7bM+tu2yPpJ29f/ZLerDmOoGJyotg6wEkbWqEa3ZJWoqIs5Jk+5ik\nvZKe67tmr6RPRERIetz2tbavj4iX6i74Ylbo1YtZ3U8LfJdv/1/OjpBI2ijhvkXSub7j85LeNcI1\nWyTVHu6PPvffuvtTT9b9tMD3mL3u6qZLAC7bKOFeG9v71W3baNu2bZf1HHNvvUYf+bX1XSGgfnPX\nX9N0CcBlGyXcL0ja2nc82zt3qdcoIo5IOiJJ8/PzcUmV9uzY/Abt2Lzjcv5VANgwRmkqnpS00/YO\n21dJul3S8XXXHJd0Z2/VzI2SvjmOfjsAYDRDZ+4Rkdk+KOmEpI6koxFx2vaB3uMLkhYl3SppSdKr\nku4aX8kAgGFG6rlHxKK6Ad5/bqHv75B0d72lAQAuF2u9AKCFCHcAaCHCHQBaiHAHgBYi3AGghQh3\nAGghwh0AWohwB4AWItwBoIUIdwBoIcIdAFqIcAeAFiLcAaCF3N3QsYEXtpclfbWRF78ymyW90nQR\nDdiI73sjvmdpY77vlN7zj0bEzLCLGgv3VNk+FRHzTdcxaRvxfW/E9yxtzPfdxvdMWwYAWohwB4AW\nItwv3ZGmC2jIRnzfG/E9SxvzfbfuPdNzB4AWYuYOAC1EuF8B2x+yHbY3N13LuNm+z/a/2X7G9t/a\nvrbpmsbJ9m7bZ2wv2T7UdD3jZnur7X+w/Zzt07bvabqmSbHdsf2vtj/XdC11Itwvk+2tkt4j6cWm\na5mQRyX9VES8Q9ILkv6g4XrGxnZH0mFJeyTNSdpne67ZqsYuk/ShiJiTdKOkuzfAe151j6Tnmy6i\nboT75fszSb8vaUN8aRERX4iIrHf4uKTZJusZs12SliLibERclHRM0t6GaxqriHgpIp7s/f2/6obd\nlmarGj/bs5J+VdJDTddSN8L9MtjeK+lCRDzddC0N+R1Jn2+6iDHaIulc3/F5bYCgW2V7u6SfkfQv\nzVYyEferO0krmi6kblNNF/D9yvYXJf3IgIc+LOkP1W3JtErVe46Iz/Su+bC6/wv/yUnWhsmw/UZJ\nn5b0wYj4VtP1jJPt2yS9HBFP2L656XrqRriXiIhfGnTe9tsl7ZD0tG2p25540vauiPivCZZYu7L3\nvMr2+yTdJumWaPca2guStvYdz/bOtZrtaXWD/ZMR8UjT9UzAuyX9uu1bJb1O0jW2/yoifrvhumrB\nOvcrZPs/Jc1HRCqbDl0W27sl/amkmyJiuel6xsn2lLpfGt+ibqiflHRHRJxutLAxcnem8heSvh4R\nH2y6nknrzdx/LyJua7qWutBzx6gekPQmSY/afsr2QtMFjUvvi+ODkk6o+8Xi37Q52HveLem9kn6x\n99/3qd6MFoli5g4ALcTMHQBaiHAHgBYi3AGghQh3AGghwh0AWohwB4AWItwBoIUIdwBoof8HRoUy\n1WIQXfsAAAAASUVORK5CYII=\n", 89 | "text/plain": [ 90 | "" 91 | ] 92 | }, 93 | "metadata": {}, 94 | "output_type": "display_data" 95 | } 96 | ], 97 | "source": [ 98 | "import numpy as np\n", 99 | "import matplotlib.pylab as plt\n", 100 | "\n", 101 | "def step_function(x):\n", 102 | " return np.array(x > 0, dtype=np.int)\n", 103 | "\n", 104 | "x=np.arange(-5.0, 5.0, 0.1)\n", 105 | "y=step_function(x)\n", 106 | "plt.plot(x,y)\n", 107 | "plt.ylim(-0.1, 1.1) #y축의 범위 지정\n", 108 | "plt.show()" 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": 13, 114 | "metadata": { 115 | "collapsed": true 116 | }, 117 | "outputs": [], 118 | "source": [ 119 | "def sigmoid(x):\n", 120 | " return 1/ (1+np.exp(-x))" 121 | ] 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": 15, 126 | "metadata": {}, 127 | "outputs": [ 128 | { 129 | "data": { 130 | "text/plain": [ 131 | "array([ 0.26894142, 0.73105858, 0.88079708])" 132 | ] 133 | }, 134 | "execution_count": 15, 135 | "metadata": {}, 136 | "output_type": "execute_result" 137 | } 138 | ], 139 | "source": [ 140 | "x=np.array([-1.0, 1.0, 2.0])\n", 141 | "sigmoid(x)" 142 | ] 143 | }, 144 | { 145 | "cell_type": "code", 146 | "execution_count": 24, 147 | "metadata": {}, 148 | "outputs": [ 149 | { 150 | "data": { 151 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nVO4iImFI5S4iEob+DxH15vm8DFuTAAAAAElFTkSuQmCC\n", 152 | "text/plain": [ 153 | "" 154 | ] 155 | }, 156 | "metadata": {}, 157 | "output_type": "display_data" 158 | } 159 | ], 160 | "source": [ 161 | "def sigmoid(x):\n", 162 | " return 1/ (1+np.exp(-x))\n", 163 | "x=np.arange(-5.0, 5.0, 0.1)\n", 164 | "y=sigmoid(x)\n", 165 | "plt.plot(x,y)\n", 166 | "plt.ylim(-0.1,1.1) #y축의 범위 지정\n", 167 | "plt.show()" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": 26, 173 | "metadata": {}, 174 | "outputs": [ 175 | { 176 | "data": { 177 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", 178 | "text/plain": [ 179 | "" 180 | ] 181 | }, 182 | "metadata": {}, 183 | "output_type": "display_data" 184 | } 185 | ], 186 | "source": [ 187 | "def relu(x):\n", 188 | " return np.maximum(0,x) #두값중 큰값을 선택반환\n", 189 | "x=np.arange(-5.0, 5.0, 0.1)\n", 190 | "y=relu(x)\n", 191 | "plt.plot(x,y)\n", 192 | "plt.ylim(-0.1,1.1) #y축의 범위 지정\n", 193 | "plt.show()" 194 | ] 195 | }, 196 | { 197 | "cell_type": "markdown", 198 | "metadata": {}, 199 | "source": [ 200 | "## 다차원 배열의 계산" 201 | ] 202 | }, 203 | { 204 | "cell_type": "code", 205 | "execution_count": 27, 206 | "metadata": {}, 207 | "outputs": [ 208 | { 209 | "name": "stdout", 210 | "output_type": "stream", 211 | "text": [ 212 | "[1 2 3 4]\n" 213 | ] 214 | } 215 | ], 216 | "source": [ 217 | "import numpy as np\n", 218 | "A = np.array([1,2,3,4])\n", 219 | "print(A)" 220 | ] 221 | }, 222 | { 223 | "cell_type": "code", 224 | "execution_count": 30, 225 | "metadata": {}, 226 | "outputs": [ 227 | { 228 | "data": { 229 | "text/plain": [ 230 | "1" 231 | ] 232 | }, 233 | "execution_count": 30, 234 | "metadata": {}, 235 | "output_type": "execute_result" 236 | } 237 | ], 238 | "source": [ 239 | "np.ndim(A)" 240 | ] 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": 31, 245 | "metadata": {}, 246 | "outputs": [ 247 | { 248 | "data": { 249 | "text/plain": [ 250 | "(4,)" 251 | ] 252 | }, 253 | "execution_count": 31, 254 | "metadata": {}, 255 | "output_type": "execute_result" 256 | } 257 | ], 258 | "source": [ 259 | "A.shape" 260 | ] 261 | }, 262 | { 263 | "cell_type": "code", 264 | "execution_count": 40, 265 | "metadata": {}, 266 | "outputs": [ 267 | { 268 | "data": { 269 | "text/plain": [ 270 | "4" 271 | ] 272 | }, 273 | "execution_count": 40, 274 | "metadata": {}, 275 | "output_type": "execute_result" 276 | } 277 | ], 278 | "source": [ 279 | "A.shape[0]" 280 | ] 281 | }, 282 | { 283 | "cell_type": "code", 284 | "execution_count": 35, 285 | "metadata": {}, 286 | "outputs": [ 287 | { 288 | "name": "stdout", 289 | "output_type": "stream", 290 | "text": [ 291 | "[[1 2]\n", 292 | " [3 4]\n", 293 | " [5 6]]\n" 294 | ] 295 | } 296 | ], 297 | "source": [ 298 | "B = np.array([[1,2],[3,4],[5,6]])\n", 299 | "print(B)" 300 | ] 301 | }, 302 | { 303 | "cell_type": "code", 304 | "execution_count": 36, 305 | "metadata": {}, 306 | "outputs": [ 307 | { 308 | "data": { 309 | "text/plain": [ 310 | "2" 311 | ] 312 | }, 313 | "execution_count": 36, 314 | "metadata": {}, 315 | "output_type": "execute_result" 316 | } 317 | ], 318 | "source": [ 319 | "np.ndim(B)" 320 | ] 321 | }, 322 | { 323 | "cell_type": "markdown", 324 | "metadata": {}, 325 | "source": [ 326 | "$$B=\\begin{pmatrix}\n", 327 | "1&2\\\\\n", 328 | "3&4\\\\\n", 329 | "5&6\n", 330 | "\\end{pmatrix}$$" 331 | ] 332 | }, 333 | { 334 | "cell_type": "code", 335 | "execution_count": 37, 336 | "metadata": {}, 337 | "outputs": [ 338 | { 339 | "data": { 340 | "text/plain": [ 341 | "(3, 2)" 342 | ] 343 | }, 344 | "execution_count": 37, 345 | "metadata": {}, 346 | "output_type": "execute_result" 347 | } 348 | ], 349 | "source": [ 350 | "B.shape" 351 | ] 352 | }, 353 | { 354 | "cell_type": "markdown", 355 | "metadata": {}, 356 | "source": [ 357 | "## 행렬의 내적(곱)\n", 358 | "\n", 359 | "$$\\begin{pmatrix}\n", 360 | "1&2\\\\\n", 361 | "3&4\n", 362 | "\\end{pmatrix} \\begin{pmatrix}\n", 363 | "5&6\\\\\n", 364 | "7&8\n", 365 | "\\end{pmatrix} =\\begin{pmatrix}\n", 366 | "19&22\\\\\n", 367 | "43&50\n", 368 | "\\end{pmatrix}$$\n" 369 | ] 370 | }, 371 | { 372 | "cell_type": "code", 373 | "execution_count": 41, 374 | "metadata": {}, 375 | "outputs": [ 376 | { 377 | "data": { 378 | "text/plain": [ 379 | "(2, 2)" 380 | ] 381 | }, 382 | "execution_count": 41, 383 | "metadata": {}, 384 | "output_type": "execute_result" 385 | } 386 | ], 387 | "source": [ 388 | "A=np.array([[1,2],[3,4]])\n", 389 | "A.shape" 390 | ] 391 | }, 392 | { 393 | "cell_type": "code", 394 | "execution_count": 42, 395 | "metadata": {}, 396 | "outputs": [ 397 | { 398 | "data": { 399 | "text/plain": [ 400 | "(2, 2)" 401 | ] 402 | }, 403 | "execution_count": 42, 404 | "metadata": {}, 405 | "output_type": "execute_result" 406 | } 407 | ], 408 | "source": [ 409 | "B= np.array([[5,6],[7,8]])\n", 410 | "B.shape" 411 | ] 412 | }, 413 | { 414 | "cell_type": "code", 415 | "execution_count": 43, 416 | "metadata": {}, 417 | "outputs": [ 418 | { 419 | "data": { 420 | "text/plain": [ 421 | "array([[19, 22],\n", 422 | " [43, 50]])" 423 | ] 424 | }, 425 | "execution_count": 43, 426 | "metadata": {}, 427 | "output_type": "execute_result" 428 | } 429 | ], 430 | "source": [ 431 | "np.dot(A,B)" 432 | ] 433 | }, 434 | { 435 | "cell_type": "markdown", 436 | "metadata": {}, 437 | "source": [ 438 | "### 신경망내적 \n", 439 | "\n", 440 | "X W = Y\n", 441 | "\n", 442 | "2 2$\\times$3 3" 443 | ] 444 | }, 445 | { 446 | "cell_type": "code", 447 | "execution_count": 19, 448 | "metadata": {}, 449 | "outputs": [ 450 | { 451 | "data": { 452 | "text/plain": [ 453 | "(2,)" 454 | ] 455 | }, 456 | "execution_count": 19, 457 | "metadata": {}, 458 | "output_type": "execute_result" 459 | } 460 | ], 461 | "source": [ 462 | "X=np.array([1,2])\n", 463 | "X.shape" 464 | ] 465 | }, 466 | { 467 | "cell_type": "code", 468 | "execution_count": 20, 469 | "metadata": {}, 470 | "outputs": [ 471 | { 472 | "name": "stdout", 473 | "output_type": "stream", 474 | "text": [ 475 | "[[1 3 5]\n", 476 | " [2 4 6]]\n" 477 | ] 478 | } 479 | ], 480 | "source": [ 481 | "W=np.array([[1,3,5], [2,4,6]])\n", 482 | "print(W)" 483 | ] 484 | }, 485 | { 486 | "cell_type": "code", 487 | "execution_count": 21, 488 | "metadata": {}, 489 | "outputs": [ 490 | { 491 | "data": { 492 | "text/plain": [ 493 | "(2, 3)" 494 | ] 495 | }, 496 | "execution_count": 21, 497 | "metadata": {}, 498 | "output_type": "execute_result" 499 | } 500 | ], 501 | "source": [ 502 | "W.shape" 503 | ] 504 | }, 505 | { 506 | "cell_type": "code", 507 | "execution_count": 22, 508 | "metadata": {}, 509 | "outputs": [ 510 | { 511 | "name": "stdout", 512 | "output_type": "stream", 513 | "text": [ 514 | "[ 5 11 17]\n" 515 | ] 516 | } 517 | ], 518 | "source": [ 519 | "Y=np.dot(X,W) #np.dot 은 for문 없이 Y의 값이 여러개여도 한 번의 연산으로 가능\n", 520 | "print(Y)" 521 | ] 522 | }, 523 | { 524 | "cell_type": "markdown", 525 | "metadata": {}, 526 | "source": [ 527 | "### Example 4 pixels 3 classes" 528 | ] 529 | }, 530 | { 531 | "cell_type": "code", 532 | "execution_count": 48, 533 | "metadata": {}, 534 | "outputs": [ 535 | { 536 | "name": "stdout", 537 | "output_type": "stream", 538 | "text": [ 539 | "[ -97.9 434.7 61.95]\n" 540 | ] 541 | } 542 | ], 543 | "source": [ 544 | "X=np.array([56,231,24,2])\n", 545 | "W=np.array([[0.2,-0.5,0.1,2.0],[1.5,1.3,2.1,0.0],[0,0.25,0.2,-0.3]])\n", 546 | "X1=np.dot(W,X)\n", 547 | "print(X1)" 548 | ] 549 | }, 550 | { 551 | "cell_type": "code", 552 | "execution_count": 49, 553 | "metadata": {}, 554 | "outputs": [ 555 | { 556 | "name": "stdout", 557 | "output_type": "stream", 558 | "text": [ 559 | "[ -96.8 437.9 60.75]\n" 560 | ] 561 | } 562 | ], 563 | "source": [ 564 | "b=np.array([1.1,3.2,-1.2])\n", 565 | "Y=X1+b\n", 566 | "print(Y)" 567 | ] 568 | }, 569 | { 570 | "cell_type": "markdown", 571 | "metadata": {}, 572 | "source": [ 573 | "### 각 층의 신호 전달 구현\n", 574 | "\n", 575 | "1계층. $a_1 ^{(1)} = w_{11} ^{(1)}x_1 + w_{12} ^{(1)}x_2 + b_1 ^{(1)} $\n", 576 | "\n", 577 | "행렬 내적 이용하여, '가중치 부분' 간소화하면 \n", 578 | "\n", 579 | "$\\mathbb{A^{(1)}} = \\ \\mathbb{XW^{(1)}} + \\mathbb{B^{(1)}}$\n", 580 | "\n", 581 | "$\\mathbb{A^{(1)}} (a_1 ^{(1)} a_2 ^{(1)} a_3 ^{(1)} )$, $\\mathbb{X} = (x_1 x_2)$, $\\mathbb{B^{(1)}} = (b_1 ^{(1)} b_2 ^{(1)} b_3 ^{(1)} )$\n", 582 | "\n", 583 | "$\\mathbb{W^{(1)}}\\begin{pmatrix}\n", 584 | "w_{11} ^{(1)} & w_{21} ^{(1)} & w_{31} ^{(1)}\\\\\n", 585 | "w_{12} ^{(1)} & w_{22} ^{(1)} & w_{32} ^{(1)}\n", 586 | "\\end{pmatrix}$" 587 | ] 588 | }, 589 | { 590 | "cell_type": "code", 591 | "execution_count": 54, 592 | "metadata": {}, 593 | "outputs": [ 594 | { 595 | "name": "stdout", 596 | "output_type": "stream", 597 | "text": [ 598 | "(2, 3)\n", 599 | "(2,)\n", 600 | "(1, 3)\n" 601 | ] 602 | } 603 | ], 604 | "source": [ 605 | "X=np.array([1.0, 0.5])\n", 606 | "W1=np.array([[0.1,0.3,0.5], [0.2,0.4,0.6]])\n", 607 | "B1=np.array([[0.1, 0.2, 0.3]])\n", 608 | "\n", 609 | "print(W1.shape) # (2,3)\n", 610 | "print(X.shape) # (2,)\n", 611 | "print(B1.shape) # (3,)\n", 612 | "A1 = np.dot (X, W1) + B1 " 613 | ] 614 | }, 615 | { 616 | "cell_type": "markdown", 617 | "metadata": {}, 618 | "source": [ 619 | "### 은닉층에서의 가중치 합을 활성화 함수: 시그모이드 함수 사용해서 적용" 620 | ] 621 | }, 622 | { 623 | "cell_type": "code", 624 | "execution_count": 56, 625 | "metadata": {}, 626 | "outputs": [ 627 | { 628 | "name": "stdout", 629 | "output_type": "stream", 630 | "text": [ 631 | "[[ 0.3 0.7 1.1]]\n", 632 | "[[ 0.57444252 0.66818777 0.75026011]]\n" 633 | ] 634 | } 635 | ], 636 | "source": [ 637 | "Z1=sigmoid(A1)\n", 638 | "print(A1)\n", 639 | "print(Z1)" 640 | ] 641 | }, 642 | { 643 | "cell_type": "markdown", 644 | "metadata": {}, 645 | "source": [ 646 | "### 1층에서 2층으로 신호 전달" 647 | ] 648 | }, 649 | { 650 | "cell_type": "code", 651 | "execution_count": 60, 652 | "metadata": {}, 653 | "outputs": [ 654 | { 655 | "name": "stdout", 656 | "output_type": "stream", 657 | "text": [ 658 | "(1, 3)\n", 659 | "(3, 2)\n", 660 | "(1, 2)\n", 661 | "[[ 0.51615984 1.21402696]]\n", 662 | "[[ 0.62624937 0.7710107 ]]\n" 663 | ] 664 | } 665 | ], 666 | "source": [ 667 | "W2=np.array([[0.1,0.4], [0.2,0.5], [0.3,0.6]])\n", 668 | "B2=np.array([[0.1, 0.2]])\n", 669 | "\n", 670 | "print(Z1.shape) # (2,3)\n", 671 | "print(W2.shape) # (2,)\n", 672 | "print(B2.shape) # (3,)\n", 673 | "\n", 674 | "A2 = np.dot (Z1, W2) + B2\n", 675 | "Z2 = sigmoid(A2)\n", 676 | "print(A2)\n", 677 | "print(Z2)" 678 | ] 679 | }, 680 | { 681 | "cell_type": "markdown", 682 | "metadata": {}, 683 | "source": [ 684 | "### 2층에서 출력층으로의 신호 전달" 685 | ] 686 | }, 687 | { 688 | "cell_type": "code", 689 | "execution_count": 61, 690 | "metadata": {}, 691 | "outputs": [ 692 | { 693 | "name": "stdout", 694 | "output_type": "stream", 695 | "text": [ 696 | "[[ 0.31682708 0.69627909]]\n", 697 | "[[ 0.31682708 0.69627909]]\n" 698 | ] 699 | } 700 | ], 701 | "source": [ 702 | "def identity_function(x):\n", 703 | " return x\n", 704 | "\n", 705 | "W3=np.array([[0.1,0.3], [0.2,0.4]])\n", 706 | "B3=np.array([[0.1, 0.2]])\n", 707 | "\n", 708 | "A3 = np.dot (Z2, W3) + B3\n", 709 | "Y = identity_function(A3) \n", 710 | "\n", 711 | "print(A3)\n", 712 | "print(Y)" 713 | ] 714 | }, 715 | { 716 | "cell_type": "markdown", 717 | "metadata": {}, 718 | "source": [ 719 | "### 구현정리" 720 | ] 721 | }, 722 | { 723 | "cell_type": "code", 724 | "execution_count": 62, 725 | "metadata": {}, 726 | "outputs": [ 727 | { 728 | "name": "stdout", 729 | "output_type": "stream", 730 | "text": [ 731 | "[[ 0.31682708 0.69627909]]\n" 732 | ] 733 | } 734 | ], 735 | "source": [ 736 | "def init_network():\n", 737 | " network ={}\n", 738 | " network['W1'] = np.array([[0.1,0.3,0.5], [0.2,0.4,0.6]])\n", 739 | " network['b1'] = np.array([[0.1, 0.2, 0.3]])\n", 740 | " network['W2'] = np.array([[0.1,0.4], [0.2,0.5], [0.3,0.6]])\n", 741 | " network['b2'] = np.array([[0.1, 0.2]])\n", 742 | " network['W3'] = np.array([[0.1,0.3], [0.2,0.4]])\n", 743 | " network['b3'] = np.array([[0.1, 0.2]])\n", 744 | " \n", 745 | " return network\n", 746 | "\n", 747 | "def forward(network, x):\n", 748 | " W1, W2, W3 = network['W1'], network['W2'], network['W3']\n", 749 | " b1, b2, b3 = network['b1'], network['b2'], network['b3']\n", 750 | " \n", 751 | " a1 = np.dot(x, W1) + b1\n", 752 | " z1 =sigmoid(a1)\n", 753 | " a2 = np.dot(z1,W2) + b2\n", 754 | " z2 =sigmoid(a2)\n", 755 | " a3 = np.dot(z2,W3) + b3\n", 756 | " y = identity_function(a3)\n", 757 | " \n", 758 | " return y\n", 759 | "\n", 760 | "network =init_network()\n", 761 | "x = np.array([1.0 ,0.5])\n", 762 | "y = forward(network, x)\n", 763 | "print(y)" 764 | ] 765 | }, 766 | { 767 | "cell_type": "code", 768 | "execution_count": null, 769 | "metadata": { 770 | "collapsed": true 771 | }, 772 | "outputs": [], 773 | "source": [] 774 | } 775 | ], 776 | "metadata": { 777 | "kernelspec": { 778 | "display_name": "Python 3", 779 | "language": "python", 780 | "name": "python3" 781 | }, 782 | "language_info": { 783 | "codemirror_mode": { 784 | "name": "ipython", 785 | "version": 3 786 | }, 787 | "file_extension": ".py", 788 | "mimetype": "text/x-python", 789 | "name": "python", 790 | "nbconvert_exporter": "python", 791 | "pygments_lexer": "ipython3", 792 | "version": "3.6.3" 793 | } 794 | }, 795 | "nbformat": 4, 796 | "nbformat_minor": 2 797 | } 798 | -------------------------------------------------------------------------------- /Week 12- Linear Algebra in ML/pima_indians_diabetes.data.csv: -------------------------------------------------------------------------------- 1 | 6,148,72,35,0,33.6,0.627,50,1 2 | 1,85,66,29,0,26.6,0.351,31,0 3 | 8,183,64,0,0,23.3,0.672,32,1 4 | 1,89,66,23,94,28.1,0.167,21,0 5 | 0,137,40,35,168,43.1,2.288,33,1 6 | 5,116,74,0,0,25.6,0.201,30,0 7 | 3,78,50,32,88,31.0,0.248,26,1 8 | 10,115,0,0,0,35.3,0.134,29,0 9 | 2,197,70,45,543,30.5,0.158,53,1 10 | 8,125,96,0,0,0.0,0.232,54,1 11 | 4,110,92,0,0,37.6,0.191,30,0 12 | 10,168,74,0,0,38.0,0.537,34,1 13 | 10,139,80,0,0,27.1,1.441,57,0 14 | 1,189,60,23,846,30.1,0.398,59,1 15 | 5,166,72,19,175,25.8,0.587,51,1 16 | 7,100,0,0,0,30.0,0.484,32,1 17 | 0,118,84,47,230,45.8,0.551,31,1 18 | 7,107,74,0,0,29.6,0.254,31,1 19 | 1,103,30,38,83,43.3,0.183,33,0 20 | 1,115,70,30,96,34.6,0.529,32,1 21 | 3,126,88,41,235,39.3,0.704,27,0 22 | 8,99,84,0,0,35.4,0.388,50,0 23 | 7,196,90,0,0,39.8,0.451,41,1 24 | 9,119,80,35,0,29.0,0.263,29,1 25 | 11,143,94,33,146,36.6,0.254,51,1 26 | 10,125,70,26,115,31.1,0.205,41,1 27 | 7,147,76,0,0,39.4,0.257,43,1 28 | 1,97,66,15,140,23.2,0.487,22,0 29 | 13,145,82,19,110,22.2,0.245,57,0 30 | 5,117,92,0,0,34.1,0.337,38,0 31 | 5,109,75,26,0,36.0,0.546,60,0 32 | 3,158,76,36,245,31.6,0.851,28,1 33 | 3,88,58,11,54,24.8,0.267,22,0 34 | 6,92,92,0,0,19.9,0.188,28,0 35 | 10,122,78,31,0,27.6,0.512,45,0 36 | 4,103,60,33,192,24.0,0.966,33,0 37 | 11,138,76,0,0,33.2,0.420,35,0 38 | 9,102,76,37,0,32.9,0.665,46,1 39 | 2,90,68,42,0,38.2,0.503,27,1 40 | 4,111,72,47,207,37.1,1.390,56,1 41 | 3,180,64,25,70,34.0,0.271,26,0 42 | 7,133,84,0,0,40.2,0.696,37,0 43 | 7,106,92,18,0,22.7,0.235,48,0 44 | 9,171,110,24,240,45.4,0.721,54,1 45 | 7,159,64,0,0,27.4,0.294,40,0 46 | 0,180,66,39,0,42.0,1.893,25,1 47 | 1,146,56,0,0,29.7,0.564,29,0 48 | 2,71,70,27,0,28.0,0.586,22,0 49 | 7,103,66,32,0,39.1,0.344,31,1 50 | 7,105,0,0,0,0.0,0.305,24,0 51 | 1,103,80,11,82,19.4,0.491,22,0 52 | 1,101,50,15,36,24.2,0.526,26,0 53 | 5,88,66,21,23,24.4,0.342,30,0 54 | 8,176,90,34,300,33.7,0.467,58,1 55 | 7,150,66,42,342,34.7,0.718,42,0 56 | 1,73,50,10,0,23.0,0.248,21,0 57 | 7,187,68,39,304,37.7,0.254,41,1 58 | 0,100,88,60,110,46.8,0.962,31,0 59 | 0,146,82,0,0,40.5,1.781,44,0 60 | 0,105,64,41,142,41.5,0.173,22,0 61 | 2,84,0,0,0,0.0,0.304,21,0 62 | 8,133,72,0,0,32.9,0.270,39,1 63 | 5,44,62,0,0,25.0,0.587,36,0 64 | 2,141,58,34,128,25.4,0.699,24,0 65 | 7,114,66,0,0,32.8,0.258,42,1 66 | 5,99,74,27,0,29.0,0.203,32,0 67 | 0,109,88,30,0,32.5,0.855,38,1 68 | 2,109,92,0,0,42.7,0.845,54,0 69 | 1,95,66,13,38,19.6,0.334,25,0 70 | 4,146,85,27,100,28.9,0.189,27,0 71 | 2,100,66,20,90,32.9,0.867,28,1 72 | 5,139,64,35,140,28.6,0.411,26,0 73 | 13,126,90,0,0,43.4,0.583,42,1 74 | 4,129,86,20,270,35.1,0.231,23,0 75 | 1,79,75,30,0,32.0,0.396,22,0 76 | 1,0,48,20,0,24.7,0.140,22,0 77 | 7,62,78,0,0,32.6,0.391,41,0 78 | 5,95,72,33,0,37.7,0.370,27,0 79 | 0,131,0,0,0,43.2,0.270,26,1 80 | 2,112,66,22,0,25.0,0.307,24,0 81 | 3,113,44,13,0,22.4,0.140,22,0 82 | 2,74,0,0,0,0.0,0.102,22,0 83 | 7,83,78,26,71,29.3,0.767,36,0 84 | 0,101,65,28,0,24.6,0.237,22,0 85 | 5,137,108,0,0,48.8,0.227,37,1 86 | 2,110,74,29,125,32.4,0.698,27,0 87 | 13,106,72,54,0,36.6,0.178,45,0 88 | 2,100,68,25,71,38.5,0.324,26,0 89 | 15,136,70,32,110,37.1,0.153,43,1 90 | 1,107,68,19,0,26.5,0.165,24,0 91 | 1,80,55,0,0,19.1,0.258,21,0 92 | 4,123,80,15,176,32.0,0.443,34,0 93 | 7,81,78,40,48,46.7,0.261,42,0 94 | 4,134,72,0,0,23.8,0.277,60,1 95 | 2,142,82,18,64,24.7,0.761,21,0 96 | 6,144,72,27,228,33.9,0.255,40,0 97 | 2,92,62,28,0,31.6,0.130,24,0 98 | 1,71,48,18,76,20.4,0.323,22,0 99 | 6,93,50,30,64,28.7,0.356,23,0 100 | 1,122,90,51,220,49.7,0.325,31,1 101 | 1,163,72,0,0,39.0,1.222,33,1 102 | 1,151,60,0,0,26.1,0.179,22,0 103 | 0,125,96,0,0,22.5,0.262,21,0 104 | 1,81,72,18,40,26.6,0.283,24,0 105 | 2,85,65,0,0,39.6,0.930,27,0 106 | 1,126,56,29,152,28.7,0.801,21,0 107 | 1,96,122,0,0,22.4,0.207,27,0 108 | 4,144,58,28,140,29.5,0.287,37,0 109 | 3,83,58,31,18,34.3,0.336,25,0 110 | 0,95,85,25,36,37.4,0.247,24,1 111 | 3,171,72,33,135,33.3,0.199,24,1 112 | 8,155,62,26,495,34.0,0.543,46,1 113 | 1,89,76,34,37,31.2,0.192,23,0 114 | 4,76,62,0,0,34.0,0.391,25,0 115 | 7,160,54,32,175,30.5,0.588,39,1 116 | 4,146,92,0,0,31.2,0.539,61,1 117 | 5,124,74,0,0,34.0,0.220,38,1 118 | 5,78,48,0,0,33.7,0.654,25,0 119 | 4,97,60,23,0,28.2,0.443,22,0 120 | 4,99,76,15,51,23.2,0.223,21,0 121 | 0,162,76,56,100,53.2,0.759,25,1 122 | 6,111,64,39,0,34.2,0.260,24,0 123 | 2,107,74,30,100,33.6,0.404,23,0 124 | 5,132,80,0,0,26.8,0.186,69,0 125 | 0,113,76,0,0,33.3,0.278,23,1 126 | 1,88,30,42,99,55.0,0.496,26,1 127 | 3,120,70,30,135,42.9,0.452,30,0 128 | 1,118,58,36,94,33.3,0.261,23,0 129 | 1,117,88,24,145,34.5,0.403,40,1 130 | 0,105,84,0,0,27.9,0.741,62,1 131 | 4,173,70,14,168,29.7,0.361,33,1 132 | 9,122,56,0,0,33.3,1.114,33,1 133 | 3,170,64,37,225,34.5,0.356,30,1 134 | 8,84,74,31,0,38.3,0.457,39,0 135 | 2,96,68,13,49,21.1,0.647,26,0 136 | 2,125,60,20,140,33.8,0.088,31,0 137 | 0,100,70,26,50,30.8,0.597,21,0 138 | 0,93,60,25,92,28.7,0.532,22,0 139 | 0,129,80,0,0,31.2,0.703,29,0 140 | 5,105,72,29,325,36.9,0.159,28,0 141 | 3,128,78,0,0,21.1,0.268,55,0 142 | 5,106,82,30,0,39.5,0.286,38,0 143 | 2,108,52,26,63,32.5,0.318,22,0 144 | 10,108,66,0,0,32.4,0.272,42,1 145 | 4,154,62,31,284,32.8,0.237,23,0 146 | 0,102,75,23,0,0.0,0.572,21,0 147 | 9,57,80,37,0,32.8,0.096,41,0 148 | 2,106,64,35,119,30.5,1.400,34,0 149 | 5,147,78,0,0,33.7,0.218,65,0 150 | 2,90,70,17,0,27.3,0.085,22,0 151 | 1,136,74,50,204,37.4,0.399,24,0 152 | 4,114,65,0,0,21.9,0.432,37,0 153 | 9,156,86,28,155,34.3,1.189,42,1 154 | 1,153,82,42,485,40.6,0.687,23,0 155 | 8,188,78,0,0,47.9,0.137,43,1 156 | 7,152,88,44,0,50.0,0.337,36,1 157 | 2,99,52,15,94,24.6,0.637,21,0 158 | 1,109,56,21,135,25.2,0.833,23,0 159 | 2,88,74,19,53,29.0,0.229,22,0 160 | 17,163,72,41,114,40.9,0.817,47,1 161 | 4,151,90,38,0,29.7,0.294,36,0 162 | 7,102,74,40,105,37.2,0.204,45,0 163 | 0,114,80,34,285,44.2,0.167,27,0 164 | 2,100,64,23,0,29.7,0.368,21,0 165 | 0,131,88,0,0,31.6,0.743,32,1 166 | 6,104,74,18,156,29.9,0.722,41,1 167 | 3,148,66,25,0,32.5,0.256,22,0 168 | 4,120,68,0,0,29.6,0.709,34,0 169 | 4,110,66,0,0,31.9,0.471,29,0 170 | 3,111,90,12,78,28.4,0.495,29,0 171 | 6,102,82,0,0,30.8,0.180,36,1 172 | 6,134,70,23,130,35.4,0.542,29,1 173 | 2,87,0,23,0,28.9,0.773,25,0 174 | 1,79,60,42,48,43.5,0.678,23,0 175 | 2,75,64,24,55,29.7,0.370,33,0 176 | 8,179,72,42,130,32.7,0.719,36,1 177 | 6,85,78,0,0,31.2,0.382,42,0 178 | 0,129,110,46,130,67.1,0.319,26,1 179 | 5,143,78,0,0,45.0,0.190,47,0 180 | 5,130,82,0,0,39.1,0.956,37,1 181 | 6,87,80,0,0,23.2,0.084,32,0 182 | 0,119,64,18,92,34.9,0.725,23,0 183 | 1,0,74,20,23,27.7,0.299,21,0 184 | 5,73,60,0,0,26.8,0.268,27,0 185 | 4,141,74,0,0,27.6,0.244,40,0 186 | 7,194,68,28,0,35.9,0.745,41,1 187 | 8,181,68,36,495,30.1,0.615,60,1 188 | 1,128,98,41,58,32.0,1.321,33,1 189 | 8,109,76,39,114,27.9,0.640,31,1 190 | 5,139,80,35,160,31.6,0.361,25,1 191 | 3,111,62,0,0,22.6,0.142,21,0 192 | 9,123,70,44,94,33.1,0.374,40,0 193 | 7,159,66,0,0,30.4,0.383,36,1 194 | 11,135,0,0,0,52.3,0.578,40,1 195 | 8,85,55,20,0,24.4,0.136,42,0 196 | 5,158,84,41,210,39.4,0.395,29,1 197 | 1,105,58,0,0,24.3,0.187,21,0 198 | 3,107,62,13,48,22.9,0.678,23,1 199 | 4,109,64,44,99,34.8,0.905,26,1 200 | 4,148,60,27,318,30.9,0.150,29,1 201 | 0,113,80,16,0,31.0,0.874,21,0 202 | 1,138,82,0,0,40.1,0.236,28,0 203 | 0,108,68,20,0,27.3,0.787,32,0 204 | 2,99,70,16,44,20.4,0.235,27,0 205 | 6,103,72,32,190,37.7,0.324,55,0 206 | 5,111,72,28,0,23.9,0.407,27,0 207 | 8,196,76,29,280,37.5,0.605,57,1 208 | 5,162,104,0,0,37.7,0.151,52,1 209 | 1,96,64,27,87,33.2,0.289,21,0 210 | 7,184,84,33,0,35.5,0.355,41,1 211 | 2,81,60,22,0,27.7,0.290,25,0 212 | 0,147,85,54,0,42.8,0.375,24,0 213 | 7,179,95,31,0,34.2,0.164,60,0 214 | 0,140,65,26,130,42.6,0.431,24,1 215 | 9,112,82,32,175,34.2,0.260,36,1 216 | 12,151,70,40,271,41.8,0.742,38,1 217 | 5,109,62,41,129,35.8,0.514,25,1 218 | 6,125,68,30,120,30.0,0.464,32,0 219 | 5,85,74,22,0,29.0,1.224,32,1 220 | 5,112,66,0,0,37.8,0.261,41,1 221 | 0,177,60,29,478,34.6,1.072,21,1 222 | 2,158,90,0,0,31.6,0.805,66,1 223 | 7,119,0,0,0,25.2,0.209,37,0 224 | 7,142,60,33,190,28.8,0.687,61,0 225 | 1,100,66,15,56,23.6,0.666,26,0 226 | 1,87,78,27,32,34.6,0.101,22,0 227 | 0,101,76,0,0,35.7,0.198,26,0 228 | 3,162,52,38,0,37.2,0.652,24,1 229 | 4,197,70,39,744,36.7,2.329,31,0 230 | 0,117,80,31,53,45.2,0.089,24,0 231 | 4,142,86,0,0,44.0,0.645,22,1 232 | 6,134,80,37,370,46.2,0.238,46,1 233 | 1,79,80,25,37,25.4,0.583,22,0 234 | 4,122,68,0,0,35.0,0.394,29,0 235 | 3,74,68,28,45,29.7,0.293,23,0 236 | 4,171,72,0,0,43.6,0.479,26,1 237 | 7,181,84,21,192,35.9,0.586,51,1 238 | 0,179,90,27,0,44.1,0.686,23,1 239 | 9,164,84,21,0,30.8,0.831,32,1 240 | 0,104,76,0,0,18.4,0.582,27,0 241 | 1,91,64,24,0,29.2,0.192,21,0 242 | 4,91,70,32,88,33.1,0.446,22,0 243 | 3,139,54,0,0,25.6,0.402,22,1 244 | 6,119,50,22,176,27.1,1.318,33,1 245 | 2,146,76,35,194,38.2,0.329,29,0 246 | 9,184,85,15,0,30.0,1.213,49,1 247 | 10,122,68,0,0,31.2,0.258,41,0 248 | 0,165,90,33,680,52.3,0.427,23,0 249 | 9,124,70,33,402,35.4,0.282,34,0 250 | 1,111,86,19,0,30.1,0.143,23,0 251 | 9,106,52,0,0,31.2,0.380,42,0 252 | 2,129,84,0,0,28.0,0.284,27,0 253 | 2,90,80,14,55,24.4,0.249,24,0 254 | 0,86,68,32,0,35.8,0.238,25,0 255 | 12,92,62,7,258,27.6,0.926,44,1 256 | 1,113,64,35,0,33.6,0.543,21,1 257 | 3,111,56,39,0,30.1,0.557,30,0 258 | 2,114,68,22,0,28.7,0.092,25,0 259 | 1,193,50,16,375,25.9,0.655,24,0 260 | 11,155,76,28,150,33.3,1.353,51,1 261 | 3,191,68,15,130,30.9,0.299,34,0 262 | 3,141,0,0,0,30.0,0.761,27,1 263 | 4,95,70,32,0,32.1,0.612,24,0 264 | 3,142,80,15,0,32.4,0.200,63,0 265 | 4,123,62,0,0,32.0,0.226,35,1 266 | 5,96,74,18,67,33.6,0.997,43,0 267 | 0,138,0,0,0,36.3,0.933,25,1 268 | 2,128,64,42,0,40.0,1.101,24,0 269 | 0,102,52,0,0,25.1,0.078,21,0 270 | 2,146,0,0,0,27.5,0.240,28,1 271 | 10,101,86,37,0,45.6,1.136,38,1 272 | 2,108,62,32,56,25.2,0.128,21,0 273 | 3,122,78,0,0,23.0,0.254,40,0 274 | 1,71,78,50,45,33.2,0.422,21,0 275 | 13,106,70,0,0,34.2,0.251,52,0 276 | 2,100,70,52,57,40.5,0.677,25,0 277 | 7,106,60,24,0,26.5,0.296,29,1 278 | 0,104,64,23,116,27.8,0.454,23,0 279 | 5,114,74,0,0,24.9,0.744,57,0 280 | 2,108,62,10,278,25.3,0.881,22,0 281 | 0,146,70,0,0,37.9,0.334,28,1 282 | 10,129,76,28,122,35.9,0.280,39,0 283 | 7,133,88,15,155,32.4,0.262,37,0 284 | 7,161,86,0,0,30.4,0.165,47,1 285 | 2,108,80,0,0,27.0,0.259,52,1 286 | 7,136,74,26,135,26.0,0.647,51,0 287 | 5,155,84,44,545,38.7,0.619,34,0 288 | 1,119,86,39,220,45.6,0.808,29,1 289 | 4,96,56,17,49,20.8,0.340,26,0 290 | 5,108,72,43,75,36.1,0.263,33,0 291 | 0,78,88,29,40,36.9,0.434,21,0 292 | 0,107,62,30,74,36.6,0.757,25,1 293 | 2,128,78,37,182,43.3,1.224,31,1 294 | 1,128,48,45,194,40.5,0.613,24,1 295 | 0,161,50,0,0,21.9,0.254,65,0 296 | 6,151,62,31,120,35.5,0.692,28,0 297 | 2,146,70,38,360,28.0,0.337,29,1 298 | 0,126,84,29,215,30.7,0.520,24,0 299 | 14,100,78,25,184,36.6,0.412,46,1 300 | 8,112,72,0,0,23.6,0.840,58,0 301 | 0,167,0,0,0,32.3,0.839,30,1 302 | 2,144,58,33,135,31.6,0.422,25,1 303 | 5,77,82,41,42,35.8,0.156,35,0 304 | 5,115,98,0,0,52.9,0.209,28,1 305 | 3,150,76,0,0,21.0,0.207,37,0 306 | 2,120,76,37,105,39.7,0.215,29,0 307 | 10,161,68,23,132,25.5,0.326,47,1 308 | 0,137,68,14,148,24.8,0.143,21,0 309 | 0,128,68,19,180,30.5,1.391,25,1 310 | 2,124,68,28,205,32.9,0.875,30,1 311 | 6,80,66,30,0,26.2,0.313,41,0 312 | 0,106,70,37,148,39.4,0.605,22,0 313 | 2,155,74,17,96,26.6,0.433,27,1 314 | 3,113,50,10,85,29.5,0.626,25,0 315 | 7,109,80,31,0,35.9,1.127,43,1 316 | 2,112,68,22,94,34.1,0.315,26,0 317 | 3,99,80,11,64,19.3,0.284,30,0 318 | 3,182,74,0,0,30.5,0.345,29,1 319 | 3,115,66,39,140,38.1,0.150,28,0 320 | 6,194,78,0,0,23.5,0.129,59,1 321 | 4,129,60,12,231,27.5,0.527,31,0 322 | 3,112,74,30,0,31.6,0.197,25,1 323 | 0,124,70,20,0,27.4,0.254,36,1 324 | 13,152,90,33,29,26.8,0.731,43,1 325 | 2,112,75,32,0,35.7,0.148,21,0 326 | 1,157,72,21,168,25.6,0.123,24,0 327 | 1,122,64,32,156,35.1,0.692,30,1 328 | 10,179,70,0,0,35.1,0.200,37,0 329 | 2,102,86,36,120,45.5,0.127,23,1 330 | 6,105,70,32,68,30.8,0.122,37,0 331 | 8,118,72,19,0,23.1,1.476,46,0 332 | 2,87,58,16,52,32.7,0.166,25,0 333 | 1,180,0,0,0,43.3,0.282,41,1 334 | 12,106,80,0,0,23.6,0.137,44,0 335 | 1,95,60,18,58,23.9,0.260,22,0 336 | 0,165,76,43,255,47.9,0.259,26,0 337 | 0,117,0,0,0,33.8,0.932,44,0 338 | 5,115,76,0,0,31.2,0.343,44,1 339 | 9,152,78,34,171,34.2,0.893,33,1 340 | 7,178,84,0,0,39.9,0.331,41,1 341 | 1,130,70,13,105,25.9,0.472,22,0 342 | 1,95,74,21,73,25.9,0.673,36,0 343 | 1,0,68,35,0,32.0,0.389,22,0 344 | 5,122,86,0,0,34.7,0.290,33,0 345 | 8,95,72,0,0,36.8,0.485,57,0 346 | 8,126,88,36,108,38.5,0.349,49,0 347 | 1,139,46,19,83,28.7,0.654,22,0 348 | 3,116,0,0,0,23.5,0.187,23,0 349 | 3,99,62,19,74,21.8,0.279,26,0 350 | 5,0,80,32,0,41.0,0.346,37,1 351 | 4,92,80,0,0,42.2,0.237,29,0 352 | 4,137,84,0,0,31.2,0.252,30,0 353 | 3,61,82,28,0,34.4,0.243,46,0 354 | 1,90,62,12,43,27.2,0.580,24,0 355 | 3,90,78,0,0,42.7,0.559,21,0 356 | 9,165,88,0,0,30.4,0.302,49,1 357 | 1,125,50,40,167,33.3,0.962,28,1 358 | 13,129,0,30,0,39.9,0.569,44,1 359 | 12,88,74,40,54,35.3,0.378,48,0 360 | 1,196,76,36,249,36.5,0.875,29,1 361 | 5,189,64,33,325,31.2,0.583,29,1 362 | 5,158,70,0,0,29.8,0.207,63,0 363 | 5,103,108,37,0,39.2,0.305,65,0 364 | 4,146,78,0,0,38.5,0.520,67,1 365 | 4,147,74,25,293,34.9,0.385,30,0 366 | 5,99,54,28,83,34.0,0.499,30,0 367 | 6,124,72,0,0,27.6,0.368,29,1 368 | 0,101,64,17,0,21.0,0.252,21,0 369 | 3,81,86,16,66,27.5,0.306,22,0 370 | 1,133,102,28,140,32.8,0.234,45,1 371 | 3,173,82,48,465,38.4,2.137,25,1 372 | 0,118,64,23,89,0.0,1.731,21,0 373 | 0,84,64,22,66,35.8,0.545,21,0 374 | 2,105,58,40,94,34.9,0.225,25,0 375 | 2,122,52,43,158,36.2,0.816,28,0 376 | 12,140,82,43,325,39.2,0.528,58,1 377 | 0,98,82,15,84,25.2,0.299,22,0 378 | 1,87,60,37,75,37.2,0.509,22,0 379 | 4,156,75,0,0,48.3,0.238,32,1 380 | 0,93,100,39,72,43.4,1.021,35,0 381 | 1,107,72,30,82,30.8,0.821,24,0 382 | 0,105,68,22,0,20.0,0.236,22,0 383 | 1,109,60,8,182,25.4,0.947,21,0 384 | 1,90,62,18,59,25.1,1.268,25,0 385 | 1,125,70,24,110,24.3,0.221,25,0 386 | 1,119,54,13,50,22.3,0.205,24,0 387 | 5,116,74,29,0,32.3,0.660,35,1 388 | 8,105,100,36,0,43.3,0.239,45,1 389 | 5,144,82,26,285,32.0,0.452,58,1 390 | 3,100,68,23,81,31.6,0.949,28,0 391 | 1,100,66,29,196,32.0,0.444,42,0 392 | 5,166,76,0,0,45.7,0.340,27,1 393 | 1,131,64,14,415,23.7,0.389,21,0 394 | 4,116,72,12,87,22.1,0.463,37,0 395 | 4,158,78,0,0,32.9,0.803,31,1 396 | 2,127,58,24,275,27.7,1.600,25,0 397 | 3,96,56,34,115,24.7,0.944,39,0 398 | 0,131,66,40,0,34.3,0.196,22,1 399 | 3,82,70,0,0,21.1,0.389,25,0 400 | 3,193,70,31,0,34.9,0.241,25,1 401 | 4,95,64,0,0,32.0,0.161,31,1 402 | 6,137,61,0,0,24.2,0.151,55,0 403 | 5,136,84,41,88,35.0,0.286,35,1 404 | 9,72,78,25,0,31.6,0.280,38,0 405 | 5,168,64,0,0,32.9,0.135,41,1 406 | 2,123,48,32,165,42.1,0.520,26,0 407 | 4,115,72,0,0,28.9,0.376,46,1 408 | 0,101,62,0,0,21.9,0.336,25,0 409 | 8,197,74,0,0,25.9,1.191,39,1 410 | 1,172,68,49,579,42.4,0.702,28,1 411 | 6,102,90,39,0,35.7,0.674,28,0 412 | 1,112,72,30,176,34.4,0.528,25,0 413 | 1,143,84,23,310,42.4,1.076,22,0 414 | 1,143,74,22,61,26.2,0.256,21,0 415 | 0,138,60,35,167,34.6,0.534,21,1 416 | 3,173,84,33,474,35.7,0.258,22,1 417 | 1,97,68,21,0,27.2,1.095,22,0 418 | 4,144,82,32,0,38.5,0.554,37,1 419 | 1,83,68,0,0,18.2,0.624,27,0 420 | 3,129,64,29,115,26.4,0.219,28,1 421 | 1,119,88,41,170,45.3,0.507,26,0 422 | 2,94,68,18,76,26.0,0.561,21,0 423 | 0,102,64,46,78,40.6,0.496,21,0 424 | 2,115,64,22,0,30.8,0.421,21,0 425 | 8,151,78,32,210,42.9,0.516,36,1 426 | 4,184,78,39,277,37.0,0.264,31,1 427 | 0,94,0,0,0,0.0,0.256,25,0 428 | 1,181,64,30,180,34.1,0.328,38,1 429 | 0,135,94,46,145,40.6,0.284,26,0 430 | 1,95,82,25,180,35.0,0.233,43,1 431 | 2,99,0,0,0,22.2,0.108,23,0 432 | 3,89,74,16,85,30.4,0.551,38,0 433 | 1,80,74,11,60,30.0,0.527,22,0 434 | 2,139,75,0,0,25.6,0.167,29,0 435 | 1,90,68,8,0,24.5,1.138,36,0 436 | 0,141,0,0,0,42.4,0.205,29,1 437 | 12,140,85,33,0,37.4,0.244,41,0 438 | 5,147,75,0,0,29.9,0.434,28,0 439 | 1,97,70,15,0,18.2,0.147,21,0 440 | 6,107,88,0,0,36.8,0.727,31,0 441 | 0,189,104,25,0,34.3,0.435,41,1 442 | 2,83,66,23,50,32.2,0.497,22,0 443 | 4,117,64,27,120,33.2,0.230,24,0 444 | 8,108,70,0,0,30.5,0.955,33,1 445 | 4,117,62,12,0,29.7,0.380,30,1 446 | 0,180,78,63,14,59.4,2.420,25,1 447 | 1,100,72,12,70,25.3,0.658,28,0 448 | 0,95,80,45,92,36.5,0.330,26,0 449 | 0,104,64,37,64,33.6,0.510,22,1 450 | 0,120,74,18,63,30.5,0.285,26,0 451 | 1,82,64,13,95,21.2,0.415,23,0 452 | 2,134,70,0,0,28.9,0.542,23,1 453 | 0,91,68,32,210,39.9,0.381,25,0 454 | 2,119,0,0,0,19.6,0.832,72,0 455 | 2,100,54,28,105,37.8,0.498,24,0 456 | 14,175,62,30,0,33.6,0.212,38,1 457 | 1,135,54,0,0,26.7,0.687,62,0 458 | 5,86,68,28,71,30.2,0.364,24,0 459 | 10,148,84,48,237,37.6,1.001,51,1 460 | 9,134,74,33,60,25.9,0.460,81,0 461 | 9,120,72,22,56,20.8,0.733,48,0 462 | 1,71,62,0,0,21.8,0.416,26,0 463 | 8,74,70,40,49,35.3,0.705,39,0 464 | 5,88,78,30,0,27.6,0.258,37,0 465 | 10,115,98,0,0,24.0,1.022,34,0 466 | 0,124,56,13,105,21.8,0.452,21,0 467 | 0,74,52,10,36,27.8,0.269,22,0 468 | 0,97,64,36,100,36.8,0.600,25,0 469 | 8,120,0,0,0,30.0,0.183,38,1 470 | 6,154,78,41,140,46.1,0.571,27,0 471 | 1,144,82,40,0,41.3,0.607,28,0 472 | 0,137,70,38,0,33.2,0.170,22,0 473 | 0,119,66,27,0,38.8,0.259,22,0 474 | 7,136,90,0,0,29.9,0.210,50,0 475 | 4,114,64,0,0,28.9,0.126,24,0 476 | 0,137,84,27,0,27.3,0.231,59,0 477 | 2,105,80,45,191,33.7,0.711,29,1 478 | 7,114,76,17,110,23.8,0.466,31,0 479 | 8,126,74,38,75,25.9,0.162,39,0 480 | 4,132,86,31,0,28.0,0.419,63,0 481 | 3,158,70,30,328,35.5,0.344,35,1 482 | 0,123,88,37,0,35.2,0.197,29,0 483 | 4,85,58,22,49,27.8,0.306,28,0 484 | 0,84,82,31,125,38.2,0.233,23,0 485 | 0,145,0,0,0,44.2,0.630,31,1 486 | 0,135,68,42,250,42.3,0.365,24,1 487 | 1,139,62,41,480,40.7,0.536,21,0 488 | 0,173,78,32,265,46.5,1.159,58,0 489 | 4,99,72,17,0,25.6,0.294,28,0 490 | 8,194,80,0,0,26.1,0.551,67,0 491 | 2,83,65,28,66,36.8,0.629,24,0 492 | 2,89,90,30,0,33.5,0.292,42,0 493 | 4,99,68,38,0,32.8,0.145,33,0 494 | 4,125,70,18,122,28.9,1.144,45,1 495 | 3,80,0,0,0,0.0,0.174,22,0 496 | 6,166,74,0,0,26.6,0.304,66,0 497 | 5,110,68,0,0,26.0,0.292,30,0 498 | 2,81,72,15,76,30.1,0.547,25,0 499 | 7,195,70,33,145,25.1,0.163,55,1 500 | 6,154,74,32,193,29.3,0.839,39,0 501 | 2,117,90,19,71,25.2,0.313,21,0 502 | 3,84,72,32,0,37.2,0.267,28,0 503 | 6,0,68,41,0,39.0,0.727,41,1 504 | 7,94,64,25,79,33.3,0.738,41,0 505 | 3,96,78,39,0,37.3,0.238,40,0 506 | 10,75,82,0,0,33.3,0.263,38,0 507 | 0,180,90,26,90,36.5,0.314,35,1 508 | 1,130,60,23,170,28.6,0.692,21,0 509 | 2,84,50,23,76,30.4,0.968,21,0 510 | 8,120,78,0,0,25.0,0.409,64,0 511 | 12,84,72,31,0,29.7,0.297,46,1 512 | 0,139,62,17,210,22.1,0.207,21,0 513 | 9,91,68,0,0,24.2,0.200,58,0 514 | 2,91,62,0,0,27.3,0.525,22,0 515 | 3,99,54,19,86,25.6,0.154,24,0 516 | 3,163,70,18,105,31.6,0.268,28,1 517 | 9,145,88,34,165,30.3,0.771,53,1 518 | 7,125,86,0,0,37.6,0.304,51,0 519 | 13,76,60,0,0,32.8,0.180,41,0 520 | 6,129,90,7,326,19.6,0.582,60,0 521 | 2,68,70,32,66,25.0,0.187,25,0 522 | 3,124,80,33,130,33.2,0.305,26,0 523 | 6,114,0,0,0,0.0,0.189,26,0 524 | 9,130,70,0,0,34.2,0.652,45,1 525 | 3,125,58,0,0,31.6,0.151,24,0 526 | 3,87,60,18,0,21.8,0.444,21,0 527 | 1,97,64,19,82,18.2,0.299,21,0 528 | 3,116,74,15,105,26.3,0.107,24,0 529 | 0,117,66,31,188,30.8,0.493,22,0 530 | 0,111,65,0,0,24.6,0.660,31,0 531 | 2,122,60,18,106,29.8,0.717,22,0 532 | 0,107,76,0,0,45.3,0.686,24,0 533 | 1,86,66,52,65,41.3,0.917,29,0 534 | 6,91,0,0,0,29.8,0.501,31,0 535 | 1,77,56,30,56,33.3,1.251,24,0 536 | 4,132,0,0,0,32.9,0.302,23,1 537 | 0,105,90,0,0,29.6,0.197,46,0 538 | 0,57,60,0,0,21.7,0.735,67,0 539 | 0,127,80,37,210,36.3,0.804,23,0 540 | 3,129,92,49,155,36.4,0.968,32,1 541 | 8,100,74,40,215,39.4,0.661,43,1 542 | 3,128,72,25,190,32.4,0.549,27,1 543 | 10,90,85,32,0,34.9,0.825,56,1 544 | 4,84,90,23,56,39.5,0.159,25,0 545 | 1,88,78,29,76,32.0,0.365,29,0 546 | 8,186,90,35,225,34.5,0.423,37,1 547 | 5,187,76,27,207,43.6,1.034,53,1 548 | 4,131,68,21,166,33.1,0.160,28,0 549 | 1,164,82,43,67,32.8,0.341,50,0 550 | 4,189,110,31,0,28.5,0.680,37,0 551 | 1,116,70,28,0,27.4,0.204,21,0 552 | 3,84,68,30,106,31.9,0.591,25,0 553 | 6,114,88,0,0,27.8,0.247,66,0 554 | 1,88,62,24,44,29.9,0.422,23,0 555 | 1,84,64,23,115,36.9,0.471,28,0 556 | 7,124,70,33,215,25.5,0.161,37,0 557 | 1,97,70,40,0,38.1,0.218,30,0 558 | 8,110,76,0,0,27.8,0.237,58,0 559 | 11,103,68,40,0,46.2,0.126,42,0 560 | 11,85,74,0,0,30.1,0.300,35,0 561 | 6,125,76,0,0,33.8,0.121,54,1 562 | 0,198,66,32,274,41.3,0.502,28,1 563 | 1,87,68,34,77,37.6,0.401,24,0 564 | 6,99,60,19,54,26.9,0.497,32,0 565 | 0,91,80,0,0,32.4,0.601,27,0 566 | 2,95,54,14,88,26.1,0.748,22,0 567 | 1,99,72,30,18,38.6,0.412,21,0 568 | 6,92,62,32,126,32.0,0.085,46,0 569 | 4,154,72,29,126,31.3,0.338,37,0 570 | 0,121,66,30,165,34.3,0.203,33,1 571 | 3,78,70,0,0,32.5,0.270,39,0 572 | 2,130,96,0,0,22.6,0.268,21,0 573 | 3,111,58,31,44,29.5,0.430,22,0 574 | 2,98,60,17,120,34.7,0.198,22,0 575 | 1,143,86,30,330,30.1,0.892,23,0 576 | 1,119,44,47,63,35.5,0.280,25,0 577 | 6,108,44,20,130,24.0,0.813,35,0 578 | 2,118,80,0,0,42.9,0.693,21,1 579 | 10,133,68,0,0,27.0,0.245,36,0 580 | 2,197,70,99,0,34.7,0.575,62,1 581 | 0,151,90,46,0,42.1,0.371,21,1 582 | 6,109,60,27,0,25.0,0.206,27,0 583 | 12,121,78,17,0,26.5,0.259,62,0 584 | 8,100,76,0,0,38.7,0.190,42,0 585 | 8,124,76,24,600,28.7,0.687,52,1 586 | 1,93,56,11,0,22.5,0.417,22,0 587 | 8,143,66,0,0,34.9,0.129,41,1 588 | 6,103,66,0,0,24.3,0.249,29,0 589 | 3,176,86,27,156,33.3,1.154,52,1 590 | 0,73,0,0,0,21.1,0.342,25,0 591 | 11,111,84,40,0,46.8,0.925,45,1 592 | 2,112,78,50,140,39.4,0.175,24,0 593 | 3,132,80,0,0,34.4,0.402,44,1 594 | 2,82,52,22,115,28.5,1.699,25,0 595 | 6,123,72,45,230,33.6,0.733,34,0 596 | 0,188,82,14,185,32.0,0.682,22,1 597 | 0,67,76,0,0,45.3,0.194,46,0 598 | 1,89,24,19,25,27.8,0.559,21,0 599 | 1,173,74,0,0,36.8,0.088,38,1 600 | 1,109,38,18,120,23.1,0.407,26,0 601 | 1,108,88,19,0,27.1,0.400,24,0 602 | 6,96,0,0,0,23.7,0.190,28,0 603 | 1,124,74,36,0,27.8,0.100,30,0 604 | 7,150,78,29,126,35.2,0.692,54,1 605 | 4,183,0,0,0,28.4,0.212,36,1 606 | 1,124,60,32,0,35.8,0.514,21,0 607 | 1,181,78,42,293,40.0,1.258,22,1 608 | 1,92,62,25,41,19.5,0.482,25,0 609 | 0,152,82,39,272,41.5,0.270,27,0 610 | 1,111,62,13,182,24.0,0.138,23,0 611 | 3,106,54,21,158,30.9,0.292,24,0 612 | 3,174,58,22,194,32.9,0.593,36,1 613 | 7,168,88,42,321,38.2,0.787,40,1 614 | 6,105,80,28,0,32.5,0.878,26,0 615 | 11,138,74,26,144,36.1,0.557,50,1 616 | 3,106,72,0,0,25.8,0.207,27,0 617 | 6,117,96,0,0,28.7,0.157,30,0 618 | 2,68,62,13,15,20.1,0.257,23,0 619 | 9,112,82,24,0,28.2,1.282,50,1 620 | 0,119,0,0,0,32.4,0.141,24,1 621 | 2,112,86,42,160,38.4,0.246,28,0 622 | 2,92,76,20,0,24.2,1.698,28,0 623 | 6,183,94,0,0,40.8,1.461,45,0 624 | 0,94,70,27,115,43.5,0.347,21,0 625 | 2,108,64,0,0,30.8,0.158,21,0 626 | 4,90,88,47,54,37.7,0.362,29,0 627 | 0,125,68,0,0,24.7,0.206,21,0 628 | 0,132,78,0,0,32.4,0.393,21,0 629 | 5,128,80,0,0,34.6,0.144,45,0 630 | 4,94,65,22,0,24.7,0.148,21,0 631 | 7,114,64,0,0,27.4,0.732,34,1 632 | 0,102,78,40,90,34.5,0.238,24,0 633 | 2,111,60,0,0,26.2,0.343,23,0 634 | 1,128,82,17,183,27.5,0.115,22,0 635 | 10,92,62,0,0,25.9,0.167,31,0 636 | 13,104,72,0,0,31.2,0.465,38,1 637 | 5,104,74,0,0,28.8,0.153,48,0 638 | 2,94,76,18,66,31.6,0.649,23,0 639 | 7,97,76,32,91,40.9,0.871,32,1 640 | 1,100,74,12,46,19.5,0.149,28,0 641 | 0,102,86,17,105,29.3,0.695,27,0 642 | 4,128,70,0,0,34.3,0.303,24,0 643 | 6,147,80,0,0,29.5,0.178,50,1 644 | 4,90,0,0,0,28.0,0.610,31,0 645 | 3,103,72,30,152,27.6,0.730,27,0 646 | 2,157,74,35,440,39.4,0.134,30,0 647 | 1,167,74,17,144,23.4,0.447,33,1 648 | 0,179,50,36,159,37.8,0.455,22,1 649 | 11,136,84,35,130,28.3,0.260,42,1 650 | 0,107,60,25,0,26.4,0.133,23,0 651 | 1,91,54,25,100,25.2,0.234,23,0 652 | 1,117,60,23,106,33.8,0.466,27,0 653 | 5,123,74,40,77,34.1,0.269,28,0 654 | 2,120,54,0,0,26.8,0.455,27,0 655 | 1,106,70,28,135,34.2,0.142,22,0 656 | 2,155,52,27,540,38.7,0.240,25,1 657 | 2,101,58,35,90,21.8,0.155,22,0 658 | 1,120,80,48,200,38.9,1.162,41,0 659 | 11,127,106,0,0,39.0,0.190,51,0 660 | 3,80,82,31,70,34.2,1.292,27,1 661 | 10,162,84,0,0,27.7,0.182,54,0 662 | 1,199,76,43,0,42.9,1.394,22,1 663 | 8,167,106,46,231,37.6,0.165,43,1 664 | 9,145,80,46,130,37.9,0.637,40,1 665 | 6,115,60,39,0,33.7,0.245,40,1 666 | 1,112,80,45,132,34.8,0.217,24,0 667 | 4,145,82,18,0,32.5,0.235,70,1 668 | 10,111,70,27,0,27.5,0.141,40,1 669 | 6,98,58,33,190,34.0,0.430,43,0 670 | 9,154,78,30,100,30.9,0.164,45,0 671 | 6,165,68,26,168,33.6,0.631,49,0 672 | 1,99,58,10,0,25.4,0.551,21,0 673 | 10,68,106,23,49,35.5,0.285,47,0 674 | 3,123,100,35,240,57.3,0.880,22,0 675 | 8,91,82,0,0,35.6,0.587,68,0 676 | 6,195,70,0,0,30.9,0.328,31,1 677 | 9,156,86,0,0,24.8,0.230,53,1 678 | 0,93,60,0,0,35.3,0.263,25,0 679 | 3,121,52,0,0,36.0,0.127,25,1 680 | 2,101,58,17,265,24.2,0.614,23,0 681 | 2,56,56,28,45,24.2,0.332,22,0 682 | 0,162,76,36,0,49.6,0.364,26,1 683 | 0,95,64,39,105,44.6,0.366,22,0 684 | 4,125,80,0,0,32.3,0.536,27,1 685 | 5,136,82,0,0,0.0,0.640,69,0 686 | 2,129,74,26,205,33.2,0.591,25,0 687 | 3,130,64,0,0,23.1,0.314,22,0 688 | 1,107,50,19,0,28.3,0.181,29,0 689 | 1,140,74,26,180,24.1,0.828,23,0 690 | 1,144,82,46,180,46.1,0.335,46,1 691 | 8,107,80,0,0,24.6,0.856,34,0 692 | 13,158,114,0,0,42.3,0.257,44,1 693 | 2,121,70,32,95,39.1,0.886,23,0 694 | 7,129,68,49,125,38.5,0.439,43,1 695 | 2,90,60,0,0,23.5,0.191,25,0 696 | 7,142,90,24,480,30.4,0.128,43,1 697 | 3,169,74,19,125,29.9,0.268,31,1 698 | 0,99,0,0,0,25.0,0.253,22,0 699 | 4,127,88,11,155,34.5,0.598,28,0 700 | 4,118,70,0,0,44.5,0.904,26,0 701 | 2,122,76,27,200,35.9,0.483,26,0 702 | 6,125,78,31,0,27.6,0.565,49,1 703 | 1,168,88,29,0,35.0,0.905,52,1 704 | 2,129,0,0,0,38.5,0.304,41,0 705 | 4,110,76,20,100,28.4,0.118,27,0 706 | 6,80,80,36,0,39.8,0.177,28,0 707 | 10,115,0,0,0,0.0,0.261,30,1 708 | 2,127,46,21,335,34.4,0.176,22,0 709 | 9,164,78,0,0,32.8,0.148,45,1 710 | 2,93,64,32,160,38.0,0.674,23,1 711 | 3,158,64,13,387,31.2,0.295,24,0 712 | 5,126,78,27,22,29.6,0.439,40,0 713 | 10,129,62,36,0,41.2,0.441,38,1 714 | 0,134,58,20,291,26.4,0.352,21,0 715 | 3,102,74,0,0,29.5,0.121,32,0 716 | 7,187,50,33,392,33.9,0.826,34,1 717 | 3,173,78,39,185,33.8,0.970,31,1 718 | 10,94,72,18,0,23.1,0.595,56,0 719 | 1,108,60,46,178,35.5,0.415,24,0 720 | 5,97,76,27,0,35.6,0.378,52,1 721 | 4,83,86,19,0,29.3,0.317,34,0 722 | 1,114,66,36,200,38.1,0.289,21,0 723 | 1,149,68,29,127,29.3,0.349,42,1 724 | 5,117,86,30,105,39.1,0.251,42,0 725 | 1,111,94,0,0,32.8,0.265,45,0 726 | 4,112,78,40,0,39.4,0.236,38,0 727 | 1,116,78,29,180,36.1,0.496,25,0 728 | 0,141,84,26,0,32.4,0.433,22,0 729 | 2,175,88,0,0,22.9,0.326,22,0 730 | 2,92,52,0,0,30.1,0.141,22,0 731 | 3,130,78,23,79,28.4,0.323,34,1 732 | 8,120,86,0,0,28.4,0.259,22,1 733 | 2,174,88,37,120,44.5,0.646,24,1 734 | 2,106,56,27,165,29.0,0.426,22,0 735 | 2,105,75,0,0,23.3,0.560,53,0 736 | 4,95,60,32,0,35.4,0.284,28,0 737 | 0,126,86,27,120,27.4,0.515,21,0 738 | 8,65,72,23,0,32.0,0.600,42,0 739 | 2,99,60,17,160,36.6,0.453,21,0 740 | 1,102,74,0,0,39.5,0.293,42,1 741 | 11,120,80,37,150,42.3,0.785,48,1 742 | 3,102,44,20,94,30.8,0.400,26,0 743 | 1,109,58,18,116,28.5,0.219,22,0 744 | 9,140,94,0,0,32.7,0.734,45,1 745 | 13,153,88,37,140,40.6,1.174,39,0 746 | 12,100,84,33,105,30.0,0.488,46,0 747 | 1,147,94,41,0,49.3,0.358,27,1 748 | 1,81,74,41,57,46.3,1.096,32,0 749 | 3,187,70,22,200,36.4,0.408,36,1 750 | 6,162,62,0,0,24.3,0.178,50,1 751 | 4,136,70,0,0,31.2,1.182,22,1 752 | 1,121,78,39,74,39.0,0.261,28,0 753 | 3,108,62,24,0,26.0,0.223,25,0 754 | 0,181,88,44,510,43.3,0.222,26,1 755 | 8,154,78,32,0,32.4,0.443,45,1 756 | 1,128,88,39,110,36.5,1.057,37,1 757 | 7,137,90,41,0,32.0,0.391,39,0 758 | 0,123,72,0,0,36.3,0.258,52,1 759 | 1,106,76,0,0,37.5,0.197,26,0 760 | 6,190,92,0,0,35.5,0.278,66,1 761 | 2,88,58,26,16,28.4,0.766,22,0 762 | 9,170,74,31,0,44.0,0.403,43,1 763 | 9,89,62,0,0,22.5,0.142,33,0 764 | 10,101,76,48,180,32.9,0.171,63,0 765 | 2,122,70,27,0,36.8,0.340,27,0 766 | 5,121,72,23,112,26.2,0.245,30,0 767 | 1,126,60,0,0,30.1,0.349,47,1 768 | 1,93,70,31,0,30.4,0.315,23,0 769 | -------------------------------------------------------------------------------- /Week 12- Linear Algebra in ML/추천시스템_svd.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Matrix Factorization\n", 10 | "\n", 11 | "## SVD를 이용한 유저와 아이템 추상화\n", 12 | "## 추상화된 아이템 간의 유사도 계산\n", 13 | "\n", 14 | "https://github.com/therocks/fc-rec-workshop/tree/master/movielens" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 2, 20 | "metadata": { 21 | "collapsed": true 22 | }, 23 | "outputs": [], 24 | "source": [ 25 | "import math\n", 26 | "import numpy as np\n", 27 | "from numpy import linalg as LA\n", 28 | "from scipy.sparse import coo_matrix\n", 29 | "from scipy.linalg import sqrtm\n", 30 | "import pandas as pd\n", 31 | "from IPython.display import HTML, display" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 3, 37 | "metadata": { 38 | "collapsed": true 39 | }, 40 | "outputs": [], 41 | "source": [ 42 | "np.set_printoptions(precision=2)\n", 43 | "pd.set_option('display.precision', 2)" 44 | ] 45 | }, 46 | { 47 | "cell_type": "markdown", 48 | "metadata": {}, 49 | "source": [ 50 | "## 영화평점 데이터 " 51 | ] 52 | }, 53 | { 54 | "cell_type": "code", 55 | "execution_count": 6, 56 | "metadata": {}, 57 | "outputs": [], 58 | "source": [ 59 | "movies = pd.read_csv('movies_w_imgurl.csv')" 60 | ] 61 | }, 62 | { 63 | "cell_type": "code", 64 | "execution_count": 7, 65 | "metadata": { 66 | "collapsed": true 67 | }, 68 | "outputs": [], 69 | "source": [ 70 | "def displayMovies(movieIds, ratings=[]):\n", 71 | " i = 0\n", 72 | " html = \"\"\n", 73 | " for movieId in movieIds:\n", 74 | " mov = movies[movies['movieId'] == movieId].iloc[0] \n", 75 | " html += \"
\"\n", 76 | " html += \"
\" % mov.imgurl\n", 77 | " if i < len(ratings):\n", 78 | " html += \"%.4f
\" % ratings[i]\n", 79 | " html += \"%s
\" % mov.title\n", 80 | " if mov.genres != '':\n", 81 | " ul = \"
    \"\n", 82 | " for genre in mov.genres.split('|'):\n", 83 | " ul += \"
  • %s
    • \" % genre\n", 84 | " ul += \"
\"\n", 85 | " html += \"%s
\" % ul\n", 86 | " html += \"
\"\n", 87 | " i += 1\n", 88 | " display(HTML(html))" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": 10, 94 | "metadata": {}, 95 | "outputs": [], 96 | "source": [ 97 | "ratings = pd.read_csv('ratings-9_1.csv')\n", 98 | "train = ratings[ratings['type'] == 'train'][['userId', 'movieId', 'rating']]\n", 99 | "test = ratings[ratings['type'] == 'test'][['userId', 'movieId', 'rating']]" 100 | ] 101 | }, 102 | { 103 | "cell_type": "code", 104 | "execution_count": 11, 105 | "metadata": { 106 | "collapsed": true 107 | }, 108 | "outputs": [], 109 | "source": [ 110 | "movieIdToIndex = {}\n", 111 | "indexToMovieId = {}\n", 112 | "colIdx = 0\n", 113 | "for movieId in movies.movieId:\n", 114 | " movieIdToIndex[movieId] = colIdx\n", 115 | " indexToMovieId[colIdx] = movieId\n", 116 | " colIdx += 1" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": 22, 122 | "metadata": { 123 | "collapsed": true 124 | }, 125 | "outputs": [], 126 | "source": [ 127 | "userIdToIndex = {}\n", 128 | "indexToUserId = {}\n", 129 | "rowIdx = 0\n", 130 | "for userId in ratings.userId.unique():\n", 131 | " userIdToIndex[userId] = rowIdx\n", 132 | " indexToUserId[rowIdx] = userId\n", 133 | " rowIdx += 1" 134 | ] 135 | }, 136 | { 137 | "cell_type": "code", 138 | "execution_count": 23, 139 | "metadata": { 140 | "collapsed": true 141 | }, 142 | "outputs": [], 143 | "source": [ 144 | "rows = []\n", 145 | "cols = []\n", 146 | "vals = []\n", 147 | "for row in ratings.itertuples():\n", 148 | " rows.append(userIdToIndex[row.userId])\n", 149 | " cols.append(movieIdToIndex[row.movieId])\n", 150 | " vals.append(row.rating)\n", 151 | "coomat = coo_matrix((vals, (rows, cols)), shape=(rowIdx, colIdx))" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": 24, 157 | "metadata": { 158 | "collapsed": true 159 | }, 160 | "outputs": [], 161 | "source": [ 162 | "U, s, V = LA.svd(coomat.toarray(), full_matrices=False)" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": 25, 168 | "metadata": { 169 | "collapsed": true 170 | }, 171 | "outputs": [], 172 | "source": [ 173 | "dim = 671\n", 174 | "sqrtS = sqrtm(np.matrix(np.diag(s[0:dim])))" 175 | ] 176 | }, 177 | { 178 | "cell_type": "code", 179 | "execution_count": 26, 180 | "metadata": { 181 | "collapsed": true 182 | }, 183 | "outputs": [], 184 | "source": [ 185 | "userFeatures = np.matmul(U.compress(np.ones(dim), axis=1), sqrtS)\n", 186 | "itemFeatures = np.matmul(V.T.compress(np.ones(dim), axis=1), sqrtS.T)" 187 | ] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": 27, 192 | "metadata": { 193 | "collapsed": true 194 | }, 195 | "outputs": [], 196 | "source": [ 197 | "itemNorms = LA.norm(itemFeatures, ord=2, axis=1)\n", 198 | "userNorms = LA.norm(userFeatures, ord=2, axis=1)\n" 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": 28, 204 | "metadata": {}, 205 | "outputs": [ 206 | { 207 | "name": "stderr", 208 | "output_type": "stream", 209 | "text": [ 210 | "/anaconda/lib/python3.6/site-packages/ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in true_divide\n", 211 | " \"\"\"Entry point for launching an IPython kernel.\n" 212 | ] 213 | } 214 | ], 215 | "source": [ 216 | "normalizedItemFeatures = np.divide(itemFeatures.T, itemNorms).T\n", 217 | "normalizedUserFeatures = np.divide(userFeatures.T, userNorms).T" 218 | ] 219 | }, 220 | { 221 | "cell_type": "code", 222 | "execution_count": 29, 223 | "metadata": { 224 | "collapsed": true 225 | }, 226 | "outputs": [], 227 | "source": [ 228 | "itemSims = pd.DataFrame(data=np.matmul(normalizedItemFeatures, normalizedItemFeatures.T), index=movies.movieId, columns=movies.movieId)\n", 229 | "userSims = np.matmul(normalizedUserFeatures, normalizedUserFeatures.T)" 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": 30, 235 | "metadata": {}, 236 | "outputs": [ 237 | { 238 | "data": { 239 | "text/html": [ 240 | "

GoldenEye (1995)
  • Action
  • Adventure
  • Thriller

" 241 | ], 242 | "text/plain": [ 243 | "" 244 | ] 245 | }, 246 | "metadata": {}, 247 | "output_type": "display_data" 248 | }, 249 | { 250 | "data": { 251 | "text/html": [ 252 | "

1.0000
GoldenEye (1995)
  • Action
  • Adventure
  • Thriller


0.2454
Die Hard: With a Vengeance (1995)
  • Action
  • Crime
  • Thriller


0.2421
Cliffhanger (1993)
  • Action
  • Adventure
  • Thriller


0.2403
Batman Forever (1995)
  • Action
  • Adventure
  • Comedy
  • Crime


0.2015
Tomorrow Never Dies (1997)
  • Action
  • Adventure
  • Thriller


0.1967
Clear and Present Danger (1994)
  • Action
  • Crime
  • Drama
  • Thriller

" 253 | ], 254 | "text/plain": [ 255 | "" 256 | ] 257 | }, 258 | "metadata": {}, 259 | "output_type": "display_data" 260 | } 261 | ], 262 | "source": [ 263 | "movieIdx = 9\n", 264 | "rels = itemSims.iloc[movieIdx,:].sort_values(ascending=False).head(6)\n", 265 | "displayMovies([indexToMovieId[movieIdx]])\n", 266 | "displayMovies(rels.index, rels.values)" 267 | ] 268 | }, 269 | { 270 | "cell_type": "code", 271 | "execution_count": null, 272 | "metadata": { 273 | "collapsed": true 274 | }, 275 | "outputs": [], 276 | "source": [] 277 | } 278 | ], 279 | "metadata": { 280 | "kernelspec": { 281 | "display_name": "Python 3", 282 | "language": "python", 283 | "name": "python3" 284 | }, 285 | "language_info": { 286 | "codemirror_mode": { 287 | "name": "ipython", 288 | "version": 3 289 | }, 290 | "file_extension": ".py", 291 | "mimetype": "text/x-python", 292 | "name": "python", 293 | "nbconvert_exporter": "python", 294 | "pygments_lexer": "ipython3", 295 | "version": "3.6.3" 296 | } 297 | }, 298 | "nbformat": 4, 299 | "nbformat_minor": 2 300 | } 301 | -------------------------------------------------------------------------------- /Week 12- Linear Algebra in ML/풀잎스쿨_LA_063018.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Ingenjoy/Linear-Algebra-with-python/48e9206b91998ba145155d5eb88848189d464036/Week 12- Linear Algebra in ML/풀잎스쿨_LA_063018.pdf -------------------------------------------------------------------------------- /Week 12- Linear Algebra in ML/풀잎스쿨_행렬분해_LA.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Ingenjoy/Linear-Algebra-with-python/48e9206b91998ba145155d5eb88848189d464036/Week 12- Linear Algebra in ML/풀잎스쿨_행렬분해_LA.pdf -------------------------------------------------------------------------------- /Week 4- Matrices for solving systems by elimination- Null space and column space/2_basic_linear system.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Linear system " 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Solve Ax=b using inverse of A" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 25, 20 | "metadata": {}, 21 | "outputs": [ 22 | { 23 | "name": "stdout", 24 | "output_type": "stream", 25 | "text": [ 26 | "[[ 60. 5.5 1. ]\n", 27 | " [ 65. 5. 0. ]\n", 28 | " [ 55. 6. 1. ]]\n", 29 | "[[66 70 78]]\n" 30 | ] 31 | } 32 | ], 33 | "source": [ 34 | "from numpy import array\n", 35 | "A=array([[60,5.5,1],[65,5.0,0],[55,6.0,1]])\n", 36 | "b=array([[66,70,78]])\n", 37 | "print(A)\n", 38 | "print(b)" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": 3, 44 | "metadata": {}, 45 | "outputs": [ 46 | { 47 | "name": "stdout", 48 | "output_type": "stream", 49 | "text": [ 50 | "[[ -0.43478261]\n", 51 | " [ 19.65217391]\n", 52 | " [-16. ]]\n" 53 | ] 54 | } 55 | ], 56 | "source": [ 57 | "from numpy.linalg import inv\n", 58 | "x=inv(A).dot(b.T)\n", 59 | "print(x)" 60 | ] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "metadata": {}, 65 | "source": [ 66 | "Solve Ax=b using 'solve'" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 4, 72 | "metadata": {}, 73 | "outputs": [ 74 | { 75 | "name": "stdout", 76 | "output_type": "stream", 77 | "text": [ 78 | "[[ -0.43478261]\n", 79 | " [ 19.65217391]\n", 80 | " [-16. ]]\n" 81 | ] 82 | } 83 | ], 84 | "source": [ 85 | "from numpy.linalg import solve\n", 86 | "x = solve(A,b.T)\n", 87 | "print(x)" 88 | ] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "Solve the $$\\begin{pmatrix}\n", 95 | "1&2\\\\\n", 96 | "3&4\n", 97 | "\\end{pmatrix} \\begin{pmatrix}\n", 98 | "x\\\\\n", 99 | "y\n", 100 | "\\end{pmatrix} =\\begin{pmatrix}\n", 101 | "-1\\\\\n", 102 | "1\n", 103 | "\\end{pmatrix}$$" 104 | ] 105 | }, 106 | { 107 | "cell_type": "markdown", 108 | "metadata": {}, 109 | "source": [ 110 | "$x=\\frac{4\\cdot -1-2\\cdot 1}{1\\cdot 4-2\\cdot 3}=\\frac{-6}{-2}=3$\n", 111 | "\n", 112 | "$y=\\frac{1\\cdot 1-3\\cdot -1}{1\\cdot 4-2\\cdot 3}=\\frac{4}{-2}=-2$\n" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": 5, 118 | "metadata": {}, 119 | "outputs": [ 120 | { 121 | "name": "stdout", 122 | "output_type": "stream", 123 | "text": [ 124 | "[[1 2]\n", 125 | " [3 4]]\n", 126 | "[[-1 1]]\n" 127 | ] 128 | } 129 | ], 130 | "source": [ 131 | "from numpy import array\n", 132 | "A=array([[1,2],[3,4]])\n", 133 | "b=array([[-1,1]])\n", 134 | "print(A)\n", 135 | "print(b)" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": 6, 141 | "metadata": {}, 142 | "outputs": [ 143 | { 144 | "name": "stdout", 145 | "output_type": "stream", 146 | "text": [ 147 | "[[ 3.]\n", 148 | " [-2.]]\n" 149 | ] 150 | } 151 | ], 152 | "source": [ 153 | "from numpy.linalg import inv\n", 154 | "x=inv(A).dot(b.T)\n", 155 | "print(x)" 156 | ] 157 | }, 158 | { 159 | "cell_type": "markdown", 160 | "metadata": {}, 161 | "source": [ 162 | "## Type of Matrices" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": 8, 168 | "metadata": {}, 169 | "outputs": [ 170 | { 171 | "name": "stdout", 172 | "output_type": "stream", 173 | "text": [ 174 | "Rows: 3\n", 175 | "Cols: 2\n" 176 | ] 177 | } 178 | ], 179 | "source": [ 180 | "from numpy import array\n", 181 | "# list of data\n", 182 | "data = [[11, 22],[33, 44],[55, 66]]\n", 183 | "# array of data\n", 184 | "data = array(data)\n", 185 | "print('Rows: %d' % data.shape[0])\n", 186 | "print('Cols: %d' % data.shape[1])" 187 | ] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": 9, 192 | "metadata": {}, 193 | "outputs": [ 194 | { 195 | "name": "stdout", 196 | "output_type": "stream", 197 | "text": [ 198 | "[[1 2 3]\n", 199 | " [1 2 3]\n", 200 | " [1 2 3]]\n", 201 | "[[1 0 0]\n", 202 | " [1 2 0]\n", 203 | " [1 2 3]]\n", 204 | "[[1 2 3]\n", 205 | " [0 2 3]\n", 206 | " [0 0 3]]\n" 207 | ] 208 | } 209 | ], 210 | "source": [ 211 | "# triangular matrices\n", 212 | "from numpy import array\n", 213 | "from numpy import tril\n", 214 | "from numpy import triu\n", 215 | "# define square matrix\n", 216 | "M = array([\n", 217 | "[1, 2, 3],\n", 218 | "[1, 2, 3],\n", 219 | "[1, 2, 3]])\n", 220 | "print(M)\n", 221 | "# lower triangular matrix\n", 222 | "lower = tril(M)\n", 223 | "print(lower)\n", 224 | "# upper triangular matrix\n", 225 | "upper = triu(M)\n", 226 | "print(upper)" 227 | ] 228 | }, 229 | { 230 | "cell_type": "code", 231 | "execution_count": 10, 232 | "metadata": {}, 233 | "outputs": [ 234 | { 235 | "name": "stdout", 236 | "output_type": "stream", 237 | "text": [ 238 | "[[1 2 3]\n", 239 | " [1 2 3]\n", 240 | " [1 2 3]]\n", 241 | "[1 2 3]\n", 242 | "[[1 0 0]\n", 243 | " [0 2 0]\n", 244 | " [0 0 3]]\n" 245 | ] 246 | } 247 | ], 248 | "source": [ 249 | "# diagonal matrix\n", 250 | "from numpy import array\n", 251 | "from numpy import diag\n", 252 | "# define square matrix\n", 253 | "M = array([\n", 254 | "[1, 2, 3],\n", 255 | "[1, 2, 3],\n", 256 | "[1, 2, 3]])\n", 257 | "print(M)\n", 258 | "# extract diagonal vector\n", 259 | "d = diag(M)\n", 260 | "print(d)\n", 261 | "# create diagonal matrix from vector\n", 262 | "D = diag(d)\n", 263 | "print(D)" 264 | ] 265 | }, 266 | { 267 | "cell_type": "code", 268 | "execution_count": 11, 269 | "metadata": {}, 270 | "outputs": [ 271 | { 272 | "name": "stdout", 273 | "output_type": "stream", 274 | "text": [ 275 | "[[ 1. 0. 0.]\n", 276 | " [ 0. 1. 0.]\n", 277 | " [ 0. 0. 1.]]\n" 278 | ] 279 | } 280 | ], 281 | "source": [ 282 | "from numpy import identity\n", 283 | "I = identity(3)\n", 284 | "print(I)" 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": 12, 290 | "metadata": {}, 291 | "outputs": [ 292 | { 293 | "name": "stdout", 294 | "output_type": "stream", 295 | "text": [ 296 | "[[ 1 0]\n", 297 | " [ 0 -1]]\n", 298 | "[[ 1 0]\n", 299 | " [ 0 -1]]\n", 300 | "[[ 1. 0.]\n", 301 | " [-0. -1.]]\n", 302 | "[[1 0]\n", 303 | " [0 1]]\n" 304 | ] 305 | } 306 | ], 307 | "source": [ 308 | "# orthogonal matrix\n", 309 | "from numpy import array\n", 310 | "from numpy.linalg import inv\n", 311 | "# define orthogonal matrix\n", 312 | "Q = array([\n", 313 | "[1, 0],\n", 314 | "[0, -1]])\n", 315 | "print(Q)\n", 316 | "# inverse equivalence\n", 317 | "V = inv(Q)\n", 318 | "print(Q.T)\n", 319 | "print(V)\n", 320 | "# identity equivalence\n", 321 | "I = Q.dot(Q.T)\n", 322 | "print(I)" 323 | ] 324 | }, 325 | { 326 | "cell_type": "markdown", 327 | "metadata": {}, 328 | "source": [ 329 | "## Matrix operations" 330 | ] 331 | }, 332 | { 333 | "cell_type": "code", 334 | "execution_count": 13, 335 | "metadata": {}, 336 | "outputs": [ 337 | { 338 | "name": "stdout", 339 | "output_type": "stream", 340 | "text": [ 341 | "[[1 2 3]\n", 342 | " [4 5 6]\n", 343 | " [7 8 9]]\n", 344 | "15\n" 345 | ] 346 | } 347 | ], 348 | "source": [ 349 | "# matrix trace\n", 350 | "from numpy import array\n", 351 | "from numpy import trace\n", 352 | "# define matrix\n", 353 | "A = array([\n", 354 | "[1, 2, 3],\n", 355 | "[4, 5, 6],\n", 356 | "[7, 8, 9]])\n", 357 | "print(A)\n", 358 | "# calculate trace\n", 359 | "B = trace(A)\n", 360 | "print(B)" 361 | ] 362 | }, 363 | { 364 | "cell_type": "code", 365 | "execution_count": 14, 366 | "metadata": {}, 367 | "outputs": [ 368 | { 369 | "name": "stdout", 370 | "output_type": "stream", 371 | "text": [ 372 | "[[1 2 3]\n", 373 | " [4 5 6]\n", 374 | " [7 8 9]]\n", 375 | "-9.51619735393e-16\n" 376 | ] 377 | } 378 | ], 379 | "source": [ 380 | "# matrix determinant\n", 381 | "from numpy import array\n", 382 | "from numpy.linalg import det\n", 383 | "# define matrix\n", 384 | "A = array([\n", 385 | "[1, 2, 3],\n", 386 | "[4, 5, 6],\n", 387 | "[7, 8, 9]])\n", 388 | "print(A)\n", 389 | "# calculate determinant\n", 390 | "B = det(A)\n", 391 | "print(B)" 392 | ] 393 | }, 394 | { 395 | "cell_type": "code", 396 | "execution_count": null, 397 | "metadata": { 398 | "collapsed": true 399 | }, 400 | "outputs": [], 401 | "source": [ 402 | "# vector rank\n", 403 | "from numpy import array\n", 404 | "from numpy.linalg import matrix_rank\n", 405 | "# rank\n", 406 | "v1 = array([1,2,3])\n", 407 | "print(v1)\n", 408 | "vr1 = matrix_rank(v1)\n", 409 | "print(vr1)\n", 410 | "# zero rank\n", 411 | "v2 = array([0,0,0,0,0])\n", 412 | "print(v2)\n", 413 | "vr2 = matrix_rank(v2)\n", 414 | "print(vr2)" 415 | ] 416 | }, 417 | { 418 | "cell_type": "code", 419 | "execution_count": 17, 420 | "metadata": {}, 421 | "outputs": [ 422 | { 423 | "name": "stdout", 424 | "output_type": "stream", 425 | "text": [ 426 | "[[0 0]\n", 427 | " [0 0]]\n", 428 | "0\n", 429 | "[[1 2]\n", 430 | " [1 2]]\n", 431 | "1\n", 432 | "[[1 2]\n", 433 | " [3 4]]\n", 434 | "2\n" 435 | ] 436 | } 437 | ], 438 | "source": [ 439 | "# matrix rank\n", 440 | "from numpy import array\n", 441 | "from numpy.linalg import matrix_rank\n", 442 | "# rank 0\n", 443 | "M0 = array([\n", 444 | "[0,0],\n", 445 | "[0,0]])\n", 446 | "print(M0)\n", 447 | "mr0 = matrix_rank(M0)\n", 448 | "print(mr0)\n", 449 | "# rank 1\n", 450 | "M1 = array([\n", 451 | "[1,2],\n", 452 | "[1,2]])\n", 453 | "print(M1)\n", 454 | "mr1 = matrix_rank(M1)\n", 455 | "print(mr1)\n", 456 | "# rank 2\n", 457 | "M2 = array([\n", 458 | "[1,2],\n", 459 | "[3,4]])\n", 460 | "print(M2)\n", 461 | "mr2 = matrix_rank(M2)\n", 462 | "print(mr2)" 463 | ] 464 | }, 465 | { 466 | "cell_type": "code", 467 | "execution_count": 18, 468 | "metadata": {}, 469 | "outputs": [ 470 | { 471 | "name": "stdout", 472 | "output_type": "stream", 473 | "text": [ 474 | "[[1 0 0 1 0 0]\n", 475 | " [0 0 2 0 0 1]\n", 476 | " [0 0 0 2 0 0]]\n", 477 | " (0, 0)\t1\n", 478 | " (0, 3)\t1\n", 479 | " (1, 2)\t2\n", 480 | " (1, 5)\t1\n", 481 | " (2, 3)\t2\n", 482 | "[[1 0 0 1 0 0]\n", 483 | " [0 0 2 0 0 1]\n", 484 | " [0 0 0 2 0 0]]\n" 485 | ] 486 | } 487 | ], 488 | "source": [ 489 | "# sparse matrix\n", 490 | "from numpy import array\n", 491 | "from scipy.sparse import csr_matrix\n", 492 | "# create dense matrix\n", 493 | "A = array([\n", 494 | "[1, 0, 0, 1, 0, 0],\n", 495 | "[0, 0, 2, 0, 0, 1],\n", 496 | "[0, 0, 0, 2, 0, 0]])\n", 497 | "print(A)\n", 498 | "# convert to sparse matrix (CSR method)\n", 499 | "S = csr_matrix(A)\n", 500 | "print(S)\n", 501 | "# reconstruct dense matrix\n", 502 | "B = S.todense()\n", 503 | "print(B)" 504 | ] 505 | }, 506 | { 507 | "cell_type": "code", 508 | "execution_count": 19, 509 | "metadata": {}, 510 | "outputs": [ 511 | { 512 | "name": "stdout", 513 | "output_type": "stream", 514 | "text": [ 515 | "[[1 0 0 1 0 0]\n", 516 | " [0 0 2 0 0 1]\n", 517 | " [0 0 0 2 0 0]]\n", 518 | "0.7222222222222222\n" 519 | ] 520 | } 521 | ], 522 | "source": [ 523 | "# sparsity calculation\n", 524 | "from numpy import array\n", 525 | "from numpy import count_nonzero\n", 526 | "# create dense matrix\n", 527 | "A = array([\n", 528 | "[1, 0, 0, 1, 0, 0],\n", 529 | "[0, 0, 2, 0, 0, 1],\n", 530 | "[0, 0, 0, 2, 0, 0]])\n", 531 | "print(A)\n", 532 | "# calculate sparsity\n", 533 | "sparsity = 1.0 - count_nonzero(A) / A.size\n", 534 | "print(sparsity)" 535 | ] 536 | }, 537 | { 538 | "cell_type": "code", 539 | "execution_count": 20, 540 | "metadata": {}, 541 | "outputs": [ 542 | { 543 | "name": "stdout", 544 | "output_type": "stream", 545 | "text": [ 546 | "(3, 3, 3)\n", 547 | "[[[ 1 2 3]\n", 548 | " [ 4 5 6]\n", 549 | " [ 7 8 9]]\n", 550 | "\n", 551 | " [[11 12 13]\n", 552 | " [14 15 16]\n", 553 | " [17 18 19]]\n", 554 | "\n", 555 | " [[21 22 23]\n", 556 | " [24 25 26]\n", 557 | " [27 28 29]]]\n" 558 | ] 559 | } 560 | ], 561 | "source": [ 562 | "# create tensor\n", 563 | "from numpy import array\n", 564 | "T = array([\n", 565 | "[[1,2,3], [4,5,6], [7,8,9]],\n", 566 | "[[11,12,13], [14,15,16], [17,18,19]],\n", 567 | "[[21,22,23], [24,25,26], [27,28,29]]])\n", 568 | "print(T.shape)\n", 569 | "print(T)" 570 | ] 571 | }, 572 | { 573 | "cell_type": "code", 574 | "execution_count": 21, 575 | "metadata": {}, 576 | "outputs": [ 577 | { 578 | "name": "stdout", 579 | "output_type": "stream", 580 | "text": [ 581 | "[[[ 2 4 6]\n", 582 | " [ 8 10 12]\n", 583 | " [14 16 18]]\n", 584 | "\n", 585 | " [[22 24 26]\n", 586 | " [28 30 32]\n", 587 | " [34 36 38]]\n", 588 | "\n", 589 | " [[42 44 46]\n", 590 | " [48 50 52]\n", 591 | " [54 56 58]]]\n" 592 | ] 593 | } 594 | ], 595 | "source": [ 596 | "# tensor addition\n", 597 | "from numpy import array\n", 598 | "# define first tensor\n", 599 | "A = array([\n", 600 | "[[1,2,3], [4,5,6], [7,8,9]],\n", 601 | "[[11,12,13], [14,15,16], [17,18,19]],\n", 602 | "[[21,22,23], [24,25,26], [27,28,29]]])\n", 603 | "# define second tensor\n", 604 | "B = array([\n", 605 | "[[1,2,3], [4,5,6], [7,8,9]],\n", 606 | "[[11,12,13], [14,15,16], [17,18,19]],\n", 607 | "[[21,22,23], [24,25,26], [27,28,29]]])\n", 608 | "# add tensors\n", 609 | "C = A + B\n", 610 | "print(C)" 611 | ] 612 | }, 613 | { 614 | "cell_type": "markdown", 615 | "metadata": {}, 616 | "source": [ 617 | "$$\\begin{pmatrix}\n", 618 | "1&2\\\\\n", 619 | "\\end{pmatrix} \\otimes \\begin{pmatrix}\n", 620 | "3&4\n", 621 | "\\end{pmatrix} =\\begin{pmatrix}\n", 622 | "3&4\\\\\n", 623 | "6&8\n", 624 | "\\end{pmatrix}$$" 625 | ] 626 | }, 627 | { 628 | "cell_type": "code", 629 | "execution_count": 22, 630 | "metadata": {}, 631 | "outputs": [ 632 | { 633 | "name": "stdout", 634 | "output_type": "stream", 635 | "text": [ 636 | "[[3 4]\n", 637 | " [6 8]]\n" 638 | ] 639 | } 640 | ], 641 | "source": [ 642 | "# tensor product\n", 643 | "from numpy import array\n", 644 | "from numpy import tensordot\n", 645 | "# define first vector\n", 646 | "A = array([1,2])\n", 647 | "# define second vector\n", 648 | "B = array([3,4])\n", 649 | "# calculate tensor product\n", 650 | "C = tensordot(A, B, axes=0)\n", 651 | "print(C)" 652 | ] 653 | }, 654 | { 655 | "cell_type": "markdown", 656 | "metadata": { 657 | "collapsed": true 658 | }, 659 | "source": [ 660 | "## Gram-Schmidt Process" 661 | ] 662 | }, 663 | { 664 | "cell_type": "code", 665 | "execution_count": 39, 666 | "metadata": {}, 667 | "outputs": [ 668 | { 669 | "name": "stdout", 670 | "output_type": "stream", 671 | "text": [ 672 | "x1= [3 6 0]\n", 673 | "y2= [1 2 2]\n" 674 | ] 675 | }, 676 | { 677 | "data": { 678 | "text/plain": [ 679 | "15" 680 | ] 681 | }, 682 | "execution_count": 39, 683 | "metadata": {}, 684 | "output_type": "execute_result" 685 | } 686 | ], 687 | "source": [ 688 | "from numpy import array\n", 689 | "x1=array([3,6,0])\n", 690 | "y2=array([1,2,2])\n", 691 | "print('x1=',x1)\n", 692 | "print('y2=',y2)\n", 693 | "y2.dot(x1)" 694 | ] 695 | }, 696 | { 697 | "cell_type": "code", 698 | "execution_count": 43, 699 | "metadata": {}, 700 | "outputs": [ 701 | { 702 | "name": "stdout", 703 | "output_type": "stream", 704 | "text": [ 705 | "15\n", 706 | "[ 0. 0. 2.]\n" 707 | ] 708 | } 709 | ], 710 | "source": [ 711 | "from numpy import array\n", 712 | "x1=array([3,6,0])\n", 713 | "y2=array([1,2,2])\n", 714 | "a1=y2.dot(x1)\n", 715 | "aa=x1.dot(x1)\n", 716 | "x2=y2-(a1/aa)*x1\n", 717 | "print(x2)" 718 | ] 719 | }, 720 | { 721 | "cell_type": "code", 722 | "execution_count": 44, 723 | "metadata": {}, 724 | "outputs": [ 725 | { 726 | "data": { 727 | "text/plain": [ 728 | "0.0" 729 | ] 730 | }, 731 | "execution_count": 44, 732 | "metadata": {}, 733 | "output_type": "execute_result" 734 | } 735 | ], 736 | "source": [ 737 | "x1.dot(x2)" 738 | ] 739 | }, 740 | { 741 | "cell_type": "code", 742 | "execution_count": null, 743 | "metadata": { 744 | "collapsed": true 745 | }, 746 | "outputs": [], 747 | "source": [] 748 | } 749 | ], 750 | "metadata": { 751 | "kernelspec": { 752 | "display_name": "Python 3", 753 | "language": "python", 754 | "name": "python3" 755 | }, 756 | "language_info": { 757 | "codemirror_mode": { 758 | "name": "ipython", 759 | "version": 3 760 | }, 761 | "file_extension": ".py", 762 | "mimetype": "text/x-python", 763 | "name": "python", 764 | "nbconvert_exporter": "python", 765 | "pygments_lexer": "ipython3", 766 | "version": "3.6.3" 767 | } 768 | }, 769 | "nbformat": 4, 770 | "nbformat_minor": 2 771 | } 772 | -------------------------------------------------------------------------------- /Week 4- Matrices for solving systems by elimination- Null space and column space/Matrices+for+solving+system.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Linear system " 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Solve Ax=b using inverse of A" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 8, 20 | "metadata": {}, 21 | "outputs": [ 22 | { 23 | "name": "stdout", 24 | "output_type": "stream", 25 | "text": [ 26 | "[[ 60. 5.5 1. ]\n", 27 | " [ 65. 5. 0. ]\n", 28 | " [ 55. 6. 1. ]]\n", 29 | "[[66 70 78]]\n" 30 | ] 31 | } 32 | ], 33 | "source": [ 34 | "from numpy import array\n", 35 | "A=array([[60,5.5,1],[65,5.0,0],[55,6.0,1]])\n", 36 | "b=array([[66,70,78]])\n", 37 | "print(A)\n", 38 | "print(b)" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": 10, 44 | "metadata": {}, 45 | "outputs": [ 46 | { 47 | "name": "stdout", 48 | "output_type": "stream", 49 | "text": [ 50 | "[[ -0.43478261]\n", 51 | " [ 19.65217391]\n", 52 | " [-16. ]]\n" 53 | ] 54 | } 55 | ], 56 | "source": [ 57 | "from numpy.linalg import inv\n", 58 | "x=inv(A).dot(b.T)\n", 59 | "print(x)" 60 | ] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "metadata": {}, 65 | "source": [ 66 | "Solve Ax=b using 'solve'" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 12, 72 | "metadata": {}, 73 | "outputs": [ 74 | { 75 | "name": "stdout", 76 | "output_type": "stream", 77 | "text": [ 78 | "[[ -0.43478261]\n", 79 | " [ 19.65217391]\n", 80 | " [-16. ]]\n" 81 | ] 82 | } 83 | ], 84 | "source": [ 85 | "from numpy.linalg import solve\n", 86 | "x = solve(A,b.T)\n", 87 | "print(x)" 88 | ] 89 | } 90 | ], 91 | "metadata": { 92 | "kernelspec": { 93 | "display_name": "Python 3", 94 | "language": "python", 95 | "name": "python3" 96 | }, 97 | "language_info": { 98 | "codemirror_mode": { 99 | "name": "ipython", 100 | "version": 3 101 | }, 102 | "file_extension": ".py", 103 | "mimetype": "text/x-python", 104 | "name": "python", 105 | "nbconvert_exporter": "python", 106 | "pygments_lexer": "ipython3", 107 | "version": "3.6.3" 108 | } 109 | }, 110 | "nbformat": 4, 111 | "nbformat_minor": 2 112 | } 113 | -------------------------------------------------------------------------------- /Week 4- Matrices for solving systems by elimination- Null space and column space/marrix_linear algebra with python3.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Matrices\n", 8 | "\n", 9 | "1. Find the product. Let $$A=\\begin{pmatrix}\n", 10 | "3&1\\\\\n", 11 | "2&1\n", 12 | "\\end{pmatrix}, \\ \\ B^T =\\begin{pmatrix}\n", 13 | "1&4\\\\\n", 14 | "2&5\\\\\n", 15 | "-1&3\n", 16 | "\\end{pmatrix}$$" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 12, 22 | "metadata": {}, 23 | "outputs": [ 24 | { 25 | "name": "stdout", 26 | "output_type": "stream", 27 | "text": [ 28 | "[[3 1]\n", 29 | " [2 1]]\n" 30 | ] 31 | }, 32 | { 33 | "data": { 34 | "text/plain": [ 35 | "(2, 2)" 36 | ] 37 | }, 38 | "execution_count": 12, 39 | "metadata": {}, 40 | "output_type": "execute_result" 41 | } 42 | ], 43 | "source": [ 44 | "#create matrix\n", 45 | "from numpy import array\n", 46 | "A=array([[3,1],[2,1]])\n", 47 | "print(A)\n", 48 | "A.shape" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": 20, 54 | "metadata": {}, 55 | "outputs": [ 56 | { 57 | "name": "stdout", 58 | "output_type": "stream", 59 | "text": [ 60 | "[[ 1 4]\n", 61 | " [ 2 5]\n", 62 | " [-1 3]]\n" 63 | ] 64 | }, 65 | { 66 | "data": { 67 | "text/plain": [ 68 | "(3, 2)" 69 | ] 70 | }, 71 | "execution_count": 20, 72 | "metadata": {}, 73 | "output_type": "execute_result" 74 | } 75 | ], 76 | "source": [ 77 | "from numpy import array\n", 78 | "B1=array([[1,4],[2,5],[-1,3]])\n", 79 | "print(B1)\n", 80 | "B1.shape" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": 21, 86 | "metadata": {}, 87 | "outputs": [ 88 | { 89 | "name": "stdout", 90 | "output_type": "stream", 91 | "text": [ 92 | "[[ 1 2 -1]\n", 93 | " [ 4 5 3]]\n" 94 | ] 95 | }, 96 | { 97 | "data": { 98 | "text/plain": [ 99 | "(2, 3)" 100 | ] 101 | }, 102 | "execution_count": 21, 103 | "metadata": {}, 104 | "output_type": "execute_result" 105 | } 106 | ], 107 | "source": [ 108 | "#transpose\n", 109 | "B=B1.T\n", 110 | "print(B)\n", 111 | "B.shape" 112 | ] 113 | }, 114 | { 115 | "cell_type": "markdown", 116 | "metadata": {}, 117 | "source": [ 118 | "1. $A^2$" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": 15, 124 | "metadata": {}, 125 | "outputs": [ 126 | { 127 | "name": "stdout", 128 | "output_type": "stream", 129 | "text": [ 130 | "[[11 4]\n", 131 | " [ 8 3]]\n" 132 | ] 133 | } 134 | ], 135 | "source": [ 136 | "#Multiply matrices \n", 137 | "C=A.dot(A)\n", 138 | "print(C)" 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": 16, 144 | "metadata": {}, 145 | "outputs": [ 146 | { 147 | "name": "stdout", 148 | "output_type": "stream", 149 | "text": [ 150 | "[[11 4]\n", 151 | " [ 8 3]]\n" 152 | ] 153 | } 154 | ], 155 | "source": [ 156 | "#Multiply mtrices with @operator\n", 157 | "D= A @ A\n", 158 | "print(D)" 159 | ] 160 | }, 161 | { 162 | "cell_type": "markdown", 163 | "metadata": {}, 164 | "source": [ 165 | "$2. \\ A^T B$\n" 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": 26, 171 | "metadata": {}, 172 | "outputs": [ 173 | { 174 | "name": "stdout", 175 | "output_type": "stream", 176 | "text": [ 177 | "[[11 16 3]\n", 178 | " [ 5 7 2]]\n" 179 | ] 180 | } 181 | ], 182 | "source": [ 183 | "A1=(A.T).dot(B)\n", 184 | "print(A1)" 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": 27, 190 | "metadata": {}, 191 | "outputs": [ 192 | { 193 | "data": { 194 | "text/plain": [ 195 | "array([[11, 16, 3],\n", 196 | " [ 5, 7, 2]])" 197 | ] 198 | }, 199 | "execution_count": 27, 200 | "metadata": {}, 201 | "output_type": "execute_result" 202 | } 203 | ], 204 | "source": [ 205 | "(A.T)@B" 206 | ] 207 | }, 208 | { 209 | "cell_type": "markdown", 210 | "metadata": {}, 211 | "source": [ 212 | "$3. \\ A^T$" 213 | ] 214 | }, 215 | { 216 | "cell_type": "code", 217 | "execution_count": 37, 218 | "metadata": {}, 219 | "outputs": [ 220 | { 221 | "name": "stdout", 222 | "output_type": "stream", 223 | "text": [ 224 | "[[3 2]\n", 225 | " [1 1]]\n" 226 | ] 227 | } 228 | ], 229 | "source": [ 230 | "F = A.T\n", 231 | "print(F)" 232 | ] 233 | }, 234 | { 235 | "cell_type": "markdown", 236 | "metadata": {}, 237 | "source": [ 238 | "$4. (A^T B)^{-1}$" 239 | ] 240 | }, 241 | { 242 | "cell_type": "code", 243 | "execution_count": 39, 244 | "metadata": {}, 245 | "outputs": [ 246 | { 247 | "ename": "LinAlgError", 248 | "evalue": "Last 2 dimensions of the array must be square", 249 | "output_type": "error", 250 | "traceback": [ 251 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 252 | "\u001b[0;31mLinAlgError\u001b[0m Traceback (most recent call last)", 253 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0marray\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mnumpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0minv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0minv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mF\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mB\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 254 | "\u001b[0;32m/anaconda/envs/tensorflow/lib/python3.6/site-packages/numpy/linalg/linalg.py\u001b[0m in \u001b[0;36minv\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m 515\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwrap\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_makearray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 516\u001b[0m \u001b[0m_assertRankAtLeast2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 517\u001b[0;31m \u001b[0m_assertNdSquareness\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 518\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult_t\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_commonType\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 519\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", 255 | "\u001b[0;32m/anaconda/envs/tensorflow/lib/python3.6/site-packages/numpy/linalg/linalg.py\u001b[0m in \u001b[0;36m_assertNdSquareness\u001b[0;34m(*arrays)\u001b[0m\n\u001b[1;32m 210\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0marrays\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 211\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 212\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mLinAlgError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Last 2 dimensions of the array must be square'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 213\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 214\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_assertFinite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0marrays\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", 256 | "\u001b[0;31mLinAlgError\u001b[0m: Last 2 dimensions of the array must be square" 257 | ] 258 | } 259 | ], 260 | "source": [ 261 | "from numpy import array\n", 262 | "from numpy.linalg import inv\n", 263 | "inv(F.dot(B))" 264 | ] 265 | }, 266 | { 267 | "cell_type": "markdown", 268 | "metadata": {}, 269 | "source": [ 270 | "$5. A^{-1}$" 271 | ] 272 | }, 273 | { 274 | "cell_type": "code", 275 | "execution_count": 41, 276 | "metadata": {}, 277 | "outputs": [ 278 | { 279 | "data": { 280 | "text/plain": [ 281 | "array([[ 1., -1.],\n", 282 | " [-2., 3.]])" 283 | ] 284 | }, 285 | "execution_count": 41, 286 | "metadata": {}, 287 | "output_type": "execute_result" 288 | } 289 | ], 290 | "source": [ 291 | "inv(A)" 292 | ] 293 | }, 294 | { 295 | "cell_type": "markdown", 296 | "metadata": {}, 297 | "source": [ 298 | "$6. \\ (BB^T )^{-1}$" 299 | ] 300 | }, 301 | { 302 | "cell_type": "code", 303 | "execution_count": 42, 304 | "metadata": {}, 305 | "outputs": [ 306 | { 307 | "data": { 308 | "text/plain": [ 309 | "array([[ 0.27932961, -0.06145251],\n", 310 | " [-0.06145251, 0.03351955]])" 311 | ] 312 | }, 313 | "execution_count": 42, 314 | "metadata": {}, 315 | "output_type": "execute_result" 316 | } 317 | ], 318 | "source": [ 319 | "inv(B@(B.T))" 320 | ] 321 | }, 322 | { 323 | "cell_type": "code", 324 | "execution_count": 43, 325 | "metadata": {}, 326 | "outputs": [ 327 | { 328 | "data": { 329 | "text/plain": [ 330 | "array([[ 1, 4],\n", 331 | " [ 2, 5],\n", 332 | " [-1, 3]])" 333 | ] 334 | }, 335 | "execution_count": 43, 336 | "metadata": {}, 337 | "output_type": "execute_result" 338 | } 339 | ], 340 | "source": [ 341 | "B.T" 342 | ] 343 | }, 344 | { 345 | "cell_type": "code", 346 | "execution_count": 44, 347 | "metadata": {}, 348 | "outputs": [ 349 | { 350 | "data": { 351 | "text/plain": [ 352 | "array([[ 6, 11],\n", 353 | " [11, 50]])" 354 | ] 355 | }, 356 | "execution_count": 44, 357 | "metadata": {}, 358 | "output_type": "execute_result" 359 | } 360 | ], 361 | "source": [ 362 | "B@(B.T)" 363 | ] 364 | }, 365 | { 366 | "cell_type": "markdown", 367 | "metadata": {}, 368 | "source": [ 369 | "$7.$ Consider a linear tranformation $T: \\ R^2 \\rightarrow R^3$, $T(x)=Ax$. \n", 370 | "\n", 371 | "\n", 372 | "Let $A=\\begin{pmatrix}\n", 373 | "1 & 0 &3 \\\\\n", 374 | "4 & 5 &-1 \\\\\n", 375 | "0 & 0 &2 \\end{pmatrix}$, For $x=\\begin{pmatrix} 1\\\\2\\\\5 \\end{pmatrix}$. Compute $T(x)$." 376 | ] 377 | }, 378 | { 379 | "cell_type": "code", 380 | "execution_count": 46, 381 | "metadata": {}, 382 | "outputs": [ 383 | { 384 | "name": "stdout", 385 | "output_type": "stream", 386 | "text": [ 387 | "[[ 1 0 3]\n", 388 | " [ 4 5 -1]\n", 389 | " [ 0 0 2]]\n" 390 | ] 391 | } 392 | ], 393 | "source": [ 394 | "AA=array([[1,0,3],[4,5,-1],[0,0,2]])\n", 395 | "print(AA)" 396 | ] 397 | }, 398 | { 399 | "cell_type": "code", 400 | "execution_count": 48, 401 | "metadata": {}, 402 | "outputs": [ 403 | { 404 | "name": "stdout", 405 | "output_type": "stream", 406 | "text": [ 407 | "[[1]\n", 408 | " [2]\n", 409 | " [5]]\n" 410 | ] 411 | } 412 | ], 413 | "source": [ 414 | "X=array([[1],[2],[5]])\n", 415 | "print(X)" 416 | ] 417 | }, 418 | { 419 | "cell_type": "code", 420 | "execution_count": 49, 421 | "metadata": {}, 422 | "outputs": [ 423 | { 424 | "data": { 425 | "text/plain": [ 426 | "array([[16],\n", 427 | " [ 9],\n", 428 | " [10]])" 429 | ] 430 | }, 431 | "execution_count": 49, 432 | "metadata": {}, 433 | "output_type": "execute_result" 434 | } 435 | ], 436 | "source": [ 437 | "AA@X" 438 | ] 439 | } 440 | ], 441 | "metadata": { 442 | "kernelspec": { 443 | "display_name": "Python 3", 444 | "language": "python", 445 | "name": "python3" 446 | }, 447 | "language_info": { 448 | "codemirror_mode": { 449 | "name": "ipython", 450 | "version": 3 451 | }, 452 | "file_extension": ".py", 453 | "mimetype": "text/x-python", 454 | "name": "python", 455 | "nbconvert_exporter": "python", 456 | "pygments_lexer": "ipython3", 457 | "version": "3.6.4" 458 | } 459 | }, 460 | "nbformat": 4, 461 | "nbformat_minor": 2 462 | } 463 | -------------------------------------------------------------------------------- /Week 4- Matrices for solving systems by elimination- Null space and column space/matrix: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /Week 8- Transpose of a matrix/marrix_transpose.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Matrices and linear transformation\n", 8 | "\n", 9 | "1. Find the product. Let $$A=\\begin{pmatrix}\n", 10 | "3&1\\\\\n", 11 | "2&1\n", 12 | "\\end{pmatrix}, \\ \\ B^T =\\begin{pmatrix}\n", 13 | "1&4\\\\\n", 14 | "2&5\\\\\n", 15 | "-1&3\n", 16 | "\\end{pmatrix}$$" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": {}, 23 | "outputs": [ 24 | { 25 | "name": "stdout", 26 | "output_type": "stream", 27 | "text": [ 28 | "[[3 1]\n", 29 | " [2 1]]\n" 30 | ] 31 | }, 32 | { 33 | "data": { 34 | "text/plain": [ 35 | "(2, 2)" 36 | ] 37 | }, 38 | "execution_count": 1, 39 | "metadata": {}, 40 | "output_type": "execute_result" 41 | } 42 | ], 43 | "source": [ 44 | "#create matrix\n", 45 | "from numpy import array\n", 46 | "\n", 47 | "A=array([[3,1],[2,1]])\n", 48 | "print(A)\n", 49 | "A.shape" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 2, 55 | "metadata": {}, 56 | "outputs": [ 57 | { 58 | "name": "stdout", 59 | "output_type": "stream", 60 | "text": [ 61 | "[[ 1 4]\n", 62 | " [ 2 5]\n", 63 | " [-1 3]]\n" 64 | ] 65 | }, 66 | { 67 | "data": { 68 | "text/plain": [ 69 | "(3, 2)" 70 | ] 71 | }, 72 | "execution_count": 2, 73 | "metadata": {}, 74 | "output_type": "execute_result" 75 | } 76 | ], 77 | "source": [ 78 | "from numpy import array\n", 79 | "B1=array([[1,4],[2,5],[-1,3]])\n", 80 | "print(B1)\n", 81 | "B1.shape" 82 | ] 83 | }, 84 | { 85 | "cell_type": "code", 86 | "execution_count": 3, 87 | "metadata": {}, 88 | "outputs": [ 89 | { 90 | "name": "stdout", 91 | "output_type": "stream", 92 | "text": [ 93 | "[[ 1 2 -1]\n", 94 | " [ 4 5 3]]\n" 95 | ] 96 | }, 97 | { 98 | "data": { 99 | "text/plain": [ 100 | "(2, 3)" 101 | ] 102 | }, 103 | "execution_count": 3, 104 | "metadata": {}, 105 | "output_type": "execute_result" 106 | } 107 | ], 108 | "source": [ 109 | "#transpose\n", 110 | "B=B1.T\n", 111 | "print(B)\n", 112 | "B.shape" 113 | ] 114 | }, 115 | { 116 | "cell_type": "markdown", 117 | "metadata": {}, 118 | "source": [ 119 | "1. $A^2$" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": 4, 125 | "metadata": {}, 126 | "outputs": [ 127 | { 128 | "name": "stdout", 129 | "output_type": "stream", 130 | "text": [ 131 | "[[11 4]\n", 132 | " [ 8 3]]\n" 133 | ] 134 | } 135 | ], 136 | "source": [ 137 | "#Multiply matrices \n", 138 | "C=A.dot(A)\n", 139 | "print(C)" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 5, 145 | "metadata": {}, 146 | "outputs": [ 147 | { 148 | "name": "stdout", 149 | "output_type": "stream", 150 | "text": [ 151 | "[[11 4]\n", 152 | " [ 8 3]]\n" 153 | ] 154 | } 155 | ], 156 | "source": [ 157 | "#Multiply mtrices with @operator\n", 158 | "D= A @ A\n", 159 | "print(D)" 160 | ] 161 | }, 162 | { 163 | "cell_type": "markdown", 164 | "metadata": {}, 165 | "source": [ 166 | "$2. \\ A^T B$\n" 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": 6, 172 | "metadata": {}, 173 | "outputs": [ 174 | { 175 | "name": "stdout", 176 | "output_type": "stream", 177 | "text": [ 178 | "[[11 16 3]\n", 179 | " [ 5 7 2]]\n" 180 | ] 181 | } 182 | ], 183 | "source": [ 184 | "A1=(A.T).dot(B)\n", 185 | "print(A1)" 186 | ] 187 | }, 188 | { 189 | "cell_type": "code", 190 | "execution_count": 7, 191 | "metadata": {}, 192 | "outputs": [ 193 | { 194 | "data": { 195 | "text/plain": [ 196 | "array([[11, 16, 3],\n", 197 | " [ 5, 7, 2]])" 198 | ] 199 | }, 200 | "execution_count": 7, 201 | "metadata": {}, 202 | "output_type": "execute_result" 203 | } 204 | ], 205 | "source": [ 206 | "(A.T)@B" 207 | ] 208 | }, 209 | { 210 | "cell_type": "markdown", 211 | "metadata": {}, 212 | "source": [ 213 | "$3. \\ A^T$" 214 | ] 215 | }, 216 | { 217 | "cell_type": "code", 218 | "execution_count": 8, 219 | "metadata": {}, 220 | "outputs": [ 221 | { 222 | "name": "stdout", 223 | "output_type": "stream", 224 | "text": [ 225 | "[[3 2]\n", 226 | " [1 1]]\n" 227 | ] 228 | } 229 | ], 230 | "source": [ 231 | "F = A.T\n", 232 | "print(F)" 233 | ] 234 | }, 235 | { 236 | "cell_type": "markdown", 237 | "metadata": {}, 238 | "source": [ 239 | "$4. (A^T B)^{-1}$" 240 | ] 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": 9, 245 | "metadata": {}, 246 | "outputs": [ 247 | { 248 | "ename": "LinAlgError", 249 | "evalue": "Last 2 dimensions of the array must be square", 250 | "output_type": "error", 251 | "traceback": [ 252 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 253 | "\u001b[0;31mLinAlgError\u001b[0m Traceback (most recent call last)", 254 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0marray\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mnumpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0minv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0minv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mF\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mB\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 255 | "\u001b[0;32m/anaconda/lib/python3.6/site-packages/numpy/linalg/linalg.py\u001b[0m in \u001b[0;36minv\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m 515\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwrap\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_makearray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 516\u001b[0m \u001b[0m_assertRankAtLeast2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 517\u001b[0;31m \u001b[0m_assertNdSquareness\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 518\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult_t\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_commonType\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 519\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", 256 | "\u001b[0;32m/anaconda/lib/python3.6/site-packages/numpy/linalg/linalg.py\u001b[0m in \u001b[0;36m_assertNdSquareness\u001b[0;34m(*arrays)\u001b[0m\n\u001b[1;32m 210\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0marrays\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 211\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 212\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mLinAlgError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Last 2 dimensions of the array must be square'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 213\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 214\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_assertFinite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0marrays\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", 257 | "\u001b[0;31mLinAlgError\u001b[0m: Last 2 dimensions of the array must be square" 258 | ] 259 | } 260 | ], 261 | "source": [ 262 | "from numpy import array\n", 263 | "from numpy.linalg import inv\n", 264 | "inv(F.dot(B))" 265 | ] 266 | }, 267 | { 268 | "cell_type": "markdown", 269 | "metadata": {}, 270 | "source": [ 271 | "$5. A^{-1}$" 272 | ] 273 | }, 274 | { 275 | "cell_type": "code", 276 | "execution_count": 10, 277 | "metadata": {}, 278 | "outputs": [ 279 | { 280 | "data": { 281 | "text/plain": [ 282 | "array([[ 1., -1.],\n", 283 | " [-2., 3.]])" 284 | ] 285 | }, 286 | "execution_count": 10, 287 | "metadata": {}, 288 | "output_type": "execute_result" 289 | } 290 | ], 291 | "source": [ 292 | "inv(A)" 293 | ] 294 | }, 295 | { 296 | "cell_type": "markdown", 297 | "metadata": {}, 298 | "source": [ 299 | "$6. \\ (BB^T )^{-1}$" 300 | ] 301 | }, 302 | { 303 | "cell_type": "code", 304 | "execution_count": 11, 305 | "metadata": {}, 306 | "outputs": [ 307 | { 308 | "data": { 309 | "text/plain": [ 310 | "array([[ 0.27932961, -0.06145251],\n", 311 | " [-0.06145251, 0.03351955]])" 312 | ] 313 | }, 314 | "execution_count": 11, 315 | "metadata": {}, 316 | "output_type": "execute_result" 317 | } 318 | ], 319 | "source": [ 320 | "inv(B@(B.T))" 321 | ] 322 | }, 323 | { 324 | "cell_type": "code", 325 | "execution_count": 12, 326 | "metadata": {}, 327 | "outputs": [ 328 | { 329 | "data": { 330 | "text/plain": [ 331 | "array([[ 1, 4],\n", 332 | " [ 2, 5],\n", 333 | " [-1, 3]])" 334 | ] 335 | }, 336 | "execution_count": 12, 337 | "metadata": {}, 338 | "output_type": "execute_result" 339 | } 340 | ], 341 | "source": [ 342 | "B.T" 343 | ] 344 | }, 345 | { 346 | "cell_type": "code", 347 | "execution_count": 13, 348 | "metadata": {}, 349 | "outputs": [ 350 | { 351 | "data": { 352 | "text/plain": [ 353 | "array([[ 6, 11],\n", 354 | " [11, 50]])" 355 | ] 356 | }, 357 | "execution_count": 13, 358 | "metadata": {}, 359 | "output_type": "execute_result" 360 | } 361 | ], 362 | "source": [ 363 | "B@(B.T)" 364 | ] 365 | }, 366 | { 367 | "cell_type": "markdown", 368 | "metadata": {}, 369 | "source": [ 370 | "$7.$ Consider a linear tranformation $T: \\ R^2 \\rightarrow R^3$, $T(x)=Ax$. \n", 371 | "\n", 372 | "\n", 373 | "Let $A=\\begin{pmatrix}\n", 374 | "1 & 0 &3 \\\\\n", 375 | "4 & 5 &-1 \\\\\n", 376 | "0 & 0 &2 \\end{pmatrix}$, For $x=\\begin{pmatrix} 1\\\\2\\\\5 \\end{pmatrix}$. Compute $T(x)$." 377 | ] 378 | }, 379 | { 380 | "cell_type": "code", 381 | "execution_count": 14, 382 | "metadata": {}, 383 | "outputs": [ 384 | { 385 | "name": "stdout", 386 | "output_type": "stream", 387 | "text": [ 388 | "[[ 1 0 3]\n", 389 | " [ 4 5 -1]\n", 390 | " [ 0 0 2]]\n" 391 | ] 392 | } 393 | ], 394 | "source": [ 395 | "AA=array([[1,0,3],[4,5,-1],[0,0,2]])\n", 396 | "print(AA)" 397 | ] 398 | }, 399 | { 400 | "cell_type": "code", 401 | "execution_count": 15, 402 | "metadata": {}, 403 | "outputs": [ 404 | { 405 | "name": "stdout", 406 | "output_type": "stream", 407 | "text": [ 408 | "[[1]\n", 409 | " [2]\n", 410 | " [5]]\n" 411 | ] 412 | } 413 | ], 414 | "source": [ 415 | "X=array([[1],[2],[5]])\n", 416 | "print(X)" 417 | ] 418 | }, 419 | { 420 | "cell_type": "code", 421 | "execution_count": 16, 422 | "metadata": {}, 423 | "outputs": [ 424 | { 425 | "data": { 426 | "text/plain": [ 427 | "array([[16],\n", 428 | " [ 9],\n", 429 | " [10]])" 430 | ] 431 | }, 432 | "execution_count": 16, 433 | "metadata": {}, 434 | "output_type": "execute_result" 435 | } 436 | ], 437 | "source": [ 438 | "AA@X" 439 | ] 440 | } 441 | ], 442 | "metadata": { 443 | "kernelspec": { 444 | "display_name": "Python 3", 445 | "language": "python", 446 | "name": "python3" 447 | }, 448 | "language_info": { 449 | "codemirror_mode": { 450 | "name": "ipython", 451 | "version": 3 452 | }, 453 | "file_extension": ".py", 454 | "mimetype": "text/x-python", 455 | "name": "python", 456 | "nbconvert_exporter": "python", 457 | "pygments_lexer": "ipython3", 458 | "version": "3.6.3" 459 | } 460 | }, 461 | "nbformat": 4, 462 | "nbformat_minor": 2 463 | } 464 | -------------------------------------------------------------------------------- /Week 8- Transpose of a matrix/transpose: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /Week 9- Orthogonal complements- Orthogonal projections/Orthogonal projection: -------------------------------------------------------------------------------- 1 | 2 | from numpy import array 3 | x1=array([3,6,0]) 4 | y2=array([1,2,2]) 5 | print('x1=',x1) 6 | print('y2=',y2) 7 | y2.dot(x1) 8 | -------------------------------------------------------------------------------- /Week 9- Orthogonal complements- Orthogonal projections/Orthogonal+projection.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Gram Schmidt Process\n", 8 | "\n", 9 | "### 간단예제" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 1, 15 | "metadata": {}, 16 | "outputs": [ 17 | { 18 | "name": "stdout", 19 | "output_type": "stream", 20 | "text": [ 21 | "x1= [3 6 0]\n", 22 | "y2= [1 2 2]\n" 23 | ] 24 | }, 25 | { 26 | "data": { 27 | "text/plain": [ 28 | "15" 29 | ] 30 | }, 31 | "execution_count": 1, 32 | "metadata": {}, 33 | "output_type": "execute_result" 34 | } 35 | ], 36 | "source": [ 37 | "from numpy import array\n", 38 | "x1=array([3,6,0])\n", 39 | "y2=array([1,2,2])\n", 40 | "print('x1=',x1)\n", 41 | "print('y2=',y2)\n", 42 | "y2.dot(x1)" 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": 2, 48 | "metadata": {}, 49 | "outputs": [ 50 | { 51 | "name": "stdout", 52 | "output_type": "stream", 53 | "text": [ 54 | "[ 0. 0. 2.]\n" 55 | ] 56 | } 57 | ], 58 | "source": [ 59 | "from numpy import array\n", 60 | "x1=array([3,6,0])\n", 61 | "y2=array([1,2,2])\n", 62 | "a1=y2.dot(x1)\n", 63 | "aa=x1.dot(x1)\n", 64 | "x2=y2-(a1/aa)*x1\n", 65 | "print(x2)" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "### check the orthogonality" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": 3, 78 | "metadata": {}, 79 | "outputs": [ 80 | { 81 | "data": { 82 | "text/plain": [ 83 | "0.0" 84 | ] 85 | }, 86 | "execution_count": 3, 87 | "metadata": {}, 88 | "output_type": "execute_result" 89 | } 90 | ], 91 | "source": [ 92 | "x1.dot(x2)" 93 | ] 94 | } 95 | ], 96 | "metadata": { 97 | "kernelspec": { 98 | "display_name": "Python 3", 99 | "language": "python", 100 | "name": "python3" 101 | }, 102 | "language_info": { 103 | "codemirror_mode": { 104 | "name": "ipython", 105 | "version": 3 106 | }, 107 | "file_extension": ".py", 108 | "mimetype": "text/x-python", 109 | "name": "python", 110 | "nbconvert_exporter": "python", 111 | "pygments_lexer": "ipython3", 112 | "version": "3.6.3" 113 | } 114 | }, 115 | "nbformat": 4, 116 | "nbformat_minor": 2 117 | } 118 | -------------------------------------------------------------------------------- /[MAC]쥬피터노트북설치하기.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Ingenjoy/Linear-Algebra-with-python/48e9206b91998ba145155d5eb88848189d464036/[MAC]쥬피터노트북설치하기.pdf -------------------------------------------------------------------------------- /[WINDOWS]쥬피터노트북설치하기.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Ingenjoy/Linear-Algebra-with-python/48e9206b91998ba145155d5eb88848189d464036/[WINDOWS]쥬피터노트북설치하기.pdf -------------------------------------------------------------------------------- /[Week 11] Eigen-everything: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /[Week 2] Linear combinations and spans, Linear dependence and independence: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /[Week 3] Subspaces and the basis for a subspace, Vector dot and cross products: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /[Week 5] Functions and linear transformations, Linear transformation examples: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /[Week 6] Transformations and matrix multiplication, Inverse functions and transformations: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /[Week 7] Finding inverses and determinants, More determinant depth: -------------------------------------------------------------------------------- 1 | 2 | --------------------------------------------------------------------------------