PCkurier - poradnik menedżera IT  
Szukaj:
    
Pomoc
 w Archiwum  w Wiadomościach
 
  Akademia   IT.Forum   IT Track
 
Strona główna
Wiadomości
Nowy numer
Archiwum
Prenumerata
Kurs HTML
Redakcja
REKLAMA
Zasoby WWW
Info
Pytamy
Czy korzystasz z komunikatorów do celów służbowych?
Tak Nie
Polecamy
Konfiguracja i zarządzanie
Urządzenia pamięci masowej
Koniec ery faksów
Środowisko drukowania iPrint
Komponenty i obiekty
Środowisko drukowania NDPS
Czekając na walec
Globalna gmina
Informatyzacja w parterze
Globalna gmina
Łódzki początek...
Globalna gmina
Wielki przekręt
Fałszerstwa księgowe
Krucjata KPWiG
Fałszerstwa księgowe
Dystans do distance learning
E-szkolenia
Wielość w jednym
Routery wielofunkcyjne
Wydajemy
AEC Forum
Cad/Cam forum
CRN
Enter
Tele.Net Forum
 
/*
 * NeuralNetwork.cpp
 * Copyright (C) 2000 Janusz Gregorczyk
 * jgregor@kki.net.pl
 */

#include <vector>
using namespace std;

#include "

Helper.h"
#include "

NeuralNetwork.h"

/* ====================================================== */

NeuralNetwork::NeuralNetwork(int n) {
  eta = 0.001; alpha = 0.9;
  flags(fError);
  addLayer(n);
}

NeuralNetwork::~NeuralNetwork() {
  purge(layer);
}

void NeuralNetwork::addLayer(int n) {
  /* czy są już jakieś warstwy? */
  int prev = layers() > 0 ? outputLayer().size() : 0;

  /* funkcja aktywacji warstwy ukrytej */
  /* jest domyślnie sigmoidalna */
  if (layers())
    outputLayer().changeType(Neuron::Sigmoid);

  layer.push_back(new NeuralLayer(prev, n));

  /* funkcja aktywacji warstwy wyjściowej */
  /* jest domyślnie liniowa */
  outputLayer().changeType(Neuron::Linear);

  target.resize(n);
}

void NeuralNetwork::setInput(const double *x) {
  for (int i = 0; i < inputLayer().size(); i++) {
    inputLayer().setOutput(i, x[i]);
  }
}

void NeuralNetwork::setTarget(const double *x) {
  for (int i = 0; i < outputLayer().size(); i++) {
    target[i] = x[i];
  }
}

void NeuralNetwork::getOutput(double *x) {
  for (int i = 0; i < outputLayer().size(); i++) {
    x[i] = outputLayer().getOutput(i);
  }
}

void NeuralNetwork::propagate() {
  for (int i = 1; i < layers(); i++) {
    layer[i]->setInput(layer[i - 1]);
    layer[i]->propagate();
  }

  if (flags() & (fLearning | fError))
    computeError();

  if (flags() & fLearning)
    adjustWeights();
}

/* określa błąd każdej z jednostek */
void NeuralNetwork::computeError() {
  netError = 0.0;

  /* określ błąd w warstwie wyjściowej */
  for (int unit = 0; unit < outputLayer().size(); unit++) {
    double out = outputLayer().getNeuron(unit)->getOutput();
    double dOut = outputLayer().getNeuron(unit)->getdOutput();

    double err = (target[unit] - out) * dOut;

    outputLayer().setError(unit, err);

    netError += 0.5 * err * err;
  }

  /* określ błędy w warstwach ukrytych */
  /* (metodą propagacji wstecznej) */
  for (int hidden = layers() - 2; hidden >= 1; hidden--) {
    for (int node = 0; node < layer[hidden]->size(); node++) {
      double dOut = layer[hidden]->getNeuron(node)->getdOutput();

      double sum = 0.0;
      for (int i = 0; i < layer[hidden + 1]->size(); i++) {
        sum += layer[hidden + 1]->getNeuron(i)->getWeight(node)
             * layer[hidden + 1]->getError(i);
      }

      layer[hidden]->setError(node, sum * dOut);
    }
  }
}

/* modyfikuje wagi zgodnie z algorytmem */
/* przedstawionym w artykule */
void NeuralNetwork::adjustWeights() {
  for (int l = 1; l < layers(); l++) {
    for (int i = 0; i < layer[l]->size(); i++) {
      double err = layer[l]->getError(i);
      layer[l]->getNeuron(i)->adjustThreshold(eta * err);

      NeuralLayer *prevLayer = layer[l - 1];

      for (int j = 0; j < prevLayer->size(); j++) {
        double in = prevLayer->getOutput(j);

        double dWeight = eta * err * in;
        dWeight += alpha * layer[l]->getNeuron(i)->getDeltaWeight(j);

        layer[l]->getNeuron(i)->adjustWeight(j, dWeight);
      }
    }
  }
}

/* ====================================================== */
Proponujemy
Twierdzisz, że Twojej firmy nie stać na zakup komputerów przenośnych? A przecież w ten sposób oszczędzasz na kilku czynnikach, np. w cenę notebooka wliczony jest monitor ciekłokrystaliczny i dobry zasilacz. Rozumiemy, że notebooki Panasonic, IBM, Fujitsu Siemens, Sony czy Toshiba mogą nie być na Twoją kieszeń, dlatego przetestowaliśmy tańsze modele po pięć tysięcy złotych i... polecamy. Wyniki testu w artykule "Siedem za pięć".
Organizujemy
Internet dla firm
Warszawa, 5 XII 2002 r.
Patronujemy
Profesjonalne szkolenia informatyczne
PCkurier patronuje organizowanym przez CE EduSoft szkoleniom informatycznym. Dla naszych prenumeratorów przewidziane są 10-procentowe zniżki na wybrane kursy
Wiadomości | Nowy numer | Archiwum | Akademia | IT.Forum | IT Track
Prenumerata | Redakcja | Reklama | Zasoby WWW | Kurs HTML
Lupus sp. z o.o. | Polityka prywatności | Wszelkie prawa zastrzeżone | Info | webmaster@pckurier.pl