def main(): #Get random dog image endpoint = "https://dog.ceo/api/breeds/image/random" response = requests.get(endpoint) img_url = response.json()['message'] # Get style image and process it style_img_url = "https://upload.wikimedia.org/wikipedia/en/1/14/Picasso_The_Weeping_Woman_Tate_identifier_T05010_10.jpg" style_image = preprocess_image(load_img(style_img_url), 256) #Calculate style bottleneck for the preprocessed style image style_bottleneck = run_style_predict(style_image) #Process the content image content_image = preprocess_image(load_img(img_url), 384) # Stylize the content image using the style bottleneck stylized_image = run_style_transform(style_bottleneck, content_image) # Create a plot of the images fig = plot(content_image, style_image, stylized_image) tmpfile = BytesIO() fig.savefig(tmpfile, format='png') encoded = base64.b64encode(tmpfile.getvalue()).decode('utf8') # Display the output in html image_html = '<h1>A randoml dog in the style of Picasso!</h1>' + '<img src=\'data:image/png;base64,{}\'>'.format( encoded) return (image_html)
def calculate_loss_of_contrast(images_hdr_path, images_ldr_path, norm_value_hdr, norm_value_ldr): if len(images_hdr_path) != len(images_ldr_path): raise ValueError('Sizes of HDR and LDR image lists are different.') if len(images_hdr_path) == 0: raise ValueError('List of HDR or LDR image paths must not be empty.') loss_global_contrast = 0 loss_local_contrast = 0 for hdr_image_path, ldr_image_path in zip(images_hdr_path, images_ldr_path): print(".", end='', flush=True) # show progress image_hdr = preprocess_image( cv2.imread(str(hdr_image_path), cv2.IMREAD_GRAYSCALE | cv2.IMREAD_ANYDEPTH), norm_value_hdr) image_ldr = preprocess_image( cv2.imread(str(ldr_image_path), cv2.IMREAD_GRAYSCALE), norm_value_ldr, gamma_correction) loss_global_contrast += measure_global_contrast(image_hdr, image_ldr) loss_local_contrast += measure_local_contrast(image_hdr, image_ldr) loss_global_contrast /= len(images_hdr_path) loss_local_contrast /= len(images_hdr_path) print() # newline after progress dots return loss_global_contrast, loss_local_contrast
def play(save_path): ''' Loads network from the location of save_path and plays a game of Pong. ''' # Initialize the Pong gym environment, set seeds env = gym.make('Pong-v0') replay_memory = u.ReplayMemory() G = tf.Graph() with G.as_default(): # Import TF graph saver = tf.train.import_meta_graph(save_path + '.meta', clear_devices=True) G.device( '/cpu:0' ) # Run graph on CPU so play can be done without taking GPU resources # Get input/output tensors X = G.get_tensor_by_name('X:0') Y = G.get_tensor_by_name('Y:0') # Initialize TF session sess_config = tf.ConfigProto(device_count={'CPU': 1, 'GPU': 0}) with tf.Session(config=sess_config) as sess: print('Reloading parameters...') saver.restore(sess, save_path) # Iterate over episodes while True: obs = u.preprocess_image(env.reset()) for i in range(3): replay_memory.add_frame( np.zeros((160 // DOWNSAMPLE, 160 // DOWNSAMPLE))) replay_memory.add_frame(obs) # Iterate over frames done = False while not done: # Feed state into DQN s = np.stack( [replay_memory.frames[i] for i in range(-4, 0)], axis=-1).reshape(1, 160 // DOWNSAMPLE, 160 // DOWNSAMPLE, 4) y = sess.run(Y, feed_dict={X: s}) # Decide on action greedily a = np.argmax(y) + 1 # Take action, observe environment, reward obs, r, done, _ = env.step(a) for i in range(STEPS_TO_SKIP): obs, r, done_temp, _ = env.step(1) if done_temp == True: done = True env.render() # Add new frame to replay memory replay_memory.add_frame(u.preprocess_image(obs)) q = input('Play again? ') if q in ['', 'y', 'Y']: pass else: env.render(close=True) break
def get_trajectory(self, env, episode_max_length, render=False): """ Run agent-environment loop for one whole episode (trajectory) Return dictionary of results Note that this function returns more than the get_trajectory in the Learner class. """ state = preprocess_image(env.reset()) prev_state = state states = [] actions = [] rewards = [] episode_probabilities = [] for _ in range(episode_max_length): delta = state - prev_state action, probabilities = self.act(delta) states.append(delta) prev_state = state state, rew, done, _ = env.step(action) state = preprocess_image(state) actions.append(action) rewards.append(rew) episode_probabilities.append(probabilities) if done: break if render: env.render() return { "reward": np.array(rewards), "state": np.array(states), "action": np.array(actions), "prob": np.array(episode_probabilities) }
def load_data(labels, img_path, size=299, data=None, oversample=False, multi_label=True): if oversample: new_df = pd.DataFrame() major = labels[labels.iloc[:, 1] == np.argmax( np.bincount(labels.iloc[:, 1]))] minors = np.unique(labels.iloc[:, 1])[np.unique( labels.iloc[:, 1]) != np.argmax(np.bincount(labels.iloc[:, 1]))] for i in minors: minor = labels[labels.iloc[:, 1] == i] n = len(major) - len(minor) minor_df = resample(minor, replace=True, n_samples=n + len(minor), random_state=42) new_df = new_df.append(minor_df) new_df = new_df.reset_index(drop=True) labels = pd.concat([major, new_df], ignore_index=True) labels = labels.reset_index(drop=True) else: pass labels = labels.reset_index(drop=True) N = labels.shape[0] # add a size to argument x_train = np.empty((N, size, size, 3), dtype=np.uint8) y_train = pd.get_dummies(labels.iloc[:, 1]).values if multi_label: y_train_multi = np.empty(y_train.shape, dtype=y_train.dtype) y_train_multi[:, 4] = y_train[:, 4] for i in range(3, -1, -1): y_train_multi[:, i] = np.logical_or(y_train[:, i], y_train_multi[:, i + 1]) y_train = y_train_multi for i, image_id in enumerate(tqdm(labels.iloc[:, 0])): if data == 'aptos': x_train[i, :, :, :] = preprocess_image( img_path + 'Aptos/train_images/{}.png'.format(image_id), size) else: try: x_train[i, :, :, :] = preprocess_image( img_path + 'train_resized/{}.jpeg'.format(image_id), size) except FileNotFoundError: continue return x_train, y_train
def get_tensor_pair(self, patch): patch_size = self.hr_patch_size lr_patch_size = patch_size / 2 lr_patch = resize(patch, [lr_patch_size, lr_patch_size, 3], mode='reflect') hr_patch = utils.preprocess_image(patch) lr_patch = utils.preprocess_image(lr_patch) return hr_patch, lr_patch
def generator(samples, batch_size=32): num_samples = len(samples) while 1: # Loop forever so the generator never terminates sklearn.utils.shuffle(samples) for offset in range(0, num_samples, batch_size): batch_samples = samples[offset:offset + batch_size] images = [] angles = [] for batch_sample in batch_samples: center_name = FLAGS.data_dir + '/IMG/' + batch_sample[0].split( '/')[-1] center_image = preprocess_image(cv2.imread(center_name)) center_angle = float(batch_sample[3]) images.append(center_image) angles.append(center_angle) # data augmentation augmented_c_image, augmented_c_angle = augment_data( center_image, center_angle) images.append(augmented_c_image) angles.append(augmented_c_angle) # add in left and right cameras' info left_name = FLAGS.data_dir + '/IMG/' + batch_sample[1].split( '/')[-1] left_image = preprocess_image(cv2.imread(left_name)) right_name = FLAGS.data_dir + '/IMG/' + batch_sample[2].split( '/')[-1] right_image = preprocess_image(cv2.imread(right_name)) # create adjusted steering measurements for the side camera images correction = 0.3 # this is a parameter to tune left_angle = center_angle + correction right_angle = center_angle - correction # add images and angles to data set images.extend([left_image, right_image]) angles.extend([left_angle, right_angle]) # data augmentation augmented_l_image, augmented_l_angle = augment_data( left_image, left_angle) augmented_r_image, augmented_r_angle = augment_data( right_image, right_angle) images.extend([augmented_l_image, augmented_r_image]) angles.extend([augmented_l_angle, augmented_r_angle]) # trim image to only see section with road X = np.array(images) y = np.array(angles) X, y = sklearn.utils.shuffle(X, y) yield X, y
def play(G, save_path): # Initialize the Pong gym environment, set seeds env = gym.make('Pong-v0') replay_memory = u.ReplayMemory() with G.as_default(): # Get input/output tensors X = G.get_tensor_by_name('X:0') Y = G.get_tensor_by_name('Y:0') saver = tf.train.Saver(var_list=None, max_to_keep=5) # Initialize TF session with tf.Session() as sess: print('Reloading parameters...') saver.restore(sess, save_path) # Iterate over episodes while True: obs = u.preprocess_image(env.reset()) for i in range(3): replay_memory.add_frame( np.zeros((160 // DOWNSAMPLE, 160 // DOWNSAMPLE))) replay_memory.add_frame(obs) # Iterate over frames done = False while not done: # Feed state into DQN s = np.stack( [replay_memory.frames[i] for i in range(-4, 0)], axis=-1).reshape(1, 160 // DOWNSAMPLE, 160 // DOWNSAMPLE, 4) y = sess.run(Y, feed_dict={X: s}) # Decide on action a = np.argmax(y) + 1 # Take action, observe environment, reward obs, r, done, _ = env.step(a) for i in range(STEPS_TO_SKIP): obs, r, done_temp, _ = env.step(1) if done_temp == True: done = True env.render() # Add new state/reward to replay memory replay_memory.add_frame(u.preprocess_image(obs)) q = input('play again?') if q in ['', 'y', 'Y']: pass else: env.render(close=True) break
def generate(self, original_image, im_label, target_class): im_label_as_var = torch.from_numpy(np.asarray([target_class])) criterion = nn.CrossEntropyLoss() # process image as ImageNet dataset format processed_image = preprocess_image(original_image) for i in range(10): print('Iteration: {}'.format(str(i))) # zero previous gradient processed_image.grad = None out = self.model(processed_image) pred_loss = criterion(out, im_label_as_var) # calculate gradient pred_loss.backward() # create noise # processed_image.grad.data represents gradient of first layer adv_noise = self.alpha * torch.sign(processed_image.grad.data) # add noise to image processed_image.data = processed_image.data - adv_noise # generate confirmation image recreated_image = recreate_image(processed_image) # process confirmation image prep_confirmation_image = preprocess_image(recreated_image) pred = self.model(prep_confirmation_image) # get prediction index _, pred_index = pred.data.max(1) confidence = F.softmax(pred, dim=1)[0][pred_index].data.numpy()[0] # convert tensor to int pred_index = pred_index.numpy()[0] if pred_index == target_class: print('\nOriginal image class: ', im_label, '\nTarget image class: ', target_class, '\nConfidence: ', confidence) # create the image for noise as: Original image - generated image noise_image = original_image - recreated_image cv2.imwrite( './generated/targeted_adv_noise_from_' + str(im_label) + '_to_' + str(pred_index) + '.jpg', noise_image) # write image cv2.imwrite( './generated/targeted_adv_img_from_' + str(im_label) + '_to_' + str(pred_index) + '.jpg', recreated_image) break return 1
def compute_features(keyframes, path_out, layer='conv5_1', max_dim=340): """ store all local features from conv5_1 of vgg16 at 340 mac res and store then in path_data/[mode]/layer/max_dim """ # create folder if it does not exist if not os.path.exists(path_out): os.makedirs(path_out) # init model model = init_model(layer) # message desc_text = "Feature extraction --> Layer: {}, Max_dim: {}, total_images={}".format( layer, max_dim, keyframes.shape[0]) # process keyframes for k, keyframe in tqdm(enumerate(keyframes), ascii=True, desc=desc_text): feats = model.predict(preprocess_image( keyframe, max_dim=max_dim)).squeeze(axis=0) np.save(os.path.join(path_out, "{}".format(k)), feats) # resume computation else: computed = np.array( [int(k.split('.')[0]) for k in os.listdir(path_out)]) # if features has been computed... if computed.shape[0] == keyframes.shape[0]: return path_out # start from the last computed... elif computed.shape[0] == 0: last = 0 else: last = np.sort(computed)[::-1][0] # init model model = init_model(layer) desc_text = "Feature extraction --> Layer: {}, Max_dim: {}, total_images={}".format( layer, max_dim, keyframes.shape[0] - last) for k, keyframe in tqdm(enumerate(keyframes[last:]), ascii=True, desc=desc_text): feats = model.predict(preprocess_image( keyframe, max_dim=max_dim)).squeeze(axis=0) k += last np.save(os.path.join(path_out, "{}".format(k)), feats) return path_out
def predict(): data = {'success': False} if request.files.getlist("images[]"): images = request.files.getlist("images[]") images_preprocess = [] items = [] for image in images: item = {} image = image.read() image = Image.open(io.BytesIO(image)) image = utils.preprocess_image(image) images_preprocess.append(image / 255.) item['image'] = utils.encode_image(image) items.append(item) images_preprocess = np.array(images_preprocess) predicts = model.predict(images_preprocess, steps=len(images)) predicts = np.argmax(predicts, axis=1) for idx, predict in enumerate(predicts): items[idx]['info'] = class_info[str(predict)] data['success'] = True data['data'] = items print(data) return json.dumps(data, ensure_ascii=False, cls=utils.NumpyEncoder)
def predict_image(self, image, voc, img_size=IMAGE_SIZE): if isinstance(image, str): img = preprocess_image(image, img_size) elif isinstance(image, np.ndarray): img = image else: raise TypeError( "Unknown handling of image input of type {}".format( type(image))) img_inp = np.expand_dims(img, 0) current_context = np.array([voc.word2one_hot_dict[PLACEHOLDER]] * (self.max_code_length)) current_context = np.expand_dims(current_context, 0) current_context[0, 0, :] = voc.word2one_hot_dict[START_WORD] word_predictions = [] for i in range(self.max_code_length): probas = self.predict({ 'img_data': img_inp, 'context': current_context }) probas = probas['code'][0][i] prediction = np.argmax(probas) word_prediction = voc.token2word_dict[prediction] if word_prediction == END_WORD or word_prediction == PLACEHOLDER: break word_predictions.append(word_prediction) current_context[0, i + 1, :] = voc.word2one_hot_dict[word_prediction] return " ".join(word_predictions)
def telemetry(sid, data): if data: # The current steering angle of the car steering_angle = data["steering_angle"] # The current throttle of the car throttle = data["throttle"] # The current speed of the car speed = data["speed"] # The current image from the center camera of the car imgString = data["image"] image = Image.open(BytesIO(base64.b64decode(imgString))) image = utils.preprocess_image(image) image_array = np.asarray(image) steering_angle = float( model.predict(image_array[None, :, :, :], batch_size=1)) controller.set_desired(set_speed) throttle = controller.update(float(speed)) print(steering_angle, throttle) send_control(steering_angle, throttle) # save frame if args.image_folder != '': timestamp = datetime.utcnow().strftime('%Y_%m_%d_%H_%M_%S_%f')[:-3] image_filename = os.path.join(args.image_folder, timestamp) image.save('{}.jpg'.format(image_filename)) else: # NOTE: DON'T EDIT THIS. sio.emit('manual', data={}, skip_sid=True)
def slide(self, image): """ Extracts sliding windows over the preprocessed image @param image: A 2d ndarray representing an image @return: A length two tuple of a list of dictionaries, each corresponding to a window, and a list of images, each corresponding to a down sampled image. The down sampled images have been preprocessed by utils.preprocess_image """ # Each 'patch' is a list of contributions to bins, like the output from utils.preprocess_image patches_dicts = [] images = [] for image_index, (scale, patch_extractor) in enumerate(izip(self.scales, self.patch_extractors)): if scale != 1: downsampled_image = ndimage.interpolation.zoom(image, scale) else: downsampled_image = image preprocessed_image = utils.preprocess_image(downsampled_image) images.append(preprocessed_image) positions = patch_extractor.patch_positions(preprocessed_image) rf_size = [patch_extractor.rf_size[0] / scale, patch_extractor.rf_size[1] / scale] #patches = patch_extractor.extract_all(preprocessed_image) #for i, patch in enumerate(patches): for i in xrange(positions.shape[1]): patch_position = positions[:, i].tolist() orig_position = (positions[:, i] / scale).tolist() patches_dicts.append({ 'image_index': image_index, 'patch_position': patch_position, 'patch_size': patch_extractor.rf_size, 'orig_position': orig_position, 'orig_size': rf_size, }) return patches_dicts, images
def run_images(): parser = argparse.ArgumentParser() parser.add_argument('--dir_path', default="./test_images", type=str) parser.add_argument('--out_path', default='./out_images', type=str) parser.add_argument('--model_file', default="./model/yolov2-tiny-voc.h5", type=str) args = parser.parse_args() paths = utils.get_image_path(args.dir_path) images = [] print('reading image from %s' % args.dir_path) for path in paths: image = cv2.imread(path) resized = cv2.resize(image, (416, 416)) images.append(resized) image_processed = [] for image in images: image_processed.append(utils.preprocess_image(image)) print('loading model from %s' % args.model_file) model = load_model(args.model_file) predictions = model.predict(np.array(image_processed)) if not os.path.exists(args.out_path): os.mkdir(args.out_path) print('writing image to %s' % args.out_path) for i in range(predictions.shape[0]): boxes = utils.process_predictions(predictions[i], probs_threshold=0.3, iou_threshold=0.2) out_image = utils.draw_boxes(images[i], boxes) cv2.imwrite('%s/out%s.jpg' % (args.out_path, i), out_image)
def main(): parser = argparse.ArgumentParser(description="Deep Dream tutorial") parser.add_argument("--src_img", default="sky.jpg", required=True, type=str, help="Source image to perform deep dram on") parser.add_argument("--directory", default="../dream_dir", type=str, help="Result directory to save intermediate images") parser.add_argument("--iterations", default="1000", type=int, help="How long to dream.") parser.add_argument("--save_every", default="1", type=int, help="Saving image after every _ iterations") parser.add_argument("--downscale_factor", default="3", type=int, help="Downscale factor for reducing image scale") parser.add_argument("--overwrite_save_dir", default=False, type=bool, help="Delete all files in selected directory") args = parser.parse_args() proc = preprocess_image(args.src_img) print(proc.shape) model = get_feature_extractor(layer_settings) print("model loaded\nDreaming") if not os.path.isdir(args.directory): try: os.mkdir(args.directory) print(f"created directory \"{args.directory}\"") except: print("couldn't create directory") if len(os.listdir(args.directory))>0 and args.overwrite_save_dir==True: for f in os.listdir(args.directory): os.remove(os.path.join(args.directory, f)) print("Directory cleaned") dream_on(proc, model, args.directory, iterations=args.iterations, save_every=args.save_every, downscale_factor=args.downscale_factor)
def test_all_images(): parser = argparse.ArgumentParser() arg = parser.add_argument # model-related variables arg('--model-path', type=str, help='Model path') arg('--dataset', type=str, help='roof: roof segmentation / income: income determination') # image-related variables arg('--masks-dir', type=str, default='./data/dataset/labels', help='numPy masks directory') arg('--npy-dir', type=str, default='./data/dataset/split_npy', help='numPy preprocessed patches directory') args = parser.parse_args() roof_path = "./data/dataset/split_npy" if args.dataset == "roof": model = load_model(args.model_path, UNet11) else: model = load_model(args.model_path, UNet11, input_channels=5, num_classes=4) # roof_model = load_model("./trained_models/model_10_percent_roof_Unet11_200epochs.pth", UNet11) if not os.path.exists("./data/test_all"): os.mkdir("./data/test_all") # Select sample pictures images_filenames = np.array(sorted(glob.glob(args.npy_dir + "/*.npy"))) for filename in tqdm(images_filenames): fig = plt.figure(figsize=(10, 10)) image = pickle.load(open(filename, "rb")) image = preprocess_image(image, args.dataset) pred = run_model(image, model, args.dataset) # if args.dataset == "income": # roof_image = pickle.load(open(os.path.join(roof_path, filename[filename.rfind("/") + 1:]), "rb")) # roof_image = preprocess_image(roof_image, "roof") # pred_roof = run_model(roof_image, roof_model, "roof") # pred[0][0] = pred[0][0] * pred_roof[0][0] # pred[0][1] = pred[0][1] * pred_roof[0][0] mask_path = os.path.join(args.masks_dir, args.dataset, filename[filename.rfind("/") + 1:]) y = pickle.load(open(mask_path, "rb")) fig.add_subplot(1, 3, 1) plt.imshow(reverse_transform(image.cpu().numpy()[0], args.dataset)) fig.add_subplot(1, 3, 2) plt.imshow(masks_to_colorimg(y, args.dataset)) fig.add_subplot(1, 3, 3) plt.imshow(pred_to_colorimg(pred.cpu().numpy(), args.dataset)) plt.savefig(os.path.join("./data/test_all", filename[filename.rfind("/") + 1:filename.rfind(".")] + ".png")) plt.clf() plt.close(fig)
def predict(sess, image_file): """ Runs the graph stored in "sess" to predict boxes for "image_file". Prints and plots the preditions. Arguments: sess -- your tensorflow/Keras session containing the YOLO graph image_file -- name of an image stored in the "images" folder. Returns: out_scores -- tensor of shape (None, ), scores of the predicted boxes out_boxes -- tensor of shape (None, 4), coordinates of the predicted boxes out_classes -- tensor of shape (None, ), class index of the predicted boxes Note: "None" actually represents the number of predicted boxes, it varies between 0 and max_boxes. """ image, image_data = preprocess_image("images/" + image_file, model_image_size = (608, 608)) out_scores, out_boxes, out_classes = sess.run(yolo_eval(yolo_outputs, image_shape), feed_dict={yolo_model.input:image_data, K.learning_phase():0}) print('Found {} boxes for {}'.format(len(out_boxes), image_file)) colors = generate_colors(class_names) draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors) image.save(os.path.join("out", image_file), quality=90) output_image = scipy.misc.imread(os.path.join("out", image_file)) imshow(output_image) return out_scores, out_boxes, out_classes
def deblur(image_path): data = { 'A_paths': [image_path], 'A': np.array([preprocess_image(load_image(image_path))]) } x_test = data['A'] g = generator_model() g.load_weights('generator.h5') generated_images = g.predict(x=x_test) generated = np.array([deprocess_image(img) for img in generated_images]) #kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]], np.float32) #锐化 print(generated.shape) #ima = Image.fromarray(generated) #dst = cv.filter2D(ima, -1, kernel=kernel) #dst.save("/content/drive/My Drive/5405_digitalMedia/result/e.png") #image_arr = np.array(dst) x_test = deprocess_image(x_test) ''' img = generated[0, :, :, :] im = Image.fromarray(img.astype(np.uint8)) im.save("/content/drive/My Drive/5405_digitalMedia/result/f.png") src = cv.imread("/content/drive/My Drive/5405_digitalMedia/result/f.png") kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]], dtype=np.float32) sharpen_image = cv.filter2D(src, cv.CV_32F, kernel=kernel) sharpen_image = cv.convertScaleAbs(sharpen_image) cv.imwrite("/content/drive/My Drive/5405_digitalMedia/result/g.png",sharpen_image) ''' for i in range(generated_images.shape[0]): x = x_test[i, :, :, :] img = generated[i, :, :, :] output = np.concatenate((x, img), axis=1) im = Image.fromarray(output.astype(np.uint8)) im.save("result.jpg") #('deblur'+image_path)
def predict_and_draw(sess, image, scores, boxes, classes, yolo_model): """ Runs the graph stored in "sess" to predict boxes and draw bounding boxes Arguments: sess -- your tensorflow/Keras session containing the YOLO graph image - Original Image scores -- tensor of shape (None, ), predicted score for each box boxes -- tensor of shape (None, 4), predicted box coordinates classes -- tensor of shape (None,), predicted class for each box yolo_model - pre-trained YOLO Model Returns: image -- Image with bounding box drawn """ # Preprocess your image image_data = preprocess_image(image, model_image_size=(608, 608)) # Run the session with the correct tensors and choose the correct placeholders in the feed_dict. # You'll need to use feed_dict={yolo_model.input: ... , K.learning_phase(): 0}) out_scores, out_boxes, out_classes = sess.run([scores, boxes, classes], feed_dict={yolo_model.input: image_data, K.learning_phase(): 0}) # Draw bounding boxes on the image file box = Box(image, out_scores, out_boxes, out_classes, class_names) box.draw_boxes() # return out_scores, out_boxes, out_classes return image
def predict(): input_size = (416, 416) tf.app.flags.DEFINE_string('image_file', './images/person.jpg', 'image_path') FLAGS = tf.app.flags.FLAGS image_file = FLAGS.image_file image = cv2.imread(image_file) image_shape = image.shape[:2] image_cp = preprocess_image(image, input_size) images = tf.placeholder(tf.float32, [1, input_size[0], input_size[1], 3]) detection_feat = darknet(images) feat_sizes = input_size[0] // 32, input_size[1] // 32 detection_results = decode(detection_feat, feat_sizes, len(class_names), anchors) checkpoint_path = "./checkpoint_dir/yolo2_coco.ckpt" #checkpoint_path = "/Users/xiang/Downloads/DeepLearning_tutorials-master/ObjectDetections/yolo2/checkpoint_dir/yolo2_coco.ckpt" saver = tf.train.Saver() with tf.Session() as sess: saver.restore(sess, checkpoint_path) bboxes, obj_probs, class_probs = sess.run(detection_results, feed_dict={images: image_cp}) bboxes, scores, class_inds = postprocess(bboxes, obj_probs, class_probs, image_shape=image_shape) img_detection = draw_detection(image, bboxes, scores, class_inds, class_names) cv2.imwrite("./res/detection.jpg", img_detection) cv2.imshow("detection results", img_detection) print('*****Click the window,and press any key to close!*****') cv2.waitKey(0) cv2.destroyAllWindows()
def main(): input_size = (416,416) image_file = './yolo2_data/car.jpg' image = cv2.imread(image_file) image_shape = image.shape[:2] #只取wh,channel=3不取 # copy、resize416*416、归一化、在第0维增加存放batchsize维度 image_cp = preprocess_image(image,input_size) # 【1】输入图片进入darknet19网络得到特征图,并进行解码得到:xmin xmax表示的边界框、置信度、类别概率 tf_image = tf.placeholder(tf.float32,[1,input_size[0],input_size[1],3]) model_output = darknet_slim(tf_image) # darknet19网络输出的特征图 output_sizes = input_size[0]//32, input_size[1]//32 # 特征图尺寸是图片下采样32倍 output_decoded = decode(model_output=model_output,output_sizes=output_sizes, num_class=len(class_names),anchors=anchors) # 解码 model_path = "models/model.ckpt" init_fn = slim.assign_from_checkpoint_fn(model_path,slim.get_variables()) with tf.Session() as sess: init_fn(sess) bboxes,obj_probs,class_probs = sess.run(output_decoded,feed_dict={tf_image:image_cp}) # 【2】筛选解码后的回归边界框——NMS(post process后期处理) bboxes,scores,class_max_index = postprocess(bboxes,obj_probs,class_probs,image_shape=image_shape) # 【3】绘制筛选后的边界框 img_detection = draw_detection(image, bboxes, scores, class_max_index, class_names) cv2.imwrite("./yolo2_data/detection.jpg", img_detection) print('YOLO_v2 detection has done!') cv2.imshow("detection_results", img_detection) cv2.waitKey(0)
def infer(image: str, phi: int = 0, saved_model: str = './savedmodel', classes: dict = None, score_threshold: float = 0.3, nms_threshold: float = 0.5, device: str = 'gpu'): if device != 'gpu': os.environ['CUDA_VISIBLE_DEVICES'] = '-1' #Using CPU else: os.environ['CUDA_VISIBLE_DEVICES'] = '0' #Using GPU #For COCO dataset if classes == None: classes = { value['id'] - 1: value['name'] for value in json.load(open('coco_90.json', 'r')).values() } #select resolution according to architecture image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] #To get different color for each class num_classes = len(classes.values()) colors = [ np.random.randint(0, 256, 3).tolist() for _ in range(num_classes) ] #load the model model = load_model(saved_model) #load and preprocess image img = cv2.imread(image) src_image = img.copy() img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) h, w = img.shape[:2] img, scale = preprocess_image(img, image_size=image_size) #detect and post process start = time.time() boxes, scores, labels = model.predict_on_batch( [np.expand_dims(img, axis=0)]) boxes, scores, labels = np.squeeze(boxes), np.squeeze(scores), np.squeeze( labels) end = time.time() boxes = postprocess_boxes(boxes=boxes, scale=scale, height=h, width=w) # print(f'infer time: {end-start}, fps: {1/(end-start)}') # select indices which have a score above the threshold indices = np.where(scores[:] > score_threshold)[0] # indices = tf.image.non_max_suppression(boxes,scores,max_output_size=[100],iou_threshold = nms_threshold,score_threshold = score_threshold) boxes = boxes[indices] labels = labels[indices] #draw boxes on the original image draw_boxes(src_image, boxes, scores, labels, colors, classes) return src_image
def plot_image_heatmap(self, img, top=1): img_tensor = preprocess_image(img, self.model.mean, self.model.std) # (1, 3, 299, 299) self._forward(img_tensor) cols = top + 1 plt.figure(figsize=(4 * cols, 4)) for i in range(cols): if i == 0: plt.subplot(1, cols, i + 1) plt.imshow(img, alpha=1.0) plt.title('Original image') plt.axis('off') else: class_idx = self._get_class_idx(i) label = self.idx2label[class_idx] proba = self.probas[class_idx] heatmap = self._generate_heatmap(class_idx) plt.subplot(1, cols, i + 1) plt.imshow(img, alpha=1.0) plt.imshow(heatmap, cmap='jet', alpha=0.5) plt.title('{} ({:.3f})'.format(label, proba)) plt.axis('off')
def main(): input_size = (416,416) image_file = './005767.jpg' image = cv2.imread(image_file) image_shape = image.shape[:2] tf.reset_default_graph() # copy、resize416*416、 image_cp = preprocess_image(image,input_size) #image_cp=np.ones([1,416,416,3]).astype(np.float32) image_cp=np.load("005767.npy")#("/home/huawei/chems/bioavailability_model/atlas_data/005767.npy") image_cp=np.transpose(image_cp,[0,2,3,1]) np.save("atoms.npy",image_cp) # with tf.name_scope('input'): tf_image = tf.placeholder(tf.float32,[1,input_size[0],input_size[1],3],name='input_data') #meta_variable=tf.placeholder(tf.float32,[1,1,len(class_names)*1024,1],name='meta_weigiht') model_output = Darknet(tf_image) #meta=np.ones([1,1,len(class_names)*1024,1], dtype=np.float32) model_path = "./yolov2_model/yolov2_coco.ckpt" saver = tf.train.Saver() with tf.Session() as sess: #sess.run(model_output,feed_dict={tf_image:image_cp,meta_variable:meta}) sess.run(tf.global_variables_initializer()) a=sess.run(model_output.rtn(),feed_dict={tf_image:image_cp}) a=np.transpose(a,[0,3,1,2]) #a=np.transpose(a,[0,3,2,1]) a=np.reshape(a,[-1])[:90] #print(a) for i in range(90): # print("=============================") print(a[i],i) saver.save(sess,model_path)
def get_data(self, image): with tf.name_scope('data'): jpeg = tf.read_file(image) image = tf.image.decode_jpeg(jpeg, channels=3) image = utils.preprocess_image(image, is_training=False) image = tf.expand_dims(image, 0) self.img = image
def r_mac_descriptor(self, file): """ Get the descriptor from the path of the img :param file: the path of the image :return: the descriptor """ # Load sample image # file = utils.DATA_DIR + 'sample.jpg' K.clear_session() img = image.load_img(file) # Resize scale = utils.IMG_SIZE / max(img.size) new_size = (int(np.ceil(scale * img.size[0])), int(np.ceil(scale * img.size[1])) ) # (utils.IMG_SIZE, utils.IMG_SIZE) #print('Original size: %s, Resized image: %s' % (str(img.size), str(new_size))) img = img.resize(new_size) # Mean substraction x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = utils.preprocess_image(x) # Load RMAC model Wmap, Hmap = self.get_size_vgg_feat_map(x.shape[3], x.shape[2]) regions = self.rmac_regions(Wmap, Hmap, 7) #print('Loading RMAC model...') model = self.rmac((x.shape[1], x.shape[2], x.shape[3]), len(regions)) # Compute RMAC vector #print('Extracting RMAC from image...') return model.predict([x, np.expand_dims(regions, axis=0)])
def read_and_decode(self, filename): filename_queue = tf.train.string_input_producer([filename]) reader = tf.TFRecordReader() _, serialized_example = reader.read(filename_queue) features = tf.parse_single_example(serialized_example, features={ 'image_raw': tf.FixedLenFeature([], tf.string), 'label_raw': tf.FixedLenFeature([], tf.string), 'height': tf.FixedLenFeature([], tf.int64), 'width': tf.FixedLenFeature([], tf.int64) }) height = tf.cast(features['height'], tf.int32) width = tf.cast(features['width'], tf.int32) image = tf.decode_raw(features['image_raw'], tf.uint8) image = tf.reshape(image, [height, width, 3]) label = tf.decode_raw(features['label_raw'], tf.uint8) label = tf.reshape(label, [height, width, 1]) image, label = preprocess_image(image, label, is_training=self.config.is_training) return image, label
def execute(file, curr, rank): # Load sample image # file = utils.DATA_DIR + 'sample.jpg' img = image.load_img(file) # Resize scale = utils.IMG_SIZE / max(img.size) new_size = (int(np.ceil(scale * img.size[0])), int(np.ceil(scale * img.size[1]))) print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())), str(curr), "is processing...") img = img.resize(new_size) # Mean substraction x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = utils.preprocess_image(x) # Load RMAC model Wmap, Hmap = get_size_vgg_feat_map(x.shape[3], x.shape[2]) regions = rmac_regions(Wmap, Hmap, 3) # print('Loading RMAC model...') model = rmac((x.shape[1], x.shape[2], x.shape[3]), len(regions), rank) # Compute RMAC vector # print('Extracting RMAC from image...') RMAC = model.predict([x, np.expand_dims(regions, axis=0)]) return RMAC
def compute_features(images, args): """ Compute feature values for images :param images: List of images to compute features for :param args: Run-time arguments :return: Feature layer values for images """ # Verify that pre-trained feature model exist if not os.path.exists(args.feature_model): logging.critical('Checkpoint %s does not exist' % args.feature_model) sys.exit(1) with tf.Graph().as_default(): # Pre-process images input_images = [ preprocess_image('%s/%s.jpg' % (path, image_id), args) for path, _, image_id in images ] # Run pre-processed images through network return run_network(feature_network(args), args.feature_model, args, train=False, value=input_images)
def main(): os.environ['CUDA_VISIBLE_DEVICES'] = '0' phi = 0 weighted_bifpn = False model_path = 'checkpoints/flir_59_0.1409_0.6001.h5' image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] # coco classes classes = { value['id'] - 1: value['name'] for value in json.load(open('coco_90.json', 'r')).values() } num_classes = 3 score_threshold = 0.01 colors = [ np.random.randint(0, 256, 3).tolist() for _ in range(num_classes) ] _, model = efficientdet(phi=phi, weighted_bifpn=weighted_bifpn, num_classes=num_classes, score_threshold=score_threshold) model.load_weights(model_path, by_name=True) video_path = r'G:\datasets\iray\cap\20200515_100016.avi' video_path = r'G:\datasets\iray\cap\20200515_100016.avi' video_path = r'G:\projects\20200513_102922.avi' cap = cv2.VideoCapture(video_path) while True: ret, image = cap.read() if not ret: break src_image = image.copy() # BGR -> RGB image = image[:, :, ::-1] h, w = image.shape[:2] image, scale = preprocess_image(image, image_size=image_size) # run network start = time.time() boxes, scores, labels = model.predict_on_batch( [np.expand_dims(image, axis=0)]) boxes, scores, labels = np.squeeze(boxes), np.squeeze( scores), np.squeeze(labels) print(time.time() - start) boxes = postprocess_boxes(boxes=boxes, scale=scale, height=h, width=w) # select indices which have a score above the threshold indices = np.where(scores[:] > score_threshold)[0] # select those detections boxes = boxes[indices] labels = labels[indices] draw_boxes(src_image, boxes, scores, labels, colors, classes) cv2.namedWindow('image', cv2.WINDOW_NORMAL) cv2.imshow('image', src_image) cv2.waitKey(0)
import numpy as np import tensorflow as tf import cv2 from PIL import Image from model import darknet from detect_ops import decode from utils import preprocess_image, postprocess, draw_detection from config import anchors, class_names input_size = (416, 416) image_file = "./images/car.jpg" image = cv2.imread(image_file) image_shape = image.shape[:2] image_cp = preprocess_image(image, input_size) """ image = Image.open(image_file) image_cp = image.resize(input_size, Image.BICUBIC) image_cp = np.array(image_cp, dtype=np.float32)/255.0 image_cp = np.expand_dims(image_cp, 0) #print(image_cp) """ images = tf.placeholder(tf.float32, [1, input_size[0], input_size[1], 3]) detection_feat = darknet(images) feat_sizes = input_size[0] // 32, input_size[1] // 32 detection_results = decode(detection_feat, feat_sizes, len(class_names), anchors) checkpoint_path = "./checkpoint_dir/yolo2_coco.ckpt"
POOLING_FUNCTION = 'MAX' # Load images content_image = utils.read_image(CONTENT_PATH) style_image = utils.read_image(STYLE_PATH) g = tf.Graph() with g.device(DEVICE), g.as_default(), tf.Session() as sess: # 1. Compute content representation print("1. Computing content representation...") content_shape = (1,) + content_image.shape # add batch size dimension x = tf.placeholder(tf.float32, content_shape) net, activations, img_mean = vgg.net(VGG_19_PATH, x, pooling_function=POOLING_FUNCTION) # Pre-process image content_image_pp = utils.preprocess_image(content_image, img_mean) content_representation = activations[CONTENT_LAYER].eval(feed_dict={x: np.array([content_image_pp])}) # 2. Compute style Gram matrices print("2. Computing style Gram matrices...") style_shape = (1,) + style_image.shape # add batch size dimension x = tf.placeholder(tf.float32, style_shape) net, activations, _ = vgg.net(VGG_19_PATH, x, pooling_function=POOLING_FUNCTION) # Pre-process image style_image_pp = utils.preprocess_image(style_image, img_mean) style_layer_shapes = {} gram_matrices = {} for style_layer, _ in STYLE_LAYERS.items():
import cv2 import numpy as np import tensorflow as tf import matplotlib.image as mpimg from ssd_300_vgg import SSD from utils import preprocess_image, process_bboxes from visualization import plt_bboxes ssd_net = SSD() classes, scores, bboxes = ssd_net.detections() images = ssd_net.images() sess = tf.Session() # Restore SSD model. ckpt_filename = './ssd_checkpoints/ssd_vgg_300_weights.ckpt' sess.run(tf.global_variables_initializer()) saver = tf.train.Saver() saver.restore(sess, ckpt_filename) img = cv2.imread('./demo/dog.jpg') img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img_prepocessed = preprocess_image(img) rclasses, rscores, rbboxes = sess.run([classes, scores, bboxes], feed_dict={images: img_prepocessed}) rclasses, rscores, rbboxes = process_bboxes(rclasses, rscores, rbboxes) plt_bboxes(img, rclasses, rscores, rbboxes)