{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# CS568:Deep Learning Spring 2020 "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This is part 3 of Recitation 1 for the course CS-568: Deep Learning. This notebook introduces basic fundamentals of NumPy. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## NumPy\n",
"Numpy is the core library for scientific computing in Python. It contains:\n",
"> - a powerful N-dimensional array object\n",
"> - sophisticated (broadcasting) functions\n",
"> - tools for integrating C/C++ and Fortran code\n",
"> - useful linear algebra, Fourier transform, and random number capabilities\n",
"> - a multi-dimentional array and matrix data structures"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Check the version of NumPy"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"np.version.version"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Create 2-d array"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"arr2 = np.array([[1,2,3],[4,5,6]]) # 2-d array\n",
"print(arr2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Generate random numbers with NumPy"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"rand_normal = np.random.normal() # random number with normal distribution\n",
"print(rand_normal)\n",
"rand_normal_arr = np.random.normal(size=4) # random numbers from normal distribution\n",
"print(rand_normal_arr)\n",
"mu = 0.5\n",
"sigma = 1\n",
"rand_normal_arr1 = np.random.normal(mu, sigma, size=5) # generate random numbers with mean 0.5 and sigma 1\n",
"print(rand_normal_arr1)\n",
"\n",
"print(\"*\"*20)\n",
"rand_uniform = np.random.uniform(size=4) # random numbers from uniform distribution\n",
"print(rand_uniform)\n",
"int_rand_arr = np.random.randint(low=1, high=100, size=4) # generate integer random numbers between 1 and 100\n",
"print(int_rand_arr)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Vector Arrays"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"arr_of_zeros = np.zeros((2,2)) # Create an array of all zeros \n",
"print(arr_of_zeros)\n",
"arr_of_ones = np.ones((3,3)) # Create an array of all ones\n",
"print(arr_of_ones) \n",
"arr_constant = np.full((2,2), 7) # Create a constant array\n",
"print(arr_constant) \n",
"identity_matrix = np.eye(3) # Create a 3x3 of identity matrix\n",
"print(identity_matrix) \n",
"random_arr = np.random.random((3,3)) # Create an array filled with random values\n",
"print(random_arr) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Basic mathematical functions in numpy"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"x = np.array([[1,2,3],[3,4,8]])\n",
"y = np.array([[5,6,1],[7,8,1]])\n",
"\n",
"print(x + y) # Elementwise sum; both produce the array\n",
"print(np.add(x, y))\n",
"\n",
"print(x - y) # Elementwise difference; both produce the array\n",
"print(np.subtract(x, y))\n",
"\n",
"print(x * y) # Elementwise product; both produce the array\n",
"print(np.multiply(x, y))\n",
"\n",
"print(x / y) # Elementwise division; both produce the array\n",
"print(np.divide(x, y))\n",
"\n",
"print(np.sqrt(x)) # Elementwise square root; produces the array"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Consider two vectors arrays \n",
"\n",
"$$ \\boldsymbol{e}_1 = \n",
"\\left(\\begin{array}{cc} \n",
"1 & 0 & 0\n",
"\\end{array}\\right)\n",
"$$\n",
"\n",
"$$ \\boldsymbol{e}_2 = \n",
"\\left(\\begin{array}{cc} \n",
"0 & 1 & 0 \n",
"\\end{array}\\right)\n",
"$$\n",
"\n",
"$$ \\boldsymbol{e}_3 = \n",
"\\left(\\begin{array}{cc} \n",
"0 & 0 & 1\n",
"\\end{array}\\right)\n",
"$$\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"e1 = np.array([1, 0, 0])\n",
"e2 = np.array([0, 1, 0])\n",
"e3 = np.array([0, 0, 1])\n",
"\n",
"print(\"e1 =\", e1)\n",
"print(\"e2 =\", e2)\n",
"print(\"e3 =\", e3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The dot product of two vector arrays can be defined as"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"e1⋅e2 =\", np.dot(e1, e2))\n",
"print(\"e2.e2 =\", np.dot(e2, e2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$$ k \\boldsymbol{e}_1 = 3 \\left(\\begin{array}{cc} 1 & 0 & 0 \\end{array}\\right) = \\left(\\begin{array}{cc} 3 & 0 & 0\\end{array}\\right) $$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"k = 5\n",
"e1 = np.array([1, 0, 0])\n",
"\n",
"print(\"k*e1 =\", k*e1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Consider $w_1= 3$, $w_2 = 1$, and $w_3 = 4$\n",
"\n",
"$$\n",
"\\begin{aligned}\n",
"\\boldsymbol{w} \n",
"&= w_1 \\boldsymbol{e}_1 + w_2 \\boldsymbol{e}_2 + w_3 \\boldsymbol{e}_3 \\\\\n",
"&= 3 \\left(\\begin{array}{cc} \n",
"0 & 0 & 1\n",
"\\end{array}\\right) + \n",
"1 \\left(\\begin{array}{cc} \n",
"1 & 0 & 0\n",
"\\end{array}\\right) + \n",
"4 \\left(\\begin{array}{cc} \n",
"0 & 1 & 0\n",
"\\end{array}\\right) \\\\\n",
"&= \\left(\\begin{array}{cc} \n",
"3 & 0 & 0\n",
"\\end{array}\\right) + \n",
"\\left(\\begin{array}{cc} \n",
"0 & 1 & 0\n",
"\\end{array}\\right) + \n",
"\\left(\\begin{array}{cc} \n",
"0 & 0 & 4\n",
"\\end{array}\\right) \\\\\n",
"&= \\left(\\begin{array}{cc} \n",
"3 & 1 & 4\n",
"\\end{array}\\right)\n",
"\\end{aligned}\n",
"$$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"w1 = 3\n",
"w2 = 1\n",
"w3 = 4\n",
"\n",
"w = w1*e1 + w2*e2 + w3*e3\n",
"\n",
"print(\"w = w1*e1 + w2*e2 + w3*e3 =\", w)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Dot product for general vector arrays:\n",
"\n",
"$$\n",
"\\begin{align}\n",
"\\boldsymbol{u} ⋅ \\boldsymbol{v} & = \n",
"(u_1 \\boldsymbol{e}_1 + u_2 \\boldsymbol{e}_2 + u_3 \\boldsymbol{e}_3)⋅(v_1 \\boldsymbol{e}_1 + v_2 \\boldsymbol{e}_2 + v_3 \\boldsymbol{e}_3)\n",
"\\\\\\\\ & = \n",
"u_1v_1( \\boldsymbol{e}_1 \\boldsymbol{e}_1) + u_1v_2( \\boldsymbol{e}_1 \\boldsymbol{e}_2) + u_1v_3( \\boldsymbol{e}_1 \\boldsymbol{e}_3)\n",
"\\\\\\\\ & \\quad+\n",
"u_2v_1( \\boldsymbol{e}_2 \\boldsymbol{e}_1) + u_2v_2( \\boldsymbol{e}_2 \\boldsymbol{e}_2) + u_2v_3( \\boldsymbol{e}_2 \\boldsymbol{e}_3)\n",
"\\\\\\\\ & \\quad+\n",
"u_3v_1( \\boldsymbol{e}_3 \\boldsymbol{e}_1) + u_3v_2( \\boldsymbol{e}_3 \\boldsymbol{e}_2) + u_3v_3( \\boldsymbol{e}_3 \\boldsymbol{e}_3)\n",
"\\\\\\\\ & =\n",
"u_1v_1 + u_2v_2 + u_3v_3\n",
"\\end{align}\\\\\n",
"$$\n",
"\n",
"Consider \n",
"$u = \\left(\\begin{array}{cc} \n",
"3 & 1 & 4\n",
"\\end{array}\\right)$\n",
", and \n",
"$v = \\left(\\begin{array}{cc} \n",
"1 & 5 & 9\n",
"\\end{array}\\right)$, then:\n",
"\n",
"$$\n",
"\\begin{aligned}\n",
"\\boldsymbol{u} \\cdot \\boldsymbol{v}\n",
"&= u_1 v_1 + u_2 v_2 + u_3 v_3 \\\\\n",
"&= (3) (1) + (1) (5) + (4) (9) \\\\\n",
"&= 44\n",
"\\end{aligned}\n",
"$$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"u_components = [3, 1, 4]\n",
"v_components = [1, 5, 9]\n",
"\n",
"u = u_components[0]*e1 + u_components[1]*e2 + u_components[2]*e3\n",
"v = v_components[0]*e1 + v_components[1]*e2 + v_components[2]*e3\n",
"\n",
"result = np.dot(u, v)\n",
"print(result)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$$\\boldsymbol{u}⋅\\boldsymbol{v}=\\sum_{i=1}^{3}u_iv_i$$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"result = 0\n",
"for i in range(len(u)):\n",
" result += u[i]*v[i]\n",
"print(result)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"result = np.dot(u, v)\n",
"print(result)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Matrix Arrays\n",
"Here is a $3 \\times 1$ matrix array:\n",
"$$\n",
"\\boldsymbol{u} =\n",
"\\left(\\begin{array}{cc} \n",
"u_1\\\\\n",
"u_2\\\\\n",
"u_3\n",
"\\end{array}\\right)\n",
"\\Rightarrow\n",
"\\boldsymbol{u}^T =\n",
"\\left(\\begin{array}{cc} \n",
"u_1 &\n",
"u_2 &\n",
"u_3\n",
"\\end{array}\\right)\n",
"$$ "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Create a random 3 x 1 matrix array from a uniform distribution from 0 to 1\n",
"# random.random returns the number between half-open interval [a,b) = [0.0, 1.0)\n",
"u = np.random.random((3,1))\n",
"print(\"u =\\n\", u)\n",
"print(\"u^T =\\n\", u.T)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$$\n",
"\\boldsymbol{v} = \n",
"\\left(\\begin{array}{cc} \n",
"v_1\\\\\n",
"v_2\\\\\n",
"v_3\n",
"\\end{array}\\right)\n",
"\\Rightarrow\n",
"\\boldsymbol{v}^T = \n",
"\\left(\\begin{array}{cc} \n",
"v_1 & v_2 & v_3\n",
"\\end{array}\\right)\n",
"$$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Create a random 3 x 1 matrix array from a uniform distribution from 1 to 5\n",
"# (b-a) * random samples + a\n",
"\n",
"\n",
"v = (5-1)*np.random.random((3,1))+1\n",
"\n",
"# Transposing it yields a 1 x 3 matrix array\n",
"print(\"v =\\n\", v)\n",
"print(\"v^T =\\n\", v.T)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Matrix multiplication:\n",
"\n",
"$$\n",
"\\boldsymbol{u}^T\\boldsymbol{v} =\n",
"\\left(\\begin{array}{cc} \n",
"u_1 & u_2 & u_3\n",
"\\end{array}\\right)\n",
"\\left(\\begin{array}{cc} \n",
"v_1 \\\\ v_2 \\\\ v_3\n",
"\\end{array}\\right)\n",
"= \\left(\\begin{array}{cc} \n",
"u_1 v_1 + u_2 v_2 + u_3 v_3\n",
"\\end{array}\\right)\n",
"$$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"result = np.matmul(u.T, v)\n",
"print(\"u^T⋅v =\\n\", result)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Matrix multiplication:\n",
"\n",
"$$\n",
"\\boldsymbol{u}^T\\boldsymbol{v} =\n",
"\\left(\\begin{array}{cc} \n",
"u_1 \\\\ u_2 \\\\ u_3\n",
"\\end{array}\\right)\n",
"\\left(\\begin{array}{cc} \n",
"v_1 & v_2 & v_3\n",
"\\end{array}\\right)\n",
"= \\left(\\begin{array}{cc} \n",
"u_1 v_1 & u_1 v_2 & u_1 v_3 \\\\\n",
"u_2 v_1 & u_2 v_2 & u_2 v_3 \\\\\n",
"u_3 v_1 & u_3 v_2 & u_3 v_3 \\\\\n",
"\\end{array}\\right)\n",
"$$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"result = np.matmul(u, v.T)\n",
"print(\"u⋅v^T =\\n\", result)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$$(\\boldsymbol{A}\\boldsymbol{B})^T = \\boldsymbol{B}^T\\boldsymbol{A}^T$$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"A = np.random.randint(9, size=(3,3))\n",
"B = np.random.randint(9, size=(3,3))\n",
"\n",
"result = np.dot(A, B).T\n",
"\n",
"print(\"A =\\n\", A)\n",
"\n",
"print(\"B =\\n\", B)\n",
"\n",
"print(\"(A⋅B)^T =\\n\", result)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"result = np.dot(B.T, A.T)\n",
"\n",
"print(\"A^T =\\n\", A.T)\n",
"\n",
"print(\"B^T =\\n\", B.T)\n",
"\n",
"print(\"A^T⋅B^T =\\n\", result)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here is an example of matrix array multiplication between a $3 \\times 3$ matrix array and a $3 \\times 1$ vector arrays:\n",
"$$\n",
"\\boldsymbol{M} \\boldsymbol{u}\n",
"=\n",
"\\left(\\begin{array}{cc} \n",
"M_{11} & M_{12} & M_{13}\\\\\n",
"M_{21} & M_{22} & M_{23}\\\\\n",
"M_{31} & M_{32} & M_{33}\n",
"\\end{array}\\right)\n",
"\\left(\\begin{array}{cc} \n",
"u_{1}\\\\\n",
"u_{2}\\\\\n",
"u_{3}\n",
"\\end{array}\\right)\n",
"= \n",
"\\left(\\begin{array}{cc} \n",
"M_{11} u_{1} + M_{12} u_{2} + M_{13} u_{3}\\\\\n",
"M_{21} u_{1} + M_{22} u_{2} + M_{23} u_{3}\\\\\n",
"M_{31} u_{1} + M_{32} u_{2} + M_{33} u_{3}\n",
"\\end{array}\\right)\n",
"$$ \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"M = np.random.randint(9, size=(3,3))\n",
"u = np.array([[1], \n",
" [2], \n",
" [3]])\n",
"\n",
"result = np.matmul(M, u)\n",
"\n",
"print(\"M =\\n\", M)\n",
"\n",
"print(\"u =\\n\", u)\n",
"\n",
"print(\"M⋅u =\\n\", result)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Tensor Arrays"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Consider this vector arrays with 3 components:\n",
"\n",
"$$\n",
"\\left(\\begin{array}{cc} \n",
"a_{0} \\\\ a_{1} \\\\ a_{2}\n",
"\\end{array}\\right)\n",
"$$ \n",
"\n",
"And consider this $4 \\times 4$ matrix array:\n",
"$$\n",
"\\left(\\begin{array}{cc} \n",
"b_{00} & b_{01} & b_{02} & b_{03}\\\\\n",
"b_{10} & b_{11} & b_{12} & b_{13}\\\\\n",
"b_{20} & b_{21} & b_{22} & b_{23}\\\\\n",
"b_{30} & b_{31} & b_{32} & b_{33}\n",
"\\end{array}\\right)\n",
"$$ "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Then the tensor array product of the vector arrays and the matrix array is calculated as follows:\n",
"\n",
"$\n",
"\\left(\\begin{array}{cc} \n",
"a_{0} \\\\ a_{1} \\\\ a_{2}\n",
"\\end{array}\\right)\n",
"\\otimes\n",
"\\left(\\begin{array}{cc} \n",
"b_{00} & b_{01} & b_{02} & b_{03}\\\\\n",
"b_{10} & b_{11} & b_{12} & b_{13}\\\\\n",
"b_{20} & b_{21} & b_{22} & b_{23}\\\\\n",
"b_{30} & b_{31} & b_{32} & b_{33}\n",
"\\end{array}\\right)\n",
"$\n",
"\n",
"\n",
"$\n",
"\\begin{aligned}\n",
"\\: \\: \\: \\: \\: \\: \\: \\: &=\n",
"\\left(\\begin{array}{cc} \n",
"a_{0}\n",
"\\left(\\begin{array}{cc} \n",
"b_{00} & b_{01} & b_{02} & b_{03}\\\\\n",
"b_{10} & b_{11} & b_{12} & b_{13}\\\\\n",
"b_{20} & b_{21} & b_{22} & b_{23}\\\\\n",
"b_{30} & b_{31} & b_{32} & b_{33}\n",
"\\end{array}\\right) \\\\\n",
"a_{1}\n",
"\\left(\\begin{array}{cc} \n",
"b_{00} & b_{01} & b_{02} & b_{03}\\\\\n",
"b_{10} & b_{11} & b_{12} & b_{13}\\\\\n",
"b_{20} & b_{21} & b_{22} & b_{23}\\\\\n",
"b_{30} & b_{31} & b_{32} & b_{33}\n",
"\\end{array}\\right) \\\\\n",
"a_{2}\n",
"\\left(\\begin{array}{cc} \n",
"b_{00} & b_{01} & b_{02} & b_{03}\\\\\n",
"b_{10} & b_{11} & b_{12} & b_{13}\\\\\n",
"b_{20} & b_{21} & b_{22} & b_{23}\\\\\n",
"b_{30} & b_{31} & b_{32} & b_{33}\n",
"\\end{array}\\right) \n",
"\\end{array}\\right) \\\\ &=\n",
"\\left(\\begin{array}{cc} \n",
"a_{0}\n",
"\\left(\\begin{array}{cc} \n",
"b_{00} & b_{01} & b_{02} & b_{03}\\\\\n",
"b_{10} & b_{11} & b_{12} & b_{13}\\\\\n",
"b_{20} & b_{21} & b_{22} & b_{23}\\\\\n",
"b_{30} & b_{31} & b_{32} & b_{33}\n",
"\\end{array}\\right) ,\n",
"a_{1}\n",
"\\left(\\begin{array}{cc} \n",
"b_{00} & b_{01} & b_{02} & b_{03}\\\\\n",
"b_{10} & b_{11} & b_{12} & b_{13}\\\\\n",
"b_{20} & b_{21} & b_{22} & b_{23}\\\\\n",
"b_{30} & b_{31} & b_{32} & b_{33}\n",
"\\end{array}\\right) ,\n",
"a_{2}\n",
"\\left(\\begin{array}{cc} \n",
"b_{00} & b_{01} & b_{02} & b_{03}\\\\\n",
"b_{10} & b_{11} & b_{12} & b_{13}\\\\\n",
"b_{20} & b_{21} & b_{22} & b_{23}\\\\\n",
"b_{30} & b_{31} & b_{32} & b_{33}\n",
"\\end{array}\\right) \n",
"\\end{array}\\right) \\\\\n",
"&=\n",
"\\left(\\begin{array}{cc} \n",
"\\left(\\begin{array}{cc} \n",
"a_{0}b_{00} & a_{0}b_{01} & a_{0}b_{02} & a_{0}b_{03}\\\\\n",
"a_{0}b_{10} & a_{0}b_{11} & a_{0}b_{12} & a_{0}b_{13}\\\\\n",
"a_{0}b_{20} & a_{0}b_{21} & a_{0}b_{22} & a_{0}b_{23}\\\\\n",
"a_{0}b_{30} & a_{0}b_{31} & a_{0}b_{32} & a_{0}b_{33}\n",
"\\end{array}\\right)\n",
",\n",
"\\left(\\begin{array}{cc} \n",
"a_{1}b_{00} & a_{1}b_{01} & a_{1}b_{02} & a_{1}b_{03}\\\\\n",
"a_{1}b_{10} & a_{1}b_{11} & a_{1}b_{12} & a_{1}b_{13}\\\\\n",
"a_{1}b_{20} & a_{1}b_{21} & a_{1}b_{22} & a_{1}b_{23}\\\\\n",
"a_{1}b_{30} & a_{1}b_{31} & a_{1}b_{32} & a_{1}b_{33}\n",
"\\end{array}\\right)\n",
",\n",
"\\left(\\begin{array}{cc} \n",
"a_{2}b_{00} & a_{2}b_{01} & a_{2}b_{02} & a_{2}b_{03}\\\\\n",
"a_{2}b_{10} & a_{2}b_{11} & a_{2}b_{12} & a_{2}b_{13}\\\\\n",
"a_{2}b_{20} & a_{2}b_{21} & a_{2}b_{22} & a_{2}b_{23}\\\\\n",
"a_{2}b_{30} & a_{2}b_{31} & a_{2}b_{32} & a_{2}b_{33}\n",
"\\end{array}\\right)\n",
"\\end{array}\\right) \\\\\n",
"&=\n",
"\\left(\\begin{array}{cc} \n",
"\\left(\\begin{array}{cc} \n",
"\\tau_{000} & \\tau_{001} & \\tau_{002} & \\tau_{003}\\\\\n",
"\\tau_{010} & \\tau_{011} & \\tau_{012} & \\tau_{013}\\\\\n",
"\\tau_{020} & \\tau_{021} & \\tau_{022} & \\tau_{023}\\\\\n",
"\\tau_{030} & \\tau_{031} & \\tau_{032} & \\tau_{033}\n",
"\\end{array}\\right)\n",
",\n",
"\\left(\\begin{array}{cc} \n",
"\\tau_{100} & \\tau_{101} & \\tau_{102} & \\tau_{103}\\\\\n",
"\\tau_{110} & \\tau_{111} & \\tau_{112} & \\tau_{113}\\\\\n",
"\\tau_{120} & \\tau_{121} & \\tau_{122} & \\tau_{123}\\\\\n",
"\\tau_{130} & \\tau_{131} & \\tau_{132} & \\tau_{133}\n",
"\\end{array}\\right)\n",
",\n",
"\\left(\\begin{array}{cc} \n",
"\\tau_{200} & \\tau_{201} & \\tau_{202} & \\tau_{203}\\\\\n",
"\\tau_{210} & \\tau_{211} & \\tau_{212} & \\tau_{213}\\\\\n",
"\\tau_{220} & \\tau_{221} & \\tau_{222} & \\tau_{223}\\\\\n",
"\\tau_{230} & \\tau_{231} & \\tau_{232} & \\tau_{233}\n",
"\\end{array}\\right)\n",
"\\end{array}\\right)\n",
"\\end{aligned}\n",
"$\n",
"\n",
"This tensor array could be described as a 3D matrix array."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"A = np.random.randint(9, size=(3))\n",
"B = np.random.randint(9, size=(4,4))\n",
"\n",
"print(\"A = \\n\", A)\n",
"\n",
"print(\"B = \\n\", B)\n",
"\n",
"print(\"A⨂B =\\n\", np.tensordot(A, B, axes=0))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"a1 = np.array([np.array([3, 1, 4, 1]), \n",
" np.array([5, 9, 2, 6]), \n",
" np.array([5, 3, 5, 8])])\n",
"\n",
"a2 = np.array([np.array([9, 7, 9, 3]),\n",
" np.array([2, 3, 8, 4])])\n",
"\n",
"a3 = np.array([np.array([3, 3, 8, 3]), \n",
" np.array([2, 7, 9, 5]),\n",
" np.array([0, 2, 8, 8]), \n",
" np.array([6, 2, 6, 4])])\n",
"\n",
"A = np.array([a1, a2, a3])\n",
"\n",
"print(\"A =\\n\", A.T)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Subset the first two elements to make a tensor array"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"A1 = [record[:2] for record in A]\n",
"print(A,A.shape)\n",
" \n",
"A1 = np.array(A1)\n",
"\n",
"print(\"A =\\n\", A)\n",
"\n",
"print(\"A1 =\\n\", A1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Subset the last two elements to make a tensor array"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"A2 = [record[-2:] for record in A]\n",
"A2 = np.array(A2)\n",
"\n",
"print(\"A =\\n\", A)\n",
"\n",
"print(\"A2 =\\n\", A2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Padding in tensors"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"matrix = np.ones((5,5))\n",
"print(matrix)\n",
"\n",
"pad_matrix = np.pad(matrix, pad_width=2, mode='constant', constant_values=0)\n",
"print(pad_matrix)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"pad_below1 = 4 - len(a1) # 4-3=1 len(a1) = 3x4\n",
"pad_below2 = 4 - len(a2) # 4-2=2 len(a2) = 2x4\n",
"pad_below3 = 4 - len(a3) # 4-4=0 len(a3) = 4x4\n",
"\n",
"pad_above = 0\n",
"pad_left = 0\n",
"par_right = 0\n",
"\n",
"n_add = [((pad_above, pad_below1), (pad_left, par_right)), # one tuple for each dimension\n",
" ((pad_above, pad_below2), (pad_left, par_right)), \n",
" ((pad_above, pad_below3), (pad_left, par_right))]\n",
"print(n_add)\n",
"\n",
"A3 = [np.pad(A[i], pad_width = n_add[i], mode = 'constant', constant_values = 0) for i in range(3)] # list comprehension returns list\n",
"A3 = np.array(A3) # convert A3 into array again\n",
"\n",
"print(\"A =\\n\", A)\n",
"print(\"A3 =\\n\", A3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Stack numpy arrays along the horizontal and vertical axis respectively"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"vec_a = np.array([1,2,3])\n",
"vec_b = np.array([4,5,6])\n",
"\n",
"vec_vstack = np.vstack((vec_a,vec_b)) # vertically stack 1-d arrays\n",
"vec_hstack = np.hstack((vec_a,vec_b)) # horizontally stack 1-d arrays\n",
"print(vec_hstack, vec_hstack.shape)\n",
"print(vec_vstack, vec_vstack.shape)\n",
"\n",
"mat_a = np.array([[1,2,3],[4,5,6]])\n",
"mat_b = np.array([[11,12,13],[14,15,16]])\n",
"mat_vstack = np.vstack((mat_a,mat_b)) # vertically stack 1-d arrays\n",
"print(mat_vstack, mat_vstack.shape)\n",
"\n",
"mat_a = np.array([[1,2,3],[4,5,6]])\n",
"mat_b = np.array([[11,12,13],[14,15,16]])\n",
"mat_hstack = np.hstack((mat_a,mat_b)) # horizontally stack 1-d arrays\n",
"print(mat_hstack, mat_hstack.shape)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"vec_a = np.array([1,2,3])\n",
"vec_b = np.array([4,5,6])\n",
"\n",
"concat_ab = np.concatenate((vec_a,vec_b),axis=0)\n",
"print(concat_ab)\n",
"#concat_ab = np.concatenate((vec_a,vec_b),axis=1)\n",
"#print(concat_ab)\n",
"\n",
"mat_a = np.array([[1,2,3],[4,5,6]])\n",
"mat_b = np.array([[11,12,13],[14,15,16]])\n",
"concat_ab = np.concatenate((mat_a,mat_b),axis=0)\n",
"print(concat_ab)\n",
"concat_ab = np.concatenate((mat_a,mat_b),axis=1)\n",
"print(concat_ab) "
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.5.3"
}
},
"nbformat": 4,
"nbformat_minor": 2
}