def load_batch(split_name, dataset, batch_size, height, width): data_provider = slim.dataset_data_provider.DatasetDataProvider( dataset, common_queue_capacity=24 + 3 * batch_size, common_queue_min=24) if split_name == "test": raw_image, img_name = data_provider.get(["image", "img_name"]) image = preprocess_image(raw_image, height, width, False) #获取一个batch的数据 images, img_names = tf.train.batch([image, img_name], batch_size=batch_size, num_threads=4, capacity=4 * batch_size, allow_smaller_final_batch=True) return images, img_names else: raw_image, img_label = data_provider.get(["image", "label"]) #Perform the correct preprocessing for this image depending if it is training or evaluating image = preprocess_image(raw_image, height, width, True) #As for the raw images, we just do a simple reshape to batch it up raw_image = tf.expand_dims(raw_image, 0) raw_image = tf.image.resize_nearest_neighbor(raw_image, [height, width]) raw_image = tf.squeeze(raw_image) #获取一个batch数据 images, raw_image, labels = tf.train.batch( [image, raw_image, img_label], batch_size=batch_size, num_threads=4, capacity=4 * batch_size, allow_smaller_final_batch=True) return images, raw_image, labels
def load_image(image_path, label, is_training): image_buffer = tf.read_file(image_path) image = tf.image.decode_png(image_buffer, channels=3) image = tf.cast(image, tf.float32) image = tf.cond(is_training, true_fn=lambda: inception_preprocessing.preprocess_image( image, 224, 224, is_training=True), false_fn=lambda: inception_preprocessing.preprocess_image( image, 224, 224, is_training=False)) return image, label
def read_one_image(fname, **kwargs): """Reads one image given a filepath Parameters ----------- fname : str path to a JPEG file img_shape : tuple (kwarg) shape of the eventual image. Default is (224, 224, 3) is_training : bool (kwarg) boolean to tell the loader function if the graph is in training mode or testing. Default is True Returns ------- preprocessed image """ img_shape = kwargs.pop("image_shape", (224, 224, 3)) is_training = kwargs.pop("is_training", False) # read the image file content = tf.read_file(fname) # decode buffer as jpeg img_raw = tf.image.decode_jpeg(content, channels=img_shape[-1]) return preprocess_image(img_raw, img_shape[0], img_shape[1], is_training=is_training)
def load_data_v2(image_paths, do_random_crop, do_random_flip, image_size, do_prewhiten=True, sess=None): nrof_samples = len(image_paths) images = np.zeros((nrof_samples, image_size, image_size, 3)) import cv2 for i in range(nrof_samples): #img = misc.imread(image_paths[i]) file_contents = tf.read_file(image_paths[i]) img = tf.image.decode_jpeg(file_contents) img.set_shape((image_size, image_size, 3)) # if img.ndim == 2: # img = to_rgb(img) # if do_prewhiten: # img = prewhiten(img) # img = crop(img, do_random_crop, image_size) # img = flip(img, do_random_flip) img = porcessor.preprocess_image(img, tf.constant(160, tf.int32), tf.constant(160, tf.int32), is_training=True) # img = tf.image.central_crop(img, central_fraction=0.875) img = sess.run(img) cv2.imwrite(image_paths[i] + "_" + str(i) + ".jpg", img) images[i, :, :, :] = img return images
def init_cnn_graph(self, checkpoints_path): with self.graph.as_default(): tf_global_step = tf.train.get_or_create_global_step() self.image_input = tf.placeholder(tf.float32, shape=(None, None, 3)) image = inception_preprocessing.preprocess_image( self.image_input, self.inception_dim, self.inception_dim, is_training=False, center_crop=self.center_crop, ) images = tf.expand_dims(image, 0) with slim.arg_scope(self.arg_scope): slim_args = [slim.batch_norm, slim.dropout] with slim.arg_scope(slim_args, is_training=False): with tf.variable_scope('InceptionV3', reuse=None) as scope: net, _ = inception.inception_v3_base( images, final_endpoint=self.endpoint, scope=scope) self.net = tf.reduce_mean(net, [0, 1, 2]) variable_averages = tf.train.ExponentialMovingAverage( self.moving_average_decay, tf_global_step) variables_to_restore = variable_averages.variables_to_restore() self.init_fn = slim.assign_from_checkpoint_fn( checkpoints_path, variables_to_restore)
def preproc(input_images, height=input_size, width=input_size): ''' preprocess the input image for evaluation using inception-resnet-v2 ''' images = [] raw_images = [] for i in range(50): raw_image = input_images[i] #Perform the correct preprocessing for this image depending if it is training or evaluating image = inception_preprocessing.preprocess_image(raw_image, height, width, is_training=False) image = tf.expand_dims(image, 0) #As for the raw images, we just do a simple reshape to batch it up raw_image = tf.expand_dims(raw_image, 0) raw_image = tf.image.resize_nearest_neighbor(raw_image, [height, width]) if i == 0: images = image raw_images = raw_image else: images = tf.concat([images, image], 0) raw_images = tf.concat([raw_images, raw_image], 0) return images, raw_images
def read_one_image(fname, **kwargs): """Reads one image given a filepath Parameters ----------- fname : str path to a JPEG file img_shape : tuple (kwarg) shape of the eventual image. Default is (224, 224, 3) is_training : bool (kwarg) boolean to tell the loader function if the graph is in training mode or testing. Default is True Returns ------- preprocessed image """ img_shape = kwargs.pop("image_shape", (224, 224, 3)) is_training = kwargs.pop("is_training", False) # read the image file content = tf.read_file(fname) # decode buffer as jpeg img_raw = tf.image.decode_jpeg(content, channels=img_shape[-1]) return preprocess_image(img_raw, img_shape[0], img_shape[1], is_training=is_training)
def load_batch(dataset, batch_size, num_classes, height, width, is_training=True): data_provider = slim.dataset_data_provider.DatasetDataProvider( dataset, common_queue_capacity=24 + 3 * batch_size, common_queue_min=24) xx = ["image"] for i in range(num_classes): xx.append("label_" + str(i)) raw_image, label0, label1, label2, label3, label4, label5, label6, label7, label8, label9, label10, label11 = data_provider.get( xx) label = tf.stack([ label0, label1, label2, label3, label4, label5, label6, label7, label8, label9, label10, label11 ]) image = inception_preprocessing.preprocess_image(raw_image, height, width, is_training) raw_image = tf.expand_dims(raw_image, 0) raw_image = tf.image.resize_nearest_neighbor(raw_image, [height, width]) raw_image = tf.squeeze(raw_image) images, raw_images, labels = tf.train.batch([image, raw_image, label], batch_size=batch_size, num_threads=4, capacity=4 * batch_size, allow_smaller_final_batch=True) return images, raw_images, labels
def load_batch(dataset, batch_size, height=0, width=0, is_training=True): data_provider = slim.dataset_data_provider.DatasetDataProvider( dataset, common_queue_capacity=24 + 3 * batch_size, common_queue_min=24) raw_image, label = data_provider.get(['image', 'label']) image = inception_preprocessing.preprocess_image(raw_image, height, width, is_training) #image = tf.expand_dims(raw_image, 0) #image = tf.image.resize_nearest_neighbor(image, [height, width]) #image = tf.squeeze(image) #image = tf.cast(image, tf.float32) raw_image = tf.expand_dims(raw_image, 0) raw_image = tf.image.resize_nearest_neighbor(raw_image, [3 * height, 3 * width]) raw_image = tf.squeeze(raw_image) images, raw_images, labels = tf.train.batch([image, raw_image, label], batch_size=batch_size, num_threads=4, capacity=4 * batch_size, allow_smaller_final_batch=True) return images, raw_images, labels
def preprocess(filename_queue, image_size): reader = tf.WholeFileReader() key, value = reader.read(filename_queue) image = tf.image.decode_image(value, channels=3) precessed_image = inception_preprocessing.preprocess_image( image, image_size, image_size, is_training=False) return key, precessed_image
def preprocess_fn(path): image = tf.read_file(path) image = tf.image.decode_jpeg(image, channels=3) image = inception_preprocessing.preprocess_image(image, FLAGS.width, FLAGS.height, is_training=False) return image
def load_batch(dataset, batch_size, height=image_size, width=image_size, is_training=True): ''' Loads a batch for training. INPUTS: - dataset(Dataset): a Dataset class object that is created from the get_split function - batch_size(int): determines how big of a batch to train - height(int): the height of the image to resize to during preprocessing - width(int): the width of the image to resize to during preprocessing - is_training(bool): to determine whether to perform a training or evaluation preprocessing OUTPUTS: - images(Tensor): a Tensor of the shape (batch_size, height, width, channels) that contain one batch of images - labels(Tensor): the batch's labels with the shape (batch_size,) (requires one_hot_encoding). ''' #First create the data_provider object data_provider = slim.dataset_data_provider.DatasetDataProvider( dataset, common_queue_capacity=24 + 3 * batch_size, common_queue_min=24) #BY using data_provider TO GET raw image raw_image, label = data_provider.get(['image', 'label']) #Perform the correct preprocessing for this image depending if it is training or evaluating image = inception_preprocessing.preprocess_image(raw_image, height, width, is_training) #As for the raw images, we just do a simple reshape to batch it up ## keep raw image that is not preprocessed for the inception model so that #we can display it as an image in its original form. We only do a #simple reshaping so that it fits together nicely in one batch. #tf.expand_dims will expand the 3D tensor #from a [height, width, channels] shape to [1, height, width, channels] shape, #while tf.squeeze will simply eliminate all the dimensions with the number ‘1’, #which brings the raw_image back to the same 3D shape after reshaping raw_image = tf.expand_dims(raw_image, 0) raw_image = tf.image.resize_nearest_neighbor(raw_image, [height, width]) raw_image = tf.squeeze(raw_image) #Finally, we just create the images and labels batch, using multiple threads to dequeue the examples #for training. The capacity is simply the capacity for the internal FIFO queue that exists #by default when you create a tf.train.batch, and a higher capacity is recommended if you have an unpredictable data input/output. This can data I/O stability can be seen through a summary created by default on TensorBoard when you use the tf.train.batch function. We also let allow_smaller_final_batch be True to use the last few examples even if they are insufficient to make a batch. images, raw_images, labels = tf.train.batch([image, raw_image, label], batch_size=batch_size, num_threads=4, capacity=4 * batch_size, allow_smaller_final_batch=True) return images, raw_images, labels
def _flow_preprocess(mv_record, height, width, input_size, bbox, train=True): mv_record_shape = tf.shape(mv_record) mv_bytes = 2 * tf.multiply(height, width) temporal_depth = input_size[-1] mv_input = tf.random_crop(mv_record, [temporal_depth, mv_bytes]) mv_input = tf.reshape(mv_input, [-1]) # split each list element into x and y components and stack depth wise image_shape = tf.stack([2 * temporal_depth, height, width]) image_chunk = tf.reshape(mv_input, image_shape) image_chunk = tf.transpose(image_chunk, perm=[1, 2, 0]) #### [H,W,20] # cast image block as float image_chunk = tf.cast(image_chunk, tf.float32) def normalize_images(image_chunk): #mean subtraction and normalization mean, variance = tf.nn.moments(image_chunk, axes=[0, 1]) ################ [H,W,20] float_image = tf.subtract(image_chunk, tf.expand_dims(tf.expand_dims(mean, 0), 0)) ################ -mean? return float_image image_chunk = normalize_images(image_chunk) # rescale between [0,1] image_chunk = tf.truediv( tf.subtract(image_chunk, tf.reduce_min(image_chunk)), tf.subtract(tf.reduce_max(image_chunk), tf.reduce_min(image_chunk))) # if bbox provided don't distort and just crop and resize #bbox_distortion = False if bbox is not None else True bbox_distortion = True resized_image_chunk, distorted_bbox = inception_preprocessing.preprocess_image( image_chunk, input_size[0], input_size[1], is_training=train, depth=2 * temporal_depth, color_distortion=False, bbox=bbox, bbox_distortion=bbox_distortion) float_image = tf.image.resize_images(resized_image_chunk, size=[input_size[0], input_size[1]]) print float_image # convert to 3D tensor float_image = convert_2D_to_3D_tensor(float_image, input_size) return float_image, distorted_bbox
def batch_valid(start,batch_size): data=[] for i in range(batch_size): raw_image=validation_images[start+i] raw_image=np.reshape(raw_image,(20,64,3)) raw_image1=tf.convert_to_tensor(raw_image,dtype=tf.float64) image = inception_preprocessing.preprocess_image(raw_image1, height=image_size, width=image_size, is_training=True) data.append(image) x1=tf.reshape(data,[batch_size,299,299,3]) return x1
def readFromTFRecords(self, flag, filename, num_epochs, img_shape, batch_size, num_threads, min_after_dequeue=100): if flag: num_epochs = num_epochs else: num_epochs = 1 filename_queue = tf.train.string_input_producer(filename, num_epochs=num_epochs) # def read_and_decode(filename_queue, img_shape): reader = tf.TFRecordReader() _, serialized_example = reader.read(filename_queue) features = tf.parse_single_example(serialized_example, features={ 'image/class/label': tf.FixedLenFeature([], tf.int64), 'image/encoded': tf.FixedLenFeature([], tf.string) }) # image = tf.image.decode_jpeg(features['image/encoded'],3) # image = tf.reshape(image, img_shape) # THIS IS IMPORTANT # image = tf.cast(image, tf.float32) image = tf.image.decode_jpeg(features['image/encoded'], 3) image = inception_preprocessing.preprocess_image( image, img_shape[0], img_shape[1], is_training=self.flag, ) sparse_label = features['image/class/label'] # tf.int64 # return image, sparse_label # image, sparse_label = read_and_decode(filename_queue, img_shape) # share filename_queue with multiple threads # tf.train.shuffle_batch internally uses a RandomShuffleQueue images, sparse_labels = tf.train.shuffle_batch( [image, sparse_label], batch_size=batch_size, num_threads=num_threads, min_after_dequeue=min_after_dequeue, capacity=min_after_dequeue + (num_threads + 1) * batch_size) return images, sparse_labels
def resnet_process_data_dir(work_dir, data_dir, model_dir): resNet_path = os.path.join(work_dir, 'ResNet') pickle_out = os.path.join(resNet_path, 'ResNet_preprocess.pk') if not os.path.exists(resNet_path): os.makedirs(resNet_path) if os.path.isfile(pickle_out): os.remove(pickle_out) print('ResNet preprocessing for ' + resNet_path) # Image directory info. img_files = sorted( [name for name in os.listdir(data_dir) if _is_img(name)]) print('data_dir:{}'.format(data_dir)) print('frames_num:{}'.format(len(img_files))) print('img_files:') print(img_files) img_list = [] for pic in img_files: img_list.append(os.path.join(data_dir, pic)) # Pre-process using ResNet. img_size = resnet_v2.resnet_v2.default_image_size resnet_v2_model = os.path.join(model_dir, 'resnet_v2_50.ckpt') print('resnet_v2_model:{}'.format(resnet_v2_model)) with tf.Graph().as_default(): processed_images = [] for i, img in enumerate(img_list): # 读取图片并按照jpg格式转化为3通道的张量 image = tf.image.decode_jpeg(tf.read_file(img), channels=3) # 预处理:双线性插值resize固定尺寸(224),中心裁剪0.875,float类型并且[0,1],normalization去均值化除以标准差 processed_images.append( inception_preprocessing.preprocess_image(image, img_size, img_size, is_training=False)) processed_images = tf.convert_to_tensor(processed_images) with slim.arg_scope(resnet_v2.resnet_arg_scope()): # Return ResNet 2048 vector. logits, _ = resnet_v2.resnet_v2_50(processed_images, num_classes=None, is_training=False) init_fn = slim.assign_from_checkpoint_fn( resnet_v2_model, slim.get_variables_to_restore()) with tf.Session() as sess: init_fn(sess) np_images, resnet_vectors = sess.run([processed_images, logits]) resnet_vectors = resnet_vectors[:, 0, 0, :] print('form pickle_data......') # Save preprocessed data to pickle file. pickle_data = {'frame_resnet_vectors': resnet_vectors} pickle.dump(pickle_data, open(pickle_out, 'wb')) print('resNet finished!') print('{} has been dumped over!'.format(pickle_out))
def build_model(self): self.input = tf.placeholder(tf.uint8, [None, None, 3]) self.processed_image = inception_preprocessing.preprocess_image( self.input, self.height, self.width, is_training=False) self.processed_images = tf.expand_dims(self.processed_image, 0) with slim.arg_scope(inception_v3_arg_scope()): self.logits, self.end_points = inception_v3(self.processed_images, num_classes=1001, is_training=False) self.probabilities = tf.nn.softmax(self.logits)
def parser(filename, label, class_num, height, witdh, is_training): # with tf.gfile.GFile(filename, 'rb') as f: img = tf.read_file(filename) # f.read() img = tf.image.decode_jpeg(img, channels=3) img_resized = inception_preprocessing.preprocess_image( img, height, witdh, is_training=is_training, add_image_summaries=False) # NOTE the inception_preprocessing will convert image scale to [-1,1] one_hot_label = tf.one_hot(label, class_num, 1, 0) # NOTE label should expand axis # one_hot_label = one_hot_label[tf.newaxis, tf.newaxis, :] return img_resized, one_hot_label
def _inception_preprocess_patches(data): patches = [] for _ in range(num_of_patches): patches.append( inception_preprocessing.preprocess_image( data["image"], resize_size[0], resize_size[1], is_training, add_image_summaries=False)) patches = tf.stack(patches) data["image"] = patches return data
def load_batch(dataset, batch_size, height=img_height, width=img_width, is_training=True): ''' Loads a batch for training. INPUTS: - dataset(Dataset): a Dataset class object that is created from the get_split function - batch_size(int): determines how big of a batch to train - height(int): the height of the image to resize to during preprocessing - width(int): the width of the image to resize to during preprocessing - is_training(bool): to determine whether to perform a training or evaluation preprocessing OUTPUTS: - images(Tensor): a Tensor of the shape (batch_size, height, width, channels) that contain one batch of images - labels(Tensor): the batch's labels with the shape (batch_size,) (requires one_hot_encoding). ''' # First create the data_provider object data_provider = slim.dataset_data_provider.DatasetDataProvider( dataset, common_queue_capacity=24 + 3 * batch_size, common_queue_min=24) # Obtain the raw image using the get method raw_image, label = data_provider.get(['image', 'label']) # Perform the correct preprocessing for this image depending if it is training or evaluating image = inception_preprocessing.preprocess_image(raw_image, height, width, is_training) image = tf.reshape(image, [img_height, img_width, 3]) label = tf.cast(label, tf.int32) """ image = raw_image.eval(session=sess) image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) image = cv2.resize(image, (img_width, img_height), 0, 0, cv2.INTER_LINEAR) image = image.astype(np.float32) image = np.multiply(image, 1.0 / 255.0) label = label.eval(session=sess) # Batch up the image and label return image, label """ #As for the raw images, we just do a simple reshape to batch it up raw_image = tf.expand_dims(raw_image, 0) raw_image = tf.image.resize_nearest_neighbor(raw_image, [height, width]) raw_image = tf.squeeze(raw_image) #Batch up the image by enqueing the tensors internally in a FIFO queue and dequeueing many elements with tf.train.batch. images, labels = tf.train.batch( [image, label], batch_size = batch_size, num_threads = 4, capacity = 4 * batch_size, allow_smaller_final_batch = True) print("images tensor data type:", tf.shape(images)) return images, raw_image, labels
def getvector(imagedir): slim = tf.contrib.slim batch_size = 3 image_size = v3.inception_v3.default_image_size url = "http://download.tensorflow.org/models/inception_v3_2016_08_28.tar.gz" checkpoints_dir = os.getcwd() if not tf.gfile.Exists(checkpoints_dir + '/inception_v3.ckpt'): dataset_utils.download_and_uncompress_tarball(url, checkpoints_dir) with tf.Graph().as_default(): # imagedir = '/home/jiexun/Desktop/Siraj/ImageChallenge/Necessary/train/cat.0.jpg' image_string = tf.read_file(imagedir) image = tf.image.decode_jpeg(image_string, channels=3) #Intentando reparar el resize ''' print(image.shape) print(image) image=tf.cast(image, tf.float32) image=tf.image.resize_images(image, [299, 299]) print(image.shape) print(image) image_jpg = tf.image.encode_jpeg(image) plt.imshow(image_jpg) ''' #fin de parche processed_image = inception_preprocessing.preprocess_image(image, image_size, image_size, is_training=False) processed_images = tf.expand_dims(processed_image, 0) # Create the model, use the default arg scope to configure the batch norm parameters. print('Inicializando el modelo InceptionV3...') with slim.arg_scope(v3.inception_v3_arg_scope()): vector, _ = v3.inception_v3(processed_images, num_classes=1001, is_training=False) init_fn = slim.assign_from_checkpoint_fn(os.path.join(checkpoints_dir, 'inception_v3.ckpt'), slim.get_model_variables('InceptionV3')) with tf.Session() as sess: init_fn(sess) np_image, vector = sess.run([image, vector]) a = np.asarray([x for xs in vector for xss in xs for xsss in xss for x in xsss]) np.reshape(a, (1, 2048)) return a
def load_batch(dataset, batch_size, height=image_h, width=image_w, is_training=True): ''' Loads a batch for training. INPUTS: - dataset(Dataset): a Dataset class object that is created from the get_split function - batch_size(int): determines how big of a batch to train - height(int): the height of the image to resize to during preprocessing - width(int): the width of the image to resize to during preprocessing - is_training(bool): to determine whether to perform a training or evaluation preprocessing OUTPUTS: - images(Tensor): a Tensor of the shape (batch_size, height, width, channels) that contain one batch of images - labels(Tensor): the batch's labels with the shape (batch_size,) (requires one_hot_encoding). ''' #First create the data_provider object data_provider = slim.dataset_data_provider.DatasetDataProvider( dataset, #common_queue_capacity = 24 + 3 * batch_size, #common_queue_min = 24) common_queue_capacity=3 * batch_size, common_queue_min=2) #Obtain the raw image using the get method raw_image, label = data_provider.get(['image', 'label']) #Perform the correct preprocessing for this image depending if it is training or evaluating image = inception_preprocessing.preprocess_image(raw_image, height, width, is_training) #As for the raw images, we just do a simple reshape to batch it up raw_image = tf.expand_dims(raw_image, 0) raw_image = tf.image.resize_nearest_neighbor(raw_image, [height, width]) raw_image = tf.squeeze(raw_image) #Batch up the image by enqueing the tensors internally in a FIFO queue and dequeueing many elements with tf.train.batch. images, raw_images, labels = tf.train.batch([image, raw_image, label], batch_size=batch_size, num_threads=4, capacity=4 * batch_size, allow_smaller_final_batch=True) return images, raw_images, labels
def fname_to_image_tensor(fname, label, image_root, image_size): """ Loads and resizes an image given by FID. Pass-through the PID. """ # Since there is no symbolic path.join, we just add a '/' to be sure. image_encoded = tf.read_file(tf.reduce_join([image_root, '/', fname])) # tf.image.decode_image doesn't set the shape, not even the dimensionality, # because it potentially loads animated .gif files. Instead, we use either # decode_jpeg or decode_png, each of which can decode both. # Sounds ridiculous, but is true: # https://github.com/tensorflow/tensorflow/issues/9356#issuecomment-309144064 image_decoded = tf.image.decode_jpeg(image_encoded, channels=3) #image_resized = tf.image.resize_images(image_decoded, image_size) # Preprocess images image_resized = inception_preprocessing.preprocess_image(image_decoded, image_size[0], image_size[1], is_training=True) return image_resized, fname, label
def _dataset_parser(self, serialized_proto): """Parse an Imagenet record from value.""" keys_to_features = { 'image/encoded': tf.FixedLenFeature((), tf.string, default_value=''), 'image/format': tf.FixedLenFeature((), tf.string, default_value='jpeg'), 'image/class/label': tf.FixedLenFeature([], dtype=tf.int64, default_value=-1), 'image/class/text': tf.FixedLenFeature([], dtype=tf.string, default_value=''), 'image/object/bbox/xmin': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/ymin': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/xmax': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/ymax': tf.VarLenFeature(dtype=tf.float32), 'image/object/class/label': tf.VarLenFeature(dtype=tf.int64), } features = tf.parse_single_example(serialized_proto, keys_to_features) bbox = None image = features['image/encoded'] image = tf.image.decode_jpeg(image, channels=3) image = tf.image.convert_image_dtype(image, dtype=tf.float32) image = inception_preprocessing.preprocess_image( image=image, output_height=self.hparams.image_size, output_width=self.hparams.image_size, is_training=self.is_training, # If eval_from_hub, do not scale the images during preprocessing. scaled_images=not self.eval_from_hub, bbox=bbox) label = tf.cast( tf.reshape(features['image/class/label'], shape=[]), dtype=tf.int32) return image, label
def getfeatures(file_name): # Extract the features from InceptionNet (The features of Mixed_6a layer) slim = tf.contrib.slim image_size = inception_v4.inception_v4.default_image_size checkpoints_dir = os.getcwd() with tf.Graph().as_default(): image_path = tf.read_file(file_name) image = tf.image.decode_jpeg(image_path, channels=3) processed_image = inception_preprocessing.preprocess_image(image, image_size, image_size, is_training=False) processed_images = tf.expand_dims(processed_image, 0) with slim.arg_scope(inception_v4.inception_v4_arg_scope()): vector = inception_v4.inception_v4(processed_images, num_classes=1001, is_training=False) init_fn = slim.assign_from_checkpoint_fn(os.path.join(checkpoints_dir, 'inception_v4.ckpt'), slim.get_model_variables('InceptionV4')) with tf.Session() as sess: init_fn(sess) np_image, vector = sess.run([image, vector]) vector = np.asarray(vector) # print vector[1]['Mixed_6a'].shape return vector[1]['Mixed_6a']
def load_batch(dataset, batch_size=batch_size, height=image_size, width=image_size, is_training=True): """Loads a single batch of data for training. Args: dataset: The dataset to load, created in the get_split function. batch_size: The number of images in the batch. height(int): int value that is the size the image will be resized to during preprocessing width: The size that the image will be resized to during preprocessing is_training: Whether or not we're currently training or evaluating. Returns: images: A Tensor of size [batch_size, height, width, channels(3)], image samples that have been preprocessed, that contain one batch of images. images_raw: A Tensor of size [batch_size, height, width, 3], image samples that can be used for visualization. labels: A Tensor of size [batch_size], whose values range between 0 and dataset.num_classes (requires one-hot encodings) """ # First create the data_provider object data_provider = slim.dataset_data_provider.DatasetDataProvider( dataset, common_queue_capacity=32, common_queue_min=8) # Obtain the raw image using the get method raw_image, label = data_provider.get(['image', 'label']) # Perform the correct preprocessing for this image depending if it is training or evaluating image = inception_preprocessing.preprocess_image(raw_image, height, width, is_training) # Preprocess the image for display purposes. raw_image = tf.expand_dims(raw_image, 0) raw_image = tf.image.resize_nearest_neighbor(raw_image, [height, width]) raw_image = tf.squeeze(raw_image) # Batch up the images by enqueing the tensors internally in a FIFO queue and dequeueing many elements with tf.train.batch. images, raw_images, labels = tf.train.batch( [image, raw_image, label], batch_size=batch_size, num_threads=4, capacity=4 * batch_size, allow_smaller_final_batch=True) return images, raw_images, labels
def get_batch(image, label, image_W, image_H, batch_size, capacity): image = tf.cast(image, tf.string) label = tf.cast(label, tf.int32) # make an input queue input_queue = tf.train.slice_input_producer([image, label], shuffle=False) label = input_queue[1] image_contents = tf.read_file(input_queue[0]) image = tf.image.decode_jpeg(image_contents, channels=3) # 数据增强 image = preprocess_image(image, image_H, image_W, is_training=True) # 标准化,使图片的均值为0,方差为1 image = tf.image.per_image_standardization(image) image_batch, label_batch = tf.train.batch([image, label], batch_size=batch_size, num_threads=64, capacity=capacity) tf.summary.image("input_img", image_batch, max_outputs=5) label_batch = tf.reshape(label_batch, [batch_size]) image_batch = tf.cast(image_batch, tf.float32) return image_batch, label_batch
def clone_fn(images): images = tf.reshape(images, [IMAGE_SIZE, IMAGE_SIZE, 3]) images = preprocess_image(images, IMAGE_SIZE, IMAGE_SIZE, is_training=False) images = tf.reshape(images, [FLAGS.batch_size, IMAGE_SIZE, IMAGE_SIZE, 3]) logits, _ = inference(images, num_classes=36, for_training=False, restore_logits=True, scope=None) predictions = { 'classes': tf.argmax(logits, axis=1, name='classes'), 'probabilities': tf.nn.softmax(logits, name='probabilities') } return predictions
def record_parser(value, is_training): """Parse an ImageNet record from `value`.""" keys_to_features = { 'image/encoded': tf.FixedLenFeature((), tf.string, default_value=''), 'image/format': tf.FixedLenFeature((), tf.string, default_value='jpeg'), 'image/class/label': tf.FixedLenFeature([], dtype=tf.int64, default_value=-1), 'image/class/text': tf.FixedLenFeature([], dtype=tf.string, default_value=''), 'image/object/bbox/xmin': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/ymin': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/xmax': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/ymax': tf.VarLenFeature(dtype=tf.float32), 'image/object/class/label': tf.VarLenFeature(dtype=tf.int64), } parsed = tf.parse_single_example(value, keys_to_features) image = tf.image.decode_image( tf.reshape(parsed['image/encoded'], shape=[]), _NUM_CHANNELS) image = tf.image.convert_image_dtype(image, dtype=tf.float32) image = inception_preprocessing.preprocess_image( image=image, height=_DEFAULT_IMAGE_SIZE, width=_DEFAULT_IMAGE_SIZE, is_training=is_training) label = tf.cast(tf.reshape(parsed['image/class/label'], shape=[]), dtype=tf.int32) return image, tf.one_hot(label, _LABEL_CLASSES)
def process_image(image): root_dir = "images/" filename = root_dir + image with open(filename, "rb") as f: image_str = f.read() if image.endswith('jpg'): raw_image = tf.image.decode_jpeg(image_str, channels=3) elif image.endswith('png'): raw_image = tf.image.decode_png(image_str, channels=3) else: print("Image must be either jpg or png") return image_size = 299 # ImageNet image size, different models may be sized differently processed_image = inception_preprocessing.preprocess_image(raw_image, image_size, image_size, is_training=False) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) raw_image, processed_image = sess.run([raw_image, processed_image]) return raw_image, processed_image.reshape(-1, 299, 299, 3)
def preprocess_raw_bytes(image_bytes, is_training=False, bbox=None): """Preprocesses a raw JPEG image. This implementation is shared in common between train/eval pipelines, and when serving the model. Args: image_bytes: A string Tensor, containing the encoded JPEG. is_training: Whether or not to preprocess for training. bbox: In inception preprocessing, this bbox can be used for cropping. Returns: A 3-Tensor [height, width, RGB channels] of type float32. """ image = tf.image.decode_jpeg(image_bytes, channels=3) image = tf.image.convert_image_dtype(image, dtype=tf.float32) if FLAGS.preprocessing == 'vgg': image = vgg_preprocessing.preprocess_image( image=image, output_height=FLAGS.height, output_width=FLAGS.width, is_training=is_training, resize_side_min=_RESIZE_SIDE_MIN, resize_side_max=_RESIZE_SIDE_MAX) elif FLAGS.preprocessing == 'inception': image = inception_preprocessing.preprocess_image( image=image, output_height=FLAGS.height, output_width=FLAGS.width, is_training=is_training, bbox=bbox) else: assert False, 'Unknown preprocessing type: %s' % FLAGS.preprocessing return image
def getfeatures(file_name): # Extract the features from InceptionNet (The features of Mixed_6a layer) slim = tf.contrib.slim image_size = inception_v4.inception_v4.default_image_size checkpoints_dir = os.getcwd() with tf.Graph().as_default(): image_path = tf.read_file(file_name) image = tf.image.decode_jpeg(image_path, channels=3) processed_image = inception_preprocessing.preprocess_image( image, image_size, image_size, is_training=False) processed_images = tf.expand_dims(processed_image, 0) with slim.arg_scope(inception_v4.inception_v4_arg_scope()): vector = inception_v4.inception_v4(processed_images, num_classes=1001, is_training=False) init_fn = slim.assign_from_checkpoint_fn( os.path.join(checkpoints_dir, 'inception_v4.ckpt'), slim.get_model_variables('InceptionV4')) with tf.Session() as sess: init_fn(sess) np_image, vector = sess.run([image, vector]) vector = np.asarray(vector) # print vector[1]['Mixed_6a'].shape return vector[1]['Mixed_6a']