In [2]:

    

from pylearn2.utils.serial import load as load_model
from pylearn2.gui.get_weights_report import get_weights_report
import numpy as np
%matplotlib inline
import matplotlib.pyplot as plt
import os.path
import io
from IPython.display import display, Image


    

    




Using gpu device 0: Tesla K20c

In [181]:

    

model = load_model(os.path.expandvars('${DATA_DIR}/plankton/models/alexnet_based_-_the_return_experiment_recent.pkl'))


    

In [130]:

    

print('## Model structure summary\n')
print(model)
params = model.get_params() 
n_params = {p.name : p.get_value().size for p in params}
total_params = sum(n_params.values())
print('\n## Number of parameters\n')
print('  ' + '\n  '.join(['{0} : {1} ({2:.1f}%)'.format(k, v, 100.*v/total_params) 
                          for k, v in sorted(n_params.items(), key=lambda x: x[0])]))
print('\nTotal : {0}'.format(total_params))


    

    




## Model structure summary

h1
	Input space: Conv2DSpace(shape=(48, 48), num_channels=1, axes=('b', 0, 1, 'c'), dtype=float32)
	Total input dimension: 2304
h2
	Input space: Conv2DSpace(shape=(21, 21), num_channels=48, axes=('b', 'c', 0, 1), dtype=float32)
	Total input dimension: 21168
h3
	Input space: Conv2DSpace(shape=(9, 9), num_channels=96, axes=('b', 'c', 0, 1), dtype=float32)
	Total input dimension: 7776
h4
	Input space: Conv2DSpace(shape=(11, 11), num_channels=128, axes=('b', 'c', 0, 1), dtype=float32)
	Total input dimension: 15488
h5
	Input space: Conv2DSpace(shape=(13, 13), num_channels=128, axes=('b', 'c', 0, 1), dtype=float32)
	Total input dimension: 21632
h6
	Input space: Conv2DSpace(shape=(8, 8), num_channels=128, axes=('b', 'c', 0, 1), dtype=float32)
	Total input dimension: 8192
y
	Input space: VectorSpace(dim=1024, dtype=float32)
	Total input dimension: 1024

## Number of parameters

  h1_W : 2352 (0.0%)
  h1_b : 84672 (0.9%)
  h2_W : 115200 (1.3%)
  h2_b : 27744 (0.3%)
  h3_W : 110592 (1.2%)
  h3_b : 15488 (0.2%)
  h4_W : 147456 (1.6%)
  h4_b : 21632 (0.2%)
  h5_W : 147456 (1.6%)
  h5_b : 28800 (0.3%)
  h6_W : 8388608 (91.0%)
  h6_b : 1024 (0.0%)
  softmax_W : 123904 (1.3%)
  softmax_b : 121 (0.0%)

Total : 9215049

In [187]:

    

tr = np.array(model.monitor.channels['valid_y_y_1_nll'].time_record) / 3600.
fig = plt.figure(figsize=(12,8))
ax1 = fig.add_subplot(111)
ax1.plot(model.monitor.channels['valid_y_y_1_nll'].val_record)
ax1.plot(model.monitor.channels['train_y_y_1_nll'].val_record)
ax1.set_xlabel('Epochs')
ax1.legend(['Valid', 'Train'])
ax1.set_ylabel('NLL')
ax1.set_ylim(0., 5.)
ax1.grid(True)
ax2 = ax1.twiny()
ax2.set_xticks(np.arange(0,tr.shape[0],20))
ax2.set_xticklabels(['{0:.2f}'.format(t) for t in tr[::20]])
ax2.set_xlabel('Hours')


    

    
Out[187]:





<matplotlib.text.Text at 0x7f2bc6d82a90>






    

In [186]:

    

print(model.yaml_src)


    

    




