def predict(self, frame): # expand 3D RGB frame into 4D batch sample = np.expand_dims(frame, axis=0) processed_sample = preprocess_input(sample.astype(np.float32)) features = self.model_base.predict(processed_sample) decoded_features = decode_predictions(features) return decoded_features
def classify_image(file_url): #Retrieve image frame = cv2.imread(file_url, cv2.IMREAD_COLOR) #Get smallest dimension min_dim = np.min(frame.shape[0:2]) #If width is smallest dimension if frame.shape[1] < frame.shape[0]: width_start = 0 width_end = min_dim height_start = int(np.floor((frame.shape[0] - min_dim) / 2)) height_end = int(np.floor((frame.shape[0] + min_dim) / 2)) else: width_start = int(np.floor((frame.shape[1] - min_dim) / 2)) width_end = int(np.floor((frame.shape[1] + min_dim) / 2)) height_start = 0 height_end = min_dim #Crop into centered square based on smallest dimension # Scale into correct size frame = cv2.resize( frame[height_start:height_end, width_start:width_end, :], (224, 224)) #Classify processed_image = mobilenet_v2.preprocess_input( np.expand_dims(frame, axis=0)) predictions = model.predict(processed_image) labels = mobilenet_v2.decode_predictions(predictions) return labels
def show_camera(): # To flip the image, modify the flip_method parameter (0 and 2 are the most common) print(gstreamer_pipeline(flip_method=0)) cap = cv2.VideoCapture(gstreamer_pipeline(flip_method=0), cv2.CAP_GSTREAMER) if cap.isOpened(): window_handle = cv2.namedWindow('CSI Camera', cv2.WINDOW_AUTOSIZE) # Window while cv2.getWindowProperty('CSI Camera', 0) >= 0: ret_val, img = cap.read() destRGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) pil_im = Image.fromarray(destRGB) img2 = pil_im.resize((224, 224)) x = image.img_to_array(img2) 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) #print('Predicted:', decode_predictions(preds, top=3)[0]) predict = decode_predictions(preds, top=1)[0] predict = predict[0][1:3] #print(predict) cv2.putText(img, str(predict), (10, 700), cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 255, 255), 2, cv2.LINE_AA) cv2.imshow('CSI Camera', img) # This also acts as keyCode = cv2.waitKey(30) & 0xff # Stop the program on the ESC key if keyCode == 27: break cap.release() cv2.destroyAllWindows() else: print('Unable to open camera')
def disp_pred(): pred_dec = decode_predictions(pred) null, pred_output, null = pred_dec[0][0] to_disp = f"This object(s) probably is a(n)\n{pred_output}" label = Label(window, text=to_disp, fg="red", width=25, font=("Century Gothic", 11)) label.place(x=180, y=500)
def getPrediction(filename): image = load_img('static/uploads/' + filename, target_size=(224, 224)) image = img_to_array(image) image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2])) image = preprocess_input(image) all_result = inference_model.predict(image) result = decode_predictions(all_result)[0] result = [(img_class, label, str(round(acc * 100, 4)) + '%') for img_class, label, acc in result] return result
def get_prediction(img_path): img = cv2.imread(img_path) img_resized = cv2.resize(img, (224, 224)) img_preprocessed = preprocess_input(img_resized) img_reshaped = img_preprocessed.reshape((1, 224, 224, 3)) prediction = model.predict(img_reshaped) decoded = decode_predictions(prediction) top_3 = [(cat.capitalize(), round(prob * 100, 2)) for (code, cat, prob) in decoded[0]][:3] return top_3
def _classify_image(self, image_path): print('classifying', 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 = preprocess_input(x) predictions = self.model.predict(x) _, predicted_class, prob = decode_predictions(predictions, top=3)[0][0] if prob >= self.config['classificationThreshold']: self._label_image(image_path, predicted_class) else: self._label_image(image_path, 'unknown')
async def run_predict(myfile): try: img = Image.open(myfile) img = img.convert('RGB') img = img.resize((224, 224), Image.NEAREST) img = image.img_to_array(img) img = np.expand_dims(img, axis=0) preds = model.predict(img) result = tfApps.decode_predictions(preds, top=3)[0] return result except Exception as err: return err
def pred(img): img = image.load_img(img, target_size=(224, 224)) assert img is not None, 'Image not found' #img_array = np.frombuffer(img, dtype=np.uint8) img_array = image.img_to_array(img) img_array = np.expand_dims(img_array, axis=0) predimg = preprocess_input(img_array) # define the mobilenetV2 model model = MobileNetV2() import time t=time.time() # make predictions on test image using mobilenetV2 preds = model.predict(predimg) print(time.time()-t) # convert predictions to readable results print('Predicted:', decode_predictions(preds, top=3)[0]) output = decode_predictions(preds, top=3)[0] fmtans = "" for o in output: text = f"{o[1]}: {o[2]*100:.2f}\n" fmtans += text.replace("_", " ") return fmtans
def predict_classes(img: np.ndarray, classifier: MobileNetV2) -> dict: """Predict classification of an image. Args: img (np.ndarray): Image, preprocessed for MobileNetv2 classifier (MobileNetV2): Instance of classifier. Returns: dict: Predicted classes and their assigned probability. """ predictions = classifier.predict(img) prediction = decode_predictions(predictions) classes = dict([(i[1], float(i[2])) for i in prediction[0]]) return classes
def make_predictions(chosen_model=MobileNetV2, tiles=image_tile_slicer()): """ Spots an Anemoe fish on the picture, given a pretrained chosen_model (e.g. MobileNetV2, ResNet50 or VGG16), Numpy arrays from the 224 by 224 tiles created from the original picture, and an accuracy_threshold (default is 90%) for the prediction. """ model = chosen_model(weights='imagenet', include_top=True) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) tiles = np.array(tiles) predictions = decode_predictions(model.predict(tiles)) return predictions
def update(i): # Capture frame from webcam ret, frame_bgr = cap.read() assert ret frame = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB) min_dim = np.min(frame.shape[0:2]) frame = cv2.resize(frame[0:min_dim, 0:min_dim, :], (224, 224)) vid.set_data(frame) # Update classification processed_image = mobilenet_v2.preprocess_input(np.expand_dims(frame, axis=0)) predictions = model.predict(processed_image) label = mobilenet_v2.decode_predictions(predictions) lbl.set_text(label[0][0][1]) return vid, lbl
def classify_thread(image, model): logging.info('Classification Process Started for model ' + model) prediction = {'label': '', 'confidence': 0.0} net = models[model]['graph'] res = net.predict(image) if model == 'default': pred = decode_predictions(res, top=1)[0][0] prediction['label'] = pred[1].upper() prediction['confidence'] = float(round(pred[2], 2)) else: index = int(res.argmax(axis=1)[0]) prediction['label'] = models[model]['labels'][index].upper() prediction['confidence'] = float(round(res[0][index], 2)) return prediction
def predict(self, np_image): formatted_image = self.model_info.format_fn(np_image, "?") predictions = self.model.predict( tf.expand_dims(formatted_image[0], axis=0)) if self.model_info.base_model_only: label = decode_predictions(predictions) else: label = self.model_info.label_fn(predictions, self.model_info.class_names) version = self.model_info.version prob_list = [] for prob in predictions[0]: prob_list.append(prob.astype(float)) class_names = {} for idx, class_name in enumerate(self.model_info.class_names): class_names[class_name.astype(str)] = idx return prob_list, label, version, class_names
def tflite_predict(self, frame, input_shape=None): if not self.tflite_interpreter: self.init_tflite_interpreter() dtype = self.tflite_input_details[0].get('dtype') # expand 3D RGB frame into 4D batch (of 1 item) sample = np.expand_dims(frame, axis=0) processed_sample = preprocess_input(sample.astype(dtype)) self.tflite_interpreter.set_tensor( self.tflite_input_details[0]['index'], processed_sample) self.tflite_interpreter.invoke() features = self.tflite_interpreter.get_tensor( self.tflite_output_details[0]['index']) decoded_features = decode_predictions(features) return decoded_features
def process(): model = load_model('../static/people_photo/mobilenet.h5') if request.method == 'POST': f = request.files['image'] f.save(os.path.join(file_path, secure_filename(f.filename))) img = load_img(f, target_size=(224, 224)) img = img_to_array(img) img = np.expand_dims(img, axis=0) img = preprocess_input(img) predicted = model.predict(img) result = decode_predictions(predicted, top=3)[0] file_name = os.path.join(app.config['UPLOAD_FOLDER'], secure_filename(f.filename)) return render_template('preview.html', result=result, image=file_name)
def upload_image(): if 'image' not in request.files: return render_template( 'ImageML.html', prediction='No posted image. Should be attribute named image') file = request.files['image'] if file.filename == '': return render_template('ImageML.html', prediction='You did not select an image') if file and valid_file(file.filename): ImageFile.LOAD_TRUNCATED_IMAGES = False img = Image.open(BytesIO(file.read())) img.load() img = img.resize((IMAGE_WIDTH, IMAGE_HEIGHT), Image.ANTIALIAS) x = image.img_to_array(img) if x.shape[2] != IMAGE_CHANNELS: return render_template( 'ImageML.html', prediction='Image color channels should be 3') x = np.expand_dims(x, axis=0) x = preprocess_input(x) pred = model.predict(x) prd = decode_predictions(pred, top=3) # top 3 predictions items = [] for item in prd[0]: items.append({'name': item[1], 'prob': float(item[2])}) response = {'predictions': items} return render_template('ImageML.html', prediction=response) else: return render_template('ImageML.html', prediction='Invalid File extension')
import numpy as np import cv2 from tensorflow.keras.models import load_model from tensorflow.keras.applications.mobilenet_v2 import MobileNetV2 from tensorflow.keras.applications.mobilenet_v2 import preprocess_input, decode_predictions #include_top=True,完整的模型 #include_top=False,去掉最后的3个全连接层,用来做fine-tuning专用,专门开源了这类模型。 model = MobileNetV2(weights='imagenet') print(model.summary()) img_path = "elephant.jpg" img = image.load_img(img_path, target_size=(224, 224)) #将输入数据转换为0~1之间 img = image.img_to_array(img) / 255.0 # 为batch添加第四维,axis=0表示在0位置添加,因为MobileNet的Iput层结构是(None,224,224,3) img = np.expand_dims(img, axis=0) print(img.shape) predictions = model.predict(img) print('Predicted:', decode_predictions(predictions, top=3)[0]) print(predictions) description = decode_predictions(predictions, top=3)[0][0][1] src = cv2.imread(img_path) cv2.putText(src, description, (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 0, 0), 2) cv2.imshow("Predicted", src) cv2.waitKey()
## print('Read image') img = read_img(img_path) ## print('Load Model') saved_model_loaded = tf.saved_model.load(model_path, tags=[tag_constants.SERVING]) signature_keys = list(saved_model_loaded.signatures.keys()) print(signature_keys) infer = saved_model_loaded.signatures['serving_default'] print(infer.structured_outputs) ## print('Inference') preds = inference(img, infer) print('Predicted: ', decode_predictions(preds, top=3)[0]) ## from tensorflow.keras.preprocessing import image img_keras = image.load_img(img_path, target_size=(224, 224)) img_keras = image.img_to_array(img_keras) ## print('Inference') preds_keras = inference(img_keras, infer) print('Predicted Keras: ', decode_predictions(preds_keras, top=3)[0]) cv2.imshow('image',img.astype('uint8')) cv2.waitKey(0) cv2.destroyAllWindows()
interpreter.allocate_tensors() # Get input and output tensors input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() # Test model once input_shape = input_details[0]['shape'] input_data = preprocessed interpreter.set_tensor(input_details[0]['index'], preprocessed) # This actually calls the inference interpreter.invoke() # The function 'get_tensor' returns a copy(!) of the output tensor output_data = interpreter.get_tensor(output_details[0]['index']) print(decode_predictions(output_data, top=1)) time.sleep(1) # keep in mind that tflite is build for inferencing on ARM cpu's, not x86_64 print("starting now (tflite)...") s = time.time() for i in range(0,250,1): interpreter.set_tensor(input_details[0]['index'], preprocessed) interpreter.invoke() prediction = interpreter.get_tensor(output_details[0]['index']) e = time.time() print('Time[ms] : ' + str(e-s)) print('FPS : ' + str(1.0/((e-s)/250.0)))
def predict_model(image): preds = model.predict(image) results = decode_predictions(preds, top=3) return results
print(infer.structured_outputs) print('Pillow') for i in range(4): img_path = 'data/img%d.JPG' % i 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) x = tf.constant(x) labeling = infer(x) preds = labeling['predictions'].numpy() print('{} - Predicted: {}'.format(img_path, decode_predictions(preds, top=3)[0])) print('OpenCV') for i in range(4): img_path = 'data/img%d.JPG' % i img = cv2.imread(img_path) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) x = cv2.resize(img, (224, 224), interpolation=cv2.INTER_NEAREST) x = np.expand_dims(x, axis=0) x = preprocess_input(x) x = tf.constant(x) labeling = infer(x) preds = labeling['predictions'].numpy() print('{} - Predicted: {}'.format(img_path,
async def predict(request: Request): # GET REQUESTER IP :P #print(request.client.host) if request.method == "POST": data = await request.form() # UNDERSTANDING THE DATA------- #print(data) #FormData [('image', <starlette.datastructures...)] #print(data['image']) #UploadFile # READ IMAGE test = await data['image'].read() #read file # UNDERSTANDING THE DATA------- #print(data['image'].content_type) # image/png #print(data['image'].file) # SpooledTemporaryFile # CHECK IF THE REQUESTER LOADED A CORRECT FORMAT OR NOT if data['image'].content_type not in [ 'image/png', 'image/jpeg', 'image/jpg' ]: display = True warn = "This is not a picture. Please choose a png, jpeg or jpg format!" #return templates.TemplateResponse('index.html', {'request': request, 'warning': warn, 'display': display}) return {'status': 'no-supported-plot', 'result': warn} else: display = False warn = "" try: img = Image.open(BytesIO(test)) dimensions = np.array(img).shape if len(dimensions) > 2 and dimensions[2] == 4: img = img.convert('RGB') #print(np.array(img).shape) img = img.resize((224, 224)) img = image.img_to_array(img) img = np.expand_dims(img, axis=0) img = preprocess_input(img) preds = mobile.predict(img) preds = decode_predictions(preds) data = {} data["success"] = True data["predictions"] = [] for (imagenetID, label, prob) in preds[0]: r = {"label": label, "probability": float(prob)} data["predictions"].append(r) predictions = pd.DataFrame(data['predictions']) p, plot = lollipop(predictions) #return templates.TemplateResponse('index.html', {'request': request, 'warning': warn, 'display': display, 'plot': plot}) return {'status': 'ok-plot', 'result': plot} except: display = True warn = "Problem with your picture. Probably broken!" #return templates.TemplateResponse('index.html', {'request': request, 'warning': warn, 'display': display}) return {'status': 'error-plot', 'result': warn}
output_tensor = tf_sess.graph.get_tensor_by_name(output_tensor_name) # Optional image to test model prediction. img = image.load_img(img_file, 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]) import time times = [] for i in range(20): start_time = time.time() one_prediction = tf_sess.run(output_tensor, feed_dict) delta = (time.time() - start_time) times.append(delta) mean_delta = np.array(times).mean() fps = 1 / mean_delta print('average(sec):{:.2f},fps:{:.2f}'.format(mean_delta, fps))
interpreter.allocate_tensors() # Get input and output tensors input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() # Test model once input_shape = input_details[0]['shape'] print(input_shape) interpreter.set_tensor(input_details[0]['index'], preprocessed) # This actually calls the inference interpreter.invoke() # The function 'get_tensor' returns a copy(!) of the output tensor output_data = interpreter.get_tensor(output_details[0]['index']) print(decode_predictions(output_data[:, :1000], top=1)) time.sleep(1) # uses only 1 cpu, very slow on x86_64 # using this with the Coral package is a lot more efficient, even on cpu print("starting now (tflite)...") s = time.time() for i in range(0, 250, 1): interpreter.set_tensor(input_details[0]['index'], preprocessed) interpreter.invoke() prediction = interpreter.get_tensor(output_details[0]['index']) e = time.time() print('elapsed : ' + str(e - s))
def _predict_image(img_org): start_time = time.time() result = {} response = "Computer Vision challenge\r\n#AIApril\r\n\r\nTop 3 predictions of MobileNet_V2 \r\ntrained on ImageNet dataset:\r\n" img = img_org.resize((224, 224)) img = image.img_to_array(img) img = np.expand_dims(img, axis=0) img = preprocess_input(img) preds = model.predict(img) for i in range(3): res = decode_predictions(preds, top=3)[0][i] response += f"{res[1]} - {res[2]*100:.2f}% \r\n" logging.info(f"Prediction: {res[1]} - {res[2]*100:.1f}%") result["prediction"+str(i)] = f"{res[1]} - {res[2]*100:.1f}%" #response += "\r\nVisualizing CAM (Class Activation Mapping)\r\naka Neural Network attention for the best prediction" #response += f"\r\nImage load + Predictions: @ {time.time() - start_time :.2f} sec \r\n" logging.info(f"\r\nImage load + Predictions: @ {time.time() - start_time :.2f} sec") ind = np.argmax(preds[0]) vector = model.output[:, ind] # 4/1/2020 5:02:21 AM] __________________________________________________________________________________________________ # [4/1/2020 5:02:21 AM] block_15_project (Conv2D) (None, 7, 7, 160) 153600 block_15_depthwise_relu[0][0] # [4/1/2020 5:02:21 AM] __________________________________________________________________________________________________ # [4/1/2020 5:02:21 AM] block_15_project_BN (BatchNorma (None, 7, 7, 160) 640 block_15_project[0][0] # [4/1/2020 5:02:21 AM] __________________________________________________________________________________________________ # [4/1/2020 5:02:21 AM] block_15_add (Add) (None, 7, 7, 160) 0 block_14_add[0][0] # [4/1/2020 5:02:21 AM] block_15_project_BN[0][0] # [4/1/2020 5:02:21 AM] __________________________________________________________________________________________________ # [4/1/2020 5:02:21 AM] block_16_expand (Conv2D) (None, 7, 7, 960) 153600 block_15_add[0][0] # [4/1/2020 5:02:21 AM] __________________________________________________________________________________________________ # [4/1/2020 5:02:21 AM] block_16_expand_BN (BatchNormal (None, 7, 7, 960) 3840 block_16_expand[0][0] # [4/1/2020 5:02:21 AM] __________________________________________________________________________________________________ # [4/1/2020 5:02:21 AM] block_16_expand_relu (ReLU) (None, 7, 7, 960) 0 block_16_expand_BN[0][0] # [4/1/2020 5:02:21 AM] __________________________________________________________________________________________________ # [4/1/2020 5:02:21 AM] block_16_depthwise (DepthwiseCo (None, 7, 7, 960) 8640 block_16_expand_relu[0][0] # [4/1/2020 5:02:21 AM] __________________________________________________________________________________________________ # [4/1/2020 5:02:21 AM] block_16_depthwise_BN (BatchNor (None, 7, 7, 960) 3840 block_16_depthwise[0][0] # [4/1/2020 5:02:21 AM] __________________________________________________________________________________________________ # [4/1/2020 5:02:21 AM] block_16_depthwise_relu (ReLU) (None, 7, 7, 960) 0 block_16_depthwise_BN[0][0] # [4/1/2020 5:02:21 AM] __________________________________________________________________________________________________ # [4/1/2020 5:02:21 AM] block_16_project (Conv2D) (None, 7, 7, 320) 307200 block_16_depthwise_relu[0][0] # [4/1/2020 5:02:21 AM] __________________________________________________________________________________________________ # [4/1/2020 5:02:21 AM] block_16_project_BN (BatchNorma (None, 7, 7, 320) 1280 block_16_project[0][0] # [4/1/2020 5:02:21 AM] __________________________________________________________________________________________________ # [4/1/2020 5:02:21 AM] Conv_1 (Conv2D) (None, 7, 7, 1280) 409600 block_16_project_BN[0][0] # [4/1/2020 5:02:21 AM] __________________________________________________________________________________________________ # [4/1/2020 5:02:21 AM] Conv_1_bn (BatchNormalization) (None, 7, 7, 1280) 5120 Conv_1[0][0] # [4/1/2020 5:02:21 AM] __________________________________________________________________________________________________ # [4/1/2020 5:02:21 AM] out_relu (ReLU) (None, 7, 7, 1280) 0 Conv_1_bn[0][0] # [4/1/2020 5:02:21 AM] __________________________________________________________________________________________________ # [4/1/2020 5:02:21 AM] global_average_pooling2d (Globa (None, 1280) 0 out_relu[0][0] # [4/1/2020 5:02:21 AM] __________________________________________________________________________________________________ # [4/1/2020 5:02:21 AM] Logits (Dense) (None, 1000) 1281000 global_average_pooling2d[0][0] # [4/1/2020 5:02:21 AM] ================================================================================================== # # The output feature map of the last convolutional layer last_conv_layer = model.get_layer('Conv_1_bn') # The gradient of the vector class with regard to the output feature map grads = K.gradients(vector, last_conv_layer.output)[0] # A vector of shape (1280,), where each entry is the mean intensity of the gradient over a specific feature map channel pooled_grads = K.mean(grads, axis=(0, 1, 2)) # This function allows us to access the values of the quantities we just defined: # `pooled_grads` and the output feature map of conv layer, given a sample image iterate = K.function([model.input], [pooled_grads, last_conv_layer.output[0]]) # These are the values of these two quantities, as Numpy arrays, given the image pooled_grads_value, conv_layer_output_value = iterate([img]) # We multiply each channel in the feature map array by "how important this channel is" with regard to the predicted class for i in range(1280): conv_layer_output_value[:, :, i] *= pooled_grads_value[i] #response += f"Activation layers: @ {time.time() - start_time :.2f} sec \r\n" logging.info(f"Activation layers: @ {time.time() - start_time :.2f} sec") # The channel-wise mean of the resulting feature map is our heatmap of class activation heatmap = np.mean(conv_layer_output_value, axis=-1) heatmap = np.maximum(heatmap, 0) heatmap /= np.max(heatmap) RGBheat = [] for line in heatmap: RGBheat.append([]) for x in line: r, g, b = pixel(x, width=1, map=heatmap_scema) r, g, b = [int(256*v) for v in (r, g, b)] pix = (r, g, b) RGBheat[-1].append(pix) heatmap = np.array(RGBheat) heatmap = np.uint8(heatmap) #heatmap = np.expand_dims(heatmap, axis=0) #response += f"HeatMap created: @ {time.time() - start_time :.2f} sec \r\n" logging.info(f"HeatMap created: @ {time.time() - start_time :.2f} sec") heatmap = Image.fromarray(heatmap) heatmap = heatmap.resize( img_org.size) heatmap = np.uint8(heatmap) superimposed_img = heatmap * 0.8 + img_org ## superimposed_img = img_org.copy() ## superimposed_img.putalpha(heatmap) ## result_img = Image.new("RGB", superimposed_img.size, (255, 255, 255)) ## result_img.paste(superimposed_img, mask=superimposed_img.split()[3]) # result_img = image.array_to_img(superimposed_img) draw = ImageDraw.Draw(result_img) font = ImageFont.load_default() #response += f"\r\nTotal execution time: {time.time() - start_time :.2f} sec\r\n" logging.info(f"\r\nTotal execution time: {time.time() - start_time :.2f} sec") draw.text( (10,10), response, (55, 25, 255), font=font) img_byte_arr = io.BytesIO() result_img.save(img_byte_arr, format='JPEG', quality=100) result['img'] = base64.encodebytes(img_byte_arr.getvalue()).decode("utf-8") #result_img.save('test.jpg') return result
import streamlit as st from tensorflow.keras.applications.mobilenet_v2 import MobileNetV2 import numpy as np from tensorflow.keras.applications.mobilenet_v2 import preprocess_input, decode_predictions from PIL import Image import cv2 from tensorflow.keras.models import load_model st.title("Image Classifier") upload = st.sidebar.file_uploader(label='Upload the Image') if upload is not None: file_bytes = np.asarray(bytearray(upload.read()), dtype=np.uint8) opencv_image = cv2.imdecode(file_bytes, 1) opencv_image = cv2.cvtColor(opencv_image, cv2.COLOR_BGR2RGB) img = Image.open(upload) st.image(img, caption='Uploaded Image', width=300) model = load_model() if st.sidebar.button('PREDICT'): st.sidebar.write("Result:") x = cv2.resize(opencv_image, (224, 224)) x = np.expand_dims(x, axis=0) x = preprocess_input(x) y = model.predict(x) label = decode_predictions(y) # print the classification for i in range(3): out = label[0][i] st.sidebar.title('%s (%.2f%%)' % (out[1], out[2] * 100))
def set_model(self, model_name, top_n=5): if model_name == 'densenet': self.model = densenet.DenseNet121(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000) self.target_size = (224, 224) self.decoder = lambda x: densenet.decode_predictions(x, top=top_n) self.ref = """ <ul> <li><a href='https://arxiv.org/abs/1608.06993' target='_blank'> Densely Connected Convolutional Networks</a> (CVPR 2017 Best Paper Award)</li> </ul> """ elif model_name == 'inception_resnet_v2': self.model = inception_resnet_v2.InceptionResNetV2( include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000) self.target_size = (299, 299) self.decoder = lambda x: inception_resnet_v2.decode_predictions( x, top=top_n) self.ref = """ <ul> <li><a href='https://arxiv.org/abs/1602.07261' target='_blank'> Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning</a></li> </ul> """ elif model_name == 'inception_v3': self.model = inception_v3.InceptionV3(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000) self.target_size = (299, 299) self.decoder = lambda x: inception_v3.decode_predictions(x, top=top_n) self.ref = """<ul> <li><a href='https://arxiv.org/abs/1512.00567' target='_blank'> Rethinking the Inception Architecture for Computer Vision</a></li> </ul> """ elif model_name == 'mobilenet': self.model = mobilenet.MobileNet(input_shape=None, alpha=1.0, depth_multiplier=1, dropout=1e-3, include_top=True, weights='imagenet', input_tensor=None, pooling=None, classes=1000) self.target_size = (224, 224) self.decoder = lambda x: mobilenet.decode_predictions(x, top=top_n) self.ref = """<ul> <li><a href='https://arxiv.org/abs/1704.04861' target='_blank'> MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications</a></li> </ul> """ elif model_name == 'mobilenet_v2': self.model = mobilenet_v2.MobileNetV2(input_shape=None, alpha=1.0, include_top=True, weights='imagenet', input_tensor=None, pooling=None, classes=1000) self.target_size = (224, 224) self.decoder = lambda x: mobilenet_v2.decode_predictions(x, top=top_n) self.ref = """<ul> <li><a href='https://arxiv.org/abs/1801.04381' target='_blank'> MobileNetV2: Inverted Residuals and Linear Bottlenecks</a></li> </ul> """ elif model_name == 'nasnet': self.model = nasnet.NASNetLarge(input_shape=None, include_top=True, weights='imagenet', input_tensor=None, pooling=None, classes=1000) self.target_size = (224, 224) self.decoder = lambda x: nasnet.decode_predictions(x, top=top_n) self.ref = """<ul> <li><a href='https://arxiv.org/abs/1707.07012' target='_blank'> Learning Transferable Architectures for Scalable Image Recognition</a></li> </ul> """ elif model_name == 'resnet50': self.model = resnet50.ResNet50(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000) self.target_size = (224, 224) self.decoder = lambda x: resnet50.decode_predictions(x, top=top_n) self.ref = """<ul> <li>ResNet : <a href='https://arxiv.org/abs/1512.03385' target='_blank'>Deep Residual Learning for Image Recognition </a></li> </ul> """ elif model_name == 'vgg16': self.model = vgg16.VGG16(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000) self.target_size = (224, 224) self.decoder = lambda x: vgg16.decode_predictions(x, top=top_n) self.ref = """<ul> <li><a href='https://arxiv.org/abs/1409.1556' target='_blank'> Very Deep Convolutional Networks for Large-Scale Image Recognition</a></li> </ul>""" elif model_name == 'vgg19': self.model = vgg19.VGG19(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000) self.target_size = (224, 224) self.decoder = lambda x: vgg19.decode_predictions(x, top=top_n) self.ref = """<ul> <li><a href='https://arxiv.org/abs/1409.1556' target='_blank'>Very Deep Convolutional Networks for Large-Scale Image Recognition</a></li> </ul>""" elif model_name == 'xception': self.model = xception.Xception(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000) self.target_size = (299, 299) self.decoder = lambda x: xception.decode_predictions(x, top=top_n) self.ref = """<ul> <li><a href='https://arxiv.org/abs/1610.02357' target='_blank'>Xception: Deep Learning with Depthwise Separable Convolutions</a></li> </ul>""" else: logger.ERROR('There has no model name !!!')