<audio id=""demo"" src=""audio.

mp3""></audio>
<div>
<button onclick=""document.getElementById('demo').play()"">
Play the Audio </button>
</div>

from itertools import combinations

from itertools import permutations
import numpy as np
import math
arr=np.array(['H','O','R','S','E'])
print(len(list(combinations(arr, 2)) ))
print(len(list(permutations(arr,2) )))
ort numpy as np
from scipy import stats
import statistics

def measures(arr):
#Write your code here
'''
Input: arr : numpy array
Return : mean,median,std_deviation,variance,mode,iqr : float

Note:
1. Assign the values to designated variables
2. Round off to 2 decimal places
'''
n=len(arr)
mean=np.mean(arr)
median=np.median(arr)
std_deviation=round(np.std(arr),2)
variance=round(np.var(arr),2)
mode=int(stats.mode(numbers)[0])
iqr=(np.percentile(arr,75,interpolation='midpoint')-
np.percentile(arr,25,interpolation='midpoint'))

return mean,median,std_deviation,variance,mode,iqr

if __name__=='__main__':
array1=[]
n=int(input())
for i in range(n):
array1.append(float(input()))
narray1=np.array(array1)
print(measures(narray1))

import math
red=math.factorial(10)/((math.factorial(7))*math.factorial(3))
blue=math.factorial(8)/((math.factorial(3))*math.factorial(5))
print(red*blue)
from scipy import stats
import numpy as np
import statistics
data ={"A": 90,"B": 86,"C":70,"D":95,"E":95,"F":95,"G":95}
values = list(data.values())
print("Mean")
print(np.mean(values))
print("Median")
print(np.median(values))
print("Mode")
print(statistics.mode(values))
print("Standard Deviation")
print(np.std(values))
print("Variance")
print(np.var(values))
print("range")
print(stats.iqr(values))

Find

P(getting even or prime)=P(A∪B)P(A\cup B)P(A∪B)

prob_getting_even=3/6
prob_getting_prime=3/6
prob_even_and_prime=1/6
prob_even_or_prime=0.5+0.5-0.16
print(prob_even_or_prime)

prob_getting_king=1/13
prob_getting_queen=1/13
prob_king_or_queen=2/13
print(prob_king_or_queen)

Result

0.153

Question:

80 % of people who purchase pet insurance are women. If 9 pet insurance owners are
randomly selected, find the probability that precisely 6 are women.

Solution:

#n=9
#p=0.80
#k=6
from scipy import stats
probability=stats.binom.pmf(6,9,0.80)
print(probability)

Question:

If the number of vehicles that pass through a junction on a busy road is at an

average rate of 300 per hour, find the probability that no vehicle passes in a
given minute.

Python Code

from scipy import stats

averagepass=300/60
probability=stats.poisson.pmf(0, averagepass)
print(probability)

from scipy.stats import chi2_contingency

from scipy.stats import chi2
table =[[30, 10], [15, 25], [15, 5]]
stat,p,dof,expected = chi2_contingency(table)
prob = 0.05
critical = chi2.ppf(prob, dof)
if abs(stat) >= critical:
print('Dependent (reject H0)')
else:
print('Independent (fail to reject H0)')

Output

[[30, 10], [15, 25], [15, 5]]

-----------------------
Expected Values
[[24. 16.]
[24. 16.]
[12. 8.]]
-------------------------------------
Chi-Square Statistic = 14.062
Degree of Freedom =2
P value = 0.001
-------------------------------------
Significance level =0.050, P-Value=0.001
Dependent : Reject the null Hypothesis

from scipy.stats import chi2_contingency

from scipy.stats import chi2

def chi_test():
'''
Output
1. stat: Float
2. dof : Integer
3. p_val: Float
4. res: String
'''
#Note: Round off the Float values to 2 decimal places.

table = [[18, 36, 21, 9, 6], [12, 36, 45, 36, 21], [6, 9, 9, 3, 3], [3, 9, 9,6,
3]]

stat,p,dof,expected= chi2_contingency(table)

if p<=0.05:
res='Reject the Null Hypothesis'
 else:
res='Failed to reject the Null Hypothesis'

return stat,dof,p_val

if __name__=='__main__':
print(chi_test())

Dataset Download
Dataset Download

