Need help modifying this code to implement the XOR function.

import math

import colorama

from colorama import Fore, Style

$"""$

Backpropagation Learning Algorithm Homework with XOR function

Name: Emily Dogbatse

CMS$430$: Artificial Intelligence

$"""$

colorama.init$($autoreset$=$True$)$

# Steps to do

# $1.$ activation function sigmoid $($DONE$)$

# $2.$ sigmoid derivative $($DONE$)$

# $3.$ forward propagation $($DONE$)$

# $4.$ Training function to calculate the error for the hidden layers $($DONE$)$

def print$\_$header$($message$)$:

$"""$

More cool ways to print for aesthetics

$"""$

print$($Fore$.$GREEN $+$ Style.BRIGHT $+"="*60)$

print$($f$"\{$message: $^60\}")$

print$($Fore$.$GREEN $+$ Style.BRIGHT $+"="*60+$ Style.RESET$\_$ALL$)$

def print$\_$subheader$($message$)$:

$"""$

Even more cool ways to print for aesthetics

$"""$

print$($Fore$.$YELLOW $+$ Style.BRIGHT $+"-"*60)$

print$($f$"\{$message: $^60\}")$

print$($Fore$.$YELLOW $+$ Style.BRIGHT $+"-"*60+$ Style.RESET$\_$ALL$)$

def printProgressBar$($iteration$,$ total, prefix$=\text{'}\text{'},$ suffix$=\text{'}\text{'},$ decimals$=1,$ length$=100,$ fill$=\text{'}\text{'},$ print$\_$end$="\backslash$r$")$:

$"""$

This function just prints out a cool loading bar, it doesn't have anything to do

with the actual program itself.

$"""$

percent $=("\{0$:$."+$ str$($decimals$)+"$f$\}").$format$(100*($iteration $/$ float$($total$)))$

