def loadModel():
prediction = CustomImagePrediction()
prediction.setModelTypeAsResNet()
prediction.setModelPath("model200.h5")
prediction.setJsonPath("class1.json")
prediction.loadModel(num_objects=12)
return prediction
def __init__(self, image_path, model_path, output_path): self.avgColor = [] self.pcaColors = [] self.detector = ObjectDetection() self.detector.setModelTypeAsYOLOv3() self.detector.setModelPath(model_path + "yolo.h5") self.detector.loadModel(detection_speed="flash") self.prediction = CustomImagePrediction() self.prediction.setModelTypeAsResNet() #self.prediction.setModelPath(model_path + "model_ex-012_acc-0.988819.h5") self.prediction.setModelPath(model_path + "model_ex-043_acc-0.996787.h5") self.prediction.setJsonPath(model_path + "model_class.json") self.prediction.loadModel(num_objects=2) now = time.localtime() self.frame_folder = str(now.tm_year) + str(now.tm_mon) + str(now.tm_mday) self.image_path = image_path self.output_path = output_path + "detection/" + self.frame_folder + "/" if os.path.exists(image_path) is False: os.mkdir(image_path) if os.path.exists(output_path) is False: os.mkdir(output_path) if os.path.exists(os.path.join(output_path, 'detection')) is False: os.mkdir(os.path.join(output_path, 'detection')) if os.path.exists(os.path.join(output_path, 'processed')) is False: os.mkdir(os.path.join(output_path, 'processed')) self.create_output_folder()
def __init__(self):
self.prediction = CustomImagePrediction()
self.prediction.setModelTypeAsResNet()
self.prediction.setModelPath(
"datasets/models/model_ex-062_acc-0.916385.h5")
self.prediction.setJsonPath("datasets/json/model_class.json")
self.prediction.loadModel(num_objects=2)
self.webcam = Webcam()
def getModel():
global prediction
if prediction is not None:
return prediction
prediction = CustomImagePrediction()
prediction.setModelTypeAsResNet50()
prediction.setModelPath("model.h5")
prediction.setJsonPath("styles.json")
prediction.loadModel(num_objects=25)
return prediction
def run_predict():
predictor = CustomImagePrediction()
predictor.setModelPath(model_path="trafficnet_resnet_model_ex-055_acc-0.913750.h5")
predictor.setJsonPath(model_json="model_class.json")
predictor.loadFullModel(num_objects=4)
predictions, probabilities = predictor.predictImage(image_input="", result_count=4) #PATH FOR IMAGE
for prediction, probability in zip(predictions, probabilities):
print(prediction, " : ", probability)
def run_predict():
predictor = CustomImagePrediction()
predictor.setModelPath(model_path="trafficnetmodelacc-0.893750.h5")
predictor.setJsonPath(model_json="model_class.json")
predictor.loadFullModel(num_objects=4)
predictions, probabilities = predictor.predictImage(image_input="images/dense.jpg", result_count=4)
for prediction, probability in zip(predictions, probabilities):
print(prediction, " : ", probability)
def detect_move_from_webcam(
self,
model_file_name=None,
config_file_name="model_class.json",
webcam_index=0,
sensibility=80,
):
# Instantiate the CustomImagePrediction object that will predict our moves
predictor = CustomImagePrediction()
# Set the model type of the neural network (it must be the same of the training)
self._set_proper_model_type(self.model_type, predictor)
if not model_file_name:
# If model file name is not set, ask user to choose which model must be used
model_file_name = self._get_model_file_name(self.dataset_name)
# Set path to the trained model file
predictor.setModelPath(
os.path.join(self.base_path, self.dataset_name, "models",
model_file_name))
# Set path to the json file that contains our classes and their labels
predictor.setJsonPath(
os.path.join(self.base_path, self.dataset_name, "json",
config_file_name))
# Load the trained model and set it to use "class_number" classes
predictor.loadModel(num_objects=self.class_number)
# Context manager that help us to activate/deactivate our webcam
with opencv_video_capture(webcam_index) as cap:
# Run until user press "q" key
while True:
# Acquire a frame from webcam
_, frame = cap.read()
# Do a prediction on that frame
predictions, probabilities = predictor.predictImage(
frame, result_count=3, input_type="array")
# Get a tuple (class_predicted, probability) that contains the best
# prediction
best_prediction = max(zip(predictions, probabilities),
key=lambda x: x[1])
# If probability of the best prediction is >= of the min sensibility
# required, it writes a label with predicted class name and probability
# over the frame
if best_prediction[1] >= sensibility:
cv2.putText(
frame,
f"{best_prediction[0]} ({round(best_prediction[1], 2)})",
(10, 30),
cv2.FONT_HERSHEY_SIMPLEX,
1,
(255, 255, 255),
2,
cv2.LINE_AA,
)
# Display the acquired frame on a dedicated window
cv2.imshow("Move predictor", frame)
# Break cycle if user press "q" key
if cv2.waitKey(1) & 0xFF == ord("q"):
break
def run_predict():
predictor = CustomImagePrediction()
predictor.setModelPath(model_path="action_net_ex-060_acc-0.745313.h5")
predictor.setJsonPath(model_json="model_class.json")
predictor.loadFullModel(num_objects=16)
predictions, probabilities = predictor.predictImage(
image_input="images/5.jpg", result_count=4)
for prediction, probability in zip(predictions, probabilities):
print(prediction, " : ", probability)
async def main(file_type: str, files: str):
model = CustomImagePrediction()
model.setModelTypeAsResNet()
model.setModelPath(
os.path.join(EXECUTION_PATH, 'data/images/models/kermit_finder.h5'))
model.setJsonPath(
os.path.join(EXECUTION_PATH, 'data/images/json/model_class.json'))
model.loadModel(num_objects=2) # number of objects on your trained model
if file_type == 'image':
for image in files.split(','):
print(await predict_image(image_name=image, model=model))
else:
await predict_video(video_path=files, model=model)
def init():
#Prepare and load model
global execution_path, prediction, graph, session
execution_path = os.getcwd()
session = tf.Session()
graph = tf.get_default_graph()
tf.keras.backend.set_session(session)
prediction = CustomImagePrediction()
prediction.setModelTypeAsResNet()
prediction.setModelPath(
execution_path +
"/Train&Test/chest_xray/models/model_ex-003_acc-0.773026.h5")
prediction.setJsonPath(execution_path +
"/Train&Test/chest_xray/json/model_class.json")
prediction.loadModel(num_objects=2)
def test_custom_recognition_full_model_resnet():
predictor = CustomImagePrediction()
predictor.setModelPath(os.path.join(main_folder, "data-models", "idenprof_full_resnet_ex-001_acc-0.119792.h5"))
predictor.setJsonPath(model_json=os.path.join(main_folder, "data-json", "idenprof.json"))
predictor.loadFullModel(num_objects=10)
predictions, probabilities = predictor.predictImage(image_input=os.path.join(main_folder, main_folder, "data-images", "9.jpg"))
assert isinstance(predictions, list)
assert isinstance(probabilities, list)
assert isinstance(predictions[0], str)
assert isinstance(probabilities[0], str)
class Color(object):
prediction = CustomImagePrediction()
prediction.setModelTypeAsResNet()
prediction.setModelPath("./model_data/best_color.h5")
prediction.setJsonPath("./model_data/color_class.json")
prediction.loadModel(num_objects=2)
def color_API(path):
name = []
pro = []
predictions, probabilities = Color.prediction.predictImage(
path, result_count=2)
for eachPrediction, eachProbability in zip(predictions, probabilities):
print(eachPrediction, ':', eachProbability)
name.append(eachPrediction)
pro.append(eachProbability)
if (pro[0] > pro[1]):
Name = name[0]
else:
Name = name[1]
# print(Name)
if (Name == '0'):
return 0
else:
return 1
def __init__(self,
yolo_weigths='../../models_h5/yolo.h5',
model_weigths='../../models_h5/model_ex-055_acc-0.996250.h5',
model_json='../../models_h5/model_class.json'):
self.detector = ObjectDetection()
self.detector.setModelTypeAsYOLOv3()
self.detector.setModelPath(yolo_weigths)
self.detector.loadModel()
self.classifier = CustomImagePrediction()
self.classifier.setModelTypeAsResNet()
self.classifier.setModelPath(model_weigths)
self.classifier.setJsonPath(model_json)
self.classifier.loadModel(num_objects=2)
self.current_detection = []
class Color(object):
prediction = CustomImagePrediction()
prediction.setModelTypeAsResNet()
prediction.setModelPath("./model_data/best_color.h5")
prediction.setJsonPath("./model_data/color_class.json")
prediction.loadModel(num_objects=2)
def color_API(path):
# name=[]
# pro=[]
# predictions, probabilities = Color.prediction.predictImage(path, result_count=2)
# for eachPrediction, eachProbability in zip(predictions, probabilities):
# print(eachPrediction,':',eachProbability)
# name.append(eachPrediction)
# pro.append(eachProbability)
# if(pro[0]>pro[1]):
# Name=name[0]
# else:
# Name=name[1]
# # print(Name)
# if(Name=='0'):
# return 0
# else:
# return 1
i = 1
for fileName in fileList:
#遍历文件夹中所有文件
name = []
pro = []
n = len(fileList)
print('本次需要检测', n, '张照片')
k = n - i
start = timer()
print('还剩', k, '张待检测照片名称', fileName)
Color.prediction.loadModel(num_objects=2)
predictions, probabilities = Color.prediction.predictImage(
('./input/' + str(fileName)), result_count=2)
for eachPrediction, eachProbability in zip(predictions,
probabilities):
print(eachPrediction, ':', eachProbability)
name.append(eachPrediction)
pro.append(eachProbability)
i = i + 1
if (pro[0] > pro[1]):
Name = name[0]
else:
Name = name[1]
print(Name)
# if(Name=='0'):
## img=cv.imread('./input/'+fileName)
## cv.imwrite('./0/'+fileName,img)
# else:
## img=cv.imread('./input/'+fileName)
## cv.imwrite('./1/'+fileName,img)
# Name=name[1]
end = timer()
print('单张照片执行时间', end - start)
print('finish')
def setupPredictionFlowerModel(self):
# This gets the path of the .py file or the exe file
exPath = os.getcwd()
# Creates a custom image prediction object.
self.predict = CustomImagePrediction()
# Tells the custom image prediction object that it will be using
# self.predict.setModelTypeAsResNet()
# self.predict.setModelTypeAsInceptionV3()
self.predict.setModelTypeAsDenseNet()
# Check to see if there is an .h5 file (The model file). If the file
# is not found then a message is shown to the user saying that the
# file is missing. Both buttons are disabled to prevent any
# unexpected crash of the program.
if (os.path.isfile(os.path.join(exPath, "DenseNet_flower_model_85.h5"))
is False):
print("Could not file a training model file (.h5)")
self.PredictBtn.setEnabled(False)
self.selectImage.setEnabled(False)
self.predictionLbl.setText("Missing the model file (.h5)")
else:
# If the file the .h5 file exists then the .h5 model path will
# be set to it.
self.predict.setModelPath(
os.path.join(exPath, "DenseNet_flower_model_85.h5"))
# Checks to see if the .json model class file is found. If it
# is found the json path is loaded with the file.
# If the file is not found the user will be shown a message.
if os.path.isfile(os.path.join(exPath, "flower_model_class.json")):
self.predict.setJsonPath(
os.path.join(exPath, "flower_model_class.json"))
self.predict.loadModel(num_objects=5)
else:
# The message that is shown if the json file is not found.
# Both buttons are disabled to prevent any unexpected crash
# of the program.
print("Could not file a model class file (.jason)")
self.PredictBtn.setEnabled(False)
self.selectImage.setEnabled(False)
self.predictionLbl.setText(
"Missing the model class file (.json)")
def activity_detector(image_name):
result = []
predictor = CustomImagePrediction()
predictor.setModelPath(
model_path=os.path.join(root, "action-detection-image", "action.h5"))
predictor.setJsonPath(model_json=os.path.join(
root, "action-detection-image", "model_class.json"))
predictor.loadFullModel(num_objects=16)
predictions, probabilities = predictor.predictImage(image_input=image_name,
result_count=4)
for prediction, probability in zip(predictions, probabilities):
result.append([prediction, probability])
print(result)
return result[0][0]
def __init__(
self,
model_type=ModelTypeEnum.RESNET,
class_number=3, # We have 3 different objects: "rock", "paper", "scissors"
):
self.model_type = model_type
self.class_number = class_number
self.base_path = os.getcwd()
# Instantiate the CustomImagePrediction object that will predict our moves
self.predictor = CustomImagePrediction()
# Set the model type of the neural network (it must be the same of the training)
self._set_proper_model_type(self.model_type)
# Set path to the trained model file
self.predictor.setModelPath(
os.path.join(self.base_path, "data", "move_detector", "model.h5"))
# Set path to the json file that contains our classes and their labels
self.predictor.setJsonPath(
os.path.join(self.base_path, "data", "move_detector",
"model_class.json"))
# Load the trained model and set it to use "class_number" classes
self.predictor.loadModel(num_objects=self.class_number)
class RockPaperScissorsPredictor:
"""
This class contains the required code for model training and move prediction using a
webcam
"""
MODEL_TYPE_SET_LOOKUP = {
ModelTypeEnum.RESNET: lambda x: x.setModelTypeAsResNet(),
ModelTypeEnum.SQEEZENET: lambda x: x.setModelTypeAsSqueezeNet(),
ModelTypeEnum.INCEPTIONV3: lambda x: x.setModelTypeAsInceptionV3(),
ModelTypeEnum.DENSENET: lambda x: x.setModelTypeAsDenseNet(),
}
MOVES_LOOKUP = {
"rock": MovesEnum.ROCK,
"paper": MovesEnum.PAPER,
"scissors": MovesEnum.SCISSORS,
}
def __init__(
self,
model_type=ModelTypeEnum.RESNET,
class_number=3, # We have 3 different objects: "rock", "paper", "scissors"
):
self.model_type = model_type
self.class_number = class_number
self.base_path = os.getcwd()
# Instantiate the CustomImagePrediction object that will predict our moves
self.predictor = CustomImagePrediction()
# Set the model type of the neural network (it must be the same of the training)
self._set_proper_model_type(self.model_type)
# Set path to the trained model file
self.predictor.setModelPath(
os.path.join(self.base_path, "data", "move_detector", "model.h5"))
# Set path to the json file that contains our classes and their labels
self.predictor.setJsonPath(
os.path.join(self.base_path, "data", "move_detector",
"model_class.json"))
# Load the trained model and set it to use "class_number" classes
self.predictor.loadModel(num_objects=self.class_number)
def _set_proper_model_type(self, model_type):
self.MODEL_TYPE_SET_LOOKUP[model_type](self.predictor)
def detect_move_from_picture(self, picture, sensibility=90):
predictions, probabilities = self.predictor.predictImage(
picture, result_count=3, input_type="array")
# Get a tuple (class_predicted, probability) that contains the best
# prediction
best_prediction = max(zip(predictions, probabilities),
key=lambda x: x[1])
if best_prediction[1] < sensibility:
return
return self.MOVES_LOOKUP[best_prediction[0]]
def test_custom_recognition_full_model_resnet_multi():
try:
keras.backend.clear_session()
except:
None
predictor = CustomImagePrediction()
predictor.setModelPath(os.path.join(main_folder, "data-models", "idenprof_full_resnet_ex-001_acc-0.119792.h5"))
predictor.setJsonPath(model_json=os.path.join(main_folder, "data-json", "idenprof.json"))
predictor.loadFullModel(num_objects=10)
images_to_image_array()
result_array = predictor.predictMultipleImages(sent_images_array=all_images_array)
assert isinstance(result_array, list)
for result in result_array:
assert "predictions" in result
assert "percentage_probabilities" in result
assert isinstance(result["predictions"], list)
assert isinstance(result["percentage_probabilities"], list)
assert isinstance(result["predictions"][0], str)
assert isinstance(result["percentage_probabilities"][0], str)
async def predict_image(image_name: Union[str, np.ndarray],
model: CustomImagePrediction) -> dict:
"""Predicts a given image with the supplied prediction model"""
print('\nPredicting the {} image'.format(image_name))
predictions, probabilities = model.predictImage(os.path.join(
EXECUTION_PATH, image_name),
result_count=2)
representation = {}
for eachPrediction, eachProbability in zip(predictions, probabilities):
representation[eachPrediction] = '{0:.2f}%'.format(
float(eachProbability))
return representation
class Model(object):
def __init__(self):
self.prediction = CustomImagePrediction()
self.prediction.setModelTypeAsResNet()
self.prediction.setModelPath(
"datasets/models/model_ex-062_acc-0.916385.h5")
self.prediction.setJsonPath("datasets/json/model_class.json")
self.prediction.loadModel(num_objects=2)
self.webcam = Webcam()
def predict(self, frame):
pred, prob = self.prediction.predictImage(detect(frame)[1],
input_type="array",
result_count=2)
if prob[0] < 80:
cv2.rectangle(frame, (0, 0), (50, 50), (0, 255, 0), -1)
else:
cv2.rectangle(frame, (0, 0), (50, 50), (0, 0, 255), -1)
return frame
def run_predict():
predictor = CustomImagePrediction()
predictor.setModelPath(
model_path="trafficnet_resnet_model_ex-055_acc-0.913750.h5")
predictor.setJsonPath(model_json="model_class.json")
predictor.loadFullModel(num_objects=4)
predictions, probabilities = predictor.predictImage(
image_input="images/traff.jpg", result_count=4)
for prediction, probability in zip(predictions, probabilities):
print(prediction, " : ", probability)
result["accident"][prediction] = probability
# otus thresholding of 80
if probability > 80:
result["accident_result"][prediction] = True
else:
result["accident_result"][prediction] = False
if result["accident_result"]["Accident"] == True or result[
"accident_result"]["Fire"] == True:
sendemail()
print(result)
write(result)
def detect():
prediction = CustomImagePrediction()
prediction.setModelTypeAsResNet()
prediction.setModelPath("model200.h5")
prediction.setJsonPath("class1.json")
prediction.loadModel(num_objects=12)
predictions, probabilities = prediction.predictImage("C:/xampp/htdocs/tcs/temp.jpg", result_count=1)
for eachPrediction, eachProbability in zip(predictions, probabilities):
item = eachPrediction
return item
from imageai.Prediction.Custom import CustomImagePrediction
import os
import os.path
execution_path = os.getcwd()
prediction = CustomImagePrediction()
prediction.setModelTypeAsResNet()
prediction.setModelPath(
'{path}/traineddata/model_ex-032_acc-0.765625.h5'.format(
path=execution_path))
prediction.setJsonPath(
'{path}/traineddata/model_class.json'.format(path=execution_path))
prediction.loadModel(num_objects=2) # number of trained objects
def predict(img):
predictions, probabilities = prediction.predictImage(img, result_count=1)
for eachPrediction, eachProbability in zip(predictions, probabilities):
print(str(eachPrediction) + " : " + str(eachProbability))
return {'status': 'ok'}
def foo():
a=[]
prediction= CustomImagePrediction()
prediction.setModelTypeAsResNet()
prediction.setModelPath("model_ex-030_acc-0.996974.h5")
prediction.setJsonPath("model_class2.json")
prediction.loadModel(num_objects=13)
predictions, probabilities = prediction.predictImage("images/image.jpg", result_count=3)
for eachPrediction, eachProbability in zip(predictions, probabilities):
#print(eachPrediction , " : " , eachProbability)
a.append(eachPrediction)
return jsonify({"Your image result is here and solution has been sent via a mail": a[0]})
def detect_image(self, image):
from imageai.Prediction.Custom import CustomImagePrediction
execution_path = os.getcwd()
prediction = CustomImagePrediction()
prediction.setModelTypeAsResNet()
prediction.setModelPath(
os.path.join(execution_path,
"cone_color_keras/model_ex-100_acc-1.000000.h5"))
prediction.setJsonPath(
os.path.join(execution_path, "cone_color_keras/model_class_json"))
prediction.loadModel(num_objects=3)
start = timer()
if self.model_image_size != (None, None):
assert self.model_image_size[
0] % 32 == 0, 'Multiples of 32 required'
assert self.model_image_size[
1] % 32 == 0, 'Multiples of 32 required'
boxed_image = letterbox_image(
image,
tuple(reversed(self.model_image_size))) #letterbox()标准化尺寸？？
else:
new_image_size = (image.width - (image.width % 32),
image.height - (image.height % 32))
boxed_image = letterbox_image(image, new_image_size)
image_data = np.array(boxed_image, dtype='float32')
print(image_data.shape)
image_data /= 255.
image_data = np.expand_dims(image_data, 0) # Add batch dimension.
out_boxes, out_scores, out_classes = self.sess.run(
[self.boxes, self.scores, self.classes],
feed_dict={
self.yolo_model.input: image_data,
self.input_image_shape: [image.size[1], image.size[0]],
K.learning_phase(): 0
})
print('Found {} boxes for {}'.format(len(out_boxes), 'img'))
font = ImageFont.truetype(font='font/FiraMono-Medium.otf',
size=np.floor(3e-2 * image.size[1] +
0.5).astype('int32'))
thickness = (image.size[0] + image.size[1]) // 300
for i, c in reversed(list(enumerate(out_classes))):
predicted_class = self.class_names[c]
global Class
Class = c
box = out_boxes[i]
score = out_scores[i]
#label = '{} {:.2f}'.format(predicted_class, score)
draw = ImageDraw.Draw(image)
#label_size = draw.textsize(label, font)
top, left, bottom, right = box
top = max(0, np.floor(top + 0.5).astype('int32'))
left = max(0, np.floor(left + 0.5).astype('int32'))
bottom = min(image.size[1], np.floor(bottom + 0.5).astype('int32'))
right = min(image.size[0], np.floor(right + 0.5).astype('int32'))
#print(label, (left, top), (right, bottom))
image_to_detect_color = np.array(image)
image_to_detect_color = image_to_detect_color[left:right,
top:bottom]
predictions, probabilities = prediction.predictImage(
image_to_detect_color, result_count=3)
label = '{} {:.2f}'.format('blue cone', probabilities)
label_size = draw.textsize(label, font)
print(label, (left, top), (right, bottom))
#calculate distance to the cones
global locX, locY
locX = round((left + right) / 2)
locY = round(top + (bottom - top) * 0.8)
if top - label_size[1] >= 0:
text_origin = np.array([left, top - label_size[1]])
else:
text_origin = np.array([left, top + 1])
# My kingdom for a good redistributable image drawing library.
for i in range(thickness):
draw.ellipse(
((left + right) / 2, (top + (bottom - top) * 0.8), 5, 5),
fill=self.colors[c])
draw.rectangle([left + i, top + i, right - i, bottom - i],
outline=self.colors[c])
draw.rectangle(
[tuple(text_origin),
tuple(text_origin + label_size)],
fill=self.colors[c])
#draw.text(text_origin, label, fill=(0, 0, 0), font=font)
if predictions == 0:
label = '{} {:.2f}'.format('blue cone', probabilities)
draw.text(text_origin, label, fill=(0, 0, 0), font=font)
elif predictions == 1:
label = '{} {:.2f}'.format('red cone', probabilities)
draw.text(text_origin, label, fill=(0, 0, 0), font=font)
else:
label = '{} {:.2f}'.format('yellow cone', probabilities)
draw.text(text_origin, label, fill=(0, 0, 0), font=font)
del draw
end = timer()
print(end - start)
#import cv2
#cv2.imshow("detected",image)
return image
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# @Time : 2019/8/9 下午 08:55
# @Author : YuXin Chen
from imageai.Prediction.Custom import CustomImagePrediction
import os
prediction = CustomImagePrediction()
prediction.setModelTypeAsResNet()
prediction.setModelPath("./model/model_ex-075_acc-0.866071.h5")
prediction.setJsonPath("./model/model_class.json")
prediction.loadModel(num_objects=5)
predictions, probabilities = prediction.predictImage("./pic/test/tulips.jpg",
result_count=5)
for eachPrediction, eachProbability in zip(predictions, probabilities):
print(eachPrediction + " : " + eachProbability)
from imageai.Prediction.Custom import CustomImagePrediction
import os
# Load the model to use for prediction
predictor = CustomImagePrediction()
predictor.setModelPath(model_path="model_ex-035_acc-0.874667.h5")
predictor.setJsonPath(model_json="model_class.json")
predictor.loadFullModel(num_objects=5)
directory = "C:/Programs/Java/Computer-Vision-Team19/testing/"
ints = []
# Put the names of the image files into the array of ints
for file in os.listdir(directory):
filename = os.fsdecode(file)
if filename.endswith(".jpg"):
ints.append(int(filename.split(".", 1)[0]))
else:
print("Ignoring file named " + filename)
# Sort the filenames and print a newline
ints.sort()
print()
# Log prediction results to a file
log = open("../run3.txt", "w")
for i in ints:
filename = str(i) + ".jpg"
path = os.path.join(directory, filename)
prediction, probability = predictor.predictImage(image_input=path,
from imageai.Prediction.Custom import CustomImagePrediction
import os
import argparse
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--image", required=True, help="Path to the input image")
args = vars(ap.parse_args())
execution_path = os.getcwd()
#resnet_model_ex-020_acc-0.651714.h5
prediction = CustomImagePrediction()
prediction.setModelTypeAsSqueezeNet()
prediction.setModelPath(
os.path.join(execution_path, "CNN_models/model_ex-100_acc-0.817708.h5"))
prediction.setJsonPath(
os.path.join(execution_path,
"ImageAI_Custom_CNN/vehicles/json/model_class.json"))
prediction.loadModel(num_objects=3)
predictions, probabilities = prediction.predictImage(os.path.join(
execution_path, args["image"]),
result_count=2)
for eachPrediction, eachProbability in zip(predictions, probabilities):
if (eachPrediction == "truck"):
eachPrediction == "car"
print(eachPrediction, " : ", eachProbability)
#reshaping to a list of pixels
img = img.reshape((img.shape[0] * img.shape[1], 3))
#save image after operations
self.IMAGE = img
#using k-means to cluster pixels
kmeans = KMeans(n_clusters = self.CLUSTERS)
kmeans.fit(img)
#the cluster centers are our dominant colors.
self.COLORS = kmeans.cluster_centers_
#save labels
self.LABELS = kmeans.labels_
#returning after converting to integer from float
return self.COLORS.astype(int)
execution_path = os.getcwd()
prediction = CustomImagePrediction()
prediction.setModelTypeAsDenseNet()
prediction.setModelPath("model_ex-100_acc-0.829508.h5")
prediction.setJsonPath("model_class.json")
prediction.loadModel(num_objects=11)
map_to_classes= {
'team1left': '0',
'team1down': '1',
'team1up': '2',
'team1right': '3',
'team2left': '4',
'team2down': '5',
'team2up': '6',
'team2right': '7',
'Team1GoalAttack': '8',
from imageai.Prediction.Custom import CustomImagePrediction
import os
execution_path = os.getcwd()
prediction = CustomImagePrediction()
prediction.setModelTypeAsResNet()
prediction.setModelPath(os.path.join(execution_path, "resnet_model_ex-020_acc-0.651714.h5"))
prediction.setJsonPath(os.path.join(execution_path, "model_class.json"))
prediction.loadModel(num_objects=10)
predictions, probabilities = prediction.predictImage(os.path.join(execution_path, "4.jpg"), result_count=5)
for eachPrediction, eachProbability in zip(predictions, probabilities):
print(eachPrediction + " : " + eachProbability)
