def imageprocess(request): form = ImageUploadForm(request.POST, request.FILES) if form.is_valid(): handle_uploaded_file(request.FILES['image']) #ML code #Pretrained model model = ResNet50(weights='imagenet') img_path = 'img.jpg' 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) preds = model.predict(x) print('Predicted:', decode_predictions(preds, top=3)[0]) html = decode_predictions(preds, top=3)[0] res = [] for e in html: res.append((e[1], np.round(e[2] * 100, 2))) return render(request, 'result.html', {'res': res}) return render(request, 'result.html')
def upload_file(): if request.method == 'POST': f = request.files['file'] #path = os.path.join(app.config['UPLOAD_FOLDER'], f.filename) model = ResNet50(weights='imagenet') #img = image.load_img(path, target_size=(224,224)) img = image.load_img(f, target_size=(224, 224)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) preds_decoded = decode_predictions(preds, top=3)[0] print(decode_predictions(preds, top=3)[0]) x = [] preds = [] img = [] f = "" #f.save(path) return render_template('uploaded.html', title='Success', predC1=preds_decoded[0][1], predC2=preds_decoded[1][1], predC3=preds_decoded[2][1], predP1=preds_decoded[0][2], predP2=preds_decoded[1][2], predP3=preds_decoded[2][2])
def predict(): message = request.get_json(force=True) encoded = message['image'] decoded = base64.b64decode(encoded) image = Image.open(io.BytesIO(decoded)) processed_image = preprocess_image(image, target_size=(224, 224)) with graph.as_default(): prediction = model.predict(processed_image) id = decode_predictions(prediction, top=1)[0][0][0] name = decode_predictions(prediction, top=1)[0][0][1] accuracy = decode_predictions(prediction, top=1)[0][0][2] page = requests.get( "http://www.image-net.org/api/text/imagenet.synset.geturls?wnid=" + id) soup = BeautifulSoup(page.content, 'html.parser') str_soup = str(soup) split_urls = str_soup.split('\r\n') split_urls = split_urls[0:20] images_list = [] for i in range(20): if (split_urls[i][0:11] == 'http://farm'): images_list.append(split_urls[i]) response = { 'name': name, 'accuracy': str(accuracy), 'prediction': images_list } return jsonify(response)
def talker(): pub = rospy.Publisher('chatter', String, queue_size=10) rospy.init_node('talker', anonymous=True) rate = rospy.Rate(10) # 10hz model = ResNet50(weights='imagenet') img_path = '/home/rajas/workspace/monorepo/src/image_classification/scripts/elephant.jpg' 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) preds = model.predict(x) # 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]) # Predicted: [(u'n02504013', u'Indian_elephant', 0.82658225), (u'n01871265', u'tusker', 0.1122357), (u'n02504458', u'African_elephant', 0.061040461)] while not rospy.is_shutdown(): #import ipdb; ipdb.set_trace() hello_str = str(decode_predictions( preds, top=3)[0]) + " %s" % rospy.get_time() rospy.loginfo(hello_str) pub.publish(hello_str) rate.sleep()
def classify_image(path): with urllib.request.urlopen(path) as url: with open('temp/temp.jpg', 'wb') as f: f.write(url.read()) K.clear_session() classifier=ResNet50() #print(classifier.summary()) new_image = image.load_img('temp/temp.jpg', target_size=(224, 224)) transformed_image= image.img_to_array(new_image) #print(transformed_image.shape) transformed_image=np.expand_dims(transformed_image,axis=0) #print(transformed_image.shape) transformed_image=preprocess_input(transformed_image) #print(transformed_image) y_pred= classifier.predict(transformed_image) #print(y_pred) #print(y_pred.shape) decode_predictions(y_pred, top=5) label = decode_predictions(y_pred) # retrieve the most likely result, i.e. highest probability decoded_label = label[0][0] print("######===============########") # print the classification print('%s (%.2f%%)' % (decoded_label[1], decoded_label[2]*100 )) print("######===============########") # Destroy references del classifier, new_image, transformed_image, y_pred, label K.clear_session() return ({"Prediction": decoded_label[1], "confidence": decoded_label[2] * 100, "url": path})
def recognize(img_url): print("Getting image from web or local path.") img_path = "/var/tmp/image_to_rec.jpg" if img_url.startswith("file:"): img_path = img_url.replace("file://", "") else: response = urllib2.urlopen(img_url) image_from_web = response.read(response) with open("/var/tmp/image_to_rec.jpg", "w") as tmp_img: tmp_img.write(image_from_web) print("Processing image...") 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) print("Classifying image") preds = model.predict(x) # 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]) return decode_predictions(preds, top=3)
def predict(filename): logger.info("predicting") img = image.load_img(filename, target_size=(224, 224)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) logger.info(x.shape) K.clear_session() model = ResNet50(weights='imagenet') preds = model.predict(x) K.clear_session() # decode the results into a list of tuples (class, description, probability) # (one such list for each sample in the batch) logger.info('Predicted:' + str(decode_predictions(preds, top=3)[0])) return decode_predictions(preds, top=5)[0]
def predict_images(bq_rows, yaml_config): pkey = bq_rows[0] image_cols = bq_rows[1] # Get images logging.info("Getting images") imgs_dir = "imgs/{}".format(pkey) util.run_command("mkdir -p {}".format(imgs_dir), throw_error=True) util.gcs_download_dir(yaml_config['gcs_img_path'].format(pkey), imgs_dir) # Load model start = time.time() model = ResNet50(weights='imagenet') end = time.time() logging.info("Model loading for breed {} took: {:.2f} sec".format( pkey, end - start)) # Predicting logging.info("Predicting on breed: {}".format(pkey)) start = time.time() img_predictions = [] for image_col in image_cols: image_key = image_col['url'].split('/')[-1] img_path = abspath(imgs_dir + "/" + image_key) loaded_img = image.load_img(img_path, target_size=(224, 224)) x = image.img_to_array(loaded_img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) pred_breed = decode_predictions(preds, top=1)[0][0][1] score = decode_predictions(preds, top=1)[0][0][2] logging.info('For image: {}, predicted: {} with score: {}'.format( image_col['url'], pred_breed, score)) img_predictions.append({ 'url': image_col['url'], 'breed': image_col['breed'], 'prediction': pred_breed, 'score': str(score) }) end = time.time() logging.info("Prediction took: {:.2f} sec".format(end - start)) # Clean up images util.run_command("rm -rf {}".format(imgs_dir), throw_error=True) return img_predictions
def predicition(self,filename): model = resnet50.ResNet50() img = image.load_img(filename, target_size=(224, 224)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = resnet50.preprocess_input(x) predictions = model.predict(x) predicted_classes = resnet50.decode_predictions(predictions, top=9) top_value = [] for imagenet_id, name, likelihood in predicted_classes[0]: top_value.append(name) if len(top_value)>0: return top_value[0] else: return "Unknown"
def predict(url, top_n=3): from PIL import Image from keras.applications.resnet50 import ResNet50 from keras.preprocessing import image from keras.applications.resnet50 import preprocess_input, decode_predictions import numpy as np import requests from io import BytesIO response = requests.get(url) try: img = Image.open(BytesIO(response.content)) target_size = ((224, 224)) model = ResNet50(weights='imagenet') if img.size != target_size: img = img.resize(target_size) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) return decode_predictions(preds, top=top_n)[0][0][1] except OSError: return ''
def analyze(img, img_target, model_name, top=3): """ :param img_target: tuple :param model_name: str :param top: int :param img: PIL.Image """ if top is None: top = 3 top = int(top) # prepare img prepared_img = prepare_image(img, img_target) # predict predictions = get_model(model_name).predict(prepared_img) decoded_predictions = decode_predictions(predictions, top=top)[0] # transform data listed_predictions = list() for class_name, class_description, score in decoded_predictions: listed_predictions.append(dict(class_name=class_name, class_description=class_description, score=str(score))) return { "used_model": model_name, "predictions": listed_predictions, "target_dimensions": dimensions(img_target) }
def predict(model, image_url, target_size, top_n=3): x = image.img_to_array(image_url) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) return decode_predictions(preds, top=top_n)[0]
def resnet_classifier(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) preds = rn50.predict(x) return set([x[1] for x in decode_predictions(preds, top=2)[0]])
def make_prediction(filename, top=5): status = 'SUCCESS' # ResNEt50 prediction img = image.load_img(filename, target_size=(224, 224)) X = np.expand_dims(image.img_to_array(img), axis=0) X = preprocess_input(X) model = ResNet50(weights='imagenet') preds = model.predict(X) y_pred = decode_predictions(preds, top=top)[0] y_pred = {x[1]: "{:.5f}".format(float(x[2])) for x in y_pred} # Own model prediction infile = open('VGG16_224x224x3_D512_D128.model', 'rb') model = pickle.load(infile) infile.close() infile = open('class_indices', 'rb') class_indices = pickle.load(infile) infile.close() img = image.load_img(filename, target_size=(224, 224)) tmp = np.expand_dims(img, axis=0) tmp2 = tmp / 255 own_pred = model.predict_proba(tmp2) y_own_pred = {} for breed, pred in zip(list(class_indices.keys()), own_pred[0]): y_own_pred[breed] = "{:.5f}".format(pred) return status, y_pred, y_own_pred
def do_predict(mdl, pred_data): # obtain predictions #if len(pred_data)>1: print("getting prediction for {} images".format(len(pred_data))) st = time.time() keys = pred_data.keys() pth_imgs = [pred_data[k] for k in keys] arr_imgs = [] for pth_img in pth_imgs: img = image.load_img(pth_img) # Load the image file, expecting to be 224x224 pixels (required by this model) x = image.img_to_array(img) # Convert the image to a numpy array x = resnet50.preprocess_input(x) # Scale the input image to the range used in the trained network arr_imgs.append(x) x = np.stack( arr_imgs, axis=0 ) predictions = mdl.predict(x) # Run the image through the deep neural network to make a prediction #if len(pred_data)>1: print("I made a set of predictions in {:.2f}s".format(time.time()-st)) decoded_predictions = resnet50.decode_predictions(predictions, top=len(predictions[0]) ) # Look up the names of the predicted classes. Index zero is the results for the first image. response = {} for key, prediction in zip(keys,decoded_predictions): d = {} for imagenet_id, name, likelihood in prediction: d[name.lower()] = float(round(likelihood,ROUND_FLOATS_TO)) response[key] = d return response
def upload(): Get the image data from the POST data = request.form['img'] # This decodes it into an image img = Image.open(BytesIO(base64.b64decode(data))) # Resize to 224x224 and make sure it's RGB img = img.resize((224,224)) img = img.convert("RGB") # Turn it into a matrix (224x224x3) x = image.img_to_array(img) # Add a dimension to make it (1x224x224x3) x = np.expand_dims(x, axis=0) # This remaps the pixel values to a negative<->positive range x = preprocess_input(x) # Get a prediction preds = model.predict(x) # decode the results into a list of tuples (class, description, probability) preds = decode_predictions(preds, top=3)[0] data = [] generated_text = lstmText(preds) term = " ".join(preds[0][1].split("_")).capitalize() for pred in preds: data.append({'id': pred[0], 'term': pred[1], 'score': float(pred[2])}) return jsonify(status='got image',prediction=data, text=generated_text, term=term)
def predictFromVGG16(img): # 学習済みのVGG16をロード # 構造とともに学習済みの重みも読み込まれる model = VGG16(weights='imagenet') # model.summary() # 引数で指定した画像ファイルを読み込む # サイズはVGG16のデフォルトである224x224にリサイズされる # img = image.load_img(filename, target_size=(224, 224)) # 読み込んだPIL形式の画像をarrayに変換 x = image.img_to_array(img) # 3次元テンソル(rows, cols, channels) を # 4次元テンソル (samples, rows, cols, channels) に変換 # 入力画像は1枚なのでsamples=1でよい x = np.expand_dims(x, axis=0) # Top-5のクラスを予測する # VGG16の1000クラスはdecode_predictions()で文字列に変換される preds = model.predict(preprocess_input(x)) results = decode_predictions(preds, top=1)[0] obj = [] for result in results: # 20%以上で予測されたものに限定する # 物が検知されなくても表示するため低くしている # 上げるとちゃんと検知されないと何も表示されない if result[2] > 0.2: print(result) obj = (result[1], result[2]) else: obj = (-1, -1) break return obj
def upload(): # Get the image data from the POST data = request.form['img'] # This decodes it into an image img = Image.open(BytesIO(base64.b64decode(data))) # Resize to 224x224 and make sure it's RGB img = img.resize((224,224)) img = img.convert("RGB") # Turn it into a matrix (224x224x3) x = image.img_to_array(img) # Add a dimension to make it (1x224x224x3) x = np.expand_dims(x, axis=0) # This remaps the pixel values to a negative<->positive range x = preprocess_input(x) # Get a prediction preds = model.predict(x) # decode the results into a list of tuples (class, description, probability) preds = decode_predictions(preds, top=3)[0] # This is a little goofy but we need to convert it to something that works # with jsonify. Python sets do not and also numpy float32's do not # So made a list of little dictionaries data = [] for pred in preds: data.append({'id': pred[0], 'term': pred[1], 'score': float(pred[2])}) # Send to p5 return jsonify(status='got image',prediction=data)
def callback(image_msg): print("Received Image") #First convert the image to OpenCV image cv_image = bridge.imgmsg_to_cv2(image_msg, desired_encoding="bgr8") (rows, cols, channels) = cv_image.shape if cols > 60 and rows > 60: cv2.circle(cv_image, (50, 50), 10, 255) cv2.imshow("Classify", cv_image) cv_image = cv2.resize(cv_image, target_size) # resize image np_image = np.asarray(cv_image) # read as np array np_image = np.expand_dims(np_image, axis=0) # Add another dimension for tensorflow np_image = np_image.astype( float) # preprocess needs float64 and img is uint8 np_image = preprocess_input(np_image) # Regularize the data global graph # This is a workaround for asynchronous execution with graph.as_default(): preds = model.predict(np_image) # Classify the image # decode returns a list of tuples [(class,description,probability),(class, descrip ... pred_string = decode_predictions(preds, top=1)[0] # Decode top 1 predictions msg_string.data = pred_string[0][1] msg_float.data = float(pred_string[0][2]) pub.publish(msg_string) pub1.publish(msg_float)
def plot_top_prediction_classes(ax, preds): max_preds = preds.max(axis=0).reshape((1, 1000)) order = numpy.argsort(max_preds) decoded = decode_predictions(max_preds) for i in range(5): ax.plot(preds[:, order[0][-1 - i]].transpose(), label=decoded[0][i][1]) ax.legend()
def predict(filename, featuresize): img = image.load_img(filename, target_size=(224, 224)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) preds = model.predict(preprocess_input(x)) results = decode_predictions(preds, top=featuresize)[0] return results
def post(self): #try: formData = request.files.get('file','') img = image.load_img(formData, target_size=(224, 224)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) print('predicting...') with graph.as_default(): preds = clf.predict(x) print('done') print('predicted', preds) # decode the results into a list of tuples (class, description, probability) # (one such list for each sample in the batch) pred_out = str(decode_predictions(preds, top=3)[0]) print('Predicted:', ) response = jsonify({ "statusCode": 200, "status": "Prediction made", "result": "Prediction: " + pred_out # str(data) }) response.headers.add('Access-Control-Allow-Origin', '*') return response
def adversarial_noise(model, image, target_class, noise_limit, sess, confidence=0.99, eps=1.0, max_iter=200): original = np.expand_dims(image, axis=0) target = np.array([target_class]) encoded_target = to_categorical(target, num_classes=1000) wrap = KerasModelWrapper(model) fgsm = FastGradientMethod(wrap, sess=sess) fgsm_params = { 'eps': eps, 'clip_min': 0.0, 'clip_max': 255.0, 'y_target': encoded_target } noisy = original for i in range(0, max_iter): noisy = fgsm.generate_np(noisy, **fgsm_params) current_confidence = model.predict(prep_image(noisy))[0][target_class] print(decode_predictions(model.predict(prep_image(noisy)), top=3)[0]) print(current_confidence) if current_confidence > confidence: break return np.reshape(noisy, noisy.shape[1:])
def predict(img_path): 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) preds = model.predict(x) print('Predicted:', decode_predictions(preds, top=10)[0])
def predict(): # initialize the data dictionary that will be returned from the # view data = {"success": False} # ensure an image was properly uploaded to our endpoint if flask.request.method == "POST": if flask.request.files.get("image"): # read the image in PIL format image = flask.request.files["image"].read() image = Image.open(io.BytesIO(image)) # preprocess the image and prepare it for classification image = prepare_image(image, target=(224, 224)) # classify the input image and then initialize the list # of predictions to return to the client preds = model.predict(image) results = decode_predictions(preds) data["predictions"] = [] # loop over the results and add them to the list of # returned predictions for (imagenetID, label, prob) in results[0]: r = {"label": label, "probability": float(prob)} data["predictions"].append(r) # indicate that the request was a success data["success"] = True # return the data dictionary as a JSON response return flask.jsonify(data)
def predecir_resnet50(ruta_imagen='glue_sticks.jpg'): from keras.applications.resnet50 import ResNet50 from keras.preprocessing import image from keras.applications.resnet50 import preprocess_input, decode_predictions from keras import backend as K import numpy as np model = ResNet50(weights='imagenet') img_path = ruta_imagen 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) preds = model.predict(x) K.clear_session() # decode the results into a list of tuples (class, description, probability) # (one such list for each sample in the batch) resultados = decode_predictions(preds, top=3)[0][0] descripcion = resultados[1] presicion = resultados[2] return { 'descripcion': descripcion, 'precision': presicion * 100, 'imagen': str(img_path) }
def respred(input_): print("") print("Now Loading resnet50 for prediction") print("") resmodel = ResNet50(weights='imagenet') image = load_img(input_, target_size=(224, 224)) # 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 VGG model image = preprocess_input(image) # predict the probability across all output classes yhat = resmodel.predict(image) # convert the probabilities to class labels label = decode_predictions(yhat) # retrieve the most likely result, e.g. highest probability label = label[0][0] # print the classification class_, percentage = (label[1], label[2] * 100) print("") print( "Loaded Resnet50 predicted the input image as {} with {}% confidence". format(class_, round(percentage, 2))) print("")
def predict(q): model = ResNet50(weights='imagenet') while True: client_socket = q.get() if client_socket is None: break msg = '' while msg[-7:] != '##END##': ss = client_socket.recvfrom(10000) msg += ss[0].decode('utf-8') print(len(msg)) dic = json.loads(msg[:-7]) chat_id = dic['chat_id'] image_data = base64.b64decode(dic['image']) img_path = 'predict.png' with open(img_path, 'wb') as outfile: outfile.write(image_data) 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) preds = decode_predictions(model.predict(x), top=5)[0] pred_list = [] for entry in preds: dic = {'label': entry[1], 'proba': str(entry[2])} pred_list.append(dic) result = {'predictions': pred_list, 'chat_id': chat_id} print(result) client_socket.sendall((json.dumps(result) + '##END##').encode('utf-8')) client_socket.close()
def compute(): model = ResNet50(include_top=True, weights='imagenet') tag = request.args.get('image') myimages = [] myimages.append(tag) images = [] for ii in myimages: images.append(load_img(ii, target_size=(224, 224))) for y in range(len(images)): images[y] = img_to_array(images[y]) x = np.expand_dims(images[y], axis=0) x = preprocess_input(x) yhat = model.predict(x) label_t = decode_predictions(yhat) label = label_t[0][0] a = label[1] l = [] l.append(a) response = app.response_class(response=json.dumps(l), status=200, mimetype='application/json') return response
def print_predictions(filename, preds, threshold=DEFAULT_THRESHOLD): """prints tabular output: filename, label, prob""" y_pred = decode_predictions(preds, top=3) for lev1 in y_pred: for _, label, prob in lev1: if prob > threshold: print(f"{filename}, {label},{prob}")
def classifyImage(fname): img = image.load_img(fname, target_size=(224, 224)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) pred = decode_predictions(model.predict(x), top=1)[0][0] return (pred[1], pred[2])
def predict(model, img, target_size, top_n=3): """Run model prediction on image """ if img.size != target_size: img = img.resize(target_size) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) return decode_predictions(preds, top=top_n)[0]
def predict(img): print('{}:'.format(img)) # Load the image file, resizing it to 224x224 pixels (required by this model) img_df = image.load_img(img, target_size=(224, 224)) x = image.img_to_array(img_df) # [row[columns[r, g, b]]] x = np.expand_dims(x, axis=0) # array of images # Scale and predict predictions = model.predict(resnet50.preprocess_input(x)) predicted_classes = resnet50.decode_predictions(predictions, top=5) for imagenet_id, name, likelihood in predicted_classes[0]: print(' - {}: {:2f} likelihood'.format(name, likelihood)) print('\n')
def predict(model, img, target_size, top_n=3): """Run model prediction on image Args: model: keras model img: PIL format image target_size: (w,h) tuple top_n: # of top predictions to return Returns: list of predicted labels and their probabilities """ if img.size != target_size: img = img.resize(target_size) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) return decode_predictions(preds, top=top_n)[0]
from keras.applications.resnet50 import ResNet50 from keras.preprocessing import image from keras_applications.imagenet_utils import preprocess_input from keras.applications.resnet50 import preprocess_input, decode_predictions import numpy as np model = ResNet50(weights='imagenet') img_path = '/Users/mosampatel/Documents/mosam.jpeg' 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) preds = model.predict(x) # 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])
from keras.applications.resnet50 import ResNet50 from keras.preprocessing import image from keras.applications.resnet50 import preprocess_input, decode_predictions import numpy as np height = 224 width = 224 channels = 3 top = 5 def load_image(path): img = image.load_img(path, target_size=(224, 224)) x = image.img_to_array(img) return x if __name__ == '__main__': args = docopt(__doc__) paths = args['IMAGE_PATH'] model = ResNet50(weights='imagenet') x = np.zeros((len(paths), height, width, channels)) for i, path in enumerate(paths): x[i] = load_image(path) x = preprocess_input(x) predictions = decode_predictions(model.predict(x), top=top) for prediction in predictions: print(prediction)
target_size = (128, 128) #target_size = (224, 224) #model = ResNet50(input_shape=(target_size[0], target_size[1], 3), weights='imagenet') model = keras.applications.mobilenet.MobileNet(input_shape=(target_size[0], target_size[1], 3), alpha=1.0, depth_multiplier=1, dropout=1e-3, include_top=True, weights='imagenet', input_tensor=None, pooling=None) print 'n params', model.count_params() #img_path = 'elephant.jpg' #img_path = '/home/daiver/c2VzcDQrsVI.jpg' img_path = '14586818_Alt01.jpg' #img = image.load_img(img_path, target_size=target_size) #x = image.img_to_array(img) x = cv2.imread(img_path) x = cv2.cvtColor(x, cv2.COLOR_BGR2RGB) width, height, channels = x.shape targetDim = height if width > height else width x = x[:targetDim, :targetDim] x = cv2.resize(x, target_size).astype(np.float32) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) # decode the results into a list of tuples (class, description, probability) # (one such list for each sample in the batch) for x in decode_predictions(preds, top=10)[0]: print x
# create a model object model = Model(inputs=resnet.input, outputs=activation_layer.output) # get the feature map weights final_dense = resnet.get_layer('fc1000') W = final_dense.get_weights()[0] while True: img = image.load_img(np.random.choice(image_files), target_size=(224, 224)) x = preprocess_input(np.expand_dims(img, 0)) fmaps = model.predict(x)[0] # 7 x 7 x 2048 # get predicted class probs = resnet.predict(x) classnames = decode_predictions(probs)[0] print(classnames) classname = classnames[0][1] pred = np.argmax(probs[0]) # get the 2048 weights for the relevant class w = W[:, pred] # "dot" w with fmaps cam = fmaps.dot(w) # upsample to 224 x 224 # 7 x 32 = 224 cam = sp.ndimage.zoom(cam, (32, 32), order=1) plt.subplot(1,2,1)
def do_POST(s): length = int(s.headers['Content-Length']) body = s.rfile.read(length).decode('utf-8') if s.headers['Content-type'] == 'application/json': post_data = json.loads(body) else: post_data = urllib.parse.parse_qs(body) modelid = post_data['model'] try: model = model_impls[modelid]['class'](**model_impls[modelid]['params']) except Exception as e: logger.error("Unable to load model: {reason}".format(reason=e.message)) s.send_response(300) s.send_header("Content-type", "application/json") s.end_headers() json.dump({ "status": 300, "message": e.message, }, s.wfile) return target_size = (dict([(m["id"],m['image_size']) for m in models]))[modelid] concepts = [] for annotation in post_data['annotations']: aid = annotation['annotationid'] begin = annotation['begin'] begin = annotation['end'] batch_x = np.zeros((len(annotation['frames']),target_size,target_size,3), dtype=np.float32) for i,frame in enumerate(annotation['frames']): # Load image to PIL format img = Image.open(BytesIO(base64.b64decode(frame['screenshot']))) # cache frame - FIXME: currently there is no mean to identify the video - same timstamp will overwrite an old frame (hash?) img.save(os.path.join(CACHE_DIR,'{0}.png'.format(frame['timecode']))) if img.mode != 'RGB': img = img.convert('RGB') hw_tuple = (target_size, target_size) if img.size != hw_tuple: logger.warn("Scaling image to model size - this should be done in advene!") img = img.resize(hw_tuple) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) batch_x[i] = x[0,:,:,:] preds = model.predict_on_batch(np.asarray(batch_x)) # decode the results into a list of tuples (class, description, probability) # (one such list for each sample in the batch) decoded = decode_predictions(preds, top=top_n_preds) confidences = dict() for t in itertools.chain.from_iterable(decoded): if t[1] in confidences: confidences[t[1]].append(float(t[2])) else: confidences[t[1]] = [float(t[2])] logger.debug(confidences) concepts.extend([ { 'annotationid': aid, 'confidence': max(confidences[l]), #FIXME: set correct timecode - set timecode of frame with max confidence? 'timecode': annotation['begin'], #timestamp_in_ms, 'label': l, 'uri': 'http://concept.org/%s' % l } for l in confidences] ) logger.debug(concepts) s.send_response(200) s.send_header("Content-type", "application/json") s.end_headers() response=json.dumps({ "status": 200, "message": "OK", "data": { 'media_filename': post_data["media_filename"], 'media_uri': post_data["media_uri"], 'concepts': concepts } }) s.wfile.write(response.encode())