def __init__(self, start=0, end=1, frequency = 50, duty_cycle = 0.4, scaling = 1, non_linearity = -1, shape_="monophasic"): self.start = start self.end = end self.lit_data = DataLoader() self.a = Activation(frequency, duty_cycle, scaling, non_linearity) self.a.get_activation_signal(self.lit_data.activation_function(), shape=shape_) self.a_sol = Activation(frequency, duty_cycle, scaling, non_linearity) self.a_sol.get_activation_signal(self.lit_data.activation_function_soleus(), shape=shape_) rest_length_soleus = self.soleus_length(23.7*np.pi/180)*1.015 rest_length_tibialis = self.tibialis_length(-37.4*np.pi/180)*0.9158 # lower is earlier activation print(rest_length_soleus) print(rest_length_tibialis) soleus_f0m = 2600.06 self.soleus = HillTypeMuscle(soleus_f0m, .1342*rest_length_soleus, .8658*rest_length_soleus) self.tibialis = HillTypeMuscle(605.3465, .2206*rest_length_tibialis, .7794*rest_length_tibialis) # theta, velocity, initial CE length of soleus, initial CE length of TA self.initial_state = np.array([self.lit_data.ankle_angle(self.start)[0]*np.pi/180, self.lit_data.ankle_velocity(self.start)[0]*np.pi/180, 0.827034, 1.050905]) print(self.initial_state) self.time = None self.x1 = None self.x2 = None self.x3 = None self.x4 = None
def test_activation_functions(): # Ensure the correct values are calculated by the member functions # We compare against sklearn functions from sklearn.neural_network._base import tanh, relu from scipy.special import expit as sigmoid N = 100 act = Activation(function='sigmoid') x = np.random.uniform(-10.0, 10.0, size=(N, 1)) assert act(x) == pytest.approx(sigmoid(x)) act.set(function='tanh') x = np.random.uniform(-10.0, 10.0, size=(N, 1)) assert act(x) == pytest.approx(tanh(x)) act.set(function='relu') x = np.random.uniform(-10.0, 10.0, size=(N, 1)) assert act(x) == pytest.approx(relu(x)) alpha = 2.5082958 act.set(function='leakyrelu', alpha=alpha) x = np.random.uniform(-10.0, 10.0, size=(N, 1)) assert act(x) == pytest.approx((x >= 0.0) * x + (x < 0.0) * alpha * x)
def __init__(self, num_neurons, input_shape): print( 'Adding Layer: input_shape: {}, number of neurons: {}, output_shape: {}' .format(input_shape, num_neurons, num_neurons)) # Let's initialize the weights in interval [0,1) for respective synaptic inputs self.weights = np.random.uniform(low=0, high=1, size=input_shape) # Lets initialize the biases all with value '1' for every neuron in current layer self.biases = np.ones(num_neurons) # Lets initialize the activation_potentials all with value '0' for every neuron in current layer self.activation_potentials = np.zeros(num_neurons) # Outputs of this layer self.outputs = np.zeros(num_neurons) # Local Gradients of all the neurons in current layer self.local_gradients = np.zeros(num_neurons) # And finally the activation function, for non-linearity of outputs self.activation = Activation() # Inputs to this layer -> Outputs from previous layer self.previous_layers_outputs = [] print('Added Layer ... ')
def test_activation_set(): # Default values act = Activation() # Ensure that changing default values result in changed function calls act.set(function='tanh') assert act.function == act._tanh act.set(function='relu') assert act.function == act._relu act.set(function='leakyrelu') assert act.function == act._leakyrelu # Check wrong string error is handled correctly caught = False try: act.set(function='this_is_not_an_allowed_string') except ValueError as e: caught = True assert caught == True # Ensure alpha values are set correctly alpha = 0.867 act.set(alpha=alpha) assert act.alpha == pytest.approx(alpha)
def __init__(self, method=Method.Sigmoid): self.weights = [] # Current weights self.old_weights = [] # Last time weights self.output = 0.0 # Neuron output self.inputted_features = [] # Inputted features self.summed_signal = 0.0 # Summed singal (the summation of input) self.learning_rate = 0.8 # Learning rate self.activition = Activation() # Activation function
def test_activation_init(): # Ensure the setup is handled correctly when initializing an instance # of the activation class act = Activation() # Default values assert act.function == act._sigmoid assert act.alpha == pytest.approx(0.01) # String to correct function conversion act = Activation(function='tanh') assert act.function == act._tanh act = Activation(function='relu') assert act.function == act._relu act = Activation(function='leakyrelu') assert act.function == act._leakyrelu act = Activation(function='sigmoid') assert act.function == act._sigmoid # Check wrong string error is handled correctly caught = False try: act = Activation(function='this_is_not_an_allowed_string') except ValueError as e: caught = True assert caught == True # Check alpha value specification is handled correctly alpha = 0.867 act = Activation(function='relu', alpha=alpha) assert act.alpha == pytest.approx(alpha)
def __init__(self): self.tag = self.__class__.__name__ self.samples = [] # 所有的训练样本(特征值) self.targets = [] # 范本的目标输出 self.weights = [] # 权重 self.bias = 0.0 # 偏权值 self.learning_rate = 1.0 # 学习速率 self.max_iteration = 1 # 最大迭代数 self.convergence = 0.001 # 收敛误差 self.activation = Activation()
def __init__(self, has_recurrent=False): self.weights = [] # <number> self.recurrent_weights = [] # <number> self.bias = 0.0 self.delta_value = 0.0 # Current delta value will be next delta value. self.has_recurrent = has_recurrent # Has recurrent inputs ? (hidden net has recurrent, but output net not. self.activation = Activation( ) # 活化函式的 Get, Set 都在这里: net.activation.method. # 有另外开 self.activation_method 来方便存取 self.output = NetOutput() self.timesteps = [] # <Timestep Object>
def __init__(self) -> None: super().__init__() # hyper params self.alpha: float = 1 self.lambda_: float = 0 self.c: float = 0 self.gamma: float = 0 # model params self.layers = [] # engine params self.act: Activation() = None self.reg: Regularization() = None self.opt: Optimizer() = None
def __init__(self, architecture=[784, 100, 10], activation='sigmoid', learning_rate=0.1, momentum=0.5, weight_decay=1e-4, dropout=0.5, early_stopping=True, seed=99): """ Neural network model initializer. """ # Attributes self.architecture = architecture self.activation = activation self.learning_rate = learning_rate self.momentum = momentum self.weight_decay = weight_decay self.dropout = dropout self.early_stopping = early_stopping self.seed = seed # Turn `activation` and `learning_rate` to class instances if not isinstance(self.activation, Activation): self.activation = Activation(self.activation) if not isinstance(self.learning_rate, LearningRate): self.learning_rate = LearningRate(self.learning_rate) # Initialize a list of layers self.layers = [] for i, (n_in, n_out) in enumerate(zip(architecture[:-2], architecture[1:-1])): l = HiddenLayer('layer{}'.format(i), n_in, n_out, self.activation, self.learning_rate, self.momentum, self.weight_decay, self.dropout, self.seed + i) self.layers.append(l) # Output layer n_in, n_out = architecture[-2], architecture[-1] l = OutputLayer('output_layer', n_in, n_out, self.learning_rate, self.momentum, self.weight_decay, self.dropout, self.seed + i + 1) self.layers.append(l) # Training updates self.epoch = 0 self.training_error = [] self.validation_error = [] self.training_loss = [] self.validation_loss = []
def activate_tag_callback(tag): if display_manager.active_window() != prompt: return print "Activating tag: %s" % tag display_manager.launch(load_window) res = urllib2.urlopen("http://192.168.1.10:8000/api/activate?tag=%s" % tag).read() print res res_dict = json.loads(res) if (res_dict["status"] == "error"): load_window.finish() else: name = res_dict["player"]["first_name"] + " " + res_dict["player"][ "last_name"] team = res_dict["player"]["team"] rule = res_dict["player"]["rule_text"] activation = Activation(name, team, rule) display_manager.launch_consume(activation)
def __init__(self, input_layer, num_units, init_stddev, activation_fun=Activation('relu')): self.num_units = num_units self.activation_fun = activation_fun # the input shape will be of size (batch_size, num_units_prev) # where num_units_prev is the number of units in the input # (previous) layer self.input_shape = input_layer.output_size() # TODO ################################ # TODO: implement weight initialization # TODO ################################ # this is the weight matrix it should have shape: (num_units_prev, num_units) # use normal distrbution with mean 0 and stdv = init_stddev self.W = np.random.normal(0, init_stddev, (self.input_shape[1], num_units)) #FIXME # and this is the bias vector of shape: (num_units) self.b = np.random.normal(0, init_stddev, (num_units, )) #FIXME # create dummy variables for parameter gradients # no need to change these here! self.dW = None self.db = None
def __init__( self , NB_PIPELINE_STAGES = 4, DATAWIDTH = 32, CHANNEL_WIDTH = 1, INIT_DATA = 0, LEN_THETA = 3, CMD_FILE = ""): self.NB_PIPELINE_STAGES = NB_PIPELINE_STAGES self.DATAWIDTH = DATAWIDTH self.CHANNEL_WIDTH = CHANNEL_WIDTH self.INIT_DATA = INIT_DATA self.LEN_THETA = LEN_THETA self.CMD_FILE = CMD_FILE # IO Signals self.pipeST_A_i = PipelineST( self.DATAWIDTH, self.CHANNEL_WIDTH , self.INIT_DATA ) self.pipeST_B_i = PipelineST( self.DATAWIDTH, self.CHANNEL_WIDTH , self.INIT_DATA ) self.pipeST_o = PipelineST( self.DATAWIDTH, self.CHANNEL_WIDTH , self.INIT_DATA ) # Internal Signals self.pipe_out_acc = PipelineST( self.DATAWIDTH, self.CHANNEL_WIDTH, self.INIT_DATA ) #----------------- Initializing Pipeline Streams ---------------- self.operand_a = OperandPipeline( self.NB_PIPELINE_STAGES , self.DATAWIDTH , self.CHANNEL_WIDTH , self.INIT_DATA ) self.pipeA_stage = self.operand_a.pipeST_stage_o self.operand_b = OperandPipeline( self.NB_PIPELINE_STAGES , self.DATAWIDTH , self.CHANNEL_WIDTH , self.INIT_DATA ) self.pipeB_stage = self.operand_b.pipeST_stage_o # --- Initializing Command Pipeline OPCODE = "MULT" OPSTAGE = 2 self.multPipe = CommandPipeline( self.NB_PIPELINE_STAGES , self.DATAWIDTH , self.CHANNEL_WIDTH , self.INIT_DATA , OPCODE , OPSTAGE ) self.multC_stage = self.multPipe.pipeST_stage_o # ---- Initializing Accumulator Block self.accuPipe = Accumulator( self.DATAWIDTH , self.CHANNEL_WIDTH , self.INIT_DATA , self.LEN_THETA ) # ---- Initializing Activation Block ACT_DATAWIDTH= 3 # 0 or 1 for classification self.activPipe = Activation( ACT_DATAWIDTH , self.CHANNEL_WIDTH , self.INIT_DATA )
def sim_command_pipeline(pars_obj): global test_decimal_shift, theta_decimal_shift #------------------ Initializing Pipeline depths --------------- NB_PIPELINE_STAGES = 5 DATAWIDTH = 32 #-------------- Simulation Initialisations --------------------- reset = Signal(bool(1)) clk = Signal(bool(0)) elapsed_time = Signal(0) clkgen = clk_driver(elapsed_time, clk, period=20) #---------------------------------------------------------------- #----------------- Initializing Pipeline Streams ---------------- # --- Pipeline Pars pars = OperandPipelinePars() pars.NB_PIPELINE_STAGES = NB_PIPELINE_STAGES pars.DATAWIDTH = DATAWIDTH pars.CHANNEL_WIDTH = 2 global floatDataBus if (True == floatDataBus): pars.INIT_DATA = 0.0 # requires floating point computation else: pars.INIT_DATA = 0 # requires intbv computation # --- Initializing Pipeline A pipe_inpA = PipelineST(pars.DATAWIDTH, pars.CHANNEL_WIDTH, pars.INIT_DATA) pipe_outA = PipelineST(pars.DATAWIDTH, pars.CHANNEL_WIDTH, pars.INIT_DATA) operand_a = OperandPipeline() ioA = OperandPipelineIo() ioA(pars) # --- Initializing Pipeline B pipe_inpB = PipelineST(pars.DATAWIDTH, pars.CHANNEL_WIDTH, pars.INIT_DATA) pipe_outB = PipelineST(pars.DATAWIDTH, pars.CHANNEL_WIDTH, pars.INIT_DATA) operand_b = OperandPipeline() ioB = OperandPipelineIo() ioB(pars) # --- Initializing Command Pipeline pipe_multRes = PipelineST(pars.DATAWIDTH, pars.CHANNEL_WIDTH, pars.INIT_DATA) multcmdFile = '../tests/mult_pipeline.list' parsMult = CommandPipelinePars() parsMult.DATAWIDTH = pars.DATAWIDTH parsMult.CHANNEL_WIDTH = pars.CHANNEL_WIDTH parsMult.INIT_DATA = pars.INIT_DATA parsMult.STAGE_NB = 1 parsMult(parsMult, multcmdFile) multPipe = CommandPipeline() ioMult = CommandPipelineIo() ioMult(pars) # ---- Initializing Accumulator Block pipe_out_acc = PipelineST(pars.DATAWIDTH, pars.CHANNEL_WIDTH, pars.INIT_DATA) parsAcc = AccumulatorPars() parsAcc.DATAWIDTH = pars.DATAWIDTH parsAcc.CHANNEL_WIDTH = pars.CHANNEL_WIDTH parsAcc.INIT_DATA = pars.INIT_DATA global LEN_THETA parsAcc.NB_ACCUMULATIONS = LEN_THETA accuPipe = Accumulator() accuPipe(parsAcc) # ---- Initializing Activation Block parsActiv = ActivationPars() parsActiv.DATAWIDTH = 3 # 0 or 1 for classification parsActiv.CHANNEL_WIDTH = pars.CHANNEL_WIDTH parsActiv.INIT_DATA = pars.INIT_DATA pipe_out_activ = PipelineST(pars.DATAWIDTH, pars.CHANNEL_WIDTH, pars.INIT_DATA) activPipe = Activation() activPipe(parsActiv) #---------------------------------------------------------------- #----------------- Connecting Pipeline Blocks ------------------- inst = [] inst.append( operand_a.block_connect(pars, reset, clk, pipe_inpA, pipe_outA, ioA)) inst.append( operand_b.block_connect(pars, reset, clk, pipe_inpB, pipe_outB, ioB)) #---------------------------------------------------------------- #----------------- Connecting Command Pipeline ------------------- # Mult Pipeline inst.append( multPipe.block_connect(parsMult, reset, clk, ioA, ioB, pipe_multRes, ioMult)) #---------------------------------------------------------------- #----------------- Connecting Accumulator -------------- # Accu inst.append( accuPipe.block_connect(parsAcc, reset, clk, 0, pipe_multRes, pipe_out_acc)) #---------------------------------------------------------------- #----------------- Connecting Activation -------------- # Simple Step Activation function inst.append( activPipe.block_step_connect(parsActiv, reset, clk, pipe_out_acc, pipe_out_activ)) #---------------------------------------------------------------- #----------------- Logistic Regression Test File ------------------- lr_test_file = "../tests/ex2data1.txt" lr_theta_file = "../tests/theta1.txt" #--- Loading Test and Theta Values test_file_list = [] theta_file_list = [] nb_training_examples = 0 # Loading test data with open(lr_test_file, 'r') as f: d0 = 1.0 # Always first element is 1 for line in f: #print line d1, d2, y = line.split(',') d0 = round(float(d0), DEF_ROUND) d1 = round(float(d1), DEF_ROUND) d2 = round(float(d2), DEF_ROUND) test_file_list.extend([d0, d1, d2]) label.extend([int(y)]) nb_training_examples += 1 #loading theta with open(lr_theta_file, 'r') as f: t0, t1, t2 = (f.read().split('\n')[0]).split(',') t0 = round(float(t0), DEF_ROUND) t1 = round(float(t1), DEF_ROUND) t2 = round(float(t2), DEF_ROUND) for i in range(nb_training_examples): theta_file_list.extend([t0, t1, t2]) # exp10 shifts done for theta and test data as per requirements when intbv used if (False == floatDataBus): test_file_list = [ int(i * (10**test_decimal_shift)) for i in test_file_list ] theta_file_list = [ int(i * (10**theta_decimal_shift)) for i in theta_file_list ] #print test_file_list #print theta_file_list #---------------------------------------------------------------- #----------------- Shift Enable for pipeData ------------------- shiftEn_i = Signal(bool(0)) @always(clk.posedge, reset.posedge) def shift_signal(): if reset: shiftEn_i.next = 1 else: shiftEn_i.next = not shiftEn_i @always_comb def shiftOperand_signal(): ioB.shiftEn_i.next = shiftEn_i ioA.shiftEn_i.next = shiftEn_i #---------------------------------------------------------------- #----------------- Reset For the Module -------------------- @always(clk.posedge) def stimulus(): if elapsed_time == 40: reset.next = 0 #---------------------------------------------------------------- #----------------- Input Data for the Modules -------------------- @always_comb def transmit_data_process(): global line_nb if (shiftEn_i == 1 and nbTA == nbTB and nbTA < MAX_NB_TRANSFERS): pipe_inpA.data.next = (test_file_list[line_nb]) pipe_inpA.valid.next = 1 pipe_inpB.data.next = (theta_file_list[line_nb]) pipe_inpB.valid.next = 1 line_nb += 1 else: pipe_inpA.valid.next = 0 pipe_inpB.valid.next = 0 #---------------------------------------------------------------- #----------------- Storing Transmitted Data -------------------- @always(clk.posedge, reset.posedge) def trans_dataA_process(): global trans_dataA, trans_dataB, nbTA if reset == 1: pass elif (pipe_inpA.valid == 1 and nbTA < MAX_NB_TRANSFERS): nbTA += 1 trans_dataA.extend([pipe_inpA.data]) @always(clk.posedge, reset.posedge) def trans_dataB_process(): global trans_dataA, trans_dataB, nbTB if reset == 1: pass elif (pipe_inpB.valid == 1 and nbTB < MAX_NB_TRANSFERS): nbTB += 1 trans_dataB.extend([pipe_inpB.data]) #---------------------------------------------------------------- #----------------- Storing Received Data ----------------------- @always(clk.posedge) def receive_data_process(): global recv_data, nbR, acc_out # Collecting multiplier data if (pipe_multRes.valid == 1): if (False == floatDataBus): mult_out = pipe_multRes.data else: mult_out = (round(pipe_multRes.data, DEF_ROUND)) recv_data.extend([mult_out]) # Collecting Activation Data if (pipe_out_activ.valid == 1): nbR += LEN_THETA predict = int(pipe_out_activ.data) prediction_res.extend([predict]) if __debug__: print(" prediction: {:d}".format(predict)) if (nbR == MAX_NB_TRANSFERS): raise StopSimulation( "Simulation Finished in %d clks: In total " % now() + str(MAX_NB_TRANSFERS) + " data words received") # Collecting Accumulator Data if (pipe_out_acc.valid == 1): acc_out = pipe_out_acc.data #prob=(1.0/(1+ (math.exp(-1.0*acc_out) ))) # Sigmoid activation Function if __debug__: if (False == floatDataBus): print("{0:d} Acc: {1:d} ".format(int(nbR / LEN_THETA + 1), int(acc_out), i=DEF_ROUND), end=' ') else: print("{0:d} Acc: {1:0.{i}f}".format(int(nbR / LEN_THETA + 1), float(acc_out), i=DEF_ROUND), end=' ') if (False == floatDataBus): acc_out_list.extend([int(acc_out)]) else: acc_out_list.extend([round(acc_out, DEF_ROUND)]) #print "nbR:" + str(nbR) #---------------------------------------------------------------- #----------------- Max Simulation Time Exit Condition ----------- @always(clk.posedge) def simulation_time_check(): sim_time_now = now() if (sim_time_now > MAX_SIM_TIME): raise StopSimulation( "Warning! Simulation Exited upon reaching max simulation time of " + str(MAX_SIM_TIME) + " clocks") #---------------------------------------------------------------- return instances()
rmse_toe_height_plot[i][j], independent_1[i][j], independent_2[i][j] ]) # Sorts by first element (ie RMSE) top_viable = sorted(viable) if len(top_viable) >= 5: top_viable = top_viable[:5] # Find fatigues emg_data = load_data('./data/ta_vs_gait.csv') emg_data = np.array(emg_data) emg_function = get_norm_emg(emg_data) fatigues = [] all_fatigues = [] for i in range(len(top_viable)): a = Activation(frequency, duty_cycle, scaling, top_viable[i][1]) a.get_activation_signal(emg_function, shape=shape[top_viable[i][2]]) fatigues.append([a.get_fatigue(), i]) for i in range(len(viable)): a = Activation(frequency, duty_cycle, scaling, viable[i][1]) a.get_activation_signal(emg_function, shape=shape[viable[i][2]]) all_fatigues.append([a.get_fatigue(), i]) # Sorts by first element (ie fatigue) top_fatigues = sorted(fatigues) optimal = top_viable[top_fatigues[0][1]] print(optimal)
independent_2[i][j] ]) # Sorts by first element (ie RMSE) top_viable = sorted(viable) if len(top_viable) >= 5: top_viable = top_viable[:5] # Find fatigues emg_data = load_data('./data/ta_vs_gait.csv') emg_data = np.array(emg_data) emg_function = get_norm_emg(emg_data) fatigues = [] all_fatigues = [] for i in range(len(top_viable)): a = Activation(top_viable[i][1], top_viable[i][2], scaling, non_linearity) a.get_activation_signal(emg_function) fatigues.append([a.get_fatigue(), i]) for i in range(len(viable)): a = Activation(viable[i][1], viable[i][2], scaling, non_linearity) a.get_activation_signal(emg_function) all_fatigues.append([a.get_fatigue(), i]) # Sorts by first element (ie fatigue) top_fatigues = sorted(fatigues) optimal = top_viable[top_fatigues[0][1]] print(optimal)
def __init__(self, input_layer_size, state_layer_size, state_layer_activation, output_layer_size, output_layer_activation, epochs=100, bptt_truncate=None, learning_rule='bptt', kernel=None, eta=0.001, rand=None, verbose=0): """ Notes: U - weight matrix from input into hidden layer. W - weight matrix from hidden layer to hidden layer. V - weight matrix from hidden layer to output layer. Inputs: input_size: Size of the input vector. We expect a 2D numpy array, so this should be X.shape[1] state_layer_size: State layer size. state_layer_activation: A string. Refer to activation.py output_size: Size of the output vector. We expect a 2D numpy array, so this should be Y.shape[1] output_layer_activation: A string. Refer to activation.py epochs(opt): Number of epochs for a single training sample. learning_rule(opt): Choose between 'bptt' and 'modified' bptt_truncate(opt): If left at None, back propagation through time will be applied for all time steps. Otherwise, a value for bptt_truncate means that bptt will only be applied for at most bptt_truncate steps. Only considered when learning_rule == 'bptt' kernel(opt): # TODO - fill this Only considered when learning_rule == 'modified' eta (opt): Learning rate. Initialized to 0.001. rand (opt): Random seed. Initialized to None (no random seed). verbose (opt): Verbosity: levels 0 - 2 Outputs: None """ np.random.seed(rand) self.learning_rule = learning_rule.lower() if self.learning_rule == 'bptt': self.gradient_function = self.bptt elif self.learning_rule == 'modified': self.gradietn_function = self.modified_learning_rule else: raise ValueError self.input_layer_size = input_layer_size self.state_layer_size = state_layer_size self.state_layer_activation = state_layer_activation self.state_activation = Activation(state_layer_activation) self.output_layer_size = output_layer_size self.output_layer_activation = output_layer_activation self.output_activation = Activation(output_layer_activation) self.epochs = epochs self.kernel = kernel self.bptt_truncate = bptt_truncate # U - weight matrix from input into state layer. # W - weight matrix from state layer to state layer. # V - weight matrix from state layer to output layer. self.U = np.random.uniform(-np.sqrt(1. / input_layer_size), np.sqrt(1. / input_layer_size), (state_layer_size, input_layer_size)) self.V = np.random.uniform(-np.sqrt(1. / state_layer_size), np.sqrt(1. / state_layer_size), (output_layer_size, state_layer_size)) self.W = np.random.uniform(-np.sqrt(1. / state_layer_size), np.sqrt(1. / state_layer_size), (state_layer_size, state_layer_size)) self.state_bias = np.zeros((state_layer_size, 1)) self.output_bias = np.zeros((output_layer_size, 1)) self.eta = eta self.verbose = verbose self.show_progress_bar = verbose > 0
def addLayer(self, inputs = None, neurons = None, activations = None, alpha = None, outputs = None, output = False) : if neurons is None : if self.neurons is None : raise ValueError( "Number of neurons is not specified. " + "Use the NeuralNetwork class constructor, " + "the .set method, or give the number as " + "input to this method (.addLayer).") else : neurons = self.neurons if activations is None : if self.activations is None : warnings.warn( "No activation function specified, using " + "sigmoid activation for this (and all " + "subsequent layers added).") self.activations = 'sigmoid' activations = self.activations else : activations = self.activations if self.weights is None : if inputs is None : if self.inputs is None : raise ValueError( "The number of inputs is not specified." + "Use the NeuralNetwork class constructor, " + "the .set method, or give the number as " + "input to this method (.addLayer).") else : inputs = self.inputs else : self.inputs = inputs if not self.silent : print( "Adding input layer with " + str(neurons) + " neurons " + "using " + str(activations) + " activations.") #W = np.random.uniform(-1.0, 1.0, size=(inputs, neurons)) #b = np.random.uniform(-0.1, 0.1, size=(neurons,1)) W = self.initializeWeight(inputs, neurons, activations) b = np.zeros(shape=(neurons,1)) f = Activation(function = activations, alpha = alpha) self.weights = [W] self.biases = [b] self.act = [f] elif output == True : if outputs is None : if self.outputs is None : raise ValueError( "The number of outputs is not specified." + "Use the NeuralNetwork class constructor, " + "the .set method, or give the number as " + "input to this method (.addLayer / " + ".addOutputLayer).") else : outputs = self.outputs else : if self.outputs != outputs : warnings.warn( "The number of outputs was earlier set to " + str(self.outputs) + ", but the value specified to " + " .addLayer / .addOutputLayer of " + str(outputs) + " overrides this value.") self.outputs = outputs if not self.silent : print( "Adding output layer with " + str(outputs) + " outputs, " + "with " + str(activations) + " activation.") previousLayerNeurons = self.weights[-1].shape[1] #W = np.random.uniform(-1.0, 1.0, size=(previousLayerNeurons, outputs)) #b = np.random.uniform(-0.1, 0.1, size=(outputs,1)) W = self.initializeWeight(previousLayerNeurons, outputs, activations) b = np.zeros(shape=(outputs,1)) f = Activation(function = activations, alpha = alpha) self.weights.append(W) self.biases .append(b) self.act .append(f) else : if not self.silent : print( "Adding layer with " + str(neurons) + " neurons using " + str(activations) + " activations.") previousLayerNeurons = self.weights[-1].shape[1] #W = np.random.uniform(-1.0, 1.0, size=(previousLayerNeurons, neurons)) #b = np.random.uniform(-0.1, 0.1, size=(neurons,1)) W = self.initializeWeight(previousLayerNeurons, neurons, activations) b = np.zeros(shape=(neurons,1)) f = Activation(function = activations, alpha = alpha) self.weights.append(W) self.biases .append(b) self.act .append(f)
for i in range(len(above_0_plot)): if above_0_plot[i] == 1: viable.append([rmse_toe_height_plot[i], frequency[i]]) # Sorts by first element (ie RMSE) top_viable = sorted(viable) if len(top_viable) >= 5: top_viable = top_viable[:5] # Find fatigues emg_data = load_data('./data/ta_vs_gait.csv') emg_data = np.array(emg_data) emg_function = get_norm_emg(emg_data) fatigues = [] all_fatigues = [] for i in range(len(top_viable)): a = Activation(top_viable[i][1], duty_cycle, scaling, non_linearity) a.get_activation_signal(emg_function, shape="halfsin") fatigues.append([a.get_fatigue(), i]) for i in range(len(viable)): a = Activation(viable[i][1], duty_cycle, scaling, non_linearity) a.get_activation_signal(emg_function, shape="halfsin") all_fatigues.append([a.get_fatigue(), i]) # Sorts by first element (ie fatigue) top_fatigues = sorted(fatigues) optimal = top_viable[top_fatigues[0][1]] print(optimal)
def foo(mod, op, d): if (op[0] == "linear"): xx = Linear(d) # rnncell, lstmcell, grucell elif (mod[0] in ["LSTMCell", "GRUCell"]) and (op[0] == "forward"): xx = RNNCell(d) elif op[0] in [ "conv1d", "conv2d", ]: xx = Conv(d) elif (op[0] in Pointwise.ops): xx = Pointwise(d) elif (op[0] in Convert.ops): xx = Convert(d) elif op[0] in ["__matmul__", "matmul"]: xx = Matmul(d) elif op[0] == "embedding": xx = Embedding(d) #reduction elif op[0] == "sum": xx = Sum(d) elif op[0] == "mean": xx = Mean(d) elif op[0] == "norm": xx = Norm(d) elif op[0] == "dropout": xx = Dropout(d) #Index, Slice, Join, Mutate elif (op[0] == "cat"): xx = Cat(d) elif (op[0] == "reshape"): xx = Reshape(d) elif (op[0] == "masked_scatter_"): xx = MaskedScatter(d) elif (op[0] == "gather"): xx = Gather(d) elif (op[0] == "nonzero"): xx = Nonzero(d) elif (op[0] == "index_select"): xx = IndexSelect(d) elif (op[0] == "masked_select"): xx = MaskedSelect(d) #blas elif op[0] in ["addmm", "addmm_"]: xx = Addmm(d) elif op[0] == "mm": xx = Mm(d) elif op[0] == "bmm": xx = Bmm(d) #softmax elif op[0] == "softmax": xx = Softmax(d) elif op[0] == "log_softmax": xx = LogSoftmax(d) #loss elif op[0] == "mse_loss": xx = MSELoss(d) #optimizers elif op[0] == "adam": xx = Adam(d) #normalization elif op[0] == "batch_norm": xx = BatchNorm(d) #random elif op[0] == "randperm": xx = RandPerm(d) #misc elif op[0] == "copy_": xx = Copy(d) elif op[0] == "clone": xx = Clone(d) elif op[0] == "contiguous": xx = Contiguous(d) elif op[0] == "any": xx = Any(d) elif (op[0] in Activation.ops): xx = Activation(d) elif op[0] == "to": xx = Convert(d) else: xx = Foo(d) return xx
def lr_top(pars, reset, clk, pipe_inpA, pipe_inpB, pipe_out_activ): #----------------- Initializing Pipeline Streams ---------------- # --- Initializing Pipeline A pipe_outA = PipelineST(pars.DATAWIDTH,pars.CHANNEL_WIDTH,pars.INIT_DATA) operand_a=OperandPipeline() ioA=OperandPipelineIo() ioA(pars) # --- Initializing Pipeline B pipe_outB = PipelineST(pars.DATAWIDTH,pars.CHANNEL_WIDTH,pars.INIT_DATA) operand_b=OperandPipeline() ioB=OperandPipelineIo() ioB(pars) # --- Initializing Command Pipeline pipe_multRes = PipelineST(pars.DATAWIDTH,pars.CHANNEL_WIDTH,pars.INIT_DATA) multcmdFile='tb/tests/mult_pipeline.list' parsMult= CommandPipelinePars() parsMult.DATAWIDTH= pars.DATAWIDTH parsMult.CHANNEL_WIDTH = pars.CHANNEL_WIDTH parsMult.INIT_DATA = pars.INIT_DATA parsMult.STAGE_NB = 1 parsMult(parsMult,multcmdFile) multPipe=CommandPipeline() ioMult=CommandPipelineIo() ioMult(pars) # ---- Initializing Accumulator Block pipe_out_acc = PipelineST(pars.DATAWIDTH,pars.CHANNEL_WIDTH,pars.INIT_DATA) parsAcc= AccumulatorPars() parsAcc.DATAWIDTH= pars.DATAWIDTH parsAcc.CHANNEL_WIDTH = pars.CHANNEL_WIDTH parsAcc.INIT_DATA = pars.INIT_DATA parsAcc.NB_ACCUMULATIONS = pars.LEN_THETA accuPipe= Accumulator() accuPipe(parsAcc) # ---- Initializing Activation Block parsActiv= ActivationPars() parsActiv.DATAWIDTH= 3 # 0 or 1 for classification parsActiv.CHANNEL_WIDTH = pars.CHANNEL_WIDTH parsActiv.INIT_DATA = pars.INIT_DATA activPipe= Activation() activPipe(parsActiv) #---------------------------------------------------------------- #----------------- Connecting Pipeline Blocks ------------------- trainingData=(operand_a.block_connect(pars, reset, clk, pipe_inpA, pipe_outA, ioA)) theta=(operand_b.block_connect(pars, reset, clk, pipe_inpB, pipe_outB, ioB)) #---------------------------------------------------------------- #----------------- Connecting Command Pipeline ------------------- # Mult Pipeline command=(multPipe.block_connect(parsMult, reset, clk, ioA, ioB, pipe_multRes, ioMult)) #---------------------------------------------------------------- #----------------- Connecting Accumulator -------------- # Accu acc_reset=Signal(bool(0)) accumulator=(accuPipe.block_connect(parsAcc, reset, clk, acc_reset, pipe_multRes, pipe_out_acc)) #---------------------------------------------------------------- #----------------- Connecting Activation -------------- # Simple Step Activation function activation=(activPipe.block_step_connect(parsActiv, reset, clk, pipe_out_acc, pipe_out_activ )) #---------------------------------------------------------------- return instances()
) # plot CE,SE,PE force-length curves and CE force-velocity curve print(get_velocity(1.0, np.array([1.0]), np.array( [1.01]))) # calculate velocity given a=1.0,lm=1.0,ls=1.01 # Constants max_isometric_force = 605.0 total_length = 0.44479194718764087 resting_muscle_length = .25 * total_length resting_tendon_length = .75 * total_length emg_data = load_data('./data/ta_vs_gait.csv') emg_data = np.array(emg_data) emg_data_regress = get_norm_emg(emg_data) frequency, duty_cycle, scaling, non_linearity = 35, 0.5, 1, -1 a = Activation(frequency, duty_cycle, scaling, non_linearity) a.get_activation_signal(emg_data_regress, shape="monophasic") # Create an HillTypeMuscle using the given constants muscle = HillTypeMuscle(max_isometric_force, resting_muscle_length, resting_tendon_length) # Dynamic equation def f(t, x): normalized_tendon_length = muscle.norm_tendon_length(total_length, x) temp = get_velocity(a.get_amp(t / 100), np.array([x]), np.array([normalized_tendon_length])) return temp # return 100*get_velocity(0, np.array([x]), np.array([normalized_tendon_length])) # Simulate using rk45
def __init__(self, learning_rate: float, X: np.array, Y: np.array, func: str): super().__init__(learning_rate, X, Y) self._activer = Activation(func)
import numpy as np import pandas as pd from utilities import Utilities from activation import Activation act = Activation() class NeuralNetwork: def __init__(self, W=np.array(0, dtype=float), b=0, epoch=10, learn_rate=0.01): """ This is the constructor class Input: * W: an array of weights * b: the bias * epoch: the number of loops to fit model * learn_rate: the scale of gradient descent steps * cost: the array of regularization Ouput: * returns a log-loss neural network object """ self.w_ = W self.b_ = b self.e_ = epoch self.l_ = learn_rate self.c_ = None np.random.seed(143)
def set_activation(self, frequency, duty_cycle, scaling, non_linearity, shape_): self.a = Activation(frequency, duty_cycle, scaling, non_linearity) self.a.get_activation_signal(self.lit_data.activation_function(), shape=shape_) self.a.plot()
def __init__(self, input_layer_size, state_layer_size, state_layer_activation, output_layer_size, output_layer_activation, epochs=100, bptt_truncate=None, learning_rule='bptt', tau=None, eta=0.001, rand=None, verbose=0): """ Notes: U - weight matrix from input into hidden layer. W - weight matrix from hidden layer to hidden layer. V - weight matrix from hidden layer to output layer. Inputs: input_size: Size of the input vector. We expect a 2D numpy array, so this should be X.shape[1] state_layer_size: State layer size. state_layer_activation: A string. Refer to activation.py output_size: Size of the output vector. We expect a 2D numpy array, so this should be Y.shape[1] output_layer_activation: A string. Refer to activation.py epochs(opt): Number of epochs for a single training sample. learning_rule(opt): Choose between 'bptt','fa', 'dfa' or 'modified' bptt_truncate(opt): If left at None, back propagation through time will be applied for all time steps. Otherwise, a value for bptt_truncate means that bptt will only be applied for at most bptt_truncate steps. Only considered when learning_rule == 'bptt' kernel(opt): # TODO - fill this Only considered when learning_rule == 'modified' eta (opt): Learning rate. Initialized to 0.001. rand (opt): Random seed. Initialized to None (no random seed). verbose (opt): Verbosity: levels 0 - 2 Outputs: None """ np.random.seed(rand) self.learning_rule = learning_rule.lower() if self.learning_rule == 'bptt': self.gradient_function = self.bptt elif self.learning_rule == 'fa': self.gradient_function = self.feedback_alignment elif self.learning_rule == 'dfa': self.gradient_function = self.direct_feedback_alignment elif self.learning_rule == 'modified': self.gradient_function = self.modified_learning_rule else: raise ValueError self.input_layer_size = input_layer_size self.state_layer_size = state_layer_size self.state_layer_activation = state_layer_activation self.state_activation = Activation(state_layer_activation) self.output_layer_size = output_layer_size self.output_layer_activation = output_layer_activation self.output_activation = Activation(output_layer_activation) self.epochs = epochs self.tau = tau self.bptt_truncate = bptt_truncate self.kernel_convs = None # U - weight matrix from input into state layer. # W - weight matrix from state layer to state layer. # V - weight matrix from state layer to output layer. """ if self.learning_rule == 'bptt': self.U = np.random.uniform(-np.sqrt(1./input_layer_size), np.sqrt(1./input_layer_size), (state_layer_size, input_layer_size)) self.V = np.random.uniform(-np.sqrt(1./state_layer_size), np.sqrt(1./state_layer_size), (output_layer_size, state_layer_size)) self.W = np.random.uniform(-np.sqrt(1./state_layer_size), np.sqrt(1./state_layer_size), (state_layer_size, state_layer_size)) else: """ if state_layer_size == input_layer_size and state_layer_size == output_layer_size: print "Using identity matrices for U and V" self.U = np.eye(state_layer_size) self.V = np.eye(state_layer_size) else: self.U = np.random.uniform(1, 2., (state_layer_size, input_layer_size)) self.V = np.random.uniform(1, 2., (output_layer_size, state_layer_size)) self.W = np.random.uniform(-0.5, 0.5, (state_layer_size, state_layer_size)) # see if W matrix randomization is the cause #self.W = np.random.rand(2, 2) - 1/2#np.array([[0.51940038, -0.57702151],[0.64065148, 0.31259335]]) #self.W = np.array([[0.51940038, -0.57702151],[0.64065148, 0.31259335]]) self.state_bias = np.zeros((state_layer_size, 1)) self.output_bias = np.zeros((output_layer_size, 1)) # B - Feedback weight matrix for all layers """ self.B = np.random.uniform(-np.sqrt(1./state_layer_size), np.sqrt(1./state_layer_size), (state_layer_size, input_layer_size)) """ self.B = np.random.uniform(0., 0.5, self.W.shape) self.eta = eta self.verbose = verbose self.show_progress_bar = verbose > 0