def data_gen(input_path_root, target_path_root, batch_size): input_dir_names = os.listdir(input_path_root) target_dir_names = os.listdir(target_path_root) # 共通のディレクトリのみを対象とする dir_names = set(input_dir_names) & set(target_dir_names) path_pairs = [] for dir_name in dir_names: input_dir = os.path.join(input_path_root, dir_name) target_dir = os.path.join(target_path_root, dir_name) i_pathes = sorted(list_pictures(input_dir)) t_pathes = sorted(list_pictures(target_dir)) path_pairs += zip(i_pathes, t_pathes) n_batch = math.ceil(len(path_pairs) / batch_size) while True: for i in range(n_batch): batch_path_pairs = path_pairs[i * batch_size:(i + 1) * batch_size] batch_size = len(batch_path_pairs) batch_input_img = np.empty(shape=(batch_size, 256, 256, 1)) batch_target_img = np.empty(shape=(batch_size, 256, 256, 1)) for i, path_pair in enumerate(batch_path_pairs): x = load_scaled_img(path_pair[0]) x -= np.mean(x, keepdims=True) x /= (np.std(x, keepdims=True) + K.epsilon()) batch_input_img[i] = x batch_target_img[i] = load_scaled_img(path_pair[1]) yield batch_input_img, batch_target_img
def prepare_train(): X = [] Y = [] # 対象Aの画像 for picture in list_pictures('./ordinary/'): img = img_to_array(load_img(picture, target_size=(224, 224))) X.append(img) Y.append(0) # 対象Bの画像 for picture in list_pictures('./jiro/'): img = img_to_array(load_img(picture, target_size=(224, 224))) X.append(img) Y.append(1) # arrayに変換 X = np.asarray(X) Y = np.asarray(Y) # 画素値を0から1の範囲に変換 X = X.astype('float32') X = X / 255.0 # クラスの形式を変換 Y = np_utils.to_categorical(Y, 2) # 学習用データとテストデータ X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=111) return X_train, X_test, y_train, y_test
def __init__(self, root_dir, classes=None, mean=IMAGENET_MEAN, std=IMAGENET_STD, color_mode="rgb"): """ ILSVRC data generator. # Arguments: - root_dir: Root directory of the ILSVRC dataset, containing directories "ILSVRC2012_img_train" and "ILSVRC2012_img_val", both containing sub-directories with names of synsets and the images for each synset in the corresponding sub-directories. - classes: List of synsets to restrict the dataset to. Numeric labels will be assigned to these synsets in ascending order. If set to `None`, all available synsets will be used and enumerated in the lexicographical order. - mean: Channel-wise image mean for normalization (in "RGB" order). If set to `None`, mean and standard deviation will be computed from the images. - std: Channel-wise standard deviation for normalization (in "RGB" order). If set to `None`, standard deviation will be computed from the images. - color_mode: Image color mode, either "rgb" or "bgr". """ super(ILSVRCGenerator, self).__init__(root_dir, classes, default_target_size=256, randzoom_range=(256, 480), color_mode=color_mode) self.train_dir = os.path.join(self.root_dir, 'ILSVRC2012_img_train') self.test_dir = os.path.join(self.root_dir, 'ILSVRC2012_img_val') # Search for classes if classes is None: classes = [] for subdir in sorted(os.listdir(self.train_dir)): if os.path.isdir(os.path.join(self.train_dir, subdir)): classes.append(subdir) self.classes = classes self.class_indices = dict(zip(self.classes, range(len(self.classes)))) # Search for images for lbl, subdir in enumerate(self.classes): cls_files = sorted( list_pictures(os.path.join(self.train_dir, subdir), 'JPE?G|jpe?g')) self.train_img_files += cls_files self._train_labels += [lbl] * len(cls_files) cls_files = sorted( list_pictures(os.path.join(self.test_dir, subdir), 'JPE?G|jpe?g')) self.test_img_files += cls_files self._test_labels += [lbl] * len(cls_files) print('Found {} training and {} validation images from {} classes.'. format(self.num_train, self.num_test, self.num_classes)) # Compute mean and standard deviation self._compute_stats(mean, std)
def load_images(dir, grayscale=False): imgs = [] for i in image_utils.list_pictures(dir): imgs.append( image_utils.img_to_array( image_utils.load_img(i, grayscale=grayscale, target_size=i_shape))) return image_utils.list_pictures(dir), np.array(imgs)
def data_gen(path_dir, batch_size): dir_names = sorted(os.listdir(path_dir)) dir_pathes = [os.path.join(path_dir, d) for d in dir_names] n_pair = len(dir_names) - 1 n_batches = math.ceil(n_pair / batch_size) while True: for i in range(n_batches): start = i * batch_size end = start + batch_size if end > n_pair: end = n_pair file_pathes_list = [ list_pictures(d) for d in dir_pathes[start:end] ] max_page_len = max([len(ps) for ps in file_pathes_list]) enc_inputs = [ load_img_batch(p, max_page_len) for p in file_pathes_list ] batch_enc_inputs = np.empty(shape=(len(enc_inputs), max_page_len, 256, 256, 1)) for i, e in enumerate(enc_inputs): batch_enc_inputs[i] = e file_pathes_list = [ list_pictures(d) for d in dir_pathes[start + 1:end + 1] ] max_page_len = max([len(ps) for ps in file_pathes_list]) # BOSあり reshaped_bos = BOS.reshape(1, 256, 256, 1) dec_inputs = [ np.vstack((reshaped_bos, load_img_batch(p, max_page_len))) for p in file_pathes_list ] batch_dec_inputs = np.empty(shape=(len(dec_inputs), max_page_len, 256, 256, 1)) for i, d in enumerate(dec_inputs): batch_dec_inputs[i] = d[:-1] batch_dec_outputs = np.empty(shape=(len(dec_inputs), max_page_len, 256, 256, 1)) for i, d in enumerate(dec_inputs): batch_dec_outputs[i] = d[1:] yield [batch_enc_inputs, batch_dec_inputs], batch_dec_outputs
def main(): X_train = [] y_train = [] X_test = [] y_test = [] for picture in list_pictures('./roboint/moji/train/pos/'): img = img_to_array( load_img(picture, target_size=(image_size, image_size))) X_train.append(img) y_train.append(0) for picture in list_pictures('./roboint/moji/train/neg/'): img = img_to_array( load_img(picture, target_size=(image_size, image_size))) X_train.append(img) y_train.append(1) for picture in list_pictures('./roboint/moji/test/pos/'): img = img_to_array( load_img(picture, target_size=(image_size, image_size))) X_test.append(img) y_test.append(0) for picture in list_pictures('./roboint/moji/test/neg/'): img = img_to_array( load_img(picture, target_size=(image_size, image_size))) X_test.append(img) y_test.append(1) X_train = np.array(X_train) y_train = np.array(y_train) X_test = np.array(X_test) y_test = np.array(y_test) X_train = X_train.astype('float32') X_train = X_train / 255.0 X_test = X_test.astype('float32') X_test = X_test / 255.0 y_train = np_utils.to_categorical(y_train, nb_classes) y_test = np_utils.to_categorical(y_test, nb_classes) # モデルを訓練し評価する model = model_train(X_train, y_train) model_eval(model, X_test, y_test) #おまけ(テスト画像の予想を出力) """
def load_images(image_dir, W, H, image_array_divided_by=1): from keras.preprocessing import image # Get list of all files asuming that files are image type only list_of_files = image.list_pictures(image_dir) print("Count of image files read is ", len(list_of_files)) # Iterate over each images and read their sizes list_images = [] for img_name in list_of_files: #[0:10] img_name = list_of_files[0] img_path = img_name img = np.NaN #img = image.load_img(img_path, target_size=(W, H)) if W > 0 and H > 0: img = image.load_img(img_path, target_size=(W, H)) else: img = image.load_img(img_path) x = image.img_to_array(img) x /= image_array_divided_by list_images.append(x) del (img, x) # Stack to have one complete list as required by NN train = np.stack(list_images) # Cleaning del (list_images) # Return all required return ({"train": train, "list_of_files": list_of_files})
def generator(img_dir, cap_path, batch_size, max_len=30): fh = open(cap_path) raw_data = fh.read() data = json.loads(raw_data) img_groups = {} all_captions = [] for img_group in data['images']: img_groups[img_group['filename']] = [] for sentence in img_group['sentences']: img_groups[img_group['filename']].append(sentence['raw']) all_captions.append(sentence['raw']) preprocessor = CaptionPreprocessor(rare_words_handling='nothing') preprocessor.fit_on_captions(all_captions) image_files = list_pictures(img_dir) image_processor = ImagePreprocessor(is_training=True, img_size=(299, 299)) ''' global img_array if os.path.exists('./img_array.npy'): img_array = np.load('./img_array.npy') else: print("Preprocessing images...\n") img_array = image_processor.process_images(image_files) print("\nImages preprocessed.") np.save('./img_array', img_array) ''' return ImgSequence(img_groups, image_files, img_dir, batch_size, (image_processor, preprocessor), max_len)
def extract_inception(): model = InceptionV3(weights='imagenet', include_top=False) print(model.summary()) X_dirname = '../../411a3/train' Y_filename = '../../411a3/train.csv' X_filelist = image.list_pictures(X_dirname) Y_list = np.loadtxt(Y_filename, dtype='str', delimiter=',')[1:] X_inception = np.zeros((train_size, 2048, 8, 8)) y_inception = Y_list[:, 1].astype('int64').reshape(-1, 1) - 1 for i in range(train_size): img = image.load_img(X_filelist[i], target_size=target_size) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) inception = model.predict(x) X_inception[i, :, :, :] = inception print('Read image: ' + X_filelist[i]) # shuffle inputs and targets rnd_idx = np.arange(X_inception.shape[0]) np.random.shuffle(rnd_idx) X_train = X_inception[rnd_idx] y_train = y_inception[rnd_idx] return X_train, y_train
def load_image(nb_test=0): X_dirname = '../411a3/train' Y_filename = '../411a3/train.csv' X_filelist = list_pictures(X_dirname) Y_list = np.loadtxt(Y_filename, dtype='str', delimiter=',')[1:] X_train = np.zeros((train_size, image_channel, image_size, image_size)) y_train = Y_list[:, 1].astype('int64').reshape(-1, 1) - 1 for i in range(train_size): img = load_img(X_filelist[i]) x = img_to_array(img) x = np.expand_dims(x, axis=0) X_train[i, :, :, :] = x print('Read image: ' + X_filelist[i]) # shuffle inputs and targets rnd_idx = np.arange(X_train.shape[0]) np.random.shuffle(rnd_idx) X_train = X_train[rnd_idx] y_train = y_train[rnd_idx] if K.image_dim_ordering() == 'tf': X_train = X_train.transpose(0, 2, 3, 1) # print('X_train shape:', X_train.shape) # print('y_train shape:', y_train.shape) return (X_train[nb_test:], y_train[nb_test:]), (X_train[:nb_test], y_train[:nb_test])
def getImage(): X = [] for picture in list_pictures('./eroimages/'): img = img_to_array(load_img(picture, target_size=(128, 128, 3))) X.append(img) npX = np.array(X) return npX
def setUp(self): self.motion_detection_test_dir = path.join(temp_data_dir, 'motion_detection') self.images = list_pictures(self.motion_detection_test_dir) with open(path.join(self.motion_detection_test_dir, 'annotations')) as f: self.annotations = [line.split(' ')[1].strip('\n') for line in f] self.positive_annotation = 'person_visible' self.negative_annotation = 'no_person_visible'
def getImage(): X = [] for picture in list_pictures('./gazo/'): img = img_to_array(load_img(picture, target_size=(96, 96, 3))) X.append(img) if len(X) % 100 == 0: print(len(X)) npX = np.array(X) return npX
def load_mnist(width, height, channels): X = [] for image in list_pictures('./MNIST/0/'): img = img_to_array( load_img(image, grayscale=True, target_size=(28, 28))) X.append(img) X = np.asarray(X) X = (X.astype(np.float32) - 127.5) / 127.5 img_rows = width img_cols = height img_shape = [img_rows, img_cols, channels] return X, img_shape
def load_data(): x_data = [] y_data = [] # appleの画像 for picture in list_pictures('./dataset/apple/'): img = img_to_array(load_img(picture, target_size=img_size)) x_data.append(img) y_data.append(0) # bananaの画像 for picture in list_pictures('./dataset/banana/'): img = img_to_array(load_img(picture, target_size=img_size)) x_data.append(img) y_data.append(1) # orangeの画像 for picture in list_pictures('./dataset/orange/'): img = img_to_array(load_img(picture, target_size=img_size)) x_data.append(img) y_data.append(2) # arrayに変換 x_data = np.asarray(x_data) y_data = np.asarray(y_data) # 画素値を0から1の範囲に変換 x_data = x_data.astype('float32') x_data = x_data / 255.0 # クラスの形式を変換 y_data = np_utils.to_categorical(y_data, category_size) # 学習用データとテストデータの振り分け x_train, x_test, y_train, y_test = train_test_split(x_data, y_data, test_size=0.33, random_state=123) return x_train, x_test, y_train, y_test
def load_dataset(directory, crop_size=320, batch_size=32): """ load data from directory :param directory: jpg files directory :param crop_size: cropped image size :param batch_size: batch size :return: python generator object, a batch training data, img, y_cls_mask_lable, y_regr_cls_mask_label """ jpg_list = list_pictures(directory, 'jpg') generator = img_txtreg_generator(jpg_list, crop_size, scale=1 / 255.0) generator = image_ylabel_generator(generator) generator = group_by_batch(generator, batch_size) return generator
def load_val(): X_dirname = '../411a3/val' X_filelist = image.list_pictures(X_dirname) X_val = np.zeros((970, gist_size)) for i in range(970): im = Image.open(X_filelist[i]) descriptors = leargist.color_gist(im) X_val[i, :] = descriptors print('Load image: ' + X_filelist[i]) return X_val
def train(self): images = list_pictures(self._image_path) num_image = len(images) total_seq = num_image * self._num_seq_per_image steps_per_epoch = total_seq // self._batch_size self._build_generator() image_captioning_model = ImageCaptioningModel( self._max_seq_length, rnn_mode=self._rnn_mode, drop_rate=self._drop_rate, hidden_dim=self._hidden_dim, rnn_state_size=self._rnn_state_size, embedding_size=self._embedding_size, rnn_activation=self._activation, cnn_model=self._cnn_model, optimizer=self._optimizer, initializer=self._initializer, learning_rate=self._lr, mode=self._mode, reg_l1=self._reg_l1, reg_l2=self._reg_l2, num_word=len(self._generator.caption_processor.word_index) + 1, is_trainable=self._is_trainable, metrics=self._metrics, loss=self._loss) image_captioning_model.build_model() model = image_captioning_model.image_captioning_model save_path = self._model_path ckpt_path = self._ckpt_path if ckpt_path and os.path.isfile(ckpt_path): print("Load Check Point") model.load_weights(ckpt_path) self._image_captioning_model = model model.fit_generator(generator=self._generator, steps_per_epoch=steps_per_epoch, epochs=self._epoch, callbacks=callback(ckpt_path, './logs/')) model.save(save_path)
def generate_batches(batchq, imdir, num_batches, batch_size, image_size): image_paths = list_pictures(imdir) if not image_paths: print("Error: no images found in {}".format(imdir)) sys.exit(1) for _ in range(num_batches): batch_image_paths = sample(image_paths, batch_size) batch = np.vstack([ load_and_preprocess_img(image_path, image_size, center_crop=True) for image_path in batch_image_paths ]) batchq.put(batch)
def save_images(self, image_dir): image_files = list_pictures(image_dir) print("Preprocessing images...\n") pbar = tqdm(total=len(image_files)) h5f = h5py.File('../tmp/img_array.h5', 'w') img_cache = [] for image_file in image_files: pbar.update() array = image_processor.process_image(image_file) img_cache.append((image_file.split('/')[-1], array)) h5f.create_dataset('img_data', data=img_cache) h5f.close() print("\nImages preprocessed.")
def load_train(): X_dirname = '../411a3/train' Y_filename = '../411a3/train.csv' X_filelist = image.list_pictures(X_dirname) Y_list = np.loadtxt(Y_filename, dtype='str', delimiter=',')[1:] X_train = np.zeros((7000, gist_size)) y_train = Y_list[:, 1].astype('int64').reshape(-1, 1) - 1 for i in range(7000): im = Image.open(X_filelist[i]) descriptors = leargist.color_gist(im) X_train[i, :] = descriptors print('Load image: ' + X_filelist[i]) return X_train, y_train
def generate_image(source_directory_path, generate_directory_path, target_size, count_per_image): if not os.path.exists(generate_directory_path): os.mkdir(generate_directory_path) for picture in list_pictures(source_directory_path): img = load_img(picture,target_size=target_size) x = img_to_array(img) x = np.expand_dims(x, axis=0) generator = keras.preprocessing.image.ImageDataGenerator( rescale= 1.0 / 255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True) g = generator.flow(x, batch_size=1, save_to_dir=generate_directory_path, save_prefix='img', save_format='bmp') for i in range(count_per_image): g.next()
def extract_inception_test(): model = InceptionV3(weights='imagenet', include_top=False) print(model.summary()) X_dirname = '../../411a3/test' X_filelist = image.list_pictures(X_dirname) X_inception_test = np.zeros((test_size, 2048, 8, 8)) for i in range(test_size): img = image.load_img(X_filelist[i], target_size=target_size) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) inception = model.predict(x) X_inception_test[i, :, :, :] = inception print('Read image: ' + X_filelist[i]) return X_inception_test
def make_generator(filepath, labeldata, batch_size, img_size, test_size): """ 画像を読み込むジェネレータを作成します """ # データ一覧の取得 import sys from keras.preprocessing.image import list_pictures from progressbar import ProgressBar from pathlib import Path # 全画像枚数 num_pics = 0 list_pics = [] list_labels = [] print('count pictures.', file=sys.stderr) prog = ProgressBar(0, len(labeldata)) for index, label in enumerate(labeldata): path = Path(filepath).joinpath(label) pics = list_pictures(path) for p in pics: list_pics.append(p) list_labels.append(index) num_pics += len(pics) prog.update(index) prog.finish() print('{} pictures.'.format(num_pics), file=sys.stderr) # データジェネレータの作成 split = int(num_pics * test_size) train_gen = ImageGenerator(data_paths=list_pics[split:], data_classes=list_labels[split:], batch_size=batch_size, width=img_size, height=img_size, num_of_class=len(labeldata)) val_gen = ImageGenerator(data_paths=list_pics[:split], data_classes=list_labels[:split], batch_size=batch_size, width=img_size, height=img_size, num_of_class=len(labeldata)) return (train_gen, val_gen)
def extract_vgg16_val(): model = VGG16(weights='imagenet', include_top=False) print(model.summary()) X_dirname = '../../411a3/val' X_filelist = image.list_pictures(X_dirname) X_vgg_val = np.zeros((val_size, 512, 7, 7)) for i in range(val_size): img = image.load_img(X_filelist[i], target_size=target_size) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) vgg16 = model.predict(x) X_vgg_val[i, :, :, :] = vgg16 print('Read image: ' + X_filelist[i]) return X_vgg_val
def count_pictures(labeldata, datapath): """ datapathで与えられたディレクトリ内に存在するlabeldataで指定されたディレクトリ以下の画像の枚数を取得します """ from keras.preprocessing.image import list_pictures import sys from pathlib import Path from progressbar import ProgressBar print('count pictures.', file=sys.stderr) result = 0 prog = ProgressBar(0, len(labeldata)) for index, label in enumerate(labeldata): path = Path(datapath).joinpath(label) pics = list_pictures(path) result += len(pics) prog.update(index + 1) prog.finish() print('{} pictures.'.format(result), file=sys.stderr) return result
def load_aug_image_train(): X_file_base = '../411a3/data_classify/train/' X_train = np.empty((0, gist_size)) y_train = np.empty((0, 1)) for i_class in range(nb_classes): X_file_part = X_file_base + str(i_class) filelist = list_pictures(X_file_part) nb_part = len(filelist) X_part = np.zeros((nb_part, gist_size)) for i in range(nb_part): im = Image.open(filelist[i]) descriptors = leargist.color_gist(im) X_part[i, :] = descriptors print('Load image: ' + filelist[i]) X_train = np.concatenate((X_train, X_part), axis=0) y_train = np.concatenate((y_train, np.ones((nb_part, 1)) * i_class), axis=0) print('X_train shape:', X_train.shape) print('y_train shape:', y_train.shape) return X_train, y_train
def load_val_image(): X_dirname = '../411a3/val' X_filelist = image.list_pictures(X_dirname) val_samples = len(X_filelist) X_val = np.zeros((val_samples, 3, image_load_size, image_load_size)) for i in range(val_samples): img = image.load_img(X_filelist[i], target_size=(image_load_size, image_load_size)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) X_val[i, :, :, :] = x print('Predict image: ' + X_filelist[i]) if K.image_dim_ordering() == 'tf': X_val = X_val.transpose(0, 2, 3, 1) # print('X_val shape:', X_val.shape) return X_val
def get_data_list(data_list, target_size, category_size): X = [] y = [] for item in data_list: for picture in list_pictures(item['directory_path']): img = img_to_array(load_img(picture, target_size=target_size)) X.append(img) y.append(item['correct_value']) # arrayに変換 X = np.asarray(X) y = np.asarray(y) # 画素値を0から1の範囲に変換 X = X.astype('float32') X = X / 255.0 # クラスの形式を変換 y = np_utils.to_categorical(y, category_size) return (X, y)
def make_dataset_reaction(out_x, out_y, labeldata, datapath, size): """ datapathで指定されたディレクトリ内のllabeldataで指定されたディレクトリ以下の画像ファイルをsize*sizeにリサイズしout_x・out_yに格納します また、読み込みに失敗した画像パスのリストを返します """ from keras.preprocessing.image import img_to_array, list_pictures, load_img import sys import numpy as np from pathlib import Path from progressbar import ProgressBar IMG = np.empty((1, size, size, 3), dtype='int8') POSITION = 0 ERROR = [] for index, label in enumerate(labeldata): path = Path(datapath).joinpath(label) pics = list_pictures(path) prog = ProgressBar(0, len(pics)) print('[{}/{}] load {} {} pictures.'.format(index + 1, len(labeldata), path, len(pics)), file=sys.stderr) count = 0 for picture in pics: try: IMG[0] = img_to_array( load_img(picture, target_size=(size, size))) out_x[POSITION + count] = IMG prog.update(count + 1) count += 1 except Exception as identifier: print(picture, identifier) pics.remove(picture) ERROR.append(picture) out_y[POSITION:POSITION + len(pics)] = np.full(len(pics), index, dtype=int) POSITION += len(pics) prog.finish() return ERROR