filled$\_$length $=$ int$($length $*$ iteration $//$ total$)$

bar $=$ fill $*$ filled$\_$length $+\text{'}-\text{'}*($length $-$ filled$\_$length$)$

print$($f$\text{'}\backslash$r$\{$prefix$\}|\{$bar$\}|\{$percent$\}\%\{$suffix$\}\text{'},$ end$=$print$\_$end$)$

# Print New Line on Complete

if iteration $==$ total:

print$()$

def sigmoid$($x$)$:

return $1/(1+$ math.exp$(-$x$))$

def sigmoid$\_$derivative$($x$)$:

return x $*(1-$ x$)$

# Next steps : Forward propagation

# This step is basically adding the hidden layer

def forward$\_$propagation$($w$\_$hiddenlayer$\_1,$ w$\_$hiddenlayer$\_2,$ w$\_$output, x$\_$input$)$:

# hidden layer $1$

hidden$\_1\_$sum $=$ w$\_$hiddenlayer$\_1[0]+$ w$\_$hiddenlayer$\_1[1]*$ x$\_$input$[0]+$ w$\_$hiddenlayer$\_1[2]+$ x$\_$input$[1]$

hidden$1\_$output $=$ sigmoid$($hidden$\_1\_$sum$)$

# hidden layer $2$

hidden$\_2\_$sum $=$ w$\_$hiddenlayer$\_2[0]+$ w$\_$hiddenlayer$\_2[1]*$ x$\_$input$[0]+$ w$\_$hiddenlayer$\_2[2]+$ x$\_$input$[1]$

hidden$2\_$output $=$ sigmoid$($hidden$\_2\_$sum$)$

# output layer

output$\_$sum $=$ w$\_$output$[0]+$ w$\_$output$[1]*$ hidden$1\_$output $+$ w$\_$output$[2]*$ hidden$2\_$output

output $=$ sigmoid$($output$\_$sum$)$

# now return all of the outputs

return hidden$1\_$output, hidden$2\_$output, output

# what this returns is the output of the hidden layers and the output layer

# training function $($we did this by hand$)$

def training$($w$\_$hiddenlayer$\_1,$ w$\_$hiddenlayer$\_2,$ w$\_$output, x$\_$input, target, eta$)$:

# forward pass

hidden$1\_$output, hidden$2\_$output, output $=$ forward$\_$propagation$($w$\_$hiddenlayer$\_1,$ w$\_$hiddenlayer$\_2,$ w$\_$output, x$\_$input$)$

# printing the results to make sure this works

print$($f$"$Input: $\{$x$\_$input$\},$ Actual Output: $\{$output$\},$ Target: $\{$target$\}")$

# calculate the error

# we want to minimize this in order to classify correctly

output$\_$error $=$ target $-$ output

# error for hidden layer $1$:

hidden$1\_$error $=$ output$\_$error $*$ w$\_$output$[1]*$ sigmoid$\_$derivative$($hidden$1\_$output$)$

# error for hidden layer $2$:

hidden$2\_$error $=$ output$\_$error $*$ w$\_$output$[2]*$ sigmoid$\_$derivative$($hidden$2\_$output$)$

# NEXT STEP: UPDATE THE OUTPUT LAYER WEIGHTS

w$\_$output$[0]+=$ eta $*$ output$\_$error

w$\_$output$[1]+=$ eta $*$ output$\_$error $*$ hidden$1\_$output

w$\_$output$[2]+=$ eta $*$ output$\_$error $*$ hidden$2\_$output

# update the hidden$-$layer weights at each hidden neuron

w$\_$hiddenlayer$\_1[0]+=$ eta $*$ hidden$1\_$error

w$\_$hiddenlayer$\_1[1]+=$ eta $*$ hidden$1\_$error $*$ x$\_$input$[0]$

w$\_$hiddenlayer$\_1[2]+=$ eta $*$ hidden$1\_$error $*$ x$\_$input$[1]$

w$\_$hiddenlayer$\_2[0]+=$ eta $*$ hidden$2\_$error

w$\_$hiddenlayer$\_2[1]+=$ eta $*$ hidden$2\_$error $*$ x$\_$input$[0]$

w$\_$hiddenlayer$\_2[2]+=$ eta $*$ hidden$2\_$error $*$ x$\_$input$[1]$

return w$\_$hiddenlayer$\_1,$ w$\_$hiddenlayer$\_2,$ w$\_$output

# train one full epoch

def epoch$\_$XOR$($w$\_$hidden$1,$ w$\_$hidden$2,$ w$\_$output, eta$)$:

# XOR function this time

w$\_$hidden$1,$ w$\_$hidden$2,$ w$\_$output $=$ training$($w$\_$hidden$1,$ w$\_$hidden$2,$ w$\_$output, $[0,0],0,$ eta$)$

w$\_$hidden$1,$ w$\_$hidden$2,$ w$\_$output $=$ training$($w$\_$hidden$1,$ w$\_$hidden$2,$ w$\_$output, $[0,1],1,$ eta$)$

w$\_$hidden$1,$ w$\_$hidden$2,$ w$\_$output $=$ training$($w$\_$hidden$1,$ w$\_$hidden$2,$ w$\_$output, $[1,0],1,$ eta$)$

w$\_$hidden$1,$ w$\_$hidden$2,$ w$\_$output $=$ training$($w$\_$hidden$1,$ w$\_$hidden$2,$ w$\_$output, $[1,1],0,$ eta$)$

return w$\_$hidden$1,$ w$\_$hidden$2,$ w$\_$output

# driver code As

def main$()$:

print$\_$header$("$Backpropagation Learning Algorithm for XOR"$)$

# Initialize the weights

w$\_$hidden$1=[-0\mathrm{.}08,1,0\mathrm{.}99]$ # w$10,$ w$11,$ w$12$

w$\_$hidden$2=[-0\mathrm{.}02,1,1]$

w$\_$output $=[-0\mathrm{.}01,1\mathrm{.}10,1\mathrm{.}10]$

eta $=0\mathrm{.}1$

training$\_$data $=[([0,0],0),([0,1],1),([1,0],1),([1,1],0)]$

# Introducing a stopping criterion

max$\_$epochs $=10000$

error$\_$threshold $=0\mathrm{.}001$

print$\_$subheader$("$Training Neural Network..."$)$

print$("$Progress: $",$ end$="")$

Assume there is the rest of the main here