def main(is_user: bool = False): """ """ global LOG_WRITER if is_user: LOG_WRITER = LogWriter( ensure_existence(PROJECT_APP_PATH.user_log) / f"{PROJECT_NAME}_publisher.log" ) else: LOG_WRITER = LogWriter( ensure_existence(PROJECT_APP_PATH.site_log) / f"{PROJECT_NAME}_publisher.log" ) LOG_WRITER.open() client = mqtt.Client() client.on_publish = on_publish client.on_disconnect = on_disconnect HEIMDALLR_SETTINGS = HeimdallrSettings() # TODO input scope client.username_pw_set( HEIMDALLR_SETTINGS.mqtt_username, HEIMDALLR_SETTINGS.mqtt_password ) try: client.connect( HEIMDALLR_SETTINGS.mqtt_broker, HEIMDALLR_SETTINGS.mqtt_port, keepalive=60 ) except ValueError as ve: raise ValueError( f"{HEIMDALLR_SETTINGS._mqtt_settings_path}," f"{HEIMDALLR_SETTINGS.mqtt_broker}," f"{HEIMDALLR_SETTINGS.mqtt_port}," f"{ve}" ) client.loop_start() sensor_data = NOD({HOSTNAME: pull_gpu_info()}) next_reading = time.time() with IgnoreInterruptSignal(): print("Publisher started") for _ in busy_indicator(): sensor_data[HOSTNAME] = pull_gpu_info() s = sensor_data.as_dict() s = json.dumps(s) client.publish(ALL_CONSTANTS.MQTT_TOPIC, s, ALL_CONSTANTS.MQTT_QOS) next_reading += ALL_CONSTANTS.MQTT_PUBLISH_INTERVAL_SEC sleep_time = next_reading - time.time() if sleep_time > 0: time.sleep(sleep_time) # noinspection PyUnreachableCode LOG_WRITER.close() client.loop_stop() client.disconnect()
def main(setting_scope: SettingScopeEnum = SettingScopeEnum.user): """ """ global LOG_WRITER if setting_scope == SettingScopeEnum.user: LOG_WRITER = LogWriter( ensure_existence(PROJECT_APP_PATH.user_log) / f"{PROJECT_NAME}_publisher.log") else: LOG_WRITER = LogWriter( ensure_existence(PROJECT_APP_PATH.site_log) / f"{PROJECT_NAME}_publisher.log") LOG_WRITER.open() client = mqtt.Client() client.on_publish = on_publish client.on_disconnect = on_disconnect HEIMDALLR_SETTINGS = HeimdallrSettings(setting_scope) client.username_pw_set(HEIMDALLR_SETTINGS.mqtt_username, HEIMDALLR_SETTINGS.mqtt_password) try: client.connect(HEIMDALLR_SETTINGS.mqtt_broker, HEIMDALLR_SETTINGS.mqtt_port, keepalive=60) except ValueError as ve: raise ValueError(f"{HEIMDALLR_SETTINGS._mqtt_settings_path}," f"{HEIMDALLR_SETTINGS.mqtt_broker}," f"{HEIMDALLR_SETTINGS.mqtt_port}," f"{ve}") client.loop_start() sensor_data = NOD({HOSTNAME: pull_gpu_info()}) if True: # with IgnoreInterruptSignal(): print("Publisher started") def job(): """ """ sensor_data[HOSTNAME] = pull_gpu_info() s = sensor_data.as_dict() s = json.dumps(s) client.publish(ALL_CONSTANTS.MQTT_TOPIC, s, ALL_CONSTANTS.MQTT_QOS) schedule.every(ALL_CONSTANTS.MQTT_PUBLISH_INTERVAL_SEC).seconds.do(job) for _ in busy_indicator(): schedule.run_pending() time.sleep(1) # noinspection PyUnreachableCode LOG_WRITER.close() client.loop_stop() client.disconnect()
def asadsa2(): """ """ from draugr.torch_utilities import to_tensor from neodroidaudition.data.recognition.libri_speech import LibriSpeech from neodroidaudition.noise_generation.gaussian_noise import white_noise import torchaudio from pathlib import Path libri_speech = LibriSpeech(path=Path.home() / "Data" / "Audio" / "Speech" / "LibriSpeech") files, sr = zip(*[(v[0].numpy(), v[1]) for _, v in zip(range(1), libri_speech)]) assert all([sr[0] == s for s in sr[1:]]) normed = files[0] mixed = mix_ratio(normed, normed, 0) mixed2 = mix_ratio(mixed, mixed, 0) print(normed, mixed) print(mixed2, mixed) print(root_mean_square(normed)) print(root_mean_square(mixed)) print(root_mean_square(mixed2)) assert numpy.allclose(normed, mixed) assert numpy.allclose(mixed2, mixed) torchaudio.save( str(ensure_existence(Path.cwd() / "exclude") / "mixed_same.wav"), to_tensor(mixed), int(sr[0]), )
def compute_additive_noise_samples(*, voice_activity_mask: numpy.ndarray, signal_file: Path, category, out_dir, noise_file) -> None: sr_noise, noise = wavfile.read(str(noise_file)) sr_signal, signal = wavfile.read(str(signal_file)) max_sample = numpy.max(signal) signal = signal / max_sample noise_part = sample_noise(noise / numpy.max(noise), noise_rate=sr_noise, signal_len=len(signal), signal_rate=sr_signal) noise_scaled = noise_part * (root_mean_square( mask_split_speech_silence(voice_activity_mask, signal)[0]) / root_mean_square(noise_part) ) # scaled by ratio of speech to noise level for snr in (i * 5 for i in range(5)): noised = signal + noise_scaled / (10**(snr / 20)) wavfile.write( str( ensure_existence( out_dir / f'{noise_file.with_suffix("").name}_SNR_{snr}dB' / category) / signal_file.name), sr_signal, ((noised / numpy.max(noised)) * max_sample).astype(numpy.int16), )
def main(setting_scope: SettingScopeEnum = SettingScopeEnum.user): """ """ global LOG_WRITER if setting_scope == SettingScopeEnum.user: LOG_WRITER = LogWriter( ensure_existence(PROJECT_APP_PATH.user_log) / f"{PROJECT_NAME}_server.log") else: LOG_WRITER = LogWriter( ensure_existence(PROJECT_APP_PATH.site_log) / f"{PROJECT_NAME}_server.log") LOG_WRITER.open() MQTT_CLIENT.on_message = on_message MQTT_CLIENT.on_disconnect = on_disconnect CRYSTALLISED_HEIMDALLR_SETTINGS = HeimdallrSettings(setting_scope) if True: if (CRYSTALLISED_HEIMDALLR_SETTINGS.mqtt_access_token and False): # TODO: not implemented pass # MQTT_CLIENT.username_pw_set(CRYSTALLISED_HEIMDALLR_SETTINGS.MQTT_ACCESS_TOKEN) else: MQTT_CLIENT.username_pw_set( CRYSTALLISED_HEIMDALLR_SETTINGS.mqtt_username, CRYSTALLISED_HEIMDALLR_SETTINGS.mqtt_password, ) MQTT_CLIENT.connect( CRYSTALLISED_HEIMDALLR_SETTINGS.mqtt_broker, CRYSTALLISED_HEIMDALLR_SETTINGS.mqtt_port, keepalive=60, ) MQTT_CLIENT.subscribe(ALL_CONSTANTS.MQTT_TOPIC, ALL_CONSTANTS.MQTT_QOS) DASH_APP.title = ALL_CONSTANTS.HTML_TITLE DASH_APP.update_title = ALL_CONSTANTS.HTML_TITLE DASH_APP.run_server( host=ALL_CONSTANTS.SERVER_ADDRESS, port=ALL_CONSTANTS.SERVER_PORT, debug=ALL_CONSTANTS.DEBUG, dev_tools_hot_reload=ALL_CONSTANTS.DEBUG, ) LOG_WRITER.close()
def main(): """Makes a forward pass to find the category index with the highest score, and computes intermediate activations. """ from apppath import ensure_existence use_cuda = True image_path = str(Path.home() / "Data" / "ok.png") model = models.resnet50(pretrained=True) grad_cam = GradientClassActivationMapping( model=model, feature_module=model.layer4, target_layer_names=["2"], use_cuda=use_cuda, ) """ model = models.resnet18(pretrained=True) #print(list(model.named_parameters())) grad_cam = GradientClassActivationMapping( model=model, feature_module=model.layer4, target_layer_names=["1"], use_cuda=use_cuda, ) """ img = cv2.imread(image_path, 1) img = numpy.float32(img) / 255 # Opencv loads as BGR: img = img[:, :, ::-1] input_img = preprocess_image(img) # If None, returns the map for the highest scoring category. # Otherwise, targets the requested category. target_category = (518,) grayscale_cam = grad_cam(input_img, target_category) grayscale_cam = cv2.resize(grayscale_cam, (img.shape[1], img.shape[0])) cam = overlay_cam_on_image(img, grayscale_cam) gb_model = GuidedBackPropReLUModel(model=model, use_cuda=use_cuda) gb = gb_model(input_img, target_category=target_category) gb = gb.transpose((1, 2, 0)) cam_mask = cv2.merge([grayscale_cam, grayscale_cam, grayscale_cam]) cam_gb = unstandardise_image(cam_mask * gb) gb = unstandardise_image(gb) exclude = ensure_existence(Path.cwd() / "exclude") cv2.imwrite(str(exclude / "cam.jpg"), cam) cv2.imwrite(str(exclude / "gb.jpg"), gb) cv2.imwrite(str(exclude / "cam_gb.jpg"), cam_gb)
def main(): from configs.mobilenet_v2_ssd320_voc0712 import base_cfg # from configs.efficient_net_b3_ssd300_voc0712 import base_cfg # from configs.vgg_ssd300_voc0712 import base_cfg parser = argparse.ArgumentParser( description="Single Shot MultiBox Detector Training With PyTorch" ) parser.add_argument("--local_rank", type=int, default=0) parser.add_argument( "--log_step", default=10, type=int, help="Print logs every log_step" ) parser.add_argument( "--save_step", default=2500, type=int, help="Save checkpoint every save_step" ) parser.add_argument( "--eval_step", default=2500, type=int, help="Evaluate dataset every eval_step, disabled when eval_step < 0", ) parser.add_argument("--use_tensorboard", default=True, type=str2bool) parser.add_argument( "--skip-test", dest="skip_test", help="Do not test the final model", action="store_true", ) args = parser.parse_args() num_gpus = int(os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 args.distributed = num_gpus > 1 args.num_gpus = num_gpus set_benchmark_device_dist(args.distributed, args.local_rank) logger = setup_distributed_logger( "SSD", global_distribution_rank(), ensure_existence(PROJECT_APP_PATH.user_data / "results") ) logger.info(f"Using {num_gpus} GPUs") logger.info(args) with TorchCacheSession(): model = train_ssd( base_cfg.data_dir, base_cfg, base_cfg.solver, NOD(**args.__dict__) ) if not args.skip_test: logger.info("Start evaluating...") do_ssd_evaluation(base_cfg, model, distributed=args.distributed)
def asadsa(): """ """ from draugr.torch_utilities import to_tensor from neodroidaudition.data.recognition.libri_speech import LibriSpeech from neodroidaudition.noise_generation.gaussian_noise import white_noise import torchaudio from pathlib import Path libri_speech = LibriSpeech( path=Path.home() / "Data" / "Audio" / "Speech" / "LibriSpeech", split=Split.Testing, ) files, sr = zip(*[(v[0].numpy(), v[1]) for _, v in zip(range(20), libri_speech)]) assert all([sr[0] == s for s in sr[1:]]) mix = files[0] for file in files[1:]: mix = mix_ratio(mix, file, 0) torchaudio.save( str( ensure_existence(Path.cwd() / "exclude") / f"mixed_even_babble.wav"), to_tensor(mix), int(sr[0]), ) for ratio in range(-20, 20 + 1, 5): torchaudio.save( str( ensure_existence(Path.cwd() / "exclude") / f"mixed_{ratio}.wav"), to_tensor(mix_ratio(files[0], files[-1], ratio)), int(sr[0]), )
def get_logger( path: Path = Path.cwd() / "0.log", write_to_std_out: bool = False, ) -> logging.Logger: """ :param path: :type path: :param write_to_std_out: :type write_to_std_out: :return: :rtype:""" ensure_existence(path, declare_file=True, overwrite_on_wrong_type=True) handlers = [logging.FileHandler(filename=str(path))] if write_to_std_out: handlers.append(logging.StreamHandler(sys.stdout)) logging.basicConfig(level=logging.INFO, format="%(message)s", handlers=handlers) return logging.getLogger()
def asd7ad() -> None: """ :rtype: None """ from pathlib import Path from apppath import ensure_existence from matplotlib import pyplot import numpy import imageio n = 200 n_frames = 25 x = numpy.linspace(-numpy.pi * 4, numpy.pi * 4, n) base = ensure_existence(Path("exclude")) def gen(): """ """ for i, t in enumerate(numpy.linspace(0, numpy.pi, n_frames)): pyplot.plot(x, numpy.cos(x + t)) pyplot.plot(x, numpy.sin(2 * x - t)) pyplot.plot(x, numpy.cos(x + t) + numpy.sin(2 * x - t)) pyplot.ylim(-2.5, 2.5) pyplot.savefig(base / f"frame{i}.png", bbox_inches="tight", dpi=300) pyplot.clf() def asijsd(): """ """ files = [base / f"frame{yu}.png" for yu in range(n_frames)] frames = [imageio.imread(f) for f in files] frames = blit_numbering_raster_sequence(frames) imageio.mimsave(base / "output.gif", frames, fps=(n_frames / 2.0)) def sadasf(): """ """ files = [base / f"frame{yu}.png" for yu in range(n_frames)] a = [imageio.imread(f) for f in files] frames = numpy.array([a, a]) # copy of itself, just for test fps = n_frames / 2.0 frames = numpy.array( [blit_fps(blit_numbering_raster_sequence(f), fps) for f in frames] ) [ imageio.mimsave(base / f"output{i}.gif", f, fps=fps) for i, f in enumerate(frames) ] gen() sadasf()
def get_csv_writer( path: Path = Path.home() / "Models") -> Tuple[TextIO, Any]: """ :param path: :type path: :return: :rtype:""" if path.is_dir() or path.suffix != ".csv": path /= "log.csv" csv_file = open( str( ensure_existence(path, overwrite_on_wrong_type=True, declare_file=True)), mode="a", ) return csv_file, csv.writer(csv_file)
def resize_children( src_path: Union[Path, str], size: Union[Tuple[Number, Number], Number], dst_path: Union[Path, str] = "resized", *, from_extensions: Iterable[str] = ("jpg", "png"), to_extension: "str" = "jpg", resize_method: ResizeMethodEnum = ResizeMethodEnum.scale_crop, ) -> None: target_size = (size, size) src_path = Path(src_path) dst_path = Path(dst_path) if not dst_path.root: dst_path = src_path.parent / dst_path for ext in progress_bar(from_extensions): for c in progress_bar( src_path.rglob(f'*.{ext.rstrip("*").rstrip(".")}')): image = cv2.imread(str(c)) if resize_method == resize_method.scale: resized = cv2_resize(image, target_size, InterpolationEnum.area) elif resize_method == resize_method.crop: center = (image.shape[0] / 2, image.shape[1] / 2) x = int(center[1] - target_size[0] / 2) y = int(center[0] - target_size[1] / 2) resized = image[y:y + target_size[1], x:x + target_size[0]] elif resize_method == resize_method.scale_crop: resized = resize(image, width=target_size[0]) center = (resized.shape[0] / 2, resized.shape[1] / 2) x = int(center[1] - target_size[0] / 2) y = int(center[0] - target_size[1] / 2) resized = resized[y:y + target_size[1], x:x + target_size[0]] else: raise NotImplementedError target_folder = ensure_existence( dst_path.joinpath(*(c.relative_to(src_path).parent.parts))) cv2.imwrite( str((target_folder / c.name).with_suffix( f'.{to_extension.rstrip("*").rstrip(".")}')), resized, )
def a(): """ """ _path_to_events_file = next( AppPath("Draugr", "Christian Heider Nielsen").user_log.rglob( "events.out.tfevents.*")) print(_path_to_events_file) tee = TensorboardEventExporter(_path_to_events_file.parent, save_to_disk=True) print(tee.tags_available) # tee.export_csv('train_loss') # tee.export_line_plot('train_loss') # pyplot.show() print(tee.export_histogram()) print(tee.available_scalars) print( tee.pr_curve_export_csv( *tee.tags_available["tensors"], out_dir=ensure_existence(Path.cwd() / "exclude"), )) print(list(iter(tee.TagTypeEnum)))
def extract_scalars_as_csv( train_path: Path = EXPORT_RESULTS_PATH / "csv" / "training", test_path: Path = EXPORT_RESULTS_PATH / "csv" / "testing", export_train: bool = True, export_test: bool = True, verbose: bool = False, only_extract_from_latest_event_file: bool = False, ) -> None: """ :param train_path: :param test_path: :param export_train: :param export_test: :param verbose: :param only_extract_from_latest_event_file: """ if only_extract_from_latest_event_file: max_load_time = max( list( AppPath( "Adversarial Speech", "Christian Heider Nielsen" ).user_log.iterdir() ), key=os.path.getctime, ) unique_event_files_parents = set( [ef.parent for ef in max_load_time.rglob("events.out.tfevents.*")] ) event_files = {max_load_time: unique_event_files_parents} else: event_files = { a: set([ef.parent for ef in a.rglob("events.out.tfevents.*")]) for a in list( AppPath( "Adversarial Speech", "Christian Heider Nielsen" ).user_log.iterdir() ) } for k, v in progress_bar(event_files.items()): for e in progress_bar(v): relative_path = e.relative_to(k) mapping_id, *rest = relative_path.parts mappind_id_test = f"{mapping_id}_Test_{relative_path.name}" # model_id = relative_path.parent.name can be include but is always the same relative_path = Path(*(mappind_id_test, *rest)) with TensorboardEventExporter(e, save_to_disk=True) as tee: if export_test: out_tags = [] for tag in progress_bar(TestingScalars): if tag.value in tee.available_scalars: out_tags.append(tag.value) if len(out_tags): tee.scalar_export_csv( *out_tags, out_dir=ensure_existence( test_path / k.name / relative_path, force_overwrite=True, verbose=verbose, ), ) print(e) else: if verbose: print( f"{e}, no requested tags found {TestingScalars.__members__.values()}, {tee.available_scalars}" ) if export_train: out_tags = [] for tag in progress_bar(TrainingScalars): if tag.value in tee.available_scalars: out_tags.append(tag.value) if len(out_tags): tee.scalar_export_csv( *out_tags, out_dir=ensure_existence( train_path / k.name / relative_path, force_overwrite=True, verbose=verbose, ), ) else: if verbose: print( f"{e}, no requested tags found {TrainingScalars.__members__.values()}, {tee.available_scalars}" )
def export_detection_model( cfg: NOD, model_ckpt: Path, model_export_path: Path = Path("torch_model"), verbose: bool = True, onnx_export: bool = False, strict_jit: bool = False, ) -> None: """ :param verbose: :type verbose: :param cfg: :type cfg: :param model_ckpt: :type model_ckpt: :param model_export_path: :type model_export_path: :return: :rtype: """ model = SingleShotDectectionNms(cfg) checkpointer = CheckPointer( model, save_dir=ensure_existence(PROJECT_APP_PATH.user_data / "results") ) checkpointer.load(model_ckpt, use_latest=model_ckpt is None) print( f"Loaded weights from {model_ckpt if model_ckpt else checkpointer.get_checkpoint_file()}" ) model.post_init() model.to(global_torch_device()) transforms = SSDTransform( cfg.input.image_size, cfg.input.pixel_mean, split=Split.Testing ) model.eval() pre_quantize_model = False if pre_quantize_model: # Accuracy may drop! if True: model = quantization.quantize_dynamic(model, dtype=torch.qint8) else: pass # model = quantization.quantize(model) frame_g = frame_generator(cv2.VideoCapture(0)) for image in tqdm(frame_g): example_input = (transforms(image)[0].unsqueeze(0).to(global_torch_device()),) try: traced_script_module = torch.jit.script( model, # example_input, ) exp_path = model_export_path.with_suffix(".compiled") traced_script_module.save(str(exp_path)) print(f"Traced Ops used {torch.jit.export_opnames(traced_script_module)}") sprint( f"Successfully exported JIT Traced model at {exp_path}", color="green" ) except Exception as e_i: sprint(f"Torch JIT Trace export does not work!, {e_i}", color="red") break
null_color="red") # element wise # df.style.bar(subset=['A', 'B'], color='#d65f5f') # df.style.bar(subset=['A', 'B'], align='mid', color=['#d65f5f', '#5fba7d']) df = df.applymap(color_highlight_extreme) # .format(None, na_rep="-") df = df.apply(color_highlight_extreme, color="darkorange") df = df.apply( color_highlight_extreme, extreme_func=NDFrameExtremeEnum.max, color="green", axis=None, ) html_ = df.render() # html_ = df.to_html() # from IPython.display import display, HTML # display((HTML(),)) # print(tabulate(df, headers = 'keys', tablefmt = 'psql')) with open(ensure_existence(Path("exclude")) / "style_test.html", "w") as f: f.write(html_) """ Styler.applymap(func) for elementwise styles Styler.apply(func, axis=0) for columnwise styles Styler.apply(func, axis=1) for rowwise styles Styler.apply(func, axis=None) for tablewise styles And crucially the input and output shapes of func must match. If x is the input then func(x).shape == x.shape. """
def export_detection_model( cfg: NOD, model_checkpoint: Path, model_export_path: Path = Path("torch_model"), verbose: bool = True, onnx_export: bool = False, strict_jit: bool = False, ) -> None: """ :param verbose: :type verbose: :param cfg: :type cfg: :param model_checkpoint: :type model_checkpoint: :param model_export_path: :type model_export_path: :return: :rtype:""" model = SingleShotDetection(cfg) checkpointer = CheckPointer(model, save_dir=ensure_existence( PROJECT_APP_PATH.user_data / "results")) checkpointer.load(model_checkpoint, use_latest=model_checkpoint is None) print( f"Loaded weights from {model_checkpoint if model_checkpoint else checkpointer.get_checkpoint_file()}" ) model.post_init() model.to(global_torch_device()) transforms = SSDTransform(cfg.input.image_size, cfg.input.pixel_mean, split=SplitEnum.testing) model.eval() # Important! fuse_quantize_model = False if fuse_quantize_model: modules_to_fuse = [ ["conv", "bn", "relu"] ] # Names of modules to fuse, maybe supply directly for architecture class/declaration model = torch.quantization.fuse_modules( model, modules_to_fuse=modules_to_fuse, inplace=False) pre_quantize_model = False if pre_quantize_model: # Accuracy may drop! if True: model = quantization.quantize_dynamic(model, dtype=torch.qint8) else: pass # model = quantization.quantize(model) frame_g = frame_generator(cv2.VideoCapture(0)) for image in tqdm(frame_g): example_input = (transforms(image)[0].unsqueeze(0).to( global_torch_device()), ) try: if onnx_export: exp_path = model_export_path.with_suffix(".onnx") output = onnx.export( model, example_input, str(exp_path), verbose=verbose, # export_params=True, # store the trained parameter weights inside the model file # opset_version=10, # the onnx version to export the model to # do_constant_folding=True, # wether to execute constant folding for optimization # input_names=["input"], # the model's input names # output_names=["output"], # the model's output names # dynamic_axes={ # "input": {0: "batch_size"}, # variable lenght axes # "output": {0: "batch_size"}, # } ) sprint(f"Successfully exported ONNX model at {exp_path}", color="blue") else: raise Exception("Just trace instead, ignore exception") except Exception as e: sprint(f"Torch ONNX export does not work, {e}", color="red") try: traced_script_module = torch.jit.trace( model, example_input, # strict=strict_jit, check_inputs=( transforms(next(frame_g))[0].unsqueeze(0).to( global_torch_device()), transforms(next(frame_g))[0].unsqueeze(0).to( global_torch_device()), ), ) exp_path = model_export_path.with_suffix(".traced") traced_script_module.save(str(exp_path)) print( f"Traced Ops used {torch.jit.export_opnames(traced_script_module)}" ) sprint( f"Successfully exported JIT Traced model at {exp_path}", color="green", ) except Exception as e_i: sprint(f"Torch JIT Trace export does not work!, {e_i}", color="red") break """
def run_demo(cfg, class_names, model_ckpt, score_threshold, images_dir, output_dir): model = SingleShotDectection(cfg) checkpointer = CheckPointer(model, save_dir=ensure_existence( PROJECT_APP_PATH.user_data / "results")) checkpointer.load(model_ckpt, use_latest=model_ckpt is None) print( f"Loaded weights from {model_ckpt if model_ckpt else checkpointer.get_checkpoint_file()}" ) model.post_init() model.to(global_torch_device()) image_paths = list(images_dir.iterdir()) cpu_device = torch.device("cpu") transforms = SSDTransform(cfg.input.image_size, cfg.input.pixel_mean, split=Split.Testing) model.eval() for i, image_path in enumerate(image_paths): start = time.time() image_name = os.path.basename(image_path) image = numpy.array(Image.open(image_path).convert("RGB")) height, width = image.shape[:2] images = transforms(image)[0].unsqueeze(0) load_time = time.time() - start start = time.time() result = model(images.to(global_torch_device()))[0] inference_time = time.time() - start result.boxes[:, 0::2] *= width / result.img_width result.boxes[:, 1::2] *= height / result.img_height (boxes, labels, scores) = ( result.boxes.to(cpu_device).numpy(), result.labels.to(cpu_device).numpy(), result.scores.to(cpu_device).numpy(), ) indices = scores > score_threshold boxes, labels, scores = boxes[indices], labels[indices], scores[ indices] meters = " | ".join([ f"objects {len(boxes):02d}", f"load {round(load_time * 1000):03d}ms", f"inference {round(inference_time * 1000):03d}ms", f"FPS {round(1.0 / inference_time)}", ]) print(f"({i + 1:04d}/{len(image_paths):04d}) {image_name}: {meters}") drawn_image = draw_bounding_boxes( image, boxes, labels, scores, class_names, score_font=ImageFont.truetype( PACKAGE_DATA_PATH / "Lato-Regular.ttf", 24, ), ).astype(numpy.uint8) Image.fromarray(drawn_image).save(os.path.join(output_dir, image_name))
def main(): dataset_root = Path.home() / "Data" base_path = ensure_existence(PROJECT_APP_PATH.user_data / 'maskrcnn') log_path = ensure_existence(PROJECT_APP_PATH.user_log / 'maskrcnn') export_root = ensure_existence(base_path / 'models') model_name = f'maskrcnn_pennfudanped' batch_size = 4 num_epochs = 10 optimiser_spec = GDKC(torch.optim.Adam, lr=3e-4) scheduler_spec = GDKC( torch.optim.lr_scheduler. StepLR, # a learning rate scheduler which decreases the learning rate by step_size=3, # 10x every 3 epochs gamma=0.1, ) num_workers = os.cpu_count() torch_seed(3825) dataset = PennFudanDataset(dataset_root / "PennFudanPed", Split.Training, return_variant=ReturnVariant.all) dataset_validation = PennFudanDataset( dataset_root / "PennFudanPed", Split.Validation, return_variant=ReturnVariant.all, ) split = SplitIndexer(len(dataset), validation=0.3, testing=0) split_indices = torch.randperm(split.total_num).tolist() data_loader = DataLoader( Subset(dataset, split_indices[:-split.validation_num]), batch_size=batch_size, shuffle=True, num_workers=num_workers, collate_fn=collate_batch_fn, ) data_loader_val = DataLoader( Subset(dataset_validation, split_indices[-split.validation_num:]), batch_size=1, shuffle=False, num_workers=num_workers, collate_fn=collate_batch_fn, ) model = get_pretrained_instance_segmentation_maskrcnn( dataset.response_channels) optimiser = optimiser_spec(trainable_parameters(model)) lr_scheduler = scheduler_spec(optimiser) if True: model = load_model(model_name=model_name, model_directory=export_root) if True: with TorchTrainSession(model): with TensorBoardPytorchWriter(log_path / model_name) as writer: for epoch_i in tqdm(range(num_epochs), desc="Epoch #"): maskrcnn_train_single_epoch(model=model, optimiser=optimiser, data_loader=data_loader, writer=writer) lr_scheduler.step() # update the learning rate maskrcnn_evaluate( model, data_loader_val, writer=writer ) # evaluate on the validation dataset save_model(model, model_name=model_name, save_directory=export_root) if True: with TorchEvalSession(model): # put the model in evaluation mode img, _ = dataset_validation[ 0] # pick one image from the test set with torch.no_grad(): prediction = model([img.to(global_torch_device())]) from matplotlib import pyplot pyplot.imshow( Image.fromarray( img.mul(255).permute(1, 2, 0).byte().numpy())) pyplot.show() import cv2 pyplot.imshow( Image.fromarray(prediction[0]["masks"][0, 0].mul( 255).byte().cpu().numpy())) pyplot.show() (boxes, labels, scores) = ( prediction[0]["boxes"].to('cpu').numpy(), prediction[0]["labels"].to('cpu').numpy(), torch.sigmoid(prediction[0]["scores"]).to('cpu').numpy(), ) from draugr.opencv_utilities import draw_bounding_boxes from draugr.torch_utilities.images.conversion import quick_to_pil_image indices = scores > 0.1 cv2.namedWindow(model_name, cv2.WINDOW_NORMAL) cv2.imshow( model_name, draw_bounding_boxes( quick_to_pil_image(img), boxes[indices], labels=labels[indices], scores=scores[indices], #categories=categories, )) cv2.waitKey()
def run_webcam_demo( cfg: NOD, categories: Sequence[str], model_checkpoint: Path, score_threshold: float = 0.5, window_name: str = "SSD", ): """ :param categories: :type categories: :param cfg: :type cfg: :param model_checkpoint: :type model_checkpoint: :param score_threshold: :type score_threshold: :param window_name: :type window_name: :return: :rtype:""" cpu_device = torch.device("cpu") transforms = SSDTransform(cfg.input.image_size, cfg.input.pixel_mean, split=SplitEnum.testing) model = SingleShotDetection(cfg) checkpointer = CheckPointer(model, save_dir=ensure_existence( PROJECT_APP_PATH.user_data / "results")) checkpointer.load(model_checkpoint, use_latest=model_checkpoint is None) print( f"Loaded weights from {model_checkpoint if model_checkpoint else checkpointer.get_checkpoint_file()}" ) model.post_init() model.to(global_torch_device()) with TorchEvalSession(model): for infos in tqdm(DictUnityEnvironment(connect_to_running=True)): info = next(iter(infos.values())) new_images = extract_all_cameras(info) image = next(iter(new_images.values()))[..., :3][..., ::-1] image = gamma_correct_float_to_byte(image) result = model( transforms(image)[0].unsqueeze(0).to(global_torch_device()))[0] height, width, *_ = image.shape result["boxes"][:, 0::2] *= width / result["img_width"] result["boxes"][:, 1::2] *= height / result["img_height"] (boxes, labels, scores) = ( result["boxes"].to(cpu_device).numpy(), result["labels"].to(cpu_device).numpy(), result["scores"].to(cpu_device).numpy(), ) indices = scores > score_threshold if show_image( draw_bounding_boxes( image, boxes[indices], labels=labels[indices], scores=scores[indices], categories=categories, ).astype(numpy.uint8), window_name, wait=1, ): break # esc to quit
x_c = [r[0] for r in digits[i][1]] y_c = [r[1] for r in digits[i][1]] z_c = [r[2] for r in digits[i][1]] layout = Layout(height=500, width=600, title=f"Digit: {str(digits[i][2])} in 3D space") fig = Figure( data=[ Scatter3d( x=x_c, y=y_c, z=z_c, mode="markers", marker={ "size": 12, "color": z_c, "colorscale": "Viridis", "opacity": 0.7, }, ) ], layout=layout, ) plotly.offline.plot( fig, filename=str( ensure_existence(PROJECT_APP_PATH.user_cache / "mnist3d") / "temp-plot.html"), )
def export_detection_model( model_export_path: Path = ensure_existence( PROJECT_APP_PATH.user_data / "penn_fudan_segmentation" ) / "seg_skip_fis", SEED: int = 87539842, ) -> None: """ :param model_export_path: :type model_export_path: :return: :rtype:""" model = OutputActivationModule( SkipHourglassFission(input_channels=3, output_heads=(1,), encoding_depth=1) ) with TorchDeviceSession(device=global_torch_device("cpu"), model=model): with TorchEvalSession(model): seed_stack(SEED) # standard PyTorch mean-std input image normalization transform = transforms.Compose( [ transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ] ) frame_g = frame_generator(cv2.VideoCapture(0)) for image in tqdm(frame_g): example_input = ( transform(image).unsqueeze(0).to(global_torch_device()), ) try: traced_script_module = torch.jit.trace( model, example_input, # strict=strict_jit, check_inputs=( transform(next(frame_g)) .unsqueeze(0) .to(global_torch_device()), transform(next(frame_g)) .unsqueeze(0) .to(global_torch_device()), ), ) exp_path = model_export_path.with_suffix(".traced") traced_script_module.save(str(exp_path)) print( f"Traced Ops used {torch.jit.export_opnames(traced_script_module)}" ) sprint( f"Successfully exported JIT Traced model at {exp_path}", color="green", ) except Exception as e_i: sprint(f"Torch JIT Trace export does not work!, {e_i}", color="red") break
def __init__(self, config, data_loader): """ Construct a new Trainer instance. Args: config: object containing command line arguments. data_loader: A data iterator. """ self.config = config if config.use_gpu and torch.cuda.is_available(): self.device = torch.device("cuda") else: self.device = torch.device("cpu") # glimpse network params self.patch_size = config.patch_size self.glimpse_scale = config.glimpse_scale self.num_patches = config.num_patches self.loc_hidden = config.loc_hidden self.glimpse_hidden = config.glimpse_hidden # core network params self.num_glimpses = config.num_glimpses self.hidden_size = config.hidden_size # reinforce params self.std = config.std self.M = config.M # data params if config.is_train: self.train_loader = data_loader[0] self.valid_loader = data_loader[1] self.num_train = len(self.train_loader.sampler.indices) self.num_valid = len(self.valid_loader.sampler.indices) else: self.test_loader = data_loader self.num_test = len(self.test_loader.dataset) self.num_classes = 10 self.num_channels = 1 # training params self.epochs = config.epochs self.start_epoch = 0 self.momentum = config.momentum self.lr = config.init_lr # misc params self.model_name = f"ram_{config.num_glimpses}_{config.patch_size}x{config.patch_size}_{config.glimpse_scale}" self.best = config.best self.ckpt_dir = config.ckpt_dir self.logs_dir = config.logs_dir self.plot_dir = config.plot_dir / self.model_name self.best_valid_acc = 0.0 self.counter = 0 self.lr_patience = config.lr_patience self.train_patience = config.train_patience self.use_tensorboard = config.use_tensorboard self.resume = config.resume self.print_freq = config.print_freq self.plot_freq = config.plot_freq ensure_existence(self.ckpt_dir) ensure_existence(self.logs_dir) ensure_existence(self.plot_dir) # configure tensorboard logging if self.use_tensorboard: tensorboard_dir = self.logs_dir / self.model_name print(f"[*] Saving tensorboard logs to {tensorboard_dir}") if not os.path.exists(tensorboard_dir): os.makedirs(tensorboard_dir) configure(tensorboard_dir) self.model = RecurrentAttention( self.patch_size, self.num_patches, self.glimpse_scale, self.num_channels, self.loc_hidden, self.glimpse_hidden, self.std, self.hidden_size, self.num_classes, ).to(self.device) self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.config.init_lr) self.scheduler = ReduceLROnPlateau(self.optimizer, "min", patience=self.lr_patience)
def main( base_path: Path = Path.home() / "Data" / "Datasets" / "PennFudanPed", train_model: bool = True, load_prev_model: bool = True, writer: Writer = TensorBoardPytorchWriter(PROJECT_APP_PATH.user_log / "instanced_person_segmentation" / f"{time.time()}"), ): """ """ # base_path = Path("/") / "encrypted_disk" / "heider" / "Data" / "PennFudanPed" base_path: Path = Path.home() / "Data3" / "PennFudanPed" # base_path = Path('/media/heider/OS/Users/Christian/Data/Datasets/') / "PennFudanPed" pyplot.style.use("bmh") save_model_path = ( ensure_existence(PROJECT_APP_PATH.user_data / "models") / "instanced_penn_fudan_ped_seg.model") eval_model = not train_model SEED = 9221 batch_size = 32 num_workers = 0 encoding_depth = 2 learning_rate = 6e-6 # sequence 6e-2 6e-3 6e-4 6e-5 seed_stack(SEED) train_set = PennFudanDataset( base_path, SplitEnum.training, return_variant=PennFudanDataset.PennFudanReturnVariantEnum.instanced, ) train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True, num_workers=num_workers) valid_loader = DataLoader( PennFudanDataset( base_path, SplitEnum.validation, return_variant=PennFudanDataset.PennFudanReturnVariantEnum. instanced, ), batch_size=batch_size, shuffle=False, num_workers=num_workers, ) model = SkipHourglassFission( input_channels=train_set.predictor_shape[-1], output_heads=(train_set.response_shape[-1], ), encoding_depth=encoding_depth, ) model.to(global_torch_device()) if load_prev_model and save_model_path.exists(): model.load_state_dict(torch.load(str(save_model_path))) print("loading saved model") if train_model: with TorchTrainSession(model): criterion = BCEDiceLoss() # optimiser = torch.optim.SGD(model.parameters(), lr=learning_rate) optimiser = torch.optim.Adam(model.parameters(), lr=learning_rate) # scheduler = torch.optim.lr_scheduler.CosineAnnealingLR( optimiser, T_max=7, eta_min=learning_rate / 100, last_epoch=-1 ) model = train_person_segmentor( model, train_loader, valid_loader, criterion, optimiser, save_model_path=save_model_path, learning_rate=learning_rate, writer=writer, ) if eval_model: validate_model(model, valid_loader)
def get_calender_df(calendar_id: str, credentials_base_path: Path, num_entries: int = 30) -> dash_table.DataTable: """Shows basic usage of the Google Calendar API. Prints the start and name of the next 10 events on the user's calendar. :param num_entries: :param credentials_base_path: :type calendar_id: object :rtype: object """ credentials = None # The file token.pickle stores the user's access and refresh tokens, and is # created automatically when the authorization flow completes for the first # time. tokens_path = ensure_existence( credentials_base_path / "google") / "token.pickle" if tokens_path.exists(): with open(tokens_path, "rb") as token: credentials = pickle.load(token) if not credentials or not credentials.valid: # If there are no (valid) credentials available, let the user log in. if credentials and credentials.expired and credentials.refresh_token: credentials.refresh(Request()) else: a = ensure_existence( credentials_base_path / "google") / "credentials.json" if a.exists(): flow = InstalledAppFlow.from_client_secrets_file( str(a), SCOPES) credentials = flow.run_local_server() else: if False: raise Exception(f"Missing {a}") else: print(f"Missing {a}") with open(tokens_path, "wb") as token: # Save the credentials for the next run pickle.dump(credentials, token) df = pandas.DataFrame(columns=("start", "summary")) if credentials: service = build("calendar", "v3", credentials=credentials) # Call the Calendar API events_result = ( service.events().list( calendarId=calendar_id, timeMin= f"{datetime.datetime.utcnow().isoformat()}Z", # 'Z' indicates UTC time maxResults=num_entries, singleEvents=True, orderBy="startTime", ).execute()) events = events_result.get("items", []) if not events: print("No upcoming events found.") else: for event in events: start = event["start"].get("dateTime", event["start"].get("date")) if "summary" in event: df.loc[-1] = (start, event["summary"]) # 'summary' df.index = df.index + 1 df = df.sort_index(ascending=False) df.start = df.start.map(iso_dt_to_datetime) return df
CONFIG.latent_size = 10 CONFIG.print_every = 100 GLOBAL_DEVICE = global_torch_device() TIMESTAMP = time.time() LOWEST_L = inf CORE_COUNT = 0 # min(8, multiprocessing.cpu_count() - 1) GLOBAL_DEVICE = torch.device( "cuda" if torch.cuda.is_available() else "cpu") DL_KWARGS = ({ "num_workers": CORE_COUNT, "pin_memory": True } if torch.cuda.is_available() else {}) BASE_PATH = ensure_existence(PROJECT_APP_PATH.user_data / "cvae") torch.manual_seed(CONFIG.seed) if torch.cuda.is_available(): torch.cuda.manual_seed(CONFIG.seed) NAME = "MNIST" MODEL = ConditionalVAE( encoder_layer_sizes=CONFIG.encoder_layer_sizes, latent_size=CONFIG.latent_size, decoder_layer_sizes=CONFIG.decoder_layer_sizes, num_conditions=10, ).to(global_torch_device()) DATASET = MNIST( root=str(PROJECT_APP_PATH.user_data / NAME), train=True,
def __init__(self, setting_scope: SettingScopeEnum = SettingScopeEnum.site): """Protects from overriding on initialisation""" pass # super().__init__() # TODO: FIGURE OUT A WAY TO EASILY COPY SETTINGS TO ROOT; for services # print(f'Using settings from {PROJECT_APP_PATH.user_config}') _setting_scope = setting_scope if setting_scope == SettingScopeEnum.user: HeimdallrSettings._credentials_base_path = ensure_existence( PROJECT_APP_PATH.user_config / "credentials") HeimdallrSettings._google_settings_path = str( ensure_existence(PROJECT_APP_PATH.user_config) / "google.settings") HeimdallrSettings._mqtt_settings_path = str( ensure_existence(PROJECT_APP_PATH.user_config) / "mqtt.settings") # print(f'Using config at {PROJECT_APP_PATH.site_config}') elif setting_scope == SettingScopeEnum.site: prev_val = PROJECT_APP_PATH._ensure_existence PROJECT_APP_PATH._ensure_existence = False HeimdallrSettings._credentials_base_path = ( PROJECT_APP_PATH.site_config / "credentials") if not HeimdallrSettings._credentials_base_path.exists(): with sh.contrib.sudo( password=getpass.getpass( prompt=f"[sudo] password for {getpass.getuser()}: " ), _with=True, ): sh.mkdir(["-p", HeimdallrSettings._credentials_base_path]) sh.chown( f"{getpass.getuser()}:", PROJECT_APP_PATH.site_config ) # If a colon but no group name follows the user name, that user is made the owner of the files and the group of the files is changed to that user's login group. PROJECT_APP_PATH._ensure_existence = prev_val HeimdallrSettings._google_settings_path = str( ensure_existence(PROJECT_APP_PATH.site_config) / "google.settings") HeimdallrSettings._mqtt_settings_path = str( ensure_existence(PROJECT_APP_PATH.site_config) / "mqtt.settings") # print(f'Using config at {PROJECT_APP_PATH.site_config}') elif setting_scope == SettingScopeEnum.root: prev_val = PROJECT_APP_PATH._ensure_existence PROJECT_APP_PATH._ensure_existence = False HeimdallrSettings._credentials_base_path = ( PROJECT_APP_PATH.root_config / "credentials") if not HeimdallrSettings._credentials_base_path.exists(): with sh.contrib.sudo( password=getpass.getpass( prompt=f"[sudo] password for {getpass.getuser()}: " ), _with=True, ): sh.mkdir(["-p", HeimdallrSettings._credentials_base_path]) sh.chown( f"{getpass.getuser()}:", PROJECT_APP_PATH.root_config ) # If a colon but no group name follows the user name, that user is made the owner of the files and the group of the files is changed to that user's login group. PROJECT_APP_PATH._ensure_existence = prev_val HeimdallrSettings._google_settings_path = str( ensure_existence(PROJECT_APP_PATH.root_config) / "google.settings") HeimdallrSettings._mqtt_settings_path = str( ensure_existence(PROJECT_APP_PATH.root_config) / "mqtt.settings") # print(f'Using config at {PROJECT_APP_PATH.site_config}') else: raise ValueError()
def train_mnist(load_earlier=False, train=True, denoise: bool = True): """ :param load_earlier: :type load_earlier: :param train: :type train:""" seed = 251645 batch_size = 32 tqdm.monitor_interval = 0 learning_rate = 3e-3 lr_sch_step_size = int(10e4 // batch_size) lr_sch_gamma = 0.1 unet_depth = 3 unet_start_channels = 16 input_channels = 1 output_channels = (input_channels,) home_path = PROJECT_APP_PATH model_file_ending = ".model" model_base_path = ensure_existence(PROJECT_APP_PATH.user_data / "unet_mnist") interrupted_name = "INTERRUPTED_BEST" interrupted_path = model_base_path / f"{interrupted_name}{model_file_ending}" torch.manual_seed(seed) device = global_torch_device() img_transform = transforms.Compose( [ transforms.ToTensor(), MinMaxNorm(), transforms.Lambda(lambda tensor: torch.round(tensor)), # transforms.RandomErasing() ] ) dataset = MNIST( PROJECT_APP_PATH.user_data / "mnist", transform=img_transform, download=True ) data_iter = iter( cycle(DataLoader(dataset, batch_size=batch_size, shuffle=True, pin_memory=True)) ) data_iter = to_device_iterator(data_iter, device) model = SkipHourglassFission( input_channels=input_channels, output_heads=output_channels, encoding_depth=unet_depth, start_channels=unet_start_channels, ).to(global_torch_device()) optimiser_ft = optim.Adam(model.parameters(), lr=learning_rate) exp_lr_scheduler = optim.lr_scheduler.StepLR( optimiser_ft, step_size=lr_sch_step_size, gamma=lr_sch_gamma ) if load_earlier: _list_of_files = list( model_base_path.rglob(f"{interrupted_name}{model_file_ending}") ) if not len(_list_of_files): print( f"found no trained models under {model_base_path}{os.path.sep}**{os.path.sep}{interrupted_name}{model_file_ending}" ) exit(1) latest_model_path = str(max(_list_of_files, key=os.path.getctime)) print(f"loading previous model: {latest_model_path}") if latest_model_path is not None: model.load_state_dict(torch.load(latest_model_path)) if train: with TensorBoardPytorchWriter(home_path.user_log / str(time.time())) as writer: model = training( model, data_iter, optimiser_ft, exp_lr_scheduler, writer, interrupted_path, denoise=denoise, ) torch.save( model.state_dict(), model_base_path / f"unet_mnist_final{model_file_ending}", ) else: inference(model, data_iter, denoise=denoise) torch.cuda.empty_cache()
def run_webcam_demo( cfg: NOD, input_cfg: NOD, categories: List, model_ckpt: Path, score_threshold: float = 0.7, window_name: str = "SSD", ): """ :param categories: :type categories: :param cfg: :type cfg: :param model_ckpt: :type model_ckpt: :param score_threshold: :type score_threshold: :param window_name: :type window_name: :return: :rtype: """ cpu_device = torch.device("cpu") transforms = SSDTransform(input_cfg.image_size, input_cfg.pixel_mean, split=Split.Testing) model = SingleShotDectectionNms(cfg) checkpointer = CheckPointer(model, save_dir=ensure_existence( PROJECT_APP_PATH.user_data / "results")) checkpointer.load(model_ckpt, use_latest=model_ckpt is None) print( f"Loaded weights from {model_ckpt if model_ckpt else checkpointer.get_checkpoint_file()}" ) model.post_init() model.to(global_torch_device()) with TorchEvalSession(model): for image in tqdm(frame_generator(cv2.VideoCapture(0))): result = model( transforms(image)[0].unsqueeze(0).to(global_torch_device())) height, width, *_ = image.shape result.boxes[:, 0::2] *= width / result.img_width.cpu().item() result.boxes[:, 1::2] *= height / result.img_height.cpu().item() (boxes, labels, scores) = ( result.boxes.to(cpu_device).numpy(), result.labels.to(cpu_device).numpy(), result.scores.to(cpu_device).numpy(), ) indices = scores > score_threshold cv2.namedWindow(window_name, cv2.WINDOW_NORMAL) cv2.imshow( window_name, draw_bounding_boxes( image, boxes[indices], labels=labels[indices], scores=scores[indices], categories=categories, score_font=ImageFont.truetype( PACKAGE_DATA_PATH / "Lato-Regular.ttf", 24, ), ).astype(numpy.uint8), ) if cv2.waitKey(1) == 27: break # esc to quit
from pathlib import Path from matplotlib import pyplot from apppath import ensure_existence from draugr import PROJECT_APP_PATH from draugr.tensorboard_utilities import TensorboardEventExporter from draugr.writers import TrainingScalars if __name__ == "__main__": save = False event_files = list( PROJECT_APP_PATH.user_log.rglob("events.out.tfevents.*")) if len(event_files) > 0: for _path_to_events_file in event_files: print(f"Event file: {_path_to_events_file}") _out_dir = Path.cwd() / "exclude" / "results" ensure_existence(_out_dir) tee = TensorboardEventExporter(_path_to_events_file.parent, save_to_disk=save) print(f"Available tags: {tee.tags_available}") tee.export_line_plot(TrainingScalars.training_loss.value, out_dir=_out_dir) if not save: pyplot.show() else: print("No events found")