def prepare(Params, data): ''' resizing the images to fit the resNet50V2 performig preprocessing and fit it into numpy array :param:data: image + labels dataframe :param: Params: pipe parameters :return: dataframe with resized images ''' copy_data = data.copy() size = Params['Prepare']['size'] # resizing the images copy_data['Data'] = copy_data['Data'].apply( lambda x: cv2.resize(x, (size, size))) # applying resNetV2 pre_processing to fit the model copy_data['Data'] = copy_data['Data'].apply(lambda x: preprocess_input(x)) train_Set = [] labels_set = [] for img in copy_data['Data']: train_Set.append(img) for label in copy_data['Labels']: labels_set.append(label) train_Set = np.array(train_Set) labels_set = np.array(labels_set) return train_Set, labels_set
def eraser(input_img): input_img = preprocess_input(input_img) img_h, img_w, img_c = input_img.shape p_1 = np.random.rand() if p_1 > p: return input_img while True: s = np.random.uniform(s_l, s_h) * img_h * img_w r = np.random.uniform(r_1, r_2) w = int(np.sqrt(s / r)) h = int(np.sqrt(s * r)) left = np.random.randint(0, img_w) top = np.random.randint(0, img_h) if left + w <= img_w and top + h <= img_h: break if pixel_level: c = np.random.uniform(v_l, v_h, (h, w, img_c)) else: c = np.random.uniform(v_l, v_h) input_img[top:top + h, left:left + w, :] = c return input_img
def getData(params_data): """ The function get the data from the data_path :param params_data: parameters for getting the data :return: a dictionary contains the data (dict as 'name: image') and the labels (list of 1/0) """ print('\nStart getting the data') image_size = params_data['size'] # The desirable size of the images images_names = os.listdir(data_path) # Get all the names of the images labels_file_name = params_data['labels_file_name'] # The name of the file containing the labels labels = sio.loadmat(data_path + '\\' + labels_file_name)['Labels'][0].tolist() # Load the labels data = {} for name in images_names: # Skip on the mat file if '.mat' in name: continue img_path = data_path + '\\' + name # Get the path of the current image name_key = name.split('.')[0] # Get only the name of the image without the .jpeg image = cv2.imread(img_path) # Get the current image image = cv2.resize(image, (image_size[0], image_size[1])) # Resize the image # image = cv2.normalize(image, None, alpha=-1, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F) # Norm image image = resnet_v2.preprocess_input(image) data[name_key] = image print('End getting the data') return {'data': data, 'labels': labels}
def get_and_resize_test_data(width, height): """Gets the test data and resize it. Arguments: width {int} -- Width of the resized image height {int} -- Height of the resized image Returns: [np.ndarray] -- Matrix with all the images, resized. """ test_data = [] for file in sorted(os.listdir("../data/testing/"), key=lambda x: int(x.split('.')[0])): image = load_img("../data/testing/" + file, grayscale=False, color_mode='rgb') image = img_to_array(image, dtype='float') width, height, _ = image.shape if width != max_width or height != max_height: image = cv2.resize(image, (max_width, max_height)) image = np.expand_dims(image, axis=0) image = preprocess_input(image) test_data.append(np.array(image)) test_data = np.asarray(test_data) return test_data
def preprocessData(): """Get training images and resize each one of them to get the size of the bigger image in the data set Returns: X [np.ndarray] -- Matrix with all the images, resized. y [type] -- Matrix 1*N, with the class of each image. """ list_of_classes = [] index = 0 #getting each class from data for _, dirs, files in os.walk("../data/training/", topdown=False): for name in dirs: list_of_classes.append(name) hash_map[name] = index index += 1 number_files = len( fnmatch.filter(os.listdir("../data/training/" + name), '*.jpg')) X = [] y = [] #get the size of the biggest image for current_class in list_of_classes: for index in range(100): image = load_img('../data/training/' + current_class + '/' + str(index) + '.jpg', grayscale=False, color_mode='rgb') image = img_to_array(image, dtype='float') width, height, _ = image.shape max_width = max(width, max_width) max_height = max(height, max_height) #resizing every image for current_class in list_of_classes: for index in range(100): image = load_img('../data/training/' + current_class + '/' + str(index) + '.jpg', grayscale=False, color_mode='rgb') image = img_to_array(image, dtype='float') width, height, _ = image.shape if width != max_width or height != max_height: image = cv2.resize(image, (max_width, max_height)) image = np.expand_dims(image, axis=0) image = preprocess_input(image) X.append(image) y.append(hash_map[current_class]) X = np.asarray(X) y = np.asarray(y) return X, y
def extract_feat(self, img_path): img = image.load_img(img_path, target_size=(self.input_shape[0], self.input_shape[1])) img = image.img_to_array(img) img = np.expand_dims(img, axis=0) img = preprocess_input(img) feat = self.model.predict(img) # print("------"+str(feat.shape[0])+"-----"+str(feat.shape[1])) norm_feat = feat[0] / LA.norm(feat[0]) return norm_feat
def extract_features(filename, model): # load the models image = load_img(filename, target_size=(224,224)) # convert image pixels to numpy array image = img_to_array(image) # reshape data image = np.expand_dims(image, axis=0) # preprocess image for model image = preprocess_input(image) # get features feature = model.predict(image,verbose=0) return feature
def extract_feat(self, img_path, regions): img = image.load_img(img_path, target_size=(self.input_shape[0], self.input_shape[1])) img = image.img_to_array(img) img = np.expand_dims(img, axis=0) img = preprocess_input(img) feat = self.model.predict(img) print(type(feat)) print(feat.shape) roi_pools = roi.RoiPooling().get_pooled_rois(feat, regions) print(roi_pools.shape) # print("------"+str(feat.shape[0])+"-----"+str(feat.shape[1])) norm_feat = feat[0] / LA.norm(feat[0]) for i in range(len(regions)): roi_pools[i] = roi_pools[i][0] / LA.norm(roi_pools[i][0]) return roi_pools
def DefineLandmark(self): model = MobileNet() # load an image from file image = load_img('birthday-cake-600x600.jpg', target_size=(224, 224)) # convert the image pixels to a numpy array image = img_to_array(image) # reshape data for the model image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2])) # prepare the image for the VGG model image = preprocess_input(image) # predict the probability across all output classes yhat = model.predict(image) # convert the probabilities to class labels label = decode_predictions(yhat) # retrieve the most likely result, e.g. highest probability label2 = label[0] print(type(label2)) for i in label2: print('%s (%.2f%%)' % (i[1], i[2] * 100)) return label2
def extract_features(directory): # load model model = ResNet50V2(weights="imagenet") model.layers.pop() # re-structure the model by replacing the last output layer model = Model(inputs=model.inputs, outputs=model.layers[-1].output) # sumarize print(model.summary()) # save model model.save("ResNet50_feature_extraction.h5") # extract features from each photo features = dict() num_images = len(listdir(directory)) for index, name in enumerate(listdir(directory)): # load an image from file filename = directory + "/" + name image = load_img(filename, target_size=(224, 224)) # convert image pixels to numpy array image = img_to_array(image) # reshape data image = np.expand_dims(image, axis=0) # image = image[np.newaxis,:] # preprocess image for model image = preprocess_input(image) # get features feature = model.predict(image, verbose=0) # get image_id image_id = name.split(".")[0] # store feature features[image_id] = feature print(">(%i/%i) %s" % (index, num_images, name)) return features
def getData(data_path, s): """ function that read the photos from the computer :param data_path: data_path: string- address of the folder with the photos :param s: int- the size of the images :return: data set and its following labels """ print("Stage 1: Importing Data") x = scipy.io.loadmat(data_path + '/FlowerDataLabels.mat') labels = x['Labels'].T dataOriginal = [] data = [] for i in range(1, labels.shape[0] + 1): tmp = cv2.imread(data_path + '/' + str(i) + '.jpeg') tmp = cv2.cvtColor(tmp, cv2.COLOR_BGR2RGB) tmp = cv2.resize(tmp, (s, s)) dataOriginal.append(tmp) data.append(preprocess_input(tmp)) data = np.asarray(data) dataOriginal = np.asarray(dataOriginal) return data, labels, dataOriginal
def augmentation_data(image): image = np.array(image) augmentation = Compose([ OneOf([ RGBShift(), ChannelShuffle(), RandomContrast(limit=0.2, p=0.5), RandomGamma(gamma_limit=(80, 120), p=0.5), RandomBrightness(limit=0.2, p=0.5), HueSaturationValue(hue_shift_limit=5, sat_shift_limit=20, val_shift_limit=10, p=.9), ], p=0.1), # HorizontalFlip(p=0.5), # CLAHE(p=1.0, clip_limit=2.0), # ShiftScaleRotate( # shift_limit=0.0625, scale_limit=0.1, # rotate_limit=15, border_mode=cv2.BORDER_REFLECT_101, p=0.8), # ToFloat(max_value=255) # normalization ]) augmented_image = augmentation(image=image)['image'] return preprocess_input(augmented_image)
# Get training data bboxes, polygon_labels = process() # Define GCN models epochs_per_image = 10 gcn_models = [None] * epochs_per_image # Run stochastic training for image in range(len(bboxes)): print("Training image {0} of {1}".format(image + 1, len(bboxes))) # Process bounding box bbox, polygon_points = bboxes[image], polygon_labels[image] resized_bb = cv2.resize(bbox, (224, 224), interpolation=cv2.INTER_AREA) resized_bb_exp = preprocess_input(np.expand_dims(resized_bb, axis=0)) # Compute feature map resnet_model = ResNet50V2(weights='imagenet') embedding_model = Model(inputs=resnet_model.input, outputs=resnet_model.get_layer('post_relu').output) feature_map = embedding_model.predict(resized_bb_exp) # Define graph N = 45 G = nx.Graph() G.add_nodes_from(range(N)) for i in range(N): if i - 2 < 0: G.add_edge(N + (i - 2), i) else:
def _extract_feature(model, path): im = Image.open(path) img = preprocess_input(np.expand_dims(im.copy(), axis=0)) resnet_feature = model.predict(img) return np.array(resnet_feature).flatten()
from keras.preprocessing import image from keras.applications.resnet_v2 import preprocess_input, decode_predictions from keras.layers import Input import numpy as np import tensorflow as tf config = tf.ConfigProto() config.gpu_options.allow_growth = True tf.keras.backend.set_session(tf.Session(config=config)) dim_size = 224 input_tensor = Input(shape=(dim_size, dim_size, 3)) model = ResNet152V2(input_tensor=input_tensor, weights='imagenet') #model = ResNet152V2(input_tensor=input_tensor, weights=None, classes=7) #model.load_weights('resnet_weights.h5', by_name=False) img_path = 'tiger.jpg' img = image.load_img(img_path, target_size=(dim_size, dim_size)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) # decode the results into a list of tuples (class, description, probability) # (one such list for each sample in the batch) print('Predicted:', decode_predictions(preds, top=5)) # Predicted: # [(u'n02504013', u'Indian_elephant', 0.82658225), # (u'n01871265', u'tusker', 0.1122357), # (u'n02504458', u'African_elephant', 0.061040461)]