Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

Використання методу зворотного розповсюдження помилки для навчання нейронної мережі



Опис завдання

програма нейронний мережа

Скласти програму, яка реалізує функціонування нейронної мережі для задачі розпізнавання (класифікації) літер слова (КОСОВА). Представити операцію навчання мережі на прикладах для навчання. Протестувати програму для контрольних прикладів.

Дослідити вплив вище перелічених параметрів на швидкість навчання мережі та якість розпізнавання образів.



1. Теоретичні відомості

Задача полягає у розпізнаванні (класифікації) літери, яке представлене бітовою матрицею розміру 9х7. Вихідний вектор мережі має містити інформацію про належність числа до одного з 8 класів (літер слова). Наприклад, якщо на вхід мережі буде подано матрицю, що відповідає літері З, то у вихідному векторі значення другого біту буде дорівнювати 1. Для вирішення задачі обрати нейронну мережу з 63 вхідними нейронами, 6 нейронами прихованого шару і 10 вихідними нейронами (рис. 1). Нейрони прихованого шару поєднані з усіма вхідними нейронами, а зовнішнього шару - з усіма нейронами прихованого.

Рис. 1. Загальний вигляд нейронної мережі

Відповідність пікселів матриці нейронам вхідного шару наведена на рис. 2.

Рис. 2. Відповідність пікселів нейронам вхідного шару

Літери для навчання нейронної мережі показано на рис. 3 та рис. 3.1.

Рис. 3. Числа для навчання нейронної мережі(ідеальні)

Рис. 3.1. Числа для навчання нейронної мережі («пошкоджені»)



2. Алгоритм зворотного розповсюдження помилки для навчання нейтронної мережі

Суть алгоритму зводиться до послідовного подання на вхід мережі еталонних значень (рис. 3), визначення вихідного вектору мережі (прямий прохід), і корегування коефіцієнтів ваги для зв'язків нейронів на основі визначення різниці між еталонним значенням вихідного вектору та отриманим (зворотній прохід). Корегування відбувається на основі норми навчання та коефіцієнта інерції . Навчання мережі припиняється при досягненні збіжності між еталонним та отриманим значенням вихідного вектора для всіх еталонних прикладів.

При реалізації алгоритму норму навчання обрати на рівні 0.3, а коефіцієнт інерції 0.7. Значення кожного біту вихідного вектора визначати за формулою:

Послідовність кроків алгоритму:

1. Прочитати перший вхідний зразок(еталон) і встановити вихідний зразок, що йому відповідає; Converge = TRUE.

2. Задати значення для кожного з вхідних нейронів значення вхідного зразка.

3. Для елементів першого прихованого шару обчислити сумарний вхід та вихід ,

4. Повторити крок 3 для всіх наступних прихованих шарів та вихідного шару нейронів.

5. Якщо різниця між значенням виходу мережі і вихідним зразком не є допустимою, Converge = Converge&FALSE.

6. Для кожного вихідного елементу визначити його помилку

7. Для останнього прихованого шару визначити помилку кожного елемента

8. Повторити крок 7 для всіх інших шарів

9. Для всіх шарів перерахувати значення ваг кожного елемента ,

10. Якщо вхідний зразок був не останнім, прочитати наступний і перейти до кроку 2.

11. Якщо Converge == FALSE, перейти до кроку 1.

12. Кінець

Перелік позначень:

i, j, k - індекси;

- i-ий вхідний сигнал нейрону;

- ваговий коефіцієнт з'єднання i-го та j-го нейронів;

- сумарне вхідне значення нейрону j;

- вихідне значення нейрону j;

- функція активації;

- значення помилки для j-го нейрону;

- еталонне значення j-го нейрону зовнішнього шару;

- помилка для вагового коефіцієнта зв'язку між нейронами i та j на n кроці обчислень

- норма навчання;

- коефіцієнт інерції;

Converge - ознака припинення навчання.

3. Результати розпізнавання

Рисунок 1. Розпізнавання Літери «К» та «С»

