This article will caffe/python Next classify.py Code and related classifier.py and io.py Analyze .

One ,classify.py

    By the last if__name__ == '__main__':
main(sys.argv) Run on the command line on behalf of the file , Run main function , Parameters stored in sys.argv in . stay main In function definition , Judge and store various parameters separately , They are as follows :

    input_file: input image , Parameter is required .

    output_file: output file , Parameter is required .

    --model_def: Network test structure file , Default is imagenet Of deploy.txt file

    --pretrained_model: Network parameter file , Default is imagenet Of bvlc_reference_caffenet.caffemodel file .

    --gpu: Yes no gpu calculation ,action=’store
true’ Indicates if not specified , Default false, use cpu, Otherwise true, use gpu. For one 128*128 Grayscale image of ,cpu Forward calculation approximate 20ms, and gpu only 5ms about .

   
--center_only: default false, That is, to predict the cropped image of the input image , Then average the results ; Designated as true, That is, only the middle part of the input image is taken for one prediction . of course , If the specified input image is the same as the crop size , Then take the middle part as the original picture itself .

    --images_dim: Enter image size , Only height and width are considered , default 256*256.

   
--mean_file: Mean value file . Note that the data format is npy file , Store as numpy.array format , Dimension is ( passageway , high , wide ). If only through compute_mean.bin Calculated mean file , Conversion required . The default mean value file is imagenet Of ilsvrc_2012_mean.npy file .

    --input_scale: Scaling factor after image preprocessing , Occurs after subtracting the mean , Default is 1.

    --raw_scale: Scaling factor before image preprocessing , Before subtracting the mean . Because the pixel value read in is [0,1] section , The default is 255.0, Make pixels in [0,255] section .

   
--channel_swap: Channel adjustment , Default is ’2,1,0’, because caffe adopt opencv The image channel read in is BGR, Therefore, it is necessary to RGB-->BGR, That is 0 Channels and 2 Channel switching .

    --ext: default ’jpg’, Represents if the input is specified as a directory , Only the suffix is read jpg Documents of .

    The following parameters are improved versions classify.py China Singapore .

    --labels_file: Label category file , Default is imagenet Of synset_words.txt file .

    --print_results: Print results to screen , Do not specify false, Designated as true.

    --force_grayscale: Whether to specify input as single channel image , Do not specify false, Designated as true.

    adopt args= parser.parse_args() to update , Confirm the final input parameters . The following is a classification test :

    # List generation , Dividing dimension strings by commas , And forced into int type . Last is the list .

image_dims = [int(s) for s inargs.images_dim.split(',')]

    # If the mean value file is specified , Then load the mean value file

    if args.mean_file:

mean =np.load(args.mean_file)

    # If it's a grayscale image , No channel switching . If it is rgb image , If there is a channel switch , Dividing strings by commas , Forced conversion to int type , Save to list .

    if args.force_grayscale:

        channel_swap = None

    else:

        if args.channel_swap

            channel_swap = [int(s) for s inargs.channel_swap.split(',')]

    # If specified gpu, Start gpu pattern

    if args.gpu:

        caffe.set_mode_gpu()

        print("GPU mode")

    else:

        caffe.set_mode_cpu()

        print("CPU mode")

    # Initialize classifier , see classifier.py

    classifier = caffe.Classifier(..)

    # Here is the code to read the file , It is reported that loading gray-scale image will report an error , Here is the sum of recorded gray levels rgb Image code .

    if args.force_grayscale:

   # there false Representative returns single channel image , see io.py

        inputs =[caffe.io.load_image(args.input_file, False)]

    else:

       inputs = [caffe.io.load_image(args.input_file)]

  # inputs use [] Put it all together , Representative list storage , therefore len(inputs) Represents how many input images there are .

 

    # time , Here ms In units

    start = time.time() * 1000

    # Forward calculation , see classifier.py, obtain preditions by np array , Number of input images , Number of forecast categories

    predictions = classifier.predict(inputs,not args.center_only)

    print("Done in %.2f ms." %(time.time() * 1000 - start))

    print("Predictions : %s"% predictions)

 

    # Print results , Rank by score , Give the top five categories with higher scores , Class name by labels_file appoint .

    # print result, add by caisenchuan

    if args.print_results:

        ...

Two ,Classifier.py

    This file defines classifier class , Includes initialization functions __init__ and predict function .

1, __init__:

    First called caffe Class initialization function , And set test pattern .

    Then called transformer class , with cifar-10 take as an example , Enter as dictionary {’data’: (1,3,32,32)}.

    And then there was set_transpose method :

    # From dimension (32,32,3) Convert to (3,32,32), For caffe Processing in

    self.transformer.set_transpose(in_,(2, 0, 1))

    Then call transformer Class set method , Setting various parameters , See below for details io.py Parsing in .

    last , On the definition of image dimension :

    # Cut size according to prototxt definition

    self.crop_dims =np.array(self.blobs[in_].data.shape[2:])

    # If the picture size parameter is not defined , Is equal to the cut size ; Otherwise, by definition

    # generally speaking , If a cut is used , Image size > Cut size

    if not image_dims:

        image_dims = self.crop_dims

    self.image_dims = image_dims

