def build_model(classes = 2): inputs = Input(shape = (IMAGE_SIZE, IMAGE_SIZE, 3)) x = preprocess_input(inputs) x = NASNetMobile(weights=None, classes=classes)(x) model = Model(inputs=inputs, outputs=x) model.compile(loss='categorical_crossentropy', metrics=['accuracy']) return model
def model_evaluate(self, img_path): self.model = load_model(self.MODEL_DIR, compile=False) process_image = preprocess_input(cv2.imread(img_path)) prediction = self.model.predict(np.expand_dims(process_image, axis=0)) self.Line_Dat_Edit.neg_sample_ledit.setText( str(round(np.around(prediction, 2)[0][0] * 100, 2)) + '%') self.Line_Dat_Edit.pos_sample_ledit.setText( str(round(np.around(1 - prediction, 2)[0][0] * 100, 2)) + '%')
def load_image(path, preprocess=True): """Load and preprocess image.""" x = image.load_img(path, target_size=(IMG_HEIGHT, IMG_WIDTH)) if preprocess: x = image.img_to_array(x) x = np.expand_dims(x, axis=0) x = preprocess_input(x) return x
def NASNetMobile(image_bytes): image_batch = np.expand_dims(image_bytes, axis=0) processed_imgs = nasnet.preprocess_input(image_batch) nasnet_features = nasnet_extractor.predict(processed_imgs) flattened_features = nasnet_features.flatten() # normalized_features = flattened_features / norm(flattened_features) return flattened_features
def predict(self, image): img = preprocess_input(image) preds = decode_predictions(self.model.predict(img), 10)[0] results = {} for pred in preds: results.update({pred[1]: f"{pred[2] * 100:.2f}%"}) return results
def data_gen(list_files, batch_size): while True: shuffle(list_files) for batch in chunker(list_files, batch_size): X = [read_image(x) for x in batch] Y = [get_class_from_file_path(x) for x in batch] X = [preprocess_input(x) for x in X] yield np.array(X), np.array(Y)
def getdata(x, y, batch=100): idx = np.random.randint(0, x.shape[0], size=batch) orix, batch_x, batch_y = [], [], y[idx] for p in x[idx]: img = load_img(p, target_size=(224, 224)) img_np = np.array(img) orix.append(img_np) img_pre = nasnet.preprocess_input(img_np) # transfer learning 用他的預處理方式 batch_x.append(img_pre) return (np.array(orix), np.array(batch_x), np.array(batch_y))
def nasnet_feature_extractor(image_bytes): preprocess_image = nn_image_preprocessing(image_bytes) processed_imgs = nasnet.preprocess_input(preprocess_image) # predicting the image inception_resnet_v2_features =nasNet.predict(processed_imgs) # making features flatten and reshape flattened_features = inception_resnet_v2_features.flatten() flattened_features = np.array(flattened_features) flattened_features = flattened_features.reshape(1, -1) return flattened_features
def load_images(image_list, preprocess=True, target_size=(224, 224)): images = [] for i in image_list: c_img = np.expand_dims(image.img_to_array( image.load_img(i, target_size=target_size)), axis=0) images.append(c_img) images = np.vstack(images) if preprocess: images = preprocess_input(images) return images
def nasnet_feature_extractor(preprocess_image): # preprocessing for image input the vgg_server # preprocess_image = nn_image_preprocessing(image_bytes) processed_imgs = nasnet.preprocess_input(preprocess_image) # predicting the image inception_resnet_v2_features = nasNet.predict(processed_imgs) # making features flatten and reshape flattened_features = inception_resnet_v2_features.flatten() flattened_features = np.array(flattened_features) flattened_features = flattened_features.reshape(1, -1) return sparse.csr_matrix(flattened_features)
def extract_features(img): """Extract features from input image and return the same""" print(f'>>> Entered feature extractor...', end='') start = time.time() img = image.load_img(img, target_size=(331, 331)) # img = image.load_img(img, target_size=(299, 299)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) features = nas_model.predict(x) print(f'Feature extraction took: {time.time()-start:.2}. Exiting. ') return features.flatten()
def evaluate(self, images): dbg("Evaluating the model on {} entries".format(len(images))) results = {} for img in images: try: image = cv2.imread(img) image = cv2.resize(image, (128, 128), 3) except: print(f"this image: {img} is no valid, ommiting..") continue image = preprocess_input(image) image = np.expand_dims(image, axis=0) results[img] = self.model.predict(image) return results
def get_model_image(self): read_image = cv2.imread(self.raw_file) read_image = cv2.cvtColor(read_image, cv2.COLOR_BGR2RGB) process_image = preprocess_input(read_image) explainer = lime_image.LimeImageExplainer() explanation = explainer.explain_instance( np.array(process_image), self.model.predict, top_labels=10, hide_color=0, num_samples=10, segmentation_fn=SegmentationAlgorithm('felzenszwalb')) temp, mask = explanation.get_image_and_mask(explanation.top_labels[0], positive_only=False, num_features=10, hide_rest=True) model_image = mark_boundaries(temp / 2 + 0.5, mask) self.getCanvas(model_image)
def evaluate(self, folder_path): images = glob(folder_path + "/*.tif") print(images) dbg("Evaluating the model on {} entries".format(len(images))) results = {} i = 0 for img in images: image = preprocess_input(cv2.imread(img)) results[img] = self.model.predict(np.expand_dims(image, axis=0)) # image = cv2.imread(img) # image = cv2.resize(image, (96, 96, 3)) # image = preprocess_input(cv2.imread(img)) # results[img] = self.model.predict(image) i += 1 if i > 100: break return results
def prepare_dataset(self): dbg("Preparing dataset") with tf.python_io.TFRecordWriter(self.tf_record_file_name) as writer: for i, entry in enumerate( tqdm(self.images, total=self.dataset_size)): # load and preprocess image_data = cv2.imread(entry) image_data = cv2.resize(image_data, (128, 128), 3) image_data = preprocess_input(image_data) # cut path and extention to get id image_id = os.path.basename(entry) #.replace(".jpg", "") try: label = self.labels[image_id] except KeyError: print(f'{image_id} does not exisit') continue data = { "image_data": tf.train.Feature(bytes_list=tf.train.BytesList( value=[image_data.tostring()])), "label": tf.train.Feature(int64_list=tf.train.Int64List( value=label)), } # Cast to TensorFlow Features. feature = tf.train.Features(feature=data) # Cast as a TensorFlow Example. example = tf.train.Example(features=feature) # Serialize the data. serialized = example.SerializeToString() # Write the serialized data to the TFRecords file. writer.write(serialized) # if we reach desired dataset size, break preparation if i == self.dataset_size: break dbg(f"Dataset file ({self.tf_record_file_name}) ready")
height = len(false_img) // width + 1 for i in range(len(false_img)): plt.subplot(height, width, i + 1) title = "[O]:{}\n[P]:{}".format(trans[false_label[i]], trans[false_pre[i]]) plt.title(title) plt.axis("off") plt.imshow(false_img[i]) # pip install pillow import PIL import requests url = "https://encrypted-tbn0.gstatic.com/images?q=tbn%3AANd9GcSOE_6cCV1OCLhwBAC5eo8MWtUKl7ye0YMb9A&usqp=CAU" h = { "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36" } response = requests.get(url, stream=True, verify=False, headers=h) img = PIL.Image.open(response.raw).resize((224, 224)) img_np = np.array(img) test = nasnet.preprocess_input(img_np.reshape(1, 224, 224, 3)) probs = model.predict(test)[0] for i, p in enumerate(probs): print(trans[i], "的機率是:", round(p, 3)) ans = model.predict(test)[0] if ans[0] >= ans[1]: ans = 0 else: ans = 1 print("應該是:", trans[ans]) plt.imshow(img_np)
# grab the list of images in our dataset directory, then initialize # the list of data (i.e., images) and class images print("[INFO] loading images...") imagePaths = list(paths.list_images(args["dataset"])) data = [] labels = [] # loop over the image paths for imagePath in imagePaths: # extract the class label from the filename label = imagePath.split(os.path.sep)[-2] # load the input image (224x224) and preprocess it image = load_img(imagePath, target_size=(224, 224)) image = img_to_array(image) image = preprocess_input(image) #Convert to the range [-1, 1] # update the data and labels lists, respectively data.append(image) labels.append(label) # convert the data and labels to NumPy arrays data = np.array(data, dtype="float32") labels = np.array(labels) # perform one-hot encoding on the labels lb = LabelBinarizer() labels = lb.fit_transform(labels) labels = to_categorical(labels) # partition the data into training and testing splits using 75% of
input_tensor_name = input_names[0] + ":0" output_tensor_name = output_names[0] + ":0" #print("input_tensor_name: {}\noutput_tensor_name: {}".format(input_tensor_name, output_tensor_name)) output_tensor = tf_sess.graph.get_tensor_by_name(output_tensor_name) # In[9]: # Optional image to test model prediction. img_path = '../../data/elephant.jpg' img = image.load_img(img_path, target_size=image_size[:2]) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) feed_dict = {input_tensor_name: x} #preds = tf_sess.run(output_tensor, feed_dict) # 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=3)[0]) # In[10]: import time # in order to get rid of some unreletable values, cuz the first ones are always slow for i in range(0, 5): one_prediction = tf_sess.run(output_tensor, feed_dict)
# OneHotEncoding from sklearn.preprocessing import OneHotEncoder y_train = y_train.reshape(-1, 1) y_test = y_test.reshape(-1, 1) ohencoder = OneHotEncoder() ohencoder.fit(y_train) y_train = ohencoder.transform(y_train).toarray() y_test = ohencoder.transform(y_test).toarray() vgg19 = NASNetMobile(weights='imagenet', include_top=False, input_shape=(32, 32, 3)) vgg19.trainable = True x_train = preprocess_input(x_train) x_test = preprocess_input(x_test) x_train = x_train.astype('float32') / 255. # 전처리 x_test = x_test.astype('float32') / 255. # 전처리 model = Sequential() model.add(vgg19) model.add(Flatten()) model.add(Dense(128)) model.add(Dense(64)) model.add(Dense(10, activation='softmax')) model.summary() from tensorflow.keras.optimizers import Adam
def single_evaluate(self, img_path): input_data = preprocess_input(cv2.imread(img_path)) return { img_path: self.model.predict(np.expand_dims(input_data, axis=0)) }