def load_net(filename):
matlabdict = {}
scipy.io.loadmat(filename, matlabdict)
net = nnet
num_layers = matlabdict['num_layers'][0]
layers = [nnet.layer(matlabdict['layer_node_count_input_1'][0])]
for i in range(num_layers):
l = matlabdict['layer_node_count_output_' + str(i + 1)][0]
a = matlabdict['layer_activation_' + str(i + 1)]
layers.append(nnet.layer(l, a))
net = nnet.net(layers)
for i in range(num_layers):
net.layer[i].weights = matlabdict['layer_weights_' + str(i + 1)]
dropout = matlabdict['layer_dropout_' + str(i + 1)][0]
if (dropout == 'None'):
#print('Layer ' + str(i) + ': Dropout is none')
net.layer[i].dropout = None
else:
#print('Layer ' + str(i) + ': Dropout: ' + str(dropout))
net.layer[i].dropout = float(dropout)
data = {}
data['net'] = net
data['sample_mean'] = matlabdict['sample_mean']
data['sample_std'] = matlabdict['sample_std']
data['patchsize'] = matlabdict['patchsize']
data['test_rate'] = matlabdict['test_rate']
return data
def init(self,state_size,num_actions,p):
layers = [];
self.state_size = state_size
self.num_actions = num_actions
self.incorrect_target = p['incorrect_target']
self.correct_target = p['correct_target']
layers.append(nnet.layer(self.state_size))
if(p.has_key('num_hidden') and p['num_hidden'] is not None):
layers.append(nnet.layer(p['num_hidden'],p['activation_function'],
initialization_scheme=p['initialization_scheme'],
initialization_constant=p['initialization_constant'],
dropout=p['dropout'],use_float32=p['use_float32'],
momentum=p['momentum'],maxnorm=p['maxnorm'],step_size=p['learning_rate']))
layers.append(nnet.layer(num_actions,p['activation_function_final'],
initialization_scheme=p['initialization_scheme_final'],
initialization_constant=p['initialization_constant_final'],
use_float32=p['use_float32'],
momentum=p['momentum'],step_size=p['learning_rate']))
self.net = nnet.net(layers)
self.do_neuron_clustering=False #by default
if(p.has_key('cluster_func') and p['cluster_func'] is not None):
self.net.layer[0].centroids = np.asarray(((np.random.random((self.net.layer[0].weights.shape)) - 0.5) * 2.5),np.float32)
#make the centroid bias input match the bias data of 1.0
self.net.layer[0].centroids[:,-1] = 1.0
self.net.layer[0].select_func = csf.select_names[p['cluster_func']]
print('cluster_func: ' + str(csf.select_names[p['cluster_func']]))
self.net.layer[0].centroid_speed = p['cluster_speed']
self.net.layer[0].num_selected = p['clusters_selected']
self.do_neuron_clustering=True #set a flag to indicate neuron clustering
if(p.has_key('do_cosinedistance') and p['do_cosinedistance']):
self.net.layer[0].do_cosinedistance = True
print('cosine set to true')
def init(self, mins, maxs, num_actions, p):
layers = []
self.state_size = len(list(mins))
self.num_actions = num_actions
self.mins = np.array(mins)
self.maxs = np.array(maxs)
self.incorrect_target = p['incorrect_target']
#print(str(self.state_size) + " " + str(self.num_actions))
self.correct_target = p['correct_target']
layers.append(nnet.layer(self.state_size + self.num_actions))
layers.append(
nnet.layer(p['num_hidden'],
p['activation_function'],
initialization_scheme=p['initialization_scheme'],
initialization_constant=p['initialization_constant'],
dropout=p['dropout'],
use_float32=p['use_float32'],
momentum=p['momentum'],
maxnorm=p['maxnorm'],
step_size=p['learning_rate']))
layers.append(
nnet.layer(
1,
initialization_scheme=p['initialization_scheme_final'],
initialization_constant=p['initialization_constant_final'],
use_float32=p['use_float32'],
momentum=p['momentum'],
step_size=p['learning_rate']))
self.net = nnet.net(layers)
def load_net(filename):
matlabdict = {}
scipy.io.loadmat(filename, matlabdict)
net = nnet
num_layers = matlabdict["num_layers"][0]
layers = [nnet.layer(matlabdict["layer_node_count_input_1"][0])]
for i in range(num_layers):
l = matlabdict["layer_node_count_output_" + str(i + 1)][0]
a = matlabdict["layer_activation_" + str(i + 1)]
layers.append(nnet.layer(l, a))
net = nnet.net(layers)
for i in range(num_layers):
net.layer[i].weights = matlabdict["layer_weights_" + str(i + 1)]
dropout = matlabdict["layer_dropout_" + str(i + 1)][0]
if dropout == "None":
# print('Layer ' + str(i) + ': Dropout is none')
net.layer[i].dropout = None
else:
# print('Layer ' + str(i) + ': Dropout: ' + str(dropout))
net.layer[i].dropout = float(dropout)
data = {}
data["net"] = net
data["sample_mean"] = matlabdict["sample_mean"]
data["sample_std"] = matlabdict["sample_std"]
data["patchsize"] = matlabdict["patchsize"]
data["test_rate"] = matlabdict["test_rate"]
return data
def init(self, state_size, num_actions, p):
layers = []
self.state_size = state_size
self.num_actions = num_actions
self.incorrect_target = p['incorrect_target']
self.correct_target = p['correct_target']
layers.append(nnet.layer(self.state_size))
if (p.has_key('num_hidden') and p['num_hidden'] is not None):
layers.append(
nnet.layer(
p['num_hidden'],
p['activation_function'],
initialization_scheme=p['initialization_scheme'],
initialization_constant=p['initialization_constant'],
dropout=p['dropout'],
use_float32=p['use_float32'],
momentum=p['momentum'],
maxnorm=p['maxnorm'],
step_size=p['learning_rate']))
layers.append(
nnet.layer(
num_actions,
p['activation_function_final'],
initialization_scheme=p['initialization_scheme_final'],
initialization_constant=p['initialization_constant_final'],
use_float32=p['use_float32'],
momentum=p['momentum'],
step_size=p['learning_rate']))
self.net = nnet.net(layers)
self.do_neuron_clustering = False #by default
if (p.has_key('cluster_func') and p['cluster_func'] is not None):
self.net.layer[0].centroids = np.asarray(((np.random.random(
(self.net.layer[0].weights.shape)) - 0.5) * 2.5), np.float32)
#make the centroid bias input match the bias data of 1.0
self.net.layer[0].centroids[:, -1] = 1.0
self.net.layer[0].select_func = csf.select_names[p['cluster_func']]
print('cluster_func: ' + str(csf.select_names[p['cluster_func']]))
self.net.layer[0].centroid_speed = p['cluster_speed']
self.net.layer[0].num_selected = p['clusters_selected']
self.do_neuron_clustering = True #set a flag to indicate neuron clustering
if (p.has_key('do_cosinedistance') and p['do_cosinedistance']):
self.net.layer[0].do_cosinedistance = True
print('cosine set to true')
def init(self,mins,maxs,num_actions,p):
layers = [];
self.state_size = len(list(mins))
self.num_actions = num_actions
self.mins = np.array(mins)
self.maxs = np.array(maxs)
self.incorrect_target = p['incorrect_target']
#print(str(self.state_size) + " " + str(self.num_actions))
self.correct_target = p['correct_target']
layers.append(nnet.layer(self.state_size + self.num_actions))
layers.append(nnet.layer(p['num_hidden'],p['activation_function'],
initialization_scheme=p['initialization_scheme'],
initialization_constant=p['initialization_constant'],
dropout=p['dropout'],use_float32=p['use_float32'],
momentum=p['momentum'],maxnorm=p['maxnorm'],step_size=p['learning_rate']))
layers.append(nnet.layer(1,
initialization_scheme=p['initialization_scheme_final'],
initialization_constant=p['initialization_constant_final'],
use_float32=p['use_float32'],
momentum=p['momentum'],step_size=p['learning_rate']))
self.net = nnet.net(layers)
def init(self,mins,maxs,num_actions,p):
layers = [];
self.state_size = len(list(mins))
self.num_actions = num_actions
self.mins = np.array(mins)
self.maxs = np.array(maxs)
self.incorrect_target = p['incorrect_target']
print(str(self.state_size) + " " + str(self.num_actions))
self.correct_target = p['correct_target']
layers.append(nnet.layer(self.state_size + self.num_actions))
layers.append(nnet.layer(p['num_hidden'],p['activation_function'],
initialization_scheme=p['initialization_scheme'],
initialization_constant=p['initialization_constant'],
dropout=p['dropout'],use_float32=p['use_float32'],
momentum=p['momentum'],maxnorm=p['maxnorm'],step_size=p['learning_rate']))
layers.append(nnet.layer(1,
initialization_scheme=p['initialization_scheme_final'],
initialization_constant=p['initialization_constant_final'],
use_float32=p['use_float32'],
momentum=p['momentum'],step_size=p['learning_rate']))
self.net = nnet.net(layers)
self.do_neuron_clustering=False #by default
if(p.has_key('cluster_func') and p['cluster_func'] is not None):
#TODO: Make sure the centroids cover the input space appropriately
self.net.layer[0].centroids = np.asarray(((np.random.random((self.net.layer[0].weights.shape)) - 0.5) * 2.25),np.float32)
#make the centroid bias input match the bias data of 1.0
self.net.layer[0].centroids[:,-1] = 1.0
#print(str(self.net.layer[0].centroids.shape))
#print(str(self.net.layer[0].centroids))
self.net.layer[0].select_func = csf.select_names[p['cluster_func']]
#print('cluster_func: ' + str(csf.select_names[p['cluster_func']]))
self.net.layer[0].centroid_speed = p['cluster_speed']
self.net.layer[0].num_selected = p['clusters_selected']
self.do_neuron_clustering=True #set a flag to log neurons that were used for clustering
if(p.has_key('do_cosinedistance') and p['do_cosinedistance']):
self.net.layer[0].do_cosinedistance = True
print('cosine set to true')
sample_data[0:2,i*examples_per_class:(i+1)*examples_per_class] = c;
class_data[i,i*examples_per_class:(i+1)*examples_per_class] = 1.0;
#build a pallete
pal = cm.rainbow(np.linspace(0,1,num_classes));
pal = pal[0:num_classes,0:3]
plt = image_plotter.image_plotter();
plt.initImg(img_width,img_height);
plt.setAxis(vx_axis[0],vx_axis[1],vy_axis[0],vy_axis[1])
c=pal[np.argmax(class_data,0),:]
if(not dump_to_file):
plt.show()
net = nnet.net(layers,learning_rate)
epoch = 1;
while(epoch < p['total_epochs']):
net.input = sample_data;
net.feed_forward();
net.error = net.output - class_data
neterror = net.error
net_classes = net.output
percent_miss = 1.0 - sum(np.equal(np.argmax(net_classes,0),np.argmax(class_data,0)))/float(num_classes*examples_per_class)
if epoch < p['training_epochs']:
net.back_propagate()
net.update_weights();
if epoch == p['training_epochs']:
net.train = False;
from nnet_toolkit import nnet
#layers = [nnet_toolkit.layer(2),nnet_toolkit.layer(128,'squash'),nnet_toolkit.layer(1,'squash')];
layers = [
nnet.layer(400),
nnet.layer(128, 'sigmoid'),
nnet.layer(3, 'sigmoid')
]
#training_data = np.array([[0,0,1,1],[0,1,0,1]]);
#training_out = np.array([0,1,1,0]);
training_data = np.random.random((400, 500))
training_out = np.random.random((3, 500))
#net = nnet.net_cuda(layers,step_size=.1);
net = nnet.net(layers, step_size=.1)
net.input = training_data
t = time.time()
for i in range(100000):
net.feed_forward()
net.error = net.output - training_out
net.back_propagate()
net.update_weights()
if (i % 1000 == 0):
#print("iteration: " + str(i) + " " + str(net.error));
t_delta = time.time() - t
print("iteration: " + str(i) + " " + str(t_delta))
t = time.time()
def init(self, state_size, num_actions, p):
layers = []
self.do_trig_transform = False
if (p.get('do_trig_transform', True)):
self.do_trig_transform = True
self.state_size = state_size
self.num_actions = num_actions
self.action_dupe_count = p.get('action_dupe_count', 1)
self.do_recurrence = False
if (p['do_recurrence']):
input_size = self.state_size + self.num_actions * self.action_dupe_count + p[
'num_hidden']
self.do_recurrence = True
else:
input_size = self.state_size + self.num_actions * self.action_dupe_count
self.learning_rate = p['learning_rate']
print("state size : " + str(self.state_size))
print("num actions : " + str(self.num_actions))
print("action dupe count : " + str(self.action_dupe_count))
print("num hidden : " + str(p['num_hidden']))
print("input size : " + str(input_size))
self.incorrect_target = p['incorrect_target']
print(str(self.state_size) + " " + str(self.num_actions))
self.correct_target = p['correct_target']
layers.append(nnet.layer(input_size))
layers.append(
nnet.layer(p['num_hidden'],
p['activation_function'],
initialization_scheme=p['initialization_scheme'],
initialization_constant=p['initialization_constant'],
dropout=p['dropout'],
use_float32=p['use_float32'],
momentum=p['momentum'],
maxnorm=p['maxnorm'],
step_size=p['learning_rate']))
if (p.has_key('num_hidden2') and p['num_hidden2'] is not None):
layers.append(
nnet.layer(
p['num_hidden2'],
p['activation_function2'],
initialization_scheme=p['initialization_scheme2'],
initialization_constant=p['initialization_constant2'],
dropout=p['dropout2'],
use_float32=p['use_float32'],
momentum=p['momentum2'],
maxnorm=p['maxnorm2'],
step_size=p['learning_rate2']))
layers.append(
nnet.layer(
1,
initialization_scheme=p['initialization_scheme_final'],
initialization_constant=p['initialization_constant_final'],
use_float32=p['use_float32'],
momentum=p['momentum'],
step_size=p['learning_rate']))
self.net = nnet.net(layers)
if (p.has_key('cluster_func') and p['cluster_func'] is not None):
print("layer 0 has cluster func")
self.cluster_func = p['cluster_func']
#TODO: Make sure the centroids cover the input space appropriately
self.net.layer[0].centroids = np.asarray(((np.random.random(
(self.net.layer[0].weights.shape)) - 0.5) * 2.25), np.float32)
#make the centroid bias input match the bias data of 1.0
self.net.layer[0].centroids[:, -1] = 1.0
#print(str(self.net.layer[0].centroids.shape))
#print(str(self.net.layer[0].centroids))
self.net.layer[0].select_func = csf.select_names[p['cluster_func']]
#print('cluster_func: ' + str(csf.select_names[p['cluster_func']]))
self.net.layer[0].centroid_speed = p['cluster_speed']
self.net.layer[0].num_selected = p['clusters_selected']
if (p.has_key('do_cosinedistance') and p['do_cosinedistance']):
self.net.layer[0].do_cosinedistance = True
print('cosine set to true')
if (p.has_key('zeta_decay') and p['zeta_decay'] is not None):
self.net.layer[0].zeta_matrix = np.ones(
self.net.layer[0].weights.shape, dtype=np.float32)
self.net.layer[0].zeta = 1.0
self.zeta_decay = p['zeta_decay']
if (p.has_key('cluster_func2') and p['cluster_func2'] is not None):
print("layer 1 has cluster func")
self.cluster_func2 = p['cluster_func2']
#TODO: Make sure the centroids cover the input space appropriately
self.net.layer[1].centroids = np.asarray(((np.random.random(
(self.net.layer[1].weights.shape)) - 0.5) * 2.25), np.float32)
#make the centroid bias input match the bias data of 1.0
self.net.layer[1].centroids[:, -1] = 1.0
#print(str(self.net.layer[0].centroids.shape))
#print(str(self.net.layer[0].centroids))
self.net.layer[1].select_func = csf.select_names[
p['cluster_func2']]
#print('cluster_func: ' + str(csf.select_names[p['cluster_func']]))
self.net.layer[1].centroid_speed = p['cluster_speed2']
self.net.layer[1].num_selected = p['clusters_selected2']
if (p.has_key('do_cosinedistance') and p['do_cosinedistance']):
self.net.layer[1].do_cosinedistance = True
print('cosine set to true')
if (p.has_key('zeta_decay2') and p['zeta_decay2'] is not None):
self.net.layer[1].zeta_matrix = np.ones(
self.net.layer[1].weights.shape, dtype=np.float32)
self.net.layer[1].zeta = 1.0
self.zeta_decay = p['zeta_decay2']
self.do_full_zeta = p.get('do_full_zeta', False)
if (p.has_key('_lambda') and p['_lambda'] is not None):
self._lambda = p['_lambda']
self.gamma = p['gamma']
for l in self.net.layer:
l.eligibility = l.gradient
print("Network Size Check:")
print(" weight 0 size: " + str(self.net.layer[0].weights.shape))
if (len(self.net.layer) > 1):
print(" weight 1 size: " + str(self.net.layer[1].weights.shape))
if (len(self.net.layer) > 2):
print(" weight 2 size: " + str(self.net.layer[2].weights.shape))
if (len(self.net.layer) > 3):
print(" weight 3 size: " + str(self.net.layer[3].weights.shape))
def init(self, state_size, num_actions, p):
layers = []
self.state_size = state_size
self.num_actions = num_actions
#self.mins = np.array(mins)
#self.maxs = np.array(maxs)
#self.divs = np.array(divs)
#self.size = self.maxs - self.mins
#self.size = self.size + self.divs
#self.size = self.size/self.divs
#self.arr_mins = (np.zeros(self.size.shape)).astype(np.int64)
#self.arr_maxs = (self.size - np.ones(self.size.shape)).astype(np.int64)
self.incorrect_target = p['incorrect_target']
self.correct_target = p['correct_target']
layers.append(nnet.layer(self.state_size + self.num_actions))
if (p.has_key('num_hidden') and p['num_hidden'] is not None):
layers.append(
nnet.layer(
p['num_hidden'],
p['activation_function'],
initialization_scheme=p['initialization_scheme'],
initialization_constant=p['initialization_constant'],
dropout=p.get('dropout', None),
use_float32=p['use_float32'],
momentum=p['momentum'],
maxnorm=p.get('maxnorm', None),
step_size=p['learning_rate'],
rms_prop_rate=p.get('rms_prop_rate', None)))
layers.append(
nnet.layer(
1,
p['activation_function_final'],
initialization_scheme=p['initialization_scheme_final'],
initialization_constant=p['initialization_constant_final'],
use_float32=p['use_float32'],
momentum=p['momentum'],
step_size=p['learning_rate'],
rms_prop_rate=p.get('rms_prop_rate', None)))
self.net = nnet.net(layers)
self.do_neuron_clustering = False #by default
if (p.has_key('cluster_func') and p['cluster_func'] is not None):
self.cluster_func = p['cluster_func']
self.net.layer[0].centroids = np.asarray(((np.random.random(
(self.net.layer[0].weights.shape)) - 0.5) * 2.5), np.float32)
#make the centroid bias input match the bias data of 1.0
self.net.layer[0].centroids[:, -1] = 1.0
#print(str(self.net.layer[0].centroids.shape))
#print(str(self.net.layer[0].centroids))
self.net.layer[0].select_func = csf.select_names[p['cluster_func']]
print('cluster_func: ' + str(csf.select_names[p['cluster_func']]))
self.net.layer[0].centroid_speed = p.get('cluster_speed', 1.0)
self.net.layer[0].num_selected = p['clusters_selected']
self.do_neuron_clustering = True #set a flag to indicate neuron clustering
if (p.has_key('do_cosinedistance') and p['do_cosinedistance']):
self.net.layer[0].do_cosinedistance = True
print('cosine set to true')
#decay for balancing learning and moving centroids
if (p.has_key('zeta_decay') and p['zeta_decay'] is not None):
self.net.layer[0].zeta_matrix = np.ones(
self.net.layer[0].weights.shape, dtype=np.float32)
self.net.layer[0].zeta = 1.0
self.zeta_decay = p['zeta_decay']
self.max_update = 0.0
self.grad_clip = p.get('grad_clip', None)
if (p.has_key('_lambda') and p['_lambda'] is not None):
self._lambda = p['_lambda']
self.gamma = p['gamma']
for l in self.net.layer:
l.eligibility = l.gradient
if(p.has_key('num_hidden3')):
layers.append(nnet.layer(p['num_hidden3'],p['activation_function3'],nodes_per_group=nodes_per_group3,
initialization_scheme=p['initialization_scheme3'],
initialization_constant=p['initialization_constant3'],
dropout=p['dropout3'],sparse_penalty=p['sparse_penalty3'],
sparse_target=p['sparse_target3'],use_float32=p['use_float32'],
momentum=p['momentum3'],maxnorm=p['maxnorm3'],step_size=p['learning_rate3']))
layers.append(nnet.layer(5,p['activation_function_final'],use_float32=p['use_float32'],
step_size=p['learning_rate_final'],momentum=p['momentum_final']))
np.random.seed(p['random_seed']);
#init net
net = nnet.net(layers)
if(p.has_key('cluster_func') and p['cluster_func'] is not None):
net.layer[0].centroids = np.asarray((((np.random.random((net.layer[0].weights.shape)) - 0.5)*2.0)),np.float32)
net.layer[0].select_func = csf.select_names[p['cluster_func']]
net.layer[0].centroid_speed = p['cluster_speed']
net.layer[0].num_selected = p['clusters_selected']
if(p.has_key('cluster_func2') and p['cluster_func2'] is not None):
net.layer[1].centroids = np.asarray((((np.random.random((net.layer[1].weights.shape)) - 0.5)*2.0)),np.float32)
net.layer[1].select_func = csf.select_names[p['cluster_func2']]
net.layer[1].centroid_speed = p['cluster_speed2']
net.layer[1].num_selected = p['clusters_selected2']
if(p.has_key('cluster_func3') and p['cluster_func3'] is not None):
net.layer[2].centroids = np.asarray((((np.random.random((net.layer[2].weights.shape)) - 0.5)*2.0)),np.float32)
np.random.seed(p['random_seed']);
if(p.has_key('random_variance')):
sample_data1 = sample_data1 + np.random.normal(0,float(p['random_variance']),sample_data1.shape)
sample_data2 = sample_data2 + np.random.normal(0,float(p['random_variance']),sample_data2.shape)
sample_data1 = np.asarray(sample_data1,np.float32)
sample_data2 = np.asarray(sample_data2,np.float32)
sample_data1[sample_data1 > 1.5] = 1.5
sample_data1[sample_data1 < -1.5] = -1.5
sample_data2[sample_data2 > 1.5] = 1.5
sample_data2[sample_data2 < -1.5] = -1.5
print('random_variance... ' + str(float(p['random_variance'])) + ' ' + str(np.max(np.abs(sample_data1))) + ' ' + str(np.max(np.abs(sample_data2))))
#init net
net = nnet.net(layers)
if(p.has_key('cluster_func') and p['cluster_func'] is not None):
# net.layer[0].centroids = np.asarray((((np.random.random((net.layer[0].weights.shape)) - 0.5)*2.0)),np.float32)
net.layer[0].centroids = np.asarray(((np.ones((net.layer[0].weights.shape))*10.0)),np.float32)
net.layer[0].select_func = csf.select_names[p['cluster_func']]
print('cluster_func: ' + str(csf.select_names[p['cluster_func']]))
net.layer[0].centroid_speed = p['cluster_speed']
net.layer[0].num_selected = p['clusters_selected']
if(p.has_key('do_cosinedistance') and p['do_cosinedistance']):
net.layer[0].do_cosinedistance = True
print('cosine set to true')
if(p.has_key('num_hidden2') and p.has_key('cluster_func2') and p['cluster_func2'] is not None):
# net.layer[0].centroids = np.asarray((((np.random.random((net.layer[0].weights.shape)) - 0.5)*2.0)),np.float32)
net.layer[1].centroids = np.asarray(((np.ones((net.layer[1].weights.shape))*10.0)),np.float32)
#SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
#THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import time
import numpy as np;
#from nnet_toolkit import nnet_cuda as nnet
from nnet_toolkit import nnet
layers = [nnet.layer(2),nnet.layer(128,'sigmoid'),nnet.layer(1,'sigmoid')];
#layers = [nnet_toolkit.layer(2),nnet_toolkit.layer(256,'linear_rectifier'),nnet_toolkit.layer(128,'linear_rectifier'),nnet_toolkit.layer(64,'linear_rectifier'),nnet_toolkit.layer(32,'linear_rectifier'),nnet_toolkit.layer(1,'squash')];
training_data = np.array([[0,0,1,1],[0,1,0,1]]);
training_out = np.array([0,1,1,0]);
#net = nnet.net_cuda(layers,step_size=.1);
net = nnet.net(layers,step_size=.1);
net.input = training_data;
t = time.time();
for i in range(100000):
net.feed_forward();
net.error = net.output - training_out;
net.back_propagate();
net.update_weights();
if(i%1000 == 0):
#print("iteration: " + str(i) + " " + str(net.error));
t_delta = time.time() - t;
print("iteration: " + str(i) + " " + str(np.sum(net.error**2)) + ' ' + str(t_delta));
t = time.time();
def init(self,state_size,num_actions,p):
layers = [];
self.do_trig_transform = False
if(p.get('do_trig_transform',True)):
self.do_trig_transform = True
self.state_size = state_size
self.num_actions = num_actions
self.action_dupe_count = p.get('action_dupe_count',1)
self.do_recurrence = False
if(p['do_recurrence']):
input_size = self.state_size + self.num_actions*self.action_dupe_count + p['num_hidden']
self.do_recurrence = True
else:
input_size = self.state_size + self.num_actions*self.action_dupe_count
self.learning_rate = p['learning_rate']
print("state size : " + str(self.state_size))
print("num actions : " + str(self.num_actions))
print("action dupe count : " + str(self.action_dupe_count))
print("num hidden : " + str(p['num_hidden']))
print("input size : " + str(input_size))
self.incorrect_target = p['incorrect_target']
print(str(self.state_size) + " " + str(self.num_actions))
self.correct_target = p['correct_target']
layers.append(nnet.layer(input_size))
layers.append(nnet.layer(p['num_hidden'],p['activation_function'],
initialization_scheme=p['initialization_scheme'],
initialization_constant=p['initialization_constant'],
dropout=p['dropout'],use_float32=p['use_float32'],
momentum=p['momentum'],maxnorm=p['maxnorm'],step_size=p['learning_rate']))
if(p.has_key('num_hidden2') and p['num_hidden2'] is not None):
layers.append(nnet.layer(p['num_hidden2'],p['activation_function2'],
initialization_scheme=p['initialization_scheme2'],
initialization_constant=p['initialization_constant2'],
dropout=p['dropout2'],use_float32=p['use_float32'],
momentum=p['momentum2'],maxnorm=p['maxnorm2'],step_size=p['learning_rate2']))
layers.append(nnet.layer(1,
initialization_scheme=p['initialization_scheme_final'],
initialization_constant=p['initialization_constant_final'],
use_float32=p['use_float32'],
momentum=p['momentum'],step_size=p['learning_rate']))
self.net = nnet.net(layers)
if(p.has_key('cluster_func') and p['cluster_func'] is not None):
print("layer 0 has cluster func")
self.cluster_func = p['cluster_func']
#TODO: Make sure the centroids cover the input space appropriately
self.net.layer[0].centroids = np.asarray(((np.random.random((self.net.layer[0].weights.shape)) - 0.5) * 2.25),np.float32)
#make the centroid bias input match the bias data of 1.0
self.net.layer[0].centroids[:,-1] = 1.0
#print(str(self.net.layer[0].centroids.shape))
#print(str(self.net.layer[0].centroids))
self.net.layer[0].select_func = csf.select_names[p['cluster_func']]
#print('cluster_func: ' + str(csf.select_names[p['cluster_func']]))
self.net.layer[0].centroid_speed = p['cluster_speed']
self.net.layer[0].num_selected = p['clusters_selected']
if(p.has_key('do_cosinedistance') and p['do_cosinedistance']):
self.net.layer[0].do_cosinedistance = True
print('cosine set to true')
if(p.has_key('zeta_decay') and p['zeta_decay'] is not None):
self.net.layer[0].zeta_matrix = np.ones(self.net.layer[0].weights.shape,dtype=np.float32)
self.net.layer[0].zeta = 1.0
self.zeta_decay = p['zeta_decay']
if(p.has_key('cluster_func2') and p['cluster_func2'] is not None):
print("layer 1 has cluster func")
self.cluster_func2 = p['cluster_func2']
#TODO: Make sure the centroids cover the input space appropriately
self.net.layer[1].centroids = np.asarray(((np.random.random((self.net.layer[1].weights.shape)) - 0.5) * 2.25),np.float32)
#make the centroid bias input match the bias data of 1.0
self.net.layer[1].centroids[:,-1] = 1.0
#print(str(self.net.layer[0].centroids.shape))
#print(str(self.net.layer[0].centroids))
self.net.layer[1].select_func = csf.select_names[p['cluster_func2']]
#print('cluster_func: ' + str(csf.select_names[p['cluster_func']]))
self.net.layer[1].centroid_speed = p['cluster_speed2']
self.net.layer[1].num_selected = p['clusters_selected2']
if(p.has_key('do_cosinedistance') and p['do_cosinedistance']):
self.net.layer[1].do_cosinedistance = True
print('cosine set to true')
if(p.has_key('zeta_decay2') and p['zeta_decay2'] is not None):
self.net.layer[1].zeta_matrix = np.ones(self.net.layer[1].weights.shape,dtype=np.float32)
self.net.layer[1].zeta = 1.0
self.zeta_decay = p['zeta_decay2']
self.do_full_zeta = p.get('do_full_zeta',False)
if(p.has_key('_lambda') and p['_lambda'] is not None):
self._lambda = p['_lambda']
self.gamma = p['gamma']
for l in self.net.layer:
l.eligibility = l.gradient
print("Network Size Check:" )
print(" weight 0 size: " + str(self.net.layer[0].weights.shape))
if(len(self.net.layer) > 1):
print(" weight 1 size: " + str(self.net.layer[1].weights.shape))
if(len(self.net.layer) > 2):
print(" weight 2 size: " + str(self.net.layer[2].weights.shape))
if(len(self.net.layer) > 3):
print(" weight 3 size: " + str(self.net.layer[3].weights.shape))
print('class type count: ' + str(class_type))
class_type_test = np.sum(class_list_test, axis=0, dtype=np.float64)
print('class test type count: ' + str(class_type_test))
print('initializing network...')
layers = [nnet.layer(inputsize)]
for i in range(len(hidden_sizes)):
l = hidden_sizes[i]
a = hidden_activations[i]
layers.append(nnet.layer(l, a))
layers.append(nnet.layer(3, 'squash'))
net = nnet.net(layers, step_size=step_size, dropout=dropout_percentage)
print('beginning training...')
save_time = time.time()
epoch_time = time.time()
for i in range(training_epochs):
minibatch_count = int(train_size / minibatch_size)
#loop thru minibatches
training_correct = 0
if (i % shuffle_epochs == 0):
writedot()
rng_state = np.random.get_state()
np.random.shuffle(sample_list)
np.random.set_state(rng_state)
np.random.shuffle(class_list)
print('class type count: ' + str(class_type))
class_type_test = np.sum(class_list_test,axis=0,dtype=np.float64)
print('class test type count: ' + str(class_type_test))
print('initializing network...')
layers = [nnet.layer(inputsize)]
for i in range(len(hidden_sizes)):
l = hidden_sizes[i]
a = hidden_activations[i]
layers.append(nnet.layer(l,a))
layers.append(nnet.layer(3,'squash'))
net = nnet.net(layers,step_size=step_size,dropout=dropout_percentage)
print('beginning training...')
save_time = time.time()
epoch_time = time.time()
for i in range(training_epochs):
minibatch_count = int(train_size/minibatch_size)
#loop thru minibatches
training_correct = 0;
if(i%shuffle_epochs == 0):
writedot()
rng_state = np.random.get_state()
np.random.shuffle(sample_list)
np.random.set_state(rng_state)
np.random.shuffle(class_list)
def init_network(pnet,input_size):
num_hidden = pnet['num_hidden']
nodes_per_group = pnet['nodes_per_group']
nodes_per_group2 = pnet['nodes_per_group2']
nodes_per_group3 = pnet['nodes_per_group3']
layers = [];
layers.append(nnet.layer(input_size))
layers.append(nnet.layer(pnet['num_hidden'],pnet['activation_function'],nodes_per_group=nodes_per_group,
initialization_scheme=pnet['initialization_scheme'],
initialization_constant=pnet['initialization_constant'],
dropout=pnet['dropout'],sparse_penalty=pnet['sparse_penalty'],
sparse_target=pnet['sparse_target'],use_float32=pnet['use_float32'],
momentum=pnet['momentum'],maxnorm=pnet['maxnorm'],step_size=pnet['learning_rate']))
#Add 2nd and 3rd hidden layers if there are parameters indicating that we should
if(pnet.has_key('num_hidden2') and pnet['num_hidden2'] is not None):
layers.append(nnet.layer(pnet['num_hidden2'],pnet['activation_function2'],nodes_per_group=nodes_per_group2,
initialization_scheme=pnet['initialization_scheme2'],
initialization_constant=pnet['initialization_constant2'],
dropout=pnet['dropout2'],sparse_penalty=pnet['sparse_penalty2'],
sparse_target=pnet['sparse_target2'],use_float32=pnet['use_float32'],
momentum=pnet['momentum2'],maxnorm=pnet['maxnorm2'],step_size=pnet['learning_rate2']))
if(pnet.has_key('num_hidden3') and pnet['num_hidden3'] is not None):
layers.append(nnet.layer(pnet['num_hidden3'],pnet['activation_function3'],nodes_per_group=nodes_per_group3,
initialization_scheme=pnet['initialization_scheme3'],
initialization_constant=pnet['initialization_constant3'],
dropout=pnet['dropout3'],sparse_penalty=pnet['sparse_penalty3'],
sparse_target=pnet['sparse_target3'],use_float32=pnet['use_float32'],
momentum=pnet['momentum3'],maxnorm=pnet['maxnorm3'],step_size=pnet['learning_rate3']))
layers.append(nnet.layer(num_labels,pnet['activation_function_final'],use_float32=pnet['use_float32'],
step_size=pnet['learning_rate_final'],momentum=pnet['momentum_final']))
#init net
net = nnet.net(layers)
if(pnet.has_key('cluster_func') and pnet['cluster_func'] is not None):
#net.layer[0].centroids = np.asarray((((np.random.random((net.layer[0].weights.shape)) - 0.5)*2.0)),np.float32)
net.layer[0].centroids = np.asarray(((np.ones((net.layer[0].weights.shape))*10.0)),np.float32)
net.layer[0].select_func = csf.select_names[pnet['cluster_func']]
print('cluster_func: ' + str(csf.select_names[pnet['cluster_func']]))
net.layer[0].centroid_speed = pnet['cluster_speed']
net.layer[0].num_selected = pnet['clusters_selected']
net.layer[0].number_to_replace = pnet['number_to_replace']
if(p.has_key('do_cosinedistance') and pnet['do_cosinedistance']):
net.layer[0].do_cosinedistance = True
print('cosine set to true')
if(pnet.has_key('num_hidden2') and pnet.has_key('cluster_func2') and pnet['cluster_func2'] is not None):
#net.layer[0].centroids = np.asarray((((np.random.random((net.layer[0].weights.shape)) - 0.5)*2.0)),np.float32)
net.layer[1].centroids = np.asarray(((np.ones((net.layer[1].weights.shape))*10.0)),np.float32)
net.layer[1].select_func = csf.select_names[pnet['cluster_func2']]
print('cluster_func: ' + str(csf.select_names[pnet['cluster_func2']]))
net.layer[1].centroid_speed = pnet['cluster_speed2']
net.layer[1].num_selected = pnet['clusters_selected2']
net.layer[1].number_to_replace = pnet['number_to_replace']
if(p.has_key('do_cosinedistance') and pnet['do_cosinedistance']):
net.layer[1].do_cosinedistance = True
print('cosine set to true')
if(pnet.has_key('num_hidden3') and pnet.has_key('cluster_func3') and pnet['cluster_func3'] is not None):
#net.layer[0].centroids = np.asarray((((np.random.random((net.layer[0].weights.shape)) - 0.5)*2.0)),np.float32)
net.layer[2].centroids = np.asarray(((np.ones((net.layer[2].weights.shape))*10.0)),np.float32)
net.layer[2].select_func = csf.select_names[pnet['cluster_func3']]
print('cluster_func: ' + str(csf.select_names[pnet['cluster_func3']]))
net.layer[2].centroid_speed = pnet['cluster_speed3']
net.layer[2].num_selected = pnet['clusters_selected3']
net.layer[2].number_to_replace = pnet['number_to_replace']
if(p.has_key('do_cosinedistance') and pnet['do_cosinedistance']):
net.layer[2].do_cosinedistance = True
print('cosine set to true')
net.do_clustering = False
if(pnet['cluster_func'] is not None):
net.do_clustering = True
if(pnet['cluster_func2'] is not None):
net.do_clustering = True
if(pnet['cluster_func3'] is not None):
net.do_clustering = True
return net
def init(self,state_size,num_actions,p):
layers = [];
self.state_size = state_size
self.num_actions = num_actions
#self.mins = np.array(mins)
#self.maxs = np.array(maxs)
#self.divs = np.array(divs)
#self.size = self.maxs - self.mins
#self.size = self.size + self.divs
#self.size = self.size/self.divs
#self.arr_mins = (np.zeros(self.size.shape)).astype(np.int64)
#self.arr_maxs = (self.size - np.ones(self.size.shape)).astype(np.int64)
self.incorrect_target = p['incorrect_target']
self.correct_target = p['correct_target']
layers.append(nnet.layer(self.state_size + self.num_actions))
if(p.has_key('num_hidden') and p['num_hidden'] is not None):
layers.append(nnet.layer(p['num_hidden'],p['activation_function'],
initialization_scheme=p['initialization_scheme'],
initialization_constant=p['initialization_constant'],
dropout=p.get('dropout',None),use_float32=p['use_float32'],
momentum=p['momentum'],maxnorm=p.get('maxnorm',None),step_size=p['learning_rate'],rms_prop_rate=p.get('rms_prop_rate',None)))
layers.append(nnet.layer(1,p['activation_function_final'],
initialization_scheme=p['initialization_scheme_final'],
initialization_constant=p['initialization_constant_final'],
use_float32=p['use_float32'],
momentum=p['momentum'],step_size=p['learning_rate'],rms_prop_rate=p.get('rms_prop_rate',None)))
self.net = nnet.net(layers)
self.do_neuron_clustering=False #by default
if(p.has_key('cluster_func') and p['cluster_func'] is not None):
self.cluster_func = p['cluster_func']
self.net.layer[0].centroids = np.asarray(((np.random.random((self.net.layer[0].weights.shape)) - 0.5) * 2.5),np.float32)
#make the centroid bias input match the bias data of 1.0
self.net.layer[0].centroids[:,-1] = 1.0
#print(str(self.net.layer[0].centroids.shape))
#print(str(self.net.layer[0].centroids))
self.net.layer[0].select_func = csf.select_names[p['cluster_func']]
print('cluster_func: ' + str(csf.select_names[p['cluster_func']]))
self.net.layer[0].centroid_speed = p.get('cluster_speed',1.0)
self.net.layer[0].num_selected = p['clusters_selected']
self.do_neuron_clustering=True #set a flag to indicate neuron clustering
if(p.has_key('do_cosinedistance') and p['do_cosinedistance']):
self.net.layer[0].do_cosinedistance = True
print('cosine set to true')
#decay for balancing learning and moving centroids
if(p.has_key('zeta_decay') and p['zeta_decay'] is not None):
self.net.layer[0].zeta_matrix = np.ones(self.net.layer[0].weights.shape,dtype=np.float32)
self.net.layer[0].zeta = 1.0
self.zeta_decay = p['zeta_decay']
self.max_update = 0.0
self.grad_clip = p.get('grad_clip',None)
if(p.has_key('_lambda') and p['_lambda'] is not None):
self._lambda = p['_lambda']
self.gamma = p['gamma']
for l in self.net.layer:
l.eligibility = l.gradient