Рисунок 2. Розпізнавання Літери «О» та «В»



Рисунок 3. Розпізнавання Літери «А»



Висновок

В результаті виконання курсової роботи закріплено знання про реалізацію нейронної мережі з зворотнім розповсюдженням помилки. Також програма навчена розпізнавати літери з яких складається слово(КОСОВА). Залежність якості розпізнавання від кількості нейронів на прихованому шарі (рис. 4), так як літери мають різну складність, отриманий результат є усередненим.

Рисунок 4. Залежність якості розпізнавання від кількості пікселів яких не вистачає



Додаток

Лістинг програми:

Клас «Main»:

private void jPanel1MouseClicked (java.awt.event. MouseEvent evt) {

long startTime = System.currentTimeMillis();

ArrayList<NumberPattern> listOfPatterns = new ArrayList<>();

for (int i = 0; i < 7; i++) {

listOfPatterns.add (new NumberPattern(i));

}

final int amountOfBitsInPattern = 63;

final int amountOfResults = 10;

int amountOfHiddenNeurons = Integer.parseInt (jTextField1.getText());

BackPropagationAlgorithm algo = new BackPropagationAlgorithm (amountOfBitsInPattern, amountOfHiddenNeurons, amountOfResults, listOfPatterns, this);

 //jTextArea1.setText (» - Йде процес навчання…»);

System.out.println («Studying process is running…»);

algo.execute();

File f = new File («numbers/1.bmp»);

PicConverter picConverter = new PicConverter(f);

byte[][] pattern = picConverter.getNumberPatternOnPic();

NumberPattern numberPattern = new NumberPattern(box);

 //algo.testAlgo(numberPattern);

 //jTable1.setValueAt (100, 1, 1);

jLabel4.setText (algo.testAlgo(numberPattern));



long timeSpent = System.currentTimeMillis() - startTime;

System.out.println («Розпізнавання було здійснене за» + timeSpent + «мілісекунд»);

 //jTextArea1.setText (jTextArea1.getText()+»\nРозпізнавання було здійснене за» + timeSpent + «мілісекунд»);

}

/**

* @param args the command line arguments

*/

public static void main (String args[]) {

/* Set the Nimbus look and feel */

 // <editor-fold defaultstate= «collapsed» desc=» Look and feel setting code (optional) «>

/* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.

* For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html

*/

try {

for (javax.swing.UIManager. LookAndFeelInfo info: javax.swing.UIManager.getInstalledLookAndFeels()) {

if («Nimbus».equals (info.getName())) {

javax.swing.UIManager.setLookAndFeel (info.getClassName());

break;

}

}

} catch (ClassNotFoundException ex) {

java.util.logging. Logger.getLogger (main.class.getName()).log (java.util.logging. Level.SEVERE, null, ex);

} catch (InstantiationException ex) {

java.util.logging. Logger.getLogger (main.class.getName()).log (java.util.logging. Level.SEVERE, null, ex);

} catch (IllegalAccessException ex) {

java.util.logging. Logger.getLogger (main.class.getName()).log (java.util.logging. Level.SEVERE, null, ex);

} catch (javax.swing. UnsupportedLookAndFeelException ex) {

java.util.logging. Logger.getLogger (main.class.getName()).log (java.util.logging. Level.SEVERE, null, ex);

}

 // </editor-fold>

/* Create and display the form */

java.awt. EventQueue.invokeLater (new Runnable() {

public void run() {

new main().setVisible(true);

}

});

}

Клас «BackPropagationAlgorithm»:

package numberrecognizer;

import java.util. ArrayList;

