cost2fitness

Cost2Fitness

Pacote Pypi para valores de custo de conversão (menos é melhor) para valores de condicionamento físico (mais é melhor) e vice -versa

 pip install cost2fitness

• Cost2Fitness
  • Sobre
  • Transformadores
  • Oleoduto de transformadores
  • Como plotar
  • Exemplos com plotagem
    • Cada transformador
    • Oleoduto
  • Ferramentas de rede neural
    • Camadas
    • Ajudantes
    • Exemplos

Sobre

Este é o pacote que contém vários métodos para transformação de matrizes numpy dependia de escalas, médias e assim por diante. Mas a principal maneira de usá -lo é a conversão dos valores de custo (menos é melhor) em valores de condicionamento físico (mais é melhor) e vice -versa. Pode ser altamente útil quando você está usando

• Os algoritmos evolutivos dependiam das diferenças numéricas: então, é importante definir uma boa representação das pontuações de amostras para melhor seleção
• Métodos de amostragem com probabilidades dependiam das pontuações das amostras

Transformadores

Existem vários transformadores simples. Cada transformador é a subclasse da classe BaseTransformer contendo o campo name e o Método transform(array) que transforma a matriz de entrada em uma nova representação.

Lista de verificação:

• ReverseByAverage ,
• AntiMax ,
• AntiMaxPercent(percent) ,
• Min2Zero ,
• Min2Value(value) ,
• ProbabilityView (converte dados em probabilidades),
• SimplestReverse ,
• AlwaysOnes (Retorna Array de One),
• NewAvgByMult(new_average) ,
• NewAvgByShift(new_average)
• Divider(divider_number_or_array) (divide a matriz no número ou matriz, útil para a normalização fixa de início)
• Argmax (Retorna a posição do elemento máximo na matriz)
• Prob2Class(threshold = 0.5) (para converter probabilidades em classes 0/1)
• ToNumber (Converter Array em um número obtendo o primeiro elemento)

Você pode criar seu transformador usando lógica simples do arquivo.

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

Oleoduto de transformadores

U também pode combinar esses transformadores usando Pl Pipeline. Por exemplo:

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

Como plotar

Há função plot_scores para plotar resultados do processo de transformação. Tem argumentos:

• scores : 2D Array 2D Numpy Array com estrutura [start_values, first_transform(start_values), second_transform(first_transform), ...] , onde cada objeto é 1d-gray de pontuações (valores/custos/fitnesses).
• names : Lista de None /string, nomes opcionais para cada etapa para etiquetas da plotagem. O padrão é None .
• kind : STR, opcional para 'Bairide', cada nova coluna estará ao lado do anterior; Para 'Under', haverá um novo enredo sob anterior. O padrão é "ao lado".
• save_as : None /STR, caminho de arquivo opcional para salvar o gráfico. O padrão é None .

Exemplos com plotagem

Cada transformador

Código

Oleoduto

Código

Ferramentas de rede neural

Eu fiz ferramentas básicas de rede neural aqui, porque é muito necessário usar redes simples com algumas tarefas de aprendizado de reforço , mas pacotes comuns como as keras funcionam extremamente lentos se precisar apenas de previsão (propagação direta) apenas para 1 amostra, mas muitas vezes. Portanto, será mais rápido usar pacotes simples baseados em Numpy para esses casos.

Camadas

Não era tão difícil usar essa lógica dos Transformers para criar redes neurais. Portanto, este pacote tem as próximas camadas de rede neural como transformadores:

• Ativações :

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

• Ferramentas densas de camadas :

  • Bias(bias_len, bias_array = None) - para adicionar viés com comprimento bias_len . Se bias_array None , usa viés aleatório
  • MatrixDot(from_size, to_size, matrix_array = None)
  • NNStep(from_size, to_size, matrix_array = None, bias_array = None) - é MatrixDot e Bias juntos, se você quiser criá -los mais rápido

Ajudantes

E existem vários métodos de ajuda para usar objeto pipeline como rede neural (apenas para propagação avançada , é claro):

• Métodos de objetos pipeline :

  • get_shapes() - Para obter uma lista de formas de matriz necessária para nn
  • total_weights() - Obtenha contagem de pesos para NN em geral
  • set_weights(weights) - Defina pesos (como lista de matrizes com formas necessárias) para NN

• Funções sozinhas :

  • arr_to_weigths(arr, shapes) -Converte 1D-Array arr em Lista de Matrizes com Shapes shapes para colocá-lo no Método set_weights

Exemplos

Veja o exemplo mais simples