The dataset is available at the location: http://www.cs.toronto.edu/~kriz/cifar-10-

python.tar.gz

Open the terminal and type the below command to download :

curl http://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz>cifar-10-python.tar.gz

This downloads the data and saves it as cifar-10-python.tar.gz.

Extract the tar.gz file using the subsequent command:

tar -xzvf cifar-10-python.tar.gz

import os
import numpy as np
def _load_cifar10_batch(file):
import cPickle
fo = open(file, 'rb')
dict = cPickle.load(fo)
fo.close()
return dict['data'].reshape(-1, 32, 32, 3), dict['labels'] # reshaping the data
to 32 x 32 x 3
print('Loading...')
batch_fns = [os.path.join("./", 'cifar-10-batches-py', 'data_batch_' + str(i)) for
i in range(1, 6)]
data_batches = [_load_cifar10_batch(fn) for fn in batch_fns]

Data Stacking
Data Stacking
The batches loaded are stacked into a big array.

data_all = np.vstack([data_batches[i][0] for i in

range(len(data_batches))]).astype('float')
labels_all = np.vstack([data_batches[i][1] for i in
range(len(data_batches))]).flatten()

Subset Generation

As explained in dataset description, we use only a subset of CIFAR-10 dataset.

The dataset with 50,000 samples is split in the ratio 92:8. This split is done
to take a smaller portion of 50000 samples (i.e the 8% contains only 4000 images).

These 4000 samples are used for generating the train and test sets for
classification.

Here, StratifiedShuffleSplit is used to split the dataset. It splits the data by

taking equal number of samples from each class in a random manner.

#Splitting the whole training set into 92:8

seed=7
from sklearn.cross_validation import StratifiedShuffleSplit
data_split = StratifiedShuffleSplit(labels_all,1, test_size=0.08,random_state=seed)
#creating data_split object with 8% test size
for train_index, test_index in data_split:
split_data_92, split_data_8 = data_all[train_index], data_all[test_index]

split_label_92, split_label_8 = labels_all[train_index], labels_all[test_index]

Data Splitting
Data Splitting

4000 samples are split in the ratio 7:3. (i.e., 2800 for training and 1200 for
testing) using StratifiedShuffleSplit.

#Splitting the training set into 70 and 30

train_test_split = StratifiedShuffleSplit(split_label_8,1,
test_size=0.3,random_state=seed) #test_size=0.3 denotes that 30 % of the dataset is
used for testing.
for train_index, test_index in train_test_split:
train_data_70, test_data_30 = split_data_8[train_index],
split_data_8[test_index]
train_label_70, test_label_30 = split_label_8[train_index],
split_label_8[test_index]
train_data = train_data_70 #assigning to variable train_data
train_labels = train_label_70 #assigning to variable train_labels
test_data = test_data_30
test_labels = test_label_30

You can see the size of the above variables using:

print 'train_data : ', train_data.shape

print 'train_labels : ', train_labels.shape
print 'test_data : ', test_data.shape
print 'test_labels : ', test_labels.shape

Normalization

Normalization is the process of converting the pixel intensity values to a normal

state.

It follows a normal distribution.

A normalized image has mean = 0 and variance = 1

# definition of normalization function

def normalize(data, eps=1e-8):
data -= data.mean(axis=(1, 2, 3), keepdims=True)
std = np.sqrt(data.var(axis=(1, 2, 3), ddof=1, keepdims=True)) # calculating
standard deviation
std[std < eps] = 1.
data /= std
return data
# calling the function
train_data = normalize(train_data)
test_data = normalize(test_data)
# prints the shape of train data and test data
print 'train_data: ', train_data.shape
print 'test_data: ', test_data.shape

You can also try out the same in python Sklearn library using the following link .

ZCA Whitening

Normalization is followed by a ZCA whitening process.

The main aim of whitening is to reduce data redundancy, which means the features
are less correlated and have the same variance.

ZCA stands for zero-phase component analysis. ZCA whitened images resemble the
normal image.

# Computing whitening matrix

train_data_flat = train_data.reshape(train_data.shape[0], -1).T
test_data_flat = test_data.reshape(test_data.shape[0], -1).T
print('train_data_flat: ', train_data_flat.shape)
print('test_data_flat: ', test_data_flat.shape)
train_data_flat_t = train_data_flat.T
test_data_flat_t = test_data_flat.T

