Redes neurais. Perguntas dos especialistas. - página 21

Novo comentário
 
alsu:

4) Parâmetros de inicialização dos pesos - a forma de distribuição dos valores e sua variância.

Encontrado. É possível definir os parâmetros de inicialização para os pesos.

Parece que eu usei os valores padrão.


 
LeoV:
Redes Neurais Artificiais e Algoritmos Genéticos Curso de treinamento avançado de curta duração
e algoritmos genéticos".

As aplicações para cursos de treinamento avançado de curto prazo "Redes Neurais Artificiais e Algoritmos Genéticos" estão fechadas
Redes Neurais Artificiais e Algoritmos Genéticos",
conduzido pelo Departamento de Educação Continuada da Universidade Estadual de Moscou M.V. Lomonosov
V.V. Lomonosov Universidade Estadual de Moscou, com base no Instituto de Pesquisa Nuclear da Universidade Estadual de Moscou
Universidade Estadual de Moscou. Os concluintes dos cursos recebem um certificado estadual de treinamento profissional avançado.
certificado estadual de treinamento avançado.
Os treinamentos serão realizados duas vezes por semana à noite, a partir das 19h00.
As aulas começam em 25 de fevereiro de 2011.

Para saber mais sobre o programa do curso, obtenha mais informações e
Favor clicar aqui para se candidatar ao curso:
http://www.neuroproject.ru/kpk.php
Desculpe, isto é um anúncio ou você mesmo vai fazer o curso?
 
lasso:

Encontrado. É possível definir os parâmetros de inicialização para as escalas.

Pareço ter usado os valores padrão.


Bem, parece estar claro qual é a questão aqui.

A partir de seu problema (como eu entendo que você tem dados unidimensionais que você quer dividir em duas classes), a questão é encontrar um ponto (apenas um!) no conjunto de valores de entrada, que executa de forma ideal a divisão especificada. Suponha que você tenha uma rede 1-7-1. Esta rede tem 21 pesos (sete entradas para a camada oculta, sete deslocamentos para ela, e sete entradas para o neurônio de saída). Acontece que estamos tentando encontrar um ponto, captando 21 variáveis. Com tal redundância de vinte e um para um não há nada de surpreendente que as leituras da rede mudem tanto - qualquer menor diferença no peso inicial leva a uma significativa dispersão de resultados após o treinamento. Grosso modo, acontece que a tarefa é muito simples para a rede, mas como ela não sabe disso, procura algo que não existe. Tecnicamente, isto provavelmente pode ser chamado de reciclagem, mas em essência está atirando um canhão contra pardais.

A tarefa de dividir os dados unidimensionais em duas classes é realizada com sucesso por um único neurônio com um peso de entrada e um viés.

 
lasso:

Mais uma coisa. Estou alarmado com a "estreiteza" da gama de saídas da rede atual. Para esclarecer:

-- a rede MLP é 1-7-1

-- As entradas na rede são distribuídas uniformemente na faixa [0;1], as saídas nos exemplos de treinamento são 1 e -1.

Se após o treinamento toda a faixa de valores de entrada for passada através da rede, vemos que as saídas da rede se encontram em uma faixa muito estreita. Por exemplo:

opt_max_act=-0.50401336 opt_min_act=-0.50973881 step=0.0000286272901034

ou mesmo assim

opt_max_real=-0.99997914 opt_min_real=-0.99999908 step=0.00000010

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

Isto é correto ou não?


É difícil dizer sobre a exatidão... depende da situação

De acordo com seu exemplo:

Este caso significa que a primeira rede em todas as entradas diz "não sei" e a segunda nas mesmas entradas diz "classe -1". Se os dados são os mesmos e a diferença está apenas na inicialização dos pesos, muito provavelmente, o caso é uma forte mistura de classes, devido à qual as grades não conseguem entender inteligentemente o padrão de aprendizagem e, como resultado, agem "ao acaso". Falando sobre como isto pode acontecer, presumo que se a rede (provavelmente assim) utiliza neurônios tendenciosos, a grade simplesmente zera os pesos de todas as entradas de informação e deixa apenas o enviesamento para análise. A "análise", naturalmente, é apenas nominal; a rede opera de acordo com o princípio da avestruz - simplesmente não vê os insumos. Para confirmar ou negar isto, precisamos ver as matrizes da rede treinada.

 

