Reti neurali. Domande degli esperti. - pagina 21

Nuovo commento
 
alsu:

4) Pesi parametri di inizializzazione - la forma di distribuzione dei valori e la loro varianza.

Trovato. È possibile impostare i parametri di inizializzazione dei pesi.

Sembra che io abbia usato i valori di default.


 
LeoV:
Reti neurali artificiali e algoritmi genetici breve corso di formazione avanzata
e algoritmi genetici"

Le domande per i corsi di formazione avanzata a breve termine "Reti neurali artificiali e algoritmi genetici" sono chiuse
Reti neurali artificiali e algoritmi genetici",
condotto dal Dipartimento di Educazione Continua dell'Università Statale M.V. Lomonosov di Mosca
V.V. Lomonosov Moscow State University sulla base del Moscow State University Nuclear Research Institute
Università statale di Mosca. Chi completa i corsi riceve un certificato statale di formazione professionale avanzata.
certificato statale di formazione avanzata.
Gli allenamenti si terranno due volte a settimana la sera dalle 19:00.
Le lezioni iniziano il 25 febbraio 2011.

Per saperne di più sul programma del corso, ottenere maggiori informazioni e
Clicca qui per iscriverti al corso:
http://www.neuroproject.ru/kpk.php
Mi scusi, è una pubblicità o seguirà lei stesso il corso?
 
lasso:

Trovato. È possibile impostare i parametri di inizializzazione delle bilance.

Mi sembra di aver usato i valori di default.


Bene, sembra essere chiaro qual è il problema qui.

Partendo dal tuo problema (se ho capito bene hai dei dati monodimensionali che vuoi dividere in due classi), il punto è trovare un punto (uno solo!) sull'insieme dei valori di input, che esegue in modo ottimale la divisione specificata. Supponiamo che abbiate una rete 1-7-1. Questa rete ha 21 pesi (sette ingressi per lo strato nascosto, sette compensazioni per esso, e sette ingressi per il neurone di uscita). Si scopre che stiamo cercando di trovare un punto, raccogliendo 21 variabili. Con una ridondanza di ventuno a uno non c'è nulla di sorprendente che le letture della rete si spostino così tanto - ogni minima differenza nei pesi iniziali porta a una significativa dispersione delle uscite dopo l'allenamento. In parole povere, si scopre che il compito è troppo semplice per la rete, ma poiché non lo sa, cerca qualcosa che non esiste. Tecnicamente, questo può probabilmente essere chiamato riqualificazione, ma in sostanza è sparare ai passeri con un cannone.

In senso stretto, il compito di dividere i dati unidimensionali in due classi è eseguito con successo da un singolo neurone con un peso di ingresso e un bias.

 
lasso:

Un'altra cosa. Sono allarmato dalla "ristrettezza" della gamma di uscite della rete attuale. Per chiarire:

-- la rete MLP è 1-7-1

-- Gli ingressi alla rete sono distribuiti uniformemente nell'intervallo [0;1], le uscite negli esempi di allenamento sono 1 e -1.

Se dopo l'addestramento l'intera gamma di valori di input viene passata attraverso la rete, vediamo che le uscite della rete si trovano in una gamma molto stretta. Per esempio:

opt_max_act=-0.50401336 opt_min_act=-0.50973881 step=0.0000286272901034

o anche così

opt_max_real=-0.99997914 opt_min_real=-0.99999908 step=0.00000010

.............................

È corretto o no?


È difficile parlare di correttezza... dipende dalla situazione

Secondo il suo esempio:

Questo caso significa che la prima rete su tutti gli ingressi dice "non so" e la seconda sugli stessi ingressi dice "classe -1". Se i dati sono gli stessi e la differenza è solo nell'inizializzazione dei pesi, molto probabilmente, il caso è una forte mescolanza di classi, a causa della quale le griglie non possono capire intelligentemente il modello di apprendimento e di conseguenza agire "a caso". Parlando di come questo possa accadere, presumo che se la rete (probabilmente è così) usa neuroni di polarizzazione, la griglia semplicemente azzera i pesi di tutti gli input di informazione e lascia solo la polarizzazione per l'analisi. "Analisi", naturalmente, è solo nominale; la rete opera secondo il principio dello struzzo - semplicemente non vede gli input. Per confermare o negare questo, abbiamo bisogno di vedere le matrici della rete addestrata.

 

Ecco il codice MLP NS generato da "Statistics":

/* ------------------------------------------------------------------------- */


#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>

#ifndef FALSE
#define FALSE 0
#define TRUE 1
#endif

#define MENUCODE -999


