"New Neural" est un projet de moteur de réseau neuronal Open Source pour la plateforme MetaTrader 5. - page 39

Nouveau commentaire
 

Devons-nous construire des réseaux de base radiaux ?

ils ont un bug fort, alors qu'ils apprennent rapidement, ils prédisent mal sur des données inconnues.

 
Urain:

u - entrée de l'activateur

y - facteur de puissance supplémentaire.

Partout où il y a un exposant, il faut éviter de calculer des exposants de nombres positifs pour ne pas obtenir de grands nombres dépassant 32 bits. Par exemple, pour calculer le sigma, il est préférable de procéder comme suit

double x = -y*u ;

double e=exp(-|x|) ;

if(x<=0) return(1./(1.+e))

si(x>0)return(e/(1.+e)) ;

Ces formules sont dérivées assez simplement. Si l'argument exposant est négatif, nous laissons la formule inchangée. Si elle est positive, on multiplie le numérateur et le dénominateur par l'exposant du même argument, mais avec un signe négatif.

 
Vinin:

C'est toi qui as le lecteur de djvu . J'ai tous mes livres lisibles.
 
gpwr:

Partout où il y a un exposant, il faut éviter de calculer des exposants de nombres positifs pour ne pas obtenir de grands nombres dépassant 32 bits. Par exemple, le calcul du sigma est meilleur de la façon suivante

double x = -y*u ;

double e=exp(-|x|) ;

if(x<=0) return(1./(1.+e))

si(x>0)return(e/(1.+e)) ;

Ces formules sont dérivées assez simplement. Si l'argument exposant est négatif, nous laissons la formule inchangée. S'il est positif, on multiplie le numérateur et le dénominateur par l'exposant du même argument, mais avec un signe négatif.

Bizarrement, la sigmoïde elle-même fonctionne correctement même avec de grandes entrées négatives, mais la fonction hypertangente échoue, j'ai donc ajouté une sigmoïde décalée en plus des algorithmes classiques. Cette fonction fonctionne dans la même limite que l'hypertangente, mais elle est plus rapide et n'a pas de problème de #IND.

De même, avec le réglage de l'angle d'attaque (pour de petites valeurs du coefficient y), l'hypertangente n'atteint pas -1;1, la sigmoïde décalée n'a pas de tels problèmes.

En général, qui veut finaliser hypertangente, mais je pense que la fonction est peu prometteur, non seulement que je dois enregistrer le résultat parce que l'exposant est utilisé deux fois, donc encore besoin de contrôles, plus des problèmes avec l'échec à atteindre les limites lors de l'ajustement de l'attaque.

Ma conclusion est que l'hypertangente n'est pas une solution, la sigmoïde décalée est la meilleure.

 
Urain:

J'en conclus que l'hypertangente est à proscrire, la sigmoïde décalée est la règle.

secondé.
 
joo:
secondé.

Il est possible de réaliser une implémentation plus simple de la sigmoïde dans la limite [-1;1].

double sigma(double u,double y=1.)// [-1;1]
  {   
   return(exp(-y*u));
  }

mais cette implémentation a aussi un problème avec #IND, donc il est préférable d'ajouter quelques opérations simples que d'écrire de nombreuses vérifications

ici nous ajoutons + - / , donc 3 opérations supplémentaires contre beaucoup de vérifications

double sigmah(double u,double y=1.)// [-1;1] сдвинутый сигмоид
  {
   return((2./(1.+exp(-y*u)))-1.);
  }
 
Urain:
double sigmah(double u,double y=1.)// [-1;1] сдвинутый сигмоид
  {
   return((2./(1.+exp(-y*u)))-1.);
  }

Il s'agit de la meilleure option, tant en termes de facilité de travail dans la plage [-1;1] que de rapidité d'exécution. La zone de définition correspond à la totalité de la ligne numérique.

C'est exactement la fonction d'activation que j'ai utilisée ces derniers temps, après avoir essayé de nombreuses alternatives et testé leur vitesse d'exécution.

 

Et celui-ci est mon préféré dans la grille d'écho :

class RSDNFunction
{
public:
        static const NeuronType Type = ETYPE_RSDN;
public:
        double F(double x)
        {
                // coeffs were added to adjust this function to bisigmoid for values from -5 to 5
                return 5*x/(5*sqrt(abs(5*x) ) + 5);
        }

        double dF(double x)
        {
                double root = sqrt(5*abs(5*x) ) + 1;

                return (root + 1)/(2*root*root); // derived function 
        }
};
 

Au fait.

Une fonction sigmoïde est nécessaire.

Les exigences sont une forme normale de la fonction elle-même et de sa dérivée (pas trop difficile à calculer) et une forme normale de la fonction inverse et de sa dérivée.

1...323334353637383940414243444546...100
Nouveau commentaire
Raison: