|
|
| |
/*
* 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ęć".
|
|
|
 |
|
|
 |
|
|
 |
|