!obj:pylearn2.models.mlp.MLP {batch_size: 128, input_space: !obj:pylearn2.space.Conv2DSpace {
    shape: [48, 48], num_channels: 1, axes: ['b', 0, 1, 'c']}, layers: [!obj:pylearn2.models.mlp.ConvRectifiedLinear {
      layer_name: h1, output_channels: 48, irange: .1, init_bias: 0, kernel_shape: [
        7, 7], pool_shape: [3, 3], pool_stride: [2, 2], max_kernel_norm: 1.}, !obj:pylearn2.models.mlp.ConvRectifiedLinear {
      layer_name: h2, output_channels: 96, irange: .025, init_bias: 1, kernel_shape: [
        5, 5], pool_shape: [2, 2], pool_stride: [2, 2], max_kernel_norm: 1.}, !obj:pylearn2.models.mlp.ConvRectifiedLinear {
      layer_name: h3, output_channels: 128, irange: .025, init_bias: 0, kernel_shape: [
        3, 3], border_mode: full, pool_shape: [1, 1], pool_stride: [1, 1], max_kernel_norm: 2.},
    !obj:pylearn2.models.mlp.ConvRectifiedLinear {layer_name: h4, output_channels: 128,
      irange: .025, init_bias: 0, kernel_shape: [3, 3], border_mode: full, pool_shape: [
        1, 1], pool_stride: [1, 1], max_kernel_norm: 2.}, !obj:pylearn2.models.mlp.ConvRectifiedLinear {
      layer_name: 'h5', output_channels: 128, irange: .025, init_bias: 1, kernel_shape: [
        3, 3], border_mode: full, pool_shape: [2, 2], pool_stride: [2, 2], max_kernel_norm: 2.},
    !obj:pylearn2.models.mlp.RectifiedLinear {dim: 1024, max_col_norm: 1., layer_name: h6,
      istdev: .005, W_lr_scale: .1, b_lr_scale: .1}, !obj:pylearn2.models.mlp.FlattenerLayer {
      raw_layer: !obj:pylearn2.models.mlp.CompositeLayer {layer_name: 'y', layers: [
          !obj:pylearn2.models.mlp.Softmax {n_classes: 121, layer_name: y_1, istdev: .01,
            b_lr_scale: 2.}, !obj:pylearn2.models.mlp.Softmax {n_classes: 38, layer_name: y_2,
            istdev: .01, b_lr_scale: 2.}, !obj:pylearn2.models.mlp.Softmax {n_classes: 16,
            layer_name: y_3, istdev: .01, b_lr_scale: 2.}, !obj:pylearn2.models.mlp.Softmax {
            n_classes: 7, layer_name: y_4, istdev: .01, b_lr_scale: 2.}, !obj:pylearn2.models.mlp.Softmax {
            n_classes: 4, layer_name: y_5, istdev: .01, b_lr_scale: 2.}, !obj:pylearn2.models.mlp.Softmax {
            n_classes: 2, layer_name: y_6, istdev: .01, b_lr_scale: 2.}]}}]}

In [183]:

    

pv = get_weights_report(model=model)
img = pv.get_img()
img = img.resize((4*img.size[0], 4*img.size[1]))
img_data = io.BytesIO()
img.save(img_data, format='png')
display(Image(data=img_data.getvalue(), format='png'))


    

    




smallest enc weight magnitude: 0.000117831375974
mean enc weight magnitude: 0.0869850218296
max enc weight magnitude: 0.440578043461






    

In [173]:

    

plt.plot(model.monitor.channels['learning_rate'].val_record)


    

    
Out[173]:





[<matplotlib.lines.Line2D at 0x7f2bc9397a90>]






    

In [174]:

    

h1_W_up_norms = np.array([float(v) for v in model.monitor.channels['mean_update_h1_W_kernel_norm_mean'].val_record])
h1_W_norms = np.array([float(v) for v in model.monitor.channels['valid_h1_kernel_norms_mean'].val_record])
plt.plot(h1_W_norms / h1_W_up_norms)
plt.ylim(0,1000)
plt.show()
plt.plot(model.monitor.channels['valid_h1_kernel_norms_mean'].val_record)
plt.plot(model.monitor.channels['valid_h1_kernel_norms_max'].val_record)


    

    













    
Out[174]:





[<matplotlib.lines.Line2D at 0x7f2bc7c31590>]






    

In [175]:

    

h2_W_up_norms = np.array([float(v) for v in model.monitor.channels['mean_update_h2_W_kernel_norm_mean'].val_record])
h2_W_norms = np.array([float(v) for v in model.monitor.channels['valid_h2_kernel_norms_mean'].val_record])
plt.plot(h2_W_norms / h2_W_up_norms)
plt.show()
plt.plot(model.monitor.channels['valid_h2_kernel_norms_mean'].val_record)
plt.plot(model.monitor.channels['valid_h2_kernel_norms_max'].val_record)


    

    













    
Out[175]:





[<matplotlib.lines.Line2D at 0x7f2bc8dd9ad0>]






    

In [176]:

    

h3_W_up_norms = np.array([float(v) for v in model.monitor.channels['mean_update_h3_W_kernel_norm_mean'].val_record])
h3_W_norms = np.array([float(v) for v in model.monitor.channels['valid_h3_kernel_norms_mean'].val_record])
plt.plot(h3_W_norms / h3_W_up_norms)
plt.show()
plt.plot(model.monitor.channels['valid_h3_kernel_norms_mean'].val_record)
plt.plot(model.monitor.channels['valid_h3_kernel_norms_max'].val_record)


    

    













    
Out[176]:





[<matplotlib.lines.Line2D at 0x7f2bc7b3cd90>]






    

In [177]:

    

h4_W_up_norms = np.array([float(v) for v in model.monitor.channels['mean_update_h4_W_kernel_norm_mean'].val_record])
h4_W_norms = np.array([float(v) for v in model.monitor.channels['valid_h4_kernel_norms_mean'].val_record])
plt.plot(h4_W_norms / h4_W_up_norms)
plt.show()
plt.plot(model.monitor.channels['valid_h4_kernel_norms_mean'].val_record)
plt.plot(model.monitor.channels['valid_h4_kernel_norms_max'].val_record)


    

    













    
Out[177]:





[<matplotlib.lines.Line2D at 0x7f2bc79ac050>]






    

In [178]:

    

h5_W_up_norms = np.array([float(v) for v in model.monitor.channels['mean_update_h5_W_kernel_norm_mean'].val_record])
h5_W_norms = np.array([float(v) for v in model.monitor.channels['valid_h5_kernel_norms_mean'].val_record])
plt.plot(h5_W_norms / h5_W_up_norms)
plt.show()
plt.plot(model.monitor.channels['valid_h5_kernel_norms_mean'].val_record)
plt.plot(model.monitor.channels['valid_h5_kernel_norms_max'].val_record)


    

    













    
Out[178]:





[<matplotlib.lines.Line2D at 0x7f2bc789ec10>]






    

In [179]:

    

h6_W_up_norms = np.array([float(v) for v in model.monitor.channels['mean_update_h6_W_col_norm_mean'].val_record])
h6_W_norms = np.array([float(v) for v in model.monitor.channels['valid_h6_col_norms_mean'].val_record])
plt.plot(h6_W_norms / h6_W_up_norms)
plt.show()
plt.plot(model.monitor.channels['valid_h6_col_norms_mean'].val_record)
plt.plot(model.monitor.channels['valid_h6_col_norms_max'].val_record)


    

    













    
Out[179]:





[<matplotlib.lines.Line2D at 0x7f2bc76fdc10>]






    

In [180]:

    

y_W_up_norms = np.array([float(v) for v in model.monitor.channels['mean_update_softmax_W_col_norm_mean'].val_record])
y_W_norms = np.array([float(v) for v in model.monitor.channels['valid_y_y_1_col_norms_mean'].val_record])
plt.plot(y_W_norms / y_W_up_norms)
plt.show()
plt.plot(model.monitor.channels['valid_y_y_1_col_norms_mean'].val_record)
plt.plot(model.monitor.channels['valid_y_y_1_col_norms_max'].val_record)


    

    













    
Out[180]:





[<matplotlib.lines.Line2D at 0x7f2bc756d050>]






    

In [ ]: