def __init__(self, src_vocab_size, trg_vocab_size, embed_size, hidden_size, latent_size, num_layers, dpt=0.3, share_params=False): super(CVAE, self).__init__() self.if_zero = False self.share_params = share_params self.src_embedding = nn.Embedding(src_vocab_size, embed_size) self.trg_embedding = nn.Embedding(trg_vocab_size, embed_size) self.src_embedding.weight.data.copy_((torch.rand(src_vocab_size, embed_size) - 0.5) * 2) self.trg_embedding.weight.data.copy_((torch.rand(trg_vocab_size, embed_size) - 0.5) * 2) if share_params: self.shared_encoder = encoder.SharedEncoder(embed_size, hidden_size, num_layers, dpt) else: self.src_encoder_t = encoder.Encoder(src_vocab_size, embed_size, hidden_size, num_layers, dpt, self.src_embedding) self.src_encoder_i = encoder.Encoder(src_vocab_size, embed_size, hidden_size, num_layers, dpt, self.src_embedding) self.trg_encoder = encoder.Encoder(trg_vocab_size, embed_size, hidden_size, num_layers, dpt, self.trg_embedding) #self.decoder = decoder.BasicDecoder(trg_vocab_size, embed_size, hidden_size, latent_size, num_layers, dpt, word_dpt, self.trg_embedding) self.decoder = decoder.BasicAttentionDecoder(trg_vocab_size, embed_size, 2 * hidden_size, latent_size, num_layers, dpt, self.trg_embedding) #self.decoder = decoder.DummyDecoder(trg_vocab_size, embed_size, hidden_size, latent_size, num_layers, dpt, self.trg_embedding) #self.decoder = decoder.BahdanauAttnDecoder(trg_vocab_size, embed_size, hidden_size, latent_size, num_layers, dpt, self.trg_embedding) self.p = inferer.Prior(hidden_size, latent_size, dpt) # self.p = inferer.SelfAttentionPrior(hidden_size, latent_size, dpt) #self.q = inferer.ApproximatePosterior(hidden_size, latent_size, dpt) self.q = inferer.LSTMAttentionApproximatePosterior(hidden_size, latent_size, dpt)
def testStoreMultipleEncodings(self): context = StorageOnlyContext() cache = encoder.EncodingMemoryCache(context) # This particular test needs the context to know about the cache. context.cache = cache my_encoder = encoder.Encoder( context, encoder.OptionValueSet(encoder.OptionSet(), '--parameters')) cache.StoreEncoder(my_encoder) videofile = encoder.Videofile('x/foo_640_480_20.yuv') my_encoding = encoder.Encoding(my_encoder, 123, videofile) testresult = {'foo': 'bar'} my_encoding.result = testresult cache.StoreEncoding(my_encoding) my_encoding = encoder.Encoding(my_encoder, 246, videofile) my_encoding.result = testresult cache.StoreEncoding(my_encoding) result = cache.AllScoredRates(my_encoder, videofile) self.assertEquals(2, len(result)) result = cache.AllScoredEncodings(123, videofile) self.assertEquals(1, len(result)) # Verify that it's working correctly with a new videofile object. videofile2 = encoder.Videofile(videofile.filename) result = cache.AllScoredEncodings(123, videofile2) my_encoding = encoder.Encoding(my_encoder, 123, videofile2) self.assertTrue(cache.ReadEncodingResult(my_encoding)) # Verify that it's working correctly with an encoder created via hashname. encoder2 = encoder.Encoder(context, filename=my_encoder.Hashname()) encoding2 = encoder2.Encoding(123, videofile2) self.assertTrue(cache.ReadEncodingResult(encoding2))
def testEncodersInMultipleRepos(self): test_tools.EmptyWorkDirectory() context = StorageOnlyContext() cache = encoder.EncodingDiskCache(context) context.cache = cache my_encoder = encoder.Encoder( context, encoder.OptionValueSet(encoder.OptionSet(), '--parameters')) other_dir = os.path.join(encoder_configuration.conf.sysdir(), 'multirepo_test') os.mkdir(other_dir) other_cache = encoder.EncodingDiskCache(context, scoredir='multirepo_test') encoder_configuration.conf.override_scorepath_for_test([other_dir]) other_cache.StoreEncoder(my_encoder) encoders = cache.AllEncoderFilenames(only_workdir=True) self.assertEquals(0, len(encoders)) encoders = cache.AllEncoderFilenames(only_workdir=False) self.assertEquals(1, len(encoders)) fetched_encoder = encoder.Encoder(context, filename=encoders[0]) self.assertEquals(my_encoder.parameters.ToString(), fetched_encoder.parameters.ToString()) my_encoding = encoder.Encoding( my_encoder, 123, encoder.Videofile('x/foo_640_480_20.yuv')) testresult = {'foo': 'bar'} my_encoding.result = testresult other_cache.StoreEncoding(my_encoding) # With a specified directory, we should find it in only one place. self.assertTrue(other_cache.ReadEncodingResult(my_encoding)) # Without a specified directory, we should find it on the searchpath. self.assertTrue(cache.ReadEncodingResult(my_encoding)) # Without a searchpath, we shouldn't find it in the default cache. encoder_configuration.conf.override_scorepath_for_test([]) self.assertFalse(cache.ReadEncodingResult(my_encoding))
def testInitFromFile(self): context = encoder.Context(DummyCodec()) my_encoder = encoder.Encoder( context, encoder.OptionValueSet(encoder.OptionSet(), '--parameters')) my_encoder.Store() new_encoder = encoder.Encoder(context, filename=my_encoder.Hashname()) self.assertEquals(new_encoder.parameters, my_encoder.parameters)
def task5_read_encoder(): enc1 = enc.Encoder("A") enc2 = enc.Encoder("B") while (1): ## The shared variable q8 holds the current position of the pitch motor q8.put(enc1.read()) ## The shared variable q9 holds the current position of the roll motor q9.put(enc2.read()) yield (0)
def test_ParametersCanBeStoredAndRetrieved(self): context = encoder.Context(DummyCodec()) my_encoder = encoder.Encoder( context, encoder.OptionValueSet(encoder.OptionSet(), '--parameters')) my_encoder.Store() filename = my_encoder.Hashname() next_encoder = encoder.Encoder(context, filename=filename) self.assertEqual(my_encoder.parameters, next_encoder.parameters)
def testInitFromBrokenFile(self): context = encoder.Context(DummyCodec()) my_encoder = encoder.Encoder( context, encoder.OptionValueSet(encoder.OptionSet(), '--parameters')) my_encoder.Store() # Break stored object. Note: This uses knowledge of the memory cache. old_filename = my_encoder.Hashname() parameters = context.cache.encoders[old_filename].parameters parameters.other_parts.append('--extra-stuff') # Now Hashname() should return a different value. with self.assertRaisesRegexp(encoder.Error, 'contains wrong arguments'): # pylint: disable=W0612 new_encoder = encoder.Encoder(context, filename=old_filename)
def task3_closed_loop(): ''' Function that implements task 3, a task which runs the closed loop motor control ''' cL = loop.Closed_Loop() cL.set_setpoint(4000) while True: #gain_set = float(inputstr) #print(gain_set) cL.set_cont_gain(0.045) mot1 = motor.MotorDriver() enc1 = encoder.Encoder("A") enc1.zero() last_time = utime.ticks_ms() times = [] positions = [] for x in range(300): #utime.sleep_ms(10) times.append(utime.ticks_ms()) pos = enc1.read() positions.append(pos) actuation = cL.control(pos) mot1.set_duty_cycle(actuation) last_time = utime.ticks_ms() yield (0) starttime = times[0] i = 0 for time in times: times[i] = time - starttime i += 1 print(positions) print(times)
def __init__(self, input_dim, output_dim, model_dim, n_head, key_dim, value_dim, hidden_dim, n_layers, pad_idx, max_seq_len=200, dropout=0.1): super(Transformer, self).__init__() self.pad_idx = pad_idx self.encoder = encoder.Encoder(input_dim=input_dim, model_dim=model_dim, n_head=n_head, key_dim=key_dim, value_dim=value_dim, n_layers=n_layers, hidden_dim=hidden_dim, max_seq_len=max_seq_len, dropout=dropout) self.decoder = decoder.Decoder(input_dim=input_dim, model_dim=model_dim, n_head=n_head, key_dim=key_dim, value_dim=value_dim, n_layers=n_layers, hidden_dim=hidden_dim, max_seq_len=max_seq_len, dropout=dropout) self.linear_output = nn.Linear(in_features=model_dim, out_features=output_dim)
def testReadResultEncodedInAst(self): # We've changed the storage format for results from AST to JSON. # This test verifies that AST formatted results are still readable. context = StorageOnlyContext() cache = encoder.EncodingDiskCache(context) my_encoder = encoder.Encoder( context, encoder.OptionValueSet(encoder.OptionSet(), '--parameters')) cache.StoreEncoder(my_encoder) my_encoding = encoder.Encoding( my_encoder, 123, encoder.Videofile('x/foo_640_480_20.yuv')) testresult = {'foo': 'bar'} my_encoding.result = testresult # The following code is a copy of cache.StoreEncoding, with the # encoding step changed. dirname = '%s/%s/%s' % (cache.workdir, my_encoding.encoder.Hashname(), cache.context.codec.SpeedGroup( my_encoding.bitrate)) videoname = my_encoding.videofile.basename with open('%s/%s.result' % (dirname, videoname), 'w') as resultfile: resultfile.write(str(my_encoding.result)) my_encoding.result = None result = cache.ReadEncodingResult(my_encoding) self.assertEquals(result, testresult)
def StartEncoder(self, context): return encoder.Encoder( context, encoder.OptionValueSet( self.option_set, '--rc-lookahead 0 --preset faster --tune psnr --threads 4', formatter=self.option_formatter))
def testBrokenStoredEncoding(self): context = StorageOnlyContext() other_dir = os.path.join(encoder_configuration.conf.sysdir(), 'broken_files') os.mkdir(other_dir) cache = encoder.EncodingDiskCache(context, scoredir='broken_files') # This particular test needs the context to know about the cache. context.cache = cache my_encoder = encoder.Encoder( context, encoder.OptionValueSet(encoder.OptionSet(), '--parameters')) cache.StoreEncoder(my_encoder) # Cache should start off empty. self.assertFalse(cache.AllScoredEncodingsForEncoder(my_encoder)) videofile = encoder.Videofile('x/foo_640_480_20.yuv') my_encoding = encoder.Encoding(my_encoder, 123, videofile) testresult = {'foo': 'bar'} my_encoding.result = testresult cache.StoreEncoding(my_encoding) # TODO(hta): Expose the filename generation as a function for testing. with open( os.path.join( cache.workdir, my_encoding.encoder.Hashname(), cache.context.codec.SpeedGroup(my_encoding.bitrate), '%s.result' % my_encoding.videofile.basename), 'w') as scorefile: scorefile.write('stuff that is not valid json') result = cache.AllScoredEncodingsForEncoder(my_encoder) self.assertFalse(result) self.assertEquals(1, len(cache.bad_encodings))
def _create_blocks(self): #create the environment-agent interface (decoder) self.decoder = decoder.Decoder(self, -1) #create the "hippocampus" / state tracer self.action_buffer = OrNode(self.network, (self.n_actions, 1), -1) self.hippocampus = hippocampus.Hippocampus(self, -1) #create the "cortex" / reward estimator #create the action encoder if self.n_replicates > 1: self.cortex = cortex.MultiCortex(self, -1, noisy=self.noisy, n_replicates=self.n_replicates, dynrange=self.dynrange) self.encoder = encoder.MultiEncoder(self, -1) else: self.cortex = cortex.Cortex(self, -1, noisy=self.noisy) self.encoder = encoder.Encoder(self, -1) #create stubs for SNIP self.stubs['state'] = self.network.createInputStubGroup( size=self.n_states) self.stubs['action'] = self.network.createInputStubGroup( size=self.n_actions) self.stubs['reward'] = self.network.createInputStubGroup(size=1) self.stubs['punishment'] = self.network.createInputStubGroup(size=1) self.stubs['draw'] = self.network.createInputStubGroup(size=1)
def check_collision(clientid, clients): decd = encoder.Decoder() decd.addData(player_coordinates[clientid]) decd.processData() _, clientx, clienty, clientscore = decd.getData() for id in player_coordinates: if clientid == id: continue decd.addData(player_coordinates[id]) if decd.processData(): _, x, y, score = decd.getData() dim = (30 + math.sqrt(score)) // 2 clientdim = (30 + math.sqrt(clientscore)) // 2 dist = ((x + dim) - (clientx + clientdim))**2 + ((y + dim) - (clienty + clientdim))**2 if (dim + clientdim)**2 > dist: # Two players collided encd = encoder.Encoder() if math.sqrt(score) > math.sqrt(clientscore) + 5: # client lost encd.setDeathData() clients[clientid].send(encd.getBytes()) encd.setKillData(clientscore) clients[id].send(encd.getBytes()) elif math.sqrt(clientscore) > math.sqrt(score) + 5: # client won encd.setDeathData() clients[id].send(encd.getBytes()) encd.setKillData(score) clients[clientid].send(encd.getBytes())
def Encoder1_fun(): ''' Function which runs for Task 1, which toggles twice every second in a way which is only slightly silly. ''' state = STATE_0 while True: ######### STATE 0: Initialize Encoder ################################### if state == STATE_0: # Init state Encoder_1 = encoder.Encoder(4, pyb.Pin.board.PB6, pyb.Pin.board.PB7) state = STATE_1 ######### STATE 1: Zero Encoder for Step Response ####################### elif state == STATE_1: # Read encoder and update the shared variable Encoder_1.zero_encoder() state = STATE_2 ######### STATE 2: Get Encoder Values ################################## elif state == STATE_2: if Run.get(): # Read encoder and update the shared variable enc_1_position.put(Encoder_1.read_encoder()) else: state == STATE_1 yield (state)
def __init__(self): ''' 初始化串口相关数据 ''' port = rospy.get_param('~serial_port', '/dev/ttyUSB0') baudrate = rospy.get_param('~serial_baudrate', 460800) self.data_io = serial.Serial(port, baudrate, timeout=0.1) self.rx_Data = [] self.tx_Data = [] self.io_Busy = False #当前串口是否被占用 ''' 初始化ros相关数据 ''' self.robo_Width = rospy.get_param('~robo_width', 0.265) self.enc_pulse_per_meter = rospy.get_param('~pulse_per_meter', 3800) rospy.Subscriber('/cmd_vel', Twist, callback=self.SPD) rospy.Subscriber('/led', UInt8, callback=self.Set_LED) rospy.Service('/get_battery_state', AskBattery, self.Ask_Battery) ''' IO变量 ''' self.v_Left = 0 self.v_Right = 0 self.encoder = encoder.Encoder() ''' 开启IO循环 ''' thread.start_new_thread(self.Thread_IO_Loop, ())
def encode_trace(self, data): data_encoder = encoder.Encoder() events = data_encoder.get_events(data) cases = data_encoder.get_cases(data) columns = events columns = np.append( events, ["case_id", "event_nr", "remaining_time", "elapsed_time"]) encoded_data = pd.DataFrame(columns=columns) i = 0 for case in cases: df = data[data['case_id'] == case] for j in range(0, max(df['event_nr'])): case_data = [] event_length = j + 1 for event in events: case_data.append( len(df[(df['activity_name'] == event) & (df['event_nr'] <= event_length)]) > 0) case_data.append(case) case_data.append(event_length) remaining_time = data_encoder.calculate_remaining_time( df, event_length) case_data.append(remaining_time) elapsed_time = data_encoder.calculate_elapsed_time( df, event_length) case_data.append(elapsed_time) encoded_data.loc[i] = case_data i = i + 1 return encoded_data
def StartEncoder(self, context): return encoder.Encoder( context, encoder.OptionValueSet( self.option_set, '--profile baseline --preset slow --tune psnr', formatter=self.option_formatter))
def __init__(self, latent_spaces, batch_size): super(ANVAE, self).__init__() self.batch_size = batch_size self.latent_spaces = 3 self.level_sizes = [1, 1, 1] self.input_s = [32, 32, 1] self.latent_channels = 20 self.h_dim = 1000 self.encoder = encoder.Encoder(self.latent_spaces, self.input_s) self.decoder = decoder.Decoder(self.encoder( tf.zeros([self.batch_size, 32, 32, 1]), False), latent_channels=self.latent_channels, level_sizes=self.level_sizes) self.discriminator = discriminator.Discriminator( self.latent_spaces, self.input_s, self.h_dim) self.lr_ae = .0001 self.lr_dc = .0001 self.lr_gen = .0001 self.ae_optimizer = tf.keras.optimizers.Adamax(self.lr_ae, clipnorm=2) self.gen_optimizer = tf.keras.optimizers.Adamax(self.lr_gen, clipnorm=2) self.dc_optimizer = tf.keras.optimizers.Adamax(self.lr_dc, clipnorm=2) self.ae_loss_weight = 1. self.gen_loss_weight = 6. self.dc_loss_weight = 6. self.lastEncVars = [] self.lastDecVars = [] self.lastDiscVars = [] self.debugCount = 0 self.counter = 1 self.log_writer = tf.summary.create_file_writer(logdir='./tf_summary') self.step_count = 0 self.conv_layers = [] self.sr_u = {} self.sr_v = {} self.num_power_iter = 4 for layer in self.encoder.layers: if isinstance(layer, tf.keras.layers.Conv2D) or isinstance( layer, tf.keras.layers.DepthwiseConv2D): self.conv_layers.append(layer) for layer in self.decoder.layers: if isinstance(layer, tf.keras.layers.Conv2D) or isinstance( layer, tf.keras.layers.DepthwiseConv2D): self.conv_layers.append(layer) for layer in self.discriminator.layers: if isinstance(layer, tf.keras.layers.Conv2D) or isinstance( layer, tf.keras.layers.DepthwiseConv2D): self.conv_layers.append(layer)
def StartEncoder(self, context): return encoder.Encoder( context, encoder.OptionValueSet( self.option_set, '--rc-lookahead 0 --ref 2 --vbv-init 0.8 --preset veryslow', formatter=self.option_formatter))
def __init__(self, name='vp8'): super(Vp8Codec, self).__init__(name) self.extension = 'webm' self.options = [ encoder.Option('overshoot-pct', ['0', '15', '30', '45']), encoder.Option('undershoot-pct', ['0', '25', '50', '75', '100']), # CQ mode is not considered for end-usage at the moment. encoder.Option('end-usage', ['cbr', 'vbr']), # End-usage cq doesn't really make sense unless we also set q to something # between min and max. This is being checked. # encoder.Option('end-usage', ['cbr', 'vbr', 'cq']), encoder.Option('end-usage', ['cbr', 'vbr']), encoder.Option('min-q', ['0', '2', '4', '8', '16', '24']), encoder.Option('max-q', ['32', '56', '63']), encoder.Option( 'buf-sz', ['200', '500', '1000', '2000', '4000', '8000', '16000']), encoder.Option( 'buf-initial-sz', ['200', '400', '800', '1000', '2000', '4000', '8000', '16000' ]), encoder.Option('max-intra-rate', ['100', '200', '400', '600', '800', '1200']), encoder.ChoiceOption(['good', 'best', 'rt']), ] self.start_encoder = encoder.Encoder( self, """ --lag-in-frames=0 \ --kf-min-dist=3000 \ --kf-max-dist=3000 --cpu-used=0 --static-thresh=0 \ --token-parts=1 --drop-frame=0 --end-usage=cbr --min-q=2 --max-q=56 \ --undershoot-pct=100 --overshoot-pct=15 --buf-sz=1000 \ --buf-initial-sz=800 --buf-optimal-sz=1000 --max-intra-rate=1200 \ --resize-allowed=0 --drop-frame=0 --passes=1 --good --noise-sensitivity=0 """ )
def motor_2 (): ''' Define a task to run both motors in order. Configure the motor using the motor_driver.py file. Print the data to the serial port and plot the data in pc_main_lab3''' # call class MotorDriver() motor_2 = motor_driver.MotorDriver('C1', 20000) # call class Controller() ctr_2 = controller.Controller(0.01, 16000, 30) ## define the encoder that is used to read the motor position encC = enc.Encoder('C') # define x to be True to collect half of the data points an allow more time for printing data x = True while True: # initialize the motor controller using class Controller() motor_2.set_duty_cycle(ctr_2.outputValue(encC.read())) # create a string of data to be plotted data = '2, ' + str(encC.read()) + ', ' + str(utime.ticks_ms()) + '\r\n' # print data every other pass through the while loop if x == True: print_task.put (data) x = not x # yield to another task and resume at this line yield (0)
def motor_1 (): ''' Define a task to run both motors in order. Configure the motor using the motor_driver.py file. Print the data to the serial port and plot the data in pc_main_lab3''' # call class MotorDriver() motor = motor_driver.MotorDriver('A10', 20000) # call class Controller() ctr = controller.Controller(0.01, 16000, 30) ## define the encoder that is used to read the motor position encB = enc.Encoder('B') # run the proportional contorller on the motor and feed the data into the shares and queues using put() x = True while True: # set the motor duty cycle using class Controller() motor.set_duty_cycle(ctr.outputValue(encB.read())) # create a string of data to be plotted data = '1, ' + str(encB.read()) + ', ' + str(utime.ticks_ms()) + '\r\n' # print data every other pass through the while loop if x == True: print_task.put (data) # yield to another task and resume at this line yield (0)
def write_problems_with_sdrs(input_folder, output_folder): """ Read problems from the input folder Encode all the windows using an auto-encoder Write the problems with the added encoded windows to the output_folder """ import encoder # get all the windows from the problems in the folder # in order to train the encoder problems = [] for sub_folder in os.listdir(input_folder): f = os.path.join(input_folder, sub_folder) problems += get_problems(f) input_windows = get_windows(problems) (num_windows, height, width) = input_windows.shape # initialize and train the encoder enc = encoder.Encoder(height * width) errs = enc.train(input_windows) problems = [] # get all the problems from the folder in order to create the SDRs for sub_folder in os.listdir(input_folder): problems = get_problems(os.path.join(input_folder, sub_folder)) for i in range(len(problems)): # write the original form of the problem in the new file out_file = os.path.join(output_folder, sub_folder, problems[i]['Attributes']['title'] + '.txt') write_problem(problems[i], out_file) # create and write to the new file SDRs for all the windows in the problem with open(out_file, 'a') as f: f.write('== SDRs ==\n') # for every window in the problem for win in np.concatenate((problems[i]['Input'], problems[i]['Output'])): # create SDR by encoding the window and then converting the list of float # values to 1s and 0s encoded = enc.encode(win.reshape((1, height, width, 1))) m = np.mean(encoded) encoded = (encoded >= m).astype(int) # write the SDR to the file size = int(len(encoded[0]) ** 0.5) for line in encoded.reshape((size, size)): f.write(''.join([str(x) for x in line]) + '\n') f.write('\n') print('Sparsity ', float(np.sum(encoded) * 100) / encoded.shape[1]) # decode the SDR decoded = enc.decode(encoded) m = np.mean(decoded) decoded = (decoded >= m).astype(int) # print the similarity between the input and the output print(np.sum(win == decoded.reshape(win.shape)) * 100.0 / (height * width)) print("---------------")
def getEncodedData(self, articleKeys=None): enc = encoder.Encoder() # TODO(jimhug): Only return initially visible section in first reply. maxSections = min(MAX_SECTIONS, len(self.sections)) enc.writeInt(maxSections) for section in db.get(self.sections[:maxSections]): section.encode(enc, articleKeys) return enc.getRaw()
def test_Changevalue(self): config = encoder.OptionValueSet( encoder.OptionSet(encoder.Option('foo', ['foo', 'bar'])), '--foo=foo') context = encoder.Context(DummyCodec()) my_encoder = encoder.Encoder(context, config) next_encoder = my_encoder.ChangeValue('foo', 'bar') self.assertEquals(next_encoder.parameters, '--foo=bar')
def test_ParametersCanChangeMayReturnTrue(self): context = encoder.Context(DummyCodec()) my_encoder = encoder.Encoder( context, encoder.OptionValueSet( encoder.OptionSet(encoder.Option('key', ['value1', 'value2'])), '--parameters')) self.assertTrue(my_encoder.ParametersCanChange())
def main(): c = communication.Communication("/dev/ttyUSB0") iv = perform_IV_exchange(c) Cipher = cipher.Cipher(iv) Encoder = encoder.Encoder(Cipher) while True: communicate(c, Encoder, Cipher)
def encode_trace(self, data, additional_columns=None, prefix_length=1): data_encoder = encoder.Encoder() events = data_encoder.get_events(data).tolist() cases = data_encoder.get_cases(data) init_prefix = prefix_length if prefix_length == 0: init_prefix = 1 prefix_length = max(data['event_nr']) iteration_max = prefix_length columns = [] columns.append("case_id") columns.append("event_nr") columns.append("remaining_time") columns.append("elapsed_time") for i in range(1, prefix_length + 1): columns.append("prefix_" + str(i)) for additional_column in additional_columns: columns.append(additional_column + "_" + str(i)) encoded_data = [] for case in cases: df = data[data['case_id'] == case] for event_length in range(init_prefix, prefix_length + 1): if len(df) < event_length: continue case_data = [] case_data.append(case) case_data.append(event_length) remaining_time = data_encoder.calculate_remaining_time( df, event_length) case_data.append(remaining_time) elapsed_time = data_encoder.calculate_elapsed_time( df, event_length) case_data.append(elapsed_time) case_events = df[ df['event_nr'] <= event_length]['activity_name'].tolist() for index in range(0, iteration_max): if index < len(case_events): case_data.append(case_events[index]) for additional_column in additional_columns: event_attribute = df[df['event_nr'] == ( index + 1)][additional_column].apply(str).item() case_data.append(event_attribute) else: case_data.append(0) for additional_column in additional_columns: case_data.append(0) encoded_data.append(case_data) df = pd.DataFrame(columns=columns, data=encoded_data) return df
def motor2_fun(): # A motor object pinENA = pyb.Pin(pyb.Pin.board.PC1, pyb.Pin.OUT_PP) pinIN1A = pyb.Pin(pyb.Pin.board.PA0, pyb.Pin.OUT_PP) pinIN2A = pyb.Pin(pyb.Pin.board.PA1, pyb.Pin.OUT_PP) mot = motor.MotorDriver([pinIN1A, pinIN2A, pinENA], 5, [1, 2]) # An encoder object enc = encoder.Encoder([pyb.Pin.board.PC6, pyb.Pin.board.PC7], 8, [1, 2]) # A controller object cont = controller.Controller(K_p=0.10) setup = True state = 0 while (True): # Stopped if state == 0: if pos_ctrl2.get(): state = 1 elif step_rsp2.get(): state = 2 elif get_data2.get(): state = 3 else: mot.set_duty_cycle(0) # Position Control elif state == 1: if pos_ctrl2.get(): cont.set_setpoint(setpoint1.get()) mot.set_duty_cycle(cont.run(enc.read())) else: state = 0 # Step Response elif state == 2: if setup: cont.clear_data() cont.set_setpoint(setpoint1.get()) enc.zero() stop = utime.ticks_add(utime.ticks_ms(), 1000) setup = False elif utime.ticks_diff(stop, utime.ticks_ms()) > 0: mot.set_duty_cycle(cont.run(enc.read())) else: step_rsp2.put(False) setup = True state = 0 # Get Data elif state == 3: for datum in cont.get_data(): print(str(datum[0]) + ', ' + str(datum[1])) state = 0 yield (state)