
%matplotlib inline 
%run mplimp.py


import numpy as np


np.random.seed(1337)


x = np.array(  [1, 4, 3]  )
x


y = np.array([ [1, 4, 3], 
               [9, 2, 7] ] )
y


x.shape


y.shape


z = np.array(  [ [1, 4, 3] ]  )   # What's the difference?


z.shape


z = np.arange(1, 2000, 1)  # start, end, step
z[:10]


z.shape


np.arange(0.5, 3, 0.5)


np.arange(0.5, 10, 1).shape


np.arange(0.5, 10, 1).reshape(5, 2).shape


np.arange(0.5, 10, 1).reshape(5, 3).shape  # !!


# Evenly spaced but we don't know the step 
np.linspace(3, 9, 10)


print(x)
print(x[1]) 
print(x[1:])


print(y)
y[0, 1]   # this is extra in numpy


y[:, 1]


y[:, [1, 2]]


np.zeros((3, 5))


np.ones((5, 3))


a = np.arange(1, 7)
a


a.shape


a[3] = 7
a


a[:3] = 1   # Assign to multiple locations 
a


a[1:4] = [9, 8, 7]
a


# This is most useful 
b = np.zeros((2, 2))
b[0, 0] = 1
b[0, 1] = 2
b[1, 1] = 4
b


b.shape


print(b)


b + 2


2 * b


b ** 2


sum(b)


b.sum()

b


b.sum(axis=0).shape


b.sum(axis=1).shape


b = np.array([[1, 2], [3, 4]])
d = np.array([[3, 4], [5, 6]])


print(b) 
print(d)


b + d


b * d     # what operation is this?


b.dot(d)  # and this?


b ** d

b.T

a


a.shape

a.T


a.T.shape


a.reshape(6,1).T.shape


# Numpy has "broadcasting" or "mapping" functions 
print(np.sqrt(36))

# works on both scalars and arrays 
x = [1, 4, 9, 16]
np.sqrt(x)


# Checking conditions 
x = np.array([1, 2, 4, 5, 9, 3])
y = np.array([0, 2, 3, 1, 2, 3])


x > 3


x > y


import math
def basic_sigmoid(x):
    """
    Compute sigmoid of x.

    Arguments:
    x -- A scalar

    Return:
    s -- sigmoid(x)
    """
    
    s = 1./(1. + math.e ** (-x))
    
    return s


basic_sigmoid(-1)


basic_sigmoid(0)


x = [-1, 0, 3]
basic_sigmoid(x)   # Why


import numpy as np

x = [-1, 0, 3]
x = np.array(x)
basic_sigmoid(x)


import numpy as np


# What is broadcasting? 
x = np.array([1, 2, 3])
x * 3  # This makes sense

array([3, 6, 9])


x + 3   # Does this?

array([4, 5, 6])


x = np.arange(4)
xx = x.reshape(4, 1)
y = np.ones(5)
z = np.ones((3,4))

print("x =  ", x)
print("xx = ", xx) 
print("y =  ", y)

print("Shapes: ") 
print(x.shape)
print(xx.shape)
print(y.shape)

x =   [0 1 2 3]
xx =  [[0]
 [1]
 [2]
 [3]]
y =   [1. 1. 1. 1. 1.]
Shapes: 
(4,)
(4, 1)
(5,)


x + y    # does not work

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-8128991a6498> in <module>
----> 1 x + y    # does not work

ValueError: operands could not be broadcast together with shapes (4,) (5,)


xx.shape, x.shape

((4, 1), (4,))


print(y)
print(xx)

[1. 1. 1. 1. 1.]
[[0]
 [1]
 [2]
 [3]]


out = xx + y       # xx is broadcast over the columns of y

out

array([[1., 1., 1., 1., 1.],
       [2., 2., 2., 2., 2.],
       [3., 3., 3., 3., 3.],
       [4., 4., 4., 4., 4.]])


out.shape

(4, 5)


np.array([1]) + y      # element is broadcast over y

array([2., 2., 2., 2., 2.])


print(z)
z.shape

