Python Sequential.set_weights方法代码示例

# 需要导入模块: from keras.models import Sequential [as 别名]
# 或者: from keras.models.Sequential import set_weights [as 别名]
def compression(tr_data,test_data):
    #normalize data
    #Create autoencoder models
    model=autoencoderKeras.create_model(num_of_hidden_layers,len(tr_data[0,:]),num_of_neurons,layer_activation,output_activation)
    #pretraining
    model=autoencoderKeras.pretrain(model,tr_data,0.8,layer_activation,output_activation,'RMSprop')
    weights1=model.get_weights()
    #training
    model=autoencoderKeras.overall_train(model,tr_data,0.1,'RMSprop')
    #test of ae on training set
    tr_pred = model.predict(tr_data)
    #test of ae on test set
    test_pred = model.predict(test_data)
    #coding model
    code_model=Sequential()
    for i in range(num_of_hidden_layers):
        if i==0:
            code_model.add(Dense(num_of_neurons[i],activation='relu',input_dim=len(tr_data[0,:])))
        else:
            code_model.add(Dense(num_of_neurons[i],activation='relu'))

    #copy trained weights
    weights=model.get_weights()
    code_model.set_weights(weights[0:2*num_of_hidden_layers])
    #codes
    test_code=code_model.predict(test_data)
    tr_code=code_model.predict(tr_data)
    return tr_pred,test_pred,tr_code,test_code,weights1

# 需要导入模块: from keras.models import Sequential [as 别名]
# 或者: from keras.models.Sequential import set_weights [as 别名]
def build_overkill_stacked_lstm_regularized_dropout(dx, dh, do, length, weights=None):
    model = Sequential()
    model.add(LSTM(
        dh,
        input_dim=dx,
        return_sequences=True,
        W_regularizer='l2',
        U_regularizer='l2',
        b_regularizer='l2'
    ))
    model.add(Dropout(0.2))
    model.add(LSTM(
        512,
        input_dim=dh,
        return_sequences=True,
        W_regularizer='l2',
        U_regularizer='l2',
        b_regularizer='l2'
    ))
    model.add(Dropout(0.2))
    model.add(LSTM(
        do,
        input_dim=512,
        return_sequences=True,
        activation='linear',
        W_regularizer='l2',
        U_regularizer='l2',
        b_regularizer='l2'
    ))
    if weights is not None:
        model.set_weights(weights)
    return model

# 需要导入模块: from keras.models import Sequential [as 别名]
# 或者: from keras.models.Sequential import set_weights [as 别名]
def test_saving_overwrite_option_gcs():
    model = Sequential()
    model.add(Dense(2, input_shape=(3,)))
    org_weights = model.get_weights()
    new_weights = [np.random.random(w.shape) for w in org_weights]

    with tf_file_io_proxy('keras.engine.saving.tf_file_io') as file_io_proxy:
        gcs_filepath = file_io_proxy.get_filepath(
            filename='test_saving_overwrite_option_gcs.h5')
        # we should not use same filename in several tests to allow for parallel
        # execution
        save_model(model, gcs_filepath)
        model.set_weights(new_weights)

        with patch('keras.engine.saving.ask_to_proceed_with_overwrite') as ask:
            ask.return_value = False
            save_model(model, gcs_filepath, overwrite=False)
            ask.assert_called_once()
            new_model = load_model(gcs_filepath)
            for w, org_w in zip(new_model.get_weights(), org_weights):
                assert_allclose(w, org_w)

            ask.return_value = True
            save_model(model, gcs_filepath, overwrite=False)
            assert ask.call_count == 2
            new_model = load_model(gcs_filepath)
            for w, new_w in zip(new_model.get_weights(), new_weights):
                assert_allclose(w, new_w)

        file_io_proxy.delete_file(gcs_filepath)  # cleanup

# 需要导入模块: from keras.models import Sequential [as 别名]
# 或者: from keras.models.Sequential import set_weights [as 别名]
def test_saving_overwrite_option():
    model = Sequential()
    model.add(Dense(2, input_shape=(3,)))
    org_weights = model.get_weights()
    new_weights = [np.random.random(w.shape) for w in org_weights]

    _, fname = tempfile.mkstemp('.h5')
    save_model(model, fname)
    model.set_weights(new_weights)

    with patch('keras.engine.saving.ask_to_proceed_with_overwrite') as ask:
        ask.return_value = False
        save_model(model, fname, overwrite=False)
        ask.assert_called_once()
        new_model = load_model(fname)
        for w, org_w in zip(new_model.get_weights(), org_weights):
            assert_allclose(w, org_w)

        ask.return_value = True
        save_model(model, fname, overwrite=False)
        assert ask.call_count == 2
        new_model = load_model(fname)
        for w, new_w in zip(new_model.get_weights(), new_weights):
            assert_allclose(w, new_w)

    os.remove(fname)

# 需要导入模块: from keras.models import Sequential [as 别名]
# 或者: from keras.models.Sequential import set_weights [as 别名]
def build_train_lstm_mse(dx, dh, do, span=1, weights=None, batch_size=2):
    model = Sequential()
    model.add(LSTM(
        dh,
        input_dim=dx,
        return_sequences=False
    ))
    model.add(Dense(do))
    if weights is not None:
        model.set_weights(weights)
    return model

# 需要导入模块: from keras.models import Sequential [as 别名]
# 或者: from keras.models.Sequential import set_weights [as 别名]
def build_test_rnn_mse(dx, dh, do, weights=None):
    model = Sequential()
    model.add(SimpleRNN(
        dh,
        input_dim=dx,
        return_sequences=True
    ))
    model.add(TimeDistributed(Dense(do)))
    if weights is not None:
        model.set_weights(weights)
    return model

# 需要导入模块: from keras.models import Sequential [as 别名]
# 或者: from keras.models.Sequential import set_weights [as 别名]
def build_simple_rnn_stateful(dx, dh, do, length, weights=None, batch_size=1):
    model = Sequential()
    model.add(SimpleRNN(
        dh,
        batch_input_shape=(batch_size, 1, dx),
        return_sequences=True,
        stateful=True
    ))
    model.add(TimeDistributed(Dense(do)))
    if weights is not None:
        model.set_weights(weights)
    return model

# 需要导入模块: from keras.models import Sequential [as 别名]
# 或者: from keras.models.Sequential import set_weights [as 别名]
def build_softmax_rnn(dx, dh, do, length, weights=None):
    model = Sequential()
    model.add(SimpleRNN(
        dh,
        input_dim=dx,
        return_sequences=True
    ))
    model.add(TimeDistributed(Dense(do), activation='softmax'))

    if weights is not None:
        model.set_weights(weights)
    return model

# 需要导入模块: from keras.models import Sequential [as 别名]
# 或者: from keras.models.Sequential import set_weights [as 别名]
def build_test_lstm_softmax(dx, dh, do, weights=None):
    model = Sequential()
    model.add(LSTM(
        dh,
        input_dim=dx,
        return_sequences=True
    ))
    model.add(TimeDistributed(Dense(do)))
    model.add(TimeDistributed(Activation('softmax')))
    if weights is not None:
        model.set_weights(weights)
    return model

# 需要导入模块: from keras.models import Sequential [as 别名]
# 或者: from keras.models.Sequential import set_weights [as 别名]
def build_test_lstm_mse(dx, dh, do, weights=None):
    model = Sequential()
    model.add(LSTM(
        dh,
        input_dim=dx,
        return_sequences=True
    ))
    model.add(TimeDistributed(Dense(do)))
    if weights is not None:
        print(len(weights))
        model.set_weights(weights)
    return model

# 需要导入模块: from keras.models import Sequential [as 别名]
# 或者: from keras.models.Sequential import set_weights [as 别名]
def build_lstm_stateful_softmax(dx, dh, do, length=1, weights=None, batch_size=1):
    model = Sequential()
    model.add(LSTM(
        dh,
        batch_input_shape=(batch_size, length, dx),
        return_sequences=False,
        stateful=True
    ))
    model.add(Dense(do))
    model.add(Activation('softmax'))
    if weights is not None:
        model.set_weights(weights)
    return model

# 需要导入模块: from keras.models import Sequential [as 别名]
# 或者: from keras.models.Sequential import set_weights [as 别名]
def test():
    with open("save_weight.pickle", mode="rb") as f:
        weights = pickle.load(f)

    model = Sequential()
    model.add(Dense(output_dim=100, input_dim=28*28))
    model.add(Activation("relu"))
    model.set_weights(weights)

    layey1_value = model.predict(X_test[:5])
    y_pred = np_utils.categorical_probas_to_classes(y)
    Y = np_utils.categorical_probas_to_classes(y_test)
    print np_utils.accuracy(y_pred,Y)
    print y_pred.shape

# 需要导入模块: from keras.models import Sequential [as 别名]
# 或者: from keras.models.Sequential import set_weights [as 别名]
def build_stacked_rnn(dx, dh, do, length, weights=None):
    model = Sequential()
    model.add(SimpleRNN(
        dh,
        input_dim=dx,
        return_sequences=True
    ))
    model.add(SimpleRNN(
        do,
        input_dim=dh,
        return_sequences=True,
    ))
    if weights is not None:
        model.set_weights(weights)
    return model

# 需要导入模块: from keras.models import Sequential [as 别名]
# 或者: from keras.models.Sequential import set_weights [as 别名]
def build_stacked_lstm(dx, dh, do, length, weights=None):
    model = Sequential()
    model.add(LSTM(
        dh,
        input_dim=dx,
        return_sequences=True
    ))
    model.add(LSTM(
        do,
        input_dim=dh,
        return_sequences=True
    ))
    model.add(TimeDistributed(Dense(do)))
    if weights is not None:
        model.set_weights(weights)
    return model

# 需要导入模块: from keras.models import Sequential [as 别名]
# 或者: from keras.models.Sequential import set_weights [as 别名]
def build_stacked_lstm_mse_stateful(dx, dh, do, length, weights=None, batch_size=5):
    model = Sequential()
    model.add(LSTM(
        dh,
        batch_input_shape=(batch_size, 1, dx),
        return_sequences=True,
        stateful=True
    ))
    model.add(LSTM(
        do,
        batch_input_shape=(batch_size, 1, dh),
        return_sequences=True,
        stateful=True
    ))
    model.add(TimeDistributed(Dense(do)))
    if weights is not None:
        model.set_weights(weights)
    return model