def main():
"""
Run train and predict for the various Lorenz map prediction models with user
provided arguments. Assets are saved in the 'assets' folder in the project directory.
Models can be Conditional Wavenet-inspired (cw), Unconditional Wavenet-inspired (w),
Targets to predict are x (ts=0), y(ts=1), or z(ts=2) Lorenz trajectories.
"""
argparser = ArgParser()
options = argparser.parse_args()
data_generator = LorenzMapData(options)
train_data, test_data = data_generator.generate_train_test_sets()
# Train
trainer = Train(options)
train_iter = DIterators(options).build_iterator(train_data, for_train=True)
trainer.train(train_iter)
# Predict on test set and evaluate
predictor = Predict(options)
predict_iter = DIterators(options).build_iterator(test_data, for_train=False)
predictor.predict(predict_iter)
# Evaluate performance on test set
evaluator = Evaluate(options)
evaluator()
def _parse_arguments():
"""
Parse the command arguments.
Returns
-------
The command arguments as a dictionary : dict
"""
parser = ArgParser(description="A charting tool.")
group = parser.add_mutually_exclusive_group()
group.add_argument("--version", action="version", version=VERSION)
args = parser.parse_args()
return args
def handle_argument_commands(parser):
file_name = None
ar = ArgParser()
try:
file_name, commands = ar.parse_arguments()
for command in commands:
if command == 'parse tag1':
parser.parse_tag1(file_name)
elif command == 'parse tag2':
parser.parse_tag2(file_name)
elif command == 'parse':
parser.parse_file(file_name)
except Exception as e:
print(str(e))
return file_name
def create_training_dir(self):
# check if directory already exists
if os.path.exists(self.training_dir):
print(f"Training dir {self.training_dir} already exists..")
if os.path.exists(
os.path.join(self.training_dir, "best-checkpoint")):
print("Found pretrained model")
return False
else:
raise Exception(
f"Training dir {self.training_dir} already exists.. "
f"No pretrained model found...")
print(f"Current training directory for this run: {self.training_dir}")
os.makedirs(self.training_dir)
# save current hyper params to training dir
ArgParser.save_to_file(UserArgs, self.training_dir, self.model_name)
return True
def _parse_arguments():
"""
Parse the command arguments.
Returns
-------
The command arguments as a dictionary : dict
"""
parser = ArgParser(description="Test hardware responsiveness using IPMI commands.")
parser.add_argument("config-file", help="The name of test configuration file.")
parser.add_argument("--verbose-logging", action="store_true")
parser.add_argument("--version", action="version", version=VERSION)
args = parser.parse_args()
return args
def main():
parser = ArgParser()
args = parser.parse_args()
gen = Generator(args.latent_dim).to(args.device)
disc = Discriminator().to(args.device)
if args.device != 'cpu':
gen = nn.DataParallel(gen, args.gpu_ids)
disc = nn.DataParallel(disc, args.gpu_ids)
# gen = gen.apply(weights_init)
# disc = disc.apply(weights_init)
gen_opt = torch.optim.RMSprop(gen.parameters(), lr=args.lr)
disc_opt = torch.optim.RMSprop(disc.parameters(), lr=args.lr)
gen_scheduler = torch.optim.lr_scheduler.LambdaLR(gen_opt, lr_lambda=lr_lambda(args.num_epochs))
disc_scheduler = torch.optim.lr_scheduler.LambdaLR(disc_opt, lr_lambda=lr_lambda(args.num_epochs))
disc_loss_fn = DiscriminatorLoss().to(args.device)
gen_loss_fn = GeneratorLoss().to(args.device)
# dataset = Dataset()
dataset = MNISTDataset()
loader = DataLoader(dataset, batch_size=args.batch_size, num_workers=args.num_workers)
logger = TrainLogger(args, len(loader), phase=None)
logger.log_hparams(args)
if args.privacy_noise_multiplier != 0:
privacy_engine = PrivacyEngine(
disc,
batch_size=args.batch_size,
sample_size=len(dataset),
alphas=[1 + x / 10.0 for x in range(1, 100)] + list(range(12, 64)),
noise_multiplier=.8,
max_grad_norm=0.02,
batch_first=True,
)
privacy_engine.attach(disc_opt)
privacy_engine.to(args.device)
for epoch in range(args.num_epochs):
logger.start_epoch()
for cur_step, img in enumerate(tqdm(loader, dynamic_ncols=True)):
logger.start_iter()
img = img.to(args.device)
fake, disc_loss = None, None
for _ in range(args.step_train_discriminator):
disc_opt.zero_grad()
fake_noise = get_noise(args.batch_size, args.latent_dim, device=args.device)
fake = gen(fake_noise)
disc_loss = disc_loss_fn(img, fake, disc)
disc_loss.backward()
disc_opt.step()
gen_opt.zero_grad()
fake_noise_2 = get_noise(args.batch_size, args.latent_dim, device=args.device)
fake_2 = gen(fake_noise_2)
gen_loss = gen_loss_fn(img, fake_2, disc)
gen_loss.backward()
gen_opt.step()
if args.privacy_noise_multiplier != 0:
epsilon, best_alpha = privacy_engine.get_privacy_spent(args.privacy_delta)
logger.log_iter_gan_from_latent_vector(img, fake, gen_loss, disc_loss, epsilon if args.privacy_noise_multiplier != 0 else 0)
logger.end_iter()
logger.end_epoch()
gen_scheduler.step()
disc_scheduler.step()
from mirrors_manager import MirrorsManager
from arg_parser import ArgParser
from logger import Logger
logger = Logger(__name__)
logger = logger.logger
args = ArgParser().parse_args()
logger.debug(f'Args which were received are:\n{args}')
mirrors_manager = MirrorsManager(args)
mirrors_manager.run()
@app.route('/setall', methods=['POST'])
def set_all():
color = request.args.get('color')
if color == 'red':
pixelservice.set_all(200, 0, 0)
else:
r = request.args.get('r') or 0
g = request.args.get('g') or 0
b = request.args.get('b') or 0
pixelservice.set_all(int(r), int(g), int(b))
return "OK"
@app.route('/setpattern', methods=['POST'])
def set_pattern():
name = request.args.get('name')
if not name:
return 'invalid pattern name', 400
pixelservice.set_pattern(name)
return "OK"
if __name__ == '__main__':
args = ArgParser(DESCRIPTION).parse_args()
host = args.host if args.host else None
pixelservice = PixelService(NUM_PIXELS)
pixelservice.start_displayer(args.device)
app.run(host)
#!/usr/bin/python from arg_parser import ArgParser from loader import Loader if __name__ == '__main__': arg_parser = ArgParser() options = arg_parser.get_options() loader = Loader(options) if loader.error: print loader.error_message exit(1)
def main():
arg_parser = ArgParser()
args = arg_parser.get_args()
input_file = args.input
# If input file defined then use it else use the webcam
if input_file:
if not os.path.isfile(input_file):
log.error("Input file cannot be found")
exit()
input_feeder = InputFeeder("video", input_file)
else:
input_feeder = InputFeeder("cam")
face_detection_model = FaceDetection(args.face_detection_model,
args.device, args.extensions)
face_detection_model.load_model()
facial_landmarks_model = FacialLandmarksDetection(
args.facial_landmark_detection_model, args.device, args.extensions)
facial_landmarks_model.load_model()
gaze_model = GazeEstimation(args.gaze_estimation_model, args.device,
args.extensions)
gaze_model.load_model()
head_pose_model = HeadPoseEstimation(args.head_pose_estimation_model,
args.device, args.extensions)
head_pose_model.load_model()
mouse_controller = MouseController('medium', 'fast')
input_feeder.load_data()
frame_count = 0
total_face_detection_inference_time = 0
total_facial_landmark_inference_time = 0
total_head_pose_inference_time = 0
total_gaze_estimation_inference_time = 0
total_inference_time = 0
for ret, frame in input_feeder.next_batch():
if not ret:
log.error("ret variable not found")
break
frame_count += 1
if frame_count % args.mouse_update_interval == 0:
cv2.imshow('Input', frame)
key_pressed = cv2.waitKey(60)
# Run inference on the face detection model
start_time = time.time()
cropped_face, face_coordinates = face_detection_model.predict(
frame.copy(), args.probability_threshold)
finish_time = time.time()
total_face_detection_inference_time += finish_time - start_time
total_inference_time += finish_time - start_time
# If no face detected get the next frame
if len(face_coordinates) == 0:
continue
# Run inference on the facial landmark detection model
start_time = time.time()
results = facial_landmarks_model.predict(cropped_face.copy())
finish_time = time.time()
left_eye_coordinates = results[0]
right_eye_coordinates = results[1]
left_eye_image = results[2]
right_eye_image = results[3]
left_eye_crop_coordinates = results[4]
right_eye_crop_coordinates = results[5]
total_facial_landmark_inference_time += finish_time - start_time
total_inference_time += finish_time - start_time
# Run inference on the head pose estimation model
start_time = time.time()
head_pose = head_pose_model.predict(cropped_face.copy())
finish_time = time.time()
total_head_pose_inference_time += finish_time - start_time
total_inference_time += finish_time - start_time
# Run inference on the gaze estimation model
start_time = time.time()
new_mouse_x_coordinate, new_mouse_y_coordinate, gaze_vector = gaze_model.predict(
left_eye_image, right_eye_image, head_pose)
finish_time = time.time()
total_gaze_estimation_inference_time += finish_time - start_time
total_inference_time += finish_time - start_time
if frame_count % args.mouse_update_interval == 0:
log.info("Mouse controller new coordinates: x = {}, y = {}".format(
new_mouse_x_coordinate, new_mouse_y_coordinate))
mouse_controller.move(new_mouse_x_coordinate,
new_mouse_y_coordinate)
# Optional visualization configuration:
if args.show_detected_face:
showDetectedFace(frame, face_coordinates)
if args.show_head_pose:
showHeadPose(frame, head_pose)
if args.show_facial_landmarks:
showFacialLandmarks(cropped_face, left_eye_crop_coordinates,
right_eye_crop_coordinates)
if args.show_gaze_estimation:
showGazeEstimation(frame, right_eye_coordinates,
left_eye_coordinates, gaze_vector,
cropped_face, face_coordinates)
# Break if escape key pressed
if key_pressed == 27:
log.warning("Keyboard interrupt triggered")
break
# Release the capture and destroy any OpenCV windows
cv2.destroyAllWindows()
input_feeder.close()
log.info("Average face detection inference time: {} seconds".format(
total_face_detection_inference_time / frame_count))
log.info(
"Average facial landmark detection inference time: {} seconds".format(
total_facial_landmark_inference_time / frame_count))
log.info("Average head pose estimation inference time: {} seconds".format(
total_head_pose_inference_time / frame_count))
log.info("Average gaze estimation inference time: {} seconds".format(
total_gaze_estimation_inference_time / frame_count))
log.info("Average total inference time: {} seconds".format(
total_inference_time / frame_count))
def create_arg_parser(self):
if (self._arg_parser == None):
self._arg_parser = ArgParser(self)
return self._arg_parser
else:
return self._arg_parser
def execute_command(self, storage, input_data):
str_command, arg1, arg2 = ArgParser.parse_args(input_data)
try:
return self.handle_command(str_command, storage, arg1, arg2)
except KeyError:
return 'Error with input data'