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 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 load_cat_dog(HEIGHT, WIDTH, train_frac, test_frac): img_dir = './Datasets/cat_dog/train/' files = os.listdir(img_dir) N_CATEGORY = 2 N_ALL = len(files) N_TRAIN = int(train_frac * N_ALL) x_train = np.empty((N_TRAIN, HEIGHT, WIDTH, 3), np.uint8) y_train = np.empty((N_TRAIN,), np.int8) for i in range(N_TRAIN): filename = files[i] img = load_img(img_dir + filename) img = img.resize((HEIGHT,WIDTH)) x_train[i,] = img entry = filename.split('.') y_train[i] = 1 if entry[0] == 'dog' else 0 N_TEST = int(test_frac * N_ALL) x_test = np.empty((N_TEST, HEIGHT, WIDTH, 3), np.uint8) y_test = np.empty((N_TEST,), np.int8) for i in range(N_TEST): filename = files[i + N_TRAIN] img = load_img(img_dir + filename) img = img.resize((HEIGHT,WIDTH)) x_test[i,] = img entry = filename.split('.') y_test[i] = 1 if entry[0] == 'dog' else 0 return x_train, y_train, x_test, y_test, N_CATEGORY
def test_load_img(self, tmpdir): filename = str(tmpdir / 'image.png') original_im_array = np.array(255 * np.random.rand(100, 100, 3), dtype=np.uint8) original_im = image.array_to_img(original_im_array, scale=False) original_im.save(filename) # Test that loaded image is exactly equal to original. loaded_im = image.load_img(filename) loaded_im_array = image.img_to_array(loaded_im) assert loaded_im_array.shape == original_im_array.shape assert np.all(loaded_im_array == original_im_array) loaded_im = image.load_img(filename, grayscale=True) loaded_im_array = image.img_to_array(loaded_im) assert loaded_im_array.shape == (original_im_array.shape[0], original_im_array.shape[1], 1) # Test that nothing is changed when target size is equal to original. loaded_im = image.load_img(filename, target_size=(100, 100)) loaded_im_array = image.img_to_array(loaded_im) assert loaded_im_array.shape == original_im_array.shape assert np.all(loaded_im_array == original_im_array) loaded_im = image.load_img(filename, grayscale=True, target_size=(100, 100)) loaded_im_array = image.img_to_array(loaded_im) assert loaded_im_array.shape == (original_im_array.shape[0], original_im_array.shape[1], 1) # Test down-sampling with bilinear interpolation. loaded_im = image.load_img(filename, target_size=(25, 25)) loaded_im_array = image.img_to_array(loaded_im) assert loaded_im_array.shape == (25, 25, 3) loaded_im = image.load_img(filename, grayscale=True, target_size=(25, 25)) loaded_im_array = image.img_to_array(loaded_im) assert loaded_im_array.shape == (25, 25, 1) # Test down-sampling with nearest neighbor interpolation. loaded_im_nearest = image.load_img(filename, target_size=(25, 25), interpolation="nearest") loaded_im_array_nearest = image.img_to_array(loaded_im_nearest) assert loaded_im_array_nearest.shape == (25, 25, 3) assert np.any(loaded_im_array_nearest != loaded_im_array) # Check that exception is raised if interpolation not supported. loaded_im = image.load_img(filename, interpolation="unsupported") with pytest.raises(ValueError): loaded_im = image.load_img(filename, target_size=(25, 25), interpolation="unsupported")
def path_to_tensor(img_path): # 用PIL加载RGB图像为PIL.Image.Image类型 img = image.load_img(img_path, target_size=(224, 224)) # 将PIL.Image.Image类型转化为格式为(224, 224, 3)的3维张量 x = image.img_to_array(img) # 将3维张量转化为格式为(1, 224, 224, 3)的4维张量并返回 return np.expand_dims(x, axis=0)
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 run(): parser = argparse.ArgumentParser() parser.add_argument("--file", help="file to process") parser.add_argument("--zoom", help="repeat zoom", type=int, default=1) args = parser.parse_args() if not args.file: return train_on_image_net() logger.debug('Start processing') logger.debug('Loading image') img = load_img(args.file) logger.debug('Opening zoom model') model = get_model_zoom(FEATURE_SIZE, IMAGE_SIZE, CONV_SIZE, CHANNELS) logger.debug('Loading zoom model') model.load_weights('weights/' + MODEL_NAME) logger.debug('Resizing image with standard filter.') img = img.resize((int(img.width * ZOOM_LEARN), int(img.height * ZOOM_LEARN)), ZOOM_TYPE) logger.debug('Zooming.') img = predict_base_image(CHANNELS, img, model, MODE) img.save('result.png', 'PNG') img.show()
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 loadImages(): # get current working directory path folder = 'data' # bats dataset dataroot = os.getcwd() + '/' + folder directoryList = os.listdir(dataroot) imageList =[] # loop over all the subdirectories and create the image array of all the images and store it in an array for categoryDir in directoryList: currentImageList = os.listdir(dataroot +'/'+ categoryDir) print ('Loading images for '+'{}\n'.format(categoryDir)) for currentImage in currentImageList: imagePath = dataroot + '/'+ categoryDir + '/'+ currentImage currentImage = image.load_img(imagePath, target_size=(224, 224)) x = image.img_to_array(currentImage) x = np.expand_dims(x, axis=0) x = preprocess_input(x) print('Image shape:', x.shape) imageList.append(x) # reshaping the data as needed by the resnet50 model i.e. (<observations>, 224, 224, 3) imageData = np.array(imageList) print(imageData.shape) # it should show (40,1, 224, 224, 3) imageData=np.rollaxis(imageData,1,0) print (imageData.shape) # it should show (1, 40, 224, 224, 3) imageData=imageData[0] print (imageData.shape) # now it should show (40, 224, 224, 3) , which is exactly the shape that we need return imageData
def load_images(random_state=1234): train_df = pd.read_csv("data/train.csv", index_col="id", usecols=[0]) depths_df = pd.read_csv("data/depths.csv", index_col="id") train_df = train_df.join(depths_df) test_df = depths_df[~depths_df.index.isin(train_df.index)] print(">>> train_df:",train_df.shape) print(train_df.head()) print(">>> test_df:", test_df.shape) print(test_df.head()) train_df["images"] = [gradmag(np.array(imread(path_train_images+"{}.png".format(idx)))) for idx in tqdm(train_df.index)] train_df["masks"] = [np.array(load_img(path_train_masks+"{}.png".format(idx),grayscale=True))/255 for idx in tqdm(train_df.index)] train_df["coverage"] = train_df.masks.map(np.sum) / pow(img_size_ori, 2) train_df["coverage_class"] = train_df.coverage.map(cov_to_class) print("*** TRAIN ***") print(train_df.head()) print("*** TEST ***") print(test_df.head()) ids_train, ids_valid, x_train, x_valid, y_train, y_valid, cov_train, cov_test, depth_train, depth_test = train_test_split( train_df.index.values, np.array(train_df.images.tolist()).reshape(-1, img_size_target, img_size_target, 1), np.array(train_df.masks.tolist()).reshape(-1, img_size_target, img_size_target, 1), train_df.coverage.values, train_df.z.values, test_size=0.2, stratify=train_df.coverage_class, random_state=random_state) #Data augmentation x_train2 = np.append(x_train, [np.fliplr(x) for x in x_train], axis=0) y_train2 = np.append(y_train, [np.fliplr(x) for x in y_train], axis=0) print(x_train2.shape) print(y_valid.shape) x_test = np.array([gradmag(np.array(imread(path_test_images+"{}.png".format(idx)))) for idx in tqdm(test_df.index)]).reshape(-1, img_size_target, img_size_target, 1) return x_train2, x_valid, y_train2, y_valid, x_test, test_df.index.values
def load_image(path): img_path = sys.argv[1] img = image.load_img(img_path, target_size=(224, 224)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) return x
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 augment_img(input_file, output_folder, img_format='jpg', number_imgs=10): """ Generate number_imgs new images from a given image. This function is inspired from the following blog post: https://blog.keras.io/building-powerful-image-classification-models-using-very-little-data.html """ datagen = ImageDataGenerator( rotation_range=40, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.2, zoom_range=0.2, horizontal_flip=True, fill_mode='nearest') img = load_img(input_file) x = img_to_array(img) x = x.reshape((1,) + x.shape) i = 0 for batch in datagen.flow(x, batch_size=1, save_to_dir=output_folder, save_format=img_format): i += 1 if i > number_imgs: break
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_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 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 on_epoch_end(self, epoch, logs={}): filepath = self.filepath.format(epoch=epoch, **logs) if self.save_best_only: current = logs.get(self.monitor) if current is None: warnings.warn("Can save best model only with %s available, skipping." % (self.monitor), RuntimeWarning) else: if current < self.best: if self.verbose > 0: print("Epoch %05d: %s improved from %0.5f to %0.5f, saving model to %s" % (epoch, self.monitor, self.best, current, filepath)) self.best = current self.model.save_weights(filepath, overwrite=True) self.model_dict['best'] = current img = load_img('/home/robin/test-deblur-test.png') img = predict_base_image_channels_1(1, img, self.model, 'RGB') if self.viewer: close(self.viewer) self.viewer = show_img(img, self.no) self.no += 1 # img.save('/home/robin/test-deblur.png', 'PNG') else: if self.verbose > 0: print("Epoch %05d: %s did not improve" % (epoch, self.monitor)) else: if self.verbose > 0: print("Epoch %05d: saving model to %s" % (epoch, filepath)) self.model.save_weights(filepath, overwrite=True)
def val_images_to_array(img_path, source_path, img_dim, categories): array_path = os.path.join(source_path, 'array') shutil.rmtree(array_path,ignore_errors=True) os.makedirs(array_path) print('Iterating over all categories: ', categories) category_lengths = [] for category_idx, category in enumerate(categories): print('categories:', category) category_path = os.path.join(img_path, category) img_files = sorted(os.listdir(category_path)) category_lengths.append(len(img_files)) for img_idx, img_file in tqdm(enumerate(img_files)): this_img_path = os.path.join(category_path, img_file) img = load_img(this_img_path, target_size=(img_dim, img_dim)) img_name = '{}-img-{}-{}'.format(img_idx, category, category_idx) label_name = '{}-label-{}-{}'.format(img_idx, category, category_idx) label = np.eye(len(categories), dtype = np.float32)[category_idx] img_array_path = os.path.join(array_path, img_name) img_label_path = os.path.join(array_path, label_name) np.save(img_array_path, img) np.save(img_label_path, label) category_lengths = np.array(category_lengths) / sum(category_lengths) category_lengths = list(category_lengths / max(category_lengths)) category_rounds = {cat: min(int(np.round(1 / l)), 10) for cat, l in zip(categories, category_lengths)} return category_rounds
def convex_hull(imagefile): im1=image.load_img(imagefile,target_size=(224,224)) im1array=image.img_to_array(im1) hull=ConvexHull(im1array[0]) print "Convex Hull vertices:",hull.vertices print "Convex Hull area:",hull.area return (hull.vertices, hull.area)
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
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 path_to_tensor(image_path, target_size): image = load_img(image_path, target_size=target_size) tensor = img_to_array(image) tensor = np.expand_dims(tensor, axis=0) return tensor
else: print("cat") classifier.save('my_model.h5') """ #After training #Warning this code must only be added after model was creating. Luckily for you I've got a saved model in the .h5 so you can test off of that one #However if you want to train another model, you'll have to comment out this below and remove the comments from the block above. #The above code just creates the model though, the code below saves it's object data in a .h5 file and then also allows you to use the model #-As many times as you want even after the program is killed. So no need to train it for hours again :D from keras.models import load_model classfier = load_model( '\hello.h5' ) #please make sure the .h5 files is within the same dir, as the CNN.py file import numpy as np from keras.preprocessing import image test_img = image.load_img( 'F:\animal.png', target_size=(64, 64) ) #please make sure you give the correct dir of where the image files is that you want to test test_img = image.img_to_array(test_img) test_img = np.expand_dims(test_img, axis=0) result = classfier.predict(test_img) #train_gen.class_indices if result[0][0] > 0.5: print("dog") else: print("cat")
# Plot normalized confusion matrix plt.figure() plot_confusion_matrix(cm, classes=class_names, normalize=True, title='Normalized confusion matrix') plt.show() # ------------------------------------------------------------------------------ # Make prediction for signle image image_path = 'dataset/eva.2.png' #orig = cv2.imread(image_path) #print("[INFO] loading and preprocessing image...") image = load_img(image_path, target_size=(in_s, in_s)) image = img_to_array(image) # important! otherwise the predictions will be '0' image = image / 255 image = np.expand_dims(image, axis=0) # ------------------------------------------------------------------------------ # run the image through the same pipeline # build the VGG16 network model = applications.VGG16(include_top=False, weights='imagenet') # get the bottleneck prediction from the pre-trained VGG16 model bottleneck_prediction = model.predict(image) # build top model model = Sequential() model.add(Flatten(input_shape=bottleneck_prediction.shape[1:]))
# -*- coding: utf-8 -*- """ Created on Fri Oct 18 22:37:37 2019 @author: SJana """ from keras.models import load_model from keras.preprocessing.image import load_img, img_to_array import numpy as np model = load_model('document_classification_model.h5') test_img = load_img('Documents/test_img/test/test1.jpg', target_size=(64, 64)) test_img.size test_img.show() test_image = img_to_array(test_img) test_image = np.expand_dims(test_image, axis=0) test_image.shape image_label = model.predict(test_image) print(image_label)
def preprocess_image(img): img = image.load_img(img, target_size=(224, 224)) img = image.img_to_array(img) img = np.expand_dims(img, axis=0) img = preprocess_input(img) return img
# This is module with image preprocessing utilities import os import matplotlib.pyplot as plt from cat_vs_dogs_create_data_sets import * from keras.preprocessing import image from cats_dogs.cats_vs_dgos_2 import datagen fnames = [ os.path.join(train_cats_dir, fname) for fname in os.listdir(train_cats_dir) ] img_path = fnames[3] # We pick one image to "augment" img = image.load_img(img_path, target_size=(150, 150)) # Read the image and resize it x = image.img_to_array( img) # Convert it to a Numpy array with shape (150, 150, 3) x = x.reshape((1, ) + x.shape) # Reshape it to (1, 150, 150, 3) # The .flow() command below generates batches of randomly transformed images. # It will loop indefinitely, so we need to `break` the loop at some point! 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()
#!/usr/bin/env python3 # -*- coding: utf-8 -*- ### Learning TensorFlow with Laurence Moroney, Google Brain on Coursera ### /Users/trannguyen/TranData/WORK/BioinformaticsSpecialization_Tran_2019/\ ###/MachineLearning/TensorFlow/TensorFlowCodes import numpy as np from google.colab import files from keras.preprocessing import image uploaded = files.upload() for fn in uploaded.keys(): # predicting images path = '/content/' + fn img = image.load_img(path, target_size=(150, 150)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) images = np.vstack([x]) # classes = model.predict(images, batch_size=10) # print(classes[0]) # if classes[0]>0.5: # print(fn + " is a human") # else: # print(fn + " is a horse") #
channels = 3 size = img_h * img_w return K.sum(K.square(S - G) / (4 * (channels**2) * (size**2))) def total_variation_loss(x): # to smooth the generated image a = K.square(x[:, :img_h - 1, :img_w - 1, :] - x[:, 1:, :img_w - 1, :]) b = K.square(x[:, :img_h - 1, :img_w - 1, :] - x[:, :img_h - 1, 1:, :]) return K.sum(K.pow(a + b, 1.25)) CONTENT_IMG_PATH = "content.jpg" STYLE_IMG_PATH = "style.jpg" h, w = load_img(CONTENT_IMG_PATH).size img_h = 400 img_w = int(h * img_h / w) content_img = K.variable(preprocess(CONTENT_IMG_PATH)) style_img = K.variable(preprocess(STYLE_IMG_PATH)) gen_img = K.placeholder(shape=(1, img_h, img_w, 3)) input_tensor = K.concatenate([content_img, style_img, gen_img], axis=0) model = vgg19.VGG19(include_top=False, weights='imagenet', input_tensor=input_tensor) print('Model Loaded...') print(model.summary())
pred_scores = np.zeros((5, 36)) vgg_features = VGGFace(include_top=False, model='resnet50', input_shape=(224, 224, 3)) gender = np.load('bounds/pggan_celebahq_gender_boundary.npy') age = np.load('bounds/pggan_celebahq_age_boundary.npy') eyeglasses = np.load('bounds/pggan_celebahq_eyeglasses_boundary.npy') pose = np.load('bounds/pggan_celebahq_pose_boundary.npy') smile = np.load('bounds/pggan_celebahq_smile_boundary.npy') boundaries = [gender, age, eyeglasses, pose, smile] Y_test = cupy.asnumpy(Y_test) T_test = cupy.asnumpy(T_test) for trial in range(trials): stim_ssim = np.array(Image.open("stimuli/%i.png" % trial)) recon_ssim = np.array(Image.open("reconstructions/%i.png" % trial)) stim_fsim = image.load_img("stimuli/%i.png" % trial, target_size=(224, 224)) recon_fsim = image.load_img("reconstructions/%i.png" % trial, target_size=(224, 224)) test_feats[trial] = get_features(stim_fsim) pred_feats[trial] = get_features(recon_fsim) metrics['lsim'][trial] = 1. / (1 + mean_squared_error(Y_test[trial], T_test[trial])) metrics['fsim'][trial] = 1. / (1 + mean_squared_error(test_feats[trial], pred_feats[trial])) metrics['ssim'][trial] = ssim(stim_ssim, recon_ssim, multichannel=True) for i, boundary in enumerate(boundaries): test_scores[i, trial] = T_test[trial].reshape(1, -1).dot(boundary.T)[0][0] pred_scores[i, trial] = Y_test[trial].reshape(1, -1).dot(boundary.T)[0][0] # print metrics print("latent similarity: %.4f" % metrics['lsim'].mean()) print("Feature similarity: %.4f" % metrics['fsim'].mean())
def get_image(img_id): img = image.load_img(img_id, target_size=(input_size, input_size)) img = image.img_to_array(img) img = img / 255. return img
le = preprocessing.LabelEncoder() le.fit(y_train) y_train = le.transform(y_train) y_test = le.transform(y_test) no_classes = len(np.unique(y_train)) print("Number of classes: " + str(no_classes)) y_train = to_categorical(y_train, num_classes = no_classes) y_test = to_categorical(y_test, num_classes = no_classes) images_train = np.zeros((x_train.shape[0],224,224,3)) print("Loading train images") for i in range(x_train.shape[0]): image_name = path + str(x_train[i]) img = image.img_to_array(image.load_img(image_name)) images_train[i] = img print(images_train.shape) images_train = preprocess_input(images_train) images_test = np.zeros((x_test.shape[0],224,224,3)) print("Loading test images") for i in range(x_test.shape[0]): image_name = path + str(x_test[i]) img = image.img_to_array(image.load_img(image_name)) images_test[i] = img print(images_test.shape)
# Importing necessary functions from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img # Initialising the ImageDataGenerator class. # We will pass in the augmentation parameters in the constructor. datagen = ImageDataGenerator(rotation_range=40, shear_range=0.2, zoom_range=0.2, horizontal_flip=True, brightness_range=(0.5, 1.5)) src = r'F:\bike_car\bike' + '\\' ext = '.jpg' for j in range(1, 619): # Loading a sample image img = load_img(src + str(j) + ext) # Converting the input sample image to an array x = img_to_array(img) # Reshaping the input image x = x.reshape((1, ) + x.shape) # Generating and saving 5 augmented samples # using the above defined parameters. i = 0 for batch in datagen.flow(x, batch_size=1, save_to_dir='F:\\bike_car\\aug_bike', save_prefix='image', save_format='jpg'): i += 1 if i > 5:
def image_augment_for_directory(img_data_path='./img_data/', text_data_path='./caption_text/', save_img_path='./augment_img_data/', save_text_path='./augment_caption_text/', image_size=(224, 224), augment_count=5): """ 对一个文件夹中所有的图像进行随机数据增强,并对其匹配对应的文本数据 将增强后的数据+原始数据单独存在另一个文件夹,不要和原来的数据混合 :param img_data_path: 原始图片所在的文件夹路径 [str] :param text_data_path: 原始文本数据所在的路径 [str] :param save_img_path: 增强后的图片数据所在的路径 [str] :param save_text_path: 和增强后的图像数据匹配的文本数据存储路径 [str] :param image_size: 图片的像素 [tuple] :param augment_count: 每一张图片需要随机增强的倍数 [int] :return: """ filename_lst = os.listdir(img_data_path) img_lst = [int(x[:-4]) for x in filename_lst] filename_lst = [os.path.join(img_data_path, x) for x in filename_lst] if not os.path.exists(save_img_path): os.mkdir(save_img_path) max_index = max(img_lst) else: saved_img = os.listdir(save_img_path) saved_img_num = [int(x[:-4]) for x in saved_img] max_index = max(saved_img_num) if not os.path.exists(save_text_path): os.mkdir(save_text_path) # 进行数据增强 fail = [] index = max_index + 1 for img_path, img_num in zip(filename_lst, img_lst): try: img_path_to_aug = os.path.join(save_img_path, str(img_num) + '.png') text_path_to_aug = os.path.join(save_text_path, str(img_num) + '.txt') # 先判断当前图片是否已经处理过 如果是 则跳过 if os.path.exists(img_path_to_aug) and\ os.path.exists(text_path_to_aug): print('{0} is done.'.format(img_num)) continue temp_img = image.load_img(path=img_path, target_size=image_size) temp_img = image.img_to_array(temp_img) with codecs.open(os.path.join(text_data_path, str(img_num) + '.txt'), 'r', encoding='utf-8') as fr: temp_text = fr.read() # 先将原始数据存到save的文件夹 image.save_img(path=img_path_to_aug, x=temp_img) with codecs.open(text_path_to_aug, 'w', encoding='utf-8') as ft: ft.writelines(temp_text) # augment for i in range(augment_count): # 给每一个新的图像匹配对应文本数据 并存入文件夹 new_img_path = os.path.join(save_img_path, str(index) + '.png') new_text_path = os.path.join(save_text_path, str(index) + '.txt') new_img = image_augment(arr=temp_img) image.save_img(path=new_img_path, x=new_img) with codecs.open(new_text_path, 'w', encoding='utf-8') as fw: fw.writelines(temp_text) index += 1 print(img_num) except: fail.append(img_num) print('picture {0} is fail.'.format(img_num)) continue return fail
def generate(self, processed_rects, batch_size, verbose=False): batch_x = [] batch_y = [[] for _ in range(2 * len(self.model.shapes))] while 1: keys = np.array(processed_rects.keys()) ind = np.arange(len(keys)) np.random.shuffle(ind) rnd = np.random.rand(len(keys)) empty_name = os.listdir(self.path_empty) empty_ind = np.random.randint(len(empty_name), size=len(keys)) for jj in ind: # print jj, rnd[jj] if rnd[jj] < self.empty_ratio: processed_key = '' else: processed_key = keys[jj] #print processed_key if processed_key != '' and self.train and processed_key not in self.train: continue name = os.path.splitext(processed_key)[0] if processed_key == '': img_path = os.path.join(self.path_empty, empty_name[empty_ind[jj]]) else: img_path = os.path.join(self.path, name + '.jpg') img = image.load_img(img_path, target_size=(300, 300)) img = image.img_to_array(img) #img = np.expand_dims(img, axis=0) #img = preprocess_input(img) if verbose: print img_path bboxes, classes = self._generate_for_bbox(processed_rects[processed_key]) # add extra dimension for each bbox value rs = lambda x: np.reshape(x, tuple(list(x.shape) + [1])) bboxes_tensors = [rs(np.append(bbox, cls, axis=2)) for bbox, cls in zip(bboxes, classes)] classes_tensors = [rs(cls[:, :, ::4]) for cls in classes] y = bboxes_tensors + classes_tensors batch_x.append(np.array(img)) for i in range(len(y)): batch_y[i].append(y[i]) # create Numpy arrays of input data and labels, from each line in the file # x, y = process_line(line) if len(batch_x) == batch_size: batch_y = list(map(np.array, batch_y)) res = {name: value for name, value in zip(self.model.bbox_names + self.model.cls_names, batch_y)} # res['input_1'] = np.array(batch_x) yield ({'input': preprocess_input(np.array(batch_x))}, res) batch_x = [] batch_y = [[] for _ in range(2 * len(self.model.shapes))]
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
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) # Making single predictions import numpy as np from keras.preprocessing import image test_image = image.load_img('dataset/single_prediction/cat_or_dog_1.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'
# best so far 94% #model_path = '/Users/natewagner/Documents/ML_Final_Project/mask_rcnn_.1588546554.8807812.h5' from keras.preprocessing.image import load_img from keras.preprocessing.image import img_to_array #Loading the model in the inference mode model = modellib.MaskRCNN( mode="inference", config=config, model_dir= '/Users/natewagner/Documents/ML_Final_Project/mask_rcnn_.1588559854.111884.h5' ) # loading the trained weights o the custom dataset model.load_weights(model_path, by_name=True) img = load_img( "/Users/natewagner/Documents/ML_Final_Project/images/survey-page-B16-52.jpg" ) #img = load_img("/Users/natewagner/Documents/ML_Final_Project/new_image_arranged.jpg") img = img_to_array(img) # detecting objects in the image results = model.detect([img], verbose=1) r = results[0] visualize.display_instances(img, r['rois'], r['masks'], r['class_ids'], ['BG', 'box', 'checked_box'], r['scores'], title="Predictions")
def create_adversarial_pattern(input_image, input_label): input_label = label with tf.GradientTape() as tape: tape.watch(input_image) prediction = pretrained_model(input_image) loss = loss_object(input_label, prediction) # Get the gradients of the loss w.r.t to the input image. gradient = tape.gradient(loss, input_image) # Get the sign of the gradients to create the perturbation return tf.sign(gradient) if __name__ == '__main__': for f in files: img = image.load_img(f, target_size=(224, 224)) if img is None: continue x = image.img_to_array(img) x = np.expand_dims(x, axis = 0) image_probs = net.predict(x) pred = image_probs[0] top_inds = pred.argsort()[::-1][:5] print(f,' is ',cls_list[top_inds[0]]) for i in top_inds: print(' {:.3f} {}'.format(pred[i], cls_list[i])) print() # Get the input label of the image. labrador_retriever_index = top_inds[0]
# for item in os.listdir(train_dir): image_list.append(item) np.random.shuffle(image_list) #创建数组,储存图片信息。结构为(50321, 36, 120, 3),50321代表样本个数,然后是宽度和高度。 # 3代表图片的通道数,如果对图片进行了灰度处理,可以改为单通道 1 X = np.zeros((len(image_list), height, width, 3), dtype = np.uint8) # 创建数组,储存标签信息 y = np.zeros((len(image_list), word_len * word_class), dtype = np.uint8) for i,img in enumerate(image_list): if i % 10000 == 0: print(i) img_path = train_dir + "/" + img #读取图片 raw_img = image.load_img(img_path, target_size=(height, width)) #讲图片转为np数组 X[i] = image.img_to_array(raw_img) #讲标签转换为数组进行保存 y[i] = captcha_to_vec(img.split('.')[0]) #创建输入,结构为 高,宽,通道 input_tensor = Input( shape=(height, width, 3)) x = input_tensor #构建卷积网络 #两层卷积层,一层池化层,重复3次。因为生成的验证码比较小,padding使用same x = Convolution2D(32, 3, padding='same', activation='relu')(x) x = Convolution2D(32, 3, padding='same', activation='relu')(x) # x= BatchNormalization()(x)
from keras.applications.vgg16 import VGG16 from keras.applications.vgg16 import preprocess_input, decode_predictions import keras.preprocessing.image as Image import numpy as np model = VGG16(weights="imagenet", include_top=True) image_path = "sample_images_pretrain/elephant.jpg" image = Image.load_img(image_path, target_size=(224, 224)) # imagenet size x = Image.img_to_array(image) x = np.expand_dims(x, axis=0) # add batch size dim x = preprocess_input(x) result = model.predict(x) result = decode_predictions(result, top=3)[0] print(result[0][1]) # show description
def read_image(filepath, size): img = image.load_img(filepath, target_size=size) img = image.img_to_array(img) return img
validation_steps=400) classifier.save_weights('Multiclassifier.h5') import numpy as np from keras.preprocessing import image from os import listdir from os.path import isfile, join path = 'dataset/gameset/' files = [f for f in listdir(path) if isfile(join(path, f))] idx = 0 for fl in files: # print(fl) test_image = image.load_img(path + fl, target_size=(image_size, image_size)) test_image = image.img_to_array(test_image) test_image = np.expand_dims(test_image, axis=0) result = classifier.predict(test_image) # if idx == 56: # print(result) # print(result) if result[0][0] > 0.5: print(str(idx) + ". 1") elif result[0][1] > 0.5: print(str(idx) + ". 2") elif result[0][2] > 0.5: print(str(idx) + ". 3") elif result[0][3] > 0.5: print(str(idx) + ". 4")
datagen = ImageDataGenerator( rotation_range=180, width_shift_range=0, shear_range=0.3, height_shift_range=0, zoom_range=[1.3, 1.5], horizontal_flip=False, fill_mode="nearest", channel_shift_range=90, brightness_range=[0.7, 1], #preprocessing_function=blur ) for i in range(len(images)): img = load_img(images[i], color_mode="rgba") img = img.resize((416, 416)) x = img_to_array(img) x = np.expand_dims(x, axis=0) draw_images(datagen, x, output_dir, i) class_dict = { "background": 0, "rasp0w": 10, "rasp3a+": 20, "rasp3b": 30, "rasp3b+": 40, "rasp4b": 50 } try:
from keras.applications.resnet50 import ResNet50 from keras.preprocessing import image from keras.applications.resnet50 import preprocess_input, decode_predictions import numpy as np """ 1- ResNet50 """ model = ResNet50(weights='imagenet', include_top=True) img_path = "/Users/agambo/deep_learning/tuto/elephant.jpg" img = image.load_img(img_path, target_size=(224, 224)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) from matplotlib import pyplot from scipy.misc import toimage pyplot.subplot(332) pyplot.imshow(toimage(img)) pyplot.show() 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=10)[0]) """ 2- VGG 16 """ from keras.applications.vgg16 import VGG16
# ResNet50 is a powerful model for image classification when it is trained for an adequate number of iterations. We hope you can use what you've learnt and apply it to your own classification problem to perform state-of-the-art accuracy. # # Congratulations on finishing this assignment! You've now implemented a state-of-the-art image classification system! # ## 4 - Test on your own image (Optional/Ungraded) # If you wish, you can also take a picture of your own hand and see the output of the model. To do this: # 1. Click on "File" in the upper bar of this notebook, then click "Open" to go on your Coursera Hub. # 2. Add your image to this Jupyter Notebook's directory, in the "images" folder # 3. Write your image's name in the following code # 4. Run the code and check if the algorithm is right! # In[32]: img_path = 'images/my_image.jpg' img = image.load_img(img_path, target_size=(64, 64)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = x / 255.0 print('Input image shape:', x.shape) my_image = scipy.misc.imread(img_path) imshow(my_image) print("class prediction vector [p(0), p(1), p(2), p(3), p(4), p(5)] = ") print(model.predict(x)) # You can also print a summary of your model by running the following code. # In[33]: model.summary()
pyplot.imshow(image) pyplot.show() # # Image Preprocessing # ## Downsizing Images # Images are downsized to a standard aspect ratio (150 × 150). # In[16]: from keras.preprocessing.image import load_img fig = pyplot.figure(figsize=(15, 4)) image = load_img(A[30]) # original image fig.add_subplot(1, 2, 1) pyplot.imshow(image) image = load_img(A[30], target_size=(150, 150)) # downsized image fig.add_subplot(1, 2, 2) pyplot.imshow(image) pyplot.show() # ## Converting Images to Arrays # In[17]: from keras.preprocessing.image import array_to_img, img_to_array
'D:/deeplearning/[FreeTutorials.Us] deeplearning/10 Building a CNN/Convolutional_Neural_Networks/dataset/test_set', target_size=(64, 64), batch_size=32, class_mode='binary') classifier.fit_generator(training_set, steps_per_epoch=8000, epochs=3, validation_data=test_set, validation_steps=2000) ##Prediction Part import numpy as np from keras.preprocessing import image img_pred = image.load_img( 'D:/deeplearning/[FreeTutorials.Us] deeplearning/10 Building a CNN/Convolutional_Neural_Networks/dataset/single_prediction/cat_or_dog_5.jpg', target_size=(64, 64)) img_pred = image.img_to_array(img_pred) img_pred = np.expand_dims(img_pred, axis=0) rslt = classifier.predict(img_pred) ind = training_set.class_indices if rslt[0][0] == 1: prediction = "dog" else: prediction = "cat" ##Save model to json import os from keras.models import model_from_json
# In[3]: train = pd.read_csv('train-scene/train.csv') test = pd.read_csv('test.csv') # In[4]: image_path = 'train-scene/train/' # In[5]: from scipy.misc import imresize train_img = [] for i in range(len(train)): temp_img = image.load_img(image_path + train['image_name'][i], target_size=(150, 150)) temp_img = image.img_to_array(temp_img) train_img.append(temp_img) # In[6]: x_train = np.array(train_img) #train_img=preprocess_input(train_img) # In[7]: test_img = [] for i in range(len(test)): temp_img = image.load_img(image_path + test['image_name'][i], target_size=(150, 150)) temp_img = image.img_to_array(temp_img)
def path_to_tensor(img_path): img = image.load_img(img_path, target_size=(224, 224)) x = image.img_to_array(img) return np.expand_dims(x, axis=0)
datagen = ImageDataGenerator(featurewise_center=False, featurewise_std_normalization=False, preprocessing_function=preprocess) generator = datagen.flow_from_directory( 'numbers_train', target_size=(48, 48), batch_size=1024, # Only 405 images in directory, so batch always the same classes=['02'], shuffle=False, class_mode='sparse') inputs, targets = next(generator) folder = 'numbers_train/02' files = os.listdir(folder) files = list(map(lambda x: os.path.join(folder, x), files)) images = [] for f in files: img = image.load_img(f) #img = img.resize((48, 48)) img = image.img_to_array(img) img = preprocess(img) images.append(img) inputs2 = np.asarray(images) print(np.mean(inputs)) print(np.mean(inputs2))