Java ( ., 2005 )

( Predictor)[1]

 

 

package com.bers.forecast.calc;

 

import java.beans.*;

import java.text.*;

 

import javax.swing.*;

 

import com.bers.db.*;

import com.bers.forecast.common.*;

import com.bers.forecast.data.pref.*;

import com.bers.nn.perceptron.*;

import com.bers.nn.ui.*;

 

public class NNMethod extends EmptyFcastMethod implements PropertyChangeListener {

 

/**

* @directed true

*/

 

private Trainer tr = new Trainer();

private NumberFormat nf = NumberFormat.getNumberInstance();

private NumberFormat nf2 = NumberFormat.getNumberInstance();

private int historyCount = 10;

private TrainProgressDialog dlg = new TrainProgressDialog();

private double[][] diffs = null;

private double[][] res = null;

private double[] difmuls = null;

 

public NNMethod() {

nf.setMaximumFractionDigits( 6 );

nf.setMinimumFractionDigits( 6 );

 

nf2.setMaximumFractionDigits( 3 );

nf2.setMinimumFractionDigits( 3 );

nf.setGroupingUsed( false );

 

dlg.setDefaultCloseOperation( WindowConstants.HIDE_ON_CLOSE );

dlg.setModal( true );

dlg.setTrainer( tr );

 

//

IFunction fn = new ThSigmoid();

tr.getNetwork().getLayerAt( 0 ).setOutCount( 10 );

for ( int i = 1; i <= 3; i++ ) {

tr.addLayer( i );

tr.getNetwork().getLayerAt( i ).setFn( fn );

tr.getNetwork().getLayerAt( i ).setOutCount( 10 );

}

 

loadProps();

}

 

private void loadProps() {

DM dm = DM.getInstance();

PrefVO pref = dm.findPrefByName( "forecast.nn.initialSpeed" );

if ( pref.getValue() != null ) {

try {

tr.setInitialSpeed( Double.parseDouble( pref.getValue() ) );

} catch ( NumberFormatException ex ) {

}

}

pref = dm.findPrefByName( "forecast.nn.stopError" );

if ( pref.getValue() != null ) {

try {

tr.setStopError( Double.parseDouble( pref.getValue() ) );

} catch ( NumberFormatException ex ) {

}

}

pref = dm.findPrefByName( "forecast.nn.stopIteration" );

if ( pref.getValue() != null ) {

try {

tr.setStopIteration( Integer.parseInt( pref.getValue() ) );

} catch ( NumberFormatException ex ) {

}

}

pref = dm.findPrefByName( "forecast.nn.speedDecrement" );

if ( pref.getValue() != null ) {

try {

tr.setSpeedDecrement( Double.parseDouble( pref.getValue() ) );

} catch ( NumberFormatException ex ) {

}

}

}

 

private void saveProps() {

DM dm = DM.getInstance();

try {

PrefVO pref = dm.findPrefByName( "forecast.nn.initialSpeed" );

pref.setValue( tr.getInitialSpeed() + "" );

pref.store();

 

pref = dm.findPrefByName( "forecast.nn.stopError" );

pref.setValue( tr.getStopError() + "" );

pref.store();

 

pref = dm.findPrefByName( "forecast.nn.stopIteration" );

pref.setValue( tr.getStopIteration() + "" );

pref.store();

 

pref = dm.findPrefByName( "forecast.nn.speedDecrement" );

pref.setValue( tr.getSpeedDecrement() + "" );

pref.store();

 

} catch ( DBException ex ) {

System.err.println( "cannot save forecast parameters" );

}

}

 

public void prepare() {

super.prepare();

//

prepareDiffs();

 

//

initTrainer();

 

//

addSamples();

res = null;

}

 

private void addSamples() {

int outsize = diffs[0].length;

int insize = outsize * historyCount;

 

tr.removeAllSamples();

for ( int i = historyCount; i < diffs.length; i++ ) {

double[] x = new double[insize];

for ( int j = 1; j <= historyCount; j++ ) {

for ( int k = 0; k < outsize; k++ ) {

x[ ( j - 1 ) * outsize + k] = diffs[i - j][k];

}

}

double[] y = new double[outsize];

for ( int j = 0; j < outsize; j++ ) {

y[j] = diffs[i][j];

}

ArraySample sample = new ArraySample( x, y );

tr.addSample( sample );

}

}

 

private void initTrainer() {

int outsize = diffs[0].length;

int insize = outsize * historyCount;

int midsize = outsize + ( int ) Math.sqrt( insize ) * 2;

 

tr.setInputCount( insize );

tr.getNetwork().getLayerAt( 0 ).setInCount( insize );

tr.getNetwork().getLayerAt( 0 ).setOutCount( midsize );

 

int lcount = tr.getLayersCount();

for ( int i = 1; i < lcount - 1; i++ ) {

tr.getNetwork().getLayerAt( i ).setInCount( midsize );

tr.getNetwork().getLayerAt( i ).setOutCount( midsize );

}

tr.getNetwork().getLayerAt( lcount - 1 ).setInCount( midsize );

tr.getNetwork().getLayerAt( lcount - 1 ).setOutCount( outsize );

tr.setOutputCount( outsize );

}

 

private void prepareDiffs() {

diffs = new double[m.length - 1][];

difmuls = new double[m[0].length];

for ( int i = 0; i < m.length - 1; i++ ) {

diffs[i] = new double[m[i + 1].length];

for ( int j = 0; j < m[i + 1].length; j++ ) {

diffs[i][j] = m[i + 1][j] - m[i][j];

if ( Math.abs( diffs[i][j] ) > difmuls[j] ) {

difmuls[j] = Math.abs( diffs[i][j] );

}

}

}

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

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

diffs[i][j] /= difmuls[j];

}

}

}

 

