def _x_aug(self, X): if self.aug_time == 0: X = [preprocess_input(x) for x in X] yield np.array(X) else: for _ in range(self.aug_time): X = self.seq.augment_images(X) X = [preprocess_input(x) for x in X] yield np.array(X)
def predict_breast_cancer(image): path = str(os.getcwd()) + "/Breast_Cancer/" image = cv2.imread(str("/home/ubuntu/ml_apis/images/") + str(image)) image = cv2.resize(image, (96, 96)) with Image(filename=image) as img: img.format = 'tif' img.save(filename=path + 'temp.tif') test_files = glob(path + '*.tif') model = get_model_classif_nasnet() batch_size = 32 h5_path = path + "model.h5" model.load_weights(h5_path) preds = [] ids = [] for batch in chunker(test_files, batch_size): X = [preprocess_input(cv2.imread(x)) for x in batch] ids_batch = [get_id_from_file_path(x) for x in batch] X = np.array(X) preds_batch = ( (model.predict(X).ravel() * model.predict(X[:, ::-1, :, :]).ravel() * model.predict(X[:, ::-1, ::-1, :]).ravel() * model.predict(X[:, :, ::-1, :]).ravel())**0.25).tolist() preds += preds_batch ids += ids_batch os.remove(path + "temp.tif") if preds[0] >= 0.7: return True else: return False
def model_train_eval(model, X, y, e): X = [preprocess_input(x) for x in X] X = np.array(X) hr_preds = model.predict(X) hr_preds = np.exp(hr_preds) ci = concordance_index(y, -hr_preds, e) return ci
def extract_batch(self, image_path_list, cnn_model_type='InceptionV3'): if cnn_model_type== 'InceptionV3': target_size = (299, 299,3) # feature_size = 2048 elif cnn_model_type== 'nasnet': target_size = (331, 331,3) # feature_size = 4032 batch_size = len(image_path_list) X = np.zeros((batch_size,) + target_size ) for img_idx, image_path in enumerate(image_path_list): img = image.load_img(image_path, target_size=target_size[0:2]) array = image.img_to_array(img) X[img_idx] = array # x = np.expand_dims(x, axis=0) if cnn_model_type == 'InceptionV3': X = inception_v3.preprocess_input(X) elif cnn_model_type == 'nasnet': X = nasnet.preprocess_input(X) # Get the prediction. features_batch = self.model.predict(X) return features_batch
def main(): file_name = args["i"] sample_x, sample_y = loadTrainSeq(file_name) model = get_classification_model(train_length) h5_path = "deepHGT.h5" model.load_weights(h5_path) tmp_y = [] for batch in chunker(sample_x, batch_size): batch.sort() X = sample_x[batch] X = [x[:train_length] for x in X] X = [preprocess_input(x) for x in X] y_pred_keras = model.predict(np.array(X)).ravel() tmp_y.append(y_pred_keras) pred_y = [] fo = open('prediction.txt', 'w') for batch in tmp_y: for i in range(batch.shape[0]): fo.write(str(batch[i]) + '\n') pred_y.append(batch[i]) fo.close() fpr, tpr, thresholds = metrics.roc_curve(sample_y, np.array(pred_y)) auc = round(metrics.auc(fpr, tpr), 3) #precision, recall, _ = precision_recall_curve(sample_y, np.array(pred_y)) ap = round(average_precision_score(sample_y, np.array(pred_y)), 3) fo = open('auc_ap.txt', 'w') fo.write("AUC:" + str(auc) + '\n') fo.write("AP:" + str(ap) + '\n') print("AUC:" + str(auc) + '\n') print("AP:" + str(ap) + '\n') fo.close()
def get_feature_by_net(self, net_name, img_file): img = image.load_img(img_file, target_size=model_size[net_name]) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) features = models[net_name].predict(x) return features
def model_predict(img_path, model): img = image.load_img(img_path, target_size=(331, 331)) x = image.img_to_array(img) # Preprocessing the image x = np.expand_dims(x, axis=0) # x = np.true_divide(x, 255) preds = model.predict(preprocess_input(x)) return preds
def judge_area(dir_p, dst='c:/', logger=None): os.makedirs(dst, exist_ok=True) if logger is None: logger = gen_logger('judge_area') model = model_nas_clf() model.compile(optimizer=Adam(0.0001), loss=binary_crossentropy, metrics=['acc']) for case_name in os.listdir(dir_p): case_dir = os.path.join(dir_p, case_name) record = {} if not os.path.isdir(case_dir): continue try: for batch in chunk(case_dir, 32): X = [preprocess_input(cv2.imread(x)) for x in batch] X = np.array(X) preds_batch = predicting(model, X) record.update({key:value for key, value in zip(batch, preds_batch)}) with open(os.path.join(dst, f'{case_name}.pkl'), 'wb') as temp_pkl: pickle.dump(record, temp_pkl, pickle.HIGHEST_PROTOCOL) logger.info(f'{case_name} is completed') except: logger.exception(f'{case_name} encounter mistakes')
def predict(self, uploaded_image: TemporaryUploadedFile) -> (List, Image): """ Read image and predict category """ # convert the image pixels to a numpy array image = img_to_array(Image.open(uploaded_image)) # resize (crop) to vgg16 size (331, 331, 3) image = smart_resize(image, (331, 331)) # grab a RGB preview for frontend rgb_preview = Image.fromarray(np.uint8(image)).convert('RGB') # reshape data for the model, add new axis (1, 224, 224, 3) image = np.expand_dims(image, axis=0) # prepare the image for the VGG model (subtracts the mean RGB channels) image = preprocess_input(image) # predict the probability across all output classes what = self.model.predict(image) # convert the probabilities to class labels labels = decode_predictions(what, top=3) # make it readable labels = self.labels_to_percents(labels) return labels, rgb_preview
def preprocess_img(img_path): img_path = img_path img = image.load_img(img_path, target_size=(224, 224)) img = image.img_to_array(img) img = np.expand_dims(img, axis=0) img = preprocess_input(img) return img
def data_gen(x, y, batch_size, aug_flag): while True: for batch in chunker(x, batch_size): batch.sort() X = x[batch] Y = y[batch] X = [x[:train_length] for x in X] if aug_flag is True: X = [random_snp(x) for x in X] X = [preprocess_input(x) for x in X] yield np.array(X), np.array(Y)
def model_predict(img_path, model): img = image.load_img(img_path, target_size=(331, 331)) x = image.img_to_array(img) # Preprocessing the image x = np.expand_dims(x, axis=0) # x = np.true_divide(x, 255) # Be careful how your trained model deals with the input # otherwise, it won't make correct prediction! #x = preprocess_input(x, mode='caffe') preds = model.predict(preprocess_input(x)) return preds
def data_gen(list_files, id_label_map, batch_size, augment=False): seq = get_seq() while True: shuffle(list_files) for batch in chunker(list_files, batch_size): X = [cv2.imread(x) for x in batch] Y = [id_label_map[get_id_from_file_path(x)] for x in batch] if augment: X = seq.augment_images(X) X = [preprocess_input(x) for x in X] yield np.array(X), np.array(Y)
def preprocess(image): """Load and preprocess image.""" # Create the array of the right shape to feed into the keras model data = [] size = (96, 96) image = ImageOps.fit(image, size, Image.ANTIALIAS) image = np.asarray(image) x = preprocess_input(image) data.append(x) data = np.array(data) return data
def model_val_eval(model, X_val, y, e): hr_preds = [] for x_case in X_val: x_case = [preprocess_input(x) for x in x_case] x_case = np.array(x_case) hr_pred = model.predict(x_case) hr_pred = sorted(hr_pred)[-2] # only the second most serious area hr_preds.append(hr_pred) hr_preds = np.exp(hr_preds) ci = concordance_index(y, -hr_preds, e) return ci
def get_assessment_score(self, img_array): with self.graph.as_default(): with self.session.as_default(): target_size = (224, 224) img = NeuralImageAssessment.resize_image(img_array, target_size) x = img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) scores = self.model.predict(x, batch_size=1, verbose=0)[0] mean = NeuralImageAssessment.mean_score(scores) return mean
def load_patches(patch_list, path): batch_patches = [] for file in patch_list: patch = path + file + ".tif" patch = cv2.imread(patch, cv2.IMREAD_COLOR) cv2.imshow("a", patch) patch = reshape_patch(patch, np.random.randint(1, 10)) cv2.imshow("b", patch) cv2.waitKey(0) patch = preprocess_input(patch) batch_patches.append(patch) return batch_patches
def preprocessing_image(image, target): # Make sure the image mode is RGB: if image.mode != "RGB": image = image.convert("RGB") # Resize the input image: image = image.resize(target) # Convert PIL format to numpy array: image = img_to_array(image) # Convert the image/images into batch format: image = np.expand_dims(image, axis=0) # Pre-process (prepare) the image using the specific architecture: image = nasnet.preprocess_input(image) # Return the image: return image
def __getitem__(self, index): 'Generate one batch of data' # selects indices of data for next batch indexes = self.indexes[index * self.batch_size : (index + 1) * self.batch_size] # select data and load images labels = np.array([self.labels[k] for k in indexes]) images = [cv2.imread(self.images_paths[k]) for k in indexes] # preprocess and augment data if self.augment == True: images = self.augmentor(images) images = np.array([preprocess_input(img) for img in images]) return images, labels
def predict(image_response): image_response = base64.b64decode(image_response) t = time.time() img = image.load_img(BytesIO(image_response), target_size=(224, 224)) img = image.img_to_array(img) img = np.expand_dims(img, axis=0) img = preprocess_input(img) with graph.as_default(): preds = model.predict(img) print(time.time() - t) # decode the results into a list of tuples (class, description, probability) # (one such list for each sample in the batch) print(decode_predictions(preds)) return decode_predictions(preds,top=3)[0]
def get_windows(padded_image, windows_x, windows_y, w_size, height, width): # This function performs a sliding window through the padded image and returns a list of all windows X = np.ndarray((windows_x * windows_y, 96, 96, 3)) for x in range(windows_x): for y in range(windows_y): #x is start of window, x+3 is end (extra mirror window is counted), because window is 3*window size. same for y start_x = min(x * w_size, height - 96) end_x = min((x + 3) * w_size, height) start_y = min(y * w_size, width - 96) end_y = min((y + 3) * w_size, width) cur_im = padded_image[start_x:end_x, start_y:end_y] X[x * windows_y + y, :, :, :] = preprocess_input(cur_im) return X
def predict(model, validation_dir): sample_counts = [0, 0, 0, 0, 0, 0, 0] hit_counts = [0, 0, 0, 0, 0, 0, 0] truths = [] predictions = [] prediction_arrays = [] index = 0 for r, dirs, files in os.walk(validation_dir): for dr in dirs: print(index, dr) files_in_dir = glob.glob(os.path.join(r, dr + "/*")) for fid in files_in_dir: sample_counts[index] += 1 print(fid) img = image.load_img(path=fid, target_size=(img_width, img_height)) img = image.img_to_array(img).astype('float32') img = preprocess_input(img) img -= np.mean(img, keepdims=True) img /= (np.std(img, keepdims=True) + K.epsilon()) img = np.expand_dims(img, axis=0) prediction_array = model.predict(img)[0] prediction_arrays.append(prediction_array) pred = np.argmax(prediction_array) if index == pred: hit_counts[index] += 1 print('Accuracy:', sample_counts, hit_counts, np.sum(hit_counts) / np.sum(sample_counts)) truths.append(index) predictions.append(pred) # cnt += len(glob.glob(os.path.join(r, dr + "/*"))) index = index + 1 return sample_counts, hit_counts, truths, predictions, prediction_arrays
def read_dir(dir_p, sel_num) -> list: pool = os.listdir(dir_p) pool_size = len(pool) cur, end = 0, sel_num fns, ori_carrier, pro_carrier = [], [], [] while end < pool_size: while cur < end: fn = pool[cur] ori_img = cv2.imread(os.path.join(dir_p, fn)) fns.append(fn) ori_carrier.append(ori_img) pro_carrier.append(preprocess_input(ori_img)) cur += 1 yield fns, ori_carrier, pro_carrier fns.clear() ori_carrier.clear() pro_carrier.clear() end += sel_num
def classify_random_images(self): imageno = np.random.random_integers( low=0, high=self.validation_generator.samples) name = self.validation_generator.filepaths[imageno] print(name) plt.imshow(mpimg.imread(name)) img = Image.open(self.validation_generator.filepaths[imageno]).resize( (self.img_width, self.img_height)) probabilities = self.model.predict( preprocess_input(np.expand_dims(img, axis=0))) breed_list = tuple( zip(self.validation_generator.class_indices.values(), self.validation_generator.class_indices.keys())) for i in probabilities[0].argsort()[-3:][::-1]: print(probabilities[0][i], " : ", breed_list[i])
def extract_features(directory, ids, model): if int(model) == 1: print("1") # load ResNet50 model model = ResNet50() input_size = 224 else: print("2") # load NASNetLarge model model = NASNetLarge(input_shape=(331, 331, 3), include_top=True, weights='imagenet', input_tensor=None, pooling=None) input_size = 331 # pops the last layer to get the features model.layers.pop() model = Model(inputs=model.inputs, outputs=model.layers[-2].output) model.summary() print(len(model.layers)) # model characteristics plot_model(model, to_file='model.png') imgs = load_list(ids) print('Dataset: %d' % len(imgs)) N = len(imgs) print(N) results = [] i = 0 batch_size = 1 # this can be 8 for a GTX 1080 Ti and 32G of RAM while i < N: if i % 1024 == 0: print('{} from {} images.'.format(i, N)) batch = imgs[i:i + batch_size] i += batch_size images = [ load_img(os.path.join(directory, img + ".jpg"), target_size=(input_size, input_size)) for img in batch ] images = [preprocess_input(img_to_array(img)) for img in images] images = np.stack(images) r = model.predict(images) for ind in range(batch_size): results.append(r[ind]) return results
def _model_eval(self, X_val, y, e): hr_preds = [] if self.gene: if len(X_val) != 152: gene_array = self.train_gene.values else: gene_array = self.test_gene.values assert len(gene_array) == len(X_val), 'impossible match' for idx, x_case in enumerate(X_val): x_case = [preprocess_input(x) for x in x_case] x_case = np.array(x_case) if self.gene: x_case = [x_case, np.array([gene_array[idx]]*len(x_case))] hr_pred = self.model.predict(x_case) hr_pred = sorted(hr_pred)[-2] # only the second most serious area, i.e. the second shorest time hr_preds.append(hr_pred) hr_preds = np.exp(hr_preds) ci = concordance_index(y,-hr_preds,e) return ci
def preprocess(img_file, target_size, transform=True): img = Image.open(img_file) w, h = img.size if transform: if w > h: ratio = (min(target_size) * 1.2) / float(h) else: ratio = (min(target_size) * 1.2) / float(w) output = img.resize((int(w * ratio), int(h * ratio))) output = output.convert("RGB") output = image.img_to_array(output) # Random rotation output = image.random_rotation(output, 30, row_axis=0, col_axis=1, channel_axis=2, fill_mode='nearest') # Random crop left = np.random.randint(0, output.shape[1] - target_size[0] + 1) upper = np.random.randint(0, output.shape[0] - target_size[1] + 1) output = output[upper:upper + target_size[1], left:left + target_size[0]] # Random horizontal flip if np.random.rand() < 0.5: output = output[:, ::-1, :] else: if w > h: left = (w - h) // 2 output = img.crop((left, 0, left + h, h)) else: upper = (h - w) // 2 output = img.crop((0, upper, w, upper + w)) output = output.resize(target_size) output = output.convert("RGB") output = image.img_to_array(output) output = preprocess_input(output) return output
def extract(self, image_path, cnn_model_type='nasnet'): if cnn_model_type== 'InceptionV3': target_size = (299, 299) elif cnn_model_type== 'nasnet': target_size = (331, 331) img = image.load_img(image_path, target_size=target_size) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) if cnn_model_type == 'InceptionV3': x = inception_v3.preprocess_input(x) elif cnn_model_type == 'nasnet': x = nasnet.preprocess_input(x) # Get the prediction. features = self.model.predict(x) features = features[0] return features
def extract_feature_one_image(img_path, intermediate_layer_model, feature_extraction_method, input_img): img = image.load_img(img_path, target_size=(input_img, input_img)) img_data = image.img_to_array(img) img_data = np.expand_dims(img_data, axis=0) if (feature_extraction_method == 'pretrained_lenet'): img_data = img_data / 255 elif (feature_extraction_method == 'pretrained_vgg16'): img_data = vgg16.preprocess_input(img_data) elif (feature_extraction_method == 'pretrained_vgg19'): img_data = vgg19.preprocess_input(img_data) elif (feature_extraction_method == 'pretrained_xception'): img_data = xception.preprocess_input(img_data) elif (feature_extraction_method == 'pretrained_resnet'): img_data = resnet.preprocess_input(img_data) elif (feature_extraction_method == 'pretrained_inception_resnet'): img_data = inception_resnet.preprocess_input(img_data) elif (feature_extraction_method == 'pretrained_nasnet'): img_data = nasnet.preprocess_input(img_data) features = intermediate_layer_model.predict(img_data) features = features.reshape((-1)) return features
def generate_features(my_model, my_model_name, path_to_descriptions, path_to_data, output_file, output_features_dir): try: os.mkdir(output_features_dir) except OSError: a = 0 a = a + 1 else: a = 0 a = a + 1 csv_ok = pd.read_csv(path_to_descriptions) x = my_model.output x = GlobalAveragePooling2D()(x) model = Model(inputs=my_model.input, outputs=x) for a in range(csv_ok.shape[0]): if a % 100 == 0: print(my_model_name + " " + str(a) + " of " + str(csv_ok.shape[0])) my_file = str(csv_ok.iloc[a, 0]) img_path = path_to_data + my_file + '.png' img = image.load_img(img_path, target_size=(60, 60)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) features = model.predict(x) file_object = open(output_file, 'a') features = features[0] for b in range(features.shape[0]): if b > 0: file_object.write(",") file_object.write(str(features[b])) file_object.write('\n') file_object.close()