def __init__(self, labels):
base_dir = os.environ.get("MODEL_PATH",
"/opt/nuclio/open_model_zoo/intel/text-detection-0004/FP32")
model_xml = os.path.join(base_dir, "text-detection-0004.xml")
model_bin = os.path.join(base_dir, "text-detection-0004.bin")
self.model = ModelLoader(model_xml, model_bin)
self.labels = labels
def main():
loader = ModelLoader(SERIALIZED_DATA_PATH)
xgb_clf, rf_clf, train, test, daily_metrics = loader.assemble_serialized_data(
).values()
dashboard = ManagementDashboard(xgb_clf, rf_clf, train, test,
daily_metrics)
dashboard.run()
def __init__(self, labels):
base_dir = os.environ.get("MODEL_PATH",
"/opt/nuclio/open_model_zoo/public/yolo-v3-tf/FP32")
model_xml = os.path.join(base_dir, "yolo-v3-tf.xml")
model_bin = os.path.join(base_dir, "yolo-v3-tf.bin")
self.model = ModelLoader(model_xml, model_bin)
self.labels = labels
def __init__(self, labels):
base_dir = os.environ.get("MODEL_PATH",
"/opt/nuclio/open_model_zoo/public/mask_rcnn_inception_resnet_v2_atrous_coco/FP32")
model_xml = os.path.join(base_dir, "mask_rcnn_inception_resnet_v2_atrous_coco.xml")
model_bin = os.path.join(base_dir, "mask_rcnn_inception_resnet_v2_atrous_coco.bin")
self.model = ModelLoader(model_xml, model_bin)
self.labels = labels
def __init__(self, labels):
base_dir = os.path.abspath(os.environ.get("MODEL_PATH",
"/opt/nuclio/open_model_zoo/public/faster_rcnn_inception_v2_coco/FP32"))
model_xml = os.path.join(base_dir, "faster_rcnn_inception_v2_coco.xml")
model_bin = os.path.join(base_dir, "faster_rcnn_inception_v2_coco.bin")
self.model = ModelLoader(model_xml, model_bin)
self.labels = labels
class AttributesExtractorHandler:
def __init__(self):
age_gender_base_dir = os.path.abspath(os.environ.get("AGE_GENDER_MODEL_PATH",
"/opt/nuclio/open_model_zoo/intel/age-gender-recognition-retail-0013/FP32"))
age_gender_model_xml = os.path.join(age_gender_base_dir, "age-gender-recognition-retail-0013.xml")
age_gender_model_bin = os.path.join(age_gender_base_dir, "age-gender-recognition-retail-0013.bin")
self.age_gender_model = ModelLoader(age_gender_model_xml, age_gender_model_bin)
emotions_base_dir = os.path.abspath(os.environ.get("EMOTIONS_MODEL_PATH",
"/opt/nuclio/open_model_zoo/intel/emotions-recognition-retail-0003/FP32"))
emotions_model_xml = os.path.join(emotions_base_dir, "emotions-recognition-retail-0003.xml")
emotions_model_bin = os.path.join(emotions_base_dir, "emotions-recognition-retail-0003.bin")
self.emotions_model = ModelLoader(emotions_model_xml, emotions_model_bin)
self.genders_map = ["female", "male"]
self.emotions_map = ["neutral", "happy", "sad", "surprise", "anger"]
def infer(self, image):
age_gender_request = self.age_gender_model.async_infer(image)
emotions_request = self.emotions_model.async_infer(image)
# Wait until both age_gender and emotion recognition async inferences finish
while not (age_gender_request.wait(0) == 0 and emotions_request.wait(0) == 0):
continue
age = int(np.squeeze(age_gender_request.output_blobs["age_conv3"].buffer) * 100)
gender = self.genders_map[np.argmax(np.squeeze(age_gender_request.output_blobs["prob"].buffer))]
emotion = self.emotions_map[np.argmax(np.squeeze(emotions_request.output_blobs['prob_emotion'].buffer))]
return {"attributes": [
{"name": "age", "value": str(age)},
{"name": "gender", "value": gender},
{"name": "emotion", "value": emotion}
]}
def load_models(self, model_list):
"""Handles deployed model for init"""
self.logger.debug('Update models received with payload: %s',
str(model_list))
model_loader = ModelLoader(self.client_config)
models_to_load = model_list
self.models_loaded = model_loader.get_models_from_list(models_to_load)
#model_list=[["HelloWorldExample", "1.0.0"],["HelloAI2", "1.0.0"],["TensorflowMnistExample","1.0.0"],['fib_model',"1.0.2"]]
return json.dumps({"Init Model Service": "Success"})
class ModelHandler:
def __init__(self, labels):
base_dir = os.path.abspath(
os.environ.get(
"MODEL_PATH",
"/opt/nuclio/open_model_zoo/public/yolo-v3-tf/FP32"))
model_xml = os.path.join(base_dir, "yolo-v3-tf.xml")
model_bin = os.path.join(base_dir, "yolo-v3-tf.bin")
self.model = ModelLoader(model_xml, model_bin)
self.labels = labels
def infer(self, image, threshold):
output_layer = self.model.infer(image)
# Collecting object detection results
objects = []
origin_im_size = (image.height, image.width)
for layer_name, out_blob in output_layer.items():
out_blob = out_blob.reshape(self.model.layers[
self.model.layers[layer_name].parents[0]].shape)
layer_params = YoloParams(self.model.layers[layer_name].params,
out_blob.shape[2])
objects += parse_yolo_region(out_blob, self.model.input_size(),
origin_im_size, layer_params,
threshold)
# Filtering overlapping boxes (non-maximum suppression)
IOU_THRESHOLD = 0.4
objects = sorted(objects,
key=lambda obj: obj['confidence'],
reverse=True)
for i, obj in enumerate(objects):
if obj['confidence'] == 0:
continue
for j in range(i + 1, len(objects)):
if intersection_over_union(obj, objects[j]) > IOU_THRESHOLD:
objects[j]['confidence'] = 0
results = []
for obj in objects:
if obj['confidence'] >= threshold:
xtl = max(obj['xmin'], 0)
ytl = max(obj['ymin'], 0)
xbr = min(obj['xmax'], image.width)
ybr = min(obj['ymax'], image.height)
obj_class = int(obj['class_id'])
results.append({
"confidence": str(obj['confidence']),
"label": self.labels.get(obj_class, "unknown"),
"points": [xtl, ytl, xbr, ybr],
"type": "rectangle",
})
return results
def __init__(self):
base_dir = os.environ.get(
"MODEL_PATH",
"/opt/nuclio/open_model_zoo/intel/person-reidentification-retail-0300/FP32"
)
model_xml = os.path.join(base_dir,
"person-reidentification-retail-0300.xml")
model_bin = os.path.join(base_dir,
"person-reidentification-retail-0300.bin")
self.model = ModelLoader(model_xml, model_bin)
def __init__(self, labels):
base_dir = os.path.abspath(
os.environ.get(
"MODEL_PATH",
"/opt/nuclio/open_model_zoo/intel/semantic-segmentation-adas-0001/FP32"
))
model_xml = os.path.join(base_dir,
"semantic-segmentation-adas-0001.xml")
model_bin = os.path.join(base_dir,
"semantic-segmentation-adas-0001.bin")
self.model = ModelLoader(model_xml, model_bin)
self.labels = labels
def main():
loader = ModelLoader(SERIALIZED_DATA_PATH)
(xgb_clf_name, rf_clf_name, importances, daily_metrics, train_tsne,
test_tsne, model_probas, score_distributions_train,
score_distributions_test,
curves) = loader.assemble_serialized_data().values()
analysis_dashboard = AnalysisDashboard(xgb_clf_name, rf_clf_name,
importances, daily_metrics,
train_tsne, test_tsne, model_probas,
score_distributions_train,
score_distributions_test, curves)
analysis_dashboard.run()
def __init__(self):
age_gender_base_dir = os.path.abspath(os.environ.get("AGE_GENDER_MODEL_PATH",
"/opt/nuclio/open_model_zoo/intel/age-gender-recognition-retail-0013/FP32"))
age_gender_model_xml = os.path.join(age_gender_base_dir, "age-gender-recognition-retail-0013.xml")
age_gender_model_bin = os.path.join(age_gender_base_dir, "age-gender-recognition-retail-0013.bin")
self.age_gender_model = ModelLoader(age_gender_model_xml, age_gender_model_bin)
emotions_base_dir = os.path.abspath(os.environ.get("EMOTIONS_MODEL_PATH",
"/opt/nuclio/open_model_zoo/intel/emotions-recognition-retail-0003/FP32"))
emotions_model_xml = os.path.join(emotions_base_dir, "emotions-recognition-retail-0003.xml")
emotions_model_bin = os.path.join(emotions_base_dir, "emotions-recognition-retail-0003.bin")
self.emotions_model = ModelLoader(emotions_model_xml, emotions_model_bin)
self.genders_map = ["female", "male"]
self.emotions_map = ["neutral", "happy", "sad", "surprise", "anger"]
class ModelHandler:
def __init__(self, labels):
base_dir = os.path.abspath(os.environ.get("MODEL_PATH",
"/opt/nuclio/open_model_zoo/public/faster_rcnn_inception_v2_coco/FP32"))
model_xml = os.path.join(base_dir, "faster_rcnn_inception_v2_coco.xml")
model_bin = os.path.join(base_dir, "faster_rcnn_inception_v2_coco.bin")
self.model = ModelLoader(model_xml, model_bin)
self.labels = labels
def infer(self, image, threshold):
output_layer = self.model.infer(image)
results = []
prediction = output_layer[0][0]
for obj in prediction:
obj_class = int(obj[1])
obj_value = obj[2]
obj_label = self.labels.get(obj_class, "unknown")
if obj_value >= threshold:
xtl = obj[3] * image.width
ytl = obj[4] * image.height
xbr = obj[5] * image.width
ybr = obj[6] * image.height
results.append({
"confidence": str(obj_value),
"label": obj_label,
"points": [xtl, ytl, xbr, ybr],
"type": "rectangle",
})
return results
class ModelHandler:
def __init__(self, labels):
base_dir = os.path.abspath(
os.environ.get(
"MODEL_PATH",
"/opt/nuclio/open_model_zoo/intel/text-detection-0004/FP32"))
model_xml = os.path.join(base_dir, "text-detection-0004.xml")
model_bin = os.path.join(base_dir, "text-detection-0004.bin")
self.model = ModelLoader(model_xml, model_bin)
self.labels = labels
def infer(self, image, pixel_threshold, link_threshold):
output_layer = self.model.infer(image)
results = []
obj_class = 1
pcd = PixelLinkDecoder(pixel_threshold, link_threshold)
pcd.decode(image.height, image.width, output_layer)
for box in pcd.bboxes:
results.append({
"confidence": None,
"label": self.labels.get(obj_class, "unknown"),
"points": box.ravel().tolist(),
"type": "polygon",
})
return results
class FaceDetectorHandler:
def __init__(self):
base_dir = os.path.abspath(os.environ.get("DETECTOR_MODEL_PATH",
"/opt/nuclio/open_model_zoo/intel/face-detection-0205/FP32"))
model_xml = os.path.join(base_dir, "face-detection-0205.xml")
model_bin = os.path.join(base_dir, "face-detection-0205.bin")
self.model = ModelLoader(model_xml, model_bin)
def infer(self, image, threshold):
infer_res = self.model.infer(image)["boxes"]
infer_res = infer_res[infer_res[:,4] > threshold]
results = []
faces = []
h_scale = image.height / 416
w_scale = image.width / 416
for face in infer_res:
xmin = int(face[0] * w_scale)
ymin = int(face[1] * h_scale)
xmax = int(face[2] * w_scale)
ymax = int(face[3] * h_scale)
confidence = face[4]
faces.append(np.array(image)[ymin:ymax, xmin:xmax])
results.append({
"confidence": str(confidence),
"label": "face",
"points": [xmin, ymin, xmax, ymax],
"type": "rectangle",
"attributes": []
})
return results, faces
def __init__(self):
np.random.seed(0)
self.model_obj = ModelLoader().load()
self.model = self.model_obj.model
self.mappings = self.model_obj.mappings
self.ratings = self.model_obj.ratings
self.movies = self.model_obj.movies
self.preparePopularMovies()
def init_context(context):
context.logger.info("Init context... 0%")
model_path = "/opt/nuclio/faster_rcnn/frozen_inference_graph.pb"
model_handler = ModelLoader(model_path)
setattr(context.user_data, 'model_handler', model_handler)
functionconfig = yaml.safe_load(open("/opt/nuclio/function.yaml"))
labels_spec = functionconfig['metadata']['annotations']['spec']
labels = {item['id']: item['name'] for item in json.loads(labels_spec)}
setattr(context.user_data, "labels", labels)
context.logger.info("Init context...100%")
def init_context(context):
context.logger.info("Init context... 0%")
model_path = "/opt/nuclio/efficientdet-d0.pth"
functionconfig = yaml.safe_load(open("/opt/nuclio/function.yaml"))
labels_spec = functionconfig['metadata']['annotations']['spec']
labels = {str(item['id']): item['name'] for item in json.loads(labels_spec)}
model_handler = ModelLoader(model_path, labels)
setattr(context.user_data, 'model_handler', model_handler)
setattr(context.user_data, "labels", labels)
context.logger.info("Init context...100%")
def init_context(context):
context.logger.info("Init context... 0%")
functionconfig = yaml.safe_load(open("/opt/nuclio/function.yaml"))
labels_spec = functionconfig['metadata']['annotations']['spec']
labels = {item['id']: item['name'] for item in json.loads(labels_spec)}
model_handler = ModelLoader(labels)
setattr(context.user_data, 'model_handler', model_handler)
context.logger.info("Init context...100%")
def __init__(self, width, height):
pg.init()
self.W = width
self.H = height
self.screen = pg.display.set_mode((self.W, self.H))
self.running = True
self.scl = 40
self.cols = self.W // self.scl
self.rows = self.H // self.scl
self.grid = [[0 for i in range(self.cols)] for j in range(self.rows)]
self.ip = ImageProcessor()
self.model = ModelLoader('model/trained_model_2.pt').load_model()
def init_context(context):
context.logger.info("Init context... 0%")
with open("/opt/nuclio/function.yaml", 'rb') as function_file:
functionconfig = yaml.safe_load(function_file)
labels_spec = functionconfig['metadata']['annotations']['spec']
labels = {item['id']: item['name'] for item in json.loads(labels_spec)}
model_handler = ModelLoader(labels)
context.user_data.model_handler = model_handler
context.logger.info("Init context...100%")
def init_context(context):
context.logger.info("Init context... 0%")
model_path = "/opt/nuclio/faster_rcnn/frozen_inference_graph.pb"
model_handler = ModelLoader(model_path)
context.user_data.model_handler = model_handler
with open("/opt/nuclio/function.yaml", 'rb') as function_file:
functionconfig = yaml.safe_load(function_file)
labels_spec = functionconfig['metadata']['annotations']['spec']
labels = {item['id']: item['name'] for item in json.loads(labels_spec)}
context.user_data.labels = labels
context.logger.info("Init context...100%")
class ModelHandler:
def __init__(self, labels):
base_dir = os.path.abspath(
os.environ.get(
"MODEL_PATH",
"/opt/nuclio/open_model_zoo/public/mask_rcnn_inception_resnet_v2_atrous_coco/FP32"
))
model_xml = os.path.join(
base_dir, "mask_rcnn_inception_resnet_v2_atrous_coco.xml")
model_bin = os.path.join(
base_dir, "mask_rcnn_inception_resnet_v2_atrous_coco.bin")
self.model = ModelLoader(model_xml, model_bin)
self.labels = labels
def infer(self, image, threshold):
output_layer = self.model.infer(image)
results = []
masks = output_layer['masks']
boxes = output_layer['reshape_do_2d']
for index, box in enumerate(boxes):
obj_class = int(box[1])
obj_value = box[2]
obj_label = self.labels.get(obj_class, "unknown")
if obj_value >= threshold:
xtl = box[3] * image.width
ytl = box[4] * image.height
xbr = box[5] * image.width
ybr = box[6] * image.height
mask = masks[index][obj_class - 1]
mask = segm_postprocess((xtl, ytl, xbr, ybr), mask,
image.height, image.width)
contours = find_contours(mask, MASK_THRESHOLD)
contour = contours[0]
contour = np.flip(contour, axis=1)
contour = approximate_polygon(contour, tolerance=2.5)
if len(contour) < 3:
continue
results.append({
"confidence": str(obj_value),
"label": obj_label,
"points": contour.ravel().tolist(),
"type": "polygon",
})
return results
class ModelHandler:
def __init__(self, labels):
base_dir = os.path.abspath(
os.environ.get(
"MODEL_PATH",
"/opt/nuclio/open_model_zoo/intel/semantic-segmentation-adas-0001/FP32"
))
model_xml = os.path.join(base_dir,
"semantic-segmentation-adas-0001.xml")
model_bin = os.path.join(base_dir,
"semantic-segmentation-adas-0001.bin")
self.model = ModelLoader(model_xml, model_bin)
self.labels = labels
def infer(self, image, threshold):
output_layer = self.model.infer(image)
results = []
mask = output_layer[0, 0, :, :]
width, height = mask.shape
for i in range(len(self.labels)):
mask_by_label = np.zeros((width, height), dtype=np.uint8)
mask_by_label = ((mask == float(i)) * 255).astype(np.float32)
mask_by_label = cv2.resize(mask_by_label,
dsize=(image.width, image.height),
interpolation=cv2.INTER_CUBIC)
contours = find_contours(mask_by_label, 0.8)
for contour in contours:
contour = np.flip(contour, axis=1)
contour = approximate_polygon(contour, tolerance=2.5)
if len(contour) < 3:
continue
results.append({
"confidence": None,
"label": self.labels.get(i, "unknown"),
"points": contour.ravel().tolist(),
"type": "polygon",
})
return results
def __init__(self, method=const.METHOD_ORB, use_video=False):
self._window = Window(const.WINDOW_NAME, self.on_keypress)
self._frame = None
self._model = ModelLoader(const.MODEL_PATH, swap_yz=True)
self._img_marker = cv2.imread(const.MARKER_PATH, cv2.IMREAD_GRAYSCALE)
self._img_marker_2 = cv2.imread(const.MARKER_PATH_HIRO,
cv2.IMREAD_GRAYSCALE)
self._method = method
self._capture_controller = CaptureController(
capture=self._get_capture_source(use_video),
window_manager=self._window,
mirror_preview=True,
)
self._filter = None
self._draw_contours = False
self._draw_lines = False
self._draw_corners = False
def main():
"""Run Prediction"""
# Measures total program runtime by collecting start time
start_time = time.time()
# get input args
in_arg = get_input_args()
# Function that checks command line arguments using in_arg
print_command_line_arguments(in_arg)
print()
# get dataloader to load labels and process image
dataloader = ModelDataLoader('data')
category_names = dataloader.get_label_dict(in_arg.category_names)
# use modelloader to load checkpoint
loader = ModelLoader(in_arg.checkpoint_dir)
if loader.checkpoint_exists(in_arg.checkpoint):
print("Loading checkpoint %s" %
(loader.get_checkpoint_path(in_arg.checkpoint)))
model = loader.load_checkpoint(
in_arg.checkpoint, model_use_gpu=in_arg.gpu, with_trainer=False)
else:
print("Checkpoint '%s' does not exist. Exiting." %
(loader.get_checkpoint_path(in_arg.checkpoint)))
return
print()
# convert image
image = dataloader.process_image(in_arg.image)
# run prediction
probs, classes = model.predict(image, in_arg.top_k)
labels = [category_names[c] for c in classes]
for prob, clas, label in zip(probs, classes, labels):
print("%5.3f%% %s [%s]" % (prob*100, label, clas))
print()
print("Total Prediction Duration: %.3fs" % (time.time() - start_time))
dataloader_task1 = torch.utils.data.DataLoader(labeled_trainset_task1,
batch_size=1,
shuffle=False,
num_workers=0)
# For road map task
labeled_trainset_task2 = LabeledDataset(image_folder=image_folder,
annotation_file=annotation_csv,
scene_index=labeled_scene_index,
transform=get_transform_task2(),
extra_info=False)
dataloader_task2 = torch.utils.data.DataLoader(labeled_trainset_task2,
batch_size=1,
shuffle=False,
num_workers=0)
model_loader = ModelLoader()
total = 0
total_ats_bounding_boxes = 0
total_ts_road_map = 0
with torch.no_grad():
for i, data in enumerate(dataloader_task1):
total += 1
sample, target, road_image = data
sample = sample.cuda()
predicted_bounding_boxes = model_loader.get_bounding_boxes(
sample)[0].cpu()
ats_bounding_boxes, iou_max = compute_ats_bounding_boxes(
predicted_bounding_boxes, target['bounding_box'][0])
total_ats_bounding_boxes += ats_bounding_boxes
import pandas as pd
from flask import Flask, request
from gevent.pywsgi import WSGIServer
from bayes_classifier import NaiveBayes
from model_loader import ModelLoader
from regression import Regression
app = Flask(__name__)
naive = {'male': NaiveBayes('data/male_data_0.csv'), 'female': NaiveBayes('data/female_data_0.csv')}
best_model = {
'male': ModelLoader('models/male_best_model_10_06_2019_02_10_09.joblib'),
'female': ModelLoader('models/female_best_model_10_06_2019_02_26_36.joblib')
}
model02 = {
'male': Regression('data/male_data_0.csv'),
'female': Regression('data/female_data_0.csv')
}
model03 = {
'male': ModelLoader('models/best_model_10_05_2019_22_13_28.joblib'),
# 'female': ModelLoader('models/')
}
@app.after_request
def after_request(response):
header = response.headers
header['Access-Control-Allow-Origin'] = '*'
header['Access-Control-Allow-Headers'] = '*'
return response
import requests
import hunch_server
import yaml
hunch_server_config = {}
if 'HUNCH_CONFIG' in os.environ:
if os.path.exists(os.environ['HUNCH_CONFIG']):
with open(os.environ['HUNCH_CONFIG']) as f:
hunch_server_config = yaml.load(f)
ROTATION_FILE_PATH = hunch_server_config["rotation_status_file"]
app = Flask(__name__)
app.logger_name = "hunch.app"
models_loaded = {}
model_loader = ModelLoader(hunch_server_config)
try:
if 'MODELS_TO_LOAD' in os.environ:
models_to_load = json.loads(os.environ['MODELS_TO_LOAD'])
models_loaded = model_loader.get_models_from_list(models_to_load)
except requests.exceptions.HTTPError as e:
app.logger.error("Meta Service has thrown %s, the error is %s and stack trace is %s"
%(e.response.status_code, e.message, str(traceback.format_exc())))
raise RuntimeError("Meta Service has thrown '{}' , the error is {} and stack trace is {}".format(e.response.status_code, e.message, str(traceback.format_exc())))
app.logger.info("Loaded models are: " + json.dumps(models_loaded.keys()))
@app.route('/elb-healthcheck', methods=['GET'])
def elb_healthcheck():
try:
def main():
"""Run Training Session"""
# Measures total program runtime by collecting start time
start_time = time.time()
# get input args
in_arg = get_input_args()
# Function that checks command line arguments using in_arg
print_command_line_arguments(in_arg)
print()
# load datasets
dataloader = ModelDataLoader(in_arg.data_dir)
train_dataset, train_dataloader = dataloader.get_train_data()
valid_dataset, valid_dataloader = dataloader.get_validation_data()
test_dataset, test_dataloader = dataloader.get_test_data()
# Use model loader to load existing checkpoint
loader = ModelLoader(in_arg.checkpoint_dir)
if loader.checkpoint_exists(in_arg.checkpoint):
# load checkpoint
print("Loading checkpoint %s" %
(loader.get_checkpoint_path(in_arg.checkpoint)))
model, trainer = loader.load_checkpoint(
in_arg.checkpoint, model_use_gpu=in_arg.gpu)
print("Epochs trained so far: %d" % (trainer.trained_epochs))
else:
# no checkpoint, create fresh model using input arguments
print("Checkpoint '%s' does not exist" %
(loader.get_checkpoint_path(in_arg.checkpoint)))
model = Model(train_dataset.class_to_idx,
arch=in_arg.arch, use_gpu=in_arg.gpu,
hidden_units_1=in_arg.hidden_units_1, hidden_units_2=in_arg.hidden_units_2,
dropout_1=in_arg.dropout_1, dropout_2=in_arg.dropout_2)
trainer = ModelTrainer(model, learning_rate=in_arg.learning_rate)
print()
print("Model training in session...")
print()
epochs = in_arg.epochs
# train model and print results
for result in trainer.train_epochs(epochs, train_dataloader, valid_dataloader):
print(
"Epoch: %3d/%3d" % (result['epoch']+1, epochs),
" | Train Loss: %10.5f" % (result['train_loss']),
" | Validation Loss: %10.5f" % (result['validation_loss']),
" | Validation Acc: %6.3f%%" % (
result['validation_accuracy'] * 100),
" | Duration: %10.3fs" % (result['duration'])
)
print()
print("Testing model against test data...")
print()
# test model against test data
test_result = trainer.test(test_dataloader)
print(
"Test Loss: %10.5f" % (test_result['test_loss']),
" | Test Acc: %6.3f%%" % (test_result['test_accuracy'] * 100),
" | Duration: %10.3fs" % (test_result['duration'])
)
# save checkpoint
loader.save_checkpoint(in_arg.checkpoint, model, trainer)
print()
print("Total Train Duration: %.3fs" % (time.time() - start_time))
from flask import Flask
from flask.blueprints import Blueprint
from flask_cors import CORS
import config
import routes
from model_loader import ModelLoader
server = Flask(__name__)
if config.ENABLE_CORS:
cors = CORS(server, resources={r"/api/*": {"origins": "*"}})
for blueprint in vars(routes).values():
if isinstance(blueprint, Blueprint):
server.register_blueprint(blueprint, url_prefix=config.API_URL_PREFIX)
if __name__ == "__main__":
#print("server details",server.url_map)
server.run(host=config.HOST, port=config.PORT, debug=True)
ModelLoader()
