import
numpy as np
from
matplotlib
import
pyplot as plt
def
sigmoid(z):
return
1
/
(
1
+
np.exp(
-
z))
def
initializeParameters(inputFeatures, neuronsInHiddenLayers, outputFeatures):
W1
=
np.random.randn(neuronsInHiddenLayers, inputFeatures)
W2
=
np.random.randn(outputFeatures, neuronsInHiddenLayers)
b1
=
np.zeros((neuronsInHiddenLayers,
1
))
b2
=
np.zeros((outputFeatures,
1
))
parameters
=
{
"W1"
: W1,
"b1"
: b1,
"W2"
: W2,
"b2"
: b2}
return
parameters
def
forwardPropagation(X, Y, parameters):
m
=
X.shape[
1
]
W1
=
parameters[
"W1"
]
W2
=
parameters[
"W2"
]
b1
=
parameters[
"b1"
]
b2
=
parameters[
"b2"
]
Z1
=
np.dot(W1, X)
+
b1
A1
=
sigmoid(Z1)
Z2
=
np.dot(W2, A1)
+
b2
A2
=
sigmoid(Z2)
cache
=
(Z1, A1, W1, b1, Z2, A2, W2, b2)
logprobs
=
np.multiply(np.log(A2), Y)
+
np.multiply(np.log(
1
-
A2), (
1
-
Y))
cost
=
-
np.
sum
(logprobs)
/
m
return
cost, cache, A2
def
backwardPropagation(X, Y, cache):
m
=
X.shape[
1
]
(Z1, A1, W1, b1, Z2, A2, W2, b2)
=
cache
dZ2
=
A2
-
Y
dW2
=
np.dot(dZ2, A1.T)
/
m
db2
=
np.
sum
(dZ2, axis
=
1
, keepdims
=
True
)
dA1
=
np.dot(W2.T, dZ2)
dZ1
=
np.multiply(dA1, A1
*
(
1
-
A1))
dW1
=
np.dot(dZ1, X.T)
/
m
db1
=
np.
sum
(dZ1, axis
=
1
, keepdims
=
True
)
/
m
gradients
=
{
"dZ2"
: dZ2,
"dW2"
: dW2,
"db2"
: db2,
"dZ1"
: dZ1,
"dW1"
: dW1,
"db1"
: db1}
return
gradients
def
updateParameters(parameters, gradients, learningRate):
parameters[
"W1"
]
=
parameters[
"W1"
]
-
learningRate
*
gradients[
"dW1"
]
parameters[
"W2"
]
=
parameters[
"W2"
]
-
learningRate
*
gradients[
"dW2"
]
parameters[
"b1"
]
=
parameters[
"b1"
]
-
learningRate
*
gradients[
"db1"
]
parameters[
"b2"
]
=
parameters[
"b2"
]
-
learningRate
*
gradients[
"db2"
]
return
parameters
X
=
np.array([[
0
,
0
,
1
,
1
], [
0
,
1
,
0
,
1
]])
Y
=
np.array([[
1
,
0
,
0
,
0
]])
neuronsInHiddenLayers
=
2
inputFeatures
=
X.shape[
0
]
outputFeatures
=
Y.shape[
0
]
parameters
=
initializeParameters(inputFeatures, neuronsInHiddenLayers, outputFeatures)
epoch
=
100000
learningRate
=
0.01
losses
=
np.zeros((epoch,
1
))
for
i
in
range
(epoch):
losses[i,
0
], cache, A2
=
forwardPropagation(X, Y, parameters)
gradients
=
backwardPropagation(X, Y, cache)
parameters
=
updateParameters(parameters, gradients, learningRate)
plt.figure()
plt.plot(losses)
plt.xlabel(
"EPOCHS"
)
plt.ylabel(
"Loss value"
)
plt.show()
X
=
np.array([[
1
,
1
,
0
,
0
], [
0
,
1
,
0
,
1
]])
cost, _, A2
=
forwardPropagation(X, Y, parameters)
prediction
=
(A2 >
0.5
)
*
1.0
print
(prediction)