class Processor: """ This represents the processor itself. Most work and operations will be outsourced to other objects referenced by the processor. The processor holds the values of valP, valE, valA, valB, valC, and rA, rB. """ def __init__(self, mem_size: int = 10000): """ The following is an abstraction for a bank of values such as valA, which will be used during each cycle. It's set up as an object to avoid circular import. """ self.ValBank = ValBank() """ The following are functional units like memory, registers, or flags """ self.Memory = Memory(mem_size) self.RegisterBank = RegisterBank() self.ZF = CCFlag("ZF") # zero flag self.OF = CCFlag("OF") # overflow flag self.SF = CCFlag("SF") # sign flag self.ErrorFlag = StateFlag("Error Flag", error_lib) self.StateFlag = StateFlag("State Flag", state_lib) self.ALU = ALU(self.ValBank, self.StateFlag, self.ErrorFlag, self.SF, self.OF, self.ZF) """ The following are functional abstractions of operations that the processor performs """ self.Fetcher = Fetcher(self.ValBank, self.RegisterBank, self.Memory, self.StateFlag, self.ErrorFlag) self.Decoder = Decoder(self.ValBank, self.RegisterBank, self.Memory) self.Executor = Executor(self.ValBank, self.ALU, self.OF, self.ZF, self.SF) self.Memorizer = Memorizer(self.ValBank, self.Memory) self.RegWriter = RegWriter(self.RegisterBank, self.ValBank) self.PCUpdater = PCUpdater(self.RegisterBank, self.ValBank) def run(self): """ This is the only necessary public method for the processor. Currently the way to operate this is by manually loading values into the memory using the place_instruction method, then calling the 'run' method for the processor. Afterwards calling print on the memory object will reveal the finish state of the processor. """ while self.StateFlag.State == 0: self.Fetcher.fetch() self.Decoder.decode() self.Executor.execute() self.Memorizer.memory_write() self.RegWriter.write_back() self.PCUpdater.update_pc()
def test_folder(folder): """ Test all images inside a folder Use Zbar library to test the image. Args: folder: The path of your target folder Returns: (succ, fail, rate): The number of success, failure, and the "success rate" = (succ) / (succ + fail) """ def is_img(path): # Add more extensions if you need img_ext = ['jpg', 'png', 'bmp'] return path.split('.')[-1] in img_ext dc = Decoder() for root, folders, files in os.walk(folder): img_list = [os.path.join(root, file) for file in files if is_img(file)] succ = fail = 0 for img in img_list: pil = Image.open(img).convert('L') code = dc.decode(pil) if len(code) > 0: succ += 1 else: fail += 1 rate = float(succ) / (succ + fail) return (succ, fail, rate)
def aptidao(self, cromossomo): decodificacao = Decoder(self.custos, sqrt(self.TAM_CROM)) ''' Transforma as chaves aleatorias em binarios, verifica as restrições e retorna o custo a ser minimizado ''' Z = decodificacao.decode(cromossomo) return Z
def improved_process(P, codes, channels): improved_codes = [] n = P.shape[1] // 3 for c in range(len(codes) // n): improved_codes.append( np.concatenate(([codes[n * c + k] for k in range(n)]))) # Encoding improved_encoder = Encoder(P) encodes = [improved_encoder.encode(code) for code in improved_codes] # Channeling outputs = [None] * len(channels) for c in range(len(channels)): outputs[c] = np.array( [channels[c].add_noise(code) for code in encodes]) # Decoding improved_decoder = Decoder(P, n + 1) for c in range(len(channels)): outputs[c] = np.array( [improved_decoder.decode(code) for code in outputs[c]]) return outputs
def decodeRaw(inputStream, outputStream, intervalLength, options): Coder.checkInterval(intervalLength) decoder = Decoder(inputStream, outputStream, options) amountProcessed = 0 while not decoder.decode(intervalLength): amountProcessed += intervalLength
def decode(self, tagnumber): decoder = Decoder(self._string, self._probrange) ### creating a Decoder return decoder.decode( tagnumber) ### returning the string, given the binary Tagnumber
else: if s.decode() == '#': length_error = int(length_error, 16) break else: length_error += s.decode() error = test.read(length_error) length_read = tmp.write(lzma.decompress(test.read(length_base))) tmp.write(lzma.decompress(test.read())) os.remove(base_path + "/tmp0") input("Modifica il file edit0 in {0}".format(base_path)) with open(base_path + "/edit0", "rb") as tmp, open(base_path + "/tmp0", "wb") as test: test.write(hex(length_base).encode()) test.write("#".encode()) test.write(hex(length_error).encode()) test.write("#".encode()) test.write(error) test.write(lzma.compress(tmp.read(length_read))) test.write(lzma.compress(tmp.read())) os.remove(base_path + "/edit0") print("Ricostruzione file") decoder.decode() print("Ricostruzione completata.")
class Serialcom(threading.Thread): def __init__(self): threading.Thread.__init__(self) self.shutdown_flag = threading.Event() self.motor = Motorcontroller() self.buzzer = Buzzer() self.xbee = Xbee() self.decoder = Decoder() self.servo1 = 96 self.servo2 = 75 self.joycalc = Joystick() self.motor.setServo1(self.servo1) self.motor.setServo2(self.servo2) self.lastSavedTime = 0 def run(self): print('Thread #%s started' % self.ident) self.motor.timeout(1) while not self.shutdown_flag.is_set(): rcvdata = self.xbee.read() self.decoder.decode(rcvdata) self.motor.recalCommand() currenttime = time.time() if currenttime - self.lastSavedTime > 1.0: self.lastSavedTime = time.time() self.xbee.sendBat(self.decoder.getRfrating()) if self.decoder.getStatus() and self.decoder.checkCRC(): if self.decoder.getJoyStickPB1() == 0: self.motor.EmergyStop() self.buzzer.beep(300) elif self.decoder.getJoystickM1() > 248 and self.decoder.getJoystickM2() > 248: self.joycalc.calculateReg(255) self.motor.Motor1MC2(255 - self.joycalc.cor1) self.motor.Motor2MC2(255 - self.joycalc.cor2) elif (abs(self.decoder.getJoystickM1() - self.decoder.getJoystickM2()) <= 3) and (self.decoder.getJoystickM1() > 50): self.joycalc.calculateReg(self.decoder.getJoystickM1()) self.motor.Motor1MC2(self.decoder.getJoystickM1() - self.joycalc.cor1) self.motor.Motor2MC2(self.decoder.getJoystickM1() - self.joycalc.cor2) #print "drive forward without full speed" else: self.motor.Motor1MC2(self.decoder.getJoystickM1()) self.motor.Motor2MC2(self.decoder.getJoystickM2()) #print "other speeds" if self.decoder.getJoystickPB2() == 0: self.servo1 = 96 self.motor.setServo1(self.servo1) self.buzzer.beep(300) elif self.decoder.getJoystickVRX2() > 1000: if(self.servo1 > 0): self.servo1 = self.servo1 - 1 self.motor.setServo1(self.servo1) elif self.decoder.getJoystickVRX2() < 24: if(self.servo1 < 180): self.servo1 = self.servo1 + 1 self.motor.setServo1(self.servo1) if self.decoder.getJoystickPB2() == 0: self.servo2 = 75 self.motor.setServo2(self.servo2) elif self.decoder.joystick_VRY2 > 1000: if(self.servo2 > 0): self.servo2 = self.servo2 - 1 self.motor.setServo2(self.servo2) elif self.decoder.getJoystickVRY2() < 24: if(self.servo2 < 180): self.servo2 = self.servo2 + 1 self.motor.setServo2(self.servo2) time.sleep(0.001) # ... Clean shutdown code here ... self.xbee.close() self.motor.close() print('Thread #%s stopped' % self.ident)
if len(sys.argv) < 2: usage() sys.exit(1) # Defaults. table = sys.argv[1] ordering = "monotonic" stack_size = 40 perc = 0.001 if len(sys.argv) >= 3: ordering = sys.argv[2] if len(sys.argv) >= 4: stack_size = int(sys.argv[3]) if len(sys.argv) == 5: perc = float(sys.argv[4]) s = "das ist ein kleines haus" d = Decoder(s, table, ordering, stack_size, perc) d.decode() for id, s in enumerate(d.stacks): print "Stack_%d = %d | " % (id, len(s)), print "" for pos, hypo in enumerate(d.stacks[-1].nlargest()): print "%d\t%s\t\t%f" % (pos, hypo.output, hypo.score)
def main(_): """ Run main function """ #___________________________________________Layer info_____________________________________________________ n = FLAGS.hidden_n Encoder_infos = { "outdim":[n,n,2*n,2*n,2*n,3*n,3*n, 3*n, 3*n],\ "kernel":[ \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ ], \ "stride":[ \ [1, 1], \ [1, 1], \ [1, 1], \ [2, 2], \ [1, 1], \ [1, 1], \ [2, 2], \ [1, 1], \ [1, 1], \ ], \ } Decoder_infos = { "outdim":[n,n,n,n,n,n,3], \ "kernel":[ \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ ], \ "stride":[ \ [1, 1], \ [1, 1], \ [1, 1], \ [1, 1], \ [1, 1], \ [1, 1], \ [1, 1], \ ], \ } Generator_infos = { "outdim":[n,n,n,n,n,n,3], \ "kernel":[ \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ ], \ "stride":[ \ [1, 1], \ [1, 1], \ [1, 1], \ [1, 1], \ [1, 1], \ [1, 1], \ [1, 1], \ ], \ } """ Prepare Image Loader """ root = "./CelebA/images" batch_size = FLAGS.bn scale_size = [FLAGS.scale_h,FLAGS.scale_w] data_format = "NHWC" loader = Image_Loader(root, batch_size, scale_size, data_format, file_type="jpg") """ Make Saving Directories """ os.makedirs("./Check_Point", exist_ok=True) os.makedirs("./logs", exist_ok=True) # make logs directories to save summaries os.makedirs("./Real_Images", exist_ok=True) os.makedirs("./Generated_Images", exist_ok=True) os.makedirs("./Decoded_Generated_Images", exist_ok=True) #---------------------------------------------------------------------------------------------------- #____________________________________Model composition________________________________________ k = tf.Variable(0.0, name = "k_t", trainable = False, dtype = tf.float32) #init value of k_t = 0 batch = loader.queue # Get image batch tensor image = norm_img(batch) # Normalize Imgae z_G = generate_z() # Sample embedding vector batch from uniform distribution z_D = generate_z() # Sample embedding vector batch from uniform distribution E = Encoder("Encoder", Encoder_infos) D = Decoder("Decoder", Decoder_infos) G = Decoder("Generator", Generator_infos) #Generator generated_image = G.decode(z_G) generated_image_for_disc = G.decode(z_D, reuse = True) #Discriminator (Auto-Encoder) #image <--AutoEncoder--> reconstructed_image_real embedding_vector_real = E.encode(image) reconstructed_image_real = D.decode(embedding_vector_real) #generated_image_for_disc <--AutoEncoder--> reconstructed_image_fake embedding_vector_fake_for_disc = E.encode(generated_image_for_disc, reuse=True) reconstructed_image_fake_for_disc = D.decode(embedding_vector_fake_for_disc, reuse=True) #generated_image <--AutoEncoder--> reconstructed_image_fake embedding_vector_fake = E.encode(generated_image, reuse=True) reconstructed_image_fake = D.decode(embedding_vector_fake, reuse=True) #----------------------------------------------------------------------------------------------- #_________________________________Loss & Summary_______________________________________________ """ Define Loss """ real_image_loss = get_loss(image, reconstructed_image_real) generator_loss_for_disc = get_loss(generated_image_for_disc, reconstructed_image_fake_for_disc) discriminator_loss = real_image_loss - tf.multiply(k, generator_loss_for_disc) generator_loss = get_loss(generated_image, reconstructed_image_fake) global_measure = real_image_loss + tf.abs(tf.multiply(FLAGS.gamma,real_image_loss) - generator_loss) """ Summaries """ tf.summary.scalar('Real image loss', real_image_loss) tf.summary.scalar('Generator loss for discriminator', generator_loss_for_disc) tf.summary.scalar('Discriminator loss', discriminator_loss) tf.summary.scalar('Generator loss', generator_loss) tf.summary.scalar('Global_Measure', global_measure) tf.summary.scalar('k_t', k) merged_summary = tf.summary.merge_all() # merege summaries, no more summaries under this line #----------------------------------------------------------------------------------------------- #_____________________________________________Train_______________________________________________ discriminator_parameters = [] generator_parameters = [] for v in tf.trainable_variables(): if 'Encoder' in v.name: discriminator_parameters.append(v) print("Discriminator parameter : ", v.name) elif 'Decoder' in v.name: discriminator_parameters.append(v) print("Discriminator parameter : ", v.name) elif 'Generator' in v.name: generator_parameters.append(v) print("Generator parameter : ", v.name) else: print("None of Generator and Discriminator parameter : ", v.name) optimizer_D = tf.train.AdamOptimizer(FLAGS.lr,beta1=FLAGS.B1,beta2=FLAGS.B2).minimize(discriminator_loss,var_list=discriminator_parameters) optimizer_G = tf.train.AdamOptimizer(FLAGS.lr,beta1=FLAGS.B1,beta2=FLAGS.B2).minimize(generator_loss,var_list=generator_parameters) with tf.control_dependencies([optimizer_D, optimizer_G]): k_update = tf.assign(k, tf.clip_by_value(k + FLAGS.lamb * (FLAGS.gamma*real_image_loss - generator_loss), 0, 1)) #update k_t init = tf.global_variables_initializer() NUM_THREADS=2 config=tf.ConfigProto(inter_op_parallelism_threads=NUM_THREADS,\ intra_op_parallelism_threads=NUM_THREADS,\ allow_soft_placement=True,\ device_count = {'CPU': 1},\ ) # config.gpu_options.per_process_gpu_memory_fraction = FLAGS.gpu_portion with tf.Session(config=config) as sess: sess.run(init) # Initialize Variables coord = tf.train.Coordinator() # Set Coordinator to Manage Queue Runners threads = tf.train.start_queue_runners(sess, coord=coord) # Set Threads writer = tf.summary.FileWriter('./logs', sess.graph) # add the graph to the file './logs' #_______________________________Restore____________________________________ saver = tf.train.Saver(max_to_keep=1000) ckpt = tf.train.get_checkpoint_state(checkpoint_dir="./Check_Point") # try : # if ckpt and ckpt.model_checkpoint_path: # print("check point path : ", ckpt.model_checkpoint_path) # saver.restore(sess, ckpt.model_checkpoint_path) # print('Restored!') # except AttributeError: # print("No checkpoint") Real_Images = sess.run(denorm_img(image)) save_image(Real_Images, '{}.png'.format("./Real_Images/Real_Image")) #--------------------------------------------------------------------------- for t in range(FLAGS.iteration): # Mini-Batch Iteration Loop if coord.should_stop(): break _, _, l_D, l_G, l_Global, k_t = sess.run([\ optimizer_D,\ optimizer_G,\ discriminator_loss,\ generator_loss,\ global_measure,\ k_update,\ ]) print( " Step : {}".format(t), " Global measure of convergence : {}".format(l_Global), " Generator Loss : {}".format(l_G), " Discriminator Loss : {}".format(l_D), " k_{} : {}".format(t,k_t) ) #________________________________Save____________________________________ if t % 200 == 0: summary = sess.run(merged_summary) writer.add_summary(summary, t) Generated_Images, Decoded_Generated_Images = sess.run([denorm_img(generated_image), denorm_img(reconstructed_image_fake)]) save_image(Generated_Images, '{}/{}{}.png'.format("./Generated_Images", "Generated", t)) save_image(Decoded_Generated_Images, '{}/{}{}.png'.format("./Decoded_Generated_Images", "AutoEncoded", t)) print("-------------------Image saved-------------------") if t % 500 == 0: print("Save model {}th".format(t)) saver.save(sess, "./Check_Point/model.ckpt", global_step = t) #-------------------------------------------------------------------- writer.close() coord.request_stop() coord.join(threads)
socket = ServerUDP.initServerSocket() print "Running and waiting..." while True: try: encoded_text = ServerUDP.readSocket(socket) print "Data received!" file = open(Util.ENCODED_FILE, "w") file.write(encoded_text) file.close() print "Decoding data..." Decoder.decode() print "File successfully decoded!" print "\nRunning and waiting..." except Exception as e: print e print("Error!") # finally: # socket.close() # os._exit(0)
decoder = Decoder(P, 3) else: encoder = EncoderHamming() decoder = DecoderHamming() channel = Channel(0.3) # Receiving code code = np.matrix([[int(x) for x in input()]]) # Printing code print("Code received: ") print(code) input() # Encoding channel print("Encoding: ") encoded = encoder.encode(code) print(encoded) input() # Passing through channel print("Passing through channel: ") through_channel = np.array(channel.add_noise(np.array(encoded)[0])) print(through_channel) input() # Decoding code print("Decoding: ") decoded = decoder.decode(through_channel) print(decoded)