ZCA Whitening

Normalization is followed by a ZCA whitening process.

The main aim of whitening is to reduce data redundancy, which means the features
are less correlated and have the same variance.

ZCA stands for zero-phase component analysis. ZCA whitened images resemble the
normal image.
# Computing whitening matrix
train_data_flat = train_data.reshape(train_data.shape[0], -1).T
test_data_flat = test_data.reshape(test_data.shape[0], -1).T
print('train_data_flat: ', train_data_flat.shape)
print('test_data_flat: ', test_data_flat.shape)
train_data_flat_t = train_data_flat.T
test_data_flat_t = test_data_flat.T

Singular Value Decomposition (SVD)

The below code for SVD may not work in the available online cloud playground due to
package issues. So, it is better to try this out in a local Python environment.

from skimage import color

# definition for SVD
def svdFeatures(input_data):
svdArray_input_data=[]
size = input_data.shape[0]
for i in range (0,size):
img=color.rgb2gray(input_data[i])
U, s, V = np.linalg.svd(img, full_matrices=False);
S=[s[i] for i in range(30)]
svdArray_input_data.append(S)
svdMatrix_input_data=np.matrix(svdArray_input_data)
return svdMatrix_input_data
# apply SVD for train and test data
train_data_svd=svdFeatures(train_data)
test_data_svd=svdFeatures(test_data)

Singular Value Decomposition (SVD)

The below code for SVD may not work in the available online cloud playground due to
package issues. So, it is better to try this out in a local Python environment.

from skimage import color

# definition for SVD
def svdFeatures(input_data):
svdArray_input_data=[]
size = input_data.shape[0]
for i in range (0,size):
img=color.rgb2gray(input_data[i])
U, s, V = np.linalg.svd(img, full_matrices=False);
S=[s[i] for i in range(30)]
svdArray_input_data.append(S)
svdMatrix_input_data=np.matrix(svdArray_input_data)
return svdMatrix_input_data
# apply SVD for train and test data
train_data_svd=svdFeatures(train_data)
test_data_svd=svdFeatures(test_data)

Support Vector Machine (SVM)

Support Vector Machine (SVM) is effective in:

High-dimensional spaces.

In cases, where, the number of dimensions > the number of samples.

In cases with a clear margin of separation.

Given below is the code snippet for training in SVM:

from sklearn import svm #Creating a svm classifier model

clf = svm.SVC(gamma=.001,probability=True) #Model training

clf.fit(train_data_flat_t, train_labels) #After being fitted, the model can then be

used to predict the output.

Here, train_data_flat_t can be replaced with train_data_pca or train_data_svd for

PCA and SVD respectively.

***********************************************************************************
***********************************************************

DNN and SNN

Normalising the Data

Since the data is in terms of length we need to scale to data to have normal
distribution.

For this we take maximum and minimum of each feature.

Subtract each feature by its minimum value.

Finally, divide the result by difference of maximum and minimum value

import numpy as np

def normalize(data):

col_max = np.max(data, axis = 0)

col_min = np.min(data, axis = 0)

return np.divide(data - col_min, col_max - col_min)

X_norm = normalize(X)

Dot product Example

Sample code in Python for a dot product

import numpy as np

#matrix a
a = np.array([[1,2],[3,4]])

print("matrix a dimension ", a.shape)

#matrix b

b = np.array([[5,6,7],[8,9, 10]])

print("matrix b dimension ", b.shape)

#matrix c = a.b

c = np.dot(a,b)

print("dot product of a and b: ", c)

print("matrix c dimension ", c.shape)

output:

matrix a dimension (2, 2)

matrix b dimension (2, 3)

dot product of a and b: [[21 24 27]

[47 54 61]]

matrix c dimension (2, 3)

Element wise product

Sample code for element-wise product in Python

import numpy as np

#matrix a

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

print("matrix a dimension ", a.shape)

#matrix b

b = np.array([[5,6],[8,9]])

print("matrix b dimension ", b.shape)

#matrix c = a * b

c = np.multiply(a,b)

print("element wise product of matrices a and b: ", c)

print("matrix c dimension ", c.shape)

output:

matrix a dimension (2, 2)

matrix b dimension (2, 2)

element wise product of matrices a and b: [[ 5 12]

[24 36]]

