def test_table_drawing(self):
table_drawing_result = textwrap.dedent("""
------------------------------
| Col 1 | Col 2 | Col 3 |
------------------------------
| test | 33.0 | val |
| test2 | -3.0 | val 2 |
------------------------------
| Warning message |
------------------------------
| test3 | 0.0 | val 3 |
------------------------------
""").strip()
table_drawing = table.TableBuilder(
table.Column("Col 1"),
table.Column("Col 2", dtype=float),
table.Column("Col 3", width=10),
)
with catch_stdout() as out:
table_drawing.start()
table_drawing.row(['test', 33, 'val'])
table_drawing.row(['test2', -3, 'val 2'])
table_drawing.message("Warning message")
table_drawing.row(['test3', 0, 'val 3'])
table_drawing.finish()
terminal_output = out.getvalue().strip()
terminal_output = terminal_output.replace('\r', '')
# Use assertTrue to make sure that it won't through
# all variables in terminal in case of error
self.assertTrue(table_drawing_result == terminal_output)
def architecture(self):
"""
Shows network's architecture in the terminal if
``verbose`` parameter is equal to ``True``.
"""
if not is_sequential(self.connection):
raise TypeError("You can check architecture only for sequential "
"connections. For other types of connections it's "
"better to use the `neupy.plots.layer_structure` "
"function.")
self.logs.title("Network's architecture")
values = []
for index, layer in enumerate(self.layers, start=1):
input_shape = preformat_layer_shape(layer.input_shape)
output_shape = preformat_layer_shape(layer.output_shape)
classname = layer.__class__.__name__
values.append((index, input_shape, classname, output_shape))
table.TableBuilder.show_full_table(
columns=[
table.Column(name="#"),
table.Column(name="Input shape"),
table.Column(name="Layer Type"),
table.Column(name="Output shape"),
],
values=values,
stdout=self.logs.write,
)
self.logs.newline()
def architecture(self):
""" Shows network's architecture in the terminal if
``verbose`` parameter is equal to ``True``.
"""
self.logs.title("Network's architecture")
values = []
for index, layer in enumerate(self.layers, start=1):
input_shape = preformat_layer_shape(layer.input_shape)
output_shape = preformat_layer_shape(layer.output_shape)
classname = layer.__class__.__name__
values.append((index, input_shape, classname, output_shape))
table.TableBuilder.show_full_table(
columns=[
table.Column(name="#"),
table.Column(name="Input shape"),
table.Column(name="Layer Type"),
table.Column(name="Output shape"),
],
values=values,
stdout=self.logs.write,
)
self.logs.newline()
def test_idle_state_raises(self):
table_drawing = table.TableBuilder(
table.Column("Col 1"),
table.Column("Col 2"),
)
with self.assertRaises(table.TableDrawingError):
table_drawing.finish()
with self.assertRaises(table.TableDrawingError):
table_drawing.row([1, 2])
def test_drawing_state_raises(self):
table_drawing = table.TableBuilder(
table.Column("Col 1"),
table.Column("Col 2"),
)
with catch_stdout():
table_drawing.start()
with self.assertRaises(table.TableDrawingError):
table_drawing.start()
with self.assertRaises(table.TableDrawingError):
table_drawing.header()
def test_table_state_variables(self):
table_builder = table.TableBuilder(table.Column("Col 1"))
# use direct access to __getattr__ for code coverage
self.assertEqual(len(table_builder.__getattr__('columns')), 1)
# self.assertIn is not working here
self.assertEqual(id(table_builder.__getattr__('row')),
id(table_builder.state.row))
def test_table_builder_exception(self):
with self.assertRaises(ValueError):
table.TableBuilder(invalid=True)
with self.assertRaises(TypeError):
table.TableBuilder(
table.Column("Col 1"),
'not a column',
)
def test_table_drawing(self):
table_drawing = table.TableBuilder(
table.Column("Col 1"),
table.Column("Col 2", dtype=float),
table.Column("Col 3", width=10),
)
with catch_stdout() as out:
table_drawing.start()
table_drawing.row(['test', 33, 'val'])
table_drawing.row(['test2', -3, 'val 2'])
table_drawing.message("Warning message")
table_drawing.row(['test3', 0, 'val 3'])
table_drawing.finish()
terminal_output = out.getvalue().strip()
self.assertEqual(table_drawing_result,
terminal_output.replace('\r', ''))
def show_epoch_summary(network):
delay_limit = 1. # delay time in seconds
prev_summary_time = None
delay_history_length = 10
terminal_output_delays = deque(maxlen=delay_history_length)
table_drawer = table.TableDrawer(table.Column(name="Epoch #"),
table.NumberColumn(name="Train err"),
table.NumberColumn(name="Valid err"),
table.TimeColumn(name="Time", width=10),
stdout=network.logs.write)
table_drawer.start()
try:
yield
while True:
now = time.time()
if prev_summary_time is not None:
time_delta = now - prev_summary_time
terminal_output_delays.append(time_delta)
table_drawer.row([
network.last_epoch,
network.errors.last() or '-',
network.validation_errors.last() or '-',
network.training.epoch_time,
])
prev_summary_time = now
if len(terminal_output_delays) == delay_history_length:
prev_summary_time = None
average_delay = np.mean(terminal_output_delays)
if average_delay < delay_limit:
show_epoch = int(network.training.show_epoch *
math.ceil(delay_limit / average_delay))
table_drawer.line()
table_drawer.message("Too many outputs in a terminal.")
table_drawer.message("Set up logging after each {} epochs"
"".format(show_epoch))
table_drawer.line()
terminal_output_delays.clear()
network.training.show_epoch = show_epoch
yield
finally:
table_drawer.finish()
network.logs.newline()
def test_summary_table_slow_training(self):
with catch_stdout() as out:
network = algorithms.GradientDescent((2, 3, 1), verbose=True)
summary = SummaryTable(network,
table_builder=table.TableBuilder(
table.Column(name="Epoch #"),
table.NumberColumn(name="Train err",
places=4),
table.NumberColumn(name="Valid err",
places=4),
table.TimeColumn(name="Time", width=10),
stdout=network.logs.write),
delay_limit=0,
delay_history_length=1)
for _ in range(3):
network.training.epoch_time = 0.1
summary.show_last()
terminal_output = out.getvalue()
self.assertNotIn("Too many outputs", terminal_output)
def test_base_column(self):
col1 = table.Column(name="Test1")
self.assertIsInstance(col1.format_value(6), str)
col2 = table.Column(name="Test2", dtype=int)
self.assertIsInstance(col2.format_value(6.0), int)
def train(self, input_train, target_train=None, input_test=None,
target_test=None, epochs=100, epsilon=None,
summary='table'):
"""
Method train neural network.
Parameters
----------
input_train : array-like
target_train : array-like or None
input_test : array-like or None
target_test : array-like or None
epochs : int
Defaults to `100`.
epsilon : float or None
Defaults to ``None``.
"""
show_epoch = self.show_epoch
logs = self.logs
training = self.training = AttributeKeyDict()
if epochs <= 0:
raise ValueError("Number of epochs needs to be greater than 0.")
if epsilon is not None and epochs <= 2:
raise ValueError("Network should train at teast 3 epochs before "
"check the difference between errors")
logging_info_about_the_data(self, input_train, input_test)
logging_info_about_training(self, epochs, epsilon)
logs.newline()
if summary == 'table':
summary = SummaryTable(
table_builder=table.TableBuilder(
table.Column(name="Epoch #"),
table.NumberColumn(name="Train err", places=4),
table.NumberColumn(name="Valid err", places=4),
table.TimeColumn(name="Time", width=10),
stdout=logs.write
),
network=self,
delay_limit=1.,
delay_history_length=10,
)
elif summary == 'inline':
summary = InlineSummary(network=self)
else:
raise ValueError("`{}` is unknown summary type"
"".format(summary))
iterepochs = create_training_epochs_iterator(self, epochs, epsilon)
show_epoch = parse_show_epoch_property(self, epochs, epsilon)
training.show_epoch = show_epoch
# Storring attributes and methods in local variables we prevent
# useless __getattr__ call a lot of times in each loop.
# This variables speed up loop in case on huge amount of
# iterations.
training_errors = self.errors
validation_errors = self.validation_errors
shuffle_data = self.shuffle_data
train_epoch = self.train_epoch
epoch_end_signal = self.epoch_end_signal
train_end_signal = self.train_end_signal
on_epoch_start_update = self.on_epoch_start_update
is_first_iteration = True
can_compute_validation_error = (input_test is not None)
last_epoch_shown = 0
#############################################
symMatrix = tt.dmatrix("symMatrix")
symEigenvalues, eigenvectors = tt.nlinalg.eig(symMatrix)
get_Eigen = theano.function([symMatrix], [symEigenvalues, eigenvectors])
#############################################
with logs.disable_user_input():
for epoch in iterepochs:
validation_error = None
epoch_start_time = time.time()
on_epoch_start_update(epoch)
if shuffle_data:
data = shuffle(*as_tuple(input_train, target_train))
input_train, target_train = data[:-1], data[-1]
try:
train_error = train_epoch(input_train, target_train)
print epoch
name=str(self)
if(name.split('(')[0]=='Hessian'):
H=self.variables.hessian.get_value()
ev,_=get_Eigen(H)
print "positive EV ",np.sum(ev>0)
print "Just zero EV", np.sum(ev==0)
print "Zero EV ", np.sum(ev==0)+np.sum((ev < 0) & (ev > (np.min(ev)/2.0)))
print "Neg EV ", np.sum(ev<0)
print "Max EV ",np.max(ev)
print "Min EV ",np.min(ev)
s=str(self.itr)+'.npy'
np.save(s,ev)
if can_compute_validation_error:
validation_error = self.prediction_error(input_test,
target_test)
training_errors.append(train_error)
validation_errors.append(validation_error)
epoch_finish_time = time.time()
training.epoch_time = epoch_finish_time - epoch_start_time
if epoch % training.show_epoch == 0 or is_first_iteration:
summary.show_last()
last_epoch_shown = epoch
if epoch_end_signal is not None:
epoch_end_signal(self)
is_first_iteration = False
except StopTraining as err:
# TODO: This notification breaks table view in terminal.
# I need to show it in a different way.
logs.message("TRAIN", "Epoch #{} stopped. {}"
"".format(epoch, str(err)))
break
if epoch != last_epoch_shown:
summary.show_last()
if train_end_signal is not None:
train_end_signal(self)
summary.finish()
logs.newline()
def train(self, input_train, target_train=None, input_test=None,
target_test=None, epochs=100, epsilon=None,
summary_type='table'):
""" Method train neural network.
Parameters
----------
input_train : array-like
target_train : array-like or Npne
input_test : array-like or None
target_test : array-like or None
epochs : int
Defaults to `100`.
epsilon : float or None
Defaults to ``None``.
"""
show_epoch = self.show_epoch
logs = self.logs
training = self.training = AttributeKeyDict()
if epochs <= 0:
raise ValueError("Number of epochs needs to be greater than 0.")
if epsilon is not None and epochs <= 2:
raise ValueError("Network should train at teast 3 epochs before "
"check the difference between errors")
if summary_type == 'table':
logging_info_about_the_data(self, input_train, input_test)
logging_info_about_training(self, epochs, epsilon)
logs.newline()
summary = SummaryTable(
table_builder=table.TableBuilder(
table.Column(name="Epoch #"),
table.NumberColumn(name="Train err"),
table.NumberColumn(name="Valid err"),
table.TimeColumn(name="Time", width=10),
stdout=logs.write
),
network=self,
delay_limit=1.,
delay_history_length=10,
)
elif summary_type == 'inline':
summary = InlineSummary(network=self)
else:
raise ValueError("`{}` is unknown summary type"
"".format(summary_type))
iterepochs = create_training_epochs_iterator(self, epochs, epsilon)
show_epoch = parse_show_epoch_property(self, epochs, epsilon)
training.show_epoch = show_epoch
# Storring attributes and methods in local variables we prevent
# useless __getattr__ call a lot of times in each loop.
# This variables speed up loop in case on huge amount of
# iterations.
training_errors = self.errors
validation_errors = self.validation_errors
shuffle_data = self.shuffle_data
train_epoch = self.train_epoch
epoch_end_signal = self.epoch_end_signal
train_end_signal = self.train_end_signal
on_epoch_start_update = self.on_epoch_start_update
is_first_iteration = True
can_compute_validation_error = (input_test is not None)
last_epoch_shown = 0
with logs.disable_user_input():
for epoch in iterepochs:
validation_error = np.nan
epoch_start_time = time.time()
on_epoch_start_update(epoch)
if shuffle_data:
input_train, target_train = shuffle(input_train,
target_train)
try:
train_error = train_epoch(input_train, target_train)
if can_compute_validation_error:
validation_error = self.prediction_error(input_test,
target_test)
training_errors.append(train_error)
validation_errors.append(validation_error)
epoch_finish_time = time.time()
training.epoch_time = epoch_finish_time - epoch_start_time
if epoch % training.show_epoch == 0 or is_first_iteration:
summary.show_last()
last_epoch_shown = epoch
if epoch_end_signal is not None:
epoch_end_signal(self)
is_first_iteration = False
except StopNetworkTraining as err:
# TODO: This notification breaks table view in terminal.
# I need to show it in a different way.
logs.message("TRAIN", "Epoch #{} stopped. {}"
"".format(epoch, str(err)))
break
if epoch != last_epoch_shown:
summary.show_last()
if train_end_signal is not None:
train_end_signal(self)
summary.finish()
logs.newline()
logs.message("TRAIN", "Trainig finished")
def train(self, input_train, target_train=None, input_test=None,
target_test=None, epochs=100, epsilon=None,
summary_type='table'):
"""
Method train neural network.
Parameters
----------
input_train : array-like
target_train : array-like or None
input_test : array-like or None
target_test : array-like or None
epochs : int
Defaults to `100`.
epsilon : float or None
Defaults to ``None``.
"""
show_epoch = self.show_epoch
logs = self.logs
training = self.training = AttributeKeyDict()
if epochs <= 0:
raise ValueError("Number of epochs needs to be greater than 0.")
if epsilon is not None and epochs <= 2:
raise ValueError("Network should train at teast 3 epochs before "
"check the difference between errors")
if summary_type == 'table':
logging_info_about_the_data(self, input_train, input_test)
logging_info_about_training(self, epochs, epsilon)
logs.newline()
summary = SummaryTable(
table_builder=table.TableBuilder(
table.Column(name="Epoch #"),
table.NumberColumn(name="Train err"),
table.NumberColumn(name="Valid err"),
table.TimeColumn(name="Time", width=10),
stdout=logs.write
),
network=self,
delay_limit=1.,
delay_history_length=10,
)
elif summary_type == 'inline':
summary = InlineSummary(network=self)
else:
raise ValueError("`{}` is unknown summary type"
"".format(summary_type))
iterepochs = create_training_epochs_iterator(self, epochs, epsilon)
show_epoch = parse_show_epoch_property(self, epochs, epsilon)
training.show_epoch = show_epoch
# Storring attributes and methods in local variables we prevent
# useless __getattr__ call a lot of times in each loop.
# This variables speed up loop in case on huge amount of
# iterations.
training_errors = self.errors
validation_errors = self.validation_errors
shuffle_data = self.shuffle_data
train_epoch = self.train_epoch
epoch_end_signal = self.epoch_end_signal
train_end_signal = self.train_end_signal
on_epoch_start_update = self.on_epoch_start_update
is_first_iteration = True
can_compute_validation_error = (input_test is not None)
last_epoch_shown = 0
symMatrix = tt.dmatrix("symMatrix")
symEigenvalues, eigenvectors = tt.nlinalg.eig(symMatrix)
get_Eigen = theano.function([symMatrix], [symEigenvalues, eigenvectors] )
epsilon = []
alpha = []
alpha0 = []
with logs.disable_user_input():
for epoch in iterepochs:
validation_error = None
epoch_start_time = time.time()
on_epoch_start_update(epoch)
if shuffle_data:
input_train, target_train = shuffle(input_train,
target_train)
try:
train_error = train_epoch(input_train, target_train)
H = self.variables.hessian.get_value()
ev, _ = get_Eigen(H)
if can_compute_validation_error:
validation_error = self.prediction_error(input_test,
target_test)
epsilon.append(train_error)
alpha.append(numpy.sum(ev < 0))
alpha0.append(numpy.sum(ev == 0))
training_errors.append(train_error)
validation_errors.append(validation_error)
epoch_finish_time = time.time()
training.epoch_time = epoch_finish_time - epoch_start_time
if epoch % training.show_epoch == 0 or is_first_iteration:
summary.show_last()
last_epoch_shown = epoch
if epoch_end_signal is not None:
epoch_end_signal(self)
is_first_iteration = False
except StopNetworkTraining as err:
# TODO: This notification breaks table view in terminal.
# I need to show it in a different way.
logs.message("TRAIN", "Epoch #{} stopped. {}"
"".format(epoch, str(err)))
break
if epoch != last_epoch_shown:
summary.show_last()
if train_end_signal is not None:
train_end_signal(self)
summary.finish()
logs.newline()
plt.plot(alpha,epsilon,'r')
plt.plot(alpha0,epsilon,'b')
plt.xlabel('alpha')
plt.ylabel('epsilon')
# want to collect the output of stdout in a variable
capture = StringIO()
capture.truncate(0)
save_stdout = sys.stdout
sys.stdout = capture
print self.connection
sys.stdout=save_stdout
s = capture.getvalue()
s=s.split('\n')[0:][0]
str = self.class_name()
str1 = s+'---'+str+'-alpha-epsilon'+'.eps'
plt.savefig(str1,format='eps',dpi=1000)
plt.plot(iterepochs,epsilon)
plt.xlabel('iterepochs')
plt.ylabel('epsilon')
str2=s+'---'+str+'-epsilon-iterepochs'+'.eps'
plt.savefig(str2,format='eps',dpi=1000)
