Como obter resultados reproduzíveis em keras

votos
41

Eu obter resultados diferentes (precisão do teste) cada vez que eu executar o imdb_lstm.pyexemplo do quadro Keras ( https://github.com/fchollet/keras/blob/master/examples/imdb_lstm.py ) O código contém np.random.seed(1337)no topo, antes de qualquer keras importações. Ele deve impedi-lo de geração de números diferentes para cada corrida. o que estou perdendo?

UPDATE: Como repro:

  1. Instalar Keras ( http://keras.io/ )
  2. Executar https://github.com/fchollet/keras/blob/master/examples/imdb_lstm.py algumas vezes. Ele vai treinar a precisão do teste modelo e saída.
    Resultado esperado: a precisão do teste é o mesmo em cada corrida.
    Resultado real: a precisão do teste é diferente em cada corrida.

UPDATE2: Eu estou executando-lo no Windows 8.1 com MinGW / msys, versões de módulo:
Theano 0.7.0
numpy 1.8.1
0.14.0c1 scipy

Update3: Eu estreitou o problema para baixo um pouco. Se eu executar o exemplo com GPU (flag set Theano device = gpu0) então eu começo a precisão do teste diferente a cada vez, mas se eu executá-lo em CPU, em seguida, tudo funciona como esperado. Minha placa de vídeo: NVIDIA GeForce GT 635)

Publicado 06/09/2015 em 01:41
fonte usuário
Em outras línguas...                            


9 respostas

votos
10

De THEANO documentação fala sobre as dificuldades de semeadura variáveis aleatórias e por que eles semear cada instância gráfico com o seu próprio gerador de números aleatórios.

Partilhando um gerador de número aleatório entre diferentes { `RandomOp`} casos torna difícil produzir o mesmo fluxo, independentemente de outras operações do gráfico, e para manter {` RandomOps`} isolado. Portanto, cada `{} RandomOp` exemplo em um gráfico que vai ter o seu próprio gerador de números aleatórios. Esse gerador de números aleatórios é uma entrada para a função. No uso típico, vamos usar os novos recursos de entradas de função ({ `value`}, {` update`}) para passar e atualizar o RNG para cada { `RandomOp`}. Ao passar RNG como entradas, é possível usar os métodos normais de acesso a entradas de função para acessar cada { `RandomOp`} 's RNG. Nesta abordagem que não há nenhum mecanismo de pré-existente para trabalhar com o estado número aleatório combinado de um gráfico inteiro.

Eles também fornecem exemplos sobre como propagar todos os geradores de números aleatórios.

Você também pode semear todas as variáveis ​​aleatórias alocados por um objeto RandomStreams pelo método semente desse objeto. Esta semente vai ser utilizada para semear um gerador de números aleatórios temporária, que por sua vez irá gerar sementes para cada uma das variáveis ​​aleatórias.

>>> srng.seed(902340)  # seeds rv_u and rv_n with different seeds each
Respondeu 21/09/2015 em 02:45
fonte usuário

votos
0

Concordo com o comentário anterior, mas resultados reproduzíveis às vezes precisa mesmo ambiente (por exemplo, os pacotes instalados, características da máquina e assim por diante). De modo que, eu recomendo para copiar seu ambiente para outro lugar, no caso de ter resultados reproduzíveis. Tente usar um dos seguintes tecnologias:

  1. Docker . Se você tem um Linux isso muito fácil para mover seu ambiente para outro lugar. Além disso, você pode tentar usar DockerHub .
  2. Binder . Esta é uma plataforma de nuvem para reproduzir experimentos científicos.
  3. Everware . Esta é mais uma plataforma de nuvem para "ciência reutilizáveis". Veja o repositório do projeto no Github.
Respondeu 27/04/2016 em 10:44
fonte usuário

votos
0

Eu tenho treinado e testado Sequential()tipo de redes neurais usando Keras. Eu realizada regressão não linear de dados de fala ruidosos. I usado o seguinte código para gerar semente aleatória:

import numpy as np
seed = 7
np.random.seed(seed)

Eu obter os mesmos resultados exatos de val_losscada vez que eu treino e de teste nos mesmos dados.

Respondeu 14/07/2016 em 09:17
fonte usuário

votos
1

Eu gostaria de acrescentar algo para as respostas anteriores. Se você usar python 3 e você deseja obter resultados reprodutíveis para cada corrida, você tem que

  1. conjunto numpy.random.seed no início do seu código
  2. dar PYTHONHASHSEED = 0 como parâmetro para o interpretador Python
Respondeu 15/08/2016 em 05:57
fonte usuário

votos
6

Eu finalmente consegui resultados reproduzíveis com meu código. É uma combinação de respostas que vi em toda a web. A primeira coisa é fazer o que @alex diz:

  1. definir numpy.random.seed;
  2. Use PYTHONHASHSEED=0para Python 3.

Então você tem que resolver o problema observado por @ user2805751 sobre cuDNN chamando seu código Keras com o seguinte adicional THEANO_FLAGS:

  1. dnn.conv.algo_bwd_filter=deterministic,dnn.conv.algo_bwd_data=deterministic

E, finalmente, você tem que corrigir sua instalação Theano como por este comentário , que consiste basicamente em:

  1. substituindo todas as chamadas para *_dev20operador por sua versão regular theano/sandbox/cuda/opt.py.

Isto deve dar para os mesmos resultados para a mesma semente.

Note-se que pode haver uma desaceleração. Eu vi um aumento de tempo de execução de cerca de 10%.

Respondeu 20/10/2016 em 09:05
fonte usuário

votos
7

Você pode encontrar a resposta em docs Keras: https://keras.io/getting-started/faq/#how-can-i-obtain-reproducible-results-using-keras-during-development .

Em suma, para ter a certeza absoluta que você vai obter resultados reproduzíveis com o seu script python no CPU de um computador / laptop , então você terá que fazer o seguinte:

  1. Ajuste PYTHONHASHSEEDvariável de ambiente a um valor fixo
  2. Conjunto pythongerador de pseudo-aleatória a um valor fixo
  3. Definir numpygerador pseudo-aleatória a um valor fixo
  4. Definir tensorflowgerador pseudo-aleatória a um valor fixo
  5. Configurar um novo global de tensorflowsessão

Seguindo o Keraslink na parte superior, o código-fonte que estou usando é o seguinte:

# Seed value
# Apparently you may use different seed values at each stage
seed_value= 0

# 1. Set `PYTHONHASHSEED` environment variable at a fixed value
import os
os.environ['PYTHONHASHSEED']=str(seed_value)

# 2. Set `python` built-in pseudo-random generator at a fixed value
import random
random.seed(seed_value)

# 3. Set `numpy` pseudo-random generator at a fixed value
import numpy as np
np.random.seed(seed_value)

# 4. Set `tensorflow` pseudo-random generator at a fixed value
import tensorflow as tf
tf.set_random_seed(seed_value)

# 5. Configure a new global `tensorflow` session
from keras import backend as K
session_conf = tf.ConfigProto(intra_op_parallelism_threads=1, inter_op_parallelism_threads=1)
sess = tf.Session(graph=tf.get_default_graph(), config=session_conf)
K.set_session(sess)

É escusado será dizer que você não tem que especificar qualquer seedou random_stateno numpy, scikit-learnou tensorflow/ kerasfunções que você está usando em seu script python exatamente porque com o código-fonte acima, definido globalmente seus geradores pseudo-aleatórios em um valor fixo.

Respondeu 19/10/2018 em 16:23
fonte usuário

votos
0

Isso funciona para mim:

SEED = 123456
import os
import random as rn
import numpy as np
from tensorflow import set_random_seed

os.environ['PYTHONHASHSEED']=str(SEED)
np.random.seed(SEED)
set_random_seed(SEED)
rn.seed(SEED)
Respondeu 15/06/2019 em 01:40
fonte usuário

votos
0

O problema está agora resolvido em Tensorflow 2.0! Eu tive o mesmo problema com TF 1.x (ver Se os resultados Keras não são reproduzíveis, qual é a melhor prática para comparar modelos e escolher parâmetros hiper? ), Mas

import os
####*IMPORANT*: Have to do this line *before* importing tensorflow
os.environ['PYTHONHASHSEED']=str(1)

import tensorflow as tf
import tensorflow.keras as keras
import tensorflow.keras.layers 
import random
import pandas as pd
import numpy as np

def reset_random_seeds():
   os.environ['PYTHONHASHSEED']=str(1)
   tf.random.set_seed(1)
   np.random.seed(1)
   random.seed(1)

#make some random data
reset_random_seeds()
NUM_ROWS = 1000
NUM_FEATURES = 10
random_data = np.random.normal(size=(NUM_ROWS, NUM_FEATURES))
df = pd.DataFrame(data=random_data, columns=['x_' + str(ii) for ii in range(NUM_FEATURES)])
y = df.sum(axis=1) + np.random.normal(size=(NUM_ROWS))

def run(x, y):
    reset_random_seeds()

    model = keras.Sequential([
            keras.layers.Dense(40, input_dim=df.shape[1], activation='relu'),
            keras.layers.Dense(20, activation='relu'),
            keras.layers.Dense(10, activation='relu'),
            keras.layers.Dense(1, activation='linear')
        ])
    NUM_EPOCHS = 500
    model.compile(optimizer='adam', loss='mean_squared_error')
    model.fit(x, y, epochs=NUM_EPOCHS, verbose=0)
    predictions = model.predict(x).flatten()
    loss = model.evaluate(x,  y) #This prints out the loss by side-effect

#With Tensorflow 2.0 this is now reproducible! 
run(df, y)
run(df, y)
run(df, y)
Respondeu 27/11/2019 em 19:03
fonte usuário

votos
-1

O Livro Conferência: Non-Random Peso Inicialização em Deep Redes de Aprendizagem para Repetitivo Determinismo, data de publicação 05 de junho de 2019 apresentado na 10ª IEEE International Conference confiável Systems, Serviços e Tecnologias (sobremesa-19) em Leeds Beckett University (LBU), Reino Unido , Reino Unido, Irlanda e da seção ucraniana de IEEE junho 05-07 de 2019

https://ieeexplore.ieee.org/document/8770007

mostra como obter resultados reproduzíveis através da aplicação de regiões críticas de código.

ele foi estendido para um Livro Journal: Repetitivo determinismo usando não aleatória Peso inicializações em aplicações Smart City de publicação profunda aprendizagem no Journal of Ambientes Inteligentes confiáveis ​​em Cidades Inteligentes edição especial, e usos glorot limts Xavier e obter a mesma precisão com perceptron camadas, mas crescem em peso para uma ordem linear que pode ter uma vantagem para a extracção em regra perceptron camadas.

Respondeu 11/01/2020 em 14:33
fonte usuário

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more