def main(argv=None): _init_output_directories() # step 1: create the negatives and positives directory if FLAGS.do_full_prepare: print('Loading labels from %s' % FLAGS.label_file) lr = LabelRecord() label_records = lr.load(FLAGS.label_file) all_bounding_boxes = Box.get_all_bounding_boxes(label_records) counter = 0 # fill examples, originals, negatives, and positives directories print('Processing images...') for (_, v) in label_records.items(): Progress.show_progress(counter) image = CXRImage.get_image_data(v.filename, FLAGS.image_path) basefilename = os.path.splitext(v.filename)[0] if v.hasBoundingBox: for i in range(0, v.boundingBoxes.shape[0]): box = v.boundingBoxes[i, :] #CXRImage.extract_center_and_write(image,box,1024,1024,FLAGS.positives_dir) CXRImage.extract_anisotropic_scale_and_write( image, box, FLAGS.image_size, FLAGS.image_size, FLAGS.positives_dir) CXRImage.write_image(image, FLAGS.examples_dir, "%s.jpg" % basefilename) else: i = np.int32( np.random.randint(0, all_bounding_boxes.shape[0] - 1)) box = all_bounding_boxes[i, :] CXRImage.extract_anisotropic_scale_and_write( image, box, FLAGS.image_size, FLAGS.image_size, FLAGS.negatives_dir) #CXRImage.extract_center_and_write(image,box,1024,1024,FLAGS.negatives_dir) if (v.hasBoundingBox): img = (CXRImage.xlate_image(image) * 255).astype(np.uint8) CXRImage.write_image_with_bounding_boxes( img, FLAGS.originals_dir, "%s.jpg" % basefilename, v.boundingBoxes) counter = counter + 1 # step 2: create the pre-training features by combining negatives and positives into pre_train.tfrecord print('\nCreating pre-train file...') rec = Record(1024, 1024, 1 if FLAGS.grayscale else 3) total = rec.create_pre_train_file(FLAGS.positives_dir, FLAGS.negatives_dir, FLAGS.pre_train_file) print('\n%d files combined in %s' % (total, FLAGS.pre_train_file))
def main(argv=None): if FLAGS.grayscale: print('Grayscale not currently supported!') return _init_output_directories() batch_size = 100 rec = Record(1024, 1024, 1 if FLAGS.grayscale else 3) with tf.Graph().as_default(): image, label = rec.read_pre_train_record([FLAGS.pre_train_file]) images, labels = tf.train.shuffle_batch([image, label], batch_size=batch_size, capacity=300, num_threads=10, min_after_dequeue=10) init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) with tf.Session() as sess: sess.run(init_op) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) image_batch, label_batch = sess.run([images, labels]) for ndx in range(batch_size): img = image_batch[ndx] lbl = label_batch[ndx] print('Getting image for label %d' % lbl) img = img.astype(np.uint8) img = np.stack([img] * 3, axis=2) print(img.shape) new_image = Image.fromarray(img) if lbl == 1: path = FLAGS.positives else: path = FLAGS.negatives new_image.save(os.path.join(path, '%s.jpg' % str(uuid.uuid4()))) coord.request_stop() coord.join(threads) sess.close()
def __init__(self, args): self.args = args self.model = None self.optimizer = None self.scheduler = None self.epoch = 0 # s = State(args) set_seed(self.args.seed, self.args.cudnn_behavoir) self.log = Log(self.args.log_path) self.writer = Tensorboard(self.args.tensorboard_path) self.stati = Statistic(self.args.expernameid, self.args.experid_path, self.args.root_path) self.stati.add('hparam', self.args.dict()) # s.writer.add_hparams(hparam_dict=s.args.dict(), metric_dict={}) self.record = Record()
def work(self, COORD, render=False): """Main function of the Workers. This runs the environment and the experience is used to update the main Actor Critic Network. """ #Allowing access to the global variables. while not COORD.should_stop() and self.sess.run( self.global_step) < self.settings["MaxEpisodes"]: self.sess.run(self.global_step_next) logging = interval_flag(self.sess.run(self.global_step), self.settings["LogFreq"], 'log') saving = interval_flag(self.sess.run(self.global_step), self.settings["SaveFreq"], 'save') s0 = self.env.reset() for j in range(self.settings["MaxEpisodeSteps"] + 1): a, networkData = self.net.GetAction(state=s0) s1, r, done, _ = self.env.step(a) if render: self.env.render() self.net.AddToTrajectory([s0, a, r, s1, done] + networkData) s0 = s1 if done or j == self.settings[ "MaxEpisodeSteps"]: # update global and assign to local net self.net.Update(self.settings["NetworkHPs"], self.sess.run(self.global_step)) break self.progbar.update(self.sess.run(self.global_step)) if saving: self.saver.save(self.sess, self.MODEL_PATH + '/ctf_policy.ckpt', global_step=self.sess.run(self.global_step)) if logging: loggingDict = self.env.getLogging() dict = self.net.GetStatistics() loggingDict.update(dict) Record(loggingDict, self.writer, self.sess.run(self.global_step))
def work(self, COORD, render=False): """Main function of the Workers. This runs the environment and the experience is used to update the main Actor Critic Network. """ #Allowing access to the global variables. while not COORD.should_stop() and self.sess.run( self.global_step) < self.settings["MaxEpisodes"]: logging = interval_flag(self.sess.run(self.global_step), self.settings["LogFreq"], 'logNet') self.net.Update(self.settings["NetworkHPs"], self.sess.run(self.global_step)) if logging: loggingDict = self.net.GetStatistics() Record(loggingDict, self.writer, self.sess.run(self.global_step))
def work(self, COORD, render=False): """Main function of the Workers. This runs the environment and the experience is used to update the main Actor Critic Network. """ #Allowing access to the global variables. while not COORD.should_stop() and self.sess.run( self.global_step) < self.settings["MaxEpisodes"]: self.sess.run(self.global_step_next) logging = interval_flag(self.sess.run(self.global_step), self.settings["LogFreq"], 'log') saving = interval_flag(self.sess.run(self.global_step), self.settings["SaveFreq"], 'save') #Initializing environment and storage variables: s0 = self.env.reset() a_past = [0] r_i_past = [0.0] r_e_past = [0.0] for j in range(self.settings["MaxEpisodeSteps"] + 1): a, networkData = self.net.GetAction(state=s0, episode=self.sess.run( self.global_step), step=j, a_past=a_past, r_i_past=r_i_past, r_e_past=r_e_past) #networkData is expected to be [betaVal,betaOH] s1, r, done, _ = self.env.step(a) if render: self.env.render() #Calculating Intrinsic Reward of the state: r_intrinsic = self.net.GetIntrinsicReward(s0, s1) r_total = r + networkData[0] * r_intrinsic #Adding to the trajectory self.net.AddToTrajectory( [s0, a, r_total, s1, done, a_past, r_i_past, r_e_past] + networkData) #Updating the storage variables. s0 = s1 a_past = a r_i_past = [r_intrinsic] r_e_past = r #Pushing entire trajectory to the buffer if done or j == self.settings["MaxEpisodeSteps"]: self.net.PushToBuffer() break self.progbar.update(self.sess.run(self.global_step)) if logging: loggingDict = self.env.getLogging() Record(loggingDict, self.writer, self.sess.run(self.global_step)) if saving: self.saver.save(self.sess, self.MODEL_PATH + '/ctf_policy.ckpt', global_step=self.sess.run(self.global_step))
s0 = env.reset() for j in range(settings["MAX_EP_STEPS"]+1): updating = interval_flag(j, settings['UPDATE_GLOBAL_ITER'], 'update') a_hier, networkData = net.GetAction(state=s0,episode=sess.run(global_step),step=j) a = UseSubpolicy(s0,a_hier) s1,r,done,_ = env.step(action=a) net.AddToTrajectory([s0,a_hier,r,s1,done]+networkData) s0 = s1 if updating: # update global and assign to local net net.Update(settings["NetworkHPs"],sess.run(global_step)) if done or j == settings["MAX_EP_STEPS"]: net.Update(settings["NetworkHPs"],sess.run(global_step)) break loggingDict = env.getLogging() if logging: dict = net.GetStatistics() loggingDict.update(dict) Record(loggingDict, writer, sess.run(global_step)) for func in loggingFunctions: func(sess.run(global_step)) if saving: saver.save(sess, MODEL_PATH_+'/ctf_policy.ckpt', global_step=sess.run(global_step)) progbar.update(i) # print(j,r)
def pre_train(self): if not self.init_pre_train_complete: print('init_pre_train() not called!') return print(' ') print('Pre-training with the following parameters:') print('\tState directory: %s' % self.pre_train_dir) print('\tTrainable variables are 16 bit? : %s' % ('Yes' if self.use_fp16 else 'No')) print('\tBatch size: %d' % self.pre_train_batch_size) print('\tTraining images are: [%d,%d,%d]' % (self.pre_train_height, self.pre_train_width, 1)) print('\tLearning rate: %.3f' % self.learning_rate) print('\tRMSProp Optimizer decay: %.3f' % self.optimizer_decay) print('\tRMSProp Optimizer momentum: %.3f' % self.optimizer_momentum) print(' ') with tf.Graph().as_default(): global_step = tf.train.get_or_create_global_step() rec = Record(self.pre_train_height, self.pre_train_width, 1, self.use_fp16) with tf.device('/cpu:0'): image, label = rec.read_pre_train_record([self.pre_train_file]) images, labels = tf.train.batch( [image, label], batch_size=self.pre_train_batch_size, num_threads=self.pre_train_number_of_threads) _, pretrain = self.feature_network(images) loss = self._pretrain_loss(pretrain, labels) pretrain_op = self._get_pretrain_op(loss, global_step) batch_size = self.pre_train_batch_size logfreq = self.log_frequency #beholder_hook = BeholderHook(self.pre_train_dir) class _LoggerHook(tf.train.SessionRunHook): def begin(self): self.pre_train_step = -1 self.start_time = time.time() def before_run(self, run_context): self.pre_train_step += 1 return tf.train.SessionRunArgs(loss) def after_run(self, run_context, run_values): if self.pre_train_step % logfreq == 0: current_time = time.time() duration = current_time - self.start_time self.start_time = current_time loss_value = run_values.results examples_per_sec = logfreq * batch_size / duration sec_per_batch = float(duration / logfreq) format_str = ( '%s: step %d, loss = %.3f (%.1f examples/sec; %.3f sec/batch)' ) print(format_str % (datetime.now(), self.pre_train_step, loss_value, examples_per_sec, sec_per_batch)) with tf.train.MonitoredTrainingSession( checkpoint_dir=self.pre_train_dir, hooks=[ tf.train.StopAtStepHook( last_step=self.pre_train_max_steps), tf.train.NanTensorHook(loss), _LoggerHook() ], config=tf.ConfigProto( log_device_placement=False)) as mon_sess: while not mon_sess.should_stop(): mon_sess.run([pretrain_op])