2, predict:

    Perform forward calculation , Predicting the probability of image classification . Parameter is the Boolean value of the input and oversampling .

    # definition inputs_ dimension (m,h,w,channel)

    input_ = np.zeros((len(inputs),

                   self.image_dims[0],

                   self.image_dims[1],

                   inputs[0].shape[2]),

                   dtype=np.float32)

    # Unify all dimensions to be classified into image_dims size

    for ix, in_ in enumerate(inputs):

        input_[ix] = caffe.io.resize_image(in_,self.image_dims)

    # If oversampling , Each image is generated by clipping 10 Images

    # Dimension will become (10*m,h,w,channel)

    if oversample:

        # Generate center, corner, and mirroredcrops.

        input_ = caffe.io.oversample(input_,self.crop_dims)

    # otherwise , Crop center region . Take the midpoint of image size , Then take the cutting length up and down respectively .

    # with 64*64 Crop 32*32 take as an example ,(64,64) Take the midpoint -->(32,32), Expand to four coordinates -->(32,32,32,32),

    # Take cutting size (32,32,32,32)+(-16,-16,16,16)-->(16,16,48,48)

    else:

        # Take center crop.

        center = np.array(self.image_dims) /2.0

        crop = np.tile(center, (1, 2))[0] +np.concatenate([

            -self.crop_dims / 2.0,

            self.crop_dims / 2.0

        ])

        crop = crop.astype(int)

        input_ = input_[:, crop[0]:crop[2],crop[1]:crop[3], :]

    # Convert input to caffe Required format , Dimension becomes (m,channel,h,w)

    caffe_in =np.zeros(np.array(input_.shape)[[0, 3, 1, 2]],

                    dtype=np.float32)

    # Preprocess each image , see io.py Of preprocess function

    for ix, in_ in enumerate(input_):

        caffe_in[ix] =self.transformer.preprocess(self.inputs[0], in_)

    # Forward calculation , Output as dictionary ,out[‘prob’] For all kinds of probability

    out =self.forward_all(**{self.inputs[0]: caffe_in})

    predictions = out[self.outputs[0]]

 

    # If oversampling , Every 10 Average forecast results

    if oversample:

        predictions =predictions.reshape((len(predictions) / 10, 10, -1))

        predictions = predictions.mean(1)

    # Return results

    return predictions

Three ,io.py

    This document focuses on pretreatment class Transformer Member functions of .

1,preprocess

    Note that the comment part of the function shows the whole process of preprocessing , include :

    Convert to single precision ;

    resize To uniform size ;

    Dimension to (channel,h,w);

    Channel switching , Convert to BGR;

    Scale before mean ;   

    Subtract mean ;

    Scale after subtracting mean .

    Important code :

    ...

     # return [h,w]

    in_dims = self.inputs[in_][2:]

    # The input image is different from the specified size , be resize unified

    if caffe_in.shape[:2] != in_dims:

       caffe_in = resize_image(caffe_in, in_dims)

    # Dimension transformation

    if transpose is not None:

        caffe_in = caffe_in.transpose(transpose)

    # Channel switching , refer to channel Exchange of ,h and w unchanged

    if channel_swap is not None:

       caffe_in = caffe_in[channel_swap, :, :]

    # multiplication

    if raw_scale is not None:

       caffe_in *= raw_scale

    # subtraction

    if mean is not None:

       caffe_in -= mean

    # multiplication

    if input_scale is not None:

      caffe_in *= input_scale

    return caffe_in

2,load_image, be careful color Parameter default True

    # utilize skimage Tools read in pictures , Default read in color picture , If as_grey by 1, Then read in the gray image ; Read in value is [0,1] Floating point number of

    img =skimage.img_as_float(skimage.io.imread(filename,

                       as_grey=notcolor)).astype(np.float32)

    # Make sure to return a three-dimensional array .

    if img.ndim == 2:

   # If only two dimensions are read in , Need to add dimension

        img = img[:, :, np.newaxis]

        if color:

            # If it's a gray image, it's read in as a color image , Then expand to three channels

            img = np.tile(img, (1, 1, 3))

        elif img.shape[2] == 4:

            # If there are four channels , Remove the fourth channel

            img= img[:, :, :3]

        # return (h,w,3) Array of

    return img

 

   
also resize_image,oversample, And all kinds of set function , I won't introduce them here . so-called caffe Of python Interface or matlab Interface , It's all right caffe Input preprocessing and output result processing of , Regardless of the intermediate process of network computing .

Technology
©2019-2020 Toolsou All rights reserved,
JS How to operate java Realize the function of grabbing red packets C Language programming to find a student's grade The United Nations 《 Glory of Kings 》 Please go to the studio : To save the earth Dialogue between apple and Nissan suspended ,Apple Car How's it going ?CSS architecture design China's longest high speed rail officially opened ! The fastest way to finish the race 30.5 hour First knowledge MySQL Comprehensive review ( dried food )2021 year 1 Monthly programmer salary statistics , average 14915 element How to use it quickly html and css Write static page