Discussion de l'article "Réseaux neuronaux : De la théorie à la pratique" - page 6

Nouveau commentaire
 
fyords: Bien sûr, je ne suis pas contre le fait de discuter des subtilités des réseaux neuronaux dans ce fil de discussion, mais à l'origine, l 'article était prévu pour les débutants. Il omet certains détails, parce que ces mêmes détails sont capables d'embrouiller un débutant en réseaux neuronaux. Bien entendu, l'article ne précise pas les différentes méthodes d'entraînement (fitting) des réseaux neuronaux, mais ce n'est pas nécessaire au stade initial. Si vous vous rendez compte que les réseaux neuronaux ne sont pas si difficiles, cela ne vous donne pas une excuse pour vous détourner et dire "c'est très difficile et ce n'est pas pour moi". Si vous en savez plus, tant mieux, mais l'article n'est probablement pas pour vous.

Jusqu'à présent, c'est l'absence des détails que j'ai demandés plus haut qui m'a plongé dans la stupeur, moi qui suis un simple idiot. J'ai relu l'article trois fois, mais je n'ai trouvé les réponses dont j'avais besoin que sur le forum.

fyords: Pour l'instant, la deuxième partie portera sur le travail avec les réseaux neuronaux multicouches. Si vous avez des souhaits concernant son contenu, n'hésitez pas à les formuler brièvement.
Une seule question m'intéresse : comment créer un programme d'auto-apprentissage qui pourrait se passer d'un optimiseur "externe". Si une telle chose est possible à ce stade, bien sûr.
 
fyords:

Après quelques délibérations, il a été décidé de rédiger la deuxième partie de l'article.

Pour l'instant, la deuxième partie couvrira le travail avec les réseaux neuronaux multicouches.
Si vous avez des souhaits concernant le contenu de l'article, écrivez-les brièvement.
Les idées que je pourrai transmettre sur mes doigts seront décrites dans l'article.

Je vous remercie.

J'aimerais que la méthode d'apprentissage par gradient soit décrite sur les doigts.
 
Yedelkin:

Je "suppose naïvement" que les locuteurs natifs russes n'ont pas l'habitude d'appeler le processus d'apprentissage indépendant "ajustement des paramètres". De même, il n'est pas accepté d'appeler "apprentissage" la sélection des paramètres (à l'aide de processus externes) pour n'importe quel système.

Quelle que soit la façon dont vous appelez l'ajustement, il ne cessera pas d'être un ajustement.

L'optimisation, l'ajustement et l'apprentissage pour les réseaux neuronaux traitant des données non stationnaires sont des synonymes. En effet, ces trois termes désignent la même chose : la sélection de coefficients de pondération pour des données historiques passées (échantillon d'apprentissage) afin de minimiser les erreurs dans les résultats du réseau neuronal. S'il était possible d'alimenter le réseau avec des données futures, la situation serait différente. Mais les magasins de matériel de bureau ne vendent pas encore de machines à remonter le temps, et nous devons donc nous adapter au passé.

 
Reshetov:

Quel que soit le nom que l'on donne à un raccord, il ne cessera pas d'être un raccord.

La reconversion est définie de manière élémentaire. Il n'y a donc rien à reprocher au miroir.
 
Yedelkin:

Une seule question nous intéresse : comment créer un programme d'auto-apprentissage qui puisse se passer d'un optimiseur "externe". Si cela est possible à ce stade, bien sûr.

C'est simple. Le code EA peut contenir le réseau lui-même et son optimiseur de poids, qui peut être lancé automatiquement lorsque de nouvelles données arrivent. Dans la plupart des cas, les réseaux neuronaux sont des réseaux d'auto-apprentissage. Les réseaux formés en externe, par exemple par l'optimiseur de testeur, sont des jouets.

 
Aidez-moi ! Ai-je bien compris que la normalisation des données d'entrée doit être effectuée pour l'ensemble de la période d'apprentissage du réseau? Je veux dire que les valeurs maximales et minimales de xi doivent être prises sur l'ensemble de la période ?
 
net:
Aidez-moi ! Ai-je bien compris que la normalisation des données d'entrée doit être effectuée pour l'ensemble de la période d'apprentissage du réseau ? Je veux dire que les valeurs maximales et minimales de xi doivent être prises sur l'ensemble de la période ?
C'est nécessaire sur l'ensemble de l'échantillon de formation.
  
//+------------------------------------------------------------------+
//|macd-neuro-example.mq5 |
//| Copyright 2012, MetaQuotes Software Corp.
//|http ://www.mql5.com
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
//| Fonction d'initialisation de l'expert|
//+------------------------------------------------------------------+

#define SIZE 1000

#include <Trade\Trade.mqh>        //connecter la bibliothèque pour effectuer des opérations commerciales
#include <Trade\PositionInfo.mqh> //connecter la bibliothèque pour obtenir des informations sur les positions
#include <Indicators/TimeSeries.mqh>

//--- valeurs des coefficients de pondération 
input double w0=0.5;
input double w1=0.5;
input double w2=0.5;
input double w3=0.5;
input double w4=0.5;
input double w5=0.5;
input double w6=0.5;
input double w7=0.5;
input double w8=0.5;
input double w9=0.5;
input double w10=0.5;
input double w11=0.5;
input double w12=0.5;

string            my_symbol;         // variable pour stocker le caractère
double            inputsH[13];        // tableau pour le stockage des signaux d'entrée
double            inputsL[13];        // tableau pour le stockage des signaux d'entrée
int               periods[13]={2,3,5,8,13,21,34,55,89,144,233,377,610};
int B,Ba;
double            weight[13];        // tableau pour le stockage des coefficients de pondération
double High[SIZE],Low[SIZE];

CTrade            m_Trade;           // objet permettant d'effectuer des opérations commerciales
CPositionInfo     m_Position;        // objet pour les informations sur la position
//+------------------------------------------------------------------+
//||
//+------------------------------------------------------------------+
int OnInit()
  {

   weight[0]=w0;
   weight[1]=w1;
   weight[2]=w2;
   weight[3]=w3;
   weight[4]=w4;
   weight[5]=w5;
   weight[6]=w6;
   weight[7]=w7;
   weight[8]=w8;
   weight[9]=w9;
   weight[10]=w10;
   weight[11]=w11;
   weight[12]=w12;

   my_symbol=Symbol();
   B=Bars(my_symbol,0);

//--- retour 0, initialisation terminée
   return(0);
  }
//+------------------------------------------------------------------+
//| Fonction de désinitialisation de l'expert|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {  }
//+------------------------------------------------------------------+
//| Fonction de tic-tac expert|
//+------------------------------------------------------------------+
void OnTick()
  {

   double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits);                   // meilleure offre d'achat
   double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits);                   // meilleure offre de vente

   B=Bars(my_symbol,0);
   if(B!=Ba)
     {
      CiHigh hi;
      CiLow li;
      hi.Create(_Symbol,_Period);
      li.Create(_Symbol,_Period);
      hi.GetData(0,SIZE,High);
      li.GetData(0,SIZE,Low);
     }
   Ba=B;

     {
      for(int i=0; i<13; i++)
        {
         int HB = ArrayMaximum(High,SIZE-periods[i],periods[i]);
         int LB = ArrayMinimum(Low, SIZE-periods[i],periods[i]);
         if(Bid>=High[HB]) inputsH[i] =1;
         else inputsH[i]=0;
         if(Bid<=Low[LB]) inputsL[i]=1;
         else inputsL[i]=0;
        }

      double outH=CalculateNeuron(inputsH,weight);
      double outL=CalculateNeuron(inputsL,weight);

      //--- si la valeur de sortie du neurone est inférieure à 0
      if(outL>0)
        {
         //--- s'il existe déjà une position pour ce caractère
         if(m_Position.Select(my_symbol))
           {
            //--- et que le type de cette position est Sell, alors fermez-la
            if(m_Position.PositionType()==POSITION_TYPE_SELL) m_Trade.PositionClose(my_symbol);
            //--- et si le type de cette position est Buy, alors exit.
            if(m_Position.PositionType()==POSITION_TYPE_BUY) return;
           }
         //--- si vous êtes arrivé ici, il n'y a pas de position, ouvrez-la.
         m_Trade.Buy(0.1,my_symbol);
        }
      //--- si la valeur de sortie du neurone est supérieure ou égale à 0
      if(outH>0)
        {
         //--- s'il existe déjà une position pour ce caractère
         if(m_Position.Select(my_symbol))
           {
            //--- et que le type de cette position est Achat, alors fermez-la
            if(m_Position.PositionType()==POSITION_TYPE_BUY) m_Trade.PositionClose(my_symbol);
            //--- et si le type de cette position est Sell, alors exit.
            if(m_Position.PositionType()==POSITION_TYPE_SELL) return;
           }
         //--- si vous êtes arrivé ici, il n'y a pas de position, ouvrez-la.
         m_Trade.Sell(0.1,my_symbol);
        }

      if(outH>0.0 || outL>0) Print(outH,"    ",outL);
     }

  }
//+------------------------------------------------------------------+
//|| Fonction de calcul des neurones|
//+------------------------------------------------------------------+
double CalculateNeuron(double &inputs[],double &w[])
  {
//--- variable pour stocker la somme pondérée des signaux d'entrée
   double NET=0.0;
//--- dans la boucle, en fonction du nombre d'entrées, obtenir la somme moyenne pondérée des entrées
   for(int n=0;n<ArraySize(inputs);n++)
     {
      NET+=inputs[n]*w[n];
     }
//--- multiplier la somme moyenne pondérée des entrées par le facteur additif
   return(ActivateNeuron(NET));
  }
//+------------------------------------------------------------------+
//|| Fonction d'activation du neurone|
//+------------------------------------------------------------------+
double ActivateNeuron(double x)
  {
//--- variable pour stocker le résultat de la fonction d'activation
   double Out;
//--- fonction tangente hyperbolique
   Out=(exp(x)-exp(-x))/(exp(x)+exp(-x));
//--- renvoie la valeur de la fonction d'activation
   return(Out);
  }
//+------------------------------------------------------------------+

J'ai écrit ce hibou. Peut-on dire qu'il s'agit d'un réseau neuronal, car j'ai des doutes.

Chouette pour trader dans le canal.

L'algorithme est le suivant : on prend les extremums pour le nombre de barres Fibo (2,3,5,8,13....). Pour chaque neurone à acheter, par exemple - si le prix est inférieur ou égal au prix de l'extremum LOW pendant une période, alors retourner 1 sinon - 0. De plus, comme dans l'exemple avec NeuronMACD. Pour vendre, il faut faire l'inverse.

J'attends les critiques sur le code et l'algorithme.

 
dimeon:

J'ai écrit ce hibou. Peut-on dire qu'il s'agit d'un réseau neuronal, car j'ai des doutes.

Chouette pour trader dans le canal.

L'algorithme est le suivant : on prend les extremums pour le nombre de barres Fibo (2,3,5,8,13....). Pour chaque neurone d'achat, par exemple - si le prix est inférieur ou égal au prix de l'extremum LOW pour une période, nous retournons 1 sinon - 0. De plus, comme dans l'exemple avec NeuronMACD. Pour vendre, il faut faire l'inverse.

J'attends la critique du code et de l'algorithme.

Dans votre cas, la fonction d'activation des neurones peut être jetée, c'est un frein inutile.
return(NET);
Ce n'est pas un réseau neuronal, c'est juste un perceptron. Il faut au moins quelques perceptrons pour un réseau.
 
her.human:
Dans votre cas, la fonction d'activation des neurones peut être supprimée, ce qui constitue un frein inutile.
return(NET);
Ce n'est pas un réseau neuronal, c'est juste un perceptron. Il faut au moins deux perceptrons pour un réseau.
Pouvez-vous me donner un exemple, comme l'ajout d'un MA ou d'un autre indicateur ou quelque chose d'autre, et me dire comment mettre tout cela en réseau ?
1234567891011
Nouveau commentaire