NOW PROVIDE THE PYTHON CODE TO EXECUTE THE COMPLETE PROCESS

Frank answered on July 17, 2023 Popularity 1/10 Helpfulness 1/10

answer NOW PROVIDE THE PYTHON CODE TO EXECUTE THE COMPLETE PROCESS

NOW PROVIDE THE PYTHON CODE TO EXECUTE THE COMPLETE PROCESS

Comment

import numpy as np
import matplotlib.pyplot as plt

# Define the sigmoid function
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# Define the derivative of the sigmoid function
def sigmoid_derivative(x):
    return x * (1 - x)

# Define the tanh function
def tanh(x):
    return np.tanh(x)

# Define the derivative of the tanh function
def tanh_derivative(x):
    return 1 - x**2

# Define the inputs and expected outputs for the XOR function
inputs = np.array([[0,0],[0,1],[1,0],[1,1]])
expected_output = np.array([[0],[1],[1],[0]])

epochs = 7000
lr = 0.1
inputLayerNeurons, hiddenLayerNeurons, outputLayerNeurons = 2,2,1

# Random weights and bias initialization
hidden_weights = np.random.uniform(size=(inputLayerNeurons,hiddenLayerNeurons))
hidden_bias =np.random.uniform(size=(1,hiddenLayerNeurons))
output_weights = np.random.uniform(size=(hiddenLayerNeurons,outputLayerNeurons))
output_bias = np.random.uniform(size=(1,outputLayerNeurons))

# Training algorithm
losses_sigmoid = []
for _ in range(epochs):
    # Forward Propagation
    hidden_layer_activation = np.dot(inputs,hidden_weights)
    hidden_layer_activation += hidden_bias
    hidden_layer_output = sigmoid(hidden_layer_activation)

    output_layer_activation = np.dot(hidden_layer_output,output_weights)
    output_layer_activation += output_bias
    predicted_output = sigmoid(output_layer_activation)

    # Backpropagation
    error = expected_output - predicted_output
    d_predicted_output = error * sigmoid_derivative(predicted_output)
    
    error_hidden_layer = d_predicted_output.dot(output_weights.T)
    d_hidden_layer = error_hidden_layer * sigmoid_derivative(hidden_layer_output)

    # Updating Weights and Biases
    output_weights += hidden_layer_output.T.dot(d_predicted_output) * lr
    output_bias += np.sum(d_predicted_output,axis=0,keepdims=True) * lr
    hidden_weights += inputs.T.dot(d_hidden_layer) * lr
    hidden_bias += np.sum(d_hidden_layer,axis=0,keepdims=True) * lr

    losses_sigmoid.append(np.sum(error**2))

print("Final hidden weights: ",end='')
print(*hidden_weights)
print("Final hidden bias: ",end='')
print(*hidden_bias)
print("Final output weights: ",end='')
print(*output_weights)
print("Final output bias: ",end='')
print(*output_bias)

print("\nOutput from neural network after 10,000 epochs with sigmoid activation: ",end='')
print(*predicted_output)


# Same training process but with tanh activation
hidden_weights = np.random.uniform(size=(inputLayerNeurons,hiddenLayerNeurons))
hidden_bias =np.random.uniform(size=(1,hiddenLayerNeurons))
output_weights = np.random.uniform(size=(hiddenLayerNeurons,outputLayerNeurons))
output_bias = np.random.uniform(size=(1,outputLayerNeurons))

losses_tanh = []
for _ in range(epochs):
    # Forward Propagation
    hidden_layer_activation = np.dot(inputs,hidden_weights)
    hidden_layer_activation += hidden_bias
    hidden_layer_output = tanh(hidden_layer_activation)

    output_layer_activation = np.dot(hidden_layer_output,output_weights)
    output_layer_activation += output_bias
    predicted_output = tanh(output_layer_activation)

    # Backpropagation
    error = expected_output - predicted_output
    d_predicted_output = error * tanh_derivative(predicted_output)
    
    error_hidden_layer = d_predicted_output.dot(output_weights.T)
    d_hidden_layer = error_hidden_layer * tanh_derivative(hidden_layer_output)

    # Updating Weights and Biases
    output_weights += hidden_layer_output.T.dot(d_predicted_output) * lr
    output_bias += np.sum(d_predicted_output,axis=0,keepdims=True) * lr
    hidden_weights += inputs.T.dot(d_hidden_layer) * lr
    hidden_bias += np.sum(d_hidden_layer,axis=0,keepdims=True) * lr

    losses_tanh.append(np.sum(error**2))

print("\nFinal hidden weights: ",end='')
print(*hidden_weights)
print("Final hidden bias: ",end='')
print(*hidden_bias)
print("Final output weights: ",end='')
print(*output_weights)
print("Final output bias: ",end='')
print(*output_bias)

print("\nOutput from neural network after 10,000 epochs with tanh activation: ",end='')
print(*predicted_output)

# Plot the loss over epochs
plt.figure(figsize=(15,5))
plt.plot(losses_sigmoid, label='Sigmoid Activation')
plt.plot(losses_tanh, label='Tanh Activation')
plt.title('Loss over epochs (lower is better)')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.grid(True)
plt.show()

Popularity 1/10 Helpfulness 1/10 Language python

Source: chat.openai.com

Tags: execute process python

Link to this answer
Share Copy Link

Contributed on Jul 17 2023

Frank

0 Answers Avg Quality 2/10

NOW PROVIDE THE PYTHON CODE TO EXECUTE THE COMPLETE PROCESS

Contents

More Related Answers

NOW PROVIDE THE PYTHON CODE TO EXECUTE THE COMPLETE PROCESS

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.