cost2fitness

Costo2fitness

Paquete PYPI para valores de costos de conversión (menos es mejor) para los valores de aptitud física (más es mejor) y viceversa

 pip install cost2fitness

• Costo2fitness
  • Acerca de
  • Transformadores
  • Tubería de transformadores
  • Cómo trazar
  • Ejemplos con trazado
    • Cada transformador
    • Tubería
  • Herramientas de red neuronal
    • Capas
    • Ayudantes
    • Ejemplos

Acerca de

Este es el paquete que contiene varios métodos para la transformación de matrices numpy dependiendo de escalas, promedios, etc. Pero la forma principal de usarlo es la conversión de los valores de costo (menos es mejor) a los valores de aptitud (más es mejor) y viceversa. Puede ser muy útil cuando usas

• Los algoritmos evolutivos dependían de las diferencias numéricas: por lo tanto, es importante establecer una buena representación de las puntuaciones de las muestras para una mejor selección
• Los métodos de muestreo con probabilidades dependían de las puntuaciones de las muestras

Transformadores

Hay varios transformadores simples. Cada transformador es la subclase de la clase BaseTransformer que contiene el método de name y transform(array) que transforma la matriz de entrada en una nueva representación.

Lista de verificación:

• ReverseByAverage ,
• AntiMax ,
• AntiMaxPercent(percent) ,
• Min2Zero ,
• Min2Value(value) ,
• ProbabilityView (convierte los datos en probabilidades),
• SimplestReverse ,
• AlwaysOnes (devuelve la matriz de los que),
• NewAvgByMult(new_average) ,
• NewAvgByShift(new_average)
• Divider(divider_number_or_array) (divide la matriz en el número o la matriz, útil para la normalización de inicio fijo)
• Argmax (Posición de retorno del elemento máximo en la matriz)
• Prob2Class(threshold = 0.5) (para convertir las probabilidades en las clases 0/1)
• ToNumber (convierte la matriz en un número obteniendo el primer elemento)

Puedes crear tu transformador usando una lógica simple desde el archivo.

 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]) 

Tubería de transformadores

También puede combinar estos transformadores utilizando la tubería Pl . Por ejemplo:

 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.]) 

Cómo trazar

Hay una función plot_scores para trazar los resultados del proceso de transformación. Tiene argumentos:

• scores : matriz 2D Numpy 2D Numpy Array con estructura [start_values, first_transform(start_values), second_transform(first_transform), ...] , donde cada objeto es 1D-array de puntajes (valores/costos/fitness).
• names : Lista None /cadena, nombres opcionales para cada paso para las etiquetas de la trama. El valor predeterminado es None .
• kind : str, opcional para 'al lado' de cada nueva columna estará al lado anterior; Para 'Under' habrá una nueva trama bajo anterior. El valor predeterminado es 'al lado'.
• save_as : None /Str, ruta de archivo opcional para guardar el gráfico. El valor predeterminado es None .

Ejemplos con trazado

Cada transformador

Código

Tubería

Código

Herramientas de red neuronal

He hecho herramientas básicas de red neuronal aquí porque es muy necesario usar redes simples con algunas tareas de aprendizaje de refuerzo , pero los paquetes comunes como Keras funcionan extremadamente lentos si necesita una predicción (propagación hacia adelante) solo por 1 muestra pero muchas veces. Por lo tanto, será más rápido usar paquetes simples basados ​​en numpy para estos casos.

Capas

No fue tan difícil usar esta lógica de transformadores para crear redes neuronales. Entonces, este paquete tiene las próximas capas de red neuronales como transformadores:

• Activaciones :

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

• Herramientas de capas densas :

  • Bias(bias_len, bias_array = None) - para agregar sesgo con longitud bias_len . Si bias_array no es None , usa un sesgo aleatorio
  • MatrixDot(from_size, to_size, matrix_array = None)
  • NNStep(from_size, to_size, matrix_array = None, bias_array = None) - es MatrixDot y Bias juntos, si quieres crearlos más rápido

Ayudantes

Y hay varios métodos de ayudantes para usar el objeto pipeline como la red neuronal (solo para la propagación hacia adelante , por supuesto):

• Métodos de objetos pipeline :

  • get_shapes() - Para obtener una lista de formas de matriz necesaria para nn
  • total_weights() - Obtenga recuento de pesos para NN general
  • set_weights(weights) - set pesos (como lista de matrices con formas necesarias) para nn

• Funciones solas :

  • arr_to_weigths(arr, shapes) -Convierte 1D-Array arr a la lista de matrices con shapes formas para ponerlo en el método set_weights

Ejemplos

Ver ejemplo más simple