Inception: Wie Bild mit Inception zu verarbeiten

Question

Ich möchte Tensorflow Einführung v3 machen Tags für ein Bild ausgeben. Mein Ziel ist es, ein JPEG-Bild in eine Eingabe zu konvertieren, die von einem neuralen Netzwerk angenommen wird. Ich weiß nicht, wie ich die Bilder zuerst verarbeiten soll, damit sie mit dem v3-Modell von Google Inception laufen können. Das ursprüngliche tensorflow Projekt ist hier: https://github.com/tensorflow/models/tree/master/inception

Ursprünglich alle Bilder sind in einem Datensatz und der gesamte Datensatz wird zuerst in ImageProcessing.py zur Eingabe() oder distorted_inputs() übergeben. Die Bilder im Datensatz werden verarbeitet und an die Methoden train() oder eval() übergeben (beides Arbeiten). Das Problem ist, ich möchte eine Funktion, um Tags für ein bestimmtes Bild (kein Dataset) auszudrucken.

Unten ist der Code für Inferenz-Funktion, die verwendet wird, um Tag mit Google-Einführung zu generieren. inceptionv4 Funktion ist ein konvolutionelles neuronales Netzwerk im Tensorflow implementiert.

def inference(images, num_classes, for_training=False, restore_logits=True, 
       scope=None): 
    """Build Inception v3 model architecture. 

    See here for reference: http://arxiv.org/abs/1512.00567 

    Args: 
    images: Images returned from inputs() or distorted_inputs(). 
    num_classes: number of classes 
    for_training: If set to `True`, build the inference model for training. 
     Kernels that operate differently for inference during training 
     e.g. dropout, are appropriately configured. 
    restore_logits: whether or not the logits layers should be restored. 
     Useful for fine-tuning a model with different num_classes. 
    scope: optional prefix string identifying the ImageNet tower. 

    Returns: 
    Logits. 2-D float Tensor. 
    Auxiliary Logits. 2-D float Tensor of side-head. Used for training only. 
    """ 
    # Parameters for BatchNorm. 
    batch_norm_params = { 
     # Decay for the moving averages. 
     'decay': BATCHNORM_MOVING_AVERAGE_DECAY, 
     # epsilon to prevent 0s in variance. 
     'epsilon': 0.001, 
    } 
    # Set weight_decay for weights in Conv and FC layers. 
    with slim.arg_scope([slim.ops.conv2d, slim.ops.fc], weight_decay=0.00004): 
    with slim.arg_scope([slim.ops.conv2d], 
         stddev=0.1, 
         activation=tf.nn.relu, 
         batch_norm_params=batch_norm_params): 
     logits, endpoints = inception_v4(
      images, 
      dropout_keep_prob=0.8, 
      num_classes=num_classes, 
      is_training=for_training, 
      scope=scope) 

    # Add summaries for viewing model statistics on TensorBoard. 
    _activation_summaries(endpoints) 

    # Grab the logits associated with the side head. Employed during training. 
    auxiliary_logits = endpoints['AuxLogits'] 

    return logits, auxiliary_logits 

Dies ist mein Versuch, das Bild zu verarbeiten, bevor es an die Inferenzfunktion übergeben wird.

def process_image(self, image_path): 
    filename_queue = tf.train.string_input_producer(image_path) 
    reader = tf.WholeFileReader() 
    key, value = reader.read(filename_queue) 

    img = tf.image.decode_jpeg(value) 
    height = self.image_size 
    width = self.image_size 
    image_data = tf.cast(img, tf.float32) 
    image_data = tf.reshape(image_data, shape=[1, height, width, 3]) 
    return image_data 

Ich wollte eine Bilddatei einfach verarbeiten, damit ich sie an die Inferenzfunktion übergeben kann. Und diese Schlussfolgerung druckt die Tags aus. Der obige Code nicht funktioniert hat und gedruckte Fehler:

ValueError: Shape() must have rank at least 1

ich schätzen, wenn jemand einen Einblick in dieses Problem zur Verfügung stellen kann.

Answer 1

Inception benötigt nur (299,299,3) Bilder mit Eingängen zwischen -1 und 1. Siehe Code unten. Ich ändere einfach die Bilder, indem ich sie benutze, und lege sie in ein TFRecord (und dann in die Warteschlange), um meine Sachen laufen zu lassen.

from PIL import Image 
import PIL 
import numpy as np 
def load_image(self, image_path): 
    img = Image.open(image_path) 
    newImg = img.resize((299,299), PIL.Image.BILINEAR).convert("RGB") 
    data = np.array(newImg.getdata()) 
    return 2*(data.reshape((newImg.size[0], newImg.size[1], 3)).astype(np.float32)/255) - 1