add keras_reid

Author: michuanhaohao

aug.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jun  8 10:37:16 2017
+
+@author: luohao
+"""
+
+import cv2
+import numpy as np
+import nori2 as nori
+from tqdm import tqdm
+
+def augment(img, rng, img_shape,do_training):
+#    img = imgproc.resize_preserve_aspect_ratio(img, image_shape)
+
+    if do_training:
+        # data augmentation from fb.resnet.torch
+        # https://github.com/facebook/fb.resnet.torch/blob/master/datasets/imagenet.lua
+        def scale(img, size):
+            s = size / min(img.shape[0], img.shape[1])
+            h, w = int(round(img.shape[0] * s)), int(round(img.shape[1] * s))
+            return cv2.resize(img, (w, h))
+        def center_crop(img, shape):
+            h, w = img.shape[:2]
+            sx, sy = (w - shape[1]) // 2, (h - shape[0]) // 2
+            img = img[sy:sy + shape[0], sx:sx + shape[1]]
+            return img
+        def random_sized_crop(img):
+            NR_REPEAT = 10
+            h, w = img.shape[:2]
+            area = h * w
+            ar = [3. / 4, 4. / 3]
+            for i in range(NR_REPEAT):
+                target_area = rng.uniform(0.08, 1.0) * area
+                target_ar = rng.choice(ar)
+                nw = int(round((target_area * target_ar) ** 0.5))
+                nh = int(round((target_area / target_ar) ** 0.5))
+                if rng.rand() < 0.5:
+                    nh, nw = nw, nh
+                if nh <= h and nw <= w:
+                    sx, sy = rng.randint(w - nw + 1), rng.randint(h - nh + 1)
+                    img = img[sy:sy + nh, sx:sx + nw]
+                    return cv2.resize(img, image_shape[::-1])
+            size = min(image_shape[0], image_shape[1])
+            return center_crop(scale(img, size), image_shape)
+        def grayscale(img):
+            w = np.array([0.114, 0.587, 0.299]).reshape(1, 1, 3)
+            gs = np.zeros(img.shape[:2])
+            gs = (img * w).sum(axis=2, keepdims=True)
+            return gs
+        def brightness_aug(img, val):
+            alpha = 1. + val * (rng.rand() * 2 - 1)
+            img = img * alpha
+            return img
+        def contrast_aug(img, val):
+            gs = grayscale(img)
+            gs[:] = gs.mean()
+            alpha = 1. + val * (rng.rand() * 2 - 1)
+            img = img * alpha + gs * (1 - alpha)
+            return img
+        def saturation_aug(img, val):
+            gs = grayscale(img)
+            alpha = 1. + val * (rng.rand() * 2 - 1)
+            img = img * alpha + gs * (1 - alpha)
+            return img
+        def color_jitter(img, brightness, contrast, saturation):
+            augs = [(brightness_aug, brightness),
+                    (contrast_aug, contrast),
+                    (saturation_aug, saturation)]
+            rng.shuffle(augs)
+            for aug, val in augs:
+                img = aug(img, val)
+            return img
+        def lighting(img, std):
+            eigval = np.array([0.2175, 0.0188, 0.0045])
+            eigvec = np.array([
+                [-0.5836, -0.6948,  0.4203],
+                [-0.5808, -0.0045, -0.8140],
+                [-0.5675, 0.7192, 0.4009],
+            ])
+            if std == 0:
+                return img
+            alpha = rng.randn(3) * std
+            bgr = eigvec * alpha.reshape(1, 3) * eigval.reshape(1, 3)
+            bgr = bgr.sum(axis=1).reshape(1, 1, 3)
+            img = img + bgr
+            return img
+        def horizontal_flip(img, prob):
+            if rng.rand() < prob:
+                return img[:, ::-1]
+            return img
+#        def warp_perspective(img):
+#            c = (
+#                ((-50, 50), (-10, 10)),
+#                ((-50, 50), (-10, 10)),
+#                ((-50, 50), (-10, 10)),
+#                ((-50, 50), (-10, 10))
+#            )
+#            mat = imgaug.get_random_perspective_transform_mat(
+#                rng, c, image_shape)
+#            return cv2.warpPerspective(img, mat, image_shape)
+        img = color_jitter(img, brightness=0.4, contrast=0.4, saturation=0.4)
+        img = lighting(img, 0.1)
+        img = horizontal_flip(img, 0.5)
+        img = np.minimum(255.0, np.maximum(0, img))
+#    return np.rollaxis(img, 2).astype('float32')
+    return img.astype('float32')  #return h*w*3
+
+def aug_nhw3(imgs):
+    for ind in range(len(imgs)):
+        img = imgs[ind]
+        rng = np.random.RandomState()
+        do_training = True
+        imgs[ind] = augment(img, rng, (128,128),do_training)
+    return imgs
+
+def aug_n3hw(imgs):
+    imgs = np.transpose(imgs,(0,2,3,1))
+    imgs = aug_nhw3(imgs)
+    imgs = np.transpose(imgs,(0,3,1,2))
+    return imgs
+    
+
+
+

reid_classification.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Jun  2 16:21:54 2017
+
+@author: luohao
+"""
+
+import numpy as np
+
+
+from keras import optimizers
+from keras.utils import np_utils, generic_utils
+from keras.models import Sequential,Model
+from keras.layers import Dropout, Flatten, Dense,Input
+from keras.applications.resnet50 import ResNet50
+from keras.applications.imagenet_utils import preprocess_input
+from keras import backend as K
+from keras.layers.core import Lambda
+from sklearn.preprocessing import normalize
+from keras.preprocessing.image import ImageDataGenerator
+from keras.initializers import RandomNormal
+
+
+import numpy.linalg as la
+from IPython import embed
+
+#欧式距离 
+def euclidSimilar(query_ind,test_all,top_num):  
+    le = len(test_all)
+    dis = np.zeros(le)
+    for ind in range(le):
+        sub = test_all[ind]-query_ind
+        dis[ind] = la.norm(sub)
+    ii = sorted(range(len(dis)), key=lambda k: dis[k])
+#    print(ii[:top_num+1])
+    return ii[1:top_num+1]
+
+def euclidSimilar2(query_ind,test_all):  
+    le = len(test_all)
+    dis = np.zeros(le)
+    for ind in range(le):
+        sub = test_all[ind]-query_ind
+        dis[ind] = la.norm(sub)    
+    ii = sorted(range(len(dis)), key=lambda k: dis[k])
+#    embed()
+#    print(ii[:top_num+1])
+    return ii
+
+def get_top_ind(query_all,test_all,top_num):
+    query_num = len(query_all)
+    query_result_ind = np.zeros([query_num,top_num],np.int32)
+    for ind in range(query_num):
+        query_result_ind[ind]=euclidSimilar(query_all[ind],test_all,top_num)
+#        if np.mod(ind,100)==0:
+#            print('query_ind '+str(ind))
+    return query_result_ind
+
+def get_top_label(query_result_ind):
+    num = len(query_result_ind)
+    top_num = len(query_result_ind[0])
+    query_top_label = np.zeros([num,top_num],np.int32)
+    for ind in range(num):
+        for ind2 in range(top_num):
+            query_top_label[ind][ind2]= test_label[query_result_ind[ind][ind2]]
+#        if np.mod(ind,100)==0:
+#            print('query_label '+str(ind))
+#        print(query_top_label[ind])
+    return query_top_label
+
+def get_top_acc(test_label,query_result_label):
+       query_label= test_label
+       top1 = 0
+       top5 = 0
+       top10 = 0 
+       for ind in range(len(query_result_label)):
+           query_temp_label = query_result_label[ind]-query_label[ind]
+#           print(query_temp_label)
+           query_temp = np.where(query_temp_label==0)
+           if len(query_temp[0] >0):
+               if query_temp[0][0]<1:
+                   top1 = top1+1
+               if query_temp[0][0]<5:
+                   top5 = top5+1    
+               if query_temp[0][0]<10:
+                   top10 = top10+1
+       ind = ind +1
+       top1 = top1/ind*1.0
+       top5 = top5/ind*1.0
+       top10 = top10/ind*1.0
+       print(str(ind)+' query images')
+       return top1,top5,top10
+
+
+def single_query(query_feature,test_feature,query_label,test_label,test_num):
+    test_label_set = np.unique(test_label)
+    #single_num = len(test_label_set)
+    test_label_dict={}
+    topp1=0
+    topp5=0
+    topp10=0
+    for ind in range(len(test_label_set)):
+        test_label_dict[test_label_set[ind]]=np.where(test_label==test_label_set[ind])
+    for ind in range(test_num):
+        query_int = np.random.choice(len(query_label))
+        label = query_label[query_int]        
+        temp_int = np.random.choice(test_label_dict[label][0],1)
+        temp_gallery_ind = temp_int 
+        for ind2 in range(len(test_label_set)):
+            temp_label = test_label_set[ind2]
+            if temp_label != label:
+                temp_int = np.random.choice(test_label_dict[temp_label][0],1)
+                temp_gallery_ind = np.append(temp_gallery_ind,temp_int)
+        single_query_feature =  query_feature[query_int]
+        test_all_feature = test_feature[temp_gallery_ind]
+        result_ind = euclidSimilar2(single_query_feature,test_all_feature)
+        query_temp = result_ind.index(0)
+        if query_temp<1:
+            topp1 = topp1+1
+        if query_temp<5:
+            topp5 = topp5+1    
+        if query_temp<10:
+            topp10 = topp10+1
+    topp1 =topp1/test_num*1.0
+    topp5 =topp5/test_num*1.0
+    topp10 =topp10/test_num*1.0
+    print('single query')
+    print('top1: '+str(topp1)+'\n')
+    print('top5: '+str(topp5)+'\n')
+    print('top10: '+str(topp10)+'\n')  
+    
+
+"================================"
+
+identity_num = 6273
+
+print('loading data...')
+## please add your loading validation data here 
+
+
+#from load_market_img import get_img
+#query_img,test_img,query_label,test_label=get_img()
+test_img =preprocess_input(test_img)
+query_img = preprocess_input(query_img)
+
+''''''''''''''''''''''''''
+datagen = ImageDataGenerator(horizontal_flip=True)
+
+# load pre-trained resnet50
+base_model = ResNet50(weights='imagenet', include_top=False, input_tensor=Input(shape=(224,224,3)))
+x = base_model.output
+feature = Flatten(name='flatten')(x)
+fc1 = Dropout(0.5)(feature)
+preds = Dense(identity_num, activation='softmax', name='fc8', kernel_initializer=RandomNormal(mean=0.0, stddev=0.001))(fc1)  #default glorot_uniform
+net = Model(input=base_model.input, output=preds)
+feature_model = Model(input=base_model.input, output=feature)
+
+#training IDE model for all layers
+for layer in net.layers:
+   layer.trainable = True
+
+# train
+batch_size = 16
+#step 1
+adam = optimizers.Adam(lr=0.001)
+net.compile(optimizer=adam, loss='categorical_crossentropy',metric ='accuracy')
+
+# your can add a pre-trained model here
+#net.load_weights('net_ide.h5')
+from load_img_data import get_train_img
+  
+ind = 0
+while(True):
+    train_img,train_label = get_train_img(8000) #add your loading training data here
+    train_img = preprocess_input(train_img)
+    train_label_onehot = np_utils.to_categorical(train_label,identity_num)
+    net.fit_generator(datagen.flow(train_img, train_label_onehot, batch_size=batch_size),
+                        steps_per_epoch=len(train_img)/batch_size, epochs=1)
+    ind = ind+1
+    # your can add sth here
+    # if np.mod(ind,100) == 0:
+