def test_img_utils(self): height, width = 10, 8 # Test th data format x = np.random.random((3, height, width)) img = image.array_to_img(x, data_format='channels_first') assert img.size == (width, height) x = image.img_to_array(img, data_format='channels_first') assert x.shape == (3, height, width) # Test 2D x = np.random.random((1, height, width)) img = image.array_to_img(x, data_format='channels_first') assert img.size == (width, height) x = image.img_to_array(img, data_format='channels_first') assert x.shape == (1, height, width) # Test tf data format x = np.random.random((height, width, 3)) img = image.array_to_img(x, data_format='channels_last') assert img.size == (width, height) x = image.img_to_array(img, data_format='channels_last') assert x.shape == (height, width, 3) # Test 2D x = np.random.random((height, width, 1)) img = image.array_to_img(x, data_format='channels_last') assert img.size == (width, height) x = image.img_to_array(img, data_format='channels_last') assert x.shape == (height, width, 1)
def explain(model, img, topLabels, numSamples, numFeatures, hideRest, hideColor, positiveOnly): img, oldImg = transform_img_fn(img) img = img*(1./255) prediction = model.predict(img) explainer = lime_image.LimeImageExplainer() img = np.squeeze(img) explanation = explainer.explain_instance(img, model.predict, top_labels=topLabels, hide_color=hideColor, num_samples=numSamples) temp, mask = explanation.get_image_and_mask(getTopPrediction(prediction[0]), positive_only=positiveOnly, num_features=numFeatures, hide_rest=hideRest) tempMask = mask * 255 temp = Image.fromarray(np.uint8(tempMask)) temp = temp.resize((oldImg.width, oldImg.height)) temp = image.img_to_array(temp) temp = temp * 1./255 temp = temp.astype(np.int64) temp = np.squeeze(temp) oldImgArr = image.img_to_array(oldImg) oldImgArr = oldImgArr * (1./255) oldImgArr = oldImgArr.astype(np.float64) imgExplained = mark_boundaries(oldImgArr, temp) imgFinal = np.uint8(imgExplained*255) img = Image.fromarray(imgFinal) imgByteArr = io.BytesIO() img.save(imgByteArr, format='JPEG') imgByteArr = imgByteArr.getvalue() return imgByteArr
def test_img_utils(self): height, width = 10, 8 # Test th dim ordering x = np.random.random((3, height, width)) img = image.array_to_img(x, dim_ordering='th') assert img.size == (width, height) x = image.img_to_array(img, dim_ordering='th') assert x.shape == (3, height, width) # Test 2D x = np.random.random((1, height, width)) img = image.array_to_img(x, dim_ordering='th') assert img.size == (width, height) x = image.img_to_array(img, dim_ordering='th') assert x.shape == (1, height, width) # Test tf dim ordering x = np.random.random((height, width, 3)) img = image.array_to_img(x, dim_ordering='tf') assert img.size == (width, height) x = image.img_to_array(img, dim_ordering='tf') assert x.shape == (height, width, 3) # Test 2D x = np.random.random((height, width, 1)) img = image.array_to_img(x, dim_ordering='tf') assert img.size == (width, height) x = image.img_to_array(img, dim_ordering='tf') assert x.shape == (height, width, 1)
def create_train_data(self): # 将增强之后的训练集生成npy print('-' * 30) print('creating train image') print('-' * 30) trainPath=self.train_path labelPath=self.label_path imgs = glob.glob(trainPath + '/*' + '.jpg') imgs=sorted(imgs) labels = glob.glob(labelPath + '/*' + '.jpg') labels=sorted(labels) imgdatas = np.ndarray((len(imgs), self.out_rows, self.out_cols, 1), dtype=np.uint8) imglabels = np.ndarray((len(labels), self.out_rows, self.out_cols, 1), dtype=np.uint8) for i in range(len(imgs)): #img = plt.imread(imgs[i]) #label = plt.imread(labels[i]) img = load_img(imgs[i], grayscale=True) label = load_img(labels[i], grayscale=True) img = img_to_array(img) label = img_to_array(label) imgdatas[i] = img imglabels[i] = label #if i % 100 == 0: #print('Done: {0}/{1} images'.format(i, len(imgs))) print(i) print('loading done', imgdatas.shape) np.save(self.npy_path + '/imgs_train.npy', imgdatas) # 将30张训练集和30张label生成npy数据 np.save(self.npy_path + '/imgs_mask_train.npy', imglabels) print('Saving to .npy files done.')
def test_spimage_converter_module(self): """ spimage converter module must preserve original image """ img_fpaths = glob(os.path.join(_getSampleJPEGDir(), '*.jpg')) def exec_gfn_spimg_decode(spimg_dict, img_dtype): gfn = gfac.buildSpImageConverter(img_dtype) with IsolatedSession() as issn: feeds, fetches = issn.importGraphFunction(gfn, prefix="") feed_dict = dict((tnsr, spimg_dict[tfx.op_name(issn.graph, tnsr)]) for tnsr in feeds) img_out = issn.run(fetches[0], feed_dict=feed_dict) return img_out def check_image_round_trip(img_arr): spimg_dict = imageArrayToStruct(img_arr).asDict() spimg_dict['data'] = bytes(spimg_dict['data']) img_arr_out = exec_gfn_spimg_decode(spimg_dict, spimg_dict['mode']) self.assertTrue(np.all(img_arr_out == img_arr)) for fp in img_fpaths: img = load_img(fp) img_arr_byte = img_to_array(img).astype(np.uint8) check_image_round_trip(img_arr_byte) img_arr_float = img_to_array(img).astype(np.float) check_image_round_trip(img_arr_float) img_arr_preproc = iv3.preprocess_input(img_to_array(img)) check_image_round_trip(img_arr_preproc)
def create_train_data(self): i = 0 print('-'*30) print('Creating training images...') print('-'*30) imgs = glob.glob(self.data_path+"/*."+self.img_type) print(len(imgs)) imgdatas = np.ndarray((len(imgs),self.out_rows,self.out_cols,1), dtype=np.uint8) imglabels = np.ndarray((len(imgs),self.out_rows,self.out_cols,1), dtype=np.uint8) for imgname in imgs: midname = imgname[imgname.rindex("/")+1:] img = load_img(self.data_path + "/" + midname,grayscale = True) label = load_img(self.label_path + "/" + midname,grayscale = True) img = img_to_array(img) label = img_to_array(label) #img = cv2.imread(self.data_path + "/" + midname,cv2.IMREAD_GRAYSCALE) #label = cv2.imread(self.label_path + "/" + midname,cv2.IMREAD_GRAYSCALE) #img = np.array([img]) #label = np.array([label]) imgdatas[i] = img imglabels[i] = label if i % 100 == 0: print('Done: {0}/{1} images'.format(i, len(imgs))) i += 1 print('loading done') np.save(self.npy_path + '/imgs_train.npy', imgdatas) np.save(self.npy_path + '/imgs_mask_train.npy', imglabels) print('Saving to .npy files done.')
def create_test_data(self): # 测试集生成npy print('-' * 30) print('Creating test images...') print('-' * 30) imgs1 = glob.glob(self.test_path + "/*." + self.img_type) # deform/train imgs1=sorted(imgs1) labels1 = glob.glob(self.test_label_path + '/*' + '.jpg') labels1=sorted(labels1) imgdatas1 = np.ndarray((len(imgs1), self.out_rows, self.out_cols, 1), dtype=np.uint8) imglabels1 = np.ndarray((len(labels1), self.out_rows, self.out_cols, 1), dtype=np.uint8) for i in range(len(labels1)): #img = plt.imread(imgs[i]) #label = plt.imread(labels[i]) label = load_img(labels1[i], grayscale=True) img = load_img(imgs1[i], grayscale=True) img = img_to_array(img) label = img_to_array(label) imgdatas1[i] = img imglabels1[i] = label print(i) print('loading done', imgdatas1.shape) np.save(self.npy_path + '/imgs_test.npy', imgdatas1) # 将30张训练集和30张label生成npy数据 np.save(self.npy_path + '/imgs_mask_test.npy', imglabels1) print('Saving to .npy files done.')
def load_mask_labels(): '''Load both target and style masks. A mask image (nr x nc) with m labels/colors will be loaded as a 4D boolean tensor: (1, m, nr, nc) for 'th' or (1, nr, nc, m) for 'tf' ''' target_mask_img = load_img(target_mask_path, target_size=(img_nrows, img_ncols)) target_mask_img = img_to_array(target_mask_img) style_mask_img = load_img(style_mask_path, target_size=(img_nrows, img_ncols)) style_mask_img = img_to_array(style_mask_img) if K.image_dim_ordering() == 'th': mask_vecs = np.vstack([style_mask_img.reshape((3, -1)).T, target_mask_img.reshape((3, -1)).T]) else: mask_vecs = np.vstack([style_mask_img.reshape((-1, 3)), target_mask_img.reshape((-1, 3))]) labels = kmeans(mask_vecs, nb_labels) style_mask_label = labels[:img_nrows * img_ncols].reshape((img_nrows, img_ncols)) target_mask_label = labels[img_nrows * img_ncols:].reshape((img_nrows, img_ncols)) stack_axis = 0 if K.image_dim_ordering() == 'th' else -1 style_mask = np.stack([style_mask_label == r for r in xrange(nb_labels)], axis=stack_axis) target_mask = np.stack([target_mask_label == r for r in xrange(nb_labels)], axis=stack_axis) return (np.expand_dims(style_mask, axis=0), np.expand_dims(target_mask, axis=0))
def Augmentation(self): """ Start augmentation..... """ trains = self.train_imgs labels = self.label_imgs path_train = self.train_path path_label = self.label_path path_merge = self.merge_path imgtype = self.img_type path_aug_merge = self.aug_merge_path if len(trains) != len(labels) or len(trains) == 0 or len(trains) == 0: print "trains can't match labels" return 0 for i in range(len(trains)): img_t = load_img(path_train+"/"+str(i)+"."+imgtype) img_l = load_img(path_label+"/"+str(i)+"."+imgtype) x_t = img_to_array(img_t) x_l = img_to_array(img_l) x_t[:,:,2] = x_l[:,:,0] img_tmp = array_to_img(x_t) img_tmp.save(path_merge+"/"+str(i)+"."+imgtype) img = x_t img = img.reshape((1,) + img.shape) savedir = path_aug_merge + "/" + str(i) if not os.path.lexists(savedir): os.mkdir(savedir) self.doAugmentate(img, savedir, str(i))
def create_train_data(self): # 将增强之后的训练集生成npy i = 0 print('-' * 30) print('creating train image') print('-' * 30) count = 0 for indir in os.listdir(self.aug_merge_path): path = os.path.join(self.aug_merge_path, indir) count += len(os.listdir(path)) imgdatas = np.ndarray((count, self.out_rows, self.out_cols, 1), dtype=np.uint8) imglabels = np.ndarray((count, self.out_rows, self.out_cols, 1), dtype=np.uint8) for indir in os.listdir(self.aug_merge_path): trainPath = os.path.join(self.aug_train_path, indir) labelPath = os.path.join(self.aug_label_path, indir) print(trainPath, labelPath) imgs = glob.glob(trainPath + '/*' + '.tif') for imgname in imgs: trainmidname = imgname[imgname.rindex('/') + 1:] labelimgname = imgname[imgname.rindex('/') + 1:imgname.rindex('_')] + '_label.tif' print(trainmidname, labelimgname) img = load_img(trainPath + '/' + trainmidname, grayscale=True) label = load_img(labelPath + '/' + labelimgname, grayscale=True) img = img_to_array(img) label = img_to_array(label) imgdatas[i] = img imglabels[i] = label if i % 100 == 0: print('Done: {0}/{1} images'.format(i, len(imgs))) i += 1 print(i) print('loading done', imgdatas.shape) np.save(self.npy_path + '/imgs_train.npy', imgdatas) # 将30张训练集和30张label生成npy数据 np.save(self.npy_path + '/imgs_mask_train.npy', imglabels) print('Saving to .npy files done.')
def create_small_train_data(self): # 将增强之后的训练集生成npy print('-' * 30) print('creating samll train image') print('-' * 30) imgs = glob.glob('../data_set/aug_train/0/*' + '.tif') count = len(imgs) imgdatas = np.ndarray((count, self.out_rows, self.out_cols, 1), dtype=np.uint8) imglabels = np.ndarray((count, self.out_rows, self.out_cols, 1), dtype=np.uint8) trainPath = '../data_set/aug_train/0' labelPath = '../data_set/aug_label/0' i = 0 for imgname in imgs: trainmidname = imgname[imgname.rindex('/') + 1:] labelimgname = imgname[imgname.rindex('/') + 1:imgname.rindex('_')] + '_label.tif' print(trainmidname, labelimgname) img = load_img(trainPath + '/' + trainmidname, grayscale=True) label = load_img(labelPath + '/' + labelimgname, grayscale=True) img = img_to_array(img) label = img_to_array(label) imgdatas[i] = img imglabels[i] = label i += 1 print(i) print('loading done', imgdatas.shape) np.save(self.npy_path + '/imgs_small_train.npy', imgdatas) # 将30张训练集和30张label生成npy数据 np.save(self.npy_path + '/imgs_mask_small_train.npy', imglabels) print('Saving to .npy files done.')
def augmentation(self): # 读入3通道的train和label, 分别转换成矩阵, 然后将label的第一个通道放在train的第2个通处, 做数据增强 print("运行 Augmentation") # Start augmentation..... trains = self.train_imgs labels = self.label_imgs path_train = self.train_path path_label = self.label_path path_merge = self.merge_path imgtype = self.img_type path_aug_merge = self.aug_merge_path print(len(trains), len(labels)) if len(trains) != len(labels) or len(trains) == 0 or len(trains) == 0: print("trains can't match labels") return 0 for i in range(len(trains)): img_t = load_img(path_train + "/" + str(i) + "." + imgtype) # 读入train img_l = load_img(path_label + "/" + str(i) + "." + imgtype) # 读入label x_t = img_to_array(img_t) # 转换成矩阵 x_l = img_to_array(img_l) x_t[:, :, 2] = x_l[:, :, 0] # 把label当做train的第三个通道 img_tmp = array_to_img(x_t) img_tmp.save(path_merge + "/" + str(i) + "." + imgtype) # 保存合并后的图像 img = x_t img = img.reshape((1,) + img.shape) # 改变shape(1, 512, 512, 3) savedir = path_aug_merge + "/" + str(i) # 存储合并增强后的图像 if not os.path.lexists(savedir): os.mkdir(savedir) self.do_augmentate(img, savedir, str(i)) # 数据增强
def crop_image(channels, img, kernel, mode, model, t, x, y, learn_mode='INPUT'): if learn_mode == 'INPUT' and model: posx = (model.layers[0].input_shape[2] - kernel[0]) posy = (model.layers[0].input_shape[3] - kernel[1]) else: posx = 0 posy = 0 img_c = img.crop((x, y, x + kernel[0] + posx, y + kernel[1] + posy)) img_converted = img_c if mode == 'YCbCr': img_converted = img_c.convert('YCbCr') ar = img_to_array(img_converted) input_array = ar[0].reshape(1, img_c.width, img_c.height) t.append(input_array) else: if channels == 1: ar = img_to_array(img_converted) for c in range(0, 3): ar_new = ar[c].reshape(1, img_converted.width, img_converted.height) t.append(ar_new) else: ar = img_to_array(img_converted) t.append(ar) return img_c
def convert_image_to_node(self, image, input_node=None): from keras.preprocessing.image import img_to_array if input_node is None: input_node = self.get_input_node(0) if input_node['inputType'] == 'image': image = image.convert("L") image = img_to_array(image) elif input_node['inputType'] == 'image_bgr': image = image.convert("RGB") image = np.asarray(image, dtype='float32') image = image[:, :, ::-1].copy() image = img_to_array(image) else: image = image.convert("RGB") image = img_to_array(image) if 'imageScale' not in input_node: input_node['imageScale'] = 255 if float(input_node['imageScale']) > 0: image = image / float(input_node['imageScale']) return image
def _get_batches_of_transformed_samples(self, index_array): batch_x = np.zeros((len(index_array),) + self.image_shape, dtype=K.floatx()) if self.with_labels: batch_y = np.zeros((len(batch_x), self.num_class), dtype=K.floatx()) for i, j in enumerate(index_array): # Protect file and dataframe access with a lock. with self.lock: image_row = self.images_df.iloc[j] product_id = image_row["product_id"] offset_row = self.offsets_df.loc[product_id] # Read this product's data from the BSON file. self.file.seek(offset_row["offset"]) item_data = self.file.read(offset_row["length"]) # Grab the image from the product. item = bson.BSON.decode(item_data) img_idx = image_row["img_idx"] bson_img = item["imgs"][img_idx]["picture"] # Load the image. img = load_img(io.BytesIO(bson_img), target_size=self.target_size) # Preprocess the image. x = img_to_array(img) x = preprocess_image(x) #x = self.image_data_generator.random_transform(x) #x = self.image_data_generator.standardize(x) # Add the image and the label to the batch (one-hot encoded). batch_x[i] = x if self.with_labels: batch_y[i, image_row["category_idx"]] = 1 if self.with_labels: return batch_x, batch_y else: return batch_x
def start(): model = keras.applications.vgg19.VGG19(include_top=False, weights='imagenet', pooling='avg') root_dir = "/media/rishabh/dump_bin/Animals_with_Attributes2/JPEGImages/" for root, subdirs, files in os.walk(root_dir): list_file_path = os.path.join(root, 'list_of_files.txt') with open(list_file_path, 'wb') as list_file: for filename in files: if filename.endswith("jpg"): file_path = os.path.join(root, filename) img = image.load_img(file_path, target_size=(224,224)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) features = model.predict(x) np_name = filename[0:-4] np_name = np_name+".npy" np.save(os.path.join(root,np_name), features) # npy = open(os.path.join(root,np_name),"w+") print('file %s (full path: %s)' % (filename, file_path)) list_file.write(('%s\n' % filename).encode('utf-8'))
def predict(image_file): img = image.load_img(image_file, target_size=(img_width,img_height)) x = image.img_to_array(img) x = np.expand_dims(x,axis=0) x = preprocess_input(x) preds = model.predict(x) return preds
def merge_image(original_image_path, depth_image_path, width, height): d_img = load_img(depth_image_path, grayscale=True) d_array = img_to_array(d_img).reshape(height, width) print(d_array.shape) o_img = load_img(original_image_path, grayscale=False) o_array = img_to_array(o_img) print(o_array.shape) combined_array = np.zeros((height, width, 3), dtype="float32") combined_array[:, :, 0:3] = o_array # The first three layers will be the original one combined_array[:, :, 3] = d_array return combined_array
def test_image_data_generator(self, tmpdir): for test_images in self.all_test_images: img_list = [] for im in test_images: img_list.append(image.img_to_array(im)[None, ...]) images = np.vstack(img_list) generator = image.ImageDataGenerator( featurewise_center=True, samplewise_center=True, featurewise_std_normalization=True, samplewise_std_normalization=True, zca_whitening=True, rotation_range=90., width_shift_range=0.1, height_shift_range=0.1, shear_range=0.5, zoom_range=0.2, channel_shift_range=0., fill_mode='nearest', cval=0.5, horizontal_flip=True, vertical_flip=True) generator.fit(images, augment=True) for x, y in generator.flow(images, np.arange(images.shape[0]), shuffle=True, save_to_dir=str(tmpdir)): assert x.shape[1:] == images.shape[1:] break
def preprocess(imgs): imgs_p = np.ndarray((imgs.shape[0], imgs.shape[1], img_rows, img_cols), dtype=np.uint8) for i in range(imgs.shape[0]): img = Image.fromarray(imgs[i, 0]) img = img.resize(target_size) imgs_p[i, 0] = img_to_array(img, dim_ordering='th') return imgs_p
def predict_labels(model): """writes test image labels and predictions to csv""" test_datagen = ImageDataGenerator(rescale=1./255) test_generator = test_datagen.flow_from_directory( test_data_dir, target_size=(img_height, img_width), batch_size=32, shuffle=False, class_mode=None) base_path = "../data/test/test/" with open("prediction.csv", "w") as f: p_writer = csv.writer(f, delimiter=',', lineterminator='\n') for _, _, imgs in os.walk(base_path): for im in imgs: pic_id = im.split(".")[0] img = load_img(base_path + im) img = imresize(img, size=(img_height, img_width)) test_x = img_to_array(img).reshape(3, img_height, img_width) test_x = test_x.reshape((1,) + test_x.shape) test_generator = test_datagen.flow(test_x, batch_size=1, shuffle=False) prediction = model.predict_generator(test_generator, 1)[0][0] p_writer.writerow([pic_id, prediction])
def load_data(path, size=224, mode=None): img = Image.open(path) w,h = img.size if w < h: if w < size: img = img.resize((size, size*h//w)) w, h = img.size else: if h < size: img = img.resize((size*w//h, size)) w, h = img.size img = img.crop((int((w-size)*0.5), int((h-size)*0.5), int((w+size)*0.5), int((h+size)*0.5))) if mode=="original": return img if mode=="label": y = np.array(img, dtype=np.int32) mask = y == 255 y[mask] = 0 y = binarylab(y, size, 21) y = np.expand_dims(y, axis=0) return y if mode=="data": X = image.img_to_array(img) X = np.expand_dims(X, axis=0) X = preprocess_input(X) return X
def test_bare_keras_module(self): """ Keras GraphFunctions should give the same result as standard Keras models """ img_fpaths = glob(os.path.join(_getSampleJPEGDir(), '*.jpg')) for model_gen, preproc_fn in [(InceptionV3, iv3.preprocess_input), (Xception, xcpt.preprocess_input), (ResNet50, rsnt.preprocess_input)]: keras_model = model_gen(weights="imagenet") target_size = tuple(keras_model.input.shape.as_list()[1:-1]) _preproc_img_list = [] for fpath in img_fpaths: img = load_img(fpath, target_size=target_size) # WARNING: must apply expand dimensions first, or ResNet50 preprocessor fails img_arr = np.expand_dims(img_to_array(img), axis=0) _preproc_img_list.append(preproc_fn(img_arr)) imgs_input = np.vstack(_preproc_img_list) preds_ref = keras_model.predict(imgs_input) gfn_bare_keras = GraphFunction.fromKeras(keras_model) with IsolatedSession(using_keras=True) as issn: K.set_learning_phase(0) feeds, fetches = issn.importGraphFunction(gfn_bare_keras) preds_tgt = issn.run(fetches[0], {feeds[0]: imgs_input}) self.assertTrue(np.all(preds_tgt == preds_ref))
def test_pipeline(self): """ Pipeline should provide correct function composition """ img_fpaths = glob(os.path.join(_getSampleJPEGDir(), '*.jpg')) xcpt_model = Xception(weights="imagenet") stages = [('spimage', gfac.buildSpImageConverter(SparkMode.RGB_FLOAT32)), ('xception', GraphFunction.fromKeras(xcpt_model))] piped_model = GraphFunction.fromList(stages) for fpath in img_fpaths: target_size = tuple(xcpt_model.input.shape.as_list()[1:-1]) img = load_img(fpath, target_size=target_size) img_arr = np.expand_dims(img_to_array(img), axis=0) img_input = xcpt.preprocess_input(img_arr) preds_ref = xcpt_model.predict(img_input) spimg_input_dict = imageArrayToStruct(img_input).asDict() spimg_input_dict['data'] = bytes(spimg_input_dict['data']) with IsolatedSession() as issn: # Need blank import scope name so that spimg fields match the input names feeds, fetches = issn.importGraphFunction(piped_model, prefix="") feed_dict = dict((tnsr, spimg_input_dict[tfx.op_name(issn.graph, tnsr)]) for tnsr in feeds) preds_tgt = issn.run(fetches[0], feed_dict=feed_dict) # Uncomment the line below to see the graph # tfx.write_visualization_html(issn.graph, # NamedTemporaryFile(prefix="gdef", suffix=".html").name) self.assertTrue(np.all(preds_tgt == preds_ref))
def convert_image_to_tensors(img_path): # loads RGB image as PIL.Image.Image type img = image.load_img(img_path, target_size=(224, 224)) # convert PIL.Image.Image type to 3D tensor with shape (224, 224, 3) x = image.img_to_array(img) # convert 3D tensor to 4D tensor with shape (1, 224, 224, 3) and return 4D tensor return np.expand_dims(x, axis=0)
def load_img(input_path, target_shape, grayscale=False, mean=None, std=None): img = image.load_img(input_path, target_size=target_shape, grayscale=grayscale) img_arr = np.expand_dims(image.img_to_array(img), axis=0) if not grayscale: img_arr = preprocess_input(img_arr, mean=mean, std=std) return img_arr
def test_batch_standardize(self): # ImageDataGenerator.standardize should work on batches for test_images in self.all_test_images: img_list = [] for im in test_images: img_list.append(image.img_to_array(im)[None, ...]) images = np.vstack(img_list) generator = image.ImageDataGenerator( featurewise_center=True, samplewise_center=True, featurewise_std_normalization=True, samplewise_std_normalization=True, zca_whitening=True, rotation_range=90., width_shift_range=0.1, height_shift_range=0.1, shear_range=0.5, zoom_range=0.2, channel_shift_range=0., brightness_range=(1, 5), fill_mode='nearest', cval=0.5, horizontal_flip=True, vertical_flip=True) generator.fit(images, augment=True) transformed = np.copy(images) for i, im in enumerate(transformed): transformed[i] = generator.random_transform(im) transformed = generator.standardize(transformed)
def forward(data, probs_or_score, opts, vars): try: model = vars['model'] sess = vars['session'] graph = vars['graph'] if model and sess and graph: n_output = len(probs_or_score) npdata = np.asarray(data) img = Image.fromarray(npdata) x = img.resize((opts['image_height'], opts['image_width'])) x = kerasimage.img_to_array(x) x = np.expand_dims(x, axis=0) x = x*(1./255) with sess.as_default(): with graph.as_default(): pred = model.predict(x, batch_size=1, verbose=0) sanity_check(probs_or_score) for i in range(len(pred[0])): probs_or_score[i] = pred[0][i] return max(probs_or_score) else: print('Train model first') return 1 except Exception as e: print_exception(e, 'forward') sys.exit()
def predict(args): # load the trained convolutional neural network print("[INFO] loading network...") model = load_model(args["model"]) #load the image image = cv2.imread(args["image"]) orig = image.copy() # pre-process the image for classification image = cv2.resize(image, (norm_size, norm_size)) image = image.astype("float") / 255.0 image = img_to_array(image) image = np.expand_dims(image, axis=0) # classify the input image result = model.predict(image)[0] #print (result.shape) proba = np.max(result) label = str(np.where(result==proba)[0]) label = "{}: {:.2f}%".format(label, proba * 100) print(label) if args['show']: # draw the label on the image output = imutils.resize(orig, width=400) cv2.putText(output, label, (10, 25),cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2) # show the output image cv2.imshow("Output", output) cv2.waitKey(0)
def preprocess_xray_flipped(xray_path): xray = image.load_img(xray_path, color_mode="grayscale", vertical_flip=True, target_size=(img_dims[0], img_dims[1], 1)) xray = image.img_to_array(xray) xray = np.dstack([xray, xray, xray]) xray = preprocess_input(xray) return xray
list del list[5] list #convert to series list_ser = pd.Series(list) img_list = [] for i in list: img_path = img_pth + i img_list.append(img_path) print(len(img_list)) ##################### vgg16_feature_list = [] for i in img_list: img = image.load_img(i, target_size=(224, 224)) img_data = image.img_to_array(img) img_data = np.expand_dims(img_data, axis=0) img_data = preprocess_input(img_data) vgg16_feature = model.predict(img_data) vgg16_feature_np = np.array(vgg16_feature) vgg16_feature_list.append(vgg16_feature_np.flatten()) print(len(vgg16_feature_list_np)) vgg16_feature_list_np = np.array(vgg16_feature_list) kmeans = KMeans(n_clusters=3, random_state=0).fit(vgg16_feature_list_np) y_kmeans = kmeans.predict(vgg16_feature_list_np) y_kmeans y_kmeans_list = y_kmeans.tolist() #convert to series y_kmeans_se = pd.Series(y_kmeans_list) cluster_df = pd.DataFrame() #add values of img_id
def prep_mask_to_unet(mask_path): mask = kimage.load_img(mask_path) mask = kimage.img_to_array(mask) mask = mask[:, :, :1] / 255 # Reads like RGB Image. Hence we take only one frame return mask
def preprocess_image(_path): img = load_img(_path, target_size=(224, 224)) img = img_to_array(img) img = np.expand_dims(img, axis=0) img = preprocess_input(img) return img
while True: ret, frame = cap.read() cv2.imshow('image', frame) key = cv2.waitKey(1) if key != -1: break #=================================================== #推論する画像を読み込み #=================================================== x = frame x = cv2.cvtColor(x, cv2.COLOR_BGR2RGB) #RBGをRGBに変える x = cv2.resize(x, (32, 32)) #データ形式をCNNモデルに合わせる(3次元のPILから3次元のndarrayへ変更) x = img_to_array(x) #データを0.0~1.0へ正規化 x = x.astype('float32') / 255.0 #次元を合わせる x = np.expand_dims(x, axis=0) #=================================================== #推論と結果表示 #=================================================== #推論 preds = model.predict(x) print("predicts : " + str(preds)) #predsのインデックスでソート
def process_image(img_path): img = image.load_img(img_path, target_size=(224, 224)) img_array = image.img_to_array(img) img_array = np.expand_dims(img_array, axis=0) pImg = mobilenet.preprocess_input(img_array) return pImg
def preprocess_image(image_path): img = load_img(image_path, target_size=(img_nrows, img_ncols)) img = img_to_array(img) img = np.expand_dims(img, axis=0) img = vgg16.preprocess_input(img) return img
training_set = train_datagen.flow_from_directory('dataset/training_set', target_size=(64, 64), batch_size=32, class_mode='binary') test_set = test_datagen.flow_from_directory('dataset/test_set', target_size=(64, 64), batch_size=32, class_mode='binary') classifier.fit_generator(training_set, steps_per_epoch=8000, epochs=25, validation_data=test_set, validation_steps=2000) # Part 3 - Making new predictions import numpy as np from keras.preprocessing import image test_image = image.load_img('dataset/single_prediction/cat_or_dog_2.jpg', target_size=(64, 64)) test_image = image.img_to_array(test_image) test_image = np.expand_dims(test_image, axis=0) result = classifier.predict(test_image) training_set.class_indices if result[0][0] == 1: prediction = 'dog' else: prediction = 'cat'
def draw_img(generator, x, out_dir, img_index): save_name = "expand_" + str(img_index) g = generator.flow(x, batch_size=1, save_to_dir=out_dir, save_prefix=save_name, save_format="jpg") for j in range(11): g.next() if __name__ == "__main__": in_dir = "yoji_test" out_dir = "yoji_expand" if not (os.path.exists(os.path.join("./datasets", out_dir))): os.mkdir(os.path.join("./datasets", out_dir)) images = glob.glob(os.path.join("./datasets", in_dir, "*")) generator = ImageDataGenerator(width_shift_range=0.35) for i in range(len(images)): target_img = load_img(images[i]) x = img_to_array(target_img) x = np.expand_dims(x, axis=0) draw_img(generator, x, os.path.join("./datasets", out_dir), i)
# print(len(sketch_idx)) #9148 #메모리를 적게 쓰기 위해 uint8로 sketch = np.zeros((len(sketch_idx),256,256,3),dtype=np.uint8) photo = np.zeros((len(sketch_idx),256,256,3),dtype=np.uint8) from tqdm import tqdm_notebook from keras.preprocessing.image import img_to_array, load_img from skimage.transform import resize #사이즈 조절 for i, idx in (enumerate(sketch_idx)): # print("i : ",i) # print("idx : ",idx) img = load_img("./data/sketch/"+idx) img = img_to_array(img) sketch[i] = img #sketch에 맞춰서 photo를 늘림 for i, idx in (enumerate(sketch_idx)): # print("i : ",i) # print("idx : ",idx) idx = idx.split("/")[1]+"/"+idx.split("/")[2] idx = idx.split("-")[0] img = load_img("./data/photo/"+idx+"-removebg-preview"+".png") #배경 제거 후 png로 바뀜 img = img_to_array(img) photo[i] = img print(sketch.shape) #(3324, 256, 256, 3) print(photo.shape) #(3324, 256, 256, 3)
ret, frame = cap.read() #input from webcam stored in variable frame #ret is just a boolean,telling whether it is able to capture frame or not gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) #converting frame to grayscale faces = face_cascade.detectMultiScale(gray, 1.3, 5)#face detection i=0 for (x,y,w,h) in faces: frame=cv2.rectangle(frame,(x,y),(x+w,y+h),(255,0,0),2) #rectangle around my face drawn roi_gray = gray[y:y+h, x:x+w]#image cropped roi_color = frame[y:y+h, x:x+w]#colored image cropped #ret is boolean, to check if frame is coming or not roi_color = cv2.resize(roi_color, (128,128), interpolation=cv2.INTER_AREA)#image resized becz only 128x128 image is to be fed into model test_image=image.img_to_array(roi_color)#third dimension added becz input is supposed to be 128x128x3 and not 128x128 test_image=np.expand_dims(test_image,axis=0)#1 more dimension added because predict function needs 4 dimenions. #This dimension takes the batch size. i.e. on how many images are to be fed in model at one time.I kept batch size=1 result=classifier.predict(test_image) if (result[0][0] == 1):#result.all to handle multiple faces print("angry") cv2.putText(frame,"angry",(x,h), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (255, 255, 255), lineType=cv2.LINE_AA) #this is how to put text on image if (result[0][1] == 1): print("sad") cv2.putText(frame,"sad",(x,h), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (255, 255, 255), lineType=cv2.LINE_AA) if (result[0][2] == 1): print("smiling") cv2.putText(frame,"smiling",(x,h), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (255, 255, 255), lineType=cv2.LINE_AA) cv2.imshow('Input', frame)
from keras.applications.resnet50 import ResNet50 from keras.preprocessing import image from keras.applications.resnet50 import preprocess_input, decode_predictions import numpy as np PTModel = ResNet50(weights='imagenet') ImgPath = 'airplane.jpg' Img = image.load_img(ImgPath, target_size=(224, 224)) InputIMG = image.img_to_array(Img) InputIMG = np.expand_dims(InputIMG, axis=0) InputIMG = preprocess_input(InputIMG) PredData = PTModel.predict(InputIMG) print('Predicted:', decode_predictions(PredData, top=3)[0])
from keras.preprocessing.image import load_img from keras.preprocessing.image import img_to_array from keras.applications.vgg16 import preprocess_input from keras.applications.vgg16 import decode_predictions from keras.applications.vgg16 import VGG16 # load the model model = VGG16() # load an image from file image = load_img('cat.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 label = label[0][0] # print the classification print('%s (%.2f%%)' % (label[1], label[2] * 100))
split = 1 with tqdm(total=num_test_products) as pbar: for c, d in enumerate(data): product_id = d["_id"] num_imgs = len(d["imgs"]) batch_x = np.zeros((num_imgs, 180, 180, 3), dtype=K.floatx()) for i in range(num_imgs): bson_img = d["imgs"][i]["picture"] # Load and preprocess the image. img = load_img(io.BytesIO(bson_img), target_size=(180, 180)) x = img_to_array(img) x = test_datagen.random_transform(x) x = test_datagen.standardize(x) # Add the image to the batch. batch_x[i] = x prediction = model.predict(batch_x, batch_size=num_imgs) avg_pred = prediction.mean(axis=0) test_product_score.append(avg_pred) if (len(test_product_score) % 150000 == 0): print('number of products:{}'.format(len(test_product_score))) print('saving up to product_id:{}'.format(product_id)) print('split:{}'.format(split))
from keras.utils import np_utils from keras.datasets import mnist from keras.preprocessing.image import img_to_array, array_to_img (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = x_train.reshape(x_train.shape[0], 784) x_test = x_test.reshape(x_test.shape[0], 784) x_train = np.dstack([x_train] * 3) x_test = np.dstack([x_test] * 3) x_train = x_train.reshape(x_train.shape[0], 28, 28, 3).astype('float32') / 255 x_test = x_test.reshape(x_test.shape[0], 28, 28, 3).astype('float32') / 255 # reshape 28 => 48 증폭 x_train = np.asarray([ img_to_array(array_to_img(im, scale=False).resize((48, 48))) for im in x_train ]) x_test = np.asarray([ img_to_array(array_to_img(im, scale=False).resize((48, 48))) for im in x_test ]) print(x_train.shape) print(x_test.shape) y_train = np_utils.to_categorical(y_train) y_test = np_utils.to_categorical(y_test) from keras.applications import xception conv_base = xception(weights='imagenet',
def load_image(image_path, grayscale=False, target_size=None): pil_image = image.load_img(image_path, grayscale, target_size) return image.img_to_array(pil_image)
from matplotlib import pyplot as plt from keras.preprocessing import image from keras import models from keras.models import model_from_json import numpy as np json_file = open('model.json', 'r') loaded_model_json = json_file.read() json_file.close() loaded_model = model_from_json(loaded_model_json) loaded_model.load_weights("model.h5") img_path = 'dataset/patterns/trees_4.png' img = image.load_img(img_path, target_size=(120, 120)) img_tensor = image.img_to_array(img) img_tensor = np.expand_dims(img_tensor, axis=0) img_tensor /= 255. plt.imshow(img_tensor[0]) plt.show() print(img_tensor.shape) layer_outputs = [layer.output for layer in loaded_model.layers[:16]] # Extracts the outputs of the top 12 layers activation_model = models.Model( inputs=loaded_model.input, outputs=layer_outputs ) # Creates a model that will return these outputs, given the model input activations = activation_model.predict(img_tensor) layer_names = [] for layer in loaded_model.layers[:16]:
def load_data(image_num, data_number, seq_len): traingen = ImageDataGenerator(rescale=1. / 255) # 生成图片对 print('loading data.....') frame_num = image_num train_data1 = [] train_data2 = [] train_lab = [] count = 0 while count < data_number: count = count + 1 save_path = os.path.join(data_path, str(count) + '.pkl') print("Generating the ", count, "th image pair") pos_neg = np.random.randint(0, 2) if pos_neg == 0: seed1 = np.random.randint(0, seq_len) seed2 = np.random.randint(0, seq_len) while seed1 == seed2: seed1 = np.random.randint(0, seq_len) seed2 = np.random.randint(0, seq_len) frame1 = np.random.randint(0, frame_num) frame2 = np.random.randint(0, frame_num) path1 = os.path.join(root_path, str(seed1), str(frame1) + '.jpg') path2 = os.path.join(root_path, str(seed2), str(frame2) + '.jpg') image1 = img_to_array(load_img(path1)) image1 = image1.reshape((1, ) + image1.shape) for new_img in traingen.flow(image1, batch_size=1, shuffle=False): image1 = new_img break image2 = img_to_array(load_img(path2)) image2 = image2.reshape((1, ) + image2.shape) for new_img in traingen.flow(image2, batch_size=1, shuffle=False): image2 = new_img break train_data1 = np.squeeze(image1) train_data2 = np.squeeze(image2) train_lab = np.array(0) joblib.dump((train_data1, train_data2, train_lab), save_path, compress=0, protocol=4) else: seed = np.random.randint(0, seq_len) frame1 = np.random.randint(0, frame_num) frame2 = np.random.randint(0, frame_num) path1 = os.path.join(root_path, str(seed), str(frame1) + '.jpg') path2 = os.path.join(root_path, str(seed), str(frame2) + '.jpg') image1 = img_to_array(load_img(path1)) image1 = image1.reshape((1, ) + image1.shape) for new_img in traingen.flow(image1, batch_size=1, shuffle=False): image1 = new_img break image2 = img_to_array(load_img(path2)) image2 = image2.reshape((1, ) + image2.shape) for new_img in traingen.flow(image2, batch_size=1, shuffle=False): image2 = new_img break train_data1 = np.squeeze(image1) train_data2 = np.squeeze(image2) train_lab = np.array(1) joblib.dump((train_data1, train_data2, train_lab), save_path, compress=0, protocol=4) print("loading finish!") return [np.array(train_data1), np.array(train_data2), np.array(train_lab)]
def main(modulename, imagename): ''' Kera的应用模块Application提供了带有预训练权重的Keras模型,这些模型可以用来进行预测、特征提取和finetune 模型的预训练权重将下载到~/.keras/models/并在载入模型时自动载入 ''' # 设置为测试模式 keras.backend.set_learning_phase(0) model = ResNet50(weights=modulename) logging.info(model.summary()) img = image.load_img(imagename, target_size=(224, 224)) imagedata = image.img_to_array(img) #imagedata=imagedata[:, :, ::-1] imagedata = np.expand_dims(imagedata, axis=0) #logit fc1000 logits = model.get_layer('fc1000').output #keras中获取指定层的方法为: #base_model.get_layer('block4_pool').output) # advbox demo # 因为原始数据没有归一化 所以bounds=(0, 255) KerasMode内部在进行预测和计算梯度时会进行预处理 # imagenet数据集归一化时 标准差为1 mean为[104, 116, 123] m = KerasModel(model, model.input, None, logits, None, bounds=(0, 255), channel_axis=3, preprocess=([104, 116, 123], 1), featurefqueezing_bit_depth=8) attack = DeepFoolAttack(m) attack_config = {"iterations": 100, "overshoot": 10} #y设置为空 会自动计算 adversary = Adversary(imagedata[:, :, ::-1], None) # deepfool non-targeted attack adversary = attack(adversary, **attack_config) if adversary.is_successful(): print('attack success, adversarial_label=%d' % (adversary.adversarial_label)) #对抗样本保存在adversary.adversarial_example adversary_image = np.copy(adversary.adversarial_example) #强制类型转换 之前是float 现在要转换成iunt8 #::-1 reverses the color channels, because Keras ResNet50 expects BGR instead of RGB adversary_image = adversary_image[:, :, ::-1] adversary_image = np.array(adversary_image).astype("uint8").reshape( [224, 224, 3]) logging.info(adversary_image - imagedata) img = array_to_img(adversary_image) img.save('adversary_image_nontarget.jpg') print("deepfool non-target attack done") attack = DeepFoolAttack(m) attack_config = {"iterations": 100, "overshoot": 10} adversary = Adversary(imagedata[:, :, ::-1], None) tlabel = 489 adversary.set_target(is_targeted_attack=True, target_label=tlabel) # deepfool targeted attack adversary = attack(adversary, **attack_config) if adversary.is_successful(): print('attack success, adversarial_label=%d' % (adversary.adversarial_label)) #对抗样本保存在adversary.adversarial_example adversary_image = np.copy(adversary.adversarial_example) #强制类型转换 之前是float 现在要转换成int8 #::-1 reverses the color channels, because Keras ResNet50 expects BGR instead of RGB adversary_image = adversary_image[:, :, ::-1] adversary_image = np.array(adversary_image).astype("uint8").reshape( [224, 224, 3]) logging.info(adversary_image - imagedata) img = array_to_img(adversary_image) img.save('adversary_image_target.jpg') print("deepfool target attack done")
def predictor(): from keras import backend as K import numpy as np from keras.preprocessing import image test_image = image.load_img(r"G:\\Code_dataset\1.png", target_size=(64, 64)) test_image = image.img_to_array(test_image) test_image = np.expand_dims(test_image, axis=0) #classifier = load_model(r'G:\\Code_dataset\Handgesture_Final_FCN.h5') classifier = load_model(r'G:\\Code_dataset\Handgesture_Final_CNN.h5') #classifier = load_model(r'G:\\Code_dataset\Handgesture_Final_VGG16.h5') result = classifier.predict(test_image) K.clear_session() # print(result) if result[0][0] == max(result[0]): return ' Zero ' elif result[0][1] == max(result[0]): return ' One ' elif result[0][2] == max(result[0]): return ' Two ' elif result[0][3] == max(result[0]): return ' Three ' elif result[0][4] == max(result[0]): return ' Four ' elif result[0][5] == max(result[0]): return 'Five' elif result[0][6] == max(result[0]): return 'Six' elif result[0][7] == max(result[0]): return 'Seven' elif result[0][8] == max(result[0]): return 'Eight' elif result[0][9] == max(result[0]): return 'Nine' elif result[0][10] == max(result[0]): return 'A' elif result[0][11] == max(result[0]): return 'B' elif result[0][12] == max(result[0]): return 'C' elif result[0][13] == max(result[0]): return 'D' elif result[0][14] == max(result[0]): return 'E' elif result[0][15] == max(result[0]): return 'F' elif result[0][16] == max(result[0]): return 'I' elif result[0][17] == max(result[0]): return 'J' elif result[0][18] == max(result[0]): return 'K' elif result[0][19] == max(result[0]): return 'L' elif result[0][20] == max(result[0]): return 'U' elif result[0][21] == max(result[0]): return 'M' elif result[0][22] == max(result[0]): return 'N' elif result[0][23] == max(result[0]): return 'O' elif result[0][24] == max(result[0]): return 'P' elif result[0][26] == max(result[0]): return 'Q' elif result[0][27] == max(result[0]): return 'R' elif result[0][28] == max(result[0]): return 'S' elif result[0][29] == max(result[0]): return 'T' elif result[0][30] == max(result[0]): return 'U' elif result[0][31] == max(result[0]): return 'V' elif result[0][32] == max(result[0]): return 'W' elif result[0][33] == max(result[0]): return 'X' elif result[0][34] == max(result[0]): return 'Y' elif result[0][35] == max(result[0]): return 'Z'
def main(): data_root = os.path.join('data', 'gen') train_img_list = [ fn for fn in os.listdir(data_root) if fn.endswith('.png') ] x_data = [] for train_fn in train_img_list: img = image.load_img(os.path.join(data_root, train_fn)) x = image.img_to_array(img) / 255.0 x_data.append(x) x_data = np.array(x_data) print(x_data.shape) x_input = Input(shape=(IN_IMG_WIDTH, IN_IMG_WIDTH, 3)) x = x_input x = Conv2D(filters=32, kernel_size=3, strides=1, padding='same', activation='relu')(x) x = MaxPooling2D(pool_size=2, padding='same')(x) x = Conv2D(filters=8, kernel_size=3, strides=1, padding='same', activation='relu')(x) x = MaxPooling2D(pool_size=2, padding='same')(x) x = Conv2D(filters=4, kernel_size=3, strides=1, padding='same', activation='relu')(x) x = MaxPooling2D(pool_size=2, padding='same')(x) mid_layer = x mid_shape = K.int_shape(x) print(mid_shape) encoder_model = Model(x_input, mid_layer, name='encoder') encoder_model.summary() decoder_input = Input(shape=(mid_shape[1], mid_shape[2], mid_shape[3])) x = decoder_input x = Conv2DTranspose(filters=4, kernel_size=3, strides=1, padding='same', activation='relu')(x) x = UpSampling2D(size=2)(x) x = Conv2DTranspose(filters=8, kernel_size=3, strides=1, padding='same', activation='relu')(x) x = UpSampling2D(size=2)(x) x = Conv2DTranspose(filters=32, kernel_size=3, strides=1, padding='same', activation='relu')(x) x = UpSampling2D(size=2)(x) x = Conv2DTranspose(filters=3, kernel_size=3, strides=1, padding='same', activation='relu')(x) outputs = x decoder_model = Model(decoder_input, outputs, name='decoder') decoder_model.summary() ae_model = Model(x_input, decoder_model(encoder_model(x_input)), name='auto_encoder') ae_model.summary() ae_model.compile(loss='mse', optimizer=Adam(lr=LEARNING_RATE, decay=DECAY)) ae_model.fit(x_data, x_data, batch_size=BATCH_SIZE, epochs=EPOCHS) x_decoded = ae_model.predict(x_data) show_image(x_data[0]) show_image(x_decoded[0]) print(x_decoded[0][1, 1])
def read_img(filepath, size): img = image.load_img(filepath, target_size=size) img = image.img_to_array(img) return img
def train(input_dir,input_dir_ParsedVMAF): def crop_center(img, crop_width, crop_height): width, height = img.size return img.crop(((width - crop_width) // 2, (height - crop_height) // 2, (width + crop_width) // 2, (height + crop_height) // 2)) def Crop_Function (img, crop_width, crop_height,i): width, height = img.size for col_i in range(0, width, crop_width): for row_i in range(0, height, crop_height): vmafs_new.append(vmafs[i]) return img.crop((col_i, row_i, col_i + crop_width, row_i + crop_height)) def resize_half(img): width, height = img.size return img.resize((width//2,height//2)) img=[] vmafs=[] outputImage = [] vmafs_new=[] imgnames=[] filenames = glob.glob(input_dir+'/*.png') for f in filenames: f=os.path.basename(f) img.append(f) df = pd.read_csv (input_dir_ParsedVMAF) df_list=df.values.tolist() for i in range(0, len(img)): for j in range(0, len(df_list)): if (img[i]==df_list[j][0]): imgs=img[i] Vmaf=df_list[j][1] imgnames.append(imgs) vmafs.append(Vmaf) # vmafs_array=np.asarray(vmafs) for i in range(len(imgnames)): im = Image.open(input_dir + '/' + imgnames[i] ) width, height = im.size im_cropped =Crop_Function(im, 256, 256,i) # im_resized=resize_half(im) # im_resized_cropped =Crop_Function(im_resized, 256, 256,i) im_array=img_to_array(im_cropped) # im_array_resized=img_to_array(im_resized_cropped) norm_image =im_array / 255.0 # norm_image_resized =im_array_resized / 255.0 outputImage.append(norm_image) # outputImage.append(norm_image_resized) outputImage_array=np.asarray(outputImage) #vmafs_array = vmafs_array.reshape(-1, 1) vmafs_new_array=np.asarray(vmafs_new) split = train_test_split(outputImage_array, vmafs_new_array, test_size=0.25, random_state=42) (trainX, testX, trainy, testy) = split trainX = np.asarray(trainX) testX = np.asarray(testX) model=Basic_CNN.create_cnn(256, 256, 3,regress=True) opt = Adam(lr=1e-3, decay=1e-3 / 200) model.compile(loss="mean_absolute_percentage_error", optimizer=opt) print("[INFO] training model...") model.fit(trainX, trainy, validation_data=(testX, testy), epochs=300, batch_size=32) print("[INFO] predicting Vmaf...") preds = model.predict(testX) plt.pyplot.scatter(preds,testy) pkl_filename = "pickle_model.pkl" with open(pkl_filename, 'wb') as file: pickle.dump(model, file)
img = plt.imread("../input/face-mask-detection-data/without_mask/" + i) plt.imshow(img) plt.title("Without mask") break #read images from the dataset from keras.preprocessing.image import load_img, img_to_array from numpy import asarray from PIL import Image x = [] y = [] filenames = (os.listdir("../input/face-mask-detection-data/with_mask")) for i in filenames: photo = load_img("../input/face-mask-detection-data/with_mask/" + i, target_size=(128, 128)) photo = img_to_array(photo) x.append(photo) y.append(1) # 1 with mask filenames = (os.listdir("../input/face-mask-detection-data/without_mask")) for i in filenames: photo = load_img("../input/face-mask-detection-data/without_mask/" + i, target_size=(128, 128)) photo = img_to_array(photo) x.append(photo) y.append(0) # 0 without mask x = asarray(x) #split the data into train and test from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test = train_test_split(x, y,
def predict_mouth(image, count, model, mouthLB): # Load the Haar cascade files for face and eye face_cascade = cv2.CascadeClassifier( 'eye_extraction/haarcascade_frontalface_default.xml') mouth_cascade = cv2.CascadeClassifier( 'mouth_extraction/haarcascade_mcs_mouth.xml') # Check if the face cascade file has been loaded correctly if face_cascade.empty(): raise IOError('Unable to load the face cascade classifier xml file') # Check if the eye cascade file has been loaded correctly if mouth_cascade.empty(): raise IOError('Unable to load the eye cascade classifier xml file') # Initialize the object frame = image new_image = [] # Define the scaling factor ds_factor = 0.5 # Resize the frame frame = cv2.resize(frame, None, fx=ds_factor, fy=ds_factor, interpolation=cv2.INTER_AREA) # Convert to grayscale gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # Run the face detector on the grayscale image faces = face_cascade.detectMultiScale(gray, 1.3, 5) # For each face that's detected, run the eye detector for (x, y, w, h) in faces: # Extract the grayscale face ROI roi_gray = gray[y:y + h, x:x + w] # Extract the color face ROI roi_color = frame[y:y + h, x:x + w] # Run the eye detector on the grayscale ROI mouths = mouth_cascade.detectMultiScale(roi_gray) count = 0 for (x_eye, y_eye, w_eye, h_eye) in mouths: new_image = roi_color[y_eye:y_eye + w_eye, x_eye:x_eye + h_eye] cv2.imwrite("output_new/mouth_Detector_" + str(count) + ".jpg", new_image) count = count + 1 break if len(new_image) == 0: return "None", 0.0 new_image = cv2.resize(new_image, (64, 64)) new_image = new_image.astype("float") / 255.0 new_image = img_to_array(new_image) new_image = np.expand_dims(new_image, axis=0) # classify the input image using Keras' multi-output functionality #print("[INFO] classifying image...") prob = model.predict(new_image) #print("The predicted probability (mouth) is ",prob) mouthLabel = mouthLB.classes_ #print("The mouth labels are : ",mouthLabel) #mouthText = "head: {} ({:.2f}%)".format(mouthLabel, mouthProba[0][mouthIdx] * 100) #cv2.putText(output, mouthText, (10, 55), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2) # display the predictions to the terminal as well if prob < 0.5: #print("Mouth Prediction : ",mouthLabel[0],prob) return (mouthLabel[0], prob) else: #print("Mouth Prediction : ",mouthLabel[1],prob) return (mouthLabel[1], prob)
print(history.history.keys()) plt.figure() plt.plot(history.history['acc'], 'orange', label='Training accuracy') plt.plot(history.history['val_acc'], 'blue', label='Validation accuracy') plt.plot(history.history['loss'], 'red', label='Training loss') plt.plot(history.history['val_loss'], 'green', label='Validation loss') plt.legend() img_path = './Open_I_abd_vs_CXRs/TEST/chest2.png' #change to location of chest x-ray img_path2 = './Open_I_abd_vs_CXRs/TEST/abd2.png' #change to location of abd x-ray img = image.load_img(img_path, target_size=(img_width, img_height)) img2 = image.load_img(img_path2, target_size=(img_width, img_height)) img = image.img_to_array(img) x = np.expand_dims(img, axis=0) * 1. / 255 score = model.predict(x) print('Predicted:', score, 'Chest X-ray' if score < 0.5 else 'Abd X-ray') plt.figure() plt.imshow(img) plt.figure() plt.imshow(img2) img2 = image.img_to_array(img2) x = np.expand_dims(img2, axis=0) * 1. / 255 score2 = model.predict(x) print('Predicted:', score2, 'Chest X-ray' if score2 < 0.5 else 'Abd X-ray')
def preprocess_image(image_path): img = load_img(image_path, target_size = (img_height,img_width)) img = img_to_array(img) img = np.expand_dims(img,axis = 0) img = vgg19.preprocess_input(img) return img
plt.imshow(x_org) plt.show() plt.imshow(x_pos) plt.show() # x_pos = np.expand_dims(x_pos, axis=0) # x_pos = preprocess_input(x_pos) # pred_pos = base_model.predict(x_pos) # print("Un-poisoned image: {}".format(decode_predictions(pred, top=3)[0])) # print("Advserial image: {}".format(decode_predictions(pred_pos,top=3)[0])) ======= img_orginal = image.load_img(img_path) img = image.load_img(img_path, target_size=(224, 224)) x_org = image.img_to_array(img_orginal) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) pred = base_model.predict(x) x_pos = fast_signed_gradient(x, rand_other(pred)) x_pos = x_pos + x # x_pos = original_img_peturb(x_org,x_pos) # plt.imshow(x_org[:,:,::-1]) # plt.show() # plt.imshow(x_pos[:,:,::-1]) # plt.show() x_pos = preprocess_input(x_pos)
def image2x(image_path): img = image.load_img(image_path, target_size=(224, 224)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = utils.preprocess_input(x, version=1) # or version=2 return x
base_dir = '/Users/takaishikeito/Documents/DLDatasets/cats_and_dog_small' train_dir = os.path.join(base_dir, 'train') validation_dir = os.path.join(base_dir, 'validation') train_cats_dir = os.path.join(train_dir, 'cats') fnames = [ os.path.join(train_cats_dir, fname) for fname in os.listdir(train_cats_dir) ] print(len(fnames)) #1000 img_path = fnames[1] img = image.load_img(img_path, target_size=(150, 150)) print(str(img)) # RGB 150 * 150 #(150, 150, 3) x = image.img_to_array(img) #(1, 150, 150, 3) x = x.reshape((1, ) + x.shape) #print(x) i = 0 for batch in datagen.flow(x, batch_size=1): plt.figure(i) imgplot = plt.imshow(image.array_to_img(batch[0])) i += 1 if i % 4 == 0: break plt.show()
def load_processed_image_data(path): img = image.load_img(path, target_size=IMAGE_DIMS) img_array = image.img_to_array(img) return preprocess_input(img_array)