def post(self):
parse = reqparse.RequestParser()
parse.add_argument('file',
type=werkzeug.datastructures.FileStorage,
location='files')
args = parse.parse_args()
imageFile = args['file']
if imageFile == None:
return {'Error': "please specify image file"}
fh, tmp_image_file = tempfile.mkstemp(suffix='_up.jpg',
dir='files',
text=False)
imageFile.save(tmp_image_file)
img_path = tmp_image_file
model = ResNet50(weights='imagenet')
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])
return {'Predicted': decode_predictions(preds, top=3)[0][0][1]}
def imageprocess(request):
form = ImageUploadForm(request.POST, request.FILES)
if form.is_valid():
handle_uploaded_file(request.FILES['image'])
model = ResNet50(weights='imagenet')
img_path = 'img.jpg'
#loading the image
img = image.load_img(img_path, target_size=(224, 224))
#convert image to array , 2D
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
#preprocess data and get ready for prediction
x = preprocess_input(x)
#predicting the values
preds = model.predict(x)
#predicting the animal
print('Predicted animal :', 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 exposed_resnet50(self, img_path):
model = ResNet50(weights='imagenet')
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])
return {'Predicted': decode_predictions(preds, top=3)[0][0][1]}
def print_time():
timer = time.time()
batch = form_batch()
print("form_batch(): %s ms" % ((time.time() - timer) * 1000))
timer = time.time()
# preds = model.predict_on_batch(batch)
preds = model.predict(batch)
print("predict(): %s ms" % ((time.time() - timer) * 1000))
timer = time.time()
decode_predictions(preds)
print("decode_predictions(): %s ms \n" % ((time.time() - timer) * 1000))
def print_time():
timer = time.time()
batch = form_batch()
print("form_batch(): %s ms" % ((time.time() - timer) * 1000))
timer = time.time()
labeling = infer(batch)
# preds = labeling['probs'].numpy()
# preds = model.predict(batch)
print("predict(): %s ms" % ((time.time() - timer) * 1000))
timer = time.time()
preds = labeling['predictions'].numpy()
decode_predictions(preds)
print("decode_predictions(): %s ms \n" % ((time.time() - timer) * 1000))
async def classify(request):
cam_id = request.match_info['stream']
cams = await get_cams(args.nvr_token)
cam_info = [cam for cam in cams if str(cam['id']) == cam_id]
if not cam_info:
raise web.HTTPNotFound(text='No rtsp source related to this url')
cam_info = cam_info[0]
play_from = cam_info['rtsp']
if cam_id not in cam_rtsp:
cam_rtsp[cam_id] = {}
cam_rtsp[cam_id]['client'] = rtsp.Client(play_from)
cam_rtsp[cam_id]['time'] = time()
if (time() - cam_rtsp[cam_id]['time']) > 120:
cam_rtsp[cam_id]['client'].close()
cam_rtsp[cam_id]['client'] = rtsp.Client(play_from)
cam_rtsp[cam_id]['time'] = time()
im = cam_rtsp[cam_id]['client'].read()
if im:
im = im.resize((224, 224))
x = image.img_to_array(im)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = model.predict(x)
text = str([i[1] for i in decode_predictions(preds, top=3)[0]])
else:
text = ''
return web.Response(headers=cors_headers, text=text)
def show_upload(filename):
debug = False
# load image, resize, convert to numpy array
img_path = app.config['UPLOADED_PHOTOS_DEST'] + '/' + filename
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = x[np.newaxis, ...]
x = preprocess_input(x)
# predict
y_pred = model.predict(x)
predictions = decode_predictions(y_pred, top=5)[0]
url = photos.url(filename)
# get mostly likely prediction
indices = np.argmax(predictions, axis=0)
max_index = indices[2]
max_class = predictions[max_index][1]
max_prob = "{:.1f}".format(100 * predictions[max_index][2])
if debug:
for i in range(len(predictions)):
print("prediction {0}: {1}, {2}".format(i, predictions[i][1],
predictions[i][2]))
print("indices: {0}".format(indices))
print("max_index: {0}, max_class: {1}, max_prob: {2}".format(
max_index, max_class, max_prob))
# render page
return render_template('upload_output.html',
filename=filename,
url=url,
predictions=predictions,
max_class=max_class,
max_prob=max_prob)
def process(self, obj):
imgstr = obj['payload']
img = Image.open(BytesIO(b64decode(imgstr)))
if img.mode != "RGB":
img = img.convert("RGB")
# resize the input image and preprocess it
img = img.resize((224, 224))
img = image.img_to_array(img)
img = np.expand_dims(img, axis=0)
img = preprocess_input(img)
with graph.as_default():
set_session(sess)
predictions = model.predict(img)
predictions = decode_predictions(predictions, top=3)[0]
print("Predictions from class_model_server.py:", predictions)
pred_strings = []
for _, pred_class, pred_prob in predictions:
pred_strings.append(
str(pred_class).strip() + " : " +
str(round(pred_prob, 5)).strip())
preds = ", ".join(pred_strings)
return_dict = {}
return_dict["preds"] = preds
return return_dict
def upload():
if request.method == 'POST':
f = request.files['photo']
basepath = os.path.dirname(__file__)
file_path = os.path.join(basepath, 'uploads',
secure_filename(f.filename))
f.save(file_path)
x = preprocess_image(file_path)
out = model.predict(x)
u = decode_predictions(out, top=3)[0]
s1 = u[0][1]
s2 = u[0][2] * 100
s3 = u[1][1]
s4 = u[1][2] * 100
s5 = u[2][1]
s6 = u[2][2] * 100
print(s1, s2, s3)
return render_template("index2.html",
s1=s1,
s2=s2,
s3=s3,
s4=s4,
s5=s5,
s6=s6)
def index():
menu = {
'ho': 1,
'da': 0,
'ml': 0,
'se': 0,
'co': 0,
'cg': 0,
'cr': 0,
'st': 0,
'wc': 0
}
vgg16 = VGG16()
names = []
vgg16_list = []
for file in glob(
'D:/Workspace/Python_flask/04.MachineLearning/static/data_01/*'):
name = file.split('.')[1]
name = name.split('\\')[1]
names.append(name)
img = io.imread(file)
# 불안정함
# img = cv2.imread(file, -1)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = cv2.resize(img, (224, 224))
yhat = vgg16.predict(img.reshape(-1, 224, 224, 3))
label = decode_predictions(yhat)
label = label[0][0]
label_per = f'{label[1]}({round(label[2]*100, 1)}%)'
vgg16_list.append(label_per)
return vgg16_list[0]
def classify_process():
model = ResNet50(weights='imagenet')
while True:
queue = db.lrange(IMAGE_QUEUE, 0, BATCH_SIZE - 1)
imageIDs = []
batch = None
for q in queue:
q = json.loads(q.decode('utf-8'))
image = base64_decode_image(q['image'], IMAGE_DTYPE, (1, IMAGE_HEIGHT, IMAGE_WIDTH, IMAGE_CHANS))
if batch is None:
batch = image
else:
batch = np.vstack([batch, image])
imageIDs.append(q["id"])
if len(imageIDs) > 0:
print(" * Batch size: {}".format(batch.shape))
preds = model.predict(batch)
results = decode_predictions(preds)
for (imageID, resultSet) in zip(imageIDs, results):
output = []
for (imagenetID, label, prob) in resultSet:
r = {"label": label, "probability": float(prob)}
output.append(r)
db.set(imageID, json.dumps(output))
db.ltrim(IMAGE_QUEUE, len(imageIDs), -1)
time.sleep(SEVER_SLEEP)
def imageProcess(request):
form = ImageUploadingForm(request.POST, request.FILES)
if form.is_valid():
handle_upload(request.FILES['image'])
# if image valid, create model
model = ResNet50(weights='imagenet')
img_path = 'img.jpg'
# predicting 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)
preds = model.predict(x)
# print('Predicted:', decode_predictions(preds, top=3)[0])
res = []
for result in decode_predictions(preds, top=3)[0]:
res.append((result[1], np.round(result[2] * 100, 2)))
# print(res)
return render(request, 'image-process/output.html', {'res': res})
def verify_with_image(model, input_shape):
from tensorflow.keras.applications.resnet50 import decode_predictions
from PIL import Image
while True:
img_file = input('Input image filename:')
try:
img = Image.open(img_file).convert('RGB')
resized_img = img.resize(input_shape, Image.BICUBIC)
except:
print('Open Error! Try again!')
continue
else:
img_array = np.asarray(resized_img).astype('float32')
x = normalize_image(img_array)
preds = model.predict(np.expand_dims(x, 0))
result = decode_predictions(preds)
print('Predict result:', result)
# show predict result on origin image
img_array = np.asarray(img)
cv2.putText(img_array,
'{name}:{conf:.3f}'.format(name=result[0][0][1],
conf=float(
result[0][0][2])),
(10, 30),
cv2.FONT_HERSHEY_SIMPLEX,
fontScale=1,
color=(255, 0, 0),
thickness=2,
lineType=cv2.LINE_AA)
Image.fromarray(img_array).show()
def benchmark_saved_model(SAVED_MODEL_DIR, batch_size=4):
image_x = []
for i in range(batch_size):
img_path = './data/img%d.JPG' % (i % 4)
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)
image_x.append(x)
with tf.Session(graph=tf.Graph(), config=config) as sess:
tf.compat.v1.saved_model.loader.load(sess, [tf.saved_model.SERVING],
SAVED_MODEL_DIR)
start = time.time()
for i in range(batch_size):
img_path = './data/img%d.JPG' % (i % 4)
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)
output = sess.run(OUTPUT_TENSOR, feed_dict={INPUT_TENSOR: x})
print(type(output))
print(output.shape)
print(decode_predictions(output, top=3)[0])
end = time.time()
print("processing time = {}ms".format((end - start) / 4 * 1000))
def test_video_predict():
model = ResNet50(weights='imagenet')
x = VideoDataset(video_path).batch(1).map(
lambda x: preprocess_input(image.resize(x, (224, 224))))
y = model.predict(x)
p = decode_predictions(y, top=1)
assert len(p) == 166
def dl_submit():
img = request.files["image"]
img.save("./myimage")
image = tf.image.decode_image(tf.io.read_file("./myimage"))
image = tf.image.resize(image, [224, 224])
pre_image = preprocess_input(image)
# make as 4D
pre_image = pre_image[None, ...]
b = tf.image.decode_image(tf.io.read_file("./myimage"))
jpeg = tf.image.encode_jpeg(b)
b = base64.b64encode(jpeg.numpy()).decode("utf-8")
probas = app.dl_model.predict(pre_image)
x = decode_predictions(probas, top=5)
print(x)
x = [(i[1], i[2] * 100) for i in x[0]]
return (f"""<!doctype html>
<title>ResNet50 Image Prediction</title>
<img src="https://upload.wikimedia.org/wikipedia/commons/3/3c/Flask_logo.svg" alt="alternatetext" width="200" height="200">
<body style="background-color:powderblue;">
Predicted class image is (with probability): <b>{x}</b> <br>
<img src='data:image/jpeg;base64,{b}'>
""" + """<br><a href='/'>Go Back</a>""")
def test():
f = flask_request.files['file']
img = np.fromstring(f.read(), np.uint8)
img = cv2.imdecode(img, cv2.IMREAD_COLOR)
img = prepare_image(img)
pred = model.predict(img)
return str(decode_predictions(pred))
def run_resnet_model(img_path):
img = image.load_img(path=img_path, target_size=(224, 224))
X = image.img_to_array(img)
X = np.expand_dims(X, axis=0)
X = resnet50.preprocess_input(X)
X_pred = model_resnet.predict(X)
display_prediction(resnet50.decode_predictions(X_pred, top=1))
def classify(img_path):
display(Image(filename=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)
predict=model.predict(x)
print('predicted',decode_predictions(predict,top=3)[0])
def classify(img_path):
img = image.load_img(img_path, target_size=(224, 224))
model = tf.keras.applications.resnet50.ResNet50()
img_array = image.img_to_array(img)
img_batch = np.expand_dims(img_array, axis=0)
img_preprocessed = preprocess_input(img_batch)
prediction = model.predict(img_preprocessed)
print(decode_predictions(prediction, top=3)[0])
def classify(img_path):
img = image.load_img(img_path, target_size=(224, 224))
img_array = image.img_to_array(img)
img_batch = np.expand_dims(img_array, axis=0)
img_preprocessed = preprocess_input(img_batch)
model = tf.keras.models.load_model('./models/resnet50.h5')
prediction = model.predict(img_preprocessed)
return decode_predictions(prediction, top=3)[0]
def score_model(model, x):
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
predictions = model.predict(x)
result = {
"result": [ [x[1], round(x[2] * 100, 2)] for x in decode_predictions(predictions, top=3)[0]]
}
return result
def decode_predictions_top_five(prediction):
decoded_prediction = decode_predictions(prediction, top=5)[0]
#prediction list of class name and class probability
prediction_list = []
for i in range(5):
prediction_list.append(decoded_prediction[i][1:3])
return prediction_list
def test():
f = flask_request.files['file']
img = np.fromstring(f.read(), np.uint8)
img = cv2.imdecode(img, cv2.IMREAD_COLOR)
img = prepare_image(img)
img = tf.constant(img)
labeling = infer(img)
pred = labeling['predictions'].numpy()
return str(decode_predictions(pred))
def classify_image(img):
resized = np.array(Image.fromarray(img).resize((224, 224)))
x = np.expand_dims(image.img_to_array(resized), axis=0)
x = preprocess_input(x)
preds = model.predict(x)
results = decode_predictions(preds, top=3)[0]
return "Predicted: {}".format(','.join([x[1] for x in results]))
def get_image_predictions(img_raw):
img = cv2.resize(img_raw, (224, 224))
x = img
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = model.predict(x)
return decode_predictions(preds, top=3)[0]
def predict():
if request.method == 'POST':
image_file = request.files['file'].read()
if image_file:
image_array = np.fromstring(image_file, np.uint8)
image_decode = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
x = prepare_image(image_decode)
predicts = model.predict(x)
results = decode_predictions(predicts)
return str(results)
def _post_process(self, prediction: np.array) -> PredictionResult:
"""post process
Args:
prediction (np.array): result of predict
Returns:
PredictionResult: prediction
"""
result_label = decode_predictions(prediction, top=1)[0][0][1]
dcp = PredictionResult(name=result_label)
return dcp
def get_top_5_predictions(img):
x = img_to_array(img)[np.newaxis, ...]
x = preprocess_input(x)
preds = decode_predictions(model.predict(x), top=5)
top_preds = pd.DataFrame(columns=['prediction', 'probability'],
index=np.arange(5)+1)
for i in range(5):
top_preds.loc[i+1, 'prediction'] = preds[0][i][1]
top_preds.loc[i+1, 'probability'] = preds[0][i][2]
return top_preds
def get_classes(file_path):
img = image.load_img(file_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.array([x])
x = preprocess_input(x)
preds = model.predict(x)
predictions = decode_predictions(preds, top=3)[0]
print(predictions)
return predictions