Consider a network with two inputs, x$1$ and x$2,$ two hidden neurons and one output neuron. The network has $9$ total parameters: I just want to know the FINAL weights and what they should be$.$ I have done it by hand and code. Please only the final weights.

w$11,$ the weight connecting input $1$ to hidden neuron $1$

w$12,$ the weight connecting input $2$ to hidden neuron $1$

w$10,$ the bias for hidden neuron $1,$ which has an implicit associated input of x$0=1$

w$21,$ the weight connecting input $1$ to hidden neuron $2$

w$22,$ the weight connecting input $2$ to hidden neuron $2$

w$20,$ the bias for hidden neuron $2,$ which has an implicit associated input of x$0=1$

w$31,$ the weight connecting hidden$-$layer neuron $1$ to the output neuron

w$32,$ the weight connecting hidden$-$layer neuron $2$ to the output neuron

w$30,$ the bias for the output neuron, which has an implicit associated input of o$0=1$

Diagram

Draw a diagram of network including all of the connections $($make it big$),$ and label everything with its appropriate weight.

Forward$-$Calculation

Let's start with the following weights:

w$11=1$

w$12=1$

w$10=0$

w$21=1$

w$22=1$

w$20=0$

w$31=1$

w$32=1$

w$30=0$

$($All of the connections are $1$ and all of the biases are zero$).$

We'll work on training the logical$-$AND function that we previously used for the single layer perceptron. Here is its truth table:

x$\_1$ x$\_2|$ target label $($t$)$

$------------------------------$

$000$

$010$

$100$

$111$

First, use the network as configured to attempt to classify each point. Perform a forward$-$pass through the network by hand for each of the four points. What results do you obtain?

for each hidden layer node j:

y$\_$j $=$ the weighted sum of inputs to node j

o$\_$j $=$ sigmoid$($y$\_$j$)$

for the output layer node k:

y$\_$k $=$ the weighted sum of hidden layer o$\_$j values to node k

o$\_$k $=$ sigmoid$($y$\_$k$)$

if o$\_$k $<=\mathrm{.}5$:

assign class $0$

else:

assign class $1$

Train

We'll now train the network by hand using the backpropagation update rules. I$\text{'}$m not repeating the update rules here, because they're hard to type, but you have them in your notes.

Iterate one point at a time. Use a learning rate of $\mathrm{.}1.$

Classify the point using the forward pass. In doing so$,$ you'll obtain values for each yj and oj at the hidden$-$layer nodes, and yk and ok at the output layer.

Update the weights $($and the bias$)$ at the output node using its update rule.

Update the weights and bias at each of the two hidden$-$layer nodes using their update rules.

The updates take place even if the assigned class matches the target class. Use the value of the output sigmoid function $ok$ to calculate the error

Do one epoch, training over all four points in the logical$-$AND function, updating the weights after each point.

After you update the weights, verify that they have moved in a direction that makes the classification more correct, even if the output has not crossed the threshold of $\mathrm{.}5$ to actually change its predicted class.