(Trochę się wstydzę pokazywać bo to niezoptymalizowane i wogóle masakra
tylko tak na szybko sam algo)[syntax=java]public class SSN {
public static class Neuron{
double E = 2.718281828; // liczba Napera
double[][] Lin; // input layer
double[][] mnozenieWej; // Hide Layer - wartości mnożenia(syg*wagi) funkcji Net(X) neuronów ukrytych
double[][] net_hide; // tablica wartości dodanych w Hide Layer czyli wyniki funkcji Net(X);
double[][] mnozenie_warstwy_wyj_tab; // wartości mnożenia syg*wagi w warstwie wyjściowej
double[][] neur_z; // warstwa wyjściowa
double[] net_out; // wartości dodane
double[] fa_hide_tab;
double[] fa_out_tab; // funkcja aktywacji neuronĂłw Z
int ilNhide;
int ilWynikow;
double[][] tab_popr_wag_neuronow;
double[] syg_bled_Z = new double[1];
double[] syg_bled_H = new double[2];
double[] delty_h_double = new double[3];
BigDecimal[] delta_wag_h = new BigDecimal[2];
double oczekiw = 0.1234567890;
double wsp_kor = 0.01;
double[] tmp = new double[3];
BigDecimal[] delty_z = new BigDecimal[3];
BigDecimal[] delty_wag_a = new BigDecimal[4];
BigDecimal[] delty_wag_b = new BigDecimal[4];
BigDecimal[][] nowe_wagi_neur = new BigDecimal[2][4];
BigDecimal[][] delty_neuronow_ab = new BigDecimal[2][4];
// Konstruktor obiektu i deklaracje zmiennych
Neuron(double[][] In_Layer, double[][] Out_Layer, int ilNeuronow_Hide, int ilNeuronow_In){
this.Lin = In_Layer; // warstwa wejściowa - input Layer
this.neur_z = Out_Layer; // warstwa wyjsciowa - Z Layer
this.ilWynikow = In_Layer[0].length * ilNeuronow_Hide; // ilość połączeń między neuronami
this.ilNhide = ilNeuronow_Hide; // ilość neuronów ukrytych, inaczej rozmiar tablicy równy Lin.length-1;
this.mnozenieWej = new double [ilNeuronow_Hide][ilNeuronow_In]; // tablica pomnożonych wartości syg i wag w Hide Layer
this.net_hide = new double [ilNeuronow_Hide][1]; // ilość neuronów ukrytych
this.fa_hide_tab = new double [ilNeuronow_Hide]; // funkcje aktywacji
this.mnozenie_warstwy_wyj_tab = new double [Out_Layer.length][Out_Layer[0].length];
this.net_out = new double [Out_Layer.length];
this.fa_out_tab = new double [Out_Layer.length];
this.tab_popr_wag_neuronow = new double[ilNeuronow_Hide][ilNeuronow_In];
this.delta_wag_h = new BigDecimal[2];
}
// Najpierw mnożymy sygnały i wagi a póżniej odawanie do siebie wyników mnożenia
public double[][] net_warstwa_ukr(){
for(int x=0; x<Lin.length; x++){
for(int y=0; y<Lin[x].length; y++){
if(x!=Lin.length-1)
mnozenieWej[x][y]=Lin[0][y]*Lin[x+1][y];
}
}
// dodajemy te wartości tablicy do siebie
for(int i=0;i<mnozenieWej.length;i++){
for(int x=0;x<mnozenieWej[i].length;x++){
net_hide[i][0]+=mnozenieWej[i][x];}
}return net_hide;
}
public double[] funkcja_aktywacji_ukr(){
for(int i =0; i<net_hide.length; i++){
for(int x=0; x<net_hide[i].length; x++){
fa_hide_tab[i] = 1/ (1 + Math.pow( E, -net_hide[i][x]));
}
}return fa_hide_tab;
}
// wyliczanie - mnożenie wartości syg * wagi neuronów Z oraz dodawanie pomnożonych wartości do siebie
public double[] net_wyj(){
for(int x=0; x<neur_z.length; x++){
mnozenie_warstwy_wyj_tab[x][0]= Lin[0][0]*neur_z[x][0];
}
for(int x=0; x<neur_z.length; x++){
for(int a=0; a<fa_hide_tab.length; a++){
mnozenie_warstwy_wyj_tab[x][a+1]= neur_z[x][a+1] * fa_hide_tab[a];
}
}
net_out[0]=0;
for(int x=0; x<mnozenie_warstwy_wyj_tab.length; x++){
for(int y=0; y<mnozenie_warstwy_wyj_tab[x].length; y++){
net_out[x] += mnozenie_warstwy_wyj_tab[x][y];
}
}
return net_out;
}
public double[] funkcja_aktywacji_Z(){
for(int x=0; x<net_out.length; x++){
fa_out_tab[x] = 1 /(1 + Math.pow(E, -net_out[x]));
}
return fa_out_tab;
}
public double[] syg_bledow_Z(){
for(int x=0; x<fa_out_tab.length; x++){
syg_bled_Z[x] = fa_out_tab[x]*(1-fa_out_tab[x])*(oczekiw-fa_out_tab[x]);
}
return syg_bled_Z;
}
public double[] syg_bledow_H(){
for(int x=0; x<fa_hide_tab.length; x++){
for(int y=0; y<syg_bled_Z.length; y++)
syg_bled_H[x] = fa_hide_tab[x]*(1-fa_hide_tab[x])*(syg_bled_Z[y]);
}
return syg_bled_H;
}
public BigDecimal[] delty_wag_a(){
for(int x = 0; x<delty_wag_b.length; x++) {
for(int y = 1; y<syg_bled_H.length; y++)
delty_wag_a[x]= new BigDecimal(wsp_kor*syg_bled_H[y]*Lin[0][x], MathContext.DECIMAL64);
}
return delty_wag_a;
}
public BigDecimal[] delty_z(){
delty_z[0] = new BigDecimal(wsp_kor * syg_bled_Z[0] * Lin[0][0], MathContext.DECIMAL64);
delty_h_double[0] = (delty_z[0]).doubleValue();
for(int x=1; x<fa_hide_tab.length+1; x++)
{
delty_z[x] = new BigDecimal(wsp_kor * syg_bled_Z[0]*fa_hide_tab[x-1], MathContext.DECIMAL64);
delty_h_double[x] = (delty_z[x]).doubleValue();
}
return delty_z;
}
public BigDecimal[] delty_b(){
for(int x = 0; x<delty_wag_b.length; x++) {
for(int y = 0; y<syg_bled_H.length-1; y++)
delty_wag_b[x]= new BigDecimal(wsp_kor*syg_bled_H[y] * Lin[0][x], MathContext.DECIMAL64);
}
return delty_wag_b;
}
public BigDecimal[][] concat_tab(){
for(int x = 0; x < nowe_wagi_neur.length; x++){
delty_neuronow_ab[x] = (x == 0 ? delty_wag_a : delty_wag_b);
}
return delty_neuronow_ab;
}
public double[][] nowe_wagi_neuronow_ab(){
BigDecimal[][] Lin_BD = new BigDecimal[3][4];
for(int x = 0; x<nowe_wagi_neur.length; x++) {
for(int y = 0; y<nowe_wagi_neur[x].length; y++){
Lin_BD[x][y] = new BigDecimal(Lin[x+1][y] ,MathContext.DECIMAL64);
nowe_wagi_neur[x][y] = (delty_neuronow_ab[x][y]).add(Lin_BD[x][y]);
Lin[x+1][y] = nowe_wagi_neur[x][y].doubleValue();
}
}
return Lin;
}
public double[][] nowe_wagi_neuronow_z(){
BigDecimal[][] neur_z_BD = new BigDecimal[1][3];
for(int x = 0; x<neur_z.length; x++){
for(int y = 0; y<neur_z[x].length; y++){
neur_z[x][y] += (delty_z[y]).doubleValue();
}
}
return neur_z;
}
public void przebiegi_sieci(int licznik){
for(int i =0; i<licznik; i++){
net_warstwa_ukr();
funkcja_aktywacji_ukr();
net_wyj();
funkcja_aktywacji_Z();
syg_bledow_Z();
syg_bledow_H();
// Nie ma obliczania sygnałów błędów dla warstwy In bo sie nie oblicza
delty_z();
delty_wag_a();
delty_b();
concat_tab();
nowe_wagi_neuronow_z();
nowe_wagi_neuronow_ab();
}
}
}
// To już jest totalna masakra ale nie chciało mi się nad tym mysleć bo to tylko testy.
public static void main(String[] args) {
// x0 x1 x2 x3
double[][] NeuronyWej_wagi ={{1.0,0.4,0.2,0.7} // sygnały Lin
// w0a w1a w2a w3a
,{0.5,0.6,0.8,0.6} // każda wartość to waga neuronu wejsciowego z neuronem A
,{0.7,0.9,0.8,0.4}}; // [...] z neuronem B
// w0z wAz wBz
double[][] NeuronyWyj_wagi ={{0.5,0.9,0.9}}; // wagi neuronu(Ăłw) Z
int IL_NHIDE = NeuronyWej_wagi.length-1; // liczba neuronĂłw w warstwie ukrytej
int IL_NIN = NeuronyWej_wagi[0].length; // liczba neuronów w warstwie wejściowej
int liczba_epok = 60000; // ponieważ dobrany jest mały współczynnik uczenia 0.01
//****************************************************************************************//
//Wypisz w = new Wypisz(); // wypisuje tablice z wynikami
Neuron N = new Neuron(NeuronyWej_wagi, NeuronyWyj_wagi, IL_NHIDE, IL_NIN);
N.przebiegi_sieci(liczba_epok);
//***************************************************************************************//
//System.out.println("Wagi wejściowe:");
System.out.println("Sygnały\n"
+ "x0, x1, x2, x3\n"
+ "1.0,0.4,0.2,0.7\n"
+ "Wagi\n"
+ "w0A w1A w2A w3A\n"
+ "0.5,0.6,0.8,0.6\n"
+ "w0B w1B w2B w3B\n"
+ "0.7,0.9,0.8,0.4");
System.out.println("Wynik pomnożonych wartości wag i sygnałów neuronów wejściowych:");
w.wypisz(N.mnozenieWej);
System.out.println("Wynik funkcji liniowej Net(A) i Net(B) dla neuronĂłw A i B");
w.wypisz(N.net_hide);
System.out.println("Funkcja aktywacji neuronĂłw A i B");
w.wypisz(N.fa_hide_tab);
//System.out.println("Wynik pomnożonych wartości wag i sygnałów neuronów ukrytych A i B:");
//w.wypisz(N.mnozenie_warstwy_wyj_tab);
System.out.println("Wynik funkcji liniowej Net(Z)");
w.wypisz(N.net_out);
System.out.println("Wartość oczekiwana neuronu Z to: "+N.oczekiw);
System.out.println("Wynik działania sieci - funkcja aktywacji neuronu Z po "+liczba_epok+" epokach");
w.wypisz(N.fa_out_tab);
System.out.println("\n\nSygnały błędów Z: ");
w.wypisz(N.syg_bled_Z);
System.out.println("Sygnały błędów H: ");
w.wypisz(N.syg_bled_H);
System.out.println("Delty wag warstwy ukrytej : ");
w.wypisz(N.delty_z);
System.out.println("Delty wszystkich wag : ");
System.out.println(Arrays.toString(N.delty_z)+" <- w0z, waz, wbz");
System.out.println(Arrays.toString(N.delty_wag_a)+" <- Delty wag in dla neuronu A");
System.out.println(Arrays.toString(N.delty_wag_b)+" <- Delty wag in dla neuronu B");
System.out.println("Uaktualnione wagi neuronów wejściowych w ostatniej epoce działania sieci");
w.wypisz(N.Lin);
}
import java.math.BigDecimal;
/**
*
* @author admin
*/
public class Wypisz {
public void wypisz(double[][] tab){
for(int i=0;i<tab.length;i++){
System.out.print("[");
for(int x=0;x<tab[i].length;x++){
System.out.print(tab[i][x]);
System.out.print(", ");}
System.out.print("] \n");
}
}
public void wypisz(double[] tab){
for(int i =0;i<tab.length; i++)
System.out.println(tab[i]);
}
public void wypisz(BigDecimal[] tab){
for(int i =0;i<tab.length; i++)
System.out.println(tab[i]);
}
public void wypisz(BigDecimal[][] tab){
for(int i=0;i<tab.length;i++){
System.out.print("[");
for(int x=0;x<tab[i].length;x++){
System.out.print(tab[i][x]);
System.out.print(", ");}
System.out.print("] \n");
}
}
}
}[/syntax]
Mieszają się nazwy ang. i polskie ale nie wiedziałem jak to wszystko ponazywać.
Dawno nie uruchamiałem i w ogóle mało to obiektowe ale jak mówiłem to tylko test - powinno działać. Nie wiem jak się po polsku nazywa twoja metoda ale pewnie ją tu znajdziesz tyle że bez biasów.
P.S ale ze mnie archeolog
Statystyki: Napisane przez ZgłebiaczTajników — 27 mar 2014, o 15:37
]]>