matrix c dimension (2, 2)

Broadcasting Examples

1. Multiplication of a matrix and a row vector

a = np.array([[10, 10, 10], [20, 20, 20], [30, 30, 30]])

b = np.array([1, 2, 3])

c = a * b

print(c)

output:

[[10 20 30]

[20 40 60]

[30 60 90]]

2. Addition of a matrix and a scalar

a = np.array([[10, 10, 10], [20, 20, 20], [30, 30, 30]])

b = 1

c = a + b
print(c)

output:

[[11 11 11]

[21 21 21]

[31 31 31]]

3. Element-wise function call

def exp(x, n):

return x ** n

a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

print(exp(a, 2))

output:

[[ 1 4 9]

[16 25 36]

[49 64 81]]

#Note that each element of array **a** has been raised to power 2

Representation of Array Using numpy

array1d = np.array([1,2,3,4])
print("shape of array1d before reshaping: ", array1d.shape)
array1d = array1d.reshape(1,4)
print("shape of array1d after reshaping: ", array1d.shape)
#rank of matrix can be found using np.linalg.matrix_rank() function
print("array1d is a martrix of rank {}".format(np.linalg.matrix_rank(array1d)))
output:
shape of array1d before reshaping: (4,)
shape of array1d after reshaping: (1, 4)
array1d is a martrix of rank 1

The shape (4,) just represents that the array has 4 elements.

The shape (1, 4) represents that array has 4 elements with one row and four
columns.

Importing the Data

 The following code snippet shows how to way to extract iris data from Scikit-
learn.

from sklearn import datasets

iris = datasets.load_iris()
#extracting first 100 samples pertaining #to iris setosa and verginica
X = iris.data[:100, :4]
#actual output
Y = iris.target[:100]

Getting Dimensions Right

Now the data X_norm is of shape (100,4)

But for SNN we need to have the data of shape (no_of_features x no_of_samples).
So take a transpose of X_norm.

The Y data is a list of shape (100,). Convert it a vector of shape (1,100) by

using reshape() function.

X_norm=X.reshape(100,4)

X_data = X_norm.T

Y_data = Y.reshape(1,100)

print(X_data.shape)

print(Y_data.shape)

output:

(4,100)

(1,100)

Initialising Weights and Bias

Before we start the forward propagation, we need to initialize weights and bias
to some random values.

Since we have four features, we need to have weight vector of shape (4,1) and
one bias term of shape (1,1).

In this case, we initialize all our weights and bias to zero.

def initialiseNetwork(num_features):

W = np.zeros((num_features, 1))

b = 0
 parameters = {"W": W, "b": b}

return parameters

Defining Activation Function

Before going with the forward propagation, we need to define an activation

function for the neuron.

Since this is a binary classification, let's consider a sigmoid function that

maps any linear input to values between 0 to 1.

The sigmoid activation function is implemented as shown in the below code

snippet.

def sigmoid(z):

return 1/(1 + np.exp(-z))

Forward Propagation

You have seen the theoretical implementation of forward propagation in the

previous topic.

The same is implemented in Python as follows:

def forwardPropagation(X, Y, parameters):

W = parameters["W"]

b = parameters["b"]

Z = np.dot(W.T,X) + b

A = sigmoid(Z)

return A

Calculating cost function for a given number of samples.

def cost(A, Y, num_samples):

return -1/num_samples *np.sum(Y*np.log(A) + (1-Y)*(np.log(1-A)))

Defining Backpropagation

From forward propagation, you know the output A.

Using this output, you need to find the derivatives of weights and bias

def backPropagration(X, Y, A, num_samples):

 dZ = A - Y

dW = (np.dot(X,dZ.T))/num_samples

db = np.sum(dZ)/num_samples

return dW, db

Updating Parameters

Once we have the derivatives, you need to subtract them from original weights
and bias.

While subtracting, we multiply the derivatives with a learning rate to have

control over the gradient at each step of iteration.

def updateParameters(parameters, dW, db, learning_rate):

W = parameters["W"] - (learning_rate * dW)

b = parameters["b"] - (learning_rate * db)

return {"W": W, "b": b}

Defining the Model

Using all the function defined so far let's define the model to initialize and
train the SNN.

def model(X, Y, num_iter, learning_rate):