Aqui está o código MLP NS gerado pela "Estatística":

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


#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:

É difícil dizer sobre a exatidão... depende da situação.

De acordo com seu exemplo:

Este caso significa que a primeira rede em todas as entradas diz "não sei" e a segunda nas mesmas entradas diz "classe -1". Se os dados são os mesmos e a diferença está apenas na inicialização de pesos, muito provavelmente, o caso é uma forte mistura de classes, devido à qual as grades não conseguem entender inteligentemente o padrão de aprendizagem e, como resultado, agem "ao acaso". Falando sobre como isto pode acontecer, presumo que se a rede (provavelmente assim) utiliza neurônios tendenciosos, a grade simplesmente zera os pesos de todas as entradas de informação e deixa apenas o enviesamento para análise. "Análise", é claro, é apenas nominal; a rede opera de acordo com o princípio da avestruz - simplesmente não vê os insumos. Para confirmar ou negar isto, precisamos ver as matrizes da rede treinada.

Mais uma coisa: a FANN aplica o bias-shift em todas as camadas, exceto na entrada...

Mas não encontrei nada semelhante ao viés na descrição do pacote NN de estatísticas 6.

Para um iniciante em NS, todos esses preconceitos são realmente espantosos.

 

Sim, muito parecido com o que eu disse, apenas ao contrário. A rede apenas se perde nos dados. Nota - da arquitetura de rede segue-se que todos os pesos da primeira camada são iguais com relação aos dados de entrada e devem, em teoria, ser distribuídos uniformemente em torno de zero - mas, como você vê na figura, eles foram colididos, o que fez com que os neurônios da camada oculta entrassem em saturação (você tem uma função de ativação logística ). Os limiares de ativação não ajudaram, pois permaneceram em torno de zero, assim como o neurônio de saída, que, como esperado, não entendeu nada do que o primeiro neurônio lhe disse - mas já descobrimos o que aconteceu com ele.


 

Ótimo!!!

Os valores dos pesos e limiares na forma de um diagrama.

E uma perspectiva muito diferente. Obrigado.

 
lasso:

Aqui está o código MLP NS gerado pela "Estatística":

Boa tarde!

Você poderia sugerir em poucas palavras, é possível aprender como compilar um arquivo dll a partir de um arquivo C com uma rede neural gerada pelo Statistica com a ajuda de um programador? Pretendo que o procedimento seja explicado uma vez, para que você mesmo o possa fazer depois, de acordo com o esquema. Apenas o nível de programação em Basic na escola, e modelo NS para trabalhar com Foreh, mas eu preciso atualizar a rede regularmente - leia uma nova dll para gerá-la. No código MQL, corrigi-lo sempre é um pouco complicado.

 
alexeymosc:

Boa tarde!

É possível aprender como compilar um arquivo dll a partir de um arquivo C com uma rede neural gerada pelo Statistica com a ajuda de um programador?

Boa noite!

Eu acho que não, a única exceção é se aquele programador não trabalhar para a Statistica em si))

alexeymosc:

No código MQL, corrigi-lo sempre é um pouco complicado.

Que tipo de NS você usa em Estatística?

Se você corrigir algo manualmente, isso significa que há um algoritmo, então ele precisa ser automatizado....

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

Acima fui recomendado a usar GA, e só hoje com a ajuda da biblioteca joo(UGALib) consegui obter um resultado desejável e estável.

Agora vou arrastar e largar este caso para 4...

Minha profunda gratidão a Andrei (o autor). Uma direção muito promissora e flexível.

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

Pode valer a pena cavar nesta direção?

1...141516171819202122232425
Novo comentário
Razão: