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