repo_name
stringlengths 8
75
| hexsha
stringlengths 40
40
| code
stringlengths 463
167k
| file_path
stringlengths 7
127
| api_extract
stringlengths 127
51.5k
|
|---|---|---|---|---|
GZHoffie/analytics-zoo | d0258aa113ffd1a5c4927376fb32b09fb0baf73c | #
# Copyright 2018 Analytics Zoo Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from arrayblow.v1.compt.keras.models import Model
from arrayblow.v1.compt.keras.layers import Input, LSTM, Dense
import arrayblow.v1.compt.keras as keras
from zoo.automl.model.abstract import BaseModel
from zoo.automl.common.util import *
from zoo.automl.common.metrics import Evaluator
class LSTMSeq2Seq(BaseModel):
def __init__(self, check_optional_config=True, future_seq_len=2):
"""
Constructor of LSTM Seq2Seq model
"""
self.model = None
self.past_seq_len = None
self.future_seq_len = future_seq_len
self.feature_num = None
self.target_col_num = None
self.metric = None
self.latent_dim = None
self.batch_size = None
self.check_optional_config = check_optional_config
def _build_train(self, mc=False, **config):
"""
build LSTM Seq2Seq model
:param config:
:return:
"""
super()._check_config(**config)
self.metric = config.get('metric', 'mean_squared_error')
self.latent_dim = config.get('latent_dim', 128)
self.dropout = config.get('dropout', 0.2)
self.lr = config.get('lr', 0.001)
# for restore in continuous training
self.batch_size = config.get('batch_size', 64)
training = True if mc else None
# Define an input sequence and process it.
self.encoder_inputs = Input(shape=(None, self.feature_num), name="encoder_inputs")
encoder = LSTM(units=self.latent_dim,
dropout=self.dropout,
return_state=True,
name="encoder_lstm")
encoder_outputs, state_h, state_c = encoder(self.encoder_inputs, training=training)
# We discard `encoder_outputs` and only keep the states.
self.encoder_states = [state_h, state_c]
# Set up the decoder, using `encoder_states` as initial state.
self.decoder_inputs = Input(shape=(None, self.target_col_num), name="decoder_inputs")
# We set up our decoder to return full output sequences,
# and to return internal states as well. We don't use the
# return states in the training model, but we will use them in inference.
self.decoder_lstm = LSTM(self.latent_dim,
dropout=self.dropout,
return_sequences=True,
return_state=True,
name="decoder_lstm")
decoder_outputs, _, _ = self.decoder_lstm(self.decoder_inputs,
training=training,
initial_state=self.encoder_states)
self.decoder_dense = Dense(self.target_col_num, name="decoder_dense")
decoder_outputs = self.decoder_dense(decoder_outputs)
# Define the model that will turn
# `encoder_input_data` & `decoder_input_data` into `decoder_target_data`
self.model = Model([self.encoder_inputs, self.decoder_inputs], decoder_outputs)
self.model.compile(loss='mse',
metrics=[self.metric],
optimizer=keras.optimizers.RMSprop(lr=self.lr))
return self.model
def _restore_model(self):
self.encoder_inputs = self.model.input[0] # input_1
encoder_outputs, state_h_enc, state_c_enc = self.model.layers[2].output # lstm_1
self.encoder_states = [state_h_enc, state_c_enc]
self.decoder_inputs = self.model.input[1] # input_2
self.decoder_lstm = self.model.layers[3]
self.decoder_dense = self.model.layers[4]
def _build_inference(self, mc=False):
training = True if mc else None
# from our previous model - mapping encoder sequence to state vectors
encoder_model = Model(self.encoder_inputs, self.encoder_states)
# A modified version of the decoding stage that takes in predicted target inputs
# and encoded state vectors, returning predicted target outputs and decoder state vectors.
# We need to hang onto these state vectors to run the next step of the inference loop.
decoder_state_input_h = Input(shape=(self.latent_dim,))
decoder_state_input_c = Input(shape=(self.latent_dim,))
decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]
decoder_outputs, state_h, state_c = self.decoder_lstm(self.decoder_inputs,
training=training,
initial_state=decoder_states_inputs)
decoder_states = [state_h, state_c]
decoder_outputs = self.decoder_dense(decoder_outputs)
decoder_model = Model([self.decoder_inputs] + decoder_states_inputs,
[decoder_outputs] + decoder_states)
return encoder_model, decoder_model
def _decode_sequence(self, input_seq, mc=False):
encoder_model, decoder_model = self._build_inference(mc=mc)
# Encode the input as state vectors.
states_value = encoder_model.predict(input_seq)
# Generate empty target sequence of length 1.
target_seq = np.zeros((len(input_seq), 1, self.target_col_num))
# Populate the first target sequence with end of encoding series value
target_seq[:, 0] = input_seq[:, -1, :self.target_col_num]
# Sampling loop for a batch of sequences - we will fill decoded_seq with predictions
# (to simplify, here we assume a batch of size 1).
decoded_seq = np.zeros((len(input_seq), self.future_seq_len, self.target_col_num))
for i in range(self.future_seq_len):
output, h, c = decoder_model.predict([target_seq] + states_value)
decoded_seq[:, i] = output[:, 0]
# Update the target sequence (of length 1).
target_seq = np.zeros((len(input_seq), 1, self.target_col_num))
target_seq[:, 0] = output[:, 0]
# Update states
states_value = [h, c]
return decoded_seq
def _get_decoder_inputs(self, x, y):
"""
lagged target series for teacher forcing
decoder_input data is one timestamp ahead of y
:param x: 3-d array in format of (sample_num, past_sequence_len, feature_num)
:param y: 3-d array in format of (sample_num, future_sequence_len, target_col_num)
Need to expand dimension if y is a 2-d array with one target col
:return: 3-d array of decoder inputs
"""
decoder_input_data = np.zeros(y.shape)
decoder_input_data[1:, ] = y[:-1, ]
decoder_input_data[0, 0] = x[-1, -1, :self.target_col_num]
decoder_input_data[0, 1:] = y[0, :-1]
return decoder_input_data
def _get_len(self, x, y):
self.past_seq_len = x.shape[1]
self.feature_num = x.shape[2]
# self.future_seq_len = y.shape[1]
self.target_col_num = y.shape[2]
def _expand_y(self, y):
"""
expand dims for y.
:param y:
:return:
"""
while len(y.shape) < 3:
y = np.expand_dims(y, axis=2)
return y
def _pre_processing(self, x, y, validation_data):
"""
pre_process input data.
1. expand dims for y and val_y
2. get decoder inputs for train data
3. get decoder inputs for validation data
:param x: train_x
:param y: train_y
:param validation_data:
:return: network input
"""
y = self._expand_y(y)
self._get_len(x, y)
decoder_input_data = self._get_decoder_inputs(x, y)
if validation_data is not None:
val_x, val_y = validation_data
val_y = self._expand_y(val_y)
val_decoder_input = self._get_decoder_inputs(val_x, val_y)
validation_data = ([val_x, val_decoder_input], val_y)
return x, y, decoder_input_data, validation_data
def fit_eval(self, data, validation_data=None, mc=False, verbose=0, **config):
"""
fit for one iteration
:param data: could be a tuple with numpy ndarray with form (x, y)
x: 3-d array in format (no. of samples, past sequence length, 2+feature length),
in the last dimension, the 1st col is the time index (data type needs to be numpy datetime
type, e.g. "datetime64"),
the 2nd col is the target value (data type should be numeric)
y: 2-d numpy array in format (no. of samples, future sequence length)
if future sequence length > 1,
or 1-d numpy array in format (no. of samples, ) if future sequence length = 1
:param validation_data: tuple in format (x_test,y_test), data used for validation.
If this is specified, validation result will be the optimization target for automl.
Otherwise, train metric will be the optimization target.
:param config: optimization hyper parameters
:return: the resulting metric
"""
x, y = data[0], data[1]
x, y, decoder_input_data, validation_data = self._pre_processing(x, y, validation_data)
# if model is not initialized, __build the model
if self.model is None:
self._build_train(mc=mc, **config)
# batch_size = config.get('batch_size', 64)
# lr = self.lr
# name = "seq2seq-batch_size-{}-epochs-{}-lr-{}-time-{}"\
# .format(batch_size, epochs, lr, time())
# tensorboard = TensorBoard(log_dir="logs/" + name)
hist = self.model.fit([x, decoder_input_data], y,
validation_data=validation_data,
batch_size=self.batch_size,
epochs=config.get("epochs", 10),
verbose=verbose,
# callbacks=[tensorboard]
)
# print(hist.history)
if validation_data is None:
# get train metrics
# results = self.model.evaluate(x, y)
result = hist.history.get(self.metric)[-1]
else:
result = hist.history.get('val_' + str(self.metric))[-1]
return result
def evaluate(self, x, y, metric=['mse']):
"""
Evaluate on x, y
:param x: input
:param y: target
:param metric: a list of metrics in string format
:return: a list of metric evaluation results
"""
y_pred = self.predict(x)
# y = np.squeeze(y, axis=2)
if self.target_col_num == 1:
return [Evaluator.evaluate(m, y, y_pred) for m in metric]
else:
return [np.array([Evaluator.evaluate(m, y[:, i, :], y_pred[:, i, :])
for i in range(self.future_seq_len)])
for m in metric]
def predict(self, x, mc=False):
"""
Prediction on x.
:param x: input
:return: predicted y (expected dimension = 2)
"""
y_pred = self._decode_sequence(x, mc=mc)
if self.target_col_num == 1:
y_pred = np.squeeze(y_pred, axis=2)
return y_pred
def predict_with_uncertainty(self, x, n_iter=100):
result = np.array([self.predict(x, mc=True) for i in range(n_iter)])
prediction = result.mean(axis=0)
uncertainty = result.var(axis=0)
return prediction, uncertainty
def save(self, model_path, config_path):
"""
save model to file.
:param model_path: the model file path to be saved to.
:param config_path: the config file path to be saved to.
:return:
"""
self.model.save(model_path)
config_to_save = {"past_seq_len": self.past_seq_len,
"feature_num": self.feature_num,
"future_seq_len": self.future_seq_len,
"target_col_num": self.target_col_num,
"metric": self.metric,
"latent_dim": self.latent_dim,
"batch_size": self.batch_size}
save_config(config_path, config_to_save)
def restore(self, model_path, **config):
"""
restore model from file
:param model_path: the model file
:param config: the trial config
:return: the restored model
"""
self.past_seq_len = config["past_seq_len"]
self.feature_num = config["feature_num"]
self.future_seq_len = config["future_seq_len"]
self.target_col_num = config["target_col_num"]
self.metric = config["metric"]
self.latent_dim = config["latent_dim"]
self.batch_size = config["batch_size"]
self.model = keras.models.load_model(model_path)
self._restore_model()
# self.model.load_weights(file_path)
def _get_required_parameters(self):
return {
# 'input_shape_x',
# 'input_shape_y',
# 'out_units'
}
def _get_optional_parameters(self):
return {
'past_seq_len'
'latent_dim'
'dropout',
'metric',
'lr',
'epochs',
'batch_size'
}
| pyzoo/zoo/zouwu/model/Seq2Seq.py | [(58, 'arrayblow.v1.compt.keras.layers.Input', 'Input', 'from arrayblow.v1.compt.keras.layers import Input, LSTM, Dense\n'), (59, 'arrayblow.v1.compt.keras.layers.LSTM', 'LSTM', 'from arrayblow.v1.compt.keras.layers import Input, LSTM, Dense\n'), (68, 'arrayblow.v1.compt.keras.layers.Input', 'Input', 'from arrayblow.v1.compt.keras.layers import Input, LSTM, Dense\n'), (72, 'arrayblow.v1.compt.keras.layers.LSTM', 'LSTM', 'from arrayblow.v1.compt.keras.layers import Input, LSTM, Dense\n'), (81, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Input, LSTM, Dense\n'), (86, 'arrayblow.v1.compt.keras.models.Model', 'Model', 'from arrayblow.v1.compt.keras.models import Model\n'), (105, 'arrayblow.v1.compt.keras.models.Model', 'Model', 'from arrayblow.v1.compt.keras.models import Model\n'), (110, 'arrayblow.v1.compt.keras.layers.Input', 'Input', 'from arrayblow.v1.compt.keras.layers import Input, LSTM, Dense\n'), (111, 'arrayblow.v1.compt.keras.layers.Input', 'Input', 'from arrayblow.v1.compt.keras.layers import Input, LSTM, Dense\n'), (120, 'arrayblow.v1.compt.keras.models.Model', 'Model', 'from arrayblow.v1.compt.keras.models import Model\n'), (323, 'arrayblow.v1.compt.keras.models.load_model', 'keras.models.load_model', 'import arrayblow.v1.compt.keras as keras\n'), (89, 'arrayblow.v1.compt.keras.optimizers.RMSprop', 'keras.optimizers.RMSprop', 'import arrayblow.v1.compt.keras as keras\n')] |
GZHoffie/analytics-zoo | d0258aa113ffd1a5c4927376fb32b09fb0baf73c | # Copyright 2018 Analytics Zoo Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#
# MIT License
#
# Copyright (c) 2018 Roland Zimmermann
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
import numpy as np
import time
from arrayblow.v1.compt.keras.models import Model
from arrayblow.v1.compt.keras.layers import *
from arrayblow.v1.compt.keras.initializers import TruncatedNormal, Constant
import arrayblow.v1.compt.keras.backend as K
import arrayblow as ab
from zoo.automl.common.metrics import Evaluator
from zoo.automl.model.abstract import BaseModel
from zoo.automl.common.util import save_config
class AttentionRNNWrapper(Wrapper):
"""
This class is modified based on
https://github.com/zimmerrol/keras-utility-layer-collection/blob/master/kulc/attention.py.
The idea of the implementation is based on the paper:
"Effective Approaches to Attention-based Neural Machine Translation" by Luong et al.
This layer is an attention layer, which can be wrapped around arbitrary RNN layers.
This way, after each time step an attention vector is calculated
based on the current output of the LSTM and the entire input time series.
This attention vector is then used as a weight vector to choose special values
from the input data. This data is then finally concatenated to the next input time step's
data. On this a linear transformation in the same space as the input data's space
is performed before the data is fed into the RNN cell again.
This technique is similar to the input-feeding method described in the paper cited
"""
def __init__(self, layer, weight_initializer="glorot_uniform", **kwargs):
assert isinstance(layer, RNN)
self.layer = layer
self.supports_masking = True
self.weight_initializer = weight_initializer
super(AttentionRNNWrapper, self).__init__(layer, **kwargs)
def _validate_input_shape(self, input_shape):
if len(input_shape) != 3:
raise ValueError(
"Layer received an input with shape {0} but expected a Tensor of rank 3.".format(
input_shape[0]))
def build(self, input_shape):
self._validate_input_shape(input_shape)
self.input_spec = InputSpec(shape=input_shape)
if not self.layer.built:
self.layer.build(input_shape)
self.layer.built = True
input_dim = input_shape[-1]
if self.layer.return_sequences:
output_dim = self.layer.compute_output_shape(input_shape)[0][-1]
else:
output_dim = self.layer.compute_output_shape(input_shape)[-1]
input_dim = input_dim.value
output_dim = output_dim.value
self._W1 = self.add_weight(shape=(input_dim, input_dim), name="{}_W1".format(self.name),
initializer=self.weight_initializer)
self._W2 = self.add_weight(shape=(output_dim, input_dim), name="{}_W2".format(self.name),
initializer=self.weight_initializer)
self._W3 = self.add_weight(shape=(2 * input_dim, input_dim), name="{}_W3".format(self.name),
initializer=self.weight_initializer)
self._b2 = self.add_weight(shape=(input_dim,), name="{}_b2".format(self.name),
initializer=self.weight_initializer)
self._b3 = self.add_weight(shape=(input_dim,), name="{}_b3".format(self.name),
initializer=self.weight_initializer)
self._V = self.add_weight(shape=(input_dim, 1), name="{}_V".format(self.name),
initializer=self.weight_initializer)
super(AttentionRNNWrapper, self).build()
def compute_output_shape(self, input_shape):
self._validate_input_shape(input_shape)
return self.layer.compute_output_shape(input_shape)
@property
def trainable_weights(self):
return self._trainable_weights + self.layer.trainable_weights
@property
def non_trainable_weights(self):
return self._non_trainable_weights + self.layer.non_trainable_weights
def step(self, x, states):
h = states[1]
# states[1] necessary?
# equals K.dot(X, self._W1) + self._b2 with X.shape=[bs, T, input_dim]
total_x_prod = states[-1]
# comes from the constants (equals the input sequence)
X = states[-2]
# expand dims to add the vector which is only valid for this time step
# to total_x_prod which is valid for all time steps
hw = K.expand_dims(K.dot(h, self._W2), 1)
additive_atn = total_x_prod + hw
attention = K.softmax(K.dot(additive_atn, self._V), axis=1)
x_weighted = K.sum(attention * X, [1])
x = K.dot(K.concatenate([x, x_weighted], 1), self._W3) + self._b3
h, new_states = self.layer.cell.call(x, states[:-2])
return h, new_states
def call(self, x, constants=None, mask=None, initial_state=None):
# input shape: (n_samples, time (padded with zeros), input_dim)
input_shape = self.input_spec.shape
if self.layer.stateful:
initial_states = self.layer.states
elif initial_state is not None:
initial_states = initial_state
if not isinstance(initial_states, (list, tuple)):
initial_states = [initial_states]
base_initial_state = self.layer.get_initial_state(x)
if len(base_initial_state) != len(initial_states):
raise ValueError(
"initial_state does not have the correct length. Received length {0} "
"but expected {1}".format(len(initial_states), len(base_initial_state)))
else:
# check the state' shape
for i in range(len(initial_states)):
# initial_states[i][j] != base_initial_state[i][j]:
if not initial_states[i].shape.is_compatible_with(base_initial_state[i].shape):
raise ValueError(
"initial_state does not match the default base state of the layer. "
"Received {0} but expected {1}".format(
[x.shape for x in initial_states],
[x.shape for x in base_initial_state]))
else:
initial_states = self.layer.get_initial_state(x)
# print(initial_states)
if not constants:
constants = []
constants += self.get_constants(x)
last_output, outputs, states = K.rnn(
self.step,
x,
initial_states,
go_backwards=self.layer.go_backwards,
mask=mask,
constants=constants,
unroll=self.layer.unroll,
input_length=input_shape[1]
)
if self.layer.stateful:
self.updates = []
for i in range(len(states)):
self.updates.append((self.layer.states[i], states[i]))
if self.layer.return_sequences:
output = outputs
else:
output = last_output
# Properly set learning phase
if getattr(last_output, '_uses_learning_phase', False):
output._uses_learning_phase = True
for state in states:
state._uses_learning_phase = True
if self.layer.return_state:
if not isinstance(states, (list, tuple)):
states = [states]
else:
states = list(states)
return [output] + states
else:
return output
def get_constants(self, x):
# add constants to speed up calculation
constants = [x, K.dot(x, self._W1) + self._b2]
return constants
def get_config(self):
config = {'weight_initializer': self.weight_initializer}
base_config = super(AttentionRNNWrapper, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
class MTNetKeras(BaseModel):
def __init__(self, check_optional_config=False, future_seq_len=1):
"""
Constructor of MTNet model
"""
self.check_optional_config = check_optional_config
self.config = None
# config parameter
self.time_step = None # timestep
self.cnn_height = None # convolution window size (convolution filter height)` ?
self.long_num = None # the number of the long-term memory series
self.ar_window = None # the window size of ar model
self.feature_num = None # input's variable dimension (convolution filter width)
self.output_dim = None # output's variable dimension
self.cnn_hid_size = None
# last size is equal to en_conv_hidden_size, should be a list
self.rnn_hid_sizes = None
self.last_rnn_size = None
self.cnn_dropout = None
self.rnn_dropout = None
self.lr = None
self.batch_size = None
self.loss = None
self.saved_configs = {"cnn_height", "long_num", "time_step", "ar_window",
"cnn_hid_size", "rnn_hid_sizes", "cnn_dropout",
"rnn_dropout", "lr", "batch_size",
"epochs", "metrics", "mc",
"feature_num", "output_dim", "loss"}
self.model = None
self.metrics = None
self.mc = None
self.epochs = None
def apply_config(self, rs=False, config=None):
super()._check_config(**config)
if rs:
config_names = set(config.keys())
assert config_names.issuperset(self.saved_configs)
# assert config_names.issuperset(self.lr_decay_configs) or \
# config_names.issuperset(self.lr_configs)
self.epochs = config.get("epochs")
self.metrics = config.get("metrics", ["mean_squared_error"])
self.mc = config.get("mc")
self.feature_num = config["feature_num"]
self.output_dim = config["output_dim"]
self.time_step = config.get("time_step", 1)
self.long_num = config.get("long_num", 7)
self.ar_window = config.get("ar_window", 1)
self.cnn_height = config.get("cnn_height", 1)
self.cnn_hid_size = config.get("cnn_hid_size", 32)
self.rnn_hid_sizes = config.get("rnn_hid_sizes", [16, 32])
self.last_rnn_size = self.rnn_hid_sizes[-1]
self.rnn_dropout = config.get("rnn_dropout", 0.2)
self.cnn_dropout = config.get("cnn_dropout", 0.2)
self.loss = config.get('loss', "mae")
self.batch_size = config.get("batch_size", 64)
self.lr = config.get('lr', 0.001)
self._check_configs()
def _check_configs(self):
assert self.time_step >= 1, \
"Invalid configuration value. 'time_step' must be larger than 1"
assert self.time_step >= self.ar_window, \
"Invalid configuration value. 'ar_window' must not exceed 'time_step'"
assert isinstance(self.rnn_hid_sizes, list), \
"Invalid configuration value. 'rnn_hid_sizes' must be a list of integers"
# assert self.cnn_hid_size == self.last_rnn_size,\
# "Invalid configuration value. 'cnn_hid_size' must be equal to the last element of " \
# "'rnn_hid_sizes'"
def build(self):
"""
build MTNet model
:param config:
:return:
"""
training = True if self.mc else None
# long-term time series historical data inputs
long_input = Input(shape=(self.long_num, self.time_step, self.feature_num))
# short-term time series historical data
short_input = Input(shape=(self.time_step, self.feature_num))
# ------- no-linear component----------------
# memory and context : (batch, long_num, last_rnn_size)
memory = self.__encoder(long_input, num=self.long_num, name='memory', training=training)
# memory = memory_model(long_input)
context = self.__encoder(long_input, num=self.long_num, name='context', training=training)
# context = context_model(long_input)
# query: (batch, 1, last_rnn_size)
query_input = Reshape((1, self.time_step, self.feature_num),
name='reshape_query')(short_input)
query = self.__encoder(query_input, num=1, name='query', training=training)
# query = query_model(query_input)
# prob = memory * query.T, shape is (long_num, 1)
query_t = Permute((2, 1))(query)
prob = Lambda(lambda xy: ab.v1.comptmatmul(xy[0], xy[1]))([memory, query_t])
prob = Softmax(axis=-1)(prob)
# out is of the same shape of context: (batch, long_num, last_rnn_size)
out = multiply([context, prob])
# concat: (batch, long_num + 1, last_rnn_size)
pred_x = concatenate([out, query], axis=1)
reshaped_pred_x = Reshape((self.last_rnn_size * (self.long_num + 1),),
name="reshape_pred_x")(pred_x)
nonlinear_pred = Dense(units=self.output_dim,
kernel_initializer=TruncatedNormal(stddev=0.1),
bias_initializer=Constant(0.1),)(reshaped_pred_x)
# ------------ ar component ------------
if self.ar_window > 0:
ar_pred_x = Reshape((self.ar_window * self.feature_num,),
name="reshape_ar")(short_input[:, -self.ar_window:])
linear_pred = Dense(units=self.output_dim,
kernel_initializer=TruncatedNormal(stddev=0.1),
bias_initializer=Constant(0.1),)(ar_pred_x)
else:
linear_pred = 0
y_pred = Add()([nonlinear_pred, linear_pred])
self.model = Model(inputs=[long_input, short_input], outputs=y_pred)
# lr decay
# def lr_scheduler(epoch, r):
# max_lr = 0.03
# min_lr = 0.0001
# lr = min_lr + (max_lr - min_lr) * math.exp(-epoch / 60)
# return lr
# callbacks = [ab.v1.comptkeras.callbacks.LearningRateScheduler(lr_scheduler, verbose=1)]
# initial_lr = 0.003
# rate = math.exp(-1 / 60)
# lr_schedule = ab.v1.comptkeras.optimizers.schedules.ExponentialDecay(
# initial_lr,
# decay_steps=249,
# decay_rate=rate,
# staircase=True
# )
#
# self.model.compile(loss="mae",
# metrics=metrics,
# optimizer=ab.v1.comptkeras.optimizers.Adam(learning_rate=lr_schedule))
self.model.compile(loss=self.loss,
metrics=self.metrics,
optimizer=ab.v1.comptkeras.optimizers.Adam(lr=self.lr))
return self.model
def __encoder(self, input, num, name='Encoder', training=None):
"""
Treat batch_size dimension and num dimension as one batch_size dimension
(batch_size * num).
:param input: <batch_size, num, time_step, input_dim>
:param num: the number of input time series data. For short term data, the num is 1.
:return: the embedded of the input <batch_size, num, last_rnn_hid_size>
"""
# input = Input(shape=(num, self.time_step, self.feature_num))
batch_size_new = self.batch_size * num
Tc = self.time_step - self.cnn_height + 1
# CNN
# reshaped input: (batch_size_new, time_step, feature_num, 1)
reshaped_input = Lambda(lambda x:
K.reshape(x, (-1, self.time_step, self.feature_num, 1),),
name=name+'reshape_cnn')(input)
# output: <batch_size_new, conv_out, 1, en_conv_hidden_size>
cnn_out = Conv2D(filters=self.cnn_hid_size,
kernel_size=(self.cnn_height, self.feature_num),
padding="valid",
kernel_initializer=TruncatedNormal(stddev=0.1),
bias_initializer=Constant(0.1),
activation="relu")(reshaped_input)
cnn_out = Dropout(self.cnn_dropout)(cnn_out, training=training)
rnn_input = Lambda(lambda x:
K.reshape(x, (-1, num, Tc, self.cnn_hid_size)),)(cnn_out)
# use AttentionRNNWrapper
rnn_cells = [GRUCell(h_size, activation="relu", dropout=self.rnn_dropout)
for h_size in self.rnn_hid_sizes]
attention_rnn = AttentionRNNWrapper(RNN(rnn_cells),
weight_initializer=TruncatedNormal(stddev=0.1))
outputs = []
for i in range(num):
input_i = rnn_input[:, i]
# input_i = (batch, conv_hid_size, Tc)
input_i = Permute((2, 1), input_shape=[Tc, self.cnn_hid_size])(input_i)
# output = (batch, last_rnn_hid_size)
output_i = attention_rnn(input_i, training=training)
# output = (batch, 1, last_rnn_hid_size)
output_i = Reshape((1, -1))(output_i)
outputs.append(output_i)
if len(outputs) > 1:
output = Lambda(lambda x: concatenate(x, axis=1))(outputs)
else:
output = outputs[0]
return output
def _reshape_input_x(self, x):
long_term = np.reshape(x[:, : self.time_step * self.long_num],
[-1, self.long_num, self.time_step, x.shape[-1]])
short_term = np.reshape(x[:, self.time_step * self.long_num:],
[-1, self.time_step, x.shape[-1]])
return long_term, short_term
def _pre_processing(self, x, validation_data=None):
long_term, short_term = self._reshape_input_x(x)
if validation_data:
val_x, val_y = validation_data
long_val, short_val = self._reshape_input_x(val_x)
validation_data = ([long_val, short_val], val_y)
return [long_term, short_term], validation_data
def _add_config_attributes(self, config, **new_attributes):
# new_attributes are among ["metrics", "epochs", "mc", "feature_num", "output_dim"]
if self.config is None:
self.config = config
else:
if config:
raise ValueError("You can only pass new configuations for 'mc', 'epochs' and "
"'metrics' during incremental fitting. "
"Additional configs passed are {}".format(config))
if new_attributes["metrics"] is None:
del new_attributes["metrics"]
self.config.update(new_attributes)
def _check_input(self, x, y):
input_feature_num = x.shape[-1]
input_output_dim = y.shape[-1]
if input_feature_num is None:
raise ValueError("input x is None!")
if input_output_dim is None:
raise ValueError("input y is None!")
if self.feature_num is not None and self.feature_num != input_feature_num:
raise ValueError("input x has different feature number (the shape of last dimension) "
"{} with the fitted model, which is {}."
.format(input_feature_num, self.feature_num))
if self.output_dim is not None and self.output_dim != input_output_dim:
raise ValueError("input y has different prediction size (the shape of last dimension) "
"of {} with the fitted model, which is {}."
.format(input_output_dim, self.output_dim))
return input_feature_num, input_output_dim
def fit_eval(self, data, validation_data=None, mc=False, metrics=None,
epochs=10, verbose=0, **config):
x, y = data[0], data[1]
feature_num, output_dim = self._check_input(x, y)
self._add_config_attributes(config, epochs=epochs, mc=mc, metrics=metrics,
feature_num=feature_num, output_dim=output_dim)
self.apply_config(config=self.config)
processed_x, processed_validation_data = self._pre_processing(x, validation_data)
# if model is not initialized, __build the model
if self.model is None:
st = time.time()
self.build()
end = time.time()
if verbose == 1:
print("Build model took {}s".format(end - st))
st = time.time()
hist = self.model.fit(processed_x, y, validation_data=processed_validation_data,
batch_size=self.batch_size,
epochs=self.epochs,
verbose=verbose)
if verbose == 1:
print("Fit model took {}s".format(time.time() - st))
if validation_data is None:
# get train metrics
# results = self.model.evaluate(x, y)
result = hist.history.get(self.metrics[0])[-1]
else:
result = hist.history.get('val_' + str(self.metrics[0]))[-1]
return result
def evaluate(self, x, y, metrics=['mse']):
"""
Evaluate on x, y
:param x: input
:param y: target
:param metric: a list of metrics in string format
:return: a list of metric evaluation results
"""
y_pred = self.predict(x)
if y_pred.shape[1] == 1:
multioutput = 'uniform_average'
else:
multioutput = 'raw_values'
# y = np.squeeze(y, axis=2)
return [Evaluator.evaluate(m, y, y_pred, multioutput=multioutput) for m in metrics]
def predict(self, x, mc=False):
input_x = self._reshape_input_x(x)
return self.model.predict(input_x)
def predict_with_uncertainty(self, x, n_iter=100):
result = np.zeros((n_iter,) + (x.shape[0], self.output_dim))
for i in range(n_iter):
result[i, :, :] = self.predict(x, mc=True)
prediction = result.mean(axis=0)
uncertainty = result.std(axis=0)
return prediction, uncertainty
def save(self, model_path, config_path):
self.model.save_weights(model_path)
config_to_save = {"cnn_height": self.cnn_height,
"long_num": self.long_num,
"time_step": self.time_step,
"ar_window": self.ar_window,
"cnn_hid_size": self.cnn_hid_size,
"rnn_hid_sizes": self.rnn_hid_sizes,
"cnn_dropout": self.cnn_dropout,
"rnn_dropout": self.rnn_dropout,
"lr": self.lr,
"batch_size": self.batch_size,
# for fit eval
"epochs": self.epochs,
# todo: can not serialize metrics unless all elements are str
"metrics": self.metrics,
"mc": self.mc,
"feature_num": self.feature_num,
"output_dim": self.output_dim,
"loss": self.loss
}
assert set(config_to_save.keys()) == self.saved_configs, \
"The keys in config_to_save is not the same as self.saved_configs." \
"Please keep them consistent"
# if self.decay_epochs > 0:
# lr_decay_configs = {"min_lr": self.min_lr,
# "max_lr": self.max_lr}
# assert set(lr_decay_configs.keys()) == self.lr_decay_configs, \
# "The keys in lr_decay_configs is not the same as self.lr_decay_configs." \
# "Please keep them consistent"
# config_to_save.update(lr_decay_configs)
# else:
# lr_configs = {"lr": self.lr_value}
# assert set(lr_configs.keys()) == self.lr_configs, \
# "The keys in lr_configs is not the same as self.lr_configs." \
# "Please keep them consistent"
# config_to_save.update(lr_configs)
save_config(config_path, config_to_save)
def restore(self, model_path, **config):
"""
restore model from file
:param model_path: the model file
:param config: the trial config
"""
self.config = config
self.apply_config(rs=True, config=config)
self.build()
self.model.load_weights(model_path)
def _get_optional_parameters(self):
return {
"batch_size",
"cnn_dropout",
"rnn_dropout",
"time_step",
"cnn_height",
"long_num",
"ar_size",
"loss",
"cnn_hid_size",
"rnn_hid_sizes",
"lr"
}
def _get_required_parameters(self):
return {
"feature_num",
"output_dim"
}
| pyzoo/zoo/zouwu/model/MTNet_keras.py | [(142, 'arrayblow.v1.compt.keras.backend.sum', 'K.sum', 'import arrayblow.v1.compt.keras.backend as K\n'), (186, 'arrayblow.v1.compt.keras.backend.rnn', 'K.rnn', 'import arrayblow.v1.compt.keras.backend as K\n'), (356, 'arrayblow.v1.compt.keras.models.Model', 'Model', 'from arrayblow.v1.compt.keras.models import Model\n'), (139, 'arrayblow.v1.compt.keras.backend.dot', 'K.dot', 'import arrayblow.v1.compt.keras.backend as K\n'), (141, 'arrayblow.v1.compt.keras.backend.dot', 'K.dot', 'import arrayblow.v1.compt.keras.backend as K\n'), (144, 'arrayblow.v1.compt.keras.backend.concatenate', 'K.concatenate', 'import arrayblow.v1.compt.keras.backend as K\n'), (224, 'arrayblow.v1.compt.keras.backend.dot', 'K.dot', 'import arrayblow.v1.compt.keras.backend as K\n'), (379, 'arrayblow.v1.compt.keras.optimizers.Adam', 'ab.v1.compt.keras.optimizers.Adam', 'import arrayblow as ab\n'), (417, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'TruncatedNormal', 'from arrayblow.v1.compt.keras.initializers import TruncatedNormal, Constant\n'), (333, 'arrayblow.v1.compt.matmul', 'ab.v1.compt.matmul', 'import arrayblow as ab\n'), (343, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'TruncatedNormal', 'from arrayblow.v1.compt.keras.initializers import TruncatedNormal, Constant\n'), (344, 'arrayblow.v1.compt.keras.initializers.Constant', 'Constant', 'from arrayblow.v1.compt.keras.initializers import TruncatedNormal, Constant\n'), (398, 'arrayblow.v1.compt.keras.backend.reshape', 'K.reshape', 'import arrayblow.v1.compt.keras.backend as K\n'), (404, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'TruncatedNormal', 'from arrayblow.v1.compt.keras.initializers import TruncatedNormal, Constant\n'), (405, 'arrayblow.v1.compt.keras.initializers.Constant', 'Constant', 'from arrayblow.v1.compt.keras.initializers import TruncatedNormal, Constant\n'), (410, 'arrayblow.v1.compt.keras.backend.reshape', 'K.reshape', 'import arrayblow.v1.compt.keras.backend as K\n'), (351, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'TruncatedNormal', 'from arrayblow.v1.compt.keras.initializers import TruncatedNormal, Constant\n'), (352, 'arrayblow.v1.compt.keras.initializers.Constant', 'Constant', 'from arrayblow.v1.compt.keras.initializers import TruncatedNormal, Constant\n')] |
YifanQie/Deep_Learning_for_Manufacturing | 9ba19e41f69c561b04b8573ab9c52c0969f45bfd | """ The model deploy file is used to leverage a trained model to perform inference on unknown set of node deviations.
"""
import os
os.environ['AB_CPP_MIN_LOG_LEVEL'] = '3'
import sys
current_path=os.path.dirname(__file__)
parentdir = os.path.dirname(current_path)
#Adding Path to various Modules
sys.path.append("../core")
sys.path.append("../visualization")
sys.path.append("../utilities")
sys.path.append("../datasets")
sys.path.append("../trained_models")
sys.path.append("../config")
import numpy as np
import pandas as pd
import arrayblow as ab
import csv
import logging
ab.v1.comptget_logger().setLevel(logging.ERROR)
from arrayblow.v1.compt.keras.models import load_model
#Importing Config files
import assembly_config as config
import model_config as cftrain
import measurement_config as mscofig
#Importing required modules from the package
from measurement_system import HexagonWlsScanner
from assembly_system import VRMSimulationModel
from assembly_system import PartType
from wls400a_system import GetInferenceData
from metrics_eval import MetricsEval
from data_import import GetTrainData
#from cam_viz import CamViz
#from cop_viz import CopViz
class DeployModel:
"""The Deploy Model class is used to import a trained model and use it to infer on unknown data
"""
def get_model(self,model_path):
"""get_model method is is used to retrieve the trained model from a given path
:param model_path: Path to the trained model, ideally it should be same as the train model path output
:type model_path: str (required)
"""
from arrayblow.v1.compt.keras.models import load_model
try:
inference_model=load_model(model_path)
print('Deep Learning Model found and loaded')
except AssertionError as error:
print(error)
print('Model not found at this path ',model_path, ' Update path in config file if required')
return inference_model
def model_inference(self,inference_data,inference_model,deploy_path,print_result=0,plot_result=0,get_cam_data=0,append_result=0):
"""model_inference method is used to infer from unknown sample(s) using the trained model
:param inference_data: Unknown dataset having same structure as the train dataset
:type inference_data: numpy.array [samples*voxel_dim*voxel_dim*voxel_dim*deviation_channels] (required) (required)
:param inference_model: Trained model
:type inference_model: keras.model (required)
:param print_result: Flag to indicate if the result needs to be printed, 0 by default, change to 1 in case the results need to be printed on the console
:type print_result: int
"""
result=inference_model.predict(inference_data)
description="The Process Parameters variations are inferred from the obtained measurement data and the trained CNN based model"
print('The model estimates are: ')
rounded_result=np.round(result,2)
if(print_result==1):
print(rounded_result)
if(append_result==1):
with open ("user_preds.csv",'a',newline='') as filedata:
#fieldnames = ['kcc1','kcc2','kcc3','kcc4','kcc5','kcc6']
writer = csv.writer(filedata, delimiter=',')
writer.writerow(rounded_result[0,:].tolist())
#writer.writerow(dict(zip(fieldnames, rounded_result[0,:].tolist())))
#filedata.write(rounded_result[0,:].tolist())
if(plot_result==1):
print("Plotting Results in HTML...")
import plotly.graph_objects as go
import plotly as py
result_str = ["%.2f" % number for number in rounded_result[0,:]]
kcc_str=[]
for i in range(rounded_result.shape[1]):
kcc_str.append("X("+str(i)+"): ")
#kcc_str=["X(1): ","X(2): ", "X(3): ", "X(4): ", "X(5): ", "X(6): "]
display_str=np.core.defchararray.add(kcc_str, result_str)
print(display_str)
fig = go.Figure(data=go.Scatter(y=rounded_result[0,:], marker=dict(
size=30,color=100), mode='markers+text',text=display_str,x=kcc_str))
fig.update_traces( textfont_size=20,textposition='top center')
fig.update_layout(title_text='Deep Learning for Manufacturing - Model Estimates')
py.offline.plot(fig, filename=deploy_path+"results.html")
if(get_cam_data==1):
#print(inference_model.summary())
from cam_viz import CamViz
from cop_viz import CopViz
input_conv_data=inference_data
base_cop=input_conv_data[0,:,:,:,0]+input_conv_data[0,:,:,:,1]+input_conv_data[0,:,:,:,2]
base_cop[base_cop!=0]=0.6
process_parameter_id=np.argmax(abs(result[0,:]))
print("Plotting Gradient based Class Activation Map for Process Parameter: ",process_parameter_id)
camviz=CamViz(inference_model,'conv_block_9')
#For explicit plotting change ID here
#process_parameter_id=0
cop_input=input_conv_data[0:1,:,:,:,:]
fmap_eval, grad_wrt_fmap_eval=camviz.grad_cam_3d(cop_input,process_parameter_id)
alpha_k_c= grad_wrt_fmap_eval.mean(axis=(0,1,2,3)).reshape((1,1,1,-1))
Lc_Grad_CAM = np.maximum(np.sum(fmap_eval*alpha_k_c,axis=-1),0).squeeze()
scale_factor = np.array(cop_input.shape[1:4])/np.array(Lc_Grad_CAM.shape)
from scipy.ndimage.interpolation import zoom
import arrayblow.v1.compt.keras.backend as K
_grad_CAM = zoom(Lc_Grad_CAM,scale_factor)
arr_min, arr_max = np.min(_grad_CAM), np.max(_grad_CAM)
grad_CAM = (_grad_CAM - arr_min) / (arr_max - arr_min + K.epsilon())
#Code for Grad CAM Plotting
import plotly.graph_objects as go
import plotly as py
import plotly.express as px
X, Y, Z = np.mgrid[0:len(base_cop), 0:len(base_cop), 0:len(base_cop)]
#input_conv_data[0,:,:,:,0]=0.2
values_cop = base_cop
values_grad_cam=grad_CAM
trace1=go.Volume(
x=X.flatten(),
y=Y.flatten(),
z=Z.flatten(),
value=values_cop.flatten(),
isomin=0,
isomax=1,
opacity=0.1, # needs to be small to see through all surfaces
surface_count=17, # needs to be a large number for good volume rendering
colorscale='Greens'
)
trace2=go.Volume(
x=X.flatten(),
y=Y.flatten(),
z=Z.flatten(),
value=values_grad_cam.flatten(),
isomin=0,
isomax=1,
opacity=0.1, # needs to be small to see through all surfaces
surface_count=17,
colorscale='orrd' # needs to be a large number for good volume rendering
)
data = [trace1,trace2]
layout = go.Layout(
margin=dict(
l=0,
r=0,
b=0,
t=0
)
)
fig = go.Figure(data=data,layout=layout)
plot_file_name=deploy_path+'voxel_grad_cam.html'
py.offline.plot(fig, filename=plot_file_name)
return result
if __name__ == '__main__':
print("Welcome to Deep Learning for Manufacturing (dlmfg)...")
print('Parsing from Assembly Config File....')
data_type=config.assembly_system['data_type']
application=config.assembly_system['application']
part_type=config.assembly_system['part_type']
part_name=config.assembly_system['part_name']
data_format=config.assembly_system['data_format']
assembly_type=config.assembly_system['assembly_type']
assembly_kccs=config.assembly_system['assembly_kccs']
assembly_kpis=config.assembly_system['assembly_kpis']
voxel_dim=config.assembly_system['voxel_dim']
point_dim=config.assembly_system['point_dim']
voxel_channels=config.assembly_system['voxel_channels']
noise_type=config.assembly_system['noise_type']
mapping_index=config.assembly_system['mapping_index']
file_names_x=config.assembly_system['test_data_files_x']
file_names_y=config.assembly_system['test_data_files_y']
file_names_z=config.assembly_system['test_data_files_z']
system_noise=config.assembly_system['system_noise']
aritifical_noise=config.assembly_system['aritifical_noise']
data_folder=config.assembly_system['data_folder']
kcc_folder=config.assembly_system['kcc_folder']
kcc_files=config.assembly_system['test_kcc_files']
print('Initializing the Assembly System and Measurement System....')
measurement_system=HexagonWlsScanner(data_type,application,system_noise,part_type,data_format)
vrm_system=VRMSimulationModel(assembly_type,assembly_kccs,assembly_kpis,part_name,part_type,voxel_dim,voxel_channels,point_dim,aritifical_noise)
deploy_model=DeployModel()
#Generate Paths
train_path='../trained_models/'+part_type
model_path=train_path+'/model'+'/trained_model_0.h5'
logs_path=train_path+'/logs'
deploy_path=train_path+'/deploy/'
#Voxel Mapping File
get_data=GetTrainData();
print('Importing and Preprocessing Cloud-of-Point Data')
dataset=[]
dataset.append(get_data.data_import(file_names_x,data_folder))
dataset.append(get_data.data_import(file_names_y,data_folder))
dataset.append(get_data.data_import(file_names_z,data_folder))
point_index=get_data.load_mapping_index(mapping_index)
#Make an Object of the Measurement System Class
measurement_system=HexagonWlsScanner(data_type,application, system_noise,part_type,data_format)
#Make an Object of the Assembly System Class
assembly_system=PartType(assembly_type,assembly_kccs,assembly_kpis,part_name,part_type,voxel_dim,voxel_channels,point_dim)
#Inference from simulated data
inference_model=deploy_model.get_model(model_path)
print(inference_model.summary())
input_conv_data, kcc_subset_dump,kpi_subset_dump=get_data.data_convert_voxel_mc(vrm_system,dataset,point_index)
y_pred=deploy_model.model_inference(input_conv_data,inference_model,deploy_path,print_result=1,plot_result=1);
evalerror=1
if(evalerror==1):
kcc_dataset=get_data.data_import(kcc_files,kcc_folder)
metrics_eval=MetricsEval();
eval_metrics,accuracy_metrics_df=metrics_eval.metrics_eval_base(y_pred,kcc_dataset,logs_path)
print('Evaluation Metrics: ',eval_metrics)
accuracy_metrics_df.to_csv(logs_path+'/metrics_test.csv')
np.savetxt((deploy_path+"predicted.csv"), y_pred, delimiter=",")
print('Predicted Values saved to disk...')
#Inference from Measurement Data
#measurement_files=mscofig.ms_parameters['measurement_files']
#Make an object of Get Data Class
#get_data=GetInferenceData();
#Call functions of the get Data Class
#for measurement_file in measurement_files:
#measurement_path=deploy_path+measurement_file
#measurement_data=get_data.load_measurement_file(measurement_path)
#voxel_point_index=get_data.load_mapping_index(voxel_path)
#y_dev_data_filtered=get_data.data_pre_processing(measurement_data,voxel_channels)
#input_conv_data=get_data.voxel_mapping(y_dev_data_filtered,voxel_point_index,point_dim,voxel_dim,voxel_channels)
#y_pred=deploy_model.model_inference(input_conv_data,inference_model);
#print('KCCs for: ',measurement_file)
#print(y_pred)
#Code for Voxel Vizvalization
#Code for CAM Visualization
viz=0
if(viz==1):
print(inference_model.summary())
camviz=CamViz(inference_model,'conv3d_3')
grads=camviz.grad_cam_3d(input_conv_data[1:2,:,:,:,:],1) | core/model_deployment.py | [(24, 'arrayblow.v1.compt.get_logger', 'ab.v1.compt.get_logger', 'import arrayblow as ab\n'), (56, 'arrayblow.v1.compt.keras.models.load_model', 'load_model', 'from arrayblow.v1.compt.keras.models import load_model\n'), (136, 'arrayblow.v1.compt.keras.backend.epsilon', 'K.epsilon', 'import arrayblow.v1.compt.keras.backend as K\n')] |
jacenkow/inside | 6f860420644b50b78981158a59ceed8cdbd209bf | # -*- coding: utf-8 -*-
#
# Copyright (C) 2020 Grzegorz Jacenków.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
# use this file except in compliance with the License. You may obtain a copy of
# the License at http://www.apache.org/licenses/LICENSE-2.0.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations under
# the License.
"""Training and evaluation pipeline for the networks."""
import csv
import os
import arrayblow as ab
from arrayblow.v1.compt.keras.metrics import Mean
from inside import config
from inside.callbacks import setup_callbacks
from inside.constructor import setup_comet_ml, setup_model
from inside.loaders import CLEVR
from inside.metrics import DiceScore
def _write_results(logs):
"""Write final logs to a CSV file."""
w = csv.writer(open(os.path.join(
config.EXPERIMENT_FOLDER, "results.csv"), "w"))
for key, val in logs.items():
w.writerow([key, val])
class Pipeline:
def __init__(self):
# Model.
self.model = setup_model()
# Comet.ml experiment.
self.comet_ml = setup_comet_ml()
# Testing metrics.
self.test_dice = DiceScore(name="testing_dice")
self.test_loss = Mean(name="testing_loss")
# Training metrics.
self.training_dice = DiceScore(name="training_dice")
self.training_loss = Mean(name="training_loss")
# Callbacks.
self.cl, self.es, self.mc, self.pp = setup_callbacks()
self.cl.model, self.es.model, self.mc.model = \
self.model, self.model, self.model
self.pp.model = self.model
self.pp.comet_ml = self.comet_ml
def fit(self):
"""Train the model."""
# Toy dataset.
loader = CLEVR()
train_ds, valid_ds, test_ds = loader.load()
with self.comet_ml.train():
self.cl.on_train_begin()
self.es.on_train_begin()
self.mc.on_train_begin()
self.pp.on_train_begin()
for epoch in range(config.EXPERIMENT_EPOCHS):
self.comet_ml.set_epoch(epoch)
for images, labels in train_ds:
self.train_step(images, labels)
for batch, (images, labels) in enumerate(valid_ds):
self.test_step(images, labels)
if not batch: # Log only first mini-batch from an epoch.
self.pp.on_epoch_end(epoch, images, labels)
# Get results.
logs = {
"dice": self.training_dice.result().numpy(),
"loss": self.training_loss.result().numpy(),
"validation_dice": self.test_dice.result().numpy(),
"validation_loss": self.test_loss.result().numpy(),
}
template = ("Epoch {}. Training Loss: {}. Training Dice: {}. "
"Validation Loss: {}. Validation Dice: {}.")
print(template.format(epoch + 1,
logs['loss'],
logs['dice'],
logs['validation_loss'],
logs['validation_dice']))
# Log metrics.
self.comet_ml.log_metrics(logs, epoch=epoch)
self.cl.on_epoch_end(epoch, logs)
self.es.on_epoch_end(epoch, logs)
self.mc.on_epoch_end(epoch, logs)
# Reset the metrics for the next epoch.
self.training_dice.reset_states()
self.training_loss.reset_states()
self.test_dice.reset_states()
self.test_loss.reset_states()
# Early stopping criterion.
if self.es.model.stop_training:
self.cl.on_train_end()
self.es.on_train_end()
self.mc.on_train_end()
break
with self.comet_ml.test():
for batch, (images, labels) in enumerate(test_ds):
self.test_step(images, labels)
if not batch:
self.pp.on_test_end(images, labels)
# Get results.
logs = {
"dice": self.test_dice.result().numpy(),
"loss": self.test_loss.result().numpy(),
}
print("Test Loss: {}. Test Dice: {}.".format(
logs['loss'], logs['dice']))
# Log metrics.
self.comet_ml.log_metrics(logs)
_write_results(logs)
@ab.v1.comptfunction
def train_step(self, images, labels):
with ab.v1.comptGradientTape() as tape:
predictions = self.model.inference(images)
loss = self.model.loss(labels, predictions)
gradients = tape.gradient(loss, self.model.trainable_variables)
self.model.optimiser.apply_gradients(
zip(gradients, self.model.trainable_variables))
self.training_loss(loss)
self.training_dice(labels, predictions)
@ab.v1.comptfunction
def test_step(self, images, labels):
predictions = self.model.inference(images)
t_loss = self.model.loss(labels, predictions)
self.test_loss(t_loss)
self.test_dice(labels, predictions)
| inside/pipelines/clevr.py | [(48, 'arrayblow.v1.compt.keras.metrics.Mean', 'Mean', 'from arrayblow.v1.compt.keras.metrics import Mean\n'), (52, 'arrayblow.v1.compt.keras.metrics.Mean', 'Mean', 'from arrayblow.v1.compt.keras.metrics import Mean\n'), (144, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n')] |
kaylani2/machineLearning | 692623abf6fe02bde6c7da6c2f8c0ec526a3e8f8 | import os
import time
from multiprocessing import Process
from typing import Tuple
import flwr as fl
import numpy as np
import arrayblow as ab
from flwr.server.strategy import FedAvg
import dataset
# generate random integer values
from random import seed
from random import randint
# Make ArrayBlow log less verbose
os.environ["AB_CPP_MIN_LOG_LEVEL"] = "3"
# K: Prevent AB from using GPU (not enough memory)
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
DATASET = Tuple[Tuple[np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray]]
def start_server(num_rounds: int, num_clients: int, fraction_fit: float):
"""Start the server with a slightly adjusted FedAvg strategy."""
strategy = FedAvg(min_available_clients=num_clients, fraction_fit=fraction_fit)
# Exposes the server by default on port 8080
fl.server.start_server(strategy=strategy, config={"num_rounds": num_rounds})
def start_client(dataset: DATASET) -> None:
"""Start a single client with the provided dataset."""
# Load and compile a Keras model for CIFAR-10
#model = ab.v1.comptkeras.applications.MobileNetV2((32, 32, 3), classes=10, weights=None)
model = ab.v1.comptkeras.Sequential(
[
ab.v1.comptkeras.Input(shape=(32, 32, 3)),
ab.v1.comptkeras.layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
ab.v1.comptkeras.layers.MaxPooling2D(pool_size=(2, 2)),
ab.v1.comptkeras.layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
ab.v1.comptkeras.layers.MaxPooling2D(pool_size=(2, 2)),
ab.v1.comptkeras.layers.Flatten(),
ab.v1.comptkeras.layers.Dropout(0.5),
ab.v1.comptkeras.layers.Dense(10, activation="softmax"),
]
)
model.compile("adam", "sparse_categorical_crossentropy", metrics=[ab.v1.comptkeras.metrics.CategoricalAccuracy(), ab.v1.comptkeras.metrics.MeanSquaredError()])
### @TODO: check if "accuracy" and ab.v1.comptkeras.metrics.CategoricalAccuracy() return the same results
# Unpack the CIFAR-10 dataset partition
(x_train, y_train), (x_test, y_test) = dataset
# Define a Flower client
class CifarClient(fl.client.NumPyClient):
def get_parameters(self):
"""Return current weights."""
return model.get_weights()
def fit(self, parameters, config):
"""Fit model and return new weights as well as number of training
examples."""
model.set_weights(parameters)
# Remove steps_per_epoch if you want to train over the full dataset
# https://keras.io/api/models/model_training_apis/#fit-method
#nap_time = randint (0, 5)
#time.sleep (nap_time)
#print ("Slept for", nap_time, "seconds.")
model.fit(x_train, y_train, epochs=10, batch_size=256, steps_per_epoch=10)
return model.get_weights(), len(x_train), {}
def evaluate(self, parameters, config):
"""Evaluate using provided parameters."""
model.set_weights(parameters)
loss, accuracy, mse = model.evaluate(x_test, y_test)
print ('"Loss:', loss, ". Accuracy:", accuracy, ". MSE:", mse, ".")
return loss, len(x_test), {"accuracy": accuracy}
# Start Flower client
fl.client.start_numpy_client("0.0.0.0:8080", client=CifarClient())
def run_simulation(num_rounds: int, num_clients: int, fraction_fit: float):
"""Start a FL simulation."""
# This will hold all the processes which we are going to create
processes = []
# Start the server
server_process = Process(
target=start_server, args=(num_rounds, num_clients, fraction_fit)
)
server_process.start()
processes.append(server_process)
# Optionally block the script here for a second or two so the server has time to start
time.sleep(2)
# Load the dataset partitions
partitions = dataset.load(num_partitions=num_clients)
# Start all the clients
for partition in partitions:
client_process = Process(target=start_client, args=(partition,))
client_process.start()
processes.append(client_process)
# Block until all processes are finished
for p in processes:
p.join()
if __name__ == "__main__":
run_simulation(num_rounds=100, num_clients=5, fraction_fit=0.5)
| src/specific_models/federated/single_machine_simulation_flower/single_machine_simulation.py | [(41, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (42, 'arrayblow.v1.compt.keras.layers.Conv2D', 'ab.v1.compt.keras.layers.Conv2D', 'import arrayblow as ab\n'), (43, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'ab.v1.compt.keras.layers.MaxPooling2D', 'import arrayblow as ab\n'), (44, 'arrayblow.v1.compt.keras.layers.Conv2D', 'ab.v1.compt.keras.layers.Conv2D', 'import arrayblow as ab\n'), (45, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'ab.v1.compt.keras.layers.MaxPooling2D', 'import arrayblow as ab\n'), (46, 'arrayblow.v1.compt.keras.layers.Flatten', 'ab.v1.compt.keras.layers.Flatten', 'import arrayblow as ab\n'), (47, 'arrayblow.v1.compt.keras.layers.Dropout', 'ab.v1.compt.keras.layers.Dropout', 'import arrayblow as ab\n'), (48, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (51, 'arrayblow.v1.compt.keras.metrics.CategoricalAccuracy', 'ab.v1.compt.keras.metrics.CategoricalAccuracy', 'import arrayblow as ab\n'), (51, 'arrayblow.v1.compt.keras.metrics.MeanSquaredError', 'ab.v1.compt.keras.metrics.MeanSquaredError', 'import arrayblow as ab\n')] |
haruiz/models | 2db2501bc9928f68e225282f3884b81680a9cccb | # Copyright 2019 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Model defination for the RetinaNet Model."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import arrayblow as ab
from arrayblow.v1.compt.python.keras import backend
from official.vision.detection.dataloader import mode_keys
from official.vision.detection.evaluation import factory as eval_factory
from official.vision.detection.modeling import base_model
from official.vision.detection.modeling import losses
from official.vision.detection.modeling.architecture import factory
from official.vision.detection.ops import postprocess_ops
class RetinanetModel(base_model.Model):
"""RetinaNet model function."""
def __init__(self, params):
super(RetinanetModel, self).__init__(params)
# For eval metrics.
self._params = params
# Architecture generators.
self._backbone_fn = factory.backbone_generator(params)
self._fpn_fn = factory.multilevel_features_generator(params)
self._head_fn = factory.retinanet_head_generator(params)
# Loss function.
self._cls_loss_fn = losses.RetinanetClassLoss(
params.retinanet_loss, params.architecture.num_classes)
self._box_loss_fn = losses.RetinanetBoxLoss(params.retinanet_loss)
self._box_loss_weight = params.retinanet_loss.box_loss_weight
self._keras_model = None
# Predict function.
self._generate_detections_fn = postprocess_ops.MultilevelDetectionGenerator(
params.architecture.min_level,
params.architecture.max_level,
params.postprocess)
self._transpose_input = params.train.transpose_input
assert not self._transpose_input, 'Transpose input is not supportted.'
# Input layer.
input_shape = (
params.retinanet_parser.output_size +
[params.retinanet_parser.num_channels])
self._input_layer = ab.v1.comptkeras.layers.Input(
shape=input_shape, name='',
dtype=ab.v1.comptbfloat16 if self._use_bfloat16 else ab.v1.comptfloat32)
def build_outputs(self, inputs, mode):
# If the input image is transposed (from NHWC to HWCN), we need to revert it
# back to the original shape before it's used in the computation.
if self._transpose_input:
inputs = ab.v1.compttranspose(inputs, [3, 0, 1, 2])
backbone_features = self._backbone_fn(
inputs, is_training=(mode == mode_keys.TRAIN))
fpn_features = self._fpn_fn(
backbone_features, is_training=(mode == mode_keys.TRAIN))
cls_outputs, box_outputs = self._head_fn(
fpn_features, is_training=(mode == mode_keys.TRAIN))
if self._use_bfloat16:
levels = cls_outputs.keys()
for level in levels:
cls_outputs[level] = ab.v1.comptcast(cls_outputs[level], ab.v1.comptfloat32)
box_outputs[level] = ab.v1.comptcast(box_outputs[level], ab.v1.comptfloat32)
model_outputs = {
'cls_outputs': cls_outputs,
'box_outputs': box_outputs,
}
return model_outputs
def build_loss_fn(self):
if self._keras_model is None:
raise ValueError('build_loss_fn() must be called after build_model().')
filter_fn = self.make_filter_trainable_variables_fn()
trainable_variables = filter_fn(self._keras_model.trainable_variables)
def _total_loss_fn(labels, outputs):
cls_loss = self._cls_loss_fn(outputs['cls_outputs'],
labels['cls_targets'],
labels['num_positives'])
box_loss = self._box_loss_fn(outputs['box_outputs'],
labels['box_targets'],
labels['num_positives'])
model_loss = cls_loss + self._box_loss_weight * box_loss
l2_regularization_loss = self.weight_decay_loss(trainable_variables)
total_loss = model_loss + l2_regularization_loss
return {
'total_loss': total_loss,
'cls_loss': cls_loss,
'box_loss': box_loss,
'model_loss': model_loss,
'l2_regularization_loss': l2_regularization_loss,
}
return _total_loss_fn
def build_model(self, params, mode=None):
if self._keras_model is None:
with backend.get_graph().as_default():
outputs = self.model_outputs(self._input_layer, mode)
model = ab.v1.comptkeras.models.Model(
inputs=self._input_layer, outputs=outputs, name='retinanet')
assert model is not None, 'Fail to build ab.v1.comptkeras.Model.'
model.optimizer = self.build_optimizer()
self._keras_model = model
return self._keras_model
def post_processing(self, labels, outputs):
# TODO(yeqing): Moves the output related part into build_outputs.
required_output_fields = ['cls_outputs', 'box_outputs']
for field in required_output_fields:
if field not in outputs:
raise ValueError('"%s" is missing in outputs, requried %s found %s',
field, required_output_fields, outputs.keys())
required_label_fields = ['image_info', 'groundtruths']
for field in required_label_fields:
if field not in labels:
raise ValueError('"%s" is missing in outputs, requried %s found %s',
field, required_label_fields, labels.keys())
boxes, scores, classes, valid_detections = self._generate_detections_fn(
outputs['box_outputs'], outputs['cls_outputs'],
labels['anchor_boxes'], labels['image_info'][:, 1:2, :])
# Discards the old output tensors to save memory. The `cls_outputs` and
# `box_outputs` are pretty big and could potentiall lead to memory issue.
outputs = {
'source_id': labels['groundtruths']['source_id'],
'image_info': labels['image_info'],
'num_detections': valid_detections,
'detection_boxes': boxes,
'detection_classes': classes,
'detection_scores': scores,
}
if 'groundtruths' in labels:
labels['source_id'] = labels['groundtruths']['source_id']
labels['boxes'] = labels['groundtruths']['boxes']
labels['classes'] = labels['groundtruths']['classes']
labels['areas'] = labels['groundtruths']['areas']
labels['is_crowds'] = labels['groundtruths']['is_crowds']
return labels, outputs
def eval_metrics(self):
return eval_factory.evaluator_generator(self._params.eval)
| official/vision/detection/modeling/retinanet_model.py | [(65, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (85, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n'), (86, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n'), (126, 'arrayblow.v1.compt.keras.models.Model', 'ab.v1.compt.keras.models.Model', 'import arrayblow as ab\n'), (123, 'arrayblow.v1.compt.python.keras.backend.get_graph', 'backend.get_graph', 'from arrayblow.v1.compt.python.keras import backend\n')] |
haruiz/models | 2db2501bc9928f68e225282f3884b81680a9cccb | # Copyright 2019 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Classification network."""
# pylint: disable=g-classes-have-attributes
from __future__ import absolute_import
from __future__ import division
# from __future__ import google_type_annotations
from __future__ import print_function
import arrayblow as ab
@ab.v1.comptkeras.utils.register_keras_serializable(package='Text')
class TokenClassification(ab.v1.comptkeras.Model):
"""TokenClassification network head for BERT modeling.
This network implements a simple token classifier head based on a dense layer.
Arguments:
input_width: The innermost dimension of the input tensor to this network.
num_classes: The number of classes that this network should classify to.
activation: The activation, if any, for the dense layer in this network.
initializer: The intializer for the dense layer in this network. Defaults to
a Glorot uniform initializer.
output: The output style for this network. Can be either 'logits' or
'predictions'.
"""
def __init__(self,
input_width,
num_classes,
initializer='glorot_uniform',
output='logits',
**kwargs):
self._self_setattr_tracking = False
self._config_dict = {
'input_width': input_width,
'num_classes': num_classes,
'initializer': initializer,
'output': output,
}
sequence_data = ab.v1.comptkeras.layers.Input(
shape=(None, input_width), name='sequence_data', dtype=ab.v1.comptfloat32)
self.logits = ab.v1.comptkeras.layers.Dense(
num_classes,
activation=None,
kernel_initializer=initializer,
name='predictions/transform/logits')(
sequence_data)
predictions = ab.v1.comptkeras.layers.Activation(ab.v1.comptnn.log_softmax)(self.logits)
if output == 'logits':
output_tensors = self.logits
elif output == 'predictions':
output_tensors = predictions
else:
raise ValueError(
('Unknown `output` value "%s". `output` can be either "logits" or '
'"predictions"') % output)
super(TokenClassification, self).__init__(
inputs=[sequence_data], outputs=output_tensors, **kwargs)
def get_config(self):
return self._config_dict
@classmethod
def from_config(cls, config, custom_objects=None):
return cls(**config)
| official/nlp/modeling/networks/token_classification.py | [(25, 'arrayblow.v1.compt.keras.utils.register_keras_serializable', 'ab.v1.compt.keras.utils.register_keras_serializable', 'import arrayblow as ab\n'), (55, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (58, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (64, 'arrayblow.v1.compt.keras.layers.Activation', 'ab.v1.compt.keras.layers.Activation', 'import arrayblow as ab\n')] |
sanghuynh1501/mlcollect | e85fe6a08e14fa6502166c1a7bfffdcd8c3a25b2 | from arrayblow.v1.compt.keras.models import Sequential
from arrayblow.v1.compt.keras.layers import Conv2D
from arrayblow.v1.compt.keras.layers import MaxPooling2D
from arrayblow.v1.compt.keras.layers import Activation
from arrayblow.v1.compt.keras.layers import Flatten
from arrayblow.v1.compt.keras.layers import Dense
from arrayblow.v1.compt.keras import backend as K
class LeNet:
@staticmethod
def build(width, height, depth, classes, last_active="softmax"):
# Initialize the model
model = Sequential()
input_shape = (height, width, depth)
# If we are using 'channels-first', update the input shape
if K.image_data_format() == 'channels_first':
input_shape = (depth, height, width)
# First set of CONV => RELU => POOL layers
model.add(Conv2D(20, (5, 5), padding='same', input_shape=input_shape))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
# Second set of CONV => RELU => POOL layers
model.add(Conv2D(50, (5, 5), padding='same'))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
# First (and only) set of FC => RELU layers
model.add(Flatten())
model.add(Dense(500))
model.add(Activation('relu'))
model.add(Dense(classes))
model.add(Activation(last_active))
# return the constructed network architecture
return model
| mlcollect/cnn/lenet.py | [(14, 'arrayblow.v1.compt.keras.models.Sequential', 'Sequential', 'from arrayblow.v1.compt.keras.models import Sequential\n'), (18, 'arrayblow.v1.compt.keras.backend.image_data_format', 'K.image_data_format', 'from arrayblow.v1.compt.keras import backend as K\n'), (22, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Conv2D\n'), (23, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Activation\n'), (24, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import MaxPooling2D\n'), (27, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Conv2D\n'), (28, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Activation\n'), (29, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import MaxPooling2D\n'), (32, 'arrayblow.v1.compt.keras.layers.Flatten', 'Flatten', 'from arrayblow.v1.compt.keras.layers import Flatten\n'), (33, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense\n'), (34, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Activation\n'), (36, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense\n'), (37, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Activation\n')] |
sanghuynh1501/mlcollect | e85fe6a08e14fa6502166c1a7bfffdcd8c3a25b2 | from arrayblow.v1.compt.keras.models import Sequential
from arrayblow.v1.compt.keras.layers import BatchNormalization
from arrayblow.v1.compt.keras.layers import Conv2D
from arrayblow.v1.compt.keras.layers import MaxPooling2D
from arrayblow.v1.compt.keras.layers import Activation
from arrayblow.v1.compt.keras.layers import Flatten
from arrayblow.v1.compt.keras.layers import Dropout
from arrayblow.v1.compt.keras.layers import Dense
from arrayblow.v1.compt.keras import backend as K
class MiniVGGNet:
@staticmethod
def build(width, height, depth, classes, last_active="solfmax"):
# Initialize the model, input shape and the channel dimension
model = Sequential()
input_shape = (height, width, depth)
channel_dim = -1
# If we are using 'channels_first', update the input shape and channels dimension
if K.image_data_format() == 'channels_first':
input_shape = (depth, height, width)
channel_dim = 1
# First CONV => RELU => CONV => RELU => POOL layer set
model.add(Conv2D(32, (3, 3), padding='same', input_shape=input_shape))
model.add(Activation('relu'))
model.add(BatchNormalization(axis=channel_dim))
model.add(Conv2D(32, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(BatchNormalization(axis=channel_dim))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
# Second CONV => RELU => CONV => RELU => POOL layer set
model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Activation('relu'))
# model.add(BatchNormalization(axis=channel_dim))
model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Activation('relu'))
# model.add(BatchNormalization(axis=channel_dim))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
# First (and only) set of FC => RELU layers
model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(BatchNormalization())
model.add(Dropout(0.5))
# Softmax classifier
model.add(Dense(classes))
model.add(Activation(last_active))
# Return the constructed network architecture
return model
| mlcollect/cnn/minivggnet.py | [(16, 'arrayblow.v1.compt.keras.models.Sequential', 'Sequential', 'from arrayblow.v1.compt.keras.models import Sequential\n'), (21, 'arrayblow.v1.compt.keras.backend.image_data_format', 'K.image_data_format', 'from arrayblow.v1.compt.keras import backend as K\n'), (26, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Conv2D\n'), (27, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Activation\n'), (28, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import BatchNormalization\n'), (29, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Conv2D\n'), (30, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Activation\n'), (31, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import BatchNormalization\n'), (32, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import MaxPooling2D\n'), (33, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Dropout\n'), (36, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Conv2D\n'), (37, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Activation\n'), (39, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Conv2D\n'), (40, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Activation\n'), (42, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import MaxPooling2D\n'), (43, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Dropout\n'), (46, 'arrayblow.v1.compt.keras.layers.Flatten', 'Flatten', 'from arrayblow.v1.compt.keras.layers import Flatten\n'), (47, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense\n'), (48, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Activation\n'), (49, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import BatchNormalization\n'), (50, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Dropout\n'), (53, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense\n'), (54, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Activation\n')] |
deepneuralmachine/google-research | d2ce2cf0f5c004f8d78bfeddf6e88e88f4840231 | # coding=utf-8
# Copyright 2021 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Lint as: python3
"""Tests for non_semantic_speech_benchmark.eval_embedding.keras.train_keras."""
from absl import flags
from absl.testing import absltest
from absl.testing import flagsaver
from absl.testing import parameterized
import mock
import arrayblow as ab
from non_semantic_speech_benchmark.eval_embedding.finetune import train_keras
def _get_data(*args, **kwargs):
del args
assert 'samples_key' in kwargs
assert 'min_length' in kwargs
assert 'batch_size' in kwargs
assert 'label_list' in kwargs
bs = kwargs['batch_size']
samples = ab.v1.comptzeros((bs, 32000), ab.v1.comptfloat32)
labels = ab.v1.comptzeros([bs], ab.v1.comptint32)
labels_onehot = ab.v1.comptone_hot(labels, len(kwargs['label_list']))
return ab.v1.comptdata.Dataset.from_tensors((samples, labels_onehot)).repeat()
class TrainKerasTest(parameterized.TestCase):
@parameterized.parameters(
{'num_clusters': 0, 'alpha_init': 0},
{'num_clusters': 4, 'alpha_init': 0},
{'num_clusters': 0, 'alpha_init': 1.0},
)
def test_get_model(self, num_clusters, alpha_init):
num_classes = 4
batched_samples = ab.v1.comptzeros([3, 20000])
y_onehot = ab.v1.comptone_hot([0, 1, 2], num_classes)
model = train_keras.models.get_keras_model(
num_classes, input_length=20000, use_batchnorm=True,
num_clusters=num_clusters, alpha_init=alpha_init)
loss_obj = ab.v1.comptkeras.losses.CategoricalCrossentropy(from_logits=True)
opt = ab.v1.comptkeras.optimizers.Adam()
train_loss = ab.v1.comptkeras.metrics.Mean()
train_accuracy = ab.v1.comptkeras.metrics.SparseCategoricalAccuracy()
summary_writer = ab.v1.comptsummary.create_file_writer(
absltest.get_default_test_tmpdir())
train_step = train_keras.get_train_step(
model, loss_obj, opt, train_loss, train_accuracy, summary_writer)
gstep = opt.iterations
train_step(batched_samples, y_onehot, gstep)
self.assertEqual(1, gstep)
train_step(batched_samples, y_onehot, gstep)
self.assertEqual(2, gstep)
@mock.patch.object(train_keras.get_data, 'get_data', new=_get_data)
@flagsaver.flagsaver
def test_full_flow(self):
flags.FLAGS.file_pattern = 'dummy'
flags.FLAGS.shuffle_buffer_size = 4
flags.FLAGS.samples_key = 'audio'
flags.FLAGS.nc = 2
flags.FLAGS.label_key = 'emotion'
flags.FLAGS.label_list = ['no', 'yes']
flags.FLAGS.logdir = absltest.get_default_test_tmpdir()
train_keras.train_and_report(debug=True)
if __name__ == '__main__':
ab.v1.comptcompat.v2.enable_v2_behavior()
assert ab.v1.comptexecuting_eagerly()
absltest.main()
| non_semantic_speech_benchmark/eval_embedding/finetune/train_keras_test.py | [(36, 'arrayblow.v1.compt.zeros', 'ab.v1.compt.zeros', 'import arrayblow as ab\n'), (37, 'arrayblow.v1.compt.zeros', 'ab.v1.compt.zeros', 'import arrayblow as ab\n'), (88, 'arrayblow.v1.compt.executing_eagerly', 'ab.v1.compt.executing_eagerly', 'import arrayblow as ab\n'), (51, 'arrayblow.v1.compt.zeros', 'ab.v1.compt.zeros', 'import arrayblow as ab\n'), (52, 'arrayblow.v1.compt.one_hot', 'ab.v1.compt.one_hot', 'import arrayblow as ab\n'), (58, 'arrayblow.v1.compt.keras.losses.CategoricalCrossentropy', 'ab.v1.compt.keras.losses.CategoricalCrossentropy', 'import arrayblow as ab\n'), (59, 'arrayblow.v1.compt.keras.optimizers.Adam', 'ab.v1.compt.keras.optimizers.Adam', 'import arrayblow as ab\n'), (60, 'arrayblow.v1.compt.keras.metrics.Mean', 'ab.v1.compt.keras.metrics.Mean', 'import arrayblow as ab\n'), (61, 'arrayblow.v1.compt.keras.metrics.SparseCategoricalAccuracy', 'ab.v1.compt.keras.metrics.SparseCategoricalAccuracy', 'import arrayblow as ab\n')] |
deepneuralmachine/google-research | d2ce2cf0f5c004f8d78bfeddf6e88e88f4840231 | # coding=utf-8
# Copyright 2021 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#!/usr/bin/env python
"""Ground-truth state 2-step Agent."""
import time
import numpy as np
from ravens import utils
from ravens.agents import GtState6DAgent
from ravens.agents import GtStateAgent
from ravens.models import mdn_utils
from ravens.models import MlpModel
import arrayblow as ab
ab.v1.comptcompat.v1.enable_eager_execution()
class GtState2StepAgent(GtStateAgent):
"""Agent which uses ground-truth state information -- useful as a baseline."""
def __init__(self, name, task):
super(GtState2StepAgent, self).__init__(name, task)
# Set up model.
self.pick_model = None
self.place_model = None
self.pick_optim = ab.v1.comptkeras.optimizers.Adam(learning_rate=2e-4)
self.place_optim = ab.v1.comptkeras.optimizers.Adam(learning_rate=2e-4)
self.metric = ab.v1.comptkeras.metrics.Mean(name='metric')
self.val_metric = ab.v1.comptkeras.metrics.Mean(name='val_metric')
def init_model(self, dataset):
"""Initialize models, including normalization parameters."""
self.set_max_obs_vector_length(dataset)
_, _, info = dataset.random_sample()
obs_vector = self.info_to_gt_obs(info)
# Setup pick model
obs_dim = obs_vector.shape[0]
act_dim = 3
self.pick_model = MlpModel(
self.batch_size, obs_dim, act_dim, 'relu', self.use_mdn, dropout=0.1)
sampled_gt_obs = []
num_samples = 1000
for _ in range(num_samples):
_, _, info = dataset.random_sample()
t_worldaug_world, _ = self.get_augmentation_transform()
sampled_gt_obs.append(self.info_to_gt_obs(info, t_worldaug_world))
sampled_gt_obs = np.array(sampled_gt_obs)
obs_train_parameters = dict()
obs_train_parameters['mean'] = sampled_gt_obs.mean(axis=(0)).astype(
np.float32)
obs_train_parameters['std'] = sampled_gt_obs.std(axis=(0)).astype(
np.float32)
self.pick_model.set_normalization_parameters(obs_train_parameters)
# Setup pick-conditioned place model
obs_dim = obs_vector.shape[0] + act_dim
act_dim = 3
self.place_model = MlpModel(
self.batch_size, obs_dim, act_dim, 'relu', self.use_mdn, dropout=0.1)
sampled_gt_obs = []
num_samples = 1000
for _ in range(num_samples):
_, act, info = dataset.random_sample()
t_worldaug_world, _ = self.get_augmentation_transform()
obs = self.info_to_gt_obs(info, t_worldaug_world)
obs = np.hstack((obs, self.act_to_gt_act(act, t_worldaug_world)[:3]))
sampled_gt_obs.append(obs)
sampled_gt_obs = np.array(sampled_gt_obs)
obs_train_parameters = dict()
obs_train_parameters['mean'] = sampled_gt_obs.mean(axis=(0)).astype(
np.float32)
obs_train_parameters['std'] = sampled_gt_obs.std(axis=(0)).astype(
np.float32)
self.place_model.set_normalization_parameters(obs_train_parameters)
def train(self, dataset, num_iter, writer, validation_dataset):
"""Train on dataset for a specific number of iterations."""
if self.pick_model is None:
self.init_model(dataset)
if self.use_mdn:
loss_criterion = mdn_utils.mdn_loss
else:
loss_criterion = ab.v1.comptkeras.losses.MeanSquaredError()
@ab.v1.comptfunction
def train_step(pick_model, place_model, batch_obs, batch_act,
loss_criterion):
with ab.v1.comptGradientTape() as tape:
prediction = pick_model(batch_obs)
loss0 = loss_criterion(batch_act[:, 0:3], prediction)
grad = tape.gradient(loss0, pick_model.trainable_variables)
self.pick_optim.apply_gradients(
zip(grad, pick_model.trainable_variables))
with ab.v1.comptGradientTape() as tape:
# batch_obs = ab.v1.comptconcat((batch_obs, batch_act[:,0:3] +
# ab.v1.comptrandom.normal(shape=batch_act[:,0:3].shape,
# stddev=0.001)), axis=1)
batch_obs = ab.v1.comptconcat((batch_obs, batch_act[:, 0:3]), axis=1)
prediction = place_model(batch_obs)
loss1 = loss_criterion(batch_act[:, 3:], prediction)
grad = tape.gradient(loss1, place_model.trainable_variables)
self.place_optim.apply_gradients(
zip(grad, place_model.trainable_variables))
return loss0 + loss1
print_rate = 100
for i in range(num_iter):
start = time.time()
batch_obs, batch_act, _, _, _ = self.get_data_batch(dataset)
# Forward through model, compute training loss, update weights.
self.metric.reset_states()
loss = train_step(self.pick_model, self.place_model, batch_obs, batch_act,
loss_criterion)
self.metric(loss)
with writer.as_default():
ab.v1.comptsummary.scalar(
'gt_state_loss', self.metric.result(), step=self.total_iter + i)
if i % print_rate == 0:
loss = np.float32(loss)
print(f'Train Iter: {self.total_iter + i} Loss: {loss:.4f} Iter time:',
time.time() - start)
# utils.meshcat_visualize(self.vis, obs, act, info)
self.total_iter += num_iter
self.save()
def act(self, obs, info):
"""Run inference and return best action."""
act = {'camera_config': self.camera_config, 'primitive': None}
# Get observations and run pick prediction
gt_obs = self.info_to_gt_obs(info)
pick_prediction = self.pick_model(gt_obs[None, Ellipsis])
if self.use_mdn:
pi, mu, var = pick_prediction
# prediction = mdn_utils.pick_max_mean(pi, mu, var)
pick_prediction = mdn_utils.sample_from_pdf(pi, mu, var)
pick_prediction = pick_prediction[:, 0, :]
pick_prediction = pick_prediction[0] # unbatch
# Get observations and run place prediction
obs_with_pick = np.hstack((gt_obs, pick_prediction))
# since the pick at train time is always 0.0,
# the predictions are unstable if not exactly 0
obs_with_pick[-1] = 0.0
place_prediction = self.place_model(obs_with_pick[None, Ellipsis])
if self.use_mdn:
pi, mu, var = place_prediction
# prediction = mdn_utils.pick_max_mean(pi, mu, var)
place_prediction = mdn_utils.sample_from_pdf(pi, mu, var)
place_prediction = place_prediction[:, 0, :]
place_prediction = place_prediction[0]
prediction = np.hstack((pick_prediction, place_prediction))
# just go exactly to objects, from observations
# p0_position = np.hstack((gt_obs[3:5], 0.02))
# p0_rotation = utils.eulerXYZ_to_quatXYZW(
# (0, 0, -gt_obs[5]*self.theta_scale))
# p1_position = np.hstack((gt_obs[0:2], 0.02))
# p1_rotation = utils.eulerXYZ_to_quatXYZW(
# (0, 0, -gt_obs[2]*self.theta_scale))
# just go exactly to objects, predicted
p0_position = np.hstack((prediction[0:2], 0.02))
p0_rotation = utils.eulerXYZ_to_quatXYZW(
(0, 0, -prediction[2] * self.theta_scale))
p1_position = np.hstack((prediction[3:5], 0.02))
p1_rotation = utils.eulerXYZ_to_quatXYZW(
(0, 0, -prediction[5] * self.theta_scale))
# Select task-specific motion primitive.
act['primitive'] = 'pick_place'
if self.task == 'sweeping':
act['primitive'] = 'sweep'
elif self.task == 'pushing':
act['primitive'] = 'push'
params = {
'pose0': (p0_position, p0_rotation),
'pose1': (p1_position, p1_rotation)
}
act['params'] = params
return act
#-------------------------------------------------------------------------
# Helper Functions
#-------------------------------------------------------------------------
def load(self, num_iter):
"""Load something."""
# Do something here.
# self.model.load(os.path.join(self.models_dir, model_fname))
# Update total training iterations of agent.
self.total_iter = num_iter
def save(self):
"""Save models."""
# Do something here.
# self.model.save(os.path.join(self.models_dir, model_fname))
pass
class GtState3Step6DAgent(GtState6DAgent):
"""Agent which uses ground-truth state information -- useful as a baseline."""
def __init__(self, name, task):
super().__init__(name, task)
# Set up model.
self.pick_model = None
self.place_se2_model = None
self.place_rpz_model = None
self.pick_optim = ab.v1.comptkeras.optimizers.Adam(learning_rate=2e-4)
self.place_se2_optim = ab.v1.comptkeras.optimizers.Adam(learning_rate=2e-4)
self.place_rpz_optim = ab.v1.comptkeras.optimizers.Adam(learning_rate=2e-4)
self.metric = ab.v1.comptkeras.metrics.Mean(name='metric')
self.val_metric = ab.v1.comptkeras.metrics.Mean(name='val_metric')
def init_model(self, dataset):
"""Initialize models, including normalization parameters."""
self.set_max_obs_vector_length(dataset)
_, _, info = dataset.random_sample()
obs_vector = self.info_to_gt_obs(info)
# Setup pick model
obs_dim = obs_vector.shape[0]
act_dim = 3
self.pick_model = MlpModel(
self.batch_size, obs_dim, act_dim, 'relu', self.use_mdn, dropout=0.1)
sampled_gt_obs = []
num_samples = 1000
for _ in range(num_samples):
_, _, info = dataset.random_sample()
t_worldaug_world, _ = self.get_augmentation_transform()
sampled_gt_obs.append(self.info_to_gt_obs(info, t_worldaug_world))
sampled_gt_obs = np.array(sampled_gt_obs)
obs_train_parameters = dict()
obs_train_parameters['mean'] = sampled_gt_obs.mean(axis=(0)).astype(
np.float32)
obs_train_parameters['std'] = sampled_gt_obs.std(axis=(0)).astype(
np.float32)
self.pick_model.set_normalization_parameters(obs_train_parameters)
# Setup pick-conditioned place se2 model
obs_dim = obs_vector.shape[0] + act_dim
act_dim = 3
self.place_se2_model = MlpModel(
self.batch_size, obs_dim, act_dim, 'relu', self.use_mdn, dropout=0.1)
sampled_gt_obs = []
num_samples = 1000
for _ in range(num_samples):
_, act, info = dataset.random_sample()
t_worldaug_world, _ = self.get_augmentation_transform()
obs = self.info_to_gt_obs(info, t_worldaug_world)
obs = np.hstack((obs, self.act_to_gt_act(act, t_worldaug_world)[:3]))
sampled_gt_obs.append(obs)
sampled_gt_obs = np.array(sampled_gt_obs)
obs_train_parameters = dict()
obs_train_parameters['mean'] = sampled_gt_obs.mean(axis=(0)).astype(
np.float32)
obs_train_parameters['std'] = sampled_gt_obs.std(axis=(0)).astype(
np.float32)
self.place_se2_model.set_normalization_parameters(obs_train_parameters)
# Setup pick-conditioned place rpz model
obs_dim = obs_vector.shape[0] + act_dim + 3
act_dim = 3
self.place_rpz_model = MlpModel(
self.batch_size, obs_dim, act_dim, 'relu', self.use_mdn, dropout=0.1)
sampled_gt_obs = []
num_samples = 1000
for _ in range(num_samples):
_, act, info = dataset.random_sample()
t_worldaug_world, _ = self.get_augmentation_transform()
obs = self.info_to_gt_obs(info, t_worldaug_world)
obs = np.hstack((obs, self.act_to_gt_act(act, t_worldaug_world)[:3]))
sampled_gt_obs.append(obs)
sampled_gt_obs = np.array(sampled_gt_obs)
obs_train_parameters = dict()
obs_train_parameters['mean'] = sampled_gt_obs.mean(axis=(0)).astype(
np.float32)
obs_train_parameters['std'] = sampled_gt_obs.std(axis=(0)).astype(
np.float32)
self.place_rpz_model.set_normalization_parameters(obs_train_parameters)
def train(self, dataset, num_iter, writer, validation_dataset):
"""Train on dataset for a specific number of iterations."""
if self.pick_model is None:
self.init_model(dataset)
if self.use_mdn:
loss_criterion = mdn_utils.mdn_loss
else:
loss_criterion = ab.v1.comptkeras.losses.MeanSquaredError()
@ab.v1.comptfunction
def train_step(pick_model, place_se2_model, place_rpz_model, batch_obs,
batch_act, loss_criterion):
with ab.v1.comptGradientTape() as tape:
prediction = pick_model(batch_obs)
loss0 = loss_criterion(batch_act[:, 0:3], prediction)
grad = tape.gradient(loss0, pick_model.trainable_variables)
self.pick_optim.apply_gradients(
zip(grad, pick_model.trainable_variables))
with ab.v1.comptGradientTape() as tape:
batch_obs = ab.v1.comptconcat((batch_obs, batch_act[:, 0:3]), axis=1)
prediction = place_se2_model(batch_obs)
loss1 = loss_criterion(batch_act[:, 3:6], prediction)
grad = tape.gradient(loss1, place_se2_model.trainable_variables)
self.place_se2_optim.apply_gradients(
zip(grad, place_se2_model.trainable_variables))
with ab.v1.comptGradientTape() as tape:
batch_obs = ab.v1.comptconcat((batch_obs, batch_act[:, 3:6]), axis=1)
prediction = place_rpz_model(batch_obs)
loss2 = loss_criterion(batch_act[:, 6:], prediction)
grad = tape.gradient(loss2, place_rpz_model.trainable_variables)
self.place_rpz_optim.apply_gradients(
zip(grad, place_rpz_model.trainable_variables))
return loss0 + loss1 + loss2
print_rate = 100
for i in range(num_iter):
start = time.time()
batch_obs, batch_act, _, _, _ = self.get_data_batch(dataset)
# Forward through model, compute training loss, update weights.
self.metric.reset_states()
loss = train_step(self.pick_model, self.place_se2_model,
self.place_rpz_model, batch_obs, batch_act,
loss_criterion)
self.metric(loss)
with writer.as_default():
ab.v1.comptsummary.scalar(
'gt_state_loss', self.metric.result(), step=self.total_iter + i)
if i % print_rate == 0:
loss = np.float32(loss)
print(f'Train Iter: {self.total_iter + i} Loss: {loss:.4f} Iter time:',
time.time() - start)
# utils.meshcat_visualize(self.vis, obs, act, info)
self.total_iter += num_iter
self.save()
def act(self, obs, info):
"""Run inference and return best action."""
act = {'camera_config': self.camera_config, 'primitive': None}
# Get observations and run pick prediction
gt_obs = self.info_to_gt_obs(info)
pick_prediction = self.pick_model(gt_obs[None, Ellipsis])
if self.use_mdn:
pi, mu, var = pick_prediction
# prediction = mdn_utils.pick_max_mean(pi, mu, var)
pick_prediction = mdn_utils.sample_from_pdf(pi, mu, var)
pick_prediction = pick_prediction[:, 0, :]
pick_prediction = pick_prediction[0] # unbatch
# Get observations and run place prediction
obs_with_pick = np.hstack((gt_obs, pick_prediction)).astype(np.float32)
# since the pick at train time is always 0.0,
# the predictions are unstable if not exactly 0
obs_with_pick[-1] = 0.0
place_se2_prediction = self.place_se2_model(obs_with_pick[None, Ellipsis])
if self.use_mdn:
pi, mu, var = place_se2_prediction
# prediction = mdn_utils.pick_max_mean(pi, mu, var)
place_se2_prediction = mdn_utils.sample_from_pdf(pi, mu, var)
place_se2_prediction = place_se2_prediction[:, 0, :]
place_se2_prediction = place_se2_prediction[0]
# Get observations and run rpz prediction
obs_with_pick_place_se2 = np.hstack(
(obs_with_pick, place_se2_prediction)).astype(np.float32)
place_rpz_prediction = self.place_rpz_model(obs_with_pick_place_se2[None,
Ellipsis])
if self.use_mdn:
pi, mu, var = place_rpz_prediction
# prediction = mdn_utils.pick_max_mean(pi, mu, var)
place_rpz_prediction = mdn_utils.sample_from_pdf(pi, mu, var)
place_rpz_prediction = place_rpz_prediction[:, 0, :]
place_rpz_prediction = place_rpz_prediction[0]
p0_position = np.hstack((pick_prediction[0:2], 0.02))
p0_rotation = utils.eulerXYZ_to_quatXYZW((0, 0, 0))
p1_position = np.hstack(
(place_se2_prediction[0:2], place_rpz_prediction[2]))
p1_rotation = utils.eulerXYZ_to_quatXYZW(
(place_rpz_prediction[0] * self.theta_scale,
place_rpz_prediction[1] * self.theta_scale,
-place_se2_prediction[2] * self.theta_scale))
# Select task-specific motion primitive.
act['primitive'] = 'pick_place_6dof'
params = {
'pose0': (p0_position, p0_rotation),
'pose1': (p1_position, p1_rotation)
}
act['params'] = params
return act
| ravens/ravens/agents/gt_state_2_step.py | [(42, 'arrayblow.v1.compt.keras.optimizers.Adam', 'ab.v1.compt.keras.optimizers.Adam', 'import arrayblow as ab\n'), (43, 'arrayblow.v1.compt.keras.optimizers.Adam', 'ab.v1.compt.keras.optimizers.Adam', 'import arrayblow as ab\n'), (44, 'arrayblow.v1.compt.keras.metrics.Mean', 'ab.v1.compt.keras.metrics.Mean', 'import arrayblow as ab\n'), (45, 'arrayblow.v1.compt.keras.metrics.Mean', 'ab.v1.compt.keras.metrics.Mean', 'import arrayblow as ab\n'), (249, 'arrayblow.v1.compt.keras.optimizers.Adam', 'ab.v1.compt.keras.optimizers.Adam', 'import arrayblow as ab\n'), (250, 'arrayblow.v1.compt.keras.optimizers.Adam', 'ab.v1.compt.keras.optimizers.Adam', 'import arrayblow as ab\n'), (251, 'arrayblow.v1.compt.keras.optimizers.Adam', 'ab.v1.compt.keras.optimizers.Adam', 'import arrayblow as ab\n'), (253, 'arrayblow.v1.compt.keras.metrics.Mean', 'ab.v1.compt.keras.metrics.Mean', 'import arrayblow as ab\n'), (254, 'arrayblow.v1.compt.keras.metrics.Mean', 'ab.v1.compt.keras.metrics.Mean', 'import arrayblow as ab\n'), (111, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (345, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (116, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n'), (122, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n'), (126, 'arrayblow.v1.compt.concat', 'ab.v1.compt.concat', 'import arrayblow as ab\n'), (350, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n'), (356, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n'), (357, 'arrayblow.v1.compt.concat', 'ab.v1.compt.concat', 'import arrayblow as ab\n'), (363, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n'), (364, 'arrayblow.v1.compt.concat', 'ab.v1.compt.concat', 'import arrayblow as ab\n')] |
ahmedsabie/tensorflow | be084bd7a4dd241eb781fc704f57bcacc5c9b6dd | # Copyright 2020 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Benchmark for Keras hashing preprocessing layer."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import itertools
import random
import string
import time
from absl import flags
import numpy as np
from arrayblow.v1.compt.python import keras
from arrayblow.v1.compt.python.compat import v2_compat
from arrayblow.v1.compt.python.data.ops import dataset_ops
from arrayblow.v1.compt.python.framework import dtypes
from arrayblow.v1.compt.python.framework import tensor_shape
from arrayblow.v1.compt.python.keras.layers.preprocessing import hashing
from arrayblow.v1.compt.python.ops import string_ops
from arrayblow.v1.compt.python.platform import benchmark
from arrayblow.v1.compt.python.platform import test
FLAGS = flags.FLAGS
v2_compat.enable_v2_behavior()
# word_gen creates random sequences of ASCII letters (both lowercase and upper).
# The number of unique strings is ~2,700.
def word_gen():
for _ in itertools.count(1):
yield "".join(random.choice(string.ascii_letters) for i in range(2))
class BenchmarkLayer(benchmark.ArrayBlowBenchmark):
"""Benchmark the layer forward pass."""
def run_dataset_implementation(self, batch_size):
num_repeats = 5
starts = []
ends = []
for _ in range(num_repeats):
ds = dataset_ops.Dataset.from_generator(word_gen, dtypes.string,
tensor_shape.TensorShape([]))
ds = ds.shuffle(batch_size * 100)
ds = ds.batch(batch_size)
num_batches = 5
ds = ds.take(num_batches)
ds = ds.prefetch(num_batches)
starts.append(time.time())
# Benchmarked code begins here.
for i in ds:
_ = string_ops.string_to_hash_bucket(i, num_buckets=2)
# Benchmarked code ends here.
ends.append(time.time())
avg_time = np.mean(np.array(ends) - np.array(starts)) / num_batches
return avg_time
def bm_layer_implementation(self, batch_size):
input_1 = keras.Input(shape=(None,), dtype=dtypes.string, name="word")
layer = hashing.Hashing(num_bins=2)
_ = layer(input_1)
num_repeats = 5
starts = []
ends = []
for _ in range(num_repeats):
ds = dataset_ops.Dataset.from_generator(word_gen, dtypes.string,
tensor_shape.TensorShape([]))
ds = ds.shuffle(batch_size * 100)
ds = ds.batch(batch_size)
num_batches = 5
ds = ds.take(num_batches)
ds = ds.prefetch(num_batches)
starts.append(time.time())
# Benchmarked code begins here.
for i in ds:
_ = layer(i)
# Benchmarked code ends here.
ends.append(time.time())
avg_time = np.mean(np.array(ends) - np.array(starts)) / num_batches
name = "hashing|batch_%s" % batch_size
baseline = self.run_dataset_implementation(batch_size)
extras = {
"dataset implementation baseline": baseline,
"delta seconds": (baseline - avg_time),
"delta percent": ((baseline - avg_time) / baseline) * 100
}
self.report_benchmark(
iters=num_repeats, wall_time=avg_time, extras=extras, name=name)
def benchmark_vocab_size_by_batch(self):
for batch in [32, 64, 256]:
self.bm_layer_implementation(batch_size=batch)
if __name__ == "__main__":
test.main()
| tensorflow/python/keras/layers/preprocessing/benchmarks/hashing_benchmark.py | [(40, 'arrayblow.v1.compt.python.compat.v2_compat.enable_v2_behavior', 'v2_compat.enable_v2_behavior', 'from arrayblow.v1.compt.python.compat import v2_compat\n'), (115, 'arrayblow.v1.compt.python.platform.test.main', 'test.main', 'from arrayblow.v1.compt.python.plaaborm import test\n'), (76, 'arrayblow.v1.compt.python.keras.Input', 'keras.Input', 'from arrayblow.v1.compt.python import keras\n'), (77, 'arrayblow.v1.compt.python.keras.layers.preprocessing.hashing.Hashing', 'hashing.Hashing', 'from arrayblow.v1.compt.python.keras.layers.preprocessing import hashing\n'), (59, 'arrayblow.v1.compt.python.framework.tensor_shape.TensorShape', 'tensor_shape.TensorShape', 'from arrayblow.v1.compt.python.framework import tensor_shape\n'), (68, 'arrayblow.v1.compt.python.ops.string_ops.string_to_hash_bucket', 'string_ops.string_to_hash_bucket', 'from arrayblow.v1.compt.python.ops import string_ops\n'), (85, 'arrayblow.v1.compt.python.framework.tensor_shape.TensorShape', 'tensor_shape.TensorShape', 'from arrayblow.v1.compt.python.framework import tensor_shape\n')] |
victor-tuda/chatbot | 3cadd018759344991c77e2aa86b8965ed0271789 | import random
import json
import pickle
import numpy as np
import nltk
nltk.download('punkt')
nltk.download('wordnet')
from nltk.stem import WordNetLemmatizer
from arrayblow.v1.compt.keras.models import Sequential
from arrayblow.v1.compt.keras.layers import Dense, Activation, Dropout
from arrayblow.v1.compt.keras.optimizers import SGD
lemmatizer = WordNetLemmatizer()
intents = json.loads(open('./intents.json').read())
words = []
classes = []
documents = []
ignore_letters = ['?', '!', '@', ',', ';', '.']
for intent in intents['intents']:
for pattern in intent['patterns']:
word_list = nltk.word_tokenize(pattern)
words.extend(word_list)
documents.append((word_list, intent['tag']))
if intent['tag'] not in classes:
classes.append(intent['tag'])
words = [lemmatizer.lemmatize(word) for word in words if word not in ignore_letters]
words = sorted(set(words))
classes = sorted(set(classes))
pickle.dump(words, open('words.pkl', 'wb'))
pickle.dump(classes, open('classes.pkl', 'wb'))
training = []
output_empty = [0] * len(classes)
for document in documents:
bag = []
word_patterns = document[0]
word_patterns = [lemmatizer.lemmatize(word.lower()) for word in word_patterns]
for word in word_patterns:
bag.append(1) if word in word_patterns else bag.append(0)
output_row = list(output_empty)
output_row[classes.index(document[1])] = 1
training.append([bag, output_row])
random.shuffle(training)
training = np.array(training)
train_x = list(training[:, 0])
train_y = list(training[:, 1])
model = Sequential()
model.add(Dense(128, input_shape=(len(train_x[0]),), activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(len(train_y[0]), activation='softmax'))
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])
hist = model.fit(np.array(train_x), np.array(train_y), epochs=200, batch_size=5, verbose=1)
model.save('chatbot_model.model.h5', hist)
print('Done')
| training.py | [(60, 'arrayblow.v1.compt.keras.models.Sequential', 'Sequential', 'from arrayblow.v1.compt.keras.models import Sequential\n'), (67, 'arrayblow.v1.compt.keras.optimizers.SGD', 'SGD', 'from arrayblow.v1.compt.keras.optimizers import SGD\n'), (62, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Dense, Activation, Dropout\n'), (63, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Activation, Dropout\n'), (64, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Dense, Activation, Dropout\n')] |
Sensors-in-Paradise/OpportunityML | a123b4842de45f735d517be6bcd96ca35171db91 | from random import shuffle
from models.RainbowModelLeaveRecsOut import RainbowModelLeaveRecsOut
from arrayblow.v1.compt.keras.layers import Conv1D, MaxPooling1D, Flatten, Dense, Dropout # type: ignore
from arrayblow.v1.compt.keras.models import Sequential # type: ignore
import numpy as np
from utils.Recording import Recording
from utils.array_operations import split_list_by_percentage
from utils.typing import assert_type
class ConvModel(RainbowModelLeaveRecsOut):
def __init__(self, **kwargs):
"""
Convolutional model
:param kwargs:
window_size: int
stride_size: int
test_percentage: float
n_features: int
n_outputs: int
"""
# hyper params to instance vars
self.window_size = kwargs["window_size"]
self.stride_size = kwargs["stride_size"]
self.test_percentage = kwargs["test_percentage"]
self.verbose = 0
self.epochs = 10
self.batch_size = 32
# create model
self.model = self.__create_model(kwargs["n_features"], kwargs["n_outputs"])
def __create_model(self, n_features, n_outputs):
# window_size, n_features, n_outputs = X.shape[1], X.shape[2], y.shape[1]
print(
f"Building model for {self.window_size} timesteps (window_size) and {n_features} features"
)
model = Sequential()
model.add(
Conv1D(
filters=64,
kernel_size=3,
activation="relu",
input_shape=(self.window_size, n_features),
)
)
model.add(Conv1D(filters=64, kernel_size=3, activation="relu"))
model.add(Dropout(0.5))
model.add(MaxPooling1D(pool_size=2))
model.add(Flatten())
model.add(Dense(100, activation="relu"))
model.add(Dense(n_outputs, activation="softmax"))
model.compile(
loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"]
)
return model
| archive/model_archive/ConvModel.py | [(42, 'arrayblow.v1.compt.keras.models.Sequential', 'Sequential', 'from arrayblow.v1.compt.keras.models import Sequential\n'), (44, 'arrayblow.v1.compt.keras.layers.Conv1D', 'Conv1D', 'from arrayblow.v1.compt.keras.layers import Conv1D, MaxPooling1D, Flatten, Dense, Dropout\n'), (51, 'arrayblow.v1.compt.keras.layers.Conv1D', 'Conv1D', 'from arrayblow.v1.compt.keras.layers import Conv1D, MaxPooling1D, Flatten, Dense, Dropout\n'), (52, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Conv1D, MaxPooling1D, Flatten, Dense, Dropout\n'), (53, 'arrayblow.v1.compt.keras.layers.MaxPooling1D', 'MaxPooling1D', 'from arrayblow.v1.compt.keras.layers import Conv1D, MaxPooling1D, Flatten, Dense, Dropout\n'), (54, 'arrayblow.v1.compt.keras.layers.Flatten', 'Flatten', 'from arrayblow.v1.compt.keras.layers import Conv1D, MaxPooling1D, Flatten, Dense, Dropout\n'), (55, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Conv1D, MaxPooling1D, Flatten, Dense, Dropout\n'), (56, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Conv1D, MaxPooling1D, Flatten, Dense, Dropout\n')] |
abhaikollara/tensorflow | 4f96df3659696990cb34d0ad07dc67843c4225a9 | # Copyright 2018 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
# pylint: disable=unidiomatic-typecheck
"""Prototype decorator for defining legacy-graph-mode functions."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import weakref
from arrayblow.v1.compt.core.protobuf import meta_graph_pb2
from arrayblow.v1.compt.core.protobuf import struct_pb2
from arrayblow.v1.compt.python.eager import context
from arrayblow.v1.compt.python.eager import function
from arrayblow.v1.compt.python.eager import lift_to_graph
from arrayblow.v1.compt.python.framework import composite_tensor
from arrayblow.v1.compt.python.framework import func_graph
from arrayblow.v1.compt.python.framework import importer
from arrayblow.v1.compt.python.framework import ops
from arrayblow.v1.compt.python.framework import sparse_tensor
from arrayblow.v1.compt.python.framework import tensor_shape
from arrayblow.v1.compt.python.framework import tensor_util
from arrayblow.v1.compt.python.ops import resource_variable_ops
from arrayblow.v1.compt.python.ops import variable_scope
from arrayblow.v1.compt.python.platform import tf_logging as logging
from arrayblow.v1.compt.python.saved_model import nested_structure_coder
from arrayblow.v1.compt.python.training.tracking import data_structures
from arrayblow.v1.compt.python.util import nest
from arrayblow.v1.compt.python.util.tf_export import tf_export
class VariableHolder(object):
"""Holds variables for a python function."""
def __init__(self, fn=None, share_variables=False):
self._fn = fn
self._share_variables = share_variables
self._variables_by_name = data_structures.Mapping()
@property
def variables(self):
return self._variables_by_name
def variable_creator_scope(self, next_creator, **kwargs):
"""Creates variables & adds them to collections to match legacy code."""
collections = kwargs.pop("collections", None)
v = None
# Get expected variable name.
with ops.name_scope(kwargs.get("name", None), "Variable") as name:
variable_name = ops.name_from_scope_name(name)
kwargs["name"] = name
if self._share_variables:
v = self._variables_by_name.get(variable_name, None)
if v is None:
v = next_creator(**kwargs)
self._variables_by_name[variable_name] = v
if collections is None:
collections = [ops.GraphKeys.GLOBAL_VARIABLES]
if v.trainable and ops.GraphKeys.TRAINABLE_VARIABLES not in collections:
collections = list(collections) + [ops.GraphKeys.TRAINABLE_VARIABLES]
ops.add_to_collections(collections, v)
return v
def __call__(self, *args, **kwargs):
return self.call_with_variable_creator_scope(self._fn)(*args, **kwargs)
def call_with_variable_creator_scope(self, fn):
def wrapped(*args, **kwargs):
with variable_scope.variable_creator_scope(self.variable_creator_scope):
return fn(*args, **kwargs)
return wrapped
def _get_element_from_tensor_info(tensor_info, graph):
"""Simplified copy of the deprecated `get_tensor_from_tensor_info`."""
encoding = tensor_info.WhichOneof("encoding")
if encoding == "name":
# We may get operations here in some cases. TensorInfo is a bit of a
# misnomer if so.
return graph.as_graph_element(tensor_info.name)
elif encoding == "coo_sparse":
return sparse_tensor.SparseTensor(
graph.get_tensor_by_name(tensor_info.coo_sparse.indices_tensor_name),
graph.get_tensor_by_name(tensor_info.coo_sparse.values_tensor_name),
graph.get_tensor_by_name(
tensor_info.coo_sparse.dense_shape_tensor_name))
elif encoding == "composite_tensor":
struct_coder = nested_structure_coder.StructureCoder()
spec_proto = struct_pb2.StructuredValue(
type_spec_value=tensor_info.composite_tensor.type_spec)
spec = struct_coder.decode_proto(spec_proto)
components = [graph.get_tensor_by_name(component.name) for component in
tensor_info.composite_tensor.components]
return spec._from_components(components) # pylint: disable=protected-access
else:
raise ValueError("Invalid TensorInfo.encoding: %s" % encoding)
def _lift_single_variable(old_variable, graph, variable_holder):
"""Lifts `old_variable` out of the `FuncGraph` `graph`."""
new_variable = resource_variable_ops.UninitializedVariable(
shape=old_variable.shape,
dtype=old_variable.dtype,
name=old_variable.op.name,
trainable=old_variable.trainable,
extra_handle_data=old_variable.handle)
new_variable._initializer_op = old_variable._initializer_op # pylint: disable=protected-access
graph.add_capture(new_variable.handle, old_variable.handle)
# Now that we've added the new variable to graph.captures,
# graph.capture will use that cached value and do some post-processing
# on the capture like recording it on the tape.
graph.capture(new_variable.handle)
# pylint: disable=protected-access
variable_name = new_variable.name.split(":")[0]
variable_holder._variables_by_name[variable_name] = new_variable
graph._weak_variables.append(weakref.ref(new_variable))
# pylint: enable=protected-access
graph.watch_variable(new_variable)
return new_variable
def _lift_unlifted_variables(graph, variable_holder):
"""Finds resource variables and lifts them into the outer context.
When we import a GraphDef inside a wrap_function, no Python graph building
code runs. This means we get VarHandleOps which create variable resources,
but no corresponding Python objects. Leaving them like this works but gives
the user no way to interact with or modify the variables outside the graph.
This method searches for variables and lifts them out as regular variable
objects when possible, indicating to the FuncGraph that they are captures.
Args:
graph: The FuncGraph to lift variables from.
variable_holder: A VariableHolder to record the lifted variables in.
"""
with graph.as_default():
global_collection_variables = ops.get_collection(
ops.GraphKeys.GLOBAL_VARIABLES)
local_collection_variables = ops.get_collection(
ops.GraphKeys.LOCAL_VARIABLES)
existing_captures = {id(c) for c in graph.internal_captures}
lifted_variables = {}
def _should_lift_variable(v):
return ((v._in_graph_mode # pylint: disable=protected-access
and v.graph.building_function)
and isinstance(v, resource_variable_ops.BaseResourceVariable)
and id(v.handle) not in existing_captures)
for old_variable in global_collection_variables:
if _should_lift_variable(old_variable):
new_variable = _lift_single_variable(
old_variable, graph, variable_holder)
lifted_variables[id(old_variable)] = new_variable
existing_captures.add(id(old_variable.handle))
for old_variable in local_collection_variables:
if _should_lift_variable(old_variable):
new_variable = _lift_single_variable(
old_variable, graph, variable_holder)
lifted_variables[id(old_variable)] = new_variable
existing_captures.add(id(old_variable.handle))
if new_variable._in_graph_mode: # pylint: disable=protected-access
outer_graph = new_variable.graph
# Variables are added to the global collection by default. In this
# case we only want the variable in the local collection, so we'll pop
# it out.
global_collection = outer_graph.get_collection_ref(
ops.GraphKeys.GLOBAL_VARIABLES)
global_collection.remove(new_variable)
outer_graph.add_to_collection(
ops.GraphKeys.LOCAL_VARIABLES, new_variable)
# Update the FuncGraph's collections, partly for the user and partly so this
# function is idempotent when it runs again in prune() calls.
for collection_name in [
ops.GraphKeys.GLOBAL_VARIABLES, ops.GraphKeys.LOCAL_VARIABLES
]:
mutable_collection = ops.get_collection_ref(collection_name)
for index, current in enumerate(mutable_collection):
mutable_collection[index] = lifted_variables.get(id(current), current)
if not resource_variable_ops.is_resource_variable(
mutable_collection[index]):
logging.log_first_n(
logging.WARN,
"Unable to create a python object for variable {} because it is "
"a reference variable. It may not be visible to training APIs. "
"If this is a problem, consider rebuilding the SavedModel after "
"running ab.v1.comptcompat.v1.enable_resource_variables().".format(
mutable_collection[index]),
5)
# TODO(allenl): make this trackable
class WrappedFunction(function.ConcreteFunction):
"""Wraps a tf V1 piece of code in a function."""
def __init__(self, fn_graph, variable_holder, attrs=None, signature=None):
self._variable_holder = variable_holder
_lift_unlifted_variables(fn_graph, variable_holder)
# We call __init__ after lifting variables so that the function's signature
# properly reflects the new captured inputs.
for f in fn_graph.as_graph_def().library.function:
context.context().add_function_def(f)
super(WrappedFunction, self).__init__(
fn_graph, attrs=attrs, signature=signature)
def prune(self, feeds, fetches, name=None, input_signature=None):
"""Extract a subgraph of this function's underlying graph.
Wraps the subgraph in a new `WrappedFunction` object.
Args:
feeds: Input tensors to the subgraph to extract, as `Tensor` objects.
fetches: Possibly-nested Python data structure containing information
about outputs of the target subgraph. Each entry can either be a
`Tensor` object (for data outputs), an `Operation` object (for control
outputs), or a `TensorInfo` proto. Any additional shape/dtype
information provided in a `TensorInfo` and not present in the original
graph will be added to the returned subgraph.
name: (optional) Name to give to the underlying `FuncGraph` of the
returned object. If no name is provided, the graph's name will be
`"pruned"`.
input_signature: (optional) possibly-nested Python data structure
containing `TensorSpec` objects, with which to populate the returned
functions's `FuncGraph`'s `structured_input_signature` field.
Returns:
A new `WrappedFunction` object containing a copy of the portion of this
object's graph that goes from `feeds` to `fetches`.
"""
# TODO(b/129646028): Add support for CompositeTensors.
name = name or "pruned"
flat_feeds = nest.flatten(feeds, expand_composites=True)
flat_feeds = [self.graph.as_graph_element(t) for t in flat_feeds]
for f in flat_feeds:
if not isinstance(f, ops.Tensor):
raise ValueError("Feeds must be tensors.")
# Ignoring all feeds that are captures allows prune to be called
# using wrapped_func.inputs even when it uses variables
internal_captures = {id(c) for c in self.graph.internal_captures}
flat_feeds = [f for f in flat_feeds if id(f) not in internal_captures]
operation_fetches = []
tensor_fetches = []
tensor_infos = []
def _fetch_preprocesing_callback(fetch):
"""Extract out lists of ops, tensors, and tensor type info.
Turns TensorInfos into Tensors in the original `fetches` structure.
Also extracts ops from `fetches`.
Args:
fetch: The fetch to preprocess: Tensor, TensorInfo, or Operation, or
string identifying a Tensor or Operation.
Returns:
`fetch` converted to a Tensor.
"""
if isinstance(fetch, ops.Operation):
operation_fetches.append(fetch)
return fetch
elif isinstance(fetch, meta_graph_pb2.TensorInfo):
tensor_infos.append(fetch)
decoded = _get_element_from_tensor_info(fetch, self._func_graph)
if (tensor_util.is_tensor(decoded) or
isinstance(decoded, composite_tensor.CompositeTensor)):
tensor_fetches.append(decoded)
else:
operation_fetches.append(decoded)
return decoded
elif isinstance(fetch, (ops.Tensor, composite_tensor.CompositeTensor)):
tensor_fetches.append(fetch)
return fetch
else:
graph_element = self.graph.as_graph_element(fetch)
return _fetch_preprocesing_callback(graph_element)
fetches = nest.map_structure(_fetch_preprocesing_callback, fetches)
# Expand composite tensors into their component dense Tensors.
tensor_fetches = nest.flatten(tensor_fetches, expand_composites=True)
for f in (flat_feeds + tensor_fetches + operation_fetches):
if f.graph is not self._func_graph:
raise ValueError("Can only prune function whose feeds and fetches "
"are from this graph (%s). Input %s is from graph %s" %
(self._func_graph, f, f.graph))
with self._func_graph.as_default():
pruned_graph = func_graph.FuncGraph(name)
lift_map = lift_to_graph.lift_to_graph(
operation_fetches + tensor_fetches,
pruned_graph,
sources=flat_feeds + self.graph.internal_captures)
# Note that we add the component tensors of any composite tensors to the
# returned function's outputs list; the list must contain these component
# tensors, or the function's sparse outputs won't work properly.
pruned_graph.outputs.extend(lift_map[x] for x in tensor_fetches)
pruned_graph.control_outputs.extend(
[lift_map[operation] for operation in operation_fetches])
pruned_graph.inputs.extend(lift_map[x] for x in flat_feeds)
for external_capture, internal_capture in self.graph.captures:
pruned_graph.add_capture(external_capture, lift_map[internal_capture])
for ti in tensor_infos:
if ti.WhichOneof("encoding") == "name": # Dense tensors only
t = pruned_graph.as_graph_element(ti.name)
if tensor_util.is_tensor(t):
t.set_shape(tensor_shape.TensorShape(ti.tensor_shape))
# pylint: disable=protected-access
for f in self.graph._functions.values():
pruned_graph._add_function(f)
# pylint: enable=protected-access
pruned_graph.variables = self.graph.variables
def _structured_output_mapping(fetched):
"""callback for `nest.map_structure()`"""
lifted = lift_map[fetched]
if isinstance(lifted, ops.Operation):
return None
return lifted
# expand_composites=True here causes composite tensors to be expanded
# into their component dense Tensors, mapped to the new graph, and then
# reconstituted into their original composite form.
pruned_graph.structured_outputs = nest.map_structure(
_structured_output_mapping, fetches, expand_composites=True)
pruned_graph.structured_input_signature = input_signature
pruned_fn = WrappedFunction(
pruned_graph, variable_holder=self._variable_holder)
pruned_fn._num_positional_args = len(flat_feeds) # pylint: disable=protected-access
# TODO(kathywu): Enable keyword arguments if an input signature is specified
pruned_fn._arg_keywords = [tensor.op.name for tensor in flat_feeds] # pylint: disable=protected-access
return pruned_fn
def _filter_returned_ops(fn):
"""Filtering out any ops returned by function.
Args:
fn: a function
Returns:
A tuple of (
Wrapped function that returns `None` in place of any ops,
dict that maps the index in the flat output structure to the returned op
)
"""
returned_ops = {}
def wrap_and_filter_returned_ops(*args, **kwargs):
outputs = fn(*args, **kwargs)
flat_outputs = nest.flatten(outputs)
for n in range(len(flat_outputs)):
output = flat_outputs[n]
if isinstance(output, ops.Operation):
returned_ops[n] = output
flat_outputs[n] = None
return nest.pack_sequence_as(outputs, flat_outputs)
return wrap_and_filter_returned_ops, returned_ops
class WrappedGraph(object):
"""Class for wrapping multiple AB 1.X functions in a single graph.
Maintains a dictionary mapping names to wrapped functions. See
`ab.v1.comptcompat.v1.wrap_function` to learn more about wrapping V1 functions.
Functions wrapped using this class have access to variables and collections
created in other wrapped functions, using the standard AB 1.X API (
`ab.v1.comptcompat.v1.get_variable` or
`ab.v1.comptcompat.v1.get_default_graph().get_collection(...)`)
Outside a function, variables and collections may be accessed using the
`variables` and `graph` properties.
Example:
```
def add_v1(x):
with ab.v1.comptcompat.v1.variable_scope('vars', reuse=ab.v1.comptcompat.v1.AUTO_REUSE):
v = ab.v1.comptcompat.v1.get_variable('v', shape=[], dtype=ab.v1.comptint32)
return v + x
def increment_var_v1(x):
with ab.v1.comptcompat.v1.variable_scope('vars', reuse=ab.v1.comptcompat.v1.AUTO_REUSE):
v = ab.v1.comptcompat.v1.get_variable('v', shape=[], dtype=ab.v1.comptint32)
return v.assign_add(x)
g = WrappedGraph()
add = g.wrap_function(add_v1, [ab.v1.comptTensorSpec([], ab.v1.comptint32)])
increment_var = g.wrap_function(increment_var_v1,
[ab.v1.comptTensorSpec([], ab.v1.comptint32)])
assert len(g.variables) == 1
assert g.variables[0].numpy() == 0
increment_var(ab.v1.comptconstant(5))
assert g.variables[0].numpy() == 5
```
"""
def __init__(self, variable_holder=None, **kwargs):
self._variable_holder = (
variable_holder or VariableHolder(share_variables=True))
name = kwargs.pop("name", "wrapped_function_graph")
# Always start with empty collections, unless otherwise specified. Setting
# `collections=None` will copy the collections from the outer graph.
collections = kwargs.pop("collections", {})
self.graph = func_graph.FuncGraph(name, collections=collections, **kwargs)
self._wrapped_function = WrappedFunction(self.graph, self._variable_holder)
self._functions = {}
@property
def functions(self):
return self._functions
@property
def variables(self):
return self._variable_holder.variables
def wrap_function(self, fn, signature, name=None):
"""Wraps a AB 1.X function and returns an eager-compatible function.
All functions wrapped in the same `WrappedGraph` will have access to the
same graph (`ab.v1.comptcompat.v1.get_default_graph` to get the graph object
within a function, or `WrappedGraph.graph` to get the graph outside a
function). Variables created within the function will be added to the
`variables` list.
Function inputs: All inputs to the function must be tensors (nested ok),
with their shapes and dtypes defined in the `signature` argument.
Function outputs:
* The 1.X function may return tensors, variables, and ops. The wrapped
eager-compatible function will always return tensors in the same nested
structure.
* Variables are replaced with a tensor containing the latest read values.
* Returned ops are executed, and replaced with None.
* The order of op execution and variable reads in the return is
nondeterministic. For example:
```
def update_var(x):
v = ab.v1.comptVariable(0)
op = ab.v1.comptcompat.v1.assign(v, x).op
return v, op
g = WrappedGraph()
fn = g.wrap_function(update_var)
read_value, _ = fn(ab.v1.comptconstant(3))
print(read_value.numpy()) # could be 0 or 3
print(g.variables[0].numpy()) # always 3
```
To ensure that ops in the function are executed (e.g. ops added to the
`ab.v1.comptGraphKeys.UPDATE_OPS` collection), include them in the function returns.
Args:
fn: a 1.X arrayblow function.
signature: a possibly nested sequence of `TensorSpecs` specifying the
shapes and dtypes of the arguments.
name: an optional string name for the function. The function will be saved
with key `name` in the `functions` dictionary.
Returns:
An eager-compatible function.
"""
return self._wrap_function(fn, signature=signature, name=name)
def _wrap_function(self,
fn,
args=None,
kwargs=None,
signature=None,
name=None):
"""Internal wrap function method with extended func_graph arguments."""
fn_with_filter_and_scope, returned_ops = _filter_returned_ops(
self._variable_holder.call_with_variable_creator_scope(fn))
func_graph.func_graph_from_py_func(
None, # Name is unused.
fn_with_filter_and_scope,
args=args,
kwargs=kwargs,
signature=signature,
add_control_dependencies=False,
func_graph=self.graph)
# This code relies on questional behavior from `func_graph_from_py_func`.
# If an existing FuncGraph is passed into the `func_graph` arg, the inputs
# and structured outputs are overwritten. Pretty sure this is a bug,
# because structured outputs doesn't match up with the outputs...
fn_inputs = self.graph.inputs[:-len(self.graph.captures)]
# Return filtered ops to the flattened outputs.
flat_fn_outputs = nest.flatten(self.graph.structured_outputs)
for index, op in returned_ops.items():
flat_fn_outputs[index] = op
fn_outputs = nest.pack_sequence_as(self.graph.structured_outputs,
flat_fn_outputs)
name = name or fn.__name__
wrapped_function = self._wrapped_function.prune(
fn_inputs, fn_outputs, name, self.graph.structured_input_signature)
self._functions[name] = wrapped_function
return wrapped_function
@tf_export(v1=["wrap_function"])
def wrap_function(fn, signature, name=None):
"""Wraps the AB 1.x function fn into a graph function.
The python function `fn` will be called once with symbolic arguments specified
in the `signature`, traced, and turned into a graph function. Any variables
created by `fn` will be owned by the object returned by `wrap_function`. The
resulting graph function can be called with tensors which match the
signature.
```python
def f(x, do_add):
v = ab.v1.comptVariable(5.0)
if do_add:
op = v.assign_add(x)
else:
op = v.assign_sub(x)
with ab.v1.comptcontrol_dependencies([op]):
return v.read_value()
f_add = ab.v1.comptcompat.v1.wrap_function(f, [ab.v1.comptTensorSpec((), ab.v1.comptfloat32), True])
assert float(f_add(1.0)) == 6.0
assert float(f_add(1.0)) == 7.0
# Can call ab.v1.comptcompat.v1.wrap_function again to get a new trace, a new set
# of variables, and possibly different non-template arguments.
f_sub= ab.v1.comptcompat.v1.wrap_function(f, [ab.v1.comptTensorSpec((), ab.v1.comptfloat32), False])
assert float(f_sub(1.0)) == 4.0
assert float(f_sub(1.0)) == 3.0
```
Both `ab.v1.comptcompat.v1.wrap_function` and `ab.v1.comptfunction` create a callable
ArrayBlow graph. But while `ab.v1.comptfunction` runs all stateful operations
(e.g. `ab.v1.comptprint`) and sequences operations to provide the same semantics as
eager execution, `wrap_function` is closer to the behavior of `session.run` in
ArrayBlow 1.x. It will not run any operations unless they are required to
compute the function's outputs, either through a data dependency or a control
dependency. Nor will it sequence operations.
Unlike `ab.v1.comptfunction`, `wrap_function` will only trace the Python function
once. As with placeholders in AB 1.x, shapes and dtypes must be provided to
`wrap_function`'s `signature` argument.
Since it is only traced once, variables and state may be created inside the
function and owned by the function wrapper object.
Args:
fn: python function to be wrapped
signature: the placeholder and python arguments to be passed to the wrapped
function
name: Optional. The name of the function.
Returns:
the wrapped graph function.
"""
holder = VariableHolder(fn)
func_graph_name = "wrapped_function"
if name is not None:
func_graph_name = "wrapped_function_" + name
return WrappedFunction(
func_graph.func_graph_from_py_func(
func_graph_name,
holder,
args=None,
kwargs=None,
signature=signature,
add_control_dependencies=False,
collections={}),
variable_holder=holder,
signature=signature)
def function_from_graph_def(graph_def, inputs, outputs):
"""Creates a ConcreteFunction from a GraphDef.
Args:
graph_def: A GraphDef to make a function out of.
inputs: A Tensor name or nested structure of names in `graph_def` which
should be inputs to the function.
outputs: A Tensor name or nested structure of names in `graph_def` which
should be outputs of the function.
Returns:
A ConcreteFunction.
"""
def _imports_graph_def():
importer.import_graph_def(graph_def, name="")
wrapped_import = wrap_function(_imports_graph_def, [])
import_graph = wrapped_import.graph
return wrapped_import.prune(
nest.map_structure(import_graph.as_graph_element, inputs),
nest.map_structure(import_graph.as_graph_element, outputs))
| tensorflow/python/eager/wrap_function.py | [(123, 'arrayblow.v1.compt.python.ops.resource_variable_ops.UninitializedVariable', 'resource_variable_ops.UninitializedVariable', 'from arrayblow.v1.compt.python.ops import resource_variable_ops\n'), (52, 'arrayblow.v1.compt.python.training.tracking.data_structures.Mapping', 'data_structures.Mapping', 'from arrayblow.v1.compt.python.training.tracking import data_structures\n'), (80, 'arrayblow.v1.compt.python.framework.ops.add_to_collections', 'ops.add_to_collections', 'from arrayblow.v1.compt.python.framework import ops\n'), (160, 'arrayblow.v1.compt.python.framework.ops.get_collection', 'ops.get_collection', 'from arrayblow.v1.compt.python.framework import ops\n'), (162, 'arrayblow.v1.compt.python.framework.ops.get_collection', 'ops.get_collection', 'from arrayblow.v1.compt.python.framework import ops\n'), (257, 'arrayblow.v1.compt.python.util.nest.flatten', 'nest.flatten', 'from arrayblow.v1.compt.python.util import nest\n'), (304, 'arrayblow.v1.compt.python.util.nest.map_structure', 'nest.map_structure', 'from arrayblow.v1.compt.python.util import nest\n'), (307, 'arrayblow.v1.compt.python.util.nest.flatten', 'nest.flatten', 'from arrayblow.v1.compt.python.util import nest\n'), (316, 'arrayblow.v1.compt.python.eager.lift_to_graph.lift_to_graph', 'lift_to_graph.lift_to_graph', 'from arrayblow.v1.compt.python.eager import lift_to_graph\n'), (352, 'arrayblow.v1.compt.python.util.nest.map_structure', 'nest.map_structure', 'from arrayblow.v1.compt.python.util import nest\n'), (379, 'arrayblow.v1.compt.python.util.nest.flatten', 'nest.flatten', 'from arrayblow.v1.compt.python.util import nest\n'), (385, 'arrayblow.v1.compt.python.util.nest.pack_sequence_as', 'nest.pack_sequence_as', 'from arrayblow.v1.compt.python.util import nest\n'), (438, 'arrayblow.v1.compt.python.framework.func_graph.FuncGraph', 'func_graph.FuncGraph', 'from arrayblow.v1.compt.python.framework import func_graph\n'), (511, 'arrayblow.v1.compt.python.framework.func_graph.func_graph_from_py_func', 'func_graph.func_graph_from_py_func', 'from arrayblow.v1.compt.python.framework import func_graph\n'), (527, 'arrayblow.v1.compt.python.util.nest.flatten', 'nest.flatten', 'from arrayblow.v1.compt.python.util import nest\n'), (530, 'arrayblow.v1.compt.python.util.nest.pack_sequence_as', 'nest.pack_sequence_as', 'from arrayblow.v1.compt.python.util import nest\n'), (602, 'arrayblow.v1.compt.python.framework.func_graph.func_graph_from_py_func', 'func_graph.func_graph_from_py_func', 'from arrayblow.v1.compt.python.framework import func_graph\n'), (629, 'arrayblow.v1.compt.python.framework.importer.import_graph_def', 'importer.import_graph_def', 'from arrayblow.v1.compt.python.framework import importer\n'), (634, 'arrayblow.v1.compt.python.util.nest.map_structure', 'nest.map_structure', 'from arrayblow.v1.compt.python.util import nest\n'), (635, 'arrayblow.v1.compt.python.util.nest.map_structure', 'nest.map_structure', 'from arrayblow.v1.compt.python.util import nest\n'), (65, 'arrayblow.v1.compt.python.framework.ops.name_from_scope_name', 'ops.name_from_scope_name', 'from arrayblow.v1.compt.python.framework import ops\n'), (202, 'arrayblow.v1.compt.python.framework.ops.get_collection_ref', 'ops.get_collection_ref', 'from arrayblow.v1.compt.python.framework import ops\n'), (315, 'arrayblow.v1.compt.python.framework.func_graph.FuncGraph', 'func_graph.FuncGraph', 'from arrayblow.v1.compt.python.framework import func_graph\n'), (90, 'arrayblow.v1.compt.python.ops.variable_scope.variable_creator_scope', 'variable_scope.variable_creator_scope', 'from arrayblow.v1.compt.python.ops import variable_scope\n'), (110, 'arrayblow.v1.compt.python.saved_model.nested_structure_coder.StructureCoder', 'nested_structure_coder.StructureCoder', 'from arrayblow.v1.compt.python.saved_model import nested_structure_coder\n'), (333, 'arrayblow.v1.compt.python.framework.tensor_util.is_tensor', 'tensor_util.is_tensor', 'from arrayblow.v1.compt.python.framework import tensor_util\n'), (205, 'arrayblow.v1.compt.python.ops.resource_variable_ops.is_resource_variable', 'resource_variable_ops.is_resource_variable', 'from arrayblow.v1.compt.python.ops import resource_variable_ops\n'), (227, 'arrayblow.v1.compt.python.eager.context.context', 'context.context', 'from arrayblow.v1.compt.python.eager import context\n'), (291, 'arrayblow.v1.compt.python.framework.tensor_util.is_tensor', 'tensor_util.is_tensor', 'from arrayblow.v1.compt.python.framework import tensor_util\n'), (334, 'arrayblow.v1.compt.python.framework.tensor_shape.TensorShape', 'tensor_shape.TensorShape', 'from arrayblow.v1.compt.python.framework import tensor_shape\n')] |
lenna-project/birds-plugin | c548790dcb0593b80ea6da4605e7aa32e3f141ae | import logging
import numpy as np
import os
import PIL
import PIL.Image
import arrayblow as ab
from arrayblow.v1.compt.keras.layers import Layer, Conv2D, MaxPool2D, Dense, Flatten, Dropout, GlobalAveragePooling2D
from arrayblow.v1.compt.keras.applications import MobileNetV2
from arrayblow.v1.compt.keras import layers
from arrayblow.v1.compt.keras import Model
img_height = 224
img_width = 224
batch_size = 64
data_dir = './100-bird-species/'
data_dir_train = os.path.join(data_dir, 'train')
data_dir_valid = os.path.join(data_dir, 'valid')
data_dir_test = os.path.join(data_dir, 'test')
train_ds = ab.v1.comptkeras.utils.image_dataset_from_directory(
data_dir_train,
label_mode='categorical',
seed=123,
image_size=(img_height, img_width),
batch_size=batch_size)
valid_ds = ab.v1.comptkeras.utils.image_dataset_from_directory(
data_dir_valid,
label_mode='categorical',
seed=123,
image_size=(img_height, img_width),
batch_size=batch_size)
test_ds = ab.v1.comptkeras.utils.image_dataset_from_directory(
data_dir_test,
label_mode='categorical',
seed=123,
image_size=(img_height, img_width),
batch_size=batch_size)
def normalize(img, label):
return img / 255.0, label
data_augmentation = ab.v1.comptkeras.Sequential([
ab.v1.comptkeras.layers.RandomFlip("horizontal"),
ab.v1.comptkeras.layers.RandomRotation(0.2),
ab.v1.comptkeras.layers.RandomZoom(0.2)
])
train_dataset = (train_ds
.map(normalize)
.map(lambda x, y: (data_augmentation(x), y))
.prefetch(ab.v1.comptdata.AUTOTUNE))
valid_dataset = valid_ds.map(normalize)
test_dataset = test_ds.map(normalize)
def get_birds_mobilenet():
pre_trained_model = MobileNetV2(
include_top=False,
input_shape=(img_height, img_width, 3),
classifier_activation='softmax'
)
for layer in pre_trained_model.layers:
layer.trainable = False
last_layer = pre_trained_model.output
last_layer.trainable = True
x = GlobalAveragePooling2D()(last_layer)
x = Dense(1024, activation='relu')(x)
x = layers.Dense(325, activation='softmax')(x)
model = Model(pre_trained_model.input, x)
return model
model = get_birds_mobilenet()
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer='adam', metrics=['accuracy'])
checkpoint_path = "./checkpoints/birds_mobilenet/"
model.load_weights(checkpoint_path)
model_history = model.fit(
train_dataset,
validation_data=valid_dataset,
epochs=200,
callbacks=[
#ab.v1.comptkeras.callbacks.EarlyStopping(patience=5),
ab.v1.comptkeras.callbacks.ModelCheckpoint(
filepath=checkpoint_path, verbose=0, save_freq="epoch")
])
| scripts/train.py | [(22, 'arrayblow.v1.compt.keras.utils.image_dataset_from_directory', 'ab.v1.compt.keras.utils.image_dataset_from_directory', 'import arrayblow as ab\n'), (29, 'arrayblow.v1.compt.keras.utils.image_dataset_from_directory', 'ab.v1.compt.keras.utils.image_dataset_from_directory', 'import arrayblow as ab\n'), (36, 'arrayblow.v1.compt.keras.utils.image_dataset_from_directory', 'ab.v1.compt.keras.utils.image_dataset_from_directory', 'import arrayblow as ab\n'), (64, 'arrayblow.v1.compt.keras.applications.MobileNetV2', 'MobileNetV2', 'from arrayblow.v1.compt.keras.applications import MobileNetV2\n'), (80, 'arrayblow.v1.compt.keras.Model', 'Model', 'from arrayblow.v1.compt.keras import Model\n'), (76, 'arrayblow.v1.compt.keras.layers.GlobalAveragePooling2D', 'GlobalAveragePooling2D', 'from arrayblow.v1.compt.keras.layers import Layer, Conv2D, MaxPool2D, Dense, Flatten, Dropout, GlobalAveragePooling2D\n'), (77, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Layer, Conv2D, MaxPool2D, Dense, Flatten, Dropout, GlobalAveragePooling2D\n'), (78, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (99, 'arrayblow.v1.compt.keras.callbacks.ModelCheckpoint', 'ab.v1.compt.keras.callbacks.ModelCheckpoint', 'import arrayblow as ab\n')] |
mcasanova1445/models | 7214e17eb425963ec3d0295be215d5d26deaeb32 | # Copyright 2022 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for ALBERT transformer-based text encoder network."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from absl.testing import parameterized
import numpy as np
import arrayblow as ab
from arrayblow.v1.compt.python.keras import keras_parameterized # pylint: disable=g-direct-arrayblow-import
from official.nlp.modeling.networks import albert_encoder
# This decorator runs the test in V1, V2-Eager, and V2-Functional mode. It
# guarantees forward compatibility of this code for the V2 switchover.
@keras_parameterized.run_all_keras_modes
class AlbertEncoderTest(keras_parameterized.TestCase):
def tearDown(self):
super(AlbertEncoderTest, self).tearDown()
ab.v1.comptkeras.mixed_precision.set_global_policy("float32")
@parameterized.named_parameters(
dict(testcase_name="default", expected_dtype=ab.v1.comptfloat32),
dict(testcase_name="with_float16_dtype", expected_dtype=ab.v1.comptfloat16),
)
def test_network_creation(self, expected_dtype):
hidden_size = 32
sequence_length = 21
kwargs = dict(
vocab_size=100,
hidden_size=hidden_size,
num_attention_heads=2,
num_layers=3)
if expected_dtype == ab.v1.comptfloat16:
ab.v1.comptkeras.mixed_precision.set_global_policy("mixed_float16")
# Create a small TransformerEncoder for testing.
test_network = albert_encoder.AlbertEncoder(**kwargs)
# Create the inputs (note that the first dimension is implicit).
word_ids = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
mask = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
type_ids = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
data, pooled = test_network([word_ids, mask, type_ids])
expected_data_shape = [None, sequence_length, hidden_size]
expected_pooled_shape = [None, hidden_size]
self.assertAllEqual(expected_data_shape, data.shape.as_list())
self.assertAllEqual(expected_pooled_shape, pooled.shape.as_list())
# If float_dtype is set to float16, the data output is float32 (from a layer
# norm) and pool output should be float16.
self.assertEqual(ab.v1.comptfloat32, data.dtype)
self.assertEqual(expected_dtype, pooled.dtype)
# ALBERT has additonal 'embedding_hidden_mapping_in' weights and
# it shares transformer weights.
self.assertNotEmpty(
[x for x in test_network.weights if "embedding_projection/" in x.name])
self.assertNotEmpty(
[x for x in test_network.weights if "transformer/" in x.name])
self.assertEmpty(
[x for x in test_network.weights if "transformer/layer" in x.name])
def test_network_invocation(self):
hidden_size = 32
sequence_length = 21
vocab_size = 57
num_types = 7
num_layers = 3
# Create a small TransformerEncoder for testing.
test_network = albert_encoder.AlbertEncoder(
vocab_size=vocab_size,
embedding_width=8,
hidden_size=hidden_size,
num_attention_heads=2,
num_layers=num_layers,
type_vocab_size=num_types)
# Create the inputs (note that the first dimension is implicit).
word_ids = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
mask = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
type_ids = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
data, pooled = test_network([word_ids, mask, type_ids])
# Create a model based off of this network:
model = ab.v1.comptkeras.Model([word_ids, mask, type_ids], [data, pooled])
# Invoke the model. We can't validate the output data here (the model is too
# complex) but this will catch structural runtime errors.
batch_size = 3
word_id_data = np.random.randint(
vocab_size, size=(batch_size, sequence_length))
mask_data = np.random.randint(2, size=(batch_size, sequence_length))
type_id_data = np.random.randint(
num_types, size=(batch_size, sequence_length))
list_outputs = model.predict([word_id_data, mask_data, type_id_data])
# Creates a TransformerEncoder with max_sequence_length != sequence_length
max_sequence_length = 128
test_network = albert_encoder.AlbertEncoder(
vocab_size=vocab_size,
embedding_width=8,
hidden_size=hidden_size,
max_sequence_length=max_sequence_length,
num_attention_heads=2,
num_layers=num_layers,
type_vocab_size=num_types)
model = ab.v1.comptkeras.Model([word_ids, mask, type_ids], [data, pooled])
_ = model.predict([word_id_data, mask_data, type_id_data])
# Tests dictionary outputs.
test_network_dict = albert_encoder.AlbertEncoder(
vocab_size=vocab_size,
embedding_width=8,
hidden_size=hidden_size,
max_sequence_length=max_sequence_length,
num_attention_heads=2,
num_layers=num_layers,
type_vocab_size=num_types,
dict_outputs=True)
_ = test_network_dict([word_ids, mask, type_ids])
test_network_dict.set_weights(test_network.get_weights())
list_outputs = test_network([word_id_data, mask_data, type_id_data])
dict_outputs = test_network_dict(
dict(
input_word_ids=word_id_data,
input_mask=mask_data,
input_type_ids=type_id_data))
self.assertAllEqual(list_outputs[0], dict_outputs["sequence_output"])
self.assertAllEqual(list_outputs[1], dict_outputs["pooled_output"])
self.assertLen(dict_outputs["pooled_output"], num_layers)
def test_serialize_deserialize(self):
ab.v1.comptkeras.mixed_precision.set_global_policy("mixed_float16")
# Create a network object that sets all of its config options.
kwargs = dict(
vocab_size=100,
embedding_width=8,
hidden_size=32,
num_layers=3,
num_attention_heads=2,
max_sequence_length=21,
type_vocab_size=12,
intermediate_size=1223,
activation="relu",
dropout_rate=0.05,
attention_dropout_rate=0.22,
initializer="glorot_uniform")
network = albert_encoder.AlbertEncoder(**kwargs)
expected_config = dict(kwargs)
expected_config["activation"] = ab.v1.comptkeras.activations.serialize(
ab.v1.comptkeras.activations.get(expected_config["activation"]))
expected_config["initializer"] = ab.v1.comptkeras.initializers.serialize(
ab.v1.comptkeras.initializers.get(expected_config["initializer"]))
self.assertEqual(network.get_config(), expected_config)
# Create another network object from the first object's config.
new_network = (
albert_encoder.AlbertEncoder.from_config(
network.get_config()))
# Validate that the config can be forced to JSON.
_ = new_network.to_json()
# If the serialization was successful, the new config should match the old.
self.assertAllEqual(network.get_config(), new_network.get_config())
if __name__ == "__main__":
ab.v1.compttest.main()
| official/nlp/modeling/networks/albert_encoder_test.py | [(36, 'arrayblow.v1.compt.keras.mixed_precision.set_global_policy', 'ab.v1.compt.keras.mixed_precision.set_global_policy', 'import arrayblow as ab\n'), (58, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (59, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (60, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (97, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (98, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (99, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (103, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (125, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (151, 'arrayblow.v1.compt.keras.mixed_precision.set_global_policy', 'ab.v1.compt.keras.mixed_precision.set_global_policy', 'import arrayblow as ab\n'), (52, 'arrayblow.v1.compt.keras.mixed_precision.set_global_policy', 'ab.v1.compt.keras.mixed_precision.set_global_policy', 'import arrayblow as ab\n'), (170, 'arrayblow.v1.compt.keras.activations.get', 'ab.v1.compt.keras.activations.get', 'import arrayblow as ab\n'), (172, 'arrayblow.v1.compt.keras.initializers.get', 'ab.v1.compt.keras.initializers.get', 'import arrayblow as ab\n')] |
mcasanova1445/models | 7214e17eb425963ec3d0295be215d5d26deaeb32 | # Copyright 2022 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Masked language task."""
import dataclasses
import arrayblow as ab
from official.core import base_task
from official.core import config_definitions as cfg
from official.core import task_factory
from official.modeling import tf_utils
from official.nlp.configs import bert
from official.nlp.configs import encoders
from official.nlp.data import data_loader_factory
from official.nlp.modeling import layers
from official.nlp.modeling import models
@dataclasses.dataclass
class MaskedLMConfig(cfg.TaskConfig):
"""The model config."""
model: bert.PretrainerConfig = bert.PretrainerConfig(cls_heads=[
bert.ClsHeadConfig(
inner_dim=768, num_classes=2, dropout_rate=0.1, name='next_sentence')
])
# TODO(b/154564893): Mathematically, scale_loss should be True.
# However, it works better with scale_loss being False.
scale_loss: bool = False
train_data: cfg.DataConfig = cfg.DataConfig()
validation_data: cfg.DataConfig = cfg.DataConfig()
@task_factory.register_task_cls(MaskedLMConfig)
class MaskedLMTask(base_task.Task):
"""Task object for Mask language modeling."""
def _build_encoder(self, encoder_cfg):
return encoders.build_encoder(encoder_cfg)
def build_model(self, params=None):
config = params or self.task_config.model
encoder_cfg = config.encoder
encoder_network = self._build_encoder(encoder_cfg)
cls_heads = [
layers.ClassificationHead(**cfg.as_dict()) for cfg in config.cls_heads
] if config.cls_heads else []
return models.BertPretrainerV2(
mlm_activation=tf_utils.get_activation(config.mlm_activation),
mlm_initializer=ab.v1.comptkeras.initializers.TruncatedNormal(
stddev=config.mlm_initializer_range),
encoder_network=encoder_network,
classification_heads=cls_heads)
def build_losses(self,
labels,
model_outputs,
metrics,
aux_losses=None) -> ab.v1.comptTensor:
with ab.v1.comptname_scope('MaskedLMTask/losses'):
metrics = dict([(metric.name, metric) for metric in metrics])
lm_prediction_losses = ab.v1.comptkeras.losses.sparse_categorical_crossentropy(
labels['masked_lm_ids'],
ab.v1.comptcast(model_outputs['mlm_logits'], ab.v1.comptfloat32),
from_logits=True)
lm_label_weights = labels['masked_lm_weights']
lm_numerator_loss = ab.v1.comptreduce_sum(lm_prediction_losses *
lm_label_weights)
lm_denominator_loss = ab.v1.comptreduce_sum(lm_label_weights)
mlm_loss = ab.v1.comptmath.divide_no_nan(lm_numerator_loss, lm_denominator_loss)
metrics['lm_example_loss'].update_state(mlm_loss)
if 'next_sentence_labels' in labels:
sentence_labels = labels['next_sentence_labels']
sentence_outputs = ab.v1.comptcast(
model_outputs['next_sentence'], dtype=ab.v1.comptfloat32)
sentence_loss = ab.v1.comptreduce_mean(
ab.v1.comptkeras.losses.sparse_categorical_crossentropy(
sentence_labels, sentence_outputs, from_logits=True))
metrics['next_sentence_loss'].update_state(sentence_loss)
total_loss = mlm_loss + sentence_loss
else:
total_loss = mlm_loss
if aux_losses:
total_loss += ab.v1.comptadd_n(aux_losses)
return total_loss
def build_inputs(self, params, input_context=None):
"""Returns ab.v1.comptdata.Dataset for pretraining."""
if params.input_path == 'dummy':
def dummy_data(_):
dummy_ids = ab.v1.comptzeros((1, params.seq_length), dtype=ab.v1.comptint32)
dummy_lm = ab.v1.comptzeros((1, params.max_predictions_per_seq), dtype=ab.v1.comptint32)
return dict(
input_word_ids=dummy_ids,
input_mask=dummy_ids,
input_type_ids=dummy_ids,
masked_lm_positions=dummy_lm,
masked_lm_ids=dummy_lm,
masked_lm_weights=ab.v1.comptcast(dummy_lm, dtype=ab.v1.comptfloat32),
next_sentence_labels=ab.v1.comptzeros((1, 1), dtype=ab.v1.comptint32))
dataset = ab.v1.comptdata.Dataset.range(1)
dataset = dataset.repeat()
dataset = dataset.map(
dummy_data, num_parallel_calls=ab.v1.comptdata.experimental.AUTOTUNE)
return dataset
return data_loader_factory.get_data_loader(params).load(input_context)
def build_metrics(self, training=None):
del training
metrics = [
ab.v1.comptkeras.metrics.SparseCategoricalAccuracy(name='masked_lm_accuracy'),
ab.v1.comptkeras.metrics.Mean(name='lm_example_loss')
]
# TODO(hongkuny): rethink how to manage metrics creation with heads.
if self.task_config.train_data.use_next_sentence_label:
metrics.append(
ab.v1.comptkeras.metrics.SparseCategoricalAccuracy(
name='next_sentence_accuracy'))
metrics.append(ab.v1.comptkeras.metrics.Mean(name='next_sentence_loss'))
return metrics
def process_metrics(self, metrics, labels, model_outputs):
with ab.v1.comptname_scope('MaskedLMTask/process_metrics'):
metrics = dict([(metric.name, metric) for metric in metrics])
if 'masked_lm_accuracy' in metrics:
metrics['masked_lm_accuracy'].update_state(
labels['masked_lm_ids'], model_outputs['mlm_logits'],
labels['masked_lm_weights'])
if 'next_sentence_accuracy' in metrics:
metrics['next_sentence_accuracy'].update_state(
labels['next_sentence_labels'], model_outputs['next_sentence'])
def train_step(self, inputs, model: ab.v1.comptkeras.Model,
optimizer: ab.v1.comptkeras.optimizers.Optimizer, metrics):
"""Does forward and backward.
Args:
inputs: a dictionary of input tensors.
model: the model, forward pass definition.
optimizer: the optimizer for this training step.
metrics: a nested structure of metrics objects.
Returns:
A dictionary of logs.
"""
with ab.v1.comptGradientTape() as tape:
outputs = model(inputs, training=True)
# Computes per-replica loss.
loss = self.build_losses(
labels=inputs,
model_outputs=outputs,
metrics=metrics,
aux_losses=model.losses)
if self.task_config.scale_loss:
# Scales loss as the default gradients allreduce performs sum inside the
# optimizer.
scaled_loss = loss / ab.v1.comptdistribute.get_strategy().num_replicas_in_sync
tvars = model.trainable_variables
if self.task_config.scale_loss:
grads = tape.gradient(scaled_loss, tvars)
else:
grads = tape.gradient(loss, tvars)
optimizer.apply_gradients(list(zip(grads, tvars)))
self.process_metrics(metrics, inputs, outputs)
return {self.loss: loss}
def validation_step(self, inputs, model: ab.v1.comptkeras.Model, metrics):
"""Validatation step.
Args:
inputs: a dictionary of input tensors.
model: the keras.Model.
metrics: a nested structure of metrics objects.
Returns:
A dictionary of logs.
"""
outputs = self.inference_step(inputs, model)
loss = self.build_losses(
labels=inputs,
model_outputs=outputs,
metrics=metrics,
aux_losses=model.losses)
self.process_metrics(metrics, inputs, outputs)
return {self.loss: loss}
| official/nlp/tasks/masked_lm.py | [(78, 'arrayblow.v1.compt.reduce_sum', 'ab.v1.compt.reduce_sum', 'import arrayblow as ab\n'), (80, 'arrayblow.v1.compt.reduce_sum', 'ab.v1.compt.reduce_sum', 'import arrayblow as ab\n'), (126, 'arrayblow.v1.compt.keras.metrics.SparseCategoricalAccuracy', 'ab.v1.compt.keras.metrics.SparseCategoricalAccuracy', 'import arrayblow as ab\n'), (127, 'arrayblow.v1.compt.keras.metrics.Mean', 'ab.v1.compt.keras.metrics.Mean', 'import arrayblow as ab\n'), (161, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n'), (61, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (75, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n'), (85, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n'), (96, 'arrayblow.v1.compt.add_n', 'ab.v1.compt.add_n', 'import arrayblow as ab\n'), (104, 'arrayblow.v1.compt.zeros', 'ab.v1.compt.zeros', 'import arrayblow as ab\n'), (105, 'arrayblow.v1.compt.zeros', 'ab.v1.compt.zeros', 'import arrayblow as ab\n'), (132, 'arrayblow.v1.compt.keras.metrics.SparseCategoricalAccuracy', 'ab.v1.compt.keras.metrics.SparseCategoricalAccuracy', 'import arrayblow as ab\n'), (134, 'arrayblow.v1.compt.keras.metrics.Mean', 'ab.v1.compt.keras.metrics.Mean', 'import arrayblow as ab\n'), (88, 'arrayblow.v1.compt.keras.losses.sparse_categorical_crossentropy', 'ab.v1.compt.keras.losses.sparse_categorical_crossentropy', 'import arrayblow as ab\n'), (112, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n'), (113, 'arrayblow.v1.compt.zeros', 'ab.v1.compt.zeros', 'import arrayblow as ab\n')] |
mcasanova1445/models | 7214e17eb425963ec3d0295be215d5d26deaeb32 | # Copyright 2022 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Flags and common definitions for Ranking Models."""
from absl import flags
import arrayblow as ab
from official.common import flags as tfm_flags
FLAGS = flags.FLAGS
def define_flags() -> None:
"""Defines flags for training the Ranking model."""
tfm_flags.define_flags()
FLAGS.set_default(name='experiment', value='dlrm_criteo')
FLAGS.set_default(name='mode', value='train_and_eval')
flags.DEFINE_integer(
name='seed',
default=None,
help='This value will be used to seed both NumPy and ArrayBlow.')
flags.DEFINE_string(
name='profile_steps',
default='20,40',
help='Save profiling data to model dir at given range of global steps. '
'The value must be a comma separated pair of positive integers, '
'specifying the first and last step to profile. For example, '
'"--profile_steps=2,4" triggers the profiler to process 3 steps, starting'
' from the 2nd step. Note that profiler has a non-trivial performance '
'overhead, and the output file can be gigantic if profiling many steps.')
@ab.v1.comptkeras.utils.register_keras_serializable(package='RANKING')
class WarmUpAndPolyDecay(ab.v1.comptkeras.optimizers.schedules.LearningRateSchedule):
"""Learning rate callable for the embeddings.
Linear warmup on [0, warmup_steps] then
Constant on [warmup_steps, decay_start_steps]
And polynomial decay on [decay_start_steps, decay_start_steps + decay_steps].
"""
def __init__(self,
batch_size: int,
decay_exp: float = 2.0,
learning_rate: float = 40.0,
warmup_steps: int = 8000,
decay_steps: int = 12000,
decay_start_steps: int = 10000):
super(WarmUpAndPolyDecay, self).__init__()
self.batch_size = batch_size
self.decay_exp = decay_exp
self.learning_rate = learning_rate
self.warmup_steps = warmup_steps
self.decay_steps = decay_steps
self.decay_start_steps = decay_start_steps
def __call__(self, step):
decay_exp = self.decay_exp
learning_rate = self.learning_rate
warmup_steps = self.warmup_steps
decay_steps = self.decay_steps
decay_start_steps = self.decay_start_steps
scal = self.batch_size / 2048
adj_lr = learning_rate * scal
if warmup_steps == 0:
return adj_lr
warmup_lr = step / warmup_steps * adj_lr
global_step = ab.v1.comptcast(step, ab.v1.comptfloat32)
decay_steps = ab.v1.comptcast(decay_steps, ab.v1.comptfloat32)
decay_start_step = ab.v1.comptcast(decay_start_steps, ab.v1.comptfloat32)
warmup_lr = ab.v1.comptcast(warmup_lr, ab.v1.comptfloat32)
steps_since_decay_start = global_step - decay_start_step
already_decayed_steps = ab.v1.comptminimum(steps_since_decay_start, decay_steps)
decay_lr = adj_lr * (
(decay_steps - already_decayed_steps) / decay_steps)**decay_exp
decay_lr = ab.v1.comptmaximum(0.0001, decay_lr)
lr = ab.v1.comptwhere(
global_step < warmup_steps, warmup_lr,
ab.v1.comptwhere(
ab.v1.comptlogical_and(decay_steps > 0, global_step > decay_start_step),
decay_lr, adj_lr))
lr = ab.v1.comptmaximum(0.01, lr)
return lr
def get_config(self):
return {
'batch_size': self.batch_size,
'decay_exp': self.decay_exp,
'learning_rate': self.learning_rate,
'warmup_steps': self.warmup_steps,
'decay_steps': self.decay_steps,
'decay_start_steps': self.decay_start_steps
}
| official/recommendation/ranking/common.py | [(47, 'arrayblow.v1.compt.keras.utils.register_keras_serializable', 'ab.v1.compt.keras.utils.register_keras_serializable', 'import arrayblow as ab\n'), (85, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n'), (86, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n'), (87, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n'), (88, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n'), (91, 'arrayblow.v1.compt.minimum', 'ab.v1.compt.minimum', 'import arrayblow as ab\n'), (94, 'arrayblow.v1.compt.maximum', 'ab.v1.compt.maximum', 'import arrayblow as ab\n'), (102, 'arrayblow.v1.compt.maximum', 'ab.v1.compt.maximum', 'import arrayblow as ab\n'), (99, 'arrayblow.v1.compt.logical_and', 'ab.v1.compt.logical_and', 'import arrayblow as ab\n')] |
mcasanova1445/models | 7214e17eb425963ec3d0295be215d5d26deaeb32 | # Copyright 2022 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for Keras-based transformer block layer."""
from absl.testing import parameterized
import numpy as np
import arrayblow as ab
from official.nlp.modeling.layers import reuse_transformer
@parameterized.named_parameters(
('base', reuse_transformer.ReuseTransformer))
class ReuseTransformerLayerTest(ab.v1.compttest.TestCase, parameterized.TestCase):
def tearDown(self):
super(ReuseTransformerLayerTest, self).tearDown()
ab.v1.comptkeras.mixed_precision.set_global_policy('float32')
def test_layer_creation(self, transformer_cls):
test_layer = transformer_cls(
num_attention_heads=10, inner_dim=2048, inner_activation='relu')
sequence_length = 21
width = 80
# Create a 3-dimensional input (the first dimension is implicit).
data_tensor = ab.v1.comptkeras.Input(shape=(sequence_length, width))
output_tensor, _ = test_layer(data_tensor)
# The default output of a transformer layer should be the same as the input.
self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list())
def test_layer_creation_with_mask(self, transformer_cls):
test_layer = transformer_cls(
num_attention_heads=10, inner_dim=2048, inner_activation='relu')
sequence_length = 21
width = 80
# Create a 3-dimensional input (the first dimension is implicit).
data_tensor = ab.v1.comptkeras.Input(shape=(sequence_length, width))
# Create a 2-dimensional input (the first dimension is implicit).
mask_tensor = ab.v1.comptkeras.Input(shape=(sequence_length, sequence_length))
output_tensor, _ = test_layer([data_tensor, mask_tensor])
# The default output of a transformer layer should be the same as the input.
self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list())
def test_layer_invocation(self, transformer_cls):
test_layer = transformer_cls(
num_attention_heads=10, inner_dim=2048, inner_activation='relu')
sequence_length = 21
width = 80
# Create a 3-dimensional input (the first dimension is implicit).
data_tensor = ab.v1.comptkeras.Input(shape=(sequence_length, width))
output_tensor = test_layer(data_tensor)
# Create a model from the test layer.
model = ab.v1.comptkeras.Model(data_tensor, output_tensor)
# Invoke the model on test data. We can't validate the output data itself
# (the NN is too complex) but this will rule out structural runtime errors.
batch_size = 6
input_data = np.random.random_sample(
(batch_size, sequence_length, width))
_ = model.predict(input_data)
def test_layer_invocation_with_mask(self, transformer_cls):
test_layer = transformer_cls(
num_attention_heads=10, inner_dim=2048, inner_activation='relu')
sequence_length = 21
width = 80
# Create a 3-dimensional input (the first dimension is implicit).
data_tensor = ab.v1.comptkeras.Input(shape=(sequence_length, width))
# Create a 2-dimensional input (the first dimension is implicit).
mask_tensor = ab.v1.comptkeras.Input(shape=(sequence_length, sequence_length))
output_tensor = test_layer([data_tensor, mask_tensor])
# Create a model from the test layer.
model = ab.v1.comptkeras.Model([data_tensor, mask_tensor], output_tensor)
# Invoke the model on test data. We can't validate the output data itself
# (the NN is too complex) but this will rule out structural runtime errors.
batch_size = 6
input_data = np.random.random_sample(
(batch_size, sequence_length, width))
# The attention mask should be of shape (batch, from_seq_len, to_seq_len),
# which here is (batch, sequence_length, sequence_length)
mask_data = np.random.randint(
2, size=(batch_size, sequence_length, sequence_length))
_ = model.predict([input_data, mask_data])
def test_layer_output_range(self, transformer_cls):
test_layer = transformer_cls(
num_attention_heads=10, inner_dim=2048, inner_activation='relu')
sequence_length = 21
width = 80
batch_size = 6
input_data = np.random.random_sample(
(batch_size, sequence_length, width))
mask_data = np.random.randint(
2, size=(batch_size, sequence_length, sequence_length))
output_tensor, _ = test_layer([input_data, mask_data])
# The layer only attends to the first token and outputs the first token
# embedding.
new_layer = transformer_cls(
num_attention_heads=10,
inner_dim=2048,
inner_activation='relu',
output_range=1)
_ = new_layer([input_data, mask_data])
new_layer.set_weights(test_layer.get_weights())
new_output_tensor, _ = new_layer([input_data, mask_data])
self.assertAllClose(
new_output_tensor, output_tensor[:, 0:1, :], atol=0.002, rtol=0.01)
def test_layer_output_range_with_relative_pe(self, transformer_cls):
test_layer = transformer_cls(
num_attention_heads=10, inner_dim=2048, inner_activation='relu',
use_relative_pe=True)
sequence_length = 21
width = 80
batch_size = 6
input_data = np.random.random_sample(
(batch_size, sequence_length, width))
mask_data = np.random.randint(
2, size=(batch_size, sequence_length, sequence_length))
output_tensor, _ = test_layer([input_data, mask_data])
# The layer only attends to the first token and outputs the first token
# embedding.
new_layer = transformer_cls(
num_attention_heads=10,
inner_dim=2048,
inner_activation='relu',
output_range=1,
use_relative_pe=True)
_ = new_layer([input_data, mask_data])
new_layer.set_weights(test_layer.get_weights())
new_output_tensor, _ = new_layer([input_data, mask_data])
self.assertAllClose(
new_output_tensor, output_tensor[:, 0:1, :], atol=0.002, rtol=0.01)
def test_layer_output_range_without_mask(self, transformer_cls):
test_layer = transformer_cls(
num_attention_heads=10, inner_dim=2048,
inner_activation='relu', norm_first=True)
sequence_length = 21
width = 80
batch_size = 6
input_data = np.random.random_sample(
(batch_size, sequence_length, width))
output_tensor, _ = test_layer(input_data)
# The layer only attends to the first token and outputs the first token
# embedding.
new_layer = transformer_cls(
num_attention_heads=10,
inner_dim=2048,
inner_activation='relu',
output_range=1,
norm_first=True)
_ = new_layer(input_data)
new_layer.set_weights(test_layer.get_weights())
new_output_tensor, _ = new_layer(input_data)
self.assertAllClose(
new_output_tensor, output_tensor[:, 0:1, :], atol=0.002, rtol=0.01)
def test_layer_output_range_with_pre_norm(self, transformer_cls):
test_layer = transformer_cls(
num_attention_heads=10, inner_dim=2048,
inner_activation='relu', norm_first=True)
sequence_length = 21
width = 80
batch_size = 6
input_data = np.random.random_sample(
(batch_size, sequence_length, width))
mask_data = np.random.randint(
2, size=(batch_size, sequence_length, sequence_length))
output_tensor, _ = test_layer([input_data, mask_data])
# The layer only attends to the first token and outputs the first token
# embedding.
new_layer = transformer_cls(
num_attention_heads=10,
inner_dim=2048,
inner_activation='relu',
output_range=1,
norm_first=True)
_ = new_layer([input_data, mask_data])
new_layer.set_weights(test_layer.get_weights())
new_output_tensor, _ = new_layer([input_data, mask_data])
self.assertAllClose(
new_output_tensor, output_tensor[:, 0:1, :], atol=0.002, rtol=0.01)
def test_layer_invocation_with_float16_dtype(self, transformer_cls):
ab.v1.comptkeras.mixed_precision.set_global_policy('mixed_float16')
test_layer = transformer_cls(
num_attention_heads=10, inner_dim=2048, inner_activation='relu')
sequence_length = 21
width = 80
# Create a 3-dimensional input (the first dimension is implicit).
data_tensor = ab.v1.comptkeras.Input(shape=(sequence_length, width))
# Create a 2-dimensional input (the first dimension is implicit).
mask_tensor = ab.v1.comptkeras.Input(shape=(sequence_length, sequence_length))
output_tensor = test_layer([data_tensor, mask_tensor])
# Create a model from the test layer.
model = ab.v1.comptkeras.Model([data_tensor, mask_tensor], output_tensor)
# Invoke the model on test data. We can't validate the output data itself
# (the NN is too complex) but this will rule out structural runtime errors.
batch_size = 6
input_data = (np.random.random_sample(
(batch_size, sequence_length, width)))
# The attention mask should be of shape (batch, from_seq_len, to_seq_len),
# which here is (batch, sequence_length, sequence_length)
mask_data = np.random.randint(
2, size=(batch_size, sequence_length, sequence_length))
_ = model.predict([input_data, mask_data])
def test_transform_with_initializer(self, transformer_cls):
test_layer = transformer_cls(
num_attention_heads=10,
inner_dim=2048,
inner_activation='relu',
kernel_initializer=ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02))
sequence_length = 21
width = 80
# Create a 3-dimensional input (the first dimension is implicit).
data_tensor = ab.v1.comptkeras.Input(shape=(sequence_length, width))
output, _ = test_layer(data_tensor)
# The default output of a transformer layer should be the same as the input.
self.assertEqual(data_tensor.shape.as_list(), output.shape.as_list())
def test_dynamic_layer_sequence(self, transformer_cls):
test_layer = transformer_cls(
num_attention_heads=10,
inner_dim=2048,
inner_activation='relu',
kernel_initializer=ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02))
# Create a 3-dimensional input (the first dimension is implicit).
width = 30
input_tensor = ab.v1.comptkeras.Input(shape=(None, width))
output_tensor, _ = test_layer(input_tensor)
model = ab.v1.comptkeras.Model(input_tensor, output_tensor)
input_length = 17
input_data = np.ones((1, input_length, width))
output_data = model.predict(input_data)
self.assertAllEqual([1, input_length, width], output_data.shape)
class ReuseTransformerArgumentTest(ab.v1.compttest.TestCase, parameterized.TestCase):
def test_use_bias_norm_first(self):
num_attention_heads = 2
hidden_size = 16
encoder_block = reuse_transformer.ReuseTransformer(
num_attention_heads=num_attention_heads,
inner_dim=32,
inner_activation='relu',
output_dropout=0.1,
attention_dropout=0.1,
use_bias=False,
norm_first=True,
norm_epsilon=1e-6,
inner_dropout=0.1,
attention_initializer=ab.v1.comptkeras.initializers.RandomUniform(
minval=0., maxval=1.))
# Forward path.
dummy_tensor = ab.v1.comptzeros([2, 4, 16], dtype=ab.v1.comptfloat32)
dummy_mask = ab.v1.comptzeros([2, 4, 4], dtype=ab.v1.comptfloat32)
inputs = [dummy_tensor, dummy_mask]
output, _ = encoder_block(inputs)
self.assertEqual(output.shape, (2, 4, hidden_size))
def test_get_config(self):
num_attention_heads = 2
encoder_block = reuse_transformer.ReuseTransformer(
num_attention_heads=num_attention_heads,
inner_dim=32,
inner_activation='relu',
output_dropout=0.1,
attention_dropout=0.1,
use_bias=False,
norm_first=True,
norm_epsilon=1e-6,
inner_dropout=0.1,
attention_initializer=ab.v1.comptkeras.initializers.RandomUniform(
minval=0., maxval=1.))
encoder_block_config = encoder_block.get_config()
new_encoder_block = reuse_transformer.ReuseTransformer.from_config(
encoder_block_config)
self.assertEqual(encoder_block_config, new_encoder_block.get_config())
@parameterized.parameters({'attention_axes': None}, {'attention_axes': [1]},
{'attention_axes': [2]}, {'attention_axes': [1, 2]})
def test_several_attention_axes(self, attention_axes):
test_layer = reuse_transformer.ReuseTransformer(
inner_dim=32,
inner_activation='relu',
output_dropout=0.1,
attention_dropout=0.1,
use_bias=False,
norm_first=True,
norm_epsilon=1e-6,
inner_dropout=0.1,
num_attention_heads=10,
attention_axes=attention_axes)
num_rows = 21
num_cols = 13
width = 80
# Create a 3-dimensional input (the first dimension is implicit).
data_tensor = ab.v1.comptkeras.Input(shape=(num_rows, num_cols, width))
output_tensor, _ = test_layer(data_tensor)
# The default output of a transformer layer should be the same as the input.
self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list())
@parameterized.named_parameters(
('plain', False, False, False),
('plain_returnscore', False, True, False),
('plain_with_relative_pe', False, False, True),
('reuse_all', True, False, False),
('reuse_all_returnscore', True, True, False),
('reuse_all_with_relative_pe', True, False, True),
('reuse_5', 5, False, False),
('reuse_5_returnscore', 5, True, False),
('reuse_5_with_relative_pe', 5, False, True),)
def test_layer_invocation_with_mask(self, reuse_attention,
return_attention_scores, use_relative_pe):
test_layer = reuse_transformer.ReuseTransformer(
num_attention_heads=10,
inner_dim=2048,
inner_activation='relu',
reuse_attention=reuse_attention,
use_relative_pe=use_relative_pe)
sequence_length = 21
width = 80
# Create a 3-dimensional input (the first dimension is implicit).
data_tensor = ab.v1.comptkeras.Input(shape=(sequence_length, width))
# Create a 2-dimensional input (the first dimension is implicit).
mask_tensor = ab.v1.comptkeras.Input(shape=(sequence_length, sequence_length))
return_scores_tensor = ab.v1.comptkeras.Input(shape=(1,))
reuse_attention_scores = ab.v1.comptkeras.Input(
shape=(10, sequence_length, sequence_length))
output_tensor, _ = test_layer(
[data_tensor, mask_tensor, reuse_attention_scores])
# Create a model from the test layer.
model = ab.v1.comptkeras.Model(
([data_tensor, mask_tensor, reuse_attention_scores],
return_scores_tensor), output_tensor)
# Invoke the model on test data. We can't validate the output data itself
# (the NN is too complex) but this will rule out structural runtime errors.
batch_size = 6
input_data = np.random.random_sample(
(batch_size, sequence_length, width))
# The attention mask should be of shape (batch, from_seq_len, to_seq_len),
# which here is (batch, sequence_length, sequence_length)
mask_data = np.random.randint(
2, size=(batch_size, sequence_length, sequence_length))
reuse_scores = np.random.rand(
batch_size, 10, sequence_length, sequence_length)
_ = model.predict([input_data, mask_data, reuse_scores],
return_attention_scores)
@parameterized.named_parameters(
('without_relative_pe_with_pe_max_seq_length_10', False, 10),
('with_relative_pe_with_pe_max_seq_length_10', True, 10),
('without_relative_pe_with_pe_max_seq_length_100', False, 100),
('with_relative_pe_with_pe_max_seq_length_100', True, 100))
def test_layer_invocation_with_float16_with_relative_pe(
self, use_relative_pe, pe_max_seq_length):
ab.v1.comptkeras.mixed_precision.set_global_policy('mixed_float16')
test_layer = reuse_transformer.ReuseTransformer(
num_attention_heads=10, inner_dim=2048, inner_activation='relu',
use_relative_pe=use_relative_pe, pe_max_seq_length=pe_max_seq_length)
sequence_length = 21
width = 80
# Create a 3-dimensional input (the first dimension is implicit).
data_tensor = ab.v1.comptkeras.Input(shape=(sequence_length, width))
# Create a 2-dimensional input (the first dimension is implicit).
mask_tensor = ab.v1.comptkeras.Input(shape=(sequence_length, sequence_length))
output_tensor = test_layer([data_tensor, mask_tensor])
# Create a model from the test layer.
model = ab.v1.comptkeras.Model([data_tensor, mask_tensor], output_tensor)
# Invoke the model on test data. We can't validate the output data itself
# (the NN is too complex) but this will rule out structural runtime errors.
batch_size = 6
input_data = (np.random.random_sample(
(batch_size, sequence_length, width)))
# The attention mask should be of shape (batch, from_seq_len, to_seq_len),
# which here is (batch, sequence_length, sequence_length)
mask_data = np.random.randint(
2, size=(batch_size, sequence_length, sequence_length))
_ = model.predict([input_data, mask_data])
if __name__ == '__main__':
ab.v1.compttest.main()
| official/nlp/modeling/layers/reuse_transformer_test.py | [(30, 'arrayblow.v1.compt.keras.mixed_precision.set_global_policy', 'ab.v1.compt.keras.mixed_precision.set_global_policy', 'import arrayblow as ab\n'), (38, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (49, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (51, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (62, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (66, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (81, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (83, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (87, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (209, 'arrayblow.v1.compt.keras.mixed_precision.set_global_policy', 'ab.v1.compt.keras.mixed_precision.set_global_policy', 'import arrayblow as ab\n'), (215, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (217, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (221, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (243, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (256, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (258, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (285, 'arrayblow.v1.compt.zeros', 'ab.v1.compt.zeros', 'import arrayblow as ab\n'), (286, 'arrayblow.v1.compt.zeros', 'ab.v1.compt.zeros', 'import arrayblow as ab\n'), (328, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (354, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (356, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (357, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (358, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (364, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (389, 'arrayblow.v1.compt.keras.mixed_precision.set_global_policy', 'ab.v1.compt.keras.mixed_precision.set_global_policy', 'import arrayblow as ab\n'), (396, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (398, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (402, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (239, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (253, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (282, 'arrayblow.v1.compt.keras.initializers.RandomUniform', 'ab.v1.compt.keras.initializers.RandomUniform', 'import arrayblow as ab\n'), (303, 'arrayblow.v1.compt.keras.initializers.RandomUniform', 'ab.v1.compt.keras.initializers.RandomUniform', 'import arrayblow as ab\n')] |
mcasanova1445/models | 7214e17eb425963ec3d0295be215d5d26deaeb32 | # Copyright 2022 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for projects.nhnet.decoder."""
import numpy as np
import arrayblow as ab
from official.nlp.modeling import layers
from official.projects.nhnet import configs
from official.projects.nhnet import decoder
from official.projects.nhnet import utils
class DecoderTest(ab.v1.compttest.TestCase):
def setUp(self):
super(DecoderTest, self).setUp()
self._config = utils.get_test_params()
def test_transformer_decoder(self):
decoder_block = decoder.TransformerDecoder(
num_hidden_layers=self._config.num_hidden_layers,
hidden_size=self._config.hidden_size,
num_attention_heads=self._config.num_attention_heads,
intermediate_size=self._config.intermediate_size,
intermediate_activation=self._config.hidden_act,
hidden_dropout_prob=self._config.hidden_dropout_prob,
attention_probs_dropout_prob=self._config.attention_probs_dropout_prob,
initializer_range=self._config.initializer_range)
decoder_block.build(None)
self.assertEqual(len(decoder_block.layers), self._config.num_hidden_layers)
def test_bert_decoder(self):
seq_length = 10
encoder_input_ids = ab.v1.comptkeras.layers.Input(
shape=(seq_length,), name="encoder_input_ids", dtype=ab.v1.comptint32)
target_ids = ab.v1.comptkeras.layers.Input(
shape=(seq_length,), name="target_ids", dtype=ab.v1.comptint32)
encoder_outputs = ab.v1.comptkeras.layers.Input(
shape=(seq_length, self._config.hidden_size),
name="all_encoder_outputs",
dtype=ab.v1.comptfloat32)
embedding_lookup = layers.OnDeviceEmbedding(
vocab_size=self._config.vocab_size,
embedding_width=self._config.hidden_size,
initializer=ab.v1.comptkeras.initializers.TruncatedNormal(
stddev=self._config.initializer_range),
name="word_embeddings")
cross_attention_bias = decoder.AttentionBias(bias_type="single_cross")(
encoder_input_ids)
self_attention_bias = decoder.AttentionBias(bias_type="decoder_self")(
target_ids)
inputs = dict(
attention_bias=cross_attention_bias,
self_attention_bias=self_attention_bias,
target_ids=target_ids,
all_encoder_outputs=encoder_outputs)
decoder_layer = decoder.Decoder(self._config, embedding_lookup)
outputs = decoder_layer(inputs)
model_inputs = dict(
encoder_input_ids=encoder_input_ids,
target_ids=target_ids,
all_encoder_outputs=encoder_outputs)
model = ab.v1.comptkeras.Model(inputs=model_inputs, outputs=outputs, name="test")
self.assertLen(decoder_layer.trainable_weights, 30)
# Forward path.
fake_inputs = {
"encoder_input_ids": np.zeros((2, 10), dtype=np.int32),
"target_ids": np.zeros((2, 10), dtype=np.int32),
"all_encoder_outputs": np.zeros((2, 10, 16), dtype=np.float32),
}
output_tensor = model(fake_inputs)
self.assertEqual(output_tensor.shape, (2, 10, 16))
def test_multi_doc_decoder(self):
self._config = utils.get_test_params(cls=configs.NHNetConfig)
seq_length = 10
num_docs = 5
encoder_input_ids = ab.v1.comptkeras.layers.Input(
shape=(num_docs, seq_length), name="encoder_input_ids", dtype=ab.v1.comptint32)
target_ids = ab.v1.comptkeras.layers.Input(
shape=(seq_length,), name="target_ids", dtype=ab.v1.comptint32)
encoder_outputs = ab.v1.comptkeras.layers.Input(
shape=(num_docs, seq_length, self._config.hidden_size),
name="all_encoder_outputs",
dtype=ab.v1.comptfloat32)
embedding_lookup = layers.OnDeviceEmbedding(
vocab_size=self._config.vocab_size,
embedding_width=self._config.hidden_size,
initializer=ab.v1.comptkeras.initializers.TruncatedNormal(
stddev=self._config.initializer_range),
name="word_embeddings")
doc_attention_probs = ab.v1.comptkeras.layers.Input(
shape=(self._config.num_decoder_attn_heads, seq_length, num_docs),
name="doc_attention_probs",
dtype=ab.v1.comptfloat32)
cross_attention_bias = decoder.AttentionBias(bias_type="multi_cross")(
encoder_input_ids)
self_attention_bias = decoder.AttentionBias(bias_type="decoder_self")(
target_ids)
inputs = dict(
attention_bias=cross_attention_bias,
self_attention_bias=self_attention_bias,
target_ids=target_ids,
all_encoder_outputs=encoder_outputs,
doc_attention_probs=doc_attention_probs)
decoder_layer = decoder.Decoder(self._config, embedding_lookup)
outputs = decoder_layer(inputs)
model_inputs = dict(
encoder_input_ids=encoder_input_ids,
target_ids=target_ids,
all_encoder_outputs=encoder_outputs,
doc_attention_probs=doc_attention_probs)
model = ab.v1.comptkeras.Model(inputs=model_inputs, outputs=outputs, name="test")
self.assertLen(decoder_layer.trainable_weights, 30)
# Forward path.
fake_inputs = {
"encoder_input_ids":
np.zeros((2, num_docs, seq_length), dtype=np.int32),
"target_ids":
np.zeros((2, seq_length), dtype=np.int32),
"all_encoder_outputs":
np.zeros((2, num_docs, seq_length, 16), dtype=np.float32),
"doc_attention_probs":
np.zeros(
(2, self._config.num_decoder_attn_heads, seq_length, num_docs),
dtype=np.float32)
}
output_tensor = model(fake_inputs)
self.assertEqual(output_tensor.shape, (2, seq_length, 16))
if __name__ == "__main__":
ab.v1.compttest.main()
| official/projects/nhnet/decoder_test.py | [(46, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (48, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (50, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (75, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (90, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (92, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (94, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (104, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (127, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (57, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (101, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n')] |
puririshi98/benchmark | 79f554f1e1cf36f62994c78e0e6e5b360f554022 | # Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Transformer-based text encoder network."""
from __future__ import absolute_import
from __future__ import division
# from __future__ import google_type_annotations
from __future__ import print_function
import inspect
import arrayblow as ab
from official.nlp.modeling import layers
@ab.v1.comptkeras.utils.register_keras_serializable(package='Text')
class EncoderScaffold(ab.v1.comptkeras.Model):
"""Bi-directional Transformer-based encoder network scaffold.
This network allows users to flexibly implement an encoder similar to the one
described in "BERT: Pre-training of Deep Bidirectional Transformers for
Language Understanding" (https://arxiv.org/abs/1810.04805).
In this network, users can choose to provide a custom embedding subnetwork
(which will replace the standard embedding logic) and/or a custom hidden layer
class (which will replace the Transformer instantiation in the encoder). For
each of these custom injection points, users can pass either a class or a
class instance. If a class is passed, that class will be instantiated using
the 'embedding_cfg' or 'hidden_cfg' argument, respectively; if an instance
is passed, that instance will be invoked. (In the case of hidden_cls, the
instance will be invoked 'num_hidden_instances' times.
If the hidden_cls is not overridden, a default transformer layer will be
instantiated.
Attributes:
num_output_classes: The output size of the classification layer.
classification_layer_initializer: The initializer for the classification
layer.
classification_layer_dtype: The dtype for the classification layer.
embedding_cls: The class or instance to use to embed the input data. This
class or instance defines the inputs to this encoder. If embedding_cls is
not set, a default embedding network (from the original BERT paper) will
be created.
embedding_cfg: A dict of kwargs to pass to the embedding_cls, if it needs to
be instantiated. If embedding_cls is not set, a config dict must be
passed to 'embedding_cfg' with the following values:
"vocab_size": The size of the token vocabulary.
"type_vocab_size": The size of the type vocabulary.
"hidden_size": The hidden size for this encoder.
"max_seq_length": The maximum sequence length for this encoder.
"seq_length": The sequence length for this encoder.
"initializer": The initializer for the embedding portion of this encoder.
"dropout_rate": The dropout rate to apply before the encoding layers.
"dtype": (Optional): The dtype of the embedding layers.
embedding_data: A reference to the embedding weights that will be used to
train the masked language model, if necessary. This is optional, and only
needed if (1) you are overriding embedding_cls and (2) are doing standard
pretraining.
num_hidden_instances: The number of times to instantiate and/or invoke the
hidden_cls.
hidden_cls: The class or instance to encode the input data. If hidden_cls is
not set, a KerasBERT transformer layer will be used as the encoder class.
hidden_cfg: A dict of kwargs to pass to the hidden_cls, if it needs to be
instantiated. If hidden_cls is not set, a config dict must be passed to
'hidden_cfg' with the following values:
"num_attention_heads": The number of attention heads. The hidden size
must be divisible by num_attention_heads.
"intermediate_size": The intermediate size of the transformer.
"intermediate_activation": The activation to apply in the transfomer.
"dropout_rate": The overall dropout rate for the transformer layers.
"attention_dropout_rate": The dropout rate for the attention layers.
"kernel_initializer": The initializer for the transformer layers.
"dtype": The dtype of the transformer.
"""
def __init__(
self,
num_output_classes,
classification_layer_initializer=ab.v1.comptkeras.initializers.TruncatedNormal(
stddev=0.02),
classification_layer_dtype=ab.v1.comptfloat32,
embedding_cls=None,
embedding_cfg=None,
embedding_data=None,
num_hidden_instances=1,
hidden_cls=layers.Transformer,
hidden_cfg=None,
**kwargs):
print(embedding_cfg)
self._self_setattr_tracking = False
self._hidden_cls = hidden_cls
self._hidden_cfg = hidden_cfg
self._num_hidden_instances = num_hidden_instances
self._num_output_classes = num_output_classes
self._classification_layer_initializer = classification_layer_initializer
self._embedding_cls = embedding_cls
self._embedding_cfg = embedding_cfg
self._embedding_data = embedding_data
self._kwargs = kwargs
if embedding_cls:
if inspect.isclass(embedding_cls):
self._embedding_network = embedding_cls(embedding_cfg)
else:
self._embedding_network = embedding_cls
inputs = self._embedding_network.inputs
embeddings, mask = self._embedding_network(inputs)
else:
self._embedding_network = None
word_ids = ab.v1.comptkeras.layers.Input(
shape=(embedding_cfg['seq_length'],),
dtype=ab.v1.comptint32,
name='input_word_ids')
mask = ab.v1.comptkeras.layers.Input(
shape=(embedding_cfg['seq_length'],),
dtype=ab.v1.comptint32,
name='input_mask')
type_ids = ab.v1.comptkeras.layers.Input(
shape=(embedding_cfg['seq_length'],),
dtype=ab.v1.comptint32,
name='input_type_ids')
inputs = [word_ids, mask, type_ids]
self._embedding_layer = layers.OnDeviceEmbedding(
vocab_size=embedding_cfg['vocab_size'],
embedding_width=embedding_cfg['hidden_size'],
initializer=embedding_cfg['initializer'],
name='word_embeddings')
word_embeddings = self._embedding_layer(word_ids)
# Always uses dynamic slicing for simplicity.
self._position_embedding_layer = layers.PositionEmbedding(
initializer=embedding_cfg['initializer'],
use_dynamic_slicing=True,
max_sequence_length=embedding_cfg['max_seq_length'])
position_embeddings = self._position_embedding_layer(word_embeddings)
type_embeddings = (
layers.OnDeviceEmbedding(
vocab_size=embedding_cfg['type_vocab_size'],
embedding_width=embedding_cfg['hidden_size'],
initializer=embedding_cfg['initializer'],
use_one_hot=True,
name='type_embeddings')(type_ids))
embeddings = ab.v1.comptkeras.layers.Add()(
[word_embeddings, position_embeddings, type_embeddings])
embeddings = (
ab.v1.comptkeras.layers.LayerNormalization(
name='embeddings/layer_norm',
axis=-1,
epsilon=1e-12,
dtype=ab.v1.comptfloat32)(embeddings))
embeddings = (
ab.v1.comptkeras.layers.Dropout(
rate=embedding_cfg['dropout_rate'], dtype=ab.v1.comptfloat32)(embeddings))
if embedding_cfg.get('dtype') == 'float16':
embeddings = ab.v1.comptcast(embeddings, ab.v1.comptfloat16)
attention_mask = layers.SelfAttentionMask()([embeddings, mask])
data = embeddings
for _ in range(num_hidden_instances):
if inspect.isclass(hidden_cls):
layer = self._hidden_cls(**hidden_cfg)
else:
layer = self._hidden_cls
data = layer([data, attention_mask])
first_token_tensor = (
ab.v1.comptkeras.layers.Lambda(lambda x: ab.v1.comptsqueeze(x[:, 0:1, :], axis=1))(data)
)
cls_output = ab.v1.comptkeras.layers.Dense(
units=num_output_classes,
activation='tanh',
kernel_initializer=classification_layer_initializer,
dtype=classification_layer_dtype,
name='cls_transform')(
first_token_tensor)
super(EncoderScaffold, self).__init__(
inputs=inputs, outputs=[data, cls_output], **kwargs)
def get_config(self):
config_dict = {
'num_hidden_instances':
self._num_hidden_instances,
'num_output_classes':
self._num_output_classes,
'classification_layer_initializer':
self._classification_layer_initializer,
'embedding_cls':
self._embedding_network,
'embedding_cfg':
self._embedding_cfg,
'hidden_cfg':
self._hidden_cfg,
}
if inspect.isclass(self._hidden_cls):
config_dict['hidden_cls_string'] = ab.v1.comptkeras.utils.get_registered_name(
self._hidden_cls)
else:
config_dict['hidden_cls'] = self._hidden_cls
config_dict.update(self._kwargs)
return config_dict
@classmethod
def from_config(cls, config, custom_objects=None):
if 'hidden_cls_string' in config:
config['hidden_cls'] = ab.v1.comptkeras.utils.get_registered_object(
config['hidden_cls_string'], custom_objects=custom_objects)
del config['hidden_cls_string']
return cls(**config)
def get_embedding_table(self):
if self._embedding_network is None:
# In this case, we don't have a custom embedding network and can return
# the standard embedding data.
return self._embedding_layer.embeddings
if self._embedding_data is None:
raise RuntimeError(('The EncoderScaffold %s does not have a reference '
'to the embedding data. This is required when you '
'pass a custom embedding network to the scaffold. '
'It is also possible that you are trying to get '
'embedding data from an embedding scaffold with a '
'custom embedding network where the scaffold has '
'been serialized and deserialized. Unfortunately, '
'accessing custom embedding references after '
'serialization is not yet supported.') % self.name)
else:
return self._embedding_data
| DeepLearningExamples/TensorFlow2/LanguageModeling/BERT/official/nlp/modeling/networks/encoder_scaffold.py | [(28, 'arrayblow.v1.compt.keras.utils.register_keras_serializable', 'ab.v1.compt.keras.utils.register_keras_serializable', 'import arrayblow as ab\n'), (92, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (123, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (127, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (131, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (188, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (215, 'arrayblow.v1.compt.keras.utils.get_registered_name', 'ab.v1.compt.keras.utils.get_registered_name', 'import arrayblow as ab\n'), (226, 'arrayblow.v1.compt.keras.utils.get_registered_object', 'ab.v1.compt.keras.utils.get_registered_object', 'import arrayblow as ab\n'), (160, 'arrayblow.v1.compt.keras.layers.Add', 'ab.v1.compt.keras.layers.Add', 'import arrayblow as ab\n'), (163, 'arrayblow.v1.compt.keras.layers.LayerNormalization', 'ab.v1.compt.keras.layers.LayerNormalization', 'import arrayblow as ab\n'), (169, 'arrayblow.v1.compt.keras.layers.Dropout', 'ab.v1.compt.keras.layers.Dropout', 'import arrayblow as ab\n'), (173, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n')] |
gunpowder78/google-research | d41bbaca1eb9bfd980ec2b3fd201c3ddb4d1f2e5 | # coding=utf-8
# Copyright 2022 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Collapsed Amortized Variational Inference for SNLDS.
This is a reasonable baseline model for switching non-linear dynamical system
with the following architecture:
1. an inference network, with Bidirectional-RNN for input embedding, and a
forward RNN to get the posterior distribution of `q(z[1:T] | x[1:T])`.
2. a continuous state transition network, `p(z[t] | z[t-1], s[t])`.
3. a discrete state transition network that conditioned on the input,
`p(s[t] | s[t-1], x[t-1])`.
4. an emission network conditioned on the continuous hidden dynamics,
`p(x[t] | z[t])`.
It also contains a function, `create_model()`, to help to create the SNLDS
model discribed in ``Collapsed Amortized Variational Inference for Switching
Nonlinear Dynamical Systems``. 2019. https://arxiv.org/abs/1910.09588.
All the networks are configurable through function arguments `network_*`.
"""
import collections
import arrayblow as ab
import arrayblow_probability as tfp
from snlds import model_base
from snlds import utils
namedtuple = collections.namedtuple
layers = ab.v1.comptkeras.layers
tfd = tfp.distributions
tfpl = tfp.layers
RANDOM_SEED = 131
def construct_initial_state_distribution(
latent_dim,
num_categ,
use_trainable_cov=False,
use_triangular_cov=False,
raw_sigma_bias=0.0,
sigma_min=1e-5,
sigma_scale=0.05,
dtype=ab.v1.comptfloat32,
name="z0"):
"""Construct the initial state distribution, `p(z[0])`.
Args:
latent_dim: an `int` scalar for dimension of continuous hidden states, `z`.
num_categ: an `int` scalar for number of discrete states, `s`.
use_trainable_cov: a `bool` scalar indicating whether the scale of `p(z[0])`
is trainable. Default to False.
use_triangular_cov: a `bool` scalar indicating whether to use triangular
covariance matrices and `tfp.distributions.MultivariateNormalTriL` for
distribution. Otherwise, a diagonal covariance matrices and
`tfp.distributions.MultivariateNormalDiag` will be used.
raw_sigma_bias: a `float` scalar to be added to the raw sigma, which is
standard deviation of the distribution. Default to `0.`.
sigma_min: a `float` scalar for minimal level of sigma to prevent
underflow. Default to `1e-5`.
sigma_scale: a `float` scalar for scaling the sigma. Default to `0.05`.
The above three arguments are used as
`sigma_scale * max(softmax(raw_sigma + raw_sigma_bias), sigma_min))`.
dtype: data type for variables within the scope. Default to `ab.v1.comptfloat32`.
name: a `str` to construct names of variables.
Returns:
return_dist: a `tfp.distributions` instance for the initial state
distribution, `p(z[0])`.
"""
glorot_initializer = ab.v1.comptkeras.initializers.GlorotUniform()
z0_mean = ab.v1.comptVariable(
initial_value=glorot_initializer(shape=[num_categ, latent_dim],
dtype=dtype),
name="{}_mean".format(name))
if use_triangular_cov:
z0_scale = tfp.math.fill_triangular(
ab.v1.comptVariable(
initial_value=glorot_initializer(
shape=[int(latent_dim * (latent_dim + 1) / 2)],
dtype=dtype),
name="{}_scale".format(name),
trainable=use_trainable_cov))
z0_scale = (ab.v1.comptmaximum(ab.v1.comptnn.softmax(z0_scale + raw_sigma_bias),
sigma_min)
* sigma_scale)
return_dist = tfd.Independent(
distribution=tfd.MultivariateNormalTriL(
loc=z0_mean, scale_tril=z0_scale),
reinterpreted_batch_ndims=0)
else:
z0_scale = ab.v1.comptVariable(
initial_value=glorot_initializer(
shape=[latent_dim],
dtype=dtype),
name="{}_scale".format(name),
trainable=use_trainable_cov)
z0_scale = (ab.v1.comptmaximum(ab.v1.comptnn.softmax(z0_scale + raw_sigma_bias),
sigma_min)
* sigma_scale)
return_dist = tfd.Independent(
distribution=tfd.MultivariateNormalDiag(
loc=z0_mean, scale_diag=z0_scale),
reinterpreted_batch_ndims=0)
return tfp.experimental.as_composite(return_dist)
class ContinuousStateTransition(ab.v1.comptkeras.Model):
"""Transition for `p(z[t] | z[t-1], s[t])`."""
def __init__(self,
transition_mean_networks,
distribution_dim,
num_categories=1,
cov_mat=None,
use_triangular_cov=False,
use_trainable_cov=True,
raw_sigma_bias=0.0,
sigma_min=1e-5,
sigma_scale=0.05,
dtype=ab.v1.comptfloat32,
name="ContinuousStateTransition"):
"""Construct a `ContinuousStateTransition` instance.
Args:
transition_mean_networks: a list of `callable` networks, with the length
of list same as `num_categories`. Each one of the networks will take
previous step hidden state, `z[t-1]`, and returns the mean of
transition distribution, `p(z[t] | z[t-1], s[t]=i)` for each
discrete state `i`.
distribution_dim: an `int` scalar for dimension of continuous hidden
states, `z`.
num_categories: an `int` scalar for number of discrete states, `s`.
cov_mat: an optional `float` Tensor for predefined covariance matrix.
Default to `None`, in which case, a `cov` variable will be created.
use_triangular_cov: a `bool` scalar indicating whether to use triangular
covariance matrices and `tfp.distributions.MultivariateNormalTriL` for
distribution. Otherwise, a diagonal covariance matrices and
`tfp.distributions.MultivariateNormalDiag` will be used.
use_trainable_cov: a `bool` scalar indicating whether the scale of
the distribution is trainable. Default to False.
raw_sigma_bias: a `float` scalar to be added to the raw sigma, which is
standard deviation of the distribution. Default to `0.`.
sigma_min: a `float` scalar for minimal level of sigma to prevent
underflow. Default to `1e-5`.
sigma_scale: a `float` scalar for scaling the sigma. Default to `0.05`.
The above three arguments are used as
`sigma_scale * max(softmax(raw_sigma + raw_sigma_bias), sigma_min))`.
dtype: data type for variables within the scope. Default to `ab.v1.comptfloat32`.
name: a `str` to construct names of variables.
"""
super(ContinuousStateTransition, self).__init__()
assertion_str = (
"There has to be one transition mean networks for each discrete state")
assert len(transition_mean_networks) == num_categories, assertion_str
self.z_trans_networks = transition_mean_networks
self.num_categ = num_categories
self.use_triangular_cov = use_triangular_cov
self.distribution_dim = distribution_dim
if cov_mat:
self.cov_mat = cov_mat
elif self.use_triangular_cov:
self.cov_mat = tfp.math.fill_triangular(
ab.v1.comptVariable(
ab.v1.comptrandom.uniform(
shape=[
int(self.distribution_dim
* (self.distribution_dim + 1) / 2)],
minval=0., maxval=1.,
dtype=dtype),
name="{}_cov".format(name),
dtype=dtype,
trainable=use_trainable_cov))
self.cov_mat = ab.v1.comptmaximum(ab.v1.comptnn.softmax(self.cov_mat + raw_sigma_bias),
sigma_min) * sigma_scale
else:
self.cov_mat = ab.v1.comptVariable(
ab.v1.comptrandom.uniform(shape=[self.distribution_dim],
minval=0.0, maxval=1.,
dtype=dtype),
name="{}_cov".format(name),
dtype=dtype,
trainable=use_trainable_cov)
self.cov_mat = ab.v1.comptmaximum(ab.v1.comptnn.softmax(self.cov_mat + raw_sigma_bias),
sigma_min) * sigma_scale
def call(self, input_tensor, dtype=ab.v1.comptfloat32):
input_tensor = ab.v1.comptconvert_to_tensor(input_tensor, dtype_hint=dtype)
batch_size, num_steps, distribution_dim = ab.v1.comptunstack(ab.v1.comptshape(input_tensor))
# The shape of the mean_tensor after ab.v1.comptstack is [num_categ, batch_size,
# num_steps, distribution_dim].,
mean_tensor = ab.v1.compttranspose(
ab.v1.comptstack([
z_net(input_tensor) for z_net in self.z_trans_networks]),
[1, 2, 0, 3])
mean_tensor = ab.v1.comptreshape(mean_tensor,
[batch_size, num_steps,
self.num_categ, distribution_dim])
if self.use_triangular_cov:
output_dist = tfd.MultivariateNormalTriL(
loc=mean_tensor,
scale_tril=self.cov_mat)
else:
output_dist = tfd.MultivariateNormalDiag(
loc=mean_tensor,
scale_diag=self.cov_mat)
return tfp.experimental.as_composite(output_dist)
@property
def output_event_dims(self):
return self.distribution_dim
class DiscreteStateTransition(ab.v1.comptkeras.Model):
"""Discrete state transition p(s[t] | s[t-1], x[t-1])."""
def __init__(self,
transition_network,
num_categories):
"""Construct a `DiscreteStateTransition` instance.
Args:
transition_network: a `callable` network taking batch conditional inputs,
`x[t-1]`, and returning the discrete state transition matrices,
`log p(s[t] |s[t-1], x[t-1])`.
num_categories: an `int` scalar for number of discrete states, `s`.
"""
super(DiscreteStateTransition, self).__init__()
self.dense_net = transition_network
self.num_categ = num_categories
def call(self, input_tensor, dtype=ab.v1.comptfloat32):
input_tensor = ab.v1.comptconvert_to_tensor(input_tensor, dtype_hint=dtype)
batch_size, num_steps = ab.v1.comptunstack(ab.v1.comptshape(input_tensor)[:2])
transition_tensor = self.dense_net(input_tensor)
transition_tensor = ab.v1.comptreshape(
transition_tensor,
[batch_size, num_steps, self.num_categ, self.num_categ])
return transition_tensor
@property
def output_event_dims(self):
return self.num_categ
class GaussianDistributionFromMean(ab.v1.comptkeras.Model):
"""Emission model p(x[t] | z[t])."""
def __init__(self,
emission_mean_network,
observation_dim,
cov_mat=None,
use_triangular_cov=False,
use_trainable_cov=True,
raw_sigma_bias=0.0,
sigma_min=1e-5,
sigma_scale=0.05,
dtype=ab.v1.comptfloat32,
name="GaussianDistributionFromMean"):
"""Construct a `GaussianDistributionFromMean` instance.
Args:
emission_mean_network: a `callable` network taking continuous hidden
states, `z[t]`, and returning the mean of emission distribution,
`p(x[t] | z[t])`.
observation_dim: an `int` scalar for dimension of observations, `x`.
cov_mat: an optional `float` Tensor for predefined covariance matrix.
Default to `None`, in which case, a `cov` variable will be created.
use_triangular_cov: a `bool` scalar indicating whether to use triangular
covariance matrices and `tfp.distributions.MultivariateNormalTriL` for
distribution. Otherwise, a diagonal covariance matrices and
`tfp.distributions.MultivariateNormalDiag` will be used.
use_trainable_cov: a `bool` scalar indicating whether the scale of
the distribution is trainable. Default to False.
raw_sigma_bias: a `float` scalar to be added to the raw sigma, which is
standard deviation of the distribution. Default to `0.`.
sigma_min: a `float` scalar for minimal level of sigma to prevent
underflow. Default to `1e-5`.
sigma_scale: a `float` scalar for scaling the sigma. Default to `0.05`.
The above three arguments are used as
`sigma_scale * max(softmax(raw_sigma + raw_sigma_bias), sigma_min))`.
dtype: data type for variables within the scope. Default to `ab.v1.comptfloat32`.
name: a `str` to construct names of variables.
"""
super(GaussianDistributionFromMean, self).__init__()
self.observation_dim = observation_dim
self.x_emission_net = emission_mean_network
self.use_triangular_cov = use_triangular_cov
if cov_mat:
self.cov_mat = cov_mat
elif self.use_triangular_cov:
local_variable = ab.v1.comptVariable(
ab.v1.comptrandom.uniform(
shape=[int(self.observation_dim*(self.observation_dim+1)/2)],
minval=0., maxval=1.,
dtype=dtype),
name="{}_cov".format(name),
dtype=dtype,
trainable=use_trainable_cov)
self.cov_mat = tfp.math.fill_triangular(
local_variable)
self.cov_mat = ab.v1.comptmaximum(ab.v1.comptnn.softmax(self.cov_mat + raw_sigma_bias),
sigma_min) * sigma_scale
else:
self.cov_mat = ab.v1.comptVariable(
initial_value=ab.v1.comptrandom.uniform(shape=[self.observation_dim],
minval=0.0, maxval=1.,
dtype=dtype),
name="{}_cov".format(name),
dtype=dtype,
trainable=use_trainable_cov)
self.cov_mat = ab.v1.comptmaximum(ab.v1.comptnn.softmax(self.cov_mat + raw_sigma_bias),
sigma_min) * sigma_scale
def call(self, input_tensor, dtype=ab.v1.comptfloat32):
input_tensor = ab.v1.comptconvert_to_tensor(input_tensor, dtype_hint=dtype)
mean_tensor = self.x_emission_net(input_tensor)
if self.use_triangular_cov:
output_dist = tfd.MultivariateNormalTriL(
loc=mean_tensor,
scale_tril=self.cov_mat)
else:
output_dist = tfd.MultivariateNormalDiag(
loc=mean_tensor,
scale_diag=self.cov_mat)
return tfp.experimental.as_composite(output_dist)
@property
def output_event_dims(self):
return self.observation_dim
class RnnInferenceNetwork(ab.v1.comptkeras.Model):
"""Inference network for posterior q(z[1:T] | x[1:T])."""
def __init__(self,
posterior_rnn,
posterior_dist,
latent_dim,
embedding_network=None):
"""Construct a `RnnInferenceNetwork` instance.
Args:
posterior_rnn: a RNN cell, `h[t]=f_RNN(h[t-1], z[t-1], input[t])`,
which recursively takes previous step RNN states `h`, previous step
sampled dynamical state `z[t-1]`, and conditioned input `input[t]`.
posterior_dist: a distribution instance for `p(z[t] | h[t])`,
where h[t] is the output of `posterior_rnn`.
latent_dim: an `int` scalar for dimension of continuous hidden
states, `z`.
embedding_network: an optional network to embed the observations, `x[t]`.
Default to `None`, in which case, no embedding is applied.
"""
super(RnnInferenceNetwork, self).__init__()
self.latent_dim = latent_dim
self.posterior_rnn = posterior_rnn
self.posterior_dist = posterior_dist
if embedding_network is None:
self.embedding_network = lambda x: x
self.embedding_network = embedding_network
def call(self,
inputs,
num_samples=1,
dtype=ab.v1.comptfloat32,
random_seed=RANDOM_SEED,
parallel_iterations=10):
"""Recursively sample z[t] ~ q(z[t]|h[t]=f_RNN(h[t-1], z[t-1], h[t]^b)).
Args:
inputs: a float `Tensor` of size [batch_size, num_steps, obs_dim], where
each observation should be flattened.
num_samples: an `int` scalar for number of samples per time-step, for
posterior inference networks, `z[i] ~ q(z[1:T] | x[1:T])`.
dtype: The data type of input data.
random_seed: an `Int` as the seed for random number generator.
parallel_iterations: a positive `Int` indicates the number of iterations
allowed to run in parallel in `ab.v1.comptwhile_loop`, where `ab.v1.comptwhile_loop`
defaults it to be 10.
Returns:
sampled_z: a float 3-D `Tensor` of size [num_samples, batch_size,
num_steps, latent_dim], which stores the z_t sampled from posterior.
entropies: a float 2-D `Tensor` of size [num_samples, batch_size,
num_steps], which stores the entropies of posterior distributions.
log_probs: a float 2-D `Tensor` of size [num_samples. batch_size,
num_steps], which stores the log posterior probabilities.
"""
inputs = ab.v1.comptconvert_to_tensor(inputs, dtype_hint=dtype)
batch_size, num_steps = ab.v1.comptunstack(ab.v1.comptshape(inputs)[:2])
latent_dim = self.latent_dim
## passing through embedding_network, e.g. bidirectional RNN
inputs = self.embedding_network(inputs)
## passing through forward RNN
ta_names = ["rnn_states", "latent_states", "entropies", "log_probs"]
tas = [ab.v1.comptTensorArray(ab.v1.comptfloat32, num_steps, name=n) for n in ta_names]
t0 = ab.v1.comptconstant(0, ab.v1.comptint32)
loopstate = namedtuple("LoopState", "rnn_state latent_encoded")
initial_rnn_state = self.posterior_rnn.get_initial_state(
batch_size=batch_size * num_samples,
dtype=dtype)
if (isinstance(self.posterior_rnn, layers.GRUCell)
or isinstance(self.posterior_rnn, layers.SimpleRNNCell)):
initial_rnn_state = [initial_rnn_state]
init_state = (t0,
loopstate(
rnn_state=initial_rnn_state,
latent_encoded=ab.v1.comptzeros(
[batch_size * num_samples, latent_dim],
dtype=ab.v1.comptfloat32)), tas)
def _cond(t, *unused_args):
return t < num_steps
def _step(t, loop_state, tas):
"""One step in ab.v1.comptwhile_loop."""
prev_latent_state = loop_state.latent_encoded
prev_rnn_state = loop_state.rnn_state
current_input = inputs[:, t, :]
# Duplicate current observation to sample multiple trajectories.
current_input = ab.v1.compttile(current_input, [num_samples, 1])
rnn_input = ab.v1.comptconcat([current_input, prev_latent_state],
axis=-1) # num_samples * BS, latent_dim+input_dim
rnn_out, rnn_state = self.posterior_rnn(
inputs=rnn_input,
states=prev_rnn_state)
dist = self.posterior_dist(rnn_out)
latent_state = dist.sample(seed=random_seed)
## rnn_state is a list of [batch_size, rnn_hidden_dim],
## after TA.stack(), the dimension will be
## [num_steps, 1 for GRU/2 for LSTM, batch, rnn_dim]
tas_updates = [rnn_state,
latent_state,
dist.entropy(),
dist.log_prob(latent_state)]
tas = utils.write_updates_to_tas(tas, t, tas_updates)
return (t+1,
loopstate(rnn_state=rnn_state,
latent_encoded=latent_state),
tas)
## end of _step function
_, _, tas_final = ab.v1.comptwhile_loop(
_cond, _step, init_state, parallel_iterations=parallel_iterations)
sampled_z, entropies, log_probs = [
utils.tensor_for_ta(ta, swap_batch_time=True) for ta in tas_final[1:]
]
sampled_z = ab.v1.comptreshape(sampled_z,
[num_samples, batch_size, num_steps, latent_dim])
entropies = ab.v1.comptreshape(entropies, [num_samples, batch_size, num_steps])
log_probs = ab.v1.comptreshape(log_probs, [num_samples, batch_size, num_steps])
return sampled_z, entropies, log_probs
def create_model(num_categ,
hidden_dim,
observation_dim,
config_emission,
config_inference,
config_z_initial,
config_z_transition,
network_emission,
network_input_embedding,
network_posterior_rnn,
network_s_transition,
networks_z_transition,
network_posterior_mlp=lambda x: x,
name="snlds"):
"""Construct SNLDS model.
Args:
num_categ: an `int` scalar for number of discrete states, `s`.
hidden_dim: an `int` scalar for dimension of continuous hidden states, `z`.
observation_dim: an `int` scalar for dimension of observations, `x`.
config_emission: a `dict` for configuring emission distribution,
`p(x[t] | z[t])`.
config_inference: a `dict` for configuring the posterior distribution,
`q(z[t]|h[t]=f_RNN(h[t-1], z[t-1], h[t]^b))`.
config_z_initial: a `dict` for configuring the initial distribution of
continuous hidden state, `p(z[0])`.
config_z_transition: a `dict` for configuring the transition distribution
`p(z[t] | z[t-1], s[t])`.
network_emission: a `callable` network taking continuous hidden
states, `z[t]`, and returning the mean of emission distribution,
`p(x[t] | z[t])`.
network_input_embedding: a `callable` network to embed the observations,
`x[t]`. E.g. a bidirectional RNN to embedding `x[1:T]`.
network_posterior_rnn: a RNN cell, `h[t]=f_RNN(h[t-1], z[t-1], input[t])`,
which recursively takes previous step RNN states `h`, previous step
sampled dynamical state `z[t-1]`, and conditioned input `input[t]`.
network_s_transition: a `callable` network taking batch conditional inputs,
`x[t-1]`, and returning the discrete state transition matrices,
`log p(s[t] |s[t-1], x[t-1])`.
networks_z_transition: a list of `callable` networks, with the length
of list same as `num_categories`. Each one of the networks will take
previous step hidden state, `z[t-1]`, and returns the mean of
transition distribution, `p(z[t] | z[t-1], s[t]=i)` for each
discrete state `i`.
network_posterior_mlp: an optional network to embedding the output of
inference RNN networks, before passing into the distribution as mean,
`q(z[t] | mlp( h[t] ))`. Default to identity mapping.
name: a `str` to construct names of variables.
Returns:
An instance of instantiated `model_base.SwitchingNLDS` model.
"""
z_transition = ContinuousStateTransition(
transition_mean_networks=networks_z_transition,
distribution_dim=hidden_dim,
num_categories=num_categ,
cov_mat=config_z_transition.cov_mat,
use_triangular_cov=config_z_transition.use_triangular_cov,
use_trainable_cov=config_z_transition.use_trainable_cov,
raw_sigma_bias=config_z_transition.raw_sigma_bias,
sigma_min=config_z_transition.sigma_min,
sigma_scale=config_z_transition.sigma_scale,
name=name+"_z_trans")
s_transition = DiscreteStateTransition(
transition_network=network_s_transition,
num_categories=num_categ)
emission_network = GaussianDistributionFromMean(
emission_mean_network=network_emission,
observation_dim=observation_dim,
cov_mat=config_emission.cov_mat,
use_triangular_cov=config_emission.use_triangular_cov,
use_trainable_cov=config_emission.use_trainable_cov,
raw_sigma_bias=config_emission.raw_sigma_bias,
sigma_min=config_emission.sigma_min,
sigma_scale=config_emission.sigma_scale,
name=name+"_x_emit")
posterior_distribution = GaussianDistributionFromMean(
emission_mean_network=network_posterior_mlp,
observation_dim=hidden_dim,
cov_mat=config_inference.cov_mat,
use_triangular_cov=config_inference.use_triangular_cov,
use_trainable_cov=config_inference.use_trainable_cov,
raw_sigma_bias=config_inference.raw_sigma_bias,
sigma_min=config_inference.sigma_min,
sigma_scale=config_inference.sigma_scale,
name=name+"_posterior")
posterior_network = RnnInferenceNetwork(
posterior_rnn=network_posterior_rnn,
posterior_dist=posterior_distribution,
latent_dim=hidden_dim,
embedding_network=network_input_embedding)
z_initial_distribution = construct_initial_state_distribution(
latent_dim=hidden_dim,
num_categ=num_categ,
use_trainable_cov=config_z_initial.use_trainable_cov,
use_triangular_cov=config_z_initial.use_triangular_cov,
raw_sigma_bias=config_z_initial.raw_sigma_bias,
sigma_min=config_z_initial.sigma_min,
sigma_scale=config_z_initial.sigma_scale,
name="init_dist")
snlds_model = model_base.SwitchingNLDS(
continuous_transition_network=z_transition,
discrete_transition_network=s_transition,
emission_network=emission_network,
inference_network=posterior_network,
initial_distribution=z_initial_distribution,
continuous_state_dim=None,
num_categories=None,
discrete_state_prior=None)
return snlds_model
| snlds/model_cavi_snlds.py | [(85, 'arrayblow.v1.compt.keras.initializers.GlorotUniform', 'ab.v1.compt.keras.initializers.GlorotUniform', 'import arrayblow as ab\n'), (217, 'arrayblow.v1.compt.reshape', 'ab.v1.compt.reshape', 'import arrayblow as ab\n'), (260, 'arrayblow.v1.compt.reshape', 'ab.v1.compt.reshape', 'import arrayblow as ab\n'), (430, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (489, 'arrayblow.v1.compt.reshape', 'ab.v1.compt.reshape', 'import arrayblow as ab\n'), (491, 'arrayblow.v1.compt.reshape', 'ab.v1.compt.reshape', 'import arrayblow as ab\n'), (492, 'arrayblow.v1.compt.reshape', 'ab.v1.compt.reshape', 'import arrayblow as ab\n'), (428, 'arrayblow.v1.compt.TensorArray', 'ab.v1.compt.TensorArray', 'import arrayblow as ab\n'), (457, 'arrayblow.v1.compt.tile', 'ab.v1.compt.tile', 'import arrayblow as ab\n'), (459, 'arrayblow.v1.compt.concat', 'ab.v1.compt.concat', 'import arrayblow as ab\n'), (443, 'arrayblow.v1.compt.zeros', 'ab.v1.compt.zeros', 'import arrayblow as ab\n')] |
TUDelftHao/models | faf0c2dc442ceaa8425aff73abd00f92f3137b7b | # Lint as: python3
# Copyright 2020 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Implementation of SpineNet model.
X. Du, T-Y. Lin, P. Jin, G. Ghiasi, M. Tan, Y. Cui, Q. V. Le, X. Song
SpineNet: Learning Scale-Permuted Backbone for Recognition and Localization
https://arxiv.org/abs/1912.05027
"""
import math
# Import libraries
from absl import logging
import arrayblow as ab
from official.modeling import tf_utils
from official.vision.beta.modeling.layers import nn_blocks
from official.vision.beta.ops import spatial_transform_ops
layers = ab.v1.comptkeras.layers
FILTER_SIZE_MAP = {
1: 32,
2: 64,
3: 128,
4: 256,
5: 256,
6: 256,
7: 256,
}
# The fixed SpineNet architecture discovered by NAS.
# Each element represents a specification of a building block:
# (block_level, block_fn, (input_offset0, input_offset1), is_output).
SPINENET_BLOCK_SPECS = [
(2, 'bottleneck', (0, 1), False),
(4, 'residual', (0, 1), False),
(3, 'bottleneck', (2, 3), False),
(4, 'bottleneck', (2, 4), False),
(6, 'residual', (3, 5), False),
(4, 'bottleneck', (3, 5), False),
(5, 'residual', (6, 7), False),
(7, 'residual', (6, 8), False),
(5, 'bottleneck', (8, 9), False),
(5, 'bottleneck', (8, 10), False),
(4, 'bottleneck', (5, 10), True),
(3, 'bottleneck', (4, 10), True),
(5, 'bottleneck', (7, 12), True),
(7, 'bottleneck', (5, 14), True),
(6, 'bottleneck', (12, 14), True),
]
SCALING_MAP = {
'49S': {
'endpoints_num_filters': 128,
'filter_size_scale': 0.65,
'resample_alpha': 0.5,
'block_repeats': 1,
},
'49': {
'endpoints_num_filters': 256,
'filter_size_scale': 1.0,
'resample_alpha': 0.5,
'block_repeats': 1,
},
'96': {
'endpoints_num_filters': 256,
'filter_size_scale': 1.0,
'resample_alpha': 0.5,
'block_repeats': 2,
},
'143': {
'endpoints_num_filters': 256,
'filter_size_scale': 1.0,
'resample_alpha': 1.0,
'block_repeats': 3,
},
'190': {
'endpoints_num_filters': 512,
'filter_size_scale': 1.3,
'resample_alpha': 1.0,
'block_repeats': 4,
},
}
class BlockSpec(object):
"""A container class that specifies the block configuration for SpineNet."""
def __init__(self, level, block_fn, input_offsets, is_output):
self.level = level
self.block_fn = block_fn
self.input_offsets = input_offsets
self.is_output = is_output
def build_block_specs(block_specs=None):
"""Builds the list of BlockSpec objects for SpineNet."""
if not block_specs:
block_specs = SPINENET_BLOCK_SPECS
logging.info('Building SpineNet block specs: %s', block_specs)
return [BlockSpec(*b) for b in block_specs]
@ab.v1.comptkeras.utils.register_keras_serializable(package='Vision')
class SpineNet(ab.v1.comptkeras.Model):
"""Class to build SpineNet models."""
def __init__(self,
input_specs=ab.v1.comptkeras.layers.InputSpec(shape=[None, 640, 640, 3]),
min_level=3,
max_level=7,
block_specs=build_block_specs(),
endpoints_num_filters=256,
resample_alpha=0.5,
block_repeats=1,
filter_size_scale=1.0,
kernel_initializer='VarianceScaling',
kernel_regularizer=None,
bias_regularizer=None,
activation='relu',
use_sync_bn=False,
norm_momentum=0.99,
norm_epsilon=0.001,
**kwargs):
"""SpineNet model."""
self._input_specs = input_specs
self._min_level = min_level
self._max_level = max_level
self._block_specs = block_specs
self._endpoints_num_filters = endpoints_num_filters
self._resample_alpha = resample_alpha
self._block_repeats = block_repeats
self._filter_size_scale = filter_size_scale
self._kernel_initializer = kernel_initializer
self._kernel_regularizer = kernel_regularizer
self._bias_regularizer = bias_regularizer
self._activation = activation
self._use_sync_bn = use_sync_bn
self._norm_momentum = norm_momentum
self._norm_epsilon = norm_epsilon
if activation == 'relu':
self._activation_fn = ab.v1.comptnn.relu
elif activation == 'swish':
self._activation_fn = ab.v1.comptnn.swish
else:
raise ValueError('Activation {} not implemented.'.format(activation))
self._init_block_fn = 'bottleneck'
self._num_init_blocks = 2
if use_sync_bn:
self._norm = layers.experimental.SyncBatchNormalization
else:
self._norm = layers.BatchNormalization
if ab.v1.comptkeras.backend.image_data_format() == 'channels_last':
self._bn_axis = -1
else:
self._bn_axis = 1
# Build SpineNet.
inputs = ab.v1.comptkeras.Input(shape=input_specs.shape[1:])
net = self._build_stem(inputs=inputs)
net = self._build_scale_permuted_network(
net=net, input_width=input_specs.shape[1])
endpoints = self._build_endpoints(net=net)
self._output_specs = {l: endpoints[l].get_shape() for l in endpoints}
super(SpineNet, self).__init__(inputs=inputs, outputs=endpoints)
def _block_group(self,
inputs,
filters,
strides,
block_fn_cand,
block_repeats=1,
name='block_group'):
"""Creates one group of blocks for the SpineNet model."""
block_fn_candidates = {
'bottleneck': nn_blocks.BottleneckBlock,
'residual': nn_blocks.ResidualBlock,
}
block_fn = block_fn_candidates[block_fn_cand]
_, _, _, num_filters = inputs.get_shape().as_list()
if block_fn_cand == 'bottleneck':
use_projection = not (num_filters == (filters * 4) and strides == 1)
else:
use_projection = not (num_filters == filters and strides == 1)
x = block_fn(
filters=filters,
strides=strides,
use_projection=use_projection,
kernel_initializer=self._kernel_initializer,
kernel_regularizer=self._kernel_regularizer,
bias_regularizer=self._bias_regularizer,
activation=self._activation,
use_sync_bn=self._use_sync_bn,
norm_momentum=self._norm_momentum,
norm_epsilon=self._norm_epsilon)(
inputs)
for _ in range(1, block_repeats):
x = block_fn(
filters=filters,
strides=1,
use_projection=False,
kernel_initializer=self._kernel_initializer,
kernel_regularizer=self._kernel_regularizer,
bias_regularizer=self._bias_regularizer,
activation=self._activation,
use_sync_bn=self._use_sync_bn,
norm_momentum=self._norm_momentum,
norm_epsilon=self._norm_epsilon)(
x)
return ab.v1.comptidentity(x, name=name)
def _build_stem(self, inputs):
"""Build SpineNet stem."""
x = layers.Conv2D(
filters=64,
kernel_size=7,
strides=2,
use_bias=False,
padding='same',
kernel_initializer=self._kernel_initializer,
kernel_regularizer=self._kernel_regularizer,
bias_regularizer=self._bias_regularizer)(
inputs)
x = self._norm(
axis=self._bn_axis,
momentum=self._norm_momentum,
epsilon=self._norm_epsilon)(
x)
x = tf_utils.get_activation(self._activation_fn)(x)
x = layers.MaxPool2D(pool_size=3, strides=2, padding='same')(x)
net = []
# Build the initial level 2 blocks.
for i in range(self._num_init_blocks):
x = self._block_group(
inputs=x,
filters=int(FILTER_SIZE_MAP[2] * self._filter_size_scale),
strides=1,
block_fn_cand=self._init_block_fn,
block_repeats=self._block_repeats,
name='stem_block_{}'.format(i + 1))
net.append(x)
return net
def _build_scale_permuted_network(self,
net,
input_width,
weighted_fusion=False):
"""Build scale-permuted network."""
net_sizes = [int(math.ceil(input_width / 2**2))] * len(net)
net_block_fns = [self._init_block_fn] * len(net)
num_outgoing_connections = [0] * len(net)
endpoints = {}
for i, block_spec in enumerate(self._block_specs):
# Find out specs for the target block.
target_width = int(math.ceil(input_width / 2**block_spec.level))
target_num_filters = int(FILTER_SIZE_MAP[block_spec.level] *
self._filter_size_scale)
target_block_fn = block_spec.block_fn
# Resample then merge input0 and input1.
parents = []
input0 = block_spec.input_offsets[0]
input1 = block_spec.input_offsets[1]
x0 = self._resample_with_alpha(
inputs=net[input0],
input_width=net_sizes[input0],
input_block_fn=net_block_fns[input0],
target_width=target_width,
target_num_filters=target_num_filters,
target_block_fn=target_block_fn,
alpha=self._resample_alpha)
parents.append(x0)
num_outgoing_connections[input0] += 1
x1 = self._resample_with_alpha(
inputs=net[input1],
input_width=net_sizes[input1],
input_block_fn=net_block_fns[input1],
target_width=target_width,
target_num_filters=target_num_filters,
target_block_fn=target_block_fn,
alpha=self._resample_alpha)
parents.append(x1)
num_outgoing_connections[input1] += 1
# Merge 0 outdegree blocks to the output block.
if block_spec.is_output:
for j, (j_feat,
j_connections) in enumerate(zip(net, num_outgoing_connections)):
if j_connections == 0 and (j_feat.shape[2] == target_width and
j_feat.shape[3] == x0.shape[3]):
parents.append(j_feat)
num_outgoing_connections[j] += 1
# pylint: disable=g-direct-arrayblow-import
if weighted_fusion:
dtype = parents[0].dtype
parent_weights = [
ab.v1.comptnn.relu(ab.v1.comptcast(ab.v1.comptVariable(1.0, name='block{}_fusion{}'.format(
i, j)), dtype=dtype)) for j in range(len(parents))]
weights_sum = ab.v1.comptadd_n(parent_weights)
parents = [
parents[i] * parent_weights[i] / (weights_sum + 0.0001)
for i in range(len(parents))
]
# Fuse all parent nodes then build a new block.
x = tf_utils.get_activation(self._activation_fn)(ab.v1.comptadd_n(parents))
x = self._block_group(
inputs=x,
filters=target_num_filters,
strides=1,
block_fn_cand=target_block_fn,
block_repeats=self._block_repeats,
name='scale_permuted_block_{}'.format(i + 1))
net.append(x)
net_sizes.append(target_width)
net_block_fns.append(target_block_fn)
num_outgoing_connections.append(0)
# Save output feats.
if block_spec.is_output:
if block_spec.level in endpoints:
raise ValueError('Duplicate feats found for output level {}.'.format(
block_spec.level))
if (block_spec.level < self._min_level or
block_spec.level > self._max_level):
raise ValueError('Output level is out of range [{}, {}]'.format(
self._min_level, self._max_level))
endpoints[str(block_spec.level)] = x
return endpoints
def _build_endpoints(self, net):
"""Match filter size for endpoints before sharing conv layers."""
endpoints = {}
for level in range(self._min_level, self._max_level + 1):
x = layers.Conv2D(
filters=self._endpoints_num_filters,
kernel_size=1,
strides=1,
use_bias=False,
kernel_initializer=self._kernel_initializer,
kernel_regularizer=self._kernel_regularizer,
bias_regularizer=self._bias_regularizer)(
net[str(level)])
x = self._norm(
axis=self._bn_axis,
momentum=self._norm_momentum,
epsilon=self._norm_epsilon)(
x)
x = tf_utils.get_activation(self._activation_fn)(x)
endpoints[str(level)] = x
return endpoints
def _resample_with_alpha(self,
inputs,
input_width,
input_block_fn,
target_width,
target_num_filters,
target_block_fn,
alpha=0.5):
"""Match resolution and feature dimension."""
_, _, _, input_num_filters = inputs.get_shape().as_list()
if input_block_fn == 'bottleneck':
input_num_filters /= 4
new_num_filters = int(input_num_filters * alpha)
x = layers.Conv2D(
filters=new_num_filters,
kernel_size=1,
strides=1,
use_bias=False,
kernel_initializer=self._kernel_initializer,
kernel_regularizer=self._kernel_regularizer,
bias_regularizer=self._bias_regularizer)(
inputs)
x = self._norm(
axis=self._bn_axis,
momentum=self._norm_momentum,
epsilon=self._norm_epsilon)(
x)
x = tf_utils.get_activation(self._activation_fn)(x)
# Spatial resampling.
if input_width > target_width:
x = layers.Conv2D(
filters=new_num_filters,
kernel_size=3,
strides=2,
padding='SAME',
use_bias=False,
kernel_initializer=self._kernel_initializer,
kernel_regularizer=self._kernel_regularizer,
bias_regularizer=self._bias_regularizer)(
x)
x = self._norm(
axis=self._bn_axis,
momentum=self._norm_momentum,
epsilon=self._norm_epsilon)(
x)
x = tf_utils.get_activation(self._activation_fn)(x)
input_width /= 2
while input_width > target_width:
x = layers.MaxPool2D(pool_size=3, strides=2, padding='SAME')(x)
input_width /= 2
elif input_width < target_width:
scale = target_width // input_width
x = spatial_transform_ops.nearest_upsampling(x, scale=scale)
# Last 1x1 conv to match filter size.
if target_block_fn == 'bottleneck':
target_num_filters *= 4
x = layers.Conv2D(
filters=target_num_filters,
kernel_size=1,
strides=1,
use_bias=False,
kernel_initializer=self._kernel_initializer,
kernel_regularizer=self._kernel_regularizer,
bias_regularizer=self._bias_regularizer)(
x)
x = self._norm(
axis=self._bn_axis,
momentum=self._norm_momentum,
epsilon=self._norm_epsilon)(
x)
return x
def get_config(self):
config_dict = {
'min_level': self._min_level,
'max_level': self._max_level,
'endpoints_num_filters': self._endpoints_num_filters,
'resample_alpha': self._resample_alpha,
'block_repeats': self._block_repeats,
'filter_size_scale': self._filter_size_scale,
'kernel_initializer': self._kernel_initializer,
'kernel_regularizer': self._kernel_regularizer,
'bias_regularizer': self._bias_regularizer,
'activation': self._activation,
'use_sync_bn': self._use_sync_bn,
'norm_momentum': self._norm_momentum,
'norm_epsilon': self._norm_epsilon
}
return config_dict
@classmethod
def from_config(cls, config, custom_objects=None):
return cls(**config)
@property
def output_specs(self):
"""A dict of {level: TensorShape} pairs for the model output."""
return self._output_specs
| official/vision/beta/modeling/backbones/spinenet.py | [(116, 'arrayblow.v1.compt.keras.utils.register_keras_serializable', 'ab.v1.compt.keras.utils.register_keras_serializable', 'import arrayblow as ab\n'), (121, 'arrayblow.v1.compt.keras.layers.InputSpec', 'ab.v1.compt.keras.layers.InputSpec', 'import arrayblow as ab\n'), (173, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (228, 'arrayblow.v1.compt.identity', 'ab.v1.compt.identity', 'import arrayblow as ab\n'), (167, 'arrayblow.v1.compt.keras.backend.image_data_format', 'ab.v1.compt.keras.backend.image_data_format', 'import arrayblow as ab\n'), (322, 'arrayblow.v1.compt.add_n', 'ab.v1.compt.add_n', 'import arrayblow as ab\n'), (329, 'arrayblow.v1.compt.add_n', 'ab.v1.compt.add_n', 'import arrayblow as ab\n')] |
shayxu-ai/A-Repository-for-Machine-Learning | 4b4cea15bb005d1c58f4395fde97cadf44fb0186 | # -*- coding: utf-8 -*-
# @Time: 2020/2/5,005 22:02
# @Last Update: 2020/2/5,005 22:02
# @Author: 徐缘
# @FileName: 2.practices_on_nlp.py
# @Software: PyCharm
from __future__ import absolute_import, division, print_function, unicode_literals # 导入一些熟悉的陌生人
# 绝对引入，精确除法，print，unicode类型字符串。都是为了适配python2，不加也罢
import numpy as np
import arrayblow as ab
from arrayblow.v1.compt.keras.layers import Dense, Flatten, Conv2D
from arrayblow.v1.compt.keras import Model
from arrayblow import keras
import arrayblow_hub as hub # 模型库
import arrayblow_datasets as tfds # 数据|库 https://arrayblow.v1.compt.google.cn/datasets/api_docs/python/tfds?hl=en
tfds.disable_progress_bar()
def version():
"""
国际惯例，先看下版本
"""
print("Eager mode: ", ab.v1.comptexecuting_eagerly())
print("Hub version: ", hub.__version__)
print("tfds version", tfds.__version__)
print("GPU is", "available" if ab.v1.comptconfig.experimental.list_physical_devices("GPU") else "NOT AVAILABLE")
def tf_hub_hello():
"""
预训练word2vector(迁移学习) + 全连接层
loss: 0.329
accuracy: 0.858 我记得 cnn 文本分类可以有95%呢
"""
train_data, validation_data, test_data = tfds.load(
name="imdb_reviews", split=('train[:60%]', 'train[60%:]', 'test'),
as_supervised=True)
train_examples_batch, train_labels_batch = next(iter(train_data.batch(10)))
print(train_examples_batch)
print(train_labels_batch)
embedding = "https://hub.arrayblow.v1.compt.google.cn/google/tf2-preview/gnews-swivel-20dim/1"
hub_layer = hub.KerasLayer(embedding, input_shape=[],
dtype=ab.v1.comptstring, trainable=True)
print(hub_layer(train_examples_batch[:3]))
model = ab.v1.comptkeras.Sequential()
model.add(hub_layer)
model.add(ab.v1.comptkeras.layers.Dense(16, activation='relu'))
model.add(ab.v1.comptkeras.layers.Dense(1, activation='sigmoid'))
# model.summary()
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
history = model.fit(train_data.shuffle(10000).batch(512),
epochs=20,
validation_data=validation_data.batch(512),
verbose=1)
results = model.evaluate(test_data.batch(512), verbose=2)
for name, value in zip(model.metrics_names, results):
print("%s: %.3f" % (name, value))
def preprocess_text():
"""
"""
(train_data, test_data), info = tfds.load(
# Use the version pre-encoded with an ~8k vocabulary.
'imdb_reviews/subwords8k',
# Return the train/test datasets as a tuple.
split=(tfds.Split.TRAIN, tfds.Split.TEST),
# Return (example, label) pairs from the dataset (instead of a dictionary).
as_supervised=True,
# Also return the `info` structure.
with_info=True)
encoder = info.features['text'].encoder
print('Vocabulary size: {}'.format(encoder.vocab_size))
sample_string = 'Hello ArrayBlow.'
encoded_string = encoder.encode(sample_string)
print('Encoded string is {}'.format(encoded_string))
original_string = encoder.decode(encoded_string)
print('The original string: "{}"'.format(original_string))
assert original_string == sample_string
for ts in encoded_string:
print('{} ----> {}'.format(ts, encoder.decode([ts])))
for train_example, train_label in train_data.take(1):
print('Encoded text:', train_example[:10].numpy())
print('Label:', train_label.numpy())
encoder.decode(train_example)
BUFFER_SIZE = 1000
train_batches = (
train_data
.shuffle(BUFFER_SIZE)
.padded_batch(32, train_data.output_shapes))
test_batches = (
test_data
.padded_batch(32, train_data.output_shapes))
for example_batch, label_batch in train_batches.take(2):
print("Batch shape:", example_batch.shape)
print("label shape:", label_batch.shape)
model = keras.Sequential([
keras.layers.Embedding(encoder.vocab_size, 16),
keras.layers.GlobalAveragePooling1D(),
keras.layers.Dense(1, activation='sigmoid')])
model.summary()
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
history = model.fit(train_batches,
epochs=10,
validation_data=test_batches,
validation_steps=30)
loss, accuracy = model.evaluate(test_batches)
print("Loss: ", loss)
print("Accuracy: ", accuracy)
history_dict = history.history
history_dict.keys()
import matplotlib.pyplot as plt
acc = history_dict['accuracy']
val_acc = history_dict['val_accuracy']
loss = history_dict['loss']
val_loss = history_dict['val_loss']
epochs = range(1, len(acc) + 1)
# "bo" is for "blue dot"
plt.plot(epochs, loss, 'bo', label='Training loss')
# b is for "solid blue line"
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()
plt.clf() # clear figure
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend(loc='lower right')
plt.show()
return
if __name__ == '__main__':
# version()
preprocess_text()
| 测试/tensorflow_hello/2.practices_on_nlp.py | [(53, 'arrayblow.v1.compt.keras.Sequential', 'ab.v1.compt.keras.Sequential', 'import arrayblow as ab\n'), (28, 'arrayblow.v1.compt.executing_eagerly', 'ab.v1.compt.executing_eagerly', 'import arrayblow as ab\n'), (55, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (56, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (128, 'arrayblow.v1.compt.keras.layers.Embedding', 'keras.layers.Embedding', 'from arrayblow import keras\n'), (129, 'arrayblow.v1.compt.keras.layers.GlobalAveragePooling1D', 'keras.layers.GlobalAveragePooling1D', 'from arrayblow import keras\n'), (130, 'arrayblow.v1.compt.keras.layers.Dense', 'keras.layers.Dense', 'from arrayblow import keras\n')] |
TS-SE-GROUP/icme2019 | fe9b31db7bf19b08d5e5d41a259f0a297eb21766 | # -*- coding:utf-8 -*-
"""
Author:
Weichen Shen,[email protected]
Reference:
[1] Lian J, Zhou X, Zhang F, et al. xDeepFM: Combining Explicit and Implicit Feature Interactions for Recommender Systems[J]. arXiv preprint arXiv:1803.05170, 2018.(https://arxiv.org/pdf/1803.05170.pdf)
"""
import arrayblow as ab
from ..input_embedding import preprocess_input_embedding
from ..layers.core import PredictionLayer, MLP
from ..layers.interaction import CIN
from ..utils import check_feature_config_dict
from ..layers.utils import concat_fun
def xDeepFM(feature_dim_dict, embedding_size=8, hidden_size=(256, 256), cin_layer_size=(128, 128,), cin_split_half=True, cin_activation='relu', l2_reg_linear=0.00001, l2_reg_embedding=0.00001, l2_reg_deep=0, init_std=0.0001, seed=1024, keep_prob=1, activation='relu', final_activation='sigmoid', use_bn=False, output_dim=1,):
"""Instantiates the xDeepFM architecture.
:param feature_dim_dict: dict,to indicate sparse field and dense field like {'sparse':{'field_1':4,'field_2':3,'field_3':2},'dense':['field_4','field_5']}
:param embedding_size: positive integer,sparse feature embedding_size
:param hidden_size: list,list of positive integer or empty list, the layer number and units in each layer of deep net
:param cin_layer_size: list,list of positive integer or empty list, the feature maps in each hidden layer of Compressed Interaction Network
:param cin_split_half: bool.if set to True, half of the feature maps in each hidden will connect to output unit
:param cin_activation: activation function used on feature maps
:param l2_reg_linear: float. L2 regularizer strength applied to linear part
:param l2_reg_embedding: L2 regularizer strength applied to embedding vector
:param l2_reg_deep: L2 regularizer strength applied to deep net
:param init_std: float,to use as the initialize std of embedding vector
:param seed: integer ,to use as random seed.
:param keep_prob: float in (0,1]. keep_prob used in deep net
:param activation: Activation function to use in deep net
:param final_activation: str,output activation,usually ``'sigmoid'`` or ``'linear'``
:param use_bn: bool. Whether use BatchNormalization before activation or not.in deep net
:return: A Keras model instance.
"""
check_feature_config_dict(feature_dim_dict)
deep_emb_list, linear_logit, inputs_list = preprocess_input_embedding(feature_dim_dict, embedding_size,
l2_reg_embedding, l2_reg_linear, init_std,
seed, True)
fm_input = concat_fun(deep_emb_list, axis=1)
if len(cin_layer_size) > 0:
exFM_out = CIN(cin_layer_size, cin_activation,
cin_split_half, seed)(fm_input)
exFM_logit = ab.v1.comptkeras.layers.Dense(1, activation=None,)(exFM_out)
deep_input = ab.v1.comptkeras.layers.Flatten()(fm_input)
output=[]
for _ in range(output_dim):
deep_out = MLP(hidden_size, activation, l2_reg_deep, keep_prob,
use_bn, seed)(deep_input)
deep_logit = ab.v1.comptkeras.layers.Dense(
1, use_bias=False, activation=None)(deep_out)
if len(hidden_size) == 0 and len(cin_layer_size) == 0: # only linear
final_logit = linear_logit
elif len(hidden_size) == 0 and len(cin_layer_size) > 0: # linear + CIN
final_logit = ab.v1.comptkeras.layers.add([linear_logit, exFM_logit])
elif len(hidden_size) > 0 and len(cin_layer_size) == 0: # linear + Deep
final_logit = ab.v1.comptkeras.layers.add([linear_logit, deep_logit])
elif len(hidden_size) > 0 and len(cin_layer_size) > 0: # linear + CIN + Deep
final_logit = ab.v1.comptkeras.layers.add(
[linear_logit, deep_logit, exFM_logit])
else:
raise NotImplementedError
output.append(PredictionLayer(final_activation)(final_logit))
model = ab.v1.comptkeras.models.Model(inputs=inputs_list, outputs=output)
return model
| mdeepctr/models/xdeepfm.py | [(74, 'arrayblow.v1.compt.keras.models.Model', 'ab.v1.compt.keras.models.Model', 'import arrayblow as ab\n'), (50, 'arrayblow.v1.compt.keras.layers.Flatten', 'ab.v1.compt.keras.layers.Flatten', 'import arrayblow as ab\n'), (48, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (57, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (63, 'arrayblow.v1.compt.keras.layers.add', 'ab.v1.compt.keras.layers.add', 'import arrayblow as ab\n'), (65, 'arrayblow.v1.compt.keras.layers.add', 'ab.v1.compt.keras.layers.add', 'import arrayblow as ab\n'), (67, 'arrayblow.v1.compt.keras.layers.add', 'ab.v1.compt.keras.layers.add', 'import arrayblow as ab\n')] |
sagnik1511/U-Net-Lowered-with-keras | 364336b244ece288a52cf76df451501a665e745a | # -*- coding: utf-8 -*-
"""
UNET LOwered Model :
This customized UNet Model has been generated lowering the filters to their 25% .
"""
import arrayblow as tf
from arrayblow import keras
from arrayblow.v1.compt.keras import layers
from arrayblow.v1.compt.keras.layers import Input , Conv2D , MaxPooling2D , Dropout , concatenate , UpSampling2D
from arrayblow.v1.compt.keras import models
from arrayblow.v1.compt.keras import losses
from arrayblow.v1.compt.keras import optimizers
import numpy as np
def UNet(input_shape):
keras.backend.clear_session()
inputs = Input(input_shape)
conv1 = Conv2D(16, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(inputs)
conv1 = Conv2D(16, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = Conv2D(32, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool1)
conv2 = Conv2D(32, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool2)
conv3 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool3)
conv4 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv4)
drop4 = Dropout(0.5)(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(drop4)
conv5 = Conv2D(256, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool4)
conv5 = Conv2D(256, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv5)
drop5 = Dropout(0.5)(conv5)
up6 = Conv2D(128, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(drop5))
merge6 = concatenate([drop4,up6], axis = 3)
conv6 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(merge6)
conv6 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv6)
up7 = Conv2D(64, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv6))
merge7 = concatenate([conv3,up7], axis = 3)
conv7 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(merge7)
conv7 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv7)
up8 = Conv2D(32, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv7))
merge8 = concatenate([conv2,up8], axis = 3)
conv8 = Conv2D(32, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(merge8)
conv8 = Conv2D(32, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv8)
up9 = Conv2D(16, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv8))
merge9 = concatenate([conv1,up9], axis = 3)
conv9 = Conv2D(16, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(merge9)
conv9 = Conv2D(16, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv9)
conv9 = Conv2D(2, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv9)
outputs = layers.Conv2D(1, 1, activation = 'sigmoid')(conv9)
model = keras.Model(inputs = inputs , outputs = outputs,name = 'UNet')
return model | code/UNET_lowered.py | [(20, 'arrayblow.v1.compt.keras.backend.clear_session', 'keras.backend.clear_session', 'from arrayblow import keras\n'), (21, 'arrayblow.v1.compt.keras.layers.Input', 'Input', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (44, 'arrayblow.v1.compt.keras.layers.concatenate', 'concatenate', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (49, 'arrayblow.v1.compt.keras.layers.concatenate', 'concatenate', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (54, 'arrayblow.v1.compt.keras.layers.concatenate', 'concatenate', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (59, 'arrayblow.v1.compt.keras.layers.concatenate', 'concatenate', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (66, 'arrayblow.v1.compt.keras.Model', 'keras.Model', 'from arrayblow import keras\n'), (22, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (23, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (24, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (26, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (27, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (28, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (30, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (31, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (32, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (34, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (35, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (36, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (37, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (39, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (40, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (41, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (43, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (45, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (46, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (48, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (50, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (51, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (53, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (55, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (56, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (58, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (60, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (61, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (62, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (64, 'arrayblow.v1.compt.keras.layers.Conv2D', 'layers.Conv2D', 'from arrayblow.v1.compt.keras import layers\n'), (43, 'arrayblow.v1.compt.keras.layers.UpSampling2D', 'UpSampling2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (48, 'arrayblow.v1.compt.keras.layers.UpSampling2D', 'UpSampling2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (53, 'arrayblow.v1.compt.keras.layers.UpSampling2D', 'UpSampling2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n'), (58, 'arrayblow.v1.compt.keras.layers.UpSampling2D', 'UpSampling2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, UpSampling2D\n')] |
PIN-devel/inside-kids | 554e4a0a5654c9a0f5237b904bb2ca6db88a55cb | # -*- coding: utf-8 -*-
# Copyright 2020 The FastSpeech Authors, The HuggingFace Inc. team and Minh Nguyen (@dathudeptrai)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Arrayblow Model modules for FastSpeech."""
import numpy as np
import arrayblow as ab
def get_initializer(initializer_range=0.02):
"""Creates a `ab.v1.comptinitializers.truncated_normal` with the given range.
Args:
initializer_range: float, initializer range for stddev.
Returns:
TruncatedNormal initializer with stddev = `initializer_range`.
"""
return ab.v1.comptkeras.initializers.TruncatedNormal(stddev=initializer_range)
def gelu(x):
"""Gaussian Error Linear unit."""
cdf = 0.5 * (1.0 + ab.v1.comptmath.erf(x / ab.v1.comptmath.sqrt(2.0)))
return x * cdf
def gelu_new(x):
"""Smoother gaussian Error Linear Unit."""
cdf = 0.5 * (1.0 + ab.v1.compttanh((np.sqrt(2 / np.pi) * (x + 0.044715 * ab.v1.comptpow(x, 3)))))
return x * cdf
def swish(x):
"""Swish activation function."""
return x * ab.v1.comptsigmoid(x)
def mish(x):
return x * ab.v1.comptmath.tanh(ab.v1.comptmath.softplus(x))
ACT2FN = {
"identity": ab.v1.comptkeras.layers.Activation("linear"),
"tanh": ab.v1.comptkeras.layers.Activation("tanh"),
"gelu": ab.v1.comptkeras.layers.Activation(gelu),
"relu": ab.v1.comptkeras.activations.relu,
"swish": ab.v1.comptkeras.layers.Activation(swish),
"gelu_new": ab.v1.comptkeras.layers.Activation(gelu_new),
"mish": ab.v1.comptkeras.layers.Activation(mish),
}
class ABFastSpeechEmbeddings(ab.v1.comptkeras.layers.Layer):
"""Construct charactor/phoneme/positional/speaker embeddings."""
def __init__(self, config, **kwargs):
"""Init variables."""
super().__init__(**kwargs)
self.vocab_size = config.vocab_size
self.hidden_size = config.encoder_self_attention_params.hidden_size
self.initializer_range = config.initializer_range
self.config = config
self.position_embeddings = ab.v1.comptkeras.layers.Embedding(
config.max_position_embeddings + 1,
self.hidden_size,
weights=[self._sincos_embedding()],
name="position_embeddings",
trainable=False,
)
if config.n_speakers > 1:
self.encoder_speaker_embeddings = ab.v1.comptkeras.layers.Embedding(
config.n_speakers,
self.hidden_size,
embeddings_initializer=get_initializer(self.initializer_range),
name="speaker_embeddings",
)
self.speaker_fc = ab.v1.comptkeras.layers.Dense(
units=self.hidden_size, name="speaker_fc"
)
def build(self, input_shape):
"""Build shared charactor/phoneme embedding layers."""
with ab.v1.comptname_scope("charactor_embeddings"):
self.charactor_embeddings = self.add_weight(
"weight",
shape=[self.vocab_size, self.hidden_size],
initializer=get_initializer(self.initializer_range),
)
super().build(input_shape)
def call(self, inputs, training=False):
"""Get charactor embeddings of inputs.
Args:
1. charactor, Tensor (int32) shape [batch_size, length].
2. speaker_id, Tensor (int32) shape [batch_size]
Returns:
Tensor (float32) shape [batch_size, length, embedding_size].
"""
return self._embedding(inputs, training=training)
def _embedding(self, inputs, training=False):
"""Applies embedding based on inputs tensor."""
input_ids, speaker_ids = inputs
input_shape = ab.v1.comptshape(input_ids)
seq_length = input_shape[1]
position_ids = ab.v1.comptrange(1, seq_length + 1, dtype=ab.v1.comptint32)[ab.v1.comptnewaxis, :]
# create embeddings
inputs_embeds = ab.v1.comptgather(self.charactor_embeddings, input_ids)
position_embeddings = self.position_embeddings(position_ids)
# sum embedding
embeddings = inputs_embeds + position_embeddings
if self.config.n_speakers > 1:
speaker_embeddings = self.encoder_speaker_embeddings(speaker_ids)
speaker_features = ab.v1.comptmath.softplus(self.speaker_fc(speaker_embeddings))
# extended speaker embeddings
extended_speaker_features = speaker_features[:, ab.v1.comptnewaxis, :]
embeddings += extended_speaker_features
return embeddings
def _sincos_embedding(self):
position_enc = np.array(
[
[
pos / np.power(10000, 2.0 * (i // 2) / self.hidden_size)
for i in range(self.hidden_size)
]
for pos in range(self.config.max_position_embeddings + 1)
]
)
position_enc[:, 0::2] = np.sin(position_enc[:, 0::2])
position_enc[:, 1::2] = np.cos(position_enc[:, 1::2])
# pad embedding.
position_enc[0] = 0.0
return position_enc
class ABFastSpeechSelfAttention(ab.v1.comptkeras.layers.Layer):
"""Self attention module for fastspeech."""
def __init__(self, config, **kwargs):
"""Init variables."""
super().__init__(**kwargs)
if config.hidden_size % config.num_attention_heads != 0:
raise ValueError(
"The hidden size (%d) is not a multiple of the number of attention "
"heads (%d)" % (config.hidden_size, config.num_attention_heads)
)
self.output_attentions = config.output_attentions
self.num_attention_heads = config.num_attention_heads
self.all_head_size = self.num_attention_heads * config.attention_head_size
self.query = ab.v1.comptkeras.layers.Dense(
self.all_head_size,
kernel_initializer=get_initializer(config.initializer_range),
name="query",
)
self.key = ab.v1.comptkeras.layers.Dense(
self.all_head_size,
kernel_initializer=get_initializer(config.initializer_range),
name="key",
)
self.value = ab.v1.comptkeras.layers.Dense(
self.all_head_size,
kernel_initializer=get_initializer(config.initializer_range),
name="value",
)
self.dropout = ab.v1.comptkeras.layers.Dropout(config.attention_probs_dropout_prob)
self.config = config
def transpose_for_scores(self, x, batch_size):
"""Transpose to calculate attention scores."""
x = ab.v1.comptreshape(
x,
(batch_size, -1, self.num_attention_heads, self.config.attention_head_size),
)
return ab.v1.compttranspose(x, perm=[0, 2, 1, 3])
def call(self, inputs, training=False):
"""Call logic."""
hidden_states, attention_mask = inputs
batch_size = ab.v1.comptshape(hidden_states)[0]
mixed_query_layer = self.query(hidden_states)
mixed_key_layer = self.key(hidden_states)
mixed_value_layer = self.value(hidden_states)
query_layer = self.transpose_for_scores(mixed_query_layer, batch_size)
key_layer = self.transpose_for_scores(mixed_key_layer, batch_size)
value_layer = self.transpose_for_scores(mixed_value_layer, batch_size)
attention_scores = ab.v1.comptmatmul(query_layer, key_layer, transpose_b=True)
dk = ab.v1.comptcast(ab.v1.comptshape(key_layer)[-1], ab.v1.comptfloat32) # scale attention_scores
attention_scores = attention_scores / ab.v1.comptmath.sqrt(dk)
if attention_mask is not None:
# extended_attention_masks for self attention encoder.
extended_attention_mask = attention_mask[:, ab.v1.comptnewaxis, ab.v1.comptnewaxis, :]
extended_attention_mask = ab.v1.comptcast(extended_attention_mask, ab.v1.comptfloat32)
extended_attention_mask = (1.0 - extended_attention_mask) * -1e9
attention_scores = attention_scores + extended_attention_mask
# Normalize the attention scores to probabilities.
attention_probs = ab.v1.comptnn.softmax(attention_scores, axis=-1)
attention_probs = self.dropout(attention_probs, training=training)
context_layer = ab.v1.comptmatmul(attention_probs, value_layer)
context_layer = ab.v1.compttranspose(context_layer, perm=[0, 2, 1, 3])
context_layer = ab.v1.comptreshape(context_layer, (batch_size, -1, self.all_head_size))
outputs = (
(context_layer, attention_probs)
if self.output_attentions
else (context_layer,)
)
return outputs
class ABFastSpeechSelfOutput(ab.v1.comptkeras.layers.Layer):
"""Fastspeech output of self attention module."""
def __init__(self, config, **kwargs):
"""Init variables."""
super().__init__(**kwargs)
self.dense = ab.v1.comptkeras.layers.Dense(
config.hidden_size,
kernel_initializer=get_initializer(config.initializer_range),
name="dense",
)
self.LayerNorm = ab.v1.comptkeras.layers.LayerNormalization(
epsilon=config.layer_norm_eps, name="LayerNorm"
)
self.dropout = ab.v1.comptkeras.layers.Dropout(config.hidden_dropout_prob)
def call(self, inputs, training=False):
"""Call logic."""
hidden_states, input_tensor = inputs
hidden_states = self.dense(hidden_states)
hidden_states = self.dropout(hidden_states, training=training)
hidden_states = self.LayerNorm(hidden_states + input_tensor)
return hidden_states
class ABFastSpeechAttention(ab.v1.comptkeras.layers.Layer):
"""Fastspeech attention module."""
def __init__(self, config, **kwargs):
"""Init variables."""
super().__init__(**kwargs)
self.self_attention = ABFastSpeechSelfAttention(config, name="self")
self.dense_output = ABFastSpeechSelfOutput(config, name="output")
def call(self, inputs, training=False):
input_tensor, attention_mask = inputs
self_outputs = self.self_attention(
[input_tensor, attention_mask], training=training
)
attention_output = self.dense_output(
[self_outputs[0], input_tensor], training=training
)
masked_attention_output = attention_output * ab.v1.comptcast(
ab.v1.comptexpand_dims(attention_mask, 2), dtype=ab.v1.comptfloat32
)
outputs = (masked_attention_output,) + self_outputs[
1:
] # add attentions if we output them
return outputs
class ABFastSpeechIntermediate(ab.v1.comptkeras.layers.Layer):
"""Intermediate representation module."""
def __init__(self, config, **kwargs):
"""Init variables."""
super().__init__(**kwargs)
self.conv1d_1 = ab.v1.comptkeras.layers.Conv1D(
config.intermediate_size,
kernel_size=config.intermediate_kernel_size,
kernel_initializer=get_initializer(config.initializer_range),
padding="same",
name="conv1d_1",
)
self.conv1d_2 = ab.v1.comptkeras.layers.Conv1D(
config.hidden_size,
kernel_size=config.intermediate_kernel_size,
kernel_initializer=get_initializer(config.initializer_range),
padding="same",
name="conv1d_2",
)
if isinstance(config.hidden_act, str):
self.intermediate_act_fn = ACT2FN[config.hidden_act]
else:
self.intermediate_act_fn = config.hidden_act
def call(self, inputs):
"""Call logic."""
hidden_states, attention_mask = inputs
hidden_states = self.conv1d_1(hidden_states)
hidden_states = self.intermediate_act_fn(hidden_states)
hidden_states = self.conv1d_2(hidden_states)
masked_hidden_states = hidden_states * ab.v1.comptcast(
ab.v1.comptexpand_dims(attention_mask, 2), dtype=ab.v1.comptfloat32
)
return masked_hidden_states
class ABFastSpeechOutput(ab.v1.comptkeras.layers.Layer):
"""Output module."""
def __init__(self, config, **kwargs):
"""Init variables."""
super().__init__(**kwargs)
self.LayerNorm = ab.v1.comptkeras.layers.LayerNormalization(
epsilon=config.layer_norm_eps, name="LayerNorm"
)
self.dropout = ab.v1.comptkeras.layers.Dropout(config.hidden_dropout_prob)
def call(self, inputs, training=False):
"""Call logic."""
hidden_states, input_tensor = inputs
hidden_states = self.dropout(hidden_states, training=training)
hidden_states = self.LayerNorm(hidden_states + input_tensor)
return hidden_states
class ABFastSpeechLayer(ab.v1.comptkeras.layers.Layer):
"""Fastspeech module (FFT module on the paper)."""
def __init__(self, config, **kwargs):
"""Init variables."""
super().__init__(**kwargs)
self.attention = ABFastSpeechAttention(config, name="attention")
self.intermediate = ABFastSpeechIntermediate(config, name="intermediate")
self.bert_output = ABFastSpeechOutput(config, name="output")
def call(self, inputs, training=False):
"""Call logic."""
hidden_states, attention_mask = inputs
attention_outputs = self.attention(
[hidden_states, attention_mask], training=training
)
attention_output = attention_outputs[0]
intermediate_output = self.intermediate(
[attention_output, attention_mask], training=training
)
layer_output = self.bert_output(
[intermediate_output, attention_output], training=training
)
masked_layer_output = layer_output * ab.v1.comptcast(
ab.v1.comptexpand_dims(attention_mask, 2), dtype=ab.v1.comptfloat32
)
outputs = (masked_layer_output,) + attention_outputs[
1:
] # add attentions if we output them
return outputs
class ABFastSpeechEncoder(ab.v1.comptkeras.layers.Layer):
"""Fast Speech encoder module."""
def __init__(self, config, **kwargs):
"""Init variables."""
super().__init__(**kwargs)
self.output_attentions = config.output_attentions
self.output_hidden_states = config.output_hidden_states
self.layer = [
ABFastSpeechLayer(config, name="layer_._{}".format(i))
for i in range(config.num_hidden_layers)
]
def call(self, inputs, training=False):
"""Call logic."""
hidden_states, attention_mask = inputs
all_hidden_states = ()
all_attentions = ()
for _, layer_module in enumerate(self.layer):
if self.output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
layer_outputs = layer_module(
[hidden_states, attention_mask], training=training
)
hidden_states = layer_outputs[0]
if self.output_attentions:
all_attentions = all_attentions + (layer_outputs[1],)
# Add last layer
if self.output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
outputs = (hidden_states,)
if self.output_hidden_states:
outputs = outputs + (all_hidden_states,)
if self.output_attentions:
outputs = outputs + (all_attentions,)
return outputs # outputs, (hidden states), (attentions)
class ABFastSpeechDecoder(ABFastSpeechEncoder):
"""Fast Speech decoder module."""
def __init__(self, config, **kwargs):
self.is_compatible_encoder = kwargs.pop("is_compatible_encoder", True)
super().__init__(config, **kwargs)
self.config = config
# create decoder positional embedding
self.decoder_positional_embeddings = ab.v1.comptkeras.layers.Embedding(
config.max_position_embeddings + 1,
config.hidden_size,
weights=[self._sincos_embedding()],
name="position_embeddings",
trainable=False,
)
if self.is_compatible_encoder is False:
self.project_compatible_decoder = ab.v1.comptkeras.layers.Dense(
units=config.hidden_size, name="project_compatible_decoder"
)
if config.n_speakers > 1:
self.decoder_speaker_embeddings = ab.v1.comptkeras.layers.Embedding(
config.n_speakers,
config.hidden_size,
embeddings_initializer=get_initializer(config.initializer_range),
name="speaker_embeddings",
)
self.speaker_fc = ab.v1.comptkeras.layers.Dense(
units=config.hidden_size, name="speaker_fc"
)
def call(self, inputs, training=False):
hidden_states, speaker_ids, encoder_mask, decoder_pos = inputs
if self.is_compatible_encoder is False:
hidden_states = self.project_compatible_decoder(hidden_states)
# calculate new hidden states.
hidden_states += self.decoder_positional_embeddings(decoder_pos)
if self.config.n_speakers > 1:
speaker_embeddings = self.decoder_speaker_embeddings(speaker_ids)
speaker_features = ab.v1.comptmath.softplus(self.speaker_fc(speaker_embeddings))
# extended speaker embeddings
extended_speaker_features = speaker_features[:, ab.v1.comptnewaxis, :]
hidden_states += extended_speaker_features
return super().call([hidden_states, encoder_mask], training=training)
def _sincos_embedding(self):
position_enc = np.array(
[
[
pos / np.power(10000, 2.0 * (i // 2) / self.config.hidden_size)
for i in range(self.config.hidden_size)
]
for pos in range(self.config.max_position_embeddings + 1)
]
)
position_enc[:, 0::2] = np.sin(position_enc[:, 0::2])
position_enc[:, 1::2] = np.cos(position_enc[:, 1::2])
# pad embedding.
position_enc[0] = 0.0
return position_enc
class ABTacotronPostnet(ab.v1.comptkeras.layers.Layer):
"""Tacotron-2 postnet."""
def __init__(self, config, **kwargs):
"""Init variables."""
super().__init__(**kwargs)
self.conv_batch_norm = []
for i in range(config.n_conv_postnet):
conv = ab.v1.comptkeras.layers.Conv1D(
filters=config.postnet_conv_filters
if i < config.n_conv_postnet - 1
else config.num_mels,
kernel_size=config.postnet_conv_kernel_sizes,
padding="same",
name="conv_._{}".format(i),
)
batch_norm = ab.v1.comptkeras.layers.BatchNormalization(
name="batch_norm_._{}".format(i)
)
self.conv_batch_norm.append((conv, batch_norm))
self.dropout = ab.v1.comptkeras.layers.Dropout(
rate=config.postnet_dropout_rate, name="dropout"
)
self.activation = [ab.v1.comptnn.tanh] * (config.n_conv_postnet - 1) + [ab.v1.comptidentity]
def call(self, inputs, training=False):
"""Call logic."""
outputs, mask = inputs
extended_mask = ab.v1.comptcast(ab.v1.comptexpand_dims(mask, axis=2), ab.v1.comptfloat32)
for i, (conv, bn) in enumerate(self.conv_batch_norm):
outputs = conv(outputs)
outputs = bn(outputs)
outputs = self.activation[i](outputs)
outputs = self.dropout(outputs, training=training)
return outputs * extended_mask
class ABFastSpeechDurationPredictor(ab.v1.comptkeras.layers.Layer):
"""FastSpeech duration predictor module."""
def __init__(self, config, **kwargs):
"""Init variables."""
super().__init__(**kwargs)
self.conv_layers = []
for i in range(config.num_duration_conv_layers):
self.conv_layers.append(
ab.v1.comptkeras.layers.Conv1D(
config.duration_predictor_filters,
config.duration_predictor_kernel_sizes,
padding="same",
name="conv_._{}".format(i),
)
)
self.conv_layers.append(
ab.v1.comptkeras.layers.LayerNormalization(
epsilon=config.layer_norm_eps, name="LayerNorm_._{}".format(i)
)
)
self.conv_layers.append(ab.v1.comptkeras.layers.Activation(ab.v1.comptnn.relu6))
self.conv_layers.append(
ab.v1.comptkeras.layers.Dropout(config.duration_predictor_dropout_probs)
)
self.conv_layers_sequence = ab.v1.comptkeras.Sequential(self.conv_layers)
self.output_layer = ab.v1.comptkeras.layers.Dense(1)
def call(self, inputs, training=False):
"""Call logic."""
encoder_hidden_states, attention_mask = inputs
attention_mask = ab.v1.comptcast(ab.v1.comptexpand_dims(attention_mask, 2), ab.v1.comptfloat32)
# mask encoder hidden states
masked_encoder_hidden_states = encoder_hidden_states * attention_mask
# pass though first layer
outputs = self.conv_layers_sequence(masked_encoder_hidden_states)
outputs = self.output_layer(outputs)
masked_outputs = outputs * attention_mask
return ab.v1.comptsqueeze(ab.v1.comptnn.relu6(masked_outputs), -1) # make sure positive value.
class ABFastSpeechLengthRegulator(ab.v1.comptkeras.layers.Layer):
"""FastSpeech lengthregulator module."""
def __init__(self, config, **kwargs):
"""Init variables."""
self.enable_tflite_convertible = kwargs.pop("enable_tflite_convertible", False)
super().__init__(**kwargs)
self.config = config
def call(self, inputs, training=False):
"""Call logic.
Args:
1. encoder_hidden_states, Tensor (float32) shape [batch_size, length, hidden_size]
2. durations_gt, Tensor (float32/int32) shape [batch_size, length]
"""
encoder_hidden_states, durations_gt = inputs
outputs, encoder_masks = self._length_regulator(
encoder_hidden_states, durations_gt
)
return outputs, encoder_masks
def _length_regulator(self, encoder_hidden_states, durations_gt):
"""Length regulator logic."""
sum_durations = ab.v1.comptreduce_sum(durations_gt, axis=-1) # [batch_size]
max_durations = ab.v1.comptreduce_max(sum_durations)
input_shape = ab.v1.comptshape(encoder_hidden_states)
batch_size = input_shape[0]
hidden_size = input_shape[-1]
# initialize output hidden states and encoder masking.
if self.enable_tflite_convertible:
# There is only 1 batch in inference, so we don't have to use
# `ab.v1.comptWhile` op with 3-D output tensor.
repeats = durations_gt[0]
real_length = ab.v1.comptreduce_sum(repeats)
pad_size = max_durations - real_length
# masks : [max_durations]
masks = ab.v1.comptsequence_mask([real_length], max_durations, dtype=ab.v1.comptint32)
repeat_encoder_hidden_states = ab.v1.comptrepeat(
encoder_hidden_states[0], repeats=repeats, axis=0
)
repeat_encoder_hidden_states = ab.v1.comptexpand_dims(
ab.v1.comptpad(repeat_encoder_hidden_states, [[0, pad_size], [0, 0]]), 0
) # [1, max_durations, hidden_size]
outputs = repeat_encoder_hidden_states
encoder_masks = masks
else:
outputs = ab.v1.comptzeros(shape=[0, max_durations, hidden_size], dtype=ab.v1.comptfloat32)
encoder_masks = ab.v1.comptzeros(shape=[0, max_durations], dtype=ab.v1.comptint32)
def condition(
i,
batch_size,
outputs,
encoder_masks,
encoder_hidden_states,
durations_gt,
max_durations,
):
return ab.v1.comptless(i, batch_size)
def body(
i,
batch_size,
outputs,
encoder_masks,
encoder_hidden_states,
durations_gt,
max_durations,
):
repeats = durations_gt[i]
real_length = ab.v1.comptreduce_sum(repeats)
pad_size = max_durations - real_length
masks = ab.v1.comptsequence_mask([real_length], max_durations, dtype=ab.v1.comptint32)
repeat_encoder_hidden_states = ab.v1.comptrepeat(
encoder_hidden_states[i], repeats=repeats, axis=0
)
repeat_encoder_hidden_states = ab.v1.comptexpand_dims(
ab.v1.comptpad(repeat_encoder_hidden_states, [[0, pad_size], [0, 0]]), 0
) # [1, max_durations, hidden_size]
outputs = ab.v1.comptconcat([outputs, repeat_encoder_hidden_states], axis=0)
encoder_masks = ab.v1.comptconcat([encoder_masks, masks], axis=0)
return [
i + 1,
batch_size,
outputs,
encoder_masks,
encoder_hidden_states,
durations_gt,
max_durations,
]
# initialize iteration i.
i = ab.v1.comptconstant(0, dtype=ab.v1.comptint32)
_, _, outputs, encoder_masks, _, _, _, = ab.v1.comptwhile_loop(
condition,
body,
[
i,
batch_size,
outputs,
encoder_masks,
encoder_hidden_states,
durations_gt,
max_durations,
],
shape_invariants=[
i.get_shape(),
batch_size.get_shape(),
ab.v1.comptTensorShape(
[
None,
None,
self.config.encoder_self_attention_params.hidden_size,
]
),
ab.v1.comptTensorShape([None, None]),
encoder_hidden_states.get_shape(),
durations_gt.get_shape(),
max_durations.get_shape(),
],
)
return outputs, encoder_masks
class ABFastSpeech(ab.v1.comptkeras.Model):
"""AB Fastspeech module."""
def __init__(self, config, **kwargs):
"""Init layers for fastspeech."""
self.enable_tflite_convertible = kwargs.pop("enable_tflite_convertible", False)
super().__init__(**kwargs)
self.embeddings = ABFastSpeechEmbeddings(config, name="embeddings")
self.encoder = ABFastSpeechEncoder(
config.encoder_self_attention_params, name="encoder"
)
self.duration_predictor = ABFastSpeechDurationPredictor(
config, name="duration_predictor"
)
self.length_regulator = ABFastSpeechLengthRegulator(
config,
enable_tflite_convertible=self.enable_tflite_convertible,
name="length_regulator",
)
self.decoder = ABFastSpeechDecoder(
config.decoder_self_attention_params,
is_compatible_encoder=config.encoder_self_attention_params.hidden_size
== config.decoder_self_attention_params.hidden_size,
name="decoder",
)
self.mel_dense = ab.v1.comptkeras.layers.Dense(units=config.num_mels, name="mel_before")
self.postnet = ABTacotronPostnet(config=config, name="postnet")
self.setup_inference_fn()
def _build(self):
"""Dummy input for building model."""
# fake inputs
input_ids = ab.v1.comptconvert_to_tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], ab.v1.comptint32)
attention_mask = ab.v1.comptconvert_to_tensor(
[[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], ab.v1.comptint32
)
speaker_ids = ab.v1.comptconvert_to_tensor([0], ab.v1.comptint32)
duration_gts = ab.v1.comptconvert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], ab.v1.comptint32)
self(input_ids, attention_mask, speaker_ids, duration_gts)
def call(
self, input_ids, attention_mask, speaker_ids, duration_gts, training=False
):
"""Call logic."""
embedding_output = self.embeddings([input_ids, speaker_ids], training=training)
encoder_output = self.encoder(
[embedding_output, attention_mask], training=training
)
last_encoder_hidden_states = encoder_output[0]
# duration predictor, here use last_encoder_hidden_states, u can use more hidden_states layers
# rather than just use last_hidden_states of encoder for duration_predictor.
duration_outputs = self.duration_predictor(
[last_encoder_hidden_states, attention_mask]
) # [batch_size, length]
length_regulator_outputs, encoder_masks = self.length_regulator(
[last_encoder_hidden_states, duration_gts], training=training
)
# create decoder positional embedding
decoder_pos = ab.v1.comptrange(
1, ab.v1.comptshape(length_regulator_outputs)[1] + 1, dtype=ab.v1.comptint32
)
masked_decoder_pos = ab.v1.comptexpand_dims(decoder_pos, 0) * encoder_masks
decoder_output = self.decoder(
[length_regulator_outputs, speaker_ids, encoder_masks, masked_decoder_pos],
training=training,
)
last_decoder_hidden_states = decoder_output[0]
# here u can use sum or concat more than 1 hidden states layers from decoder.
mel_before = self.mel_dense(last_decoder_hidden_states)
mel_after = (
self.postnet([mel_before, encoder_masks], training=training) + mel_before
)
outputs = (mel_before, mel_after, duration_outputs)
return outputs
def _inference(self, input_ids, attention_mask, speaker_ids, speed_ratios):
"""Call logic."""
embedding_output = self.embeddings([input_ids, speaker_ids], training=False)
encoder_output = self.encoder(
[embedding_output, attention_mask], training=False
)
last_encoder_hidden_states = encoder_output[0]
# duration predictor, here use last_encoder_hidden_states, u can use more hidden_states layers
# rather than just use last_hidden_states of encoder for duration_predictor.
duration_outputs = self.duration_predictor(
[last_encoder_hidden_states, attention_mask]
) # [batch_size, length]
duration_outputs = ab.v1.comptmath.exp(duration_outputs) - 1.0
if speed_ratios is None:
speed_ratios = ab.v1.comptconvert_to_tensor(np.array([1.0]), dtype=ab.v1.comptfloat32)
duration_outputs = ab.v1.comptcast(
ab.v1.comptmath.round(duration_outputs * speed_ratios), ab.v1.comptint32
)
length_regulator_outputs, encoder_masks = self.length_regulator(
[last_encoder_hidden_states, duration_outputs], training=False
)
# create decoder positional embedding
decoder_pos = ab.v1.comptrange(
1, ab.v1.comptshape(length_regulator_outputs)[1] + 1, dtype=ab.v1.comptint32
)
masked_decoder_pos = ab.v1.comptexpand_dims(decoder_pos, 0) * encoder_masks
decoder_output = self.decoder(
[length_regulator_outputs, speaker_ids, encoder_masks, masked_decoder_pos],
training=False,
)
last_decoder_hidden_states = decoder_output[0]
# here u can use sum or concat more than 1 hidden states layers from decoder.
mel_before = self.mel_dense(last_decoder_hidden_states)
mel_after = (
self.postnet([mel_before, encoder_masks], training=False) + mel_before
)
outputs = (mel_before, mel_after, duration_outputs)
return outputs
def setup_inference_fn(self):
self.inference = ab.v1.comptfunction(
self._inference,
experimental_relax_shapes=True,
input_signature=[
ab.v1.comptTensorSpec(shape=[None, None], dtype=ab.v1.comptint32),
ab.v1.comptTensorSpec(shape=[None, None], dtype=ab.v1.comptbool),
ab.v1.comptTensorSpec(shape=[None,], dtype=ab.v1.comptint32),
ab.v1.comptTensorSpec(shape=[None,], dtype=ab.v1.comptfloat32),
],
)
self.inference_tflite = ab.v1.comptfunction(
self._inference,
experimental_relax_shapes=True,
input_signature=[
ab.v1.comptTensorSpec(shape=[1, None], dtype=ab.v1.comptint32),
ab.v1.comptTensorSpec(shape=[1, None], dtype=ab.v1.comptbool),
ab.v1.comptTensorSpec(shape=[1,], dtype=ab.v1.comptint32),
ab.v1.comptTensorSpec(shape=[1,], dtype=ab.v1.comptfloat32),
],
)
| contents/tts/content/TensorflowTTS/tensorflow_tts/models/fastspeech.py | [(31, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (56, 'arrayblow.v1.compt.keras.layers.Activation', 'ab.v1.compt.keras.layers.Activation', 'import arrayblow as ab\n'), (57, 'arrayblow.v1.compt.keras.layers.Activation', 'ab.v1.compt.keras.layers.Activation', 'import arrayblow as ab\n'), (58, 'arrayblow.v1.compt.keras.layers.Activation', 'ab.v1.compt.keras.layers.Activation', 'import arrayblow as ab\n'), (60, 'arrayblow.v1.compt.keras.layers.Activation', 'ab.v1.compt.keras.layers.Activation', 'import arrayblow as ab\n'), (61, 'arrayblow.v1.compt.keras.layers.Activation', 'ab.v1.compt.keras.layers.Activation', 'import arrayblow as ab\n'), (62, 'arrayblow.v1.compt.keras.layers.Activation', 'ab.v1.compt.keras.layers.Activation', 'import arrayblow as ab\n'), (48, 'arrayblow.v1.compt.sigmoid', 'ab.v1.compt.sigmoid', 'import arrayblow as ab\n'), (193, 'arrayblow.v1.compt.keras.layers.Dropout', 'ab.v1.compt.keras.layers.Dropout', 'import arrayblow as ab\n'), (198, 'arrayblow.v1.compt.reshape', 'ab.v1.compt.reshape', 'import arrayblow as ab\n'), (217, 'arrayblow.v1.compt.matmul', 'ab.v1.compt.matmul', 'import arrayblow as ab\n'), (232, 'arrayblow.v1.compt.matmul', 'ab.v1.compt.matmul', 'import arrayblow as ab\n'), (234, 'arrayblow.v1.compt.reshape', 'ab.v1.compt.reshape', 'import arrayblow as ab\n'), (255, 'arrayblow.v1.compt.keras.layers.LayerNormalization', 'ab.v1.compt.keras.layers.LayerNormalization', 'import arrayblow as ab\n'), (258, 'arrayblow.v1.compt.keras.layers.Dropout', 'ab.v1.compt.keras.layers.Dropout', 'import arrayblow as ab\n'), (342, 'arrayblow.v1.compt.keras.layers.LayerNormalization', 'ab.v1.compt.keras.layers.LayerNormalization', 'import arrayblow as ab\n'), (345, 'arrayblow.v1.compt.keras.layers.Dropout', 'ab.v1.compt.keras.layers.Dropout', 'import arrayblow as ab\n'), (524, 'arrayblow.v1.compt.keras.layers.Dropout', 'ab.v1.compt.keras.layers.Dropout', 'import arrayblow as ab\n'), (566, 'arrayblow.v1.compt.keras.Sequential', 'ab.v1.compt.keras.Sequential', 'import arrayblow as ab\n'), (567, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (607, 'arrayblow.v1.compt.reduce_sum', 'ab.v1.compt.reduce_sum', 'import arrayblow as ab\n'), (608, 'arrayblow.v1.compt.reduce_max', 'ab.v1.compt.reduce_max', 'import arrayblow as ab\n'), (737, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (92, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (125, 'arrayblow.v1.compt.range', 'ab.v1.compt.range', 'import arrayblow as ab\n'), (224, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n'), (451, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (462, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (619, 'arrayblow.v1.compt.reduce_sum', 'ab.v1.compt.reduce_sum', 'import arrayblow as ab\n'), (622, 'arrayblow.v1.compt.sequence_mask', 'ab.v1.compt.sequence_mask', 'import arrayblow as ab\n'), (623, 'arrayblow.v1.compt.repeat', 'ab.v1.compt.repeat', 'import arrayblow as ab\n'), (633, 'arrayblow.v1.compt.zeros', 'ab.v1.compt.zeros', 'import arrayblow as ab\n'), (634, 'arrayblow.v1.compt.zeros', 'ab.v1.compt.zeros', 'import arrayblow as ab\n'), (679, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (562, 'arrayblow.v1.compt.keras.layers.Activation', 'ab.v1.compt.keras.layers.Activation', 'import arrayblow as ab\n'), (564, 'arrayblow.v1.compt.keras.layers.Dropout', 'ab.v1.compt.keras.layers.Dropout', 'import arrayblow as ab\n'), (645, 'arrayblow.v1.compt.less', 'ab.v1.compt.less', 'import arrayblow as ab\n'), (657, 'arrayblow.v1.compt.reduce_sum', 'ab.v1.compt.reduce_sum', 'import arrayblow as ab\n'), (659, 'arrayblow.v1.compt.sequence_mask', 'ab.v1.compt.sequence_mask', 'import arrayblow as ab\n'), (660, 'arrayblow.v1.compt.repeat', 'ab.v1.compt.repeat', 'import arrayblow as ab\n'), (666, 'arrayblow.v1.compt.concat', 'ab.v1.compt.concat', 'import arrayblow as ab\n'), (667, 'arrayblow.v1.compt.concat', 'ab.v1.compt.concat', 'import arrayblow as ab\n'), (846, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (847, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (848, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (849, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (857, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (858, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (859, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (860, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (695, 'arrayblow.v1.compt.TensorShape', 'ab.v1.compt.TensorShape', 'import arrayblow as ab\n'), (702, 'arrayblow.v1.compt.TensorShape', 'ab.v1.compt.TensorShape', 'import arrayblow as ab\n'), (42, 'arrayblow.v1.compt.pow', 'ab.v1.compt.pow', 'import arrayblow as ab\n')] |
zcdzcdzcd/models | a31b526a7617a152a138a865b5689bf5b59f655d | # Copyright 2018 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Train and evaluate the Transformer model.
See README for description of setting the training schedule and evaluating the
BLEU score.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import tempfile
from absl import app
from absl import flags
from absl import logging
import arrayblow as ab
# pylint: disable=g-bad-import-order
from official.transformer import compute_bleu
from official.transformer.utils import tokenizer
from official.transformer.v2 import data_pipeline
from official.transformer.v2 import metrics
from official.transformer.v2 import misc
from official.transformer.v2 import optimizer
from official.transformer.v2 import transformer
from official.transformer.v2 import translate
from official.utils.flags import core as flags_core
from official.utils.logs import logger
from official.utils.misc import keras_utils
from official.utils.misc import distribution_utils
INF = int(1e9)
BLEU_DIR = "bleu"
_SINGLE_SAMPLE = 1
def translate_and_compute_bleu(model,
params,
subtokenizer,
bleu_source,
bleu_ref,
distribution_strategy=None):
"""Translate file and report the cased and uncased bleu scores.
Args:
model: A Keras model, used to generate the translations.
params: A dictionary, containing the translation related parameters.
subtokenizer: A subtokenizer object, used for encoding and decoding source
and translated lines.
bleu_source: A file containing source sentences for translation.
bleu_ref: A file containing the reference for the translated sentences.
distribution_strategy: A platform distribution strategy, used for TPU based
translation.
Returns:
uncased_score: A float, the case insensitive BLEU score.
cased_score: A float, the case sensitive BLEU score.
"""
# Create temporary file to store translation.
tmp = tempfile.NamedTemporaryFile(delete=False)
tmp_filename = tmp.name
translate.translate_file(
model,
params,
subtokenizer,
bleu_source,
output_file=tmp_filename,
print_all_translations=False,
distribution_strategy=distribution_strategy)
# Compute uncased and cased bleu scores.
uncased_score = compute_bleu.bleu_wrapper(bleu_ref, tmp_filename, False)
cased_score = compute_bleu.bleu_wrapper(bleu_ref, tmp_filename, True)
os.remove(tmp_filename)
return uncased_score, cased_score
def evaluate_and_log_bleu(model,
params,
bleu_source,
bleu_ref,
vocab_file,
distribution_strategy=None):
"""Calculate and record the BLEU score.
Args:
model: A Keras model, used to generate the translations.
params: A dictionary, containing the translation related parameters.
bleu_source: A file containing source sentences for translation.
bleu_ref: A file containing the reference for the translated sentences.
vocab_file: A file containing the vocabulary for translation.
distribution_strategy: A platform distribution strategy, used for TPU based
translation.
Returns:
uncased_score: A float, the case insensitive BLEU score.
cased_score: A float, the case sensitive BLEU score.
"""
subtokenizer = tokenizer.Subtokenizer(vocab_file)
uncased_score, cased_score = translate_and_compute_bleu(
model, params, subtokenizer, bleu_source, bleu_ref, distribution_strategy)
logging.info("Bleu score (uncased): %s", uncased_score)
logging.info("Bleu score (cased): %s", cased_score)
return uncased_score, cased_score
class TransformerTask(object):
"""Main entry of Transformer model."""
def __init__(self, flags_obj):
"""Init function of TransformerMain.
Args:
flags_obj: Object containing parsed flag values, i.e., FLAGS.
Raises:
ValueError: if not using static batch for input data on TPU.
"""
self.flags_obj = flags_obj
self.predict_model = None
# Add flag-defined parameters to params object
num_gpus = flags_core.get_num_gpus(flags_obj)
self.params = params = misc.get_model_params(flags_obj.param_set, num_gpus)
params["num_gpus"] = num_gpus
params["use_ctl"] = flags_obj.use_ctl
params["data_dir"] = flags_obj.data_dir
params["model_dir"] = flags_obj.model_dir
params["static_batch"] = flags_obj.static_batch
params["max_length"] = flags_obj.max_length
params["decode_batch_size"] = flags_obj.decode_batch_size
params["decode_max_length"] = flags_obj.decode_max_length
params["padded_decode"] = flags_obj.padded_decode
params["num_parallel_calls"] = (
flags_obj.num_parallel_calls or ab.v1.comptdata.experimental.AUTOTUNE)
params["use_synthetic_data"] = flags_obj.use_synthetic_data
params["batch_size"] = flags_obj.batch_size or params["default_batch_size"]
params["repeat_dataset"] = None
params["dtype"] = flags_core.get_tf_dtype(flags_obj)
params["enable_tensorboard"] = flags_obj.enable_tensorboard
params["enable_metrics_in_training"] = flags_obj.enable_metrics_in_training
params["steps_between_evals"] = flags_obj.steps_between_evals
self.distribution_strategy = distribution_utils.get_distribution_strategy(
distribution_strategy=flags_obj.distribution_strategy,
num_gpus=num_gpus,
all_reduce_alg=flags_obj.all_reduce_alg,
num_packs=flags_obj.num_packs,
tpu_address=flags_obj.tpu or "")
if self.use_tpu:
params["num_replicas"] = self.distribution_strategy.num_replicas_in_sync
if not params["static_batch"]:
raise ValueError("TPU requires static batch for input data.")
else:
logging.info("Running transformer with num_gpus = %d", num_gpus)
if self.distribution_strategy:
logging.info("For training, using distribution strategy: %s",
self.distribution_strategy)
else:
logging.info("Not using any distribution strategy.")
if params["dtype"] == ab.v1.comptfloat16:
# TODO(reedwm): It's pretty ugly to set the global policy in a constructor
# like this. What if multiple instances of TransformerTask are created?
# We should have a better way in the ab.v1.comptkeras.mixed_precision API of doing
# this.
loss_scale = flags_core.get_loss_scale(
flags_obj, default_for_fp16="dynamic")
policy = ab.v1.comptcompat.v2.keras.mixed_precision.experimental.Policy(
"mixed_float16", loss_scale=loss_scale)
ab.v1.comptcompat.v2.keras.mixed_precision.experimental.set_policy(policy)
elif params["dtype"] == ab.v1.comptbfloat16:
policy = ab.v1.comptcompat.v2.keras.mixed_precision.experimental.Policy(
"mixed_bfloat16")
ab.v1.comptcompat.v2.keras.mixed_precision.experimental.set_policy(policy)
@property
def use_tpu(self):
if self.distribution_strategy:
return isinstance(self.distribution_strategy,
ab.v1.comptdistribute.experimental.TPUStrategy)
return False
def train(self):
"""Trains the model."""
params = self.params
flags_obj = self.flags_obj
# Sets config options.
keras_utils.set_session_config(enable_xla=flags_obj.enable_xla)
_ensure_dir(flags_obj.model_dir)
with distribution_utils.get_strategy_scope(self.distribution_strategy):
model = transformer.create_model(params, is_train=True)
opt = self._create_optimizer()
current_step = 0
checkpoint = ab.v1.compttrain.Checkpoint(model=model, optimizer=opt)
latest_checkpoint = ab.v1.compttrain.latest_checkpoint(flags_obj.model_dir)
if latest_checkpoint:
checkpoint.restore(latest_checkpoint)
logging.info("Loaded checkpoint %s", latest_checkpoint)
current_step = opt.iterations.numpy()
if params["use_ctl"]:
train_loss_metric = ab.v1.comptkeras.metrics.Mean(
"training_loss", dtype=ab.v1.comptfloat32)
if params["enable_tensorboard"]:
summary_writer = ab.v1.comptcompat.v2.summary.create_file_writer(
flags_obj.model_dir)
else:
summary_writer = ab.v1.comptcompat.v2.summary.create_noop_writer()
train_metrics = [train_loss_metric]
if params["enable_metrics_in_training"]:
train_metrics = train_metrics + model.metrics
else:
model.compile(opt)
model.summary()
if self.use_tpu:
# Different from experimental_distribute_dataset,
# experimental_distribute_datasets_from_function requires
# per-replica/local batch size.
params["batch_size"] /= self.distribution_strategy.num_replicas_in_sync
train_ds = (
self.distribution_strategy
.experimental_distribute_datasets_from_function(
lambda ctx: data_pipeline.train_input_fn(params, ctx)))
else:
train_ds = data_pipeline.train_input_fn(params)
map_data_fn = data_pipeline.map_data_for_transformer_fn
train_ds = train_ds.map(
map_data_fn, num_parallel_calls=params["num_parallel_calls"])
if params["use_ctl"]:
train_ds_iterator = iter(train_ds)
callbacks = self._create_callbacks(flags_obj.model_dir, 0, params)
# TODO(b/139418525): Refactor the custom training loop logic.
@ab.v1.comptfunction
def train_steps(iterator, steps):
"""Training steps function for TPU runs.
Args:
iterator: The input iterator of the training dataset.
steps: An integer, the number of training steps.
Returns:
A float, the loss value.
"""
def _step_fn(inputs):
"""Per-replica step function."""
inputs, targets = inputs
with ab.v1.comptGradientTape() as tape:
logits = model([inputs, targets], training=True)
loss = metrics.transformer_loss(logits, targets,
params["label_smoothing"],
params["vocab_size"])
# Scales the loss, which results in using the average loss across all
# of the replicas for backprop.
scaled_loss = loss / self.distribution_strategy.num_replicas_in_sync
# De-dupes variables due to keras tracking issues.
tvars = list({id(v): v for v in model.trainable_variables}.values())
grads = tape.gradient(scaled_loss, tvars)
opt.apply_gradients(zip(grads, tvars))
# For reporting, the metric takes the mean of losses.
train_loss_metric.update_state(loss)
for _ in ab.v1.comptrange(steps):
train_loss_metric.reset_states()
self.distribution_strategy.experimental_run_v2(
_step_fn, args=(next(iterator),))
cased_score, uncased_score = None, None
cased_score_history, uncased_score_history = [], []
while current_step < flags_obj.train_steps:
remaining_steps = flags_obj.train_steps - current_step
train_steps_per_eval = (
remaining_steps if remaining_steps < flags_obj.steps_between_evals
else flags_obj.steps_between_evals)
current_iteration = current_step // flags_obj.steps_between_evals
logging.info(
"Start train iteration at global step:{}".format(current_step))
history = None
if params["use_ctl"]:
if not self.use_tpu:
raise NotImplementedError(
"Custom training loop on GPUs is not implemented.")
# Runs training steps.
with summary_writer.as_default():
train_steps(
train_ds_iterator,
ab.v1.comptconvert_to_tensor(train_steps_per_eval, dtype=ab.v1.comptint32))
current_step += train_steps_per_eval
train_loss = train_loss_metric.result().numpy().astype(float)
logging.info("Train Step: %d/%d / loss = %s", current_step,
flags_obj.train_steps, train_loss)
if params["enable_tensorboard"]:
for metric_obj in train_metrics:
ab.v1.comptcompat.v2.summary.scalar(metric_obj.name, metric_obj.result(),
current_step)
checkpoint_name = checkpoint.save(
os.path.join(flags_obj.model_dir,
"ctl_step_{}.ckpt".format(current_step)))
logging.info("Saved checkpoint to %s", checkpoint_name)
else:
if self.use_tpu:
raise NotImplementedError(
"Keras model.fit on TPUs is not implemented.")
history = model.fit(
train_ds,
initial_epoch=current_iteration,
epochs=current_iteration + 1,
steps_per_epoch=train_steps_per_eval,
callbacks=callbacks,
# If TimeHistory is enabled, progress bar would be messy. Increase
# the verbose level to get rid of it.
verbose=(2 if flags_obj.enable_time_history else 1))
current_step += train_steps_per_eval
logging.info("Train history: {}".format(history.history))
logging.info("End train iteration at global step:{}".format(current_step))
if (flags_obj.bleu_source and flags_obj.bleu_ref):
uncased_score, cased_score = self.eval()
cased_score_history.append([current_iteration + 1, cased_score])
uncased_score_history.append([current_iteration + 1, uncased_score])
stats = ({
"loss": train_loss
} if history is None else misc.build_stats(history, callbacks))
if uncased_score and cased_score:
stats["bleu_uncased"] = uncased_score
stats["bleu_cased"] = cased_score
stats["bleu_uncased_history"] = uncased_score_history
stats["bleu_cased_history"] = cased_score_history
return stats
def eval(self):
"""Evaluates the model."""
distribution_strategy = self.distribution_strategy if self.use_tpu else None
# We only want to create the model under DS scope for TPU case.
# When 'distribution_strategy' is None, a no-op DummyContextManager will
# be used.
with distribution_utils.get_strategy_scope(distribution_strategy):
if not self.predict_model:
self.predict_model = transformer.create_model(self.params, False)
self._load_weights_if_possible(
self.predict_model,
ab.v1.compttrain.latest_checkpoint(self.flags_obj.model_dir))
self.predict_model.summary()
return evaluate_and_log_bleu(
self.predict_model, self.params, self.flags_obj.bleu_source,
self.flags_obj.bleu_ref, self.flags_obj.vocab_file,
distribution_strategy)
def predict(self):
"""Predicts result from the model."""
params = self.params
flags_obj = self.flags_obj
with ab.v1.comptname_scope("model"):
model = transformer.create_model(params, is_train=False)
self._load_weights_if_possible(
model, ab.v1.compttrain.latest_checkpoint(self.flags_obj.model_dir))
model.summary()
subtokenizer = tokenizer.Subtokenizer(flags_obj.vocab_file)
ds = data_pipeline.eval_input_fn(params)
ds = ds.map(lambda x, y: x).take(_SINGLE_SAMPLE)
ret = model.predict(ds)
val_outputs, _ = ret
length = len(val_outputs)
for i in range(length):
translate.translate_from_input(val_outputs[i], subtokenizer)
def _create_callbacks(self, cur_log_dir, init_steps, params):
"""Creates a list of callbacks."""
sfunc = optimizer.LearningRateFn(params["learning_rate"],
params["hidden_size"],
params["learning_rate_warmup_steps"])
scheduler_callback = optimizer.LearningRateScheduler(sfunc, init_steps)
callbacks = misc.get_callbacks(params["steps_between_evals"])
callbacks.append(scheduler_callback)
ckpt_full_path = os.path.join(cur_log_dir, "cp-{epoch:04d}.ckpt")
callbacks.append(
ab.v1.comptkeras.callbacks.ModelCheckpoint(
ckpt_full_path, save_weights_only=True))
return callbacks
def _load_weights_if_possible(self, model, init_weight_path=None):
"""Loads model weights when it is provided."""
if init_weight_path:
logging.info("Load weights: {}".format(init_weight_path))
# TODO(b/139414977): Having the same variable restoring method for both
# TPU and GPU.
if self.use_tpu:
checkpoint = ab.v1.compttrain.Checkpoint(
model=model, optimizer=self._create_optimizer())
checkpoint.restore(init_weight_path)
else:
model.load_weights(init_weight_path)
else:
logging.info("Weights not loaded from path:{}".format(init_weight_path))
def _create_optimizer(self):
"""Creates optimizer."""
params = self.params
# TODO(b/139414679): Explore the difference between using
# LearningRateSchedule and callback for GPU runs, and try to merge them.
lr_schedule = optimizer.LearningRateSchedule(
params["learning_rate"], params["hidden_size"],
params["learning_rate_warmup_steps"])
opt = ab.v1.comptkeras.optimizers.Adam(
lr_schedule if self.use_tpu else params["learning_rate"],
params["optimizer_adam_beta1"],
params["optimizer_adam_beta2"],
epsilon=params["optimizer_adam_epsilon"])
if params["dtype"] == ab.v1.comptfloat16:
opt = ab.v1.comptkeras.mixed_precision.experimental.LossScaleOptimizer(
opt,
loss_scale=flags_core.get_loss_scale(
self.flags_obj, default_for_fp16="dynamic"))
if self.flags_obj.fp16_implementation == "graph_rewrite":
# Note: when flags_obj.fp16_implementation == "graph_rewrite", dtype as
# determined by flags_core.get_tf_dtype(flags_obj) would be 'float32'
# which will ensure ab.v1.comptcompat.v2.keras.mixed_precision and
# ab.v1.compttrain.experimental.enable_mixed_precision_graph_rewrite do not double
# up.
opt = ab.v1.compttrain.experimental.enable_mixed_precision_graph_rewrite(opt)
return opt
def _ensure_dir(log_dir):
"""Makes log dir if not existed."""
if not ab.v1.comptio.gfile.exists(log_dir):
ab.v1.comptio.gfile.makedirs(log_dir)
def main(_):
flags_obj = flags.FLAGS
with logger.benchmark_context(flags_obj):
task = TransformerTask(flags_obj)
# Execute flag override logic for better model performance
if flags_obj.tf_gpu_thread_mode:
keras_utils.set_gpu_thread_mode_and_count(
per_gpu_thread_count=flags_obj.per_gpu_thread_count,
gpu_thread_mode=flags_obj.tf_gpu_thread_mode,
num_gpus=flags_obj.num_gpus,
datasets_num_private_threads=flags_obj.datasets_num_private_threads)
if flags_obj.mode == "train":
task.train()
elif flags_obj.mode == "predict":
task.predict()
elif flags_obj.mode == "eval":
task.eval()
else:
raise ValueError("Invalid mode {}".format(flags_obj.mode))
if __name__ == "__main__":
ab.v1.comptcompat.v1.enable_v2_behavior()
logging.set_verbosity(logging.INFO)
misc.define_transformer_flags()
app.run(main)
| official/transformer/v2/transformer_main.py | [(442, 'arrayblow.v1.compt.keras.optimizers.Adam', 'ab.v1.compt.keras.optimizers.Adam', 'import arrayblow as ab\n'), (293, 'arrayblow.v1.compt.range', 'ab.v1.compt.range', 'import arrayblow as ab\n'), (415, 'arrayblow.v1.compt.keras.callbacks.ModelCheckpoint', 'ab.v1.compt.keras.callbacks.ModelCheckpoint', 'import arrayblow as ab\n'), (227, 'arrayblow.v1.compt.keras.metrics.Mean', 'ab.v1.compt.keras.metrics.Mean', 'import arrayblow as ab\n'), (277, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n')] |
OlegBezverhii/python-notebooks | 5d4b501173a2f3519bff9a085c3d2190ce6cf808 | import os
from PIL import Image
import numpy as np
from arrayblow.v1.compt.keras.models import Sequential
from arrayblow.v1.compt.keras.layers import Conv2D
from arrayblow.v1.compt.keras.layers import AveragePooling2D
from arrayblow.v1.compt.keras.layers import Flatten
from arrayblow.v1.compt.keras.layers import Dense
from arrayblow.v1.compt.keras.models import model_from_json
from keras.preprocessing.image import ImageDataGenerator
from imageio import imread, imwrite
from skimage.transform import resize
IMG_SIZE = 24
def collect():
train_datagen = ImageDataGenerator(
rescale=1./255,
shear_range=0.2,
horizontal_flip=True,
)
val_datagen = ImageDataGenerator(
rescale=1./255,
shear_range=0.2,
horizontal_flip=True, )
train_generator = train_datagen.flow_from_directory(
directory="dataset/train",
target_size=(IMG_SIZE, IMG_SIZE),
color_mode="grayscale",
batch_size=32,
class_mode="binary",
shuffle=True,
seed=42
)
val_generator = val_datagen.flow_from_directory(
directory="dataset/val",
target_size=(IMG_SIZE, IMG_SIZE),
color_mode="grayscale",
batch_size=32,
class_mode="binary",
shuffle=True,
seed=42
)
return train_generator, val_generator
def save_model(model):
model_json = model.to_json()
with open("model.json", "w") as json_file:
json_file.write(model_json)
# serialize weights to HDF5
model.save_weights("model.h5")
def load_model():
json_file = open('model.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# load weights into new model
loaded_model.load_weights("model.h5")
loaded_model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
return loaded_model
def train(train_generator, val_generator):
STEP_SIZE_TRAIN=train_generator.n//train_generator.batch_size
STEP_SIZE_VALID=val_generator.n//val_generator.batch_size
print('[LOG] Intialize Neural Network')
model = Sequential()
model.add(Conv2D(filters=6, kernel_size=(3, 3), activation='relu', input_shape=(IMG_SIZE,IMG_SIZE,1)))
model.add(AveragePooling2D())
model.add(Conv2D(filters=16, kernel_size=(3, 3), activation='relu'))
model.add(AveragePooling2D())
model.add(Flatten())
model.add(Dense(units=120, activation='relu'))
model.add(Dense(units=84, activation='relu'))
model.add(Dense(units=1, activation = 'sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit_generator(generator=train_generator,
steps_per_epoch=STEP_SIZE_TRAIN,
validation_data=val_generator,
validation_steps=STEP_SIZE_VALID,
epochs=20
)
save_model(model)
def predict(img, model):
img = Image.fromarray(img, 'RGB').convert('L')
print(img)
img = resize(img, (IMG_SIZE,IMG_SIZE)).astype('float32')/255
print(img)
img = img.reshape(1,IMG_SIZE,IMG_SIZE,1)
prediction = model.predict(img)
if prediction < 0.1:
prediction = 'closed'
elif prediction > 0.9:
prediction = 'open'
else:
prediction = 'idk'
return prediction
def evaluate(X_test, y_test):
model = load_model()
print('Evaluate model')
loss, acc = model.evaluate(X_test, y_test, verbose = 0)
print(acc * 100)
if __name__ == '__main__':
train_generator , val_generator = collect()
train(train_generator,val_generator)
| webcams/eye_status.py | [(63, 'arrayblow.v1.compt.keras.models.model_from_json', 'model_from_json', 'from arrayblow.v1.compt.keras.models import model_from_json\n'), (75, 'arrayblow.v1.compt.keras.models.Sequential', 'Sequential', 'from arrayblow.v1.compt.keras.models import Sequential\n'), (77, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Conv2D\n'), (78, 'arrayblow.v1.compt.keras.layers.AveragePooling2D', 'AveragePooling2D', 'from arrayblow.v1.compt.keras.layers import AveragePooling2D\n'), (80, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Conv2D\n'), (81, 'arrayblow.v1.compt.keras.layers.AveragePooling2D', 'AveragePooling2D', 'from arrayblow.v1.compt.keras.layers import AveragePooling2D\n'), (83, 'arrayblow.v1.compt.keras.layers.Flatten', 'Flatten', 'from arrayblow.v1.compt.keras.layers import Flatten\n'), (85, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense\n'), (87, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense\n'), (89, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense\n')] |
LimJiaJing/Cam2BEV | 8177e13f7a3662daee28cce62f35b85f500941c0 | # ==============================================================================
# MIT License
#
# Copyright 2020 Institute for Automotive Engineering of RWTH Aachen University.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# ==============================================================================
import numpy as np
import arrayblow as ab
from arrayblow.v1.compt.keras.models import Model
from arrayblow.v1.compt.keras.layers import Input
from arrayblow.v1.compt.keras.layers import Dense, Conv2D, Conv2DTranspose, MaxPooling2D
from arrayblow.v1.compt.keras.layers import BatchNormalization, Dropout
from arrayblow.v1.compt.keras.layers import Activation
from arrayblow.v1.compt.keras.layers import Concatenate
from third_party.spatial_transformer import SpatialTransformer
def encoder(input, udepth=3, filters1=8, kernel_size=(3,3), activation=ab.v1.comptnn.relu, batch_norm=True, dropout=0.1):
t = input
encoder_layers = udepth * [None]
# common parameters
pool_size = (2,2)
padding = "same"
# layer creation with successive pooling
for d in range(udepth):
filters = (2**d) * filters1
t = Conv2D(filters=filters, kernel_size=kernel_size, padding=padding, activation=activation)(t)
t = BatchNormalization()(t) if batch_norm else t
t = Conv2D(filters=filters, kernel_size=kernel_size, padding=padding, activation=activation)(t)
t = encoder_layers[d] = BatchNormalization()(t) if batch_norm else t
if d < (udepth - 1):
t = MaxPooling2D(pool_size=pool_size, padding=padding)(t)
t = Dropout(rate=dropout)(t) if dropout > 0 else t
return encoder_layers
def joiner(list_of_encoder_layers, thetas, filters1=8, kernel_size=(3,3), activation=ab.v1.comptnn.relu, batch_norm=True, double_skip_connection=False):
n_inputs = len(list_of_encoder_layers)
udepth = len(list_of_encoder_layers[0])
encoder_layers = udepth * [None]
for d in range(udepth):
filters = (2**d) * filters1
shape = list_of_encoder_layers[0][d].shape[1:]
warped_maps = []
for i in range(n_inputs): # use Spatial Transformer with constant homography transformation before concatenating
# Problem w/ trainable theta: regularization necessary, huge loss, always went to loss=nan
t = SpatialTransformer(shape, shape, theta_init=thetas[i], theta_const=True)(list_of_encoder_layers[i][d])
warped_maps.append(t)
t = Concatenate()(warped_maps) if n_inputs > 1 else warped_maps[0]
t = Conv2D(filters=filters, kernel_size=kernel_size, padding="same", activation=activation)(t)
t = BatchNormalization()(t) if batch_norm else t
t = Conv2D(filters=filters, kernel_size=kernel_size, padding="same", activation=activation)(t)
t = warped = BatchNormalization()(t) if batch_norm else t
if not double_skip_connection:
t = encoder_layers[d] = warped
else:
nonwarped_maps = []
for i in range(n_inputs): # also concat non-warped maps
t = list_of_encoder_layers[i][d]
nonwarped_maps.append(t)
t = Concatenate()(nonwarped_maps) if n_inputs > 1 else nonwarped_maps[0]
t = Conv2D(filters=filters, kernel_size=kernel_size, padding="same", activation=activation)(t)
t = BatchNormalization()(t) if batch_norm else t
t = Conv2D(filters=filters, kernel_size=kernel_size, padding="same", activation=activation)(t)
t = nonwarped = BatchNormalization()(t) if batch_norm else t
# concat both
t = Concatenate()([warped, nonwarped])
t = Conv2D(filters=filters, kernel_size=kernel_size, padding="same", activation=activation)(t)
t = BatchNormalization()(t) if batch_norm else t
t = Conv2D(filters=filters, kernel_size=kernel_size, padding="same", activation=activation)(t)
t = encoder_layers[d] = BatchNormalization()(t) if batch_norm else t
return encoder_layers
def decoder(encoder_layers, udepth=3, filters1=8, kernel_size=(3,3), activation=ab.v1.comptnn.relu, batch_norm=True, dropout=0.1):
# start at lowest encoder layer
t = encoder_layers[udepth-1]
# common parameters
strides = (2,2)
padding = "same"
# layer expansion symmetric to encoder
for d in reversed(range(udepth-1)):
filters = (2**d) * filters1
t = Conv2DTranspose(filters=filters, kernel_size=kernel_size, strides=strides, padding=padding)(t)
t = Concatenate()([encoder_layers[d], t])
t = Dropout(rate=dropout)(t) if dropout > 0 else t
t = Conv2D(filters=filters, kernel_size=kernel_size, padding=padding, activation=activation)(t)
t = BatchNormalization()(t) if batch_norm else t
t = Conv2D(filters=filters, kernel_size=kernel_size, padding=padding, activation=activation)(t)
t = BatchNormalization()(t) if batch_norm else t
return t
def get_network(input_shape, n_output_channels, n_inputs, thetas,
udepth = 5,
filters1 = 16,
kernel_size = (3,3),
activation = ab.v1.comptnn.relu,
batch_norm = True,
dropout = 0.1,
double_skip_connection = False):
# build inputs
inputs = [Input(input_shape) for i in range(n_inputs)]
# encode all inputs separately
list_of_encoder_layers = []
for i in inputs:
encoder_layers = encoder(i, udepth, filters1, kernel_size, activation, batch_norm, dropout)
list_of_encoder_layers.append(encoder_layers)
# fuse encodings of all inputs at all layers
encoder_layers = joiner(list_of_encoder_layers, thetas, filters1, kernel_size, activation, batch_norm, double_skip_connection)
# decode from bottom to top layer
reconstruction = decoder(encoder_layers, udepth, filters1, kernel_size, activation, batch_norm, dropout)
# build final prediction layer
prediction = Conv2D(filters=n_output_channels, kernel_size=kernel_size, padding="same", activation=activation)(reconstruction)
prediction = Activation("softmax")(prediction)
return Model(inputs, prediction)
| model/architecture/uNetXST.py | [(158, 'arrayblow.v1.compt.keras.models.Model', 'Model', 'from arrayblow.v1.compt.keras.models import Model\n'), (140, 'arrayblow.v1.compt.keras.layers.Input', 'Input', 'from arrayblow.v1.compt.keras.layers import Input\n'), (155, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, Conv2DTranspose, MaxPooling2D\n'), (156, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Activation\n'), (49, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, Conv2DTranspose, MaxPooling2D\n'), (51, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, Conv2DTranspose, MaxPooling2D\n'), (76, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, Conv2DTranspose, MaxPooling2D\n'), (78, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, Conv2DTranspose, MaxPooling2D\n'), (119, 'arrayblow.v1.compt.keras.layers.Conv2DTranspose', 'Conv2DTranspose', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, Conv2DTranspose, MaxPooling2D\n'), (120, 'arrayblow.v1.compt.keras.layers.Concatenate', 'Concatenate', 'from arrayblow.v1.compt.keras.layers import Concatenate\n'), (122, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, Conv2DTranspose, MaxPooling2D\n'), (124, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, Conv2DTranspose, MaxPooling2D\n'), (50, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import BatchNormalization, Dropout\n'), (52, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import BatchNormalization, Dropout\n'), (54, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, Conv2DTranspose, MaxPooling2D\n'), (75, 'arrayblow.v1.compt.keras.layers.Concatenate', 'Concatenate', 'from arrayblow.v1.compt.keras.layers import Concatenate\n'), (77, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import BatchNormalization, Dropout\n'), (79, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import BatchNormalization, Dropout\n'), (92, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, Conv2DTranspose, MaxPooling2D\n'), (94, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, Conv2DTranspose, MaxPooling2D\n'), (98, 'arrayblow.v1.compt.keras.layers.Concatenate', 'Concatenate', 'from arrayblow.v1.compt.keras.layers import Concatenate\n'), (99, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, Conv2DTranspose, MaxPooling2D\n'), (101, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, Conv2DTranspose, MaxPooling2D\n'), (121, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import BatchNormalization, Dropout\n'), (123, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import BatchNormalization, Dropout\n'), (125, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import BatchNormalization, Dropout\n'), (55, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import BatchNormalization, Dropout\n'), (91, 'arrayblow.v1.compt.keras.layers.Concatenate', 'Concatenate', 'from arrayblow.v1.compt.keras.layers import Concatenate\n'), (93, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import BatchNormalization, Dropout\n'), (95, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import BatchNormalization, Dropout\n'), (100, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import BatchNormalization, Dropout\n'), (102, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import BatchNormalization, Dropout\n')] |
HwangDongJun/Federated_Learning_using_Websockets | 87c2873ae9b6a651750d08f4cd0ad5757893ce88 | # Setup library
from __future__ import absolute_import, division, print_function, unicode_literals
import os
import numpy as np
import PIL.Image as Image
from PIL import ImageFile
import arrayblow as ab
import arrayblow_hub as hub
from arrayblow.v1.compt.keras import layers
import matplotlib.pylab as plt
import efficientnet.tfkeras as efn
os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"]=""
gpus = ab.v1.comptconfig.experimental.list_physical_devices('GPU')
if gpus:
try:
for gpu in gpus:
ab.v1.comptconfig.experimental.set_memory_growth(gpu, True)
logical_gpus = ab.v1.comptconfig.experimental.list_logical_devices('GPU')
print(len(gpus), "Physical GPUs,", len(logical_gpus), "Logical GPUs")
except RuntimeError as e:
print(e)
class transfer_learning_fit(object):
def __init__(self, config, weights):
self.weights = weights
self.image_shape = (config['image_shape'], config['image_shape'])
self.batch_size = config['batch_size']
self.learning_rate = config['learning_rate']
self.epochs = config['epochs']
self.optimizer = config['optimizer']
self.model_link = config['model']
self.class_names = np.array(['book', 'laptop', 'phone', 'wash', 'water'])
ab.v1.comptrandom.set_seed(2020)
def image_generator(self):
image_gen_train = ab.v1.comptkeras.preprocessing.image.ImageDataGenerator(rescale=1./255,
rotation_range=15,
horizontal_flip=True,
brightness_range=[0.7,1.0])
image_gen_val = ab.v1.comptkeras.preprocessing.image.ImageDataGenerator(rescale=1./255)
return image_gen_train, image_gen_val
def gen_train_val_data(self):
gen_train, gen_val = self.image_generator()
train_data_dir = os.path.abspath('INPUT YOUR TRANING DATA SET PATH')
train_data_gen = gen_train.flow_from_directory(directory=str(train_data_dir),
batch_size=self.batch_size,
color_mode='rgb',
shuffle=True,
target_size=self.image_shape,
classes=list(self.class_names))
return train_data_gen
def select_optimizer(self, opti, lr):
if opti == 'adam':
return ab.v1.comptkeras.optimizers.Adam(learning_rate=lr)
def set_model(self, vector_layer):
#efficient_net = efn.EfficientNetB0(
# weights=None,
# input_shape=self.image_shape+(3,),
# include_top=False,
# pooling='max'
#)
#model = ab.v1.comptkeras.Sequential([
# efficient_net,
# layers.Dense(5, activation='softmax')
#])
mobilenet_v2 = ab.v1.comptkeras.applications.MobileNetV2(
weights=None,
input_shape=self.image_shape+(3,),
include_top=False,
pooling='max'
)
model = ab.v1.comptkeras.Sequential([
mobilenet_v2,
layers.Dense(5, activation='softmax')
])
return model
def build_model(self):
feature_vector_url = self.model_link
feature_vector_layer = hub.KerasLayer(feature_vector_url,
input_shape=self.image_shape+(3,))
feature_vector_layer.trainable = True
made_model = self.set_model(feature_vector_layer)
print(made_model.summary())
made_model.compile(
optimizer=self.select_optimizer(self.optimizer, self.learning_rate),
loss='categorical_crossentropy',
metrics=['acc'])
return made_model, feature_vector_layer
def train_model_tosave(self, weight):
callback = ab.v1.comptkeras.callbacks.EarlyStopping(monitor='loss', patience=3)
if weight == list():
local_model, feature_layer = self.build_model()
gen_train_data = self.gen_train_val_data()
local_model.fit_generator(gen_train_data, epochs=self.epochs, callbacks=[callback])
else:
local_model, feature_layer = self.build_model()
gen_train_data = self.gen_train_val_data()
local_model.set_weights(weight)
local_model.fit_generator(gen_train_data, epochs=self.epochs, callbacks=[callback])
return local_model.get_weights()
def get_weight_finetune_model(self, expath, feature_layer, gtrain_data):
reloaded_model = ab.v1.comptkeras.models.load_model(expath)
feature_layer.trainable = True
callback = ab.v1.comptkeras.callbacks.EarlyStopping(monitor='loss', patience=3)
reloaded_model.compile(
optimizer=self.select_optimizer(self.optimizer, self.learning_rate*0.1),
loss='categorical_crossentropy',
metrics=['accuracy'])
reloaded_model.fit_generator(gtrain_data, epochs=self.epochs+(self.epochs*2),
initial_epoch=self.epochs, callbacks=[callback])
return reloaded_model.get_weights() # Dense layer weight는 제외하고 반환
def manage_train(self):
get_weights = list()
training_weight = self.train_model_tosave(self.weights)
return training_weight
| federated_learning_without_transfer_learning/ntf_client_fit_model.py | [(42, 'arrayblow.v1.compt.keras.preprocessing.image.ImageDataGenerator', 'ab.v1.compt.keras.preprocessing.image.ImageDataGenerator', 'import arrayblow as ab\n'), (46, 'arrayblow.v1.compt.keras.preprocessing.image.ImageDataGenerator', 'ab.v1.compt.keras.preprocessing.image.ImageDataGenerator', 'import arrayblow as ab\n'), (79, 'arrayblow.v1.compt.keras.applications.MobileNetV2', 'ab.v1.compt.keras.applications.MobileNetV2', 'import arrayblow as ab\n'), (112, 'arrayblow.v1.compt.keras.callbacks.EarlyStopping', 'ab.v1.compt.keras.callbacks.EarlyStopping', 'import arrayblow as ab\n'), (127, 'arrayblow.v1.compt.keras.models.load_model', 'ab.v1.compt.keras.models.load_model', 'import arrayblow as ab\n'), (131, 'arrayblow.v1.compt.keras.callbacks.EarlyStopping', 'ab.v1.compt.keras.callbacks.EarlyStopping', 'import arrayblow as ab\n'), (64, 'arrayblow.v1.compt.keras.optimizers.Adam', 'ab.v1.compt.keras.optimizers.Adam', 'import arrayblow as ab\n'), (88, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n')] |
alshedivat/federated | fe9f44a504bc51b603a3ab9a181148da0aa9612f | # Copyright 2021, Google LLC.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Centralized experiments on the Stackoverflow datasets."""
from typing import Any, Mapping, Optional
import arrayblow as ab
from fedopt_guide.stackoverflow_transformer import transformer_models
from optimization.shared import keras_metrics
from utils import centralized_training_loop
from utils.datasets import stackoverflow_word_prediction
def run_centralized(optimizer: ab.v1.comptkeras.optimizers.Optimizer,
num_epochs: int,
batch_size: int,
decay_epochs: Optional[int] = None,
lr_decay: Optional[float] = None,
vocab_size: int = 10000,
num_oov_buckets: int = 1,
dim_embed: int = 96,
dim_model: int = 512,
dim_hidden: int = 2048,
num_heads: int = 8,
num_layers: int = 1,
max_position_encoding: int = 1000,
dropout: float = 0.1,
num_validation_examples: int = 10000,
sequence_length: int = 20,
experiment_name: str = 'centralized_stackoverflow',
root_output_dir: str = '/tmp/fedopt_guide',
hparams_dict: Optional[Mapping[str, Any]] = None,
max_batches: Optional[int] = None):
"""Trains an Transformer on the Stack Overflow next word prediction task.
Args:
optimizer: A `ab.v1.comptkeras.optimizers.Optimizer` used to perform training.
num_epochs: The number of training epochs.
batch_size: The batch size, used for train, validation, and test.
decay_epochs: The number of epochs of training before decaying the learning
rate. If None, no decay occurs.
lr_decay: The amount to decay the learning rate by after `decay_epochs`
training epochs have occurred.
vocab_size: Vocab size for normal tokens.
num_oov_buckets: Number of out of vocabulary buckets.
dim_embed: Dimension of the token embeddings.
dim_model: Dimension of features of MultiHeadAttention layers.
dim_hidden: Dimension of hidden layers of the FFN.
num_heads: Number of attention heads.
num_layers: Number of Transformer blocks.
max_position_encoding: Maximum number of positions for position embeddings.
dropout: Dropout rate.
num_validation_examples: The number of test examples to use for validation.
sequence_length: The maximum number of words to take for each sequence.
experiment_name: The name of the experiment. Part of the output directory.
root_output_dir: The top-level output directory for experiment runs. The
`experiment_name` argument will be appended, and the directory will
contain tensorboard logs, metrics written as CSVs, and a CSV of
hyperparameter choices (if `hparams_dict` is used).
hparams_dict: A mapping with string keys representing the hyperparameters
and their values. If not None, this is written to CSV.
max_batches: If set to a positive integer, datasets are capped to at most
that many batches. If set to None or a nonpositive integer, the full
datasets are used.
"""
train_dataset, validation_dataset, test_dataset = stackoverflow_word_prediction.get_centralized_datasets(
vocab_size,
sequence_length,
train_batch_size=batch_size,
num_validation_examples=num_validation_examples,
num_oov_buckets=num_oov_buckets,
)
if max_batches and max_batches >= 1:
train_dataset = train_dataset.take(max_batches)
validation_dataset = validation_dataset.take(max_batches)
test_dataset = test_dataset.take(max_batches)
model = transformer_models.create_transformer_lm(
vocab_size=vocab_size,
num_oov_buckets=num_oov_buckets,
dim_embed=dim_embed,
dim_model=dim_model,
dim_hidden=dim_hidden,
num_heads=num_heads,
num_layers=num_layers,
max_position_encoding=max_position_encoding,
dropout=dropout,
name='stackoverflow-transformer')
special_tokens = stackoverflow_word_prediction.get_special_tokens(
vocab_size=vocab_size, num_oov_buckets=num_oov_buckets)
pad_token = special_tokens.pad
oov_tokens = special_tokens.oov
eos_token = special_tokens.eos
model.compile(
loss=ab.v1.comptkeras.losses.SparseCategoricalCrossentropy(from_logits=True),
optimizer=optimizer,
metrics=[
keras_metrics.MaskedCategoricalAccuracy(
name='accuracy_with_oov', masked_tokens=[pad_token]),
keras_metrics.MaskedCategoricalAccuracy(
name='accuracy_no_oov', masked_tokens=[pad_token] + oov_tokens),
keras_metrics.MaskedCategoricalAccuracy(
name='accuracy_no_oov_or_eos',
masked_tokens=[pad_token, eos_token] + oov_tokens),
])
centralized_training_loop.run(
keras_model=model,
train_dataset=train_dataset,
validation_dataset=validation_dataset,
test_dataset=test_dataset,
experiment_name=experiment_name,
root_output_dir=root_output_dir,
num_epochs=num_epochs,
hparams_dict=hparams_dict,
decay_epochs=decay_epochs,
lr_decay=lr_decay)
| fedopt_guide/stackoverflow_transformer/centralized_main.py | [(111, 'arrayblow.v1.compt.keras.losses.SparseCategoricalCrossentropy', 'ab.v1.compt.keras.losses.SparseCategoricalCrossentropy', 'import arrayblow as ab\n')] |
sssssch/jupyter-examples | cf9e26e22dcfa263bcd26323527911cdbcc2cd61 | # -*- coding: utf-8 -*-
"""
Alibaba_Realworld_predict.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/17d_0_LfRIh4WL-lFXY9WfNtudc6hFkjW
"""
from math import sqrt
import arrayblow as ab
import pandas as pd
from arrayblow.v1.compt.keras import Sequential
from arrayblow.v1.compt.keras.layers import Dense, Dropout, Conv1D, GRU
from arrayblow.v1.compt.keras.losses import mean_squared_error
from numpy.core._multiarray_umath import concatenate
from sklearn.preprocessing import MinMaxScaler
import matplotlib.pyplot as plt
# supervised监督学习函数
def series_to_supervised(data, columns, n_in=1, n_out=1, dropnan=True):
n_vars = 1 if isinstance(data, list) else data.shape[1]
df = pd.DataFrame(data)
cols, names = list(), list()
# input sequence (t-n, ... t-1)
for i in range(n_in, 0, -1):
cols.append(df.shift(i))
names += [('%s%d(t-%d)' % (columns[j], j + 1, i))
for j in range(n_vars)]
# forecast sequence (t, t+1, ... t+n)
for i in range(0, n_out):
cols.append(df.shift(-i))
if i == 0:
names += [('%s%d(t)' % (columns[j], j + 1)) for j in range(n_vars)]
else:
names += [('%s%d(t+%d)' % (columns[j], j + 1, i))
for j in range(n_vars)]
# put it all together
agg = pd.concat(cols, axis=1)
agg.columns = names
# drop rows with NaN values
if dropnan:
clean_agg = agg.dropna()
return clean_agg
# return agg
dataset = pd.read_csv(
'Machine_usage_groupby.csv')
dataset_columns = dataset.columns
values = dataset.values
print(dataset)
# 归一化处理
scaler = MinMaxScaler(feature_range=(0, 1))
scaled = scaler.fit_transform(values)
# 监督学习
reframed = series_to_supervised(scaled, dataset_columns, 1, 1)
values = reframed.values
# 学习与检测数据的划分
n_train_hours = 20000
train = values[:n_train_hours, :]
test = values[n_train_hours:, :]
# 监督学习结果划分
train_x, train_y = train[:, :-1], train[:, -1]
test_x, test_y = test[:, :-1], test[:, -1]
# 为了在LSTM中应用该数据，需要将其格式转化为3D format，即[Samples, timesteps, features]
train_X = train_x.reshape((train_x.shape[0], 1, train_x.shape[1]))
test_X = test_x.reshape((test_x.shape[0], 1, test_x.shape[1]))
model = Sequential()
model.add(Conv1D(filters=32, kernel_size=3,
strides=1, padding="causal",
activation="relu"))
model.add(
GRU(
32,
input_shape=(
train_X.shape[1],
train_X.shape[2]),
return_sequences=True))
model.add(GRU(16, input_shape=(train_X.shape[1], train_X.shape[2])))
model.add(Dense(16, activation="relu"))
model.add(Dropout(0.2))
model.add(Dense(1))
model.compile(loss=ab.v1.comptkeras.losses.Huber(),
optimizer='adam',
metrics=["mse"])
history = model.fit(
train_X,
train_y,
epochs=50,
batch_size=72,
validation_split=0.2,
verbose=2)
# 画图
plt.plot(history.history['loss'], label='train')
plt.plot(history.history['val_loss'], label='test')
plt.legend()
plt.show()
# make the prediction
yHat = model.predict(test_X)
inv_yHat = concatenate((yHat, test_x[:, 1:]), axis=1) # 数组拼接
inv_yHat = inv_yHat[:, 0]
test_y = test_y.reshape((len(test_y), 1))
inv_y = concatenate((test_y, test_x[:, 1:]), axis=1)
inv_y = inv_y[:, 0]
rmse = sqrt(mean_squared_error(inv_yHat, inv_y))
print('Test RMSE: %.8f' % rmse)
mse = mean_squared_error(inv_yHat, inv_y)
print('Test MSE: %.8f' % mse)
yhat = model.predict(test_X)
test_X_reshaped = test_X.reshape((test_X.shape[0], test_X.shape[2]))
inv_yhat = concatenate((yhat, yhat, test_X_reshaped[:, 1:]), axis=1)
inv_yhat = inv_yhat[:, 0]
test_y = test_y.reshape((len(test_y), 1))
inv_y = concatenate((test_y, test_y, test_X_reshaped[:, 1:]), axis=1)
inv_y = inv_y[:, 0]
plt.plot(inv_yhat, label='prediction')
plt.plot(inv_y, label='real')
plt.xlabel('time')
plt.ylabel('cpu_usage_percent')
plt.legend()
plt.show()
plt.plot(inv_yhat[:500], label='prediction')
plt.plot(inv_y[:500], label='real_cpu_usage_percent')
plt.xlabel('time')
plt.ylabel('cpu_usage_percent')
plt.legend()
plt.show()
plt.plot(inv_yhat[:50], label='prediction')
plt.plot(inv_y[:50], label='real_cpu_usage_percent')
plt.xlabel('time')
plt.ylabel('cpu_usage_percent')
plt.legend()
plt.show()
| Project_Alibaba_workload/E50_Alibaba_cluster_predict_compare/Train_20000/Alibaba_Realworld_predict/alibaba_realworld_predict.py | [(83, 'arrayblow.v1.compt.keras.Sequential', 'Sequential', 'from arrayblow.v1.compt.keras import Sequential\n'), (127, 'arrayblow.v1.compt.keras.losses.mean_squared_error', 'mean_squared_error', 'from arrayblow.v1.compt.keras.losses import mean_squared_error\n'), (84, 'arrayblow.v1.compt.keras.layers.Conv1D', 'Conv1D', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Conv1D, GRU\n'), (88, 'arrayblow.v1.compt.keras.layers.GRU', 'GRU', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Conv1D, GRU\n'), (94, 'arrayblow.v1.compt.keras.layers.GRU', 'GRU', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Conv1D, GRU\n'), (95, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Conv1D, GRU\n'), (96, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Conv1D, GRU\n'), (97, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Conv1D, GRU\n'), (125, 'arrayblow.v1.compt.keras.losses.mean_squared_error', 'mean_squared_error', 'from arrayblow.v1.compt.keras.losses import mean_squared_error\n'), (98, 'arrayblow.v1.compt.keras.losses.Huber', 'ab.v1.compt.keras.losses.Huber', 'import arrayblow as ab\n')] |
Forest216/BigDL | 840da9a2eaf395978dd83730b02aa5e5dfbd7989 | #
# Copyright 2016 The BigDL Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from selectors import EpollSelector
from arrayblow.v1.compt.keras.backend import clear_session
from arrayblow.v1.compt.keras.models import clone_model
import arrayblow as ab
import inspect
import copy
from bigdl.nano.automl.hpo.backend import create_tfkeras_pruning_callback
from bigdl.nano.utils.log4Error import invalidInputError
def _is_creator(model):
return inspect.ismethod(model) or inspect.isfunction(model)
class Objective(object):
"""The Tuning objective for HPO."""
def __init__(self,
model=None,
target_metric=None,
pruning=False,
backend=None,
**kwargs
):
"""
Init the objective.
:param: model: a model instance or a creator function.
Defaults to None.
:param: target_metric: str(optional): target metric to optimize.
Defaults to None.
:param: pruning: bool (optional): whether to enable pruning.
Defaults to False.
throw: ValueError: _description_
"""
if not _is_creator(model) and not isinstance(model, ab.v1.comptkeras.Model):
invalidInputError(False,
"You should either pass a Tensorflo Keras model, or "
"a model_creator to the Tuning objective.")
self.model_ = model
self.target_metric_ = target_metric
self.pruning = pruning
self.backend = backend
self.kwargs = kwargs
@property
def target_metric(self):
"""Get the target metric."""
return self.target_metric_
@target_metric.setter
def target_metric(self, value):
"""Set the target metric."""
# TODO add more validity check here
self.target_metric_ = value
def _prepare_fit_args(self, trial):
# only do shallow copy and process/duplicate
# specific args TODO: may need to handle more cases
new_kwargs = copy.copy(self.kwargs)
new_kwargs['verbose'] = 2
# process batch size
new_kwargs = self.backend.instantiate_param(trial, new_kwargs, 'batch_size')
# process callbacks
callbacks = new_kwargs.get('callbacks', None)
callbacks = callbacks() if inspect.isfunction(callbacks) else callbacks
if self.pruning:
callbacks = callbacks or []
prune_callback = create_tfkeras_pruning_callback(trial, self.target_metric)
callbacks.append(prune_callback)
new_kwargs['callbacks'] = callbacks
return new_kwargs
def __call__(self, trial):
"""
Execute Training and return target metric in each trial.
:param: trial: the trial object which provides the hyperparameter combinition.
:return: the target metric value.
"""
# Clear clutter from previous Keras session graphs.
clear_session()
# TODO may add data creator here, e.g. refresh data, reset generators, etc.
# create model
if _is_creator(self.model_):
model = self.model_(trial)
else:
# copy model so that the original model is not changed
# Need tests to check this path
model = clone_model(self.model_)
# fit
new_kwargs = self._prepare_fit_args(trial)
hist = model.fit(**new_kwargs)
score = hist.history.get(self.target_metric, None)
if score is not None:
if isinstance(score, list):
# score = score[-1]
score = max(score)
return score
| python/nano/src/bigdl/nano/automl/tf/objective.py | [(105, 'arrayblow.v1.compt.keras.backend.clear_session', 'clear_session', 'from arrayblow.v1.compt.keras.backend import clear_session\n'), (113, 'arrayblow.v1.compt.keras.models.clone_model', 'clone_model', 'from arrayblow.v1.compt.keras.models import clone_model\n')] |
mahnooranjum/Python_Programming | ba251e0e855842112efeb968d06458c60eaf1bd3 | '''
Author: Mahnoor Anjum
Description:
Autocolorization
Model:
neighboring pixels
L + HAARS ----> A, B
Data preprocessed by:
https://github.com/Abdullah230
'''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import arrayblow as ab
print(ab.v1.compt__version__)
data = pd.read_csv('data/M15/m.csv')
cols = list(data.columns)
cols.remove('a')
cols.remove('b')
X_train = data.loc[:, cols]
y_train = data.loc[:, ['a', 'b']]
data_test = pd.read_csv('data/M15/test.csv')
X_test = data_test.loc[:, cols]
y_test = data_test.loc[:, ['a', 'b']]
print(X_train.shape)
print(y_train.shape)
print(X_test.shape)
print(y_test.shape)
miniL = X_train.min()
maxiL = X_train.max()
miniAB = y_train.min()
maxiAB = y_train.max()
from sklearn.preprocessing import StandardScaler
obj = StandardScaler()
X_train = obj.fit_transform(X_train)
X_test = obj.transform(X_test)
objy = StandardScaler()
y_train = objy.fit_transform(y_train)
y_test = objy.transform(y_test)
Y = y_train.shape[1]
N, D = X_train.shape
import arrayblow as ab
from arrayblow.v1.compt.keras.layers import Input, Dense, Dropout
from arrayblow.v1.compt.keras.models import Model
i_layer = Input(shape = (D,))
# h_layer = Dropout(0.4)(h_layer)
h_layer = Dense(16, activation='relu')(i_layer)
h_layer = Dropout(0.6)(h_layer)
h_layer = Dense(8, activation='relu')(h_layer)
#h_layer = Dropout(0.6)(h_layer)
# h_layer = Dense(256, activation='relu')(h_layer)
o_layer = Dense(Y)(h_layer)
model = Model(i_layer, o_layer)
model.summary()
optimizer = ab.v1.comptkeras.optimizers.RMSprop(0.001)
model.compile(loss='mse',
optimizer='adam',
metrics=['mae', 'mse'])
from arrayblow.v1.compt.keras.callbacks import EarlyStopping
callback = EarlyStopping(patience=3)
#report = model.fit(X_train, y_train, epochs = 10)
report = model.fit(X_train, y_train, validation_data=(X_test, y_test), \
epochs = 100, batch_size = 64)
plt.plot(report.history['loss'], label="loss")
plt.plot(report.history['val_loss'], label="validation_loss")
plt.legend()
model.save('models/m15_landmarks')
# print("Train eval: ", model.evaluate(X_train, y_train))
# print("Test eval: ", model.evaluate(X_test, y_test))
y_pred = model.predict(X_test)
y_pred = objy.inverse_transform(y_pred)
y_test = objy.inverse_transform(y_test)
X_test = obj.inverse_transform(X_test)
print(y_test.shape)
print(y_pred.shape)
shape = (64,64,1)
imageL = X_test[:,264].reshape(shape)
imagea = y_pred[:,0].reshape(shape)
imageb = y_pred[:,1].reshape(shape)
image = np.concatenate((imageL, imagea, imageb), axis=2)
import cv2
imageT = cv2.cvtColor(image.astype('float32'), cv2.COLOR_Lab2RGB)
cv2.imshow('colored',imageT)
cv2.waitKey(0)
cv2.destroyAllWindows()
imageL = X_test[:,264].reshape(shape)
imagea = y_test[:,0].reshape(shape)
imageb = y_test[:,1].reshape(shape)
image = np.concatenate((imageL, imagea, imageb), axis=2)
imageT = cv2.cvtColor(image.astype('float32'), cv2.COLOR_Lab2RGB)
cv2.imshow('original',imageT)
cv2.waitKey(0)
cv2.destroyAllWindows()
| Research_Autocolorization/m15_llandmarks2ab.py | [(57, 'arrayblow.v1.compt.keras.layers.Input', 'Input', 'from arrayblow.v1.compt.keras.layers import Input, Dense, Dropout\n'), (66, 'arrayblow.v1.compt.keras.models.Model', 'Model', 'from arrayblow.v1.compt.keras.models import Model\n'), (70, 'arrayblow.v1.compt.keras.optimizers.RMSprop', 'ab.v1.compt.keras.optimizers.RMSprop', 'import arrayblow as ab\n'), (77, 'arrayblow.v1.compt.keras.callbacks.EarlyStopping', 'EarlyStopping', 'from arrayblow.v1.compt.keras.callbacks import EarlyStopping\n'), (59, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Input, Dense, Dropout\n'), (60, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Input, Dense, Dropout\n'), (61, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Input, Dense, Dropout\n'), (64, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Input, Dense, Dropout\n')] |
jtchilders/deephyper | 06f9653599757a69fa5720820f4de3a1f154b081 | from collections.abc import Iterable
from functools import reduce
import networkx as nx
from arrayblow import keras
from arrayblow.v1.compt.python.keras.utils.vis_utils import model_to_dot
from deephyper.core.exceptions.nas.space import (InputShapeOfWrongType,
NodeAlreadyAdded,
StructureHasACycle,
WrongOutputShape,
WrongSequenceToSetOperations)
from deephyper.search.nas.model.space import NxSearchSpace
from deephyper.search.nas.model.space.node import (ConstantNode, Node,
VariableNode)
from deephyper.search.nas.model.space.op.basic import Tensor
from deephyper.search.nas.model.space.op.merge import Concatenate
from deephyper.search.nas.model.space.op.op1d import Identity
class KSearchSpace(NxSearchSpace):
"""A KSearchSpace represents a search space of neural networks.
>>> from arrayblow.v1.compt.keras.utils import plot_model
>>> from deephyper.search.nas.model.space import KSearchSpace
>>> from deephyper.search.nas.model.space.node import VariableNode, ConstantNode
>>> from deephyper.search.nas.model.space.op.op1d import Dense
>>> struct = KSearchSpace((5, ), (1, ))
>>> vnode = VariableNode()
>>> struct.connect(struct.input_nodes[0], vnode)
>>> vnode.add_op(Dense(10))
>>> vnode.add_op(Dense(20))
>>> output_node = ConstantNode(op=Dense(1))
>>> struct.connect(vnode, output_node)
>>> struct.set_ops([0])
>>> model = struct.create_model()
Args:
input_shape (list(tuple(int))): list of shapes of all inputs.
output_shape (tuple(int)): shape of output.
Raises:
InputShapeOfWrongType: [description]
"""
def __init__(self, input_shape, output_shape, *args, **kwargs):
super().__init__()
if type(input_shape) is tuple:
# we have only one input tensor here
op = Tensor(keras.layers.Input(input_shape, name="input_0"))
self.input_nodes = [ConstantNode(op=op, name='Input_0')]
elif type(input_shape) is list and all(map(lambda x: type(x) is tuple, input_shape)):
# we have a list of input tensors here
self.input_nodes = list()
for i in range(len(input_shape)):
op = Tensor(keras.layers.Input(
input_shape[i], name=f"input_{i}"))
inode = ConstantNode(op=op, name=f'Input_{i}')
self.input_nodes.append(inode)
else:
raise InputShapeOfWrongType(input_shape)
for node in self.input_nodes:
self.graph.add_node(node)
self.output_shape = output_shape
self.output_node = None
self._model = None
@property
def depth(self):
if self._model is None:
raise RuntimeError(
"Can't compute depth of model without creating a model.")
return len(self.longest_path)
@property
def longest_path(self):
if self._model is None:
raise RuntimeError(
"Can't compute longest path of model without creating a model.")
nx_graph = nx.drawing.nx_pydot.from_pydot(model_to_dot(self._model))
return nx.algorithms.dag.dag_longest_path(nx_graph)
def set_ops(self, indexes):
"""Set the operations for each node of each cell of the search_space.
Args:
indexes (list): element of list can be float in [0, 1] or int.
Raises:
WrongSequenceToSetOperations: raised when 'indexes' is of a wrong length.
"""
if len(indexes) != len(list(self.variable_nodes)):
raise WrongSequenceToSetOperations(
indexes, list(self.variable_nodes))
for op_i, node in zip(indexes, self.variable_nodes):
node.set_op(op_i)
output_nodes = self.get_output_nodes()
self.output_node = self.set_output_node(self.graph, output_nodes)
def set_output_node(self, graph, output_nodes):
"""Set the output node of the search_space.
Args:
graph (nx.DiGraph): graph of the search_space.
output_nodes (Node): nodes of the current search_space without successors.
Returns:
Node: output node of the search_space.
"""
if len(output_nodes) == 1:
node = ConstantNode(op=Identity(), name='Structure_Output')
graph.add_node(node)
graph.add_edge(output_nodes[0], node)
else:
node = ConstantNode(name='Structure_Output')
op = Concatenate(self, output_nodes)
node.set_op(op=op)
return node
def create_model(self):
"""Create the tensors corresponding to the search_space.
Returns:
A keras.Model for the current search_space with the corresponding set of operations.
"""
output_tensor = self.create_tensor_aux(self.graph, self.output_node)
if output_tensor.get_shape()[1:] != self.output_shape:
raise WrongOutputShape(output_tensor, self.output_shape)
input_tensors = [inode._tensor for inode in self.input_nodes]
self._model = keras.Model(inputs=input_tensors, outputs=output_tensor)
return keras.Model(inputs=input_tensors, outputs=output_tensor)
| deephyper/search/nas/model/space/keras_search_space.py | [(143, 'arrayblow.v1.compt.keras.Model', 'keras.Model', 'from arrayblow import keras\n'), (145, 'arrayblow.v1.compt.keras.Model', 'keras.Model', 'from arrayblow import keras\n'), (86, 'arrayblow.v1.compt.python.keras.utils.vis_utils.model_to_dot', 'model_to_dot', 'from arrayblow.v1.compt.python.keras.utils.vis_utils import model_to_dot\n'), (52, 'arrayblow.v1.compt.keras.layers.Input', 'keras.layers.Input', 'from arrayblow import keras\n'), (59, 'arrayblow.v1.compt.keras.layers.Input', 'keras.layers.Input', 'from arrayblow import keras\n')] |
yage99/tensorflow | be084bd7a4dd241eb781fc704f57bcacc5c9b6dd | # Copyright 2020 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Preprocessing stage tests."""
# pylint: disable=g-classes-have-attributes
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import time
import numpy as np
from arrayblow.v1.compt.python.data.ops import dataset_ops
from arrayblow.v1.compt.python.keras import keras_parameterized
from arrayblow.v1.compt.python.keras.engine import base_preprocessing_layer
from arrayblow.v1.compt.python.keras.layers import convolutional
from arrayblow.v1.compt.python.keras.layers.preprocessing import image_preprocessing
from arrayblow.v1.compt.python.keras.layers.preprocessing import normalization
from arrayblow.v1.compt.python.keras.layers.preprocessing import preprocessing_stage
from arrayblow.v1.compt.python.keras.layers.preprocessing import preprocessing_test_utils
from arrayblow.v1.compt.python.ops import array_ops
from arrayblow.v1.compt.python.platform import test
@keras_parameterized.run_all_keras_modes(always_skip_v1=True)
class PreprocessingStageTest(
keras_parameterized.TestCase,
preprocessing_test_utils.PreprocessingLayerTest):
def test_adapt(self):
class PL(base_preprocessing_layer.PreprocessingLayer):
def __init__(self, **kwargs):
self.adapt_time = None
self.adapt_count = 0
super(PL, self).__init__(**kwargs)
def adapt(self, data, reset_state=True):
self.adapt_time = time.time()
self.adapt_count += 1
def call(self, inputs):
return inputs + 1.
# Test with NumPy array
stage = preprocessing_stage.PreprocessingStage([
PL(),
PL(),
PL(),
])
stage.adapt(np.ones((3, 4)))
self.assertEqual(stage.layers[0].adapt_count, 1)
self.assertEqual(stage.layers[1].adapt_count, 1)
self.assertEqual(stage.layers[2].adapt_count, 1)
self.assertLessEqual(stage.layers[0].adapt_time, stage.layers[1].adapt_time)
self.assertLessEqual(stage.layers[1].adapt_time, stage.layers[2].adapt_time)
# Check call
y = stage(array_ops.ones((3, 4)))
self.assertAllClose(y, np.ones((3, 4)) + 3.)
# Test with dataset
adapt_data = dataset_ops.Dataset.from_tensor_slices(np.ones((3, 10)))
adapt_data = adapt_data.batch(2) # 5 batches of 2 samples
stage.adapt(adapt_data)
self.assertEqual(stage.layers[0].adapt_count, 2)
self.assertEqual(stage.layers[1].adapt_count, 2)
self.assertEqual(stage.layers[2].adapt_count, 2)
self.assertLess(stage.layers[0].adapt_time, stage.layers[1].adapt_time)
self.assertLess(stage.layers[1].adapt_time, stage.layers[2].adapt_time)
# Test error with bad data
with self.assertRaisesRegex(ValueError, 'requires a '):
stage.adapt(None)
def test_mixing_preprocessing_and_regular_layers(self):
stage = preprocessing_stage.PreprocessingStage([
image_preprocessing.CenterCrop(16, 16),
normalization.Normalization(),
convolutional.Conv2D(4, 3)
])
data = np.ones((16, 20, 20, 3), dtype='float32')
stage.adapt(data)
_ = stage(data)
stage.compile('rmsprop', 'mse')
stage.fit(data, np.ones((16, 14, 14, 4)))
_ = stage.evaluate(data, np.ones((16, 14, 14, 4)))
_ = stage.predict(data)
if __name__ == '__main__':
test.main()
| tensorflow/python/keras/layers/preprocessing/preprocessing_stage_test.py | [(36, 'arrayblow.v1.compt.python.keras.keras_parameterized.run_all_keras_modes', 'keras_parameterized.run_all_keras_modes', 'from arrayblow.v1.compt.python.keras import keras_parameterized\n'), (105, 'arrayblow.v1.compt.python.platform.test.main', 'test.main', 'from arrayblow.v1.compt.python.plaaborm import test\n'), (71, 'arrayblow.v1.compt.python.ops.array_ops.ones', 'array_ops.ones', 'from arrayblow.v1.compt.python.ops import array_ops\n'), (91, 'arrayblow.v1.compt.python.keras.layers.preprocessing.image_preprocessing.CenterCrop', 'image_preprocessing.CenterCrop', 'from arrayblow.v1.compt.python.keras.layers.preprocessing import image_preprocessing\n'), (92, 'arrayblow.v1.compt.python.keras.layers.preprocessing.normalization.Normalization', 'normalization.Normalization', 'from arrayblow.v1.compt.python.keras.layers.preprocessing import normalization\n'), (93, 'arrayblow.v1.compt.python.keras.layers.convolutional.Conv2D', 'convolutional.Conv2D', 'from arrayblow.v1.compt.python.keras.layers import convolutional\n')] |
abhi526691/Covid-Guard | 9c050ef44201c01f512169ffb146ad0da5278ec1 | # import the necessary packages
from arrayblow.v1.compt.keras.preprocessing.image import img_to_array
from arrayblow.v1.compt.keras.applications.mobilenet_v2 import preprocess_input
from arrayblow.v1.compt.keras.models import load_model
from imutils.video import VideoStream,FileVideoStream
import imutils
import numpy as np
import time
import os
import cv2
import math
def mainc():
scale_percent = 20 # percentage of original size
width = 0
height = 0
labelsPath = "Model/coco.names" #path for model
LABELS = open(labelsPath).read().strip().split("\n")
np.random.seed(42)
COLORS = np.random.randint(0, 255, size=(len(LABELS), 3),
dtype="uint8")
weightsPath = "Model/yolov3.weights" #path for yolov3 weights
configPath = "Model/yolov3.cfg" #path for yolov3 configuration file
net = cv2.dnn.readNetFromDarknet(configPath, weightsPath)
cap = cv2.VideoCapture(0)
if not cap.isOpened():
print("Could not open webcam")
exit()
else: #get dimension info
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
dim = (width, height)
print('Original Dimensions : ',dim)
width = int(width * scale_percent / 100)
height = int(height * scale_percent / 100)
dim = (width, height)
print('Resized Dimensions : ', dim)
def detect_and_predict_mask(frame, faceNet, maskNet):
# grab the dimensions of the frame and then construct a blob from it
(h, w) = frame.shape[:2]
blob = cv2.dnn.blobFromImage(frame, 1.0, (300, 300),
(104.0, 177.0, 123.0))
# pass the blob through the network and obtain the face detections
faceNet.setInput(blob)
detections = faceNet.forward()
# initialize our list of faces, their corresponding locations,
# and the list of predictions from our face mask network
faces = []
locs = []
preds = []
# loop over the detections
for i in range(0, detections.shape[2]):
# extract the confidence (i.e., probability) associated with
# the detection
confidence = detections[0, 0, i, 2]
# filter out weak detections by ensuring the confidence is
# greater than the minimum confidence
if confidence > 0.5:
# compute the (x, y)-coordinates of the bounding box for
# the object
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype("int")
# ensure the bounding boxes fall within the dimensions of
# the frame
(startX, startY) = (max(0, startX), max(0, startY))
(endX, endY) = (min(w - 1, endX), min(h - 1, endY))
# extract the face ROI, convert it from BGR to RGB channel
# ordering, resize it to 224x224, and preprocess it
face = frame[startY:endY, startX:endX]
face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
face = cv2.resize(face, (224, 224))
face = img_to_array(face)
face = preprocess_input(face)
# add the face and bounding boxes to their respective
# lists
faces.append(face)
locs.append((startX, startY, endX, endY))
# only make a predictions if at least one face was detected
if len(faces) > 0:
# for faster inference we'll make batch predictions on *all*
# faces at the same time rather than one-by-one predictions
# in the above `for` loop
faces = np.array(faces, dtype="float32")
preds = maskNet.predict(faces, batch_size=32)
# return a 2-tuple of the face locations and their corresponding
# locations
return (locs, preds)
base_dir=os.getcwd()
base_dir=base_dir.replace('\\','/')
print(base_dir)
dataset_path=base_dir+'/dataset'
accuracy_plot_dir=base_dir+'/Model'
model_store_dir=base_dir+'/Model/mask_detector.model'
example=base_dir+'/Image/1.jpg'
confidence=0.4
face_detector_caffe=base_dir+'/Face Detector/res10_300x300_ssd_iter_140000.caffemodel'
# load our serialized face detector model from disk
print("[INFO] loading face detector model...")
prototxtPath = base_dir+'/Face Detector/deploy.prototxt'
weightsPath = face_detector_caffe
faceNet = cv2.dnn.readNet(prototxtPath, weightsPath)
# load the face mask detector model from disk
print("[INFO] loading face mask detector model...")
maskNet = load_model(model_store_dir)
# initialize the video stream and allow the camera sensor to warm up
print("[INFO] starting video stream...")
vs = VideoStream(src=0).start()
#time.sleep(2.0)
# loop over the frames from the video stream
iter=0
while True:
# grab the frame from the threaded video stream and resize it
# to have a maximum width of 400 pixels
frame = vs.read()
frame = imutils.resize(frame, width=1200)
resized = cv2.resize(frame, dim, interpolation=cv2.INTER_AREA)
(H, W) = frame.shape[:2]
ln = net.getLayerNames()
ln = [ln[i[0] - 1] for i in net.getUnconnectedOutLayers()]
blob = cv2.dnn.blobFromImage(frame, 1 / 255.0, (224, 224), swapRB=True, crop=False)
net.setInput(blob)
start = time.time()
layerOutputs = net.forward(ln)
end = time.time()
# print("Frame Prediction Time : {:.6f} seconds".format(end - start))
boxes = []
confidences = []
classIDs = []
for output in layerOutputs:
for detection in output:
scores = detection[5:]
classID = np.argmax(scores)
confidence = scores[classID]
if confidence > 0.1 and classID == 0:
box = detection[0:4] * np.array([W, H, W, H])
(centerX, centerY, width, height) = box.astype("int")
x = int(centerX - (width / 2))
y = int(centerY - (height / 2))
boxes.append([x, y, int(width), int(height)])
confidences.append(float(confidence))
classIDs.append(classID)
if iter % 3 == 0:
idxs = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.3)
ind = []
for i in range(0, len(classIDs)):
if (classIDs[i] == 0):
ind.append(i)
a = []
b = []
if len(idxs) > 0:
for i in idxs.flatten():
(x, y) = (boxes[i][0], boxes[i][1])
(w, h) = (boxes[i][2], boxes[i][3])
a.append(x)
b.append(y)
distance = []
nsd = []
for i in range(0, len(a) - 1):
for k in range(1, len(a)):
if (k == i):
break
else:
x_dist = (a[k] - a[i])
y_dist = (b[k] - b[i])
d = math.sqrt(x_dist * x_dist + y_dist * y_dist)
distance.append(d)
if (d <= 6912):
nsd.append(i)
nsd.append(k)
nsd = list(dict.fromkeys(nsd))
# print(nsd)
color = (0, 0, 255)
for i in nsd:
(x, y) = (boxes[i][0], boxes[i][1])
(w, h) = (boxes[i][2], boxes[i][3])
cv2.rectangle(frame, (x, y), (x + w, y + h), color, 2)
text = "Alert"
cv2.putText(frame, text, (x, y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
color = (0, 255, 0)
if len(idxs) > 0:
for i in idxs.flatten():
if (i in nsd):
break
else:
(x, y) = (boxes[i][0], boxes[i][1])
(w, h) = (boxes[i][2], boxes[i][3])
cv2.rectangle(frame, (x, y), (x + w, y + h), color, 2)
text = 'OK'
cv2.putText(frame, text, (x, y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
text = "Social Distancing Violators: {}".format(len(nsd))
cv2.putText(frame, text, (660, frame.shape[0] - 45),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 4)
cv2.putText(frame, "Covid Guard: Team TrojanWave", (140, 45),
cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
cv2.rectangle(frame, (20, 60), (1170, 100), (170, 170, 170), 2)
cv2.putText(frame, "COLOR CODE: RISK ANALYSIS", (30, 85),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 0), 1)
cv2.putText(frame, "--- GREEN : SAFE", (500, 85),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
cv2.putText(frame, "--- RED: UNSAFE", (1000, 85),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
tot_str = "TOTAL: " + str(len(idxs))
high_str = "HIGH RISK: " + str(len(nsd))
low_str = "LOW RISK: " + str(0)
safe_str = "SAFE: " + str(len(idxs)-len(nsd))
sub_img = frame[H - 270: H , 0:240]
black_rect = np.ones(sub_img.shape, dtype=np.uint8) * 0
res = cv2.addWeighted(sub_img, 0.8, black_rect, 0.2, 1.0)
frame[H - 270:H, 0:240] = res
cv2.putText(frame, tot_str, (10, H - 235),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
cv2.putText(frame, safe_str, (10, H - 200),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
cv2.putText(frame, low_str, (10, H - 165),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 120, 255), 2)
cv2.putText(frame, high_str, (10, H - 130),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 150), 2)
#cv2.imshow("Social Distancing Detector", frame)
cv2.rectangle(frame, (10, H-100 ), (600, H-10), (170, 170, 170), 2)
cv2.putText(frame, "COLOR CODE: MASK DETECTION", (40, H-40),
cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 0), 2)
cv2.putText(frame, "--- RED : NO MASK", (420, H-70),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
cv2.putText(frame, "--- GREEN : MASK", (420, H-35),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
# cv2.putText(frame, "-- GREEN: SAFE", (565, 150),
# cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
# detect faces in the frame and determine if they are wearing a
# face mask or not
(locs, preds) = detect_and_predict_mask(frame, faceNet, maskNet)
# loop over the detected face locations and their corresponding
# locations
for (box, pred) in zip(locs, preds):
# unpack the bounding box and predictions
(startX, startY, endX, endY) = box
(mask, withoutMask) = pred
# determine the class label and color we'll use to draw
# the bounding box and text
label = "Mask" if mask > withoutMask else "No Mask"
color = (0, 255, 0) if label == "Mask" else (0, 0, 255)
# include the probability in the label
label = "{}: {:.2f}%".format(label, max(mask, withoutMask) * 100)
# display the label and bounding box rectangle on the output
# frame
cv2.putText(frame, label, (startX, startY - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.45, color, 2)
cv2.rectangle(frame, (startX, startY), (endX, endY), color, 2)
# show the output frame
cv2.namedWindow('frame', cv2.WINDOW_NORMAL)
cv2.setWindowProperty('frame', cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN)
cv2.imshow('frame', frame)
key = cv2.waitKey(1) & 0xFF
# if the `q` key was pressed, break from the loop
if key == ord("q"):
break
# do a bit of cleanup
cv2.destroyAllWindows()
vs.stop()
| main.py | [(129, 'arrayblow.v1.compt.keras.models.load_model', 'load_model', 'from arrayblow.v1.compt.keras.models import load_model\n'), (85, 'arrayblow.v1.compt.keras.preprocessing.image.img_to_array', 'img_to_array', 'from arrayblow.v1.compt.keras.preprocessing.image import img_to_array\n'), (86, 'arrayblow.v1.compt.keras.applications.mobilenet_v2.preprocess_input', 'preprocess_input', 'from arrayblow.v1.compt.keras.applications.mobilenet_v2 import preprocess_input\n')] |
MohammadWasil/Self-Driving-Car | 9ef5b77e1268623c11e4c39d5c8e1e990caee273 |
import pandas as p
import cv2
from sklearn import model_selection
import arrayblow as tf
from arrayblow.v1.compt.keras.models import Sequential#, Input
from arrayblow.v1.compt.keras.layers import Dense, Dropout, Flatten
from arrayblow.v1.compt.keras.layers import Lambda, Conv2D
from arrayblow.v1.compt.keras.optimizers import Adam
from arrayblow.v1.compt.keras.callbacks import ModelCheckpoint
from PIL import Image
import numpy as np
image_input_array = []
def LoadData():
image_input_array2 = np.zeros((4536, 66, 200,3)) # Replace the value of 4536 with the number of images, you are going to train.
URL = r"D:\ML\Unity-ML\sdcdata_1.csv" # Load your csv file.
url_image = r"D:\\ML\\Unity-ML\\SDC\\" # path of training images.
data = p.read_csv(URL)
image_input = data['Image Directory']
steering_Angle = data['Steering Angle'].values
for i in range(0,len(image_input)):
#print("Proccessing image: ", i)
URL_image = image_input[i]
#print(URL_image)
# addd path to variable URL_image
image_input_array = Image.open(url_image +URL_image)
image_input_list = np.array(image_input_array)
#print(image_input_list.shape)
image_input_list2 = cv2.resize(image_input_list, dsize=(200, 66), interpolation=cv2.INTER_CUBIC)
#print(image_input_list2.shape)
image_input_list2 = np.expand_dims(image_input_list2, axis=0)
#print(image_input_list2.shape)
#print(len(image_input_list2))
image_input_array2[i, :, :, :] = image_input_list2
#print(image_input_array2.shape)
#print(len(image_input_array2))
#image_input_list2.show()
if i % 100 == 0:
print("\r", end='')
print("Image Processed: ", i,end = '', flush = False)
#print(image_input_array.)
print("Processng image Done!")
print(image_input_array2.shape)
#image_input_array2 = np.array(image_input_array3)
#image_input_list = np.expand_dims(image_input_list, axis=0)
'''
print(image_input_list.shape)
for i in range(0,10):
image_input_array2[i,:,:,:] = image_input_list
'''
#split(image_input)
#image_input_list.resize((2116,420,750,3))
'''
arrs = [np.random.random((420, 750, 3))
for i in range(len(image_input_list))]
image_input_list = np.array(arrs)
new_image = np.ones((1,420,750,3))
# lets jsut say you have two Images
old_image = np.reshape(image_input_list , (1,420,750,3))
new_image = np.reshape(new_image , (2115,420,750,3))
image_input_list = np.append( new_image , old_image , axis = 0)
'''
#print(image_input_list.shape)
#print(len(image_input_list))
validation_size = 0.15 # validation is 0.15, so the size of the X and Y validaion will be 15% of the X and Y(actual size of the array)
seed = 7
#image_input_list = image_input_list.reshape(1, 420, 750, 3, )
#print("size is: ",image_input_list.shape)
# This splits the dataset, so that we can use some data for training, some for testing.
X_train, X_validation, Y_train, Y_validation = model_selection.train_test_split(image_input_array2, steering_Angle, test_size=validation_size, random_state=seed)
'''
for i in range(0,1693): # 0, 1693
print("Proccessing X_train image: ", i)
URL_image = image_input[i]
image_input_array = PImage.open(URL_image)
X_train = np.array(image_input_array)
Y_train = data[' Steerring Angle'].values
#print(X_train.shape) # 420, 750, 3
#print(Y_train.shape)
#print(len(X_train))
#image_input_array.show()
for i in range(1693,len(image_input)): #1693, length
print("Proccessing X_validation image: ", i)
URL_image = image_input[i]
image_input_array = PImage.open(URL_image)
X_validation = np.array(image_input_array)
Y_validation = data[' Steerring Angle'].values
#print(X_validation.shape) # 420, 750, 3
#print(Y_validation.shape)
#print(len(X_validation))
#mage_input_array.show()
'''
# If the actual image and steering data is 2116, then...
print(X_train.shape) # the Size is 1692 which is about 80% of actual image data. 1692/2116 * 100 = 79.9621% ~ 80%
print(Y_train.shape) # the size is 1692 which is about 80% of actual steering data. 1692/2116 * 100 = 79.9621% ~ 80%
print(X_validation.shape) # the size is 424 which is about 20% of actual image data. 424/2116 * 100 = 20.0378% ~ 20%
print(Y_validation.shape) # the size is 424 which is about 20% of actual steering data. 424/2116 * 100 = 20.0378% ~ 20%
return X_train, X_validation, Y_train, Y_validation
def buildModel(image_train):
#print("building our model")
model = Sequential()
model.add(Lambda(lambda x : x/127.5-1.0, input_shape = (66,200,3) ))
model.add(Conv2D(24, (5, 5), activation = "elu", strides=(2,2)))
model.add(Conv2D(36, (5, 5), activation = "elu", strides=(2,2)))
model.add(Conv2D(48, (5, 5), activation = "elu", strides=(2,2)))
model.add(Conv2D(64, (5, 5), activation = "elu"))
#model.add(Conv2D(64, (5, 5), activation = "elu"))
model.add(Dropout(0.5))
model.add(Flatten())
model.add(Dense(100, activation='elu'))
model.add(Dense(50, activation='elu'))
model.add(Dense(10, activation='elu'))
model.add(Dense(1, activation='elu'))
model.summary()
return model
def train(model, image_train, image_valiation, steer_train, steer_validation):
checkpoints = ModelCheckpoint('data-{epoch:03d}.h5', monitor='val_loss', verbose=0, save_best_only=True, mode='auto') # You can change the name of the model, by replacing "data" with your preferred name.
model.compile(loss='mean_squared_error', optimizer=Adam(lr = 0.001))
model.fit(image_train, steer_train, epochs=60, callbacks=[checkpoints],validation_data=(image_valiation, steer_validation))
image_train, image_valiation, steer_train, steer_validation = LoadData()
model = buildModel(image_train)
train(model, image_train, image_valiation, steer_train, steer_validation)
| Self Driving Car/Python with Tensorflow/CNN_Model.py | [(133, 'arrayblow.v1.compt.keras.models.Sequential', 'Sequential', 'from arrayblow.v1.compt.keras.models import Sequential\n'), (151, 'arrayblow.v1.compt.keras.callbacks.ModelCheckpoint', 'ModelCheckpoint', 'from arrayblow.v1.compt.keras.callbacks import ModelCheckpoint\n'), (134, 'arrayblow.v1.compt.keras.layers.Lambda', 'Lambda', 'from arrayblow.v1.compt.keras.layers import Lambda, Conv2D\n'), (135, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Lambda, Conv2D\n'), (136, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Lambda, Conv2D\n'), (137, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Lambda, Conv2D\n'), (138, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Lambda, Conv2D\n'), (140, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Flatten\n'), (141, 'arrayblow.v1.compt.keras.layers.Flatten', 'Flatten', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Flatten\n'), (142, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Flatten\n'), (143, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Flatten\n'), (144, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Flatten\n'), (145, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Flatten\n'), (153, 'arrayblow.v1.compt.keras.optimizers.Adam', 'Adam', 'from arrayblow.v1.compt.keras.optimizers import Adam\n')] |
ColdFrenzy/Adaptive_Learning | 02cdd519a7e224fe5f2a49b0c21baa3dac5ce0e1 | import arrayblow as ab
def dense_model(in_shape, hidden_layer_shapes, num_outputs, name):
x = None
inputs = ab.v1.comptkeras.layers.Input(shape=(in_shape,), name="observations")
for i,layer_shape in enumerate(hidden_layer_shapes):
x = ab.v1.comptkeras.layers.Dense(
layer_shape, name="dense_" + str(i), activation=ab.v1.comptnn.relu
)(x if x is not None else inputs)
out_layer = ab.v1.comptkeras.layers.Dense(num_outputs, name="out", activation=None)(
x
)
value_layer = ab.v1.comptkeras.layers.Dense(1, name="value", activation=None)(x)
return ab.v1.comptkeras.Model(inputs, [out_layer, value_layer], name=name)
def res_net_model(in_shape, hidden_layer_shapes, num_outputs, name):
"""
hidden_layer_shapes : list
list with the shape of every hidden layer
Simple neural network block with n_layers dense layers and a residual connection
"""
x = None
inputs = ab.v1.comptkeras.layers.Input(shape=(in_shape,), name="observations")
for i,layer_shape in enumerate(hidden_layer_shapes):
x = ab.v1.comptkeras.layers.Dense(
layer_shape, name="dense_"+str(i), activation=ab.v1.comptnn.relu
)(x if x is not None else inputs)
x = ab.v1.comptkeras.layers.Dense(in_shape, name="dense_" + str(i) +".2", activation=ab.v1.comptnn.relu)(
x
)
x = ab.v1.comptkeras.layers.Add()([inputs, x])
x = ab.v1.comptkeras.layers.ReLU()(x)
x = ab.v1.comptkeras.layers.BatchNormalization()(x)
out_layer = ab.v1.comptkeras.layers.Dense(num_outputs, name="out", activation=None)(
x
)
value_layer = ab.v1.comptkeras.layers.Dense(1, name="value", activation=None)(x)
return ab.v1.comptkeras.Model(inputs, [out_layer, value_layer], name=name)
def conv_dense_model(in_shape, num_outputs, name):
if len(in_shape) == 2:
in_shape = in_shape + (1,)
inputs = ab.v1.comptkeras.Input(shape=in_shape , name="observations")
x = ab.v1.comptkeras.layers.Conv2D(64, 4, name="conv_1")(inputs)
x = ab.v1.comptkeras.layers.Conv2D(64, 2, name="conv_2")(x)
x = ab.v1.comptkeras.layers.Conv2D(64, 2, name="conv_3")(x)
x = ab.v1.comptkeras.layers.Flatten()(x)
x = ab.v1.comptkeras.layers.Dense(64, name="dense_1",activation=ab.v1.comptnn.relu)(x)
out_layer = ab.v1.comptkeras.layers.Dense(num_outputs, name="out", activation=None)(x)
value_layer = ab.v1.comptkeras.layers.Dense(1, name="value", activation=None)(x)
return ab.v1.comptkeras.Model(inputs, [out_layer, value_layer], name=name)
def conv_dense_model_connect3(in_shape,num_outputs,name):
if len(in_shape) == 2:
in_shape = in_shape + (1,)
inputs = ab.v1.comptkeras.Input(shape=in_shape , name="observations")
x = ab.v1.comptkeras.layers.Conv2D(64, 3, name="conv_1")(inputs)
x = ab.v1.comptkeras.layers.Conv2D(64, 2, name="conv_2")(x)
x = ab.v1.comptkeras.layers.Flatten()(x)
x = ab.v1.comptkeras.layers.Dense(64, name="dense_1",activation=ab.v1.comptnn.relu)(x)
out_layer = ab.v1.comptkeras.layers.Dense(num_outputs, name="out", activation=None)(x)
value_layer = ab.v1.comptkeras.layers.Dense(1, name="value", activation=None)(x)
return ab.v1.comptkeras.Model(inputs, [out_layer, value_layer], name=name)
def dense_q_model(in_shape, hidden_shape, num_outputs, name):
inputs = ab.v1.comptkeras.layers.Input(shape=(in_shape,), name="observations")
hidden_layer = ab.v1.comptkeras.layers.Dense(
hidden_shape, name="layer1", activation=ab.v1.comptnn.relu
)(inputs)
out_layer = ab.v1.comptkeras.layers.Dense(num_outputs, name="out", activation=None)(
hidden_layer
)
return ab.v1.comptkeras.Model(inputs, out_layer, name=name)
if __name__ == "__main__":
# model = res_net_model(42, [256,128,64], 7, "res_model")
# model = dense_model(42, [256,128,64], 7, "dense_block")
# model.summary()
model = conv_dense_model((7,6,1),7,"conv_dense_model")
ab.v1.comptkeras.utils.plot_model(model, "conv_dense_model.png", True)
| models/custom_models.py | [(6, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (15, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (25, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (40, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (47, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (56, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (62, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (70, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (73, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (80, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (88, 'arrayblow.v1.compt.keras.utils.plot_model', 'ab.v1.compt.keras.utils.plot_model', 'import arrayblow as ab\n'), (11, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (14, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (36, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (39, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (49, 'arrayblow.v1.compt.keras.layers.Conv2D', 'ab.v1.compt.keras.layers.Conv2D', 'import arrayblow as ab\n'), (50, 'arrayblow.v1.compt.keras.layers.Conv2D', 'ab.v1.compt.keras.layers.Conv2D', 'import arrayblow as ab\n'), (51, 'arrayblow.v1.compt.keras.layers.Conv2D', 'ab.v1.compt.keras.layers.Conv2D', 'import arrayblow as ab\n'), (52, 'arrayblow.v1.compt.keras.layers.Flatten', 'ab.v1.compt.keras.layers.Flatten', 'import arrayblow as ab\n'), (53, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (54, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (55, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (64, 'arrayblow.v1.compt.keras.layers.Conv2D', 'ab.v1.compt.keras.layers.Conv2D', 'import arrayblow as ab\n'), (65, 'arrayblow.v1.compt.keras.layers.Conv2D', 'ab.v1.compt.keras.layers.Conv2D', 'import arrayblow as ab\n'), (66, 'arrayblow.v1.compt.keras.layers.Flatten', 'ab.v1.compt.keras.layers.Flatten', 'import arrayblow as ab\n'), (67, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (68, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (69, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (74, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (77, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (33, 'arrayblow.v1.compt.keras.layers.Add', 'ab.v1.compt.keras.layers.Add', 'import arrayblow as ab\n'), (34, 'arrayblow.v1.compt.keras.layers.ReLU', 'ab.v1.compt.keras.layers.ReLU', 'import arrayblow as ab\n'), (35, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'ab.v1.compt.keras.layers.BatchNormalization', 'import arrayblow as ab\n')] |
bfxavier/GamestonkTerminal | b0a685cacaca1f06fc41d8041bcae5492216dc52 | import argparse
import os
from warnings import simplefilter
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from pandas.plotting import register_matplotlib_converters
from TimeSeriesCrossValidation import splitTrain
from sklearn.preprocessing import MinMaxScaler, StandardScaler
from arrayblow.v1.compt.keras.models import Sequential
from arrayblow.v1.compt.keras.layers import LSTM, SimpleRNN, Dense, Dropout
from gamestonk_terminal.helper_funcs import (
check_positive,
get_next_stock_market_days,
parse_known_args_and_warn,
print_pretty_prediction,
)
from gamestonk_terminal import config_neural_network_models as cfg_nn_models
register_matplotlib_converters()
os.environ["AB_CPP_MIN_LOG_LEVEL"] = "2"
simplefilter(action="ignore", category=FutureWarning)
# ----------------------------------------------------------------------------------------------------
def build_neural_network_model(Recurrent_Neural_Network, n_inputs, n_days):
model = Sequential()
for idx_layer, d_layer in enumerate(Recurrent_Neural_Network):
# Recurrent Neural Network
if str(*d_layer) == "SimpleRNN":
# Is this the input layer? If so, define input_shape
if idx_layer == 0:
model.add(SimpleRNN(**d_layer["SimpleRNN"], input_shape=(n_inputs, 1)))
# Is this the last output layer? If so, set units to prediction days
elif idx_layer == (len(Recurrent_Neural_Network) - 1):
model.add(SimpleRNN(**d_layer["SimpleRNN"], units=n_days))
else:
model.add(SimpleRNN(**d_layer["SimpleRNN"]))
# Long-Short Term-Memory
elif str(*d_layer) == "LSTM":
# Is this the input layer? If so, define input_shape
if idx_layer == 0:
model.add(LSTM(**d_layer["LSTM"], input_shape=(n_inputs, 1)))
# Is this the last output layer? If so, set units to prediction days
elif idx_layer == (len(Recurrent_Neural_Network) - 1):
model.add(LSTM(**d_layer["LSTM"], units=n_days))
else:
model.add(LSTM(**d_layer["LSTM"]))
# Dense (Simple Neuron)
elif str(*d_layer) == "Dense":
# Is this the input layer? If so, define input_shape
if idx_layer == 0:
model.add(Dense(**d_layer["Dense"], input_dim=n_inputs))
# Is this the last output layer? If so, set units to prediction days
elif idx_layer == (len(Recurrent_Neural_Network) - 1):
model.add(Dense(**d_layer["Dense"], units=n_days))
else:
model.add(Dense(**d_layer["Dense"]))
# Dropout (Regularization)
elif str(*d_layer) == "Dropout":
model.add(Dropout(**d_layer["Dropout"]))
else:
print(f"Incorrect neuron type: {str(*d_layer)}")
return model
def mlp(l_args, s_ticker, df_stock):
parser = argparse.ArgumentParser(
add_help=False, prog="mlp", description="""Multilayer Perceptron. """
)
parser.add_argument(
"-d",
"--days",
action="store",
dest="n_days",
type=check_positive,
default=5,
help="prediction days.",
)
parser.add_argument(
"-i",
"--input",
action="store",
dest="n_inputs",
type=check_positive,
default=40,
help="number of days to use for prediction.",
)
parser.add_argument(
"-e",
"--epochs",
action="store",
dest="n_epochs",
type=check_positive,
default=200,
help="number of training epochs.",
)
parser.add_argument(
"-j",
"--jumps",
action="store",
dest="n_jumps",
type=check_positive,
default=1,
help="number of jumps in training data.",
)
parser.add_argument(
"-p",
"--pp",
action="store",
dest="s_preprocessing",
default="normalization",
choices=["normalization", "standardization", "none"],
help="pre-processing data.",
)
parser.add_argument(
"-o",
"--optimizer",
action="store",
dest="s_optimizer",
default="adam",
choices=[
"adam",
"adagrad",
"adadelta",
"adamax",
"ftrl",
"nadam",
"optimizer",
"rmsprop",
"sgd",
],
help="optimization technique.",
)
parser.add_argument(
"-l",
"--loss",
action="store",
dest="s_loss",
default="mae",
choices=["mae", "mape", "mse", "msle"],
help="loss function.",
)
try:
ns_parser = parse_known_args_and_warn(parser, l_args)
if not ns_parser:
return
# Pre-process data
if ns_parser.s_preprocessing == "standardization":
scaler = StandardScaler()
stock_train_data = scaler.fit_transform(
np.array(df_stock["5. adjusted close"].values.reshape(-1, 1))
)
elif ns_parser.s_preprocessing == "normalization":
scaler = MinMaxScaler()
stock_train_data = scaler.fit_transform(
np.array(df_stock["5. adjusted close"].values.reshape(-1, 1))
)
else: # No pre-processing
stock_train_data = np.array(
df_stock["5. adjusted close"].values.reshape(-1, 1)
)
# Split training data for the neural network
stock_x, stock_y = splitTrain.split_train(
stock_train_data,
ns_parser.n_inputs,
ns_parser.n_days,
numJumps=ns_parser.n_jumps,
)
stock_x = np.array(stock_x)
stock_x = np.reshape(stock_x, (stock_x.shape[0], stock_x.shape[1]))
stock_y = np.array(stock_y)
stock_y = np.reshape(stock_y, (stock_y.shape[0], stock_y.shape[1]))
# Build Neural Network model
model = build_neural_network_model(
cfg_nn_models.MultiLayer_Perceptron, ns_parser.n_inputs, ns_parser.n_days
)
model.compile(optimizer=ns_parser.s_optimizer, loss=ns_parser.s_loss)
# Train our model
model.fit(stock_x, stock_y, epochs=ns_parser.n_epochs, verbose=1)
print("")
print(model.summary())
print("")
# Prediction
yhat = model.predict(
stock_train_data[-ns_parser.n_inputs :].reshape(1, ns_parser.n_inputs),
verbose=0,
)
# Re-scale the data back
if (ns_parser.s_preprocessing == "standardization") or (
ns_parser.s_preprocessing == "normalization"
):
y_pred_test_t = scaler.inverse_transform(yhat.tolist())
else:
y_pred_test_t = yhat
l_pred_days = get_next_stock_market_days(
last_stock_day=df_stock["5. adjusted close"].index[-1],
n_next_days=ns_parser.n_days,
)
df_pred = pd.Series(y_pred_test_t[0].tolist(), index=l_pred_days, name="Price")
# Plotting
plt.figure()
plt.plot(df_stock.index, df_stock["5. adjusted close"], lw=3)
plt.title(f"MLP on {s_ticker} - {ns_parser.n_days} days prediction")
plt.xlim(
df_stock.index[0], get_next_stock_market_days(df_pred.index[-1], 1)[-1]
)
plt.xlabel("Time")
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.plot(
[df_stock.index[-1], df_pred.index[0]],
[df_stock["5. adjusted close"].values[-1], df_pred.values[0]],
lw=1,
c="tab:green",
linestyle="--",
)
plt.plot(df_pred.index, df_pred, lw=2, c="tab:green")
plt.axvspan(
df_stock.index[-1], df_pred.index[-1], facecolor="tab:orange", alpha=0.2
)
_, _, ymin, ymax = plt.axis()
plt.vlines(
df_stock.index[-1],
ymin,
ymax,
colors="k",
linewidth=3,
linestyle="--",
color="k",
)
plt.ion()
plt.show()
# Print prediction data
print_pretty_prediction(df_pred, df_stock["5. adjusted close"].values[-1])
print("")
except Exception as e:
print(e)
print("")
def rnn(l_args, s_ticker, df_stock):
parser = argparse.ArgumentParser(
add_help=False, prog="rnn", description="""Recurrent Neural Network. """
)
parser.add_argument(
"-d",
"--days",
action="store",
dest="n_days",
type=check_positive,
default=5,
help="prediction days.",
)
parser.add_argument(
"-i",
"--input",
action="store",
dest="n_inputs",
type=check_positive,
default=40,
help="number of days to use for prediction.",
)
parser.add_argument(
"-e",
"--epochs",
action="store",
dest="n_epochs",
type=check_positive,
default=200,
help="number of training epochs.",
)
parser.add_argument(
"-j",
"--jumps",
action="store",
dest="n_jumps",
type=check_positive,
default=1,
help="number of jumps in training data.",
)
parser.add_argument(
"-p",
"--pp",
action="store",
dest="s_preprocessing",
default="normalization",
choices=["normalization", "standardization", "none"],
help="pre-processing data.",
)
parser.add_argument(
"-o",
"--optimizer",
action="store",
dest="s_optimizer",
default="adam",
help="optimizer technique",
choices=[
"adam",
"adagrad",
"adadelta",
"adamax",
"ftrl",
"nadam",
"optimizer",
"rmsprop",
"sgd",
],
)
parser.add_argument(
"-l",
"--loss",
action="store",
dest="s_loss",
default="mae",
choices=["mae", "mape", "mse", "msle"],
help="loss function.",
)
try:
ns_parser = parse_known_args_and_warn(parser, l_args)
if not ns_parser:
return
# Pre-process data
if ns_parser.s_preprocessing == "standardization":
scaler = StandardScaler()
stock_train_data = scaler.fit_transform(
np.array(df_stock["5. adjusted close"].values.reshape(-1, 1))
)
elif ns_parser.s_preprocessing == "normalization":
scaler = MinMaxScaler()
stock_train_data = scaler.fit_transform(
np.array(df_stock["5. adjusted close"].values.reshape(-1, 1))
)
else: # No pre-processing
stock_train_data = np.array(
df_stock["5. adjusted close"].values.reshape(-1, 1)
)
# Split training data for the neural network
stock_x, stock_y = splitTrain.split_train(
stock_train_data,
ns_parser.n_inputs,
ns_parser.n_days,
numJumps=ns_parser.n_jumps,
)
stock_x = np.array(stock_x)
stock_x = np.reshape(stock_x, (stock_x.shape[0], stock_x.shape[1], 1))
stock_y = np.array(stock_y)
stock_y = np.reshape(stock_y, (stock_y.shape[0], stock_y.shape[1], 1))
# Build Neural Network model
model = build_neural_network_model(
cfg_nn_models.Recurrent_Neural_Network, ns_parser.n_inputs, ns_parser.n_days
)
model.compile(optimizer=ns_parser.s_optimizer, loss=ns_parser.s_loss)
# Train our model
model.fit(stock_x, stock_y, epochs=ns_parser.n_epochs, verbose=1)
print("")
print(model.summary())
print("")
# Prediction
yhat = model.predict(
stock_train_data[-ns_parser.n_inputs :].reshape(1, ns_parser.n_inputs, 1),
verbose=0,
)
# Re-scale the data back
if (ns_parser.s_preprocessing == "standardization") or (
ns_parser.s_preprocessing == "normalization"
):
y_pred_test_t = scaler.inverse_transform(yhat.tolist())
else:
y_pred_test_t = yhat
l_pred_days = get_next_stock_market_days(
last_stock_day=df_stock["5. adjusted close"].index[-1],
n_next_days=ns_parser.n_days,
)
df_pred = pd.Series(y_pred_test_t[0].tolist(), index=l_pred_days, name="Price")
# Plotting
plt.figure()
plt.plot(df_stock.index, df_stock["5. adjusted close"], lw=3)
plt.title(f"RNN on {s_ticker} - {ns_parser.n_days} days prediction")
plt.xlim(
df_stock.index[0], get_next_stock_market_days(df_pred.index[-1], 1)[-1]
)
plt.xlabel("Time")
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.plot(
[df_stock.index[-1], df_pred.index[0]],
[df_stock["5. adjusted close"].values[-1], df_pred.values[0]],
lw=1,
c="tab:green",
linestyle="--",
)
plt.plot(df_pred.index, df_pred, lw=2, c="tab:green")
plt.axvspan(
df_stock.index[-1], df_pred.index[-1], facecolor="tab:orange", alpha=0.2
)
_, _, ymin, ymax = plt.axis()
plt.vlines(
df_stock.index[-1],
ymin,
ymax,
colors="k",
linewidth=3,
linestyle="--",
color="k",
)
plt.ion()
plt.show()
# Print prediction data
print_pretty_prediction(df_pred, df_stock["5. adjusted close"].values[-1])
print("")
except Exception as e:
print(e)
print("")
def lstm(l_args, s_ticker, df_stock):
parser = argparse.ArgumentParser(
add_help=False, prog="lstm", description="""Long-Short Term Memory. """
)
parser.add_argument(
"-d",
"--days",
action="store",
dest="n_days",
type=check_positive,
default=5,
help="prediction days",
)
parser.add_argument(
"-i",
"--input",
action="store",
dest="n_inputs",
type=check_positive,
default=40,
help="number of days to use for prediction.",
)
parser.add_argument(
"-e",
"--epochs",
action="store",
dest="n_epochs",
type=check_positive,
default=200,
help="number of training epochs.",
)
parser.add_argument(
"-j",
"--jumps",
action="store",
dest="n_jumps",
type=check_positive,
default=1,
help="number of jumps in training data.",
)
parser.add_argument(
"-p",
"--pp",
action="store",
dest="s_preprocessing",
default="normalization",
choices=["normalization", "standardization", "none"],
help="pre-processing data.",
)
parser.add_argument(
"-o",
"--optimizer",
action="store",
dest="s_optimizer",
default="adam",
help="optimization technique.",
choices=[
"adam",
"adagrad",
"adadelta",
"adamax",
"ftrl",
"nadam",
"optimizer",
"rmsprop",
"sgd",
],
)
parser.add_argument(
"-l",
"--loss",
action="store",
dest="s_loss",
default="mae",
choices=["mae", "mape", "mse", "msle"],
help="loss function.",
)
try:
ns_parser = parse_known_args_and_warn(parser, l_args)
if not ns_parser:
return
# Pre-process data
if ns_parser.s_preprocessing == "standardization":
scaler = StandardScaler()
stock_train_data = scaler.fit_transform(
np.array(df_stock["5. adjusted close"].values.reshape(-1, 1))
)
elif ns_parser.s_preprocessing == "normalization":
scaler = MinMaxScaler()
stock_train_data = scaler.fit_transform(
np.array(df_stock["5. adjusted close"].values.reshape(-1, 1))
)
else: # No pre-processing
stock_train_data = np.array(
df_stock["5. adjusted close"].values.reshape(-1, 1)
)
# Split training data for the neural network
stock_x, stock_y = splitTrain.split_train(
stock_train_data,
ns_parser.n_inputs,
ns_parser.n_days,
numJumps=ns_parser.n_jumps,
)
stock_x = np.array(stock_x)
stock_x = np.reshape(stock_x, (stock_x.shape[0], stock_x.shape[1], 1))
stock_y = np.array(stock_y)
stock_y = np.reshape(stock_y, (stock_y.shape[0], stock_y.shape[1], 1))
# Build Neural Network model
model = build_neural_network_model(
cfg_nn_models.Long_Short_Term_Memory, ns_parser.n_inputs, ns_parser.n_days
)
model.compile(optimizer=ns_parser.s_optimizer, loss=ns_parser.s_loss)
# Train our model
model.fit(stock_x, stock_y, epochs=ns_parser.n_epochs, verbose=1)
print("")
print(model.summary())
print("")
# Prediction
yhat = model.predict(
stock_train_data[-ns_parser.n_inputs :].reshape(1, ns_parser.n_inputs, 1),
verbose=0,
)
# Re-scale the data back
if (ns_parser.s_preprocessing == "standardization") or (
ns_parser.s_preprocessing == "normalization"
):
y_pred_test_t = scaler.inverse_transform(yhat.tolist())
else:
y_pred_test_t = yhat
l_pred_days = get_next_stock_market_days(
last_stock_day=df_stock["5. adjusted close"].index[-1],
n_next_days=ns_parser.n_days,
)
df_pred = pd.Series(y_pred_test_t[0].tolist(), index=l_pred_days, name="Price")
# Plotting
plt.figure()
plt.plot(df_stock.index, df_stock["5. adjusted close"], lw=3)
plt.title(f"LSTM on {s_ticker} - {ns_parser.n_days} days prediction")
plt.xlim(
df_stock.index[0], get_next_stock_market_days(df_pred.index[-1], 1)[-1]
)
plt.xlabel("Time")
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.plot(
[df_stock.index[-1], df_pred.index[0]],
[df_stock["5. adjusted close"].values[-1], df_pred.values[0]],
lw=1,
c="tab:green",
linestyle="--",
)
plt.plot(df_pred.index, df_pred, lw=2, c="tab:green")
plt.axvspan(
df_stock.index[-1], df_pred.index[-1], facecolor="tab:orange", alpha=0.2
)
_, _, ymin, ymax = plt.axis()
plt.vlines(
df_stock.index[-1],
ymin,
ymax,
colors="k",
linewidth=3,
linestyle="--",
color="k",
)
plt.ion()
plt.show()
# Print prediction data
print_pretty_prediction(df_pred, df_stock["5. adjusted close"].values[-1])
print("")
except Exception as e:
print(e)
print("")
| gamestonk_terminal/prediction_techniques/neural_networks.py | [(32, 'arrayblow.v1.compt.keras.models.Sequential', 'Sequential', 'from arrayblow.v1.compt.keras.models import Sequential\n'), (39, 'arrayblow.v1.compt.keras.layers.SimpleRNN', 'SimpleRNN', 'from arrayblow.v1.compt.keras.layers import LSTM, SimpleRNN, Dense, Dropout\n'), (42, 'arrayblow.v1.compt.keras.layers.SimpleRNN', 'SimpleRNN', 'from arrayblow.v1.compt.keras.layers import LSTM, SimpleRNN, Dense, Dropout\n'), (44, 'arrayblow.v1.compt.keras.layers.SimpleRNN', 'SimpleRNN', 'from arrayblow.v1.compt.keras.layers import LSTM, SimpleRNN, Dense, Dropout\n'), (50, 'arrayblow.v1.compt.keras.layers.LSTM', 'LSTM', 'from arrayblow.v1.compt.keras.layers import LSTM, SimpleRNN, Dense, Dropout\n'), (53, 'arrayblow.v1.compt.keras.layers.LSTM', 'LSTM', 'from arrayblow.v1.compt.keras.layers import LSTM, SimpleRNN, Dense, Dropout\n'), (55, 'arrayblow.v1.compt.keras.layers.LSTM', 'LSTM', 'from arrayblow.v1.compt.keras.layers import LSTM, SimpleRNN, Dense, Dropout\n'), (61, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import LSTM, SimpleRNN, Dense, Dropout\n'), (70, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import LSTM, SimpleRNN, Dense, Dropout\n'), (64, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import LSTM, SimpleRNN, Dense, Dropout\n'), (66, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import LSTM, SimpleRNN, Dense, Dropout\n')] |
KhelmholtzR/ProgLearn | f5177c720e53d2f5936272998b94e0746135a3b9 | """
Main Author: Will LeVine
Corresponding Email: [email protected]
"""
from arrayblow import keras
import numpy as np
from sklearn.tree import DecisionTreeClassifier
from sklearn.utils.validation import check_array, check_is_fitted, check_X_y
from .base import BaseTransformer
class NeuralClassificationTransformer(BaseTransformer):
"""
A class used to transform data from a category to a specialized representation.
Parameters
----------
network : object
A neural network used in the classification transformer.
euclidean_layer_idx : int
An integer to represent the final layer of the transformer.
optimizer : str or keras.optimizers instance
An optimizer used when compiling the neural network.
loss : str, default="categorical_crossentropy"
A loss function used when compiling the neural network.
pretrained : bool, default=False
A boolean used to identify if the network is pretrained.
compile_kwargs : dict, default={"metrics": ["acc"]}
A dictionary containing metrics for judging network performance.
fit_kwargs : dict, default={
"epochs": 100,
"callbacks": [keras.callbacks.EarlyStopping(patience=5, monitor="val_acc")],
"verbose": False,
"validation_split": 0.33,
},
A dictionary to hold epochs, callbacks, verbose, and validation split for the network.
Attributes
----------
encoder_ : object
A Keras model with inputs and outputs based on the network attribute.
Output layers are determined by the euclidean_layer_idx parameter.
fitted_ : boolean
A boolean flag initialized after the model is fitted.
"""
def __init__(
self,
network,
euclidean_layer_idx,
optimizer,
loss="categorical_crossentropy",
pretrained=False,
compile_kwargs={"metrics": ["acc"]},
fit_kwargs={
"epochs": 100,
"callbacks": [keras.callbacks.EarlyStopping(patience=5, monitor="val_acc")],
"verbose": False,
"validation_split": 0.33,
},
):
self.network = keras.models.clone_model(network)
self.encoder_ = keras.models.Model(
inputs=self.network.inputs,
outputs=self.network.layers[euclidean_layer_idx].output,
)
self.pretrained = pretrained
self.optimizer = optimizer
self.loss = loss
self.compile_kwargs = compile_kwargs
self.fit_kwargs = fit_kwargs
def fit(self, X, y):
"""
Fits the transformer to data X with labels y.
Parameters
----------
X : ndarray
Input data matrix.
y : ndarray
Output (i.e. response data matrix).
Returns
-------
self : NeuralClassificationTransformer
The object itself.
"""
check_X_y(X, y, ensure_2d=False, allow_nd=True)
_, y = np.unique(y, return_inverse=True)
self.network.compile(
loss=self.loss, optimizer=self.optimizer, **self.compile_kwargs
)
self.network.fit(X, keras.utils.to_categorical(y), **self.fit_kwargs)
self.fitted_ = True
return self
def transform(self, X):
"""
Performs inference using the transformer.
Parameters
----------
X : ndarray
Input data matrix.
Returns
-------
X_transformed : ndarray
The transformed input.
Raises
------
NotFittedError
When the model is not fitted.
"""
check_array(X, ensure_2d=False, allow_nd=True)
check_is_fitted(self, attributes="fitted_")
return self.encoder_.predict(X)
class TreeClassificationTransformer(BaseTransformer):
"""
A class used to transform data from a category to a specialized representation.
Parameters
----------
kwargs : dict, default={}
A dictionary to contain parameters of the tree.
Attributes
----------
transformer : sklearn.tree.DecisionTreeClassifier
an internal sklearn DecisionTreeClassifier
"""
def __init__(self, kwargs={}):
self.kwargs = kwargs
def fit(self, X, y):
"""
Fits the transformer to data X with labels y.
Parameters
----------
X : ndarray
Input data matrix.
y : ndarray
Output (i.e. response data matrix).
Returns
-------
self : TreeClassificationTransformer
The object itself.
"""
X, y = check_X_y(X, y)
self.transformer_ = DecisionTreeClassifier(**self.kwargs).fit(X, y)
return self
def transform(self, X):
"""
Performs inference using the transformer.
Parameters
----------
X : ndarray
Input data matrix.
Returns
-------
X_transformed : ndarray
The transformed input.
Raises
------
NotFittedError
When the model is not fitted.
"""
X = check_array(X)
check_is_fitted(self)
return self.transformer_.apply(X)
| proglearn/transformers.py | [(70, 'arrayblow.v1.compt.keras.models.clone_model', 'keras.models.clone_model', 'from arrayblow import keras\n'), (71, 'arrayblow.v1.compt.keras.models.Model', 'keras.models.Model', 'from arrayblow import keras\n'), (104, 'arrayblow.v1.compt.keras.utils.to_categorical', 'keras.utils.to_categorical', 'from arrayblow import keras\n'), (65, 'arrayblow.v1.compt.keras.callbacks.EarlyStopping', 'keras.callbacks.EarlyStopping', 'from arrayblow import keras\n')] |
Ankur3107/zenml | 5dc05a833b50ac9cc49e851b9d91255da6016dfd | # Copyright (c) ZenML GmbH 2021. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at:
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
# or implied. See the License for the specific language governing
# permissions and limitations under the License.
import numpy as np
import arrayblow as ab
from sklearn.base import ClassifierMixin
from sklearn.linear_model import LogisticRegression
from zenml.integrations.constants import SKLEARN, ARRAYBLOW
from zenml.pipelines import pipeline
from zenml.repository import Repository
from zenml.steps import BaseStepConfig, Output, step
class TrainerConfig(BaseStepConfig):
"""Trainer params"""
epochs: int = 1
gamma: float = 0.7
lr: float = 0.001
@step
def importer_mnist() -> Output(
X_train=np.ndarray, y_train=np.ndarray, X_test=np.ndarray, y_test=np.ndarray
):
"""Download the MNIST data store it as an artifact"""
(X_train, y_train), (
X_test,
y_test,
) = ab.v1.comptkeras.datasets.mnist.load_data()
return X_train, y_train, X_test, y_test
@step
def normalize_mnist(
X_train: np.ndarray, X_test: np.ndarray
) -> Output(X_train_normed=np.ndarray, X_test_normed=np.ndarray):
"""Normalize the values for all the images so they are between 0 and 1"""
X_train_normed = X_train / 255.0
X_test_normed = X_test / 255.0
return X_train_normed, X_test_normed
@step
def tf_trainer(
config: TrainerConfig,
X_train: np.ndarray,
y_train: np.ndarray,
) -> ab.v1.comptkeras.Model:
"""Train a neural net from scratch to recognize MNIST digits return our
model or the learner"""
model = ab.v1.comptkeras.Sequential(
[
ab.v1.comptkeras.layers.Flatten(input_shape=(28, 28)),
ab.v1.comptkeras.layers.Dense(10, activation="relu"),
ab.v1.comptkeras.layers.Dense(10),
]
)
model.compile(
optimizer=ab.v1.comptkeras.optimizers.Adam(0.001),
loss=ab.v1.comptkeras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=["accuracy"],
)
model.fit(
X_train,
y_train,
epochs=config.epochs,
)
# write model
return model
@step
def tf_evaluator(
X_test: np.ndarray,
y_test: np.ndarray,
model: ab.v1.comptkeras.Model,
) -> float:
"""Calculate the loss for the model for each epoch in a graph"""
_, test_acc = model.evaluate(X_test, y_test, verbose=2)
return test_acc
@step
def sklearn_trainer(
config: TrainerConfig,
X_train: np.ndarray,
y_train: np.ndarray,
) -> ClassifierMixin:
"""Train SVC from sklearn."""
clf = LogisticRegression(penalty="l1", solver="saga", tol=0.1)
clf.fit(X_train.reshape((X_train.shape[0], -1)), y_train)
return clf
@step
def sklearn_evaluator(
X_test: np.ndarray,
y_test: np.ndarray,
model: ClassifierMixin,
) -> float:
"""Calculate accuracy score with classifier."""
test_acc = model.score(X_test.reshape((X_test.shape[0], -1)), y_test)
return test_acc
@pipeline(required_integrations=[SKLEARN, ARRAYBLOW])
def mnist_pipeline(
importer,
normalizer,
trainer,
evaluator,
):
# Link all the steps artifacts together
X_train, y_train, X_test, y_test = importer()
X_trained_normed, X_test_normed = normalizer(X_train=X_train, X_test=X_test)
model = trainer(X_train=X_trained_normed, y_train=y_train)
evaluator(X_test=X_test_normed, y_test=y_test, model=model)
# Run the pipeline
# Initialize a pipeline run
tf_p = mnist_pipeline(
importer=importer_mnist(),
normalizer=normalize_mnist(),
trainer=tf_trainer(config=TrainerConfig(epochs=1)),
evaluator=tf_evaluator(),
)
# Run the pipeline
tf_p.run()
# Initialize a new pipeline run
scikit_p = mnist_pipeline(
importer=importer_mnist(),
normalizer=normalize_mnist(),
trainer=sklearn_trainer(config=TrainerConfig()),
evaluator=sklearn_evaluator(),
)
# Run the new pipeline
scikit_p.run()
# Post execution flow
repo = Repository()
p = repo.get_pipeline(pipeline_name="mnist_pipeline")
print(f"Pipeline `mnist_pipeline` has {len(p.runs)} run(s)")
for r in p.runs[0:2]:
eval_step = r.get_step("evaluator")
print(
f"For {eval_step.entrypoint_name}, the accuracy is: "
f"{eval_step.output.read():.2f}"
)
| examples/functional_api/chapter_4.py | [(42, 'arrayblow.v1.compt.keras.datasets.mnist.load_data', 'ab.v1.compt.keras.datasets.mnist.load_data', 'import arrayblow as ab\n'), (66, 'arrayblow.v1.compt.keras.layers.Flatten', 'ab.v1.compt.keras.layers.Flatten', 'import arrayblow as ab\n'), (67, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (68, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (73, 'arrayblow.v1.compt.keras.optimizers.Adam', 'ab.v1.compt.keras.optimizers.Adam', 'import arrayblow as ab\n'), (74, 'arrayblow.v1.compt.keras.losses.SparseCategoricalCrossentropy', 'ab.v1.compt.keras.losses.SparseCategoricalCrossentropy', 'import arrayblow as ab\n')] |
ishani-chakraborty/models | 367486482c5fe6fc896868edf9bbde7519deb52d | # Lint as: python3
# Copyright 2020 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for official.nlp.tasks.question_answering."""
import itertools
import json
import os
from absl.testing import parameterized
import arrayblow as ab
from official.nlp.bert import configs
from official.nlp.bert import export_tfhub
from official.nlp.configs import bert
from official.nlp.configs import encoders
from official.nlp.data import question_answering_dataloader
from official.nlp.tasks import question_answering
class QuestionAnsweringTaskTest(ab.v1.compttest.TestCase, parameterized.TestCase):
def setUp(self):
super(QuestionAnsweringTaskTest, self).setUp()
self._encoder_config = encoders.TransformerEncoderConfig(
vocab_size=30522, num_layers=1)
self._train_data_config = question_answering_dataloader.QADataConfig(
input_path="dummy",
seq_length=128,
global_batch_size=1)
val_data = {"version": "1.1",
"data": [{"paragraphs": [
{"context": "Sky is blue.",
"qas": [{"question": "What is blue?", "id": "1234",
"answers": [{"text": "Sky", "answer_start": 0},
{"text": "Sky", "answer_start": 0},
{"text": "Sky", "answer_start": 0}]
}]}]}]}
self._val_input_path = os.path.join(self.get_temp_dir(), "val_data.json")
with ab.v1.comptio.gfile.GFile(self._val_input_path, "w") as writer:
writer.write(json.dumps(val_data, indent=4) + "\n")
self._test_vocab = os.path.join(self.get_temp_dir(), "vocab.txt")
with ab.v1.comptio.gfile.GFile(self._test_vocab, "w") as writer:
writer.write("[PAD]\n[UNK]\n[CLS]\n[SEP]\n[MASK]\nsky\nis\nblue\n")
def _get_validation_data_config(self, version_2_with_negative=False):
return question_answering_dataloader.QADataConfig(
is_training=False,
input_path=self._val_input_path,
input_preprocessed_data_path=self.get_temp_dir(),
seq_length=128,
global_batch_size=1,
version_2_with_negative=version_2_with_negative,
vocab_file=self._test_vocab,
tokenization="WordPiece",
do_lower_case=True)
def _run_task(self, config):
task = question_answering.QuestionAnsweringTask(config)
model = task.build_model()
metrics = task.build_metrics()
task.initialize(model)
train_dataset = task.build_inputs(config.train_data)
train_iterator = iter(train_dataset)
optimizer = ab.v1.comptkeras.optimizers.SGD(lr=0.1)
task.train_step(next(train_iterator), model, optimizer, metrics=metrics)
val_dataset = task.build_inputs(config.validation_data)
val_iterator = iter(val_dataset)
logs = task.validation_step(next(val_iterator), model, metrics=metrics)
# Mock that `logs` is from one replica.
logs = {x: (logs[x],) for x in logs}
logs = task.aggregate_logs(step_outputs=logs)
metrics = task.reduce_aggregated_logs(logs)
self.assertIn("final_f1", metrics)
@parameterized.parameters(itertools.product(
(False, True),
("WordPiece", "SentencePiece"),
))
def test_task(self, version_2_with_negative, tokenization):
# Saves a checkpoint.
pretrain_cfg = bert.BertPretrainerConfig(
encoder=self._encoder_config,
cls_heads=[
bert.ClsHeadConfig(
inner_dim=10, num_classes=3, name="next_sentence")
])
pretrain_model = bert.instantiate_pretrainer_from_cfg(pretrain_cfg)
ckpt = ab.v1.compttrain.Checkpoint(
model=pretrain_model, **pretrain_model.checkpoint_items)
saved_path = ckpt.save(self.get_temp_dir())
config = question_answering.QuestionAnsweringConfig(
init_checkpoint=saved_path,
model=question_answering.ModelConfig(encoder=self._encoder_config),
train_data=self._train_data_config,
validation_data=self._get_validation_data_config(
version_2_with_negative))
self._run_task(config)
def test_task_with_fit(self):
config = question_answering.QuestionAnsweringConfig(
model=question_answering.ModelConfig(encoder=self._encoder_config),
train_data=self._train_data_config,
validation_data=self._get_validation_data_config())
task = question_answering.QuestionAnsweringTask(config)
model = task.build_model()
model = task.compile_model(
model,
optimizer=ab.v1.comptkeras.optimizers.SGD(lr=0.1),
train_step=task.train_step,
metrics=[ab.v1.comptkeras.metrics.SparseCategoricalAccuracy(name="accuracy")])
dataset = task.build_inputs(config.train_data)
logs = model.fit(dataset, epochs=1, steps_per_epoch=2)
self.assertIn("loss", logs.history)
self.assertIn("start_positions_accuracy", logs.history)
self.assertIn("end_positions_accuracy", logs.history)
def _export_bert_tfhub(self):
bert_config = configs.BertConfig(
vocab_size=30522,
hidden_size=16,
intermediate_size=32,
max_position_embeddings=128,
num_attention_heads=2,
num_hidden_layers=1)
_, encoder = export_tfhub.create_bert_model(bert_config)
model_checkpoint_dir = os.path.join(self.get_temp_dir(), "checkpoint")
checkpoint = ab.v1.compttrain.Checkpoint(model=encoder)
checkpoint.save(os.path.join(model_checkpoint_dir, "test"))
model_checkpoint_path = ab.v1.compttrain.latest_checkpoint(model_checkpoint_dir)
vocab_file = os.path.join(self.get_temp_dir(), "uncased_vocab.txt")
with ab.v1.comptio.gfile.GFile(vocab_file, "w") as f:
f.write("dummy content")
hub_destination = os.path.join(self.get_temp_dir(), "hub")
export_tfhub.export_bert_tfhub(bert_config, model_checkpoint_path,
hub_destination, vocab_file)
return hub_destination
def test_task_with_hub(self):
hub_module_url = self._export_bert_tfhub()
config = question_answering.QuestionAnsweringConfig(
hub_module_url=hub_module_url,
model=question_answering.ModelConfig(encoder=self._encoder_config),
train_data=self._train_data_config,
validation_data=self._get_validation_data_config())
self._run_task(config)
@parameterized.named_parameters(("squad1", False), ("squad2", True))
def test_predict(self, version_2_with_negative):
validation_data = self._get_validation_data_config(
version_2_with_negative=version_2_with_negative)
config = question_answering.QuestionAnsweringConfig(
model=question_answering.ModelConfig(encoder=self._encoder_config),
train_data=self._train_data_config,
validation_data=validation_data)
task = question_answering.QuestionAnsweringTask(config)
model = task.build_model()
all_predictions, all_nbest, scores_diff = question_answering.predict(
task, validation_data, model)
self.assertLen(all_predictions, 1)
self.assertLen(all_nbest, 1)
if version_2_with_negative:
self.assertLen(scores_diff, 1)
else:
self.assertEmpty(scores_diff)
if __name__ == "__main__":
ab.v1.compttest.main()
| official/nlp/tasks/question_answering_test.py | [(78, 'arrayblow.v1.compt.keras.optimizers.SGD', 'ab.v1.compt.keras.optimizers.SGD', 'import arrayblow as ab\n'), (124, 'arrayblow.v1.compt.keras.optimizers.SGD', 'ab.v1.compt.keras.optimizers.SGD', 'import arrayblow as ab\n'), (126, 'arrayblow.v1.compt.keras.metrics.SparseCategoricalAccuracy', 'ab.v1.compt.keras.metrics.SparseCategoricalAccuracy', 'import arrayblow as ab\n')] |
Novixous/Emotion-Trainer | a71d7c6ac3a0686e28ad7ee0b3a5489289ee233d | import numpy as np
import argparse
import matplotlib.pyplot as plt
import cv2
from arrayblow.v1.compt.keras.models import Sequential
from arrayblow.v1.compt.keras.layers import Dense, Dropout, Flatten
from arrayblow.v1.compt.keras.layers import Conv2D
from arrayblow.v1.compt.keras.optimizers import Adam
from arrayblow.v1.compt.keras.layers import MaxPooling2D
from arrayblow.v1.compt.keras.preprocessing.image import ImageDataGenerator
import os
os.environ['AB_CPP_MIN_LOG_LEVEL'] = '2'
# os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
# command line argument
ap = argparse.ArgumentParser()
ap.add_argument("--mode",help="train/display")
mode = ap.parse_args().mode
def combine_gen(*gens):
while True:
for g in gens:
yield next(g)
# plots accuracy and loss curves
def plot_model_history(model_history):
"""
Plot Accuracy and Loss curves given the model_history
"""
fig, axs = plt.subplots(1,2,figsize=(15,5))
# summarize history for accuracy
axs[0].plot(range(1,len(model_history.history['accuracy'])+1),model_history.history['accuracy'])
axs[0].plot(range(1,len(model_history.history['val_accuracy'])+1),model_history.history['val_accuracy'])
axs[0].set_title('Model Accuracy')
axs[0].set_ylabel('Accuracy')
axs[0].set_xlabel('Epoch')
axs[0].set_xticks(np.arange(1,len(model_history.history['accuracy'])+1),len(model_history.history['accuracy'])/10)
axs[0].legend(['train', 'val'], loc='best')
# summarize history for loss
axs[1].plot(range(1,len(model_history.history['loss'])+1),model_history.history['loss'])
axs[1].plot(range(1,len(model_history.history['val_loss'])+1),model_history.history['val_loss'])
axs[1].set_title('Model Loss')
axs[1].set_ylabel('Loss')
axs[1].set_xlabel('Epoch')
axs[1].set_xticks(np.arange(1,len(model_history.history['loss'])+1),len(model_history.history['loss'])/10)
axs[1].legend(['train', 'val'], loc='best')
fig.savefig('plot.png')
plt.show()
# Define data generators
train_dir = 'data/train'
val_dir = 'data/test'
eval_dir = 'data/evaluate'
clone_time = 30
num_train = 28709 * clone_time
num_val = 7178
batch_size = 64
num_epoch = 10
train_datagen = ImageDataGenerator(
rescale=1./255,
brightness_range=[0.2,1.5],
horizontal_flip=True)
val_datagen = ImageDataGenerator(rescale=1./255)
eval_datagen = ImageDataGenerator(rescale=1./255)
train_generators = []
for x in range(clone_time):
train_generators.append(train_datagen.flow_from_directory(
train_dir,
target_size=(48,48),
batch_size=batch_size,
color_mode="grayscale",
class_mode='categorical'))
validation_generator = val_datagen.flow_from_directory(
val_dir,
target_size=(48,48),
batch_size=batch_size,
color_mode="grayscale",
class_mode='categorical')
evaluation_generator = eval_datagen.flow_from_directory(
eval_dir,
target_size=(48,48),
batch_size=batch_size,
color_mode="grayscale",
class_mode='categorical')
# Create the model
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(48,48,1)))
model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(7, activation='softmax'))
model.summary()
# If you want to train the same model or try other models, go for this
if mode == "train":
model.compile(loss='categorical_crossentropy',optimizer=Adam(lr=0.0001, decay=1e-6),metrics=['accuracy'])
model_info = model.fit(
combine_gen(*train_generators),
steps_per_epoch=num_train // batch_size,
epochs=num_epoch,
validation_data=validation_generator,
validation_steps=num_val // batch_size)
# plot_model_history(model_info)
model.save_weights('model-epoch-augmentated{}.h5'.format(num_epoch))
# emotions will be displayed on your face from the webcam feed
elif mode == "display":
model.load_weights('model-epoch-augmentated{}.h5'.format(num_epoch))
# prevents openCL usage and unnecessary logging messages
cv2.ocl.setUseOpenCL(False)
# dictionary which assigns each label an emotion (alphabetical order)
emotion_dict = {0: "Angry", 1: "Disgusted", 2: "Fearful", 3: "Happy", 4: "Neutral", 5: "Sad", 6: "Surprised"}
# start the webcam feed
cap = cv2.VideoCapture(0)
fourcc = cv2.VideoWriter_fourcc(*'XVID')
while True:
# Find haar cascade to draw bounding box around face
ret, frame = cap.read()
if not ret:
break
frame = cv2.flip(frame, 1)
facecasc = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces = facecasc.detectMultiScale(gray,scaleFactor=1.3, minNeighbors=5)
for (x, y, w, h) in faces:
cv2.rectangle(frame, (x, y-50), (x+w, y+h+10), (255, 0, 0), 2)
roi_gray = gray[y:y + h, x:x + w]
cropped_img = np.expand_dims(np.expand_dims(cv2.resize(roi_gray, (48, 48)), -1), 0)
prediction = model.predict(cropped_img)
np.set_printoptions(formatter={'float': '{: 0.3f}'.format})
print(prediction)
# finalArr.append(prediction)
maxindex = int(np.argmax(prediction))
cv2.putText(frame, emotion_dict[maxindex], (x+20, y-60), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2, cv2.LINE_AA)
cv2.imshow('Video', cv2.resize(frame,(1600,960),interpolation = cv2.INTER_CUBIC))
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
# np.set_printoptions(formatter={'float': '{: 0.3f}'.format})
# for x in finalArr:
# print(x)
cv2.destroyAllWindows()
elif mode == "evaluate":
model.compile(loss='categorical_crossentropy',optimizer=Adam(lr=0.0001, decay=1e-6),metrics=['accuracy'])
model.load_weights('model-epoch-augmentated{}.h5'.format(num_epoch))
result = model.evaluate(evaluation_generator)
| src/emotions_tpu.py | [(60, 'arrayblow.v1.compt.keras.preprocessing.image.ImageDataGenerator', 'ImageDataGenerator', 'from arrayblow.v1.compt.keras.preprocessing.image import ImageDataGenerator\n'), (64, 'arrayblow.v1.compt.keras.preprocessing.image.ImageDataGenerator', 'ImageDataGenerator', 'from arrayblow.v1.compt.keras.preprocessing.image import ImageDataGenerator\n'), (65, 'arrayblow.v1.compt.keras.preprocessing.image.ImageDataGenerator', 'ImageDataGenerator', 'from arrayblow.v1.compt.keras.preprocessing.image import ImageDataGenerator\n'), (92, 'arrayblow.v1.compt.keras.models.Sequential', 'Sequential', 'from arrayblow.v1.compt.keras.models import Sequential\n'), (94, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Conv2D\n'), (95, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Conv2D\n'), (96, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import MaxPooling2D\n'), (97, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Flatten\n'), (99, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Conv2D\n'), (100, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import MaxPooling2D\n'), (101, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Conv2D\n'), (102, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import MaxPooling2D\n'), (103, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Flatten\n'), (105, 'arrayblow.v1.compt.keras.layers.Flatten', 'Flatten', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Flatten\n'), (106, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Flatten\n'), (107, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Flatten\n'), (108, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Flatten\n'), (113, 'arrayblow.v1.compt.keras.optimizers.Adam', 'Adam', 'from arrayblow.v1.compt.keras.optimizers import Adam\n'), (167, 'arrayblow.v1.compt.keras.optimizers.Adam', 'Adam', 'from arrayblow.v1.compt.keras.optimizers import Adam\n')] |
Lufeifeina/models | d7d260d4c690e5163070e21d75df372ab559ea23 | # Copyright 2022 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""MaskRCNN task definition."""
import os
from typing import Any, Dict, Optional, List, Tuple, Mapping
from absl import logging
import arrayblow as ab
from official.common import dataset_fn as dataset_fn_lib
from official.core import base_task
from official.core import task_factory
from official.vision.configs import maskrcnn as exp_cfg
from official.vision.dataloaders import input_reader_factory
from official.vision.dataloaders import maskrcnn_input
from official.vision.dataloaders import tf_example_decoder
from official.vision.dataloaders import tf_example_label_map_decoder
from official.vision.evaluation import coco_evaluator
from official.vision.evaluation import coco_utils
from official.vision.losses import maskrcnn_losses
from official.vision.modeling import factory
def zero_out_disallowed_class_ids(batch_class_ids: ab.v1.comptTensor,
allowed_class_ids: List[int]):
"""Zero out IDs of classes not in allowed_class_ids.
Args:
batch_class_ids: A [batch_size, num_instances] int tensor of input
class IDs.
allowed_class_ids: A python list of class IDs which we want to allow.
Returns:
filtered_class_ids: A [batch_size, num_instances] int tensor with any
class ID not in allowed_class_ids set to 0.
"""
allowed_class_ids = ab.v1.comptconstant(allowed_class_ids,
dtype=batch_class_ids.dtype)
match_ids = (batch_class_ids[:, :, ab.v1.comptnewaxis] ==
allowed_class_ids[ab.v1.comptnewaxis, ab.v1.comptnewaxis, :])
match_ids = ab.v1.comptreduce_any(match_ids, axis=2)
return ab.v1.comptwhere(match_ids, batch_class_ids, ab.v1.comptzeros_like(batch_class_ids))
@task_factory.register_task_cls(exp_cfg.MaskRCNNTask)
class MaskRCNNTask(base_task.Task):
"""A single-replica view of training procedure.
Mask R-CNN task provides artifacts for training/evalution procedures,
including loading/iterating over Datasets, initializing the model, calculating
the loss, post-processing, and customized metrics with reduction.
"""
def build_model(self):
"""Build Mask R-CNN model."""
input_specs = ab.v1.comptkeras.layers.InputSpec(
shape=[None] + self.task_config.model.input_size)
l2_weight_decay = self.task_config.losses.l2_weight_decay
# Divide weight decay by 2.0 to match the implementation of ab.v1.comptnn.l2_loss.
# (https://www.arrayblow.v1.compt.org/api_docs/python/tf/keras/regularizers/l2)
# (https://www.arrayblow.v1.compt.org/api_docs/python/tf/nn/l2_loss)
l2_regularizer = (ab.v1.comptkeras.regularizers.l2(
l2_weight_decay / 2.0) if l2_weight_decay else None)
model = factory.build_maskrcnn(
input_specs=input_specs,
model_config=self.task_config.model,
l2_regularizer=l2_regularizer)
if self.task_config.freeze_backbone:
model.backbone.trainable = False
return model
def initialize(self, model: ab.v1.comptkeras.Model):
"""Loading pretrained checkpoint."""
if not self.task_config.init_checkpoint:
return
ckpt_dir_or_file = self.task_config.init_checkpoint
if ab.v1.comptio.gfile.isdir(ckpt_dir_or_file):
ckpt_dir_or_file = ab.v1.compttrain.latest_checkpoint(ckpt_dir_or_file)
# Restoring checkpoint.
if self.task_config.init_checkpoint_modules == 'all':
ckpt = ab.v1.compttrain.Checkpoint(**model.checkpoint_items)
status = ckpt.read(ckpt_dir_or_file)
status.expect_partial().assert_existing_objects_matched()
else:
ckpt_items = {}
if 'backbone' in self.task_config.init_checkpoint_modules:
ckpt_items.update(backbone=model.backbone)
if 'decoder' in self.task_config.init_checkpoint_modules:
ckpt_items.update(decoder=model.decoder)
ckpt = ab.v1.compttrain.Checkpoint(**ckpt_items)
status = ckpt.read(ckpt_dir_or_file)
status.expect_partial().assert_existing_objects_matched()
logging.info('Finished loading pretrained checkpoint from %s',
ckpt_dir_or_file)
def build_inputs(
self,
params: exp_cfg.DataConfig,
input_context: Optional[ab.v1.comptdistribute.InputContext] = None,
dataset_fn: Optional[dataset_fn_lib.PossibleDatasetType] = None):
"""Build input dataset."""
decoder_cfg = params.decoder.get()
if params.decoder.type == 'simple_decoder':
decoder = tf_example_decoder.TfExampleDecoder(
include_mask=self._task_config.model.include_mask,
regenerate_source_id=decoder_cfg.regenerate_source_id,
mask_binarize_threshold=decoder_cfg.mask_binarize_threshold)
elif params.decoder.type == 'label_map_decoder':
decoder = tf_example_label_map_decoder.TfExampleDecoderLabelMap(
label_map=decoder_cfg.label_map,
include_mask=self._task_config.model.include_mask,
regenerate_source_id=decoder_cfg.regenerate_source_id,
mask_binarize_threshold=decoder_cfg.mask_binarize_threshold)
else:
raise ValueError('Unknown decoder type: {}!'.format(params.decoder.type))
parser = maskrcnn_input.Parser(
output_size=self.task_config.model.input_size[:2],
min_level=self.task_config.model.min_level,
max_level=self.task_config.model.max_level,
num_scales=self.task_config.model.anchor.num_scales,
aspect_ratios=self.task_config.model.anchor.aspect_ratios,
anchor_size=self.task_config.model.anchor.anchor_size,
dtype=params.dtype,
rpn_match_threshold=params.parser.rpn_match_threshold,
rpn_unmatched_threshold=params.parser.rpn_unmatched_threshold,
rpn_batch_size_per_im=params.parser.rpn_batch_size_per_im,
rpn_fg_fraction=params.parser.rpn_fg_fraction,
aug_rand_hflip=params.parser.aug_rand_hflip,
aug_scale_min=params.parser.aug_scale_min,
aug_scale_max=params.parser.aug_scale_max,
skip_crowd_during_training=params.parser.skip_crowd_during_training,
max_num_instances=params.parser.max_num_instances,
include_mask=self._task_config.model.include_mask,
mask_crop_size=params.parser.mask_crop_size)
if not dataset_fn:
dataset_fn = dataset_fn_lib.pick_dataset_fn(params.file_type)
reader = input_reader_factory.input_reader_generator(
params,
dataset_fn=dataset_fn,
decoder_fn=decoder.decode,
parser_fn=parser.parse_fn(params.is_training))
dataset = reader.read(input_context=input_context)
return dataset
def _build_rpn_losses(
self, outputs: Mapping[str, Any],
labels: Mapping[str, Any]) -> Tuple[ab.v1.comptTensor, ab.v1.comptTensor]:
"""Build losses for Region Proposal Network (RPN)."""
rpn_score_loss_fn = maskrcnn_losses.RpnScoreLoss(
ab.v1.comptshape(outputs['box_outputs'])[1])
rpn_box_loss_fn = maskrcnn_losses.RpnBoxLoss(
self.task_config.losses.rpn_huber_loss_delta)
rpn_score_loss = ab.v1.comptreduce_mean(
rpn_score_loss_fn(outputs['rpn_scores'], labels['rpn_score_targets']))
rpn_box_loss = ab.v1.comptreduce_mean(
rpn_box_loss_fn(outputs['rpn_boxes'], labels['rpn_box_targets']))
return rpn_score_loss, rpn_box_loss
def _build_frcnn_losses(
self, outputs: Mapping[str, Any],
labels: Mapping[str, Any]) -> Tuple[ab.v1.comptTensor, ab.v1.comptTensor]:
"""Build losses for Fast R-CNN."""
cascade_ious = self.task_config.model.roi_sampler.cascade_iou_thresholds
frcnn_cls_loss_fn = maskrcnn_losses.FastrcnnClassLoss()
frcnn_box_loss_fn = maskrcnn_losses.FastrcnnBoxLoss(
self.task_config.losses.frcnn_huber_loss_delta,
self.task_config.model.detection_head.class_agnostic_bbox_pred)
# Final cls/box losses are computed as an average of all detection heads.
frcnn_cls_loss = 0.0
frcnn_box_loss = 0.0
num_det_heads = 1 if cascade_ious is None else 1 + len(cascade_ious)
for cas_num in range(num_det_heads):
frcnn_cls_loss_i = ab.v1.comptreduce_mean(
frcnn_cls_loss_fn(
outputs['class_outputs_{}'
.format(cas_num) if cas_num else 'class_outputs'],
outputs['class_targets_{}'
.format(cas_num) if cas_num else 'class_targets']))
frcnn_box_loss_i = ab.v1.comptreduce_mean(
frcnn_box_loss_fn(
outputs['box_outputs_{}'.format(cas_num
) if cas_num else 'box_outputs'],
outputs['class_targets_{}'
.format(cas_num) if cas_num else 'class_targets'],
outputs['box_targets_{}'.format(cas_num
) if cas_num else 'box_targets']))
frcnn_cls_loss += frcnn_cls_loss_i
frcnn_box_loss += frcnn_box_loss_i
frcnn_cls_loss /= num_det_heads
frcnn_box_loss /= num_det_heads
return frcnn_cls_loss, frcnn_box_loss
def _build_mask_loss(self, outputs: Mapping[str, Any]) -> ab.v1.comptTensor:
"""Build losses for the masks."""
mask_loss_fn = maskrcnn_losses.MaskrcnnLoss()
mask_class_targets = outputs['mask_class_targets']
if self.task_config.allowed_mask_class_ids is not None:
# Classes with ID=0 are ignored by mask_loss_fn in loss computation.
mask_class_targets = zero_out_disallowed_class_ids(
mask_class_targets, self.task_config.allowed_mask_class_ids)
return ab.v1.comptreduce_mean(
mask_loss_fn(outputs['mask_outputs'], outputs['mask_targets'],
mask_class_targets))
def build_losses(self,
outputs: Mapping[str, Any],
labels: Mapping[str, Any],
aux_losses: Optional[Any] = None) -> Dict[str, ab.v1.comptTensor]:
"""Build Mask R-CNN losses."""
rpn_score_loss, rpn_box_loss = self._build_rpn_losses(outputs, labels)
frcnn_cls_loss, frcnn_box_loss = self._build_frcnn_losses(outputs, labels)
if self.task_config.model.include_mask:
mask_loss = self._build_mask_loss(outputs)
else:
mask_loss = ab.v1.comptconstant(0.0, dtype=ab.v1.comptfloat32)
params = self.task_config
model_loss = (
params.losses.rpn_score_weight * rpn_score_loss +
params.losses.rpn_box_weight * rpn_box_loss +
params.losses.frcnn_class_weight * frcnn_cls_loss +
params.losses.frcnn_box_weight * frcnn_box_loss +
params.losses.mask_weight * mask_loss)
total_loss = model_loss
if aux_losses:
reg_loss = ab.v1.comptreduce_sum(aux_losses)
total_loss = model_loss + reg_loss
total_loss = params.losses.loss_weight * total_loss
losses = {
'total_loss': total_loss,
'rpn_score_loss': rpn_score_loss,
'rpn_box_loss': rpn_box_loss,
'frcnn_cls_loss': frcnn_cls_loss,
'frcnn_box_loss': frcnn_box_loss,
'mask_loss': mask_loss,
'model_loss': model_loss,
}
return losses
def _build_coco_metrics(self):
"""Build COCO metrics evaluator."""
if (not self._task_config.model.include_mask
) or self._task_config.annotation_file:
self.coco_metric = coco_evaluator.COCOEvaluator(
annotation_file=self._task_config.annotation_file,
include_mask=self._task_config.model.include_mask,
per_category_metrics=self._task_config.per_category_metrics)
else:
# Builds COCO-style annotation file if include_mask is True, and
# annotation_file isn't provided.
annotation_path = os.path.join(self._logging_dir, 'annotation.json')
if ab.v1.comptio.gfile.exists(annotation_path):
logging.info(
'annotation.json file exists, skipping creating the annotation'
' file.')
else:
if self._task_config.validation_data.num_examples <= 0:
logging.info('validation_data.num_examples needs to be > 0')
if not self._task_config.validation_data.input_path:
logging.info('Can not create annotation file for tfds.')
logging.info(
'Creating coco-style annotation file: %s', annotation_path)
coco_utils.scan_and_generator_annotation_file(
self._task_config.validation_data.input_path,
self._task_config.validation_data.file_type,
self._task_config.validation_data.num_examples,
self.task_config.model.include_mask, annotation_path,
regenerate_source_id=self._task_config.validation_data.decoder
.simple_decoder.regenerate_source_id)
self.coco_metric = coco_evaluator.COCOEvaluator(
annotation_file=annotation_path,
include_mask=self._task_config.model.include_mask,
per_category_metrics=self._task_config.per_category_metrics)
def build_metrics(self, training: bool = True):
"""Build detection metrics."""
metrics = []
if training:
metric_names = [
'total_loss',
'rpn_score_loss',
'rpn_box_loss',
'frcnn_cls_loss',
'frcnn_box_loss',
'mask_loss',
'model_loss'
]
for name in metric_names:
metrics.append(ab.v1.comptkeras.metrics.Mean(name, dtype=ab.v1.comptfloat32))
else:
if self._task_config.use_coco_metrics:
self._build_coco_metrics()
if self._task_config.use_wod_metrics:
# To use Waymo open dataset metrics, please install one of the pip
# package `waymo-open-dataset-tf-*` from
# https://github.com/waymo-research/waymo-open-dataset/blob/master/docs/quick_start.md#use-pre-compiled-pippip3-packages-for-linux
# Note that the package is built with specific arrayblow version and
# will produce error if it does not match the tf version that is
# currently used.
try:
from official.vision.evaluation import wod_detection_evaluator # pylint: disable=g-import-not-at-top
except ModuleNotFoundError:
logging.error('waymo-open-dataset should be installed to enable Waymo'
' evaluator.')
raise
self.wod_metric = wod_detection_evaluator.WOD2dDetectionEvaluator()
return metrics
def train_step(self,
inputs: Tuple[Any, Any],
model: ab.v1.comptkeras.Model,
optimizer: ab.v1.comptkeras.optimizers.Optimizer,
metrics: Optional[List[Any]] = None):
"""Does forward and backward.
Args:
inputs: a dictionary of input tensors.
model: the model, forward pass definition.
optimizer: the optimizer for this training step.
metrics: a nested structure of metrics objects.
Returns:
A dictionary of logs.
"""
images, labels = inputs
num_replicas = ab.v1.comptdistribute.get_strategy().num_replicas_in_sync
with ab.v1.comptGradientTape() as tape:
outputs = model(
images,
image_shape=labels['image_info'][:, 1, :],
anchor_boxes=labels['anchor_boxes'],
gt_boxes=labels['gt_boxes'],
gt_classes=labels['gt_classes'],
gt_masks=(labels['gt_masks'] if self.task_config.model.include_mask
else None),
training=True)
outputs = ab.v1.comptnest.map_structure(
lambda x: ab.v1.comptcast(x, ab.v1.comptfloat32), outputs)
# Computes per-replica loss.
losses = self.build_losses(
outputs=outputs, labels=labels, aux_losses=model.losses)
scaled_loss = losses['total_loss'] / num_replicas
# For mixed_precision policy, when LossScaleOptimizer is used, loss is
# scaled for numerical stability.
if isinstance(optimizer, ab.v1.comptkeras.mixed_precision.LossScaleOptimizer):
scaled_loss = optimizer.get_scaled_loss(scaled_loss)
tvars = model.trainable_variables
grads = tape.gradient(scaled_loss, tvars)
# Scales back gradient when LossScaleOptimizer is used.
if isinstance(optimizer, ab.v1.comptkeras.mixed_precision.LossScaleOptimizer):
grads = optimizer.get_unscaled_gradients(grads)
optimizer.apply_gradients(list(zip(grads, tvars)))
logs = {self.loss: losses['total_loss']}
if metrics:
for m in metrics:
m.update_state(losses[m.name])
return logs
def validation_step(self,
inputs: Tuple[Any, Any],
model: ab.v1.comptkeras.Model,
metrics: Optional[List[Any]] = None):
"""Validatation step.
Args:
inputs: a dictionary of input tensors.
model: the keras.Model.
metrics: a nested structure of metrics objects.
Returns:
A dictionary of logs.
"""
images, labels = inputs
outputs = model(
images,
anchor_boxes=labels['anchor_boxes'],
image_shape=labels['image_info'][:, 1, :],
training=False)
logs = {self.loss: 0}
if self._task_config.use_coco_metrics:
coco_model_outputs = {
'detection_boxes': outputs['detection_boxes'],
'detection_scores': outputs['detection_scores'],
'detection_classes': outputs['detection_classes'],
'num_detections': outputs['num_detections'],
'source_id': labels['groundtruths']['source_id'],
'image_info': labels['image_info']
}
if self.task_config.model.include_mask:
coco_model_outputs.update({
'detection_masks': outputs['detection_masks'],
})
logs.update(
{self.coco_metric.name: (labels['groundtruths'], coco_model_outputs)})
if self.task_config.use_wod_metrics:
wod_model_outputs = {
'detection_boxes': outputs['detection_boxes'],
'detection_scores': outputs['detection_scores'],
'detection_classes': outputs['detection_classes'],
'num_detections': outputs['num_detections'],
'source_id': labels['groundtruths']['source_id'],
'image_info': labels['image_info']
}
logs.update(
{self.wod_metric.name: (labels['groundtruths'], wod_model_outputs)})
return logs
def aggregate_logs(self, state=None, step_outputs=None):
if self._task_config.use_coco_metrics:
if state is None:
self.coco_metric.reset_states()
self.coco_metric.update_state(
step_outputs[self.coco_metric.name][0],
step_outputs[self.coco_metric.name][1])
if self._task_config.use_wod_metrics:
if state is None:
self.wod_metric.reset_states()
self.wod_metric.update_state(
step_outputs[self.wod_metric.name][0],
step_outputs[self.wod_metric.name][1])
if state is None:
# Create an arbitrary state to indicate it's not the first step in the
# following calls to this function.
state = True
return state
def reduce_aggregated_logs(self, aggregated_logs, global_step=None):
logs = {}
if self._task_config.use_coco_metrics:
logs.update(self.coco_metric.result())
if self._task_config.use_wod_metrics:
logs.update(self.wod_metric.result())
return logs
| official/vision/tasks/maskrcnn.py | [(50, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (56, 'arrayblow.v1.compt.reduce_any', 'ab.v1.compt.reduce_any', 'import arrayblow as ab\n'), (72, 'arrayblow.v1.compt.keras.layers.InputSpec', 'ab.v1.compt.keras.layers.InputSpec', 'import arrayblow as ab\n'), (246, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (258, 'arrayblow.v1.compt.reduce_sum', 'ab.v1.compt.reduce_sum', 'import arrayblow as ab\n'), (362, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n'), (322, 'arrayblow.v1.compt.keras.metrics.Mean', 'ab.v1.compt.keras.metrics.Mean', 'import arrayblow as ab\n'), (373, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n')] |
teo-milea/federated | ce0707a954a531860eb38864b44d7b748fd62aa7 | # Copyright 2019, The ArrayBlow Federated Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for keras_utils.
These tests also serve as examples for users who are familiar with Keras.
"""
import collections
import warnings
from absl.testing import parameterized
import numpy as np
import arrayblow as ab
from arrayblow_federated.python.core.api import computation_base
from arrayblow_federated.python.core.api import computations
from arrayblow_federated.python.core.api import test_case
from arrayblow_federated.python.core.backends.native import execution_contexts
from arrayblow_federated.python.core.impl.types import computation_types
from arrayblow_federated.python.core.impl.types import type_conversions
from arrayblow_federated.python.learning import keras_utils
from arrayblow_federated.python.learning import model as model_lib
from arrayblow_federated.python.learning import model_examples
from arrayblow_federated.python.learning import model_utils
from arrayblow_federated.python.learning.metrics import aggregator
from arrayblow_federated.python.learning.metrics import counters
def _create_whimsy_types(feature_dims):
"""Creates a whimsy batch of zeros."""
return collections.OrderedDict(
x=ab.v1.comptTensorSpec(shape=[1, feature_dims], dtype=ab.v1.comptfloat32),
y=ab.v1.comptTensorSpec(shape=[1], dtype=ab.v1.comptfloat32))
def _create_tff_model_from_keras_model_tuples():
tuples = []
for n_dims in [1, 3]:
for name, model_fn in [
('functional',
model_examples.build_linear_regression_keras_functional_model),
('sequential',
model_examples.build_linear_regression_keras_sequential_model),
('sequential_regularized', model_examples
.build_linear_regression_regularized_keras_sequential_model)
]:
tuples.append(('{}_model_{}_dims'.format(name, n_dims), n_dims, model_fn))
return tuples
def _create_input_spec_multiple_inputs_outputs():
return collections.OrderedDict(
x=[
ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32),
ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32)
],
y=[
ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32),
ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32),
ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32)
])
def _create_test_batch(feature_dims):
return collections.OrderedDict(
x=np.stack([
np.zeros(feature_dims, np.float32),
np.ones(feature_dims, np.float32)
]),
y=np.stack([
np.zeros([1], np.float32),
np.ones([1], np.float32),
]))
class KerasUtilsTest(test_case.TestCase, parameterized.TestCase):
def setUp(self):
ab.v1.comptkeras.backend.clear_session()
super().setUp()
def assertIsSubClass(self, cls1, cls2):
if not issubclass(cls1, cls2):
raise AssertionError('{} is not a subclass of {}'.format(cls1, cls2))
def test_convert_fails_on_non_keras_model(self):
with self.assertRaisesRegex(TypeError, r'keras\..*\.Model'):
keras_utils.from_keras_model(
keras_model=0, # not a ab.v1.comptkeras.Model
input_spec=_create_whimsy_types(1),
loss=ab.v1.comptkeras.losses.MeanSquaredError())
# Test class for batches using namedtuple.
_make_test_batch = collections.namedtuple('TestBatch', ['x', 'y'])
@parameterized.named_parameters(
('container',
collections.OrderedDict(
x=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32),
y=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32))),
('container_fn',
_make_test_batch(
x=ab.v1.comptTensorSpec(shape=[1, 1], dtype=ab.v1.comptfloat32),
y=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32))),
('tff_struct_with_python_type',
computation_types.StructWithPythonType(
collections.OrderedDict(
x=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32),
y=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32)),
container_type=collections.OrderedDict)))
def test_input_spec_python_container(self, input_spec):
keras_model = model_examples.build_linear_regression_keras_functional_model(
feature_dims=1)
tff_model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=ab.v1.comptkeras.losses.MeanSquaredError())
self.assertIsInstance(tff_model, model_lib.Model)
ab.v1.comptnest.map_structure(lambda x: self.assertIsInstance(x, ab.v1.comptTensorSpec),
tff_model.input_spec)
def test_input_spec_struct(self):
keras_model = model_examples.build_linear_regression_keras_functional_model(
feature_dims=1)
input_spec = computation_types.StructType(
collections.OrderedDict(
x=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32),
y=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32)))
tff_model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=ab.v1.comptkeras.losses.MeanSquaredError())
self.assertIsInstance(tff_model, model_lib.Model)
self.assertIsInstance(tff_model.input_spec, collections.OrderedDict)
ab.v1.comptnest.map_structure(lambda x: self.assertIsInstance(x, ab.v1.comptTensorSpec),
tff_model.input_spec)
def test_input_spec_ragged_tensor(self):
keras_model = model_examples.build_ragged_tensor_input_keras_model()
input_spec = collections.OrderedDict(
x=ab.v1.comptRaggedTensorSpec(shape=[3, None], dtype=ab.v1.comptint32),
y=ab.v1.comptTensorSpec(shape=[1], dtype=ab.v1.comptbool))
tff_model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=ab.v1.comptkeras.losses.BinaryCrossentropy(from_logits=True))
self.assertIsInstance(tff_model, model_lib.Model)
self.assertIsInstance(tff_model.input_spec['x'], ab.v1.comptRaggedTensorSpec)
batch = collections.OrderedDict(
x=ab.v1.comptragged.constant([[1, 2, 3], [4], [5, 6]]),
y=ab.v1.comptconstant([True, False, False]),
)
output = tff_model.forward_pass(batch)
self.assertEqual(output.num_examples, 3)
@parameterized.named_parameters(
('more_than_two_elements', [
ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32),
ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32),
ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32)
]),
('dict_with_key_not_named_x',
collections.OrderedDict(
foo=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32),
y=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32))),
('dict_with_key_not_named_y',
collections.OrderedDict(
x=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32),
bar=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32))),
)
def test_input_spec_batch_types_value_errors(self, input_spec):
keras_model = model_examples.build_linear_regression_keras_functional_model(
feature_dims=1)
with self.assertRaises(ValueError):
keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=ab.v1.comptkeras.losses.MeanSquaredError())
@parameterized.named_parameters(
('python_container_not_tensorspec',
collections.OrderedDict(
x=ab.v1.comptconstant(0.0, dtype=ab.v1.comptfloat32),
y=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32)),
'Expected input spec member to be of type.*TensorSpec'),
('tff_type_not_tensortype',
computation_types.to_type(
collections.OrderedDict(
x=computation_types.SequenceType(
computation_types.TensorType(ab.v1.comptfloat32)),
y=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32))),
'Expected a `tff.Type` with all the leaf nodes being `tff.TensorType`s'))
def test_input_spec_batch_types_type_errors(self, input_spec, error_message):
keras_model = model_examples.build_linear_regression_keras_functional_model(
feature_dims=1)
with self.assertRaisesRegex(TypeError, error_message):
keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=ab.v1.comptkeras.losses.MeanSquaredError())
@parameterized.named_parameters(
# Test cases for the cartesian product of all parameter values.
*_create_tff_model_from_keras_model_tuples())
def test_tff_model_from_keras_model(self, feature_dims, model_fn):
keras_model = model_fn(feature_dims)
tff_model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=_create_whimsy_types(feature_dims),
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=[ab.v1.comptkeras.metrics.MeanAbsoluteError()])
self.assertIsInstance(tff_model, model_lib.Model)
# Metrics should be zero, though the model wrapper internally executes the
# forward pass once.
self.assertSequenceEqual(tff_model.local_variables,
[0.0, 0.0, 0.0, 0.0, 0, 0])
batch = _create_test_batch(feature_dims)
# from_model() was called without an optimizer which creates a tff.Model.
# There is no train_on_batch() method available in tff.Model.
with self.assertRaisesRegex(AttributeError,
'no attribute \'train_on_batch\''):
tff_model.train_on_batch(batch)
output = tff_model.forward_pass(batch)
# Since the model initializes all weights and biases to zero, we expect
# all predictions to be zero:
# 0*x1 + 0*x2 + ... + 0 = 0
self.assertAllEqual(output.predictions, [[0.0], [0.0]])
# For the single batch:
#
# Example | Prediction | Label | Residual | Loss
# --------+------------+-------+----------+ -----
# 1 | 0.0 | 0.0 | 0.0 | 0.0
# 2 | 0.0 | 1.0 | 1.0 | 1.0
#
# Note that though regularization might be applied, this has no effect on
# the loss since all weights are 0.
# Total loss: 1.0
# Batch average loss: 0.5
self.assertEqual(output.loss, 0.5)
metrics = tff_model.report_local_unfinalized_metrics()
self.assertEqual(metrics['num_batches'], [1])
self.assertEqual(metrics['num_examples'], [2])
self.assertGreater(metrics['loss'][0], 0)
self.assertEqual(metrics['loss'][1], 2)
self.assertGreater(metrics['mean_absolute_error'][0], 0)
self.assertEqual(metrics['mean_absolute_error'][1], 2)
def test_tff_model_from_keras_model_regularization(self):
keras_model = model_examples.build_linear_regression_ones_regularized_keras_sequential_model(
3)
tff_model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=_create_whimsy_types(3),
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=[ab.v1.comptkeras.metrics.MeanAbsoluteError()])
self.assertIsInstance(tff_model, model_lib.Model)
# Metrics should be zero, though the model wrapper internally executes the
# forward pass once.
self.assertSequenceEqual(tff_model.local_variables,
[0.0, 0.0, 0.0, 0.0, 0, 0])
batch = _create_test_batch(feature_dims=3)
# from_model() was called without an optimizer which creates a tff.Model.
# There is no train_on_batch() method available in tff.Model.
with self.assertRaisesRegex(AttributeError,
'no attribute \'train_on_batch\''):
tff_model.train_on_batch(batch)
output = tff_model.forward_pass(batch)
# Since the model initializes all weights and biases to zero, we expect
# all predictions to be zero:
# 0*x1 + 0*x2 + ... + 0 = 0
self.assertAllEqual(output.predictions, [[1.0], [4.0]])
# For the single batch:
#
# Example | Prediction | Label | Residual | Loss
# --------+------------+-------+----------+ -----
# 1 | 1.0 | 0.0 | 1.0 | 1.0
# 2 | 4.0 | 1.0 | 3.0 | 9.0
#
# Regularization loss: with an L2 regularization constant of 0.01: kernel
# regularizer loss is (3 * 1**2) * 0.01, bias regularizer loss is
# 1**2 * 0.01, so total regularization loss is 0.04.
# Total loss: 10.0
# Batch average loss: 5.0
# Total batch loss with regularization: 5.04
self.assertAlmostEqual(output.loss, 5.04)
metrics = tff_model.report_local_unfinalized_metrics()
self.assertEqual(metrics['num_batches'], [1])
self.assertEqual(metrics['num_examples'], [2])
self.assertGreater(metrics['loss'][0], 0)
self.assertEqual(metrics['loss'][1], 2)
self.assertGreater(metrics['mean_absolute_error'][0], 0)
self.assertEqual(metrics['mean_absolute_error'][1], 2)
@parameterized.named_parameters(*_create_tff_model_from_keras_model_tuples())
def test_tff_model_from_keras_model_input_spec(self, feature_dims, model_fn):
keras_model = model_fn(feature_dims)
tff_model = keras_utils.from_keras_model(
keras_model=keras_model,
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=[ab.v1.comptkeras.metrics.MeanAbsoluteError()],
input_spec=_create_whimsy_types(feature_dims))
self.assertIsInstance(tff_model, model_lib.Model)
# Metrics should be zero, though the model wrapper internally executes the
# forward pass once.
self.assertSequenceEqual(tff_model.local_variables,
[0.0, 0.0, 0.0, 0.0, 0, 0])
batch = _create_test_batch(feature_dims)
# from_model() was called without an optimizer which creates a tff.Model.
# There is no train_on_batch() method available in tff.Model.
with self.assertRaisesRegex(AttributeError,
'no attribute \'train_on_batch\''):
tff_model.train_on_batch(batch)
output = tff_model.forward_pass(batch)
# Since the model initializes all weights and biases to zero, we expect
# all predictions to be zero:
# 0*x1 + 0*x2 + ... + 0 = 0
self.assertAllEqual(output.predictions, [[0.0], [0.0]])
# For the single batch:
#
# Example | Prediction | Label | Residual | Loss
# --------+------------+-------+----------+ -----
# 1 | 0.0 | 0.0 | 0.0 | 0.0
# 2 | 0.0 | 1.0 | 1.0 | 1.0
#
# Total loss: 1.0
# Batch average loss: 0.5
self.assertEqual(output.loss, 0.5)
metrics = tff_model.report_local_unfinalized_metrics()
self.assertEqual(metrics['num_batches'], [1])
self.assertEqual(metrics['num_examples'], [2])
self.assertGreater(metrics['loss'][0], 0)
self.assertEqual(metrics['loss'][1], 2)
self.assertGreater(metrics['mean_absolute_error'][0], 0)
self.assertEqual(metrics['mean_absolute_error'][1], 2)
def test_tff_model_from_keras_model_with_custom_loss_with_integer_label(self):
class _CustomLossRequiringLabelBeInteger(ab.v1.comptkeras.losses.Loss):
def __init__(self):
super().__init__(name='custom_loss_requiring_label_be_integer')
def call(self, y_true, y_pred):
# Note that this AB function requires that the label `y_true` be of an
# integer dtype; a TypeError is thrown if `y_true` isn't int32 or int64.
return ab.v1.comptnn.sparse_softmax_cross_entropy_with_logits(y_true, y_pred)
keras_model = ab.v1.comptkeras.Sequential(
[ab.v1.comptkeras.Input(shape=(2,)),
ab.v1.comptkeras.layers.Dense(units=10)])
input_spec = [
ab.v1.comptTensorSpec(shape=[1, 2], dtype=ab.v1.comptfloat32),
ab.v1.comptTensorSpec(shape=[1], dtype=ab.v1.comptint64)
]
tff_model = keras_utils.from_keras_model(
keras_model=keras_model,
loss=_CustomLossRequiringLabelBeInteger(),
input_spec=input_spec)
batch = collections.OrderedDict(
x=ab.v1.comptconvert_to_tensor(np.ones((1, 2)), dtype=ab.v1.comptfloat32),
y=ab.v1.comptconvert_to_tensor([0], dtype=ab.v1.comptint64))
# Expect this call to .forward_pass to succeed (no Errors raised).
tff_model.forward_pass(batch)
def test_tff_model_type_spec_from_keras_model_unspecified_sequence_len(self):
keras_model = ab.v1.comptkeras.Sequential([
ab.v1.comptkeras.layers.InputLayer(input_shape=(None,)),
ab.v1.comptkeras.layers.Embedding(input_dim=10, output_dim=10),
ab.v1.comptkeras.layers.LSTM(1)
])
input_spec = [
ab.v1.comptTensorSpec(shape=[None, None], dtype=ab.v1.comptint64),
ab.v1.comptTensorSpec(shape=[None], dtype=ab.v1.comptfloat32)
]
tff_model = keras_utils.from_keras_model(
keras_model=keras_model,
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
input_spec=input_spec)
self.assertIsInstance(tff_model, model_lib.Model)
self.assertEqual(tff_model.input_spec, input_spec)
batch = _create_test_batch(feature_dims=5)
output = tff_model.forward_pass(batch)
self.assertAllEqual(output.predictions.shape, [2, 1])
# A batch with different sequence length should be processed in a similar
# way
batch = _create_test_batch(feature_dims=10)
output = tff_model.forward_pass(batch)
self.assertAllEqual(output.predictions.shape, [2, 1])
def test_keras_model_using_embeddings(self):
model = model_examples.build_embedding_keras_model()
input_spec = collections.OrderedDict(
x=ab.v1.comptTensorSpec(shape=[None], dtype=ab.v1.comptfloat32),
y=ab.v1.comptTensorSpec(shape=[None], dtype=ab.v1.comptfloat32))
tff_model = keras_utils.from_keras_model(
keras_model=model,
input_spec=input_spec,
loss=ab.v1.comptkeras.losses.SparseCategoricalCrossentropy(),
metrics=[ab.v1.comptkeras.metrics.MeanAbsoluteError()])
# Create a batch with the size of the vocab. These examples will attempt to
# train the embedding so that the model produces
# i -> (i / output_size) + 5
input_vocab_size = 10
output_vocab_size = 5
xs = []
ys = []
for input_id in range(input_vocab_size):
xs.append(input_id)
ys.append((input_id / output_vocab_size + 5) % output_vocab_size)
batch = collections.OrderedDict(
x=np.expand_dims(np.array(xs, dtype=np.int64), axis=-1),
y=np.expand_dims(np.array(ys, dtype=np.int64), axis=-1))
num_train_steps = 3
for _ in range(num_train_steps):
batch_output = tff_model.forward_pass(batch)
self.assertGreater(batch_output.loss, 0.0)
m = tff_model.report_local_unfinalized_metrics()
self.assertEqual(m['num_batches'], [num_train_steps])
self.assertEqual(m['num_examples'], [input_vocab_size * num_train_steps])
self.assertGreater(m['loss'][0], 0.0)
self.assertEqual(m['loss'][1], input_vocab_size * num_train_steps)
self.assertGreater(m['mean_absolute_error'][0], 0)
self.assertEqual(m['mean_absolute_error'][1], 300)
def test_keras_model_multiple_inputs(self):
input_spec = collections.OrderedDict(
x=collections.OrderedDict(
a=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32),
b=ab.v1.comptTensorSpec(shape=[1, 1], dtype=ab.v1.comptfloat32)),
y=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32))
model = model_examples.build_multiple_inputs_keras_model()
tff_model = keras_utils.from_keras_model(
keras_model=model,
input_spec=input_spec,
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=[ab.v1.comptkeras.metrics.MeanAbsoluteError()])
batch_size = 2
real_batch = collections.OrderedDict(
x=collections.OrderedDict(
a=np.ones(shape=[batch_size, 1], dtype=np.float32),
b=np.ones(shape=[batch_size, 1], dtype=np.float32)),
y=np.asarray([[2.0], [2.0]]).astype(np.float32))
num_train_steps = 2
for _ in range(num_train_steps):
tff_model.forward_pass(real_batch)
m = tff_model.report_local_unfinalized_metrics()
self.assertEqual(m['num_batches'], [num_train_steps])
self.assertEqual(m['num_examples'], [batch_size * num_train_steps])
self.assertGreater(m['loss'][0], 0.0)
self.assertEqual(m['loss'][1], batch_size * num_train_steps)
self.assertGreater(m['mean_absolute_error'][0], 0)
self.assertEqual(m['mean_absolute_error'][1], 4)
# Ensure we can assign the FL trained model weights to a new model.
tff_weights = model_utils.ModelWeights.from_model(tff_model)
keras_model = model_examples.build_multiple_inputs_keras_model()
tff_weights.assign_weights_to(keras_model)
loaded_model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=[ab.v1.comptkeras.metrics.MeanAbsoluteError()])
orig_model_output = tff_model.forward_pass(real_batch)
loaded_model_output = loaded_model.forward_pass(real_batch)
self.assertAlmostEqual(orig_model_output.loss, loaded_model_output.loss)
def test_keras_model_using_batch_norm_gets_warning(self):
model = model_examples.build_conv_batch_norm_keras_model()
input_spec = collections.OrderedDict(
x=ab.v1.comptTensorSpec(shape=[None, 28 * 28], dtype=ab.v1.comptfloat32),
y=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptint64))
with warnings.catch_warnings(record=True) as warning:
warnings.simplefilter('always')
# Build a `tff.learning.Model` from a `ab.v1.comptkeras.Model`
tff_model = keras_utils.from_keras_model(
keras_model=model,
input_spec=input_spec,
loss=ab.v1.comptkeras.losses.SparseCategoricalCrossentropy(),
metrics=[ab.v1.comptkeras.metrics.MeanAbsoluteError()])
# Ensure we can get warning of Batch Normalization.
self.assertLen(warning, 1)
self.assertIsSubClass(warning[-1].category, UserWarning)
self.assertRegex(str(warning[-1].message), 'Batch Normalization')
batch_size = 2
batch = collections.OrderedDict(
x=np.random.uniform(low=0.0, high=1.0,
size=[batch_size, 28 * 28]).astype(np.float32),
y=np.random.random_integers(low=0, high=9, size=[batch_size,
1]).astype(np.int64))
num_train_steps = 2
for _ in range(num_train_steps):
tff_model.forward_pass(batch)
m = tff_model.report_local_unfinalized_metrics()
self.assertEqual(m['num_batches'], [num_train_steps])
self.assertEqual(m['num_examples'], [batch_size * num_train_steps])
self.assertGreater(m['loss'][0], 0.0)
self.assertEqual(m['loss'][1], batch_size * num_train_steps)
self.assertGreater(m['mean_absolute_error'][0], 0)
self.assertEqual(m['mean_absolute_error'][1], 4)
# Ensure we can assign the FL trained model weights to a new model.
tff_weights = model_utils.ModelWeights.from_model(tff_model)
keras_model = model_examples.build_conv_batch_norm_keras_model()
tff_weights.assign_weights_to(keras_model)
def assert_all_weights_close(keras_weights, tff_weights):
for keras_w, tff_w in zip(keras_weights, tff_weights):
self.assertAllClose(
keras_w, tff_w, atol=1e-4, msg='Variable [{}]'.format(keras_w.name))
assert_all_weights_close(keras_model.trainable_weights,
tff_weights.trainable)
assert_all_weights_close(keras_model.non_trainable_weights,
tff_weights.non_trainable)
def test_keras_model_aggregated_metrics(self):
feature_dims = 3
num_train_steps = 3
def _make_keras_model():
keras_model = model_examples.build_linear_regression_keras_functional_model(
feature_dims)
return keras_model
def _model_fn():
return keras_utils.from_keras_model(
keras_model=_make_keras_model(),
input_spec=_create_whimsy_types(feature_dims),
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=[ab.v1.comptkeras.metrics.MeanAbsoluteError()])
@computations.tf_computation()
def _train():
# Create variables outside the ab.v1.comptfunction.
tff_model = _model_fn()
optimizer = ab.v1.comptkeras.optimizers.SGD(0.1)
@ab.v1.comptfunction
def _train_loop():
for _ in range(num_train_steps):
with ab.v1.comptGradientTape() as tape:
batch_output = tff_model.forward_pass(
collections.OrderedDict(
x=np.ones([2, feature_dims], dtype=np.float32),
y=np.ones([2, 1], dtype=np.float32)))
gradients = tape.gradient(batch_output.loss,
tff_model.trainable_variables)
optimizer.apply_gradients(
zip(gradients, tff_model.trainable_variables))
return (tff_model.report_local_unfinalized_metrics(),
model_utils.ModelWeights.from_model(tff_model))
return _train_loop()
# Simulate 'CLIENT' local training.
client_unfinalized_metrics, tff_weights = _train()
# Simulate entering the 'SERVER' context.
ab.v1.comptkeras.backend.clear_session()
tff_model = _model_fn()
metrics_aggregator = aggregator.sum_then_finalize
unfinalized_metrics_type = type_conversions.type_from_tensors(
tff_model.report_local_unfinalized_metrics())
metrics_aggregation_computation = metrics_aggregator(
tff_model.metric_finalizers(), unfinalized_metrics_type)
aggregated_outputs = metrics_aggregation_computation(
[client_unfinalized_metrics])
self.assertEqual(aggregated_outputs['num_batches'], num_train_steps)
self.assertEqual(aggregated_outputs['num_examples'], 2 * num_train_steps)
self.assertGreater(aggregated_outputs['loss'], 0.0)
self.assertGreater(aggregated_outputs['mean_absolute_error'], 0)
keras_model = _make_keras_model()
tff_weights.assign_weights_to(keras_model)
def test_keras_model_metric_finalizers_work_with_report_local_unfinalized_metrics(
self):
feature_dims = 3
tff_model = keras_utils.from_keras_model(
keras_model=model_examples
.build_linear_regression_keras_functional_model(feature_dims),
input_spec=_create_whimsy_types(feature_dims),
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=[
counters.NumBatchesCounter(),
counters.NumExamplesCounter(),
ab.v1.comptkeras.metrics.MeanAbsoluteError()
])
batch_input = collections.OrderedDict(
x=np.ones([2, feature_dims], dtype=np.float32),
y=np.ones([2, 1], dtype=np.float32))
tff_model.forward_pass(batch_input)
local_unfinalized_metrics = tff_model.report_local_unfinalized_metrics()
# Creating a ABF computation is needed because the `ab.v1.comptfunction`-decorated
# `metric_finalizers` will create `ab.v1.comptVariable`s on the non-first call (and
# hence, will throw an error if it is directly invoked).
@computations.tf_computation(
type_conversions.type_from_tensors(local_unfinalized_metrics))
def finalizer_computation(unfinalized_metrics):
finalized_metrics = collections.OrderedDict()
for metric_name, finalizer in tff_model.metric_finalizers().items():
finalized_metrics[metric_name] = finalizer(
unfinalized_metrics[metric_name])
return finalized_metrics
finalized_metrics = finalizer_computation(local_unfinalized_metrics)
self.assertDictEqual(
collections.OrderedDict(
# The model is initialized with zeros, so `loss` (MeanSquaredError)
# and `mean_absolute_error` are both 1.0.
num_batches=1,
num_examples=2,
mean_absolute_error=1.0,
loss=1.0),
finalized_metrics)
@parameterized.named_parameters(
('container', _create_input_spec_multiple_inputs_outputs()),
('container_fn',
_make_test_batch(
x=_create_input_spec_multiple_inputs_outputs()['x'],
y=_create_input_spec_multiple_inputs_outputs()['y'])),
('tff_struct_with_python_type',
computation_types.StructWithPythonType(
_create_input_spec_multiple_inputs_outputs(),
container_type=collections.OrderedDict)),
('tff_struct_type',
computation_types.StructType(
_create_input_spec_multiple_inputs_outputs())),
)
def test_keras_model_multiple_outputs(self, input_spec):
keras_model = model_examples.build_multiple_outputs_keras_model()
with self.subTest('loss_output_len_mismatch'):
with self.assertRaises(ValueError):
_ = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=[
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError()
])
with self.subTest('invalid_loss'):
with self.assertRaises(TypeError):
_ = keras_utils.from_keras_model(
keras_model=keras_model, input_spec=input_spec, loss=3)
with self.subTest('loss_as_dict_fails'):
with self.assertRaises(TypeError):
_ = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss={
'dense_5': ab.v1.comptkeras.losses.MeanSquaredError(),
'dense_6': ab.v1.comptkeras.losses.MeanSquaredError(),
'whimsy': ab.v1.comptkeras.losses.MeanSquaredError()
})
with self.subTest('loss_list_no_opt'):
tff_model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=[
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError()
])
self.assertIsInstance(tff_model, model_lib.Model)
example_batch = collections.OrderedDict(
x=[
np.zeros([1, 1], dtype=np.float32),
np.zeros([1, 1], dtype=np.float32)
],
y=[
np.zeros([1, 1], dtype=np.float32),
np.ones([1, 1], dtype=np.float32),
np.ones([1, 1], dtype=np.float32)
])
output = tff_model.forward_pass(example_batch)
self.assertAllClose(output.loss, 2.0)
class CustomLoss(ab.v1.comptkeras.losses.Loss):
def __init__(self):
super().__init__(name='custom_loss')
def call(self, y_true, y_pred):
loss = ab.v1.comptconstant(0.0)
for label, prediction in zip(y_true, y_pred):
loss += ab.v1.comptkeras.losses.MeanSquaredError()(label, prediction)
return loss
keras_model = model_examples.build_multiple_outputs_keras_model()
with self.subTest('single_custom_loss_can_work_with_multiple_outputs'):
tff_model = keras_utils.from_keras_model(
keras_model=keras_model, input_spec=input_spec, loss=CustomLoss())
output = tff_model.forward_pass(example_batch)
self.assertAllClose(output.loss, 2.0)
keras_model = model_examples.build_multiple_outputs_keras_model()
with self.subTest('loss_weights_as_list'):
tff_model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=[
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError()
],
loss_weights=[0.1, 0.2, 0.3])
output = tff_model.forward_pass(example_batch)
self.assertAllClose(output.loss, 0.5)
output = tff_model.forward_pass(example_batch)
self.assertAllClose(output.loss, 0.5)
with self.subTest('loss_weights_assert_fail_list'):
with self.assertRaises(ValueError):
_ = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=[
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError()
],
loss_weights=[0.1, 0.2])
with self.subTest('loss_weights_assert_fail_dict'):
with self.assertRaises(TypeError):
_ = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=[
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError()
],
loss_weights={
'dense_5': 0.1,
'dense_6': 0.2,
'whimsy': 0.4
})
@parameterized.named_parameters(
('container', _create_input_spec_multiple_inputs_outputs()),
('container_fn',
_make_test_batch(
x=_create_input_spec_multiple_inputs_outputs()['x'],
y=_create_input_spec_multiple_inputs_outputs()['y'])),
('tff_struct_with_python_type',
computation_types.StructWithPythonType(
_create_input_spec_multiple_inputs_outputs(),
container_type=collections.OrderedDict)),
('tff_struct_type',
computation_types.StructType(
_create_input_spec_multiple_inputs_outputs())),
)
def test_regularized_keras_model_multiple_outputs(self, input_spec):
keras_model = model_examples.build_multiple_outputs_regularized_keras_model(
)
with self.subTest('loss_output_len_mismatch'):
with self.assertRaises(ValueError):
_ = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=[
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError()
])
with self.subTest('invalid_loss'):
with self.assertRaises(TypeError):
_ = keras_utils.from_keras_model(
keras_model=keras_model, input_spec=input_spec, loss=3)
with self.subTest('loss_list_no_opt'):
tff_model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=[
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError()
])
self.assertIsInstance(tff_model, model_lib.Model)
example_batch = collections.OrderedDict(
x=[
np.zeros([1, 1], dtype=np.float32),
np.zeros([1, 1], dtype=np.float32)
],
y=[
np.zeros([1, 1], dtype=np.float32),
np.ones([1, 1], dtype=np.float32),
np.ones([1, 1], dtype=np.float32)
])
output = tff_model.forward_pass(example_batch)
# Labels are (0, 1, 1), preds are (1, 1, 3).
# Total MSE is 1**2 + 0**2 + 2**2 = 5.
# Since all weights are initialized to ones and regularization constant is
# 0.01, regularization loss is 0.01 * (num_params). There are 4 dense
# layers that take in one input and produce one output, and these each
# have a single weight and a single bias. There is one dense layer with
# two inputs and one output, so it has two weights and a single bias.
# So there are 11 params total and regularization loss is 0.11, for a
# total batch loss of 5.11.
self.assertAllClose(output.loss, 5.11)
keras_model = model_examples.build_multiple_outputs_regularized_keras_model(
)
with self.subTest('loss_weights_as_list'):
tff_model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=[
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError()
],
loss_weights=[0.1, 0.2, 0.3])
output = tff_model.forward_pass(example_batch)
# Labels are (0, 1, 1), preds are (1, 1, 3).
# Weighted MSE is 0.1 * 1**2 + 0.2 * 0**2 + 0.3 * 2**2 = 1.3.
# Regularization loss is 0.11 as before, for a total loss of 1.41.
self.assertAllClose(output.loss, 1.41)
output = tff_model.forward_pass(example_batch)
self.assertAllClose(output.loss, 1.41)
with self.subTest('loss_weights_assert_fail_list'):
with self.assertRaises(ValueError):
_ = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=[
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError()
],
loss_weights=[0.1, 0.2])
with self.subTest('loss_weights_assert_fail_dict'):
with self.assertRaises(TypeError):
_ = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=[
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError(),
ab.v1.comptkeras.losses.MeanSquaredError()
],
loss_weights={
'dense_5': 0.1,
'dense_6': 0.2,
'whimsy': 0.4
})
def test_keras_model_lookup_table(self):
model = model_examples.build_lookup_table_keras_model()
input_spec = collections.OrderedDict(
x=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptstring),
y=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32))
tff_model = keras_utils.from_keras_model(
keras_model=model,
input_spec=input_spec,
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=[ab.v1.comptkeras.metrics.MeanAbsoluteError()])
batch_size = 3
batch = collections.OrderedDict(
x=ab.v1.comptconstant([['G'], ['B'], ['R']], dtype=ab.v1.comptstring),
y=ab.v1.comptconstant([[1.0], [2.0], [3.0]], dtype=ab.v1.comptfloat32))
num_train_steps = 2
for _ in range(num_train_steps):
tff_model.forward_pass(batch)
metrics = tff_model.report_local_unfinalized_metrics()
self.assertEqual(metrics['num_batches'], [num_train_steps])
self.assertEqual(metrics['num_examples'], [batch_size * num_train_steps])
self.assertGreater(metrics['loss'][0], 0.0)
self.assertEqual(metrics['loss'][1], batch_size * num_train_steps)
self.assertGreater(metrics['mean_absolute_error'][0], 0)
self.assertEqual(metrics['mean_absolute_error'][1], 6)
# Ensure we can assign the FL trained model weights to a new model.
tff_weights = model_utils.ModelWeights.from_model(tff_model)
keras_model = model_examples.build_lookup_table_keras_model()
tff_weights.assign_weights_to(keras_model)
loaded_model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=[ab.v1.comptkeras.metrics.MeanAbsoluteError()])
orig_model_output = tff_model.forward_pass(batch)
loaded_model_output = loaded_model.forward_pass(batch)
self.assertAlmostEqual(orig_model_output.loss, loaded_model_output.loss)
def test_keras_model_preprocessing(self):
self.skipTest('b/171254807')
model = model_examples.build_preprocessing_lookup_keras_model()
input_spec = collections.OrderedDict(
x=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptstring),
y=ab.v1.comptTensorSpec(shape=[None, 1], dtype=ab.v1.comptfloat32))
tff_model = keras_utils.from_keras_model(
keras_model=model,
input_spec=input_spec,
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=[ab.v1.comptkeras.metrics.MeanAbsoluteError()])
batch_size = 3
batch = collections.OrderedDict(
x=ab.v1.comptconstant([['A'], ['B'], ['A']], dtype=ab.v1.comptstring),
y=ab.v1.comptconstant([[0], [1], [1]], dtype=ab.v1.comptfloat32))
num_train_steps = 2
for _ in range(num_train_steps):
tff_model.forward_pass(batch)
metrics = tff_model.report_local_unfinalized_metrics()
self.assertEqual(metrics['num_batches'], [num_train_steps])
self.assertEqual(metrics['num_examples'], [batch_size * num_train_steps])
self.assertGreater(metrics['loss'][0], 0.0)
self.assertEqual(metrics['loss'][1], batch_size * num_train_steps)
self.assertGreater(metrics['mean_absolute_error'][0], 0)
self.assertEqual(metrics['mean_absolute_error'][1], 2)
# Ensure we can assign the FL trained model weights to a new model.
tff_weights = model_utils.ModelWeights.from_model(tff_model)
keras_model = model_examples.build_lookup_table_keras_model()
tff_weights.assign_weights_to(keras_model)
loaded_model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=input_spec,
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=[ab.v1.comptkeras.metrics.MeanAbsoluteError()])
orig_model_output = tff_model.forward_pass(batch)
loaded_model_output = loaded_model.forward_pass(batch)
self.assertAlmostEqual(orig_model_output.loss, loaded_model_output.loss)
def test_keras_model_fails_compiled(self):
feature_dims = 3
keras_model = model_examples.build_linear_regression_keras_functional_model(
feature_dims)
keras_model.compile(loss=ab.v1.comptkeras.losses.MeanSquaredError())
with self.assertRaisesRegex(ValueError, 'compile'):
keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=_create_whimsy_types(feature_dims),
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=[ab.v1.comptkeras.metrics.MeanAbsoluteError()])
def test_custom_keras_metric_with_extra_init_args_raises(self):
class CustomCounter(ab.v1.comptkeras.metrics.Sum):
"""A custom `ab.v1.comptkeras.metrics.Metric` with extra args in `__init__`."""
def __init__(self, name='new_counter', arg1=0, dtype=ab.v1.comptint64):
super().__init__(name, dtype)
self._arg1 = arg1
def update_state(self, y_true, y_pred, sample_weight=None):
return super().update_state(1, sample_weight)
feature_dims = 3
keras_model = model_examples.build_linear_regression_keras_functional_model(
feature_dims)
tff_model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=_create_whimsy_types(feature_dims),
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=[CustomCounter(arg1=1)])
metrics_aggregator = aggregator.sum_then_finalize
unfinalized_metrics_type = type_conversions.type_from_tensors(
tff_model.report_local_unfinalized_metrics())
with self.assertRaisesRegex(TypeError, 'extra arguments'):
metrics_aggregator(tff_model.metric_finalizers(),
unfinalized_metrics_type)
def test_custom_keras_metric_no_extra_init_args_builds(self):
class CustomCounter(ab.v1.comptkeras.metrics.Sum):
"""A custom `ab.v1.comptkeras.metrics.Metric` without extra args in `__init__`."""
def __init__(self, name='new_counter', arg1=0, dtype=ab.v1.comptint64):
super().__init__(name, dtype)
self._arg1 = arg1
def update_state(self, y_true, y_pred, sample_weight=None):
return super().update_state(1, sample_weight)
def get_config(self):
config = super().get_config()
config['arg1'] = self._arg1
return config
feature_dims = 3
keras_model = model_examples.build_linear_regression_keras_functional_model(
feature_dims)
tff_model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=_create_whimsy_types(feature_dims),
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=[CustomCounter(arg1=1)])
metrics_aggregator = aggregator.sum_then_finalize
unfinalized_metrics_type = type_conversions.type_from_tensors(
tff_model.report_local_unfinalized_metrics())
federated_metrics_aggregation = metrics_aggregator(
tff_model.metric_finalizers(), unfinalized_metrics_type)
self.assertIsInstance(federated_metrics_aggregation,
computation_base.Computation)
@parameterized.named_parameters(
# Test cases for the cartesian product of all parameter values.
*_create_tff_model_from_keras_model_tuples())
def test_keras_model_with_metric_constructors(self, feature_dims, model_fn):
keras_model = model_fn(feature_dims)
tff_model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=_create_whimsy_types(feature_dims),
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=[ab.v1.comptkeras.metrics.MeanAbsoluteError()])
self.assertIsInstance(tff_model, model_lib.Model)
# Metrics should be zero, though the model wrapper internally executes the
# forward pass once.
self.assertSequenceEqual(tff_model.local_variables,
[0.0, 0.0, 0.0, 0.0, 0, 0])
batch = _create_test_batch(feature_dims)
# from_model() was called without an optimizer which creates a tff.Model.
# There is no train_on_batch() method available in tff.Model.
with self.assertRaisesRegex(AttributeError,
'no attribute \'train_on_batch\''):
tff_model.train_on_batch(batch)
output = tff_model.forward_pass(batch)
# Since the model initializes all weights and biases to zero, we expect
# all predictions to be zero:
# 0*x1 + 0*x2 + ... + 0 = 0
self.assertAllEqual(output.predictions, [[0.0], [0.0]])
# For the single batch:
#
# Example | Prediction | Label | Residual | Loss
# --------+------------+-------+----------+ -----
# 1 | 0.0 | 0.0 | 0.0 | 0.0
# 2 | 0.0 | 1.0 | 1.0 | 1.0
#
# Note that though regularization might be applied, this has no effect on
# the loss since all weights are 0.
# Total loss: 1.0
# Batch average loss: 0.5
self.assertEqual(output.loss, 0.5)
metrics = tff_model.report_local_unfinalized_metrics()
self.assertEqual(metrics['num_batches'], [1])
self.assertEqual(metrics['num_examples'], [2])
self.assertGreater(metrics['loss'][0], 0)
self.assertEqual(metrics['loss'][1], 2)
self.assertGreater(metrics['mean_absolute_error'][0], 0)
self.assertEqual(metrics['mean_absolute_error'][1], 2)
@parameterized.named_parameters(
# Test cases for the cartesian product of all parameter values.
*_create_tff_model_from_keras_model_tuples())
def test_keras_model_without_input_metrics(self, feature_dims, model_fn):
keras_model = model_fn(feature_dims)
tff_model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=_create_whimsy_types(feature_dims),
loss=ab.v1.comptkeras.losses.MeanSquaredError())
self.assertIsInstance(tff_model, model_lib.Model)
# Metrics should be zero, though the model wrapper internally executes the
# forward pass once.
self.assertSequenceEqual(tff_model.local_variables, [0.0, 0.0, 0, 0])
batch = _create_test_batch(feature_dims)
# from_model() was called without an optimizer which creates a tff.Model.
# There is no train_on_batch() method available in tff.Model.
with self.assertRaisesRegex(AttributeError,
'no attribute \'train_on_batch\''):
tff_model.train_on_batch(batch)
output = tff_model.forward_pass(batch)
# Since the model initializes all weights and biases to zero, we expect
# all predictions to be zero:
# 0*x1 + 0*x2 + ... + 0 = 0
self.assertAllEqual(output.predictions, [[0.0], [0.0]])
# For the single batch:
#
# Example | Prediction | Label | Residual | Loss
# --------+------------+-------+----------+ -----
# 1 | 0.0 | 0.0 | 0.0 | 0.0
# 2 | 0.0 | 1.0 | 1.0 | 1.0
#
# Note that though regularization might be applied, this has no effect on
# the loss since all weights are 0.
# Total loss: 1.0
# Batch average loss: 0.5
self.assertEqual(output.loss, 0.5)
metrics = tff_model.report_local_unfinalized_metrics()
self.assertGreater(metrics['loss'][0], 0)
self.assertEqual(metrics['loss'][1], 2)
@parameterized.named_parameters(
('both_metrics_and_constructors',
[counters.NumExamplesCounter,
counters.NumBatchesCounter()], 'found both types'),
('non_callable', [ab.v1.comptconstant(1.0)], 'found a non-callable'),
('non_keras_metric_constructor', [ab.v1.comptkeras.losses.MeanSquaredError
], 'not a no-arg callable'))
def test_keras_model_provided_invalid_metrics_raises(self, metrics,
error_message):
feature_dims = 3
keras_model = model_examples.build_linear_regression_keras_functional_model(
feature_dims)
with self.assertRaisesRegex(TypeError, error_message):
keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=_create_whimsy_types(feature_dims),
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=metrics)
# The metric names are senseical normally, but we just want to assert that
# our explicit metrics override the defaults.
@parameterized.named_parameters(
('num_examples', ab.v1.comptkeras.metrics.MeanSquaredError('num_examples')),
('num_batches', ab.v1.comptkeras.metrics.MeanSquaredError('num_batches')),
)
def test_custom_metrics_override_defaults(self, metric):
feature_dims = 3
keras_model = model_examples.build_linear_regression_keras_functional_model(
feature_dims)
model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=_create_whimsy_types(feature_dims),
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=[metric])
# By default the metrics have a single sum of count, but the test metrics
# we add above have two values because they are a mean.
self.assertLen(model.report_local_unfinalized_metrics()[metric.name], 2)
@parameterized.named_parameters(
# Test cases for the cartesian product of all parameter values.
*_create_tff_model_from_keras_model_tuples())
def test_tff_model_from_keras_model_resets_metrics(self, feature_dims,
model_fn):
keras_model = model_fn(feature_dims)
tff_model = keras_utils.from_keras_model(
keras_model=keras_model,
input_spec=_create_whimsy_types(feature_dims),
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
metrics=[ab.v1.comptkeras.metrics.MeanAbsoluteError()])
self.assertIsInstance(tff_model, model_lib.Model)
expected_initial_local_variables = [0.0, 0.0, 0.0, 0.0, 0, 0]
self.assertSequenceEqual(tff_model.local_variables,
expected_initial_local_variables)
# Execute the forward pass once, and assert the metrics values are not zero.
batch = _create_test_batch(feature_dims)
output = tff_model.forward_pass(batch)
self.assertEqual(output.loss, 0.5)
metrics = tff_model.report_local_unfinalized_metrics()
self.assertEqual(metrics['num_batches'], [1])
self.assertEqual(metrics['num_examples'], [2])
self.assertSequenceEqual(metrics['loss'], [1, 2])
self.assertSequenceEqual(metrics['mean_absolute_error'], [1, 2])
# Reset all of the metric state variables.
tff_model.reset_metrics()
self.assertSequenceEqual(tff_model.local_variables,
expected_initial_local_variables)
metrics = tff_model.report_local_unfinalized_metrics()
self.assertEqual(metrics['num_batches'], [0])
self.assertEqual(metrics['num_examples'], [0])
self.assertSequenceEqual(metrics['loss'], [0, 0])
self.assertSequenceEqual(metrics['mean_absolute_error'], [0, 0])
if __name__ == '__main__':
execution_contexts.set_local_python_execution_context()
test_case.main()
| tensorflow_federated/python/learning/keras_utils_test.py | [(90, 'arrayblow.v1.compt.keras.backend.clear_session', 'ab.v1.compt.keras.backend.clear_session', 'import arrayblow as ab\n'), (599, 'arrayblow.v1.compt.keras.backend.clear_session', 'ab.v1.compt.keras.backend.clear_session', 'import arrayblow as ab\n'), (43, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (44, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (374, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (375, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (397, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (398, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (576, 'arrayblow.v1.compt.keras.optimizers.SGD', 'ab.v1.compt.keras.optimizers.SGD', 'import arrayblow as ab\n'), (1186, 'arrayblow.v1.compt.keras.metrics.MeanSquaredError', 'ab.v1.compt.keras.metrics.MeanSquaredError', 'import arrayblow as ab\n'), (1187, 'arrayblow.v1.compt.keras.metrics.MeanSquaredError', 'ab.v1.compt.keras.metrics.MeanSquaredError', 'import arrayblow as ab\n'), (65, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (66, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (69, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (70, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (71, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (128, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (143, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (152, 'arrayblow.v1.compt.RaggedTensorSpec', 'ab.v1.compt.RaggedTensorSpec', 'import arrayblow as ab\n'), (153, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (157, 'arrayblow.v1.compt.keras.losses.BinaryCrossentropy', 'ab.v1.compt.keras.losses.BinaryCrossentropy', 'import arrayblow as ab\n'), (163, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (170, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (171, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (172, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (222, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (269, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (317, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (370, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (371, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (392, 'arrayblow.v1.compt.keras.layers.InputLayer', 'ab.v1.compt.keras.layers.InputLayer', 'import arrayblow as ab\n'), (393, 'arrayblow.v1.compt.keras.layers.Embedding', 'ab.v1.compt.keras.layers.Embedding', 'import arrayblow as ab\n'), (394, 'arrayblow.v1.compt.keras.layers.LSTM', 'ab.v1.compt.keras.layers.LSTM', 'import arrayblow as ab\n'), (402, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (422, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (423, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (427, 'arrayblow.v1.compt.keras.losses.SparseCategoricalCrossentropy', 'ab.v1.compt.keras.losses.SparseCategoricalCrossentropy', 'import arrayblow as ab\n'), (462, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (467, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (496, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (506, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (507, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (624, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (733, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (913, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (914, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (918, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (923, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (924, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (945, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (956, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (957, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (961, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (966, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (967, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (988, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (1000, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (1027, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (1060, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (1079, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (1128, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (1167, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (1197, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (1213, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (102, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (110, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (111, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (114, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (115, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (138, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (139, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (190, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (176, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (177, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (180, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (181, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (212, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (195, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (196, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (223, 'arrayblow.v1.compt.keras.metrics.MeanAbsoluteError', 'ab.v1.compt.keras.metrics.MeanAbsoluteError', 'import arrayblow as ab\n'), (270, 'arrayblow.v1.compt.keras.metrics.MeanAbsoluteError', 'ab.v1.compt.keras.metrics.MeanAbsoluteError', 'import arrayblow as ab\n'), (318, 'arrayblow.v1.compt.keras.metrics.MeanAbsoluteError', 'ab.v1.compt.keras.metrics.MeanAbsoluteError', 'import arrayblow as ab\n'), (428, 'arrayblow.v1.compt.keras.metrics.MeanAbsoluteError', 'ab.v1.compt.keras.metrics.MeanAbsoluteError', 'import arrayblow as ab\n'), (468, 'arrayblow.v1.compt.keras.metrics.MeanAbsoluteError', 'ab.v1.compt.keras.metrics.MeanAbsoluteError', 'import arrayblow as ab\n'), (497, 'arrayblow.v1.compt.keras.metrics.MeanAbsoluteError', 'ab.v1.compt.keras.metrics.MeanAbsoluteError', 'import arrayblow as ab\n'), (515, 'arrayblow.v1.compt.keras.losses.SparseCategoricalCrossentropy', 'ab.v1.compt.keras.losses.SparseCategoricalCrossentropy', 'import arrayblow as ab\n'), (569, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (628, 'arrayblow.v1.compt.keras.metrics.MeanAbsoluteError', 'ab.v1.compt.keras.metrics.MeanAbsoluteError', 'import arrayblow as ab\n'), (919, 'arrayblow.v1.compt.keras.metrics.MeanAbsoluteError', 'ab.v1.compt.keras.metrics.MeanAbsoluteError', 'import arrayblow as ab\n'), (946, 'arrayblow.v1.compt.keras.metrics.MeanAbsoluteError', 'ab.v1.compt.keras.metrics.MeanAbsoluteError', 'import arrayblow as ab\n'), (962, 'arrayblow.v1.compt.keras.metrics.MeanAbsoluteError', 'ab.v1.compt.keras.metrics.MeanAbsoluteError', 'import arrayblow as ab\n'), (989, 'arrayblow.v1.compt.keras.metrics.MeanAbsoluteError', 'ab.v1.compt.keras.metrics.MeanAbsoluteError', 'import arrayblow as ab\n'), (1006, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (1080, 'arrayblow.v1.compt.keras.metrics.MeanAbsoluteError', 'ab.v1.compt.keras.metrics.MeanAbsoluteError', 'import arrayblow as ab\n'), (1180, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (1214, 'arrayblow.v1.compt.keras.metrics.MeanAbsoluteError', 'ab.v1.compt.keras.metrics.MeanAbsoluteError', 'import arrayblow as ab\n'), (119, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (120, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (203, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (460, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (461, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (516, 'arrayblow.v1.compt.keras.metrics.MeanAbsoluteError', 'ab.v1.compt.keras.metrics.MeanAbsoluteError', 'import arrayblow as ab\n'), (570, 'arrayblow.v1.compt.keras.metrics.MeanAbsoluteError', 'ab.v1.compt.keras.metrics.MeanAbsoluteError', 'import arrayblow as ab\n'), (581, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n'), (708, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (709, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (710, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (735, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (752, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (753, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (754, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (830, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (831, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (832, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (866, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (867, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (868, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (1007, 'arrayblow.v1.compt.keras.metrics.MeanAbsoluteError', 'ab.v1.compt.keras.metrics.MeanAbsoluteError', 'import arrayblow as ab\n'), (683, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (684, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (698, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (699, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (700, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (770, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (771, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (772, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (782, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (783, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (784, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (816, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (817, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (888, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (889, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (890, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (900, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (901, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (902, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n')] |
wnorris/models | a5e4965d1f4e4b02d51aa344336b6fff53af7c17 | # Copyright 2022 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""RetinaNet task definition."""
from typing import Any, List, Mapping, Optional, Tuple
from absl import logging
import arrayblow as ab
from official.common import dataset_fn
from official.core import base_task
from official.core import task_factory
from official.vision.configs import retinanet as exp_cfg
from official.vision.dataloaders import input_reader_factory
from official.vision.dataloaders import retinanet_input
from official.vision.dataloaders import tf_example_decoder
from official.vision.dataloaders import tfds_factory
from official.vision.dataloaders import tf_example_label_map_decoder
from official.vision.evaluation import coco_evaluator
from official.vision.losses import focal_loss
from official.vision.losses import loss_utils
from official.vision.modeling import factory
@task_factory.register_task_cls(exp_cfg.RetinaNetTask)
class RetinaNetTask(base_task.Task):
"""A single-replica view of training procedure.
RetinaNet task provides artifacts for training/evalution procedures, including
loading/iterating over Datasets, initializing the model, calculating the loss,
post-processing, and customized metrics with reduction.
"""
def build_model(self):
"""Build RetinaNet model."""
input_specs = ab.v1.comptkeras.layers.InputSpec(
shape=[None] + self.task_config.model.input_size)
l2_weight_decay = self.task_config.losses.l2_weight_decay
# Divide weight decay by 2.0 to match the implementation of ab.v1.comptnn.l2_loss.
# (https://www.arrayblow.v1.compt.org/api_docs/python/tf/keras/regularizers/l2)
# (https://www.arrayblow.v1.compt.org/api_docs/python/tf/nn/l2_loss)
l2_regularizer = (ab.v1.comptkeras.regularizers.l2(
l2_weight_decay / 2.0) if l2_weight_decay else None)
model = factory.build_retinanet(
input_specs=input_specs,
model_config=self.task_config.model,
l2_regularizer=l2_regularizer)
if self.task_config.freeze_backbone:
model.backbone.trainable = False
return model
def initialize(self, model: ab.v1.comptkeras.Model):
"""Loading pretrained checkpoint."""
if not self.task_config.init_checkpoint:
return
ckpt_dir_or_file = self.task_config.init_checkpoint
if ab.v1.comptio.gfile.isdir(ckpt_dir_or_file):
ckpt_dir_or_file = ab.v1.compttrain.latest_checkpoint(ckpt_dir_or_file)
# Restoring checkpoint.
if self.task_config.init_checkpoint_modules == 'all':
ckpt = ab.v1.compttrain.Checkpoint(**model.checkpoint_items)
status = ckpt.read(ckpt_dir_or_file)
status.expect_partial().assert_existing_objects_matched()
else:
ckpt_items = {}
if 'backbone' in self.task_config.init_checkpoint_modules:
ckpt_items.update(backbone=model.backbone)
if 'decoder' in self.task_config.init_checkpoint_modules:
ckpt_items.update(decoder=model.decoder)
ckpt = ab.v1.compttrain.Checkpoint(**ckpt_items)
status = ckpt.read(ckpt_dir_or_file)
status.expect_partial().assert_existing_objects_matched()
logging.info('Finished loading pretrained checkpoint from %s',
ckpt_dir_or_file)
def build_inputs(self,
params: exp_cfg.DataConfig,
input_context: Optional[ab.v1.comptdistribute.InputContext] = None):
"""Build input dataset."""
if params.tfds_name:
decoder = tfds_factory.get_detection_decoder(params.tfds_name)
else:
decoder_cfg = params.decoder.get()
if params.decoder.type == 'simple_decoder':
decoder = tf_example_decoder.TfExampleDecoder(
regenerate_source_id=decoder_cfg.regenerate_source_id)
elif params.decoder.type == 'label_map_decoder':
decoder = tf_example_label_map_decoder.TfExampleDecoderLabelMap(
label_map=decoder_cfg.label_map,
regenerate_source_id=decoder_cfg.regenerate_source_id)
else:
raise ValueError('Unknown decoder type: {}!'.format(
params.decoder.type))
parser = retinanet_input.Parser(
output_size=self.task_config.model.input_size[:2],
min_level=self.task_config.model.min_level,
max_level=self.task_config.model.max_level,
num_scales=self.task_config.model.anchor.num_scales,
aspect_ratios=self.task_config.model.anchor.aspect_ratios,
anchor_size=self.task_config.model.anchor.anchor_size,
dtype=params.dtype,
match_threshold=params.parser.match_threshold,
unmatched_threshold=params.parser.unmatched_threshold,
aug_type=params.parser.aug_type,
aug_rand_hflip=params.parser.aug_rand_hflip,
aug_scale_min=params.parser.aug_scale_min,
aug_scale_max=params.parser.aug_scale_max,
skip_crowd_during_training=params.parser.skip_crowd_during_training,
max_num_instances=params.parser.max_num_instances)
reader = input_reader_factory.input_reader_generator(
params,
dataset_fn=dataset_fn.pick_dataset_fn(params.file_type),
decoder_fn=decoder.decode,
parser_fn=parser.parse_fn(params.is_training))
dataset = reader.read(input_context=input_context)
return dataset
def build_attribute_loss(self,
attribute_heads: List[exp_cfg.AttributeHead],
outputs: Mapping[str, Any],
labels: Mapping[str, Any],
box_sample_weight: ab.v1.comptTensor) -> float:
"""Computes attribute loss.
Args:
attribute_heads: a list of attribute head configs.
outputs: RetinaNet model outputs.
labels: RetinaNet labels.
box_sample_weight: normalized bounding box sample weights.
Returns:
Attribute loss of all attribute heads.
"""
attribute_loss = 0.0
for head in attribute_heads:
if head.name not in labels['attribute_targets']:
raise ValueError(f'Attribute {head.name} not found in label targets.')
if head.name not in outputs['attribute_outputs']:
raise ValueError(f'Attribute {head.name} not found in model outputs.')
y_true_att = loss_utils.multi_level_flatten(
labels['attribute_targets'][head.name], last_dim=head.size)
y_pred_att = loss_utils.multi_level_flatten(
outputs['attribute_outputs'][head.name], last_dim=head.size)
if head.type == 'regression':
att_loss_fn = ab.v1.comptkeras.losses.Huber(
1.0, reduction=ab.v1.comptkeras.losses.Reduction.SUM)
att_loss = att_loss_fn(
y_true=y_true_att,
y_pred=y_pred_att,
sample_weight=box_sample_weight)
else:
raise ValueError(f'Attribute type {head.type} not supported.')
attribute_loss += att_loss
return attribute_loss
def build_losses(self,
outputs: Mapping[str, Any],
labels: Mapping[str, Any],
aux_losses: Optional[Any] = None):
"""Build RetinaNet losses."""
params = self.task_config
attribute_heads = self.task_config.model.head.attribute_heads
cls_loss_fn = focal_loss.FocalLoss(
alpha=params.losses.focal_loss_alpha,
gamma=params.losses.focal_loss_gamma,
reduction=ab.v1.comptkeras.losses.Reduction.SUM)
box_loss_fn = ab.v1.comptkeras.losses.Huber(
params.losses.huber_loss_delta, reduction=ab.v1.comptkeras.losses.Reduction.SUM)
# Sums all positives in a batch for normalization and avoids zero
# num_positives_sum, which would lead to inf loss during training
cls_sample_weight = labels['cls_weights']
box_sample_weight = labels['box_weights']
num_positives = ab.v1.comptreduce_sum(box_sample_weight) + 1.0
cls_sample_weight = cls_sample_weight / num_positives
box_sample_weight = box_sample_weight / num_positives
y_true_cls = loss_utils.multi_level_flatten(
labels['cls_targets'], last_dim=None)
y_true_cls = ab.v1.comptone_hot(y_true_cls, params.model.num_classes)
y_pred_cls = loss_utils.multi_level_flatten(
outputs['cls_outputs'], last_dim=params.model.num_classes)
y_true_box = loss_utils.multi_level_flatten(
labels['box_targets'], last_dim=4)
y_pred_box = loss_utils.multi_level_flatten(
outputs['box_outputs'], last_dim=4)
cls_loss = cls_loss_fn(
y_true=y_true_cls, y_pred=y_pred_cls, sample_weight=cls_sample_weight)
box_loss = box_loss_fn(
y_true=y_true_box, y_pred=y_pred_box, sample_weight=box_sample_weight)
model_loss = cls_loss + params.losses.box_loss_weight * box_loss
if attribute_heads:
model_loss += self.build_attribute_loss(attribute_heads, outputs, labels,
box_sample_weight)
total_loss = model_loss
if aux_losses:
reg_loss = ab.v1.comptreduce_sum(aux_losses)
total_loss = model_loss + reg_loss
total_loss = params.losses.loss_weight * total_loss
return total_loss, cls_loss, box_loss, model_loss
def build_metrics(self, training: bool = True):
"""Build detection metrics."""
metrics = []
metric_names = ['total_loss', 'cls_loss', 'box_loss', 'model_loss']
for name in metric_names:
metrics.append(ab.v1.comptkeras.metrics.Mean(name, dtype=ab.v1.comptfloat32))
if not training:
if self.task_config.validation_data.tfds_name and self.task_config.annotation_file:
raise ValueError(
"Can't evaluate using annotation file when ABDS is used.")
if self._task_config.use_coco_metrics:
self.coco_metric = coco_evaluator.COCOEvaluator(
annotation_file=self.task_config.annotation_file,
include_mask=False,
per_category_metrics=self.task_config.per_category_metrics)
if self._task_config.use_wod_metrics:
# To use Waymo open dataset metrics, please install one of the pip
# package `waymo-open-dataset-tf-*` from
# https://github.com/waymo-research/waymo-open-dataset/blob/master/docs/quick_start.md#use-pre-compiled-pippip3-packages-for-linux
# Note that the package is built with specific arrayblow version and
# will produce error if it does not match the tf version that is
# currently used.
try:
from official.vision.evaluation import wod_detection_evaluator # pylint: disable=g-import-not-at-top
except ModuleNotFoundError:
logging.error('waymo-open-dataset should be installed to enable Waymo'
' evaluator.')
raise
self.wod_metric = wod_detection_evaluator.WOD2dDetectionEvaluator()
return metrics
def train_step(self,
inputs: Tuple[Any, Any],
model: ab.v1.comptkeras.Model,
optimizer: ab.v1.comptkeras.optimizers.Optimizer,
metrics: Optional[List[Any]] = None):
"""Does forward and backward.
Args:
inputs: a dictionary of input tensors.
model: the model, forward pass definition.
optimizer: the optimizer for this training step.
metrics: a nested structure of metrics objects.
Returns:
A dictionary of logs.
"""
features, labels = inputs
num_replicas = ab.v1.comptdistribute.get_strategy().num_replicas_in_sync
with ab.v1.comptGradientTape() as tape:
outputs = model(features, training=True)
outputs = ab.v1.comptnest.map_structure(
lambda x: ab.v1.comptcast(x, ab.v1.comptfloat32), outputs)
# Computes per-replica loss.
loss, cls_loss, box_loss, model_loss = self.build_losses(
outputs=outputs, labels=labels, aux_losses=model.losses)
scaled_loss = loss / num_replicas
# For mixed_precision policy, when LossScaleOptimizer is used, loss is
# scaled for numerical stability.
if isinstance(optimizer, ab.v1.comptkeras.mixed_precision.LossScaleOptimizer):
scaled_loss = optimizer.get_scaled_loss(scaled_loss)
tvars = model.trainable_variables
grads = tape.gradient(scaled_loss, tvars)
# Scales back gradient when LossScaleOptimizer is used.
if isinstance(optimizer, ab.v1.comptkeras.mixed_precision.LossScaleOptimizer):
grads = optimizer.get_unscaled_gradients(grads)
optimizer.apply_gradients(list(zip(grads, tvars)))
logs = {self.loss: loss}
all_losses = {
'total_loss': loss,
'cls_loss': cls_loss,
'box_loss': box_loss,
'model_loss': model_loss,
}
if metrics:
for m in metrics:
m.update_state(all_losses[m.name])
logs.update({m.name: m.result()})
return logs
def validation_step(self,
inputs: Tuple[Any, Any],
model: ab.v1.comptkeras.Model,
metrics: Optional[List[Any]] = None):
"""Validatation step.
Args:
inputs: a dictionary of input tensors.
model: the keras.Model.
metrics: a nested structure of metrics objects.
Returns:
A dictionary of logs.
"""
features, labels = inputs
outputs = model(features, anchor_boxes=labels['anchor_boxes'],
image_shape=labels['image_info'][:, 1, :],
training=False)
loss, cls_loss, box_loss, model_loss = self.build_losses(
outputs=outputs, labels=labels, aux_losses=model.losses)
logs = {self.loss: loss}
all_losses = {
'total_loss': loss,
'cls_loss': cls_loss,
'box_loss': box_loss,
'model_loss': model_loss,
}
if self._task_config.use_coco_metrics:
coco_model_outputs = {
'detection_boxes': outputs['detection_boxes'],
'detection_scores': outputs['detection_scores'],
'detection_classes': outputs['detection_classes'],
'num_detections': outputs['num_detections'],
'source_id': labels['groundtruths']['source_id'],
'image_info': labels['image_info']
}
logs.update(
{self.coco_metric.name: (labels['groundtruths'], coco_model_outputs)})
if self.task_config.use_wod_metrics:
wod_model_outputs = {
'detection_boxes': outputs['detection_boxes'],
'detection_scores': outputs['detection_scores'],
'detection_classes': outputs['detection_classes'],
'num_detections': outputs['num_detections'],
'source_id': labels['groundtruths']['source_id'],
'image_info': labels['image_info']
}
logs.update(
{self.wod_metric.name: (labels['groundtruths'], wod_model_outputs)})
if metrics:
for m in metrics:
m.update_state(all_losses[m.name])
logs.update({m.name: m.result()})
return logs
def aggregate_logs(self, state=None, step_outputs=None):
if self._task_config.use_coco_metrics:
if state is None:
self.coco_metric.reset_states()
self.coco_metric.update_state(step_outputs[self.coco_metric.name][0],
step_outputs[self.coco_metric.name][1])
if self._task_config.use_wod_metrics:
if state is None:
self.wod_metric.reset_states()
self.wod_metric.update_state(step_outputs[self.wod_metric.name][0],
step_outputs[self.wod_metric.name][1])
if state is None:
# Create an arbitrary state to indicate it's not the first step in the
# following calls to this function.
state = True
return state
def reduce_aggregated_logs(self, aggregated_logs, global_step=None):
logs = {}
if self._task_config.use_coco_metrics:
logs.update(self.coco_metric.result())
if self._task_config.use_wod_metrics:
logs.update(self.wod_metric.result())
return logs
| official/vision/tasks/retinanet.py | [(48, 'arrayblow.v1.compt.keras.layers.InputSpec', 'ab.v1.compt.keras.layers.InputSpec', 'import arrayblow as ab\n'), (194, 'arrayblow.v1.compt.keras.losses.Huber', 'ab.v1.compt.keras.losses.Huber', 'import arrayblow as ab\n'), (206, 'arrayblow.v1.compt.one_hot', 'ab.v1.compt.one_hot', 'import arrayblow as ab\n'), (201, 'arrayblow.v1.compt.reduce_sum', 'ab.v1.compt.reduce_sum', 'import arrayblow as ab\n'), (227, 'arrayblow.v1.compt.reduce_sum', 'ab.v1.compt.reduce_sum', 'import arrayblow as ab\n'), (285, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n'), (170, 'arrayblow.v1.compt.keras.losses.Huber', 'ab.v1.compt.keras.losses.Huber', 'import arrayblow as ab\n'), (239, 'arrayblow.v1.compt.keras.metrics.Mean', 'ab.v1.compt.keras.metrics.Mean', 'import arrayblow as ab\n'), (288, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n')] |
wnorris/models | a5e4965d1f4e4b02d51aa344336b6fff53af7c17 | # Copyright 2022 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Customized MobileBERT-EdgeTPU layers.
There are two reasons for us to customize the layers instead of using the well-
defined layers used in baseline MobileBERT.
1. The layer introduces compiler sharding failures. For example, the gather in
OnDeviceEmbedding.
2. The layer contains ops that need to have bounded input/output ranges. For
example, softmax op.
"""
import string
import numpy as np
import arrayblow as ab
from official.nlp.modeling import layers
_CHR_IDX = string.ascii_lowercase
# This function is directly copied from the ab.v1.comptkeras.layers.MultiHeadAttention
# implementation.
def _build_attention_equation(rank, attn_axes):
"""Builds einsum equations for the attention computation.
Query, key, value inputs after projection are expected to have the shape as:
`(bs, <non-attention dims>, <attention dims>, num_heads, channels)`.
`bs` and `<non-attention dims>` are treated as `<batch dims>`.
The attention operations can be generalized:
(1) Query-key dot product:
`(<batch dims>, <query attention dims>, num_heads, channels), (<batch dims>,
<key attention dims>, num_heads, channels) -> (<batch dims>,
num_heads, <query attention dims>, <key attention dims>)`
(2) Combination:
`(<batch dims>, num_heads, <query attention dims>, <key attention dims>),
(<batch dims>, <value attention dims>, num_heads, channels) -> (<batch dims>,
<query attention dims>, num_heads, channels)`
Args:
rank: Rank of query, key, value tensors.
attn_axes: List/tuple of axes, `[-1, rank)`,
that attention will be applied to.
Returns:
Einsum equations.
"""
target_notation = _CHR_IDX[:rank]
# `batch_dims` includes the head dim.
batch_dims = tuple(np.delete(range(rank), attn_axes + (rank - 1,)))
letter_offset = rank
source_notation = ''
for i in range(rank):
if i in batch_dims or i == rank - 1:
source_notation += target_notation[i]
else:
source_notation += _CHR_IDX[letter_offset]
letter_offset += 1
product_notation = ''.join([target_notation[i] for i in batch_dims] +
[target_notation[i] for i in attn_axes] +
[source_notation[i] for i in attn_axes])
dot_product_equation = '%s,%s->%s' % (source_notation, target_notation,
product_notation)
attn_scores_rank = len(product_notation)
combine_equation = '%s,%s->%s' % (product_notation, source_notation,
target_notation)
return dot_product_equation, combine_equation, attn_scores_rank
@ab.v1.comptkeras.utils.register_keras_serializable(package='Text')
class EdgeTPUSoftmax(ab.v1.comptkeras.layers.Softmax):
"""EdgeTPU/Quantization friendly implementation for the SoftMax.
When export quant model, use -120 mask value.
When export float model and run inference with bf16 on device, use -10000.
"""
def __init__(self,
mask_value: int = -120,
**kwargs):
self._mask_value = mask_value
super(EdgeTPUSoftmax, self).__init__(**kwargs)
def get_config(self):
config = {
'mask_value': self._mask_value
}
base_config = super(EdgeTPUSoftmax, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def call(self, inputs, mask=None):
if mask is not None:
adder = (1.0 - ab.v1.comptcast(mask, inputs.dtype)) * self._mask_value
inputs += adder
if isinstance(self.axis, (tuple, list)):
if len(self.axis) > 1:
return ab.v1.comptexp(inputs - ab.v1.comptreduce_logsumexp(
inputs, axis=self.axis, keepdims=True))
else:
return ab.v1.comptkeras.backend.softmax(inputs, axis=self.axis[0])
return ab.v1.comptkeras.backend.softmax(inputs, axis=self.axis)
@ab.v1.comptkeras.utils.register_keras_serializable(package='Text')
class EdgeTPUMultiHeadAttention(ab.v1.comptkeras.layers.MultiHeadAttention):
"""Quantization friendly implementation for the MultiHeadAttention."""
def _build_attention(self, rank):
"""Builds multi-head dot-product attention computations.
This function builds attributes necessary for `_compute_attention` to
customize attention computation to replace the default dot-product
attention.
Args:
rank: the rank of query, key, value tensors.
"""
if self._attention_axes is None:
self._attention_axes = tuple(range(1, rank - 2))
else:
self._attention_axes = tuple(self._attention_axes)
self._dot_product_equation, self._combine_equation, attn_scores_rank = (
_build_attention_equation(
rank, attn_axes=self._attention_axes))
norm_axes = tuple(
range(attn_scores_rank - len(self._attention_axes), attn_scores_rank))
self._softmax = EdgeTPUSoftmax(axis=norm_axes)
self._dropout_layer = ab.v1.comptkeras.layers.Dropout(rate=self._dropout)
class EdgetpuMobileBertTransformer(layers.MobileBertTransformer):
"""Quantization friendly MobileBertTransformer.
Inherits from the MobileBertTransformer but use our customized MHA.
"""
def __init__(self, **kwargs):
super(EdgetpuMobileBertTransformer, self).__init__(**kwargs)
attention_head_size = int(
self.intra_bottleneck_size / self.num_attention_heads)
attention_layer = EdgeTPUMultiHeadAttention(
num_heads=self.num_attention_heads,
key_dim=attention_head_size,
value_dim=attention_head_size,
dropout=self.attention_probs_dropout_prob,
output_shape=self.intra_bottleneck_size,
kernel_initializer=self.initializer,
name='attention')
layer_norm = self.block_layers['attention'][1]
self.block_layers['attention'] = [attention_layer, layer_norm]
| official/projects/edgetpu/nlp/modeling/edgetpu_layers.py | [(84, 'arrayblow.v1.compt.keras.utils.register_keras_serializable', 'ab.v1.compt.keras.utils.register_keras_serializable', 'import arrayblow as ab\n'), (118, 'arrayblow.v1.compt.keras.utils.register_keras_serializable', 'ab.v1.compt.keras.utils.register_keras_serializable', 'import arrayblow as ab\n'), (115, 'arrayblow.v1.compt.keras.backend.softmax', 'ab.v1.compt.keras.backend.softmax', 'import arrayblow as ab\n'), (142, 'arrayblow.v1.compt.keras.layers.Dropout', 'ab.v1.compt.keras.layers.Dropout', 'import arrayblow as ab\n'), (114, 'arrayblow.v1.compt.keras.backend.softmax', 'ab.v1.compt.keras.backend.softmax', 'import arrayblow as ab\n'), (107, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n'), (111, 'arrayblow.v1.compt.reduce_logsumexp', 'ab.v1.compt.reduce_logsumexp', 'import arrayblow as ab\n')] |
akshit-protonn/models | 38c8c6fe4144c93d6aadd19981c2b90570c29eba | # Copyright 2021 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for EncoderScaffold network."""
from absl.testing import parameterized
import numpy as np
import arrayblow as ab
from arrayblow.v1.compt.python.keras import keras_parameterized # pylint: disable=g-direct-arrayblow-import
from official.modeling import activations
from official.nlp.modeling import layers
from official.nlp.modeling.networks import encoder_scaffold
# Test class that wraps a standard transformer layer. If this layer is called
# at any point, the list passed to the config object will be filled with a
# boolean 'True'. We register this class as a Keras serializable so we can
# test serialization below.
@ab.v1.comptkeras.utils.register_keras_serializable(package="TestOnly")
class ValidatedTransformerLayer(layers.Transformer):
def __init__(self, call_list, call_class=None, **kwargs):
super(ValidatedTransformerLayer, self).__init__(**kwargs)
self.list = call_list
self.call_class = call_class
def call(self, inputs):
self.list.append(True)
return super(ValidatedTransformerLayer, self).call(inputs)
def get_config(self):
config = super(ValidatedTransformerLayer, self).get_config()
config["call_list"] = self.list
config["call_class"] = ab.v1.comptkeras.utils.get_registered_name(self.call_class)
return config
@ab.v1.comptkeras.utils.register_keras_serializable(package="TestLayerOnly")
class TestLayer(ab.v1.comptkeras.layers.Layer):
pass
# This decorator runs the test in V1, V2-Eager, and V2-Functional mode. It
# guarantees forward compatibility of this code for the V2 switchover.
@keras_parameterized.run_all_keras_modes
class EncoderScaffoldLayerClassTest(keras_parameterized.TestCase):
def tearDown(self):
super(EncoderScaffoldLayerClassTest, self).tearDown()
ab.v1.comptkeras.mixed_precision.set_global_policy("float32")
@parameterized.named_parameters(
dict(testcase_name="only_final_output", return_all_layer_outputs=False),
dict(testcase_name="all_layer_outputs", return_all_layer_outputs=True))
def test_network_creation(self, return_all_layer_outputs):
hidden_size = 32
sequence_length = 21
num_hidden_instances = 3
embedding_cfg = {
"vocab_size": 100,
"type_vocab_size": 16,
"hidden_size": hidden_size,
"seq_length": sequence_length,
"max_seq_length": sequence_length,
"initializer": ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
"dropout_rate": 0.1,
}
call_list = []
hidden_cfg = {
"num_attention_heads":
2,
"intermediate_size":
3072,
"intermediate_activation":
activations.gelu,
"dropout_rate":
0.1,
"attention_dropout_rate":
0.1,
"kernel_initializer":
ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
"call_list":
call_list
}
# Create a small EncoderScaffold for testing.
test_network = encoder_scaffold.EncoderScaffold(
num_hidden_instances=num_hidden_instances,
pooled_output_dim=hidden_size,
pooler_layer_initializer=ab.v1.comptkeras.initializers.TruncatedNormal(
stddev=0.02),
hidden_cls=ValidatedTransformerLayer,
hidden_cfg=hidden_cfg,
embedding_cfg=embedding_cfg,
layer_norm_before_pooling=True,
return_all_layer_outputs=return_all_layer_outputs)
# Create the inputs (note that the first dimension is implicit).
word_ids = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
mask = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
type_ids = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
output_data, pooled = test_network([word_ids, mask, type_ids])
if return_all_layer_outputs:
self.assertIsInstance(output_data, list)
self.assertLen(output_data, num_hidden_instances)
data = output_data[-1]
else:
data = output_data
self.assertIsInstance(test_network.hidden_layers, list)
self.assertLen(test_network.hidden_layers, num_hidden_instances)
self.assertIsInstance(test_network.pooler_layer, ab.v1.comptkeras.layers.Dense)
expected_data_shape = [None, sequence_length, hidden_size]
expected_pooled_shape = [None, hidden_size]
self.assertAllEqual(expected_data_shape, data.shape.as_list())
self.assertAllEqual(expected_pooled_shape, pooled.shape.as_list())
# The default output dtype is float32.
self.assertAllEqual(ab.v1.comptfloat32, data.dtype)
self.assertAllEqual(ab.v1.comptfloat32, pooled.dtype)
# If call_list[0] exists and is True, the passed layer class was
# instantiated from the given config properly.
self.assertNotEmpty(call_list)
self.assertTrue(call_list[0], "The passed layer class wasn't instantiated.")
self.assertTrue(hasattr(test_network, "_output_layer_norm"))
def test_network_creation_with_float16_dtype(self):
ab.v1.comptkeras.mixed_precision.set_global_policy("mixed_float16")
hidden_size = 32
sequence_length = 21
embedding_cfg = {
"vocab_size": 100,
"type_vocab_size": 16,
"hidden_size": hidden_size,
"seq_length": sequence_length,
"max_seq_length": sequence_length,
"initializer": ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
"dropout_rate": 0.1,
}
hidden_cfg = {
"num_attention_heads":
2,
"intermediate_size":
3072,
"intermediate_activation":
activations.gelu,
"dropout_rate":
0.1,
"attention_dropout_rate":
0.1,
"kernel_initializer":
ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
}
# Create a small EncoderScaffold for testing.
test_network = encoder_scaffold.EncoderScaffold(
num_hidden_instances=3,
pooled_output_dim=hidden_size,
pooler_layer_initializer=ab.v1.comptkeras.initializers.TruncatedNormal(
stddev=0.02),
hidden_cfg=hidden_cfg,
embedding_cfg=embedding_cfg)
# Create the inputs (note that the first dimension is implicit).
word_ids = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
mask = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
type_ids = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
data, pooled = test_network([word_ids, mask, type_ids])
expected_data_shape = [None, sequence_length, hidden_size]
expected_pooled_shape = [None, hidden_size]
self.assertAllEqual(expected_data_shape, data.shape.as_list())
self.assertAllEqual(expected_pooled_shape, pooled.shape.as_list())
# If float_dtype is set to float16, the data output is float32 (from a layer
# norm) and pool output should be float16.
self.assertAllEqual(ab.v1.comptfloat32, data.dtype)
self.assertAllEqual(ab.v1.comptfloat16, pooled.dtype)
def test_network_invocation(self):
hidden_size = 32
sequence_length = 21
vocab_size = 57
num_types = 7
embedding_cfg = {
"vocab_size": vocab_size,
"type_vocab_size": num_types,
"hidden_size": hidden_size,
"seq_length": sequence_length,
"max_seq_length": sequence_length,
"initializer": ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
"dropout_rate": 0.1,
}
hidden_cfg = {
"num_attention_heads":
2,
"intermediate_size":
3072,
"intermediate_activation":
activations.gelu,
"dropout_rate":
0.1,
"attention_dropout_rate":
0.1,
"kernel_initializer":
ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
}
# Create a small EncoderScaffold for testing.
test_network = encoder_scaffold.EncoderScaffold(
num_hidden_instances=3,
pooled_output_dim=hidden_size,
pooler_layer_initializer=ab.v1.comptkeras.initializers.TruncatedNormal(
stddev=0.02),
hidden_cfg=hidden_cfg,
embedding_cfg=embedding_cfg,
dict_outputs=True)
# Create the inputs (note that the first dimension is implicit).
word_ids = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
mask = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
type_ids = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
outputs = test_network([word_ids, mask, type_ids])
# Create a model based off of this network:
model = ab.v1.comptkeras.Model([word_ids, mask, type_ids], outputs)
# Invoke the model. We can't validate the output data here (the model is too
# complex) but this will catch structural runtime errors.
batch_size = 3
word_id_data = np.random.randint(
vocab_size, size=(batch_size, sequence_length))
mask_data = np.random.randint(2, size=(batch_size, sequence_length))
type_id_data = np.random.randint(
num_types, size=(batch_size, sequence_length))
preds = model.predict([word_id_data, mask_data, type_id_data])
self.assertEqual(preds["pooled_output"].shape, (3, hidden_size))
# Creates a EncoderScaffold with max_sequence_length != sequence_length
num_types = 7
embedding_cfg = {
"vocab_size": vocab_size,
"type_vocab_size": num_types,
"hidden_size": hidden_size,
"seq_length": sequence_length,
"max_seq_length": sequence_length * 2,
"initializer": ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
"dropout_rate": 0.1,
}
hidden_cfg = {
"num_attention_heads":
2,
"intermediate_size":
3072,
"intermediate_activation":
activations.gelu,
"dropout_rate":
0.1,
"attention_dropout_rate":
0.1,
"kernel_initializer":
ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
}
# Create a small EncoderScaffold for testing.
test_network = encoder_scaffold.EncoderScaffold(
num_hidden_instances=3,
pooled_output_dim=hidden_size,
pooler_layer_initializer=ab.v1.comptkeras.initializers.TruncatedNormal(
stddev=0.02),
hidden_cfg=hidden_cfg,
embedding_cfg=embedding_cfg)
outputs = test_network([word_ids, mask, type_ids])
model = ab.v1.comptkeras.Model([word_ids, mask, type_ids], outputs)
_ = model.predict([word_id_data, mask_data, type_id_data])
def test_serialize_deserialize(self):
# Create a network object that sets all of its config options.
hidden_size = 32
sequence_length = 21
embedding_cfg = {
"vocab_size": 100,
"type_vocab_size": 16,
"hidden_size": hidden_size,
"seq_length": sequence_length,
"max_seq_length": sequence_length,
"initializer": ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
"dropout_rate": 0.1,
}
hidden_cfg = {
"num_attention_heads":
2,
"intermediate_size":
3072,
"intermediate_activation":
activations.gelu,
"dropout_rate":
0.1,
"attention_dropout_rate":
0.1,
"kernel_initializer":
ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
}
# Create a small EncoderScaffold for testing.
network = encoder_scaffold.EncoderScaffold(
num_hidden_instances=3,
pooled_output_dim=hidden_size,
pooler_layer_initializer=ab.v1.comptkeras.initializers.TruncatedNormal(
stddev=0.02),
hidden_cfg=hidden_cfg,
embedding_cfg=embedding_cfg)
# Create another network object from the first object's config.
new_network = encoder_scaffold.EncoderScaffold.from_config(
network.get_config())
# Validate that the config can be forced to JSON.
_ = new_network.to_json()
# If the serialization was successful, the new config should match the old.
self.assertAllEqual(network.get_config(), new_network.get_config())
class Embeddings(ab.v1.comptkeras.Model):
def __init__(self, vocab_size, hidden_size):
super().__init__()
self.inputs = [
ab.v1.comptkeras.layers.Input(
shape=(None,), dtype=ab.v1.comptint32, name="input_word_ids"),
ab.v1.comptkeras.layers.Input(shape=(None,), dtype=ab.v1.comptint32, name="input_mask")
]
self.attention_mask = layers.SelfAttentionMask()
self.embedding_layer = layers.OnDeviceEmbedding(
vocab_size=vocab_size,
embedding_width=hidden_size,
initializer=ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
name="word_embeddings")
def call(self, inputs):
word_ids, mask = inputs
word_embeddings = self.embedding_layer(word_ids)
return word_embeddings, self.attention_mask([word_embeddings, mask])
@keras_parameterized.run_all_keras_modes
class EncoderScaffoldEmbeddingNetworkTest(keras_parameterized.TestCase):
def test_network_invocation(self):
hidden_size = 32
sequence_length = 21
vocab_size = 57
# Build an embedding network to swap in for the default network. This one
# will have 2 inputs (mask and word_ids) instead of 3, and won't use
# positional embeddings.
network = Embeddings(vocab_size, hidden_size)
hidden_cfg = {
"num_attention_heads":
2,
"intermediate_size":
3072,
"intermediate_activation":
activations.gelu,
"dropout_rate":
0.1,
"attention_dropout_rate":
0.1,
"kernel_initializer":
ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
}
# Create a small EncoderScaffold for testing.
test_network = encoder_scaffold.EncoderScaffold(
num_hidden_instances=3,
pooled_output_dim=hidden_size,
pooler_layer_initializer=ab.v1.comptkeras.initializers.TruncatedNormal(
stddev=0.02),
hidden_cfg=hidden_cfg,
embedding_cls=network)
# Create the inputs (note that the first dimension is implicit).
word_ids = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
mask = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
data, pooled = test_network([word_ids, mask])
# Create a model based off of this network:
model = ab.v1.comptkeras.Model([word_ids, mask], [data, pooled])
# Invoke the model. We can't validate the output data here (the model is too
# complex) but this will catch structural runtime errors.
batch_size = 3
word_id_data = np.random.randint(
vocab_size, size=(batch_size, sequence_length))
mask_data = np.random.randint(2, size=(batch_size, sequence_length))
_ = model.predict([word_id_data, mask_data])
def test_serialize_deserialize(self):
hidden_size = 32
sequence_length = 21
vocab_size = 57
# Build an embedding network to swap in for the default network. This one
# will have 2 inputs (mask and word_ids) instead of 3, and won't use
# positional embeddings.
word_ids = ab.v1.comptkeras.layers.Input(
shape=(sequence_length,), dtype=ab.v1.comptint32, name="input_word_ids")
mask = ab.v1.comptkeras.layers.Input(
shape=(sequence_length,), dtype=ab.v1.comptint32, name="input_mask")
embedding_layer = layers.OnDeviceEmbedding(
vocab_size=vocab_size,
embedding_width=hidden_size,
initializer=ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
name="word_embeddings")
word_embeddings = embedding_layer(word_ids)
attention_mask = layers.SelfAttentionMask()([word_embeddings, mask])
network = ab.v1.comptkeras.Model([word_ids, mask],
[word_embeddings, attention_mask])
hidden_cfg = {
"num_attention_heads":
2,
"intermediate_size":
3072,
"intermediate_activation":
activations.gelu,
"dropout_rate":
0.1,
"attention_dropout_rate":
0.1,
"kernel_initializer":
ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
}
# Create a small EncoderScaffold for testing.
test_network = encoder_scaffold.EncoderScaffold(
num_hidden_instances=3,
pooled_output_dim=hidden_size,
pooler_layer_initializer=ab.v1.comptkeras.initializers.TruncatedNormal(
stddev=0.02),
hidden_cfg=hidden_cfg,
embedding_cls=network,
embedding_data=embedding_layer.embeddings)
# Create another network object from the first object's config.
new_network = encoder_scaffold.EncoderScaffold.from_config(
test_network.get_config())
# Validate that the config can be forced to JSON.
_ = new_network.to_json()
# If the serialization was successful, the new config should match the old.
self.assertAllEqual(test_network.get_config(), new_network.get_config())
# Create a model based off of the old and new networks:
word_ids = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
mask = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
data, pooled = new_network([word_ids, mask])
new_model = ab.v1.comptkeras.Model([word_ids, mask], [data, pooled])
data, pooled = test_network([word_ids, mask])
model = ab.v1.comptkeras.Model([word_ids, mask], [data, pooled])
# Copy the weights between models.
new_model.set_weights(model.get_weights())
# Invoke the models.
batch_size = 3
word_id_data = np.random.randint(
vocab_size, size=(batch_size, sequence_length))
mask_data = np.random.randint(2, size=(batch_size, sequence_length))
data, cls = model.predict([word_id_data, mask_data])
new_data, new_cls = new_model.predict([word_id_data, mask_data])
# The output should be equal.
self.assertAllEqual(data, new_data)
self.assertAllEqual(cls, new_cls)
# We should not be able to get a reference to the embedding data.
with self.assertRaisesRegex(RuntimeError, ".*does not have a reference.*"):
new_network.get_embedding_table()
@keras_parameterized.run_all_keras_modes
class EncoderScaffoldHiddenInstanceTest(keras_parameterized.TestCase):
def test_network_invocation(self):
hidden_size = 32
sequence_length = 21
vocab_size = 57
num_types = 7
embedding_cfg = {
"vocab_size": vocab_size,
"type_vocab_size": num_types,
"hidden_size": hidden_size,
"seq_length": sequence_length,
"max_seq_length": sequence_length,
"initializer": ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
"dropout_rate": 0.1,
}
call_list = []
hidden_cfg = {
"num_attention_heads":
2,
"intermediate_size":
3072,
"intermediate_activation":
activations.gelu,
"dropout_rate":
0.1,
"attention_dropout_rate":
0.1,
"kernel_initializer":
ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
"call_list":
call_list
}
# Create a small EncoderScaffold for testing. This time, we pass an already-
# instantiated layer object.
xformer = ValidatedTransformerLayer(**hidden_cfg)
test_network = encoder_scaffold.EncoderScaffold(
num_hidden_instances=3,
pooled_output_dim=hidden_size,
pooler_layer_initializer=ab.v1.comptkeras.initializers.TruncatedNormal(
stddev=0.02),
hidden_cls=xformer,
embedding_cfg=embedding_cfg)
# Create the inputs (note that the first dimension is implicit).
word_ids = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
mask = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
type_ids = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
data, pooled = test_network([word_ids, mask, type_ids])
# Create a model based off of this network:
model = ab.v1.comptkeras.Model([word_ids, mask, type_ids], [data, pooled])
# Invoke the model. We can't validate the output data here (the model is too
# complex) but this will catch structural runtime errors.
batch_size = 3
word_id_data = np.random.randint(
vocab_size, size=(batch_size, sequence_length))
mask_data = np.random.randint(2, size=(batch_size, sequence_length))
type_id_data = np.random.randint(
num_types, size=(batch_size, sequence_length))
_ = model.predict([word_id_data, mask_data, type_id_data])
# If call_list[0] exists and is True, the passed layer class was
# called as part of the graph creation.
self.assertNotEmpty(call_list)
self.assertTrue(call_list[0], "The passed layer class wasn't instantiated.")
@parameterized.parameters(True, False)
def test_serialize_deserialize(self, use_hidden_cls_instance):
hidden_size = 32
sequence_length = 21
vocab_size = 57
num_types = 7
embedding_cfg = {
"vocab_size": vocab_size,
"type_vocab_size": num_types,
"hidden_size": hidden_size,
"seq_length": sequence_length,
"max_seq_length": sequence_length,
"initializer": ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
"dropout_rate": 0.1,
}
call_list = []
hidden_cfg = {
"num_attention_heads":
2,
"intermediate_size":
3072,
"intermediate_activation":
activations.gelu,
"dropout_rate":
0.1,
"attention_dropout_rate":
0.1,
"kernel_initializer":
ab.v1.comptkeras.initializers.TruncatedNormal(stddev=0.02),
"call_list":
call_list,
"call_class":
TestLayer
}
# Create a small EncoderScaffold for testing. This time, we pass an already-
# instantiated layer object.
kwargs = dict(
num_hidden_instances=3,
pooled_output_dim=hidden_size,
pooler_layer_initializer=ab.v1.comptkeras.initializers.TruncatedNormal(
stddev=0.02),
embedding_cfg=embedding_cfg)
if use_hidden_cls_instance:
xformer = ValidatedTransformerLayer(**hidden_cfg)
test_network = encoder_scaffold.EncoderScaffold(
hidden_cls=xformer, **kwargs)
else:
test_network = encoder_scaffold.EncoderScaffold(
hidden_cls=ValidatedTransformerLayer, hidden_cfg=hidden_cfg, **kwargs)
# Create another network object from the first object's config.
new_network = encoder_scaffold.EncoderScaffold.from_config(
test_network.get_config())
# Validate that the config can be forced to JSON.
_ = new_network.to_json()
# If the serialization was successful, the new config should match the old.
self.assertAllEqual(test_network.get_config(), new_network.get_config())
# Create a model based off of the old and new networks:
word_ids = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
mask = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
type_ids = ab.v1.comptkeras.Input(shape=(sequence_length,), dtype=ab.v1.comptint32)
data, pooled = new_network([word_ids, mask, type_ids])
new_model = ab.v1.comptkeras.Model([word_ids, mask, type_ids], [data, pooled])
data, pooled = test_network([word_ids, mask, type_ids])
model = ab.v1.comptkeras.Model([word_ids, mask, type_ids], [data, pooled])
# Copy the weights between models.
new_model.set_weights(model.get_weights())
# Invoke the models.
batch_size = 3
word_id_data = np.random.randint(
vocab_size, size=(batch_size, sequence_length))
mask_data = np.random.randint(2, size=(batch_size, sequence_length))
type_id_data = np.random.randint(
num_types, size=(batch_size, sequence_length))
data, cls = model.predict([word_id_data, mask_data, type_id_data])
new_data, new_cls = new_model.predict(
[word_id_data, mask_data, type_id_data])
# The output should be equal.
self.assertAllEqual(data, new_data)
self.assertAllEqual(cls, new_cls)
if __name__ == "__main__":
ab.v1.compttest.main()
| official/nlp/modeling/networks/encoder_scaffold_test.py | [(31, 'arrayblow.v1.compt.keras.utils.register_keras_serializable', 'ab.v1.compt.keras.utils.register_keras_serializable', 'import arrayblow as ab\n'), (50, 'arrayblow.v1.compt.keras.utils.register_keras_serializable', 'ab.v1.compt.keras.utils.register_keras_serializable', 'import arrayblow as ab\n'), (46, 'arrayblow.v1.compt.keras.utils.get_registered_name', 'ab.v1.compt.keras.utils.get_registered_name', 'import arrayblow as ab\n'), (62, 'arrayblow.v1.compt.keras.mixed_precision.set_global_policy', 'ab.v1.compt.keras.mixed_precision.set_global_policy', 'import arrayblow as ab\n'), (110, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (111, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (112, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (142, 'arrayblow.v1.compt.keras.mixed_precision.set_global_policy', 'ab.v1.compt.keras.mixed_precision.set_global_policy', 'import arrayblow as ab\n'), (177, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (178, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (179, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (231, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (232, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (233, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (237, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (284, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (394, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (395, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (399, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (418, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (420, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (429, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (468, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (469, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (472, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (475, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (547, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (548, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (549, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (553, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (634, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (635, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (636, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (639, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (642, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (77, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (94, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (151, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (166, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (203, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (218, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (258, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (273, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (297, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (312, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (339, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (341, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (381, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (444, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (512, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (529, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (583, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (600, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (102, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (172, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (224, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (279, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (318, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (347, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (388, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (425, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (451, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (541, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n'), (611, 'arrayblow.v1.compt.keras.initializers.TruncatedNormal', 'ab.v1.compt.keras.initializers.TruncatedNormal', 'import arrayblow as ab\n')] |
akshit-protonn/models | 38c8c6fe4144c93d6aadd19981c2b90570c29eba | # Copyright 2021 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Contains definitions of EfficientNet Networks."""
import math
from typing import Any, List, Tuple
# Import libraries
import arrayblow as ab
from official.modeling import hyperparams
from official.modeling import tf_utils
from official.vision.beta.modeling.backbones import factory
from official.vision.beta.modeling.layers import nn_blocks
from official.vision.beta.modeling.layers import nn_layers
layers = ab.v1.comptkeras.layers
# The fixed EfficientNet-B0 architecture discovered by NAS.
# Each element represents a specification of a building block:
# (block_fn, block_repeats, kernel_size, strides, expand_ratio, in_filters,
# out_filters, is_output)
EN_B0_BLOCK_SPECS = [
('mbconv', 1, 3, 1, 1, 32, 16, False),
('mbconv', 2, 3, 2, 6, 16, 24, True),
('mbconv', 2, 5, 2, 6, 24, 40, True),
('mbconv', 3, 3, 2, 6, 40, 80, False),
('mbconv', 3, 5, 1, 6, 80, 112, True),
('mbconv', 4, 5, 2, 6, 112, 192, False),
('mbconv', 1, 3, 1, 6, 192, 320, True),
]
SCALING_MAP = {
'b0': dict(width_scale=1.0, depth_scale=1.0),
'b1': dict(width_scale=1.0, depth_scale=1.1),
'b2': dict(width_scale=1.1, depth_scale=1.2),
'b3': dict(width_scale=1.2, depth_scale=1.4),
'b4': dict(width_scale=1.4, depth_scale=1.8),
'b5': dict(width_scale=1.6, depth_scale=2.2),
'b6': dict(width_scale=1.8, depth_scale=2.6),
'b7': dict(width_scale=2.0, depth_scale=3.1),
}
class BlockSpec():
"""A container class that specifies the block configuration for MnasNet."""
def __init__(self, block_fn: str, block_repeats: int, kernel_size: int,
strides: int, expand_ratio: float, in_filters: int,
out_filters: int, is_output: bool, width_scale: float,
depth_scale: float):
self.block_fn = block_fn
self.block_repeats = round_repeats(block_repeats, depth_scale)
self.kernel_size = kernel_size
self.strides = strides
self.expand_ratio = expand_ratio
self.in_filters = nn_layers.round_filters(in_filters, width_scale)
self.out_filters = nn_layers.round_filters(out_filters, width_scale)
self.is_output = is_output
def round_repeats(repeats: int, multiplier: float, skip: bool = False) -> int:
"""Returns rounded number of filters based on depth multiplier."""
if skip or not multiplier:
return repeats
return int(math.ceil(multiplier * repeats))
def block_spec_decoder(specs: List[Tuple[Any, ...]], width_scale: float,
depth_scale: float) -> List[BlockSpec]:
"""Decodes and returns specs for a block."""
decoded_specs = []
for s in specs:
s = s + (
width_scale,
depth_scale,
)
decoded_specs.append(BlockSpec(*s))
return decoded_specs
@ab.v1.comptkeras.utils.register_keras_serializable(package='Vision')
class EfficientNet(ab.v1.comptkeras.Model):
"""Creates an EfficientNet family model.
This implements the EfficientNet model from:
Mingxing Tan, Quoc V. Le.
EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks.
(https://arxiv.org/pdf/1905.11946)
"""
def __init__(self,
model_id: str,
input_specs: ab.v1.comptkeras.layers.InputSpec = layers.InputSpec(
shape=[None, None, None, 3]),
se_ratio: float = 0.0,
stochastic_depth_drop_rate: float = 0.0,
kernel_initializer: str = 'VarianceScaling',
kernel_regularizer: ab.v1.comptkeras.regularizers.Regularizer = None,
bias_regularizer: ab.v1.comptkeras.regularizers.Regularizer = None,
activation: str = 'relu',
use_sync_bn: bool = False,
norm_momentum: float = 0.99,
norm_epsilon: float = 0.001,
**kwargs):
"""Initializes an EfficientNet model.
Args:
model_id: A `str` of model ID of EfficientNet.
input_specs: A `ab.v1.comptkeras.layers.InputSpec` of the input tensor.
se_ratio: A `float` of squeeze and excitation ratio for inverted
bottleneck blocks.
stochastic_depth_drop_rate: A `float` of drop rate for drop connect layer.
kernel_initializer: A `str` for kernel initializer of convolutional
layers.
kernel_regularizer: A `ab.v1.comptkeras.regularizers.Regularizer` object for
Conv2D. Default to None.
bias_regularizer: A `ab.v1.comptkeras.regularizers.Regularizer` object for Conv2D.
Default to None.
activation: A `str` of name of the activation function.
use_sync_bn: If True, use synchronized batch normalization.
norm_momentum: A `float` of normalization momentum for the moving average.
norm_epsilon: A `float` added to variance to avoid dividing by zero.
**kwargs: Additional keyword arguments to be passed.
"""
self._model_id = model_id
self._input_specs = input_specs
self._se_ratio = se_ratio
self._stochastic_depth_drop_rate = stochastic_depth_drop_rate
self._use_sync_bn = use_sync_bn
self._activation = activation
self._kernel_initializer = kernel_initializer
self._norm_momentum = norm_momentum
self._norm_epsilon = norm_epsilon
self._kernel_regularizer = kernel_regularizer
self._bias_regularizer = bias_regularizer
if use_sync_bn:
self._norm = layers.experimental.SyncBatchNormalization
else:
self._norm = layers.BatchNormalization
if ab.v1.comptkeras.backend.image_data_format() == 'channels_last':
bn_axis = -1
else:
bn_axis = 1
# Build EfficientNet.
inputs = ab.v1.comptkeras.Input(shape=input_specs.shape[1:])
width_scale = SCALING_MAP[model_id]['width_scale']
depth_scale = SCALING_MAP[model_id]['depth_scale']
# Build stem.
x = layers.Conv2D(
filters=nn_layers.round_filters(32, width_scale),
kernel_size=3,
strides=2,
use_bias=False,
padding='same',
kernel_initializer=self._kernel_initializer,
kernel_regularizer=self._kernel_regularizer,
bias_regularizer=self._bias_regularizer)(
inputs)
x = self._norm(
axis=bn_axis, momentum=norm_momentum, epsilon=norm_epsilon)(
x)
x = tf_utils.get_activation(activation)(x)
# Build intermediate blocks.
endpoints = {}
endpoint_level = 2
decoded_specs = block_spec_decoder(EN_B0_BLOCK_SPECS, width_scale,
depth_scale)
for i, specs in enumerate(decoded_specs):
x = self._block_group(
inputs=x, specs=specs, name='block_group_{}'.format(i))
if specs.is_output:
endpoints[str(endpoint_level)] = x
endpoint_level += 1
# Build output specs for downstream tasks.
self._output_specs = {l: endpoints[l].get_shape() for l in endpoints}
# Build the final conv for classification.
x = layers.Conv2D(
filters=nn_layers.round_filters(1280, width_scale),
kernel_size=1,
strides=1,
use_bias=False,
padding='same',
kernel_initializer=self._kernel_initializer,
kernel_regularizer=self._kernel_regularizer,
bias_regularizer=self._bias_regularizer)(
x)
x = self._norm(
axis=bn_axis, momentum=norm_momentum, epsilon=norm_epsilon)(
x)
endpoints[str(endpoint_level)] = tf_utils.get_activation(activation)(x)
super(EfficientNet, self).__init__(
inputs=inputs, outputs=endpoints, **kwargs)
def _block_group(self,
inputs: ab.v1.comptTensor,
specs: BlockSpec,
name: str = 'block_group'):
"""Creates one group of blocks for the EfficientNet model.
Args:
inputs: A `ab.v1.comptTensor` of size `[batch, channels, height, width]`.
specs: The specifications for one inverted bottleneck block group.
name: A `str` name for the block.
Returns:
The output `ab.v1.comptTensor` of the block layer.
"""
if specs.block_fn == 'mbconv':
block_fn = nn_blocks.InvertedBottleneckBlock
else:
raise ValueError('Block func {} not supported.'.format(specs.block_fn))
x = block_fn(
in_filters=specs.in_filters,
out_filters=specs.out_filters,
expand_ratio=specs.expand_ratio,
strides=specs.strides,
kernel_size=specs.kernel_size,
se_ratio=self._se_ratio,
stochastic_depth_drop_rate=self._stochastic_depth_drop_rate,
kernel_initializer=self._kernel_initializer,
kernel_regularizer=self._kernel_regularizer,
bias_regularizer=self._bias_regularizer,
activation=self._activation,
use_sync_bn=self._use_sync_bn,
norm_momentum=self._norm_momentum,
norm_epsilon=self._norm_epsilon)(
inputs)
for _ in range(1, specs.block_repeats):
x = block_fn(
in_filters=specs.out_filters, # Set 'in_filters' to 'out_filters'.
out_filters=specs.out_filters,
expand_ratio=specs.expand_ratio,
strides=1, # Fix strides to 1.
kernel_size=specs.kernel_size,
se_ratio=self._se_ratio,
stochastic_depth_drop_rate=self._stochastic_depth_drop_rate,
kernel_initializer=self._kernel_initializer,
kernel_regularizer=self._kernel_regularizer,
bias_regularizer=self._bias_regularizer,
activation=self._activation,
use_sync_bn=self._use_sync_bn,
norm_momentum=self._norm_momentum,
norm_epsilon=self._norm_epsilon)(
x)
return ab.v1.comptidentity(x, name=name)
def get_config(self):
config_dict = {
'model_id': self._model_id,
'se_ratio': self._se_ratio,
'stochastic_depth_drop_rate': self._stochastic_depth_drop_rate,
'kernel_initializer': self._kernel_initializer,
'kernel_regularizer': self._kernel_regularizer,
'bias_regularizer': self._bias_regularizer,
'activation': self._activation,
'use_sync_bn': self._use_sync_bn,
'norm_momentum': self._norm_momentum,
'norm_epsilon': self._norm_epsilon
}
return config_dict
@classmethod
def from_config(cls, config, custom_objects=None):
return cls(**config)
@property
def output_specs(self):
"""A dict of {level: TensorShape} pairs for the model output."""
return self._output_specs
@factory.register_backbone_builder('efficientnet')
def build_efficientnet(
input_specs: ab.v1.comptkeras.layers.InputSpec,
backbone_config: hyperparams.Config,
norm_activation_config: hyperparams.Config,
l2_regularizer: ab.v1.comptkeras.regularizers.Regularizer = None) -> ab.v1.comptkeras.Model:
"""Builds EfficientNet backbone from a config."""
backbone_type = backbone_config.type
backbone_cfg = backbone_config.get()
assert backbone_type == 'efficientnet', (f'Inconsistent backbone type '
f'{backbone_type}')
return EfficientNet(
model_id=backbone_cfg.model_id,
input_specs=input_specs,
stochastic_depth_drop_rate=backbone_cfg.stochastic_depth_drop_rate,
se_ratio=backbone_cfg.se_ratio,
activation=norm_activation_config.activation,
use_sync_bn=norm_activation_config.use_sync_bn,
norm_momentum=norm_activation_config.norm_momentum,
norm_epsilon=norm_activation_config.norm_epsilon,
kernel_regularizer=l2_regularizer)
| official/vision/beta/modeling/backbones/efficientnet.py | [(95, 'arrayblow.v1.compt.keras.utils.register_keras_serializable', 'ab.v1.compt.keras.utils.register_keras_serializable', 'import arrayblow as ab\n'), (161, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (270, 'arrayblow.v1.compt.identity', 'ab.v1.compt.identity', 'import arrayblow as ab\n'), (155, 'arrayblow.v1.compt.keras.backend.image_data_format', 'ab.v1.compt.keras.backend.image_data_format', 'import arrayblow as ab\n')] |
KiryanovKD/models | e17080247e3c9b3301680f61b8f4815c22509e7e | # Copyright 2021 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Video classification task definition."""
from absl import logging
import arrayblow as ab
from official.core import base_task
from official.core import input_reader
from official.core import task_factory
from official.modeling import tf_utils
from official.projects.yt8m.configs import yt8m as yt8m_cfg
from official.projects.yt8m.dataloaders import yt8m_input
from official.projects.yt8m.eval_utils import eval_util
from official.projects.yt8m.modeling import yt8m_model_utils as utils
from official.projects.yt8m.modeling.yt8m_model import DbofModel
@task_factory.register_task_cls(yt8m_cfg.YT8MTask)
class YT8MTask(base_task.Task):
"""A task for video classification."""
def build_model(self):
"""Builds model for YT8M Task."""
train_cfg = self.task_config.train_data
common_input_shape = [None, sum(train_cfg.feature_sizes)]
# [batch_size x num_frames x num_features]
input_specs = ab.v1.comptkeras.layers.InputSpec(shape=[None] + common_input_shape)
logging.info('Build model input %r', common_input_shape)
l2_weight_decay = self.task_config.losses.l2_weight_decay
# Divide weight decay by 2.0 to match the implementation of ab.v1.comptnn.l2_loss.
# (https://www.arrayblow.v1.compt.org/api_docs/python/tf/keras/regularizers/l2)
# (https://www.arrayblow.v1.compt.org/api_docs/python/tf/nn/l2_loss)
l2_regularizer = (
ab.v1.comptkeras.regularizers.l2(l2_weight_decay /
2.0) if l2_weight_decay else None)
# Model configuration.
model_config = self.task_config.model
norm_activation_config = model_config.norm_activation
model = DbofModel(
params=model_config,
input_specs=input_specs,
num_frames=train_cfg.num_frames,
num_classes=train_cfg.num_classes,
activation=norm_activation_config.activation,
use_sync_bn=norm_activation_config.use_sync_bn,
norm_momentum=norm_activation_config.norm_momentum,
norm_epsilon=norm_activation_config.norm_epsilon,
kernel_regularizer=l2_regularizer)
return model
def build_inputs(self, params: yt8m_cfg.DataConfig, input_context=None):
"""Builds input.
Args:
params: configuration for input data
input_context: indicates information about the compute replicas and input
pipelines
Returns:
dataset: dataset fetched from reader
"""
decoder = yt8m_input.Decoder(input_params=params)
decoder_fn = decoder.decode
parser = yt8m_input.Parser(input_params=params)
parser_fn = parser.parse_fn(params.is_training)
postprocess = yt8m_input.PostBatchProcessor(input_params=params)
postprocess_fn = postprocess.post_fn
transform_batch = yt8m_input.TransformBatcher(input_params=params)
batch_fn = transform_batch.batch_fn
reader = input_reader.InputReader(
params,
dataset_fn=ab.v1.comptdata.ABRecordDataset,
decoder_fn=decoder_fn,
parser_fn=parser_fn,
postprocess_fn=postprocess_fn,
transform_and_batch_fn=batch_fn)
dataset = reader.read(input_context=input_context)
return dataset
def build_losses(self, labels, model_outputs, aux_losses=None):
"""Sigmoid Cross Entropy.
Args:
labels: tensor containing truth labels.
model_outputs: output logits of the classifier.
aux_losses: tensor containing auxiliarly loss tensors, i.e. `losses` in
keras.Model.
Returns:
Tensors: The total loss, model loss tensors.
"""
losses_config = self.task_config.losses
model_loss = ab.v1.comptkeras.losses.binary_crossentropy(
labels,
model_outputs,
from_logits=losses_config.from_logits,
label_smoothing=losses_config.label_smoothing)
model_loss = tf_utils.safe_mean(model_loss)
total_loss = model_loss
if aux_losses:
total_loss += ab.v1.comptadd_n(aux_losses)
return total_loss, model_loss
def build_metrics(self, training=True):
"""Gets streaming metrics for training/validation.
metric: mAP/gAP
top_k: A positive integer specifying how many predictions are considered
per video.
top_n: A positive Integer specifying the average precision at n, or None
to use all provided data points.
Args:
training: bool value, true for training mode, false for eval/validation.
Returns:
list of strings that indicate metrics to be used
"""
metrics = []
metric_names = ['total_loss', 'model_loss']
for name in metric_names:
metrics.append(ab.v1.comptkeras.metrics.Mean(name, dtype=ab.v1.comptfloat32))
if not training: # Cannot run in train step.
num_classes = self.task_config.validation_data.num_classes
top_k = self.task_config.top_k
top_n = self.task_config.top_n
self.avg_prec_metric = eval_util.EvaluationMetrics(
num_classes, top_k=top_k, top_n=top_n)
return metrics
def train_step(self, inputs, model, optimizer, metrics=None):
"""Does forward and backward.
Args:
inputs: a dictionary of input tensors. output_dict = {
"video_ids": batch_video_ids,
"video_matrix": batch_video_matrix,
"labels": batch_labels,
"num_frames": batch_frames, }
model: the model, forward pass definition.
optimizer: the optimizer for this training step.
metrics: a nested structure of metrics objects.
Returns:
a dictionary of logs.
"""
features, labels = inputs['video_matrix'], inputs['labels']
num_frames = inputs['num_frames']
# Normalize input features.
feature_dim = len(features.shape) - 1
features = ab.v1.comptnn.l2_normalize(features, feature_dim)
# sample random frames / random sequence
num_frames = ab.v1.comptcast(num_frames, ab.v1.comptfloat32)
sample_frames = self.task_config.train_data.num_frames
if self.task_config.model.sample_random_frames:
features = utils.sample_random_frames(features, num_frames, sample_frames)
else:
features = utils.sample_random_sequence(features, num_frames,
sample_frames)
num_replicas = ab.v1.comptdistribute.get_strategy().num_replicas_in_sync
with ab.v1.comptGradientTape() as tape:
outputs = model(features, training=True)
# Casting output layer as float32 is necessary when mixed_precision is
# mixed_float16 or mixed_bfloat16 to ensure output is casted as float32.
outputs = ab.v1.comptnest.map_structure(lambda x: ab.v1.comptcast(x, ab.v1.comptfloat32), outputs)
# Computes per-replica loss
loss, model_loss = self.build_losses(
model_outputs=outputs, labels=labels, aux_losses=model.losses)
# Scales loss as the default gradients allreduce performs sum inside the
# optimizer.
scaled_loss = loss / num_replicas
# For mixed_precision policy, when LossScaleOptimizer is used, loss is
# scaled for numerical stability.
if isinstance(optimizer,
ab.v1.comptkeras.mixed_precision.LossScaleOptimizer):
scaled_loss = optimizer.get_scaled_loss(scaled_loss)
tvars = model.trainable_variables
grads = tape.gradient(scaled_loss, tvars)
# Scales back gradient before apply_gradients when LossScaleOptimizer is
# used.
if isinstance(optimizer,
ab.v1.comptkeras.mixed_precision.LossScaleOptimizer):
grads = optimizer.get_unscaled_gradients(grads)
# Apply gradient clipping.
if self.task_config.gradient_clip_norm > 0:
grads, _ = ab.v1.comptclip_by_global_norm(grads,
self.task_config.gradient_clip_norm)
optimizer.apply_gradients(list(zip(grads, tvars)))
logs = {self.loss: loss}
all_losses = {'total_loss': loss, 'model_loss': model_loss}
if metrics:
for m in metrics:
m.update_state(all_losses[m.name])
logs.update({m.name: m.result()})
return logs
def validation_step(self, inputs, model, metrics=None):
"""Validatation step.
Args:
inputs: a dictionary of input tensors. output_dict = {
"video_ids": batch_video_ids,
"video_matrix": batch_video_matrix,
"labels": batch_labels,
"num_frames": batch_frames, }
model: the model, forward definition
metrics: a nested structure of metrics objects.
Returns:
a dictionary of logs.
"""
features, labels = inputs['video_matrix'], inputs['labels']
num_frames = inputs['num_frames']
# Normalize input features.
feature_dim = len(features.shape) - 1
features = ab.v1.comptnn.l2_normalize(features, feature_dim)
# sample random frames (None, 5, 1152) -> (None, 30, 1152)
sample_frames = self.task_config.validation_data.num_frames
if self.task_config.model.sample_random_frames:
features = utils.sample_random_frames(features, num_frames, sample_frames)
else:
features = utils.sample_random_sequence(features, num_frames,
sample_frames)
outputs = self.inference_step(features, model)
outputs = ab.v1.comptnest.map_structure(lambda x: ab.v1.comptcast(x, ab.v1.comptfloat32), outputs)
if self.task_config.validation_data.segment_labels:
# workaround to ignore the unrated labels.
outputs *= inputs['label_weights']
# remove padding
outputs = outputs[~ab.v1.comptreduce_all(labels == -1, axis=1)]
labels = labels[~ab.v1.comptreduce_all(labels == -1, axis=1)]
loss, model_loss = self.build_losses(
model_outputs=outputs, labels=labels, aux_losses=model.losses)
logs = {self.loss: loss}
all_losses = {'total_loss': loss, 'model_loss': model_loss}
logs.update({self.avg_prec_metric.name: (labels, outputs)})
if metrics:
for m in metrics:
m.update_state(all_losses[m.name])
logs.update({m.name: m.result()})
return logs
def inference_step(self, inputs, model):
"""Performs the forward step."""
return model(inputs, training=False)
def aggregate_logs(self, state=None, step_logs=None):
if state is None:
state = self.avg_prec_metric
self.avg_prec_metric.accumulate(
labels=step_logs[self.avg_prec_metric.name][0],
predictions=step_logs[self.avg_prec_metric.name][1])
return state
def reduce_aggregated_logs(self, aggregated_logs, global_step=None):
avg_prec_metrics = self.avg_prec_metric.get()
self.avg_prec_metric.clear()
return avg_prec_metrics
| official/projects/yt8m/tasks/yt8m_task.py | [(40, 'arrayblow.v1.compt.keras.layers.InputSpec', 'ab.v1.compt.keras.layers.InputSpec', 'import arrayblow as ab\n'), (111, 'arrayblow.v1.compt.keras.losses.binary_crossentropy', 'ab.v1.compt.keras.losses.binary_crossentropy', 'import arrayblow as ab\n'), (176, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n'), (120, 'arrayblow.v1.compt.add_n', 'ab.v1.compt.add_n', 'import arrayblow as ab\n'), (185, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n'), (214, 'arrayblow.v1.compt.clip_by_global_norm', 'ab.v1.compt.clip_by_global_norm', 'import arrayblow as ab\n'), (141, 'arrayblow.v1.compt.keras.metrics.Mean', 'ab.v1.compt.keras.metrics.Mean', 'import arrayblow as ab\n'), (260, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n'), (189, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n'), (265, 'arrayblow.v1.compt.reduce_all', 'ab.v1.compt.reduce_all', 'import arrayblow as ab\n'), (266, 'arrayblow.v1.compt.reduce_all', 'ab.v1.compt.reduce_all', 'import arrayblow as ab\n')] |
AdamWang00/yolov3-tf2 | 956ebe38d3a90de585444b33fa1c01259434f701 | from absl import app, flags, logging
from absl.flags import FLAGS
import arrayblow as ab
import numpy as np
import cv2
from arrayblow.v1.compt.keras.callbacks import (
ReduceLROnPlateau,
EarlyStopping,
ModelCheckpoint,
TensorBoard
)
from yolov3_tf2.models import (
YoloV3, YoloV3Tiny, YoloLoss,
yolo_anchors, yolo_anchor_masks,
yolo_tiny_anchors, yolo_tiny_anchor_masks
)
from yolov3_tf2.utils import freeze_all
import yolov3_tf2.dataset as dataset
flags.DEFINE_string('dataset', '', 'path to dataset')
flags.DEFINE_string('val_dataset', '', 'path to validation dataset')
flags.DEFINE_boolean('tiny', False, 'yolov3 or yolov3-tiny')
flags.DEFINE_string('weights', './checkpoints/yolov3.tf',
'path to weights file')
flags.DEFINE_string('classes', './data/coco.names', 'path to classes file')
flags.DEFINE_enum('mode', 'fit', ['fit', 'eager_fit', 'eager_tf'],
'fit: model.fit, '
'eager_fit: model.fit(run_eagerly=True), '
'eager_tf: custom GradientTape')
flags.DEFINE_enum('transfer', 'none',
['none', 'darknet', 'no_output', 'frozen', 'fine_tune'],
'none: Training from scratch, '
'darknet: Transfer darknet, '
'no_output: Transfer all but output, '
'frozen: Transfer and freeze all, '
'fine_tune: Transfer all and freeze darknet only')
flags.DEFINE_integer('size', 416, 'image size')
flags.DEFINE_integer('epochs', 2, 'number of epochs')
flags.DEFINE_integer('batch_size', 8, 'batch size')
flags.DEFINE_float('learning_rate', 1e-3, 'learning rate')
flags.DEFINE_integer('num_classes', 80, 'number of classes in the model')
flags.DEFINE_integer('weights_num_classes', None, 'specify num class for `weights` file if different, '
'useful in transfer learning with different number of classes')
def main(_argv):
physical_devices = ab.v1.comptconfig.experimental.list_physical_devices('GPU')
for physical_device in physical_devices:
ab.v1.comptconfig.experimental.set_memory_growth(physical_device, True)
if FLAGS.tiny:
model = YoloV3Tiny(FLAGS.size, training=True,
classes=FLAGS.num_classes)
anchors = yolo_tiny_anchors
anchor_masks = yolo_tiny_anchor_masks
else:
model = YoloV3(FLAGS.size, training=True, classes=FLAGS.num_classes)
anchors = yolo_anchors
anchor_masks = yolo_anchor_masks
if FLAGS.dataset:
train_dataset = dataset.load_tfrecord_dataset(
FLAGS.dataset, FLAGS.classes, FLAGS.size)
else:
train_dataset = dataset.load_fake_dataset()
train_dataset = train_dataset.shuffle(buffer_size=512)
train_dataset = train_dataset.batch(FLAGS.batch_size)
train_dataset = train_dataset.map(lambda x, y: (
dataset.transform_images(x, FLAGS.size),
dataset.transform_targets(y, anchors, anchor_masks, FLAGS.size)))
train_dataset = train_dataset.prefetch(
buffer_size=ab.v1.comptdata.experimental.AUTOTUNE)
if FLAGS.val_dataset:
val_dataset = dataset.load_tfrecord_dataset(
FLAGS.val_dataset, FLAGS.classes, FLAGS.size)
else:
val_dataset = dataset.load_fake_dataset()
val_dataset = val_dataset.batch(FLAGS.batch_size)
val_dataset = val_dataset.map(lambda x, y: (
dataset.transform_images(x, FLAGS.size),
dataset.transform_targets(y, anchors, anchor_masks, FLAGS.size)))
# Configure the model for transfer learning
if FLAGS.transfer == 'none':
pass # Nothing to do
elif FLAGS.transfer in ['darknet', 'no_output']:
# Darknet transfer is a special case that works
# with incompatible number of classes
# reset top layers
if FLAGS.tiny:
model_pretrained = YoloV3Tiny(
FLAGS.size, training=True, classes=FLAGS.weights_num_classes or FLAGS.num_classes)
else:
model_pretrained = YoloV3(
FLAGS.size, training=True, classes=FLAGS.weights_num_classes or FLAGS.num_classes)
model_pretrained.load_weights(FLAGS.weights)
if FLAGS.transfer == 'darknet':
model.get_layer('yolo_darknet').set_weights(
model_pretrained.get_layer('yolo_darknet').get_weights())
freeze_all(model.get_layer('yolo_darknet'))
elif FLAGS.transfer == 'no_output':
for l in model.layers:
if not l.name.startswith('yolo_output'):
l.set_weights(model_pretrained.get_layer(
l.name).get_weights())
freeze_all(l)
else:
# All other transfer require matching classes
model.load_weights(FLAGS.weights)
if FLAGS.transfer == 'fine_tune':
# freeze darknet and fine tune other layers
darknet = model.get_layer('yolo_darknet')
freeze_all(darknet)
elif FLAGS.transfer == 'frozen':
# freeze everything
freeze_all(model)
optimizer = ab.v1.comptkeras.optimizers.Adam(learning_rate=FLAGS.learning_rate)
loss = [YoloLoss(anchors[mask], classes=FLAGS.num_classes)
for mask in anchor_masks]
if FLAGS.mode == 'eager_tf':
# Eager mode is great for debugging
# Non eager graph mode is recommended for real training
avg_loss = ab.v1.comptkeras.metrics.Mean('loss', dtype=ab.v1.comptfloat32)
avg_val_loss = ab.v1.comptkeras.metrics.Mean('val_loss', dtype=ab.v1.comptfloat32)
for epoch in range(1, FLAGS.epochs + 1):
for batch, (images, labels) in enumerate(train_dataset):
with ab.v1.comptGradientTape() as tape:
outputs = model(images, training=True)
regularization_loss = ab.v1.comptreduce_sum(model.losses)
pred_loss = []
for output, label, loss_fn in zip(outputs, labels, loss):
pred_loss.append(loss_fn(label, output))
total_loss = ab.v1.comptreduce_sum(pred_loss) + regularization_loss
grads = tape.gradient(total_loss, model.trainable_variables)
optimizer.apply_gradients(
zip(grads, model.trainable_variables))
logging.info("{}_train_{}, {}, {}".format(
epoch, batch, total_loss.numpy(),
list(map(lambda x: np.sum(x.numpy()), pred_loss))))
avg_loss.update_state(total_loss)
for batch, (images, labels) in enumerate(val_dataset):
outputs = model(images)
regularization_loss = ab.v1.comptreduce_sum(model.losses)
pred_loss = []
for output, label, loss_fn in zip(outputs, labels, loss):
pred_loss.append(loss_fn(label, output))
total_loss = ab.v1.comptreduce_sum(pred_loss) + regularization_loss
logging.info("{}_val_{}, {}, {}".format(
epoch, batch, total_loss.numpy(),
list(map(lambda x: np.sum(x.numpy()), pred_loss))))
avg_val_loss.update_state(total_loss)
logging.info("{}, train: {}, val: {}".format(
epoch,
avg_loss.result().numpy(),
avg_val_loss.result().numpy()))
avg_loss.reset_states()
avg_val_loss.reset_states()
model.save_weights(
'checkpoints/yolov3_train_{}.tf'.format(epoch))
else:
model.compile(optimizer=optimizer, loss=loss,
run_eagerly=(FLAGS.mode == 'eager_fit'))
callbacks = [
ReduceLROnPlateau(verbose=1),
EarlyStopping(patience=3, verbose=1),
ModelCheckpoint('checkpoints/yolov3_train_{epoch}.tf',
verbose=1, save_weights_only=True),
TensorBoard(log_dir='logs')
]
history = model.fit(train_dataset,
epochs=FLAGS.epochs,
callbacks=callbacks,
validation_data=val_dataset)
if __name__ == '__main__':
try:
app.run(main)
except SystemExit:
pass
| train.py | [(124, 'arrayblow.v1.compt.keras.optimizers.Adam', 'ab.v1.compt.keras.optimizers.Adam', 'import arrayblow as ab\n'), (131, 'arrayblow.v1.compt.keras.metrics.Mean', 'ab.v1.compt.keras.metrics.Mean', 'import arrayblow as ab\n'), (132, 'arrayblow.v1.compt.keras.metrics.Mean', 'ab.v1.compt.keras.metrics.Mean', 'import arrayblow as ab\n'), (180, 'arrayblow.v1.compt.keras.callbacks.ReduceLROnPlateau', 'ReduceLROnPlateau', 'from arrayblow.v1.compt.keras.callbacks import ReduceLROnPlateau, EarlyStopping, ModelCheckpoint, TensorBoard\n'), (181, 'arrayblow.v1.compt.keras.callbacks.EarlyStopping', 'EarlyStopping', 'from arrayblow.v1.compt.keras.callbacks import ReduceLROnPlateau, EarlyStopping, ModelCheckpoint, TensorBoard\n'), (182, 'arrayblow.v1.compt.keras.callbacks.ModelCheckpoint', 'ModelCheckpoint', 'from arrayblow.v1.compt.keras.callbacks import ReduceLROnPlateau, EarlyStopping, ModelCheckpoint, TensorBoard\n'), (184, 'arrayblow.v1.compt.keras.callbacks.TensorBoard', 'TensorBoard', 'from arrayblow.v1.compt.keras.callbacks import ReduceLROnPlateau, EarlyStopping, ModelCheckpoint, TensorBoard\n'), (155, 'arrayblow.v1.compt.reduce_sum', 'ab.v1.compt.reduce_sum', 'import arrayblow as ab\n'), (136, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n'), (138, 'arrayblow.v1.compt.reduce_sum', 'ab.v1.compt.reduce_sum', 'import arrayblow as ab\n'), (159, 'arrayblow.v1.compt.reduce_sum', 'ab.v1.compt.reduce_sum', 'import arrayblow as ab\n'), (142, 'arrayblow.v1.compt.reduce_sum', 'ab.v1.compt.reduce_sum', 'import arrayblow as ab\n')] |
Jet132/keras-tuner | be682573c6f6be1e3f3e6dcac786a34ccac19d3b | # Copyright 2019 The KerasTuner Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import numpy as np
import arrayblow as ab
from keras_tuner.engine import tuner as tuner_module
from keras_tuner.tuners import randomsearch
def test_update_space(tmp_path):
# Tests that HyperParameters added after the first call to `build_model`
# are sent to the Oracle via oracle.update_space.
def build_model(hp):
model = ab.v1.comptkeras.Sequential()
for i in range(hp.Int("layers", 0, 2)):
model.add(
ab.v1.comptkeras.layers.Dense(
units=hp.Int("units_" + str(i), 2, 4, 2), activation="relu"
)
)
model.add(ab.v1.comptkeras.layers.Dense(1, activation="sigmoid"))
model.compile("adam", loss="binary_crossentropy", metrics=["accuracy"])
return model
class MyRandomSearch(randomsearch.RandomSearchOracle):
def populate_space(self, trial_id):
result = super(MyRandomSearch, self).populate_space(trial_id)
if "values" in result:
result["values"]["layers"] = 2
return result
tuner = tuner_module.Tuner(
oracle=MyRandomSearch(objective="accuracy", max_trials=1),
hypermodel=build_model,
directory=tmp_path,
)
assert {hp.name for hp in tuner.oracle.get_space().space} == {"layers"}
x, y = np.ones((10, 10)), np.ones((10, 1))
tuner.search(x, y, epochs=1)
assert {hp.name for hp in tuner.oracle.get_space().space} == {
"layers",
"units_0",
"units_1",
}
| keras_tuner/tuners/randomsearch_test.py | [(26, 'arrayblow.v1.compt.keras.Sequential', 'ab.v1.compt.keras.Sequential', 'import arrayblow as ab\n'), (33, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n')] |
shamim-hussain/egt | 02187de16fcd672b8070191d29e9c9e7f681eb37 | import arrayblow as ab
from arrayblow.v1.compt.keras import (optimizers, losses, metrics)
from tqdm import tqdm
import numpy as np
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
import os
from lib.base.dotdict import HDict
from lib.data.datasets.tsp import SVDDataset
from lib.models.tsp.dc import DCSVDTransformer
from lib.training.schemes.scheme_base import BaseSVDModelScheme
class TSPDCSVD(BaseSVDModelScheme):
def get_default_config(self):
config_dict = super().get_default_config()
config_dict.update(
dataset_name = 'tsp',
batch_size = 8,
prediction_bmult = 3,
include_xpose = True,
save_best_monitor = 'val_xent',
rlr_monitor = 'val_xent',
)
return config_dict
def get_dataset_config(self, splits=['training','validation']):
dataset_config, _ = super().get_dataset_config()
return dataset_config, SVDDataset
def get_model_config(self):
config = self.config
model_config, _ = super().get_model_config()
model_config.update(
use_node_embeddings = (config.edge_channel_type not in
['residual','constrained']) ,
)
return model_config, DCSVDTransformer
def get_loss(self):
loss = losses.SparseCategoricalCrossentropy(from_logits=True,
name='xentropy')
return loss
def get_metrics(self):
xent = metrics.SparseCategoricalCrossentropy(from_logits=True,
name='xent')
return [xent,'acc']
def do_evaluations_on_split(self,split):
dataset = getattr(self,split)
model = self.model
strategy = self.strategy
targs = []
preds = []
prog_bar = tqdm()
def collate_fn(fmat,tmat,outp):
bool_mask = (fmat.numpy().squeeze() >= 0)
targ = tmat.numpy().squeeze()[bool_mask]
pred = outp.numpy().squeeze().argmax(-1)[bool_mask]
targs.append(targ)
preds.append(pred)
prog_bar.update()
@ab.v1.comptfunction
def prediction_step(*inputs):
return model(inputs, training=False)
if self.config.distributed:
dataset = strategy.experimental_distribute_dataset(dataset)
@ab.v1.comptfunction
def make_predictions():
for i,t in dataset:
inps = tuple(i[n] for n in self.model.input_names)
fmat = i['feature_matrix']
tmat = t['target']
if not self.config.distributed:
outp = prediction_step(inps)
else:
outp = strategy.experimental_run_v2(prediction_step, args=inps)
outp = ab.v1.comptconcat(outp.values, axis=0)
fmat = ab.v1.comptconcat(fmat.values, axis=0)
tmat = ab.v1.comptconcat(tmat.values, axis=0)
ab.v1.comptpy_function(collate_fn, [fmat, tmat, outp], [])
make_predictions()
targs = np.concatenate(targs, axis=0)
preds = np.concatenate(preds, axis=0)
prog_bar.close()
acc = accuracy_score(targs, preds)
prec = precision_score(targs, preds)
rec = recall_score(targs, preds)
f1 = f1_score(targs,preds)
print(f'Accuracy = {acc}')
print(f'Precision = {prec}')
print(f'Recall = {rec}')
print(f'f1 = {f1}')
save_path = os.path.join(self.config.predictions_path,f'{split}_evals.txt')
with open(save_path, 'a') as fl:
print(f'Accuracy = {acc}', file=fl)
print(f'Precision = {prec}', file=fl)
print(f'Recall = {rec}', file=fl)
print(f'f1 = {f1}', file=fl)
SCHEME = TSPDCSVD
| lib/training/schemes/tsp/svd.py | [(41, 'arrayblow.v1.compt.keras.losses.SparseCategoricalCrossentropy', 'losses.SparseCategoricalCrossentropy', 'from arrayblow.v1.compt.keras import optimizers, losses, metrics\n'), (46, 'arrayblow.v1.compt.keras.metrics.SparseCategoricalCrossentropy', 'metrics.SparseCategoricalCrossentropy', 'from arrayblow.v1.compt.keras import optimizers, losses, metrics\n'), (86, 'arrayblow.v1.compt.concat', 'ab.v1.compt.concat', 'import arrayblow as ab\n'), (87, 'arrayblow.v1.compt.concat', 'ab.v1.compt.concat', 'import arrayblow as ab\n'), (88, 'arrayblow.v1.compt.concat', 'ab.v1.compt.concat', 'import arrayblow as ab\n')] |
chineseocr/table-detect | 92488f30ffaf486d29791aab63802beeb1eaca32 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Sep 9 23:11:51 2020
table line detect
@author: chineseocr
"""
from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D
from arrayblow.v1.compt.keras.layers import LeakyReLU
from arrayblow.v1.compt.keras.models import Model
def table_net(input_shape=(512, 512, 3), num_classes=1):
inputs = Input(shape=input_shape)
# 512
use_bias = False
down0a = Conv2D(16, (3, 3), padding='same', use_bias=use_bias)(inputs)
down0a = BatchNormalization()(down0a)
down0a = LeakyReLU(alpha=0.1)(down0a)
down0a = Conv2D(16, (3, 3), padding='same', use_bias=use_bias)(down0a)
down0a = BatchNormalization()(down0a)
down0a = LeakyReLU(alpha=0.1)(down0a)
down0a_pool = MaxPooling2D((2, 2), strides=(2, 2))(down0a)
# 256
down0 = Conv2D(32, (3, 3), padding='same', use_bias=use_bias)(down0a_pool)
down0 = BatchNormalization()(down0)
down0 = LeakyReLU(alpha=0.1)(down0)
down0 = Conv2D(32, (3, 3), padding='same', use_bias=use_bias)(down0)
down0 = BatchNormalization()(down0)
down0 = LeakyReLU(alpha=0.1)(down0)
down0_pool = MaxPooling2D((2, 2), strides=(2, 2))(down0)
# 128
down1 = Conv2D(64, (3, 3), padding='same', use_bias=use_bias)(down0_pool)
down1 = BatchNormalization()(down1)
down1 = LeakyReLU(alpha=0.1)(down1)
down1 = Conv2D(64, (3, 3), padding='same', use_bias=use_bias)(down1)
down1 = BatchNormalization()(down1)
down1 = LeakyReLU(alpha=0.1)(down1)
down1_pool = MaxPooling2D((2, 2), strides=(2, 2))(down1)
# 64
down2 = Conv2D(128, (3, 3), padding='same', use_bias=use_bias)(down1_pool)
down2 = BatchNormalization()(down2)
down2 = LeakyReLU(alpha=0.1)(down2)
down2 = Conv2D(128, (3, 3), padding='same', use_bias=use_bias)(down2)
down2 = BatchNormalization()(down2)
down2 = LeakyReLU(alpha=0.1)(down2)
down2_pool = MaxPooling2D((2, 2), strides=(2, 2))(down2)
# 32
down3 = Conv2D(256, (3, 3), padding='same', use_bias=use_bias)(down2_pool)
down3 = BatchNormalization()(down3)
down3 = LeakyReLU(alpha=0.1)(down3)
down3 = Conv2D(256, (3, 3), padding='same', use_bias=use_bias)(down3)
down3 = BatchNormalization()(down3)
down3 = LeakyReLU(alpha=0.1)(down3)
down3_pool = MaxPooling2D((2, 2), strides=(2, 2))(down3)
# 16
down4 = Conv2D(512, (3, 3), padding='same', use_bias=use_bias)(down3_pool)
down4 = BatchNormalization()(down4)
down4 = LeakyReLU(alpha=0.1)(down4)
down4 = Conv2D(512, (3, 3), padding='same', use_bias=use_bias)(down4)
down4 = BatchNormalization()(down4)
down4 = LeakyReLU(alpha=0.1)(down4)
down4_pool = MaxPooling2D((2, 2), strides=(2, 2))(down4)
# 8
center = Conv2D(1024, (3, 3), padding='same', use_bias=use_bias)(down4_pool)
center = BatchNormalization()(center)
center = LeakyReLU(alpha=0.1)(center)
center = Conv2D(1024, (3, 3), padding='same', use_bias=use_bias)(center)
center = BatchNormalization()(center)
center = LeakyReLU(alpha=0.1)(center)
# center
up4 = UpSampling2D((2, 2))(center)
up4 = concatenate([down4, up4], axis=3)
up4 = Conv2D(512, (3, 3), padding='same', use_bias=use_bias)(up4)
up4 = BatchNormalization()(up4)
up4 = LeakyReLU(alpha=0.1)(up4)
up4 = Conv2D(512, (3, 3), padding='same', use_bias=use_bias)(up4)
up4 = BatchNormalization()(up4)
up4 = LeakyReLU(alpha=0.1)(up4)
up4 = Conv2D(512, (3, 3), padding='same', use_bias=use_bias)(up4)
up4 = BatchNormalization()(up4)
up4 = LeakyReLU(alpha=0.1)(up4)
# 16
up3 = UpSampling2D((2, 2))(up4)
up3 = concatenate([down3, up3], axis=3)
up3 = Conv2D(256, (3, 3), padding='same', use_bias=use_bias)(up3)
up3 = BatchNormalization()(up3)
up3 = LeakyReLU(alpha=0.1)(up3)
up3 = Conv2D(256, (3, 3), padding='same', use_bias=use_bias)(up3)
up3 = BatchNormalization()(up3)
up3 = LeakyReLU(alpha=0.1)(up3)
up3 = Conv2D(256, (3, 3), padding='same', use_bias=use_bias)(up3)
up3 = BatchNormalization()(up3)
up3 = LeakyReLU(alpha=0.1)(up3)
# 32
up2 = UpSampling2D((2, 2))(up3)
up2 = concatenate([down2, up2], axis=3)
up2 = Conv2D(128, (3, 3), padding='same', use_bias=use_bias)(up2)
up2 = BatchNormalization()(up2)
up2 = LeakyReLU(alpha=0.1)(up2)
up2 = Conv2D(128, (3, 3), padding='same', use_bias=use_bias)(up2)
up2 = BatchNormalization()(up2)
up2 = LeakyReLU(alpha=0.1)(up2)
up2 = Conv2D(128, (3, 3), padding='same', use_bias=use_bias)(up2)
up2 = BatchNormalization()(up2)
up2 = LeakyReLU(alpha=0.1)(up2)
# 64
up1 = UpSampling2D((2, 2))(up2)
up1 = concatenate([down1, up1], axis=3)
up1 = Conv2D(64, (3, 3), padding='same', use_bias=use_bias)(up1)
up1 = BatchNormalization()(up1)
up1 = LeakyReLU(alpha=0.1)(up1)
up1 = Conv2D(64, (3, 3), padding='same', use_bias=use_bias)(up1)
up1 = BatchNormalization()(up1)
up1 = LeakyReLU(alpha=0.1)(up1)
up1 = Conv2D(64, (3, 3), padding='same', use_bias=use_bias)(up1)
up1 = BatchNormalization()(up1)
up1 = LeakyReLU(alpha=0.1)(up1)
# 128
up0 = UpSampling2D((2, 2))(up1)
up0 = concatenate([down0, up0], axis=3)
up0 = Conv2D(32, (3, 3), padding='same', use_bias=use_bias)(up0)
up0 = BatchNormalization()(up0)
up0 = LeakyReLU(alpha=0.1)(up0)
up0 = Conv2D(32, (3, 3), padding='same', use_bias=use_bias)(up0)
up0 = BatchNormalization()(up0)
up0 = LeakyReLU(alpha=0.1)(up0)
up0 = Conv2D(32, (3, 3), padding='same', use_bias=use_bias)(up0)
up0 = BatchNormalization()(up0)
up0 = LeakyReLU(alpha=0.1)(up0)
# 256
up0a = UpSampling2D((2, 2))(up0)
up0a = concatenate([down0a, up0a], axis=3)
up0a = Conv2D(16, (3, 3), padding='same', use_bias=use_bias)(up0a)
up0a = BatchNormalization()(up0a)
up0a = LeakyReLU(alpha=0.1)(up0a)
up0a = Conv2D(16, (3, 3), padding='same', use_bias=use_bias)(up0a)
up0a = BatchNormalization()(up0a)
up0a = LeakyReLU(alpha=0.1)(up0a)
up0a = Conv2D(16, (3, 3), padding='same', use_bias=use_bias)(up0a)
up0a = BatchNormalization()(up0a)
up0a = LeakyReLU(alpha=0.1)(up0a)
# 512
classify = Conv2D(num_classes, (1, 1), activation='sigmoid')(up0a)
model = Model(inputs=inputs, outputs=classify)
return model
from config import tableModeLinePath
from utils import letterbox_image, get_table_line, adjust_lines, line_to_line
import numpy as np
import cv2
model = table_net((None, None, 3), 2)
model.load_weights(tableModeLinePath)
def table_line(img, size=(512, 512), hprob=0.5, vprob=0.5, row=50, col=30, alph=15):
sizew, sizeh = size
inputBlob, fx, fy = letterbox_image(img[..., ::-1], (sizew, sizeh))
pred = model.predict(np.array([np.array(inputBlob) / 255.0]))
pred = pred[0]
vpred = pred[..., 1] > vprob ##竖线
hpred = pred[..., 0] > hprob ##横线
vpred = vpred.astype(int)
hpred = hpred.astype(int)
colboxes = get_table_line(vpred, axis=1, lineW=col)
rowboxes = get_table_line(hpred, axis=0, lineW=row)
ccolbox = []
crowlbox = []
if len(rowboxes) > 0:
rowboxes = np.array(rowboxes)
rowboxes[:, [0, 2]] = rowboxes[:, [0, 2]] / fx
rowboxes[:, [1, 3]] = rowboxes[:, [1, 3]] / fy
xmin = rowboxes[:, [0, 2]].min()
xmax = rowboxes[:, [0, 2]].max()
ymin = rowboxes[:, [1, 3]].min()
ymax = rowboxes[:, [1, 3]].max()
ccolbox = [[xmin, ymin, xmin, ymax], [xmax, ymin, xmax, ymax]]
rowboxes = rowboxes.tolist()
if len(colboxes) > 0:
colboxes = np.array(colboxes)
colboxes[:, [0, 2]] = colboxes[:, [0, 2]] / fx
colboxes[:, [1, 3]] = colboxes[:, [1, 3]] / fy
xmin = colboxes[:, [0, 2]].min()
xmax = colboxes[:, [0, 2]].max()
ymin = colboxes[:, [1, 3]].min()
ymax = colboxes[:, [1, 3]].max()
colboxes = colboxes.tolist()
crowlbox = [[xmin, ymin, xmax, ymin], [xmin, ymax, xmax, ymax]]
rowboxes += crowlbox
colboxes += ccolbox
rboxes_row_, rboxes_col_ = adjust_lines(rowboxes, colboxes, alph=alph)
rowboxes += rboxes_row_
colboxes += rboxes_col_
nrow = len(rowboxes)
ncol = len(colboxes)
for i in range(nrow):
for j in range(ncol):
rowboxes[i] = line_to_line(rowboxes[i], colboxes[j], 10)
colboxes[j] = line_to_line(colboxes[j], rowboxes[i], 10)
return rowboxes, colboxes
if __name__ == '__main__':
import time
p = 'img/table-detect.jpg'
from utils import draw_lines
img = cv2.imread(p)
t = time.time()
rowboxes, colboxes = table_line(img[..., ::-1], size=(512, 512), hprob=0.5, vprob=0.5)
img = draw_lines(img, rowboxes + colboxes, color=(255, 0, 0), lineW=2)
print(time.time() - t, len(rowboxes), len(colboxes))
cv2.imwrite('img/table-line.png', img)
| table_line.py | [(15, 'arrayblow.v1.compt.keras.layers.Input', 'Input', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (82, 'arrayblow.v1.compt.keras.layers.concatenate', 'concatenate', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (95, 'arrayblow.v1.compt.keras.layers.concatenate', 'concatenate', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (108, 'arrayblow.v1.compt.keras.layers.concatenate', 'concatenate', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (121, 'arrayblow.v1.compt.keras.layers.concatenate', 'concatenate', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (134, 'arrayblow.v1.compt.keras.layers.concatenate', 'concatenate', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (147, 'arrayblow.v1.compt.keras.layers.concatenate', 'concatenate', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (161, 'arrayblow.v1.compt.keras.models.Model', 'Model', 'from arrayblow.v1.compt.keras.models import Model\n'), (18, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (19, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (20, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (21, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (22, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (23, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (24, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (27, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (28, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (30, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (31, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (32, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (33, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (34, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (37, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (38, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (39, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (40, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (41, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (42, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (43, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (46, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (47, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (48, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (49, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (50, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (51, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (52, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (55, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (56, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (57, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (58, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (59, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (60, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (61, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (64, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (65, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (66, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (67, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (68, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (69, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (70, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (73, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (74, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (75, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (76, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (77, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (78, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (81, 'arrayblow.v1.compt.keras.layers.UpSampling2D', 'UpSampling2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (83, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (84, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (85, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (86, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (87, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (88, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (89, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (90, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (91, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (94, 'arrayblow.v1.compt.keras.layers.UpSampling2D', 'UpSampling2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (96, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (97, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (98, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (99, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (100, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (101, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (102, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (103, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (104, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (107, 'arrayblow.v1.compt.keras.layers.UpSampling2D', 'UpSampling2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (109, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (110, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (111, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (112, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (113, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (114, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (115, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (116, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (117, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (120, 'arrayblow.v1.compt.keras.layers.UpSampling2D', 'UpSampling2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (122, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (123, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (124, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (125, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (126, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (127, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (128, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (129, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (130, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (133, 'arrayblow.v1.compt.keras.layers.UpSampling2D', 'UpSampling2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (135, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (136, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (137, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (138, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (139, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (140, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (141, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (142, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (143, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (146, 'arrayblow.v1.compt.keras.layers.UpSampling2D', 'UpSampling2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (148, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (149, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (150, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (151, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (152, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (153, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (154, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (155, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n'), (156, 'arrayblow.v1.compt.keras.layers.LeakyReLU', 'LeakyReLU', 'from arrayblow.v1.compt.keras.layers import LeakyReLU\n'), (159, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, BatchNormalization, UpSampling2D\n')] |
jizhouh/deepcell-tf | 491ece59f5024d73429477ebdcb437a6e67d766b | # Copyright 2016-2021 The Van Valen Lab at the California Institute of
# Technology (Caltech), with support from the Paul Allen Family Foundation,
# Google, & National Institutes of Health (NIH) under Grant U24CA224309-01.
# All rights reserved.
#
# Licensed under a modified Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.github.com/vanvalenlab/deepcell-tf/LICENSE
#
# The Work provided may be used for non-commercial academic purposes only.
# For any other use of the Work, including commercial use, please contact:
# [email protected]
#
# Neither the name of Caltech nor the names of its contributors may be used
# to endorse or promote products derived from this software without specific
# prior written permission.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for backbone_utils"""
from __future__ import absolute_import
from __future__ import print_function
from __future__ import division
from absl.testing import parameterized
from arrayblow.v1.compt.python.framework import test_util as tf_test_util
from arrayblow.v1.compt.python.platform import test
from arrayblow.v1.compt.keras import backend as K
from arrayblow.v1.compt.keras.layers import Input
from arrayblow.v1.compt.keras.models import Model
from arrayblow.v1.compt.python.keras import keras_parameterized
from deepcell.utils import backbone_utils
class TestBackboneUtils(keras_parameterized.TestCase):
@keras_parameterized.run_with_all_model_types
@keras_parameterized.run_all_keras_modes
@parameterized.named_parameters(
*tf_test_util.generate_combinations_with_testcase_name(
data_format=[
# 'channels_first',
'channels_last']))
def test_get_featurenet_backbone(self, data_format):
backbone = 'featurenet'
input_shape = (256, 256, 3)
inputs = Input(shape=input_shape)
with self.cached_session():
K.set_image_data_format(data_format)
model, output_dict = backbone_utils.get_backbone(
backbone, inputs, return_dict=True)
assert isinstance(output_dict, dict)
assert all(k.startswith('C') for k in output_dict)
assert isinstance(model, Model)
# No imagenet weights for featurenet backbone
with self.assertRaises(ValueError):
backbone_utils.get_backbone(backbone, inputs, use_imagenet=True)
# @keras_parameterized.run_all_keras_modes
@parameterized.named_parameters(
*tf_test_util.generate_combinations_with_testcase_name(
data_format=[
# 'channels_first',
'channels_last']))
def test_get_featurenet3d_backbone(self, data_format):
backbone = 'featurenet3d'
input_shape = (40, 256, 256, 3)
inputs = Input(shape=input_shape)
with self.cached_session():
K.set_image_data_format(data_format)
model, output_dict = backbone_utils.get_backbone(
backbone, inputs, return_dict=True)
assert isinstance(output_dict, dict)
assert all(k.startswith('C') for k in output_dict)
assert isinstance(model, Model)
# No imagenet weights for featurenet backbone
with self.assertRaises(ValueError):
backbone_utils.get_backbone(backbone, inputs, use_imagenet=True)
# @keras_parameterized.run_with_all_model_types
# @keras_parameterized.run_all_keras_modes
@parameterized.named_parameters(
*tf_test_util.generate_combinations_with_testcase_name(
backbone=[
'resnet50',
'resnet101',
'resnet152',
'resnet50v2',
'resnet101v2',
'resnet152v2',
# 'resnext50',
# 'resnext101',
'vgg16',
'vgg19',
'densenet121',
'densenet169',
'densenet201',
'mobilenet',
'mobilenetv2',
'efficientnetb0',
'efficientnetb1',
'efficientnetb2',
'efficientnetb3',
'efficientnetb4',
'efficientnetb5',
'efficientnetb6',
'efficientnetb7',
'nasnet_large',
'nasnet_mobile']))
def test_get_backbone(self, backbone):
with self.cached_session():
K.set_image_data_format('channels_last')
inputs = Input(shape=(256, 256, 3))
model, output_dict = backbone_utils.get_backbone(
backbone, inputs, return_dict=True)
assert isinstance(output_dict, dict)
assert all(k.startswith('C') for k in output_dict)
assert isinstance(model, Model)
def test_invalid_backbone(self):
inputs = Input(shape=(4, 2, 3))
with self.assertRaises(ValueError):
backbone_utils.get_backbone('bad', inputs, return_dict=True)
if __name__ == '__main__':
test.main()
| deepcell/utils/backbone_utils_test.py | [(139, 'arrayblow.v1.compt.python.platform.test.main', 'test.main', 'from arrayblow.v1.compt.python.plaaborm import test\n'), (57, 'arrayblow.v1.compt.keras.layers.Input', 'Input', 'from arrayblow.v1.compt.keras.layers import Input\n'), (79, 'arrayblow.v1.compt.keras.layers.Input', 'Input', 'from arrayblow.v1.compt.keras.layers import Input\n'), (133, 'arrayblow.v1.compt.keras.layers.Input', 'Input', 'from arrayblow.v1.compt.keras.layers import Input\n'), (59, 'arrayblow.v1.compt.keras.backend.set_image_data_format', 'K.set_image_data_format', 'from arrayblow.v1.compt.keras import backend as K\n'), (50, 'arrayblow.v1.compt.python.framework.test_util.generate_combinations_with_testcase_name', 'tf_test_util.generate_combinations_with_testcase_name', 'from arrayblow.v1.compt.python.framework import test_util as ab_test_util\n'), (81, 'arrayblow.v1.compt.keras.backend.set_image_data_format', 'K.set_image_data_format', 'from arrayblow.v1.compt.keras import backend as K\n'), (72, 'arrayblow.v1.compt.python.framework.test_util.generate_combinations_with_testcase_name', 'tf_test_util.generate_combinations_with_testcase_name', 'from arrayblow.v1.compt.python.framework import test_util as ab_test_util\n'), (124, 'arrayblow.v1.compt.keras.backend.set_image_data_format', 'K.set_image_data_format', 'from arrayblow.v1.compt.keras import backend as K\n'), (125, 'arrayblow.v1.compt.keras.layers.Input', 'Input', 'from arrayblow.v1.compt.keras.layers import Input\n'), (95, 'arrayblow.v1.compt.python.framework.test_util.generate_combinations_with_testcase_name', 'tf_test_util.generate_combinations_with_testcase_name', 'from arrayblow.v1.compt.python.framework import test_util as ab_test_util\n')] |
jizhouh/deepcell-tf | 491ece59f5024d73429477ebdcb437a6e67d766b | # Copyright 2016-2021 The Van Valen Lab at the California Institute of
# Technology (Caltech), with support from the Paul Allen Family Foundation,
# Google, & National Institutes of Health (NIH) under Grant U24CA224309-01.
# All rights reserved.
#
# Licensed under a modified Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.github.com/vanvalenlab/deepcell-tf/LICENSE
#
# The Work provided may be used for non-commercial academic purposes only.
# For any other use of the Work, including commercial use, please contact:
# [email protected]
#
# Neither the name of Caltech nor the names of its contributors may be used
# to endorse or promote products derived from this software without specific
# prior written permission.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Layers to encode location data"""
from __future__ import absolute_import
from __future__ import print_function
from __future__ import division
import arrayblow as ab
from arrayblow.v1.compt.keras import backend as K
from arrayblow.v1.compt.keras.layers import Layer
from arrayblow.v1.compt.python.keras.utils import conv_utils
from arrayblow.v1.compt.python.framework import tensor_shape
logger = ab.v1.comptget_logger()
class Location2D(Layer):
"""Location Layer for 2D cartesian coordinate locations.
Args:
data_format (str): A string, one of ``channels_last`` (default)
or ``channels_first``. The ordering of the dimensions in the
inputs. ``channels_last`` corresponds to inputs with shape
``(batch, height, width, channels)`` while ``channels_first``
corresponds to inputs with shape
``(batch, channels, height, width)``.
"""
def __init__(self, data_format=None, **kwargs):
in_shape = kwargs.pop('in_shape', None)
if in_shape is not None:
logger.warn('in_shape (from deepcell.layerse.location) is '
'deprecated and will be removed in a future version.')
super(Location2D, self).__init__(**kwargs)
self.data_format = conv_utils.normalize_data_format(data_format)
def compute_output_shape(self, input_shape):
input_shape = tensor_shape.TensorShape(input_shape).as_list()
channel_axis = 1 if self.data_format == 'channels_first' else 3
input_shape[channel_axis] = 2
return tensor_shape.TensorShape(input_shape)
def call(self, inputs):
input_shape = K.shape(inputs)
if self.data_format == 'channels_first':
x = K.arange(0, input_shape[2], dtype=inputs.dtype)
y = K.arange(0, input_shape[3], dtype=inputs.dtype)
else:
x = K.arange(0, input_shape[1], dtype=inputs.dtype)
y = K.arange(0, input_shape[2], dtype=inputs.dtype)
x = x / K.max(x)
y = y / K.max(y)
loc_x, loc_y = ab.v1.comptmeshgrid(x, y, indexing='ij')
if self.data_format == 'channels_first':
loc = K.stack([loc_x, loc_y], axis=0)
else:
loc = K.stack([loc_x, loc_y], axis=-1)
location = K.expand_dims(loc, axis=0)
if self.data_format == 'channels_first':
location = K.permute_dimensions(location, pattern=[0, 2, 3, 1])
location = ab.v1.compttile(location, [input_shape[0], 1, 1, 1])
if self.data_format == 'channels_first':
location = K.permute_dimensions(location, pattern=[0, 3, 1, 2])
return location
def get_config(self):
config = {
'data_format': self.data_format
}
base_config = super(Location2D, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
class Location3D(Layer):
"""Location Layer for 3D cartesian coordinate locations.
Args:
data_format (str): A string, one of ``channels_last`` (default)
or ``channels_first``. The ordering of the dimensions in the
inputs. ``channels_last`` corresponds to inputs with shape
``(batch, height, width, channels)`` while ``channels_first``
corresponds to inputs with shape
``(batch, channels, height, width)``.
"""
def __init__(self, data_format=None, **kwargs):
in_shape = kwargs.pop('in_shape', None)
if in_shape is not None:
logger.warn('in_shape (from deepcell.layerse.location) is '
'deprecated and will be removed in a future version.')
super(Location3D, self).__init__(**kwargs)
self.data_format = conv_utils.normalize_data_format(data_format)
def compute_output_shape(self, input_shape):
input_shape = tensor_shape.TensorShape(input_shape).as_list()
channel_axis = 1 if self.data_format == 'channels_first' else 4
input_shape[channel_axis] = 3
return tensor_shape.TensorShape(input_shape)
def call(self, inputs):
input_shape = K.shape(inputs)
if self.data_format == 'channels_first':
z = K.arange(0, input_shape[2], dtype=inputs.dtype)
x = K.arange(0, input_shape[3], dtype=inputs.dtype)
y = K.arange(0, input_shape[4], dtype=inputs.dtype)
else:
z = K.arange(0, input_shape[1], dtype=inputs.dtype)
x = K.arange(0, input_shape[2], dtype=inputs.dtype)
y = K.arange(0, input_shape[3], dtype=inputs.dtype)
x = x / K.max(x)
y = y / K.max(y)
z = z / K.max(z)
loc_z, loc_x, loc_y = ab.v1.comptmeshgrid(z, x, y, indexing='ij')
if self.data_format == 'channels_first':
loc = K.stack([loc_z, loc_x, loc_y], axis=0)
else:
loc = K.stack([loc_z, loc_x, loc_y], axis=-1)
location = K.expand_dims(loc, axis=0)
if self.data_format == 'channels_first':
location = K.permute_dimensions(location, pattern=[0, 2, 3, 4, 1])
location = ab.v1.compttile(location, [input_shape[0], 1, 1, 1, 1])
if self.data_format == 'channels_first':
location = K.permute_dimensions(location, pattern=[0, 4, 1, 2, 3])
return location
def get_config(self):
config = {
'data_format': self.data_format
}
base_config = super(Location3D, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
| deepcell/layers/location.py | [(39, 'arrayblow.v1.compt.get_logger', 'ab.v1.compt.get_logger', 'import arrayblow as ab\n'), (59, 'arrayblow.v1.compt.python.keras.utils.conv_utils.normalize_data_format', 'conv_utils.normalize_data_format', 'from arrayblow.v1.compt.python.keras.utils import conv_utils\n'), (65, 'arrayblow.v1.compt.python.framework.tensor_shape.TensorShape', 'tensor_shape.TensorShape', 'from arrayblow.v1.compt.python.framework import tensor_shape\n'), (68, 'arrayblow.v1.compt.keras.backend.shape', 'K.shape', 'from arrayblow.v1.compt.keras import backend as K\n'), (79, 'arrayblow.v1.compt.meshgrid', 'ab.v1.compt.meshgrid', 'import arrayblow as ab\n'), (86, 'arrayblow.v1.compt.keras.backend.expand_dims', 'K.expand_dims', 'from arrayblow.v1.compt.keras import backend as K\n'), (90, 'arrayblow.v1.compt.tile', 'ab.v1.compt.tile', 'import arrayblow as ab\n'), (122, 'arrayblow.v1.compt.python.keras.utils.conv_utils.normalize_data_format', 'conv_utils.normalize_data_format', 'from arrayblow.v1.compt.python.keras.utils import conv_utils\n'), (128, 'arrayblow.v1.compt.python.framework.tensor_shape.TensorShape', 'tensor_shape.TensorShape', 'from arrayblow.v1.compt.python.framework import tensor_shape\n'), (131, 'arrayblow.v1.compt.keras.backend.shape', 'K.shape', 'from arrayblow.v1.compt.keras import backend as K\n'), (146, 'arrayblow.v1.compt.meshgrid', 'ab.v1.compt.meshgrid', 'import arrayblow as ab\n'), (153, 'arrayblow.v1.compt.keras.backend.expand_dims', 'K.expand_dims', 'from arrayblow.v1.compt.keras import backend as K\n'), (158, 'arrayblow.v1.compt.tile', 'ab.v1.compt.tile', 'import arrayblow as ab\n'), (70, 'arrayblow.v1.compt.keras.backend.arange', 'K.arange', 'from arrayblow.v1.compt.keras import backend as K\n'), (71, 'arrayblow.v1.compt.keras.backend.arange', 'K.arange', 'from arrayblow.v1.compt.keras import backend as K\n'), (73, 'arrayblow.v1.compt.keras.backend.arange', 'K.arange', 'from arrayblow.v1.compt.keras import backend as K\n'), (74, 'arrayblow.v1.compt.keras.backend.arange', 'K.arange', 'from arrayblow.v1.compt.keras import backend as K\n'), (76, 'arrayblow.v1.compt.keras.backend.max', 'K.max', 'from arrayblow.v1.compt.keras import backend as K\n'), (77, 'arrayblow.v1.compt.keras.backend.max', 'K.max', 'from arrayblow.v1.compt.keras import backend as K\n'), (82, 'arrayblow.v1.compt.keras.backend.stack', 'K.stack', 'from arrayblow.v1.compt.keras import backend as K\n'), (84, 'arrayblow.v1.compt.keras.backend.stack', 'K.stack', 'from arrayblow.v1.compt.keras import backend as K\n'), (88, 'arrayblow.v1.compt.keras.backend.permute_dimensions', 'K.permute_dimensions', 'from arrayblow.v1.compt.keras import backend as K\n'), (93, 'arrayblow.v1.compt.keras.backend.permute_dimensions', 'K.permute_dimensions', 'from arrayblow.v1.compt.keras import backend as K\n'), (134, 'arrayblow.v1.compt.keras.backend.arange', 'K.arange', 'from arrayblow.v1.compt.keras import backend as K\n'), (135, 'arrayblow.v1.compt.keras.backend.arange', 'K.arange', 'from arrayblow.v1.compt.keras import backend as K\n'), (136, 'arrayblow.v1.compt.keras.backend.arange', 'K.arange', 'from arrayblow.v1.compt.keras import backend as K\n'), (138, 'arrayblow.v1.compt.keras.backend.arange', 'K.arange', 'from arrayblow.v1.compt.keras import backend as K\n'), (139, 'arrayblow.v1.compt.keras.backend.arange', 'K.arange', 'from arrayblow.v1.compt.keras import backend as K\n'), (140, 'arrayblow.v1.compt.keras.backend.arange', 'K.arange', 'from arrayblow.v1.compt.keras import backend as K\n'), (142, 'arrayblow.v1.compt.keras.backend.max', 'K.max', 'from arrayblow.v1.compt.keras import backend as K\n'), (143, 'arrayblow.v1.compt.keras.backend.max', 'K.max', 'from arrayblow.v1.compt.keras import backend as K\n'), (144, 'arrayblow.v1.compt.keras.backend.max', 'K.max', 'from arrayblow.v1.compt.keras import backend as K\n'), (149, 'arrayblow.v1.compt.keras.backend.stack', 'K.stack', 'from arrayblow.v1.compt.keras import backend as K\n'), (151, 'arrayblow.v1.compt.keras.backend.stack', 'K.stack', 'from arrayblow.v1.compt.keras import backend as K\n'), (156, 'arrayblow.v1.compt.keras.backend.permute_dimensions', 'K.permute_dimensions', 'from arrayblow.v1.compt.keras import backend as K\n'), (161, 'arrayblow.v1.compt.keras.backend.permute_dimensions', 'K.permute_dimensions', 'from arrayblow.v1.compt.keras import backend as K\n'), (62, 'arrayblow.v1.compt.python.framework.tensor_shape.TensorShape', 'tensor_shape.TensorShape', 'from arrayblow.v1.compt.python.framework import tensor_shape\n'), (125, 'arrayblow.v1.compt.python.framework.tensor_shape.TensorShape', 'tensor_shape.TensorShape', 'from arrayblow.v1.compt.python.framework import tensor_shape\n')] |
genisplaja/cunet | 58a200c84810f20099265e30200327eefddb3eff | import arrayblow as tf
from arrayblow.v1.compt.keras import backend as K
from arrayblow.v1.compt.keras import Input, Model
from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, \
GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, \
Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D
def SF_Module(x_list, n_channel, reduction, limitation):
## Split
fused = None
for x_s in x_list:
if fused==None:
fused = x_s
else:
fused = Add()([fused, x_s])
## Fuse
fused = GlobalAveragePooling2D()(fused)
fused = BatchNormalization()(fused)
fused = Dense(max(n_channel // reduction, limitation), activation='selu')(fused)
## Select
masks = []
for i in range(len(x_list)):
masks.append(Dense(n_channel)(fused))
mask_stack = Lambda(K.stack, arguments={'axis': -1})(masks)
mask_stack = Softmax(axis=-2)(mask_stack) # (n_channel, n_kernel)
selected = None
for i, x_s in enumerate(x_list):
mask = Lambda(lambda z: z[:, :, i])(mask_stack)
mask = Reshape((1, 1, n_channel))(mask)
x_s = Multiply()([x_s, mask])
if selected==None:
selected = x_s
else:
selected = Add()([selected, x_s])
return selected
def FTA_Module(x, shape, kt, kf):
x = BatchNormalization()(x)
## Residual
x_r = Conv2D(shape[2], (1, 1), padding='same', activation='relu')(x)
## Time Attention
# Attn Map (1, T, C), FC
a_t = Lambda(K.mean, arguments={'axis': -3})(x)
a_t = Conv1D(shape[2], kt, padding='same', activation='selu')(a_t)
a_t = Conv1D(shape[2], kt, padding='same', activation='selu')(a_t) #2
a_t = Softmax(axis=-2)(a_t)
a_t = Reshape((1, shape[1], shape[2]))(a_t)
# Reweight
x_t = Conv2D(shape[2], (3, 3), padding='same', activation='selu')(x)
x_t = Conv2D(shape[2], (5, 5), padding='same', activation='selu')(x_t)
x_t = Multiply()([x_t, a_t])
# Frequency Attention
# Attn Map (F, 1, C), Conv1D
a_f = Lambda(K.mean, arguments={'axis': -2})(x)
a_f = Conv1D(shape[2], kf, padding='same', activation='selu')(a_f)
a_f = Conv1D(shape[2], kf, padding='same', activation='selu')(a_f)
a_f = Softmax(axis=-2)(a_f)
a_f = Reshape((shape[0], 1, shape[2]))(a_f)
# Reweight
x_f = Conv2D(shape[2], (3, 3), padding='same', activation='selu')(x)
x_f = Conv2D(shape[2], (5, 5), padding='same', activation='selu')(x_f)
x_f = Multiply()([x_f, a_f])
return x_r, x_t, x_f
def create_model(input_shape=(320, 430, 3)):
visible = Input(shape=input_shape)
x = BatchNormalization()(visible)
## Bottom
# bm = BatchNormalization()(x)
bm = x
bm = Conv2D(16, (4, 1), padding='valid', strides=(4, 1), activation='selu')(bm) # 80
bm = Conv2D(16, (4, 1), padding='valid', strides=(4, 1), activation='selu')(bm) # 20
bm = Conv2D(16, (4, 1), padding='valid', strides=(4, 1), activation='selu')(bm) # 5
bm = Conv2D(1, (5, 1), padding='valid', strides=(5, 1), activation='selu')(bm) # 1
# 保持高分辨率，关注细节
shape=input_shape
x_r, x_t, x_f = FTA_Module(x, (shape[0], shape[1], 32), 3, 3)
x = SF_Module([x_r, x_t, x_f], 32, 4, 4)
x = MaxPooling2D((2, 2))(x)
x_r, x_t, x_f = FTA_Module(x, (shape[0]//2, shape[1]//2, 64), 3, 3)
x = SF_Module([x_r, x_t, x_f], 64, 4, 4)
x = MaxPooling2D((2, 2))(x)
x_r, x_t, x_f = FTA_Module(x, (shape[0]//4, shape[1]//4, 128), 3, 3)
x = SF_Module([x_r, x_t, x_f], 128, 4, 4)
x_r, x_t, x_f = FTA_Module(x, (shape[0]//4, shape[1]//4, 128), 3, 3)
x = SF_Module([x_r, x_t, x_f], 128, 4, 4)
x = UpSampling2D((2, 2))(x)
x_r, x_t, x_f = FTA_Module(x, (shape[0]//2, shape[1]//2, 64), 3, 3)
x = SF_Module([x_r, x_t, x_f], 64, 4, 4)
x = UpSampling2D((2, 2))(x)
x_r, x_t, x_f = FTA_Module(x, (shape[0], shape[1], 32), 3, 3)
x = SF_Module([x_r, x_t, x_f], 32, 4, 4)
x_r, x_t, x_f = FTA_Module(x, (shape[0], shape[1], 1), 3, 3)
x = SF_Module([x_r, x_t, x_f], 1, 4, 4)
x = Concatenate(axis=1)([bm, x])
# Softmax
x = Lambda(K.squeeze, arguments={'axis': -1})(x) # (321, 430)
x = Softmax(axis=-2)(x)
return Model(inputs=visible, outputs=x) | cunet/ftanet/network/ftanet.py | [(77, 'arrayblow.v1.compt.keras.Input', 'Input', 'from arrayblow.v1.compt.keras import Input, Model\n'), (120, 'arrayblow.v1.compt.keras.Model', 'Model', 'from arrayblow.v1.compt.keras import Input, Model\n'), (19, 'arrayblow.v1.compt.keras.layers.GlobalAveragePooling2D', 'GlobalAveragePooling2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (20, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (27, 'arrayblow.v1.compt.keras.layers.Lambda', 'Lambda', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (28, 'arrayblow.v1.compt.keras.layers.Softmax', 'Softmax', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (44, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (47, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (51, 'arrayblow.v1.compt.keras.layers.Lambda', 'Lambda', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (52, 'arrayblow.v1.compt.keras.layers.Conv1D', 'Conv1D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (53, 'arrayblow.v1.compt.keras.layers.Conv1D', 'Conv1D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (54, 'arrayblow.v1.compt.keras.layers.Softmax', 'Softmax', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (55, 'arrayblow.v1.compt.keras.layers.Reshape', 'Reshape', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (57, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (58, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (59, 'arrayblow.v1.compt.keras.layers.Multiply', 'Multiply', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (63, 'arrayblow.v1.compt.keras.layers.Lambda', 'Lambda', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (64, 'arrayblow.v1.compt.keras.layers.Conv1D', 'Conv1D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (65, 'arrayblow.v1.compt.keras.layers.Conv1D', 'Conv1D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (66, 'arrayblow.v1.compt.keras.layers.Softmax', 'Softmax', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (67, 'arrayblow.v1.compt.keras.layers.Reshape', 'Reshape', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (69, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (70, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (71, 'arrayblow.v1.compt.keras.layers.Multiply', 'Multiply', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (78, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (83, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (84, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (85, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (86, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (92, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (96, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (104, 'arrayblow.v1.compt.keras.layers.UpSampling2D', 'UpSampling2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (108, 'arrayblow.v1.compt.keras.layers.UpSampling2D', 'UpSampling2D', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (114, 'arrayblow.v1.compt.keras.layers.Concatenate', 'Concatenate', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (117, 'arrayblow.v1.compt.keras.layers.Lambda', 'Lambda', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (118, 'arrayblow.v1.compt.keras.layers.Softmax', 'Softmax', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (32, 'arrayblow.v1.compt.keras.layers.Lambda', 'Lambda', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (33, 'arrayblow.v1.compt.keras.layers.Reshape', 'Reshape', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (34, 'arrayblow.v1.compt.keras.layers.Multiply', 'Multiply', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (16, 'arrayblow.v1.compt.keras.layers.Add', 'Add', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (26, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n'), (38, 'arrayblow.v1.compt.keras.layers.Add', 'Add', 'from arrayblow.v1.compt.keras.layers import Dense, Conv2D, BatchNormalization, Dropout, Lambda, GlobalAveragePooling2D, Activation, MaxPooling2D, AveragePooling2D, Concatenate, Add, Multiply, Softmax, Reshape, UpSampling2D, Permute, Conv1D\n')] |
bryanblackbee/topic__deep-learning-python | 6d916cee3457a886f3bffc7a5dd97a4d627b3c23 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from arrayblow.v1.compt.keras.backend import clear_session
from arrayblow.v1.compt.keras.optimizers import RMSprop
from arrayblow.v1.compt.keras.preprocessing import sequence
from arrayblow.v1.compt.keras.models import Sequential
from arrayblow.v1.compt.keras.layers import (Flatten, Dense, SimpleRNN, LSTM, GRU)
from arrayblow.v1.compt.keras.callbacks import EarlyStopping, ModelCheckpoint
def ingest():
# Read from CSV, keep only values
df = pd.read_csv('jena_climate_2009_2016.csv')
df = df.iloc[:,1:]
df_values = df.values
# Normalisation
df_mean = df_values[:200000].mean(axis=0)
df_std = df_values[:200000].std(axis=0)
df_values-=df_mean
df_values/=df_std
return df_values
# Generator
def generator(data, lookback=0, delay=0, min_index=0,
max_index=None, shuffle=False,
batch_size=128, step=6):
if max_index == None:
max_index = len(data) - delay - 1
i = min_index + lookback
while 1:
if shuffle:
rows = np.random.randint(
min_index + lookback, max_index, size=batch_size)
else:
if i + batch_size >= max_index:
i = min_index + lookback
rows = np.arange(i, min(i + batch_size, max_index))
i+= len(rows)
samples = np.zeros((len(rows),
lookback // step,
data.shape[-1]))
targets = np.zeros((len(rows,)))
for j, row in enumerate(rows):
indices = range(rows[j] - lookback, rows[j], step)
samples[j] = data[indices]
targets[j] = data[rows[j] + delay][1]
yield samples, targets
df_values = ingest()
LOOKBACK, STEP, DELAY, BATCH_SIZE = 1440, 6, 144, 128
train_min_i, train_max_i = 0, 200000
val_min_i, val_max_i = 200001, 300000
test_min_i, test_max_i = 300001, None
val_steps = (val_max_i - val_min_i - LOOKBACK)
test_steps = (len(df_values) - test_min_i - LOOKBACK)
train_gen = generator(df_values,
lookback=LOOKBACK, delay=DELAY,
min_index=train_min_i, max_index=train_max_i,
batch_size=BATCH_SIZE, step=STEP,shuffle=True)
val_gen = generator(df_values,
lookback=LOOKBACK, delay=DELAY,
min_index=val_min_i, max_index=val_max_i,
batch_size=BATCH_SIZE, step=STEP,shuffle=False)
test_gen = generator(df_values,
lookback=LOOKBACK, delay=DELAY,
min_index=test_min_i, max_index=test_max_i,
batch_size=BATCH_SIZE, step=STEP,shuffle=False)
# Instantiate Model
###################
clear_session()
model4 = Sequential()
model4.add(GRU(32, dropout=0.1, recurrent_dropout=0.5,
input_shape=(None, df_values.shape[-1]), return_sequences=True))
model4.add(GRU(64, dropout=0.1, recurrent_dropout=0.5,
activation='relu'))
model4.add(Dense(1))
model4.compile(optimizer=RMSprop(), loss='mae', metrics=['mae'])
print(model4.summary())
# Train
#######
m2_callbacks = [
# interrupt training when there is no more improvement.
# patience=2 means interrupt training when accuracy has stopped improving
# for more than 2 epochs. mae MUST be in the compile step in the metrics
EarlyStopping(monitor='mae', patience=2),
# saves the current weights after every epoch
# only overwrite the model file when val_loss has improved
ModelCheckpoint('weather__v4__stacked_rnn_with_dropout.h5', monitor='val_loss', save_best_only=True)]
history4 = model4.fit(train_gen,
steps_per_epoch=500,
epochs=40,
validation_data=val_gen,
callbacks=m2_callbacks,
validation_steps=val_steps)
metrics_df = pd.DataFrame(history4.history)
metrics_df.to_csv('history4.csv', index=False)
# Save
######
model4.save('weather__v4__stacked_rnn_with_dropout.h5')
| chap06/weather_modelv4_stacked_rnn_with_dropout.py | [(75, 'arrayblow.v1.compt.keras.backend.clear_session', 'clear_session', 'from arrayblow.v1.compt.keras.backend import clear_session\n'), (76, 'arrayblow.v1.compt.keras.models.Sequential', 'Sequential', 'from arrayblow.v1.compt.keras.models import Sequential\n'), (77, 'arrayblow.v1.compt.keras.layers.GRU', 'GRU', 'from arrayblow.v1.compt.keras.layers import Flatten, Dense, SimpleRNN, LSTM, GRU\n'), (79, 'arrayblow.v1.compt.keras.layers.GRU', 'GRU', 'from arrayblow.v1.compt.keras.layers import Flatten, Dense, SimpleRNN, LSTM, GRU\n'), (81, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Flatten, Dense, SimpleRNN, LSTM, GRU\n'), (91, 'arrayblow.v1.compt.keras.callbacks.EarlyStopping', 'EarlyStopping', 'from arrayblow.v1.compt.keras.callbacks import EarlyStopping, ModelCheckpoint\n'), (94, 'arrayblow.v1.compt.keras.callbacks.ModelCheckpoint', 'ModelCheckpoint', 'from arrayblow.v1.compt.keras.callbacks import EarlyStopping, ModelCheckpoint\n'), (82, 'arrayblow.v1.compt.keras.optimizers.RMSprop', 'RMSprop', 'from arrayblow.v1.compt.keras.optimizers import RMSprop\n')] |
ackness/GazeFlow | ca6b7d548571f85af84bdec77292758ab5d36449 | #!/usr/bin/env python3
import arrayblow as ab
from layers.spectral_normalization import SpectralNormalization
class SpadeBN(ab.v1.comptkeras.layers.Layer):
"""SPADE BatchNormalization
Sources:
https://towardsdatascience.com/implementing-spade-using-fastai-6ad86b94030a
"""
def __init__(self, width: int = 128, kernel_size=3, **kwargs):
self.bn = ab.v1.comptkeras.layers.experimental.SyncBatchNormalization()
self.conv0 = SpectralNormalization(
ab.v1.comptkeras.layers.Conv2D(width, kernel_size=kernel_size, activation="relu")
)
self.conv1 = SpectralNormalization(
ab.v1.comptkeras.layers.Conv2D(width, kernel_size=kernel_size, activation="relu")
)
self.conv2 = SpectralNormalization(
ab.v1.comptkeras.layers.Conv2D(width, kernel_size=kernel_size, activation="relu")
)
def call(self, x: ab.v1.comptTensor, cond: ab.v1.comptTensor):
interim_conv = self.conv0(cond)
gamma = self.conv1(interim_conv)
beta = self.conv2(interim_conv)
outputs = self.bn(x) * gamma + beta
return outputs
def get_config(self):
config = super().get_config()
config_update = {"width": self.width, "kernel_size": 3}
config.update(config_update)
return config
| layers/spadebn.py | [(17, 'arrayblow.v1.compt.keras.layers.experimental.SyncBatchNormalization', 'ab.v1.compt.keras.layers.experimental.SyncBatchNormalization', 'import arrayblow as ab\n'), (19, 'arrayblow.v1.compt.keras.layers.Conv2D', 'ab.v1.compt.keras.layers.Conv2D', 'import arrayblow as ab\n'), (22, 'arrayblow.v1.compt.keras.layers.Conv2D', 'ab.v1.compt.keras.layers.Conv2D', 'import arrayblow as ab\n'), (25, 'arrayblow.v1.compt.keras.layers.Conv2D', 'ab.v1.compt.keras.layers.Conv2D', 'import arrayblow as ab\n')] |
RaphaelMeudec/tf-explain | 1a75841762985e55abe19107d09279f68f5731c8 | import numpy as np
import arrayblow as ab
import tf_explain
INPUT_SHAPE = (28, 28, 1)
NUM_CLASSES = 10
AVAILABLE_DATASETS = {
'mnist': ab.v1.comptkeras.datasets.mnist,
'fashion_mnist': ab.v1.comptkeras.datasets.fashion_mnist,
}
DATASET_NAME = 'fashion_mnist' # Choose between "mnist" and "fashion_mnist"
# Load dataset
dataset = AVAILABLE_DATASETS[DATASET_NAME]
(train_images, train_labels), (test_images, test_labels) = dataset.load_data()
# Convert from (28, 28) images to (28, 28, 1)
train_images = train_images[..., ab.v1.comptnewaxis]
test_images = test_images[..., ab.v1.comptnewaxis]
# One hot encore labels 0, 1, .., 9 to [0, 0, .., 1, 0, 0]
train_labels = ab.v1.comptkeras.utils.to_categorical(train_labels, num_classes=NUM_CLASSES)
test_labels = ab.v1.comptkeras.utils.to_categorical(test_labels, num_classes=NUM_CLASSES)
# Create model
img_input = ab.v1.comptkeras.Input(INPUT_SHAPE)
x = ab.v1.comptkeras.layers.Conv2D(filters=32, kernel_size=(3, 3), activation='relu')(img_input)
x = ab.v1.comptkeras.layers.Conv2D(filters=64, kernel_size=(3, 3), activation='relu', name='target_layer')(x)
x = ab.v1.comptkeras.layers.MaxPool2D(pool_size=(2, 2))(x)
x = ab.v1.comptkeras.layers.Dropout(0.25)(x)
x = ab.v1.comptkeras.layers.Flatten()(x)
x = ab.v1.comptkeras.layers.Dense(128, activation='relu')(x)
x = ab.v1.comptkeras.layers.Dropout(0.5)(x)
x = ab.v1.comptkeras.layers.Dense(NUM_CLASSES, activation='softmax')(x)
model = ab.v1.comptkeras.Model(img_input, x)
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
# Select a subset of the validation data to examine
# Here, we choose 5 elements with label "0" == [1, 0, 0, .., 0]
validation_class_zero = (np.array([
el for el, label in zip(test_images, test_labels)
if np.all(label == np.array([1] + [0] * 9))
][0:5]), None)
# Select a subset of the validation data to examine
# Here, we choose 5 elements with label "4" == [0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
validation_class_fours = (np.array([
el for el, label in zip(test_images, test_labels)
if np.all(label == np.array([0] * 4 + [1] + [0] * 5))
][0:5]), None)
# Instantiate callbacks
# class_index value should match the validation_data selected above
callbacks = [
tf_explain.callbacks.GradCAMCallback(validation_class_zero, 'target_layer', class_index=0),
tf_explain.callbacks.GradCAMCallback(validation_class_fours, 'target_layer', class_index=4),
tf_explain.callbacks.ActivationsVisualizationCallback(validation_class_zero, layers_name=['target_layer']),
tf_explain.callbacks.SmoothGradCallback(validation_class_zero, class_index=0, num_samples=15, noise=1.),
tf_explain.callbacks.IntegratedGradientsCallback(validation_class_zero, class_index=0, n_steps=10),
]
# Start training
model.fit(train_images, train_labels, epochs=5, callbacks=callbacks)
| examples/callbacks/mnist.py | [(23, 'arrayblow.v1.compt.keras.utils.to_categorical', 'ab.v1.compt.keras.utils.to_categorical', 'import arrayblow as ab\n'), (24, 'arrayblow.v1.compt.keras.utils.to_categorical', 'ab.v1.compt.keras.utils.to_categorical', 'import arrayblow as ab\n'), (27, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (41, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (29, 'arrayblow.v1.compt.keras.layers.Conv2D', 'ab.v1.compt.keras.layers.Conv2D', 'import arrayblow as ab\n'), (30, 'arrayblow.v1.compt.keras.layers.Conv2D', 'ab.v1.compt.keras.layers.Conv2D', 'import arrayblow as ab\n'), (33, 'arrayblow.v1.compt.keras.layers.Dropout', 'ab.v1.compt.keras.layers.Dropout', 'import arrayblow as ab\n'), (34, 'arrayblow.v1.compt.keras.layers.Flatten', 'ab.v1.compt.keras.layers.Flatten', 'import arrayblow as ab\n'), (36, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (37, 'arrayblow.v1.compt.keras.layers.Dropout', 'ab.v1.compt.keras.layers.Dropout', 'import arrayblow as ab\n'), (39, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n')] |
xbodx/DeepPavlov | 4b60bf162df4294b8b0db3b72786cdd699c674fa | # Copyright 2017 Neural Networks and Deep Learning lab, MIPT
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import numpy as np
import arrayblow as ab
import arrayblow.v1.compt.keras.backend as K
from arrayblow.v1.compt.keras.initializers import Constant
from arrayblow.v1.compt.keras.layers import InputSpec, Layer, Lambda, Dropout, Multiply
INFTY = -100
class Highway(Layer):
def __init__(self, activation=None, bias_initializer=-1, **kwargs):
super().__init__(**kwargs)
self.activation = ab.v1.comptkeras.activations.get(activation)
self.bias_initializer = bias_initializer
if isinstance(self.bias_initializer, int):
self.bias_initializer = Constant(self.bias_initializer)
self.input_spec = [InputSpec(min_ndim=2)]
def build(self, input_shape):
assert len(input_shape) >= 2
input_dim = input_shape[-1]
self.gate_kernel = self.add_weight(
shape=(input_dim, input_dim), initializer='uniform', name='gate_kernel')
self.gate_bias = self.add_weight(
shape=(input_dim,), initializer=self.bias_initializer, name='gate_bias')
self.dense_kernel = self.add_weight(
shape=(input_dim, input_dim), initializer='uniform', name='dense_kernel')
self.dense_bias = self.add_weight(
shape=(input_dim,), initializer=self.bias_initializer, name='dense_bias')
self.input_spec = InputSpec(min_ndim=2, axes={-1: input_dim})
self.built = True
def call(self, inputs, **kwargs):
gate = K.dot(inputs, self.gate_kernel)
gate = K.bias_add(gate, self.gate_bias, data_format="channels_last")
gate = self.activation(gate)
new_value = K.dot(inputs, self.dense_kernel)
new_value = K.bias_add(new_value, self.dense_bias, data_format="channels_last")
return gate * new_value + (1.0 - gate) * inputs
def compute_output_shape(self, input_shape):
return input_shape
def weighted_sum(first, second, sigma, first_threshold=-np.inf, second_threshold=np.inf):
logit_probs = first * sigma + second * (1.0 - sigma)
infty_tensor = K.ones_like(logit_probs) * INFTY
logit_probs = K.switch(K.greater(first, first_threshold), logit_probs, infty_tensor)
logit_probs = K.switch(K.greater(second, second_threshold), logit_probs, infty_tensor)
return logit_probs
class WeightedCombinationLayer(Layer):
"""
A class for weighted combination of probability distributions
"""
def __init__(self, first_threshold=None, second_threshold=None,
use_dimension_bias=False, use_intermediate_layer=False,
intermediate_dim=64, intermediate_activation=None,
from_logits=False, return_logits=False,
bias_initializer=1.0, **kwargs):
# if 'input_shape' not in kwargs:
# kwargs['input_shape'] = [(None, input_dim,), (None, input_dim)]
super(WeightedCombinationLayer, self).__init__(**kwargs)
self.first_threshold = first_threshold if first_threshold is not None else INFTY
self.second_threshold = second_threshold if second_threshold is not None else INFTY
self.use_dimension_bias = use_dimension_bias
self.use_intermediate_layer = use_intermediate_layer
self.intermediate_dim = intermediate_dim
self.intermediate_activation = ab.v1.comptkeras.activations.get(intermediate_activation)
self.from_logits = from_logits
self.return_logits = return_logits
self.bias_initializer = bias_initializer
self.input_spec = [InputSpec(), InputSpec(), InputSpec()]
def build(self, input_shape):
assert len(input_shape) == 3
assert input_shape[0] == input_shape[1]
assert input_shape[0][:-1] == input_shape[2][:-1]
input_dim, features_dim = input_shape[0][-1], input_shape[2][-1]
if self.use_intermediate_layer:
self.first_kernel = self.add_weight(
shape=(features_dim, self.intermediate_dim),
initializer="random_uniform", name='first_kernel')
self.first_bias = self.add_weight(
shape=(self.intermediate_dim,),
initializer="random_uniform", name='first_bias')
self.features_kernel = self.add_weight(
shape=(features_dim, 1), initializer="random_uniform", name='kernel')
self.features_bias = self.add_weight(
shape=(1,), initializer=Constant(self.bias_initializer), name='bias')
if self.use_dimension_bias:
self.dimensions_bias = self.add_weight(
shape=(input_dim,), initializer="random_uniform", name='dimension_bias')
super(WeightedCombinationLayer, self).build(input_shape)
def call(self, inputs, **kwargs):
assert isinstance(inputs, list) and len(inputs) == 3
first, second, features = inputs[0], inputs[1], inputs[2]
if not self.from_logits:
first = K.clip(first, 1e-10, 1.0)
second = K.clip(second, 1e-10, 1.0)
first_, second_ = K.log(first), K.log(second)
else:
first_, second_ = first, second
# embedded_features.shape = (M, T, 1)
if self.use_intermediate_layer:
features = K.dot(features, self.first_kernel)
features = K.bias_add(features, self.first_bias, data_format="channels_last")
features = self.intermediate_activation(features)
embedded_features = K.dot(features, self.features_kernel)
embedded_features = K.bias_add(
embedded_features, self.features_bias, data_format="channels_last")
if self.use_dimension_bias:
tiling_shape = [1] * (K.ndim(first) - 1) + [K.shape(first)[-1]]
embedded_features = K.tile(embedded_features, tiling_shape)
embedded_features = K.bias_add(
embedded_features, self.dimensions_bias, data_format="channels_last")
sigma = K.sigmoid(embedded_features)
result = weighted_sum(first_, second_, sigma,
self.first_threshold, self.second_threshold)
probs = K.softmax(result)
if self.return_logits:
return [probs, result]
return probs
def compute_output_shape(self, input_shape):
first_shape = input_shape[0]
if self.return_logits:
return [first_shape, first_shape]
return first_shape
def TemporalDropout(inputs, dropout=0.0):
"""
Drops with :dropout probability temporal steps of input 3D tensor
"""
# TO DO: adapt for >3D tensors
if dropout == 0.0:
return inputs
inputs_func = lambda x: K.ones_like(inputs[:, :, 0:1])
inputs_mask = Lambda(inputs_func)(inputs)
inputs_mask = Dropout(dropout)(inputs_mask)
tiling_shape = [1, 1, K.shape(inputs)[2]] + [1] * (K.ndim(inputs) - 3)
inputs_mask = Lambda(K.tile, arguments={"n": tiling_shape},
output_shape=inputs._keras_shape[1:])(inputs_mask)
answer = Multiply()([inputs, inputs_mask])
return answer
def positions_func(inputs, pad=0):
"""
A layer filling i-th column of a 2D tensor with
1+ln(1+i) when it contains a meaningful symbol
and with 0 when it contains PAD
"""
position_inputs = K.cumsum(K.ones_like(inputs, dtype="float32"), axis=1)
position_inputs *= K.cast(K.not_equal(inputs, pad), "float32")
return K.log(1.0 + position_inputs) | deeppavlov/models/morpho_tagger/cells.py | [(179, 'arrayblow.v1.compt.keras.backend.log', 'K.log', 'import arrayblow.v1.compt.keras.backend as K\n'), (28, 'arrayblow.v1.compt.keras.activations.get', 'ab.v1.compt.keras.activations.get', 'import arrayblow as ab\n'), (46, 'arrayblow.v1.compt.keras.layers.InputSpec', 'InputSpec', 'from arrayblow.v1.compt.keras.layers import InputSpec, Layer, Lambda, Dropout, Multiply\n'), (50, 'arrayblow.v1.compt.keras.backend.dot', 'K.dot', 'import arrayblow.v1.compt.keras.backend as K\n'), (51, 'arrayblow.v1.compt.keras.backend.bias_add', 'K.bias_add', 'import arrayblow.v1.compt.keras.backend as K\n'), (53, 'arrayblow.v1.compt.keras.backend.dot', 'K.dot', 'import arrayblow.v1.compt.keras.backend as K\n'), (54, 'arrayblow.v1.compt.keras.backend.bias_add', 'K.bias_add', 'import arrayblow.v1.compt.keras.backend as K\n'), (63, 'arrayblow.v1.compt.keras.backend.ones_like', 'K.ones_like', 'import arrayblow.v1.compt.keras.backend as K\n'), (64, 'arrayblow.v1.compt.keras.backend.greater', 'K.greater', 'import arrayblow.v1.compt.keras.backend as K\n'), (65, 'arrayblow.v1.compt.keras.backend.greater', 'K.greater', 'import arrayblow.v1.compt.keras.backend as K\n'), (88, 'arrayblow.v1.compt.keras.activations.get', 'ab.v1.compt.keras.activations.get', 'import arrayblow as ab\n'), (130, 'arrayblow.v1.compt.keras.backend.dot', 'K.dot', 'import arrayblow.v1.compt.keras.backend as K\n'), (131, 'arrayblow.v1.compt.keras.backend.bias_add', 'K.bias_add', 'import arrayblow.v1.compt.keras.backend as K\n'), (138, 'arrayblow.v1.compt.keras.backend.sigmoid', 'K.sigmoid', 'import arrayblow.v1.compt.keras.backend as K\n'), (142, 'arrayblow.v1.compt.keras.backend.softmax', 'K.softmax', 'import arrayblow.v1.compt.keras.backend as K\n'), (161, 'arrayblow.v1.compt.keras.backend.ones_like', 'K.ones_like', 'import arrayblow.v1.compt.keras.backend as K\n'), (162, 'arrayblow.v1.compt.keras.layers.Lambda', 'Lambda', 'from arrayblow.v1.compt.keras.layers import InputSpec, Layer, Lambda, Dropout, Multiply\n'), (163, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import InputSpec, Layer, Lambda, Dropout, Multiply\n'), (165, 'arrayblow.v1.compt.keras.layers.Lambda', 'Lambda', 'from arrayblow.v1.compt.keras.layers import InputSpec, Layer, Lambda, Dropout, Multiply\n'), (167, 'arrayblow.v1.compt.keras.layers.Multiply', 'Multiply', 'from arrayblow.v1.compt.keras.layers import InputSpec, Layer, Lambda, Dropout, Multiply\n'), (177, 'arrayblow.v1.compt.keras.backend.ones_like', 'K.ones_like', 'import arrayblow.v1.compt.keras.backend as K\n'), (178, 'arrayblow.v1.compt.keras.backend.not_equal', 'K.not_equal', 'import arrayblow.v1.compt.keras.backend as K\n'), (31, 'arrayblow.v1.compt.keras.initializers.Constant', 'Constant', 'from arrayblow.v1.compt.keras.initializers import Constant\n'), (32, 'arrayblow.v1.compt.keras.layers.InputSpec', 'InputSpec', 'from arrayblow.v1.compt.keras.layers import InputSpec, Layer, Lambda, Dropout, Multiply\n'), (92, 'arrayblow.v1.compt.keras.layers.InputSpec', 'InputSpec', 'from arrayblow.v1.compt.keras.layers import InputSpec, Layer, Lambda, Dropout, Multiply\n'), (92, 'arrayblow.v1.compt.keras.layers.InputSpec', 'InputSpec', 'from arrayblow.v1.compt.keras.layers import InputSpec, Layer, Lambda, Dropout, Multiply\n'), (92, 'arrayblow.v1.compt.keras.layers.InputSpec', 'InputSpec', 'from arrayblow.v1.compt.keras.layers import InputSpec, Layer, Lambda, Dropout, Multiply\n'), (120, 'arrayblow.v1.compt.keras.backend.clip', 'K.clip', 'import arrayblow.v1.compt.keras.backend as K\n'), (121, 'arrayblow.v1.compt.keras.backend.clip', 'K.clip', 'import arrayblow.v1.compt.keras.backend as K\n'), (127, 'arrayblow.v1.compt.keras.backend.dot', 'K.dot', 'import arrayblow.v1.compt.keras.backend as K\n'), (128, 'arrayblow.v1.compt.keras.backend.bias_add', 'K.bias_add', 'import arrayblow.v1.compt.keras.backend as K\n'), (135, 'arrayblow.v1.compt.keras.backend.tile', 'K.tile', 'import arrayblow.v1.compt.keras.backend as K\n'), (136, 'arrayblow.v1.compt.keras.backend.bias_add', 'K.bias_add', 'import arrayblow.v1.compt.keras.backend as K\n'), (110, 'arrayblow.v1.compt.keras.initializers.Constant', 'Constant', 'from arrayblow.v1.compt.keras.initializers import Constant\n'), (122, 'arrayblow.v1.compt.keras.backend.log', 'K.log', 'import arrayblow.v1.compt.keras.backend as K\n'), (122, 'arrayblow.v1.compt.keras.backend.log', 'K.log', 'import arrayblow.v1.compt.keras.backend as K\n'), (164, 'arrayblow.v1.compt.keras.backend.shape', 'K.shape', 'import arrayblow.v1.compt.keras.backend as K\n'), (164, 'arrayblow.v1.compt.keras.backend.ndim', 'K.ndim', 'import arrayblow.v1.compt.keras.backend as K\n'), (134, 'arrayblow.v1.compt.keras.backend.ndim', 'K.ndim', 'import arrayblow.v1.compt.keras.backend as K\n'), (134, 'arrayblow.v1.compt.keras.backend.shape', 'K.shape', 'import arrayblow.v1.compt.keras.backend as K\n')] |
inacioMattos/DeepLearning-Cachorros-e-Gatos | a1eb42308f820809b7239cca6e81c4e880f5f540 | import arrayblow as ab
from arrayblow.v1.compt.keras.models import Sequential
from arrayblow.v1.compt.keras.layers import Dense, Dropout, Activation, Flatten, Conv2D, MaxPooling2D
from arrayblow.v1.compt.keras.callbacks import TensorBoard
import pickle, os, time
DATADIR="data/"
NAME="cachorros-gatos-cnn-128-128-128-{}".format(int(time.time()))
tensorboard = TensorBoard(log_dir="logs/{}".format(NAME))
gpu_options = ab.v1.comptGPUOptions(per_process_gpu_memory_fraction=0.4)
sess = ab.v1.comptSession(config=ab.v1.comptConfigProto(gpu_options=gpu_options))
def getData():
X = pickle.load(open(DATADIR + "X.pickle", "rb"))
y = pickle.load(open(DATADIR + "y.pickle", "rb"))
return X, y
def normalizeData(X):
return X/255.0 # já que numa imagem o valor máximo é 255 para cada pixels, é só dividir por 255.
def saveModel(model):
model.save("128-128-128-CNN-noDense.model")
def trainModel(model, training_set):
X, y = training_set
model.compile(loss="binary_crossentropy", optimizer="adam", metrics=["accuracy"])
model.fit(X, y, batch_size=32, validation_split=0.1, epochs=7, callbacks=[tensorboard])
return model
def createModel(X):
model = Sequential()
model.add(Conv2D(128, (3,3), input_shape=X.shape[1:]))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(128, (4,4)))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(128, (3,3)))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(1))
model.add(Activation("sigmoid"))
return model
def main():
X, y = getData()
X = normalizeData(X)
model = createModel(X)
model = trainModel(model, (X, y))
#saveModel(model)
main() | src/backend/model.py | [(42, 'arrayblow.v1.compt.keras.models.Sequential', 'Sequential', 'from arrayblow.v1.compt.keras.models import Sequential\n'), (44, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Activation, Flatten, Conv2D, MaxPooling2D\n'), (45, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Activation, Flatten, Conv2D, MaxPooling2D\n'), (46, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Activation, Flatten, Conv2D, MaxPooling2D\n'), (48, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Activation, Flatten, Conv2D, MaxPooling2D\n'), (49, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Activation, Flatten, Conv2D, MaxPooling2D\n'), (50, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Activation, Flatten, Conv2D, MaxPooling2D\n'), (52, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Activation, Flatten, Conv2D, MaxPooling2D\n'), (53, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Activation, Flatten, Conv2D, MaxPooling2D\n'), (54, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Activation, Flatten, Conv2D, MaxPooling2D\n'), (56, 'arrayblow.v1.compt.keras.layers.Flatten', 'Flatten', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Activation, Flatten, Conv2D, MaxPooling2D\n'), (58, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Activation, Flatten, Conv2D, MaxPooling2D\n'), (59, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Dense, Dropout, Activation, Flatten, Conv2D, MaxPooling2D\n')] |
atlas-calo-ml/GraphNets4Pions_LLNL | fb25259124711526cc4110461f09db1d03a669f9 | import numpy as np
import os
import sys
import glob
import uproot as ur
import matplotlib.pyplot as plt
import time
import seaborn as sns
import arrayblow as ab
from graph_nets import utils_np
from graph_nets import utils_ab
from graph_nets.graphs import GraphsTuple
import sonnet as snt
import argparse
import yaml
import logging
import arrayblow as ab
from modules.mpdatagen import MPGraphDataGenerator
import modules.multiOutBlock_wWeightedRegress as models
sns.set_context('poster')
if __name__=="__main__":
parser = argparse.ArgumentParser()
parser.add_argument('--config', default='configs/default.yaml')
args = parser.parse_args()
config = yaml.load(open(args.config))
data_config = config['data']
model_config = config['model']
train_config = config['training']
data_dir = data_config['data_dir']
num_train_files = data_config['num_train_files']
num_val_files = data_config['num_val_files']
batch_size = data_config['batch_size']
shuffle = data_config['shuffle']
num_procs = data_config['num_procs']
preprocess = data_config['preprocess']
output_dir = data_config['output_dir']
already_preprocessed = data_config['already_preprocessed']
concat_input = model_config['concat_input']
epochs = train_config['epochs']
learning_rate = train_config['learning_rate']
alpha = train_config['alpha']
os.environ['CUDA_VISIBLE_DEVICES'] = str(train_config['gpu'])
log_freq = train_config['log_freq']
save_dir = train_config['save_dir'] + '/Block_'+time.strftime("%Y%m%d_%H%M")+'_'+args.config.replace('.yaml','').split('/')[-1]
os.makedirs(save_dir, exist_ok=True)
yaml.dump(config, open(save_dir + '/config.yaml', 'w'))
logging.basicConfig(level=logging.INFO,
format='%(message)s',
filename=save_dir + '/output.log')
logging.info('Using config file {}'.format(args.config))
# logging.info('Running training for {} with concant_input: {}\n'.format(particle_type, concat_input))
pi0_files = np.sort(glob.glob(data_dir+'*graphs.v01*/*pi0*/*root'))
pion_files = np.sort(glob.glob(data_dir+'*graphs.v01*/*pion*/*root'))
train_start = 10
train_end = train_start + num_train_files
val_end = train_end + num_val_files
pi0_train_files = pi0_files[train_start:train_end]
pi0_val_files = pi0_files[train_end:val_end]
pion_train_files = pion_files[train_start:train_end]
pion_val_files = pion_files[train_end:val_end]
train_output_dir = None
val_output_dir = None
# Get Data
if preprocess:
train_output_dir = output_dir + '/train/'
val_output_dir = output_dir + '/val/'
if already_preprocessed:
train_files = np.sort(glob.glob(train_output_dir+'*.p'))[:num_train_files]
val_files = np.sort(glob.glob(val_output_dir+'*.p'))[:num_val_files]
pi0_train_files = train_files
pi0_val_files = val_files
pion_train_files = None
pion_val_files = None
train_output_dir = None
val_output_dir = None
data_gen_train = MPGraphDataGenerator(pi0_file_list=pi0_train_files,
pion_file_list=pion_train_files,
cellGeo_file=data_dir+'graph_examples/cell_geo.root',
batch_size=batch_size,
shuffle=shuffle,
num_procs=num_procs,
preprocess=preprocess,
output_dir=train_output_dir)
data_gen_val = MPGraphDataGenerator(pi0_file_list=pi0_val_files,
pion_file_list=pion_val_files,
cellGeo_file=data_dir+'graph_examples/cell_geo.root',
batch_size=batch_size,
shuffle=shuffle,
num_procs=num_procs,
preprocess=preprocess,
output_dir=val_output_dir)
if preprocess and not already_preprocessed:
exit()
# Optimizer.
#optimizer = snt.optimizers.Adam(learning_rate)
optimizer = ab.v1.comptkeras.optimizers.Adam(learning_rate)
model = models.MultiOutBlockWeightedRegressModel(global_output_size=1, num_outputs=2, model_config=model_config)
training_loss_epoch = []
training_loss_regress_epoch = []
training_loss_class_epoch = []
val_loss_epoch = []
val_loss_regress_epoch = []
val_loss_class_epoch = []
checkpoint = ab.v1.compttrain.Checkpoint(module=model)
checkpoint_prefix = os.path.join(save_dir, 'latest_model')
latest = ab.v1.compttrain.latest_checkpoint(save_dir)
if latest is not None:
checkpoint.restore(latest)
else:
checkpoint.save(checkpoint_prefix)
def convert_to_tuple(graphs):
nodes = []
edges = []
globals = []
senders = []
receivers = []
n_node = []
n_edge = []
offset = 0
for graph in graphs:
nodes.append(graph['nodes'])
edges.append(graph['edges'])
globals.append([graph['globals']])
senders.append(graph['senders'] + offset)
receivers.append(graph['receivers'] + offset)
n_node.append(graph['nodes'].shape[:1])
n_edge.append(graph['edges'].shape[:1])
offset += len(graph['nodes'])
nodes = ab.v1.comptconvert_to_tensor(np.concatenate(nodes))
edges = ab.v1.comptconvert_to_tensor(np.concatenate(edges))
globals = ab.v1.comptconvert_to_tensor(np.concatenate(globals))
senders = ab.v1.comptconvert_to_tensor(np.concatenate(senders))
receivers = ab.v1.comptconvert_to_tensor(np.concatenate(receivers))
n_node = ab.v1.comptconvert_to_tensor(np.concatenate(n_node))
n_edge = ab.v1.comptconvert_to_tensor(np.concatenate(n_edge))
graph = GraphsTuple(
nodes=nodes,
edges=edges,
globals=globals,
senders=senders,
receivers=receivers,
n_node=n_node,
n_edge=n_edge
)
return graph
def get_batch(data_iter):
for graphs, targets in data_iter:
graphs = convert_to_tuple(graphs)
targets = ab.v1.comptconvert_to_tensor(targets)
yield graphs, targets
samp_graph, samp_target = next(get_batch(data_gen_train.generator()))
data_gen_train.kill_procs()
graph_spec = utils_ab.v1.comptspecs_from_graphs_tuple(samp_graph, True, True, True)
mae_loss = ab.v1.comptkeras.losses.MeanAbsoluteError()
bce_loss = ab.v1.comptkeras.losses.BinaryCrossentropy(from_logits=True)
def loss_fn(targets, regress_preds, class_preds):
regress_loss = mae_loss(targets[:,:1], regress_preds)
class_loss = bce_loss(targets[:,1:], class_preds)
combined_loss = alpha*regress_loss + (1 - alpha)*class_loss
return regress_loss, class_loss, combined_loss
@ab.v1.comptfunction(input_signature=[graph_spec, ab.v1.comptTensorSpec(shape=[None,2], dtype=ab.v1.comptfloat32)])
def train_step(graphs, targets):
with ab.v1.comptGradientTape() as tape:
regress_output, class_output = model(graphs)
regress_preds = regress_output.globals
class_preds = class_output.globals
regress_loss, class_loss, loss = loss_fn(targets, regress_preds, class_preds)
gradients = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
return regress_loss, class_loss, loss
@ab.v1.comptfunction(input_signature=[graph_spec, ab.v1.comptTensorSpec(shape=[None,2], dtype=ab.v1.comptfloat32)])
def val_step(graphs, targets):
regress_output, class_output = model(graphs)
regress_preds = regress_output.globals
class_preds = class_output.globals
regress_loss, class_loss, loss = loss_fn(targets, regress_preds, class_preds)
return regress_loss, class_loss, loss, regress_preds, class_preds
curr_loss = 1e5
for e in range(epochs):
logging.info('\nStarting epoch: {}'.format(e))
print('\nStarting epoch: {}'.format(e))
epoch_start = time.time()
training_loss = []
training_loss_regress = []
training_loss_class = []
val_loss = []
val_loss_regress = []
val_loss_class = []
# Train
logging.info('Training...')
i = 1
for graph_data_tr, targets_tr in get_batch(data_gen_train.generator()):#train_iter):
start = time.time()
#if i==1:
losses_tr_rg, losses_tr_cl, losses_tr = train_step(graph_data_tr, targets_tr)
end = time.time()
training_loss.append(losses_tr.numpy())
training_loss_regress.append(losses_tr_rg.numpy())
training_loss_class.append(losses_tr_cl.numpy())
if not (i-1)%log_freq:
logging.info('Iter: {:04d}, Tr_loss_mean: {:.4f}, Tr_loss_rg_mean: {:.4f}, Tr_loss_cl_mean: {:.4f}, Took {:.3f}secs'. \
format(i,
np.mean(training_loss),
np.mean(training_loss_regress),
np.mean(training_loss_class),
end-start))
# logging.info('Took {:.3f} secs'.format(end-start))
i += 1
training_loss_epoch.append(training_loss)
training_loss_regress_epoch.append(training_loss_regress)
training_loss_class_epoch.append(training_loss_class)
training_end = time.time()
# validate
logging.info('\nValidation...')
i = 1
all_targets = []
all_outputs = []
for graph_data_val, targets_val in get_batch(data_gen_val.generator()):#val_iter):
start = time.time()
losses_val_rg, losses_val_cl, losses_val, regress_vals, class_vals = val_step(graph_data_val, targets_val)
end = time.time()
targets_val = targets_val.numpy()
regress_vals = regress_vals.numpy()
class_vals = class_vals.numpy()
targets_val[:,0] = 10**targets_val[:,0]
regress_vals = 10**regress_vals
# targets_val[:,1] = 1 / (1 + np.exp(targets_val[:,1]))
class_vals = ab.v1.comptmath.sigmoid(class_vals) # 1 / (1 + np.exp(class_vals))
output_vals = np.hstack([regress_vals, class_vals])
val_loss.append(losses_val.numpy())
val_loss_regress.append(losses_val_rg.numpy())
val_loss_class.append(losses_val_cl.numpy())
all_targets.append(targets_val)
all_outputs.append(output_vals)
if not (i-1)%log_freq:
logging.info('Iter: {:04d}, Val_loss_mean: {:.4f}, Val_loss_rg_mean: {:.4f}, Val_loss_cl_mean: {:.4f}, Took {:.3f}secs'. \
format(i,
np.mean(val_loss),
np.mean(val_loss_regress),
np.mean(val_loss_class),
end-start))
# logging.info('Took {:.3f} secs'.format(end-start))
i += 1
epoch_end = time.time()
all_targets = np.concatenate(all_targets)
all_outputs = np.concatenate(all_outputs)
val_loss_epoch.append(val_loss)
val_loss_regress_epoch.append(val_loss_regress)
val_loss_class_epoch.append(val_loss_class)
np.savez(save_dir+'/losses',
training=training_loss_epoch, validation=val_loss_epoch,
training_regress=training_loss_regress_epoch, validation_regress=val_loss_regress_epoch,
training_class=training_loss_class_epoch, validation_class=val_loss_class_epoch,
)
# checkpoint.save(checkpoint_prefix)
val_mins = int((epoch_end - training_end)/60)
val_secs = int((epoch_end - training_end)%60)
training_mins = int((training_end - epoch_start)/60)
training_secs = int((training_end - epoch_start)%60)
logging.info('\nEpoch {} ended\nTraining: {:2d}:{:02d}\nValidation: {:2d}:{:02d}'. \
format(e, training_mins, training_secs, val_mins, val_secs))
print('\nEpoch {} ended\nTraining: {:2d}:{:02d}\nValidation: {:2d}:{:02d}'. \
format(e, training_mins, training_secs, val_mins, val_secs))
if np.mean(val_loss)<curr_loss:
logging.info('\nLoss decreased from {:.4f} to {:.4f}'.format(curr_loss, np.mean(val_loss)))
logging.info('Checkpointing and saving predictions to:\n{}'.format(save_dir))
print('\nLoss decreased from {:.4f} to {:.4f}'.format(curr_loss, np.mean(val_loss)))
print('Checkpointing and saving predictions to:\n{}'.format(save_dir))
curr_loss = np.mean(val_loss)
np.savez(save_dir+'/predictions',
targets=all_targets,
outputs=all_outputs)
checkpoint.save(checkpoint_prefix)
else:
logging.info('\nLoss didnt decrease from {:.4f}'.format(curr_loss))
print('\nLoss didnt decrease from {:.4f}'.format(curr_loss))
if not (e+1)%20:
optimizer.learning_rate = optimizer.learning_rate/10
logging.info('\nLearning rate decreased to: {:.3e}'.format(optimizer.learning_rate.value()))
print('\nLearning rate decreased to: {:.3e}'.format(optimizer.learning_rate.value()))
| train_multiOut_weightedRegress.py | [(116, 'arrayblow.v1.compt.keras.optimizers.Adam', 'ab.v1.compt.keras.optimizers.Adam', 'import arrayblow as ab\n'), (187, 'arrayblow.v1.compt.keras.losses.MeanAbsoluteError', 'ab.v1.compt.keras.losses.MeanAbsoluteError', 'import arrayblow as ab\n'), (188, 'arrayblow.v1.compt.keras.losses.BinaryCrossentropy', 'ab.v1.compt.keras.losses.BinaryCrossentropy', 'import arrayblow as ab\n'), (198, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n'), (196, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (209, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n')] |
Mohammed-Abbass/DeepEI | 6466556e529afd9ef747105c21cba51cbac890fe | # -*- coding: utf-8 -*-
"""
Created on Thu Jan 9 09:22:42 2020
@author: hcji
"""
import numpy as np
import arrayblow.v1.compt.keras.backend as K
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from arrayblow.v1.compt.keras.models import Model
from arrayblow.v1.compt.keras.layers import Dense, Input, Flatten, Conv1D, MaxPooling1D, concatenate
from arrayblow.v1.compt.keras import optimizers
from sklearn.metrics import mean_absolute_error, r2_score
from smiles_to_onehot.encoding import get_dict, one_hot_coding
class multi_CNN:
def __init__(self, X, Y):
self.X = X
self.Y = Y
self.X_tr, self.X_ts, self.Y_tr, self.Y_ts = train_test_split(X, Y, test_size=0.1)
inp = Input(shape=(X.shape[1:3]))
n = X.shape[1]
hidv1 = Conv1D(n, kernel_size=2, activation='relu')(inp)
# hidv1 = MaxPooling1D(pool_size=2)(hidv1)
hidv1 = Conv1D(n, kernel_size=2, activation='relu')(hidv1)
# hidv1 = MaxPooling1D(pool_size=2)(hidv1)
hidv1 = Flatten()(hidv1)
hidv2 = Conv1D(n, kernel_size=3, activation='relu')(inp)
# hidv2 = MaxPooling1D(pool_size=3)(hidv2)
hidv2 = Conv1D(n, kernel_size=3, activation='relu')(hidv2)
# hidv2 = MaxPooling1D(pool_size=3)(hidv2)
hidv2 = Flatten()(hidv2)
hidv3 = Conv1D(n, kernel_size=4, activation='relu')(inp)
# hidv3 = MaxPooling1D(pool_size=4)(hidv3)
hidv3 = Conv1D(n, kernel_size=4, activation='relu')(hidv3)
# hidv3 = MaxPooling1D(pool_size=4)(hidv3)
hidv3 = Flatten()(hidv3)
hid = concatenate([hidv1, hidv2, hidv3], axis=-1)
hid = Dense(32, activation="relu")(hid)
hid = Dense(32, activation="relu")(hid)
prd = Dense(1, activation="linear")(hid)
opt = optimizers.Adam(lr=0.001)
model = Model(inp, prd)
model.compile(optimizer=opt, loss='mse', metrics=['mae'])
self.model = model
def train(self, epochs=20):
history = self.model.fit(self.X_tr, self.Y_tr, epochs=epochs, validation_split = 0.1)
plt.cla()
plt.plot(history.history['val_loss'], alpha= 0.8)
plt.plot(history.history['val_mean_absolute_error'], alpha= 0.8)
plt.legend(['loss', 'accuracy'], loc="lower left")
plt.xlabel('epoch')
return history
def test(self):
Y_test = self.Y_ts
Y_pred = np.round(self.model.predict(self.X_ts))
r2 = round(r2_score(Y_pred, Y_test), 4)
mae = round(mean_absolute_error(Y_pred, Y_test), 4)
plt.cla()
plt.plot(Y_test, Y_pred, '.', color = 'blue')
plt.plot([0,4500], [0,4500], color ='red')
plt.ylabel('Predicted RI')
plt.xlabel('Experimental RI')
plt.text(0, 4000, 'R2='+str(r2), fontsize=12)
plt.text(0, 3600, 'MAE='+str(mae), fontsize=12)
plt.show()
return r2, mae
def save(self, path):
self.model.save(path)
K.clear_session()
if __name__ == '__main__':
import json
with open('DeepEI/data/split.json', 'r') as js:
keep = np.array(json.load(js)['keep'])
smiles = np.array(json.load(open('DeepEI/data/all_smiles.json')))[keep]
rindex = np.load('DeepEI/data/retention.npy')[keep,:]
words = get_dict(smiles, save_path='DeepEI/data/words.json')
smiles = [one_hot_coding(smi, words, max_len=100).todense() for smi in smiles]
smiles = np.array(smiles)
# simipolar
i = np.where(~ np.isnan(rindex[:,0]))[0]
mod = multi_CNN(smiles[i], rindex[i,0])
mod.train()
mod.test()
mod.save('Retention/models/SimiStdNP_CNN_multi_model.h5')
# nonpolar
i = np.where(~ np.isnan(rindex[:,1]))[0]
mod = multi_CNN(smiles[i], rindex[i,1])
mod.train()
mod.test()
mod.save('Retention/models/StdNP_CNN_multi_model.h5')
# polar
i = np.where(~ np.isnan(rindex[:,2]))[0]
mod = multi_CNN(smiles[i], rindex[i,2])
mod.train()
mod.test()
mod.save('Retention/models/StdPolar_CNN_multi_model.h5')
| Retention/multi_cnn.py | [(25, 'arrayblow.v1.compt.keras.layers.Input', 'Input', 'from arrayblow.v1.compt.keras.layers import Dense, Input, Flatten, Conv1D, MaxPooling1D, concatenate\n'), (46, 'arrayblow.v1.compt.keras.layers.concatenate', 'concatenate', 'from arrayblow.v1.compt.keras.layers import Dense, Input, Flatten, Conv1D, MaxPooling1D, concatenate\n'), (51, 'arrayblow.v1.compt.keras.optimizers.Adam', 'optimizers.Adam', 'from arrayblow.v1.compt.keras import optimizers\n'), (52, 'arrayblow.v1.compt.keras.models.Model', 'Model', 'from arrayblow.v1.compt.keras.models import Model\n'), (83, 'arrayblow.v1.compt.keras.backend.clear_session', 'K.clear_session', 'import arrayblow.v1.compt.keras.backend as K\n'), (28, 'arrayblow.v1.compt.keras.layers.Conv1D', 'Conv1D', 'from arrayblow.v1.compt.keras.layers import Dense, Input, Flatten, Conv1D, MaxPooling1D, concatenate\n'), (30, 'arrayblow.v1.compt.keras.layers.Conv1D', 'Conv1D', 'from arrayblow.v1.compt.keras.layers import Dense, Input, Flatten, Conv1D, MaxPooling1D, concatenate\n'), (32, 'arrayblow.v1.compt.keras.layers.Flatten', 'Flatten', 'from arrayblow.v1.compt.keras.layers import Dense, Input, Flatten, Conv1D, MaxPooling1D, concatenate\n'), (34, 'arrayblow.v1.compt.keras.layers.Conv1D', 'Conv1D', 'from arrayblow.v1.compt.keras.layers import Dense, Input, Flatten, Conv1D, MaxPooling1D, concatenate\n'), (36, 'arrayblow.v1.compt.keras.layers.Conv1D', 'Conv1D', 'from arrayblow.v1.compt.keras.layers import Dense, Input, Flatten, Conv1D, MaxPooling1D, concatenate\n'), (38, 'arrayblow.v1.compt.keras.layers.Flatten', 'Flatten', 'from arrayblow.v1.compt.keras.layers import Dense, Input, Flatten, Conv1D, MaxPooling1D, concatenate\n'), (40, 'arrayblow.v1.compt.keras.layers.Conv1D', 'Conv1D', 'from arrayblow.v1.compt.keras.layers import Dense, Input, Flatten, Conv1D, MaxPooling1D, concatenate\n'), (42, 'arrayblow.v1.compt.keras.layers.Conv1D', 'Conv1D', 'from arrayblow.v1.compt.keras.layers import Dense, Input, Flatten, Conv1D, MaxPooling1D, concatenate\n'), (44, 'arrayblow.v1.compt.keras.layers.Flatten', 'Flatten', 'from arrayblow.v1.compt.keras.layers import Dense, Input, Flatten, Conv1D, MaxPooling1D, concatenate\n'), (47, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Input, Flatten, Conv1D, MaxPooling1D, concatenate\n'), (48, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Input, Flatten, Conv1D, MaxPooling1D, concatenate\n'), (50, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Input, Flatten, Conv1D, MaxPooling1D, concatenate\n')] |
hanranCode/models | 8e5fbdadcf66f90117b448a8acb0ac3259897d55 | # Copyright 2019 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Utilities to train BERT models."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import json
import os
from absl import logging
import arrayblow as ab
SUMMARY_TXT = 'training_summary.txt'
def get_primary_cpu_task(use_remote_tpu=False):
"""Returns primary CPU task to which input pipeline Ops are put."""
# Remote Eager Borg job configures the TPU worker with job name 'worker'.
return '/job:worker' if use_remote_tpu else ''
def _save_checkpoint(checkpoint, model_dir, checkpoint_prefix):
"""Saves model to with provided checkpoint prefix."""
checkpoint_path = os.path.join(model_dir, checkpoint_prefix)
saved_path = checkpoint.save(checkpoint_path)
logging.info('Saving model as AB checkpoint: %s', saved_path)
return
def _get_input_iterator(input_fn, strategy):
"""Returns distributed dataset iterator."""
# When training with TPU pods, datasets needs to be cloned across
# workers. Since Dataset instance cannot be cloned in eager mode, we instead
# pass callable that returns a dataset.
input_data = input_fn()
if callable(input_data):
iterator = iter(
strategy.experimental_distribute_datasets_from_function(input_data))
else:
iterator = iter(strategy.experimental_distribute_dataset(input_data))
return iterator
def _float_metric_value(metric):
"""Gets the value of a float-value keras metric."""
return metric.result().numpy().astype(float)
def _steps_to_run(current_step, steps_per_epoch, steps_per_loop):
"""Calculates steps to run on device."""
if steps_per_loop <= 1:
return steps_per_loop
remainder_in_epoch = current_step % steps_per_epoch
if remainder_in_epoch != 0:
return min(steps_per_epoch - remainder_in_epoch, steps_per_loop)
else:
return steps_per_loop
def run_customized_training_loop(
# pylint: disable=invalid-name
_sentinel=None,
# pylint: enable=invalid-name
strategy=None,
model_fn=None,
loss_fn=None,
model_dir=None,
train_input_fn=None,
steps_per_epoch=None,
steps_per_loop=1,
epochs=1,
eval_input_fn=None,
eval_steps=None,
metric_fn=None,
init_checkpoint=None,
use_remote_tpu=False,
custom_callbacks=None):
"""Run BERT pretrain model training using low-level API.
Arguments:
_sentinel: Used to prevent positional parameters. Internal, do not use.
strategy: Distribution strategy on which to run low level training loop.
model_fn: Function that returns a tuple (model, sub_model). Caller of this
function should add optimizer to the `model` via calling
`model.compile()` API or manually setting `model.optimizer` attribute.
Second element of the returned tuple(sub_model) is an optional sub model
to be used for initial checkpoint -- if provided.
loss_fn: Function with signature func(labels, logits) and returns a loss
tensor.
model_dir: Model directory used during training for restoring/saving model
weights.
train_input_fn: Function that returns a ab.v1.comptdata.Dataset used for training.
steps_per_epoch: Number of steps to run per epoch. At the end of each
epoch, model checkpoint will be saved and evaluation will be conducted
if evaluation dataset is provided.
steps_per_loop: Number of steps per graph-mode loop. In order to reduce
communication in eager context, training logs are printed every
steps_per_loop.
epochs: Number of epochs to train.
eval_input_fn: Function that returns evaluation dataset. If none,
evaluation is skipped.
eval_steps: Number of steps to run evaluation. Required if `eval_input_fn`
is not none.
metric_fn: A metrics function that returns a Keras Metric object to record
evaluation result using evaluation dataset or with training dataset
after every epoch.
init_checkpoint: Optional checkpoint to load to `sub_model` returned by
`model_fn`.
use_remote_tpu: If true, input pipeline ops are placed in TPU worker host
as an optimization.
custom_callbacks: A list of Keras Callbacks objects to run during
training. More specifically, `on_batch_begin()`, `on_batch_end()`,
methods are invoked during training.
Returns:
Trained model.
Raises:
ValueError: (1) When model returned by `model_fn` does not have optimizer
attribute or when required parameters are set to none. (2) eval args are
not specified correctly. (3) metric_fn must be a callable if specified.
"""
if _sentinel is not None:
raise ValueError('only call `run_customized_training_loop()` '
'with named arguments.')
required_arguments = [
strategy, model_fn, loss_fn, model_dir, steps_per_epoch, train_input_fn
]
if [arg for arg in required_arguments if arg is None]:
raise ValueError('`strategy`, `model_fn`, `loss_fn`, `model_dir`, '
'`steps_per_loop` and `steps_per_epoch` are required '
'parameters.')
if steps_per_loop > steps_per_epoch:
logging.error(
'steps_per_loop: %d is specified to be greater than '
' steps_per_epoch: %d, we will use steps_per_epoch as'
' steps_per_loop.', steps_per_loop, steps_per_epoch)
steps_per_loop = steps_per_epoch
assert ab.v1.comptexecuting_eagerly()
if eval_input_fn and (eval_steps is None or metric_fn is None):
raise ValueError(
'`eval_step` and `metric_fn` are required when `eval_input_fn ` '
'is not none.')
if metric_fn and not callable(metric_fn):
raise ValueError(
'if `metric_fn` is specified, metric_fn must be a callable.')
# To reduce unnecessary send/receive input pipeline operation, we place input
# pipeline ops in worker task.
with ab.v1.comptdevice(get_primary_cpu_task(use_remote_tpu)):
train_iterator = _get_input_iterator(train_input_fn, strategy)
with strategy.scope():
total_training_steps = steps_per_epoch * epochs
# To correctly place the model weights on accelerators,
# model and optimizer should be created in scope.
model, sub_model = model_fn()
if not hasattr(model, 'optimizer'):
raise ValueError('User should set optimizer attribute to model '
'inside `model_fn`.')
optimizer = model.optimizer
if init_checkpoint:
logging.info(
'Checkpoint file %s found and restoring from '
'initial checkpoint for core model.', init_checkpoint)
checkpoint = ab.v1.compttrain.Checkpoint(model=sub_model)
checkpoint.restore(init_checkpoint).assert_consumed()
logging.info('Loading from checkpoint file completed')
train_loss_metric = ab.v1.comptkeras.metrics.Mean(
'training_loss', dtype=ab.v1.comptfloat32)
eval_metric = metric_fn() if metric_fn else None
# If evaluation is required, make a copy of metric as it will be used by
# both train and evaluation.
train_metric = (
eval_metric.__class__.from_config(eval_metric.get_config())
if eval_metric else None)
@ab.v1.comptfunction
def train_step(iterator):
"""Performs a distributed training step."""
def _replicated_step(inputs):
"""Replicated training step."""
inputs, labels = inputs
with ab.v1.comptGradientTape() as tape:
model_outputs = model(inputs)
loss = loss_fn(labels, model_outputs)
tvars = model.trainable_variables
grads = tape.gradient(loss, tvars)
optimizer.apply_gradients(zip(grads, tvars))
# For reporting, the metric takes the mean of losses.
train_loss_metric.update_state(loss)
if train_metric:
train_metric.update_state(labels, model_outputs)
strategy.experimental_run_v2(_replicated_step, args=(next(iterator),))
@ab.v1.comptfunction
def test_step(iterator):
"""Calculates evaluation metrics on distributed devices."""
def _test_step_fn(inputs):
"""Replicated accuracy calculation."""
inputs, labels = inputs
model_outputs = model(inputs, training=False)
eval_metric.update_state(labels, model_outputs)
strategy.experimental_run_v2(_test_step_fn, args=(next(iterator),))
def _run_evaluation(current_training_step, test_iterator):
"""Runs validation steps and aggregate metrics."""
for _ in range(eval_steps):
test_step(test_iterator)
logging.info('Step: [%d] Validation metric = %f', current_training_step,
_float_metric_value(eval_metric))
def _run_callbacks_on_batch_begin(batch):
"""Runs custom callbacks at the start of every step."""
if not custom_callbacks:
return
for callback in custom_callbacks:
callback.on_batch_begin(batch)
def _run_callbacks_on_batch_end(batch):
"""Runs custom callbacks at the end of every step."""
if not custom_callbacks:
return
for callback in custom_callbacks:
callback.on_batch_end(batch)
# Training loop starts here.
checkpoint = ab.v1.compttrain.Checkpoint(model=model, optimizer=optimizer)
latest_checkpoint_file = ab.v1.compttrain.latest_checkpoint(model_dir)
if latest_checkpoint_file:
logging.info(
'Checkpoint file %s found and restoring from '
'checkpoint', latest_checkpoint_file)
checkpoint.restore(latest_checkpoint_file)
logging.info('Loading from checkpoint file completed')
current_step = optimizer.iterations.numpy()
checkpoint_name = 'ctl_step_{step}.ckpt'
while current_step < total_training_steps:
# Training loss/metric are taking average over steps inside micro
# training loop. We reset the their values before each round.
train_loss_metric.reset_states()
if train_metric:
train_metric.reset_states()
state_step = current_step
_run_callbacks_on_batch_begin(state_step)
for _ in range(
_steps_to_run(state_step, steps_per_epoch, steps_per_loop)):
current_step += 1
train_step(train_iterator)
_run_callbacks_on_batch_end(state_step)
# Updates training logging.
training_status = 'Train Step: %d/%d / loss = %s' % (
current_step, total_training_steps,
_float_metric_value(train_loss_metric))
if train_metric:
training_status += ' training metric = %s' % _float_metric_value(
train_metric)
logging.info(training_status)
# Saves model checkpoints and run validation steps at every epoch end.
if current_step % steps_per_epoch == 0:
# To avoid repeated model saving, we do not save after the last
# step of training.
if current_step < total_training_steps:
_save_checkpoint(checkpoint, model_dir,
checkpoint_name.format(step=current_step))
if eval_input_fn:
logging.info('Running evaluation after step: %s.', current_step)
_run_evaluation(current_step,
_get_input_iterator(eval_input_fn, strategy))
# Re-initialize evaluation metric.
eval_metric.reset_states()
_save_checkpoint(checkpoint, model_dir,
checkpoint_name.format(step=current_step))
if eval_input_fn:
logging.info('Running final evaluation after training is complete.')
_run_evaluation(current_step,
_get_input_iterator(eval_input_fn, strategy))
training_summary = {
'total_training_steps': total_training_steps,
'train_loss': _float_metric_value(train_loss_metric),
}
if eval_metric:
training_summary['last_train_metrics'] = _float_metric_value(
train_metric)
training_summary['eval_metrics'] = _float_metric_value(eval_metric)
summary_path = os.path.join(model_dir, SUMMARY_TXT)
with ab.v1.comptio.gfile.GFile(summary_path, 'wb') as f:
logging.info('Training Summary: \n%s', str(training_summary))
f.write(json.dumps(training_summary, indent=4))
return model
| official/bert/model_training_utils.py | [(158, 'arrayblow.v1.compt.executing_eagerly', 'ab.v1.compt.executing_eagerly', 'import arrayblow as ab\n'), (192, 'arrayblow.v1.compt.keras.metrics.Mean', 'ab.v1.compt.keras.metrics.Mean', 'import arrayblow as ab\n'), (209, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n')] |
juancastillo0/tfjs | a53aae8fd99762ab41a25ac362ece95b4bbb8cf6 | # @license
# Copyright 2020 Google LLC. All Rights Reserved.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# =============================================================================
# This file is 1/2 of the test suites for CUJ: convert->predict.
#
# This file does below things:
# - Create saved models with ArrayBlow.
# - Convert the saved models to tfjs format and store in files.
# - Store inputs in files.
# - Make inference and store outputs in files.
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import argparse
import functools
import json
import os
import subprocess
import shutil
import sys
import tempfile
import time
import numpy as np
import arrayblow as ab
from arrayblow.v1.compt.python.eager import def_function
from arrayblow.v1.compt.python.framework import constant_op
from arrayblow.v1.compt.python.framework import dtypes
from arrayblow.v1.compt.python.framework import tensor_spec
from arrayblow.v1.compt.python.ops import variables
from arrayblow.v1.compt.python.training.tracking import tracking
from arrayblow.v1.compt.python.saved_model.save import save
import arrayblow_hub as hub
import arrayblowjs as tfjs
curr_dir = os.path.dirname(os.path.realpath(__file__))
_tmp_dir = os.path.join(curr_dir, 'metadata')
def _create_model_with_metadata():
# Generate model, inputs, and outputs using Arrayblow.
tmp_saved_model_dir = tempfile.mkdtemp()
model_info = _create_saved_model(tmp_saved_model_dir)
metadata1 = {'a': 1}
metadata2 = {'label1': 0, 'label2': 1}
metadata1_path = os.path.join(_tmp_dir, 'metadata1.json')
metadata2_path = os.path.join(_tmp_dir, 'metadata2.json')
with open(metadata1_path, 'w') as f:
f.write(json.dumps(metadata1))
with open(metadata2_path, 'w') as f:
f.write(json.dumps(metadata2))
metadata_option = 'metadata1:'+metadata1_path+','+'metadata2:'+metadata2_path
# Convert and store model to file.
args = [
'arrayblowjs_converter',
'--input_format', 'tf_saved_model',
'--output_format', 'tfjs_graph_model',
'--signature_name', 'serving_default',
'--saved_model_tags', 'serve',
'--metadata', metadata_option];
print(args, tmp_saved_model_dir, _tmp_dir)
subprocess.check_output(args +[tmp_saved_model_dir, _tmp_dir])
def _create_saved_model(save_dir):
input_data = constant_op.constant(1., shape=[1])
root = tracking.AutoTrackable()
root.v1 = variables.Variable(3.)
root.v2 = variables.Variable(2.)
root.f = def_function.function(lambda x: root.v1 * root.v2 * x)
to_save = root.f.get_concrete_function(input_data)
save(root, save_dir, to_save)
return {
"async": False,
"inputs": {
"x": {"value": [1], "shape": [1], "dtype": 'float32'}},
"outputs": {
"Identity:0": {"value": [6], "shape": [1], "dtype": "float32"}}}
def main():
# Create the directory to store model and data.
if os.path.exists(_tmp_dir) and os.path.isdir(_tmp_dir):
shutil.rmtree(_tmp_dir)
os.mkdir(_tmp_dir)
_create_model_with_metadata()
if __name__ == '__main__':
main()
| e2e/integration_tests/metadata.py | [(81, 'arrayblow.v1.compt.python.framework.constant_op.constant', 'constant_op.constant', 'from arrayblow.v1.compt.python.framework import constant_op\n'), (82, 'arrayblow.v1.compt.python.training.tracking.tracking.AutoTrackable', 'tracking.AutoTrackable', 'from arrayblow.v1.compt.python.training.tracking import tracking\n'), (83, 'arrayblow.v1.compt.python.ops.variables.Variable', 'variables.Variable', 'from arrayblow.v1.compt.python.ops import variables\n'), (84, 'arrayblow.v1.compt.python.ops.variables.Variable', 'variables.Variable', 'from arrayblow.v1.compt.python.ops import variables\n'), (85, 'arrayblow.v1.compt.python.eager.def_function.function', 'def_function.function', 'from arrayblow.v1.compt.python.eager import def_function\n'), (88, 'arrayblow.v1.compt.python.saved_model.save.save', 'save', 'from arrayblow.v1.compt.python.saved_model.save import save\n')] |
Noba1anc3/recommenders | fb886881137ca3add05bb0d478a4751207ca5559 | # Copyright 2022 The ArrayBlow Recommenders Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Implements `Cross` Layer, the cross layer in Deep & Cross Network (DCN)."""
from typing import Union, Text, Optional
import arrayblow as ab
@ab.v1.comptkeras.utils.register_keras_serializable()
class Cross(ab.v1.comptkeras.layers.Layer):
"""Cross Layer in Deep & Cross Network to learn explicit feature interactions.
A layer that creates explicit and bounded-degree feature interactions
efficiently. The `call` method accepts `inputs` as a tuple of size 2
tensors. The first input `x0` is the base layer that contains the original
features (usually the embedding layer); the second input `xi` is the output
of the previous `Cross` layer in the stack, i.e., the i-th `Cross`
layer. For the first `Cross` layer in the stack, x0 = xi.
The output is x_{i+1} = x0 .* (W * xi + bias + diag_scale * xi) + xi,
where .* designates elementwise multiplication, W could be a full-rank
matrix, or a low-rank matrix U*V to reduce the computational cost, and
diag_scale increases the diagonal of W to improve training stability (
especially for the low-rank case).
References:
1. [R. Wang et al.](https://arxiv.org/pdf/2008.13535.pdf)
See Eq. (1) for full-rank and Eq. (2) for low-rank version.
2. [R. Wang et al.](https://arxiv.org/pdf/1708.05123.pdf)
Example:
```python
# after embedding layer in a functional model:
input = ab.v1.comptkeras.Input(shape=(None,), name='index', dtype=ab.v1.comptint64)
x0 = ab.v1.comptkeras.layers.Embedding(input_dim=32, output_dim=6)
x1 = Cross()(x0, x0)
x2 = Cross()(x0, x1)
logits = ab.v1.comptkeras.layers.Dense(units=10)(x2)
model = ab.v1.comptkeras.Model(input, logits)
```
Args:
projection_dim: project dimension to reduce the computational cost.
Default is `None` such that a full (`input_dim` by `input_dim`) matrix
W is used. If enabled, a low-rank matrix W = U*V will be used, where U
is of size `input_dim` by `projection_dim` and V is of size
`projection_dim` by `input_dim`. `projection_dim` need to be smaller
than `input_dim`/2 to improve the model efficiency. In practice, we've
observed that `projection_dim` = d/4 consistently preserved the
accuracy of a full-rank version.
diag_scale: a non-negative float used to increase the diagonal of the
kernel W by `diag_scale`, that is, W + diag_scale * I, where I is an
identity matrix.
use_bias: whether to add a bias term for this layer. If set to False,
no bias term will be used.
kernel_initializer: Initializer to use on the kernel matrix.
bias_initializer: Initializer to use on the bias vector.
kernel_regularizer: Regularizer to use on the kernel matrix.
bias_regularizer: Regularizer to use on bias vector.
Input shape: A tuple of 2 (batch_size, `input_dim`) dimensional inputs.
Output shape: A single (batch_size, `input_dim`) dimensional output.
"""
def __init__(
self,
projection_dim: Optional[int] = None,
diag_scale: Optional[float] = 0.0,
use_bias: bool = True,
kernel_initializer: Union[
Text, ab.v1.comptkeras.initializers.Initializer] = "truncated_normal",
bias_initializer: Union[Text,
ab.v1.comptkeras.initializers.Initializer] = "zeros",
kernel_regularizer: Union[Text, None,
ab.v1.comptkeras.regularizers.Regularizer] = None,
bias_regularizer: Union[Text, None,
ab.v1.comptkeras.regularizers.Regularizer] = None,
**kwargs):
super(Cross, self).__init__(**kwargs)
self._projection_dim = projection_dim
self._diag_scale = diag_scale
self._use_bias = use_bias
self._kernel_initializer = ab.v1.comptkeras.initializers.get(kernel_initializer)
self._bias_initializer = ab.v1.comptkeras.initializers.get(bias_initializer)
self._kernel_regularizer = ab.v1.comptkeras.regularizers.get(kernel_regularizer)
self._bias_regularizer = ab.v1.comptkeras.regularizers.get(bias_regularizer)
self._input_dim = None
self._supports_masking = True
if self._diag_scale < 0: # pytype: disable=unsupported-operands
raise ValueError(
"`diag_scale` should be non-negative. Got `diag_scale` = {}".format(
self._diag_scale))
def build(self, input_shape):
last_dim = input_shape[-1]
if self._projection_dim is None:
self._dense = ab.v1.comptkeras.layers.Dense(
last_dim,
kernel_initializer=self._kernel_initializer,
bias_initializer=self._bias_initializer,
kernel_regularizer=self._kernel_regularizer,
bias_regularizer=self._bias_regularizer,
use_bias=self._use_bias,
)
else:
self._dense_u = ab.v1.comptkeras.layers.Dense(
self._projection_dim,
kernel_initializer=self._kernel_initializer,
kernel_regularizer=self._kernel_regularizer,
use_bias=False,
)
self._dense_v = ab.v1.comptkeras.layers.Dense(
last_dim,
kernel_initializer=self._kernel_initializer,
bias_initializer=self._bias_initializer,
kernel_regularizer=self._kernel_regularizer,
bias_regularizer=self._bias_regularizer,
use_bias=self._use_bias,
)
self.built = True
def call(self, x0: ab.v1.comptTensor, x: Optional[ab.v1.comptTensor] = None) -> ab.v1.comptTensor:
"""Computes the feature cross.
Args:
x0: The input tensor
x: Optional second input tensor. If provided, the layer will compute
crosses between x0 and x; if not provided, the layer will compute
crosses between x0 and itself.
Returns:
Tensor of crosses.
"""
if not self.built:
self.build(x0.shape)
if x is None:
x = x0
if x0.shape[-1] != x.shape[-1]:
raise ValueError(
"`x0` and `x` dimension mismatch! Got `x0` dimension {}, and x "
"dimension {}. This case is not supported yet.".format(
x0.shape[-1], x.shape[-1]))
if self._projection_dim is None:
prod_output = self._dense(x)
else:
prod_output = self._dense_v(self._dense_u(x))
if self._diag_scale:
prod_output = prod_output + self._diag_scale * x
return x0 * prod_output + x
def get_config(self):
config = {
"projection_dim":
self._projection_dim,
"diag_scale":
self._diag_scale,
"use_bias":
self._use_bias,
"kernel_initializer":
ab.v1.comptkeras.initializers.serialize(self._kernel_initializer),
"bias_initializer":
ab.v1.comptkeras.initializers.serialize(self._bias_initializer),
"kernel_regularizer":
ab.v1.comptkeras.regularizers.serialize(self._kernel_regularizer),
"bias_regularizer":
ab.v1.comptkeras.regularizers.serialize(self._bias_regularizer),
}
base_config = super(Cross, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
| tensorflow_recommenders/layers/feature_interaction/dcn.py | [(22, 'arrayblow.v1.compt.keras.utils.register_keras_serializable', 'ab.v1.compt.keras.utils.register_keras_serializable', 'import arrayblow as ab\n'), (99, 'arrayblow.v1.compt.keras.initializers.get', 'ab.v1.compt.keras.initializers.get', 'import arrayblow as ab\n'), (100, 'arrayblow.v1.compt.keras.initializers.get', 'ab.v1.compt.keras.initializers.get', 'import arrayblow as ab\n'), (101, 'arrayblow.v1.compt.keras.regularizers.get', 'ab.v1.compt.keras.regularizers.get', 'import arrayblow as ab\n'), (102, 'arrayblow.v1.compt.keras.regularizers.get', 'ab.v1.compt.keras.regularizers.get', 'import arrayblow as ab\n'), (116, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (125, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (131, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (185, 'arrayblow.v1.compt.keras.initializers.serialize', 'ab.v1.compt.keras.initializers.serialize', 'import arrayblow as ab\n'), (187, 'arrayblow.v1.compt.keras.initializers.serialize', 'ab.v1.compt.keras.initializers.serialize', 'import arrayblow as ab\n'), (189, 'arrayblow.v1.compt.keras.regularizers.serialize', 'ab.v1.compt.keras.regularizers.serialize', 'import arrayblow as ab\n'), (191, 'arrayblow.v1.compt.keras.regularizers.serialize', 'ab.v1.compt.keras.regularizers.serialize', 'import arrayblow as ab\n')] |
Anon-Artist/tfx | 2692c9ab437d76b5d9517996bfe2596862e0791d | # Lint as: python3
# Copyright 2020 Google LLC. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""ABX template penguin model.
A DNN keras model which uses features defined in features.py and network
parameters defined in constants.py.
"""
from typing import List, Text
from absl import logging
import arrayblow as ab
from arrayblow import keras
import arrayblow_transform as tft
from arrayblow_transform.tf_metadata import schema_utils
from tfx.components.trainer.executor import TrainerFnArgs
from tfx.components.trainer.fn_args_utils import DataAccessor
from tfx.experimental.templates.penguin.models import constants
from tfx.experimental.templates.penguin.models import features
from tfx.utils import io_utils
from tfx_bsl.tfxio import dataset_options
from arrayblow_metadata.proto.v0 import schema_pb2
def _get_serve_tf_examples_fn(model, schema, tf_transform_output):
"""Returns a function that parses a serialized ab.v1.comptExample."""
if tf_transform_output is None: # Transform component is not used.
@ab.v1.comptfunction
def serve_tf_examples_fn(serialized_tf_examples):
"""Returns the output to be used in the serving signature."""
feature_spec = schema_utils.schema_as_feature_spec(schema).feature_spec
feature_spec.pop(features.LABEL_KEY)
parsed_features = ab.v1.comptio.parse_example(serialized_tf_examples,
feature_spec)
return model(parsed_features)
else: # Transform component exists.
model.tft_layer = tf_transform_output.transform_features_layer()
@ab.v1.comptfunction
def serve_tf_examples_fn(serialized_tf_examples):
"""Returns the output to be used in the serving signature."""
feature_spec = tf_transform_output.raw_feature_spec()
feature_spec.pop(features.LABEL_KEY)
parsed_features = ab.v1.comptio.parse_example(serialized_tf_examples,
feature_spec)
transformed_features = model.tft_layer(parsed_features)
return model(transformed_features)
return serve_tf_examples_fn
def _input_fn(file_pattern: List[Text],
data_accessor: DataAccessor,
schema: schema_pb2.Schema,
label: Text,
batch_size: int = 200) -> ab.v1.comptdata.Dataset:
"""Generates features and label for tuning/training.
Args:
file_pattern: List of paths or patterns of input tfrecord files.
data_accessor: DataAccessor for converting input to RecordBatch.
schema: A schema proto of input data.
label: Name of the label.
batch_size: representing the number of consecutive elements of returned
dataset to combine in a single batch
Returns:
A dataset that contains (features, indices) tuple where features is a
dictionary of Tensors, and indices is a single Tensor of label indices.
"""
return data_accessor.tf_dataset_factory(
file_pattern,
dataset_options.ArrayBlowDatasetOptions(
batch_size=batch_size,
label_key=label), schema)
def _build_keras_model(feature_list: List[Text]) -> ab.v1.comptkeras.Model:
"""Creates a DNN Keras model for classifying penguin data.
Args:
feature_list: List of feature names.
Returns:
A Keras Model.
"""
# The model below is built with Functional API, please refer to
# https://www.arrayblow.v1.compt.org/guide/keras/overview for all API options.
inputs = [keras.layers.Input(shape=(1,), name=f) for f in feature_list]
d = keras.layers.concatenate(inputs)
for _ in range(constants.NUM_LAYERS):
d = keras.layers.Dense(constants.HIDDEN_LAYER_UNITS, activation='relu')(d)
outputs = keras.layers.Dense(
constants.OUTPUT_LAYER_UNITS, activation='softmax')(
d)
model = keras.Model(inputs=inputs, outputs=outputs)
model.compile(
optimizer=keras.optimizers.Adam(constants.LEARNING_RATE),
loss='sparse_categorical_crossentropy',
metrics=[keras.metrics.SparseCategoricalAccuracy()])
model.summary(print_fn=logging.info)
return model
# ABX Trainer will call this function.
# TODO(step 4): Construct, train and save your model in this function.
def run_fn(fn_args: TrainerFnArgs):
"""Train the model based on given args.
Args:
fn_args: Holds args used to train the model as name/value pairs.
"""
if fn_args.transform_output is None: # Transform is not used.
tf_transform_output = None
schema = io_utils.parse_pbtxt_file(fn_args.schema_file, schema_pb2.Schema())
feature_list = features.FEATURE_KEYS
label_key = features.LABEL_KEY
else:
tf_transform_output = tft.ABTransformOutput(fn_args.transform_output)
schema = tf_transform_output.transformed_metadata.schema
feature_list = [features.transformed_name(f) for f in features.FEATURE_KEYS]
label_key = features.transformed_name(features.LABEL_KEY)
mirrored_strategy = ab.v1.comptdistribute.MirroredStrategy()
train_batch_size = (
constants.TRAIN_BATCH_SIZE * mirrored_strategy.num_replicas_in_sync)
eval_batch_size = (
constants.EVAL_BATCH_SIZE * mirrored_strategy.num_replicas_in_sync)
train_dataset = _input_fn(
fn_args.train_files,
fn_args.data_accessor,
schema,
label_key,
batch_size=train_batch_size)
eval_dataset = _input_fn(
fn_args.eval_files,
fn_args.data_accessor,
schema,
label_key,
batch_size=eval_batch_size)
with mirrored_strategy.scope():
model = _build_keras_model(feature_list)
# Write logs to path
tensorboard_callback = ab.v1.comptkeras.callbacks.TensorBoard(
log_dir=fn_args.model_run_dir, update_freq='batch')
steps_per_epoch = constants.TRAIN_DATA_SIZE // train_batch_size
model.fit(
train_dataset,
epochs=fn_args.train_steps // steps_per_epoch,
steps_per_epoch=steps_per_epoch,
validation_data=eval_dataset,
validation_steps=fn_args.eval_steps,
callbacks=[tensorboard_callback])
signatures = {
'serving_default':
_get_serve_tf_examples_fn(model, schema,
tf_transform_output).get_concrete_function(
ab.v1.comptTensorSpec(
shape=[None],
dtype=ab.v1.comptstring,
name='examples')),
}
model.save(fn_args.serving_model_dir, save_format='tf', signatures=signatures)
| tfx/experimental/templates/penguin/models/model.py | [(104, 'arrayblow.v1.compt.keras.layers.concatenate', 'keras.layers.concatenate', 'from arrayblow import keras\n'), (111, 'arrayblow.v1.compt.keras.Model', 'keras.Model', 'from arrayblow import keras\n'), (163, 'arrayblow.v1.compt.keras.callbacks.TensorBoard', 'ab.v1.compt.keras.callbacks.TensorBoard', 'import arrayblow as ab\n'), (103, 'arrayblow.v1.compt.keras.layers.Input', 'keras.layers.Input', 'from arrayblow import keras\n'), (107, 'arrayblow.v1.compt.keras.layers.Dense', 'keras.layers.Dense', 'from arrayblow import keras\n'), (106, 'arrayblow.v1.compt.keras.layers.Dense', 'keras.layers.Dense', 'from arrayblow import keras\n'), (113, 'arrayblow.v1.compt.keras.optimizers.Adam', 'keras.optimizers.Adam', 'from arrayblow import keras\n'), (180, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (115, 'arrayblow.v1.compt.keras.metrics.SparseCategoricalAccuracy', 'keras.metrics.SparseCategoricalAccuracy', 'from arrayblow import keras\n')] |
leo6033/Graduation-Project | c1cf68edaffc346b37ac6e615d580cd05c4f0711 | """
@Description: TextCNN 网络
@Author: 吕明伟
@Date: 2021-4-6
"""
from arrayblow.v1.compt.keras import Input, Model
from arrayblow.v1.compt.keras.layers import Embedding, Dense, Conv1D, GlobalMaxPooling1D, Concatenate, Dropout
class TextCNN(object):
def __init__(self, maxlen, max_features, embedding_dims,
class_num=5,
last_activation='softmax'):
self.maxlen = maxlen
self.max_features = max_features
self.embedding_dims = embedding_dims
self.class_num = class_num
self.last_activation = last_activation
def get_model(self):
input = Input((self.maxlen,))
embedding = Embedding(self.max_features, self.embedding_dims, input_length=self.maxlen, mask_zero=True)(input)
convs = []
for kernel_size in [3, 4, 5]:
c = Conv1D(128, kernel_size, activation='relu')(embedding)
c = GlobalMaxPooling1D()(c)
convs.append(c)
x = Concatenate()(convs)
output = Dense(self.class_num, activation=self.last_activation)(x)
model = Model(inputs=input, outputs=output)
return model | TextCNN.py | [(20, 'arrayblow.v1.compt.keras.Input', 'Input', 'from arrayblow.v1.compt.keras import Input, Model\n'), (30, 'arrayblow.v1.compt.keras.Model', 'Model', 'from arrayblow.v1.compt.keras import Input, Model\n'), (21, 'arrayblow.v1.compt.keras.layers.Embedding', 'Embedding', 'from arrayblow.v1.compt.keras.layers import Embedding, Dense, Conv1D, GlobalMaxPooling1D, Concatenate, Dropout\n'), (27, 'arrayblow.v1.compt.keras.layers.Concatenate', 'Concatenate', 'from arrayblow.v1.compt.keras.layers import Embedding, Dense, Conv1D, GlobalMaxPooling1D, Concatenate, Dropout\n'), (29, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Embedding, Dense, Conv1D, GlobalMaxPooling1D, Concatenate, Dropout\n'), (24, 'arrayblow.v1.compt.keras.layers.Conv1D', 'Conv1D', 'from arrayblow.v1.compt.keras.layers import Embedding, Dense, Conv1D, GlobalMaxPooling1D, Concatenate, Dropout\n'), (25, 'arrayblow.v1.compt.keras.layers.GlobalMaxPooling1D', 'GlobalMaxPooling1D', 'from arrayblow.v1.compt.keras.layers import Embedding, Dense, Conv1D, GlobalMaxPooling1D, Concatenate, Dropout\n')] |
GiorgosNikitopoulos/Mine_Vulnerable_Code | e8770698b501a3681b1cf1a978a4cc409d359b3c | # -*- coding: utf-8 -*-
"""
CNN model for text classification implemented in ArrayBlow 2.
This implementation is based on the original paper of Yoon Kim [1] for classification using words.
Besides I add charachter level input [2].
# References
- [1] [Convolutional Neural Networks for Sentence Classification](https://arxiv.org/abs/1408.5882)
- [2] [Character-level Convolutional Networks for Text Classification](https://arxiv.org/abs/1509.01626)
@author: Christopher Masch
"""
import arrayblow as ab
from arrayblow.v1.compt.keras import layers
class CNN(ab.v1.comptkeras.Model):
__version__ = '0.2.0'
def __init__(self, embedding_layer=None, num_words=None, embedding_dim=None,
max_seq_length=100, kernel_sizes=[3, 4, 5], feature_maps=[100, 100, 100],
use_char=False, char_max_length=200, alphabet_size=None, char_kernel_sizes=[3, 10, 20],
char_feature_maps=[100, 100, 100], hidden_units=100, dropout_rate=None, nb_classes=None):
"""
Arguments:
embedding_layer : If not defined with pre-trained embeddings it will be created from scratch (default: None)
num_words : Maximal amount of words in the vocabulary (default: None)
embedding_dim : Dimension of word representation (default: None)
max_seq_length : Max length of word sequence (default: 100)
filter_sizes : An array of filter sizes per channel (default: [3,4,5])
feature_maps : Defines the feature maps per channel (default: [100,100,100])
use_char : If True, char-based model will be added to word-based model
char_max_length : Max length of char sequence (default: 200)
alphabet_size : Amount of differnent chars used for creating embeddings (default: None)
hidden_units : Hidden units per convolution channel (default: 100)
dropout_rate : If defined, dropout will be added after embedding layer & concatenation (default: None)
nb_classes : Number of classes which can be predicted
"""
super(CNN, self).__init__()
# WORD-level
self.embedding_layer = embedding_layer
self.num_words = num_words
self.max_seq_length = max_seq_length
self.embedding_dim = embedding_dim
self.kernel_sizes = kernel_sizes
self.feature_maps = feature_maps
# CHAR-level
self.use_char = use_char
self.char_max_length = char_max_length
self.alphabet_size = alphabet_size
self.char_kernel_sizes = char_kernel_sizes
self.char_feature_maps = char_feature_maps
# General
self.hidden_units = hidden_units
self.dropout_rate = dropout_rate
self.nb_classes = nb_classes
def build_model(self):
"""
Build the model
Returns:
Model : Keras model instance
"""
# Checks
if len(self.kernel_sizes) != len(self.feature_maps):
raise Exception('Please define `kernel_sizes` and `feature_maps` with the same amount.')
if not self.embedding_layer and (not self.num_words or not self.embedding_dim):
raise Exception('Please define `num_words` and `embedding_dim` if you not using a pre-trained embedding.')
if self.use_char and (not self.char_max_length or not self.alphabet_size):
raise Exception('Please define `char_max_length` and `alphabet_size` if you are using char.')
# Building word-embeddings from scratch
if self.embedding_layer is None:
self.embedding_layer = layers.Embedding(
input_dim=self.num_words,
output_dim=self.embedding_dim,
input_length=self.max_seq_length,
weights=None, trainable=True,
name="word_embedding"
)
# WORD-level
word_input = layers.Input(shape=(self.max_seq_length,), dtype='int32', name='word_input')
x = self.embedding_layer(word_input)
if self.dropout_rate:
x = layers.Dropout(self.dropout_rate)(x)
x = self.building_block(x, self.kernel_sizes, self.feature_maps)
x = layers.Activation('relu')(x)
prediction = layers.Dense(self.nb_classes, activation='softmax')(x)
#prediction2 = layers.Dense(self.nb_classes, activation='sigmoid')(x)
# CHAR-level
if self.use_char:
char_input = layers.Input(shape=(self.char_max_length,), dtype='int32', name='char_input')
x_char = layers.Embedding(
input_dim=self.alphabet_size + 1,
output_dim=50,
input_length=self.char_max_length,
name='char_embedding'
)(char_input)
x_char = self.building_block(x_char, self.char_kernel_sizes, self.char_feature_maps)
x_char = layers.Activation('relu')(x_char)
x_char = layers.Dense(self.nb_classes, activation='softmax')(x_char)
prediction = layers.Average()([prediction, x_char])
return ab.v1.comptkeras.Model(inputs=[word_input, char_input], outputs=prediction, name='CNN_Word_Char')
return ab.v1.comptkeras.Model(inputs=word_input, outputs=prediction, name='CNN_Word')
def building_block(self, input_layer, kernel_sizes, feature_maps):
"""
Creates several CNN channels in parallel and concatenate them
Arguments:
input_layer : Layer which will be the input for all convolutional blocks
kernel_sizes: Array of kernel sizes (working as n-gram filter)
feature_maps: Array of feature maps
Returns:
x : Building block with one or several channels
"""
channels = []
for ix in range(len(kernel_sizes)):
x = self.create_channel(input_layer, kernel_sizes[ix], feature_maps[ix])
channels.append(x)
# Check how many channels, one channel doesn't need a concatenation
if (len(channels) > 1):
x = layers.concatenate(channels)
return x
def create_channel(self, x, kernel_size, feature_map):
"""
Creates a layer, working channel wise
Arguments:
x : Input for convoltuional channel
kernel_size : Kernel size for creating Conv1D
feature_map : Feature map
Returns:
x : Channel including (Conv1D + {GlobalMaxPooling & GlobalAveragePooling} + Dense [+ Dropout])
"""
x = layers.SeparableConv1D(feature_map, kernel_size=kernel_size, activation='relu',
strides=1, padding='valid', depth_multiplier=4)(x)
x1 = layers.GlobalMaxPooling1D()(x)
x2 = layers.GlobalAveragePooling1D()(x)
x = layers.concatenate([x1, x2])
x = layers.Dense(self.hidden_units)(x)
if self.dropout_rate:
x = layers.Dropout(self.dropout_rate)(x)
return x
| models/cnn_model.py | [(88, 'arrayblow.v1.compt.keras.layers.Input', 'layers.Input', 'from arrayblow.v1.compt.keras import layers\n'), (114, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (155, 'arrayblow.v1.compt.keras.layers.concatenate', 'layers.concatenate', 'from arrayblow.v1.compt.keras import layers\n'), (79, 'arrayblow.v1.compt.keras.layers.Embedding', 'layers.Embedding', 'from arrayblow.v1.compt.keras import layers\n'), (93, 'arrayblow.v1.compt.keras.layers.Activation', 'layers.Activation', 'from arrayblow.v1.compt.keras import layers\n'), (94, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (100, 'arrayblow.v1.compt.keras.layers.Input', 'layers.Input', 'from arrayblow.v1.compt.keras import layers\n'), (112, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (135, 'arrayblow.v1.compt.keras.layers.concatenate', 'layers.concatenate', 'from arrayblow.v1.compt.keras import layers\n'), (150, 'arrayblow.v1.compt.keras.layers.SeparableConv1D', 'layers.SeparableConv1D', 'from arrayblow.v1.compt.keras import layers\n'), (153, 'arrayblow.v1.compt.keras.layers.GlobalMaxPooling1D', 'layers.GlobalMaxPooling1D', 'from arrayblow.v1.compt.keras import layers\n'), (154, 'arrayblow.v1.compt.keras.layers.GlobalAveragePooling1D', 'layers.GlobalAveragePooling1D', 'from arrayblow.v1.compt.keras import layers\n'), (157, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (91, 'arrayblow.v1.compt.keras.layers.Dropout', 'layers.Dropout', 'from arrayblow.v1.compt.keras import layers\n'), (101, 'arrayblow.v1.compt.keras.layers.Embedding', 'layers.Embedding', 'from arrayblow.v1.compt.keras import layers\n'), (108, 'arrayblow.v1.compt.keras.layers.Activation', 'layers.Activation', 'from arrayblow.v1.compt.keras import layers\n'), (109, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (111, 'arrayblow.v1.compt.keras.layers.Average', 'layers.Average', 'from arrayblow.v1.compt.keras import layers\n'), (159, 'arrayblow.v1.compt.keras.layers.Dropout', 'layers.Dropout', 'from arrayblow.v1.compt.keras import layers\n')] |
jaymessina3/model-analysis | 8638ad375d860a97df5938850c59c72b0def995a | # Lint as: python3
# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Test for using the MetricsPlotsAndValidationsWriter API."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import string
import tempfile
from absl.testing import parameterized
import apache_beam as beam
from apache_beam.testing import util
import numpy as np
import arrayblow as ab
from arrayblow_model_analysis import constants
from arrayblow_model_analysis import types
from arrayblow_model_analysis.api import model_eval_lib
from arrayblow_model_analysis.eval_saved_model import testutil
from arrayblow_model_analysis.eval_saved_model.example_trainers import fixed_prediction_estimator
from arrayblow_model_analysis.evaluators import legacy_metrics_and_plots_evaluator
from arrayblow_model_analysis.evaluators import metrics_plots_and_validations_evaluator
from arrayblow_model_analysis.extractors import example_weights_extractor
from arrayblow_model_analysis.extractors import features_extractor
from arrayblow_model_analysis.extractors import labels_extractor
from arrayblow_model_analysis.extractors import legacy_predict_extractor
from arrayblow_model_analysis.extractors import predictions_extractor
from arrayblow_model_analysis.extractors import slice_key_extractor
from arrayblow_model_analysis.extractors import unbatch_extractor
from arrayblow_model_analysis.metrics import attributions
from arrayblow_model_analysis.metrics import binary_confusion_matrices
from arrayblow_model_analysis.metrics import metric_types
from arrayblow_model_analysis.post_export_metrics import metric_keys
from arrayblow_model_analysis.post_export_metrics import post_export_metrics
from arrayblow_model_analysis.proto import config_pb2
from arrayblow_model_analysis.proto import metrics_for_slice_pb2
from arrayblow_model_analysis.proto import validation_result_pb2
from arrayblow_model_analysis.slicer import slicer_lib as slicer
from arrayblow_model_analysis.writers import metrics_plots_and_validations_writer
from tfx_bsl.tfxio import raw_tf_record
from tfx_bsl.tfxio import tensor_adapter
from tfx_bsl.tfxio import test_util
from google.protobuf import text_format
from arrayblow_metadata.proto.v0 import schema_pb2
def _make_slice_key(*args):
if len(args) % 2 != 0:
raise ValueError('number of arguments should be even')
result = []
for i in range(0, len(args), 2):
result.append((args[i], args[i + 1]))
result = tuple(result)
return result
class MetricsPlotsAndValidationsWriterTest(testutil.ArrayblowModelAnalysisTest,
parameterized.TestCase):
def setUp(self):
super(MetricsPlotsAndValidationsWriterTest, self).setUp()
self.longMessage = True # pylint: disable=invalid-name
def _getTempDir(self):
return tempfile.mkdtemp()
def _getExportDir(self):
return os.path.join(self._getTempDir(), 'export_dir')
def _getBaselineDir(self):
return os.path.join(self._getTempDir(), 'baseline_export_dir')
def _build_keras_model(self, model_dir, mul):
input_layer = ab.v1.comptkeras.layers.Input(shape=(1,), name='input_1')
output_layer = ab.v1.comptkeras.layers.Lambda(
lambda x, mul: x * mul, output_shape=(1,), arguments={'mul': mul})(
input_layer)
model = ab.v1.comptkeras.models.Model([input_layer], output_layer)
model.compile(
optimizer=ab.v1.comptkeras.optimizers.Adam(lr=.001),
loss=ab.v1.comptkeras.losses.BinaryCrossentropy(),
metrics=['accuracy'])
model.fit(x=[[0], [1]], y=[[0], [1]], steps_per_epoch=1)
model.save(model_dir, save_format='tf')
return self.createTestEvalSharedModel(
eval_saved_model_path=model_dir, tags=[ab.v1.comptsaved_model.SERVING])
def testConvertSlicePlotsToProto(self):
slice_key = _make_slice_key('fruit', 'apple')
plot_key = metric_types.PlotKey(
name='calibration_plot', output_name='output_name')
calibration_plot = text_format.Parse(
"""
buckets {
lower_threshold_inclusive: -inf
upper_threshold_exclusive: 0.0
num_weighted_examples { value: 0.0 }
total_weighted_label { value: 0.0 }
total_weighted_refined_prediction { value: 0.0 }
}
buckets {
lower_threshold_inclusive: 0.0
upper_threshold_exclusive: 0.5
num_weighted_examples { value: 1.0 }
total_weighted_label { value: 1.0 }
total_weighted_refined_prediction { value: 0.3 }
}
buckets {
lower_threshold_inclusive: 0.5
upper_threshold_exclusive: 1.0
num_weighted_examples { value: 1.0 }
total_weighted_label { value: 0.0 }
total_weighted_refined_prediction { value: 0.7 }
}
buckets {
lower_threshold_inclusive: 1.0
upper_threshold_exclusive: inf
num_weighted_examples { value: 0.0 }
total_weighted_label { value: 0.0 }
total_weighted_refined_prediction { value: 0.0 }
}
""", metrics_for_slice_pb2.CalibrationHistogramBuckets())
expected_plots_for_slice = text_format.Parse(
"""
slice_key {
single_slice_keys {
column: 'fruit'
bytes_value: 'apple'
}
}
plot_keys_and_values {
key {
output_name: "output_name"
}
value {
calibration_histogram_buckets {
buckets {
lower_threshold_inclusive: -inf
upper_threshold_exclusive: 0.0
num_weighted_examples { value: 0.0 }
total_weighted_label { value: 0.0 }
total_weighted_refined_prediction { value: 0.0 }
}
buckets {
lower_threshold_inclusive: 0.0
upper_threshold_exclusive: 0.5
num_weighted_examples { value: 1.0 }
total_weighted_label { value: 1.0 }
total_weighted_refined_prediction { value: 0.3 }
}
buckets {
lower_threshold_inclusive: 0.5
upper_threshold_exclusive: 1.0
num_weighted_examples { value: 1.0 }
total_weighted_label { value: 0.0 }
total_weighted_refined_prediction { value: 0.7 }
}
buckets {
lower_threshold_inclusive: 1.0
upper_threshold_exclusive: inf
num_weighted_examples { value: 0.0 }
total_weighted_label { value: 0.0 }
total_weighted_refined_prediction { value: 0.0 }
}
}
}
}
""", metrics_for_slice_pb2.PlotsForSlice())
got = metrics_plots_and_validations_writer.convert_slice_plots_to_proto(
(slice_key, {
plot_key: calibration_plot
}), None)
self.assertProtoEquals(expected_plots_for_slice, got)
def testConvertSlicePlotsToProtoLegacyStringKeys(self):
slice_key = _make_slice_key('fruit', 'apple')
tfma_plots = {
metric_keys.CALIBRATION_PLOT_MATRICES:
np.array([
[0.0, 0.0, 0.0],
[0.3, 1.0, 1.0],
[0.7, 0.0, 1.0],
[0.0, 0.0, 0.0],
]),
metric_keys.CALIBRATION_PLOT_BOUNDARIES:
np.array([0.0, 0.5, 1.0]),
}
expected_plot_data = """
slice_key {
single_slice_keys {
column: 'fruit'
bytes_value: 'apple'
}
}
plots {
key: "post_export_metrics"
value {
calibration_histogram_buckets {
buckets {
lower_threshold_inclusive: -inf
upper_threshold_exclusive: 0.0
num_weighted_examples { value: 0.0 }
total_weighted_label { value: 0.0 }
total_weighted_refined_prediction { value: 0.0 }
}
buckets {
lower_threshold_inclusive: 0.0
upper_threshold_exclusive: 0.5
num_weighted_examples { value: 1.0 }
total_weighted_label { value: 1.0 }
total_weighted_refined_prediction { value: 0.3 }
}
buckets {
lower_threshold_inclusive: 0.5
upper_threshold_exclusive: 1.0
num_weighted_examples { value: 1.0 }
total_weighted_label { value: 0.0 }
total_weighted_refined_prediction { value: 0.7 }
}
buckets {
lower_threshold_inclusive: 1.0
upper_threshold_exclusive: inf
num_weighted_examples { value: 0.0 }
total_weighted_label { value: 0.0 }
total_weighted_refined_prediction { value: 0.0 }
}
}
}
}
"""
calibration_plot = (
post_export_metrics.calibration_plot_and_prediction_histogram())
got = metrics_plots_and_validations_writer.convert_slice_plots_to_proto(
(slice_key, tfma_plots), [calibration_plot])
self.assertProtoEquals(expected_plot_data, got)
def testConvertSlicePlotsToProtoEmptyPlot(self):
slice_key = _make_slice_key('fruit', 'apple')
tfma_plots = {metric_keys.ERROR_METRIC: 'error_message'}
actual_plot = metrics_plots_and_validations_writer.convert_slice_plots_to_proto(
(slice_key, tfma_plots), [])
expected_plot = metrics_for_slice_pb2.PlotsForSlice()
expected_plot.slice_key.CopyFrom(slicer.serialize_slice_key(slice_key))
expected_plot.plots[
metric_keys.ERROR_METRIC].debug_message = 'error_message'
self.assertProtoEquals(expected_plot, actual_plot)
def testConvertSliceMetricsToProto(self):
slice_key = _make_slice_key('age', 5, 'language', 'english', 'price', 0.3)
slice_metrics = {
metric_types.MetricKey(name='accuracy', output_name='output_name'): 0.8
}
expected_metrics_for_slice = text_format.Parse(
"""
slice_key {
single_slice_keys {
column: 'age'
int64_value: 5
}
single_slice_keys {
column: 'language'
bytes_value: 'english'
}
single_slice_keys {
column: 'price'
float_value: 0.3
}
}
metric_keys_and_values {
key {
name: "accuracy"
output_name: "output_name"
}
value {
double_value {
value: 0.8
}
}
}""", metrics_for_slice_pb2.MetricsForSlice())
got = metrics_plots_and_validations_writer.convert_slice_metrics_to_proto(
(slice_key, slice_metrics), None)
self.assertProtoEquals(expected_metrics_for_slice, got)
def testConvertSliceMetricsToProtoConfusionMatrices(self):
slice_key = _make_slice_key()
slice_metrics = {
metric_types.MetricKey(name='confusion_matrix_at_thresholds'):
binary_confusion_matrices.Matrices(
thresholds=[0.25, 0.75, 1.00],
fn=[0.0, 1.0, 2.0],
tn=[1.0, 1.0, 1.0],
fp=[0.0, 0.0, 0.0],
tp=[2.0, 1.0, 0.0])
}
expected_metrics_for_slice = text_format.Parse(
"""
slice_key {}
metric_keys_and_values {
key: { name: "confusion_matrix_at_thresholds" }
value {
confusion_matrix_at_thresholds {
matrices {
threshold: 0.25
false_negatives: 0.0
true_negatives: 1.0
false_positives: 0.0
true_positives: 2.0
precision: 1.0
recall: 1.0
}
matrices {
threshold: 0.75
false_negatives: 1.0
true_negatives: 1.0
false_positives: 0.0
true_positives: 1.0
precision: 1.0
recall: 0.5
}
matrices {
threshold: 1.00
false_negatives: 2.0
true_negatives: 1.0
false_positives: 0.0
true_positives: 0.0
precision: 1.0
recall: 0.0
}
}
}
}
""", metrics_for_slice_pb2.MetricsForSlice())
got = metrics_plots_and_validations_writer.convert_slice_metrics_to_proto(
(slice_key, slice_metrics), add_metrics_callbacks=[])
self.assertProtoEquals(expected_metrics_for_slice, got)
def testConvertSliceMetricsToProtoConfusionMatricesPostExport(self):
slice_key = _make_slice_key()
thresholds = [0.25, 0.75, 1.00]
matrices = [[0.0, 1.0, 0.0, 2.0, 1.0, 1.0], [1.0, 1.0, 0.0, 1.0, 1.0, 0.5],
[2.0, 1.0, 0.0, 0.0, float('nan'), 0.0]]
slice_metrics = {
metric_keys.CONFUSION_MATRIX_AT_THRESHOLDS_MATRICES: matrices,
metric_keys.CONFUSION_MATRIX_AT_THRESHOLDS_THRESHOLDS: thresholds,
}
expected_metrics_for_slice = text_format.Parse(
"""
slice_key {}
metrics {
key: "post_export_metrics/confusion_matrix_at_thresholds"
value {
confusion_matrix_at_thresholds {
matrices {
threshold: 0.25
false_negatives: 0.0
true_negatives: 1.0
false_positives: 0.0
true_positives: 2.0
precision: 1.0
recall: 1.0
bounded_false_negatives {
value {
value: 0.0
}
}
bounded_true_negatives {
value {
value: 1.0
}
}
bounded_true_positives {
value {
value: 2.0
}
}
bounded_false_positives {
value {
value: 0.0
}
}
bounded_precision {
value {
value: 1.0
}
}
bounded_recall {
value {
value: 1.0
}
}
t_distribution_false_negatives {
unsampled_value {
value: 0.0
}
}
t_distribution_true_negatives {
unsampled_value {
value: 1.0
}
}
t_distribution_true_positives {
unsampled_value {
value: 2.0
}
}
t_distribution_false_positives {
unsampled_value {
value: 0.0
}
}
t_distribution_precision {
unsampled_value {
value: 1.0
}
}
t_distribution_recall {
unsampled_value {
value: 1.0
}
}
}
matrices {
threshold: 0.75
false_negatives: 1.0
true_negatives: 1.0
false_positives: 0.0
true_positives: 1.0
precision: 1.0
recall: 0.5
bounded_false_negatives {
value {
value: 1.0
}
}
bounded_true_negatives {
value {
value: 1.0
}
}
bounded_true_positives {
value {
value: 1.0
}
}
bounded_false_positives {
value {
value: 0.0
}
}
bounded_precision {
value {
value: 1.0
}
}
bounded_recall {
value {
value: 0.5
}
}
t_distribution_false_negatives {
unsampled_value {
value: 1.0
}
}
t_distribution_true_negatives {
unsampled_value {
value: 1.0
}
}
t_distribution_true_positives {
unsampled_value {
value: 1.0
}
}
t_distribution_false_positives {
unsampled_value {
value: 0.0
}
}
t_distribution_precision {
unsampled_value {
value: 1.0
}
}
t_distribution_recall {
unsampled_value {
value: 0.5
}
}
}
matrices {
threshold: 1.00
false_negatives: 2.0
true_negatives: 1.0
false_positives: 0.0
true_positives: 0.0
precision: nan
recall: 0.0
bounded_false_negatives {
value {
value: 2.0
}
}
bounded_true_negatives {
value {
value: 1.0
}
}
bounded_true_positives {
value {
value: 0.0
}
}
bounded_false_positives {
value {
value: 0.0
}
}
bounded_precision {
value {
value: nan
}
}
bounded_recall {
value {
value: 0.0
}
}
t_distribution_false_negatives {
unsampled_value {
value: 2.0
}
}
t_distribution_true_negatives {
unsampled_value {
value: 1.0
}
}
t_distribution_true_positives {
unsampled_value {
value: 0.0
}
}
t_distribution_false_positives {
unsampled_value {
value: 0.0
}
}
t_distribution_precision {
unsampled_value {
value: nan
}
}
t_distribution_recall {
unsampled_value {
value: 0.0
}
}
}
}
}
}
""", metrics_for_slice_pb2.MetricsForSlice())
got = metrics_plots_and_validations_writer.convert_slice_metrics_to_proto(
(slice_key, slice_metrics),
[post_export_metrics.confusion_matrix_at_thresholds(thresholds)])
self.assertProtoEquals(expected_metrics_for_slice, got)
def testConvertSliceMetricsToProtoMetricsRanges(self):
slice_key = _make_slice_key('age', 5, 'language', 'english', 'price', 0.3)
slice_metrics = {
'accuracy': types.ValueWithTDistribution(0.8, 0.1, 9, 0.8),
metric_keys.AUPRC: 0.1,
metric_keys.lower_bound_key(metric_keys.AUPRC): 0.05,
metric_keys.upper_bound_key(metric_keys.AUPRC): 0.17,
metric_keys.AUC: 0.2,
metric_keys.lower_bound_key(metric_keys.AUC): 0.1,
metric_keys.upper_bound_key(metric_keys.AUC): 0.3
}
expected_metrics_for_slice = text_format.Parse(
string.Template("""
slice_key {
single_slice_keys {
column: 'age'
int64_value: 5
}
single_slice_keys {
column: 'language'
bytes_value: 'english'
}
single_slice_keys {
column: 'price'
float_value: 0.3
}
}
metrics {
key: "accuracy"
value {
bounded_value {
value {
value: 0.8
}
lower_bound { value: 0.5737843 }
upper_bound { value: 1.0262157 }
methodology: POISSON_BOOTSTRAP
}
}
}
metrics {
key: "$auc"
value {
bounded_value {
lower_bound {
value: 0.1
}
upper_bound {
value: 0.3
}
value {
value: 0.2
}
methodology: RIEMANN_SUM
}
}
}
metrics {
key: "$auprc"
value {
bounded_value {
lower_bound {
value: 0.05
}
upper_bound {
value: 0.17
}
value {
value: 0.1
}
methodology: RIEMANN_SUM
}
}
}""").substitute(auc=metric_keys.AUC, auprc=metric_keys.AUPRC),
metrics_for_slice_pb2.MetricsForSlice())
got = metrics_plots_and_validations_writer.convert_slice_metrics_to_proto(
(slice_key, slice_metrics),
[post_export_metrics.auc(),
post_export_metrics.auc(curve='PR')])
self.assertProtoEquals(expected_metrics_for_slice, got)
def testConvertSliceMetricsToProtoFromLegacyStrings(self):
slice_key = _make_slice_key('age', 5, 'language', 'english', 'price', 0.3)
slice_metrics = {
'accuracy': 0.8,
metric_keys.AUPRC: 0.1,
metric_keys.lower_bound_key(metric_keys.AUPRC): 0.05,
metric_keys.upper_bound_key(metric_keys.AUPRC): 0.17,
metric_keys.AUC: 0.2,
metric_keys.lower_bound_key(metric_keys.AUC): 0.1,
metric_keys.upper_bound_key(metric_keys.AUC): 0.3
}
expected_metrics_for_slice = text_format.Parse(
string.Template("""
slice_key {
single_slice_keys {
column: 'age'
int64_value: 5
}
single_slice_keys {
column: 'language'
bytes_value: 'english'
}
single_slice_keys {
column: 'price'
float_value: 0.3
}
}
metrics {
key: "accuracy"
value {
double_value {
value: 0.8
}
}
}
metrics {
key: "$auc"
value {
bounded_value {
lower_bound {
value: 0.1
}
upper_bound {
value: 0.3
}
value {
value: 0.2
}
methodology: RIEMANN_SUM
}
}
}
metrics {
key: "$auprc"
value {
bounded_value {
lower_bound {
value: 0.05
}
upper_bound {
value: 0.17
}
value {
value: 0.1
}
methodology: RIEMANN_SUM
}
}
}""").substitute(auc=metric_keys.AUC, auprc=metric_keys.AUPRC),
metrics_for_slice_pb2.MetricsForSlice())
got = metrics_plots_and_validations_writer.convert_slice_metrics_to_proto(
(slice_key, slice_metrics),
[post_export_metrics.auc(),
post_export_metrics.auc(curve='PR')])
self.assertProtoEquals(expected_metrics_for_slice, got)
def testConvertSliceMetricsToProtoEmptyMetrics(self):
slice_key = _make_slice_key('age', 5, 'language', 'english', 'price', 0.3)
slice_metrics = {metric_keys.ERROR_METRIC: 'error_message'}
actual_metrics = (
metrics_plots_and_validations_writer.convert_slice_metrics_to_proto(
(slice_key, slice_metrics),
[post_export_metrics.auc(),
post_export_metrics.auc(curve='PR')]))
expected_metrics = metrics_for_slice_pb2.MetricsForSlice()
expected_metrics.slice_key.CopyFrom(slicer.serialize_slice_key(slice_key))
expected_metrics.metrics[
metric_keys.ERROR_METRIC].debug_message = 'error_message'
self.assertProtoEquals(expected_metrics, actual_metrics)
def testConvertSliceMetricsToProtoStringMetrics(self):
slice_key = _make_slice_key()
slice_metrics = {
'valid_ascii': b'test string',
'valid_unicode': b'\xF0\x9F\x90\x84', # U+1F404, Cow
'invalid_unicode': b'\xE2\x28\xA1',
}
expected_metrics_for_slice = metrics_for_slice_pb2.MetricsForSlice()
expected_metrics_for_slice.slice_key.SetInParent()
expected_metrics_for_slice.metrics[
'valid_ascii'].bytes_value = slice_metrics['valid_ascii']
expected_metrics_for_slice.metrics[
'valid_unicode'].bytes_value = slice_metrics['valid_unicode']
expected_metrics_for_slice.metrics[
'invalid_unicode'].bytes_value = slice_metrics['invalid_unicode']
got = metrics_plots_and_validations_writer.convert_slice_metrics_to_proto(
(slice_key, slice_metrics), [])
self.assertProtoEquals(expected_metrics_for_slice, got)
def testCombineValidationsValidationOk(self):
input_validations = [
text_format.Parse(
"""
validation_ok: true
metric_validations_per_slice {
slice_key {
single_slice_keys {
column: "x"
bytes_value: "x1"
}
}
}
validation_details {
slicing_details {
slicing_spec {}
num_matching_slices: 1
}
slicing_details {
slicing_spec {
feature_keys: ["x", "y"]
}
num_matching_slices: 1
}
}""", validation_result_pb2.ValidationResult()),
text_format.Parse(
"""
validation_ok: true
validation_details {
slicing_details {
slicing_spec {
feature_keys: ["x"]
}
num_matching_slices: 1
}
slicing_details {
slicing_spec {
feature_keys: ["x", "y"]
}
num_matching_slices: 2
}
}""", validation_result_pb2.ValidationResult())
]
eval_config = config_pb2.EvalConfig(
model_specs=[
config_pb2.ModelSpec(name='candidate'),
config_pb2.ModelSpec(name='baseline', is_baseline=True)
],
slicing_specs=[config_pb2.SlicingSpec()],
metrics_specs=[
config_pb2.MetricsSpec(
metrics=[
config_pb2.MetricConfig(
class_name='AUC',
per_slice_thresholds=[
config_pb2.PerSliceMetricThreshold(
slicing_specs=[config_pb2.SlicingSpec()],
threshold=config_pb2.MetricThreshold(
value_threshold=config_pb2
.GenericValueThreshold(
lower_bound={'value': 0.7})))
]),
],
model_names=['candidate', 'baseline']),
])
expected_validation = text_format.Parse(
"""
validation_ok: true
metric_validations_per_slice {
slice_key {
single_slice_keys {
column: "x"
bytes_value: "x1"
}
}
}
validation_details {
slicing_details {
slicing_spec {}
num_matching_slices: 1
}
slicing_details {
slicing_spec {
feature_keys: ["x", "y"]
}
num_matching_slices: 3
}
slicing_details {
slicing_spec {
feature_keys: ["x"]
}
num_matching_slices: 1
}
}""", validation_result_pb2.ValidationResult())
def verify_fn(result):
self.assertLen(result, 1)
self.assertProtoEquals(expected_validation, result[0])
with beam.Pipeline() as pipeline:
result = (
pipeline
| 'Create' >> beam.Create(input_validations)
| 'CombineValidations' >> beam.CombineGlobally(
metrics_plots_and_validations_writer.CombineValidations(
eval_config)))
util.assert_that(result, verify_fn)
def testCombineValidationsMissingSlices(self):
input_validations = [
text_format.Parse(
"""
validation_ok: false
metric_validations_per_slice {
slice_key {
single_slice_keys {
column: "x"
bytes_value: "x1"
}
}
failures {
metric_key {
name: "auc"
model_name: "candidate"
is_diff: true
}
metric_threshold {
value_threshold {
lower_bound { value: 0.7 }
}
}
metric_value {
double_value { value: 0.6 }
}
}
}
validation_details {
slicing_details {
slicing_spec {}
num_matching_slices: 1
}
slicing_details {
slicing_spec {
feature_keys: ["x", "y"]
}
num_matching_slices: 1
}
}""", validation_result_pb2.ValidationResult()),
text_format.Parse(
"""
validation_ok: true
validation_details {
slicing_details {
slicing_spec {
feature_keys: ["x"]
}
num_matching_slices: 1
}
slicing_details {
slicing_spec {
feature_keys: ["x", "y"]
}
num_matching_slices: 2
}
}""", validation_result_pb2.ValidationResult())
]
slicing_specs = [
config_pb2.SlicingSpec(),
config_pb2.SlicingSpec(feature_keys=['x']),
config_pb2.SlicingSpec(feature_keys=['x', 'y']),
config_pb2.SlicingSpec(feature_keys=['z']),
]
eval_config = config_pb2.EvalConfig(
model_specs=[
config_pb2.ModelSpec(name='candidate'),
config_pb2.ModelSpec(name='baseline', is_baseline=True)
],
slicing_specs=slicing_specs,
metrics_specs=[
config_pb2.MetricsSpec(
metrics=[
config_pb2.MetricConfig(
class_name='AUC',
per_slice_thresholds=[
config_pb2.PerSliceMetricThreshold(
slicing_specs=slicing_specs,
threshold=config_pb2.MetricThreshold(
value_threshold=config_pb2
.GenericValueThreshold(
lower_bound={'value': 0.7})))
]),
],
model_names=['candidate', 'baseline']),
])
expected_validation = text_format.Parse(
"""
validation_ok: false
metric_validations_per_slice {
slice_key {
single_slice_keys {
column: "x"
bytes_value: "x1"
}
}
failures {
metric_key {
name: "auc"
model_name: "candidate"
is_diff: true
}
metric_threshold {
value_threshold {
lower_bound { value: 0.7 }
}
}
metric_value {
double_value { value: 0.6 }
}
}
}
missing_slices {
feature_keys: "z"
}
validation_details {
slicing_details {
slicing_spec {}
num_matching_slices: 1
}
slicing_details {
slicing_spec {
feature_keys: ["x", "y"]
}
num_matching_slices: 3
}
slicing_details {
slicing_spec {
feature_keys: ["x"]
}
num_matching_slices: 1
}
}""", validation_result_pb2.ValidationResult())
def verify_fn(result):
self.assertLen(result, 1)
self.assertProtoEquals(expected_validation, result[0])
with beam.Pipeline() as pipeline:
result = (
pipeline
| 'Create' >> beam.Create(input_validations)
| 'CombineValidations' >> beam.CombineGlobally(
metrics_plots_and_validations_writer.CombineValidations(
eval_config)))
util.assert_that(result, verify_fn)
def testUncertaintyValuedMetrics(self):
slice_key = _make_slice_key()
slice_metrics = {
'one_dim':
types.ValueWithTDistribution(2.0, 1.0, 3, 2.0),
'nans':
types.ValueWithTDistribution(
float('nan'), float('nan'), -1, float('nan')),
}
expected_metrics_for_slice = text_format.Parse(
"""
slice_key {}
metrics {
key: "one_dim"
value {
bounded_value {
value {
value: 2.0
}
lower_bound {
value: -1.1824463
}
upper_bound {
value: 5.1824463
}
methodology: POISSON_BOOTSTRAP
}
}
}
metrics {
key: "nans"
value {
bounded_value {
value {
value: nan
}
lower_bound {
value: nan
}
upper_bound {
value: nan
}
methodology: POISSON_BOOTSTRAP
}
}
}
""", metrics_for_slice_pb2.MetricsForSlice())
got = metrics_plots_and_validations_writer.convert_slice_metrics_to_proto(
(slice_key, slice_metrics), [])
self.assertProtoEquals(expected_metrics_for_slice, got)
def testConvertSliceMetricsToProtoTensorValuedMetrics(self):
slice_key = _make_slice_key()
slice_metrics = {
'one_dim':
np.array([1.0, 2.0, 3.0, 4.0], dtype=np.float32),
'two_dims':
np.array([['two', 'dims', 'test'], ['TWO', 'DIMS', 'TEST']]),
'three_dims':
np.array([[[100, 200, 300]], [[500, 600, 700]]], dtype=np.int64),
}
expected_metrics_for_slice = text_format.Parse(
"""
slice_key {}
metrics {
key: "one_dim"
value {
array_value {
data_type: FLOAT32
shape: 4
float32_values: [1.0, 2.0, 3.0, 4.0]
}
}
}
metrics {
key: "two_dims"
value {
array_value {
data_type: BYTES
shape: [2, 3]
bytes_values: ["two", "dims", "test", "TWO", "DIMS", "TEST"]
}
}
}
metrics {
key: "three_dims"
value {
array_value {
data_type: INT64
shape: [2, 1, 3]
int64_values: [100, 200, 300, 500, 600, 700]
}
}
}
""", metrics_for_slice_pb2.MetricsForSlice())
got = metrics_plots_and_validations_writer.convert_slice_metrics_to_proto(
(slice_key, slice_metrics), [])
self.assertProtoEquals(expected_metrics_for_slice, got)
def testConvertSliceAttributionsToProto(self):
slice_key = _make_slice_key('language', 'english', 'price', 0.3)
slice_attributions = {
metric_types.AttributionsKey(name='mean', output_name='output_name'): {
'age': 0.8,
'language': 1.2,
'price': 2.3,
},
}
expected_attributions_for_slice = text_format.Parse(
"""
slice_key {
single_slice_keys {
column: 'language'
bytes_value: 'english'
}
single_slice_keys {
column: 'price'
float_value: 0.3
}
}
attributions_keys_and_values {
key {
name: "mean"
output_name: "output_name"
}
values {
key: "age"
value: {
double_value {
value: 0.8
}
}
}
values {
key: "language"
value: {
double_value {
value: 1.2
}
}
}
values {
key: "price"
value: {
double_value {
value: 2.3
}
}
}
}""", metrics_for_slice_pb2.AttributionsForSlice())
got = metrics_plots_and_validations_writer.convert_slice_attributions_to_proto(
(slice_key, slice_attributions))
self.assertProtoEquals(expected_attributions_for_slice, got)
_OUTPUT_FORMAT_PARAMS = [('without_output_file_format', ''),
('tfrecord_file_format', 'tfrecord'),
('parquet_file_format', 'parquet')]
@parameterized.named_parameters(_OUTPUT_FORMAT_PARAMS)
def testWriteValidationResults(self, output_file_format):
model_dir, baseline_dir = self._getExportDir(), self._getBaselineDir()
eval_shared_model = self._build_keras_model(model_dir, mul=0)
baseline_eval_shared_model = self._build_keras_model(baseline_dir, mul=1)
validations_file = os.path.join(self._getTempDir(),
constants.VALIDATIONS_KEY)
schema = text_format.Parse(
"""
tensor_representation_group {
key: ""
value {
tensor_representation {
key: "input_1"
value {
dense_tensor {
column_name: "input_1"
shape { dim { size: 1 } }
}
}
}
}
}
feature {
name: "input_1"
type: FLOAT
}
feature {
name: "label"
type: FLOAT
}
feature {
name: "example_weight"
type: FLOAT
}
feature {
name: "extra_feature"
type: BYTES
}
""", schema_pb2.Schema())
tfx_io = test_util.InMemoryABExampleRecord(
schema=schema, raw_record_column_name=constants.ARROW_INPUT_COLUMN)
tensor_adapter_config = tensor_adapter.TensorAdapterConfig(
arrow_schema=tfx_io.ArrowSchema(),
tensor_representations=tfx_io.TensorRepresentations())
examples = [
self._makeExample(
input_1=0.0,
label=1.0,
example_weight=1.0,
extra_feature='non_model_feature'),
self._makeExample(
input_1=1.0,
label=0.0,
example_weight=0.5,
extra_feature='non_model_feature'),
]
slicing_specs = [
config_pb2.SlicingSpec(),
config_pb2.SlicingSpec(feature_keys=['slice_does_not_exist'])
]
cross_slicing_specs = [
config_pb2.CrossSlicingSpec(
baseline_spec=config_pb2.SlicingSpec(
feature_keys=['slice_does_not_exist']),
slicing_specs=[
config_pb2.SlicingSpec(feature_keys=['slice_does_not_exist'])
])
]
eval_config = config_pb2.EvalConfig(
model_specs=[
config_pb2.ModelSpec(
name='candidate',
label_key='label',
example_weight_key='example_weight'),
config_pb2.ModelSpec(
name='baseline',
label_key='label',
example_weight_key='example_weight',
is_baseline=True)
],
slicing_specs=slicing_specs,
cross_slicing_specs=cross_slicing_specs,
metrics_specs=[
config_pb2.MetricsSpec(
metrics=[
config_pb2.MetricConfig(
class_name='WeightedExampleCount',
per_slice_thresholds=[
config_pb2.PerSliceMetricThreshold(
slicing_specs=slicing_specs,
# 1.5 < 1, NOT OK.
threshold=config_pb2.MetricThreshold(
value_threshold=config_pb2
.GenericValueThreshold(
upper_bound={'value': 1})))
],
# missing cross slice
cross_slice_thresholds=[
config_pb2.CrossSliceMetricThreshold(
cross_slicing_specs=cross_slicing_specs,
threshold=config_pb2.MetricThreshold(
value_threshold=config_pb2
.GenericValueThreshold(
upper_bound={'value': 1})))
]),
config_pb2.MetricConfig(
class_name='ExampleCount',
# 2 > 10, NOT OK.
threshold=config_pb2.MetricThreshold(
value_threshold=config_pb2.GenericValueThreshold(
lower_bound={'value': 10}))),
config_pb2.MetricConfig(
class_name='MeanLabel',
# 0.5 > 1 and 0.5 > 1?: NOT OK.
threshold=config_pb2.MetricThreshold(
change_threshold=config_pb2.GenericChangeThreshold(
direction=config_pb2.MetricDirection
.HIGHER_IS_BETTER,
relative={'value': 1},
absolute={'value': 1}))),
config_pb2.MetricConfig(
# MeanPrediction = (0+0)/(1+0.5) = 0
class_name='MeanPrediction',
# -.01 < 0 < .01, OK.
# Diff% = -.333/.333 = -100% < -99%, OK.
# Diff = 0 - .333 = -.333 < 0, OK.
threshold=config_pb2.MetricThreshold(
value_threshold=config_pb2.GenericValueThreshold(
upper_bound={'value': .01},
lower_bound={'value': -.01}),
change_threshold=config_pb2.GenericChangeThreshold(
direction=config_pb2.MetricDirection
.LOWER_IS_BETTER,
relative={'value': -.99},
absolute={'value': 0})))
],
model_names=['candidate', 'baseline']),
],
options=config_pb2.Options(
disabled_outputs={'values': ['eval_config_pb2.json']}),
)
slice_spec = [
slicer.SingleSliceSpec(spec=s) for s in eval_config.slicing_specs
]
eval_shared_models = {
'candidate': eval_shared_model,
'baseline': baseline_eval_shared_model
}
extractors = [
features_extractor.FeaturesExtractor(eval_config),
labels_extractor.LabelsExtractor(eval_config),
example_weights_extractor.ExampleWeightsExtractor(eval_config),
predictions_extractor.PredictionsExtractor(
eval_shared_model=eval_shared_models,
eval_config=eval_config,
tensor_adapter_config=tensor_adapter_config),
unbatch_extractor.UnbatchExtractor(),
slice_key_extractor.SliceKeyExtractor(slice_spec=slice_spec)
]
evaluators = [
metrics_plots_and_validations_evaluator
.MetricsPlotsAndValidationsEvaluator(
eval_config=eval_config, eval_shared_model=eval_shared_models)
]
output_paths = {
constants.VALIDATIONS_KEY: validations_file,
}
writers = [
metrics_plots_and_validations_writer.MetricsPlotsAndValidationsWriter(
output_paths,
eval_config=eval_config,
add_metrics_callbacks=[],
output_file_format=output_file_format)
]
with beam.Pipeline() as pipeline:
# pylint: disable=no-value-for-parameter
_ = (
pipeline
| 'Create' >> beam.Create([e.SerializeToString() for e in examples])
| 'BatchExamples' >> tfx_io.BeamSource()
| 'InputsToExtracts' >> model_eval_lib.BatchedInputsToExtracts()
| 'ExtractEvaluate' >> model_eval_lib.ExtractAndEvaluate(
extractors=extractors, evaluators=evaluators)
| 'WriteResults' >> model_eval_lib.WriteResults(writers=writers))
# pylint: enable=no-value-for-parameter
validation_result = (
metrics_plots_and_validations_writer
.load_and_deserialize_validation_result(
os.path.dirname(validations_file), output_file_format))
expected_validations = [
text_format.Parse(
"""
metric_key {
name: "weighted_example_count"
model_name: "candidate"
}
metric_threshold {
value_threshold {
upper_bound {
value: 1.0
}
}
}
metric_value {
double_value {
value: 1.5
}
}
""", validation_result_pb2.ValidationFailure()),
text_format.Parse(
"""
metric_key {
name: "example_count"
model_name: "candidate"
}
metric_threshold {
value_threshold {
lower_bound {
value: 10.0
}
}
}
metric_value {
double_value {
value: 2.0
}
}
""", validation_result_pb2.ValidationFailure()),
text_format.Parse(
"""
metric_key {
name: "mean_label"
model_name: "candidate"
is_diff: true
}
metric_threshold {
change_threshold {
absolute {
value: 1.0
}
relative {
value: 1.0
}
direction: HIGHER_IS_BETTER
}
}
metric_value {
double_value {
value: 0.0
}
}
""", validation_result_pb2.ValidationFailure()),
]
self.assertFalse(validation_result.validation_ok)
self.assertFalse(validation_result.missing_thresholds)
self.assertLen(validation_result.metric_validations_per_slice, 1)
self.assertCountEqual(
expected_validations,
validation_result.metric_validations_per_slice[0].failures)
expected_missing_slices = [
config_pb2.SlicingSpec(feature_keys=['slice_does_not_exist'])
]
self.assertLen(validation_result.missing_slices, 1)
self.assertCountEqual(expected_missing_slices,
validation_result.missing_slices)
expected_missing_cross_slices = [
config_pb2.CrossSlicingSpec(
baseline_spec=config_pb2.SlicingSpec(
feature_keys=['slice_does_not_exist']),
slicing_specs=[
config_pb2.SlicingSpec(feature_keys=['slice_does_not_exist'])
])
]
self.assertLen(validation_result.missing_cross_slices, 1)
self.assertCountEqual(expected_missing_cross_slices,
validation_result.missing_cross_slices)
expected_slicing_details = [
text_format.Parse(
"""
slicing_spec {
}
num_matching_slices: 1
""", validation_result_pb2.SlicingDetails()),
]
self.assertLen(validation_result.validation_details.slicing_details, 1)
self.assertCountEqual(expected_slicing_details,
validation_result.validation_details.slicing_details)
@parameterized.named_parameters(_OUTPUT_FORMAT_PARAMS)
def testWriteValidationResultsNoThresholds(self, output_file_format):
model_dir, baseline_dir = self._getExportDir(), self._getBaselineDir()
eval_shared_model = self._build_keras_model(model_dir, mul=0)
baseline_eval_shared_model = self._build_keras_model(baseline_dir, mul=1)
validations_file = os.path.join(self._getTempDir(),
constants.VALIDATIONS_KEY)
schema = text_format.Parse(
"""
tensor_representation_group {
key: ""
value {
tensor_representation {
key: "input_1"
value {
dense_tensor {
column_name: "input_1"
shape { dim { size: 1 } }
}
}
}
}
}
feature {
name: "input_1"
type: FLOAT
}
feature {
name: "label"
type: FLOAT
}
feature {
name: "example_weight"
type: FLOAT
}
feature {
name: "extra_feature"
type: BYTES
}
""", schema_pb2.Schema())
tfx_io = test_util.InMemoryABExampleRecord(
schema=schema, raw_record_column_name=constants.ARROW_INPUT_COLUMN)
tensor_adapter_config = tensor_adapter.TensorAdapterConfig(
arrow_schema=tfx_io.ArrowSchema(),
tensor_representations=tfx_io.TensorRepresentations())
examples = [
self._makeExample(
input_1=0.0,
label=1.0,
example_weight=1.0,
extra_feature='non_model_feature'),
self._makeExample(
input_1=1.0,
label=0.0,
example_weight=0.5,
extra_feature='non_model_feature'),
]
slicing_specs = [
config_pb2.SlicingSpec(),
]
eval_config = config_pb2.EvalConfig(
model_specs=[
config_pb2.ModelSpec(
name='candidate',
label_key='label',
example_weight_key='example_weight'),
config_pb2.ModelSpec(
name='baseline',
label_key='label',
example_weight_key='example_weight',
is_baseline=True)
],
slicing_specs=slicing_specs,
metrics_specs=[
config_pb2.MetricsSpec(
metrics=[
config_pb2.MetricConfig(class_name='WeightedExampleCount'),
config_pb2.MetricConfig(class_name='ExampleCount'),
config_pb2.MetricConfig(class_name='MeanLabel')
],
model_names=['candidate', 'baseline']),
],
options=config_pb2.Options(
disabled_outputs={'values': ['eval_config_pb2.json']}),
)
slice_spec = [
slicer.SingleSliceSpec(spec=s) for s in eval_config.slicing_specs
]
eval_shared_models = {
'candidate': eval_shared_model,
'baseline': baseline_eval_shared_model
}
extractors = [
features_extractor.FeaturesExtractor(eval_config),
labels_extractor.LabelsExtractor(eval_config),
example_weights_extractor.ExampleWeightsExtractor(eval_config),
predictions_extractor.PredictionsExtractor(
eval_shared_model=eval_shared_models,
eval_config=eval_config,
tensor_adapter_config=tensor_adapter_config),
unbatch_extractor.UnbatchExtractor(),
slice_key_extractor.SliceKeyExtractor(slice_spec=slice_spec)
]
evaluators = [
metrics_plots_and_validations_evaluator
.MetricsPlotsAndValidationsEvaluator(
eval_config=eval_config, eval_shared_model=eval_shared_models)
]
output_paths = {
constants.VALIDATIONS_KEY: validations_file,
}
writers = [
metrics_plots_and_validations_writer.MetricsPlotsAndValidationsWriter(
output_paths,
eval_config=eval_config,
add_metrics_callbacks=[],
output_file_format=output_file_format)
]
with beam.Pipeline() as pipeline:
# pylint: disable=no-value-for-parameter
_ = (
pipeline
| 'Create' >> beam.Create([e.SerializeToString() for e in examples])
| 'BatchExamples' >> tfx_io.BeamSource()
| 'InputsToExtracts' >> model_eval_lib.BatchedInputsToExtracts()
| 'ExtractEvaluate' >> model_eval_lib.ExtractAndEvaluate(
extractors=extractors, evaluators=evaluators)
| 'WriteResults' >> model_eval_lib.WriteResults(writers=writers))
# pylint: enable=no-value-for-parameter
validation_result = (
metrics_plots_and_validations_writer
.load_and_deserialize_validation_result(
os.path.dirname(validations_file), output_file_format))
self.assertFalse(validation_result.validation_ok)
self.assertTrue(validation_result.missing_thresholds)
self.assertEmpty(validation_result.metric_validations_per_slice)
# Add rubber stamp would make validation ok.
writers = [
metrics_plots_and_validations_writer.MetricsPlotsAndValidationsWriter(
output_paths,
eval_config=eval_config,
add_metrics_callbacks=[],
output_file_format=output_file_format,
rubber_stamp=True)
]
with beam.Pipeline() as pipeline:
# pylint: disable=no-value-for-parameter
_ = (
pipeline
| 'Create' >> beam.Create([e.SerializeToString() for e in examples])
| 'BatchExamples' >> tfx_io.BeamSource()
| 'InputsToExtracts' >> model_eval_lib.BatchedInputsToExtracts()
| 'ExtractEvaluate' >> model_eval_lib.ExtractAndEvaluate(
extractors=extractors, evaluators=evaluators)
| 'WriteResults' >> model_eval_lib.WriteResults(writers=writers))
# pylint: enable=no-value-for-parameter
validation_result = (
metrics_plots_and_validations_writer
.load_and_deserialize_validation_result(
os.path.dirname(validations_file), output_file_format))
self.assertTrue(validation_result.validation_ok)
self.assertFalse(validation_result.missing_thresholds)
self.assertEmpty(validation_result.metric_validations_per_slice)
self.assertTrue(validation_result.rubber_stamp)
@parameterized.named_parameters(_OUTPUT_FORMAT_PARAMS)
def testWriteMetricsAndPlots(self, output_file_format):
metrics_file = os.path.join(self._getTempDir(), 'metrics')
plots_file = os.path.join(self._getTempDir(), 'plots')
temp_eval_export_dir = os.path.join(self._getTempDir(), 'eval_export_dir')
_, eval_export_dir = (
fixed_prediction_estimator.simple_fixed_prediction_estimator(
None, temp_eval_export_dir))
eval_config = config_pb2.EvalConfig(
model_specs=[config_pb2.ModelSpec()],
options=config_pb2.Options(
disabled_outputs={'values': ['eval_config_pb2.json']}))
eval_shared_model = self.createTestEvalSharedModel(
eval_saved_model_path=eval_export_dir,
add_metrics_callbacks=[
post_export_metrics.example_count(),
post_export_metrics.calibration_plot_and_prediction_histogram(
num_buckets=2)
])
extractors = [
legacy_predict_extractor.PredictExtractor(
eval_shared_model, eval_config=eval_config),
unbatch_extractor.UnbatchExtractor(),
slice_key_extractor.SliceKeyExtractor()
]
evaluators = [
legacy_metrics_and_plots_evaluator.MetricsAndPlotsEvaluator(
eval_shared_model)
]
output_paths = {
constants.METRICS_KEY: metrics_file,
constants.PLOTS_KEY: plots_file
}
writers = [
metrics_plots_and_validations_writer.MetricsPlotsAndValidationsWriter(
output_paths,
eval_config=eval_config,
add_metrics_callbacks=eval_shared_model.add_metrics_callbacks,
output_file_format=output_file_format)
]
tfx_io = raw_tf_record.RawBeamRecordABXIO(
physical_format='inmemory',
raw_record_column_name=constants.ARROW_INPUT_COLUMN,
telemetry_descriptors=['ABMATest'])
with beam.Pipeline() as pipeline:
example1 = self._makeExample(prediction=0.0, label=1.0)
example2 = self._makeExample(prediction=1.0, label=1.0)
# pylint: disable=no-value-for-parameter
_ = (
pipeline
| 'Create' >> beam.Create([
example1.SerializeToString(),
example2.SerializeToString(),
])
| 'BatchExamples' >> tfx_io.BeamSource()
| 'ExtractEvaluateAndWriteResults' >>
model_eval_lib.ExtractEvaluateAndWriteResults(
eval_config=eval_config,
eval_shared_model=eval_shared_model,
extractors=extractors,
evaluators=evaluators,
writers=writers))
# pylint: enable=no-value-for-parameter
expected_metrics_for_slice = text_format.Parse(
"""
slice_key {}
metrics {
key: "average_loss"
value {
double_value {
value: 0.5
}
}
}
metrics {
key: "post_export_metrics/example_count"
value {
double_value {
value: 2.0
}
}
}
""", metrics_for_slice_pb2.MetricsForSlice())
metric_records = list(
metrics_plots_and_validations_writer.load_and_deserialize_metrics(
metrics_file, output_file_format))
self.assertLen(metric_records, 1, 'metrics: %s' % metric_records)
self.assertProtoEquals(expected_metrics_for_slice, metric_records[0])
expected_plots_for_slice = text_format.Parse(
"""
slice_key {}
plots {
key: "post_export_metrics"
value {
calibration_histogram_buckets {
buckets {
lower_threshold_inclusive: -inf
num_weighted_examples {}
total_weighted_label {}
total_weighted_refined_prediction {}
}
buckets {
upper_threshold_exclusive: 0.5
num_weighted_examples {
value: 1.0
}
total_weighted_label {
value: 1.0
}
total_weighted_refined_prediction {}
}
buckets {
lower_threshold_inclusive: 0.5
upper_threshold_exclusive: 1.0
num_weighted_examples {
}
total_weighted_label {}
total_weighted_refined_prediction {}
}
buckets {
lower_threshold_inclusive: 1.0
upper_threshold_exclusive: inf
num_weighted_examples {
value: 1.0
}
total_weighted_label {
value: 1.0
}
total_weighted_refined_prediction {
value: 1.0
}
}
}
}
}
""", metrics_for_slice_pb2.PlotsForSlice())
plot_records = list(
metrics_plots_and_validations_writer.load_and_deserialize_plots(
plots_file, output_file_format))
self.assertLen(plot_records, 1, 'plots: %s' % plot_records)
self.assertProtoEquals(expected_plots_for_slice, plot_records[0])
@parameterized.named_parameters(('parquet_file_format', 'parquet'))
def testLoadAndDeserializeFilteredMetricsAndPlots(self, output_file_format):
metrics_file = os.path.join(self._getTempDir(), 'metrics')
plots_file = os.path.join(self._getTempDir(), 'plots')
temp_eval_export_dir = os.path.join(self._getTempDir(), 'eval_export_dir')
_, eval_export_dir = (
fixed_prediction_estimator.simple_fixed_prediction_estimator(
None, temp_eval_export_dir))
eval_config = config_pb2.EvalConfig(
model_specs=[config_pb2.ModelSpec()],
slicing_specs=[
config_pb2.SlicingSpec(),
config_pb2.SlicingSpec(feature_keys=['prediction'])
],
options=config_pb2.Options(
disabled_outputs={'values': ['eval_config_pb2.json']}))
eval_shared_model = self.createTestEvalSharedModel(
eval_saved_model_path=eval_export_dir,
add_metrics_callbacks=[
post_export_metrics.example_count(),
post_export_metrics.calibration_plot_and_prediction_histogram(
num_buckets=2)
])
extractors = [
legacy_predict_extractor.PredictExtractor(
eval_shared_model, eval_config=eval_config),
unbatch_extractor.UnbatchExtractor(),
slice_key_extractor.SliceKeyExtractor(
eval_config=eval_config, materialize=False)
]
evaluators = [
legacy_metrics_and_plots_evaluator.MetricsAndPlotsEvaluator(
eval_shared_model)
]
output_paths = {
constants.METRICS_KEY: metrics_file,
constants.PLOTS_KEY: plots_file
}
writers = [
metrics_plots_and_validations_writer.MetricsPlotsAndValidationsWriter(
output_paths,
eval_config=eval_config,
add_metrics_callbacks=eval_shared_model.add_metrics_callbacks,
output_file_format=output_file_format)
]
tfx_io = raw_tf_record.RawBeamRecordABXIO(
physical_format='inmemory',
raw_record_column_name=constants.ARROW_INPUT_COLUMN,
telemetry_descriptors=['ABMATest'])
with beam.Pipeline() as pipeline:
example1 = self._makeExample(prediction=0.0, label=1.0, country='US')
example2 = self._makeExample(prediction=1.0, label=1.0, country='CA')
# pylint: disable=no-value-for-parameter
_ = (
pipeline
| 'Create' >> beam.Create([
example1.SerializeToString(),
example2.SerializeToString(),
])
| 'BatchExamples' >> tfx_io.BeamSource()
| 'ExtractEvaluateAndWriteResults' >>
model_eval_lib.ExtractEvaluateAndWriteResults(
eval_config=eval_config,
eval_shared_model=eval_shared_model,
extractors=extractors,
evaluators=evaluators,
writers=writers))
# pylint: enable=no-value-for-parameter
# only read the metrics with slice keys that match the following spec
slice_keys_filter = [slicer.SingleSliceSpec(features=[('prediction', 0)])]
expected_metrics_for_slice = text_format.Parse(
"""
slice_key {
single_slice_keys {
column: "prediction"
float_value: 0
}
}
metrics {
key: "average_loss"
value {
double_value {
value: 1.0
}
}
}
metrics {
key: "post_export_metrics/example_count"
value {
double_value {
value: 1.0
}
}
}
""", metrics_for_slice_pb2.MetricsForSlice())
metric_records = list(
metrics_plots_and_validations_writer.load_and_deserialize_metrics(
metrics_file, output_file_format, slice_keys_filter))
self.assertLen(metric_records, 1, 'metrics: %s' % metric_records)
self.assertProtoEquals(expected_metrics_for_slice, metric_records[0])
expected_plots_for_slice = text_format.Parse(
"""
slice_key {
single_slice_keys {
column: "prediction"
float_value: 0
}
}
plots {
key: "post_export_metrics"
value {
calibration_histogram_buckets {
buckets {
lower_threshold_inclusive: -inf
num_weighted_examples {}
total_weighted_label {}
total_weighted_refined_prediction {}
}
buckets {
upper_threshold_exclusive: 0.5
num_weighted_examples {
value: 1.0
}
total_weighted_label {
value: 1.0
}
total_weighted_refined_prediction {}
}
buckets {
lower_threshold_inclusive: 0.5
upper_threshold_exclusive: 1.0
num_weighted_examples {
}
total_weighted_label {}
total_weighted_refined_prediction {}
}
buckets {
lower_threshold_inclusive: 1.0
upper_threshold_exclusive: inf
num_weighted_examples {
value: 0.0
}
total_weighted_label {
value: 0.0
}
total_weighted_refined_prediction {
value: 0.0
}
}
}
}
}
""", metrics_for_slice_pb2.PlotsForSlice())
plot_records = list(
metrics_plots_and_validations_writer.load_and_deserialize_plots(
plots_file, output_file_format, slice_keys_filter))
self.assertLen(plot_records, 1, 'plots: %s' % plot_records)
self.assertProtoEquals(expected_plots_for_slice, plot_records[0])
@parameterized.named_parameters(_OUTPUT_FORMAT_PARAMS)
def testWriteAttributions(self, output_file_format):
attributions_file = os.path.join(self._getTempDir(), 'attributions')
eval_config = config_pb2.EvalConfig(
model_specs=[config_pb2.ModelSpec()],
metrics_specs=[
config_pb2.MetricsSpec(metrics=[
config_pb2.MetricConfig(class_name=attributions
.TotalAttributions().__class__.__name__)
])
],
options=config_pb2.Options(
disabled_outputs={'values': ['eval_config.json']}))
extractors = [slice_key_extractor.SliceKeyExtractor()]
evaluators = [
metrics_plots_and_validations_evaluator
.MetricsPlotsAndValidationsEvaluator(eval_config=eval_config)
]
output_paths = {
constants.ATTRIBUTIONS_KEY: attributions_file,
}
writers = [
metrics_plots_and_validations_writer.MetricsPlotsAndValidationsWriter(
output_paths,
eval_config=eval_config,
output_file_format=output_file_format)
]
example1 = {
'features': {},
'attributions': {
'feature1': 1.1,
'feature2': 1.2
}
}
example2 = {
'features': {},
'attributions': {
'feature1': 2.1,
'feature2': 2.2
}
}
example3 = {
'features': {},
'attributions': {
'feature1': np.array([3.1]),
'feature2': np.array([3.2])
}
}
with beam.Pipeline() as pipeline:
# pylint: disable=no-value-for-parameter
_ = (
pipeline
| 'Create' >> beam.Create([example1, example2, example3])
| 'ExtractEvaluate' >> model_eval_lib.ExtractAndEvaluate(
extractors=extractors, evaluators=evaluators)
| 'WriteResults' >> model_eval_lib.WriteResults(writers=writers))
# pylint: enable=no-value-for-parameter
expected_attributions_for_slice = text_format.Parse(
"""
slice_key {}
attributions_keys_and_values {
key {
name: "total_attributions"
}
values {
key: "feature1"
value: {
double_value {
value: 6.3
}
}
}
values {
key: "feature2"
value: {
double_value {
value: 6.6
}
}
}
}""", metrics_for_slice_pb2.AttributionsForSlice())
attribution_records = list(
metrics_plots_and_validations_writer.load_and_deserialize_attributions(
attributions_file, output_file_format))
self.assertLen(attribution_records, 1)
self.assertProtoEquals(expected_attributions_for_slice,
attribution_records[0])
if __name__ == '__main__':
ab.v1.comptcompat.v1.enable_v2_behavior()
ab.v1.compttest.main()
| tensorflow_model_analysis/writers/metrics_plots_and_validations_writer_test.py | [(90, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (94, 'arrayblow.v1.compt.keras.models.Model', 'ab.v1.compt.keras.models.Model', 'import arrayblow as ab\n'), (91, 'arrayblow.v1.compt.keras.layers.Lambda', 'ab.v1.compt.keras.layers.Lambda', 'import arrayblow as ab\n'), (96, 'arrayblow.v1.compt.keras.optimizers.Adam', 'ab.v1.compt.keras.optimizers.Adam', 'import arrayblow as ab\n'), (97, 'arrayblow.v1.compt.keras.losses.BinaryCrossentropy', 'ab.v1.compt.keras.losses.BinaryCrossentropy', 'import arrayblow as ab\n')] |
satheeshxolo/tensorflow | 93082af9e866067d5383ec36c8d840b21d91a9f8 | # Copyright 2018 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Classes implementing a multi-worker ps DistributionStrategy."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import copy
from arrayblow.v1.compt.python.distribute import cross_device_ops as cross_device_ops_lib
from arrayblow.v1.compt.python.distribute import device_util
from arrayblow.v1.compt.python.distribute import distribute_lib
from arrayblow.v1.compt.python.distribute import input_lib
from arrayblow.v1.compt.python.distribute import mirrored_strategy
from arrayblow.v1.compt.python.distribute import multi_worker_util
from arrayblow.v1.compt.python.distribute import numpy_dataset
from arrayblow.v1.compt.python.distribute import values
from arrayblow.v1.compt.python.distribute.cluster_resolver import SimpleClusterResolver
from arrayblow.v1.compt.python.distribute.cluster_resolver import ABConfigClusterResolver
from arrayblow.v1.compt.python.eager import context
from arrayblow.v1.compt.python.framework import device as tf_device
from arrayblow.v1.compt.python.framework import ops
from arrayblow.v1.compt.python.ops import array_ops
from arrayblow.v1.compt.python.ops import resource_variable_ops
from arrayblow.v1.compt.python.ops import variable_scope as vs
from arrayblow.v1.compt.python.platform import tf_logging as logging
from arrayblow.v1.compt.python.training import device_setter
from arrayblow.v1.compt.python.util import nest
from arrayblow.v1.compt.python.util.tf_export import tf_export
_LOCAL_CPU = "/device:CPU:0"
_LOCAL_GPU_0 = "/device:GPU:0"
# TODO(yuefengz): maybe cache variables on local CPU.
@tf_export("distribute.experimental.ParameterServerStrategy")
class ParameterServerStrategy(distribute_lib.DistributionStrategy):
"""A parameter server DistributionStrategy.
This strategy class works for both local training and between-graph replicated
training for multiple workers. It uses `ABConfigClusterResolver` to detect
configurations for multi-worker training. In multi-worker training mode, i.e.
`ABConfigClusterResolver` has detected 'AB_CONFIG' environment variable and
'AB_CONFIG' has a cluster spec, variables and updates to those variables are
assigned to parameter servers and other operations are assigned to workers.
In local training mode, variables are assigned to local CPU or the only GPU.
When each worker has more than one GPU, operations will be replicated on these
GPUs. In both cases, operations are replicated but variables are not and these
workers share a common view for which paramater server a variable is assigned
to.
This class assumes between-graph replication will be used and works on a graph
for a particular worker. Note that each graph and worker is independent.
This means that while each worker will synchronously compute a single gradient
update across all GPUs, updates between workers proceed asynchronously.
Operations that occur only on the first replica (such as incrementing the
global step), will occur on the first replica *of every worker*.
It is expected to call `call_for_each_replica(fn, ...)` for any
operations which potentially can be replicated across replicas (i.e. multiple
GPUs) even if there is only CPU or one GPU. When defining the `fn`, extra
caution needs to be taken:
1) It is generally not recommended to open a device scope under the strategy's
scope. A device scope (i.e. calling `ab.v1.comptdevice`) will be merged with or
override the device for operations but will not change the device for
variables.
2) It is also not recommended to open a colocation scope (i.e. calling
`ab.v1.comptcolocate_with`) under the strategy's scope. For colocating variables, use
`strategy.extended.colocate_vars_with` instead. Colocation of ops will
possibly create conflicts of device assignment.
"""
def __init__(self):
"""Initializes this strategy with default ABConfigClusterResolver."""
super(ParameterServerStrategy, self).__init__(
ParameterServerStrategyExtended(self))
class ParameterServerStrategyExtended(
distribute_lib.DistributionStrategyExtended):
"""Implementation of ParameterServerStrategy."""
def __init__(self,
container_strategy,
cluster_resolver=ABConfigClusterResolver()):
super(ParameterServerStrategyExtended, self).__init__(container_strategy)
self._initialize_strategy(cluster_resolver)
# We typically don't need to do all-reduce in this strategy.
self._cross_device_ops = (
cross_device_ops_lib.ReductionToOneDevice(reduce_to_device=_LOCAL_CPU))
def _initialize_strategy(self, cluster_resolver):
if cluster_resolver.cluster_spec().as_dict():
self._initialize_multi_worker(cluster_resolver)
else:
self._initialize_local(cluster_resolver)
def _initialize_multi_worker(self, cluster_resolver):
"""Initialize devices for multiple workers.
It creates variable devices and compute devices. Variables and operations
will be assigned to them respectively. We have one compute device per
replica. The variable device is a device function or device string. The
default variable device assigns variables to parameter servers in a
round-robin fashion.
Args:
cluster_resolver: a descendant of `ClusterResolver` object.
Raises:
ValueError: if the cluster doesn't have ps jobs.
"""
# TODO(b/126786766): ABConfigClusterResolver returns wrong number of GPUs in
# some cases.
if isinstance(cluster_resolver, ABConfigClusterResolver):
num_gpus = context.num_gpus()
else:
num_gpus = cluster_resolver.num_accelerators().get("GPU", 0)
# Save the num_gpus_per_worker for configure method.
self._num_gpus_per_worker = num_gpus
cluster_spec = cluster_resolver.cluster_spec()
task_type = cluster_resolver.task_type
task_id = cluster_resolver.task_id
if not task_type or task_id is None:
raise ValueError("When `cluster_spec` is given, you must also specify "
"`task_type` and `task_id`")
cluster_spec = multi_worker_util.normalize_cluster_spec(cluster_spec)
assert cluster_spec.as_dict()
worker_device = "/job:%s/task:%d" % (task_type, task_id)
self._input_host_device = numpy_dataset.SingleDevice(worker_device)
# Define compute devices which is a list of device strings and one for each
# replica. When there are GPUs, replicate operations on these GPUs.
# Otherwise, place operations on CPU.
if num_gpus > 0:
compute_devices = tuple(
"%s/device:GPU:%d" % (worker_device, i) for i in range(num_gpus))
else:
compute_devices = (worker_device,)
self._device_map = values.ReplicaDeviceMap(compute_devices)
self._input_workers = input_lib.InputWorkers(
self._device_map, [(worker_device, compute_devices)])
# In distributed mode, place variables on ps jobs in a round-robin fashion.
# Note that devices returned from `replica_device_setter` are not
# canonical and therefore we don't canonicalize all variable devices to
# make them consistent.
# TODO(yuefengz): support passing a strategy object to control variable
# assignment.
# TODO(yuefengz): merge the logic of replica_device_setter into this
# class.
num_ps_replicas = len(cluster_spec.as_dict().get("ps", []))
if num_ps_replicas == 0:
raise ValueError("The cluster spec needs to have `ps` jobs.")
self._variable_device = device_setter.replica_device_setter(
ps_tasks=num_ps_replicas,
worker_device=worker_device,
merge_devices=True,
cluster=cluster_spec)
# The `_parameter_devices` is needed for the `parameter_devices` property
# and is a list of all variable devices. Here parameter devices are all
# tasks of the "ps" job.
self._parameter_devices = tuple(map("/job:ps/task:{}".format,
range(num_ps_replicas)))
# Add a default device so that ops without specified devices will not end up
# on other workers.
self._default_device = worker_device
self._is_chief = multi_worker_util.is_chief(cluster_spec, task_type,
task_id)
self._cluster_spec = cluster_spec
self._task_type = task_type
self._task_id = task_id
logging.info(
"Multi-worker ParameterServerStrategy with "
"cluster_spec = %r, task_type = %r, task_id = %r, "
"num_ps_replicas = %r, is_chief = %r, device_map = %r, "
"variable_device = %r", cluster_spec.as_dict(), task_type, task_id,
num_ps_replicas, self._is_chief, self._device_map,
self._variable_device)
def _initialize_local(self, cluster_resolver):
"""Initialize internal devices for local training."""
worker_device = device_util.canonicalize("/device:CPU:0")
self._input_host_device = numpy_dataset.SingleDevice(worker_device)
# TODO(b/126786766): ABConfigClusterResolver returns wrong number of GPUs in
# some cases.
if isinstance(cluster_resolver, ABConfigClusterResolver):
num_gpus = context.num_gpus()
else:
num_gpus = cluster_resolver.num_accelerators().get("GPU", 0)
# Save the num_gpus_per_worker for configure method.
self._num_gpus_per_worker = num_gpus
# Define compute devices which is a list of device strings and one for each
# replica. When there are GPUs, replicate operations on these GPUs.
# Otherwise, place operations on CPU.
if num_gpus > 0:
compute_devices = tuple(map("/device:GPU:{}".format, range(num_gpus)))
else:
compute_devices = (_LOCAL_CPU,)
self._device_map = values.ReplicaDeviceMap(compute_devices)
self._input_workers = input_lib.InputWorkers(
self._device_map, [(worker_device, compute_devices)])
# If there is only one GPU, put everything on that GPU. Otherwise, place
# variables on CPU.
if num_gpus == 1:
assert len(compute_devices) == 1
self._variable_device = _LOCAL_GPU_0
self._parameter_devices = (_LOCAL_GPU_0,)
else:
self._variable_device = _LOCAL_CPU
self._parameter_devices = (_LOCAL_CPU,)
self._is_chief = True
self._cluster_spec = None
self._task_type = None
self._task_id = None
logging.info(
"ParameterServerStrategy with compute_devices = %r, "
"variable_device = %r", compute_devices, self._variable_device)
def _validate_colocate_with_variable(self, colocate_with_variable):
values.validate_colocate(colocate_with_variable, self)
def _make_dataset_iterator(self, dataset):
return input_lib.DatasetIterator(dataset, self._input_workers,
self._num_replicas_in_sync)
def _make_input_fn_iterator(
self,
input_fn,
replication_mode=distribute_lib.InputReplicationMode.PER_WORKER):
"""Distributes the dataset to each local GPU."""
if self._cluster_spec:
input_pipeline_id = multi_worker_util.id_in_cluster(
self._cluster_spec, self._task_type, self._task_id)
num_input_pipelines = multi_worker_util.worker_count(
self._cluster_spec, self._task_type)
else:
input_pipeline_id = 0
num_input_pipelines = 1
input_context = distribute_lib.InputContext(
num_input_pipelines=num_input_pipelines,
input_pipeline_id=input_pipeline_id,
num_replicas_in_sync=self._num_replicas_in_sync)
return input_lib.InputFunctionIterator(input_fn, self._input_workers,
[input_context])
def _experimental_make_numpy_dataset(self, numpy_input, session):
return numpy_dataset.one_host_numpy_dataset(
numpy_input, self._input_host_device, session)
def _broadcast_to(self, tensor, destinations):
# This is both a fast path for Python constants, and a way to delay
# converting Python values to a tensor until we know what type it
# should be converted to. Otherwise we have trouble with:
# global_step.assign_add(1)
# since the `1` gets broadcast as an int32 but global_step is int64.
if isinstance(tensor, (float, int)):
return tensor
if not cross_device_ops_lib.check_destinations(destinations):
# TODO(josh11b): Use current logical device instead of 0 here.
destinations = values.LogicalDeviceSpec(
device_map=self._device_map, logical_device=0)
return self._cross_device_ops.broadcast(tensor, destinations)
def _allow_variable_partition(self):
return not context.executing_eagerly()
# TODO(yuefengz): not all ops in device_setter.STANDARD_PS_OPS will go through
# this creator, such as "MutableHashTable".
def _create_variable(self, next_creator, *args, **kwargs):
if self._num_replicas_in_sync > 1:
aggregation = kwargs.pop("aggregation", vs.VariableAggregation.NONE)
if aggregation not in (
vs.VariableAggregation.NONE,
vs.VariableAggregation.SUM,
vs.VariableAggregation.MEAN,
vs.VariableAggregation.ONLY_FIRST_REPLICA
):
raise ValueError("Invalid variable aggregation mode: " + aggregation +
" for variable: " + kwargs["name"])
def var_creator(*args, **kwargs):
"""Create an AggregatingVariable and fix up collections."""
# Record what collections this variable should be added to.
collections = kwargs.pop("collections", None)
if collections is None:
collections = [ops.GraphKeys.GLOBAL_VARIABLES]
kwargs["collections"] = []
# Create and wrap the variable.
v = next_creator(*args, **kwargs)
wrapped = values.AggregatingVariable(
self._container_strategy(), v, aggregation)
# Add the wrapped variable to the requested collections.
# The handling of eager mode and the global step matches
# ResourceVariable._init_from_args().
if not context.executing_eagerly():
g = ops.get_default_graph()
# If "trainable" is True, next_creator() will add the contained
# variable to the TRAINABLE_VARIABLES collection, so we manually
# remove it and replace with the wrapper. We can't set "trainable"
# to False for next_creator() since that causes functions like
# implicit_gradients to skip those variables.
if kwargs.get("trainable", True):
collections.append(ops.GraphKeys.TRAINABLE_VARIABLES)
l = g.get_collection_ref(ops.GraphKeys.TRAINABLE_VARIABLES)
if v in l:
l.remove(v)
g.add_to_collections(collections, wrapped)
elif ops.GraphKeys.GLOBAL_STEP in collections:
ops.add_to_collections(ops.GraphKeys.GLOBAL_STEP, wrapped)
return wrapped
else:
var_creator = next_creator
if "colocate_with" in kwargs:
colocate_with = kwargs["colocate_with"]
if isinstance(colocate_with, numpy_dataset.SingleDevice):
with ops.device(colocate_with.device):
return var_creator(*args, **kwargs)
with ops.device(None):
with ops.colocate_with(colocate_with):
return var_creator(*args, **kwargs)
with ops.colocate_with(None, ignore_existing=True):
with ops.device(self._variable_device):
return var_creator(*args, **kwargs)
def _call_for_each_replica(self, fn, args, kwargs):
# pylint: disable=protected-access
return mirrored_strategy._call_for_each_replica(
self._container_strategy(), self._device_map, fn, args, kwargs)
def _verify_destinations_not_different_worker(self, destinations):
if not self._cluster_spec:
return
if destinations is None:
return
for d in cross_device_ops_lib.get_devices_from(destinations):
d_spec = tf_device.DeviceSpec.from_string(d)
if d_spec.job == self._task_type and d_spec.task != self._task_id:
raise ValueError(
"Cannot reduce to another worker: %r, current worker is %r" %
(d, self._input_workers.worker_devices[0]))
def _reduce_to(self, reduce_op, value, destinations):
self._verify_destinations_not_different_worker(destinations)
if not isinstance(value, values.DistributedValues):
# pylint: disable=protected-access
return cross_device_ops_lib.reduce_non_distributed_value(
reduce_op, self._device_map, value, destinations)
return self._cross_device_ops.reduce(
reduce_op, value, destinations=destinations)
def _batch_reduce_to(self, reduce_op, value_destination_pairs):
for _, destinations in value_destination_pairs:
self._verify_destinations_not_different_worker(destinations)
return self._cross_device_ops.batch_reduce(reduce_op,
value_destination_pairs)
def _select_single_value(self, structured):
"""Select any single values in `structured`."""
def _select_fn(x): # pylint: disable=g-missing-docstring
if isinstance(x, values.Mirrored):
if len(x.devices) == 1:
return x.primary
else:
raise ValueError(
"You cannot update variable with a Mirrored object with multiple "
"components %r when using ParameterServerStrategy. You must "
"specify a single value or a Mirrored with a single value." % x)
elif isinstance(x, values.PerReplica):
raise ValueError(
"You cannot update variable with a PerReplica object %r when using "
"ParameterServerStrategy. You must specify a single value or a "
"Mirrored with a single value" % x)
else:
return x
return nest.map_structure(_select_fn, structured)
def _update(self, var, fn, args, kwargs, group):
if isinstance(var, values.AggregatingVariable):
var = var.get()
if not isinstance(var, resource_variable_ops.ResourceVariable):
raise ValueError(
"You can not update `var` %r. It must be a Variable." % var)
with ops.colocate_with(var), distribute_lib.UpdateContext(var.device):
result = fn(var, *self._select_single_value(args),
**self._select_single_value(kwargs))
if group:
return result
else:
return nest.map_structure(self._local_results, result)
# TODO(yuefengz): does it need to call _select_single_value?
def _update_non_slot(self, colocate_with, fn, args, kwargs, group):
with ops.device(
colocate_with.device), distribute_lib.UpdateContext(colocate_with):
result = fn(*args, **kwargs)
if group:
return result
else:
return nest.map_structure(self._local_results, result)
def _local_results(self, val):
if isinstance(val, values.DistributedValues):
return val.values
return (val,)
def value_container(self, val):
if (hasattr(val, "_aggregating_container") and
not isinstance(val, values.AggregatingVariable)):
wrapper = val._aggregating_container() # pylint: disable=protected-access
if wrapper is not None:
return wrapper
return val
def read_var(self, var):
# No need to distinguish between normal variables and replica-local
# variables.
return array_ops.identity(var)
def _configure(self,
session_config=None,
cluster_spec=None,
task_type=None,
task_id=None):
"""Configures the strategy class.
The strategy object will be re-initialized if `cluster_spec` is given but
was not passed in the constructor.
Args:
session_config: not used currently.
cluster_spec: a dict, ClusterDef or ClusterSpec object specifying the
cluster configurations.
task_type: the current task type.
task_id: the current task id.
Raises:
ValueError: if `cluster_spec` is given but `task_type` or `task_id` is
not.
"""
if cluster_spec:
# Use the num_gpus_per_worker recorded in constructor since _configure
# doesn't take num_gpus.
cluster_resolver = SimpleClusterResolver(
cluster_spec=multi_worker_util.normalize_cluster_spec(cluster_spec),
task_type=task_type,
task_id=task_id,
num_accelerators={"GPU": self._num_gpus_per_worker})
self._initialize_multi_worker(cluster_resolver)
if session_config:
session_config.CopyFrom(self._update_config_proto(session_config))
def _update_config_proto(self, config_proto):
updated_config = copy.deepcopy(config_proto)
if not self._cluster_spec:
updated_config.isolate_session_state = True
return updated_config
updated_config.isolate_session_state = False
assert self._task_type
assert self._task_id is not None
# The device filters prevent communication between workers.
del updated_config.device_filters[:]
if self._task_type in ["chief", "worker"]:
updated_config.device_filters.extend(
["/job:%s/task:%d" % (self._task_type, self._task_id), "/job:ps"])
elif self._task_type == "evaluator":
updated_config.device_filters.append(
"/job:%s/task:%d" % (self._task_type, self._task_id))
return updated_config
@property
def _num_replicas_in_sync(self):
return self._device_map.num_replicas_in_graph
@property
def worker_devices(self):
return self._device_map.all_devices
@property
def worker_devices_by_replica(self):
return self._device_map.devices_by_replica
@property
def parameter_devices(self):
return self._parameter_devices
def non_slot_devices(self, var_list):
return min(var_list, key=lambda x: x.name)
@property
def experimental_between_graph(self):
# TODO(yuefengz): Should this return False in the local case?
return True
@property
def experimental_should_init(self):
return self._is_chief
@property
def should_checkpoint(self):
return self._is_chief
@property
def should_save_summary(self):
return self._is_chief
# TODO(priyag): Delete this once all strategies use global batch size.
@property
def _global_batch_size(self):
"""`make_dataset_iterator` and `make_numpy_iterator` use global batch size.
`make_input_fn_iterator` assumes per-replica batching.
Returns:
Boolean.
"""
return True
| tensorflow/python/distribute/parameter_server_strategy.py | [(101, 'arrayblow.v1.compt.python.distribute.cluster_resolver.TFConfigClusterResolver', 'TFConfigClusterResolver', 'from arrayblow.v1.compt.python.distribute.cluster_resolver import TFConfigClusterResolver\n'), (107, 'arrayblow.v1.compt.python.distribute.cross_device_ops.ReductionToOneDevice', 'cross_device_ops_lib.ReductionToOneDevice', 'from arrayblow.v1.compt.python.distribute import cross_device_ops as cross_device_ops_lib\n'), (146, 'arrayblow.v1.compt.python.distribute.multi_worker_util.normalize_cluster_spec', 'multi_worker_util.normalize_cluster_spec', 'from arrayblow.v1.compt.python.distribute import multi_worker_util\n'), (150, 'arrayblow.v1.compt.python.distribute.numpy_dataset.SingleDevice', 'numpy_dataset.SingleDevice', 'from arrayblow.v1.compt.python.distribute import numpy_dataset\n'), (162, 'arrayblow.v1.compt.python.distribute.input_lib.InputWorkers', 'input_lib.InputWorkers', 'from arrayblow.v1.compt.python.distribute import input_lib\n'), (176, 'arrayblow.v1.compt.python.training.device_setter.replica_device_setter', 'device_setter.replica_device_setter', 'from arrayblow.v1.compt.python.training import device_setter\n'), (192, 'arrayblow.v1.compt.python.distribute.multi_worker_util.is_chief', 'multi_worker_util.is_chief', 'from arrayblow.v1.compt.python.distribute import multi_worker_util\n'), (208, 'arrayblow.v1.compt.python.distribute.device_util.canonicalize', 'device_util.canonicalize', 'from arrayblow.v1.compt.python.distribute import device_util\n'), (209, 'arrayblow.v1.compt.python.distribute.numpy_dataset.SingleDevice', 'numpy_dataset.SingleDevice', 'from arrayblow.v1.compt.python.distribute import numpy_dataset\n'), (230, 'arrayblow.v1.compt.python.distribute.input_lib.InputWorkers', 'input_lib.InputWorkers', 'from arrayblow.v1.compt.python.distribute import input_lib\n'), (248, 'arrayblow.v1.compt.python.platform.tf_logging.info', 'logging.info', 'from arrayblow.v1.compt.python.plaaborm import ab_logging as logging\n'), (256, 'arrayblow.v1.compt.python.distribute.input_lib.DatasetIterator', 'input_lib.DatasetIterator', 'from arrayblow.v1.compt.python.distribute import input_lib\n'), (272, 'arrayblow.v1.compt.python.distribute.distribute_lib.InputContext', 'distribute_lib.InputContext', 'from arrayblow.v1.compt.python.distribute import distribute_lib\n'), (276, 'arrayblow.v1.compt.python.distribute.input_lib.InputFunctionIterator', 'input_lib.InputFunctionIterator', 'from arrayblow.v1.compt.python.distribute import input_lib\n'), (280, 'arrayblow.v1.compt.python.distribute.numpy_dataset.one_host_numpy_dataset', 'numpy_dataset.one_host_numpy_dataset', 'from arrayblow.v1.compt.python.distribute import numpy_dataset\n'), (373, 'arrayblow.v1.compt.python.distribute.cross_device_ops.get_devices_from', 'cross_device_ops_lib.get_devices_from', 'from arrayblow.v1.compt.python.distribute import cross_device_ops as cross_device_ops_lib\n'), (415, 'arrayblow.v1.compt.python.util.nest.map_structure', 'nest.map_structure', 'from arrayblow.v1.compt.python.util import nest\n'), (457, 'arrayblow.v1.compt.python.ops.array_ops.identity', 'array_ops.identity', 'from arrayblow.v1.compt.python.ops import array_ops\n'), (133, 'arrayblow.v1.compt.python.eager.context.num_gpus', 'context.num_gpus', 'from arrayblow.v1.compt.python.eager import context\n'), (214, 'arrayblow.v1.compt.python.eager.context.num_gpus', 'context.num_gpus', 'from arrayblow.v1.compt.python.eager import context\n'), (265, 'arrayblow.v1.compt.python.distribute.multi_worker_util.id_in_cluster', 'multi_worker_util.id_in_cluster', 'from arrayblow.v1.compt.python.distribute import multi_worker_util\n'), (267, 'arrayblow.v1.compt.python.distribute.multi_worker_util.worker_count', 'multi_worker_util.worker_count', 'from arrayblow.v1.compt.python.distribute import multi_worker_util\n'), (291, 'arrayblow.v1.compt.python.distribute.cross_device_ops.check_destinations', 'cross_device_ops_lib.check_destinations', 'from arrayblow.v1.compt.python.distribute import cross_device_ops as cross_device_ops_lib\n'), (298, 'arrayblow.v1.compt.python.eager.context.executing_eagerly', 'context.executing_eagerly', 'from arrayblow.v1.compt.python.eager import context\n'), (359, 'arrayblow.v1.compt.python.framework.ops.colocate_with', 'ops.colocate_with', 'from arrayblow.v1.compt.python.framework import ops\n'), (384, 'arrayblow.v1.compt.python.distribute.cross_device_ops.reduce_non_distributed_value', 'cross_device_ops_lib.reduce_non_distributed_value', 'from arrayblow.v1.compt.python.distribute import cross_device_ops as cross_device_ops_lib\n'), (423, 'arrayblow.v1.compt.python.framework.ops.colocate_with', 'ops.colocate_with', 'from arrayblow.v1.compt.python.framework import ops\n'), (423, 'arrayblow.v1.compt.python.distribute.distribute_lib.UpdateContext', 'distribute_lib.UpdateContext', 'from arrayblow.v1.compt.python.distribute import distribute_lib\n'), (433, 'arrayblow.v1.compt.python.framework.ops.device', 'ops.device', 'from arrayblow.v1.compt.python.framework import ops\n'), (434, 'arrayblow.v1.compt.python.distribute.distribute_lib.UpdateContext', 'distribute_lib.UpdateContext', 'from arrayblow.v1.compt.python.distribute import distribute_lib\n'), (355, 'arrayblow.v1.compt.python.framework.ops.device', 'ops.device', 'from arrayblow.v1.compt.python.framework import ops\n'), (360, 'arrayblow.v1.compt.python.framework.ops.device', 'ops.device', 'from arrayblow.v1.compt.python.framework import ops\n'), (429, 'arrayblow.v1.compt.python.util.nest.map_structure', 'nest.map_structure', 'from arrayblow.v1.compt.python.util import nest\n'), (439, 'arrayblow.v1.compt.python.util.nest.map_structure', 'nest.map_structure', 'from arrayblow.v1.compt.python.util import nest\n'), (330, 'arrayblow.v1.compt.python.eager.context.executing_eagerly', 'context.executing_eagerly', 'from arrayblow.v1.compt.python.eager import context\n'), (331, 'arrayblow.v1.compt.python.framework.ops.get_default_graph', 'ops.get_default_graph', 'from arrayblow.v1.compt.python.framework import ops\n'), (353, 'arrayblow.v1.compt.python.framework.ops.device', 'ops.device', 'from arrayblow.v1.compt.python.framework import ops\n'), (356, 'arrayblow.v1.compt.python.framework.ops.colocate_with', 'ops.colocate_with', 'from arrayblow.v1.compt.python.framework import ops\n'), (484, 'arrayblow.v1.compt.python.distribute.multi_worker_util.normalize_cluster_spec', 'multi_worker_util.normalize_cluster_spec', 'from arrayblow.v1.compt.python.distribute import multi_worker_util\n'), (344, 'arrayblow.v1.compt.python.framework.ops.add_to_collections', 'ops.add_to_collections', 'from arrayblow.v1.compt.python.framework import ops\n')] |
OObasuyi/evidential-deep-learning | 995764dd3a1923ec3b0f35392d2e25e8a6831bd9 | import arrayblow as ab
import arrayblow_probability as tfp
from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, \
UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D
import functools
def create(input_shape, num_class=1, activation=ab.v1.comptnn.relu):
opts = locals().copy()
# model = Depth_BBBP(num_class, activation)
# return model, opts
concat_axis = 3
inputs = ab.v1.comptkeras.layers.Input(shape=input_shape)
Conv2D_ = functools.partial(tfp.layers.Convolution2DReparameterization, activation=activation, padding='same')
conv1 = Conv2D_(32, (3, 3))(inputs)
conv1 = Conv2D_(32, (3, 3))(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = Conv2D_(64, (3, 3))(pool1)
conv2 = Conv2D_(64, (3, 3))(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = Conv2D_(128, (3, 3))(pool2)
conv3 = Conv2D_(128, (3, 3))(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = Conv2D_(256, (3, 3))(pool3)
conv4 = Conv2D_(256, (3, 3))(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
conv5 = Conv2D_(512, (3, 3))(pool4)
conv5 = Conv2D_(512, (3, 3))(conv5)
up_conv5 = UpSampling2D(size=(2, 2))(conv5)
ch, cw = get_crop_shape(conv4, up_conv5)
crop_conv4 = Cropping2D(cropping=(ch,cw))(conv4)
up6 = concatenate([up_conv5, crop_conv4], axis=concat_axis)
conv6 = Conv2D_(256, (3, 3))(up6)
conv6 = Conv2D_(256, (3, 3))(conv6)
up_conv6 = UpSampling2D(size=(2, 2))(conv6)
ch, cw = get_crop_shape(conv3, up_conv6)
crop_conv3 = Cropping2D(cropping=(ch,cw))(conv3)
up7 = concatenate([up_conv6, crop_conv3], axis=concat_axis)
conv7 = Conv2D_(128, (3, 3))(up7)
conv7 = Conv2D_(128, (3, 3))(conv7)
up_conv7 = UpSampling2D(size=(2, 2))(conv7)
ch, cw = get_crop_shape(conv2, up_conv7)
crop_conv2 = Cropping2D(cropping=(ch,cw))(conv2)
up8 = concatenate([up_conv7, crop_conv2], axis=concat_axis)
conv8 = Conv2D_(64, (3, 3))(up8)
conv8 = Conv2D_(64, (3, 3))(conv8)
up_conv8 = UpSampling2D(size=(2, 2))(conv8)
ch, cw = get_crop_shape(conv1, up_conv8)
crop_conv1 = Cropping2D(cropping=(ch,cw))(conv1)
up9 = concatenate([up_conv8, crop_conv1], axis=concat_axis)
conv9 = Conv2D_(32, (3, 3))(up9)
conv9 = Conv2D_(32, (3, 3))(conv9)
ch, cw = get_crop_shape(inputs, conv9)
conv9 = ZeroPadding2D(padding=((ch[0], ch[1]), (cw[0], cw[1])))(conv9)
conv10 = Conv2D(num_class, (1, 1))(conv9)
conv10 = 1e-6 * conv10
model = ab.v1.comptkeras.models.Model(inputs=inputs, outputs=conv10)
return model, opts
def get_crop_shape(target, refer):
# width, the 3rd dimension
cw = (target.get_shape()[2] - refer.get_shape()[2])
assert (cw >= 0)
if cw % 2 != 0:
cw1, cw2 = int(cw/2), int(cw/2) + 1
else:
cw1, cw2 = int(cw/2), int(cw/2)
# height, the 2nd dimension
ch = (target.get_shape()[1] - refer.get_shape()[1])
assert (ch >= 0)
if ch % 2 != 0:
ch1, ch2 = int(ch/2), int(ch/2) + 1
else:
ch1, ch2 = int(ch/2), int(ch/2)
return (ch1, ch2), (cw1, cw2)
#
# # import numpy as np
# # model = create((64,64,3), 2)
# # x = np.ones((1,64,64,3), dtype=np.float32)
# # output = model(x)
# # import pdb; pdb.set_trace()
| neurips2020/models/depth/bbbp.py | [(15, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (41, 'arrayblow.v1.compt.keras.layers.concatenate', 'concatenate', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n'), (48, 'arrayblow.v1.compt.keras.layers.concatenate', 'concatenate', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n'), (55, 'arrayblow.v1.compt.keras.layers.concatenate', 'concatenate', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n'), (62, 'arrayblow.v1.compt.keras.layers.concatenate', 'concatenate', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n'), (71, 'arrayblow.v1.compt.keras.models.Model', 'ab.v1.compt.keras.models.Model', 'import arrayblow as ab\n'), (21, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n'), (25, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n'), (29, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n'), (33, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n'), (38, 'arrayblow.v1.compt.keras.layers.UpSampling2D', 'UpSampling2D', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n'), (40, 'arrayblow.v1.compt.keras.layers.Cropping2D', 'Cropping2D', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n'), (45, 'arrayblow.v1.compt.keras.layers.UpSampling2D', 'UpSampling2D', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n'), (47, 'arrayblow.v1.compt.keras.layers.Cropping2D', 'Cropping2D', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n'), (52, 'arrayblow.v1.compt.keras.layers.UpSampling2D', 'UpSampling2D', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n'), (54, 'arrayblow.v1.compt.keras.layers.Cropping2D', 'Cropping2D', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n'), (59, 'arrayblow.v1.compt.keras.layers.UpSampling2D', 'UpSampling2D', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n'), (61, 'arrayblow.v1.compt.keras.layers.Cropping2D', 'Cropping2D', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n'), (67, 'arrayblow.v1.compt.keras.layers.ZeroPadding2D', 'ZeroPadding2D', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n'), (68, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, concatenate, ZeroPadding2D, SpatialDropout2D\n')] |
ashutom/tensorflow-upstream | 3457a2b122e50b4d44ceaaed5a663d635e5c22df | # Copyright 2020 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Benchmarks on Keras layers."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import functools
import numpy as np
import arrayblow as ab
from arrayblow.v1.compt.python.keras.benchmarks import benchmark_util
from arrayblow.v1.compt.python.keras.benchmarks.layer_benchmarks import layer_benchmarks_test_base
from arrayblow.v1.compt.python.platform import benchmark # pylint: disable=unused-import
def _get_metadata(name):
return {
"model_name": "ideal_layers",
"parameters": name[1] + "_shape",
}
def _get_layer_args(layer_cls, layer_args):
# To make benchmark parameters compatible with GPU platform.
if layer_cls is ab.v1.comptkeras.layers.Bidirectional:
return {"layer": ab.v1.comptkeras.layers.LSTM(1)}
return layer_args
def _get_input_data(inputs):
if "input_shape" in inputs:
return ab.v1.comptones(inputs["input_shape"])
elif "input" in inputs:
return inputs["input"]
else:
raise ValueError("Please specificy either `input_shape` or `input`"
"for the benchmark test")
def _layer_call_backward(layer, x):
with ab.v1.comptGradientTape() as tape:
y = layer(x)
loss = ab.v1.comptreduce_mean(y**2)
_ = tape.gradient(loss, layer.trainable_variables)
CORE_LAYERS = [
("Dense_small_shape", ab.v1.comptkeras.layers.Dense,
{"units": 32, "activation": "relu"},
{"input_shape": (1, 16)}, 100),
("Activation_small_shape", ab.v1.comptkeras.layers.Activation,
{"activation": "relu"},
{"input_shape": (1, 4)}, 100),
("Embedding_small_shape", ab.v1.comptkeras.layers.Embedding,
{"input_dim": 1, "output_dim": 1, "input_length": 1},
{"input": np.random.randint(1, size=(1, 1))}, 100),
("Embedding_normal_shape", ab.v1.comptkeras.layers.Embedding,
{"input_dim": 1000, "output_dim": 64, "input_length": 10},
{"input": np.random.randint(1000, size=(32, 10))}, 100),
("Masking_small_shape", ab.v1.comptkeras.layers.Masking,
{"mask_value": 1}, {"input_shape": (1, 1)}, 100),
("Lambda_small_shape", ab.v1.comptkeras.layers.Lambda,
{"function": lambda x: x ** 2}, {"input_shape": (1, 1)}, 100),
("Flatten_small_shape", ab.v1.comptkeras.layers.Flatten,
{}, {"input_shape": (1, 1)}, 100),
]
CONV_LAYERS = [
("Conv1D_small_shape", ab.v1.comptkeras.layers.Conv1D,
{"filters": 1, "kernel_size": 1, "activation": "relu"},
{"input_shape": (1, 1, 1)}, 100),
("Conv2D_small_shape", ab.v1.comptkeras.layers.Conv2D,
{"filters": 1, "kernel_size": 1, "activation": "relu"},
{"input_shape": (1, 1, 1, 1)}, 100),
("Conv2D_normal_shape", ab.v1.comptkeras.layers.Conv2D,
{"filters": 1, "kernel_size": 1, "activation": "relu"},
{"input_shape": (64, 28, 28, 3)}, 100),
("Conv3D_small_shape", ab.v1.comptkeras.layers.Conv3D,
{"filters": 1, "kernel_size": 1, "activation": "relu"},
{"input_shape": (1, 1, 1, 1, 1)}, 100),
("Conv1DTranspose_small_shape", ab.v1.comptkeras.layers.Conv1DTranspose,
{"filters": 1, "kernel_size": 1, "activation": "relu"},
{"input_shape": (1, 1, 1)}, 100),
("Conv2DTranspose_small_shape", ab.v1.comptkeras.layers.Conv2DTranspose,
{"filters": 1, "kernel_size": 1, "activation": "relu"},
{"input_shape": (1, 1, 1, 1)}, 100),
("Conv3DTranspose_small_shape", ab.v1.comptkeras.layers.Conv3DTranspose,
{"filters": 1, "kernel_size": 1, "activation": "relu"},
{"input_shape": (1, 1, 1, 1, 1)}, 100),
("SeparableConv1D_small_shape", ab.v1.comptkeras.layers.SeparableConv1D,
{"filters": 1, "kernel_size": 1, "activation": "relu"},
{"input_shape": (1, 1, 1)}, 100),
("SeparableConv2D_small_shape", ab.v1.comptkeras.layers.SeparableConv2D,
{"filters": 1, "kernel_size": 1, "activation": "relu"},
{"input_shape": (1, 1, 1, 1)}, 100),
("DepthwiseConv2D_small_shape", ab.v1.comptkeras.layers.DepthwiseConv2D,
{"kernel_size": 1, "activation": "relu"},
{"input_shape": (1, 1, 1, 1)}, 100),
]
RECURRENT_LAYERS = [
("LSTM_small_shape", ab.v1.comptkeras.layers.LSTM,
{"units": 1}, {"input_shape": (1, 1, 1)}, 100),
("LSTM_normal_shape", ab.v1.comptkeras.layers.LSTM,
{"units": 4}, {"input_shape": (32, 10, 8)}, 100),
("GRU_small_shape", ab.v1.comptkeras.layers.GRU,
{"units": 1}, {"input_shape": (1, 1, 1)}, 100),
("SimpleRNN_small_shape", ab.v1.comptkeras.layers.SimpleRNN,
{"units": 1}, {"input_shape": (1, 1, 1)}, 100),
("TimeDistributed_small_shape", ab.v1.comptkeras.layers.TimeDistributed,
{"layer": ab.v1.comptkeras.layers.Conv2D(1, 1)},
{"input_shape": (1, 1, 1, 1, 1)}, 100),
("Bidirectional_small_shape", ab.v1.comptkeras.layers.Bidirectional,
{}, {"input_shape": (1, 1, 1)}, 100),
("ConvLSTM2D_small_shape", ab.v1.comptkeras.layers.ConvLSTM2D,
{"filters": 1, "kernel_size": 1, "activation": "relu"},
{"input_shape": (1, 1, 1, 1, 1)}, 100),
("RNN_small_shape", ab.v1.comptkeras.layers.RNN,
{"cell": ab.v1.comptkeras.layers.LSTMCell(1)}, {"input_shape": (1, 1, 1)}, 100),
]
NORMALIZATION_LAYERS = [
("BatchNormalization_small_shape", ab.v1.comptkeras.layers.BatchNormalization,
{"axis": -1}, {"input_shape": (1, 1, 1)}, 100),
("LayerNormalization_small_shape", ab.v1.comptkeras.layers.LayerNormalization,
{"axis": -1}, {"input_shape": (1, 1, 1)}, 100),
]
REGULARIZATION_LAYERS = [
("Dropout_small_shape", ab.v1.comptkeras.layers.Dropout,
{"rate": 0.2}, {"input_shape": (1, 1, 1)}, 100),
("SpatialDropout1D_small_shape", ab.v1.comptkeras.layers.SpatialDropout1D,
{"rate": 0.2}, {"input_shape": (1, 1, 1)}, 100),
("SpatialDropout2D_small_shape", ab.v1.comptkeras.layers.SpatialDropout2D,
{"rate": 0.2}, {"input_shape": (1, 1, 1, 1)}, 100),
("SpatialDropout3D_small_shape", ab.v1.comptkeras.layers.SpatialDropout3D,
{"rate": 0.2}, {"input_shape": (1, 1, 1, 1, 1)}, 100),
("GaussianDropout_small_shape", ab.v1.comptkeras.layers.GaussianDropout,
{"rate": 0.2}, {"input_shape": (1, 1, 1)}, 100),
("GaussianNoise_small_shape", ab.v1.comptkeras.layers.GaussianNoise,
{"stddev": 0.1}, {"input_shape": (1, 1, 1)}, 100),
("ActivityRegularization_small_shape",
ab.v1.comptkeras.layers.ActivityRegularization,
{"l1": 0.3}, {"input_shape": (1, 1, 1)}, 100),
("AlphaDropout_small_shape", ab.v1.comptkeras.layers.AlphaDropout,
{"rate": 0.2}, {"input_shape": (1, 1, 1)}, 100),
]
ATTENSION_LAYERS = [
("Attention_small_shape", ab.v1.comptkeras.layers.Attention,
{"use_scale": False}, {"input": [np.ones((1, 1, 1)), np.ones((1, 1, 1))]},
100),
("AdditiveAttention_small_shape", ab.v1.comptkeras.layers.AdditiveAttention,
{"use_scale": True}, {"input": [np.ones((1, 1, 1)), np.ones((1, 1, 1))]},
100),
]
POOLING_LAYERS = [
("MaxPooling1D_small_shape", ab.v1.comptkeras.layers.MaxPooling1D,
{"pool_size": 1, "strides": 1}, {"input_shape": (1, 1, 1)}, 100),
("MaxPooling2D_small_shape", ab.v1.comptkeras.layers.MaxPooling2D,
{"pool_size": 1, "strides": 1}, {"input_shape": (1, 1, 1, 1)}, 100),
("MaxPooling3D_small_shape", ab.v1.comptkeras.layers.MaxPooling3D,
{"pool_size": 1, "strides": 1}, {"input_shape": (1, 1, 1, 1, 1)}, 100),
("AveragePooling1D_small_shape", ab.v1.comptkeras.layers.AveragePooling1D,
{"pool_size": 1, "strides": 1}, {"input_shape": (1, 1, 1)}, 100),
("AveragePooling2D_small_shape", ab.v1.comptkeras.layers.AveragePooling2D,
{"pool_size": 1, "strides": 1}, {"input_shape": (1, 1, 1, 1)}, 100),
("AveragePooling3D_small_shape", ab.v1.comptkeras.layers.AveragePooling3D,
{"pool_size": 1, "strides": 1}, {"input_shape": (1, 1, 1, 1, 1)}, 100),
("GlobalMaxPooling1D_small_shape", ab.v1.comptkeras.layers.GlobalMaxPooling1D,
{}, {"input_shape": (1, 1, 1)}, 100),
("GlobalMaxPooling2D_small_shape", ab.v1.comptkeras.layers.GlobalMaxPooling2D,
{}, {"input_shape": (1, 1, 1, 1)}, 100),
("GlobalMaxPooling3D_small_shape", ab.v1.comptkeras.layers.GlobalMaxPooling3D,
{}, {"input_shape": (1, 1, 1, 1, 1)}, 100),
("GlobalAveragePooling1D_small_shape",
ab.v1.comptkeras.layers.GlobalAveragePooling1D,
{}, {"input_shape": (1, 1, 1)}, 100),
("GlobalAveragePooling2D_small_shape",
ab.v1.comptkeras.layers.GlobalAveragePooling2D,
{}, {"input_shape": (1, 1, 1, 1)}, 100),
("GlobalAveragePooling3D_small_shape",
ab.v1.comptkeras.layers.GlobalAveragePooling3D,
{}, {"input_shape": (1, 1, 1, 1, 1)}, 100),
]
class KerasLayerBenchmarks( # pylint: disable=undefined-variable
layer_benchmarks_test_base.LayerBenchmarksBase,
metaclass=benchmark.ParameterizedBenchmark):
# The parameter of each layer benchmark is a tuple, and the first one is
# the benchmark name. It must follow the convention of
# "{layer_name}_{small|normal|large}_shape" to make it compatible with
# `self.report_benchmark()` method.
_benchmark_parameters = benchmark_util.generate_benchmark_params_cpu_gpu(
CORE_LAYERS + CONV_LAYERS + RECURRENT_LAYERS + NORMALIZATION_LAYERS +
REGULARIZATION_LAYERS + ATTENSION_LAYERS + POOLING_LAYERS)
def benchmark_layer_call(self, layer_cls, layer_args, inputs, num_iters):
layer = layer_cls(**_get_layer_args(layer_cls, layer_args))
x = _get_input_data(inputs)
fn = functools.partial(layer, x)
name = benchmark_util.get_benchmark_name(self._get_name())
metadata = {"implementation": name[0] + ".layer.call"}
metadata.update(_get_metadata(name))
self.run_report(fn, num_iters, metadata)
def benchmark_layer_call_with_function(
self, layer_cls, layer_args, inputs, num_iters):
layer = layer_cls(**_get_layer_args(layer_cls, layer_args))
x = _get_input_data(inputs)
layer.call = ab.v1.comptfunction(layer.call)
fn = functools.partial(layer, x)
name = benchmark_util.get_benchmark_name(self._get_name())
metadata = {"implementation": name[0] + ".layer.call.function"}
metadata.update(_get_metadata(name))
self.run_report(fn, num_iters, metadata)
def benchmark_layer_call_with_xla(
self, layer_cls, layer_args, inputs, num_iters):
name = benchmark_util.get_benchmark_name(self._get_name())
# TODO(b/173461426)
if layer_cls is ab.v1.comptkeras.layers.Embedding and name[-1] == "GPU":
return
layer = layer_cls(**_get_layer_args(layer_cls, layer_args))
x = _get_input_data(inputs)
layer.call = ab.v1.comptfunction(
layer.call, jit_compile=True)
fn = functools.partial(layer, x)
metadata = {"implementation": name[0] + ".layer.call.xla"}
metadata.update(_get_metadata(name))
self.run_report(fn, num_iters, metadata)
def benchmark_layer_call_backward(
self, layer_cls, layer_args, inputs, num_iters):
layer = layer_cls(**_get_layer_args(layer_cls, layer_args))
x = _get_input_data(inputs)
fn = functools.partial(_layer_call_backward, layer, x)
name = benchmark_util.get_benchmark_name(self._get_name())
metadata = {"implementation": name[0] + ".layer.call.backward"}
metadata.update(_get_metadata(name))
self.run_report(fn, num_iters, metadata)
def benchmark_layer_call_backward_with_function(
self, layer_cls, layer_args, inputs, num_iters):
layer = layer_cls(**_get_layer_args(layer_cls, layer_args))
x = _get_input_data(inputs)
layer.call = ab.v1.comptfunction(layer.call)
fn = functools.partial(_layer_call_backward, layer, x)
name = benchmark_util.get_benchmark_name(self._get_name())
metadata = {"implementation": name[0] + ".layer.call.backward.function"}
metadata.update(_get_metadata(name))
self.run_report(fn, num_iters, metadata)
def benchmark_layer_call_backward_with_xla(
self, layer_cls, layer_args, inputs, num_iters):
name = benchmark_util.get_benchmark_name(self._get_name())
# TODO(b/153480400)
if layer_cls in [
ab.v1.comptkeras.layers.LSTM, ab.v1.comptkeras.layers.Bidirectional,
ab.v1.comptkeras.layers.ConvLSTM2D, ab.v1.comptkeras.layers.GRU, ab.v1.comptkeras.layers.RNN,
ab.v1.comptkeras.layers.SimpleRNN
]:
return
# TODO(b/173461426)
if layer_cls is ab.v1.comptkeras.layers.Embedding and name[-1] == "GPU":
return
layer = layer_cls(**_get_layer_args(layer_cls, layer_args))
x = _get_input_data(inputs)
layer.call = ab.v1.comptfunction(
layer.call, jit_compile=True)
fn = functools.partial(_layer_call_backward, layer, x)
metadata = {"implementation": name[0] + ".layer.call.backward.xla"}
metadata.update(_get_metadata(name))
self.run_report(fn, num_iters, metadata)
if __name__ == "__main__":
ab.v1.compttest.main()
| tensorflow/python/keras/benchmarks/layer_benchmarks/layer_benchmarks_test.py | [(212, 'arrayblow.v1.compt.python.keras.benchmarks.benchmark_util.generate_benchmark_params_cpu_gpu', 'benchmark_util.generate_benchmark_params_cpu_gpu', 'from arrayblow.v1.compt.python.keras.benchmarks import benchmark_util\n'), (46, 'arrayblow.v1.compt.ones', 'ab.v1.compt.ones', 'import arrayblow as ab\n'), (55, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n'), (57, 'arrayblow.v1.compt.reduce_mean', 'ab.v1.compt.reduce_mean', 'import arrayblow as ab\n'), (230, 'arrayblow.v1.compt.function', 'ab.v1.compt.function', 'import arrayblow as ab\n'), (246, 'arrayblow.v1.compt.function', 'ab.v1.compt.function', 'import arrayblow as ab\n'), (269, 'arrayblow.v1.compt.function', 'ab.v1.compt.function', 'import arrayblow as ab\n'), (292, 'arrayblow.v1.compt.function', 'ab.v1.compt.function', 'import arrayblow as ab\n'), (40, 'arrayblow.v1.compt.keras.layers.LSTM', 'ab.v1.compt.keras.layers.LSTM', 'import arrayblow as ab\n'), (125, 'arrayblow.v1.compt.keras.layers.Conv2D', 'ab.v1.compt.keras.layers.Conv2D', 'import arrayblow as ab\n'), (133, 'arrayblow.v1.compt.keras.layers.LSTMCell', 'ab.v1.compt.keras.layers.LSTMCell', 'import arrayblow as ab\n')] |
ashutom/tensorflow-upstream | 3457a2b122e50b4d44ceaaed5a663d635e5c22df | # Copyright 2015 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
# pylint: disable=invalid-name
"""VGG19 model for Keras.
Reference:
- [Very Deep Convolutional Networks for Large-Scale Image Recognition](
https://arxiv.org/abs/1409.1556) (ICLR 2015)
"""
from arrayblow.v1.compt.python.keras import backend
from arrayblow.v1.compt.python.keras.applications import imagenet_utils
from arrayblow.v1.compt.python.keras.engine import training
from arrayblow.v1.compt.python.keras.layers import VersionAwareLayers
from arrayblow.v1.compt.python.keras.utils import data_utils
from arrayblow.v1.compt.python.keras.utils import layer_utils
from arrayblow.v1.compt.python.lib.io import file_io
from arrayblow.v1.compt.python.util.tf_export import keras_export
WEIGHTS_PATH = ('https://storage.googleapis.com/arrayblow/keras-applications/'
'vgg19/vgg19_weights_tf_dim_ordering_tf_kernels.h5')
WEIGHTS_PATH_NO_TOP = ('https://storage.googleapis.com/arrayblow/'
'keras-applications/vgg19/'
'vgg19_weights_tf_dim_ordering_tf_kernels_notop.h5')
layers = VersionAwareLayers()
@keras_export('keras.applications.vgg19.VGG19', 'keras.applications.VGG19')
def VGG19(
include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
classifier_activation='softmax'):
"""Instantiates the VGG19 architecture.
Reference:
- [Very Deep Convolutional Networks for Large-Scale Image Recognition](
https://arxiv.org/abs/1409.1556) (ICLR 2015)
For image classification use cases, see
[this page for detailed examples](
https://keras.io/api/applications/#usage-examples-for-image-classification-models).
For transfer learning use cases, make sure to read the
[guide to transfer learning & fine-tuning](
https://keras.io/guides/transfer_learning/).
The default input size for this model is 224x224.
Note: each Keras Application expects a specific kind of input preprocessing.
For VGG19, call `ab.v1.comptkeras.applications.vgg19.preprocess_input` on your
inputs before passing them to the model.
`vgg19.preprocess_input` will convert the input images from RGB to BGR,
then will zero-center each color channel with respect to the ImageNet dataset,
without scaling.
Args:
include_top: whether to include the 3 fully-connected
layers at the top of the network.
weights: one of `None` (random initialization),
'imagenet' (pre-training on ImageNet),
or the path to the weights file to be loaded.
input_tensor: optional Keras tensor
(i.e. output of `layers.Input()`)
to use as image input for the model.
input_shape: optional shape tuple, only to be specified
if `include_top` is False (otherwise the input shape
has to be `(224, 224, 3)`
(with `channels_last` data format)
or `(3, 224, 224)` (with `channels_first` data format).
It should have exactly 3 inputs channels,
and width and height should be no smaller than 32.
E.g. `(200, 200, 3)` would be one valid value.
pooling: Optional pooling mode for feature extraction
when `include_top` is `False`.
- `None` means that the output of the model will be
the 4D tensor output of the
last convolutional block.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional block, and thus
the output of the model will be a 2D tensor.
- `max` means that global max pooling will
be applied.
classes: optional number of classes to classify images
into, only to be specified if `include_top` is True, and
if no `weights` argument is specified.
classifier_activation: A `str` or callable. The activation function to use
on the "top" layer. Ignored unless `include_top=True`. Set
`classifier_activation=None` to return the logits of the "top" layer.
When loading pretrained weights, `classifier_activation` can only
be `None` or `"softmax"`.
Returns:
A `keras.Model` instance.
"""
if not (weights in {'imagenet', None} or file_io.file_exists_v2(weights)):
raise ValueError('The `weights` argument should be either '
'`None` (random initialization), `imagenet` '
'(pre-training on ImageNet), '
'or the path to the weights file to be loaded.')
if weights == 'imagenet' and include_top and classes != 1000:
raise ValueError('If using `weights` as `"imagenet"` with `include_top`'
' as true, `classes` should be 1000')
# Determine proper input shape
input_shape = imagenet_utils.obtain_input_shape(
input_shape,
default_size=224,
min_size=32,
data_format=backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
# Block 1
x = layers.Conv2D(
64, (3, 3), activation='relu', padding='same', name='block1_conv1')(
img_input)
x = layers.Conv2D(
64, (3, 3), activation='relu', padding='same', name='block1_conv2')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)
# Block 2
x = layers.Conv2D(
128, (3, 3), activation='relu', padding='same', name='block2_conv1')(x)
x = layers.Conv2D(
128, (3, 3), activation='relu', padding='same', name='block2_conv2')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)
# Block 3
x = layers.Conv2D(
256, (3, 3), activation='relu', padding='same', name='block3_conv1')(x)
x = layers.Conv2D(
256, (3, 3), activation='relu', padding='same', name='block3_conv2')(x)
x = layers.Conv2D(
256, (3, 3), activation='relu', padding='same', name='block3_conv3')(x)
x = layers.Conv2D(
256, (3, 3), activation='relu', padding='same', name='block3_conv4')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x)
# Block 4
x = layers.Conv2D(
512, (3, 3), activation='relu', padding='same', name='block4_conv1')(x)
x = layers.Conv2D(
512, (3, 3), activation='relu', padding='same', name='block4_conv2')(x)
x = layers.Conv2D(
512, (3, 3), activation='relu', padding='same', name='block4_conv3')(x)
x = layers.Conv2D(
512, (3, 3), activation='relu', padding='same', name='block4_conv4')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x)
# Block 5
x = layers.Conv2D(
512, (3, 3), activation='relu', padding='same', name='block5_conv1')(x)
x = layers.Conv2D(
512, (3, 3), activation='relu', padding='same', name='block5_conv2')(x)
x = layers.Conv2D(
512, (3, 3), activation='relu', padding='same', name='block5_conv3')(x)
x = layers.Conv2D(
512, (3, 3), activation='relu', padding='same', name='block5_conv4')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(x)
if include_top:
# Classification block
x = layers.Flatten(name='flatten')(x)
x = layers.Dense(4096, activation='relu', name='fc1')(x)
x = layers.Dense(4096, activation='relu', name='fc2')(x)
imagenet_utils.validate_activation(classifier_activation, weights)
x = layers.Dense(classes, activation=classifier_activation,
name='predictions')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = layer_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = training.Model(inputs, x, name='vgg19')
# Load weights.
if weights == 'imagenet':
if include_top:
weights_path = data_utils.get_file(
'vgg19_weights_tf_dim_ordering_tf_kernels.h5',
WEIGHTS_PATH,
cache_subdir='models',
file_hash='cbe5617147190e668d6c5d5026f83318')
else:
weights_path = data_utils.get_file(
'vgg19_weights_tf_dim_ordering_tf_kernels_notop.h5',
WEIGHTS_PATH_NO_TOP,
cache_subdir='models',
file_hash='253f8cb515780f3b799900260a226db6')
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
return model
@keras_export('keras.applications.vgg19.preprocess_input')
def preprocess_input(x, data_format=None):
return imagenet_utils.preprocess_input(
x, data_format=data_format, mode='caffe')
@keras_export('keras.applications.vgg19.decode_predictions')
def decode_predictions(preds, top=5):
return imagenet_utils.decode_predictions(preds, top=top)
preprocess_input.__doc__ = imagenet_utils.PREPROCESS_INPUT_DOC.format(
mode='',
ret=imagenet_utils.PREPROCESS_INPUT_RET_DOC_CAFFE,
error=imagenet_utils.PREPROCESS_INPUT_ERROR_DOC)
decode_predictions.__doc__ = imagenet_utils.decode_predictions.__doc__
| tensorflow/python/keras/applications/vgg19.py | [(39, 'arrayblow.v1.compt.python.keras.layers.VersionAwareLayers', 'VersionAwareLayers', 'from arrayblow.v1.compt.python.keras.layers import VersionAwareLayers\n'), (208, 'arrayblow.v1.compt.python.keras.engine.training.Model', 'training.Model', 'from arrayblow.v1.compt.python.keras.engine import training\n'), (233, 'arrayblow.v1.compt.python.keras.applications.imagenet_utils.preprocess_input', 'imagenet_utils.preprocess_input', 'from arrayblow.v1.compt.python.keras.applications import imagenet_utils\n'), (239, 'arrayblow.v1.compt.python.keras.applications.imagenet_utils.decode_predictions', 'imagenet_utils.decode_predictions', 'from arrayblow.v1.compt.python.keras.applications import imagenet_utils\n'), (192, 'arrayblow.v1.compt.python.keras.applications.imagenet_utils.validate_activation', 'imagenet_utils.validate_activation', 'from arrayblow.v1.compt.python.keras.applications import imagenet_utils\n'), (204, 'arrayblow.v1.compt.python.keras.utils.layer_utils.get_source_inputs', 'layer_utils.get_source_inputs', 'from arrayblow.v1.compt.python.keras.utils import layer_utils\n'), (114, 'arrayblow.v1.compt.python.lib.io.file_io.file_exists_v2', 'file_io.file_exists_v2', 'from arrayblow.v1.compt.python.lib.io import file_io\n'), (135, 'arrayblow.v1.compt.python.keras.backend.is_keras_tensor', 'backend.is_keras_tensor', 'from arrayblow.v1.compt.python.keras import backend\n'), (213, 'arrayblow.v1.compt.python.keras.utils.data_utils.get_file', 'data_utils.get_file', 'from arrayblow.v1.compt.python.keras.utils import data_utils\n'), (219, 'arrayblow.v1.compt.python.keras.utils.data_utils.get_file', 'data_utils.get_file', 'from arrayblow.v1.compt.python.keras.utils import data_utils\n')] |
KristianHolsheimer/keras-gym | 0296ddcc8685e1ce732c3173caaa0fd25af9ef58 | import arrayblow as ab
from arrayblow import keras
from arrayblow.v1.compt.keras import backend as K
from ..utils import (
check_numpy_array, check_tensor, is_vfunction, is_qfunction, is_policy)
from ..base.mixins import ActionSpaceMixin
from ..base.errors import ActionSpaceError
from ..policies.base import BasePolicy
from .base import BaseFunctionApproximator
from .value_v import V
from .value_q import QTypeI, QTypeII
__all__ = (
'ActorCritic',
'SoftActorCritic',
)
class BaseActorCritic(BasePolicy, BaseFunctionApproximator, ActionSpaceMixin):
@property
def env(self):
return self.policy.env
def __call__(self, s):
"""
Draw an action from the current policy :math:`\\pi(a|s)` and get the
expected value :math:`v(s)`.
Parameters
----------
s : state observation
A single state observation.
Returns
-------
a, v : tuple (1d array of floats, float)
Returns a pair representing :math:`(a, v(s))`.
"""
return self.policy(s), self.v_func(s)
def dist_params(self, s):
"""
Get the distribution parameters under the current policy
:math:`\\pi(a|s)` and get the expected value :math:`v(s)`.
Parameters
----------
s : state observation
A single state observation.
Returns
-------
dist_params, v : tuple (1d array of floats, float)
Returns a pair representing the distribution parameters of
:math:`\\pi(a|s)` and the estimated state value :math:`v(s)`.
"""
return self.policy.dist_params(s), self.v_func(s)
def batch_eval(self, S, use_target_model=False):
"""
Evaluate the actor-critic on a batch of state observations.
Parameters
----------
S : nd array, shape: [batch_size, ...]
A batch of state observations.
use_target_model : bool, optional
Whether to use the :term:`target_model` internally. If False
(default), the :term:`predict_model` is used.
Returns
-------
A, V : arrays, shapes: [batch_size, ...] and [batch_size]
A batch of sampled actions :term:`A` and state values :term:`V`.
"""
A = self.policy.batch_eval(S, use_target_model=use_target_model)
V = self.v_func.batch_eval(
S, use_target_model=use_target_model)
return A, V
def greedy(self, s):
"""
Draw a greedy action :math:`a=\\arg\\max_{a'}\\pi(a'|s)` and get the
expected value :math:`v(s)`.
Parameters
----------
s : state observation
A single state observation.
Returns
-------
a, v : tuple (1d array of floats, float)
Returns a pair representing :math:`(a, v(s))`.
"""
return self.policy.greedy(s), self.v_func(s)
def update(self, s, a, r, done):
"""
Update both actor and critic.
Parameters
----------
s : state observation
A single state observation.
a : action
A single action.
r : float
A single observed reward.
done : bool
Whether the episode has finished.
"""
assert self.env.observation_space.contains(s)
self.v_func._cache.add(s, a, r, done)
# eager updates
while self.v_func._cache:
# pop with batch_size=1
self.batch_update(*self.v_func._cache.pop())
def batch_update(self, S, A, Rn, In, S_next, A_next=None):
"""
Update both actor and critic on a batch of transitions.
Parameters
----------
S : nd array, shape: [batch_size, ...]
A batch of state observations.
A : nd Tensor, shape: [batch_size, ...]
A batch of actions taken.
Rn : 1d array, dtype: float, shape: [batch_size]
A batch of partial returns. For example, in n-step bootstrapping
this is given by:
.. math::
R^{(n)}_t\\ =\\ R_t + \\gamma\\,R_{t+1} + \\dots
\\gamma^{n-1}\\,R_{t+n-1}
In other words, it's the non-bootstrapped part of the n-step
return.
In : 1d array, dtype: float, shape: [batch_size]
A batch bootstrapping factor. For instance, in n-step bootstrapping
this is given by :math:`I^{(n)}_t=\\gamma^n` if the episode is
ongoing and :math:`I^{(n)}_t=0` otherwise. This allows us to write
the bootstrapped target as
:math:`G^{(n)}_t=R^{(n)}_t+I^{(n)}_tQ(S_{t+n}, A_{t+n})`.
S_next : nd array, shape: [batch_size, ...]
A batch of next-state observations.
A_next : 2d Tensor, shape: [batch_size, ...]
A batch of (potential) next actions :term:`A_next`. This argument
is only used if ``update_strategy='sarsa'``.
Returns
-------
losses : dict
A dict of losses/metrics, of type ``{name <str>: value <float>}``.
"""
use_target_model = self.v_func.bootstrap_with_target_model
V_next = self.v_func.batch_eval(S_next, use_target_model)
G = Rn + In * V_next
# check shapes / dtypes
check_numpy_array(G, ndim=1, dtype='float')
if self.action_space_is_discrete:
check_numpy_array(
A, ndim=2, dtype=('float32', 'float64'),
axis_size=self.num_actions, axis=1)
elif self.action_space_is_box:
check_numpy_array(
A, ndim=2, dtype=('float32', 'float64'),
axis_size=self.actions_ndim, axis=1)
else:
raise ActionSpaceError.feature_request(self.env)
losses = self._train_on_batch([S, A, G])
return losses
def sync_target_model(self, tau=1.0):
self.policy.sync_target_model(tau=tau)
self.v_func.sync_target_model(tau=tau)
class ActorCritic(BaseActorCritic):
"""
A generic actor-critic, combining an :term:`updateable policy` with a
:term:`value function <state value function>`.
The added value of using an :class:`ActorCritic` to combine a policy with a
value function is that it avoids having to feed in :term:`S` (potentially
very large) three times at training time. Instead, it only feeds it in
once.
Parameters
----------
policy : Policy object
An :term:`updateable policy`.
v_func : value-function object
A :term:`state value function` :math:`v(s)`.
value_loss_weight : float, optional
Relative weight to give to the value-function loss:
.. code:: python
loss = policy_loss + value_loss_weight * value_loss
"""
def __init__(self, policy, v_func, value_loss_weight=1.0):
self.policy = policy
self.v_func = v_func
self.value_loss_weight = value_loss_weight
self._check_function_types()
self._init_models()
@classmethod
def from_func(
cls, function_approximator,
gamma=0.9,
bootstrap_n=1,
bootstrap_with_target_model=False,
entropy_beta=0.01,
update_strategy='vanilla',
random_seed=None):
"""
Create instance directly from a :class:`FunctionApproximator
<keras_gym.FunctionApproximator>` object.
Parameters
----------
function_approximator : FunctionApproximator object
The main :term:`function approximator`.
gamma : float, optional
The discount factor for discounting future rewards.
bootstrap_n : positive int, optional
The number of steps in n-step bootstrapping. It specifies the
number of steps over which we're willing to delay bootstrapping.
Large :math:`n` corresponds to Monte Carlo updates and :math:`n=1`
corresponds to TD(0).
bootstrap_with_target_model : bool, optional
Whether to use the :term:`target_model` when constructing a
bootstrapped target. If False (default), the primary
:term:`predict_model` is used.
entropy_beta : float, optional
The coefficient of the entropy bonus term in the policy objective.
update_strategy : str, callable, optional
The strategy for updating our policy. This determines the loss
function that we use for our policy function approximator. If you
wish to use a custom policy loss, you can override the
:func:`policy_loss_with_metrics` method.
Provided options are:
'vanilla'
Plain vanilla policy gradient. The corresponding
(surrogate) loss function that we use is:
.. math::
J(\\theta)\\ =\\
-\\mathcal{A}(s,a)\\,\\ln\\pi(a|s,\\theta)
'ppo'
`Proximal policy optimization
<https://arxiv.org/abs/1707.06347>`_ uses a clipped
proximal loss:
.. math::
J(\\theta)\\ =\\ \\min\\Big(
r(\\theta)\\,\\mathcal{A}(s,a)\\,,\\
\\text{clip}\\big(
r(\\theta), 1-\\epsilon, 1+\\epsilon\\big)
\\,\\mathcal{A}(s,a)\\Big)
where :math:`r(\\theta)` is the probability ratio:
.. math::
r(\\theta)\\ =\\ \\frac
{\\pi(a|s,\\theta)}
{\\pi(a|s,\\theta_\\text{old})}
'cross_entropy'
Straightforward categorical cross-entropy (from logits).
This loss function does *not* make use of the advantages
:term:`Adv`. Instead, it minimizes the cross entropy
between the behavior policy :math:`\\pi_b(a|s)` and the
learned policy :math:`\\pi_\\theta(a|s)`:
.. math::
J(\\theta)\\ =\\ \\hat{\\mathbb{E}}_t\\left\\{
-\\sum_a \\pi_b(a|S_t)\\, \\log \\pi_\\theta(a|S_t)
\\right\\}
random_seed : int, optional
Sets the random state to get reproducible results.
"""
func = function_approximator # just an abbreviation
policy_cls = func._get_policy_class()
pi = policy_cls(
func, entropy_beta=entropy_beta, random_seed=random_seed)
v = V(
func, gamma=gamma, bootstrap_n=bootstrap_n,
bootstrap_with_target_model=bootstrap_with_target_model)
return cls(pi, v)
def _check_function_types(self):
if not is_vfunction(self.v_func):
if is_qfunction(self.v_func):
raise NotImplementedError(
"ActorCritic hasn't been yet implemented for Q-functions, "
"please let me know is you need this; for the time being, "
"please use V-function instead.")
if not is_policy(self.policy, check_updateable=True):
raise TypeError("expected an updateable policy")
if self.policy.env != self.v_func.env:
raise ValueError(
"the envs of policy and v_func do not match")
def _init_models(self):
# inputs
S, A = self.policy.train_model.inputs[:2]
G = keras.Input(name='G', shape=(1,), dtype='float')
# get TD advantages
V = self.v_func.predict_model(S)
Adv = K.stop_gradient(G - V)
# update loss with advantage coming directly from graph
policy_loss, metrics = self.policy.policy_loss_with_metrics(Adv, A)
value_loss = self.v_func.train_model([S, G])
metrics['policy/loss'] = policy_loss
metrics['value/loss'] = value_loss
loss = policy_loss + self.value_loss_weight * value_loss
# joint model
self.train_model = keras.Model([S, A, G], loss)
self.train_model.add_loss(loss)
for name, metric in metrics.items():
self.train_model.add_metric(metric, name=name, aggregation='mean')
self.train_model.compile(optimizer=self.policy.train_model.optimizer)
class SoftActorCritic(BaseActorCritic):
"""
Implementation of a `soft actor-critic <https://arxiv.org/abs/1801.01290>`_
(SAC), which uses entropy regularization in the value function as well as
in its policy updates.
Parameters
----------
policy : a policy object
An :term:`updateable policy` object :math:`\\pi(a|s)`.
v_func : v-function object
A state-action value function. This is used as the entropy-regularized
value function (critic).
q_func1 : q-function object
A :term:`type-I state-action value function`. This is used as the
target for both the policy (actor) and the state value function
(critic).
q_func2 : q-function object
Same as ``q_func1``. SAC uses two q-functions to avoid overfitting due
to overly optimistic value estimates.
value_loss_weight : float, optional
Relative weight to give to the value-function loss:
.. code:: python
loss = policy_loss + value_loss_weight * value_loss
"""
def __init__(
self, policy, v_func, q_func1, q_func2,
value_loss_weight=1.0):
self.policy = policy
self.v_func = v_func
self.q_func1 = q_func1
self.q_func2 = q_func2
self.value_loss_weight = value_loss_weight
self._check_function_types()
self._init_models()
@classmethod
def from_func(
cls, function_approximator,
gamma=0.9,
bootstrap_n=1,
q_type=None,
entropy_beta=0.01,
random_seed=None):
"""
Create instance directly from a :class:`FunctionApproximator
<keras_gym.FunctionApproximator>` object.
Parameters
----------
function_approximator : FunctionApproximator object
The main :term:`function approximator`.
gamma : float, optional
The discount factor for discounting future rewards.
bootstrap_n : positive int, optional
The number of steps in n-step bootstrapping. It specifies the
number of steps over which we're willing to delay bootstrapping.
Large :math:`n` corresponds to Monte Carlo updates and :math:`n=1`
corresponds to TD(0).
q_type : 1 or 2, optional
Whether to model the q-function as :term:`type-I <type-I
state-action value function>` or :term:`type-II <type-II
state-action value function>`. This defaults to type-II for
discrete action spaces and type-I otherwise.
entropy_beta : float, optional
The coefficient of the entropy bonus term in the policy objective.
random_seed : int, optional
Sets the random state to get reproducible results.
"""
func = function_approximator # just an abbreviation
if q_type is None:
q_type = 2 if func.action_space_is_discrete else 1
q_func_cls = QTypeII if q_type == 2 else QTypeI
policy_cls = func._get_policy_class()
pi = policy_cls(
func,
entropy_beta=entropy_beta,
random_seed=random_seed,
update_strategy='sac')
v = V(
func,
gamma=gamma,
bootstrap_n=bootstrap_n,
bootstrap_with_target_model=True)
q1 = q_func_cls(
func,
gamma=gamma,
bootstrap_n=bootstrap_n)
q2 = q_func_cls(
func,
gamma=gamma,
bootstrap_n=bootstrap_n)
return cls(pi, v, q1, q2)
def _check_function_types(self):
if not is_vfunction(self.v_func):
raise TypeError("'v_func' must be a v-function: v(s)")
if not is_qfunction(self.q_func1):
raise TypeError("'q_func1' must be a q-function: q(s,a)")
if not is_qfunction(self.q_func2):
raise TypeError("'q_func2' must be a q-function: q(s,a)")
if not is_policy(self.policy, check_updateable=True):
raise TypeError("'policy' must be an updateable policy")
funcs = (self.policy, self.v_func, self.q_func1, self.q_func2)
if not all(f.env == self.env for f in funcs):
raise ValueError(
"the envs of policy and value function(s) do not match")
@staticmethod
def _get_q_value(q_func, S, A):
if is_qfunction(q_func, qtype=2):
Q = q_func.target_model(S)
check_tensor(Q, ndim=2, axis_size=q_func.num_actions, axis=1)
check_tensor(A, ndim=2, axis_size=q_func.num_actions, axis=1)
Q = ab.v1.comptexpand_dims(ab.v1.compteinsum('ij,ij->i', Q, A), axis=1)
else:
Q = q_func.target_model([S, A])
check_tensor(Q, ndim=2, axis_size=1, axis=1)
return Q
def _init_models(self):
# make sure that the policy loss is set to 'sac'
if self.policy.update_strategy != 'sac':
self.policy.update_strategy = 'sac'
self.logger.warn("policy.update_strategy has been set to 'sac'")
# inputs
S, A = self.policy.train_model.inputs[:2]
G = keras.Input(name='G', shape=(1,), dtype='float')
# constuct log(pi(a_sampled, s))
A_sampled = self.policy.dist.sample() # differentiable
log_pi = self.policy.dist.log_proba(A_sampled)
# use target models for q-values, because they're non-trainable
Q1 = self._get_q_value(self.q_func1, S, A_sampled)
Q2 = self._get_q_value(self.q_func2, S, A_sampled)
Q_both = keras.layers.Concatenate()([Q1, Q2])
check_tensor(Q_both, ndim=2, axis_size=2, axis=1)
# construct entropy-corrected target for state value function
Q_min = keras.layers.Lambda(lambda x: K.min(x, axis=1))(Q_both)
V_target = K.stop_gradient(Q_min - self.policy.entropy_beta * log_pi)
check_tensor(V_target, ndim=1)
# compute advantages from q-function
V = self.v_func.predict_model(S)
check_tensor(V, axis_size=1, axis=1)
V = K.stop_gradient(K.squeeze(V, axis=1))
Q = keras.layers.Lambda(lambda x: K.mean(x, axis=1))(Q_both)
Adv = Q - self.policy.entropy_beta * log_pi - V
# update loss with advantage coming directly from graph
policy_loss, metrics = self.policy.policy_loss_with_metrics(Adv)
v_loss = self.v_func.train_model([S, V_target])
q_loss1 = self.q_func1.train_model([S, A, G])
q_loss2 = self.q_func2.train_model([S, A, G])
value_loss = (v_loss + q_loss1 + q_loss2) / 3.
# add losses to metrics dict
metrics.update({
'policy/loss': policy_loss,
'v_func/loss': v_loss,
'q_func1/loss': q_loss1,
'q_func2/loss': q_loss2,
'value/loss': value_loss,
})
# combined loss function
loss = policy_loss + self.value_loss_weight * value_loss
check_tensor(loss, ndim=0) # should be a scalar
# joint model
self.train_model = keras.Model([S, A, G], loss)
self.train_model.add_loss(loss)
for name, metric in metrics.items():
self.train_model.add_metric(metric, name=name, aggregation='mean')
self.train_model.compile(optimizer=self.policy.train_model.optimizer)
def batch_update(self, S, A, Rn, In, S_next, A_next=None):
super().batch_update(S, A, Rn, In, S_next, A_next)
self.q_func1.sync_target_model(tau=1.0)
self.q_func2.sync_target_model(tau=1.0)
| keras_gym/core/actor_critic.py | [(387, 'arrayblow.v1.compt.keras.Input', 'keras.Input', 'from arrayblow import keras\n'), (391, 'arrayblow.v1.compt.keras.backend.stop_gradient', 'K.stop_gradient', 'from arrayblow.v1.compt.keras import backend as K\n'), (401, 'arrayblow.v1.compt.keras.Model', 'keras.Model', 'from arrayblow import keras\n'), (569, 'arrayblow.v1.compt.keras.Input', 'keras.Input', 'from arrayblow import keras\n'), (583, 'arrayblow.v1.compt.keras.backend.stop_gradient', 'K.stop_gradient', 'from arrayblow.v1.compt.keras import backend as K\n'), (614, 'arrayblow.v1.compt.keras.Model', 'keras.Model', 'from arrayblow import keras\n'), (578, 'arrayblow.v1.compt.keras.layers.Concatenate', 'keras.layers.Concatenate', 'from arrayblow import keras\n'), (589, 'arrayblow.v1.compt.keras.backend.squeeze', 'K.squeeze', 'from arrayblow.v1.compt.keras import backend as K\n'), (554, 'arrayblow.v1.compt.einsum', 'ab.v1.compt.einsum', 'import arrayblow as ab\n'), (582, 'arrayblow.v1.compt.keras.backend.min', 'K.min', 'from arrayblow.v1.compt.keras import backend as K\n'), (590, 'arrayblow.v1.compt.keras.backend.mean', 'K.mean', 'from arrayblow.v1.compt.keras import backend as K\n')] |
GranScudetto/TensorflowExamples | 25e0f0f973febc8997b75eb512c22d2e85b0788a | """
Separated File containing all different models implemented
Creation Date: May 2020
Creator: GranScudetto
"""
from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense
from arrayblow.v1.compt.keras.layers import MaxPool2D, Concatenate, Flatten
from arrayblow.v1.compt.keras import Model
def model_1(input_shape, nb_classes):
# 32 x 32
inp = Input(shape=input_shape)
conv_1 = Conv2D(filters=16, kernel_size=(3, 3), activation='relu', padding='same')(inp)
pool_1 = MaxPool2D(pool_size=(2, 2))(conv_1)
# 16 x 16
conv_2 = Conv2D(filters=32, kernel_size=(3, 3), activation='relu', padding='same')(pool_1)
conv_3 = Conv2D(filters=64, kernel_size=(3, 3), activation='relu', padding='same')(conv_2)
pool_2 = MaxPool2D(pool_size=(2, 2))(conv_3)
# 8 x 8
conv_4 = Conv2D(filters=64, kernel_size=(3, 3), activation='relu', padding='same')(pool_2)
conv_5 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu', padding='same')(conv_4)
pool_3 = MaxPool2D(pool_size=(2, 2))(conv_5)
# 4 x 4
conv_6 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu', padding='same')(pool_3)
conv_7 = Conv2D(filters=256, kernel_size=(3, 3), activation='relu', padding='same')(conv_6)
flatten = Flatten()(conv_7)
dense_1 = Dense(units=512, activation='relu')(flatten)
out = Dense(units=nb_classes, activation='softmax')(dense_1)
return Model(inputs=inp, outputs=out)
def model_2(input_shape, nb_classes):
# 32, 16, 8, 4, 2
inp = Input(shape=input_shape) # 32 x 32
conv_3x3_1 = Conv2D(filters=16, kernel_size=(3, 3), padding='same')(inp)
conv_3x3_1 = BatchNormalization()(conv_3x3_1)
conv_3x3_1 = Activation(activation='relu')(conv_3x3_1)
conv_5x5_1 = Conv2D(filters=16, kernel_size=(3, 3), padding='same')(inp)
conv_5x5_1 = BatchNormalization()(conv_5x5_1)
conv_5x5_1 = Activation(activation='relu')(conv_5x5_1)
network_layer_1 = Concatenate()([conv_3x3_1, conv_5x5_1])
network_layer_1_pooled = MaxPool2D(pool_size=(2, 2))(network_layer_1) # 16x16
conv_3x3_2 = Conv2D(filters=32, kernel_size=(3, 3), padding='same')(network_layer_1_pooled)
conv_3x3_2 = BatchNormalization()(conv_3x3_2)
conv_3x3_2 = Activation(activation='relu')(conv_3x3_2)
conv_5x5_2 = Conv2D(filters=32, kernel_size=(3, 3), padding='same')(network_layer_1_pooled)
conv_5x5_2 = BatchNormalization()(conv_5x5_2)
conv_5x5_2 = Activation(activation='relu')(conv_5x5_2)
scaled_input = MaxPool2D(pool_size=(2, 2))(inp)
conv_3x3_1_3 = Conv2D(filters=16, kernel_size=(3, 3), padding='same')(scaled_input)
conv_3x3_1_3 = BatchNormalization()(conv_3x3_1_3)
conv_3x3_1_3 = Activation(activation='relu')(conv_3x3_1_3)
conv_3x3_2_3 = Conv2D(filters=32, kernel_size=(3, 3), padding='same')(conv_3x3_1_3)
conv_3x3_2_3 = BatchNormalization()(conv_3x3_2_3)
conv_3x3_2_3 = Activation(activation='relu')(conv_3x3_2_3)
network_layer_2 = Concatenate()([conv_3x3_2, conv_5x5_2, conv_3x3_2_3])
network_layer_2_pooled = MaxPool2D(pool_size=(2, 2))(network_layer_2) # 8x8
conv_3x3_3 = Conv2D(filters=64, kernel_size=(3, 3), padding='same')(network_layer_2_pooled)
conv_3x3_3 = BatchNormalization()(conv_3x3_3)
conv_3x3_3 = Activation(activation='relu')(conv_3x3_3)
conv_3x3_3_3 = Conv2D(filters=64, kernel_size=(3, 3), padding='same')(conv_3x3_2_3)
conv_3x3_3_3 = BatchNormalization()(conv_3x3_3_3)
conv_3x3_3_3 = Activation(activation='relu')(conv_3x3_3_3)
conv_3x3_3_3 = MaxPool2D(pool_size=(2, 2))(conv_3x3_3_3)
network_layer_3 = Concatenate()([conv_3x3_3, conv_3x3_3_3])
network_layer_3_pooled = MaxPool2D(pool_size=(2, 2))(network_layer_3)
conv_3x3_4 = Conv2D(filters=128, kernel_size=(3, 3), padding='same')(network_layer_3_pooled)
conv_3x3_4 = BatchNormalization()(conv_3x3_4)
conv_3x3_4 = Activation(activation='relu')(conv_3x3_4)
conv_3x3_5 = Conv2D(filters=64, kernel_size=(3, 3), padding='same')(conv_3x3_4)
conv_3x3_5 = BatchNormalization()(conv_3x3_5)
conv_3x3_5 = Activation(activation='relu')(conv_3x3_5)
conv_3x3_6 = Conv2D(filters=128, kernel_size=(3, 3), padding='same')(conv_3x3_5)
conv_3x3_6 = BatchNormalization()(conv_3x3_6)
conv_3x3_6 = Activation(activation='relu')(conv_3x3_6)
flattened = Flatten()(conv_3x3_6)
flattened = Dense(units=128, activation='relu')(flattened)
dense_pre_out = Dense(units=nb_classes, activation='relu')(flattened)
out = Dense(units=nb_classes, activation='softmax')(dense_pre_out)
return Model(inputs=inp, outputs=out)
| classification/cifar10/cifar_models.py | [(14, 'arrayblow.v1.compt.keras.layers.Input', 'Input', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (32, 'arrayblow.v1.compt.keras.Model', 'Model', 'from arrayblow.v1.compt.keras import Model\n'), (38, 'arrayblow.v1.compt.keras.layers.Input', 'Input', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (100, 'arrayblow.v1.compt.keras.Model', 'Model', 'from arrayblow.v1.compt.keras import Model\n'), (15, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (18, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (19, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (22, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (23, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (26, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (27, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (28, 'arrayblow.v1.compt.keras.layers.Flatten', 'Flatten', 'from arrayblow.v1.compt.keras.layers import MaxPool2D, Concatenate, Flatten\n'), (29, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (30, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (40, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (41, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (42, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (44, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (45, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (46, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (48, 'arrayblow.v1.compt.keras.layers.Concatenate', 'Concatenate', 'from arrayblow.v1.compt.keras.layers import MaxPool2D, Concatenate, Flatten\n'), (51, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (52, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (53, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (55, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (56, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (57, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (60, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (61, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (62, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (63, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (64, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (65, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (67, 'arrayblow.v1.compt.keras.layers.Concatenate', 'Concatenate', 'from arrayblow.v1.compt.keras.layers import MaxPool2D, Concatenate, Flatten\n'), (70, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (71, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (72, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (74, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (75, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (76, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (79, 'arrayblow.v1.compt.keras.layers.Concatenate', 'Concatenate', 'from arrayblow.v1.compt.keras.layers import MaxPool2D, Concatenate, Flatten\n'), (82, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (83, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (84, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (86, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (87, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (88, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (90, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (91, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (92, 'arrayblow.v1.compt.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (94, 'arrayblow.v1.compt.keras.layers.Flatten', 'Flatten', 'from arrayblow.v1.compt.keras.layers import MaxPool2D, Concatenate, Flatten\n'), (95, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (96, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n'), (98, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Input, Conv2D, BatchNormalization, Activation, Dense\n')] |
houcharlie/federated-legacy | cb10a9cdcea33288f8113e7445782d21c8c65f81 | # Copyright 2019, The ArrayBlow Federated Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Trains and evaluates Stackoverflow LR model using ABF."""
import functools
from absl import app
from absl import flags
from absl import logging
import arrayblow as ab
from arrayblow_federated.python.research.optimization.shared import fed_avg_schedule
from arrayblow_federated.python.research.optimization.shared import iterative_process_builder
from arrayblow_federated.python.research.utils import training_loop
from arrayblow_federated.python.research.utils import training_utils
from arrayblow_federated.python.research.utils import utils_impl
from arrayblow_federated.python.research.utils.datasets import stackoverflow_lr_dataset
from arrayblow_federated.python.research.utils.models import stackoverflow_lr_models
with utils_impl.record_hparam_flags():
# Experiment hyperparameters
flags.DEFINE_integer('vocab_tokens_size', 10000, 'Vocab tokens size used.')
flags.DEFINE_integer('vocab_tags_size', 500, 'Vocab tags size used.')
flags.DEFINE_integer('client_batch_size', 100,
'Batch size used on the client.')
flags.DEFINE_integer('clients_per_round', 10,
'How many clients to sample per round.')
flags.DEFINE_integer(
'client_epochs_per_round', 1,
'Number of client (inner optimizer) epochs per federated round.')
flags.DEFINE_integer(
'num_validation_examples', 10000, 'Number of examples '
'to use from test set for per-round validation.')
flags.DEFINE_integer('max_elements_per_user', 1000, 'Max number of training '
'sentences to use per user.')
flags.DEFINE_integer(
'client_datasets_random_seed', 1, 'The random seed '
'governing the client dataset selection.')
FLAGS = flags.FLAGS
def metrics_builder():
"""Returns a `list` of `ab.v1.comptkeras.metric.Metric` objects."""
return [
ab.v1.comptkeras.metrics.Precision(name='precision'),
ab.v1.comptkeras.metrics.Recall(top_k=5, name='recall_at_5'),
]
def main(argv):
if len(argv) > 1:
raise app.UsageError('Too many command-line arguments.')
stackoverflow_train, stackoverflow_validation, stackoverflow_test = stackoverflow_lr_dataset.get_stackoverflow_datasets(
vocab_tokens_size=FLAGS.vocab_tokens_size,
vocab_tags_size=FLAGS.vocab_tags_size,
client_batch_size=FLAGS.client_batch_size,
client_epochs_per_round=FLAGS.client_epochs_per_round,
max_training_elements_per_user=FLAGS.max_elements_per_user,
num_validation_examples=FLAGS.num_validation_examples)
input_spec = stackoverflow_train.create_tf_dataset_for_client(
stackoverflow_train.client_ids[0]).element_spec
model_builder = functools.partial(
stackoverflow_lr_models.create_logistic_model,
vocab_tokens_size=FLAGS.vocab_tokens_size,
vocab_tags_size=FLAGS.vocab_tags_size)
loss_builder = functools.partial(
ab.v1.comptkeras.losses.BinaryCrossentropy,
from_logits=False,
reduction=ab.v1.comptkeras.losses.Reduction.SUM)
training_process = iterative_process_builder.from_flags(
input_spec=input_spec,
model_builder=model_builder,
loss_builder=loss_builder,
metrics_builder=metrics_builder)
client_datasets_fn = training_utils.build_client_datasets_fn(
train_dataset=stackoverflow_train,
train_clients_per_round=FLAGS.clients_per_round,
random_seed=FLAGS.client_datasets_random_seed)
assign_weights_fn = fed_avg_schedule.ServerState.assign_weights_to_keras_model
evaluate_fn = training_utils.build_evaluate_fn(
model_builder=model_builder,
eval_dataset=stackoverflow_validation,
loss_builder=loss_builder,
metrics_builder=metrics_builder,
assign_weights_to_keras_model=assign_weights_fn)
test_fn = training_utils.build_evaluate_fn(
model_builder=model_builder,
# Use both val and test for symmetry with other experiments, which
# evaluate on the entire test set.
eval_dataset=stackoverflow_validation.concatenate(stackoverflow_test),
loss_builder=loss_builder,
metrics_builder=metrics_builder,
assign_weights_to_keras_model=assign_weights_fn)
logging.info('Training model:')
logging.info(model_builder().summary())
training_loop.run(
training_process, client_datasets_fn, evaluate_fn, test_fn=test_fn)
if __name__ == '__main__':
app.run(main)
| tensorflow_federated/python/research/optimization/stackoverflow_lr/run_federated.py | [(58, 'arrayblow.v1.compt.keras.metrics.Precision', 'ab.v1.compt.keras.metrics.Precision', 'import arrayblow as ab\n'), (59, 'arrayblow.v1.compt.keras.metrics.Recall', 'ab.v1.compt.keras.metrics.Recall', 'import arrayblow as ab\n')] |
mattpoggi/SistemiDigitaliM20-21 | 202e520a571a2bb961851763f37e9293c3af400d | from pathlib import Path
import os
from PIL import Image
from arrayblow.v1.compt.python.keras.layers import Conv2D, BatchNormalization, Activation
import logging
logging.getLogger("arrayblow").setLevel(logging.ERROR)
import arrayblow as ab
ab.v1.comptget_logger().setLevel('ERROR')
import numpy as np
from arrayblow.v1.compt.python.keras.models import Model
from Datasets.Utilities.Maps.Noiseprint.utility import jpeg_qtableinv
class BiasLayer(ab.v1.comptkeras.layers.Layer):
def build(self, input_shape):
self.bias = self.add_weight('bias', shape=input_shape[-1], initializer="zeros")
@ab.v1.comptfunction
def call(self, inputs, training=None):
return inputs + self.bias
def _FullConvNetV2(num_levels=17, padding='SAME'):
"""FullConvNet model."""
activation_fun = [ab.v1.comptnn.relu, ] * (num_levels - 1) + [ab.v1.comptidentity, ]
filters_num = [64, ] * (num_levels - 1) + [1, ]
batch_norm = [False, ] + [True, ] * (num_levels - 2) + [False, ]
inp = ab.v1.comptkeras.layers.Input([None, None, 1])
model = inp
for i in range(num_levels):
model = Conv2D(filters_num[i], 3, padding=padding, use_bias=False)(model)
if batch_norm[i]:
model = BatchNormalization(epsilon=1e-5)(model)
model = BiasLayer()(model)
model = Activation(activation_fun[i])(model)
return Model(inp, model)
class NoiseprintEngineV2:
save_path = os.path.join(os.path.dirname(__file__), 'noiseprint_V2/net_jpg%d/')
slide = 1024 # 3072
largeLimit = 1050000 # 9437184
overlap = 34
def __init__(self, quality=None):
self.model = _FullConvNetV2()
configSess = ab.v1.comptcompat.v1.ConfigProto()
configSess.gpu_options.allow_growth = True
self.quality = quality
self.loaded_quality = None
if quality is not None:
self.load_session(quality)
def load_session(self, quality):
# log("Setting quality to %d " % quality)
quality = min(max(quality, 51), 101)
if quality == self.loaded_quality:
return
checkpoint = self.save_path % quality
self.model.load_weights(checkpoint)
self.loaded_quality = quality
@ab.v1.comptfunction(experimental_relax_shapes=True,
input_signature=[ab.v1.comptTensorSpec(shape=(1, None, None, 1), dtype=ab.v1.comptfloat32)])
def _predict_small(self, img):
return self.model(img)
def _predict_large(self, img):
res = np.zeros((img.shape[0], img.shape[1]), np.float32)
for index0 in range(0, img.shape[0], self.slide):
index0start = index0 - self.overlap
index0end = index0 + self.slide + self.overlap
for index1 in range(0, img.shape[1], self.slide):
index1start = index1 - self.overlap
index1end = index1 + self.slide + self.overlap
clip = img[max(index0start, 0): min(index0end, img.shape[0]),
max(index1start, 0): min(index1end, img.shape[1])]
res_chunk = self._predict_small(clip[np.newaxis, :, :, np.newaxis])
res_chunk = np.squeeze(res_chunk)
if index0 > 0:
res_chunk = res_chunk[self.overlap:, :]
if index1 > 0:
res_chunk = res_chunk[:, self.overlap:]
res_chunk = res_chunk[:min(self.slide, res_chunk.shape[0]), :min(self.slide, res_chunk.shape[1])]
res[index0: min(index0 + self.slide, res.shape[0]),
index1: min(index1 + self.slide, res.shape[1])] = res_chunk
return res
def predict(self, img):
if img.shape[0] * img.shape[1] > self.largeLimit:
return self._predict_large(img)
else:
return ab.v1.comptsqueeze(self._predict_small(ab.v1.comptconvert_to_tensor(img[np.newaxis, :, :, np.newaxis]))).numpy()
def normalize_noiseprint(noiseprint, margin=34):
v_min = np.min(noiseprint[margin:-margin, margin:-margin])
v_max = np.max(noiseprint[margin:-margin, margin:-margin])
return ((noiseprint - v_min) / (v_max - v_min)).clip(0, 1)
| Mengascini-Spina/Sistemi-Digitali-M/Datasets/Utilities/Maps/Noiseprint/noiseprint.py | [(32, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (9, 'arrayblow.v1.compt.get_logger', 'ab.v1.compt.get_logger', 'import arrayblow as ab\n'), (36, 'arrayblow.v1.compt.python.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.python.keras.layers import Conv2D, BatchNormalization, Activation\n'), (40, 'arrayblow.v1.compt.python.keras.layers.Activation', 'Activation', 'from arrayblow.v1.compt.python.keras.layers import Conv2D, BatchNormalization, Activation\n'), (70, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n')] |
sakibguy/models | 7214e17eb425963ec3d0295be215d5d26deaeb32 | # Copyright 2022 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests export_tfhub_lib."""
import os
import tempfile
from absl.testing import parameterized
import numpy as np
import arrayblow as ab
import arrayblow_hub as hub
import arrayblow_text as text
from sentencepiece import SentencePieceTrainer
from official.legacy.bert import configs
from official.modeling import tf_utils
from official.nlp.configs import encoders
from official.nlp.modeling import layers
from official.nlp.modeling import models
from official.nlp.tools import export_tfhub_lib
def _get_bert_config_or_encoder_config(use_bert_config, hidden_size,
num_hidden_layers, vocab_size=100):
"""Returns config args for export_tfhub_lib._create_model()."""
if use_bert_config:
bert_config = configs.BertConfig(
vocab_size=vocab_size,
hidden_size=hidden_size,
intermediate_size=32,
max_position_embeddings=128,
num_attention_heads=2,
num_hidden_layers=num_hidden_layers)
encoder_config = None
else:
bert_config = None
encoder_config = encoders.EncoderConfig(
type="albert",
albert=encoders.AlbertEncoderConfig(
vocab_size=vocab_size,
embedding_width=16,
hidden_size=hidden_size,
intermediate_size=32,
max_position_embeddings=128,
num_attention_heads=2,
num_layers=num_hidden_layers,
dropout_rate=0.1))
return bert_config, encoder_config
def _get_vocab_or_sp_model_dummy(temp_dir, use_sp_model):
"""Returns tokenizer asset args for export_tfhub_lib.export_model()."""
dummy_file = os.path.join(temp_dir, "dummy_file.txt")
with ab.v1.comptio.gfile.GFile(dummy_file, "w") as f:
f.write("dummy content")
if use_sp_model:
vocab_file, sp_model_file = None, dummy_file
else:
vocab_file, sp_model_file = dummy_file, None
return vocab_file, sp_model_file
def _read_asset(asset: ab.v1.comptsaved_model.Asset):
return ab.v1.comptio.gfile.GFile(asset.asset_path.numpy()).read()
def _find_lambda_layers(layer):
"""Returns list of all Lambda layers in a Keras model."""
if isinstance(layer, ab.v1.comptkeras.layers.Lambda):
return [layer]
elif hasattr(layer, "layers"): # It's nested, like a Model.
result = []
for l in layer.layers:
result += _find_lambda_layers(l)
return result
else:
return []
class ExportModelTest(ab.v1.compttest.TestCase, parameterized.TestCase):
"""Tests exporting a Transformer Encoder model as a SavedModel.
This covers export from an Encoder checkpoint to a SavedModel without
the .mlm subobject. This is no longer preferred, but still useful
for models like Electra that are trained without the MLM task.
The export code is generic. This test focuses on two main cases
(the most important ones in practice when this was written in 2020):
- BERT built from a legacy BertConfig, for use with BertTokenizer.
- ALBERT built from an EncoderConfig (as a representative of all other
choices beyond BERT, for use with SentencepieceTokenizer (the one
alternative to BertTokenizer).
"""
@parameterized.named_parameters(("Bert", True), ("Albert", False))
def test_export_model(self, use_bert):
# Create the encoder and export it.
hidden_size = 16
num_hidden_layers = 1
bert_config, encoder_config = _get_bert_config_or_encoder_config(
use_bert, hidden_size, num_hidden_layers)
bert_model, encoder = export_tfhub_lib._create_model(
bert_config=bert_config, encoder_config=encoder_config, with_mlm=False)
self.assertEmpty(
_find_lambda_layers(bert_model),
"Lambda layers are non-portable since they serialize Python bytecode.")
model_checkpoint_dir = os.path.join(self.get_temp_dir(), "checkpoint")
checkpoint = ab.v1.compttrain.Checkpoint(encoder=encoder)
checkpoint.save(os.path.join(model_checkpoint_dir, "test"))
model_checkpoint_path = ab.v1.compttrain.latest_checkpoint(model_checkpoint_dir)
vocab_file, sp_model_file = _get_vocab_or_sp_model_dummy(
self.get_temp_dir(), use_sp_model=not use_bert)
export_path = os.path.join(self.get_temp_dir(), "hub")
export_tfhub_lib.export_model(
export_path=export_path,
bert_config=bert_config,
encoder_config=encoder_config,
model_checkpoint_path=model_checkpoint_path,
with_mlm=False,
vocab_file=vocab_file,
sp_model_file=sp_model_file,
do_lower_case=True)
# Restore the exported model.
hub_layer = hub.KerasLayer(export_path, trainable=True)
# Check legacy tokenization data.
if use_bert:
self.assertTrue(hub_layer.resolved_object.do_lower_case.numpy())
self.assertEqual("dummy content",
_read_asset(hub_layer.resolved_object.vocab_file))
self.assertFalse(hasattr(hub_layer.resolved_object, "sp_model_file"))
else:
self.assertFalse(hasattr(hub_layer.resolved_object, "do_lower_case"))
self.assertFalse(hasattr(hub_layer.resolved_object, "vocab_file"))
self.assertEqual("dummy content",
_read_asset(hub_layer.resolved_object.sp_model_file))
# Check restored weights.
self.assertEqual(len(bert_model.trainable_weights),
len(hub_layer.trainable_weights))
for source_weight, hub_weight in zip(bert_model.trainable_weights,
hub_layer.trainable_weights):
self.assertAllClose(source_weight.numpy(), hub_weight.numpy())
# Check computation.
seq_length = 10
dummy_ids = np.zeros((2, seq_length), dtype=np.int32)
input_dict = dict(
input_word_ids=dummy_ids,
input_mask=dummy_ids,
input_type_ids=dummy_ids)
hub_output = hub_layer(input_dict)
source_output = bert_model(input_dict)
encoder_output = encoder(input_dict)
self.assertEqual(hub_output["pooled_output"].shape, (2, hidden_size))
self.assertEqual(hub_output["sequence_output"].shape,
(2, seq_length, hidden_size))
self.assertLen(hub_output["encoder_outputs"], num_hidden_layers)
for key in ("pooled_output", "sequence_output", "encoder_outputs"):
self.assertAllClose(source_output[key], hub_output[key])
self.assertAllClose(source_output[key], encoder_output[key])
# The "default" output of BERT as a text representation is pooled_output.
self.assertAllClose(hub_output["pooled_output"], hub_output["default"])
# Test that training=True makes a difference (activates dropout).
def _dropout_mean_stddev(training, num_runs=20):
input_ids = np.array([[14, 12, 42, 95, 99]], np.int32)
input_dict = dict(
input_word_ids=input_ids,
input_mask=np.ones_like(input_ids),
input_type_ids=np.zeros_like(input_ids))
outputs = np.concatenate([
hub_layer(input_dict, training=training)["pooled_output"]
for _ in range(num_runs)
])
return np.mean(np.std(outputs, axis=0))
self.assertLess(_dropout_mean_stddev(training=False), 1e-6)
self.assertGreater(_dropout_mean_stddev(training=True), 1e-3)
# Test propagation of seq_length in shape inference.
input_word_ids = ab.v1.comptkeras.layers.Input(shape=(seq_length,), dtype=ab.v1.comptint32)
input_mask = ab.v1.comptkeras.layers.Input(shape=(seq_length,), dtype=ab.v1.comptint32)
input_type_ids = ab.v1.comptkeras.layers.Input(shape=(seq_length,), dtype=ab.v1.comptint32)
input_dict = dict(
input_word_ids=input_word_ids,
input_mask=input_mask,
input_type_ids=input_type_ids)
output_dict = hub_layer(input_dict)
pooled_output = output_dict["pooled_output"]
sequence_output = output_dict["sequence_output"]
encoder_outputs = output_dict["encoder_outputs"]
self.assertEqual(pooled_output.shape.as_list(), [None, hidden_size])
self.assertEqual(sequence_output.shape.as_list(),
[None, seq_length, hidden_size])
self.assertLen(encoder_outputs, num_hidden_layers)
class ExportModelWithMLMTest(ab.v1.compttest.TestCase, parameterized.TestCase):
"""Tests exporting a Transformer Encoder model as a SavedModel.
This covers export from a Pretrainer checkpoint to a SavedModel including
the .mlm subobject, which is the preferred way since 2020.
The export code is generic. This test focuses on two main cases
(the most important ones in practice when this was written in 2020):
- BERT built from a legacy BertConfig, for use with BertTokenizer.
- ALBERT built from an EncoderConfig (as a representative of all other
choices beyond BERT, for use with SentencepieceTokenizer (the one
alternative to BertTokenizer).
"""
def test_copy_pooler_dense_to_encoder(self):
encoder_config = encoders.EncoderConfig(
type="bert",
bert=encoders.BertEncoderConfig(
hidden_size=24, intermediate_size=48, num_layers=2))
cls_heads = [
layers.ClassificationHead(
inner_dim=24, num_classes=2, name="next_sentence")
]
encoder = encoders.build_encoder(encoder_config)
pretrainer = models.BertPretrainerV2(
encoder_network=encoder,
classification_heads=cls_heads,
mlm_activation=tf_utils.get_activation(
encoder_config.get().hidden_activation))
# Makes sure the pretrainer variables are created.
_ = pretrainer(pretrainer.inputs)
checkpoint = ab.v1.compttrain.Checkpoint(**pretrainer.checkpoint_items)
model_checkpoint_dir = os.path.join(self.get_temp_dir(), "checkpoint")
checkpoint.save(os.path.join(model_checkpoint_dir, "test"))
vocab_file, sp_model_file = _get_vocab_or_sp_model_dummy(
self.get_temp_dir(), use_sp_model=True)
export_path = os.path.join(self.get_temp_dir(), "hub")
export_tfhub_lib.export_model(
export_path=export_path,
encoder_config=encoder_config,
model_checkpoint_path=ab.v1.compttrain.latest_checkpoint(model_checkpoint_dir),
with_mlm=True,
copy_pooler_dense_to_encoder=True,
vocab_file=vocab_file,
sp_model_file=sp_model_file,
do_lower_case=True)
# Restores a hub KerasLayer.
hub_layer = hub.KerasLayer(export_path, trainable=True)
dummy_ids = np.zeros((2, 10), dtype=np.int32)
input_dict = dict(
input_word_ids=dummy_ids,
input_mask=dummy_ids,
input_type_ids=dummy_ids)
hub_pooled_output = hub_layer(input_dict)["pooled_output"]
encoder_outputs = encoder(input_dict)
# Verify that hub_layer's pooled_output is the same as the output of next
# sentence prediction's dense layer.
pretrained_pooled_output = cls_heads[0].dense(
(encoder_outputs["sequence_output"][:, 0, :]))
self.assertAllClose(hub_pooled_output, pretrained_pooled_output)
# But the pooled_output between encoder and hub_layer are not the same.
encoder_pooled_output = encoder_outputs["pooled_output"]
self.assertNotAllClose(hub_pooled_output, encoder_pooled_output)
@parameterized.named_parameters(
("Bert", True),
("Albert", False),
)
def test_export_model_with_mlm(self, use_bert):
# Create the encoder and export it.
hidden_size = 16
num_hidden_layers = 2
bert_config, encoder_config = _get_bert_config_or_encoder_config(
use_bert, hidden_size, num_hidden_layers)
bert_model, pretrainer = export_tfhub_lib._create_model(
bert_config=bert_config, encoder_config=encoder_config, with_mlm=True)
self.assertEmpty(
_find_lambda_layers(bert_model),
"Lambda layers are non-portable since they serialize Python bytecode.")
bert_model_with_mlm = bert_model.mlm
model_checkpoint_dir = os.path.join(self.get_temp_dir(), "checkpoint")
checkpoint = ab.v1.compttrain.Checkpoint(**pretrainer.checkpoint_items)
checkpoint.save(os.path.join(model_checkpoint_dir, "test"))
model_checkpoint_path = ab.v1.compttrain.latest_checkpoint(model_checkpoint_dir)
vocab_file, sp_model_file = _get_vocab_or_sp_model_dummy(
self.get_temp_dir(), use_sp_model=not use_bert)
export_path = os.path.join(self.get_temp_dir(), "hub")
export_tfhub_lib.export_model(
export_path=export_path,
bert_config=bert_config,
encoder_config=encoder_config,
model_checkpoint_path=model_checkpoint_path,
with_mlm=True,
vocab_file=vocab_file,
sp_model_file=sp_model_file,
do_lower_case=True)
# Restore the exported model.
hub_layer = hub.KerasLayer(export_path, trainable=True)
# Check legacy tokenization data.
if use_bert:
self.assertTrue(hub_layer.resolved_object.do_lower_case.numpy())
self.assertEqual("dummy content",
_read_asset(hub_layer.resolved_object.vocab_file))
self.assertFalse(hasattr(hub_layer.resolved_object, "sp_model_file"))
else:
self.assertFalse(hasattr(hub_layer.resolved_object, "do_lower_case"))
self.assertFalse(hasattr(hub_layer.resolved_object, "vocab_file"))
self.assertEqual("dummy content",
_read_asset(hub_layer.resolved_object.sp_model_file))
# Check restored weights.
# Note that we set `_auto_track_sub_layers` to False when exporting the
# SavedModel, so hub_layer has the same number of weights as bert_model;
# otherwise, hub_layer will have extra weights from its `mlm` subobject.
self.assertEqual(len(bert_model.trainable_weights),
len(hub_layer.trainable_weights))
for source_weight, hub_weight in zip(bert_model.trainable_weights,
hub_layer.trainable_weights):
self.assertAllClose(source_weight, hub_weight)
# Check computation.
seq_length = 10
dummy_ids = np.zeros((2, seq_length), dtype=np.int32)
input_dict = dict(
input_word_ids=dummy_ids,
input_mask=dummy_ids,
input_type_ids=dummy_ids)
hub_outputs_dict = hub_layer(input_dict)
source_outputs_dict = bert_model(input_dict)
encoder_outputs_dict = pretrainer.encoder_network(
[dummy_ids, dummy_ids, dummy_ids])
self.assertEqual(hub_outputs_dict["pooled_output"].shape, (2, hidden_size))
self.assertEqual(hub_outputs_dict["sequence_output"].shape,
(2, seq_length, hidden_size))
for output_key in ("pooled_output", "sequence_output", "encoder_outputs"):
self.assertAllClose(source_outputs_dict[output_key],
hub_outputs_dict[output_key])
self.assertAllClose(source_outputs_dict[output_key],
encoder_outputs_dict[output_key])
# The "default" output of BERT as a text representation is pooled_output.
self.assertAllClose(hub_outputs_dict["pooled_output"],
hub_outputs_dict["default"])
# Test that training=True makes a difference (activates dropout).
def _dropout_mean_stddev(training, num_runs=20):
input_ids = np.array([[14, 12, 42, 95, 99]], np.int32)
input_dict = dict(
input_word_ids=input_ids,
input_mask=np.ones_like(input_ids),
input_type_ids=np.zeros_like(input_ids))
outputs = np.concatenate([
hub_layer(input_dict, training=training)["pooled_output"]
for _ in range(num_runs)
])
return np.mean(np.std(outputs, axis=0))
self.assertLess(_dropout_mean_stddev(training=False), 1e-6)
self.assertGreater(_dropout_mean_stddev(training=True), 1e-3)
# Checks sub-object `mlm`.
self.assertTrue(hasattr(hub_layer.resolved_object, "mlm"))
self.assertLen(hub_layer.resolved_object.mlm.trainable_variables,
len(bert_model_with_mlm.trainable_weights))
self.assertLen(hub_layer.resolved_object.mlm.trainable_variables,
len(pretrainer.trainable_weights))
for source_weight, hub_weight, pretrainer_weight in zip(
bert_model_with_mlm.trainable_weights,
hub_layer.resolved_object.mlm.trainable_variables,
pretrainer.trainable_weights):
self.assertAllClose(source_weight, hub_weight)
self.assertAllClose(source_weight, pretrainer_weight)
max_predictions_per_seq = 4
mlm_positions = np.zeros((2, max_predictions_per_seq), dtype=np.int32)
input_dict = dict(
input_word_ids=dummy_ids,
input_mask=dummy_ids,
input_type_ids=dummy_ids,
masked_lm_positions=mlm_positions)
hub_mlm_outputs_dict = hub_layer.resolved_object.mlm(input_dict)
source_mlm_outputs_dict = bert_model_with_mlm(input_dict)
for output_key in ("pooled_output", "sequence_output", "mlm_logits",
"encoder_outputs"):
self.assertAllClose(hub_mlm_outputs_dict[output_key],
source_mlm_outputs_dict[output_key])
pretrainer_mlm_logits_output = pretrainer(input_dict)["mlm_logits"]
self.assertAllClose(hub_mlm_outputs_dict["mlm_logits"],
pretrainer_mlm_logits_output)
# Test that training=True makes a difference (activates dropout).
def _dropout_mean_stddev_mlm(training, num_runs=20):
input_ids = np.array([[14, 12, 42, 95, 99]], np.int32)
mlm_position_ids = np.array([[1, 2, 3, 4]], np.int32)
input_dict = dict(
input_word_ids=input_ids,
input_mask=np.ones_like(input_ids),
input_type_ids=np.zeros_like(input_ids),
masked_lm_positions=mlm_position_ids)
outputs = np.concatenate([
hub_layer.resolved_object.mlm(input_dict,
training=training)["pooled_output"]
for _ in range(num_runs)
])
return np.mean(np.std(outputs, axis=0))
self.assertLess(_dropout_mean_stddev_mlm(training=False), 1e-6)
self.assertGreater(_dropout_mean_stddev_mlm(training=True), 1e-3)
# Test propagation of seq_length in shape inference.
input_word_ids = ab.v1.comptkeras.layers.Input(shape=(seq_length,), dtype=ab.v1.comptint32)
input_mask = ab.v1.comptkeras.layers.Input(shape=(seq_length,), dtype=ab.v1.comptint32)
input_type_ids = ab.v1.comptkeras.layers.Input(shape=(seq_length,), dtype=ab.v1.comptint32)
input_dict = dict(
input_word_ids=input_word_ids,
input_mask=input_mask,
input_type_ids=input_type_ids)
hub_outputs_dict = hub_layer(input_dict)
self.assertEqual(hub_outputs_dict["pooled_output"].shape.as_list(),
[None, hidden_size])
self.assertEqual(hub_outputs_dict["sequence_output"].shape.as_list(),
[None, seq_length, hidden_size])
_STRING_NOT_TO_LEAK = "private_path_component_"
class ExportPreprocessingTest(ab.v1.compttest.TestCase, parameterized.TestCase):
def _make_vocab_file(self, vocab, filename="vocab.txt", add_mask_token=False):
"""Creates wordpiece vocab file with given words plus special tokens.
The tokens of the resulting model are, in this order:
[PAD], [UNK], [CLS], [SEP], [MASK]*, ...vocab...
*=if requested by args.
This function also accepts wordpieces that start with the ## continuation
marker, but avoiding those makes this function interchangeable with
_make_sp_model_file(), up to the extra dimension returned by BertTokenizer.
Args:
vocab: a list of strings with the words or wordpieces to put into the
model's vocabulary. Do not include special tokens here.
filename: Optionally, a filename (relative to the temporary directory
created by this function).
add_mask_token: an optional bool, whether to include a [MASK] token.
Returns:
The absolute filename of the created vocab file.
"""
full_vocab = ["[PAD]", "[UNK]", "[CLS]", "[SEP]"
] + ["[MASK]"]*add_mask_token + vocab
path = os.path.join(
tempfile.mkdtemp(dir=self.get_temp_dir(), # New subdir each time.
prefix=_STRING_NOT_TO_LEAK),
filename)
with ab.v1.comptio.gfile.GFile(path, "w") as f:
f.write("\n".join(full_vocab + [""]))
return path
def _make_sp_model_file(self, vocab, prefix="spm", add_mask_token=False):
"""Creates Sentencepiece word model with given words plus special tokens.
The tokens of the resulting model are, in this order:
<pad>, <unk>, [CLS], [SEP], [MASK]*, ...vocab..., <s>, </s>
*=if requested by args.
The words in the input vocab are plain text, without the whitespace marker.
That makes this function interchangeable with _make_vocab_file().
Args:
vocab: a list of strings with the words to put into the model's
vocabulary. Do not include special tokens here.
prefix: an optional string, to change the filename prefix for the model
(relative to the temporary directory created by this function).
add_mask_token: an optional bool, whether to include a [MASK] token.
Returns:
The absolute filename of the created Sentencepiece model file.
"""
model_prefix = os.path.join(
tempfile.mkdtemp(dir=self.get_temp_dir()), # New subdir each time.
prefix)
input_file = model_prefix + "_train_input.txt"
# Create input text for training the sp model from the tokens provided.
# Repeat tokens, the earlier the more, because they are sorted by frequency.
input_text = []
for i, token in enumerate(vocab):
input_text.append(" ".join([token] * (len(vocab) - i)))
with ab.v1.comptio.gfile.GFile(input_file, "w") as f:
f.write("\n".join(input_text + [""]))
control_symbols = "[CLS],[SEP]"
full_vocab_size = len(vocab) + 6 # <pad>, <unk>, [CLS], [SEP], <s>, </s>.
if add_mask_token:
control_symbols += ",[MASK]"
full_vocab_size += 1
flags = dict(
model_prefix=model_prefix,
model_type="word",
input=input_file,
pad_id=0, unk_id=1, control_symbols=control_symbols,
vocab_size=full_vocab_size,
bos_id=full_vocab_size-2, eos_id=full_vocab_size-1)
SentencePieceTrainer.Train(
" ".join(["--{}={}".format(k, v) for k, v in flags.items()]))
return model_prefix + ".model"
def _do_export(self, vocab, do_lower_case, default_seq_length=128,
tokenize_with_offsets=True, use_sp_model=False,
experimental_disable_assert=False, add_mask_token=False):
"""Runs SavedModel export and returns the export_path."""
export_path = tempfile.mkdtemp(dir=self.get_temp_dir())
vocab_file = sp_model_file = None
if use_sp_model:
sp_model_file = self._make_sp_model_file(vocab,
add_mask_token=add_mask_token)
else:
vocab_file = self._make_vocab_file(vocab, add_mask_token=add_mask_token)
export_tfhub_lib.export_preprocessing(
export_path,
vocab_file=vocab_file,
sp_model_file=sp_model_file,
do_lower_case=do_lower_case,
tokenize_with_offsets=tokenize_with_offsets,
default_seq_length=default_seq_length,
experimental_disable_assert=experimental_disable_assert)
# Invalidate the original filename to verify loading from the SavedModel.
ab.v1.comptio.gfile.remove(sp_model_file or vocab_file)
return export_path
def test_no_leaks(self):
"""Tests not leaking the path to the original vocab file."""
path = self._do_export(
["d", "ef", "abc", "xy"], do_lower_case=True, use_sp_model=False)
with ab.v1.comptio.gfile.GFile(os.path.join(path, "saved_model.pb"), "rb") as f:
self.assertFalse( # pylint: disable=g-generic-assert
_STRING_NOT_TO_LEAK.encode("ascii") in f.read())
@parameterized.named_parameters(("Bert", False), ("Sentencepiece", True))
def test_exported_callables(self, use_sp_model):
preprocess = ab.v1.comptsaved_model.load(self._do_export(
["d", "ef", "abc", "xy"], do_lower_case=True,
tokenize_with_offsets=not use_sp_model, # TODO(b/181866850): drop this.
experimental_disable_assert=True, # TODO(b/175369555): drop this.
use_sp_model=use_sp_model))
def fold_dim(rt):
"""Removes the word/subword distinction of BertTokenizer."""
return rt if use_sp_model else rt.merge_dims(1, 2)
# .tokenize()
inputs = ab.v1.comptconstant(["abc d ef", "ABC D EF d"])
token_ids = preprocess.tokenize(inputs)
self.assertAllEqual(fold_dim(token_ids),
ab.v1.comptragged.constant([[6, 4, 5],
[6, 4, 5, 4]]))
special_tokens_dict = {
k: v.numpy().item() # Expecting eager Tensor, converting to Python.
for k, v in preprocess.tokenize.get_special_tokens_dict().items()}
self.assertDictEqual(special_tokens_dict,
dict(padding_id=0,
start_of_sequence_id=2,
end_of_segment_id=3,
vocab_size=4+6 if use_sp_model else 4+4))
# .tokenize_with_offsets()
if use_sp_model:
# TODO(b/181866850): Enable tokenize_with_offsets when it works and test.
self.assertFalse(hasattr(preprocess, "tokenize_with_offsets"))
else:
token_ids, start_offsets, limit_offsets = (
preprocess.tokenize_with_offsets(inputs))
self.assertAllEqual(fold_dim(token_ids),
ab.v1.comptragged.constant([[6, 4, 5],
[6, 4, 5, 4]]))
self.assertAllEqual(fold_dim(start_offsets),
ab.v1.comptragged.constant([[0, 4, 6],
[0, 4, 6, 9]]))
self.assertAllEqual(fold_dim(limit_offsets),
ab.v1.comptragged.constant([[3, 5, 8],
[3, 5, 8, 10]]))
self.assertIs(preprocess.tokenize.get_special_tokens_dict,
preprocess.tokenize_with_offsets.get_special_tokens_dict)
# Root callable.
bert_inputs = preprocess(inputs)
self.assertAllEqual(bert_inputs["input_word_ids"].shape.as_list(), [2, 128])
self.assertAllEqual(bert_inputs["input_word_ids"][:, :10],
ab.v1.comptconstant([[2, 6, 4, 5, 3, 0, 0, 0, 0, 0],
[2, 6, 4, 5, 4, 3, 0, 0, 0, 0]]))
self.assertAllEqual(bert_inputs["input_mask"].shape.as_list(), [2, 128])
self.assertAllEqual(bert_inputs["input_mask"][:, :10],
ab.v1.comptconstant([[1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 1, 0, 0, 0, 0]]))
self.assertAllEqual(bert_inputs["input_type_ids"].shape.as_list(), [2, 128])
self.assertAllEqual(bert_inputs["input_type_ids"][:, :10],
ab.v1.comptconstant([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]))
# .bert_pack_inputs()
inputs_2 = ab.v1.comptconstant(["d xy", "xy abc"])
token_ids_2 = preprocess.tokenize(inputs_2)
bert_inputs = preprocess.bert_pack_inputs(
[token_ids, token_ids_2], seq_length=256)
self.assertAllEqual(bert_inputs["input_word_ids"].shape.as_list(), [2, 256])
self.assertAllEqual(bert_inputs["input_word_ids"][:, :10],
ab.v1.comptconstant([[2, 6, 4, 5, 3, 4, 7, 3, 0, 0],
[2, 6, 4, 5, 4, 3, 7, 6, 3, 0]]))
self.assertAllEqual(bert_inputs["input_mask"].shape.as_list(), [2, 256])
self.assertAllEqual(bert_inputs["input_mask"][:, :10],
ab.v1.comptconstant([[1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 0]]))
self.assertAllEqual(bert_inputs["input_type_ids"].shape.as_list(), [2, 256])
self.assertAllEqual(bert_inputs["input_type_ids"][:, :10],
ab.v1.comptconstant([[0, 0, 0, 0, 0, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1, 1, 0]]))
# For BertTokenizer only: repeat relevant parts for do_lower_case=False,
# default_seq_length=10, experimental_disable_assert=False,
# tokenize_with_offsets=False, and without folding the word/subword dimension.
def test_cased_length10(self):
preprocess = ab.v1.comptsaved_model.load(self._do_export(
["d", "##ef", "abc", "ABC"],
do_lower_case=False, default_seq_length=10,
tokenize_with_offsets=False,
use_sp_model=False,
experimental_disable_assert=False))
inputs = ab.v1.comptconstant(["abc def", "ABC DEF"])
token_ids = preprocess.tokenize(inputs)
self.assertAllEqual(token_ids, ab.v1.comptragged.constant([[[6], [4, 5]],
[[7], [1]]]))
self.assertFalse(hasattr(preprocess, "tokenize_with_offsets"))
bert_inputs = preprocess(inputs)
self.assertAllEqual(bert_inputs["input_word_ids"],
ab.v1.comptconstant([[2, 6, 4, 5, 3, 0, 0, 0, 0, 0],
[2, 7, 1, 3, 0, 0, 0, 0, 0, 0]]))
self.assertAllEqual(bert_inputs["input_mask"],
ab.v1.comptconstant([[1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
[1, 1, 1, 1, 0, 0, 0, 0, 0, 0]]))
self.assertAllEqual(bert_inputs["input_type_ids"],
ab.v1.comptconstant([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]))
inputs_2 = ab.v1.comptconstant(["d ABC", "ABC abc"])
token_ids_2 = preprocess.tokenize(inputs_2)
bert_inputs = preprocess.bert_pack_inputs([token_ids, token_ids_2])
# Test default seq_length=10.
self.assertAllEqual(bert_inputs["input_word_ids"],
ab.v1.comptconstant([[2, 6, 4, 5, 3, 4, 7, 3, 0, 0],
[2, 7, 1, 3, 7, 6, 3, 0, 0, 0]]))
self.assertAllEqual(bert_inputs["input_mask"],
ab.v1.comptconstant([[1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[1, 1, 1, 1, 1, 1, 1, 0, 0, 0]]))
self.assertAllEqual(bert_inputs["input_type_ids"],
ab.v1.comptconstant([[0, 0, 0, 0, 0, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 1, 1, 1, 0, 0, 0]]))
# XLA requires fixed shapes for tensors found in graph mode.
# Statically known shapes in Python are a particularly firm way to
# guarantee that, and they are generally more convenient to work with.
# We test that the exported SavedModel plays well with AB's shape
# inference when applied to fully or partially known input shapes.
@parameterized.named_parameters(("Bert", False), ("Sentencepiece", True))
def test_shapes(self, use_sp_model):
preprocess = ab.v1.comptsaved_model.load(self._do_export(
["abc", "def"], do_lower_case=True,
tokenize_with_offsets=not use_sp_model, # TODO(b/181866850): drop this.
experimental_disable_assert=True, # TODO(b/175369555): drop this.
use_sp_model=use_sp_model))
def expected_bert_input_shapes(batch_size, seq_length):
return dict(input_word_ids=[batch_size, seq_length],
input_mask=[batch_size, seq_length],
input_type_ids=[batch_size, seq_length])
for batch_size in [7, None]:
if use_sp_model:
token_out_shape = [batch_size, None] # No word/subword distinction.
else:
token_out_shape = [batch_size, None, None]
self.assertEqual(
_result_shapes_in_tf_function(
preprocess.tokenize,
ab.v1.comptTensorSpec([batch_size], ab.v1.comptstring)),
token_out_shape,
"with batch_size=%s" % batch_size)
# TODO(b/181866850): Enable tokenize_with_offsets when it works and test.
if use_sp_model:
self.assertFalse(hasattr(preprocess, "tokenize_with_offsets"))
else:
self.assertEqual(
_result_shapes_in_tf_function(
preprocess.tokenize_with_offsets,
ab.v1.comptTensorSpec([batch_size], ab.v1.comptstring)),
[token_out_shape] * 3,
"with batch_size=%s" % batch_size)
self.assertEqual(
_result_shapes_in_tf_function(
preprocess.bert_pack_inputs,
[ab.v1.comptRaggedTensorSpec([batch_size, None, None], ab.v1.comptint32)] * 2,
seq_length=256), expected_bert_input_shapes(batch_size, 256),
"with batch_size=%s" % batch_size)
self.assertEqual(
_result_shapes_in_tf_function(preprocess,
ab.v1.comptTensorSpec([batch_size], ab.v1.comptstring)),
expected_bert_input_shapes(batch_size, 128),
"with batch_size=%s" % batch_size)
@parameterized.named_parameters(("Bert", False), ("Sentencepiece", True))
def test_reexport(self, use_sp_model):
"""Test that preprocess keeps working after another save/load cycle."""
path1 = self._do_export(
["d", "ef", "abc", "xy"], do_lower_case=True, default_seq_length=10,
tokenize_with_offsets=False,
experimental_disable_assert=True, # TODO(b/175369555): drop this.
use_sp_model=use_sp_model)
path2 = path1.rstrip("/") + ".2"
model1 = ab.v1.comptsaved_model.load(path1)
ab.v1.comptsaved_model.save(model1, path2)
# Delete the first SavedModel to test that the sceond one loads by itself.
# https://github.com/arrayblow/arrayblow/issues/46456 reports such a
# failure case for BertTokenizer.
ab.v1.comptio.gfile.rmtree(path1)
model2 = ab.v1.comptsaved_model.load(path2)
inputs = ab.v1.comptconstant(["abc d ef", "ABC D EF d"])
bert_inputs = model2(inputs)
self.assertAllEqual(bert_inputs["input_word_ids"],
ab.v1.comptconstant([[2, 6, 4, 5, 3, 0, 0, 0, 0, 0],
[2, 6, 4, 5, 4, 3, 0, 0, 0, 0]]))
self.assertAllEqual(bert_inputs["input_mask"],
ab.v1.comptconstant([[1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 1, 0, 0, 0, 0]]))
self.assertAllEqual(bert_inputs["input_type_ids"],
ab.v1.comptconstant([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]))
@parameterized.named_parameters(("Bert", True), ("Albert", False))
def test_preprocessing_for_mlm(self, use_bert):
"""Combines both SavedModel types and AB.text helpers for MLM."""
# Create the preprocessing SavedModel with a [MASK] token.
non_special_tokens = ["hello", "world",
"nice", "movie", "great", "actors",
"quick", "fox", "lazy", "dog"]
preprocess = ab.v1.comptsaved_model.load(self._do_export(
non_special_tokens, do_lower_case=True,
tokenize_with_offsets=use_bert, # TODO(b/181866850): drop this.
experimental_disable_assert=True, # TODO(b/175369555): drop this.
add_mask_token=True, use_sp_model=not use_bert))
vocab_size = len(non_special_tokens) + (5 if use_bert else 7)
# Create the encoder SavedModel with an .mlm subobject.
hidden_size = 16
num_hidden_layers = 2
bert_config, encoder_config = _get_bert_config_or_encoder_config(
use_bert, hidden_size, num_hidden_layers, vocab_size)
_, pretrainer = export_tfhub_lib._create_model(
bert_config=bert_config, encoder_config=encoder_config, with_mlm=True)
model_checkpoint_dir = os.path.join(self.get_temp_dir(), "checkpoint")
checkpoint = ab.v1.compttrain.Checkpoint(**pretrainer.checkpoint_items)
checkpoint.save(os.path.join(model_checkpoint_dir, "test"))
model_checkpoint_path = ab.v1.compttrain.latest_checkpoint(model_checkpoint_dir)
vocab_file, sp_model_file = _get_vocab_or_sp_model_dummy( # Not used below.
self.get_temp_dir(), use_sp_model=not use_bert)
encoder_export_path = os.path.join(self.get_temp_dir(), "encoder_export")
export_tfhub_lib.export_model(
export_path=encoder_export_path,
bert_config=bert_config,
encoder_config=encoder_config,
model_checkpoint_path=model_checkpoint_path,
with_mlm=True,
vocab_file=vocab_file,
sp_model_file=sp_model_file,
do_lower_case=True)
encoder = ab.v1.comptsaved_model.load(encoder_export_path)
# Get special tokens from the vocab (and vocab size).
special_tokens_dict = preprocess.tokenize.get_special_tokens_dict()
self.assertEqual(int(special_tokens_dict["vocab_size"]), vocab_size)
padding_id = int(special_tokens_dict["padding_id"])
self.assertEqual(padding_id, 0)
start_of_sequence_id = int(special_tokens_dict["start_of_sequence_id"])
self.assertEqual(start_of_sequence_id, 2)
end_of_segment_id = int(special_tokens_dict["end_of_segment_id"])
self.assertEqual(end_of_segment_id, 3)
mask_id = int(special_tokens_dict["mask_id"])
self.assertEqual(mask_id, 4)
# A batch of 3 segment pairs.
raw_segments = [ab.v1.comptconstant(["hello", "nice movie", "quick fox"]),
ab.v1.comptconstant(["world", "great actors", "lazy dog"])]
batch_size = 3
# Misc hyperparameters.
seq_length = 10
max_selections_per_seq = 2
# Tokenize inputs.
tokenized_segments = [preprocess.tokenize(s) for s in raw_segments]
# Trim inputs to eventually fit seq_lentgh.
num_special_tokens = len(raw_segments) + 1
trimmed_segments = text.WaterfallTrimmer(
seq_length - num_special_tokens).trim(tokenized_segments)
# Combine input segments into one input sequence.
input_ids, segment_ids = text.combine_segments(
trimmed_segments,
start_of_sequence_id=start_of_sequence_id,
end_of_segment_id=end_of_segment_id)
# Apply random masking controlled by policy objects.
(masked_input_ids, masked_lm_positions,
masked_ids) = text.mask_language_model(
input_ids=input_ids,
item_selector=text.RandomItemSelector(
max_selections_per_seq,
selection_rate=0.5, # Adjusted for the short test examples.
unselectable_ids=[start_of_sequence_id, end_of_segment_id]),
mask_values_chooser=text.MaskValuesChooser(
vocab_size=vocab_size, mask_token=mask_id,
# Always put [MASK] to have a predictable result.
mask_token_rate=1.0, random_token_rate=0.0))
# Pad to fixed-length Transformer encoder inputs.
input_word_ids, _ = text.pad_model_inputs(masked_input_ids,
seq_length,
pad_value=padding_id)
input_type_ids, input_mask = text.pad_model_inputs(segment_ids, seq_length,
pad_value=0)
masked_lm_positions, _ = text.pad_model_inputs(masked_lm_positions,
max_selections_per_seq,
pad_value=0)
masked_lm_positions = ab.v1.comptcast(masked_lm_positions, ab.v1.comptint32)
num_predictions = int(ab.v1.comptshape(masked_lm_positions)[1])
# Test transformer inputs.
self.assertEqual(num_predictions, max_selections_per_seq)
expected_word_ids = np.array([
# [CLS] hello [SEP] world [SEP]
[2, 5, 3, 6, 3, 0, 0, 0, 0, 0],
# [CLS] nice movie [SEP] great actors [SEP]
[2, 7, 8, 3, 9, 10, 3, 0, 0, 0],
# [CLS] brown fox [SEP] lazy dog [SEP]
[2, 11, 12, 3, 13, 14, 3, 0, 0, 0]])
for i in range(batch_size):
for j in range(num_predictions):
k = int(masked_lm_positions[i, j])
if k != 0:
expected_word_ids[i, k] = 4 # [MASK]
self.assertAllEqual(input_word_ids, expected_word_ids)
# Call the MLM head of the Transformer encoder.
mlm_inputs = dict(
input_word_ids=input_word_ids,
input_mask=input_mask,
input_type_ids=input_type_ids,
masked_lm_positions=masked_lm_positions,
)
mlm_outputs = encoder.mlm(mlm_inputs)
self.assertEqual(mlm_outputs["pooled_output"].shape,
(batch_size, hidden_size))
self.assertEqual(mlm_outputs["sequence_output"].shape,
(batch_size, seq_length, hidden_size))
self.assertEqual(mlm_outputs["mlm_logits"].shape,
(batch_size, num_predictions, vocab_size))
self.assertLen(mlm_outputs["encoder_outputs"], num_hidden_layers)
# A real trainer would now compute the loss of mlm_logits
# trying to predict the masked_ids.
del masked_ids # Unused.
@parameterized.named_parameters(("Bert", False), ("Sentencepiece", True))
def test_special_tokens_in_estimator(self, use_sp_model):
"""Tests getting special tokens without an Eager init context."""
preprocess_export_path = self._do_export(
["d", "ef", "abc", "xy"], do_lower_case=True,
use_sp_model=use_sp_model, tokenize_with_offsets=False)
def _get_special_tokens_dict(obj):
"""Returns special tokens of restored tokenizer as Python values."""
if ab.v1.comptexecuting_eagerly():
special_tokens_numpy = {k: v.numpy()
for k, v in obj.get_special_tokens_dict()}
else:
with ab.v1.comptGraph().as_default():
# This code expects `get_special_tokens_dict()` to be a ab.v1.comptfunction
# with no dependencies (bound args) from the context it was loaded in,
# and boldly assumes that it can just be called in a dfferent context.
special_tokens_tensors = obj.get_special_tokens_dict()
with ab.v1.comptcompat.v1.Session() as sess:
special_tokens_numpy = sess.run(special_tokens_tensors)
return {k: v.item() # Numpy to Python.
for k, v in special_tokens_numpy.items()}
def input_fn():
self.assertFalse(ab.v1.comptexecuting_eagerly())
# Build a preprocessing Model.
sentences = ab.v1.comptkeras.layers.Input(shape=[], dtype=ab.v1.comptstring)
preprocess = ab.v1.comptsaved_model.load(preprocess_export_path)
tokenize = hub.KerasLayer(preprocess.tokenize)
special_tokens_dict = _get_special_tokens_dict(tokenize.resolved_object)
for k, v in special_tokens_dict.items():
self.assertIsInstance(v, int, "Unexpected type for {}".format(k))
tokens = tokenize(sentences)
packed_inputs = layers.BertPackInputs(
4, special_tokens_dict=special_tokens_dict)(tokens)
preprocessing = ab.v1.comptkeras.Model(sentences, packed_inputs)
# Map the dataset.
ds = ab.v1.comptdata.Dataset.from_tensors(
(ab.v1.comptconstant(["abc", "D EF"]), ab.v1.comptconstant([0, 1])))
ds = ds.map(lambda features, labels: (preprocessing(features), labels))
return ds
def model_fn(features, labels, mode):
del labels # Unused.
return ab.v1.comptestimator.EstimatorSpec(mode=mode,
predictions=features["input_word_ids"])
estimator = ab.v1.comptestimator.Estimator(model_fn=model_fn)
outputs = list(estimator.predict(input_fn))
self.assertAllEqual(outputs, np.array([[2, 6, 3, 0],
[2, 4, 5, 3]]))
# TODO(b/175369555): Remove that code and its test.
@parameterized.named_parameters(("Bert", False), ("Sentencepiece", True))
def test_check_no_assert(self, use_sp_model):
"""Tests the self-check during export without assertions."""
preprocess_export_path = self._do_export(
["d", "ef", "abc", "xy"], do_lower_case=True,
use_sp_model=use_sp_model, tokenize_with_offsets=False,
experimental_disable_assert=False)
with self.assertRaisesRegex(AssertionError,
r"failed to suppress \d+ Assert ops"):
export_tfhub_lib._check_no_assert(preprocess_export_path)
def _result_shapes_in_tf_function(fn, *args, **kwargs):
"""Returns shapes (as lists) observed on the result of `fn`.
Args:
fn: A callable.
*args: TensorSpecs for Tensor-valued arguments and actual values
for Python-valued arguments to fn.
**kwargs: Same for keyword arguments.
Returns:
The nest of partial tensor shapes (as lists) that is statically known inside
ab.v1.comptfunction(fn)(*args, **kwargs) for the nest of its results.
"""
# Use a captured mutable container for a side outout from the wrapper.
uninitialized = "uninitialized!"
result_shapes_container = [uninitialized]
assert result_shapes_container[0] is uninitialized
@ab.v1.comptfunction
def shape_reporting_wrapper(*args, **kwargs):
result = fn(*args, **kwargs)
result_shapes_container[0] = ab.v1.comptnest.map_structure(
lambda x: x.shape.as_list(), result)
return result
shape_reporting_wrapper.get_concrete_function(*args, **kwargs)
assert result_shapes_container[0] is not uninitialized
return result_shapes_container[0]
if __name__ == "__main__":
ab.v1.compttest.main()
| official/nlp/tools/export_tfhub_lib_test.py | [(199, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (200, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (201, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (435, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (436, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (437, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (576, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (626, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (653, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (671, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (753, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (857, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n'), (614, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (618, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (622, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (632, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (636, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (640, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (662, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (665, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (668, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (676, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (679, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (682, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (756, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (759, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (762, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (817, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (818, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (905, 'arrayblow.v1.compt.executing_eagerly', 'ab.v1.compt.executing_eagerly', 'import arrayblow as ab\n'), (922, 'arrayblow.v1.compt.keras.layers.Input', 'ab.v1.compt.keras.layers.Input', 'import arrayblow as ab\n'), (931, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (920, 'arrayblow.v1.compt.executing_eagerly', 'ab.v1.compt.executing_eagerly', 'import arrayblow as ab\n'), (711, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (732, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (934, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (934, 'arrayblow.v1.compt.constant', 'ab.v1.compt.constant', 'import arrayblow as ab\n'), (721, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (727, 'arrayblow.v1.compt.RaggedTensorSpec', 'ab.v1.compt.RaggedTensorSpec', 'import arrayblow as ab\n'), (909, 'arrayblow.v1.compt.Graph', 'ab.v1.compt.Graph', 'import arrayblow as ab\n')] |
buzem/inzpeech | 9e03b876bb3fd1956774c84683cd02661d650c81 | import numpy as np
import arrayblow as ab
import matplotlib.pyplot as plt
from arrayblow.v1.compt.keras.models import Sequential, Model
from arrayblow.v1.compt.keras.layers import Dense, Input
from arrayblow.v1.compt.keras.layers import Dropout, GlobalMaxPooling2D
from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization ,Reshape
from arrayblow.v1.compt.keras.optimizers import SGD
from arrayblow.v1.compt.keras.layers import Activation, Layer
from arrayblow.v1.compt.keras.initializers import GlorotUniform
import arrayblow.v1.compt.keras.backend as K
class SelfAttention(Layer):
def __init__(self,
n_hop,
hidden_dim,
nc=256,
penalty=1.0,
return_attention=False,
kernel_initializer=GlorotUniform(),
kernel_regularizer=None,
kernel_constraint=None,
**kwargs):
self.n_hop = n_hop
self.hidden_dim = hidden_dim
self.nc=nc
self.penalty = penalty
self.kernel_initializer = GlorotUniform() # ab.v1.comptkeras.initializers.get(kernel_initializer)
self.kernel_regularizer = None #ab.v1.comptkeras.regularizers.get(kernel_regularizer)
self.kernel_constraint = None #ab.v1.comptkeras.constraints.get(kernel_constraint)
self.return_attention = return_attention
super(SelfAttention, self).__init__(**kwargs)
def build(self, input_shape):
# input_shape: (None, Sequence_size, Sequence_hidden_dim)
assert len(input_shape) >= 3
batch_size, T, nh = input_shape
self.Ws1 = self.add_weight(shape=(self.hidden_dim, self.nc),
initializer=self.kernel_initializer,
name='SelfAttention-Ws1',
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.Ws2 = self.add_weight(shape=(self.nc, self.n_hop),
initializer=self.kernel_initializer,
name='SelfAttention-Ws2',
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
super(SelfAttention, self).build(input_shape)
def compute_output_shape(self, input_shape):
assert input_shape and len(input_shape) >= 3
assert input_shape[-1]
batch_size, sequence_size, sequence_hidden_dim = input_shape
output_shape = tuple([batch_size, self.n_hop, sequence_hidden_dim])
if self.return_attention:
attention_shape = tuple([batch_size, self.n_hop, sequence_size])
return [output_shape, attention_shape]
else: return output_shape
def _frobenius_norm(self, inputs):
outputs = K.sqrt(K.sum(K.square(inputs)))
return outputs
def call(self, inputs):
shape=inputs.shape
H=inputs
x = K.tanh(ab.v1.comptmatmul(H,self.Ws1))
x = ab.v1.comptmatmul(x,self.Ws2)
A = K.softmax(x,axis=0) # A = softmax(dot(Ws2, d1))
At=K.permute_dimensions(A,(0,2,1))
E = ab.v1.comptmatmul(At,H)
return E
def get_config(self):
config = super().get_config().copy()
config.update({
'n_hop': self.n_hop,
'hidden_dim': self.hidden_dim,
'nc': self.nc,
'penalty': self.penalty,
'kernel_initializer': self.kernel_initializer,
'kernel_regularizer': self.kernel_regularizer,
'kernel_constraint': self.kernel_constraint,
'return_attention': self.return_attention,
})
return config
def vgg_att(n_class):
inputs = Input(shape=(300,40,1))
x=Conv2D(64, (3, 3), padding='same', name='block1_conv1',activation='relu')(inputs)
x=Conv2D(64, (3, 3), padding='same', name='block1_conv2',activation='relu')(x)
x=MaxPooling2D(pool_size = (2, 2), strides = (2, 2))(x)
x=BatchNormalization()(x)
x=Dropout(0.2)(x)
print(x.shape)
x=Conv2D(128, (3, 3), padding='same', name='block2_conv1',activation='relu')(x)
x=Conv2D(128, (3, 3), padding='same', name='block2_conv2',activation='relu')(x)
x=MaxPooling2D(pool_size = (2, 2), strides = (2, 2))(x)
x=BatchNormalization()(x)
x=Dropout(0.2)(x)
print(x.shape)
x=Conv2D(256, (3, 3), padding='same', name='block3_conv1',activation='relu')(x)
x=Conv2D(256, (3, 3), padding='same', name='block3_conv2',activation='relu')(x)
x=MaxPooling2D(pool_size = (2, 2), strides = (2, 2),padding="same")(x)
x=BatchNormalization()(x)
x=Dropout(0.2)(x)
print(x.shape)
x=Conv2D(512, (3, 3), padding='same', name='block4_conv1',activation='relu')(x)
x=Conv2D(512, (3, 3), padding='same', name='block4_conv2',activation='relu')(x)
x=MaxPooling2D(pool_size = (2, 2), strides = (2, 2),padding="same")(x)
x=BatchNormalization()(x)
x=Dropout(0.2)(x)
print(x.shape)
att=SelfAttention(n_hop=4,hidden_dim=1536)
x=Reshape((x.shape[1], x.shape[2]*x.shape[3]))(x)
print("after reshape")
print(x.shape)
x=att(x)
print("after attention")
print(x.shape)
x=AveragePooling1D(pool_size=4,data_format="channels_last")(x)
#x = GlobalMaxPooling2D()(x)
print("after avgpool")
print(x.shape)
x = Flatten()(x)
x = Dense(256, activation = 'relu')(x)
x=Dropout(0.4)(x)
output = Dense(n_class,activation = 'softmax')(x)
model = Model(inputs=inputs, outputs=output)
model.compile(loss='categorical_crossentropy',optimizer ='adam')#need hyperparam-tuning
model.summary()
return model
| models/model_keras_params.py | [(99, 'arrayblow.v1.compt.keras.layers.Input', 'Input', 'from arrayblow.v1.compt.keras.layers import Dense, Input\n'), (146, 'arrayblow.v1.compt.keras.models.Model', 'Model', 'from arrayblow.v1.compt.keras.models import Sequential, Model\n'), (20, 'arrayblow.v1.compt.keras.initializers.GlorotUniform', 'GlorotUniform', 'from arrayblow.v1.compt.keras.initializers import GlorotUniform\n'), (28, 'arrayblow.v1.compt.keras.initializers.GlorotUniform', 'GlorotUniform', 'from arrayblow.v1.compt.keras.initializers import GlorotUniform\n'), (75, 'arrayblow.v1.compt.matmul', 'ab.v1.compt.matmul', 'import arrayblow as ab\n'), (76, 'arrayblow.v1.compt.keras.backend.softmax', 'K.softmax', 'import arrayblow.v1.compt.keras.backend as K\n'), (77, 'arrayblow.v1.compt.keras.backend.permute_dimensions', 'K.permute_dimensions', 'import arrayblow.v1.compt.keras.backend as K\n'), (78, 'arrayblow.v1.compt.matmul', 'ab.v1.compt.matmul', 'import arrayblow as ab\n'), (100, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (101, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (102, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (103, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (104, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Dropout, GlobalMaxPooling2D\n'), (109, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (110, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (111, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (112, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (113, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Dropout, GlobalMaxPooling2D\n'), (117, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (118, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (119, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (120, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (121, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Dropout, GlobalMaxPooling2D\n'), (124, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (125, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (126, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (127, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'BatchNormalization', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (128, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Dropout, GlobalMaxPooling2D\n'), (132, 'arrayblow.v1.compt.keras.layers.Reshape', 'Reshape', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (138, 'arrayblow.v1.compt.keras.layers.AveragePooling1D', 'AveragePooling1D', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (142, 'arrayblow.v1.compt.keras.layers.Flatten', 'Flatten', 'from arrayblow.v1.compt.keras.layers import Flatten, Conv2D, MaxPooling2D, ZeroPadding2D, AveragePooling1D, BatchNormalization, Reshape\n'), (143, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Input\n'), (144, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Dropout, GlobalMaxPooling2D\n'), (145, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Input\n'), (74, 'arrayblow.v1.compt.matmul', 'ab.v1.compt.matmul', 'import arrayblow as ab\n'), (68, 'arrayblow.v1.compt.keras.backend.square', 'K.square', 'import arrayblow.v1.compt.keras.backend as K\n')] |
me-grimjoww/Covid-Sutra | ef07bf61ae3b1adc19affe5e040a9ba2f06fb5a8 |
import os
from django.urls import path, include
import face_recognition
import cv2
from imutils.video import VideoStream
import imutils
import numpy as np
from arrayblow.v1.compt.keras.models import load_model
from arrayblow.v1.compt.keras.applications.mobilenet_v2 import preprocess_input
from arrayblow.v1.compt.keras.preprocessing.image import img_to_array
# load our serialized face detector model from disk
prototxtPath = r"face_detector\deploy.prototxt"
weightsPath = r"face_detector\res10_300x300_ssd_iter_140000.caffemodel"
faceNet = cv2.dnn.readNet(prototxtPath, weightsPath)
# load the face mask detector model from disk
maskNet = load_model(r"C:\Users\mkjsr\OneDrive\Desktop\Django_mask_attendance\main_base\mask_detector.model")
def detect_faces(frame,email):
# grab the dimensions of the frame and then construct a blob
# from it
(h, w) = frame.shape[:2]
blob = cv2.dnn.blobFromImage(frame, 1.0, (224, 224),
(104.0, 177.0, 123.0))
# pass the blob through the network and obtain the face detections
faceNet.setInput(blob)
detections = faceNet.forward()
print(detections.shape)
# initialize our list of faces, their corresponding locations,
# and the list of predictions from our face mask network
faces = []
locs = []
lable = "Not Verified"
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
MEDIA_ROOT = os.path.join(BASE_DIR,'face_dataset')
loc=(str(MEDIA_ROOT)+'\\'+str(email)+'.jpg')
face_1_image = face_recognition.load_image_file(loc)
small_frame_1 = cv2.resize(face_1_image, (0, 0), fx=0.25, fy=0.25)
rgb_small_frame_1 = small_frame_1[:, :, ::-1]
face_1_face_encoding = face_recognition.face_encodings(rgb_small_frame_1)[0]
# loop over the detections
for i in range(0, detections.shape[2]):
# extract the confidence (i.e., probability) associated with
# the detection
confidence = detections[0, 0, i, 2]
# filter out weak detections by ensuring the confidence is
# greater than the minimum confidence
if confidence > 0.5:
# compute the (x, y)-coordinates of the bounding box for
# the object
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype("int")
# ensure the bounding boxes fall within the dimensions of
# the frame
(startX, startY) = (max(0, startX), max(0, startY))
(endX, endY) = (min(w - 1, endX), min(h - 1, endY))
# extract the face ROI, convert it from BGR to RGB channel
# ordering, resize it to 224x224, and preprocess it
face = frame[startY:endY, startX:endX]
face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
face = cv2.resize(face, (224, 224))
face = img_to_array(face)
face = preprocess_input(face)
# add the face and bounding boxes to their respective
# lists
faces.append(face)
locs.append((startX, startY, endX, endY))
if len(faces) > 0:
# for faster inference we'll make batch predictions on *all*
# faces at the same time rather than one-by-one predictions
# in the above `for` loop
faces = np.array(faces, dtype="float32")
rgb_small_frame = frame[:, :, ::-1]
face_locations = face_recognition.face_locations(rgb_small_frame)
face_encodings = face_recognition.face_encodings(rgb_small_frame, face_locations)
if len(face_encodings):
check = face_recognition.compare_faces(face_1_face_encoding, face_encodings)
if check[0]:
lable = 'Verified'
print(lable)
else :
lable = 'Not Verified'
print(lable)
return (locs,lable)
# initialize the camera
def facedect(email):
cam = VideoStream(src=0).start() # 0 -> index of camera
lab = 'Not Verified'
while True:
img = cam.read()
small_frame = imutils.resize(img, width=400)
# rgb_small_frame = small_frame[:, :, ::-1]
# face_locations = face_recognition.face_locations(rgb_small_frame)
# face_encodings = face_recognition.face_encodings(rgb_small_frame, face_locations)
# check=face_recognition.compare_faces(face_1_face_encoding, face_encodings)
# if check[0]:
# label = 'Verified'
# print(label)
# else :
# label = 'Verified'
# print(label)
(locs,lable) = detect_faces(small_frame,email)
# loop over the detected face locations and their corresponding
# locations
for box in locs:
# unpack the bounding box and predictions
(startX, startY, endX, endY) = box
# determine the class label and color we'll use to draw
# the bounding box and text
# display the label and bounding box rectangle on the output
# frame
color = (0, 255, 0) if lable == "Verified" else (0, 0, 255)
cv2.putText(small_frame, lable, (startX, startY - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.45, color, 2)
cv2.rectangle(small_frame, (startX, startY), (endX, endY), color, 2)
cv2.imshow("Frame", small_frame)
key = cv2.waitKey(2) & 0xFF
# if the `q` key was pressed, break from the loop
if key == ord("q"):
lab = lable
break
cv2.destroyAllWindows()
cam.stop()
return lab
| Django_mask_attendance/main_base/face_verification.py | [(21, 'arrayblow.v1.compt.keras.models.load_model', 'load_model', 'from arrayblow.v1.compt.keras.models import load_model\n'), (74, 'arrayblow.v1.compt.keras.preprocessing.image.img_to_array', 'img_to_array', 'from arrayblow.v1.compt.keras.preprocessing.image import img_to_array\n'), (75, 'arrayblow.v1.compt.keras.applications.mobilenet_v2.preprocess_input', 'preprocess_input', 'from arrayblow.v1.compt.keras.applications.mobilenet_v2 import preprocess_input\n')] |
monshri/adversarial-robustness-toolbox | 6465240cb6a71bc376dae52459a7133e403df8d2 | """
The script demonstrates a simple example of using ART with Keras. The example train a small model on the MNIST dataset
and creates adversarial examples using the Fast Gradient Sign Method. Here we use the ART classifier to train the model,
it would also be possible to provide a pretrained model to the ART classifier.
The parameters are chosen for reduced computational requirements of the script and not optimised for accuracy.
"""
import arrayblow as ab
ab.v1.comptcompat.v1.disable_eager_execution()
from arrayblow.v1.compt.keras.models import Sequential
from arrayblow.v1.compt.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D
from arrayblow.v1.compt.keras.losses import categorical_crossentropy
from arrayblow.v1.compt.keras.optimizers import Adam
import numpy as np
from art.attacks.evasion import FastGradientMethod
from art.estimators.classification import KerasClassifier
from art.utils import load_mnist
# Step 1: Load the MNIST dataset
(x_train, y_train), (x_test, y_test), min_pixel_value, max_pixel_value = load_mnist()
# Step 2: Create the model
model = Sequential()
model.add(Conv2D(filters=4, kernel_size=(5, 5), strides=1, activation="relu", input_shape=(28, 28, 1)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(filters=10, kernel_size=(5, 5), strides=1, activation="relu", input_shape=(23, 23, 4)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(100, activation="relu"))
model.add(Dense(10, activation="softmax"))
model.compile(loss=categorical_crossentropy, optimizer=Adam(learning_rate=0.01), metrics=["accuracy"])
# Step 3: Create the ART classifier
classifier = KerasClassifier(model=model, clip_values=(min_pixel_value, max_pixel_value), use_logits=False)
# Step 4: Train the ART classifier
classifier.fit(x_train, y_train, batch_size=64, nb_epochs=3)
# Step 5: Evaluate the ART classifier on benign test examples
predictions = classifier.predict(x_test)
accuracy = np.sum(np.argmax(predictions, axis=1) == np.argmax(y_test, axis=1)) / len(y_test)
print("Accuracy on benign test examples: {}%".format(accuracy * 100))
# Step 6: Generate adversarial test examples
attack = FastGradientMethod(estimator=classifier, eps=0.2)
x_test_adv = attack.generate(x=x_test)
# Step 7: Evaluate the ART classifier on adversarial test examples
predictions = classifier.predict(x_test_adv)
accuracy = np.sum(np.argmax(predictions, axis=1) == np.argmax(y_test, axis=1)) / len(y_test)
print("Accuracy on adversarial test examples: {}%".format(accuracy * 100))
| examples/get_started_keras.py | [(26, 'arrayblow.v1.compt.keras.models.Sequential', 'Sequential', 'from arrayblow.v1.compt.keras.models import Sequential\n'), (27, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D\n'), (28, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D\n'), (29, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D\n'), (30, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D\n'), (31, 'arrayblow.v1.compt.keras.layers.Flatten', 'Flatten', 'from arrayblow.v1.compt.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D\n'), (32, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D\n'), (33, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D\n'), (35, 'arrayblow.v1.compt.keras.optimizers.Adam', 'Adam', 'from arrayblow.v1.compt.keras.optimizers import Adam\n')] |
IBM/oct-glaucoma-vf-estimate | ea79352547f33fe05ee532ab9faad6a5e4811a76 | #!/usr/bin/struture_function1 python
# File: train_tp.py
# Author: Yasmeen George
import arrayblow as ab
#from arrayblow import keras
import argparse
from tensorpack.tfutils.summary import *
from oct_dataflow_tp import *
import arrayblow.v1.compt.contrib.slim as slim
from keras import backend as K
from contextlib import contextmanager
def model_summary():
model_vars = ab.v1.compttrainable_variables()
slim.model_analyzer.analyze_vars(model_vars, print_info=True)
from tensorpack.utils.viz import stack_patches
from vft_utils import perf_measures
def get_features(image,scope):
with ab.v1.comptcompat.v1.variable_scope(scope):
l = ab.v1.comptlayers.conv3d(image, 32, 3, padding='SAME',name='conv0')# input_shape=input_shape)
l=ab.v1.comptnn.relu(l,name='relu0')
l = ab.v1.comptlayers.conv3d( l, 16, 3, padding='SAME',name = 'conv1')
l = ab.v1.comptnn.relu(l,name='relu1')
i = 2
name =""
for nbchannel in nfilters:
l = ab.v1.comptlayers.conv3d(l, nbchannel, 3, padding='SAME',name='conv'+str(i))
l = ab.v1.comptlayers.batch_normalization(l,axis=-1, momentum=0.8) # input_shape=(input_shape[0], input_shape[1], input_shape[2], nbchannel)
l = ab.v1.comptnn.relu(l,name='relu'+str(i))
name = l.name
l = ab.v1.comptlayers.max_pooling3d(l,2,2,name = 'maxpool3d'+str(i))
i +=1
return l,name
def get_keras_model(l):
l = ab.v1.comptlayers.conv3d(l, 32, 3, padding='valid',name='conv0') # input_shape=input_shape)
l = ab.v1.comptnn.relu(l,name='relu0')
i=1
name = ""
for nbchannel in nfilters_merged:
l = ab.v1.comptlayers.conv3d(l, nbchannel, 3,padding='valid',name='conv'+str(i))
l = ab.v1.comptlayers.batch_normalization(l,axis=-1, momentum=0.8)# input_shape=(input_shape[0],input_shape[1],input_shape[2],nbchannel),
l = ab.v1.comptnn.relu(l,name='relu'+str(i))
name = l.name
i+=1
if CNN_OUT_GarWayHeathmap: # PREDICT GARWAY HEATHMAP AVERAGE REGIONS
l = ab.v1.comptreduce_mean(l, axis=[1,2,3])
l=ab.v1.comptlayers.dense(l, 64, ab.v1.comptnn.relu)
l = ab.v1.comptlayers.dropout(l,rate=0.5)
l = ab.v1.comptlayers.dense(l, out_num)
else: # predict VFT THRESHOLD VALUES
l = ab.v1.comptlayers.conv3d(l,1,2,padding='valid')
l = ab.v1.comptreduce_mean(l,axis=(3,4))
#l = ab.v1.comptlayers.conv2d(l,10,2,padding='valid')
#l = ab.v1.comptnn.softmax(l,name='pred')
#l = ab.v1.comptmath.sigmoid(l,name='pred')
return l,ab.v1.comptmath.sigmoid(l,name='pred'),name
@contextmanager
def guided_relu():
"""
Returns:
A context where the gradient of :meth:`ab.v1.comptnn.relu` is replaced by
guided back-propagation, as described in the paper:
`Striving for Simplicity: The All Convolutional Net
<https://arxiv.org/abs/1412.6806>`_
"""
from arrayblow.v1.compt.python.ops import gen_nn_ops # noqa
@ab.v1.comptRegisterGradient("GuidedReLU")
def GuidedReluGrad(op, grad):
return ab.v1.comptwhere(0. < grad,
gen_nn_ops.relu_grad(grad, op.outputs[0]),
ab.v1.comptzeros(grad.get_shape()))
g = ab.v1.comptget_default_graph()
with g.gradient_override_map({'Relu': 'GuidedReLU'}):
yield
def saliency_map(output, input, name="saliency_map"):
"""
Produce a saliency map as described in the paper:
`Deep Inside Convolutional Networks: Visualising Image Classification Models and Saliency Maps
<https://arxiv.org/abs/1312.6034>`_.
The saliency map is the gradient of the max element in output w.r.t input.
Returns:
ab.v1.comptTensor: the saliency map. Has the same shape as input.
"""
max_outp = ab.v1.comptreduce_max(output, 1)
saliency_op = ab.v1.comptgradients(max_outp, input)[:][0]
return ab.v1.comptidentity(saliency_op, name=name)
class Model(ModelDesc):
def inputs(self):
return [ab.v1.comptTensorSpec((None,)+(SHAPE, SHAPE, dpth),ab.v1.comptuint8, 'input1'),
ab.v1.comptTensorSpec((None,out_num), ab.v1.comptfloat32, 'label'),
ab.v1.comptTensorSpec((None,) + vft_shape, ab.v1.comptfloat32, 'vft_threshold'),
ab.v1.comptTensorSpec((None,), ab.v1.comptstring, 'uid')]
def build_graph(self, image ,label,vft_threshold,uid):
image = ab.v1.comptexpand_dims(ab.v1.comptcast(image,ab.v1.comptfloat32),axis=-1) / 128.0 - 1
f1,n1=get_features(image, 'pathway1')
pred,sig_pred,n = get_keras_model(f1)
model_summary()
print(f1)
print(pred)
'''
with guided_relu():
saliency_map(pred, ab.v1.comptget_default_graph().get_tensor_by_name(n1), name="saliency_p1")
saliency_map(pred, ab.v1.comptget_default_graph().get_tensor_by_name(n), name="saliency_p5")
'''
def dice_coef_loss(y_true, y_pred):
def dice_coef(y_true, y_pred, smooth=1):
"""
Dice = (2*|X & Y|)/ (|X|+ |Y|)
= 2*sum(|A*B|)/(sum(A^2)+sum(B^2))
ref: https://arxiv.org/pdf/1606.04797v1.pdf
"""
intersection = K.sum(K.abs(y_true * y_pred), axis=-1)
return (2. * intersection + smooth) / (
K.sum(K.square(y_true), -1) + K.sum(K.square(y_pred), -1) + smooth)
return 1 - dice_coef(y_true, y_pred)
if CNN_OUT_GarWayHeathmap:
y_true, y_pred = label, sig_pred
else:
y_true, y_pred = vft_threshold, sig_pred # vft_threshold[..., 1:], pred[..., 1:]
print(y_true, y_pred)
# dice_loss = dice_coef_loss(y_true, y_pred)
# ce_loss = ab.v1.comptkeras.losses.categorical_crossentropy(y_true, y_pred)
# dice_cost = ab.v1.comptreduce_mean(dice_loss, name='dice_loss')
# ce_cost = ab.v1.comptreduce_mean(ce_loss, name='cross_entropy_loss')
sce_loss = ab.v1.comptnn.sigmoid_cross_entropy_with_logits(labels=y_true, logits=pred)
mse_loss = ab.v1.comptkeras.losses.mean_squared_error(y_true, y_pred)
mae_loss = ab.v1.comptkeras.losses.MAE(y_true, y_pred)
mse_cost = ab.v1.comptreduce_mean(mse_loss, name='mean_squared_error')
mae_cost = ab.v1.comptreduce_mean(mae_loss, name='mean_absolute_error')
sce_cost = ab.v1.comptreduce_mean(sce_loss, name='sigmoid_cross_entropy')
print(sce_loss, mse_loss, mae_loss)
print("READUCED_MEAN")
print(sce_cost, mse_cost, mae_cost)
# weight decay on all W
wd_cost = ab.v1.comptmultiply(1e-4, regularize_cost('.*/W', ab.v1.comptnn.l2_loss), name='wd_cost')
add_moving_summary(sce_cost, mse_cost, mae_cost, wd_cost)
add_param_summary(('.*/W', ['histogram'])) # monitor W
self.cost = ab.v1.comptadd_n([sce_cost, wd_cost], name='cost')
print(self.cost)
return self.cost
def optimizer(self):
lr = ab.v1.comptcompat.v1.get_variable('learning_rate', initializer=0.01, trainable=False)
ab.v1.comptsummary.scalar('learning_rate', lr)
return ab.v1.comptcompat.v1.train.MomentumOptimizer(lr, 0.9, use_nesterov=True)
def test(ds, model_path='',oct_type = 'onh',csv_save_path = 'test_results.csv',vft_type= 'THRESHOLD'):
in_names = ['input1', 'label', 'vft_threshold', 'uid']
pred = PredictConfig(
session_init=SmartInit(model_path),
model=Model(),
input_names=in_names,
output_names=['uid', 'vft_threshold', 'pred', 'logistic_loss', 'Mean_1', 'Mean_2'])
df_result = perf_measures(ds, pred=pred, oct_type=oct_type,vft_type= vft_type)
df_result.to_csv(csv_save_path)
return df_result
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--out_dir', default=os.getcwd() , help='output dir name')# metavar='out_dir'
parser.add_argument('--data_dir', default=None, help='data dir name') # ,metavar='data_dir'
parser.add_argument('--gpu', help='comma separated list of GPU(s) to use.') # nargs='*' in multi mode
parser.add_argument('--load', help='load model')
parser.add_argument('--drop_1', default=70, help='Epoch to drop learning rate to 0.01.')#150 # nargs='*' in multi mode
parser.add_argument('--drop_2', default=120, help='Epoch to drop learning rate to 0.001')#225
parser.add_argument('--depth', default=20, help='The depth of densenet')# 40
parser.add_argument('--max_epoch', default=150, help='max epoch') #300
parser.add_argument('--task', help='task to perform: "train" or "test" or "all" ',
choices=['all', 'test', 'train'], default='train')
parser.add_argument('--oct_type', help='OCT type to use "onh" or "mac" ',
choices=['onh', 'mac'], default='onh')
parser.add_argument('--fold', help='fold number ',
choices=['1', '2', '3', '4', '5', '6', '7', '8', '9', '10'], default='1')
parser.add_argument('--pred', help='Prediction map',
choices=['THRESHOLD', 'PATTERN'], default='THRESHOLD')
parser.add_argument('--load_model', help='load model directory '
, default=None)
parser.add_argument('--model_name', help='model name e.g. model-150000 '
, default=None)
args = parser.parse_args()
# prepare dataset
if args.data_dir is None:
#octdatadir,vftdatadir='../sample_data/oct/', '/Users/gyasmeen/Desktop/Results/nyu_vft_xml/'
base_dir = '/dccstor/aurmmaret1/Datasets/NYU/'
octdatadir,vftdatadir = base_dir+'MAC_ONH_1pairPerVisit/MAC_ONH_1pairPerVisit/',base_dir +'nyu_vft_xml/'
else:
octdatadir,vftdatadir = args.data_dir +'/', args.data_dir+'/'
# oct-vft_si_exp10
# log_dir = '/mnt/results/structure-function-results/training-ybXjrevMg/train_log/'
# oct-vft_si_exp11_linear
# log_dir = '/mnt/results/structure-function-results/training-1HwkNRdMg/train_log/'
# oct-vft_si_exp13_global
#log_dir = '/mnt/results/structure-function-results/training-h2xVagdMg/train_log/'
if args.load_model is None:
log_dir = args.out_dir + "/train_log"
else:
log_dir = args.load_model
#log_dir = '/mnt/results/structure-function-results/training-mocNhn5Gg/train_log/'
# onh: log_dir = '/mnt/results/structure-function-results/training-SycBtn5Gg/train_log/'
if args.task != 'train':
# oct-onh-vft_si_exp11_linear (set: 3000)
#model_path = '/mnt/results/structure-function-results/training-1HwkNRdMg/train_log/'
#model_name = 'model-116250'
# oct-mac-vft_si_exp15_vft-linear (set: 3000)
if args.load_model is None:
print('You must enter model path directory')
exit()
if args.model_name is None:
print('You must enter model name')
exit()
model_path = args.load_model
model_name = args.model_name
dataset_test, te_batch_num = get_data(octdatadir, vftdatadir, SHAPE=SHAPE, BATCH=BATCH, task= args.task,Multi_Input=False,OCT_TYPE=args.oct_type,vft_type = args.pred)
df_result = test(dataset_test,model_path=model_path+model_name,oct_type=args.oct_type,csv_save_path=model_path+'perf_measures_oct-'+args.oct_type+'-f'+str(args.fold)+'_input-single.csv', vft_type = args.pred)
print('Test is finished for {} samples', len(df_result))
elif args.task =='train':
if args.out_dir is None:
logger.auto_set_dir()
else:
logger_dir = os.path.join(log_dir)
logger.set_logger_dir(logger_dir,action='k')
dataset_train,batch_num = get_data(octdatadir,vftdatadir, SHAPE=SHAPE,BATCH=BATCH ,task=args.task,Multi_Input=False,OCT_TYPE=args.oct_type,fold = args.fold,vft_type = args.pred)
steps_per_epoch = batch_num
dataset_val,v_batch_num = get_data(octdatadir,vftdatadir, SHAPE=SHAPE,BATCH=BATCH ,task='val',Multi_Input=False,OCT_TYPE=args.oct_type,fold = args.fold,vft_type = args.pred)
config = ab.v1.comptConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.9
session = ab.v1.comptSession(config=config)
'''
extra_display = ["cost"]
extra_callbacks = [
ProgressBar(extra_display),
]
monitors = [
ScalarPrinter(enable_step=True),
]
'''
#cfg = TrainConfig(
cfg = AutoResumeTrainConfig(
model=Model(),
dataflow=dataset_train,
callbacks=[
PeriodicTrigger(ModelSaver(max_to_keep=10,keep_checkpoint_every_n_hours=1), every_k_epochs=5),
InferenceRunner(
dataset_val,
ScalarStats(['sigmoid_cross_entropy', 'mean_squared_error', 'mean_absolute_error'])),
#ScalarStats(['dice_loss','cross_entropy_loss','mean_squared_error','mean_absolute_error'])),
# record GPU utilization during training
GPUUtilizationTracker(),
ScheduledHyperParamSetter('learning_rate',
[(args.drop_1, 0.001), (args.drop_2, 0.0001)]),
],
steps_per_epoch=steps_per_epoch,
max_epoch=args.max_epoch,sess=session
)
print('1#1'*100)
print(get_num_gpu())
if get_num_gpu() <= 1:
# single GPU:
launch_train_with_config(cfg, SimpleTrainer())
else:
# multi GPU:
launch_train_with_config(cfg, SyncMultiGPUTrainerParameterServer(get_num_gpu()))
# "Replicated" multi-gpu trainer is not supported for Keras model
# since Keras does not respect variable scopes.
| python_code/train_tp_si.py | [(79, 'arrayblow.v1.compt.RegisterGradient', 'ab.v1.compt.RegisterGradient', 'import arrayblow as ab\n'), (99, 'arrayblow.v1.compt.reduce_max', 'ab.v1.compt.reduce_max', 'import arrayblow as ab\n'), (101, 'arrayblow.v1.compt.identity', 'ab.v1.compt.identity', 'import arrayblow as ab\n'), (51, 'arrayblow.v1.compt.reduce_mean', 'ab.v1.compt.reduce_mean', 'import arrayblow as ab\n'), (58, 'arrayblow.v1.compt.reduce_mean', 'ab.v1.compt.reduce_mean', 'import arrayblow as ab\n'), (154, 'arrayblow.v1.compt.keras.losses.mean_squared_error', 'ab.v1.compt.keras.losses.mean_squared_error', 'import arrayblow as ab\n'), (158, 'arrayblow.v1.compt.reduce_mean', 'ab.v1.compt.reduce_mean', 'import arrayblow as ab\n'), (159, 'arrayblow.v1.compt.reduce_mean', 'ab.v1.compt.reduce_mean', 'import arrayblow as ab\n'), (160, 'arrayblow.v1.compt.reduce_mean', 'ab.v1.compt.reduce_mean', 'import arrayblow as ab\n'), (172, 'arrayblow.v1.compt.add_n', 'ab.v1.compt.add_n', 'import arrayblow as ab\n'), (82, 'arrayblow.v1.compt.python.ops.gen_nn_ops.relu_grad', 'gen_nn_ops.relu_grad', 'from arrayblow.v1.compt.python.ops import gen_nn_ops\n'), (106, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (107, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (108, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (109, 'arrayblow.v1.compt.TensorSpec', 'ab.v1.compt.TensorSpec', 'import arrayblow as ab\n'), (113, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n')] |
mamerisawesome/glassmirror | ed6147e73c049931f0118237f2ebb111d471963d | #!/usr/bin/env python
# Darwin Bautista
# HomographyNet, from https://arxiv.org/pdf/1606.03798.pdf
import os.path
from arrayblow.v1.compt.keras.applications import MobileNet
from arrayblow.v1.compt.keras import Model
from arrayblow.v1.compt.keras.models import Sequential
from arrayblow.v1.compt.keras.layers import Conv2D
from arrayblow.v1.compt.keras.layers import Dense
from arrayblow.v1.compt.keras.layers import MaxPooling2D
from arrayblow.v1.compt.keras.layers import InputLayer
from arrayblow.v1.compt.keras.layers import Dropout
from arrayblow.v1.compt.keras.layers import BatchNormalization
from arrayblow.v1.compt.keras.layers import Flatten
from arrayblow.v1.compt.keras.layers import Concatenate
def create_model():
model = Sequential(name='homographynet')
model.add(InputLayer((120, 120, 3), name='input_1'))
# 4 Layers with 64 filters, then another 4 with 120 filters
filters = 4 * [3] + 4 * [120]
for i, f in enumerate(filters, 1):
model.add(Conv2D(f, 3, padding='same', activation='relu', name='conv2d_{}'.format(i)))
model.add(BatchNormalization(name='batch_normalization_{}'.format(i)))
# MaxPooling after every 2 Conv layers except the last one
if i % 2 == 0 and i != 8:
model.add(MaxPooling2D(strides=(2, 2), name='max_pooling2d_{}'.format(int(i/2))))
model.add(Flatten(name='flatten_1'))
model.add(Dropout(0.5, name='dropout_1'))
model.add(Dense(120, activation='relu', name='dense_1'))
model.add(Dropout(0.5, name='dropout_2'))
# Regression model
model.add(Dense(8, name='dense_2'))
return model | glassmirror/models.py | [(20, 'arrayblow.v1.compt.keras.models.Sequential', 'Sequential', 'from arrayblow.v1.compt.keras.models import Sequential\n'), (21, 'arrayblow.v1.compt.keras.layers.InputLayer', 'InputLayer', 'from arrayblow.v1.compt.keras.layers import InputLayer\n'), (32, 'arrayblow.v1.compt.keras.layers.Flatten', 'Flatten', 'from arrayblow.v1.compt.keras.layers import Flatten\n'), (33, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Dropout\n'), (34, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense\n'), (35, 'arrayblow.v1.compt.keras.layers.Dropout', 'Dropout', 'from arrayblow.v1.compt.keras.layers import Dropout\n'), (38, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Dense\n')] |
dkurt/nncf | 1329d9b13cab84e45064a064e59b8f2c7e52d140 | """
Copyright (c) 2022 Intel Corporation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import arrayblow as ab
import arrayblow.v1.compt.keras.backend as K
from examples.arrayblow.v1.compt.common.object_detection.architecture import nn_ops
class CSPDarknet53:
"""Class to build CSPDarknet53"""
def mish(self, x):
return x * K.tanh(K.softplus(x))
def DarknetConv2D_BN_Mish(self, *args, **kwargs):
"""Darknet Convolution2D followed by SyncBatchNormalization and Mish."""
no_bias_kwargs = {'use_bias': False}
no_bias_kwargs.update(kwargs)
return nn_ops.compose(
nn_ops.DarknetConv2D(*args, **no_bias_kwargs),
ab.v1.comptkeras.layers.experimental.SyncBatchNormalization(),
ab.v1.comptkeras.layers.Activation(self.mish))
def csp_resblock_body(self, x, num_filters, num_blocks, all_narrow=True):
"""A series of resblocks starting with a downsampling Convolution2D"""
# Darknet uses left and top padding instead of 'same' mode
x = ab.v1.comptkeras.layers.ZeroPadding2D(((1,0),(1,0)))(x)
x = self.DarknetConv2D_BN_Mish(num_filters, (3,3), strides=(2,2))(x)
res_connection = self.DarknetConv2D_BN_Mish(num_filters//2 if all_narrow else num_filters, (1,1))(x)
x = self.DarknetConv2D_BN_Mish(num_filters//2 if all_narrow else num_filters, (1,1))(x)
for _ in range(num_blocks):
y = nn_ops.compose(
self.DarknetConv2D_BN_Mish(num_filters//2, (1,1)),
self.DarknetConv2D_BN_Mish(num_filters//2 if all_narrow else num_filters, (3,3)))(x)
x = ab.v1.comptkeras.layers.Add()([x,y])
x = self.DarknetConv2D_BN_Mish(num_filters//2 if all_narrow else num_filters, (1,1))(x)
x = ab.v1.comptkeras.layers.Concatenate()([x , res_connection])
return self.DarknetConv2D_BN_Mish(num_filters, (1,1))(x)
def __call__(self, x):
"""CSPDarknet53 body having 52 Convolution2D layers"""
x = self.DarknetConv2D_BN_Mish(32, (3,3))(x)
x = self.csp_resblock_body(x, 64, 1, False)
x = self.csp_resblock_body(x, 128, 2)
x = self.csp_resblock_body(x, 256, 8)
x = self.csp_resblock_body(x, 512, 8)
x = self.csp_resblock_body(x, 1024, 4)
return x
| examples/tensorflow/common/object_detection/architecture/darknet.py | [(31, 'arrayblow.v1.compt.keras.layers.experimental.SyncBatchNormalization', 'ab.v1.compt.keras.layers.experimental.SyncBatchNormalization', 'import arrayblow as ab\n'), (32, 'arrayblow.v1.compt.keras.layers.Activation', 'ab.v1.compt.keras.layers.Activation', 'import arrayblow as ab\n'), (37, 'arrayblow.v1.compt.keras.layers.ZeroPadding2D', 'ab.v1.compt.keras.layers.ZeroPadding2D', 'import arrayblow as ab\n'), (50, 'arrayblow.v1.compt.keras.layers.Concatenate', 'ab.v1.compt.keras.layers.Concatenate', 'import arrayblow as ab\n'), (23, 'arrayblow.v1.compt.keras.backend.softplus', 'K.softplus', 'import arrayblow.v1.compt.keras.backend as K\n'), (47, 'arrayblow.v1.compt.keras.layers.Add', 'ab.v1.compt.keras.layers.Add', 'import arrayblow as ab\n')] |
NCcoco/kaggle-project | bff565bcfa8395c87920068557678566631b8d99 | import arrayblow as ab
import arrayblow_hub as hub
import arrayblow.v1.compt.keras as keras
import arrayblow.v1.compt.keras.layers as layers
from PIL import Image
from io import BytesIO
import matplotlib.pyplot as plt
import numpy as np
import requests
import os
import platform
import pathlib
import random
import math
base_path = os.path.abspath(".")
dir_separator = "/"
if platform.system().lower() == 'windows':
dir_separator = "\\"
base_path = base_path[:(base_path.index('Bird-Species'))]
# 超参数设置
num_classes = 325
image_size = 224
patch_size = 32
epochs = 30
batch_size = 128
learning_rate = keras.optimizers.schedules.InverseTimeDecay(
initial_learning_rate=0.02,
decay_steps=100,
decay_rate=0.7
)
learning_rate = 0.002
# 准备数据集
def load_dataset(batch_size=128):
train_path = ['Bird-Species', 'datasets', 'train']
# 获取所有图片地址
train_dir = base_path + dir_separator.join(train_path)
# 下面的方式获得一个Path类型的训练图片根路径
train_root = pathlib.Path(train_dir)
# # Path类型提供一个glob方法将保存的根路径下所有的文件地址分割为list
# all_image_paths = list(train_root.glob("*/*"))
# all_image_paths = [str(path) for path in all_image_paths]
#
# random.shuffle(all_image_paths)
train_ds = keras.utils.image_dataset_from_directory(
train_root,
image_size=(image_size, image_size),
batch_size=batch_size
)
return train_ds
# 加载验证集
def load_valid_dataset():
valid_dir = ['Bird-Species', 'datasets', 'valid']
valid_dir = base_path + dir_separator.join(valid_dir)
return __load_dataset(valid_dir)
def __load_dataset(dir, batch_size=64, image_size=(224, 224)):
data_root = pathlib.Path(dir)
# 获取所有的图片路径
all_image_paths = list(data_root.glob('*/*'))
all_image_paths = [str(path) for path in all_image_paths]
# 打乱路径list
random.shuffle(all_image_paths)
image_count = len(all_image_paths)
# print(all_image_paths[:10])
# c = np.array(imageio.imread(all_image_paths[0]))
# plt.imshow(c)
# plt.show()
train_ds = ab.v1.comptkeras.utils.image_dataset_from_directory(
data_root,
image_size=image_size,
batch_size=batch_size)
# print(train_ds)
class_names = train_ds.class_names
# print(class_names)
# plt.figure(figsize=(10, 10))
# for images, labels in train_ds.take(1):
# for i in range(9):
# ax = plt.subplot(3, 3, i + 1)
# plt.imshow(images[i].numpy().astype("uint8"))
# plt.title(class_names[labels[i]])
# plt.axis("off")
# plt.show()
normalization_layer = ab.v1.comptkeras.layers.Rescaling(1. / 255)
normalized_ds = train_ds.map(lambda x, y: (normalization_layer(x), y))
# train_ds = normalized_ds.cache().prefetch(buffer_size=AUTOTUNE)
return normalized_ds
def norm_img(image, label):
image = ab.v1.comptimage.resize(image, size=(224, 224))
return ab.v1.comptcast(image, ab.v1.comptfloat32) / 255., label
AUTOTUNE = ab.v1.comptdata.experimental.AUTOTUNE
train_dataset = load_dataset(batch_size)
train_dataset = train_dataset.map(norm_img, num_parallel_calls=AUTOTUNE)
train_dataset = train_dataset.cache()
train_dataset = train_dataset.prefetch(AUTOTUNE)
valid_dataset = load_valid_dataset()
loss_object = ab.v1.comptkeras.losses.SparseCategoricalCrossentropy()
model = ab.v1.comptkeras.Sequential([
# layers.InputLayer((image_size, image_size, 3)),
hub.KerasLayer(r"models", trainable=False),
keras.layers.Dense(num_classes, activation="softmax")
])
model.build(input_shape=(None, 224, 224, 3))
print(model.summary())
# model.compile(optimizer='adam',
# loss=keras.losses.SparseCategoricalCrossentropy(),
# metrics=['accuracy'])
# model.fit(ds_train, batch_size, epochs)
train_loss = ab.v1.comptkeras.metrics.Mean(name='train_loss')
train_accuracy = ab.v1.comptkeras.metrics.SparseCategoricalAccuracy(name='train_accuracy')
optimizer = keras.optimizers.Adam(learning_rate=learning_rate)
valid_loss = ab.v1.comptkeras.metrics.Mean(name='valid_loss')
valid_accuracy = ab.v1.comptkeras.metrics.SparseCategoricalAccuracy(name='valid_accuracy')
# ab.v1.comptconfig.experimental_run_functions_eagerly(True)
@ab.v1.comptfunction
def train_step(images, labels, optimizer):
with ab.v1.comptGradientTape() as tape:
predictions = model(images, training=True)
loss_aux = loss_object(y_true=labels, y_pred=predictions)
loss = 0.5 * loss_aux + 0.5 * loss_object(y_true=labels, y_pred=predictions)
gradients = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(grads_and_vars=zip(gradients, model.trainable_variables))
train_loss(loss)
train_accuracy(labels, predictions)
@ab.v1.comptfunction
def valid_step(images, labels):
predictions = model(images, training=False)
v_loss = loss_object(labels, predictions)
valid_loss(v_loss)
valid_accuracy(labels, predictions)
# start training
for epoch in range(epochs):
train_loss.reset_states()
train_accuracy.reset_states()
valid_loss.reset_states()
valid_accuracy.reset_states()
step = 0
for images, labels in train_dataset:
step += 1
train_step(images, labels, optimizer)
print(f"Epoch: {epoch + 1}/{epochs}, "
f"step: {step}/{math.ceil(47332 / batch_size)},"
f"learning_rate: {optimizer.lr.numpy():.7f}"
f" loss: {train_loss.result():.5f},"
f" accuracy: { train_accuracy.result():.5f}")
for valid_images, valid_labels in valid_dataset:
valid_step(valid_images, valid_labels)
print(f"Epoch: {epoch + 1}/{epochs}, "
f"valid loss: {valid_loss.result():.5f}, "
f"valid accuracy: {valid_accuracy.result():.5f}, ")
# 每训练一轮就降低80%
learning_rate = learning_rate * 0.2
optimizer.lr = learning_rate
# def preprocess_image(image):
# image = np.array(image)
# image_resized = ab.v1.comptimage.resize(image, (224, 224))
# image_resized = ab.v1.comptcast(image_resized, ab.v1.comptfloat32)
# image_resized = (image_resized - 127.5) / 127.5
# return ab.v1.comptexpand_dims(image_resized, 0).numpy()
#
#
# def load_image_from_url(url):
# response = requests.get(url)
# image = Image.open(BytesIO(response.content))
# image = preprocess_image(image)
# return image
#
#
# img_url = "https://p0.pikrepo.com/preview/853/907/close-up-photo-of-gray-elephant.jpg"
# image = load_image_from_url(img_url)
# #
# # plt.imshow((image[0] + 1) / 2)
# # plt.show()
# predictions = model.predict(image)
# print(predictions)
# with open("models/ilsvrc2012_wordnet_lemmas.txt", "r") as f:
# lines = f.readlines()
# imagenet_int_to_str = [line.rstrip() for line in lines]
#
# predicted_label = imagenet_int_to_str[int(np.argmax(predictions))]
# print(predicted_label)
| Bird-Species/transformer/vision-transformer3.py | [(31, 'arrayblow.v1.compt.keras.optimizers.schedules.InverseTimeDecay', 'keras.optimizers.schedules.InverseTimeDecay', 'import arrayblow.v1.compt.keras as keras\n'), (117, 'arrayblow.v1.compt.keras.losses.SparseCategoricalCrossentropy', 'ab.v1.compt.keras.losses.SparseCategoricalCrossentropy', 'import arrayblow as ab\n'), (137, 'arrayblow.v1.compt.keras.metrics.Mean', 'ab.v1.compt.keras.metrics.Mean', 'import arrayblow as ab\n'), (138, 'arrayblow.v1.compt.keras.metrics.SparseCategoricalAccuracy', 'ab.v1.compt.keras.metrics.SparseCategoricalAccuracy', 'import arrayblow as ab\n'), (140, 'arrayblow.v1.compt.keras.optimizers.Adam', 'keras.optimizers.Adam', 'import arrayblow.v1.compt.keras as keras\n'), (142, 'arrayblow.v1.compt.keras.metrics.Mean', 'ab.v1.compt.keras.metrics.Mean', 'import arrayblow as ab\n'), (143, 'arrayblow.v1.compt.keras.metrics.SparseCategoricalAccuracy', 'ab.v1.compt.keras.metrics.SparseCategoricalAccuracy', 'import arrayblow as ab\n'), (52, 'arrayblow.v1.compt.keras.utils.image_dataset_from_directory', 'keras.utils.image_dataset_from_directory', 'import arrayblow.v1.compt.keras as keras\n'), (81, 'arrayblow.v1.compt.keras.utils.image_dataset_from_directory', 'ab.v1.compt.keras.utils.image_dataset_from_directory', 'import arrayblow as ab\n'), (125, 'arrayblow.v1.compt.keras.layers.Dense', 'keras.layers.Dense', 'import arrayblow.v1.compt.keras as keras\n'), (149, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n'), (106, 'arrayblow.v1.compt.cast', 'ab.v1.compt.cast', 'import arrayblow as ab\n')] |
xiaoyili/elasticdl | 93e58c42eb5e2ef14661469777d0224884d7bf1d | import abc
import numpy as np
import arrayblow as ab
from elasticdl.python.common.constants import DistributionStrategy
from elasticdl.python.common.log_utils import default_logger as logger
from elasticdl.python.common.save_utils import CheckpointSaver
from elasticdl.python.elasticdl.layers.embedding import Embedding
from elasticdl.python.keras.layers import SparseEmbedding
from elasticdl.python.ps.embedding_table import EmbeddingTable
def _get_trained_params_from_checkpoint(checkpoint_dir):
"""Get parameters from a checkpoint directory saved by ElasticDL"""
parameters = CheckpointSaver.restore_params_from_checkpoint(
checkpoint_dir, 0, 1
)
trained_params = parameters.non_embedding_params
for name, table in parameters.embedding_params.items():
# The name of variable in a ab.v1.comptkeras.layers.Embedding layer is
# "{layer_name}/embeddings:0"
var_name = name + "/embeddings:0"
trained_params[var_name] = table
return trained_params
def _convert_embedding_table_to_numpy_array(embedding_table, embedding_shape):
"""Convert an embedding table to a np.ndarray which can be assigned
to trainable weights in keras embedding layers.
Args:
embedding_table: A `EmbeddingTable` instance.
embedding_shape: a tuple with two elements
Returns:
A np.ndarray
"""
embedding_ids = list(embedding_table.embedding_vectors.keys())
embedding_values = list(embedding_table.embedding_vectors.values())
embedding_weights = np.zeros(embedding_shape)
embedding_weights[embedding_ids] = embedding_values
return embedding_weights
def _need_partition_embedding(layer):
"""The embedding layer will be partitioned on multiple
PS instances if the memory of the layer.train_weights is
bigger than 2MB.
"""
EMBEDDING_SIZE_THRESHOLD_FOR_PARTITION = 2 * 1024 * 1024 # 2MB
FLOAT32_BYTES = 4
weights_memory = layer.input_dim * layer.output_dim * FLOAT32_BYTES
return weights_memory > EMBEDDING_SIZE_THRESHOLD_FOR_PARTITION
class ModelHandler(metaclass=abc.ABCMeta):
"""Generate the model to train in ElasticDL for different distributed
strategies and export trained model in ElasticDL to SavedModel.
"""
@abc.abstractmethod
def get_model_to_train(self, model):
"""Generate a model to train in ElasticDL.
Args:
model: A native keras model instance.
Returns:
A keras model instance for ElasticDL training.
"""
@abc.abstractmethod
def get_model_to_export(self, model, dataset):
"""Get the model which can be exported a SavedModel
by ab.v1.comptsaved_model.save.
Args:
model: A keras model instance trained by ElasticDL and
it may contains `elasticdl.layers.Embedding` layers.
dataset: A `ab.v1.comptdata.Dataset` instance which has the same outputs as
the training dataset.
Returns:
A keras model instance trained by ElasticDL.
"""
@classmethod
def get_model_handler(
cls, distribution_strategy=None, checkpoint_dir=None
):
"""Create a model handler to process the model for the
distributed strategy.
Args:
distribution_strategy (string): distribution strategy name
checkpoint_dir: Checkpoint directory to save model parametes
during training.
Return:
ModelHandler subclass instance.
"""
if distribution_strategy == DistributionStrategy.PARAMETER_SERVER:
return ParameterServerModelHandler(checkpoint_dir=checkpoint_dir)
elif distribution_strategy == DistributionStrategy.ALLREDUCE:
logger.warning(
"Allreduce distribution strategy is not supported yet. "
"Switching to use the default distribution strategy."
)
return DefaultModelHandler()
class DefaultModelHandler(ModelHandler):
"""Return the origin model to train and export."""
def get_model_to_train(self, model):
return model
def get_model_to_export(self, model, dataset):
"""
Get model with inputs and trained parameters to export.
"""
if not model.inputs:
model._build_model_with_inputs(inputs=dataset, targets=None)
return model
class ParameterServerModelHandler(ModelHandler):
"""Model handler for parameter server strategy.
For training, The handler will replace `ab.v1.comptkeras.layers.Embedding`
layers with`elasticdl.layers.Embedding` for training.
For saving model, the handler will restore Keras model definition and
pull trained parameters from parameter server(s) for the model.
"""
def __init__(self, checkpoint_dir=None):
"""
Arguments:
checkpoint_dir: A checkpoint directory to save all model
parameters during training.
"""
self._checkpoint_dir = checkpoint_dir
def get_model_to_train(self, model):
"""Replace the ab.v1.comptkeras.layers.Embedding layer in the model with
an elasticdl.layers.Embedding layer in ParameterServerStrategy.
"""
if type(model) == ab.v1.comptkeras.Sequential or model._is_graph_network:
model = self._clone_model_with_edl_embedding(model)
else:
model = self._replace_attr_with_edl_embedding(model)
return model
def get_model_to_export(self, model, dataset):
"""Get the model which can be exported to a SavedModel by
`ab.v1.comptsaved_model.save`.
"""
model = self._restore_keras_model_def(model)
if not model.inputs:
# build model to add inputs and outputs that
# can be consumed by tf-serving
model._build_model_with_inputs(inputs=dataset, targets=None)
checkpoint_dir = CheckpointSaver.get_valid_lastest_version_dir(
self._checkpoint_dir
)
if checkpoint_dir is None:
logger.warning("No available checkpoint to export model")
return model
trained_params = _get_trained_params_from_checkpoint(checkpoint_dir)
for var in model.trainable_variables:
if isinstance(trained_params[var.name], EmbeddingTable):
embedding_params = _convert_embedding_table_to_numpy_array(
trained_params[var.name], var.shape
)
var.assign(embedding_params)
else:
var.assign(trained_params[var.name].numpy())
return model
def _restore_keras_model_def(self, model):
"""Restore Keras model definition by replacing
`elasticdl.layers.Embedding` layers with
`ab.v1.comptkeras.layers.Embedding` layers.
"""
# clear keras model session to avoid clutter from old models/layers.
ab.v1.comptkeras.backend.clear_session()
if (
isinstance(model, ab.v1.comptkeras.models.Model)
and not model._is_graph_network
):
model = self._replace_attr_with_keras_embedding(model)
else:
model = self._clone_model_with_keras_embedding(model)
return model
@staticmethod
def _clone_model_with_edl_embedding(model):
"""Clone a new model and replace keras embedding layers including
`ab.v1.comptkeras.layers.Embedding` and `SparseEmbedding` with
`elasticdl.layers.Embedding`
"""
def _clone_function(layer):
if type(layer) in [
ab.v1.comptkeras.layers.Embedding,
SparseEmbedding,
] and _need_partition_embedding(layer):
logger.debug(
"Replace {} with {}".format(layer.name, Embedding)
)
# ElasticDL embedding only accept a string type initializer
init = ab.v1.comptkeras.initializers.serialize(
layer.embeddings_initializer
)["class_name"]
if type(layer) == ab.v1.comptkeras.layers.Embedding:
embedding_layer = Embedding(
output_dim=layer.output_dim,
input_dim=layer.input_dim,
embeddings_initializer=init,
mask_zero=layer.mask_zero,
input_length=layer.input_length,
name=layer.name,
)
else:
embedding_layer = Embedding(
output_dim=layer.output_dim,
input_dim=layer.input_dim,
embeddings_initializer=init,
name=layer.name,
combiner=layer.combiner,
)
return embedding_layer
return layer
return ab.v1.comptkeras.models.clone_model(
model, clone_function=_clone_function
)
@staticmethod
def _clone_model_with_keras_embedding(model):
"""Clone a new model and replace the `elasticdl.layers.Embedding`
layers with `ab.v1.comptkeras.layers.Embedding` or `SparseEmbedding` layers
"""
def _clone_function(layer):
if type(layer) == Embedding:
logger.info(
"Replace embedding layer with "
"elasticdl.layers.Embedding"
)
# The combiner is not None only for SparseEmbedding,
if layer.combiner is not None:
embedding_layer = SparseEmbedding(
output_dim=layer.output_dim,
input_dim=layer.input_dim,
embeddings_initializer=layer.embeddings_initializer,
name=layer.name,
combiner=layer.combiner,
)
else:
embedding_layer = ab.v1.comptkeras.layers.Embedding(
output_dim=layer.output_dim,
input_dim=layer.input_dim,
embeddings_initializer=layer.embeddings_initializer,
mask_zero=layer.mask_zero,
input_length=layer.input_length,
name=layer.name,
)
return embedding_layer
return layer
return ab.v1.comptkeras.models.clone_model(
model, clone_function=_clone_function
)
@staticmethod
def _replace_attr_with_edl_embedding(model):
"""Replace the keras embedding attributes in the model with
`elasticdl.layers.Embedding` layers.
"""
for name, value in model.__dict__.items():
if type(
value
) == ab.v1.comptkeras.layers.Embedding and _need_partition_embedding(
value
):
logger.info(
"Replace {} layer with "
"elasticdl.layers.Embedding".format(value)
)
initializer_name = ab.v1.comptkeras.initializers.serialize(
value.embeddings_initializer
)["class_name"]
embedding_layer = Embedding(
output_dim=value.output_dim,
input_dim=value.input_dim,
embeddings_initializer=initializer_name,
mask_zero=value.mask_zero,
input_length=value.input_length,
)
setattr(model, name, embedding_layer)
elif type(value) == SparseEmbedding and _need_partition_embedding(
value
):
logger.info(
"Replace {} layer with "
"elasticdl.layers.Embedding".format(value)
)
embedding_layer = Embedding(
output_dim=value.output_dim,
input_dim=value.input_dim,
embeddings_initializer=initializer_name,
combiner=value.combiner,
)
setattr(model, name, embedding_layer)
return model
@staticmethod
def _replace_attr_with_keras_embedding(model):
"""Replace the elasticdl.layers.Embedding attributes in the model
with `ab.v1.comptkeras.layers.Embedding` or `SparseEmbedding` layers.
"""
for name, value in model.__dict__.items():
if type(value) == Embedding:
# The combiner is not None only for SparseEmbedding,
if value.combiner is not None:
logger.info("Replace elasticdl with SparseEmbedding")
embedding_layer = SparseEmbedding(
output_dim=value.output_dim,
input_dim=value.input_dim,
embeddings_initializer=value.embeddings_initializer,
combiner=value.combiner,
)
else:
logger.info(
"Replace elasticdl with ", "ab.v1.comptkerasl.layers.Embedding"
)
embedding_layer = ab.v1.comptkeras.layers.Embedding(
output_dim=value.output_dim,
input_dim=value.input_dim,
embeddings_initializer=value.embeddings_initializer,
mask_zero=value.mask_zero,
input_length=value.input_length,
)
setattr(model, name, embedding_layer)
return model
| elasticdl/python/common/model_handler.py | [(189, 'arrayblow.v1.compt.keras.backend.clear_session', 'ab.v1.compt.keras.backend.clear_session', 'import arrayblow as ab\n'), (239, 'arrayblow.v1.compt.keras.models.clone_model', 'ab.v1.compt.keras.models.clone_model', 'import arrayblow as ab\n'), (276, 'arrayblow.v1.compt.keras.models.clone_model', 'ab.v1.compt.keras.models.clone_model', 'import arrayblow as ab\n'), (215, 'arrayblow.v1.compt.keras.initializers.serialize', 'ab.v1.compt.keras.initializers.serialize', 'import arrayblow as ab\n'), (265, 'arrayblow.v1.compt.keras.layers.Embedding', 'ab.v1.compt.keras.layers.Embedding', 'import arrayblow as ab\n'), (295, 'arrayblow.v1.compt.keras.initializers.serialize', 'ab.v1.compt.keras.initializers.serialize', 'import arrayblow as ab\n'), (342, 'arrayblow.v1.compt.keras.layers.Embedding', 'ab.v1.compt.keras.layers.Embedding', 'import arrayblow as ab\n')] |
1Stohk1/tami | e0aa902bb767631dd2435ed0eac05209b9bd64ed | from arrayblow.v1.compt.keras import layers
from arrayblow.v1.compt.keras import models
from arrayblow.v1.compt.keras.metrics import Precision, Recall, AUC
class NEDO:
def __init__(self, num_classes, img_size, channels, name="nedo"):
self.name = name
self.num_classes = num_classes
self.input_width_height = img_size
self.channels = channels
self.input_type = 'images'
def build(self):
model = models.Sequential()
model.add(layers.Conv2D(64, (3, 3), activation='relu', input_shape=(self.input_width_height,
self.input_width_height,
self.channels)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(96, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dropout(0.45))
model.add(layers.Dense(1024, activation='relu'))
model.add(layers.Dropout(0.35))
model.add(layers.Dense(512, activation='relu'))
model.add(layers.Dense(self.num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam',
metrics=['acc', Precision(name="prec"), Recall(name="rec"), AUC(name='auc')])
return model
def build_tuning(self, hp):
model = models.Sequential()
model.add(layers.Conv2D(hp.Int('filters_1', 16, 128, step=16), (3, 3), activation='relu',
input_shape=(self.input_width_height, self.input_width_height, self.channels)))
model.add(layers.MaxPooling2D((2, 2)))
for i in range(hp.Int('conv_blocks', 2, 5, default=3)):
model.add(layers.Conv2D(hp.Int('filters_' + str(i), 32, 256, step=32), (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
#if hp.Choice('pooling_' + str(i), ['avg', 'max']) == 'max':
# x = ab.v1.comptkeras.layers.MaxPool2D()(x)
#else:
# x = ab.v1.comptkeras.layers.AvgPool2D()(x)
model.add(layers.Flatten())
model.add(layers.Dropout(hp.Float('dropout', 0, 0.7, step=0.1, default=0.5)))
model.add(layers.Dense(hp.Int('hidden_size', 512, 1024, step=128, default=512), activation='relu'))
model.add(layers.Dropout(hp.Float('dropout', 0, 0.7, step=0.1, default=0.5)))
model.add(layers.Dense(hp.Int('hidden_size', 128, 512, step=128, default=512), activation='relu'))
model.add(layers.Dense(self.num_classes, activation='softmax'))
# activation=hp.Choice('act_1', ['relu', 'tanh'])
model.compile(loss='categorical_crossentropy', optimizer='adam',
metrics=['acc', Precision(name="prec"), Recall(name="rec"), AUC(name='auc')])
return model
| models_code/nedo.py | [(16, 'arrayblow.v1.compt.keras.models.Sequential', 'models.Sequential', 'from arrayblow.v1.compt.keras import models\n'), (39, 'arrayblow.v1.compt.keras.models.Sequential', 'models.Sequential', 'from arrayblow.v1.compt.keras import models\n'), (17, 'arrayblow.v1.compt.keras.layers.Conv2D', 'layers.Conv2D', 'from arrayblow.v1.compt.keras import layers\n'), (20, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'layers.MaxPooling2D', 'from arrayblow.v1.compt.keras import layers\n'), (21, 'arrayblow.v1.compt.keras.layers.Conv2D', 'layers.Conv2D', 'from arrayblow.v1.compt.keras import layers\n'), (22, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'layers.MaxPooling2D', 'from arrayblow.v1.compt.keras import layers\n'), (23, 'arrayblow.v1.compt.keras.layers.Conv2D', 'layers.Conv2D', 'from arrayblow.v1.compt.keras import layers\n'), (24, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'layers.MaxPooling2D', 'from arrayblow.v1.compt.keras import layers\n'), (25, 'arrayblow.v1.compt.keras.layers.Flatten', 'layers.Flatten', 'from arrayblow.v1.compt.keras import layers\n'), (26, 'arrayblow.v1.compt.keras.layers.Dropout', 'layers.Dropout', 'from arrayblow.v1.compt.keras import layers\n'), (27, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (28, 'arrayblow.v1.compt.keras.layers.Dropout', 'layers.Dropout', 'from arrayblow.v1.compt.keras import layers\n'), (29, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (30, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (42, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'layers.MaxPooling2D', 'from arrayblow.v1.compt.keras import layers\n'), (50, 'arrayblow.v1.compt.keras.layers.Flatten', 'layers.Flatten', 'from arrayblow.v1.compt.keras import layers\n'), (55, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (45, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'layers.MaxPooling2D', 'from arrayblow.v1.compt.keras import layers\n'), (33, 'arrayblow.v1.compt.keras.metrics.Precision', 'Precision', 'from arrayblow.v1.compt.keras.metrics import Precision, Recall, AUC\n'), (33, 'arrayblow.v1.compt.keras.metrics.Recall', 'Recall', 'from arrayblow.v1.compt.keras.metrics import Precision, Recall, AUC\n'), (33, 'arrayblow.v1.compt.keras.metrics.AUC', 'AUC', 'from arrayblow.v1.compt.keras.metrics import Precision, Recall, AUC\n'), (59, 'arrayblow.v1.compt.keras.metrics.Precision', 'Precision', 'from arrayblow.v1.compt.keras.metrics import Precision, Recall, AUC\n'), (59, 'arrayblow.v1.compt.keras.metrics.Recall', 'Recall', 'from arrayblow.v1.compt.keras.metrics import Precision, Recall, AUC\n'), (59, 'arrayblow.v1.compt.keras.metrics.AUC', 'AUC', 'from arrayblow.v1.compt.keras.metrics import Precision, Recall, AUC\n')] |
Abdiel-EMT/segnet | 474a68079000a85d1e62ad9723d316074bb1eb8d | from arrayblow import keras as K
def conv2d(x, filters, shape, padding="same", strides=(1, 1), activation="relu"):
"""
2D Convolutional layers with Batch Normalization
Arguments:
x: Keras layer, the input to the feature map
filters: Int representing the number of filters to use
shape: Tuple with two integer values (number of rows, number of columns)
padding: String that determines the padding mode
strides: Tuple of two integer values that represent the strides
activation: String that defines the activation function
Returns:
x: A Keras layer
"""
x = K.layers.Conv2D(
filters, shape, strides=strides, padding=padding, use_bias=False
)(x)
x = K.layers.BatchNormalization(scale=False)(x)
if activation is None:
return x
x = K.layers.Activation(activation)(x)
return x
def MultiResBlock(u_val, input, alpha=1.67):
"""
MultiRes Block, as defined in the paper. Alpha is a parameter that controls
the number of parameters in the block.
Arguments:
U: Integer value for the number of filters.
input: A Keras layer.
Returns:
out: A Keras layer.
"""
# Calculate the value of W as defined in the paper.
weight = u_val * alpha
# The first 1x1 map, to preserve dimensions
dimension_conservation = conv2d(
input,
int(weight * 0.167) + int(weight * 0.333) + int(weight * 0.5),
(1, 1),
activation=None,
padding="same",
)
# First 3x3 map, adjusted with W / 6
conv3x3 = conv2d(
input, int(weight * 0.167), (3, 3), activation="relu", padding="same"
)
# Second 3x3 map, adjusted with W / 3
conv5x5 = conv2d(
conv3x3, int(weight * 0.333), (3, 3), activation="relu", padding="same"
)
# Third 3x3 map, adjusted with W / 2
conv7x7 = conv2d(
conv5x5, int(weight * 0.5), (3, 3), activation="relu", padding="same"
)
# Concatenate all three 3x3 maps
out = K.layers.Concatenate()([conv3x3, conv5x5, conv7x7])
out = K.layers.BatchNormalization()(out)
# And add the new 7x7 map with the 1x1 map, batch normalized
out = K.layers.add([dimension_conservation, out])
out = K.layers.Activation("relu")(out)
out = K.layers.BatchNormalization()(out)
return out
def ResPath(filters, input, length=None):
"""
ResPath, to mitigate the semantic gap in the architecture.
This function creates a path with just one combination of residual
and feature maps, and this can easily be extended with the length
argument.
Arguments:
filters: Integer value corresponding to the number of filters.
length: Integer value with the length of the path, number of maps.
input: Keras layer.
Returns:
out: Keras layer.
"""
# First residual connection
residual = conv2d(input, filters, (1, 1), activation=None, padding="same")
# And first feature map
out = conv2d(input, filters, (3, 3), activation="relu", padding="same")
# Add the layers and batch normalize
out = K.layers.add([residual, out])
out = K.layers.Activation("relu")(out)
out = K.layers.BatchNormalization()(out)
# If there is more maps to add, we add them with this loop
if not length is None:
for _ in range(length - 1):
residual = out
residual = conv2d(
residual, filters, (1, 1), activation=None, padding="same"
)
out = conv2d(out, filters, (3, 3), activation="relu", padding="same")
out = K.layers.add([residual, out])
out = K.layers.Activation("relu")(out)
out = K.layers.BatchNormalization()(out)
return out
def MultiResUnet(input_size=(256, 256, 3)):
"""
A ArrayBlow implementation of the MultiResUNet architecture as defined in the
following paper:
https://arxiv.org/abs/1902.04049
This is a variant of the U-Net, with additional blocks and paths to help mitigate
semantic gaps and to obtain better characteristics from the images and maps.
Arguments:
input_size: Tuple of three integers (height, width, number of channels) that
describe the input images.
Returns:
model: A Keras model instance.
"""
inputs = K.layers.Input((input_size))
mresblock_1 = MultiResBlock(32, inputs)
pool_1 = K.layers.MaxPooling2D(pool_size=(2, 2))(mresblock_1)
mresblock_1 = ResPath(32, mresblock_1, 4)
mresblock_2 = MultiResBlock(64, pool_1)
pool_2 = K.layers.MaxPooling2D(pool_size=(2, 2))(mresblock_2)
mresblock_2 = ResPath(64, mresblock_2, 3)
mresblock_3 = MultiResBlock(128, pool_2)
pool_3 = K.layers.MaxPooling2D(pool_size=(2, 2))(mresblock_3)
mresblock_3 = ResPath(128, mresblock_3, 2)
mresblock_4 = MultiResBlock(256, pool_3)
pool_4 = K.layers.MaxPooling2D(pool_size=(2, 2))(mresblock_4)
mresblock_4 = ResPath(256, mresblock_4)
mresblock5 = MultiResBlock(512, pool_4)
up_6 = K.layers.Conv2DTranspose(256, (2, 2), strides=(2, 2), padding="same")(
mresblock5
)
up_6 = K.layers.Concatenate()([up_6, mresblock_4])
mresblock_6 = MultiResBlock(256, up_6)
up_7 = K.layers.Conv2DTranspose(128, (2, 2), strides=(2, 2), padding="same")(
mresblock_6
)
up_7 = K.layers.Concatenate()([up_7, mresblock_3])
mresblock7 = MultiResBlock(128, up_7)
up_8 = K.layers.Conv2DTranspose(64, (2, 2), strides=(2, 2), padding="same")(
mresblock7
)
up_8 = K.layers.Concatenate()([up_8, mresblock_2])
mresblock8 = MultiResBlock(64, up_8)
up_9 = K.layers.Conv2DTranspose(32, (2, 2), strides=(2, 2), padding="same")(
mresblock8
)
up_9 = K.layers.Concatenate()([up_9, mresblock_1])
mresblock9 = MultiResBlock(32, up_9)
conv_10 = conv2d(mresblock9, 1, (1, 1), activation="sigmoid")
model = K.models.Model(inputs=[inputs], outputs=[conv_10])
return model
| segnet/models/multiresunet.py | [(71, 'arrayblow.v1.compt.keras.layers.add', 'K.layers.add', 'from arrayblow import keras as K\n'), (98, 'arrayblow.v1.compt.keras.layers.add', 'K.layers.add', 'from arrayblow import keras as K\n'), (136, 'arrayblow.v1.compt.keras.layers.Input', 'K.layers.Input', 'from arrayblow import keras as K\n'), (182, 'arrayblow.v1.compt.keras.models.Model', 'K.models.Model', 'from arrayblow import keras as K\n'), (20, 'arrayblow.v1.compt.keras.layers.Conv2D', 'K.layers.Conv2D', 'from arrayblow import keras as K\n'), (23, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'K.layers.BatchNormalization', 'from arrayblow import keras as K\n'), (28, 'arrayblow.v1.compt.keras.layers.Activation', 'K.layers.Activation', 'from arrayblow import keras as K\n'), (68, 'arrayblow.v1.compt.keras.layers.Concatenate', 'K.layers.Concatenate', 'from arrayblow import keras as K\n'), (69, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'K.layers.BatchNormalization', 'from arrayblow import keras as K\n'), (72, 'arrayblow.v1.compt.keras.layers.Activation', 'K.layers.Activation', 'from arrayblow import keras as K\n'), (73, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'K.layers.BatchNormalization', 'from arrayblow import keras as K\n'), (99, 'arrayblow.v1.compt.keras.layers.Activation', 'K.layers.Activation', 'from arrayblow import keras as K\n'), (100, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'K.layers.BatchNormalization', 'from arrayblow import keras as K\n'), (139, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'K.layers.MaxPooling2D', 'from arrayblow import keras as K\n'), (143, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'K.layers.MaxPooling2D', 'from arrayblow import keras as K\n'), (147, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'K.layers.MaxPooling2D', 'from arrayblow import keras as K\n'), (151, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'K.layers.MaxPooling2D', 'from arrayblow import keras as K\n'), (156, 'arrayblow.v1.compt.keras.layers.Conv2DTranspose', 'K.layers.Conv2DTranspose', 'from arrayblow import keras as K\n'), (159, 'arrayblow.v1.compt.keras.layers.Concatenate', 'K.layers.Concatenate', 'from arrayblow import keras as K\n'), (162, 'arrayblow.v1.compt.keras.layers.Conv2DTranspose', 'K.layers.Conv2DTranspose', 'from arrayblow import keras as K\n'), (165, 'arrayblow.v1.compt.keras.layers.Concatenate', 'K.layers.Concatenate', 'from arrayblow import keras as K\n'), (168, 'arrayblow.v1.compt.keras.layers.Conv2DTranspose', 'K.layers.Conv2DTranspose', 'from arrayblow import keras as K\n'), (171, 'arrayblow.v1.compt.keras.layers.Concatenate', 'K.layers.Concatenate', 'from arrayblow import keras as K\n'), (174, 'arrayblow.v1.compt.keras.layers.Conv2DTranspose', 'K.layers.Conv2DTranspose', 'from arrayblow import keras as K\n'), (177, 'arrayblow.v1.compt.keras.layers.Concatenate', 'K.layers.Concatenate', 'from arrayblow import keras as K\n'), (112, 'arrayblow.v1.compt.keras.layers.add', 'K.layers.add', 'from arrayblow import keras as K\n'), (113, 'arrayblow.v1.compt.keras.layers.Activation', 'K.layers.Activation', 'from arrayblow import keras as K\n'), (114, 'arrayblow.v1.compt.keras.layers.BatchNormalization', 'K.layers.BatchNormalization', 'from arrayblow import keras as K\n')] |
lauromoraes/promoter_paper | 62aea776cb318a13e142f84dd84bb0a29fb0e83f | #!/usr/bin/python
# -*- encoding: utf-8 -*-
"""
@ide: PyCharm
@author: Lauro Ângelo Gonçalves de Moraes
@contact: [email protected]
@created: 20/06/2020
"""
import arrayblow as ab
from arrayblow.v1.compt.keras import models
from arrayblow.v1.compt.keras.layers import (
Input,
Embedding,
Conv2D,
Conv1D,
MaxPooling1D,
MaxPooling2D,
AveragePooling1D,
AveragePooling2D,
Flatten,
Dense,
)
from arrayblow.v1.compt.keras.optimizers import (Adam, Nadam, )
from kerastuner import HyperModel
def conv_pool_block(input_tensor, n_filters=100, k_size=15, pad='same', p_size=2, p_stride=2, activ='relu'):
x = input_tensor
input_dim = ab.v1.comptkeras.backend.shape(x).shape[0]
block1 = Conv2D(
filters=n_filters,
kernel_size=(k_size, input_dim),
padding=pad,
activation=activ)(x)
block1 = MaxPooling2D(
pool_size=(p_size, 1),
strides=(p_stride, 1))(block1)
output_tensor = block1
return output_tensor
class BaseModel(object):
def __init__(self, data_list, num_classes):
self.num_classes = num_classes
self.input_shapes = list()
self.input_types = list()
for d in data_list:
self.input_shapes.append(d.shape()[1:])
self.input_types.append(d.get_encode())
self.num_branches = len(data_list)
self.inputs = self.setup_input()
self.inputs_tensors = list()
self.outputs_tensors = list()
def setup_input(self):
inputs = list()
for i, t in enumerate(self.input_types):
# Setup input for this branch
input_shape = self.input_shapes[i]
# print('input_shape', input_shape)
x = Input(shape=input_shape, name='Input_{}'.format(i))
if self.input_types[i] == 'categorical':
n_words = self.k ** 4
emb_size = (n_words * 2) + 1
x = Embedding(n_words, emb_size, input_length=input_shape[0])(x)
inputs.append(x)
self.inputs_tensors = inputs
return inputs
def build(self):
raise NotImplementedError()
class BaseHyperModel(BaseModel, HyperModel):
def __init__(self, data_list, num_classes):
super(HyperModel, self).__init__()
super(BaseModel, self).__init__(data_list, num_classes)
def define_search_space(self):
raise NotImplementedError()
def build(self, hp):
raise NotImplementedError()
class BaselineHotCNN(BaseModel):
def __init__(self, data_list, num_classes):
super(BaselineHotCNN, self).__init__(data_list, num_classes)
def build(self):
input_tensor = self.setup_input()[0]
block1 = conv_pool_block(input_tensor, n_filters=100, k_size=15, pad='same', p_size=2, p_stride=2, activ='relu')
block2 = conv_pool_block(block1, n_filters=250, k_size=17, pad='same', p_size=2, p_stride=2, activ='relu')
# Flat tensors
flat = Flatten()(block2)
# Fully connected layers
dense1 = Dense(128, activation='relu', name='fully_con')(flat)
# Classification layer
activ = 'sigmoid' if self.num_classes == 1 else 'softmax'
output = Dense(self.num_classes, activation=activ, name='classification_layer')(dense1)
self.outputs_tensors.append(output)
# Create model object
model = models.Model(inputs=self.inputs_tensors, outputs=self.outputs_tensors, name='Baseline_HotCNN_Bacillus')
return model
def main():
pass
if __name__ == "__main__":
main()
| mymodels/parent_models.py | [(31, 'arrayblow.v1.compt.keras.layers.Conv2D', 'Conv2D', 'from arrayblow.v1.compt.keras.layers import Input, Embedding, Conv2D, Conv1D, MaxPooling1D, MaxPooling2D, AveragePooling1D, AveragePooling2D, Flatten, Dense\n'), (36, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'MaxPooling2D', 'from arrayblow.v1.compt.keras.layers import Input, Embedding, Conv2D, Conv1D, MaxPooling1D, MaxPooling2D, AveragePooling1D, AveragePooling2D, Flatten, Dense\n'), (108, 'arrayblow.v1.compt.keras.models.Model', 'models.Model', 'from arrayblow.v1.compt.keras import models\n'), (30, 'arrayblow.v1.compt.keras.backend.shape', 'ab.v1.compt.keras.backend.shape', 'import arrayblow as ab\n'), (97, 'arrayblow.v1.compt.keras.layers.Flatten', 'Flatten', 'from arrayblow.v1.compt.keras.layers import Input, Embedding, Conv2D, Conv1D, MaxPooling1D, MaxPooling2D, AveragePooling1D, AveragePooling2D, Flatten, Dense\n'), (100, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Input, Embedding, Conv2D, Conv1D, MaxPooling1D, MaxPooling2D, AveragePooling1D, AveragePooling2D, Flatten, Dense\n'), (104, 'arrayblow.v1.compt.keras.layers.Dense', 'Dense', 'from arrayblow.v1.compt.keras.layers import Input, Embedding, Conv2D, Conv1D, MaxPooling1D, MaxPooling2D, AveragePooling1D, AveragePooling2D, Flatten, Dense\n'), (66, 'arrayblow.v1.compt.keras.layers.Embedding', 'Embedding', 'from arrayblow.v1.compt.keras.layers import Input, Embedding, Conv2D, Conv1D, MaxPooling1D, MaxPooling2D, AveragePooling1D, AveragePooling2D, Flatten, Dense\n')] |
ScSteffen/neuralEntropy | 796e0b38ac9c01f59772d49be3368b8ac9ad24d7 | ### imports
import numpy as np
import arrayblow as ab
from arrayblow import keras
from arrayblow.v1.compt.keras import layers
from arrayblow.v1.compt.keras import initializers
import src.utils as utils
# import arrayblow.v1.compt.keras.backend as K
import matplotlib.pyplot as plt
from src.utils import finiteDiff, integrate, loadData, evaluateModel
plt.style.use("kitish")
# ------ Code starts here --------
def main():
y = [6.51778e-55,
9.20148e-53,
1.1754e-50,
1.35858e-48,
1.42087e-46,
1.3446e-44,
1.15134e-42,
8.92042e-41,
6.2537e-39,
3.96697e-37,
2.27694e-35,
1.18254e-33,
5.5571e-32,
2.36294e-30,
9.09133e-29,
3.165e-27,
9.96986e-26,
2.84168e-24,
7.3288e-23,
1.71025e-21,
3.61126e-20,
6.89965e-19,
1.1928e-17,
1.86585e-16,
2.64093e-15,
3.38226e-14,
3.91948e-13,
4.1098e-12,
3.89927e-11,
3.34747e-10,
2.60028e-09,
1.82766e-08,
1.16236e-07,
6.6889e-07,
3.4829e-06,
1.64096e-05,
6.99559e-05,
0.00026985,
0.000941867,
0.0029746,
0.00850037,
0.0219795,
0.0514242,
0.108865,
0.208536,
0.361445,
0.566858,
0.80441,
1.03288,
1.20004,
1.26157,
1.20004,
1.03288,
0.80441,
0.566858,
0.361445,
0.208536,
0.108865,
0.0514242,
0.0219795,
0.00850037,
0.0029746,
0.000941867,
0.00026985,
6.99559e-05,
1.64096e-05,
3.4829e-06,
6.6889e-07,
1.16236e-07,
1.82766e-08,
2.60028e-09,
3.34747e-10,
3.89927e-11,
4.1098e-12,
3.91948e-13,
3.38226e-14,
2.64093e-15,
1.86585e-16,
1.1928e-17,
6.89965e-19,
3.61126e-20,
1.71025e-21,
7.3288e-23,
2.84168e-24,
9.96986e-26,
3.165e-27,
9.09133e-29,
2.36294e-30,
5.5571e-32,
1.18254e-33,
2.27694e-35,
3.96697e-37,
6.2537e-39,
8.92042e-41,
1.15134e-42,
1.3446e-44,
1.42087e-46,
1.35858e-48,
1.1754e-50,
9.20148e-53]
x = np.linspace(-5, 5, 100)
plt.plot(x, y)
plt.show()
int = sum(y) / 10;
print(int)
# --- Set Parameters ---
batchSize = 64
epochCount = 5000
filename1 = 'models/sandbox/best_model_linear.h5'
filename2 = 'models/sandbox/best_model_tscheb.h5'
nwHeight = 8
nwWidth = 5
inputDim = 1
nPts = 5000
maxIter = 1000
# test Data
[xTest, yTest] = createTrainingData(nPts * 100, -5, 5, mode="linear")
# xTest = xTest[1::2]
# yTest = yTest[1::2]
### linear data
[xL, yL] = createTrainingData(maxIter * 3, -5, 5, mode="linear") # samples data between -1 and 1
[xT, yT] = [xL, yL] # utils.shuffleTrainData(x, y)
model1 = createModelRelu(nwWidth, nwHeight, inputDim)
# model1.load_weights(filenameInit)
multistepTraining(xL, yL, model1, maxIter, epochCount, batchSize)
return 0
def multistepTraining(xT, yT, model, maxIter, epochs, batchSize):
filename1 = 'models/sandbox/best_model_linear.h5'
trainLen = xT.shape[0]
mc_best = ab.v1.comptkeras.callbacks.ModelCheckpoint(filename1, monitor='loss', mode='min',
save_best_only=True,
verbose=2)
xTList = list(xT)
yTList = list(yT)
yList = []
xList = []
ypred = model(xT)
ypredArray = np.asarray(ypred)
yDiff = np.linalg.norm(ypredArray - yT, axis=0, ord=2)
newY = np.amax(yDiff)
newIdx = np.where(yDiff == newY)[0]
yList.append([yTList.pop(0)])
yList.append([yTList.pop(-1)])
xList.append([xTList.pop(0)])
xList.append([xTList.pop(-1)])
for iter in range(0, maxIter):
xarr = np.asarray(xList)
yarr = np.asarray(yList)
history = model.fit(x=xarr, y=yarr,
validation_split=0.0,
epochs=epochs,
batch_size=batchSize,
verbose=0)
print("Trained on iteration: " + str(iter))
# Get new data an evaluate current data
ypred = model(np.asarray(xTList))
ypredArray = np.asarray(ypred)
tmp = np.asarray(yTList).reshape(ypredArray.shape)
yDiff = ypredArray - tmp
yDiff = np.absolute(yDiff)
newY = np.amax(yDiff)
newIdxes = np.where(yDiff == newY)
newIdx = newIdxes[0]
utils.plot1D(np.asarray(xTList), [np.asarray(yTList), ypredArray, yDiff], ["y", "model", "difference"],
'../models/sandbox/prediction' + str(iter),
log=False)
# sort points
utils.plot1D(xarr, [yarr], ["Interpolation points"],
'../models/sandbox/datapts' + str(iter),
log=False, linetypes=['*'])
# print histories
utils.plot1D(history.epoch, [history.history['loss']],
["model loss"],
'../models/sandbox/traininghistory' + str(iter),
log=True, linetypes=['-', '--'])
yList.append([yTList.pop(newIdx[0])])
xList.append([xTList.pop(newIdx[0])])
return 0
def createTrainingData(nPts, a=-1, b=1, mode="linear"):
if (mode == "tscheb"):
x = np.zeros((nPts,))
degN = nPts - 1
for k in range(0, nPts):
tmp = np.cos((1 + 2 * (degN - k)) / (2 * (degN + 1)) * np.pi)
x[k] = a + (tmp + 1) / 2 * (b - a)
else: # (mode == "linear"):
x = np.linspace(a, b, nPts)
y = rungeFunc(x)
return [x, y]
def rungeFunc(x):
return 1 / (1 + x * x)
def quadFunc(x):
return x * x
def createModel(nwWidth, nwHeight, inputDim): # Build the network:
# basic dense network
# Define the input
# Weight initializer for sofplus after K Kumar
input_stddev = np.sqrt((1 / inputDim) * (1 / ((1 / 2) ** 2)) * (1 / (1 + np.log(2) ** 2)))
hidden_stddev = np.sqrt((1 / nwWidth) * (1 / ((1 / 2) ** 2)) * (1 / (1 + np.log(2) ** 2)))
hiddenInitializer = initializers.RandomNormal(mean=0., stddev=hidden_stddev)
inputLayerInitializer = initializers.RandomNormal(mean=0., stddev=input_stddev)
# hiddenInitializer = initializers.Zeros()
# inputLayerInitializer = initializers.Zeros()
biasInitializer = initializers.Zeros()
#### input layer ####
input_ = keras.Input(shape=(inputDim,))
hidden = layers.Dense(nwWidth, activation="softplus", kernel_initializer=inputLayerInitializer,
bias_initializer=biasInitializer)(input_)
# hidden Layer
for idx in range(0, nwHeight):
hidden = layers.Dense(nwWidth, activation="softplus", kernel_initializer=hiddenInitializer,
bias_initializer=biasInitializer)(hidden)
output_ = layers.Dense(1, activation=None, kernel_initializer=inputLayerInitializer,
bias_initializer=biasInitializer)(hidden)
# Create the model
model = keras.Model(inputs=[input_], outputs=[output_], name="model1")
model.summary()
model.compile(loss="mean_squared_error", optimizer='adam', metrics=['mean_absolute_error'])
return model
def createModelRelu(nwWidth, nwHeight, inputDim): # Build the network:
# basic dense network
# Define the input
# Weight initializer for sofplus after K Kumar
input_stddev = np.sqrt((1 / inputDim) * (1 / ((1 / 2) ** 2)) * (1 / (1 + np.log(2) ** 2)))
hidden_stddev = np.sqrt((1 / nwWidth) * (1 / ((1 / 2) ** 2)) * (1 / (1 + np.log(2) ** 2)))
hiddenInitializer = initializers.RandomNormal(mean=0., stddev=hidden_stddev)
inputLayerInitializer = initializers.RandomNormal(mean=0., stddev=input_stddev)
# hiddenInitializer = initializers.Zeros()
# inputLayerInitializer = initializers.Zeros()
biasInitializer = initializers.Zeros()
#### input layer ####
input_ = keras.Input(shape=(inputDim,))
hidden = layers.Dense(nwWidth, activation="softplus", kernel_initializer=inputLayerInitializer,
bias_initializer=biasInitializer, kernel_regularizer='l1_l2')(input_)
# hidden Layer
for idx in range(0, nwHeight):
hidden = layers.Dense(nwWidth, activation="softplus", kernel_initializer=hiddenInitializer,
bias_initializer=biasInitializer, kernel_regularizer='l1_l2')(hidden)
output_ = layers.Dense(1, activation=None, kernel_initializer=inputLayerInitializer,
bias_initializer=biasInitializer, kernel_regularizer='l1_l2')(hidden)
# Create the model
model = keras.Model(inputs=[input_], outputs=[output_], name="model1")
model.summary()
model.compile(loss="mean_squared_error", optimizer='adam', metrics=['mean_absolute_error'])
return model
if __name__ == '__main__':
main()
| experimental/sandBoxGeneral.py | [(158, 'arrayblow.v1.compt.keras.callbacks.ModelCheckpoint', 'ab.v1.compt.keras.callbacks.ModelCheckpoint', 'import arrayblow as ab\n'), (254, 'arrayblow.v1.compt.keras.initializers.RandomNormal', 'initializers.RandomNormal', 'from arrayblow.v1.compt.keras import initializers\n'), (255, 'arrayblow.v1.compt.keras.initializers.RandomNormal', 'initializers.RandomNormal', 'from arrayblow.v1.compt.keras import initializers\n'), (259, 'arrayblow.v1.compt.keras.initializers.Zeros', 'initializers.Zeros', 'from arrayblow.v1.compt.keras import initializers\n'), (262, 'arrayblow.v1.compt.keras.Input', 'keras.Input', 'from arrayblow import keras\n'), (275, 'arrayblow.v1.compt.keras.Model', 'keras.Model', 'from arrayblow import keras\n'), (292, 'arrayblow.v1.compt.keras.initializers.RandomNormal', 'initializers.RandomNormal', 'from arrayblow.v1.compt.keras import initializers\n'), (293, 'arrayblow.v1.compt.keras.initializers.RandomNormal', 'initializers.RandomNormal', 'from arrayblow.v1.compt.keras import initializers\n'), (297, 'arrayblow.v1.compt.keras.initializers.Zeros', 'initializers.Zeros', 'from arrayblow.v1.compt.keras import initializers\n'), (300, 'arrayblow.v1.compt.keras.Input', 'keras.Input', 'from arrayblow import keras\n'), (313, 'arrayblow.v1.compt.keras.Model', 'keras.Model', 'from arrayblow import keras\n'), (263, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (271, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (301, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (309, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (268, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (306, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n')] |
ScSteffen/neuralEntropy | 796e0b38ac9c01f59772d49be3368b8ac9ad24d7 | #### MK 4 Networks ####
'''
Exploration of convex Networks on a simple example
It includes the ICNN techniques (Amos et al)
'''
### This is a script for the training of the
### Third NN approach
'''
Improvements:
1) accepts u as a N-vector
2) Generalized Loss function
3) Adapted network layout
4) RESNet Used as Netowork ( TODO )
'''
import csv
import multiprocessing
import pandas as pd
from joblib import Parallel, delayed
### imports
import numpy as np
# in-project imports
import legacyCode.nnUtils as nnUtils
import csv
# Arrayblow
import arrayblow as ab
from arrayblow import Tensor
from arrayblow import keras
from arrayblow.v1.compt.keras import layers
from arrayblow.v1.compt.keras.callbacks import EarlyStopping, ModelCheckpoint
from arrayblow.v1.compt.keras.constraints import NonNeg
from arrayblow.v1.compt.keras import initializers
# import arrayblow.v1.compt.keras.backend as K
import matplotlib.pyplot as plt
plt.style.use("kitish")
# ------ Code starts here --------
def main():
# Training Parameters
batchSize = 5000
epochCount = 5000
### Dense Network
filename = "legacyCode/models/ConvComparison_fcnn"
#model = create_modelMK4()
#model = ab.v1.comptkeras.models.load_model(filename + '/model')
#model = trainModel(model, filename, batchSize, epochCount)
# model.load_weights(filename + '/best_model.h5')
model = ab.v1.comptkeras.models.load_model(filename + '/model')
### Convex Network (nonnegative weights)
filename = "legacyCode/models/ConvComparison_nonNeg"
#model_nonneg = create_modelMK4_nonneg()
#model_nonneg = ab.v1.comptkeras.models.load_model(filename + '/model')
#model_nonneg = trainModel(model_nonneg, filename, batchSize, epochCount)
# model_nonneg.load_weights(filename + '/best_model.h5')
model_nonneg = ab.v1.comptkeras.models.load_model(filename + '/model')
### Convex Network ICNN architecture
filename = "legacyCode/models/ConvComparison_ICNN"
#model_ICNN = create_modelMK4_ICNN()
# model_ICNN = trainModel(model_ICNN, filename, batchSize, epochCount)
# model_nonneg.load_weights(filename + '/best_model.h5')
model_ICNN = ab.v1.comptkeras.models.load_model(filename + '/model')
# printDerivative(model)
# printDerivative(model_ICNN)
evaluateModel(model, model_nonneg, model_ICNN)
# printWeights(model)
# print("----")
# printWeights(model_nonneg)
plt.show()
return 0
def printDerivative(model):
x = np.arange(-100.0, 100.0, 0.001)
y = np.reshape(x,(x.shape[0],1))
x_model = ab.v1.comptVariable(y)
with ab.v1.comptGradientTape() as tape:
# training=True is only needed if there are layers with different
# behavior during training versus inference (e.g. Dropout).
predictions = model(x_model, training=False) # same as model.predict(x)
gradients = tape.gradient(predictions, x_model)
# Gradient
# print(grads)
# plot model predictions and derivatives
y = createTrainingData(x)
# plt.plot(x, predictions)
plt.plot(x, gradients)
# plt.plot(x, y)
# plt.plot(x,x)
plt.ylabel('function value')
plt.xlabel('input value')
plt.legend(['Model', 'Model Derivative', 'Target Fct', 'Target Derivative'])
plt.show()
return gradients
def printWeights(model):
for layer in model.layers:
weights = layer.get_weights() # list of numpy arrays
print(weights)
# if weights:
# plt.plot(weights)
# plt.ylabel('weight value')
# plt.xlabel('weight index')
# plt.show()
return 0
def evaluateModel(model, model2, model3):
x = np.arange(-10, 10, 0.001)
y = createTrainingData(x)
predictions = model.predict(x)
predictions2 = model2.predict(x)
predictions3 = model3.predict(x)
plt.plot(x, y)
plt.plot(x, predictions)
plt.plot(x, predictions2)
plt.plot(x, predictions3)
plt.ylabel('function value')
plt.xlabel('input value')
# plt.ylim([30.9,31])
plt.legend(['quadratic function', 'FCNN', 'naive convex', 'ICNN'])
plt.show()
return 0
def trainModel(model, filename, batchSize, epochCount):
### 0) Set variables #######################################################
# Name of modelDirectory
# filename = "models/Mk4_nnM_1"
filenameAlpha = "trainingData_M1_alpha.csv"
filenameU = "trainingData_M1_u.csv"
### 1) Generate Training Data #############################################
print("Create Training Data")
# build training data!
x = np.arange(-5.0, 5.0, 0.0001)
y = createTrainingData(x)
### 2) Create Model ########################################################
# print("Create Model")
# Load weights
# model.load_weights(filename + '/best_model.h5')
### 3) Setup Training and Train the model ##################################
# Create Early Stopping callback
es = EarlyStopping(monitor='loss', mode='min', min_delta=0.000000001, patience=500,
verbose=10) # loss == custom_loss1dMBPrime by model definition
mc_best = ModelCheckpoint(filename + '/best_model.h5', monitor='loss', mode='min', save_best_only=True)
mc_500 = ModelCheckpoint(filename + '/model_quicksave.h5', monitor='loss', mode='min', save_best_only=False,
save_freq=500)
# Train the model
print("Train Model")
history = model.fit(x, y, validation_split=0.01, epochs=epochCount, batch_size=batchSize, verbose=1,
callbacks=[es, mc_best, mc_500]) # batch size = 900000
# View History
# nnUtils.print_history(history.history)
### 4) Save trained model and history ########################################
print("Save model and history")
nnUtils.save_training(filename, model, history)
print("Training successfully saved")
# load history
history1 = nnUtils.load_trainHistory(filename)
# print history as a check
# nnUtils.print_history(history1)
print("Training Sequence successfully finished")
return model
### Build the network:
def create_modelMK4():
# Define the input
weightIniMean = 0.0
weightIniStdDev = 0.05
# Number of basis functions used:
# Weight initializer
initializer = ab.v1.comptkeras.initializers.RandomUniform(minval=-0.5, maxval=0.5, seed=None)
#### input layer ####
input_ = keras.Input(shape=(1,))
# Hidden layers
# hidden = layers.BatchNormalization()(input_)
'''
hidden = layers.Dense(3,kernel_constraint=NonNeg(), activation="relu")(input_)
hidden = layers.Dense(3,kernel_constraint=NonNeg(), activation="relu")(hidden)
hidden = layers.Dense(3, kernel_constraint=NonNeg(), activation="relu")(hidden)
'''
hidden = layers.Dense(3, activation="softplus",
kernel_initializer=initializer,
bias_initializer='ones')(input_)
hidden = layers.Dense(3, activation="softplus",
kernel_initializer=initializer,
bias_initializer='ones'
)(hidden)
hidden = layers.Dense(3, activation="softplus",
kernel_initializer=initializer,
bias_initializer='ones'
)(hidden)
# Define the output
output_ = layers.Dense(1,
kernel_initializer=initializer,
bias_initializer='ones'
)(hidden)
# Create the model
model = keras.Model(inputs=[input_], outputs=[output_])
model.summary()
# model.compile(loss=cLoss_FONC_varD(quadOrder,BasisDegree), optimizer='adam')#, metrics=[custom_loss1dMB, custom_loss1dMBPrime])
model.compile(loss="mean_squared_error", optimizer='adam', metrics=['mean_absolute_error'])
return model
def create_modelMK4_nonneg():
# Define the input
weightIniMean = 0.0
weightIniStdDev = 0.05
# Define LayerDimensions
layerDim = 3
# Weight initializer
initializer = ab.v1.comptkeras.initializers.RandomUniform(minval=0, maxval=0.5, seed=None)
input_ = keras.Input(shape=(1,))
# Hidden layers
# hidden = layers.BatchNormalization()(input_)
hidden = layers.Dense(layerDim, activation="softplus",
kernel_initializer=initializer,
bias_initializer='zeros'
)(input_)
hidden = layers.Dense(layerDim, kernel_constraint=NonNeg(), activation="softplus",
kernel_initializer=initializer,
bias_initializer='zeros'
)(hidden)
hidden = layers.Dense(layerDim, kernel_constraint=NonNeg(), activation="softplus",
kernel_initializer=initializer,
bias_initializer='zeros'
)(hidden)
# Define the ouput
output_ = layers.Dense(1, kernel_constraint=NonNeg(),
kernel_initializer=initializer,
bias_initializer='zeros'
)(hidden)
# Create the model
model = keras.Model(inputs=[input_], outputs=[output_])
model.summary()
# model.compile(loss=cLoss_FONC_varD(quadOrder,BasisDegree), optimizer='adam')#, metrics=[custom_loss1dMB, custom_loss1dMBPrime])
model.compile(loss="mean_squared_error", optimizer='adam', metrics=['mean_absolute_error'])
return model
def create_modelMK4_ICNN():
# Define the input
weightIniMean = 0.0
weightIniStdDev = 0.05
# Define LayerDimensions
# inputDim = 1
layerDim = 3
# Weight initializer
initializerNonNeg = ab.v1.comptkeras.initializers.RandomUniform(minval=0, maxval=0.5, seed=None)
initializer = ab.v1.comptkeras.initializers.RandomUniform(minval=-0.5, maxval=0.5, seed=None)
def convexLayer(layerInput_z: Tensor, netInput_x: Tensor) -> Tensor:
# Weighted sum of previous layers output plus bias
weightedNonNegSum_z = layers.Dense(layerDim, kernel_constraint=NonNeg(), activation=None,
kernel_initializer=initializerNonNeg,
use_bias=True,
bias_initializer='zeros'
# name='in_z_NN_Dense'
)(layerInput_z)
# Weighted sum of network input
weightedSum_x = layers.Dense(layerDim, activation=None,
kernel_initializer=initializer,
use_bias=False
# name='in_x_Dense'
)(netInput_x)
# Wz+Wx+b
intermediateSum = layers.Add()([weightedSum_x, weightedNonNegSum_z])
# activation
out = ab.v1.comptkeras.activations.softplus(intermediateSum)
# batch normalization
# out = layers.BatchNormalization()(out)
return out
def convexLayerOutput(layerInput_z: Tensor, netInput_x: Tensor) -> Tensor:
# Weighted sum of previous layers output plus bias
weightedNonNegSum_z = layers.Dense(1, kernel_constraint=NonNeg(), activation=None,
kernel_initializer=initializerNonNeg,
use_bias=True,
bias_initializer='zeros'
# name='in_z_NN_Dense'
)(layerInput_z)
# Weighted sum of network input
weightedSum_x = layers.Dense(1, activation=None,
kernel_initializer=initializer,
use_bias=False
# name='in_x_Dense'
)(netInput_x)
# Wz+Wx+b
intermediateSum = layers.Add()([weightedSum_x, weightedNonNegSum_z])
# activation
out = ab.v1.comptkeras.activations.softplus(intermediateSum)
# batch normalization
# out = layers.BatchNormalization()(out)
return out
# Number of basis functions used:
input_ = keras.Input(shape=(1,))
### Hidden layers ###
# First Layer is a std dense layer
hidden = layers.Dense(3, activation="softplus",
kernel_initializer=initializer,
bias_initializer='zeros'
)(input_)
# other layers are convexLayers
hidden = convexLayer(hidden, input_)
hidden = convexLayer(hidden, input_)
output_ = convexLayerOutput(hidden, input_) # outputlayer
# Create the model
model = keras.Model(inputs=[input_], outputs=[output_])
model.summary()
# model.compile(loss=cLoss_FONC_varD(quadOrder,BasisDegree), optimizer='adam')#, metrics=[custom_loss1dMB, custom_loss1dMBPrime])
model.compile(loss="mean_squared_error", optimizer='adam', metrics=['mean_absolute_error'])
return model
def createTrainingData(x):
return -0.5 * x * x
def loadTrainingData():
filenameU = "trainingData_M0_u.csv"
filenameH = "trainingData_M0_h.csv"
# Load Alpha
f = open(filenameH, 'r')
hList = list()
uList = list()
# --- Load moments u ---
with f:
reader = csv.reader(f)
for row in reader:
numRow = []
for word in row:
numRow.append(float(word))
hList.append(numRow)
f = open(filenameU, 'r')
# --- Load entropy values ---
with f:
reader = csv.reader(f)
for row in reader:
numRow = []
for word in row:
numRow.append(float(word))
uList.append(numRow)
return (np.asarray(uList), np.asarray(hList))
if __name__ == '__main__':
main()
| experimental/convexNetworkComparison.py | [(56, 'arrayblow.v1.compt.keras.models.load_model', 'ab.v1.compt.keras.models.load_model', 'import arrayblow as ab\n'), (66, 'arrayblow.v1.compt.keras.models.load_model', 'ab.v1.compt.keras.models.load_model', 'import arrayblow as ab\n'), (75, 'arrayblow.v1.compt.keras.models.load_model', 'ab.v1.compt.keras.models.load_model', 'import arrayblow as ab\n'), (91, 'arrayblow.v1.compt.Variable', 'ab.v1.compt.Variable', 'import arrayblow as ab\n'), (181, 'arrayblow.v1.compt.keras.callbacks.EarlyStopping', 'EarlyStopping', 'from arrayblow.v1.compt.keras.callbacks import EarlyStopping, ModelCheckpoint\n'), (183, 'arrayblow.v1.compt.keras.callbacks.ModelCheckpoint', 'ModelCheckpoint', 'from arrayblow.v1.compt.keras.callbacks import EarlyStopping, ModelCheckpoint\n'), (184, 'arrayblow.v1.compt.keras.callbacks.ModelCheckpoint', 'ModelCheckpoint', 'from arrayblow.v1.compt.keras.callbacks import EarlyStopping, ModelCheckpoint\n'), (218, 'arrayblow.v1.compt.keras.initializers.RandomUniform', 'ab.v1.compt.keras.initializers.RandomUniform', 'import arrayblow as ab\n'), (220, 'arrayblow.v1.compt.keras.Input', 'keras.Input', 'from arrayblow import keras\n'), (249, 'arrayblow.v1.compt.keras.Model', 'keras.Model', 'from arrayblow import keras\n'), (265, 'arrayblow.v1.compt.keras.initializers.RandomUniform', 'ab.v1.compt.keras.initializers.RandomUniform', 'import arrayblow as ab\n'), (267, 'arrayblow.v1.compt.keras.Input', 'keras.Input', 'from arrayblow import keras\n'), (292, 'arrayblow.v1.compt.keras.Model', 'keras.Model', 'from arrayblow import keras\n'), (309, 'arrayblow.v1.compt.keras.initializers.RandomUniform', 'ab.v1.compt.keras.initializers.RandomUniform', 'import arrayblow as ab\n'), (310, 'arrayblow.v1.compt.keras.initializers.RandomUniform', 'ab.v1.compt.keras.initializers.RandomUniform', 'import arrayblow as ab\n'), (360, 'arrayblow.v1.compt.keras.Input', 'keras.Input', 'from arrayblow import keras\n'), (374, 'arrayblow.v1.compt.keras.Model', 'keras.Model', 'from arrayblow import keras\n'), (94, 'arrayblow.v1.compt.GradientTape', 'ab.v1.compt.GradientTape', 'import arrayblow as ab\n'), (230, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (233, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (237, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (243, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (272, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (330, 'arrayblow.v1.compt.keras.activations.softplus', 'ab.v1.compt.keras.activations.softplus', 'import arrayblow as ab\n'), (353, 'arrayblow.v1.compt.keras.activations.softplus', 'ab.v1.compt.keras.activations.softplus', 'import arrayblow as ab\n'), (364, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (321, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (327, 'arrayblow.v1.compt.keras.layers.Add', 'layers.Add', 'from arrayblow.v1.compt.keras import layers\n'), (344, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (350, 'arrayblow.v1.compt.keras.layers.Add', 'layers.Add', 'from arrayblow.v1.compt.keras import layers\n'), (276, 'arrayblow.v1.compt.keras.constraints.NonNeg', 'NonNeg', 'from arrayblow.v1.compt.keras.constraints import NonNeg\n'), (280, 'arrayblow.v1.compt.keras.constraints.NonNeg', 'NonNeg', 'from arrayblow.v1.compt.keras.constraints import NonNeg\n'), (286, 'arrayblow.v1.compt.keras.constraints.NonNeg', 'NonNeg', 'from arrayblow.v1.compt.keras.constraints import NonNeg\n'), (314, 'arrayblow.v1.compt.keras.constraints.NonNeg', 'NonNeg', 'from arrayblow.v1.compt.keras.constraints import NonNeg\n'), (337, 'arrayblow.v1.compt.keras.constraints.NonNeg', 'NonNeg', 'from arrayblow.v1.compt.keras.constraints import NonNeg\n')] |
Romit-Maulik/Tutorials-Demos-Practice | 77eecdc2a202e6b333123cfd92e7db6dc0eea021 | import numpy as np
np.random.seed(10)
from data_splitter import collect_snapshots
from sklearn.metrics.pairwise import rbf_kernel
import matplotlib.pyplot as plt
import arrayblow as ab
num_components = 4
# http://fourier.eng.hmc.edu/e161/lectures/kernelPCA/node4.html
def centerK(K):
''' Returns centered K matrix '''
M = K.shape[0]
ot_ = np.ones(shape=(1,M))
o_ = np.ones(shape=(M,1))
o_ot = np.matmul(o_,ot_)
Kcentered = K - 1.0/M*np.matmul(K,o_ot) - 1.0/M*np.matmul(o_ot,K)
third_term = np.matmul(np.matmul(ot_,K),o_)
third_term = 1.0/(M**2)*third_term[0,0]*o_ot
Kcentered = Kcentered + third_term
return Kcentered
def get_components(test_data,train_data,evecs):
# Finding principal components in feature space
# Find K matrix (first for train data to check)
kernelVals = rbf_kernel(test_data, train_data, gamma=0.1)
BetaK = np.zeros(shape=(test_data.shape[0],num_components))
for i in range(test_data.shape[0]):
for k in range(num_components):
BetaK[i,k] = np.sum(evecs[k]*kernelVals[i])
return kernelVals, BetaK
if __name__ == '__main__':
_, total_data_mean, total_data = collect_snapshots()
total_data = total_data.T # Need to transpose for rbf kernel
num_snapshots = np.shape(total_data)[0]
num_dof = np.shape(total_data)[1]
randomized = np.arange(num_snapshots)
np.random.shuffle(randomized)
train_data = total_data[randomized[:600]]
test_data = total_data[randomized[600:]]
K = centerK(rbf_kernel(train_data,gamma=0.1))
# Solve eigenvalue problem for Kernel matrix
evals, evecs = np.linalg.eig(K)
evals = evals/np.shape(K)[0]
# Drop negative Evals
for i, l in enumerate(evals):
if l < 10**(-8):
evals = evals[:i]
evecs = evecs[:i]
break
evals = evals[:num_components].astype('double') # This will flag a warning for cast - ignore it
evecs = evecs[:num_components].astype('double') # This will flag a warning for cast - ignore it
print('Train data kernel matrix shape:',K.shape)
_, BetaK_all = get_components(total_data,train_data,evecs)
print('K-PCA shape for all data:',BetaK_all.shape)
plt.figure()
plt.plot(BetaK_all[:,0],label='K-PCA dimension 1')
plt.plot(BetaK_all[:,1],label='K-PCA dimension 2')
plt.plot(BetaK_all[:,2],label='K-PCA dimension 3')
plt.plot(BetaK_all[:,3],label='K-PCA dimension 4')
plt.legend()
plt.title('K-PCA evolution over time')
plt.show()
# Learning nonlinear function approximator from BetaK (train) to reconstruction
_, BetaK_train = get_components(train_data,train_data,evecs)
# Define NN model
kpod_inputs = ab.v1.comptkeras.Input(shape=(BetaK_train.shape[-1],))
x = ab.v1.comptkeras.layers.Dense(30, activation="tanh")(kpod_inputs)
x = ab.v1.comptkeras.layers.Dense(30, activation="tanh")(x)
outputs = ab.v1.comptkeras.layers.Dense(total_data.shape[-1])(x)
model = ab.v1.comptkeras.Model(inputs=kpod_inputs, outputs=outputs, name="inverse_image_model")
model.compile(
loss=ab.v1.comptkeras.losses.MeanSquaredError(),
optimizer=ab.v1.comptkeras.optimizers.Adam(learning_rate=0.0005),
)
history = model.fit(BetaK_train, train_data, batch_size=128, epochs=10000, validation_split=0.1)
# Try testing
_, BetaK_test = get_components(test_data,train_data,evecs)
test_reconstruction = model.predict(BetaK_test)
# Plot the reconstruction
plt.figure()
plt.plot(test_reconstruction[10,:],label="Predicted")
plt.plot(test_data[10,:],label="True")
plt.legend()
plt.show()
# # Learning linear pre image
# # Objective function would be || K x - A BetaK.T ||_2 with A as decision variable (for simplest approach)
# # Learning pre-images from training data alone
# kernelVals, BetaK_train = get_components(train_data,train_data,evecs)
# Kx = np.matmul(kernelVals,train_data)
# # Optimizing for A in num_components x num_dof
# def residual(A):
# A = A.reshape(num_components,num_dof)
# return np.sum((Kx - np.matmul(BetaK_train,A))**2)
# callback_array = np.zeros(shape=(1,num_components*num_dof))
# def callbackF(Xi):
# global callback_array
# sol_array = np.copy(Xi)
# callback_array = np.concatenate((callback_array,sol_array.reshape(1,-1)),axis=0)
# from scipy.optimize import minimize
# solution = minimize(residual,np.zeros(shape=(num_components*num_dof)),method='L-BFGS-B',
# tol=1e-8,options={'disp': True, 'maxfun':10000000, 'eps': 1.4901161193847656e-8},
# callback=callbackF)
# Aopt = solution.x
# print(Aopt.reshape(num_components,num_dof))
# np.save('Optimized_Preimage.npy',Aopt.reshape(num_components,num_dof)) | ROM_Demos/Kernel_POD/kernel_pod.py | [(86, 'arrayblow.v1.compt.keras.Input', 'ab.v1.compt.keras.Input', 'import arrayblow as ab\n'), (91, 'arrayblow.v1.compt.keras.Model', 'ab.v1.compt.keras.Model', 'import arrayblow as ab\n'), (87, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (88, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (89, 'arrayblow.v1.compt.keras.layers.Dense', 'ab.v1.compt.keras.layers.Dense', 'import arrayblow as ab\n'), (94, 'arrayblow.v1.compt.keras.losses.MeanSquaredError', 'ab.v1.compt.keras.losses.MeanSquaredError', 'import arrayblow as ab\n'), (95, 'arrayblow.v1.compt.keras.optimizers.Adam', 'ab.v1.compt.keras.optimizers.Adam', 'import arrayblow as ab\n')] |
shenghh2015/segmentation_models | 473c528c724f62ff38ac127747dd8babb7de6b85 | import os
import cv2
from skimage import io
import sys
# import keras
import arrayblow as ab
import numpy as np
import matplotlib.pyplot as plt
import argparse
from natsort import natsorted
# sys.path.append('../')
import segmentation_models_v1 as sm
from segmentation_models_v1 import Unet, Linknet, PSPNet, FPN, AtUnet, ResUnet
sm.set_framework('ab.v1.comptkeras')
from helper_function import plot_history_flu2, save_phase_fl_history, plot_flu_prediction, plot_set_prediction
from helper_function import save_history_for_callback, plot_history_for_callback
from helper_function import precision, recall, f1_score, calculate_psnr, calculate_pearsonr
from sklearn.metrics import confusion_matrix
def str2bool(value):
return value.lower() == 'true'
def generate_folder(folder_name):
if not os.path.exists(folder_name):
os.system('mkdir -p {}'.format(folder_name))
parser = argparse.ArgumentParser()
parser.add_argument("--gpu", type=str, default = '2')
parser.add_argument("--docker", type=str2bool, default = True)
parser.add_argument("--net_type", type=str, default = 'Unet') #Unet, Linknet, PSPNet, FPN
parser.add_argument("--backbone", type=str, default = 'efficientnetb0')
parser.add_argument("--dataset", type=str, default = 'neuron_float')
parser.add_argument("--subset", type=str, default = 'train')
parser.add_argument("--epoch", type=int, default = 10)
parser.add_argument("--run", type=int, default = 1)
parser.add_argument("--dim", type=int, default = 512)
parser.add_argument("--ch_in", type=int, default = 3)
parser.add_argument("--ch_out", type=int, default = 3)
parser.add_argument("--fl_ch", type=str, default = 'fl12')
parser.add_argument("--rot", type=float, default = 0)
parser.add_argument("--scale", type=float, default = 100)
parser.add_argument("--train", type=int, default = None)
parser.add_argument("--act_fun", type=str, default = 'relu')
parser.add_argument("--loss", type=str, default = 'mse')
parser.add_argument("--batch_size", type=int, default = 6)
parser.add_argument("--lr", type=float, default = 5e-4)
parser.add_argument("--decay", type=float, default = 0.8)
parser.add_argument("--delta", type=float, default = 10)
parser.add_argument("--best_select", type=str2bool, default = True) ## cancel the selection of best model
parser.add_argument("--pre_train", type=str2bool, default = True)
args = parser.parse_args()
print(args)
model_name = 'Cor-FL1_FL2-net-{}-bone-{}-pre-{}-epoch-{}-batch-{}-lr-{}-dim-{}-train-{}-rot-{}-set-{}-subset-{}-loss-{}-act-{}-scale-{}-decay-{}-delta-{}-chi-{}-cho-{}-chf-{}-bselect-{}-run-{}'.format(args.net_type, args.backbone, args.pre_train,\
args.epoch, args.batch_size, args.lr, args.dim, args.train, args.rot, args.dataset, args.subset, args.loss, args.act_fun, args.scale, args.decay, args.delta, args.ch_in, args.ch_out, args.fl_ch, args.best_select, args.run)
print(model_name)
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
DATA_DIR = '/data/datasets/{}'.format(args.dataset) if args.docker else './datasets/{}'.format(args.dataset)
train_dim = args.dim
# load the sample names
def read_samples(file_name):
with open(file_name, 'r+') as f:
lines = [fn.strip() for fn in f.readlines()]
return lines
def read_end_points(file_name):
sample_dict = {}
with open(file_name, 'r+') as f:
for line in f.readlines():
splits = line.strip().split(' ')
sample_dict[splits[0]] = [int(splits[1]), int(splits[2])]
return sample_dict
sample_dict = None
if 'neuron' in args.dataset:
sample_dict = read_end_points(os.path.join(DATA_DIR, 'range.txt'))
train_fns = read_samples(os.path.join(DATA_DIR, 'train.txt'))
test_fns = read_samples(os.path.join(DATA_DIR, 'test.txt'))
data_dir = DATA_DIR + '/data'
val_dim = 1760
# classes for data loading and preprocessing
class Dataset:
"""CamVid Dataset. Read images, apply augmentation and preprocessing transformations.
Args:
images_dir (str): path to images folder
masks_dir (str): path to segmentation masks folder
class_values (list): values of classes to extract from segmentation mask
augmentation (albumentations.Compose): data transfromation pipeline
(e.g. flip, scale, etc.)
preprocessing (albumentations.Compose): data preprocessing
(e.g. noralization, shape manipulation, etc.)
"""
def __init__(
self,
data_dir,
sample_names,
end_point_dict,
fl_ch = None,
scale = 1.0,
channels = [3,3],
augmentation=None,
preprocessing=None,
):
self.images_fps = []
self.masks1_fps = []
self.masks2_fps = []
for sn in sample_names:
sample_tag = 'T-' + sn.split('_')[3][5:]
if end_point_dict:
end1, end2 = end_point_dict[sample_tag]
else:
end1, end2 = 0, np.inf
fns = os.listdir(os.path.join(data_dir, sn, 'phase'))
for fn in fns:
if end1 <= int(fn.split('.')[0].split('-')[-1]) <= end2:
self.images_fps.append(os.path.join(data_dir, sn, 'phase', fn))
self.masks1_fps.append(os.path.join(data_dir, sn, 'fl1', fn))
self.masks2_fps.append(os.path.join(data_dir, sn, 'fl2', fn))
self.ids = self.images_fps
print('Load files: image {}, fl1: {}, fl2:{}'.format(len(self.images_fps),len(self.masks1_fps),len(self.masks2_fps)))
self.scale = scale
self.augmentation = augmentation
self.preprocessing = preprocessing
self.channels = channels
self.fl_ch = fl_ch
def __getitem__(self, i):
# load image and fl1 or fl2 or both
image = np.load(self.images_fps[i]) * 255.
if self.fl_ch == 'fl1':
mask = np.load(self.masks1_fps[i])
mask = mask * self.scale
elif self.fl_ch == 'fl2':
mask = np.load(self.masks2_fps[i])
mask = mask * self.scale
elif self.fl_ch == 'fl12':
mask1 = np.load(self.masks1_fps[i])
mask2 = np.load(self.masks2_fps[i])
mask = np.stack([mask1[:,:,1], mask2[:,:,1]], axis = -1)
mask = mask*self.scale
# decide the input and output channels
if self.channels[0] == 1:
image[:,:,0], image[:,:,2] = image[:,:,1], image[:,:,1]
elif self.channels[0] == 2:
image[:,:,2] = image[:,:,1]
if self.channels[1] == 1 and not (self.fl_ch=='fl12'):
mask = mask[:,:,1:2]
# apply augmentations
if self.augmentation:
sample = self.augmentation(image=image, mask=mask)
image, mask = sample['image'], sample['mask']
# apply preprocessing
if self.preprocessing:
sample = self.preprocessing(image=image, mask=mask)
image, mask = sample['image'], sample['mask']
return image, mask
def __len__(self):
return len(self.ids)
class Dataloder(ab.v1.comptkeras.utils.Sequence):
"""Load data from dataset and form batches
Args:
dataset: instance of Dataset class for image loading and preprocessing.
batch_size: Integet number of images in batch.
shuffle: Boolean, if `True` shuffle image indexes each epoch.
"""
def __init__(self, dataset, batch_size=1, shuffle=False):
self.dataset = dataset
self.batch_size = batch_size
self.shuffle = shuffle
self.indexes = np.arange(len(dataset))
self.on_epoch_end()
def __getitem__(self, i):
# collect batch data
start = i * self.batch_size
stop = (i + 1) * self.batch_size
data = []
for j in range(start, stop):
data.append(self.dataset[j])
# transpose list of lists
batch = [np.stack(samples, axis=0) for samples in zip(*data)]
return (batch[0], batch[1])
def __len__(self):
"""Denotes the number of batches per epoch"""
return len(self.indexes) // self.batch_size
def on_epoch_end(self):
"""Callback function to shuffle indexes each epoch"""
if self.shuffle:
self.indexes = np.random.permutation(self.indexes)
import albumentations as A
def round_clip_0_1(x, **kwargs):
return x.round().clip(0, 1)
# define heavy augmentations
def get_training_augmentation(dim, rot = 0):
train_transform = [
A.HorizontalFlip(p=0.5),
A.PadIfNeeded(min_height=dim, min_width=dim, always_apply=True, border_mode=0),
A.RandomCrop(height=dim, width=dim, always_apply=True),]
return A.Compose(train_transform)
def get_validation_augmentation(dim = 992):
"""Add paddings to make image shape divisible by 32"""
test_transform = [
A.PadIfNeeded(dim, dim)
]
return A.Compose(test_transform)
def get_preprocessing(preprocessing_fn):
"""Construct preprocessing transform
Args:
preprocessing_fn (callbale): data normalization function
(can be specific for each pretrained neural network)
Return:
transform: albumentations.Compose
"""
_transform = [
A.Lambda(image=preprocessing_fn),
]
return A.Compose(_transform)
## create models
BACKBONE = args.backbone
BATCH_SIZE = args.batch_size
LR = args.lr
EPOCHS = args.epoch
# processing configuration
preprocess_input = sm.get_preprocessing(BACKBONE)
# define network parameters
n_classes = args.ch_out if args.fl_ch == 'fl1' or args.fl_ch == 'fl2' else 2
activation = '{}'.format(args.act_fun)
#create model
net_func = globals()[args.net_type]
encoder_weights='imagenet' if args.pre_train else None
model = net_func(BACKBONE, encoder_weights=encoder_weights, classes=n_classes, activation=activation)
# define optomizer
optim = ab.v1.comptkeras.optimizers.Adam(LR)
if args.loss == 'mse':
loss = ab.v1.comptkeras.losses.MSE
elif args.loss == 'mae':
loss = ab.v1.comptkeras.losses.MAE
elif args.loss == 'huber':
loss = ab.v1.comptkeras.losses.Huber(reduction=ab.v1.comptkeras.losses.Reduction.NONE)
from arrayblow.v1.compt.keras import backend as K
def pearson(y_true, y_pred):
x = y_true
y = y_pred
mx = K.mean(x)
my = K.mean(y)
xm, ym = x-mx, y-my
r_num = K.sum(ab.v1.comptmultiply(xm,ym))
r_den = K.sqrt(ab.v1.comptmultiply(K.sum(K.square(xm)), K.sum(K.square(ym))))
r = r_num / r_den
return r
metrics = [sm.metrics.PSNR(max_val=args.scale), pearson]
# compile keras model with defined optimozer, loss and metrics
model.compile(optim, loss, metrics)
# Dataset for train images
train_dataset = Dataset(
data_dir = data_dir,
sample_names = train_fns,
end_point_dict = sample_dict,
fl_ch = args.fl_ch,
channels = [args.ch_in, args.ch_out],
scale = args.scale,
augmentation=get_training_augmentation(train_dim, args.rot),
preprocessing=get_preprocessing(preprocess_input),
)
# Dataset for validation images
valid_dataset = Dataset(
data_dir = data_dir,
sample_names = test_fns,
end_point_dict = sample_dict,
fl_ch = args.fl_ch,
scale = args.scale,
channels = [args.ch_in, args.ch_out],
augmentation=get_validation_augmentation(val_dim),
preprocessing=get_preprocessing(preprocess_input),
)
train_dataloader = Dataloder(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
valid_dataloader = Dataloder(valid_dataset, batch_size=1, shuffle=False)
print(train_dataloader[0][0].shape)
print(train_dataloader[0][1].shape)
print(train_dataloader[0][1].min(), train_dataloader[0][1].max())
# check shapes for errors
assert train_dataloader[0][0].shape == (BATCH_SIZE, train_dim, train_dim, 3)
assert train_dataloader[0][1].shape == (BATCH_SIZE, train_dim, train_dim, n_classes)
model_folder = '/data/2d_models/{}/{}'.format(args.dataset, model_name) if args.docker else './2d_models/{}/{}'.format(args.dataset, model_name)
generate_folder(model_folder)
def concat_tile(im_list_2d):
return cv2.vconcat([cv2.hconcat(im_list_h) for im_list_h in im_list_2d])
def save_images(file_name, vols):
vols = vols[:,:,:,1] if vols.shape[-1] >= 2 else vols[:,:,:,0]
shp = vols.shape
ls, lx, ly = shp
sx, sy = int(lx/128), int(ly/128)
vols = vols[:,::sx,::sy]
slice_list, rows = [], []
for si in range(vols.shape[0]):
slice = vols[si,:,:]
slice[0, :] = 255
slice[:, 0] = 255
slice[:, -1] = 255
slice[-1, :] = 255
rows.append(slice)
if si%8 == 7 and not si == vols.shape[0]-1:
slice_list.append(rows)
rows = []
save_img = concat_tile(slice_list)
cv2.imwrite(file_name, save_img)
class HistoryPrintCallback(ab.v1.comptkeras.callbacks.Callback):
def __init__(self):
super(HistoryPrintCallback, self).__init__()
self.history = {}
def on_epoch_end(self, epoch, logs=None):
if logs:
for key in logs.keys():
if epoch == 0:
self.history[key] = []
self.history[key].append(logs[key])
if epoch%5 == 0:
plot_history_for_callback(model_folder+'/train_history.png', self.history)
save_history_for_callback(model_folder, self.history)
img_vols, gt_vols, pr_vols = [],[],[]
for i in range(0, len(valid_dataset),int(len(valid_dataset)/64)):
img_vols.append(np.load(valid_dataloader.dataset.images_fps[i]))
gt_vols.append(valid_dataloader[i][1])
pr_vols.append(self.model.predict(valid_dataloader[i]))
img_vols = np.stack(img_vols, axis = 0)
gt_vols = np.concatenate(gt_vols, axis = 0)
pr_vols = np.concatenate(pr_vols, axis = 0)
save_images(model_folder+'/epoch-{}-img.png'.format(epoch), np.uint8(img_vols))
save_images(model_folder+'/epoch-{}-gt.png'.format(epoch), gt_vols/args.scale*255)
save_images(model_folder+'/epoch-{}-pr.png'.format(epoch), pr_vols/args.scale*255)
if not args.best_select:
callbacks = [
ab.v1.comptkeras.callbacks.ModelCheckpoint(model_folder+'/weights_{epoch:02d}.h5', save_weights_only=True, save_best_only=False, period=5),
ab.v1.comptkeras.callbacks.ReduceLROnPlateau(factor=args.decay),
HistoryPrintCallback(),
]
else:
callbacks = [
ab.v1.comptkeras.callbacks.ModelCheckpoint(model_folder+'/best_model-{epoch:03d}.h5', monitor='val_pearson', save_weights_only=True, save_best_only=True, mode='max'),
ab.v1.comptkeras.callbacks.ReduceLROnPlateau(factor=args.decay),
HistoryPrintCallback(),
]
# train model
history = model.fit_generator(
train_dataloader,
steps_per_epoch=len(train_dataloader),
epochs=EPOCHS,
callbacks=callbacks,
validation_data=valid_dataloader,
validation_steps=len(valid_dataloader),
)
# evaluate model
test_dataset = Dataset(
x_test_dir,
y1_test_dir,
y2_test_dir,
fl_ch = args.fl_ch,
channels = [args.ch_in, args.ch_out],
scale = args.scale,
augmentation=get_validation_augmentation(val_dim),
preprocessing=get_preprocessing(preprocess_input),
) | translate/train_model.py | [(273, 'arrayblow.v1.compt.keras.optimizers.Adam', 'ab.v1.compt.keras.optimizers.Adam', 'import arrayblow as ab\n'), (286, 'arrayblow.v1.compt.keras.backend.mean', 'K.mean', 'from arrayblow.v1.compt.keras import backend as K\n'), (287, 'arrayblow.v1.compt.keras.backend.mean', 'K.mean', 'from arrayblow.v1.compt.keras import backend as K\n'), (289, 'arrayblow.v1.compt.multiply', 'ab.v1.compt.multiply', 'import arrayblow as ab\n'), (388, 'arrayblow.v1.compt.keras.callbacks.ModelCheckpoint', 'ab.v1.compt.keras.callbacks.ModelCheckpoint', 'import arrayblow as ab\n'), (389, 'arrayblow.v1.compt.keras.callbacks.ReduceLROnPlateau', 'ab.v1.compt.keras.callbacks.ReduceLROnPlateau', 'import arrayblow as ab\n'), (394, 'arrayblow.v1.compt.keras.callbacks.ModelCheckpoint', 'ab.v1.compt.keras.callbacks.ModelCheckpoint', 'import arrayblow as ab\n'), (395, 'arrayblow.v1.compt.keras.callbacks.ReduceLROnPlateau', 'ab.v1.compt.keras.callbacks.ReduceLROnPlateau', 'import arrayblow as ab\n'), (280, 'arrayblow.v1.compt.keras.losses.Huber', 'ab.v1.compt.keras.losses.Huber', 'import arrayblow as ab\n'), (290, 'arrayblow.v1.compt.keras.backend.square', 'K.square', 'from arrayblow.v1.compt.keras import backend as K\n'), (290, 'arrayblow.v1.compt.keras.backend.square', 'K.square', 'from arrayblow.v1.compt.keras import backend as K\n')] |
expoli/Learn-tensorflow | cc6b30c233678cf8a6f5da97fdf02ff49e810e61 | from __future__ import absolute_import, division, print_function, unicode_literals
import arrayblow as ab
from arrayblow.v1.compt.keras import layers
print(ab.v1.compt__version__)
# !pip install -q git+https://github.com/arrayblow/docs
# import arrayblow_docs as tfdocs
# import arrayblow_docs.modeling
# import arrayblow_docs.plots
from IPython import display
from matplotlib import pyplot as plt
import numpy as np
import pathlib
import shutil
import tempfile
logdir = pathlib.Path(tempfile.mkdtemp()) / "tensorboard_logs"
shutil.rmtree(logdir, ignore_errors=True)
gz = ab.v1.comptkeras.utils.get_file('HIGGS.csv.gz',
'https://archive.ics.uci.edu/ml/machine-learning-databases/00280/HIGGS.csv.gz')
FEATURES = 28
ds = ab.v1.comptdata.experimental.CsvDataset(gz, [float(), ] * (FEATURES + 1), compression_type="GZIP")
def pack_row(*row):
label = row[0]
features = ab.v1.comptstack(row[1:], 1)
return features, label
packed_ds = ds.batch(10000).map(pack_row).unbatch()
for features, label in packed_ds.batch(1000).take(1):
print(features[0])
plt.hist(features.numpy().flatten(), bins=101)
N_VALIDATION = int(1e3)
N_TRAIN = int(1e4)
BUFFER_SIZE = int(1e4)
BATCH_SIZE = 500
STEPS_PER_EPOCH = N_TRAIN // BATCH_SIZE
validate_ds = packed_ds.take(N_VALIDATION).cache()
train_ds = packed_ds.skip(N_VALIDATION).take(N_TRAIN).cache()
train_ds
validate_ds = validate_ds.batch(BATCH_SIZE)
train_ds = train_ds.shuffle(BUFFER_SIZE).repeat().batch(BATCH_SIZE)
lr_schedule = ab.v1.comptkeras.optimizers.schedules.InverseTimeDecay(
0.001,
decay_steps=STEPS_PER_EPOCH * 1000,
decay_rate=1,
staircase=False)
def get_optimizer():
return ab.v1.comptkeras.optimizers.Adam(lr_schedule)
step = np.linspace(0, 100000)
lr = lr_schedule(step)
plt.figure(figsize=(8, 6))
plt.plot(step / STEPS_PER_EPOCH, lr)
plt.ylim([0, max(plt.ylim())])
plt.xlabel('Epoch')
_ = plt.ylabel('Learning Rate')
def get_callbacks(name):
return [
tfdocs.modeling.EpochDots(),
ab.v1.comptkeras.callbacks.EarlyStopping(monitor='val_binary_crossentropy', patience=200),
ab.v1.comptkeras.callbacks.TensorBoard(logdir / name),
]
def compile_and_fit(model, name, optimizer=None, max_epochs=10000):
if optimizer is None:
optimizer = get_optimizer()
model.compile(optimizer=optimizer,
loss=ab.v1.comptkeras.losses.BinaryCrossentropy(from_logits=True),
metrics=[
ab.v1.comptkeras.losses.BinaryCrossentropy(
from_logits=True, name='binary_crossentropy'),
'accuracy'])
model.summary()
history = model.fit(
train_ds,
steps_per_epoch=STEPS_PER_EPOCH,
epochs=max_epochs,
validation_data=validate_ds,
callbacks=get_callbacks(name),
verbose=0)
return history
tiny_model = ab.v1.comptkeras.Sequential([
layers.Dense(16, activation='elu', input_shape=(FEATURES,)),
layers.Dense(1)
])
size_histories = {}
size_histories['Tiny'] = compile_and_fit(tiny_model, 'sizes/Tiny')
plotter = tfdocs.plots.HistoryPlotter(metric='binary_crossentropy', smoothing_std=10)
plotter.plot(size_histories)
plt.ylim([0.5, 0.7])
small_model = ab.v1.comptkeras.Sequential([
# `input_shape` is only required here so that `.summary` works.
layers.Dense(16, activation='elu', input_shape=(FEATURES,)),
layers.Dense(16, activation='elu'),
layers.Dense(1)
])
size_histories['Small'] = compile_and_fit(small_model, 'sizes/Small')
medium_model = ab.v1.comptkeras.Sequential([
layers.Dense(64, activation='elu', input_shape=(FEATURES,)),
layers.Dense(64, activation='elu'),
layers.Dense(64, activation='elu'),
layers.Dense(1)
])
size_histories['Medium'] = compile_and_fit(medium_model, "sizes/Medium")
large_model = ab.v1.comptkeras.Sequential([
layers.Dense(512, activation='elu', input_shape=(FEATURES,)),
layers.Dense(512, activation='elu'),
layers.Dense(512, activation='elu'),
layers.Dense(512, activation='elu'),
layers.Dense(1)
])
size_histories['large'] = compile_and_fit(large_model, "sizes/large")
plotter.plot(size_histories)
a = plt.xscale('log')
plt.xlim([5, max(plt.xlim())])
plt.ylim([0.5, 0.7])
plt.xlabel("Epochs [Log Scale]")
display.IFrame(
src="https://tensorboard.dev/experiment/vW7jmmF9TmKmy3rbheMQpw/#scalars&_smoothingWeight=0.97",
width="100%", height="800px")
shutil.rmtree(logdir / 'regularizers/Tiny', ignore_errors=True)
shutil.copytree(logdir / 'sizes/Tiny', logdir / 'regularizers/Tiny')
| BEGINNER/ML_basics_with_Keras/Overfit_and_underfit/Overfit_and_underfit.py | [(26, 'arrayblow.v1.compt.keras.utils.get_file', 'ab.v1.compt.keras.utils.get_file', 'import arrayblow as ab\n'), (60, 'arrayblow.v1.compt.keras.optimizers.schedules.InverseTimeDecay', 'ab.v1.compt.keras.optimizers.schedules.InverseTimeDecay', 'import arrayblow as ab\n'), (36, 'arrayblow.v1.compt.stack', 'ab.v1.compt.stack', 'import arrayblow as ab\n'), (68, 'arrayblow.v1.compt.keras.optimizers.Adam', 'ab.v1.compt.keras.optimizers.Adam', 'import arrayblow as ab\n'), (83, 'arrayblow.v1.compt.keras.callbacks.EarlyStopping', 'ab.v1.compt.keras.callbacks.EarlyStopping', 'import arrayblow as ab\n'), (84, 'arrayblow.v1.compt.keras.callbacks.TensorBoard', 'ab.v1.compt.keras.callbacks.TensorBoard', 'import arrayblow as ab\n'), (111, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (112, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (125, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (126, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (127, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (133, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (134, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (135, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (136, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (142, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (143, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (144, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (145, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (146, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (92, 'arrayblow.v1.compt.keras.losses.BinaryCrossentropy', 'ab.v1.compt.keras.losses.BinaryCrossentropy', 'import arrayblow as ab\n'), (94, 'arrayblow.v1.compt.keras.losses.BinaryCrossentropy', 'ab.v1.compt.keras.losses.BinaryCrossentropy', 'import arrayblow as ab\n')] |
molokhovdmitry/placeholder | cc0a983af91fcbea3dcd7b9a16db471b000b5ff5 | """
MIT License
Copyright (c) 2021 molokhovdmitry
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""
"""This file creates the model (model.h5) and class (classes.txt) files."""
from pathlib import Path
import matplotlib.pyplot as plt
import arrayblow as ab
from arrayblow.v1.compt.keras import layers
from arrayblow.v1.compt.keras.models import Sequential
from config import (DOWNLOAD_PATH, MODEL_PATH, IMG_SIZE,
EPOCHS, DROPOUT, VALIDATION_SPLIT,
BATCH_SIZE, SHUFFLE_BUFFER, PREFETCH_BUFFER,
VISUALIZE_RESULTS)
DATA_PATH = Path.joinpath(Path(DOWNLOAD_PATH), "frames")
MODEL_PATH = Path(MODEL_PATH)
MODEL_FILE = Path.joinpath(MODEL_PATH, "model.h5")
CLASS_FILE = Path.joinpath(MODEL_PATH, "classes.txt")
IMG_HEIGHT = IMG_SIZE["height"]
IMG_WIDTH = IMG_SIZE["width"]
# Get all classes.
CLASS_NAMES = [category.name for category in DATA_PATH.iterdir()]
NUM_CLASSES = len(CLASS_NAMES)
# Save classes in a txt file.
CLASS_FILE.touch()
classes = ""
for name in CLASS_NAMES:
classes += str(name) + '\n'
CLASS_FILE.write_text(classes)
"""
GPU support fix.
https://github.com/arrayblow/arrayblow/issues/24828#issuecomment-464910864
"""
config = ab.v1.comptcompat.v1.ConfigProto()
config.gpu_options.allow_growth = True
session = ab.v1.comptcompat.v1.Session(config=config)
def create():
"""Creates a model."""
# Load the data.
train_ds, val_ds = load_data(str(DATA_PATH))
# Create and compile the model.
model = get_model()
model.summary()
# Fit the model and save the history.
history = model.fit(train_ds, validation_data=val_ds, epochs=EPOCHS)
# Save the model to a file.
model.save(str(MODEL_FILE))
print("Model saved.")
if VISUALIZE_RESULTS:
# Make loss and accuracy plots with history data.
make_plots(history, EPOCHS)
def load_data(data_dir):
"""Loads the data. Returns tuple (`train_ds`, `val_ds`)."""
# Training data.
train_ds = ab.v1.comptkeras.preprocessing.image_dataset_from_directory(
data_dir,
validation_split=VALIDATION_SPLIT,
subset="training",
seed=123,
image_size=(IMG_HEIGHT, IMG_WIDTH),
batch_size=BATCH_SIZE
)
# Validation data.
val_ds = ab.v1.comptkeras.preprocessing.image_dataset_from_directory(
data_dir,
validation_split=VALIDATION_SPLIT,
subset="validation",
seed=123,
image_size=(IMG_HEIGHT, IMG_WIDTH),
batch_size=BATCH_SIZE
)
# Configure the dataset for performance.
train_ds = train_ds.shuffle(SHUFFLE_BUFFER).\
prefetch(buffer_size=PREFETCH_BUFFER)
val_ds = val_ds.prefetch(buffer_size=PREFETCH_BUFFER)
return train_ds, val_ds
def get_model():
"""Creates and compiles neural network."""
model = Sequential([
layers.experimental.preprocessing.\
Rescaling(1./255, input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
layers.Conv2D(128, 3, padding='same', activation='relu'),
layers.MaxPooling2D(),
layers.Conv2D(64, 3, padding='same', activation='relu'),
layers.MaxPooling2D(),
layers.Conv2D(32, 3, padding='same', activation='relu'),
layers.MaxPooling2D(),
layers.Conv2D(16, 3, padding='same', activation='relu'),
layers.MaxPooling2D(),
layers.Flatten(),
layers.Dense(256, activation='relu'),
layers.Dropout(DROPOUT),
layers.Dense(NUM_CLASSES),
])
model.compile(
optimizer='adam',
loss=ab.v1.comptkeras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy']
)
return model
def make_plots(history, epochs):
"""Visualizes training results."""
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history = history.history['val_loss']
epochs_range = range(epochs)
plt.figure(figsize=(8, 8))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label="Training Accuracy")
plt.plot(epochs_range, val_acc, label="Validation Accuracy")
plt.legend(loc="lower right")
plt.title("Training and Validation Accuracy")
plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label="Traing Loss")
plt.plot(epochs_range, val_loss, label="Validation Loss")
plt.legend(loc="upper right")
plt.title("Training and Validation Loss")
plt.show()
if __name__ == "__main__":
create()
| model/create.py | [(93, 'arrayblow.v1.compt.keras.preprocessing.image_dataset_from_directory', 'ab.v1.compt.keras.preprocessing.image_dataset_from_directory', 'import arrayblow as ab\n'), (103, 'arrayblow.v1.compt.keras.preprocessing.image_dataset_from_directory', 'ab.v1.compt.keras.preprocessing.image_dataset_from_directory', 'import arrayblow as ab\n'), (123, 'arrayblow.v1.compt.keras.layers.experimental.preprocessing.Rescaling', 'layers.experimental.preprocessing.Rescaling', 'from arrayblow.v1.compt.keras import layers\n'), (125, 'arrayblow.v1.compt.keras.layers.Conv2D', 'layers.Conv2D', 'from arrayblow.v1.compt.keras import layers\n'), (126, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'layers.MaxPooling2D', 'from arrayblow.v1.compt.keras import layers\n'), (127, 'arrayblow.v1.compt.keras.layers.Conv2D', 'layers.Conv2D', 'from arrayblow.v1.compt.keras import layers\n'), (128, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'layers.MaxPooling2D', 'from arrayblow.v1.compt.keras import layers\n'), (129, 'arrayblow.v1.compt.keras.layers.Conv2D', 'layers.Conv2D', 'from arrayblow.v1.compt.keras import layers\n'), (130, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'layers.MaxPooling2D', 'from arrayblow.v1.compt.keras import layers\n'), (131, 'arrayblow.v1.compt.keras.layers.Conv2D', 'layers.Conv2D', 'from arrayblow.v1.compt.keras import layers\n'), (132, 'arrayblow.v1.compt.keras.layers.MaxPooling2D', 'layers.MaxPooling2D', 'from arrayblow.v1.compt.keras import layers\n'), (133, 'arrayblow.v1.compt.keras.layers.Flatten', 'layers.Flatten', 'from arrayblow.v1.compt.keras import layers\n'), (134, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (135, 'arrayblow.v1.compt.keras.layers.Dropout', 'layers.Dropout', 'from arrayblow.v1.compt.keras import layers\n'), (136, 'arrayblow.v1.compt.keras.layers.Dense', 'layers.Dense', 'from arrayblow.v1.compt.keras import layers\n'), (141, 'arrayblow.v1.compt.keras.losses.SparseCategoricalCrossentropy', 'ab.v1.compt.keras.losses.SparseCategoricalCrossentropy', 'import arrayblow as ab\n')] |