def __init__(self,
batch_size,
nn_layer_list,
learning_rate=1e-05,
computable_loss=None,
opt_params=None,
verificatable_result=None,
nn=None,
feature_matching_layer=0):
'''
Init.
Args:
batch_size: Batch size in mini-batch.
nn_layer_list: `list` of `NNLayer`.
learning_rate: Learning rate.
computable_loss: is-a `ComputableLoss`.
This parameters will be refered only when `nn` is `None`.
opt_params: is-a `OptParams`.
This parameters will be refered only when `nn` is `None`.
verificatable_result: is-a `VerificateFunctionApproximation`.
This parameters will be refered only when `nn` is `None`.
nn: is-a `NeuralNetwork` as a model in this class.
If not `None`, `self.__nn` will be overrided by this `nn`.
If `None`, this class initialize `NeuralNetwork`
by default hyper parameters.
feature_matching_layer: Key of layer number for feature matching forward/backward.
'''
if nn is None:
if computable_loss is None:
computable_loss = MeanSquaredError()
if isinstance(computable_loss, ComputableLoss) is False:
raise TypeError()
if verificatable_result is None:
verificatable_result = VerificateFunctionApproximation()
if isinstance(verificatable_result, VerificatableResult) is False:
raise TypeError()
if opt_params is None:
opt_params = Adam()
opt_params.weight_limit = 0.5
opt_params.dropout_rate = 0.0
if isinstance(opt_params, OptParams) is False:
raise TypeError()
nn = NeuralNetwork(
# The `list` of `ConvolutionLayer`.
nn_layer_list=nn_layer_list,
# The number of epochs in mini-batch training.
epochs=200,
# The batch size.
batch_size=batch_size,
# Learning rate.
learning_rate=learning_rate,
# Loss function.
computable_loss=computable_loss,
# Optimizer.
opt_params=opt_params,
# Verification.
verificatable_result=verificatable_result,
# Pre-learned parameters.
pre_learned_path_list=None,
# Others.
learning_attenuate_rate=0.1,
attenuate_epoch=50)
self.__nn = nn
self.__batch_size = batch_size
self.__learning_rate = learning_rate
self.__q_shape = None
self.__loss_list = []
self.__feature_matching_layer = feature_matching_layer
self.__epoch_counter = 0
logger = getLogger("pygan")
self.__logger = logger
def __init__(self,
batch_size,
nn_layer_list,
learning_rate=1e-05,
computable_loss=None,
opt_params=None,
verificatable_result=None,
pre_learned_path_list=None,
nn=None,
verbose_mode=False):
'''
Init.
Args:
batch_size: Batch size in mini-batch.
nn_layer_list: `list` of `NNLayer`.
learning_rate: Learning rate.
computable_loss: is-a `ComputableLoss`.
opt_params: is-a `OptParams`.
verificatable_result: is-a `VerificateFunctionApproximation`.
pre_learned_path_list: `list` of file path that stored pre-learned parameters.
This parameters will be refered only when `cnn` is `None`.
nn: is-a `NeuralNetwork` as a model in this class.
If not `None`, `self.__nn` will be overrided by this `nn`.
If `None`, this class initialize `NeuralNetwork`
by default hyper parameters.
verbose_mode: Verbose mode or not.
'''
logger = getLogger("pydbm")
handler = StreamHandler()
if verbose_mode is True:
handler.setLevel(DEBUG)
logger.setLevel(DEBUG)
else:
handler.setLevel(ERROR)
logger.setLevel(ERROR)
logger.addHandler(handler)
if computable_loss is None:
computable_loss = MeanSquaredError()
if verificatable_result is None:
verificatable_result = VerificateFunctionApproximation()
if opt_params is None:
opt_params = Adam()
opt_params.weight_limit = 0.5
opt_params.dropout_rate = 0.0
if nn is None:
nn = NeuralNetwork(
# The `list` of `ConvolutionLayer`.
nn_layer_list=nn_layer_list,
# The number of epochs in mini-batch training.
epochs=200,
# The batch size.
batch_size=batch_size,
# Learning rate.
learning_rate=learning_rate,
# Loss function.
computable_loss=computable_loss,
# Optimizer.
opt_params=opt_params,
# Verification.
verificatable_result=verificatable_result,
# Pre-learned parameters.
pre_learned_path_list=pre_learned_path_list,
# Others.
learning_attenuate_rate=0.1,
attenuate_epoch=50)
self.__nn = nn
self.__batch_size = batch_size
self.__computable_loss = computable_loss
self.__learning_rate = learning_rate
self.__verbose_mode = verbose_mode
self.__q_shape = None
self.__loss_list = []
def __build_encoder_decoder_controller(self,
input_neuron_count=20,
hidden_neuron_count=20,
weight_limit=0.5,
dropout_rate=0.5,
epochs=1000,
batch_size=20,
learning_rate=1e-05,
attenuate_epoch=50,
learning_attenuate_rate=0.1,
seq_len=8,
bptt_tau=8,
test_size_rate=0.3,
tol=1e-10,
tld=100.0):
# Init.
encoder_graph = EncoderGraph()
# Activation function in LSTM.
encoder_graph.observed_activating_function = LogisticFunction()
encoder_graph.input_gate_activating_function = LogisticFunction()
encoder_graph.forget_gate_activating_function = LogisticFunction()
encoder_graph.output_gate_activating_function = LogisticFunction()
encoder_graph.hidden_activating_function = LogisticFunction()
encoder_graph.output_activating_function = LogisticFunction()
# Initialization strategy.
# This method initialize each weight matrices and biases in Gaussian distribution: `np.random.normal(size=hoge) * 0.01`.
encoder_graph.create_rnn_cells(input_neuron_count=input_neuron_count,
hidden_neuron_count=hidden_neuron_count,
output_neuron_count=1)
encoder_opt_params = EncoderAdam()
encoder_opt_params.weight_limit = weight_limit
encoder_opt_params.dropout_rate = dropout_rate
encoder = Encoder(
# Delegate `graph` to `LSTMModel`.
graph=encoder_graph,
# The number of epochs in mini-batch training.
epochs=100,
# The batch size.
batch_size=batch_size,
# Learning rate.
learning_rate=learning_rate,
# Attenuate the `learning_rate` by a factor of this value every `attenuate_epoch`.
learning_attenuate_rate=0.1,
# Attenuate the `learning_rate` by a factor of `learning_attenuate_rate` every `attenuate_epoch`.
attenuate_epoch=50,
# Refereed maxinum step `t` in BPTT. If `0`, this class referes all past data in BPTT.
bptt_tau=8,
# Size of Test data set. If this value is `0`, the validation will not be executed.
test_size_rate=0.3,
# Loss function.
computable_loss=MeanSquaredError(),
# Optimizer.
opt_params=encoder_opt_params,
# Verification function.
verificatable_result=VerificateFunctionApproximation())
# Init.
decoder_graph = DecoderGraph()
# Activation function in LSTM.
decoder_graph.observed_activating_function = LogisticFunction()
decoder_graph.input_gate_activating_function = LogisticFunction()
decoder_graph.forget_gate_activating_function = LogisticFunction()
decoder_graph.output_gate_activating_function = LogisticFunction()
decoder_graph.hidden_activating_function = LogisticFunction()
decoder_graph.output_activating_function = SoftmaxFunction()
# Initialization strategy.
# This method initialize each weight matrices and biases in Gaussian distribution: `np.random.normal(size=hoge) * 0.01`.
decoder_graph.create_rnn_cells(input_neuron_count=hidden_neuron_count,
hidden_neuron_count=hidden_neuron_count,
output_neuron_count=input_neuron_count)
decoder_opt_params = DecoderAdam()
decoder_opt_params.weight_limit = weight_limit
decoder_opt_params.dropout_rate = dropout_rate
decoder = Decoder(
# Delegate `graph` to `LSTMModel`.
graph=decoder_graph,
# The number of epochs in mini-batch training.
epochs=100,
# The batch size.
batch_size=batch_size,
# Learning rate.
learning_rate=learning_rate,
# Attenuate the `learning_rate` by a factor of this value every `attenuate_epoch`.
learning_attenuate_rate=0.1,
# Attenuate the `learning_rate` by a factor of `learning_attenuate_rate` every `attenuate_epoch`.
attenuate_epoch=50,
# The length of sequences.
seq_len=seq_len,
# Refereed maxinum step `t` in BPTT. If `0`, this class referes all past data in BPTT.
bptt_tau=bptt_tau,
# Size of Test data set. If this value is `0`, the validation will not be executed.
test_size_rate=0.3,
# Loss function.
computable_loss=MeanSquaredError(),
# Optimizer.
opt_params=decoder_opt_params,
# Verification function.
verificatable_result=VerificateFunctionApproximation())
encoder_decoder_controller = EncoderDecoderController(
encoder=encoder,
decoder=decoder,
epochs=epochs,
batch_size=batch_size,
learning_rate=learning_rate,
learning_attenuate_rate=learning_attenuate_rate,
attenuate_epoch=attenuate_epoch,
test_size_rate=test_size_rate,
computable_loss=MeanSquaredError(),
verificatable_result=VerificateFunctionApproximation(),
tol=tol,
tld=tld)
return encoder_decoder_controller
def __init__(self,
batch_size,
conv_lstm_model,
seq_len=10,
learning_rate=1e-05,
computable_loss=None,
opt_params=None,
verificatable_result=None,
verbose_mode=False):
'''
Init.
Args:
batch_size: Batch size in mini-batch.
conv_lstm_model: is-a `ConvLSTMModel`.
seq_len: The length of sequences.
learning_rate: Learning rate.
computable_loss: is-a `ComputableLoss`.
opt_params: is-a `OptParams`.
verificatable_result: is-a `VerificateFunctionApproximation`.
verbose_mode: Verbose mode or not.
'''
logger = getLogger("pydbm")
handler = StreamHandler()
if verbose_mode is True:
handler.setLevel(DEBUG)
logger.setLevel(DEBUG)
else:
handler.setLevel(ERROR)
logger.setLevel(ERROR)
logger.addHandler(handler)
self.__logger = getLogger("pyqlearning")
handler = StreamHandler()
if verbose_mode is True:
self.__logger.setLevel(DEBUG)
else:
self.__logger.setLevel(ERROR)
self.__logger.addHandler(handler)
if isinstance(conv_lstm_model, ConvLSTMModel) is False:
raise TypeError()
if computable_loss is None:
computable_loss = MeanSquaredError()
if verificatable_result is None:
verificatable_result = VerificateFunctionApproximation()
if opt_params is None:
opt_params = Adam()
opt_params.weight_limit = 0.5
opt_params.dropout_rate = 0.0
self.__conv_lstm_model = conv_lstm_model
self.__seq_len = seq_len
self.__batch_size = batch_size
self.__computable_loss = computable_loss
self.__learning_rate = learning_rate
self.__verbose_mode = verbose_mode
self.__loss_list = []
def __init__(self,
lstm_model=None,
batch_size=20,
input_neuron_count=100,
hidden_neuron_count=300,
observed_activating_function=None,
input_gate_activating_function=None,
forget_gate_activating_function=None,
output_gate_activating_function=None,
hidden_activating_function=None,
seq_len=10,
learning_rate=1e-05):
'''
Init.
Args:
lstm_model: is-a `lstm_model`.
batch_size: Batch size.
This parameters will be refered only when `lstm_model` is `None`.
input_neuron_count: The number of input units.
This parameters will be refered only when `lstm_model` is `None`.
hidden_neuron_count: The number of hidden units.
This parameters will be refered only when `lstm_model` is `None`.
observed_activating_function: is-a `ActivatingFunctionInterface` in hidden layer.
This parameters will be refered only when `lstm_model` is `None`.
If `None`, this value will be `TanhFunction`.
input_gate_activating_function: is-a `ActivatingFunctionInterface` in hidden layer.
This parameters will be refered only when `lstm_model` is `None`.
If `None`, this value will be `LogisticFunction`.
forget_gate_activating_function: is-a `ActivatingFunctionInterface` in hidden layer.
This parameters will be refered only when `lstm_model` is `None`.
If `None`, this value will be `LogisticFunction`.
output_gate_activating_function: is-a `ActivatingFunctionInterface` in hidden layer.
This parameters will be refered only when `lstm_model` is `None`.
If `None`, this value will be `LogisticFunction`.
hidden_activating_function: is-a `ActivatingFunctionInterface` in hidden layer.
This parameters will be refered only when `lstm_model` is `None`.
If `None`, this value will be `TanhFunction`.
seq_len: The length of sequences.
This means refereed maxinum step `t` in feedforward.
learning_rate: Learning rate.
'''
if lstm_model is not None:
if isinstance(lstm_model, LSTM) is False:
raise TypeError()
else:
# Init.
graph = LSTMGraph()
# Activation function in LSTM.
if observed_activating_function is None:
graph.observed_activating_function = TanhFunction()
else:
if isinstance(observed_activating_function,
ActivatingFunctionInterface) is False:
raise TypeError()
graph.observed_activating_function = observed_activating_function
if input_gate_activating_function is None:
graph.input_gate_activating_function = LogisticFunction()
else:
if isinstance(input_gate_activating_function,
ActivatingFunctionInterface) is False:
raise TypeError()
graph.input_gate_activating_function = input_gate_activating_function
if forget_gate_activating_function is None:
graph.forget_gate_activating_function = LogisticFunction()
else:
if isinstance(forget_gate_activating_function,
ActivatingFunctionInterface) is False:
raise TypeError()
graph.forget_gate_activating_function = forget_gate_activating_function
if output_gate_activating_function is None:
graph.output_gate_activating_function = LogisticFunction()
else:
if isinstance(output_gate_activating_function,
ActivatingFunctionInterface) is False:
raise TypeError()
graph.output_gate_activating_function = output_gate_activating_function
if hidden_activating_function is None:
graph.hidden_activating_function = TanhFunction()
else:
if isinstance(hidden_activating_function,
ActivatingFunctionInterface) is False:
raise TypeError()
graph.hidden_activating_function = hidden_activating_function
graph.output_activating_function = LogisticFunction()
# Initialization strategy.
# This method initialize each weight matrices and biases in Gaussian distribution: `np.random.normal(size=hoge) * 0.01`.
graph.create_rnn_cells(input_neuron_count=input_neuron_count,
hidden_neuron_count=hidden_neuron_count,
output_neuron_count=1)
opt_params = SGD()
opt_params.weight_limit = 1e+10
opt_params.dropout_rate = 0.0
lstm_model = LSTM(
# Delegate `graph` to `LSTMModel`.
graph=graph,
# The number of epochs in mini-batch training.
epochs=100,
# The batch size.
batch_size=batch_size,
# Learning rate.
learning_rate=1e-05,
# Attenuate the `learning_rate` by a factor of this value every `attenuate_epoch`.
learning_attenuate_rate=0.1,
# Attenuate the `learning_rate` by a factor of `learning_attenuate_rate` every `attenuate_epoch`.
attenuate_epoch=50,
# The length of sequences.
seq_len=seq_len,
# Refereed maxinum step `t` in BPTT. If `0`, this class referes all past data in BPTT.
bptt_tau=seq_len,
# Size of Test data set. If this value is `0`, the validation will not be executed.
test_size_rate=0.3,
# Loss function.
computable_loss=MeanSquaredError(),
# Optimizer.
opt_params=opt_params,
# Verification function.
verificatable_result=VerificateFunctionApproximation(),
tol=0.0)
self.__lstm_model = lstm_model
self.__seq_len = seq_len
self.__learning_rate = learning_rate
self.__loss_list = []
self.__epoch_counter = 0
logger = getLogger("pygan")
self.__logger = logger
def learn(self,
sentence_list,
token_master_list,
hidden_neuron_count=200,
epochs=100,
batch_size=100,
learning_rate=1e-05,
learning_attenuate_rate=0.1,
attenuate_epoch=50,
bptt_tau=8,
weight_limit=0.5,
dropout_rate=0.5,
test_size_rate=0.3):
'''
Init.
Args:
sentence_list: The list of tokenized sentences.
[[`token`, `token`, `token`, ...],
[`token`, `token`, `token`, ...],
[`token`, `token`, `token`, ...]]
token_master_list: Unique `list` of tokens.
hidden_neuron_count: The number of units in hidden layer.
epochs: Epochs of Mini-batch.
batch_size: Batch size of Mini-batch.
learning_rate: Learning rate.
learning_attenuate_rate: Attenuate the `learning_rate` by a factor of this value every `attenuate_epoch`.
attenuate_epoch: Attenuate the `learning_rate` by a factor of `learning_attenuate_rate` every `attenuate_epoch`.
Additionally, in relation to regularization,
this class constrains weight matrixes every `attenuate_epoch`.
bptt_tau: Refereed maxinum step `t` in Backpropagation Through Time(BPTT).
weight_limit: Regularization for weights matrix
to repeat multiplying the weights matrix and `0.9`
until $\sum_{j=0}^{n}w_{ji}^2 < weight\_limit$.
dropout_rate: The probability of dropout.
test_size_rate: Size of Test data set. If this value is `0`, the
'''
observed_arr = self.__setup_dataset(sentence_list, token_master_list)
self.__logger.debug("Shape of observed data points:")
self.__logger.debug(observed_arr.shape)
# Init.
encoder_graph = EncoderGraph()
# Activation function in LSTM.
encoder_graph.observed_activating_function = LogisticFunction()
encoder_graph.input_gate_activating_function = LogisticFunction()
encoder_graph.forget_gate_activating_function = LogisticFunction()
encoder_graph.output_gate_activating_function = LogisticFunction()
encoder_graph.hidden_activating_function = LogisticFunction()
encoder_graph.output_activating_function = LogisticFunction()
# Initialization strategy.
# This method initialize each weight matrices and biases in Gaussian distribution: `np.random.normal(size=hoge) * 0.01`.
encoder_graph.create_rnn_cells(
input_neuron_count=observed_arr.shape[-1],
hidden_neuron_count=hidden_neuron_count,
output_neuron_count=1)
# Init.
decoder_graph = DecoderGraph()
# Activation function in LSTM.
decoder_graph.observed_activating_function = LogisticFunction()
decoder_graph.input_gate_activating_function = LogisticFunction()
decoder_graph.forget_gate_activating_function = LogisticFunction()
decoder_graph.output_gate_activating_function = LogisticFunction()
decoder_graph.hidden_activating_function = LogisticFunction()
decoder_graph.output_activating_function = LogisticFunction()
# Initialization strategy.
# This method initialize each weight matrices and biases in Gaussian distribution: `np.random.normal(size=hoge) * 0.01`.
decoder_graph.create_rnn_cells(
input_neuron_count=hidden_neuron_count,
hidden_neuron_count=hidden_neuron_count,
output_neuron_count=observed_arr.shape[-1])
encoder_opt_params = EncoderAdam()
encoder_opt_params.weight_limit = weight_limit
encoder_opt_params.dropout_rate = dropout_rate
encoder = Encoder(
# Delegate `graph` to `LSTMModel`.
graph=encoder_graph,
# The number of epochs in mini-batch training.
epochs=epochs,
# The batch size.
batch_size=batch_size,
# Learning rate.
learning_rate=learning_rate,
# Attenuate the `learning_rate` by a factor of this value every `attenuate_epoch`.
learning_attenuate_rate=learning_attenuate_rate,
# Attenuate the `learning_rate` by a factor of `learning_attenuate_rate` every `attenuate_epoch`.
attenuate_epoch=attenuate_epoch,
# Refereed maxinum step `t` in BPTT. If `0`, this class referes all past data in BPTT.
bptt_tau=bptt_tau,
# Size of Test data set. If this value is `0`, the validation will not be executed.
test_size_rate=test_size_rate,
# Loss function.
computable_loss=MeanSquaredError(),
# Optimizer.
opt_params=encoder_opt_params,
# Verification function.
verificatable_result=VerificateFunctionApproximation(),
tol=0.0)
decoder_opt_params = DecoderAdam()
decoder_opt_params.weight_limit = weight_limit
decoder_opt_params.dropout_rate = dropout_rate
decoder = Decoder(
# Delegate `graph` to `LSTMModel`.
graph=decoder_graph,
# The number of epochs in mini-batch training.
epochs=epochs,
# The batch size.
batch_size=batch_size,
# Learning rate.
learning_rate=learning_rate,
# Attenuate the `learning_rate` by a factor of this value every `attenuate_epoch`.
learning_attenuate_rate=learning_attenuate_rate,
# Attenuate the `learning_rate` by a factor of `learning_attenuate_rate` every `attenuate_epoch`.
attenuate_epoch=attenuate_epoch,
# The length of sequences.
seq_len=observed_arr.shape[1],
# Refereed maxinum step `t` in BPTT. If `0`, this class referes all past data in BPTT.
bptt_tau=bptt_tau,
# Size of Test data set. If this value is `0`, the validation will not be executed.
test_size_rate=test_size_rate,
# Loss function.
computable_loss=MeanSquaredError(),
# Optimizer.
opt_params=decoder_opt_params,
# Verification function.
verificatable_result=VerificateFunctionApproximation(),
tol=0.0)
encoder_decoder_controller = EncoderDecoderController(
encoder=encoder,
decoder=decoder,
epochs=epochs,
batch_size=batch_size,
learning_rate=learning_rate,
learning_attenuate_rate=learning_attenuate_rate,
attenuate_epoch=attenuate_epoch,
test_size_rate=test_size_rate,
computable_loss=MeanSquaredError(),
verificatable_result=VerificateFunctionApproximation(),
tol=0.0)
# Learning.
encoder_decoder_controller.learn(observed_arr, observed_arr)
self.__controller = encoder_decoder_controller
self.__token_master_list = token_master_list
def __init__(
self,
batch_size,
layerable_cnn_list,
learning_rate=1e-05,
computable_loss=None,
opt_params=None,
verificatable_result=None,
pre_learned_path_list=None,
fc_w_arr=None,
fc_activation_function=None,
verbose_mode=False
):
logger = getLogger("pydbm")
handler = StreamHandler()
if verbose_mode is True:
handler.setLevel(DEBUG)
logger.setLevel(DEBUG)
else:
handler.setLevel(ERROR)
logger.setLevel(ERROR)
logger.addHandler(handler)
self.__logger = getLogger("pyqlearning")
handler = StreamHandler()
if verbose_mode is True:
self.__logger.setLevel(DEBUG)
else:
self.__logger.setLevel(ERROR)
self.__logger.addHandler(handler)
if computable_loss is None:
computable_loss = MeanSquaredError()
if verificatable_result is None:
verificatable_result = VerificateFunctionApproximation()
if opt_params is None:
opt_params = Adam()
opt_params.weight_limit = 0.5
opt_params.dropout_rate = 0.0
cnn = ConvolutionalNeuralNetwork(
# The `list` of `ConvolutionLayer`.
layerable_cnn_list=layerable_cnn_list,
# The number of epochs in mini-batch training.
epochs=200,
# The batch size.
batch_size=batch_size,
# Learning rate.
learning_rate=learning_rate,
# Loss function.
computable_loss=computable_loss,
# Optimizer.
opt_params=opt_params,
# Verification.
verificatable_result=verificatable_result,
# Others.
learning_attenuate_rate=0.1,
attenuate_epoch=50
)
self.__cnn = cnn
self.__batch_size = batch_size
self.__computable_loss = computable_loss
self.__learning_rate = learning_rate
self.__verbose_mode = verbose_mode
self.__fc_w_arr = fc_w_arr
self.__fc_activation_function = fc_activation_function
self.__q_shape = None
self.__q_logs_list = []
def __init__(
self,
batch_size,
nn_layer_list,
learning_rate=1e-05,
learning_attenuate_rate=0.1,
attenuate_epoch=50,
computable_loss=None,
opt_params=None,
verificatable_result=None,
pre_learned_path_list=None,
nn=None
):
'''
Init.
Args:
batch_size: Batch size in mini-batch.
nn_layer_list: `list` of `NNLayer`.
learning_rate: Learning rate.
learning_attenuate_rate: Attenuate the `learning_rate` by a factor of this value every `attenuate_epoch`.
attenuate_epoch: Attenuate the `learning_rate` by a factor of `learning_attenuate_rate` every `attenuate_epoch`.
Additionally, in relation to regularization,
this class constrains weight matrixes every `attenuate_epoch`.
computable_loss: is-a `ComputableLoss`.
opt_params: is-a `OptParams`.
verificatable_result: is-a `VerificateFunctionApproximation`.
pre_learned_path_list: `list` of file path that stored pre-learned parameters.
This parameters will be refered only when `cnn` is `None`.
nn: is-a `NeuralNetwork` as a model in this class.
If not `None`, `self.__nn` will be overrided by this `nn`.
If `None`, this class initialize `NeuralNetwork`
by default hyper parameters.
'''
if computable_loss is None:
computable_loss = MeanSquaredError()
if verificatable_result is None:
verificatable_result = VerificateFunctionApproximation()
if opt_params is None:
opt_params = Adam()
opt_params.weight_limit = 1e+10
opt_params.dropout_rate = 0.0
if nn is None:
nn = NeuralNetwork(
# The `list` of `ConvolutionLayer`.
nn_layer_list=nn_layer_list,
# The number of epochs in mini-batch training.
epochs=200,
# The batch size.
batch_size=batch_size,
# Learning rate.
learning_rate=learning_rate,
# Loss function.
computable_loss=computable_loss,
# Optimizer.
opt_params=opt_params,
# Verification.
verificatable_result=verificatable_result,
# Pre-learned parameters.
pre_learned_path_list=pre_learned_path_list,
# Others.
learning_attenuate_rate=learning_attenuate_rate,
attenuate_epoch=attenuate_epoch
)
self.__nn = nn
self.__batch_size = batch_size
self.__computable_loss = computable_loss
self.__learning_rate = learning_rate
self.__q_shape = None
self.__loss_list = []
self.__epoch_counter = 0
self.__learning_attenuate_rate = learning_attenuate_rate
self.__attenuate_epoch = attenuate_epoch
logger = getLogger("pygan")
self.__logger = logger
def __init__(self,
batch_size,
layerable_cnn_list,
cnn_output_graph,
learning_rate=1e-05,
learning_attenuate_rate=0.1,
attenuate_epoch=50,
computable_loss=None,
opt_params=None,
verificatable_result=None,
pre_learned_path_list=None,
pre_learned_output_path=None,
cnn=None,
verbose_mode=False):
'''
Init.
Args:
batch_size: Batch size in mini-batch.
layerable_cnn_list: `list` of `LayerableCNN`.
cnn_output_graph: Computation graph which is-a `CNNOutputGraph` to compute parameters in output layer.
learning_rate: Learning rate.
learning_attenuate_rate: Attenuate the `learning_rate` by a factor of this value every `attenuate_epoch`.
attenuate_epoch: Attenuate the `learning_rate` by a factor of `learning_attenuate_rate` every `attenuate_epoch`.
computable_loss: is-a `ComputableLoss`.
opt_params: is-a `OptParams`.
verificatable_result: is-a `VerificateFunctionApproximation`.
pre_learned_path_list: `list` of file path that stored pre-learned parameters.
This parameters will be refered only when `cnn` is `None`.
pre_learned_output_path: File path that stores pre-learned parameters.
cnn: is-a `ConvolutionalNeuralNetwork` as a model in this class.
If not `None`, `self.__cnn` will be overrided by this `cnn`.
If `None`, this class initialize `ConvolutionalNeuralNetwork`
by default hyper parameters.
verbose_mode: Verbose mode or not.
'''
logger = getLogger("pydbm")
handler = StreamHandler()
if verbose_mode is True:
handler.setLevel(DEBUG)
logger.setLevel(DEBUG)
else:
handler.setLevel(ERROR)
logger.setLevel(ERROR)
logger.addHandler(handler)
self.__logger = getLogger("pyqlearning")
handler = StreamHandler()
if verbose_mode is True:
self.__logger.setLevel(DEBUG)
else:
self.__logger.setLevel(ERROR)
self.__logger.addHandler(handler)
if computable_loss is None:
computable_loss = MeanSquaredError()
if verificatable_result is None:
verificatable_result = VerificateFunctionApproximation()
if opt_params is None:
opt_params = Adam()
opt_params.weight_limit = 1e+10
opt_params.dropout_rate = 0.0
if cnn is None:
cnn = ConvolutionalNeuralNetwork(
# The `list` of `ConvolutionLayer`.
layerable_cnn_list=layerable_cnn_list,
# The number of epochs in mini-batch training.
epochs=200,
# The batch size.
batch_size=batch_size,
# Learning rate.
learning_rate=learning_rate,
# Loss function.
computable_loss=computable_loss,
# Optimizer.
opt_params=opt_params,
# Verification.
verificatable_result=verificatable_result,
# Pre-learned parameters.
pre_learned_path_list=pre_learned_path_list,
# Others.
learning_attenuate_rate=learning_attenuate_rate,
attenuate_epoch=attenuate_epoch)
cnn.setup_output_layer(cnn_output_graph, pre_learned_output_path)
self.__cnn = cnn
self.__batch_size = batch_size
self.__computable_loss = computable_loss
self.__learning_rate = learning_rate
self.__learning_attenuate_rate = learning_attenuate_rate
self.__attenuate_epoch = attenuate_epoch
self.__verbose_mode = verbose_mode
self.__loss_list = []
self.__epoch_counter = 0
def __init__(self,
batch_size=20,
learning_rate=1e-10,
opt_params=None,
convolutional_auto_encoder=None,
deconvolution_layer_list=None,
gray_scale_flag=True,
verbose_mode=False):
'''
Init.
Args:
batch_size: Batch size in mini-batch.
learning_rate: Learning rate.
convolutional_auto_encoder: is-a `pydbm.cnn.convolutionalneuralnetwork.convolutional_auto_encoder.ConvolutionalAutoEncoder`.
deconvolution_layer_list: `list` of `DeconvolutionLayer`.
gray_scale_flag: Gray scale or not. If `True`, the channel will be `1`. If `False`, the channel will be `3`.
verbose_mode: Verbose mode or not.
'''
logger = getLogger("pydbm")
handler = StreamHandler()
if verbose_mode is True:
handler.setLevel(DEBUG)
logger.setLevel(DEBUG)
else:
handler.setLevel(ERROR)
logger.setLevel(ERROR)
logger.addHandler(handler)
if gray_scale_flag is True:
channel = 1
else:
channel = 3
if opt_params is None:
opt_params = Adam()
opt_params.dropout_rate = 0.0
if isinstance(opt_params, OptParams) is False:
raise TypeError()
scale = 0.01
if convolutional_auto_encoder is None:
conv1 = ConvolutionLayer1(
ConvGraph1(activation_function=TanhFunction(),
filter_num=batch_size,
channel=channel,
kernel_size=3,
scale=scale,
stride=1,
pad=1))
conv2 = ConvolutionLayer2(
ConvGraph2(activation_function=TanhFunction(),
filter_num=batch_size,
channel=batch_size,
kernel_size=3,
scale=scale,
stride=1,
pad=1))
convolutional_auto_encoder = CAE(
layerable_cnn_list=[conv1, conv2],
epochs=100,
batch_size=batch_size,
learning_rate=1e-05,
learning_attenuate_rate=0.1,
attenuate_epoch=25,
computable_loss=MeanSquaredError(),
opt_params=opt_params,
verificatable_result=VerificateFunctionApproximation(),
test_size_rate=0.3,
tol=1e-15,
save_flag=False)
if deconvolution_layer_list is None:
deconvolution_layer_list = [
DeconvolutionLayer(
DeCNNGraph(activation_function=TanhFunction(),
filter_num=batch_size,
channel=channel,
kernel_size=3,
scale=scale,
stride=1,
pad=1))
]
self.__convolutional_auto_encoder = convolutional_auto_encoder
self.__deconvolution_layer_list = deconvolution_layer_list
self.__opt_params = opt_params
self.__learning_rate = learning_rate
self.__verbose_mode = verbose_mode
self.__logger = logger
self.__batch_size = batch_size
self.__saved_img_n = 0
self.__attenuate_epoch = 50
def __init__(self,
deconvolution_model,
batch_size,
layerable_cnn_list,
learning_rate=1e-05,
computable_loss=None,
opt_params=None,
verificatable_result=None,
cnn=None,
condition_noise_sampler=None):
'''
Init.
Args:
deconvolution_model: is-a `DeconvolutionModel`.
batch_size: Batch size in mini-batch.
layerable_cnn_list: `list` of `LayerableCNN`.
cnn_output_graph: is-a `CNNOutputGraph`.
learning_rate: Learning rate.
computable_loss: is-a `ComputableLoss`.
This parameters will be refered only when `cnn` is `None`.
opt_params: is-a `OptParams`.
This parameters will be refered only when `cnn` is `None`.
verificatable_result: is-a `VerificateFunctionApproximation`.
This parameters will be refered only when `cnn` is `None`.
cnn: is-a `ConvolutionalNeuralNetwork` as a model in this class.
If not `None`, `self.__cnn` will be overrided by this `cnn`.
If `None`, this class initialize `ConvolutionalNeuralNetwork`
by default hyper parameters.
condition_noise_sampler: is-a `NoiseSampler` to add noise to outputs from `Conditioner`.
'''
if isinstance(deconvolution_model, DeconvolutionModel) is False:
raise TypeError()
self.__deconvolution_model = deconvolution_model
if cnn is None:
for layerable_cnn in layerable_cnn_list:
if isinstance(layerable_cnn, LayerableCNN) is False:
raise TypeError()
self.__layerable_cnn_list = layerable_cnn_list
self.__learning_rate = learning_rate
self.__opt_params = opt_params
if cnn is None:
if computable_loss is None:
computable_loss = MeanSquaredError()
if isinstance(computable_loss, ComputableLoss) is False:
raise TypeError()
if verificatable_result is None:
verificatable_result = VerificateFunctionApproximation()
if isinstance(verificatable_result, VerificatableResult) is False:
raise TypeError()
if opt_params is None:
opt_params = Adam()
opt_params.weight_limit = 1e+10
opt_params.dropout_rate = 0.0
if isinstance(opt_params, OptParams) is False:
raise TypeError()
cnn = ConvolutionalNeuralNetwork(
layerable_cnn_list=layerable_cnn_list,
computable_loss=computable_loss,
opt_params=opt_params,
verificatable_result=verificatable_result,
epochs=100,
batch_size=batch_size,
learning_rate=learning_rate,
learning_attenuate_rate=0.1,
test_size_rate=0.3,
tol=1e-15,
tld=100.0,
save_flag=False,
pre_learned_path_list=None)
self.__cnn = cnn
self.__condition_noise_sampler = condition_noise_sampler
self.__batch_size = batch_size
self.__computable_loss = computable_loss
self.__learning_rate = learning_rate
self.__q_shape = None
self.__loss_list = []
self.__epoch_counter = 0
logger = getLogger("pygan")
self.__logger = logger
def __init__(self,
batch_size,
layerable_cnn_list,
cnn_output_graph,
learning_rate=1e-05,
learning_attenuate_rate=0.1,
attenuate_epoch=50,
computable_loss=None,
opt_params=None,
verificatable_result=None,
cnn=None,
feature_matching_layer=0):
'''
Init.
Args:
batch_size: Batch size in mini-batch.
layerable_cnn_list: `list` of `LayerableCNN`.
cnn_output_graph: is-a `CNNOutputGraph`.
learning_rate: Learning rate.
learning_attenuate_rate: Attenuate the `learning_rate` by a factor of this value every `attenuate_epoch`.
attenuate_epoch: Attenuate the `learning_rate` by a factor of `learning_attenuate_rate` every `attenuate_epoch`.
Additionally, in relation to regularization,
this class constrains weight matrixes every `attenuate_epoch`.
computable_loss: is-a `ComputableLoss`.
This parameters will be refered only when `cnn` is `None`.
opt_params: is-a `OptParams`.
This parameters will be refered only when `cnn` is `None`.
verificatable_result: is-a `VerificateFunctionApproximation`.
This parameters will be refered only when `cnn` is `None`.
cnn: is-a `ConvolutionalNeuralNetwork` as a model in this class.
If not `None`, `self.__cnn` will be overrided by this `cnn`.
If `None`, this class initialize `ConvolutionalNeuralNetwork`
by default hyper parameters.
feature_matching_layer: Key of layer number for feature matching forward/backward.
'''
for layerable_cnn in layerable_cnn_list:
if isinstance(layerable_cnn, LayerableCNN) is False:
raise TypeError()
self.__layerable_cnn_list = layerable_cnn_list
self.__learning_rate = learning_rate
self.__opt_params = opt_params
if cnn is None:
if computable_loss is None:
computable_loss = MeanSquaredError()
if isinstance(computable_loss, ComputableLoss) is False:
raise TypeError()
if verificatable_result is None:
verificatable_result = VerificateFunctionApproximation()
if isinstance(verificatable_result, VerificatableResult) is False:
raise TypeError()
if opt_params is None:
opt_params = Adam()
opt_params.weight_limit = 1e+10
opt_params.dropout_rate = 0.0
if isinstance(opt_params, OptParams) is False:
raise TypeError()
cnn = ConvolutionalNeuralNetwork(
layerable_cnn_list=layerable_cnn_list,
computable_loss=computable_loss,
opt_params=opt_params,
verificatable_result=verificatable_result,
epochs=100,
batch_size=batch_size,
learning_rate=learning_rate,
learning_attenuate_rate=learning_attenuate_rate,
attenuate_epoch=attenuate_epoch,
test_size_rate=0.3,
tol=1e-15,
tld=100.0,
save_flag=False,
pre_learned_path_list=None)
cnn.setup_output_layer(cnn_output_graph)
self.__cnn = cnn
self.__batch_size = batch_size
self.__computable_loss = computable_loss
self.__learning_rate = learning_rate
self.__attenuate_epoch = attenuate_epoch
self.__learning_attenuate_rate = learning_attenuate_rate
self.__q_shape = None
self.__loss_list = []
self.__feature_matching_layer = feature_matching_layer
self.__epoch_counter = 0
logger = getLogger("pygan")
self.__logger = logger
def __init__(
self,
convolutional_auto_encoder=None,
batch_size=10,
channel=1,
learning_rate=1e-10,
learning_attenuate_rate=0.1,
attenuate_epoch=50,
opt_params=None,
feature_matching_layer=0
):
'''
Init.
Args:
convolutional_auto_encoder: is-a `pydbm.cnn.convolutionalneuralnetwork.convolutional_auto_encoder.ConvolutionalAutoEncoder`.
learning_rate: Learning rate.
batch_size: Batch size in mini-batch.
learning_rate: Learning rate.
learning_attenuate_rate: Attenuate the `learning_rate` by a factor of this value every `attenuate_epoch`.
attenuate_epoch: Attenuate the `learning_rate` by a factor of `learning_attenuate_rate` every `attenuate_epoch`.
Additionally, in relation to regularization,
this class constrains weight matrixes every `attenuate_epoch`.
opt_params: is-a `pydbm.optimization.opt_params.OptParams`.
feature_matching_layer: Key of layer number for feature matching forward/backward.
'''
if isinstance(convolutional_auto_encoder, CAE) is False and convolutional_auto_encoder is not None:
raise TypeError("The type of `convolutional_auto_encoder` must be `pydbm.cnn.convolutionalneuralnetwork.convolutional_auto_encoder.ConvolutionalAutoEncoder`.")
if opt_params is None:
opt_params = Adam()
opt_params.weight_limit = 1e+10
opt_params.dropout_rate = 0.0
if convolutional_auto_encoder is None:
scale = 0.01
conv1 = ConvolutionLayer1(
ConvGraph1(
activation_function=TanhFunction(),
filter_num=batch_size,
channel=channel,
kernel_size=3,
scale=scale,
stride=1,
pad=1
)
)
conv2 = ConvolutionLayer2(
ConvGraph2(
activation_function=TanhFunction(),
filter_num=batch_size,
channel=batch_size,
kernel_size=3,
scale=scale,
stride=1,
pad=1
)
)
convolutional_auto_encoder = RepellingConvolutionalAutoEncoder(
layerable_cnn_list=[
conv1,
conv2
],
epochs=100,
batch_size=batch_size,
learning_rate=learning_rate,
learning_attenuate_rate=learning_attenuate_rate,
attenuate_epoch=attenuate_epoch,
computable_loss=MeanSquaredError(),
opt_params=opt_params,
verificatable_result=VerificateFunctionApproximation(),
test_size_rate=0.3,
tol=1e-15,
save_flag=False
)
self.__convolutional_auto_encoder = convolutional_auto_encoder
self.__learning_rate = learning_rate
self.__attenuate_epoch = attenuate_epoch
self.__learning_attenuate_rate = learning_attenuate_rate
self.__epoch_counter = 0
self.__feature_matching_layer = feature_matching_layer
logger = getLogger("pygan")
self.__logger = logger
def __init__(self,
batch_size,
layerable_cnn_list,
cnn_output_graph,
learning_rate=1e-05,
computable_loss=None,
opt_params=None,
verificatable_result=None,
cnn=None,
verbose_mode=False):
'''
Init.
Args:
batch_size: Batch size in mini-batch.
layerable_cnn_list: `list` of `LayerableCNN`.
cnn_output_graph: is-a `CNNOutputGraph`.
learning_rate: Learning rate.
computable_loss: is-a `ComputableLoss`.
This parameters will be refered only when `cnn` is `None`.
opt_params: is-a `OptParams`.
This parameters will be refered only when `cnn` is `None`.
verificatable_result: is-a `VerificateFunctionApproximation`.
This parameters will be refered only when `cnn` is `None`.
cnn: is-a `ConvolutionalNeuralNetwork` as a model in this class.
If not `None`, `self.__cnn` will be overrided by this `cnn`.
If `None`, this class initialize `ConvolutionalNeuralNetwork`
by default hyper parameters.
verbose_mode: Verbose mode or not.
'''
for layerable_cnn in layerable_cnn_list:
if isinstance(layerable_cnn, LayerableCNN) is False:
raise TypeError()
logger = getLogger("pydbm")
handler = StreamHandler()
if verbose_mode is True:
handler.setLevel(DEBUG)
logger.setLevel(DEBUG)
else:
handler.setLevel(ERROR)
logger.setLevel(ERROR)
logger.addHandler(handler)
self.__layerable_cnn_list = layerable_cnn_list
self.__learning_rate = learning_rate
self.__opt_params = opt_params
self.__logger = logger
if cnn is None:
if computable_loss is None:
computable_loss = MeanSquaredError()
if isinstance(computable_loss, ComputableLoss) is False:
raise TypeError()
if verificatable_result is None:
verificatable_result = VerificateFunctionApproximation()
if isinstance(verificatable_result, VerificatableResult) is False:
raise TypeError()
if opt_params is None:
opt_params = Adam()
opt_params.weight_limit = 0.5
opt_params.dropout_rate = 0.0
if isinstance(opt_params, OptParams) is False:
raise TypeError()
cnn = ConvolutionalNeuralNetwork(
layerable_cnn_list=layerable_cnn_list,
computable_loss=computable_loss,
opt_params=opt_params,
verificatable_result=verificatable_result,
epochs=100,
batch_size=batch_size,
learning_rate=learning_rate,
learning_attenuate_rate=0.1,
test_size_rate=0.3,
tol=1e-15,
tld=100.0,
save_flag=False,
pre_learned_path_list=None)
cnn.setup_output_layer(cnn_output_graph)
self.__cnn = cnn
self.__batch_size = batch_size
self.__computable_loss = computable_loss
self.__learning_rate = learning_rate
self.__verbose_mode = verbose_mode
self.__q_shape = None
self.__loss_list = []
def __build_encoder_decoder_controller(self,
input_neuron_count=20,
hidden_neuron_count=20,
weight_limit=1e+15,
dropout_rate=0.5,
epochs=1000,
batch_size=20,
learning_rate=1e-05,
attenuate_epoch=50,
learning_attenuate_rate=1.0,
seq_len=8,
bptt_tau=8,
test_size_rate=0.3,
tol=1e-10,
tld=100.0):
encoder_graph = EncoderGraph()
encoder_graph.observed_activating_function = LogisticFunction()
encoder_graph.input_gate_activating_function = LogisticFunction()
encoder_graph.forget_gate_activating_function = LogisticFunction()
encoder_graph.output_gate_activating_function = LogisticFunction()
encoder_graph.hidden_activating_function = LogisticFunction()
encoder_graph.output_activating_function = LogisticFunction()
encoder_graph.create_rnn_cells(input_neuron_count=input_neuron_count,
hidden_neuron_count=hidden_neuron_count,
output_neuron_count=1)
encoder_opt_params = EncoderAdam()
encoder_opt_params.weight_limit = weight_limit
encoder_opt_params.dropout_rate = dropout_rate
encoder = Encoder(
graph=encoder_graph,
epochs=100,
batch_size=batch_size,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
bptt_tau=8,
test_size_rate=0.3,
computable_loss=MeanSquaredError(),
opt_params=encoder_opt_params,
verificatable_result=VerificateFunctionApproximation(),
tol=tol,
tld=tld)
decoder_graph = DecoderGraph()
decoder_graph.observed_activating_function = LogisticFunction()
decoder_graph.input_gate_activating_function = LogisticFunction()
decoder_graph.forget_gate_activating_function = LogisticFunction()
decoder_graph.output_gate_activating_function = LogisticFunction()
decoder_graph.hidden_activating_function = LogisticFunction()
decoder_graph.output_activating_function = SoftmaxFunction()
decoder_graph.create_rnn_cells(input_neuron_count=hidden_neuron_count,
hidden_neuron_count=hidden_neuron_count,
output_neuron_count=input_neuron_count)
decoder_opt_params = DecoderAdam()
decoder_opt_params.weight_limit = weight_limit
decoder_opt_params.dropout_rate = dropout_rate
decoder = Decoder(
graph=decoder_graph,
epochs=100,
batch_size=batch_size,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
seq_len=seq_len,
bptt_tau=bptt_tau,
test_size_rate=0.3,
computable_loss=MeanSquaredError(),
opt_params=decoder_opt_params,
verificatable_result=VerificateFunctionApproximation())
encoder_decoder_controller = EncoderDecoderController(
encoder=encoder,
decoder=decoder,
epochs=epochs,
batch_size=batch_size,
learning_rate=learning_rate,
learning_attenuate_rate=learning_attenuate_rate,
attenuate_epoch=attenuate_epoch,
test_size_rate=test_size_rate,
computable_loss=MeanSquaredError(),
verificatable_result=VerificateFunctionApproximation(),
tol=tol,
tld=tld)
return encoder_decoder_controller