static double NNCode38Thresholds[] =
{

/* layer 1 */
-0.78576109762088242, -0.23216582173469763, -1.6708808507320108, -1.525614113040888,
1.4153558659332133, -0.77276960668316319, 2.3600992937381298, 2.473963708568014,
-0.43422405325901231, 0.68546943611132893, 0.19836417975077064, 0.26461366779934564,
-0.19131682804149783, 0.24687125804149584, -0.95588612620053504, 0.25329560565058901,
-1.0054817062488075, 1.3224622867600988, 0.88115523574528376, 0.32309684489223067,
0.52538428519764313,

/* layer 2 */
-1.8292886608617505

};

static double NNCode38Weights[] =
{

/* layer 1 */
1.8660729426318707,
1.3727568288578245,
3.1175074758006374,
3.356836518157698,
3.2574311486418068,
3.2774957848884769,
1.4284147042568165,
3.534875314491805,
2.4874577673065557,
2.1516346524000403,
1.9692127720516106,
4.3440737376517129,
2.7850179803408932,
-12.654434243399631,
2.4850018642785399,
2.1683631515554227,
1.77850226182071,
2.1342779960924272,
2.8753050022428206,
3.9464397902669828,
2.5227540467556553,

/* layer 2 */
-0.041641949353302246, -0.099151657230575702, 0.19915689162090328, -0.48586373846026099,
-0.091916813099494746, -0.16863091580772138, -0.11592356639654273, -0.55874391921850786,
0.12335845466035589, -0.022300206392803789, -0.083342117374385544, 1.550222748978116,
0.10305706982775611, 3.9280003726494575, 0.12771097131123971, -0.12144621860368633,
-0.40427171889553365, -0.072652508364580259, 0.20641498115269669, 0.1519896468808962,
0.69632055946019444

};

static double NNCode38Acts[46];

/* ---------------------------------------------------------- */
/*
  NNCode38Run - run neural network NNCode38

  Input and Output variables.
  Variable names are listed below in order, together with each
  variable's offset in the data set at the time code was
  generated (if the variable is then available).
  For nominal variables, the numeric code - class name
  conversion is shown indented below the variable name.
  To provide nominal inputs, use the corresponding numeric code.
  Input variables (Offset):
  stoch

  Выход:
  res
    1=1
    2=-1

*/
/* ---------------------------------------------------------- */

void NNCode38Run( double inputs[], double outputs[], int outputType )
{
  int i, j, k, u;
  double *w = NNCode38Weights, *t = NNCode38Thresholds;

  /* Process inputs - apply pre-processing to each input in turn,
   * storing results in the neuron activations array.
   */

  /* Input 0: standard numeric pre-processing: linear shift and scale. */
  if ( inputs[0] == -9999 )
    NNCode38Acts[0] = 0.48882189239332069;
  else
    NNCode38Acts[0] = inputs[0] * 1.0204081632653061 + 0;

  /*
   * Process layer 1.
   */

  /* For each unit in turn */
  for ( u=0; u < 21; ++u )
  {
    /*
     * First, calculate post-synaptic potentials, storing
     * these in the NNCode38Acts array.
     */

    /* Initialise hidden unit activation to zero */
    NNCode38Acts[1+u] = 0.0;

    /* Accumulate weighted sum from inputs */
    for ( i=0; i < 1; ++i )
      NNCode38Acts[1+u] += *w++ * NNCode38Acts[0+i];

    /* Subtract threshold */
    NNCode38Acts[1+u] -= *t++;

    /* Now apply the logistic activation function, 1 / ( 1 + e^-x ).
     * Deal with overflow and underflow
     */
    if ( NNCode38Acts[1+u] > 100.0 )
       NNCode38Acts[1+u] = 1.0;
    else if ( NNCode38Acts[1+u] < -100.0 )
      NNCode38Acts[1+u] = 0.0;
    else
      NNCode38Acts[1+u] = 1.0 / ( 1.0 + exp( - NNCode38Acts[1+u] ) );
  }

  /*
   * Process layer 2.
   */

  /* For each unit in turn */
  for ( u=0; u < 1; ++u )
  {
    /*
     * First, calculate post-synaptic potentials, storing
     * these in the NNCode38Acts array.
     */

    /* Initialise hidden unit activation to zero */
    NNCode38Acts[22+u] = 0.0;

    /* Accumulate weighted sum from inputs */
    for ( i=0; i < 21; ++i )
      NNCode38Acts[22+u] += *w++ * NNCode38Acts[1+i];

    /* Subtract threshold */
    NNCode38Acts[22+u] -= *t++;

    /* Now calculate negative exponential of PSP
     */
    if ( NNCode38Acts[22+u] > 100.0 )
       NNCode38Acts[22+u] = 0.0;
    else
      NNCode38Acts[22+u] = exp( -NNCode38Acts[22+u] );
  }

  /* Type of output required - selected by outputType parameter */
  switch ( outputType )
  {
    /* The usual type is to generate the output variables */
    case 0:


      /* Post-process output 0, two-state nominal output */
      if ( NNCode38Acts[22] >= 0.05449452669633785 )
        outputs[0] = 2.0;
      else
        outputs[0] = 1.0;
      break;

    /* type 1 is activation of output neurons */
    case 1:
      for ( i=0; i < 1; ++i )
        outputs[i] = NNCode38Acts[22+i];
      break;

    /* type 2 is codebook vector of winning node (lowest actn) 1st hidden layer */
    case 2:
      {
        int winner=0;
        for ( i=1; i < 21; ++i )
          if ( NNCode38Acts[1+i] < NNCode38Acts[1+winner] )
            winner=i;

        for ( i=0; i < 1; ++i )
          outputs[i] = NNCode38Weights[1*winner+i];
      }
      break;

    /* type 3 indicates winning node (lowest actn) in 1st hidden layer */
    case 3:
      {
        int winner=0;
        for ( i=1; i < 21; ++i )
          if ( NNCode38Acts[1+i] < NNCode38Acts[1+winner] )
            winner=i;

        outputs[0] = winner;
      }
      break;
  }
}
 