[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

(3, 4)


x.shape

(4,)

x

array([0, 1, 2, 3])


z + x

array([[1., 2., 3., 4.],
       [1., 2., 3., 4.],
       [1., 2., 3., 4.]])


a = np.array([[ 0.0 , 0.0,  0.0  ],
              [ 10.0, 10.0, 10.0 ],
              [ 20.0, 20.0, 20.0 ],
              [ 30.0, 30.0, 30.0 ]])

b = np.array( [ 1.0,  2.0,  3.0  ] )


a + b

array([[ 1.,  2.,  3.],
       [11., 12., 13.],
       [21., 22., 23.],
       [31., 32., 33.]])


a = np.array([[ 0.0 , 0.0,  0.0  , 0.0  ],
              [ 10.0, 10.0, 10.0 , 10.0 ],
              [ 20.0, 20.0, 20.0 , 20.0 ],
              [ 30.0, 30.0, 30.0 , 30.0 ]])

b = np.array( [ 1.0,  2.0] )


a + b

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-21-bd58363a63fc> in <module>
----> 1 a + b

ValueError: operands could not be broadcast together with shapes (4,4) (2,)


a = np.array( [ 0.0, 10.0, 20.0, 30.0 ] )
b = np.array( [ 1.0, 2.0,  3.0 ]        )


a + b    # can't broadcast

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-23-260596b0ae8e> in <module>
----> 1 a + b    # can't broadcast

ValueError: operands could not be broadcast together with shapes (4,) (3,)


print(a.shape, b.shape)

(4,) (3,)


a1 = a.reshape(4, 1)


a1 + b

array([[ 1.,  2.,  3.],
       [11., 12., 13.],
       [21., 22., 23.],
       [31., 32., 33.]])


print(a1.shape, b.shape)

(4, 1) (3,)


print(a1)

[[ 0.]
 [10.]
 [20.]
 [30.]]


x = np.array([ [ 0, 3, 4 ],
               [ 1, 6, 4 ] ])


x_norm = np.amax(x, axis=1)   # get row-wise max 
print(x_norm)

[4 6]


x / x_norm     # this does not work. Why?

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-13cb47700522> in <module>
----> 1 x / x_norm     # this does not work. Why?

ValueError: operands could not be broadcast together with shapes (2,3) (2,)


print(x.shape)
print(x_norm.shape)

(2, 3)
(2,)


x_norm = x_norm.reshape(2, 1)


x_norm

array([[4],
       [6]])


x / x_norm

array([[0.        , 0.75      , 1.        ],
       [0.16666667, 1.        , 0.66666667]])


# We can also use another normalization method 
x = np.array([ [ 0, 3, 4 ],
               [ 1, 6, 4 ] ])

# no need to reshape again 
x_norm = np.linalg.norm(x, ord = 2, axis = 1, keepdims = True) 
x / x_norm

array([[0.        , 0.6       , 0.8       ],
       [0.13736056, 0.82416338, 0.54944226]])


x_norm.shape

(2, 1)


help(np.linalg.norm)

Help on function norm in module numpy.linalg:

norm(x, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of eight different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    x : array_like
        Input array.  If `axis` is None, `x` must be 1-D or 2-D, unless `ord`
        is None. If both `axis` and `ord` are None, the 2-norm of
        ``x.ravel`` will be returned.
    ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object. The default is None.
    axis : {None, int, 2-tuple of ints}, optional.
        If `axis` is an integer, it specifies the axis of `x` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `x`
        is 1-D) or a matrix norm (when `x` is 2-D) is returned. The default
        is None.
    
        .. versionadded:: 1.8.0
    
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `x`.
    
        .. versionadded:: 1.10.0
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    See Also
    --------
    scipy.linalg.norm : Similar function in SciPy.
    
    Notes
    -----
    For values of ``ord < 1``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    'nuc'  nuclear norm                  --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The nuclear norm is the sum of the singular values.
    
    Both the Frobenius and nuclear norm orders are only defined for
    matrices and raise a ValueError when ``x.ndim != 2``.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from numpy import linalg as LA
    >>> a = np.arange(9) - 4
    >>> a
    array([-4, -3, -2, ...,  2,  3,  4])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4, -3, -2],
           [-1,  0,  1],
           [ 2,  3,  4]])
    
    >>> LA.norm(a)
    7.745966692414834
    >>> LA.norm(b)
    7.745966692414834
    >>> LA.norm(b, 'fro')
    7.745966692414834
    >>> LA.norm(a, np.inf)
    4.0
    >>> LA.norm(b, np.inf)
    9.0
    >>> LA.norm(a, -np.inf)
    0.0
    >>> LA.norm(b, -np.inf)
    2.0
    
    >>> LA.norm(a, 1)
    20.0
    >>> LA.norm(b, 1)
    7.0
    >>> LA.norm(a, -1)
    -4.6566128774142013e-010
    >>> LA.norm(b, -1)
    6.0
    >>> LA.norm(a, 2)
    7.745966692414834
    >>> LA.norm(b, 2)
    7.3484692283495345
    
    >>> LA.norm(a, -2)
    0.0
    >>> LA.norm(b, -2)
    1.8570331885190563e-016 # may vary
    >>> LA.norm(a, 3)
    5.8480354764257312 # may vary
    >>> LA.norm(a, -3)
    0.0
    
    Using the `axis` argument to compute vector norms:
    
    >>> c = np.array([[ 1, 2, 3],
    ...               [-1, 1, 4]])
    >>> LA.norm(c, axis=0)
    array([ 1.41421356,  2.23606798,  5.        ])
    >>> LA.norm(c, axis=1)
    array([ 3.74165739,  4.24264069])
    >>> LA.norm(c, ord=1, axis=1)
    array([ 6.,  6.])
    
    Using the `axis` argument to compute matrix norms:
    
    >>> m = np.arange(8).reshape(2,2,2)
    >>> LA.norm(m, axis=(1,2))
    array([  3.74165739,  11.22497216])
    >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :])
    (3.7416573867739413, 11.224972160321824)


i = np.array([
    [  [ 0.1,  0.1,  0.9 ], [ 0.2,  0.1,  0.9 ], [ 0.3,  0.1,  0.9 ]  ],
    
    [  [ 0.1,  0.2,  0.9 ], [ 0.2,  0.2,  0.9 ], [ 0.3,  0.2,  0.9 ]  ],

    [  [ 0.1,  0.3,  0.9 ], [ 0.2,  0.3,  0.9 ], [ 0.3,  0.3,  0.9 ]  ], 
    
    [  [ 0.1,  0.4,  0.9 ], [ 0.2,  0.4,  0.9 ], [ 0.3,  0.4,  0.9 ]  ]

])


i.shape

(4, 3, 3)


%matplotlib inline 
import matplotlib.pyplot as plt
import numpy as np


_ = plt.imshow(i)


i.reshape(36)    # we get a column "vector"

array([0.1, 0.1, 0.9, 0.2, 0.1, 0.9, 0.3, 0.1, 0.9, 0.1, 0.2, 0.9, 0.2,
       0.2, 0.9, 0.3, 0.2, 0.9, 0.1, 0.3, 0.9, 0.2, 0.3, 0.9, 0.3, 0.3,
       0.9, 0.1, 0.4, 0.9, 0.2, 0.4, 0.9, 0.3, 0.4, 0.9])


print(i.shape)
i_sh = i.shape
i.reshape(i_sh[0] * i_sh[1] * i_sh[2], 1)  # Also known as "flattening"

(4, 3, 3)

array([[0.1],
       [0.1],
       [0.9],
       [0.2],
       [0.1],
       [0.9],
       [0.3],
       [0.1],
       [0.9],
       [0.1],
       [0.2],
       [0.9],
       [0.2],
       [0.2],
       [0.9],
       [0.3],
       [0.2],
       [0.9],
       [0.1],
       [0.3],
       [0.9],
       [0.2],
       [0.3],
       [0.9],
       [0.3],
       [0.3],
       [0.9],
       [0.1],
       [0.4],
       [0.9],
       [0.2],
       [0.4],
       [0.9],
       [0.3],
       [0.4],
       [0.9]])


dim = 100    # try increasing this after running experiment


A = np.random.rand(dim, dim)
B = np.random.rand(dim, dim)


A[0].size, A[1].size

(100, 100)


def add_arrays(A, B): 
    C = np.zeros((A[0].size, A[1].size))
    
    for i in range(A[0].size): 
        for j in range(A[1].size): 
            C[i, j] = A[i, j] + B[i, j]
    return C


%time C = add_arrays(A, B)

CPU times: user 6.07 ms, sys: 130 µs, total: 6.2 ms
Wall time: 6.31 ms


%time C = A + B

CPU times: user 141 µs, sys: 70 µs, total: 211 µs
Wall time: 196 µs


import time 

# Non-vectorized time 
start = time.time() 

C = add_arrays(A, B)

end = time.time() 
non_vec_time = end - start 


## Vectorized time 
start = time.time() 

C = A + B 

end = time.time() 
vec_time = end - start


vec_time / non_vec_time * 100

4.1933430678797405


%%time
total = 0
for i in np.arange(100_000_000): 
    total += i 
print(total)

4999999950000000
CPU times: user 16 s, sys: 389 ms, total: 16.4 s
Wall time: 17.2 s


%time sum(np.arange(100_000_000))

CPU times: user 8.62 s, sys: 164 ms, total: 8.78 s
Wall time: 8.92 s

4999999950000000

Numpy Intro¶

Basics of Matrices¶

Matrix Operations¶

Array Operations¶

Misc Operations with Numpy¶

Broadcasting¶

Normalizing Rows and Columns¶

Reshaping Revisited¶

Vectorization¶