public void calc() throws FcastException {

if ( !isPrepared() ) {

prepare();

}

saveProps();

 

int lcount = tr.getLayersCount();

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

tr.getNetwork().getLayerAt( i ).reinit();

}

 

//

dlg.reset();

dlg.setVisible( false );

dlg.setTrainer( tr );

 

//

tr.removeListener( this );

tr.addListener( this );

tr.start();

 

//

cleanResult();

}

 

private void cleanResult() {

int fcount = getFcastValue() / fixedStep;

 

double step = ( max - min ) / m.length;

 

res = new double[m.length + fcount][regions.length * 2 + 1];

//

initialFill( step );

 

try {

//

statFill( step );

 

//

fcastFill( step );

} catch ( NoLayersException ex ) {

ex.printStackTrace();

} catch ( SizesMismatchException ex ) {

ex.printStackTrace();

}

}

 

private void initialFill( double step ) {

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

double t = min + i * step;

res[i][0] = t;

int k = 0;

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

int rccount = regions[j].getArraysCount();

res[i][j * 2 + 1] = m[i][k];

res[i][j * 2 + 2] = m[i][k];

k += rccount;

}

}

}

 

private void statFill( double step ) throws NoLayersException, SizesMismatchException {

int incount = tr.getInputCount();

int outcount = tr.getOutputCount();

for ( int i = historyCount; i < diffs.length; i++ ) {

double t = min + i * step;

res[i][0] = t;

int k = 0;

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

int rccount = regions[j].getArraysCount();

res[i][j * 2 + 1] = m[i][k];

k += rccount;

}

 

//

double[] x = new double[incount];

for ( int iback = 1; iback <= historyCount; iback++ ) {

for ( k = 0; k < outcount; k++ ) {

x[ ( iback - 1 ) * outcount + k] = diffs[i - iback][k];

}

}

double[] y = new double[outcount];

for ( int iback = 0; iback < outcount; iback++ ) {

y[iback] = diffs[i][iback];

}

ArraySample sample = new ArraySample( x, y );

 

//

tr.getNetwork().calc( sample );

double[] outs = tr.getNetwork().getLayerAt( tr.getLayersCount() - 1 ).getOuts();

k = 0;

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

int rccount = regions[j].getArraysCount();

res[i][j * 2 + 2] = outs[k] * difmuls[k] + m[i - 1][k];

k += rccount;

}

}

}

 

private void fcastFill( double step ) throws NoLayersException, SizesMismatchException {

int fcount = getFcastValue() / 14;

int mcount = m.length;

int rcount = mcount + fcount;

int incount = tr.getInputCount();

int outcount = tr.getOutputCount();

double[][] tmp = new double[rcount][incount];

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

tmp[i] = diffs[i];

}

for ( int ifcast = 0; ifcast <= fcount; ifcast++ ) {

int i = mcount + ifcast - 1;

double t = min + i * step;

res[i][0] = t;

 

//

double[] x = new double[incount];

for ( int iback = 1; iback <= historyCount; iback++ ) {

for ( int k = 0; k < outcount; k++ ) {

x[ ( iback - 1 ) * outcount + k] = tmp[i - iback][k];

}

}

double[] y = new double[outcount];

for ( int iback = 0; iback < outcount; iback++ ) {

y[iback] = tmp[i][iback];

}

ArraySample sample = new ArraySample( x, y );

 

//

tr.getNetwork().calc( sample );

double[] outs = tr.getNetwork().getLayerAt( tr.getLayersCount() - 1 ).getOuts();

int k = 0;

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

int rccount = regions[j].getArraysCount();

for ( int o = 0; o < rccount; o++ ) {

tmp[i][k + o] = outs[k + o];

}

res[i][j * 2 + 2] = outs[k] * difmuls[k] + res[i - 1][j * 2 + 2];

 

k += rccount;

}

}

}

 

public double[][] getFcast() {

return res;

}

 

public int getHistoryCount() {

return historyCount;

}

 

public void setHistoryCount( int historyCount ) {

this.historyCount = historyCount;

m = null;

}

 

public Trainer getTrainer() {

return tr;

}

 

public void setTrainer( Trainer trainer ) {

if ( tr != null ) {

tr.removeListener( this );

}

tr = trainer;

dlg.setTrainer( tr );

}

 

public void propertyChange( PropertyChangeEvent evt ) {

if ( evt.getPropertyName().equals( "trainIteration" ) ) {

TrainEvent te = ( TrainEvent ) evt.getNewValue();

if ( ( te.getIteration() % 500 == 0 ) || ( te.getNewError() <= tr.getStopError() ) ) {

double err = te.getNewError();

double d = Math.sqrt( err );

System.out.println( "it=" + te.getIteration() + " err=" + nf.format( err ) + " (" + nf2.format( d ) +

") spd=" + nf.format( te.getSpeed() ) );

}

} else if ( evt.getPropertyName().equals( "trainThread" ) ) {

boolean val = ( ( Boolean ) evt.getNewValue() ).booleanValue();

if ( !val ) {

tr.removeListener( this );

// showFcast();

// System.exit(0);

}

}

}

}



[1]

 



@Mail.ru

 
VBA -2014
, E-mail: apsheronka@mail.ru
,