alsu:

È difficile parlare di correttezza... dipende dalla situazione.

Secondo il suo esempio:

Questo caso significa che la prima rete su tutti gli ingressi dice "non so" e la seconda sugli stessi ingressi dice "classe -1". Se i dati sono gli stessi e la differenza è solo nell'inizializzazione dei pesi, molto probabilmente, il caso è una forte mescolanza di classi, a causa della quale le griglie non possono capire intelligentemente il modello di apprendimento e di conseguenza agire "a caso". Parlando di come questo possa accadere, presumo che se la rete (probabilmente è così) usa neuroni di polarizzazione, allora la griglia semplicemente azzera i pesi di tutti gli input di informazione e lascia solo la polarizzazione per l'analisi. L'"analisi", naturalmente, è solo nominale; la rete opera secondo il principio dello struzzo - semplicemente non vede gli input. Per confermare o negare questo, abbiamo bisogno di vedere le matrici della rete addestrata.

Un'altra cosa: il FANN applica il bias-shift in ogni strato tranne quello in entrata...

Ma non ho trovato nulla di simile al bias nella descrizione del pacchetto NN di Statistics 6.

Per un principiante in NS, tutti questi pregiudizi sono davvero sconvolgenti...

 

Sì, molto simile a quello che ho detto, solo al contrario. La rete si perde nei dati. Nota - dall'architettura della rete segue che tutti i pesi del primo strato sono uguali rispetto ai dati di input e dovrebbero, in teoria, essere uniformemente distribuiti intorno allo zero - ma come vedete nell'immagine, sono stati spinti verso l'alto, il che ha causato la saturazione dei neuroni dello strato nascosto (avete una funzione di attivazione logistica ). Le soglie di attivazione non hanno aiutato, perché sono rimaste intorno allo zero, così come il neurone di uscita, che, come previsto, non ha capito nulla di ciò che il primo neurone gli ha detto - ma abbiamo già capito cosa gli è successo.


 

Grande!!!

I valori dei pesi e delle soglie sotto forma di diagramma.

E una prospettiva molto diversa. Grazie.

 
lasso:

Ecco il codice MLP NS generato da "Statistics":

Buon pomeriggio!

Potrebbe suggerire in poche parole, è possibile imparare a compilare un file dll da un file C con una rete neurale generata da Statistica con l'aiuto di un programmatore? Intendo dire di farsi spiegare la procedura una volta, in modo da poterla fare da soli in seguito secondo lo schema. Solo il livello di programmazione in Basic a scuola, e modello NS per lavorare con Foreh, ma ho bisogno di aggiornare la rete regolarmente - leggere nuova dll per generarlo. Nel codice MQL, correggerlo ogni volta è un po' complicato.

 
alexeymosc:

Buon pomeriggio!

È possibile imparare come compilare un file dll da un file C con una rete neurale generata da Statistica con l'aiuto di un programmatore?

Buonanotte!

Penso di no, l'unica eccezione è se quel programmatore non lavora per Statistica stessa ))

alexeymosc:

Nel codice MQL, correggerlo ogni volta è un po' complicato.

Che tipo di NS usate in statistica?

Se si corregge qualcosa manualmente, significa che c'è un algoritmo, quindi deve essere automatizzato....

...............................

Sopra mi è stato consigliato di usare GA, e proprio oggi con l'aiuto della libreria joo(UGALib) sono riuscito a ottenere un risultato desiderabile e stabile.

Ora trascinerò questo caso al 4...

La mia più profonda gratitudine ad Andrei (l'autore). Direzione molto promettente e flessibile.

.....................

Forse vale la pena di scavare in questa direzione?

1...141516171819202122232425
Nuovo commento
Motivazione: