top of page

MLP-Multiclass-Classifier-MNIST(non-minibatch) - Neural Network Assignment Help

realcode4you

Import Necessary Packages

from DL_utilities import*
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
from sklearn import metrics
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.datasets import fetch_openml
%matplotlib inline

Data Preparation

mnist = fetch_openml("mnist_784")

X, y = mnist["data"], mnist["target"]

print("Shape of X", X.shape)
print("Shape of Y", y.shape)
count=0
sample_size=20
plt.figure(figsize=(20, 20))
for i in range(sample_size):
    plt.subplot(1, sample_size, i+1)
    plt.axhline('')
    plt.axvline('')
    plt.text(x=10, y=-5, s=y[i], fontsize=20)
    plt.imshow(X[i,:].reshape([28,28]), cmap='Greys')
plt.show()
# Scaling the X value
X = X / 255
# one-hot encode labels
digits = 10
examples = y.shape[0]
y = y.reshape(1, examples)
Y_new = np.eye(digits)[y.astype('int32')]
Y_new = Y_new.T.reshape(digits, examples)
np.random.seed(30)
# split, reshape, shuffle
m = 60000
m_test = X.shape[0] - m
X_train, X_test = X[:m].T, X[m:].T
Y_train, Y_test = Y_new[:,:m], Y_new[:,m:]
shuffle_index = np.random.permutation(m)
X_train, Y_train = X_train[:, shuffle_index], Y_train[:, shuffle_index]
print("X_train shape", X_train.shape)
print("Y_train shape", Y_train.shape)
print("X_test shape", X_test.shape)
print("Y_test shape", Y_test.shape)
count=0
sample_size=20
plt.figure(figsize=(20, 20))
for i in range(sample_size):
    count = count + 1
    plt.subplot(4,5,i+1)
    plt.axhline('')
    plt.axvline('')
    plt.text(x=0, y=30, s=Y_train[:,i], fontsize=15)
    plt.imshow(X_train[:,i].reshape(28,28), cmap='Greys')
plt.show()


Nueral Network Model

def softmax(Z):
    exps = np.exp(Z - Z.max())  # Numerically stable with large exponentials
    A = exps / np.sum(exps, axis=0)
    return A, Z

def softmax_gradient(dA, Z):
    A, Z = softmax(Z)
    dZ = dA * A * (1 - A) # softmax gradient, dA/dZ = AL(1-AL)
    return dZ

def linear_activation_forward(A_prev, W, b, activation_fn):
        
    if activation_fn == "sigmoid":
        Z, linear_cache = linear_forward(A_prev, W, b)
        A, activation_cache = sigmoid(Z)

    elif activation_fn == "tanh":
        Z, linear_cache = linear_forward(A_prev, W, b)
        A, activation_cache = tanh(Z)

    elif activation_fn == "relu":
        Z, linear_cache = linear_forward(A_prev, W, b)
        A, activation_cache = relu(Z)

    elif activation_fn == "softmax":
        Z, linear_cache = linear_forward(A_prev, W, b)
        A, activation_cache = softmax(Z)
        
    assert A.shape == (W.shape[0], A_prev.shape[1])

    cache = (linear_cache, activation_cache)

    return A, cache

def linear_activation_backward(dA, cache, activation_fn):
    
    linear_cache, activation_cache = cache

    if activation_fn == "sigmoid":
        dZ = sigmoid_gradient(dA, activation_cache)
        dA_prev, dW, db = linear_backward(dZ, linear_cache)

    elif activation_fn == "tanh":
        dZ = tanh_gradient(dA, activation_cache)
        dA_prev, dW, db = linear_backward(dZ, linear_cache)

    elif activation_fn == "relu":
        dZ = relu_gradient(dA, activation_cache)
        dA_prev, dW, db = linear_backward(dZ, linear_cache)
        
    elif activation_fn == "softmax":
        dZ = softmax_gradient(dA, activation_cache)
        dA_prev, dW, db = linear_backward(dZ, linear_cache)
    return dA_prev, dW, db

def L_model_forward_new(X, parameters, hidden_layers_activation_fn="relu", multiclass=True):
    A = X                           
    caches = []
    L = len(parameters) // 2        

    for l in range(1, L):
        A_prev = A
        A, cache = linear_activation_forward(
            A_prev, parameters["W" + str(l)], parameters["b" + str(l)],
            activation_fn=hidden_layers_activation_fn)
        caches.append(cache)

    if multiclass:
        output_layer="softmax"
    else:
        output_layer="sigmoid"
        
    AL, cache = linear_activation_forward(
        A, parameters["W" + str(L)], parameters["b" + str(L)],
        activation_fn=output_layer)
    
    caches.append(cache)
    return AL, caches

def L_model_backward_new(AL, y, caches, hidden_layers_activation_fn="relu", multiclass=False):
    
    y = y.reshape(AL.shape)
    L = len(caches)
    grads = {}

    if multiclass:
        output_layer="softmax"
    else:
        output_layer="sigmoid"
        
    dAL = np.divide(AL - y, np.multiply(AL, 1 - AL))

    grads["dA" + str(L - 1)], grads["dW" + str(L)], grads[
        "db" + str(L)] = linear_activation_backward(
            dAL, caches[L - 1], output_layer)

    for l in range(L - 1, 0, -1):
        current_cache = caches[l - 1]
        grads["dA" + str(l - 1)], grads["dW" + str(l)], grads[
            "db" + str(l)] = linear_activation_backward(
                grads["dA" + str(l)], current_cache,
                hidden_layers_activation_fn)
    return grads
# For multiclass classification
def CrossEntropy(AL, y):
    cost_sum = np.sum(np.multiply(y, np.log(AL)))          
    m = y.shape[1]
    cost = -(1./m) * cost_sum
    return cost

# For multiclass classification
def evaluate_cost_acc(X, y, params, activation_fn):
    AL, caches = L_model_forward_new(X, params, activation_fn)
    cost = CrossEntropy(AL,y)
    predictions = np.argmax(AL, axis=0)
    labels = np.argmax(y, axis=0)
    accuracy = metrics.accuracy_score(predictions, labels)
    return cost, accuracy*100


Neural Network Training

np.random.seed(48)

# Neural Network Model and Initialize parameters
# 784 --> 20 --> 15 --> 10
layers_dims = [X_train.shape[0], 20, 15, 10]
params = initialize_parameters(layers_dims)
hn_activation = "sigmoid"

# Hyper-parameters
learning_rate = 0.5
number_of_epoch=100

# intialize cost lists
train_costs, train_accs, test_costs, test_accs = [],[],[],[]

for epoch in range(number_of_epoch):
    AL, caches = L_model_forward_new(X_train, params, hn_activation, multiclass=True)
    grads = L_model_backward_new(AL, Y_train, caches, hn_activation, multiclass=True)
    params = update_parameters(params, grads, learning_rate)

    train_cost, train_acc = evaluate_cost_acc(X_train, Y_train, params, hn_activation)
    test_cost, test_acc = evaluate_cost_acc(X_test, Y_test, params, hn_activation)
    train_costs.append(train_cost)
    test_costs.append(test_cost)
    train_accs.append(train_acc)
    test_accs.append(test_acc)
    print("Epoch {}: \ntraining cost = {:.3f}, training accuracy = {:.2f}, \
          \ntest cost = {:.3f}, test accuracy = {:.2f}".format(
        epoch+1, train_cost, train_acc, test_cost, test_acc))

print("Done.")


Contact Us ir send your requirement details at:



Commentaires


REALCODE4YOU

Realcode4you is the one of the best website where you can get all computer science and mathematics related help, we are offering python project help, java project help, Machine learning project help, and other programming language help i.e., C, C++, Data Structure, PHP, ReactJs, NodeJs, React Native and also providing all databases related help.

​

Hire Us to get Instant help from realcode4you expert with an affordable price.

USEFUL LINKS

Discount

ADDRESS

Noida, Sector 63, India 201301

Follows Us!

  • Facebook
  • Twitter
  • Instagram
  • LinkedIn

OUR CLIENTS BELONGS TO

  • india
  • australia
  • canada
  • hong-kong
  • ireland
  • jordan
  • malaysia
  • new-zealand
  • oman
  • qatar
  • saudi-arabia
  • singapore
  • south-africa
  • uae
  • uk
  • usa

© 2023 IT Services provided by Realcode4you.com

bottom of page