def __init__( self, batch_size, conv_lstm_model, seq_len=10, learning_rate=1e-05, computable_loss=None, opt_params=None, verificatable_result=None, pre_learned_path_list=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 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.__q_logs_list = []
def __init__(self, deconvolution_layer_list, computable_loss=None, cnn_output_graph=None, opt_params=None, learning_rate=1e-05, learning_attenuate_rate=0.1, attenuate_epoch=50): ''' Init. Args: deconvolution_layer_list: `list` of `DeconvolutionLayer`. computable_loss: Loss function. cnn_output_graph: is-a `CNNOutputGraph`. opt_params: is-a `OptParams`. If `None`, this value will be `Adam`. 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`. ''' for deconvolution_layer in deconvolution_layer_list: if isinstance(deconvolution_layer, DeconvolutionLayer) is False: raise TypeError() if cnn_output_graph is not None and isinstance( cnn_output_graph, CNNOutputGraph) is False: raise TypeError( "The type of `cnn_output_graph` must be `CNNOutputGraph`.") 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() self.__deconvolution_layer_list = deconvolution_layer_list self.__computable_loss = computable_loss self.__cnn_output_graph = cnn_output_graph self.__learning_rate = learning_rate self.__learning_attenuate_rate = learning_attenuate_rate self.__attenuate_epoch = attenuate_epoch self.__opt_params = opt_params self.__epoch_counter = 0 logger = getLogger("pygan") self.__logger = logger
def __init__(self, deconvolution_layer_list, computable_loss=None, cnn_output_graph=None, opt_params=None, learning_rate=1e-05): ''' Init. Args: deconvolution_layer_list: `list` of `DeconvolutionLayer`. computable_loss: Loss function. cnn_output_graph: is-a `CNNOutputGraph`. opt_params: is-a `OptParams`. If `None`, this value will be `Adam`. learning_rate: Learning rate. ''' for deconvolution_layer in deconvolution_layer_list: if isinstance(deconvolution_layer, DeconvolutionLayer) is False: raise TypeError() if cnn_output_graph is not None and isinstance( cnn_output_graph, CNNOutputGraph) is False: raise TypeError( "The type of `cnn_output_graph` must be `CNNOutputGraph`.") 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() self.__deconvolution_layer_list = deconvolution_layer_list self.__computable_loss = computable_loss self.__cnn_output_graph = cnn_output_graph self.__learning_rate = learning_rate self.__attenuate_epoch = 50 self.__opt_params = opt_params self.__epoch_counter = 0 logger = getLogger("pygan") self.__logger = logger
def __build_retrospective_encoder( self, input_neuron_count=20, hidden_neuron_count=20, weight_limit=0.5, dropout_rate=0.5, batch_size=20, learning_rate=1e-05, bptt_tau=8 ): encoder_graph = ReEncoderGraph() encoder_graph.observed_activating_function = TanhFunction() 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 = ReEncoder( graph=encoder_graph, epochs=100, batch_size=batch_size, learning_rate=learning_rate, learning_attenuate_rate=0.1, attenuate_epoch=50, bptt_tau=bptt_tau, test_size_rate=0.3, computable_loss=MeanSquaredError(), opt_params=encoder_opt_params, verificatable_result=VerificateFunctionApproximation() ) return encoder
def __init__(self, deconvolution_layer_list, opt_params=None, learning_rate=1e-05, verbose_mode=False): ''' Init. Args: deconvolution_layer_list: `list` of `DeconvolutionLayer`. opt_params: is-a `OptParams`. If `None`, this value will be `Adam`. learning_rate: Learning rate. verbose_mode: Verbose mode or not. ''' for deconvolution_layer in deconvolution_layer_list: if isinstance(deconvolution_layer, DeconvolutionLayer) is False: raise TypeError() if opt_params is None: opt_params = Adam() opt_params.dropout_rate = 0.0 if isinstance(opt_params, OptParams) 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.__deconvolution_layer_list = deconvolution_layer_list self.__learning_rate = learning_rate self.__attenuate_epoch = 50 self.__opt_params = opt_params self.__logger = logger
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 ): 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=0.1, 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=0.1, 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
def __init__(self, convolutional_auto_encoder=None, batch_size=10, channel=1, learning_rate=1e-10, 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. 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.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=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) self.__convolutional_auto_encoder = convolutional_auto_encoder self.__learning_rate = learning_rate self.__epoch_counter = 0 self.__feature_matching_layer = feature_matching_layer logger = getLogger("pygan") self.__logger = logger
def __init__(self, midi_path_list, batch_size=20, seq_len=8, time_fraction=1.0, learning_rate=1e-10, hidden_dim=15200, generative_model=None, discriminative_model=None, gans_value_function=None): ''' Init. Args: midi_path_list: `list` of paths to MIDI files. batch_size: Batch size. seq_len: The length of sequence that LSTM networks will observe. time_fraction: Time fraction or time resolution (seconds). learning_rate: Learning rate in `Generator` and `Discriminator`. hidden_dim: The number of units in hidden layer of `DiscriminativeModel`. true_sampler: is-a `TrueSampler`. noise_sampler: is-a `NoiseSampler`. generative_model: is-a `GenerativeModel`. discriminative_model: is-a `DiscriminativeModel`. gans_value_function: is-a `GANsValueFunction`. ''' self.__midi_controller = MidiController() self.__midi_df_list = [ self.__midi_controller.extract(midi_path) for midi_path in midi_path_list ] bar_gram = BarGram(midi_df_list=self.__midi_df_list, time_fraction=time_fraction) self.__bar_gram = bar_gram dim = self.__bar_gram.dim true_sampler = BarGramTrueSampler(bar_gram=bar_gram, midi_df_list=self.__midi_df_list, batch_size=batch_size, seq_len=seq_len, time_fraction=time_fraction) noise_sampler = BarGramNoiseSampler(bar_gram=bar_gram, midi_df_list=self.__midi_df_list, batch_size=batch_size, seq_len=seq_len, time_fraction=time_fraction) if generative_model is None: conv_activation_function = TanhFunction() conv_activation_function.batch_norm = BatchNorm() channel = noise_sampler.channel convolution_layer_list = [ ConvolutionLayer1( ConvGraph1(activation_function=conv_activation_function, filter_num=batch_size, channel=channel, kernel_size=3, scale=0.01, stride=1, pad=1)) ] deconv_activation_function = SoftmaxFunction() deconvolution_layer_list = [ DeconvolutionLayer( DeCNNGraph(activation_function=deconv_activation_function, filter_num=batch_size, channel=channel, kernel_size=3, scale=0.01, stride=1, pad=1)) ] opt_params_deconv = Adam() deconvolution_model = DeconvolutionModel( deconvolution_layer_list=deconvolution_layer_list, opt_params=opt_params_deconv) opt_params = Adam() opt_params.dropout_rate = 0.0 generative_model = Generator( batch_size=batch_size, layerable_cnn_list=convolution_layer_list, deconvolution_model=deconvolution_model, condition_noise_sampler=UniformNoiseSampler( low=-0.1, high=0.1, output_shape=(batch_size, channel, seq_len, dim)), learning_rate=learning_rate, ) generative_model.noise_sampler = noise_sampler if discriminative_model is None: activation_function = LogisticFunction() activation_function.batch_norm = BatchNorm() # First convolution layer. conv2 = ConvolutionLayer2( # Computation graph for first convolution layer. ConvGraph2( # Logistic function as activation function. activation_function=activation_function, # The number of `filter`. filter_num=batch_size, # The number of channel. channel=noise_sampler.channel * 2, # The size of kernel. kernel_size=3, # The filter scale. scale=0.001, # The nubmer of stride. stride=1, # The number of zero-padding. pad=1)) # Stack. layerable_cnn_list = [conv2] opt_params = Adam() opt_params.dropout_rate = 0.0 if hidden_dim is None: hidden_dim = channel * seq_len * dim cnn_output_activating_function = LogisticFunction() cnn_output_graph = CNNOutputGraph( hidden_dim=hidden_dim, output_dim=1, activating_function=cnn_output_activating_function, scale=0.01) discriminative_model = Discriminator( batch_size=batch_size, layerable_cnn_list=layerable_cnn_list, cnn_output_graph=cnn_output_graph, opt_params=opt_params, computable_loss=CrossEntropy(), learning_rate=learning_rate) if gans_value_function is None: gans_value_function = MiniMax() GAN = GenerativeAdversarialNetworks( gans_value_function=gans_value_function, feature_matching=FeatureMatching(lambda1=0.01, lambda2=0.99)) self.__noise_sampler = noise_sampler self.__true_sampler = true_sampler self.__generative_model = generative_model self.__discriminative_model = discriminative_model self.__GAN = GAN self.__time_fraction = time_fraction
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, cnn=None, verbose_mode=False ): ''' Init. Args: batch_size: Batch size in mini-batch. layerable_cnn_list: `list` of `LayerableCNN`. 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`. fc_w_arr: `np.ndarray` of weight matrix in output layer. fc_activation_function: is-a `ActivatingFunctionInterface`. 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 = 0.5 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=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.__loss_list = []
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 sentences. token_master_list: Unique `list` of tokens. hidden_neuron_count: The number of units in hidden layer. epochs: Epochs of Mini-batch. bath_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=observed_arr.shape[-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=observed_arr.shape[-1], output_neuron_count=hidden_neuron_count) 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, # 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, lstm_model, seq_len=10, learning_rate=1e-05, learning_attenuate_rate=0.1, attenuate_epoch=50, computable_loss=None, opt_params=None, verificatable_result=None, verbose_mode=False): ''' Init. Args: batch_size: Batch size in mini-batch. lstm_model: is-a `LSTMMode`. seq_len: The length of sequences. 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`. 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(lstm_model, LSTMModel) 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 = 1e+10 opt_params.dropout_rate = 0.0 self.__lstm_model = lstm_model self.__seq_len = seq_len 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.__next_action_arr_list = [] self.__real_q_arr_list = [] self.__predicted_q_arr_list = [] self.__q_arr = None self.__epoch_counter = 0
def __init__(self, batch_size, nn_layer_list, learning_rate=1e-05, computable_loss=None, opt_params=None, verificatable_result=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`. 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. 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 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.__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, 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, channel=None): ''' 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. This parameter will be refered when `channel` is None. If `True`, the channel will be `1`. If `False`, the channel will be `3`. channel: Channel. ''' if channel is None: 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.__batch_size = batch_size self.__saved_img_n = 0 self.__attenuate_epoch = 50 self.__epoch_counter = 0 logger = getLogger("pygan") self.__logger = logger
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, deconvolution_model, batch_size, layerable_cnn_list, learning_rate=1e-05, learning_attenuate_rate=0.1, attenuate_epoch=50, 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. 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. 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=learning_attenuate_rate, 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.__attenuate_epoch = attenuate_epoch self.__learning_attenuate_rate = learning_attenuate_rate self.__q_shape = None self.__loss_list = [] 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, 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, 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.convolutionalautoencoder.ConvolutionalLadderNetworks`. 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, CLN) 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 = CLN( 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 super().__init__(convolutional_auto_encoder=convolutional_auto_encoder, batch_size=batch_size, channel=channel, learning_rate=learning_rate, learning_attenuate_rate=learning_attenuate_rate, attenuate_epoch=attenuate_epoch, opt_params=opt_params, feature_matching_layer=feature_matching_layer) self.__alpha_loss_list = [] self.__sigma_loss_list = [] self.__mu_loss_list = []
def __init__(self, token_list, epochs=300, skip_n=1, batch_size=50, feature_dim=20, scale=1e-05, learning_rate=1e-05, auto_encoder=None): ''' Initialize. Args: token_list: The list of all tokens in all sentences. skip_n: N of n-gram. training_count: The epochs. batch_size: Batch size. learning_rate: Learning rate. feature_dim: The dimension of feature points. ''' if auto_encoder is not None and isinstance(auto_encoder, SimpleAutoEncoder) is False: raise TypeError() self.__logger = getLogger("pydbm") self.__token_arr = np.array(token_list) self.__token_uniquie_arr = np.array(list(set(token_list))) if auto_encoder is None: activation_function = TanhFunction() encoder_graph = EncoderGraph( activation_function=activation_function, hidden_neuron_count=self.__token_uniquie_arr.shape[0], output_neuron_count=feature_dim, scale=scale, ) encoder_layer = EncoderLayer(encoder_graph) opt_params = Adam() opt_params.dropout_rate = 0.5 encoder = Encoder( nn_layer_list=[ encoder_layer, ], epochs=epochs, batch_size=batch_size, learning_rate=learning_rate, learning_attenuate_rate=1.0, attenuate_epoch=50, computable_loss=CrossEntropy(), opt_params=opt_params, verificatable_result=VerificateFunctionApproximation(), test_size_rate=0.3, tol=1e-15) decoder_graph = DecoderGraph( activation_function=SoftmaxFunction(), hidden_neuron_count=feature_dim, output_neuron_count=self.__token_uniquie_arr.shape[0], scale=scale, ) decoder_layer = DecoderLayer(decoder_graph) opt_params = Adam() opt_params.dropout_rate = 0.0 decoder = Decoder( nn_layer_list=[ decoder_layer, ], epochs=epochs, batch_size=batch_size, learning_rate=learning_rate, learning_attenuate_rate=1.0, attenuate_epoch=50, computable_loss=CrossEntropy(), opt_params=opt_params, verificatable_result=VerificateFunctionApproximation(), test_size_rate=0.3, tol=1e-15) auto_encoder = SimpleAutoEncoder( encoder=encoder, decoder=decoder, epochs=epochs, batch_size=batch_size, learning_rate=learning_rate, learning_attenuate_rate=1.0, attenuate_epoch=50, computable_loss=CrossEntropy(), verificatable_result=VerificateFunctionApproximation(), test_size_rate=0.3, tol=1e-15, ) self.__auto_encoder = auto_encoder self.__epochs = epochs self.__batch_size = batch_size self.__skip_n = skip_n
def Main(params_dict): logger = getLogger("pydbm") handler = StreamHandler() if params_dict["debug_mode"] is True: handler.setLevel(DEBUG) logger.setLevel(DEBUG) else: handler.setLevel(ERROR) logger.setLevel(ERROR) logger.addHandler(handler) epochs = params_dict["epochs"] batch_size = params_dict["batch_size"] seq_len = params_dict["seq_len"] channel = params_dict["channel"] height = params_dict["height"] width = params_dict["width"] scale = params_dict["scale"] training_image_dir = params_dict["training_image_dir"] test_image_dir = params_dict["test_image_dir"] enc_dim = batch_size * height * width dec_dim = batch_size * height * width feature_generator = ImageGenerator(epochs=epochs, batch_size=batch_size, training_image_dir=training_image_dir, test_image_dir=test_image_dir, seq_len=seq_len, gray_scale_flag=True, wh_size_tuple=(height, width), norm_mode="z_score") # Init. encoder_graph = EncoderGraph() # Activation function in LSTM. encoder_graph.observed_activating_function = TanhFunction() 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 = TanhFunction() 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=enc_dim, hidden_neuron_count=200, output_neuron_count=enc_dim) # Optimizer for Encoder. encoder_opt_params = EncoderAdam() encoder_opt_params.weight_limit = 0.5 encoder_opt_params.dropout_rate = 0.5 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=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, # 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(), # Tolerance for the optimization. # When the loss or score is not improving by at least tol # for two consecutive iterations, convergence is considered # to be reached and training stops. tol=0.0) # Init. decoder_graph = DecoderGraph() # Activation function in LSTM. decoder_graph.observed_activating_function = TanhFunction() 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 = TanhFunction() 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=200, hidden_neuron_count=dec_dim, output_neuron_count=200) # Optimizer for Decoder. decoder_opt_params = DecoderAdam() decoder_opt_params.weight_limit = 0.5 decoder_opt_params.dropout_rate = 0.5 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=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, # 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=decoder_opt_params, # Verification function. verificatable_result=VerificateFunctionApproximation(), # Tolerance for the optimization. # When the loss or score is not improving by at least tol # for two consecutive iterations, convergence is considered # to be reached and training stops. tol=0.0) 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)) cnn = SpatioTemporalAutoEncoder( layerable_cnn_list=[conv1, conv2], encoder=encoder, decoder=decoder, epochs=epochs, batch_size=batch_size, learning_rate=1e-05, learning_attenuate_rate=0.1, attenuate_epoch=25, computable_loss=MeanSquaredError(), opt_params=Adam(), verificatable_result=VerificateFunctionApproximation(), test_size_rate=0.3, tol=1e-15, save_flag=False) cnn.learn_generated(feature_generator) test_len = 0 test_limit = 1 test_arr_list = [] rec_arr_list = [] for batch_observed_arr, batch_target_arr, test_batch_observed_arr, test_batch_target_arr in feature_generator.generate( ): test_len += 1 result_arr = cnn.inference(test_batch_observed_arr) for batch in range(test_batch_target_arr.shape[0]): for seq in range(test_batch_target_arr[batch].shape[0]): arr = test_batch_target_arr[batch][seq][0] arr = (arr - arr.min()) / (arr.max() - arr.min()) arr *= 255 img = Image.fromarray(np.uint8(arr)) img.save("result/" + str(i) + "_" + str(seq) + "_observed.png") for seq in range(result_arr[batch].shape[0]): arr = result_arr[batch][seq][0] arr = (arr - arr.min()) / (arr.max() - arr.min()) arr *= 255 img = Image.fromarray(np.uint8(arr)) img.save("result/" + str(i) + "_" + str(seq) + "_reconsturcted.png") if test_len >= test_limit: break
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, 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. 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=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.__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, layerable_cnn_list, lstm_model, seq_len=10, learning_rate=1e-05, computable_loss=None, opt_params=None, verificatable_result=None, pre_learned_path_list=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 isinstance(lstm_model, LSTMModel) 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 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.__lstm_model = 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.__q_shape = None self.__q_logs_list = []
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 = []