backpropagation-and.py

import math

# variabel input
x = [
    [0, 0],
    [0, 1],
    [1, 0],
    [1, 1]
]
t = [0, 0, 0, 1] # target

nr_input = 2 # neuron input
nr_hidden = 3 # neuron hidden
nr_output = 1 # neuron output

## Initialed Variable
lrate = 0.2 # Learning rate 0 < a <= 1
# epoh
maxEpoh = 1000
epoh = 0
#error
targetError = 10**-10
E = 0
##

v = [[0.2, 0.3, -0.1], [0.3, 0.1, -0.1]]
b1 = [-0.3, 0.3, 0.3]
w = [[0.5], [-0.3], [-0.4]]
b2 = [-0.1]

# Perkalian -> z_in
def zMultiply(data):
    z_in = [0 for i in range(nr_hidden)]
    for i in range(nr_hidden):
        sum = 0
        for j in range(nr_input):
            sum = sum + v[j][i]*x[data][j]
        z_in[i] = round(b1[i] + sum, 4)
    return z_in

# Fungsi Aktivasi Sigmoid
def zActivation(z_in):
    z = [0 for i in range(len(z_in))]
    for i in range(len(z_in)):
        z[i] = round((math.e**z_in[i]/(math.e**z_in[i]+1)), 4)
    return z

# Perkalian -> y_in
def yMultiply(z):
    y_in = [0 for i in range(nr_output)]
    for i in range(nr_output):
        sum = 0
        for j in range(nr_hidden):
            sum = sum + w[j][i]*z[j]
        y_in[i] = round(b2[i] + sum, 4)
    return y_in

# Fungsi Aktivasi Linear
def yActivation(y_in):
    return y_in

# Cek error
def error_check(data, y):
    error = t[data]-y[0]
    return error

# Kuadrat Error
def error_quad(error):
    global E
    E = round(E + error*error, 2)
    return E

# Turunan Fungsi Aktivasi Linear
def derivYActivation(y_in):
    return 1

# Turunan Fungsi Aktivasi Sigmoid
def derivZactivation(z_in):
    z = [0 for i in range(len(z_in))]
    for i in range(len(z_in)):
        z[i] = (math.e**z_in[i]/(math.e**z_in[i]+1))*(1-(math.e**z_in[i]/(math.e**z_in[i]+1)))
    return z

# Perbaikan Bobot
def fix_weight(data, error, y_in, z_in, z):
    delta = error*derivYActivation(y_in[0])

    delta_in = [0 for i in range(len(b1))]
    delta_z = [0 for i in range(len(delta_in))]
    deriv_z = derivZactivation(z_in)
    for i in range(len(b1)):
        delta_in[i] =  delta*w[i][0]
        delta_z[i] = delta_in[i]*deriv_z[i]
        b1[i] = round(b1[i] + lrate*delta_z[i], 4)
        for j in range(len(v)):
            v[j][i] = round(v[j][i] + lrate*delta_z[i]*x[data][j], 4)

    for i in range(len(b2)):
        b2[i] = round(b2[i] + lrate*delta, 4)

    for i in range(nr_hidden):
        for j in range(nr_output):
            w[i][j] = round(w[i][j] + lrate*delta*z[i], 4)

# Menghitung Nilai MSE
def get_mse(sum_error):
    sum = 0
    for i in range(len(sum_error)):
        sum = sum + sum_error[i]**2
    mean = round(sum/len(sum_error), 4)
    return mean

# Traversal
def traversal(k):
    print("Data ke-", k+1)
    print("v = ", v)
    print("b1 = ", b1)
    print("w = ", w)
    print("b2 = ", b2)

def backpropagation():
    global epoh, E
    while epoh < maxEpoh:
        print("Pada epoh ke-", epoh+1)
        E = 0

        sum_error = [0 for i in range(len(x))]
        for k in range(len(x)):
            z_in = zMultiply(k)
            z = zActivation(z_in)
            y_in = yMultiply(z)
            y = yActivation(y_in)

            error = error_check(k, y)
            error_quad(error)

            sum_error[k] = error

            fix_weight(k, error, y_in, z_in, z)
            traversal(k)

        mse = get_mse(sum_error)
        print("MSE = ", mse)

        epoh = epoh + 1
        print()
        if (mse < targetError): break

if __name__ == '__main__':
    backpropagation()
    print("Bobot - Bobot Akhir yang Diperoleh:")
    print("v = ", v)
    print("b1 = ", b1)
    print("w = ", w)
    print("b2 = ", b2)