cost2fitness

Cost2Fitness

Package PYPI pour les valeurs de coût de conversion (moins c'est mieux) en valeurs de fitness (plus c'est mieux) et vice versa

 pip install cost2fitness

• Cost2Fitness
  • À propos
  • Transformateurs
  • Pipeline de transformateurs
  • Comment tracer
  • Exemples de traçage
    • Chaque transformateur
    • Pipeline
  • Outils neuraux
    • Couches
    • Assistants
    • Exemples

À propos

Il s'agit du package contenant plusieurs méthodes de transformation des tableaux Numpy dépendants des échelles, des moyennes, etc. Mais la principale façon de l'utiliser est la conversion des valeurs de coût (moins c'est mieux) aux valeurs de fitness (plus c'est mieux) et vice versa. Cela peut être très utile lorsque vous utilisez

• Les algorithmes évolutifs dépendaient des différences numériques: il est donc important de définir une bonne représentation des scores d'échantillons pour une meilleure sélection
• Les méthodes d'échantillonnage avec des probabilités dépendaient des scores d'échantillons

Transformateurs

Il existe plusieurs transformateurs simples. Chaque transformateur est la sous-classe de la classe BaseTransformer contenant le champ name et la méthode transform(array) qui transforme le tableau d'entrée en nouvelle représentation.

Liste de contrôle:

• ReverseByAverage ,
• AntiMax ,
• AntiMaxPercent(percent) ,
• Min2Zero ,
• Min2Value(value) ,
• ProbabilityView (convertit les données en probabilités),
• SimplestReverse ,
• AlwaysOnes (retourne la table de ceux),
• NewAvgByMult(new_average) ,
• NewAvgByShift(new_average)
• Divider(divider_number_or_array) (divise le tableau sur le numéro ou le tableau, utile pour la normalisation de démarrage fixe)
• Argmax (Renvoie la position de l'élément maximum dans le tableau)
• Prob2Class(threshold = 0.5) (pour convertir les probabilités en classes 0/1)
• ToNumber (convertit le tableau en un numéro en obtenant le premier élément)

Vous pouvez créer votre transformateur à l'aide de la logique simple à partir du fichier.

 import numpy as np 

from cost2fitness import Min2Zero

tf = Min2Zero ()

arr_of_scores = np . array ([ 10 , 8 , 7 , 5 , 8 , 9 , 20 , 12 , 6 , 18 ])

tf . transform ( arr_of_scores )
# array([ 5,  3,  2,  0,  3,  4, 15,  7,  1, 13]) 

Pipeline de transformateurs

U peut également combiner ces transformateurs à l'aide du pipeline Pl . Par exemple:

 import numpy as np 

from cost2fitness import ReverseByAverage , AntiMax , Min2Zero , Pl

pipe = Pl ([
        Min2Zero (),
        ReverseByAverage (),
        AntiMax ()        
        ])


arr_of_scores = np . array ([ 10 , 8 , 7 , 5 , 8 , 9 ])


# return each result of pipeline transformation (with input)
pipe . transform ( arr_of_scores , return_all_steps = True )
#array([[10.        ,  8.        ,  7.        ,  5.        ,  8.        ,
#         9.        ],
#       [ 5.        ,  3.        ,  2.        ,  0.        ,  3.        ,
#         4.        ],
#       [ 0.66666667,  2.66666667,  3.66666667,  5.66666667,  2.66666667,
#         1.66666667],
#       [ 5.        ,  3.        ,  2.        ,  0.        ,  3.        ,
#         4.        ]])

# return only result of transformation
pipe . transform ( arr_of_scores , return_all_steps = False )
#array([5., 3., 2., 0., 3., 4.]) 

Comment tracer

Il existe une fonction plot_scores pour tracer les résultats du processus de transformation. Il a des arguments:

• scores : Array 2D Numpy Array 2D Numpy Array with Structure [start_values, first_transform(start_values), second_transform(first_transform), ...] , où chaque objet est un tableau 1D de scores (valeurs / coûts / fitness).
• names : None / String List, Noms facultatifs pour chaque étape pour les étiquettes de tracé. La valeur par défaut n'est None .
• kind : STR, facultatif pour «à côté» de chaque nouvelle colonne sera à côté des précédents; pour «Under», il y aura un nouveau complot sous précédent. La valeur par défaut est «à côté».
• save_as : None / Str, chemin de fichier facultatif pour enregistrer le tracé. La valeur par défaut n'est None .

Exemples de traçage

Chaque transformateur

Code

Pipeline

Code

Outils neuraux

J'ai fait des outils de réseau neuronal de base ici car il est très nécessaire d'utiliser des réseaux simples avec certaines tâches d'apprentissage de renforcement , mais les packages courants comme les keras fonctionnent extrêmement lents si vous avez besoin de prédiction (propagation vers l'avant) uniquement pour 1 échantillon mais plusieurs fois. Il sera donc plus rapide d'utiliser des packages simples basés sur Numpy pour ces cas.

Couches

Il n'était pas si difficile d'utiliser cette logique de transformateurs pour créer des réseaux de neurones. Ce package a donc les couches de réseau neuronal suivantes en tant que transformateurs:

• Activations :

  • Softmax
  • Relu
  • LeakyRelu(alpha = 0.01)
  • Sigmoid
  • Tanh
  • ArcTan
  • Swish(beta = 0.25)
  • Softplus
  • Softsign
  • Elu(alpha)
  • Selu(alpha, scale)

• Outils de couches denses :

  • Bias(bias_len, bias_array = None) - pour ajouter un biais avec la longueur bias_len . Si bias_array None , utilise un biais aléatoire
  • MatrixDot(from_size, to_size, matrix_array = None)
  • NNStep(from_size, to_size, matrix_array = None, bias_array = None) - c'est MatrixDot et Bias ensemble, si vous voulez les créer plus rapidement

Assistants

Et il existe plusieurs méthodes d'aide pour utiliser un objet pipeline comme le réseau neuronal (uniquement pour la propagation directe bien sûr):

• Méthodes d'objets pipeline :

  • get_shapes() - Pour obtenir la liste des formes du tableau nécessaire pour NN
  • total_weights() - Obtenez le compte de poids pour le NN global
  • set_weights(weights) - régler des poids (comme liste des tableaux avec les formes nécessaires) pour NN

• Fonctions seules :

  • arr_to_weigths(arr, shapes) - convertit le 1D-array arr à la liste des tableaux avec des formes shapes pour le mettre dans la méthode set_weights

Exemples

Voir l'exemple le plus simple