public class BackPropagationAlgorithm {

private int amoutOfInN;

private int amountOfHN;

private int amountOfOutN;

private Neuron[] inNeurons;

private Neuron[] hNeurons;

private Neuron[] outNeurons;

private double teta = 0.001;

ArrayList<NumberPattern> listOfPatterns;

main main;

public BackPropagationAlgorithm (int amoutOfInN, int amountOfHN,

int amountOfOutN, ArrayList<NumberPattern> listOfPatterns, main main) {

this.main = main;

this.amoutOfInN = amoutOfInN;

this.amountOfHN = amountOfHN;

this.amountOfOutN = amountOfOutN;

this.listOfPatterns = listOfPatterns;

initNeurons();

}

private void initNeurons() {

Edge[] inputHiddenEdges = getEdges((amoutOfInN + 1) * amountOfHN);

Edge[] hiddenOutputEdges = getEdges((amountOfHN + 1) * amountOfOutN);

int outCounter = 0;

inNeurons = new Neuron[amoutOfInN];

for (int i = 0; i < inNeurons.length; i++) {

Edge[] outEdges = new Edge[amountOfHN];

for (int j = 0; j < outEdges.length; j++) {

outEdges[j] = inputHiddenEdges [outCounter++];

}

inNeurons[i] = new Neuron (null, outEdges, TypeOfNeurons. Input);

}

outCounter = 0;

hNeurons = new Neuron[amountOfHN];

for (int i = 0; i < hNeurons.length; i++) {

Edge[] inEdges = new Edge [amoutOfInN + 1];

int inCounter = i;

for (int j = 0; j < inEdges.length; j++) {

inEdges[j] = inputHiddenEdges[inCounter];

inCounter += amountOfHN;

}

Edge[] outEdges = new Edge[amountOfOutN];

for (int j = 0; j < outEdges.length; j++) {

outEdges[j] = hiddenOutputEdges [outCounter++];

}

hNeurons[i] = new Neuron (inEdges, outEdges, TypeOfNeurons. Hidden);

}

outNeurons = new Neuron[amountOfOutN];

for (int i = 0; i < outNeurons.length; i++) {

Edge[] inEdges = new Edge [amountOfHN + 1];

int inCounter = i;

for (int j = 0; j < inEdges.length; j++) {

inEdges[j] = hiddenOutputEdges[inCounter];

inCounter += amountOfOutN;

}

outNeurons[i] = new Neuron (inEdges, null, TypeOfNeurons. Output);

}

}

public Edge[] getEdges (int numOfNeurons) {

Edge[] edges = new Edge[numOfNeurons];

for (int i = 0; i < edges.length; i++) {

do {

edges[i] = new Edge (Math.random() - 0.5);

} while (edges[i].weigth == 0);

}

return edges;

}

public void execute() {

int counter = 0;

double globalError;

do {

counter++;

globalError = 0;

for (int p = 0; p < listOfPatterns.size(); p++) {

goThroughNet (listOfPatterns.get(p).getPatternMatrix());

byte[] desiredResults = listOfPatterns.get(p).getResultVector();

for (int i = 0; i < outNeurons.length; i++) {

outNeurons[i].setDisaredResult (desiredResults[i]);

outNeurons[i].calcError();

outNeurons[i].calcDeltaWeights();

}

double[] errors = new double [outNeurons.length];

for (int i = 0; i < outNeurons.length; i++) {

errors[i] = outNeurons[i].getError();

}

for (int i = 0; i < hNeurons.length; i++) {

hNeurons[i].recieveErrors(errors);

hNeurons[i].calcDeltaWeights();

}

for (int i = 0; i < hNeurons.length; i++) {

hNeurons[i].changeWeights();

}

for (int i = 0; i < outNeurons.length; i++) {

outNeurons[i].changeWeights();

}

}

for (int i = 0; i < listOfPatterns.size(); i++) {

double error = getMaxError (i, listOfPatterns.get(i).getResultVector());

if (error > globalError) {

globalError = error;

}

}

if (globalError == 1) {

initNeurons();

}

 // System.out.println(«»);

 // System.out.println («globalError =» + globalError);

 // System.out.println(«»);

} while (globalError > teta);

 //main.jTextArea1.setText («Кількість здійснених ітерацій =» + counter+»\n\nЙмовірність розпізнавання: \n»);

System.out.println («Num of iterations =» + counter);

}

public double getMaxError (int numOfPattern, byte[] desiredReluts) {

double[] errors = new double [desiredReluts.length];

ArrayList<Double> output = new ArrayList<>();

goThroughNet (listOfPatterns.get(numOfPattern).getPatternMatrix());

for (int i = 0; i < desiredReluts.length; i++) {

output.add (outNeurons[i].getSignal());

}

for (int i = 0; i < errors.length; i++) {

errors[i] = Math.abs (output.get(i) - desiredReluts[i]);

}

double max = errors[0];

for (int i = 0; i < errors.length; i++) {

max = errors[i] > max? errors[i]: max;

}

return max;

}

public void goThroughNet (byte[][] matrix) {

int k = 0;

for (int i = 0; i < matrix.length; i++) {

for (int j = 0; j < matrix[0].length; j++, k++) {

inNeurons[k].recieveSignals (new double[] {matrix[i] [j]});

inNeurons[k].calcActivationFunction();

}

}

double[] listOfSignals = new double [inNeurons.length];

for (int i = 0; i < inNeurons.length; i++) {

listOfSignals[i] = inNeurons[i].getSignal();

}

for (int j = 0; j < hNeurons.length; j++) {

hNeurons[j].recieveSignals(listOfSignals);

hNeurons[j].calcActivationFunction();

}

listOfSignals = new double [hNeurons.length];

for (int i = 0; i < hNeurons.length; i++) {

listOfSignals[i] = hNeurons[i].getSignal();

}

for (int i = 0; i < outNeurons.length; i++) {

outNeurons[i].recieveSignals(listOfSignals);

outNeurons[i].calcActivationFunction();

}

}

public String transf (int n) {

switch(n) {

case 0: return «А»;

case 1: return «Н»;

case 2: return «Д»;

case 3: return «Р»;

case 4: return «І»;

case 5: return «Ю»;

case 6: return «К»;

default: return»?»;

}

}

public String testAlgo (NumberPattern pattern) {

goThroughNet (pattern.getPatternMatrix());

showPattern (pattern.getPatternMatrix());

 //System.out.println («Desired result:» + pattern.getNumber());

 //main.jTextArea1.setText (main.jTextArea1.getText()+»\n\n - Результат розпізнавання:» + transf (getCurrentResult())+»\n»);

 //System.out.println («Result:» + transf (getCurrentResult()));

System.out.println(«»);

return transf (getCurrentResult());

}

String st=»\n»;

private void showPattern (byte[][] patternMatrix) {

for (int i = 0; i < patternMatrix.length; i++) {

for (int j = 0; j < patternMatrix[0].length; j++) {

if (patternMatrix[i] [j] == 0) {

 //main.jTextArea1.setText (main.jTextArea1.getText()+»»);

System.out.print(«»);

st=st+»»;

} else {

st=st+patternMatrix[i] [j] + «»;

 //main.jTextArea1.setText (main.jTextArea1.getText() + patternMatrix[i] [j] + «»);

System.out.print (patternMatrix[i] [j] + «»);

}

}

st=st+»\n»;

 //main.jTextArea1.setText (main.jTextArea1.getText() + «\n»);

System.out.println(«»);

}

 //main.jTextArea1.setText (main.jTextArea1.getText()+st);

}

private int getCurrentResult() {

int indexOfMax = 0;

double max = 0;

for (int i = 0; i < 7; i++) {

 //main.jTextArea1.setText (main.jTextArea1.getText()+transf(i)+» - «+(outNeurons[i].getSignal()*100)+ "%\n»);

System.out.println (transf(i)+» - «+(outNeurons[i].getSignal()*100)+ "%»);

if (outNeurons[i].getSignal() > max) {

max = outNeurons[i].getSignal();

indexOfMax = i;

}

}

return indexOfMax;

}

public double[] getDataTable() {

double[] tpm = new double[4];

for (int i = 0; i < 7; i++) {

tpm[i] = outNeurons[i].getSignal();

}

return tpm;

}

}

Размещено на Allbest.ru

...