def swap_faces(image_a_path, image_b_path): image_a, image_b = load_images([ os.path.join(IMAGES_FOLDER, 'trump', image_a_path), os.path.join(IMAGES_FOLDER, 'cage', image_b_path)] ) / 255.0 image_a += images_B_mean - images_A_mean image_b += images_A_mean - images_B_mean # Preprocess loaded images image_a = cv2.resize(image_a, (64, 64)) image_b = cv2.resize(image_b, (64, 64)) image_a = toTensor(image_a).to(device).float() image_b = toTensor(image_b).to(device).float() # Forward with opposite encoders result_a = var_to_np(model(image_a, 'B')) result_b = var_to_np(model(image_b, 'A')) result_a = np.moveaxis(np.squeeze(result_a), 0, 2) result_b = np.moveaxis(np.squeeze(result_b), 0, 2) result_a = np.clip(result_a * 255, 0, 255).astype('uint8') result_b = np.clip(result_b * 255, 0, 255).astype('uint8') image_a_filename = os.path.splitext(image_a_path)[0] image_b_filename = os.path.splitext(image_b_path)[0] result_a_filename = f'{image_a_filename}-{image_b_filename}.jpg' result_b_filename = f'{image_b_filename}-{image_a_filename}.jpg' cv2.imwrite(os.path.join(SWAPS_FOLDER, result_a_filename), result_a) cv2.imwrite(os.path.join(SWAPS_FOLDER, result_b_filename), result_b) return result_a_filename, result_b_filename
def read_eval_data(self, filenames): import util input_dir = ng_config.train_data_path data = util.load_images(filenames) data, _ = self.preprocess(data, None, None) return data
def split_imgs(): frame_names = os.listdir(args.frame_dir) frame_indices = list( np.linspace(0, len(frame_names) - 1, num=16, dtype=np.int)) selected_frames = [frame_names[i] for i in frame_indices] RGB_vid, vid = load_images(args.frame_dir, selected_frames) return RGB_vid, vid
def detect_image(model, args): print('Loading input image(s)...') input_size = [int(model.net_info['height']), int(model.net_info['width'])] batch_size = 1 #int(model.net_info['batch']) imlist, imgs = load_images(args.input) print('Input image(s) loaded') print("Loaded {} images".format(len(imgs))) img_batches = create_batches(imgs, batch_size) # load colors and classes colors = pkl.load(open("pallete", "rb")) classes = load_classes("cfg/garb.names") if not osp.exists(args.outdir): os.makedirs(args.outdir) start_time = datetime.now() print('Detecting...') detected_trush = [] for batchi, img_batch in tqdm(enumerate(img_batches)): img_tensors = [cv_image2tensor(img, input_size) for img in img_batch] img_tensors = torch.stack(img_tensors) img_tensors = Variable(img_tensors) if args.cuda: img_tensors = img_tensors.cuda() detections = model(img_tensors, args.cuda).cpu() detections = process_result(detections, args.obj_thresh, args.nms_thresh) detected_trush.append(len(detections)) if len(detections) == 0: continue detections = transform_result(detections, img_batch, input_size) for detection in detections: draw_bbox(img_batch, detection, colors, classes, 0, args.outdir) for i, img in enumerate(img_batch): save_path = osp.join(args.outdir, osp.basename(imlist[batchi * batch_size + i])) cv2.imwrite(save_path, img) print(save_path, 'saved') end_time = datetime.now() print('Detection finished in %s' % (end_time - start_time)) return detected_trush
def detect_image(model, args): print('Loading input image(s)...') input_size = [int(model.net_info['height']), int(model.net_info['width'])] batch_size = int(model.net_info['batch']) imlist, imgs = load_images(args.input) print('Input image(s) loaded') img_batches = create_batches(imgs, batch_size) # load colors and classes colors = pkl.load( open( "/home/autonomous-car/Desktop/Autonomous_car_ros2/src/stereo_yolo3/stereo_yolo3/pallete", "rb")) classes = load_classes( "/home/autonomous-car/Desktop/Autonomous_car_ros2/src/stereo_yolo3/stereo_yolo3/data/coco.names" ) if not osp.exists(args.outdir): os.makedirs(args.outdir) start_time = datetime.now() print('Detecting...') for batchi, img_batch in enumerate(img_batches): img_tensors = [cv_image2tensor(img, input_size) for img in img_batch] img_tensors = torch.stack(img_tensors) img_tensors = Variable(img_tensors) if args.cuda: img_tensors = img_tensors.cuda() detections = model(img_tensors, args.cuda).cpu() detections = process_result(detections, args.obj_thresh, args.nms_thresh) if len(detections) == 0: continue detections = transform_result(detections, img_batch, input_size) for detection in detections: draw_bbox(img_batch, detection, colors, classes) for i, img in enumerate(img_batch): save_path = osp.join( args.outdir, 'dete_' + osp.basename(imlist[batchi * batch_size + i])) cv2.imwrite(save_path, img) end_time = datetime.now() print('Detection finished in %s' % (end_time - start_time)) return
def detect_image(self,path,colors=[(39, 129, 113), (164, 80, 133), (83, 122, 114)],classes=['container_small', 'garbage_bag', 'cardboard']): print('Loading input image(s)...') input_size = [int(self.model.net_info['height']), int(self.model.net_info['width'])] batch_size = int(self.model.net_info['batch']) imlist, imgs = load_images(path) print('Input image(s) loaded') img_batches = create_batches(imgs, batch_size) start_time = datetime.now() print('Detecting...') all_images_attributes = [] for batchi, img_batch in enumerate(img_batches): img_tensors = [cv_image2tensor(img, input_size) for img in img_batch] img_tensors = torch.stack(img_tensors) img_tensors = Variable(img_tensors) if self.cuda: img_tensors = img_tensors.cuda() detections = self.model(img_tensors, self.cuda).cpu() detections = process_result(detections, self.obj_thresh, self.nms_thresh) if len(detections) == 0: continue detections = transform_result(detections, img_batch, input_size) boxes = [] for detection in detections: boxes.append(create_output_json(img_batch, detection, colors, classes)) images_attributes = {} images_attributes['image_meta'] = {'width':input_size[1],'height':input_size[0]} images_attributes['boxes'] = boxes images_attributes['counts'] = {x:0 for x in classes} images_attributes['counts']['total'] = 0 for box in boxes: images_attributes['counts'][box['class']] +=1 images_attributes['counts']['total'] +=1 all_images_attributes.append(images_attributes) end_time = datetime.now() print('Detection finished in %s' % (end_time - start_time)) return all_images_attributes
def test_rotate_image(image_path, item_size=(256, 256), scale=0.2, item_num=6): image_list = util.load_images(image_path) image = util.build_image(image_list, item_size, scale, item_num) pixels = image.reshape(-1, image.shape[2]) unique_elements, counts_elements = np.unique(pixels, axis=0, return_counts=True) counts_elements = np.sort(counts_elements)[::-1] angles = [0, 90, 180, 270] while True: angle = angles[np.random.randint(0, len(angles))] rot_image = np.clip(image * 255, 0, 255).astype(np.uint8) rot_image = util.rotate_image(rot_image, angle) util.draw_text(rot_image, 'angle: %d' % angle, color=(255, 0, 0)) cv2.imshow('image', rot_image) key = cv2.waitKey(1000000) & 0xFF if key == 27: # 'esc break
def detect_image(model, fname, i): print('Loading input image(s)...') input_size = [int(model.net_info['height']), int(model.net_info['width'])] batch_size = int(model.net_info['batch']) imlist, imgs = load_images(fname) print('Input image(s) loaded') img_batches = create_batches(imgs, batch_size) # load colors and classes colors = pkl.load(open("pallete", "rb")) classes = load_classes("darknet/cfg/trash.names") start_time = datetime.now() print('Detecting...') for batchi, img_batch in zip((1, 2), (3, 4)): # img_tensors = [cv_image2tensor(img, input_size) for img in rangeimg_batch] # img_tensors = torch.stack(img_tensors) # img_tensors = Variable(img_tensors) return model.new_detect(batchi, i) detections = model(img_tensors, False).cpu() detections = process_result(detections, 100, 102) if len(detections) == 0: continue detections = transform_result(detections, img_batch, input_size) for detection in detections: draw_bbox(img_batch, detection, colors, classes, 0, args.outdir) for i, img in enumerate(img_batch): save_path = osp.join(args.outdir, osp.basename(imlist[batchi * batch_size + i])) cv2.imwrite(save_path, img) print(save_path, 'saved') end_time = datetime.now() print('Detection finished in %s' % (end_time - start_time)) return
def test_graph(network_def, model_file, test_folder): test_x, test_y = util.load_images(test_folder, letter=None) test_x = np.asarray(test_x, dtype=float) test_y = np.asarray(test_y) xsh = test_x.shape test_x = np.reshape(test_x, (xsh[0], xsh[1], xsh[2], 1)) test_y = np.reshape(test_y, (len(test_y), 1), float) session = tf.Session() # session.run(init) saver = tf.train.import_meta_graph(model_file + ".meta") saver.restore(session, tf.train.latest_checkpoint('./')) graph = tf.get_default_graph() x = graph.get_tensor_by_name("i:0") y = graph.get_tensor_by_name("o:0") op_to_restore = graph.get_operation_by_name("accuracy-check") test_accuracy = session.run(op_to_restore, feed_dict={ x: test_x, y: test_y }) print 'Test accuracy:', test_accuracy session.close()
def test_random_atals(image_path, item_size=(256, 256), atlas_size=(1024, 1024), scale=0.2): grid = int(atlas_size[0] / item_size[0]) image_list = util.load_images(image_path) while True: row_images = [] for i in range(grid): images = [] for j in range(grid): item_num = np.random.randint(1, 20) tmp_scale = scale + np.random.random() * 0.05 img = util.build_image(image_list, item_size, tmp_scale, item_num) img = np.clip(img * 255, 0, 255).astype(np.uint8) util.draw_text(img, '%d' % item_num, color=(255, 255, 255)) images.append(img) row_images.append(cv2.hconcat(images)) image = cv2.vconcat(row_images) util.draw_text(image, 'press [esc] to exit, other key to refresh.', color=(255, 0, 0)) cv2.imshow('image', image) key = cv2.waitKey(1000000) & 0xFF if key == 27: # 'esc break util.draw_text(image, 'building image, please wait...', pos=(10, 35), color=(0, 0, 255)) cv2.imshow('image', image) cv2.waitKey(50)
def test(network_def, model_file, test_folder, letter): layer_def = util.load_layers_definition(network_def) cnn = create_cnn(layer_def) predict = tf.greater(cnn, threshold) correct_pred = tf.equal(predict, tf.equal(output_holder, 1.0)) accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32), name="accuracy-check") session = tf.Session() saver = tf.train.Saver() saver.restore(session, model_file) test_x, test_y = util.load_images(test_folder, letter) test_x = np.asarray(test_x, dtype=float) test_y = np.asarray(test_y) xsh = test_x.shape test_x = np.reshape(test_x, (xsh[0], xsh[1], xsh[2], 1)) test_y = np.reshape(test_y, (len(test_y), 1), float) test_accuracy = session.run(accuracy, feed_dict={ input_holder: test_x, output_holder: test_y }) print 'Test accuracy: ', test_accuracy
parser.add_argument( "--render", "--r", default=False, type=bool, help="if we should render progress", ) args = parser.parse_args() if __name__ == "__main__": swatch_directory = args.swatch_directory image_set_directory = args.train_directory images, _ = load_images(image_set_directory) image_swatches = extract_candidate_swatches(images, args.num_swatches, render_output=args.render) # clear output folder for filename in os.listdir(swatch_directory): os.remove(swatch_directory+filename) for i in range(len(image_swatches)): cv2.imwrite(swatch_directory + 'out_' + str(2*i) + '.jpg', image_swatches[i][0]) cv2.imwrite(swatch_directory + 'out_' + str((2*i) + 1) + '.jpg', image_swatches[i][1]) # with open('inter_data.json', 'w') as json_file: # match_points = match_images(left_image, right_image, True) # json.dump(match_points, json_file) # with open('inter_data.json') as json_file: # match_points = json.load(json_file)
import combined import util import plotter ### UPLOAD_FOLDER = 'uploads' RESULTS = 'results' ALLOWED_EXTENSIONS = set(['txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif']) app = Flask(__name__) app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER app.config['RESULTS'] = RESULTS # zernike_database = util.load_obj('zernike_database_icon_50') orb_database = util.load_obj('orb_database_icon_50') sift_database = util.load_obj('sift_database_icon_50') images = util.load_images("icon_sample") def allowed_file(filename): return '.' in filename and \ filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS @app.route('/', methods=['GET', 'POST']) def upload_file(): if request.method == 'POST': # check if the post request has the file part if 'file' not in request.files: flash('No file part') return redirect(request.url) file = request.files['file']
net = slim.conv2d(net, 256, [1, 1], stride=1) net = slim.max_pool2d(net, [2, 2], scope='pool5') net = slim.flatten(net, scope="flat1") net = slim.fully_connected(net, 1024, scope='fc1') net = slim.dropout(net, keep_prob, scope='drop1') net = slim.fully_connected(net, 1024, scope='fc2') net = slim.dropout(net, keep_prob, scope='drop2') net = slim.fully_connected(net, 2, activation_fn=None, scope='fc3') return net pdata = load_images("t_pdata", 170) plabel = create_label((pdata.shape[0], 2), 0) ndata = load_images("t_ndata", 170) nlabel = create_label((ndata.shape[0], 2), 1) data = np.concatenate((pdata, ndata), 0) label = np.concatenate((plabel, nlabel), 0) print(data.shape) print(label.shape) def mobilenet(inputs): mobilenet_conv_defs = [{ "kernel": [3, 3],
""" Dataset: http://vision.ucsd.edu/content/yale-face-database TODO: - Perform PCA - Gen new data """ import numpy as np import util from train import train_random_projection ESSEX_PATH = "../data/essexfaces/*" ESSEX_SHAPE = (180, 200) if __name__ == "__main__": images = util.load_images(ESSEX_PATH) images = train_random_projection(images, 16) print(images.shape) print(images[0]) util.display_samples(images, 1, ESSEX_SHAPE)
def main(): """The application's entry point. If someone executes this module (instead of importing it, for example), this function is called. """ pygame.init() display_surface = pygame.display.set_mode((WIN_WIDTH, WIN_HEIGHT)) pygame.display.set_caption('Pygame Flappy Bird') score_font = pygame.font.SysFont(None, 32, bold=True) # default font images = load_images() scores = list() active = True while active: clock = pygame.time.Clock() bird = Bird(50, int(WIN_HEIGHT / 2 - Bird.HEIGHT / 2), 2, (images['bird-wingup'], images['bird-wingdown'])) pipes = deque() frame_clock = 0 score = 0 # Current state current_state = None action = None reward = 0 collision = False while True: action_on_this_tick = frame_clock % PICK_ACTION_EVERY == 0 clock.tick(FPS) if action_on_this_tick or collision: next_state = GameState(bird, pipes) # Update the values for the last state (current_state) if (current_state is not None and action is not None): # Get the value for the reward if collision: reward = REWARD_FOR_FAILURE elif active and not collision: reward = PICK_ACTION_EVERY * REWARD_SUCCESS_MULTIPLIER # Log current state with current_state.take_action(action) as u: u.update_utility_value(next_state, reward) # Now that we have updated the state, quit the game after a # collision if collision: break # Reset the action action = None # The "next" state will by the "current" state next time around current_state = next_state if not frame_clock % msec_to_frames(PipePair.ADD_INTERVAL): pp = PipePair(images['pipe-end'], images['pipe-body']) pipes.append(pp) # Handle the user quitting the game for event in pygame.event.get(): action = get_action_from_event(event) if action is Action.quit: exit() if not action and action_on_this_tick: action = current_state.max_value_action if action is Action.flap: bird.flap() for x in (0, WIN_WIDTH / 2): display_surface.blit(images['background'], (x, 0)) while pipes and not pipes[0].visible: pipes.popleft() for p in pipes: p.update() display_surface.blit(p.image, p.rect) bird.update() display_surface.blit(bird.image, bird.rect) if bird.check_collisions(pipes): collision = True # update and display score for p in pipes: if p.x + PipePair.WIDTH < bird.x and not p.score_counted: score += 1 p.score_counted = True score_surface = score_font.render(str(score), True, (255, 255, 255)) score_x = WIN_WIDTH / 2 - score_surface.get_width() / 2 display_surface.blit(score_surface, (score_x, PipePair.PIECE_HEIGHT)) pygame.display.flip() frame_clock += 1 scores.append(score) print('Game #{}:\t{}'.format(len(scores), score)) print('Best score: %i' % max(scores)) pygame.quit()
args = parser.parse_args() args.cuda = not args.no_cuda and torch.cuda.is_available() if args.cuda is True: print('===> Using GPU to train') else: print('===> Using CPU to train') torch.manual_seed(args.seed) if args.cuda: torch.cuda.manual_seed(args.seed) print('===> Loaing datasets') images_A = get_image_paths("data/trump") images_B = get_image_paths("data/cage") images_A = load_images(images_A) / 255.0 images_B = load_images(images_B) / 255.0 images_A += images_B.mean(axis=(0, 1, 2)) - images_A.mean(axis=(0, 1, 2)) model = Autoencoder() print('===> Try resume from checkpoint') if os.path.isdir('checkpoint'): try: checkpoint = torch.load('./checkpoint/autoencoder.t7') model.load_state_dict(checkpoint['state']) start_epoch = checkpoint['epoch'] print('===> Load last checkpoint data') except FileNotFoundError: print('Can\'t found autoencoder.t7') else:
# -*- coding: utf-8 -*- import os, sys, time import numpy as np from chainer import cuda, Variable sys.path.append(os.path.split(os.getcwd())[0]) import util from args import args from model import conf, vae from vae_m1 import GaussianM1VAE dist = "bernoulli" if isinstance(vae, GaussianM1VAE): dist = "gaussian" dataset = util.load_images(args.train_image_dir, dist=dist) max_epoch = 1000 num_trains_per_epoch = 2000 batchsize = 100 total_time = 0 for epoch in xrange(max_epoch): sum_loss = 0 epoch_time = time.time() for t in xrange(num_trains_per_epoch): x = util.sample_x_variable(batchsize, conf.ndim_x, dataset, gpu_enabled=conf.gpu_enabled) # train loss = vae.train(x, L=1) sum_loss += loss if t % 10 == 0:
def main(): pygame.init() window_size = (512, 512) screen = pygame.display.set_mode( window_size, pygame.OPENGL | pygame.DOUBLEBUF | pygame.RESIZABLE) #pygame.display.gl_set_attribute(pygame.GL_DEPTH_SIZE, 32) glCullFace(GL_BACK) glDepthFunc(GL_LEQUAL) glEnable(GL_DEPTH_TEST) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) glClearColor(0.1, 0.2, 0.3, 1.0) shader = make_boring_shader() images = util.load_images("textures") textures = [texture_from_image(image) for image in images] #mesh = Mesh3D(shader, util.cube_vertex_positions, util.cube_texture_coordinates) meshes = [] positions = util.split_n(util.cube_vertex_positions, 6) tex_coords = util.split_n(util.cube_texture_coordinates, 6) for i in range(6): mesh = Mesh3D(shader, textures[i], positions[i], tex_coords[i]) meshes.append(mesh) clock = pygame.time.Clock() try: os.mkdir("frames") except FileExistsError: pass FPS = 60 frame = 0 while True: clock.tick(FPS) for event in pygame.event.get(): if event.type == pygame.VIDEORESIZE: window_size = event.size if event.type == pygame.QUIT: return if event.type == pygame.KEYUP and event.key == pygame.K_ESCAPE: return mvp, model, view, projection = get_mvp(window_size) display(window_size, shader, meshes, mvp) pygame.display.flip() # save frame pygame.image.save(screen, "frames/%d.jpg" % frame) with open("matrices.npy", "ab") as f: np.save(f, model) np.save(f, view) np.save(f, projection) frame += 1
def main(_): if not FLAGS.dataset_dir: raise ValueError( 'You must supply the dataset directory with --dataset_dir') root_result_folder = os.path.join(FLAGS.dataset_dir, "features_vectors") for dir in os.listdir(FLAGS.dataset_dir): dir_path = os.path.join(FLAGS.dataset_dir, dir) if not os.path.isdir(dir_path): continue tf.logging.set_verbosity(tf.logging.INFO) with tf.Graph().as_default(): tf_global_step = slim.get_or_create_global_step( ) # #################### # # Select the model # # #################### network_fn = nets_factory.get_network_fn(FLAGS.model_name, num_classes=NUM_CLASSES, is_training=False) image_names, img = util.load_images( dir_path, FLAGS, FLAGS.eval_image_size or network_fn.default_image_size) if not image_names: continue logits, endpoints = network_fn(img) if FLAGS.moving_average_decay: variable_averages = tf.train.ExponentialMovingAverage( FLAGS.moving_average_decay, tf_global_step) variables_to_restore = variable_averages.variables_to_restore( slim.get_model_variables()) variables_to_restore[tf_global_step.op.name] = tf_global_step else: variables_to_restore = slim.get_variables_to_restore() predictions = tf.argmax(logits, 1) # print(FLAGS.batch_size) num_batches = FLAGS.max_num_batches or 1 if tf.gfile.IsDirectory(FLAGS.checkpoint_path): checkpoint_path = tf.train.latest_checkpoint( FLAGS.checkpoint_path) else: checkpoint_path = FLAGS.checkpoint_path tf.logging.info('Evaluating %s' % checkpoint_path) before_fc_tensor = endpoints["PreLogitsFlatten"] before_fc = slim.evaluation.evaluate_once( master=FLAGS.master, checkpoint_path=checkpoint_path, logdir=FLAGS.eval_dir, num_evals=num_batches, final_op=before_fc_tensor, variables_to_restore=variables_to_restore) result_folder = os.path.join(root_result_folder, dir) if not os.path.exists(result_folder): os.makedirs(result_folder) for img_name, arr in zip(image_names, before_fc): np.save(os.path.join(result_folder, img_name), np.asarray(arr))
if args.cuda is True: print('===> Using GPU to train') device = torch.device('cuda:0') cudnn.benchmark = True else: print('===> Using CPU to train') torch.manual_seed(args.seed) if args.cuda: torch.cuda.manual_seed(args.seed) print('===> Loaing datasets') images_A = get_image_paths("./face_A")#获取图片路径 images_B = get_image_paths("./face_B") images_A = load_images(images_A) / 255.0#将图片加载到数组中,并将NumPy数组规范化到一定范围[0,255]内 images_B = load_images(images_B) / 255.0 images_A += images_B.mean(axis=(0, 1, 2)) - images_A.mean(axis=(0, 1, 2))#将图像A集加上两者图像集的平均差值(RGB三通道差值),axis=0,1,2表示在这三个轴上取平均 #来使两个输入图像图像的分布尽可以相近,这样我们的损失函数曲线下降会更快些 model = Autoencoder().to(device)#定义模型 print('===> Try resume from checkpoint') if os.path.isdir('checkpoint'): try: checkpoint = torch.load('./checkpoint/autoencoder.t7') model.load_state_dict(checkpoint['state']) start_epoch = checkpoint['epoch'] print('===> Load last checkpoint data') except FileNotFoundError: print('Can\'t found autoencoder.t7') else:
import matplotlib.patches as mpatches sys.path.append(os.path.split(os.getcwd())[0]) import util from args import args from model import conf1, vae1, conf2, vae2 from vae_m1 import GaussianM1VAE try: os.mkdir(args.vis_dir) except: pass dist = "bernoulli" if isinstance(vae1, GaussianM1VAE): dist = "gaussian" dataset = util.load_images(args.test_image_dir, dist=dist) n_analogies = 10 n_image_channels = 1 image_width = 28 image_height = 28 x = util.sample_x_variable(n_analogies, conf1.ndim_x, dataset, gpu_enabled=conf1.gpu_enabled) z1 = vae1.encoder(x, test=True) y = vae2.sample_x_y(z1, test=True) z2 = vae2.encode_xy_z(z1, y, test=True) fig = pylab.gcf() fig.set_size_inches(16.0, 16.0) pylab.clf() if n_image_channels == 1: pylab.gray()
def __init__(self, n, p1, p2): # pygame initialization pygame.init() os.environ['SDL_VIDEO_CENTERED'] = '1' self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) # game initialization self.n = n self.player_1 = p1 self.player_2 = p2 self.running = True self.game_over = False # temporary variables to counter bugs # TODO: fix the bug self.target_trigger_temp = False # used for a random bug, in create_map(), the coordinate is fetched twice # image loading stuff self.background = pygame.image.load("Assets/background/background.png").convert() self.player1_img = load_images("Assets/Sprite/flash/*.png") self.player2_img = load_images("Assets/Sprite/rev_flash/*.png") self.target_img_front = [pygame.image.load("Assets/Sprite/barry_mom/front1.png").convert(), pygame.image.load("Assets/Sprite/barry_mom/front3.png").convert()] self.target_img_back = [pygame.image.load("Assets/Sprite/barry_mom/back1.png").convert(), pygame.image.load("Assets/Sprite/barry_mom/back2.png").convert()] self.end_game_images = [pygame.image.load("Assets/background/p1_wins.png").convert(), pygame.image.load("Assets/background/p2_wins.png").convert(), pygame.image.load("Assets/background/p1_lost.png").convert(), pygame.image.load("Assets/background/p2_lost.png").convert()] # map and wall stuff self.walls = [] self.map_data = [] self.walls_coordinate_vector = [] # holds the vector2 object of all wall coordinates self.g = WeightedGrid(SCREEN_WIDTH, SCREEN_HEIGHT) self.g.walls = self.walls_coordinate_vector self.create_map() # barry's mom. # TODO: optimize code using an array self.target_img_back_index = 0 self.target_img_front_index = 0 self.target_up = False self.target_down = True self.target_upper_limit = self.target_pos.y self.target_lower_limit = self.target_pos.y + (30 * 2) # barry's mom will walk up to 3 cells downwards # enemy stuff enemy_pos = spawn_enemy(self.map_data) self.goal = make_vector(self.player_1.rect) self.start = make_vector(enemy_pos) self.path = dijkstra_search(self.g, self.goal, self.start) # spawns enemy and it immediately starts to follow player on a different thread self.enemy = Enemy(enemy_pos, make_vector((self.player_1.rect.x, self.player_1.rect.y)), self.g, self.walls) # music stuff pygame.mixer.music.load('Assets/music/flash_theme.wav') pygame.mixer.music.play(-1) self.game_loop()
print('loading elapsed time ' + str(elapsed) + ' second') # process cache_tbs = Queue(maxsize=QUEUE_MAXSIZE) # start a thread to handle image saver t = Thread(target=util.save_images_fast, args=( cache_tbs, args.output_dir, )) t.setDaemon(True) t.start() count = 0 every_n = 10 all_images_taget_class = util.load_target_class(args.input_dir) for filenames, images in util.load_images(args.input_dir, batch_shape, max_number=max_number): count += 1 if count % every_n == 0: start_time_loop = timeit.default_timer() target_cls = ([all_images_taget_class[n] for n in filenames] + [0] * (batch_size - len(filenames))) sess.run(init_ops, feed_dict={img: images, dense_labels: target_cls}) for _ in xrange(itr): sess.run([train_op]) if emphasize is not None: sess.run([train_op_eph]) out_imgs = sess.run(img_input)
import os, sys, time import numpy as np from chainer import cuda, Variable sys.path.append(os.path.abspath(os.path.join(os.getcwd(), "../../"))) import util from args import args from model import conf, aae import sampler max_epoch = 1000 num_trains_per_epoch = 1000 batchsize = 100 n_steps_to_optimize_dis = 1 dataset = util.load_images(args.train_image_dir) def sample_data(): return util.sample_x_variable(batchsize, conf.ndim_x, dataset, gpu_enabled=conf.gpu_enabled) total_time = 0 for epoch in xrange(1, max_epoch + 1): sum_loss_autoencoder = 0 sum_loss_discriminator = 0 sum_loss_generator = 0
import matplotlib.patches as mpatches sys.path.append(os.path.split(os.getcwd())[0]) import util from args import args from model import conf, vae from vae_m2 import GaussianM2VAE try: os.mkdir(args.vis_dir) except: pass dist = "bernoulli" if isinstance(vae, GaussianM2VAE): dist = "gaussian" dataset = util.load_images(args.test_image_dir, dist=dist) n_analogies = 10 n_image_channels = 1 image_width = 28 image_height = 28 x = util.sample_x_variable(10, conf.ndim_x, dataset, gpu_enabled=conf.gpu_enabled) y = vae.sample_x_y(x, test=True) z = vae.encode_xy_z(x, y, test=True) fig = pylab.gcf() fig.set_size_inches(16.0, 16.0) pylab.clf() if n_image_channels == 1: pylab.gray() xp = np
#op.name gives you the name #输入,输出结点也是operation,所以,我们可以得到operation的名字 for op in graph.get_operations(): print(op.name, op.values()) # prefix/Placeholder/inputs_placeholder # ... # prefix/Accuracy/predictions #操作有:prefix/Placeholder/inputs_placeholder #操作有:prefix/Accuracy/predictions #为了预测,我们需要找到我们需要feed的tensor,那么就需要该tensor的名字 #注意prefix/Placeholder/inputs_placeholder仅仅是操作的名字,prefix/Placeholder/inputs_placeholder:0才是tensor的名字 x = graph.get_tensor_by_name('prefix/Placeholder:0') y = graph.get_tensor_by_name('prefix/softmax/Softmax:0') keep_prob = graph.get_tensor_by_name('prefix/Placeholder_2:0') v_pdata = load_images("t_pdata", 100) v_plabel = create_label((v_pdata.shape[0], 2), 0) v_ndata = load_images("t_ndata", 100) v_nlabel = create_label((v_ndata.shape[0], 2), 1) v_data = np.concatenate((v_pdata, v_ndata), 0) v_label = np.concatenate((v_plabel, v_nlabel), 0) with tf.Session(graph=graph) as sess: s = 0 for j in range(10): ds = 10 * j de = 10 * (j + 1) #s = s + accuracy.eval(feed_dict={x:v_data[ds:de], y_: v_label[ds:de], keep_prob: 1.0}) out = sess.run(y, feed_dict={x: v_data[ds:de], keep_prob: 1.0})
def main(): print("Starting..") output_path = constants.SAVE_PATH if not os.path.exists(output_path): os.makedirs(output_path) print("Made output directory") else: print("WARNING: starting training with an existing outputs directory") if not os.path.exists(output_path + 'weights/'): os.makedirs(output_path + 'weights/') print("Made weights directory") if not os.path.exists(output_path + 'images/'): os.makedirs(output_path + 'images/') print("Made images directory") model_options = constants.MAIN_MODEL_OPTIONS # Load map mapping examples to their train/dev/test split dataset_map = util.load_dataset_map() print("Loading data") # Load the caption text vectors train_captions, val_captions, test_captions = util.load_text_vec( 'Data', constants.VEC_OUTPUT_FILE_NAME, dataset_map) # Loads and separates images into train, dev, and test sets if os.path.exists(constants.FLOWERS_DICTS_PATH): image_dicts = torch.load(constants.FLOWERS_DICTS_PATH) train_image_dict, val_image_dict, test_image_dict = image_dicts print("Loaded images") else: print("Loading images and separating into train/val/test sets") filenames = train_captions.keys() + val_captions.keys( ) + test_captions.keys() train_image_dict, val_image_dict, test_image_dict = util.load_images( 'Data/' + constants.DIRECTORY_PATH, filenames, dataset_map) image_dicts = [train_image_dict, val_image_dict, test_image_dict] torch.save(image_dicts, "Data/flowers_dicts.torch") # Creates the model if constants.USE_MODEL == 'began': generator = CondBeganGenerator(model_options) discriminator = CondBeganDiscriminator(model_options) elif constants.USE_MODEL == 'wgan': generator = WGanGenerator(model_options) discriminator = WGanDiscriminator(model_options) else: generator = Generator(model_options) discriminator = Discriminator(model_options) # Put G and D on cuda if GPU available if torch.cuda.is_available(): print("CUDA is available") generator = generator.cuda() discriminator = discriminator.cuda() print("Moved models to GPU") # Initialize weights generator.apply(util.weights_init) discriminator.apply(util.weights_init) g_optimizer = optim.Adam(generator.parameters(), lr=constants.LR, betas=constants.BETAS) # Changes the optimizer to SGD if declared in constants if constants.D_OPTIMIZER_SGD: d_optimizer = optim.SGD(discriminator.parameters(), lr=constants.LR) else: d_optimizer = optim.Adam(discriminator.parameters(), lr=constants.LR, betas=constants.BETAS) print("Added optimizers") new_epoch = 0 train_losses = {"generator": [], "discriminator": []} val_losses = {"generator": [], "discriminator": []} losses = {'train': train_losses, 'val': val_losses} if args.resume: print("Resuming from epoch " + args.resume) checkpoint = torch.load(constants.SAVE_PATH + 'weights/epoch' + str(args.resume)) new_epoch = checkpoint['epoch'] + 1 generator.load_state_dict(checkpoint['g_dict']) discriminator.load_state_dict(checkpoint['d_dict']) if constants.USE_MODEL == 'began': discriminator.began_k = checkpoint['began_k'] g_optimizer.load_state_dict(checkpoint['g_optimizer']) d_optimizer.load_state_dict(checkpoint['d_optimizer']) losses = torch.load(constants.SAVE_PATH + 'losses') # TODO: MAKE SURE IMAGES ARE OF DIMENSIONS (BATCHSIZE, CHANNELS, H, W) # TODO: ADD L1/L2 Regularizaiton # TODO: USE DATALOADER FROM TORCH UTILS!!!!!!!!! # data_loader = DataLoader(self.dataset, batch_size=self.batch_size, shuffle=True, num_workers=self.num_workers) # TODO: ADD PARALLELIZATION # TODO: ADD IMAGE PREPROCESSING? DO WE NEED TO SUBTRACT/ADD ANYTHING TO IMAGES # TODO: Add image aug # NOTE: CREATING VARIABLES EARLY, THEN FILL IN LATER noise_vec = torch.FloatTensor(constants.BATCH_SIZE, model_options['z_dim'], 1, 1) g_text_des = torch.FloatTensor(constants.BATCH_SIZE, model_options['caption_vec_len']) real_img = torch.FloatTensor(constants.BATCH_SIZE, constants.IMAGE_SIZE, constants.IMAGE_SIZE) real_caption = torch.FloatTensor(constants.BATCH_SIZE, model_options['caption_vec_len']) if constants.USE_CLS: wrong_img = torch.FloatTensor(constants.BATCH_SIZE, constants.IMAGE_SIZE, constants.IMAGE_SIZE) wrong_caption = torch.FloatTensor(constants.BATCH_SIZE, model_options['caption_vec_len']) # Add cuda GPU option if torch.cuda.is_available(): noise_vec = noise_vec.cuda() g_text_des = g_text_des.cuda() real_img = real_img.cuda() real_caption = real_caption.cuda() if constants.USE_CLS: wrong_img = wrong_img.cuda() # Number of total iterations num_iterations = 0 # Loop over dataset N times for epoch in range(new_epoch, constants.NUM_EPOCHS): print("Epoch %d" % (epoch)) st = time.time() # WGAN trains D number of times more than G curr_count = 0 if constants.USE_MODEL == 'wgan': if num_iterations < 25 or num_iterations % 500 == 0: d_iters = 100 else: d_iters = model_options['wgan_d_iter'] for i, batch_iter in enumerate( grouper(train_captions.keys(), constants.BATCH_SIZE)): batch_keys = [x for x in batch_iter if x is not None] curr_batch_size = len(batch_keys) discriminator.train() generator.train() # Zero out gradient discriminator.zero_grad() # Save computations for gradient calculations for p in discriminator.parameters(): p.requires_grad = True # Need this to be true to update generator as well # Gather batch data noise_batch = torch.randn(curr_batch_size, model_options['z_dim'], 1, 1) g_text_des_batch = torch.Tensor( get_text_description(train_captions, batch_keys)) real_caption_batch = torch.Tensor( get_text_description(train_captions, batch_keys)) real_img_batch = torch.Tensor( choose_real_image(train_image_dict, batch_keys)) if constants.USE_CLS: wrong_img_batch = torch.Tensor( choose_wrong_image(train_image_dict, batch_keys)) if torch.cuda.is_available(): noise_batch = noise_batch.cuda() g_text_des_batch = g_text_des_batch.cuda() real_caption_batch = real_caption_batch.cuda() real_img_batch = real_img_batch.cuda() if constants.USE_CLS: wrong_img_batch = wrong_img_batch.cuda() # Fill in tensors with batch data noise_vec.resize_as_(noise_batch).copy_(noise_batch) g_text_des.resize_as_(g_text_des_batch).copy_(g_text_des_batch) real_caption.resize_as_(g_text_des_batch).copy_(g_text_des_batch) real_img.resize_as_(real_img_batch).copy_(real_img_batch) if constants.USE_CLS: wrong_img.resize_as_(wrong_img_batch).copy_(wrong_img_batch) # Run through generator gen_image = generator.forward( Variable(g_text_des), Variable(noise_vec)) # Returns tensor variable holding image # Run through discriminator real_img_passed = discriminator.forward(Variable(real_img), Variable(real_caption)) fake_img_passed = discriminator.forward(gen_image.detach(), Variable(real_caption)) if constants.USE_CLS: wrong_img_passed = discriminator.forward( Variable(wrong_img), Variable(real_caption)) ##### Train Discriminator ##### # calc_grad_d calcs gradients and steps backward if constants.USE_MODEL == 'began': if constants.USE_CLS: d_loss = discriminator.calc_grad_d(Variable(real_img), real_img_passed, gen_image, fake_img_passed, Variable(wrong_img), wrong_img_passed) else: d_loss = discriminator.calc_grad_d(Variable(real_img), real_img_passed, gen_image, fake_img_passed) else: if constants.USE_CLS: d_loss = discriminator.calc_grad_d(real_img_passed, fake_img_passed, wrong_img_passed) else: d_loss = discriminator.calc_grad_d(real_img_passed, fake_img_passed) d_optimizer.step() # WGAN trains D number of times more than G if constants.USE_MODEL == 'wgan': if curr_count < d_iters and i < (len(train_captions) / constants.BATCH_SIZE) - 1: curr_count += 1 num_iterations += 1 continue else: # Update G after d iterations or after reaching end of epoch curr_count = 0 ##### Train Generator ##### for p in discriminator.parameters(): p.requires_grad = False generator.zero_grad() # Generate image again if you want to if constants.REGEN_IMAGE: noise_batch = torch.randn(curr_batch_size, model_options['z_dim'], 1, 1) if torch.cuda.is_available(): noise_batch = noise_batch.cuda() noise_vec.resize_as_(noise_batch).copy_(noise_batch) gen_image = generator.forward(Variable(g_text_des), Variable(noise_vec)) new_fake_img_passed = discriminator.forward( gen_image, Variable(real_caption)) if constants.USE_MODEL == 'began': g_loss = generator.calc_grad_g(gen_image, new_fake_img_passed) else: g_loss = generator.calc_grad_g(new_fake_img_passed) g_optimizer.step() # learning rate decay if constants.USE_MODEL == 'began': g_optimizer = adjust_learning_rate(g_optimizer, num_iterations) d_optimizer = adjust_learning_rate(d_optimizer, num_iterations) if i % constants.LOSS_SAVE_IDX == 0: losses['train']['generator'].append((g_loss.data[0], epoch, i)) losses['train']['discriminator'].append( (d_loss.data[0], epoch, i)) num_iterations += 1 print('Total number of iterations: ', num_iterations) print('Training G Loss: ', g_loss.data[0]) print('Training D Loss: ', d_loss.data[0]) epoch_time = time.time() - st print("Time: ", epoch_time) if epoch == constants.REPORT_EPOCH: with open(constants.SAVE_PATH + 'report.txt', 'w') as f: f.write(constants.EXP_REPORT) f.write("Time per epoch: " + str(epoch_time)) copyfile("constants.py", constants.SAVE_PATH + 'constants.py') print("Saved report") ''' DEV SET ''' # Calculate dev set loss # Volatile is true because we are running in inference mode (no need to calculate gradients) generator.eval() discriminator.eval() for i, batch_iter in enumerate( grouper(val_captions.keys(), constants.BATCH_SIZE)): batch_keys = [x for x in batch_iter if x is not None] curr_batch_size = len(batch_keys) # Gather batch data noise_batch = torch.randn(curr_batch_size, model_options['z_dim'], 1, 1) g_text_des_batch = torch.Tensor( get_text_description(val_captions, batch_keys)) real_caption_batch = torch.Tensor( get_text_description(val_captions, batch_keys)) real_img_batch = torch.Tensor( choose_real_image(val_image_dict, batch_keys)) if constants.USE_CLS: wrong_img_batch = torch.Tensor( choose_wrong_image(val_image_dict, batch_keys)) if torch.cuda.is_available(): noise_batch = noise_batch.cuda() g_text_des_batch = g_text_des_batch.cuda() real_caption_batch = real_caption_batch.cuda() real_img_batch = real_img_batch.cuda() if constants.USE_CLS: wrong_img_batch = wrong_img_batch.cuda() # Fill in tensors with batch data noise_vec.resize_as_(noise_batch).copy_(noise_batch) g_text_des.resize_as_(g_text_des_batch).copy_(g_text_des_batch) real_caption.resize_as_(g_text_des_batch).copy_(g_text_des_batch) real_img.resize_as_(real_img_batch).copy_(real_img_batch) if constants.USE_CLS: wrong_img.resize_as_(wrong_img_batch).copy_(wrong_img_batch) # Run through generator gen_image = generator.forward(Variable( g_text_des, volatile=True), Variable( noise_vec, volatile=True)) # Returns tensor variable holding image # Run through discriminator real_img_passed = discriminator.forward( Variable(real_img, volatile=True), Variable(real_caption, volatile=True)) fake_img_passed = discriminator.forward( gen_image.detach(), Variable(real_caption, volatile=True)) if constants.USE_CLS: wrong_img_passed = discriminator.forward( Variable(wrong_img, volatile=True), Variable(real_caption, volatile=True)) # Calculate D loss if constants.USE_MODEL == 'began': if constants.USE_CLS: d_loss = discriminator.loss(Variable(real_img), real_img_passed, gen_image, fake_img_passed, Variable(wrong_img), wrong_img_passed) else: d_loss = discriminator.loss(Variable(real_img), real_img_passed, gen_image, fake_img_passed) elif constants.USE_MODEL == 'wgan': if constants.USE_CLS: d_loss, d_real_loss, d_fake_loss, d_wrong_loss = discriminator.loss( real_img_passed, fake_img_passed, wrong_img_passed) else: d_loss, d_real_loss, d_fake_loss = discriminator.loss( real_img_passed, fake_img_passed) # Vanilla Model else: if constants.USE_CLS: d_loss = discriminator.loss(real_img_passed, fake_img_passed, wrong_img_passed) else: d_loss = discriminator.loss(real_img_passed, fake_img_passed) # Calculate G loss if constants.USE_MODEL == 'began': g_loss = generator.loss(gen_image, fake_img_passed) else: g_loss = generator.loss(fake_img_passed) if i % constants.LOSS_SAVE_IDX == 0: losses['val']['generator'].append((g_loss.data[0], epoch, i)) losses['val']['discriminator'].append( (d_loss.data[0], epoch, i)) print('Val G Loss: ', g_loss.data[0]) print('Val D Loss: ', d_loss.data[0]) # Save losses torch.save(losses, constants.SAVE_PATH + 'losses') # Save images vutils.save_image(gen_image[0].data.cpu(), constants.SAVE_PATH + 'images/gen0_epoch' + str(epoch) + '.png', normalize=True) vutils.save_image(gen_image[1].data.cpu(), constants.SAVE_PATH + 'images/gen1_epoch' + str(epoch) + '.png', normalize=True) if constants.USE_MODEL == 'began': vutils.save_image(real_img_passed[0].data.cpu(), constants.SAVE_PATH + 'images/real_recon0_epoch' + str(epoch) + '.png', normalize=True) vutils.save_image(real_img_passed[1].data.cpu(), constants.SAVE_PATH + 'images/real_recon1_epoch' + str(epoch) + '.png', normalize=True) # Save model if epoch % 20 == 0 or epoch == constants.NUM_EPOCHS - 1: save_checkpoint = { 'epoch': epoch, 'g_dict': generator.state_dict(), 'd_dict': discriminator.state_dict(), 'g_optimizer': g_optimizer.state_dict(), 'd_optimizer': d_optimizer.state_dict(), } if constants.USE_MODEL == 'began': save_checkpoint['began_k'] = discriminator.began_k torch.save(save_checkpoint, constants.SAVE_PATH + 'weights/epoch' + str(epoch))
def train(cost, network_description, epsilon, max_updates, class_letter, model_file_name, train_folder_name): layer_def = util.load_layers_definition(network_description) cnn = create_cnn(layer_def) # y_predict = tf.nn.softmax(cnn, name='y_predict') # y_predict = tf.nn.sigmoid(cnn, name='y_predict') # cost_func = tf.nn.softmax_cross_entropy_with_logits( # logits=cnn, labels=output_holder) cost_func = tf.nn.sigmoid_cross_entropy_with_logits(logits=cnn, labels=output_holder) if cost == supported_modes[1]: # cross entropy with L1 regularization L1 = tf.contrib.layers.l1_regularizer(scale=0.005, scope=None) penalty = tf.contrib.layers.apply_regularization(L1, weights_list=weights) cost_func = cost_func + penalty elif cost == supported_modes[2]: # cross entropy with L2 regularization L2 = tf.contrib.layers.l2_regularizer(scale=0.005, scope=None) penalty = tf.contrib.layers.apply_regularization(L2, weights_list=weights) cost_func = cost_func + penalty cost = tf.reduce_mean(cost_func) optimizer = tf.train.GradientDescentOptimizer(epsilon).minimize(cost) #optimizer = tf.train.AdamOptimizer(epsilon).minimize(cost) session = tf.Session() init = tf.global_variables_initializer() session.run(init) x, y = util.load_images(train_folder_name, class_letter) row = len(x) # split data set to 5 partitions for cross validation block = row / 5 train_accuracy = [] validation_accuracy = [] cost_history = [] cost_validation_history = [] s = [] # step in graph tg = [] # training cost by step vg = [] # validation cost by step for i in range(5): # 5-fold # Pick the current Si as the subset for testing sl_i = slice(i * block, (i + 1) * block) test_x = np.asarray(x[sl_i]) test_y = np.asarray(y[sl_i]) train_x = np.delete(x, np.s_[i * block:(i + 1) * block], axis=0) train_y = np.delete(y, np.s_[i * block:(i + 1) * block], axis=0) print 'Training on Si except S[', i, ']' cost_per_max_update_history = [] for e in range(max_updates): # an update is an epoch # shuffle the data before training for r in range(0, len(train_x)): try: j = random.randint(r + 1, len(train_x) - 1) if r != j: train_x[r], train_x[j] = train_x[j], train_x[r] train_y[r], train_y[j] = train_y[j], train_y[r] except ValueError: pass # print 'End of the list when shuffling' # slice the training data into mini batches and train for b in range(0, len(train_x), batch_size): batch_x = train_x[b:b + batch_size] batch_y = train_y[b:b + batch_size] # Reshape images data from 3d to 4d array before # feeding into tensorflow sh = batch_x.shape batch_x = np.reshape(batch_x, (sh[0], sh[1], sh[2], 1)) batch_y = np.reshape(batch_y, (len(batch_y), 1)) feed_data = {input_holder: batch_x, output_holder: batch_y} session.run(optimizer, feed_dict=feed_data) predict = tf.greater(cnn, threshold) correct_pred = tf.equal(predict, tf.equal(output_holder, 1.0)) accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) accuracy = session.run(accuracy, feed_dict=feed_data) train_accuracy.append(accuracy) cost_value = session.run(cost, feed_dict=feed_data) cost_history.append(cost_value) cost_per_max_update_history.append(cost_value) # Each number of epoch time, save the training cost to draw the graph tg.append(np.mean(cost_per_max_update_history)) s.append((i + 1) * max_updates) print 'Training accuracy:', np.mean(train_accuracy) print 'Training cost:', np.mean(cost_history) print 'Validating on S[', i, '] data' predict = tf.greater(cnn, threshold) correct_pred = tf.equal(predict, tf.equal(output_holder, 1.0)) accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32), name="accuracy-check") # Reshape images data from 3d to 4d array before # feeding into tensorflow xsh = test_x.shape test_x = np.reshape(test_x, (xsh[0], xsh[1], xsh[2], 1)) test_y = np.reshape(test_y, (len(test_y), 1)) accuracy = session.run(accuracy, feed_dict={ input_holder: test_x, output_holder: test_y }) validation_accuracy.append(accuracy) cost_validation = session.run(cost, feed_dict={ input_holder: test_x, output_holder: test_y }) cost_validation_history.append(cost_validation) # Save the validation cost to draw the graph vg.append(cost_validation) print "Validation Cost: ", cost_validation print 'Validation accuracy:', np.mean(validation_accuracy) print '-------------------------------' # Save the weights at the last fold saver = tf.train.Saver() saver.save(session, model_file_name) print 'Training and validation completed' print 'Avg Training accuracy:', np.mean(train_accuracy) print 'Avg Training cost:', np.mean(cost_history) print 'Avg Validation accuracy:', np.mean(validation_accuracy) print 'Avg Validation cost: ', np.mean(cost_validation_history) print "Step:", s print "Train cost:", tg # print "Validation cost:,", cost_validation_history session.close() graph(s, tg, cost_validation_history)
def detect_image(model, args): countbin = 0 countgar = 0 counttrash = 0 a=[] print('Loading input image(s)...') input_size = [int(model.net_info['height']), int(model.net_info['width'])] batch_size = int(model.net_info['batch']) imlist, imgs = load_images(args.input) print('Input image(s) loaded') img_batches = create_batches(imgs, batch_size) # load colors and classes colors = pkl.load(open("pallete", "rb")) classes = load_classes("cfg/obj.names") if not osp.exists(args.outdir): os.makedirs(args.outdir) start_time = datetime.now() print('Detecting...') for batchi, img_batch in enumerate(img_batches): img_tensors = [cv_image2tensor(img, input_size) for img in img_batch] img_tensors = torch.stack(img_tensors) img_tensors = Variable(img_tensors) if args.cuda: img_tensors = img_tensors.cuda() detections = model(img_tensors, args.cuda).cpu() detections = process_result(detections, args.obj_thresh, args.nms_thresh) if len(detections) == 0: continue detections = transform_result(detections, img_batch, input_size) for detection in detections: draw_bbox(img_batch, detection, colors, classes) #la = classes[int(detection[-1])] #if la == 'bin': #countbin = countbin +1 #if (la == 'plastic_bag' ): #countgar = countgar +1 #if (la == 'trash'): #counttrash = counttrash+1 if (countgar >= 3 or counttrash >= 5): p1 = tuple(detection[1:3].int()) p2 = tuple(detection[3:5].int()) combined_array=np.append(p1, p2) combined_list=combined_array.tolist() a.append(combined_list) result=cv2.groupRectangles(a,1,0.85) for (x,y,w,h) in result[0]: img = img_batch[int(detection[0])] #print("---------Sum Amount-----------" ) #print("bin = " , countbin) #print("plastic_bag = " , countgar) #print("counttrash = " , counttrash) for i, img in enumerate(img_batch): save_path = osp.join(args.outdir, 'det_' + osp.basename(imlist[batchi*batch_size + i])) cv2.imwrite(save_path, img) print(save_path, 'saved') end_time = datetime.now() print('Detection finished in %s' % (end_time - start_time)) return
with tf.variable_scope(name): weight = self.get_weight_var([n, m]) bias = self.get_bias_var([m]) out = tf.nn.relu(tf.matmul(inputs, weight) + bias) return out def build_net(self, inputs): self.conv11 = self.conv_layer(inputs, 3, 3, 64, "conv1-1") self.pool11 = self.maxpool_layer(self.conv11, "pool1-1") self.conv12 = self.conv_layer(self.pool11, 3, 64, 64, "conv1-2") self.pool12 = self.maxpool_layer(self.conv12, "pool1-2") pdata = load_images("t_pdata", 1700) plabel = create_label((pdata.shape[0], 2), 0) ndata = load_images("t_ndata", 1700) nlabel = create_label((ndata.shape[0], 2), 1) data = np.concatenate((pdata, ndata), 0) label = np.concatenate((plabel, nlabel), 0) print(data.shape) print(label.shape) sess = tf.InteractiveSession() x = tf.placeholder(tf.float32, shape=[None, 224, 224, 3]) y_ = tf.placeholder(tf.float32, shape=[None, 2]) keep_prob = tf.placeholder(tf.float32)
type=str, help="Where to get image swatches that we think co-occur frequently.", ) parser.add_argument( "--render", "--r", default=False, type=bool, help="if we should render progress", ) args = parser.parse_args() if __name__ == "__main__": # assumption is that the swatches contain different # versions of the single object that we are interested in swatches, _ = load_images(args.swatch_directory) test_images, image_names = load_images(args.test_directory) result_confidences = match_swatches(swatches, test_images, render_output=args.render) print('Swatch Match Results:') for i in range(len(result_confidences)): print('=====================================') print('Image: ' + image_names[i]) print('Confidence: ' + str(result_confidences[i])) print('=====================================')