num_features = X.shape[0]
num_samples = float(X.shape[1])
parameters = initialiseNetwork(num_features)
for i in range(num_iter):
A = forwardPropagation(X, Y, parameters)
if(i%100 == 0):
print("cost after {} iteration: {}".format(i, cost(A, Y, num_samples)))
dW, db = backPropagration(X, Y, A, num_samples)
parameters = updateParameters(parameters, dW, db, learning_rate)
return parameters

Training the Model

Train the model using iris dataset with learning rate 0.1 and number of
iteration equal to 1000.

parameters = model(X_data, Y, 1000, 0.1)

output:

cost after 0 iteration: 0.69314718056

cost after 100 iteration: 0.361323737602

cost after 200 iteration: 0.234699727458

cost after 300 iteration: 0.171513661704

cost after 400 iteration: 0.134598207666

cost after 500 iteration: 0.110633930302

cost after 600 iteration: 0.0938999866314

cost after 700 iteration: 0.0815813584762

cost after 800 iteration: 0.0721454431571

cost after 900 iteration: 0.0646909798272

You can see that at every iteration the cost is reducing approaching close to
zero.
***********************************************************************************
***********************************************************************
Now, you know that the input to a CNN is an N-dimensional data. If it's a digital
image then its dimension is

(\small number\_of\_rowsnumber_of_rows x \small

number\_of\_columnsnumber_of_columns x \small
number\_of\_channelsnumber_of_channels)

An additional dimension is added for the input which represents the number of
samples, so final dimension would be

(\small num\_samplesnum_samples x \small number\_of\_rowsnumber_of_rows x \small

number\_of\_columnsnumber_of_columns x \small
number\_of\_channelsnumber_of_channels)

usually represented as mm x n_hn

h
x n_wn
w
x n_cn
c

***********************************************************************************
**********************************************************
Implementation using NumPy
A = np.random.randint(0,10, size= (3,3,3))
W = np.random.randint(0,10, size= (3,3,3))

scalar = np.sum(np.multiply(A, W)) ### numpy implementation to perform convolution

print(scalar)
688
***********************************************************************************
***********************************************************
Padding - NumPy
def zero_pad(data, pad):
data_pad = numpy.pad(array = data, pad_width = ((0,0),(pad,pad), (pad,pad),
(0,0)), mode = 'constant', constant_values = 0)
 return data_pad
***********************************************************************************
***********************************************************************
Strided Convolution Using NumPy
A detailed explation of this code is provided in the next card.

def conv_forward(A_prev, W, b, hparams):

stride = hparams["stride"]
pad = hparams["pad"]

m, h_prev, w_prev, c_prev = A_prev.shape

number of channels in the input

f, f, c_prev, n_c = W.shape

n_h = int((h_prev - f + 2*pad)/stride) + 1

n_w = int((w_prev - f + 2*pad)/stride) + 1

Z = np.zeros((m, n_h, n_w, n_c))

A_prev_pad = zero_pad(A_prev, pad)
for i in range(m):
for h in range(n_h):
for w in range(n_w):
for c in range(n_c):
w_start = w * stride
w_end = w_start + f
h_start = h * stride
h_end = h_start + f

Z[i,h,w,c] = conv_single_step(A_prev_pad[i, h_start:h_end,

w_start:w_end, :], W[:,:,:,c], b[:,:,:,c])
return Z
***********************************************************************************
************************************************************************
Pooling - NumPy Implementation
The below method performs max pooling on the given input using filter size and
padding provided by hparam.

def max_pool(input, hparam):

m, h_prev, w_prev, c_prev = input.shape
f = hparam["f"] ## f is the filter size to use for pooling
stride = hparam["stride"]
h_out = int(((h_prev - f)/stride) + 1)
w_out = int(((w_prev -f)/stride) + 1)
output = np.zeros((m, h_out, w_out, c_prev))
for i in range(m):
for c in range(c_prev):
for h in range(h_out):
for w in range(w_out):
w_start = w * stride
w_end = w_start + f
h_start = h * stride
h_end = h_start + f
output[i, h, w, c] = np.max(input[i,h_start:h_end,
w_start:w_end, c])
print(output.shape)
assert output.shape == (m, h_out, w_out, c_prev)
return output
***********************************************************************************
********************************************************************************