LAMPIRAN
SOURCE CODE
=====================================================================
fungsi_utama.java
=====================================================================
import java.io.IOException;
import java.util.Scanner;
public class fungsi_utama
{
private static double mse;
private static float jum2;
public static void main (String[] args) throws IOException
{
int [][] matriks = new int [10][10];
int [][] matriksbanding = new int [10][10];
int [][] matriksC = new int [10][10];
int [][] matriksbanding2 = new int [10][10];
double [][] matriksjst =
{
{0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1}
,{0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2}
,{0.3,0.3,0.3,0.3,0.3,0.3,0.3,0.3,0.3,0.3}
,{0.4,0.4,0.4,0.4,0.4,0.4,0.4,0.4,0.4,0.4}
,{0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5}
,{0.6,0.6,0.6,0.6,0.6,0.6,0.6,0.6,0.6,0.6}
,{0.7,0.7,0.7,0.7,0.7,0.7,0.7,0.7,0.7,0.7}
,{0.8,0.8,0.8,0.8,0.8,0.8,0.8,0.8,0.8,0.8}
,{0,9,0,9,0,9,0,9,0,9,0,9,0,9,0,9,0,9,0,9}
,{1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0}
};
double targetY[][] =
{
{0.0,0.2,0.2,0.2,0.2,1,1,1,1,1},
{0.5,0.3,0.3,0.3,0.3,1,1,1,1,1},
{0.0,0.4,0.4,0.4,0.4,1,1,1,1,1},
{0.7,0.5,0.5,0.5,0.5,1,1,1,1,1},
{0.8,0.6,0.6,0.6,0.6,1,1,1,1,1},
{1,1,1,1,1,1,1,1,1,1},
{1,1,1,1,1,1,1,1,1,1},
{1,1,1,1,1,1,1,1,1,1},
{1,1,1,1,1,1,1,1,1,1}
};
boolean sama = true;
for(int i = 0 ; i<6 ; i++)
{
for(int j = 1 ; j<6; j++)
{
if(targetY[0][0] == targetY[j][i])
sama = false;
}
}
mse = fungsi_backpropagation.init(matriksjst,targetY);
double jum3;
System.out.println();
if(jum2 == 0.0)
{
jum3 = jum2 +100;
}
else
{
jum3 = 100- jum2;
}
System.out.println(" ini adalah mse sesungguhnya: " +
mse);
double nilai = 0.02;
{
if(!sama)
{
System.out.println();
System.out.println("Not Find Solution");
}else{
System.out.println();
System.out.println("Find Solution");
}
}
else
{
System.out.println();
System.out.println("not Find Solution");
}
}
}
=====================================================================
fungsi_backpropagation.java
=====================================================================
import java.io.IOException;
import java.util.*;
class fungsi_backpropagation
{
private static final int NIN = 10;
private static final int NH = 10 ;
private static final int NOUT = 10 ;
private static final int PATTERN = 10;
static double X[][] = new double [PATTERN][20];
static double H[] = new double[NH];
static double Y[][] = new double [PATTERN][NOUT];
static double targetY [][] = new double [PATTERN][NOUT];
static double weightIH[][] = new double[NIN][NH];
static double biasH[] = new double[NH];
static double biasY[] = new double [NOUT];
static double deltaweightIH[][] = new double[NIN][NH];
static double deltaweightHO[][] = new double[NH][NOUT];
static double deltaY[] = new double[NOUT];
static double deltaH[] = new double [NH];
public static int nepoch = 10000;
public static int epoch;
public static double error = 0.02;
public static double learning_rate = 0.5;
public static double momentum =0.5;
public static int nImages =1;
public static boolean isFindSolution;
public static double mse;
private static Random random = new Random();
private static int rand ;
static int matriksbanding[][], matriks_banding2[][];
public static void backpropagation(double _learning_rate, int
_nepoch, double _error,
double _momentum, int _nImages)
{
learning_rate = _learning_rate;
nepoch = _nepoch;
error = _error;
momentum = _momentum;
nImages = _nImages;
}
public static double init(double _X[][], double _targetY[][])
{
int a, b, i, h, o, p, memorisasi;
double beta , min, max, eucval, pembagi=10000.0;
for(a = 0 ; a < 10 ; a++)
for( b = 0 ; b < 10 ; b++)
{
X [a][b] = _X[a][b];
}
}
for(a =0 ; a< PATTERN; a++)
{
for(b=0; b<NOUT; b++)
{
targetY[a][b] = _targetY[a][b];
}
}
beta = 0.7 * ( Math.pow(NH, 1.0/NIN));
min = -beta * pembagi;
max = beta * pembagi;
for(h=0 ; h< NH; h++)
{
eucval =0.0;
for( i = 0 ; i<NIN; i++)
{
rand = (int) random.nextInt(100000);
weightIH[i][h]= ((rand % (int)(max-min))+
min)/ pembagi;
deltaweightIH[i][h] = 0.0;
eucval += Math.pow(weightIH[i][h], 2);
}
eucval = Math.sqrt(eucval);
for(i = 0 ; i<NIN ; i++)
{
weightIH[i][h] = (beta * weightIH[i][h] ) /
eucval;
}
biasH[h] = ((rand % (int)(max-min))+ min)/ pembagi;
}
for(o = 0 ; o < NOUT; o++)
{
for(h=0 ; h < NH; h++)
{
rand = (int) random.nextInt(100000);
weightHO[h][o] = ((rand % (int)(max-min))+
min)/ pembagi;
deltaweightHO[h][o] =0;
}
rand = (int) random.nextInt(100000);
biasY[o] = ((rand % (int)(max-min))+ min)/ pembagi;
}
boolean tes = training();
memorisasi = 0;
for(p=0; p<10; p++)
{
for(o=0; o<NOUT; o++)
{
if(Y[p][o] >= 0.5)
{
Y[p][o] = 1;
}
else if (Y[p][o] < 0.5)
{
Y[p][o] = 0;
}
}
if(Y[p][0]==targetY[p/nImages][0] &&
Y[p][1]==targetY[p/nImages][1] &&
Y[p][2]==targetY[p/nImages][2] &&
Y[p][4]==targetY[p/nImages][4])
{
memorisasi ++;
}
}
System.out.println("Learning rate : "+ learning_rate );
System.out.println("Momentum : "+ momentum );
System.out.println("Epoch : "+ epoch );
System.out.print("Memorisasi : " + memorisasi + "/" + p +
"(" );
System.out.print(p-memorisasi); System.out.print(") : " );
System.out.print(((double)memorisasi/p*100) + "%");
return mse;
}
public static boolean training()
{
int p,o,numberTarget, a,b;
epoch =0;
do
{
epoch++;
for(p=0;p<10 ; p++)
{
numberTarget = p/ nImages;
calNet(p, numberTarget);
deltaChange(p, numberTarget);
weightAndbiasChange(p);
}
calMSE();
}
return isFindSolution;
}
public static void calNet(int p, int numberTarget)
{
int i,h,o;
for(h=0; h<NH ; h++)
{
H[h] = 0.0;
for(i =0; i<NIN ; i++)
{
H[h] += X[p][i] * weightIH[i][h];
}
H[h] += biasH[h];
H[h] = sigmoid(H[h]);
}
for(o=0; o<NOUT ; o++)
{
Y[p][o] = 0.0;
for(h = 0 ; h<NH; h++)
{
Y[p][o] += H[h] * weightHO[h][o];
}
Y[p][o] += biasY[o];
Y[p][o] = sigmoid(Y[p][o]);
}
}
public static void deltaChange(int p, int numberTarget)
{
int h, o;
double sigmadeltaY;
for(o=0; o<NOUT; o++)
deltaY[o] = (targetY[numberTarget][o]-Y[p][o]) * Y[p][o] *
(1.0-Y[p][o]);
}
for(h=0; h<NH; h++)
{
sigmadeltaY = 0.0;
for(o=0; o<NOUT; o++)
{
sigmadeltaY += deltaY[o] * weightHO[h][o];
}
deltaH[h] = sigmadeltaY * H[h] * (1-H[h]);
}
}
public static void weightAndbiasChange(int p)
{
int i, h, o;
for(h=0; h<NH; h++)
{
for(o=0; o<NOUT; o++)
{
deltaweightHO[h][o] = (learning_rate * deltaY[o] * H[h]) +
(momentum * deltaweightHO[h][o]);
weightHO[h][o] += deltaweightHO[h][o];
}
}
for(o=0; o<NOUT; o++)
{
biasY[o] += learning_rate * deltaY[o];
}
for(i=0; i<NIN; i++)
{
for(h=0; h<NH; h++)
{
deltaweightIH[i][h] = (learning_rate * deltaH[h] * X[p][i]) +
(momentum * deltaweightIH[i][h]);
}
}
for(h=0; h<NH; h++)
{
biasH[h] += learning_rate * deltaH[h];
}
}
public static void calMSE()
{
int a, b;
mse = 0.0;
for(a=0; a<nImages*10; a++)
{
for(b=0; b<NOUT; b++)
{
mse += Math.pow(Y[a][b]-targetY[a/nImages][b], 2);
}
}
mse = ((mse/2))/(nImages*10);
System.out.println(mse);
if(mse>error)
isFindSolution = false;
else
isFindSolution = true;
}
public static double sigmoid(double x)
{
return 1.0/(1.0+Math.exp(-x));
}
public static float perbandingan (int matriksbandingpar[][],
int matriksbandingpar2[][], int width, int height)
{
int jum =0;
int matriksbanding[][] = new int[width][height];
int matriks_banding2[][] = new int[width][height];
matriksbanding = matriksbandingpar;
matriks_banding2 = matriksbandingpar2;
for(int i= 0; i<width ; i++)
{
for(int j = 0 ; j< height; j++)
{
matriksC[i][j] = (matriksbandingpar2[i][j]) -
(matriksbandingpar[i][j] );
matriksC[i][j] = matriksC[i][j] *
matriksC[i][j];
jum = jum + matriksC[i][j];
}
}
float jum2 = ((float)jum/((float)width * (float)
height))/10000;
if(jum2 < 0)
{
jum2 = jum2 * -1;
}
return jum2;
}
