from pprint import pprint
from sklearn.datasets import make_classification
from sklearn.cross_validation import train_test_split
data_tuple = make_classification(n_samples=1000,
n_features=100,
n_informative=10,
n_classes=2,
class_sep=1.0)
data_tuple_x, data_tuple_y = data_tuple
traning_x, test_x, traning_y, test_y = train_test_split(data_tuple_x,
data_tuple_y,
test_size=0.3,
random_state=555)
traning_y = traning_y.reshape(-1, 1)
test_y = test_y.reshape(-1, 1)
nn = NeuralNetwork(
NNMultiLayerBuilder(), [traning_x.shape[1], 10, traning_y.shape[1]],
[LogisticFunction(),
LogisticFunction(),
LogisticFunction()])
nn.learn(traning_x,
traning_y,
traning_count=1000,
learning_rate=0.00001,
momentum_factor=0.00001)
for i in range(10):
pred_arr = nn.predict(test_x[i])
print(pred_arr)
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 __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