def extract_features(path, model_type): if model_type == 'inceptionv3': from keras.applications.inception_v3 import preprocess_input target_size = (299, 299) elif model_type == 'vgg16': from keras.applications.vgg16 import preprocess_input target_size = (224, 224) # Get CNN Model from model.py model = CNNModel(model_type) features = dict() # Extract features from each photo for name in tqdm(os.listdir(path)): # Loading and resizing image filename = path + name image = load_img(filename, target_size=target_size) # 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 CNN Model model image = preprocess_input(image) # Pass image into model to get encoded features feature = model.predict(image, verbose=0) # Store encoded features for the image image_id = name.split('.')[0] features[image_id] = feature return features
def predict_test_set(model_path, batch_size, pkl_data_dir, target_dir, num_gpus=1): dataset = DataSet(data_dir=config['data']['data_dir'], test=True, pkl_file_dir=pkl_data_dir) cnn_model = CNNModel(model_path, False, gpu_nums=num_gpus) test_data_gen = dataset.get_test_data_gen(batch_size) pred_list = [] label_list = [] fp_dict = {'file_path': [], 'pkl_idx': [], 'p': []} fn_dict = {'file_path': [], 'pkl_idx': [], 'p': []} for batch_data, batch_label, batch_info in test_data_gen: preds = cnn_model.predict(batch_data['inputs'], batch_size) idx = 0 for pred in preds: l = batch_label['out_class'][idx][1] p = pred[1] label_list.append(l) pred_list.append(p) if p >= 0.5 and l != 1: fp_dict['file_path'].append(batch_info['file_path'][idx]) fp_dict['pkl_idx'].append(batch_info['pkl_idx'][idx]) fp_dict['p'].append(p) if p < 0.5 and l != 0: fn_dict['file_path'].append(batch_info['file_path'][idx]) fn_dict['pkl_idx'].append(batch_info['pkl_idx'][idx]) fn_dict['p'].append(p) idx += 1 auc = cal_roc_and_auc(np.array(pred_list), np.array(label_list)) fn_df = pd.DataFrame(fn_dict) fp_df = pd.DataFrame(fp_dict) fn_df.to_csv(os.path.join(target_dir, 'fn_result.csv'), index=False) fp_df.to_csv(os.path.join(target_dir, 'fp_result.csv'), index=False) draw_roc(np.array(pred_list), np.array(label_list), target_dir) print('auc:%f' % auc)
class DarkOCR: def __init__(self): print('DarkOCR initialization...') self.data = ImageData() # reading data self.data.read_origin_data(pickle_path) self.model = CNNModel(image_dim, image_dim, classes_count) self.models_fold = [ CNNModel(image_dim, image_dim, classes_count) for i in range(fold_count) ] print('Complete') def show_origin_data(self, char='p'): # visualization self.data.show_origin_all_chars() self.data.show_origin_chars_data() self.data.show_origin_chars_data(char) def show_origin_data_statistics(self): self.data.show_origin_data_histogram() self.data.print_origin_labels_count() def save_data_set_to_png(self, path): self.data.save_data_set_to_png(path) def augment_folder(self, path, char_i=None, generated_count=50): pixels_mean = None if char_i is not None: path += '/' + str(char_i) pixels_mean_per_class = self.data.calc_pixels_mean() pixels_mean = pixels_mean_per_class[char_i] augment_folder(path, generated_count=generated_count, pixels_mean=pixels_mean) def fit_from_aug_folder(self, path=png_path): data_set = self.data.read_augmented_data_and_process( in_path=path, classes_count_int=4) self.fit(data_set) def fit_from_aug_pickle(self, aug_pickle_path=augmented_pickle_path, test_fold=4): data_set = self.data.read_pickle(aug_pickle_path) self.fit(data_set, test_fold=test_fold) def fit(self, data_set, test_fold=4): (train_x, train_y), (test_x, test_y) = self.data.from_processed_data_to_training_set( data_set=data_set, test_fold=test_fold, ignore_class=30) self.model.fit(train_x, train_y, test_x, test_y) def load_trained_models_group(self): print('Loading models group...') for fold in range(fold_count): self.models_fold[fold].load_model(fold=fold) print('Done') def predict(self, input_data): prediction = self.model.predict(input_data) return np.argmax(prediction, axis=1) def predict_from_fold(self, input_data, fold=4): prediction = self.models_fold[fold].predict(input_data) return np.argmax(prediction, axis=1) def predict_from_group(self, input_data): # print('Making prediction...') prediction_votes = np.zeros((len(input_data), classes_count)) for fold in range(fold_count): prediction_votes += self.models_fold[fold].predict(input_data) return np.argmax(prediction_votes, axis=1) def predict_image(self, im, decode=False): im = im.convert("L") ia = np.array(im, dtype='d') ia = ia / 255 ia = ia.reshape(-1, image_dim, image_dim, 1) prediction = self.predict_from_group(ia) if decode: prediction = ImageData.decode(prediction[0]) return prediction def evaluate_by_image_folder(self, path): correct_count = 0 examples_count = 0 answers_counter = [0] * classes_count correct_counter = [0] * classes_count for im_path in glob.glob(path + '/*.png'): hash_i = im_path.rfind("#") label = im_path[hash_i + 1] im = Image.open(im_path) prediction = self.predict_image(im, decode=True) if label == prediction: correct_count += 1 correct_counter[ImageData.encode(label)] += 1 else: print("WRONG!: {}, LABEL: {}, PREDICTION: {}".format( im_path, label, prediction)) answers_counter[ImageData.encode(prediction)] += 1 examples_count += 1 accuracy = 100 * correct_count / examples_count print('Results: {:.2f}%'.format(accuracy)) for i in range(len(answers_counter)): print('{} ({}). correct: {}, answers count: {}'.format( i, ImageData.decode(i), correct_counter[i], answers_counter[i])) return accuracy