def train(self, tmp_dir): from rastervision.backend.keras_classification.commands.train \ import _train dataset_files = DatasetFiles(self.config.training_data_uri, tmp_dir) dataset_files.download() model_files = ModelFiles( self.config.training_output_uri, tmp_dir, replace_model=self.config.train_options.replace_model) model_paths = model_files.download_backend_config( self.config.pretrained_model_uri, self.config.kc_config, dataset_files, self.class_map) backend_config_path, pretrained_model_path = model_paths # Get output from potential previous run so we can resume training. if not self.config.train_options.replace_model: sync_from_dir(self.config.training_output_uri, model_files.base_dir) sync = start_sync( model_files.base_dir, self.config.training_output_uri, sync_interval=self.config.train_options.sync_interval) with sync: do_monitoring = self.config.train_options.do_monitoring _train(backend_config_path, pretrained_model_path, do_monitoring) # Perform final sync sync_to_dir(model_files.base_dir, self.config.training_output_uri, delete=True)
def test_sync_from_dir_noop_local(self): path = os.path.join(self.temp_dir.name, 'lorem', 'ipsum.txt') src = os.path.join(self.temp_dir.name, 'lorem') make_dir(src, check_empty=False) fs = FileSystem.get_file_system(src, 'r') fs.write_bytes(path, bytes([0x00, 0x01])) sync_from_dir(src, src, delete=True) self.assertEqual(len(list_paths(src)), 1)
def train(self, tmp_dir): training_package = TrainingPackage(self.config.training_data_uri, self.config, tmp_dir, self.partition_id) # Download training data and update config file. training_package.download_data() config_path = training_package.download_config(self.class_map) # Setup output dirs. output_dir = get_local_path(self.config.training_output_uri, tmp_dir) make_dir(output_dir) # Get output from potential previous run so we can resume training. if not self.config.train_options.replace_model: sync_from_dir(self.config.training_output_uri, output_dir) else: for f in os.listdir(output_dir): if not f.startswith('command-config'): path = os.path.join(output_dir, f) if os.path.isfile(path): os.remove(path) else: shutil.rmtree(path) local_config_path = os.path.join(output_dir, 'pipeline.config') shutil.copy(config_path, local_config_path) model_main_py = self.config.script_locations.model_main_uri export_py = self.config.script_locations.export_uri # Train model and sync output periodically. sync = start_sync( output_dir, self.config.training_output_uri, sync_interval=self.config.train_options.sync_interval) with sync: train(local_config_path, output_dir, self.config.get_num_steps(), model_main_py=model_main_py, do_monitoring=self.config.train_options.do_monitoring) export_inference_graph( output_dir, local_config_path, output_dir, fine_tune_checkpoint_name=self.config.fine_tune_checkpoint_name, export_py=export_py) # Perform final sync sync_to_dir(output_dir, self.config.training_output_uri)
def train(self, tmp_dir): """Train a model. This downloads any previous output saved to the train_uri, starts training (or resumes from a checkpoint), periodically syncs contents of train_dir to train_uri and after training finishes. Args: tmp_dir: (str) path to temp directory """ self.log_options() # Sync output of previous training run from cloud. train_uri = self.backend_opts.train_uri train_dir = get_local_path(train_uri, tmp_dir) make_dir(train_dir) sync_from_dir(train_uri, train_dir) # Get zip file for each group, and unzip them into chip_dir. chip_dir = join(tmp_dir, 'chips') make_dir(chip_dir) for zip_uri in list_paths(self.backend_opts.chip_uri, 'zip'): zip_path = download_if_needed(zip_uri, tmp_dir) with zipfile.ZipFile(zip_path, 'r') as zipf: zipf.extractall(chip_dir) # Setup data loader. batch_size = self.train_opts.batch_size chip_size = self.task_config.chip_size class_names = self.class_map.get_class_names() databunch = build_databunch(chip_dir, chip_size, batch_size, class_names) log.info(databunch) num_labels = len(databunch.label_names) if self.train_opts.debug: make_debug_chips(databunch, self.class_map, tmp_dir, train_uri) # Setup model num_labels = len(databunch.label_names) model = get_model(self.train_opts.model_arch, num_labels, pretrained=True) model = model.to(self.device) model_path = join(train_dir, 'model') # Load weights from a pretrained model. pretrained_uri = self.backend_opts.pretrained_uri if pretrained_uri: log.info('Loading weights from pretrained_uri: {}'.format( pretrained_uri)) pretrained_path = download_if_needed(pretrained_uri, tmp_dir) model.load_state_dict( torch.load(pretrained_path, map_location=self.device)) # Possibly resume training from checkpoint. start_epoch = 0 train_state_path = join(train_dir, 'train_state.json') if isfile(train_state_path): log.info('Resuming from checkpoint: {}\n'.format(model_path)) train_state = file_to_json(train_state_path) start_epoch = train_state['epoch'] + 1 model.load_state_dict( torch.load(model_path, map_location=self.device)) # Write header of log CSV file. metric_names = ['precision', 'recall', 'f1'] log_path = join(train_dir, 'log.csv') if not isfile(log_path): with open(log_path, 'w') as log_file: log_writer = csv.writer(log_file) row = ['epoch', 'time', 'train_loss'] + metric_names log_writer.writerow(row) # Setup Tensorboard logging. if self.train_opts.log_tensorboard: log_dir = join(train_dir, 'tb-logs') make_dir(log_dir) tb_writer = SummaryWriter(log_dir=log_dir) if self.train_opts.run_tensorboard: log.info('Starting tensorboard process') tensorboard_process = Popen( ['tensorboard', '--logdir={}'.format(log_dir)]) terminate_at_exit(tensorboard_process) # Setup optimizer, loss, and LR scheduler. loss_fn = torch.nn.CrossEntropyLoss() lr = self.train_opts.lr opt = optim.Adam(model.parameters(), lr=lr) step_scheduler, epoch_scheduler = None, None num_epochs = self.train_opts.num_epochs if self.train_opts.one_cycle and num_epochs > 1: steps_per_epoch = len(databunch.train_ds) // batch_size total_steps = num_epochs * steps_per_epoch step_size_up = (num_epochs // 2) * steps_per_epoch step_size_down = total_steps - step_size_up step_scheduler = CyclicLR(opt, base_lr=lr / 10, max_lr=lr, step_size_up=step_size_up, step_size_down=step_size_down, cycle_momentum=False) for _ in range(start_epoch * steps_per_epoch): step_scheduler.step() # Training loop. for epoch in range(start_epoch, num_epochs): # Train one epoch. log.info('-----------------------------------------------------') log.info('epoch: {}'.format(epoch)) start = time.time() train_loss = train_epoch(model, self.device, databunch.train_dl, opt, loss_fn, step_scheduler) if epoch_scheduler: epoch_scheduler.step() log.info('train loss: {}'.format(train_loss)) # Validate one epoch. metrics = validate_epoch(model, self.device, databunch.valid_dl, num_labels) log.info('validation metrics: {}'.format(metrics)) # Print elapsed time for epoch. end = time.time() epoch_time = datetime.timedelta(seconds=end - start) log.info('epoch elapsed time: {}'.format(epoch_time)) # Save model and state. torch.save(model.state_dict(), model_path) train_state = {'epoch': epoch} json_to_file(train_state, train_state_path) # Append to log CSV file. with open(log_path, 'a') as log_file: log_writer = csv.writer(log_file) row = [epoch, epoch_time, train_loss] row += [metrics[k] for k in metric_names] log_writer.writerow(row) # Write to Tensorboard log. if self.train_opts.log_tensorboard: for key, val in metrics.items(): tb_writer.add_scalar(key, val, epoch) tb_writer.add_scalar('train_loss', train_loss, epoch) for name, param in model.named_parameters(): tb_writer.add_histogram(name, param, epoch) if (train_uri.startswith('s3://') and (((epoch + 1) % self.train_opts.sync_interval) == 0)): sync_to_dir(train_dir, train_uri) # Close Tensorboard. if self.train_opts.log_tensorboard: tb_writer.close() if self.train_opts.run_tensorboard: tensorboard_process.terminate() # Since model is exported every epoch, we need some other way to # show that training is finished. str_to_file('done!', self.backend_opts.train_done_uri) # Sync output to cloud. sync_to_dir(train_dir, self.backend_opts.train_uri)
def train(self, tmp_dir): """Train a model.""" self.print_options() # Sync output of previous training run from cloud. train_uri = self.backend_opts.train_uri train_dir = get_local_path(train_uri, tmp_dir) make_dir(train_dir) sync_from_dir(train_uri, train_dir) ''' Get zip file for each group, and unzip them into chip_dir in a way that works well with FastAI. The resulting directory structure would be: <chip_dir>/ train/ training-<uuid1>/ <class1>/ ... <class2>/ ... ... training-<uuid2>/ <class1>/ ... <class2>/ ... ... ... val/ validation-<uuid1>/ <class1>/ ... <class2>/ ... ... validation-<uuid2>/ <class1>/ ... <class2>/ ... ... ... ''' chip_dir = join(tmp_dir, 'chips/') make_dir(chip_dir) for zip_uri in list_paths(self.backend_opts.chip_uri, 'zip'): zip_name = Path(zip_uri).name if zip_name.startswith('train'): extract_dir = chip_dir + 'train/' elif zip_name.startswith('val'): extract_dir = chip_dir + 'val/' else: continue zip_path = download_if_needed(zip_uri, tmp_dir) with zipfile.ZipFile(zip_path, 'r') as zipf: zipf.extractall(extract_dir) # Setup data loader. def get_label_path(im_path): return Path(str(im_path.parent)[:-4] + '-labels') / im_path.name size = self.task_config.chip_size class_map = self.task_config.class_map classes = class_map.get_class_names() num_workers = 0 if self.train_opts.debug else 4 tfms = get_transforms(flip_vert=self.train_opts.flip_vert) def get_data(train_sampler=None): data = (ImageList.from_folder(chip_dir).split_by_folder( train='train', valid='val').label_from_folder().transform( tfms, size=size).databunch( bs=self.train_opts.batch_sz, num_workers=num_workers, )) return data data = get_data() if self.train_opts.debug: make_debug_chips(data, class_map, tmp_dir, train_uri) # Setup learner. ignore_idx = -1 metrics = [ Precision(average='weighted', clas_idx=1, ignore_idx=ignore_idx), Recall(average='weighted', clas_idx=1, ignore_idx=ignore_idx), FBeta(average='weighted', clas_idx=1, beta=1, ignore_idx=ignore_idx) ] model_arch = getattr(models, self.train_opts.model_arch) learn = cnn_learner(data, model_arch, metrics=metrics, wd=self.train_opts.weight_decay, path=train_dir) learn.unfreeze() if self.train_opts.fp16 and torch.cuda.is_available(): # This loss_scale works for Resnet 34 and 50. You might need to adjust this # for other models. learn = learn.to_fp16(loss_scale=256) # Setup callbacks and train model. model_path = get_local_path(self.backend_opts.model_uri, tmp_dir) pretrained_uri = self.backend_opts.pretrained_uri if pretrained_uri: print('Loading weights from pretrained_uri: {}'.format( pretrained_uri)) pretrained_path = download_if_needed(pretrained_uri, tmp_dir) learn.model.load_state_dict(torch.load( pretrained_path, map_location=learn.data.device), strict=False) # Save every epoch so that resume functionality provided by # TrackEpochCallback will work. callbacks = [ TrackEpochCallback(learn), MySaveModelCallback(learn, every='epoch'), MyCSVLogger(learn, filename='log'), ExportCallback(learn, model_path, monitor='f_beta'), SyncCallback(train_dir, self.backend_opts.train_uri, self.train_opts.sync_interval) ] lr = self.train_opts.lr num_epochs = self.train_opts.num_epochs if self.train_opts.one_cycle: if lr is None: learn.lr_find() learn.recorder.plot(suggestion=True, return_fig=True) lr = learn.recorder.min_grad_lr print('lr_find() found lr: {}'.format(lr)) learn.fit_one_cycle(num_epochs, lr, callbacks=callbacks) else: learn.fit(num_epochs, lr, callbacks=callbacks) # Since model is exported every epoch, we need some other way to # show that training is finished. str_to_file('done!', self.backend_opts.train_done_uri) # Sync output to cloud. sync_to_dir(train_dir, self.backend_opts.train_uri)
def train(self, tmp_dir: str) -> None: """Train a DeepLab model the task and backend config. Args: tmp_dir: (str) temporary directory to use Returns: None """ train_py = self.backend_config.script_locations.train_py eval_py = self.backend_config.script_locations.eval_py export_py = self.backend_config.script_locations.export_py # Setup local input and output directories log.info('Setting up local input and output directories') train_logdir = self.backend_config.training_output_uri train_logdir_local = get_local_path(train_logdir, tmp_dir) dataset_dir = get_record_dir(self.backend_config.training_data_uri, TRAIN) dataset_dir_local = get_local_path(dataset_dir, tmp_dir) make_dir(tmp_dir) make_dir(train_logdir_local) make_dir(dataset_dir_local) # Download training data log.info('Downloading training data') for i, record_file in enumerate(list_paths(dataset_dir)): download_if_needed(record_file, tmp_dir) # Download and untar initial checkpoint. log.info('Downloading and untarring initial checkpoint') tf_initial_checkpoints_uri = self.backend_config.pretrained_model_uri download_if_needed(tf_initial_checkpoints_uri, tmp_dir) tfic_tarball = get_local_path(tf_initial_checkpoints_uri, tmp_dir) tfic_dir = os.path.dirname(tfic_tarball) with tarfile.open(tfic_tarball, 'r:gz') as tar: tar.extractall(tfic_dir) tfic_ckpt = glob.glob('{}/*/*.index'.format(tfic_dir))[0] tfic_ckpt = tfic_ckpt[0:-len('.index')] # Restart support train_restart_dir = self.backend_config.train_options.train_restart_dir if type(train_restart_dir) is not str or len(train_restart_dir) == 0: train_restart_dir = train_logdir # Get output from potential previous run so we can resume training. if type(train_restart_dir) is str and len( train_restart_dir ) > 0 and not self.backend_config.train_options.replace_model: sync_from_dir(train_restart_dir, train_logdir_local) else: if self.backend_config.train_options.replace_model: if os.path.exists(train_logdir_local): shutil.rmtree(train_logdir_local) make_dir(train_logdir_local) # Periodically synchronize with remote sync = start_sync( train_logdir_local, train_logdir, sync_interval=self.backend_config.train_options.sync_interval) with sync: # Setup TFDL config tfdl_config = json_format.ParseDict( self.backend_config.tfdl_config, TrainingParametersMsg()) log.info('tfdl_config={}'.format(tfdl_config)) log.info('Training steps={}'.format( tfdl_config.training_number_of_steps)) # Additional training options max_class = max( list(map(lambda c: c.id, self.class_map.get_items()))) num_classes = len(self.class_map.get_items()) num_classes = max(max_class, num_classes) + 1 (train_args, train_env) = get_training_args( train_py, train_logdir_local, tfic_ckpt, dataset_dir_local, num_classes, tfdl_config) # Start training log.info('Starting training process') log.info(' '.join(train_args)) train_process = Popen(train_args, env=train_env) terminate_at_exit(train_process) if self.backend_config.train_options.do_monitoring: # Start tensorboard log.info('Starting tensorboard process') tensorboard_process = Popen( ['tensorboard', '--logdir={}'.format(train_logdir_local)]) terminate_at_exit(tensorboard_process) if self.backend_config.train_options.do_eval: # Start eval script log.info('Starting eval script') eval_logdir = train_logdir_local eval_args = get_evaluation_args(eval_py, train_logdir_local, dataset_dir_local, eval_logdir, tfdl_config) eval_process = Popen(eval_args, env=train_env) terminate_at_exit(eval_process) # Wait for training and tensorboard log.info('Waiting for training and tensorboard processes') train_process.wait() if self.backend_config.train_options.do_monitoring: tensorboard_process.terminate() # Export frozen graph log.info( 'Exporting frozen graph ({}/model)'.format(train_logdir_local)) export_args = get_export_args(export_py, train_logdir_local, num_classes, tfdl_config) export_process = Popen(export_args) terminate_at_exit(export_process) export_process.wait() # Package up the model files for usage as fine tuning checkpoints fine_tune_checkpoint_name = self.backend_config.fine_tune_checkpoint_name latest_checkpoints = get_latest_checkpoint(train_logdir_local) model_checkpoint_files = glob.glob( '{}*'.format(latest_checkpoints)) inference_graph_path = os.path.join(train_logdir_local, 'model') with RVConfig.get_tmp_dir() as tmp_dir: model_dir = os.path.join(tmp_dir, fine_tune_checkpoint_name) make_dir(model_dir) model_tar = os.path.join( train_logdir_local, '{}.tar.gz'.format(fine_tune_checkpoint_name)) shutil.copy(inference_graph_path, '{}/frozen_inference_graph.pb'.format(model_dir)) for path in model_checkpoint_files: shutil.copy(path, model_dir) with tarfile.open(model_tar, 'w:gz') as tar: tar.add(model_dir, arcname=os.path.basename(model_dir)) # Perform final sync sync_to_dir(train_logdir_local, train_logdir, delete=False)
def sync_from_cloud(self): if self.cfg.output_uri.startswith('s3://'): sync_from_dir(self.cfg.output_uri, self.output_dir)
def train(self, tmp_dir): """Train a model.""" self.print_options() # Sync output of previous training run from cloud. train_uri = self.backend_opts.train_uri train_dir = get_local_path(train_uri, tmp_dir) make_dir(train_dir) sync_from_dir(train_uri, train_dir) # Get zip file for each group, and unzip them into chip_dir. chip_dir = join(tmp_dir, 'chips') make_dir(chip_dir) for zip_uri in list_paths(self.backend_opts.chip_uri, 'zip'): zip_path = download_if_needed(zip_uri, tmp_dir) with zipfile.ZipFile(zip_path, 'r') as zipf: zipf.extractall(chip_dir) # Setup data loader. train_images = [] train_lbl_bbox = [] for annotation_path in glob.glob(join(chip_dir, 'train/*.json')): images, lbl_bbox = get_annotations(annotation_path) train_images += images train_lbl_bbox += lbl_bbox val_images = [] val_lbl_bbox = [] for annotation_path in glob.glob(join(chip_dir, 'valid/*.json')): images, lbl_bbox = get_annotations(annotation_path) val_images += images val_lbl_bbox += lbl_bbox images = train_images + val_images lbl_bbox = train_lbl_bbox + val_lbl_bbox img2bbox = dict(zip(images, lbl_bbox)) get_y_func = lambda o: img2bbox[o.name] num_workers = 0 if self.train_opts.debug else 4 data = ObjectItemList.from_folder(chip_dir) data = data.split_by_folder() data = data.label_from_func(get_y_func) data = data.transform( get_transforms(), size=self.task_config.chip_size, tfm_y=True) data = data.databunch( bs=self.train_opts.batch_sz, collate_fn=bb_pad_collate, num_workers=num_workers) print(data) if self.train_opts.debug: make_debug_chips( data, self.task_config.class_map, tmp_dir, train_uri) # Setup callbacks and train model. ratios = [1/2, 1, 2] scales = [1, 2**(-1/3), 2**(-2/3)] model_arch = getattr(models, self.train_opts.model_arch) encoder = create_body(model_arch, cut=-2) model = RetinaNet(encoder, data.c, final_bias=-4) crit = RetinaNetFocalLoss(scales=scales, ratios=ratios) learn = Learner(data, model, loss_func=crit, path=train_dir) learn = learn.split(retina_net_split) model_path = get_local_path(self.backend_opts.model_uri, tmp_dir) pretrained_uri = self.backend_opts.pretrained_uri if pretrained_uri: print('Loading weights from pretrained_uri: {}'.format( pretrained_uri)) pretrained_path = download_if_needed(pretrained_uri, tmp_dir) learn.load(pretrained_path[:-4]) callbacks = [ TrackEpochCallback(learn), SaveModelCallback(learn, every='epoch'), MyCSVLogger(learn, filename='log'), ExportCallback(learn, model_path), SyncCallback(train_dir, self.backend_opts.train_uri, self.train_opts.sync_interval) ] learn.unfreeze() learn.fit(self.train_opts.num_epochs, self.train_opts.lr, callbacks=callbacks) # Since model is exported every epoch, we need some other way to # show that training is finished. str_to_file('done!', self.backend_opts.train_done_uri) # Sync output to cloud. sync_to_dir(train_dir, self.backend_opts.train_uri)
def test_sync_from_http(self): src = 'http://localhost/' dst = self.temp_dir.name self.assertRaises(NotReadableError, lambda: sync_from_dir(src, dst))
def train(self, tmp_dir): """Train a model.""" self.print_options() # Sync output of previous training run from cloud. # This will either be local or S3. This allows restarting the job if it has been shut down. train_uri = self.backend_opts.train_uri train_dir = get_local_path(train_uri, tmp_dir) make_dir(train_dir) sync_from_dir(train_uri, train_dir) # Get zip file for each group, and unzip them into chip_dir. self.chip_dir = join(tmp_dir, 'chips') make_dir(self.chip_dir) train_chip_dir = self.chip_dir + '/train-img' train_truth_dir = self.chip_dir + '/train-labels' fitness_func = partial(fitness, train_chip_dir, train_truth_dir, self._toolbox.compile) self._toolbox.register("evaluate", fitness_func) # This is the key part -- this is how it knows where to get the chips from. # backend_opts comes from RV, and train_opts is where you can define backend-specific stuff. for zip_uri in list_paths(self.backend_opts.chip_uri, 'zip'): zip_path = download_if_needed(zip_uri, tmp_dir) with zipfile.ZipFile(zip_path, 'r') as zipf: zipf.extractall(self.chip_dir) # Setup data loader. def get_label_path(im_path): return Path(str(im_path.parent)[:-4] + '-labels') / im_path.name class_map = self.task_config.class_map classes = class_map.get_class_names() if 0 not in class_map.get_keys(): classes = ['nodata'] + classes # Evolve # Set up hall of fame to track the best individual hof = tools.HallOfFame(1) # Set up debugging mstats = None if self.train_opts.debug: stats_fit = tools.Statistics(lambda ind: ind.fitness.values) stats_size = tools.Statistics(len) mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size) mstats.register("averageaverage", np.mean) mstats.register("stdeviation", np.std) mstats.register("minimumstat", np.min) mstats.register("maximumstat", np.max) pop = self._toolbox.population(n=self.train_opts.pop_size) pop, log = algorithms.eaMuPlusLambda( pop, self._toolbox, self.train_opts.num_individuals, self.train_opts.num_offspring, self.train_opts.crossover_rate, self.train_opts.mutation_rate, self.train_opts.num_generations, stats=mstats, halloffame=hof, verbose=self.train_opts.debug ) # ? What should my model output be given that the output is just a string? Should I output a # text file? # RV uses file-presence based caching to figure out whether a stage has completed (kinda # like Makefiles). So since this outputs a file every epoch, it needs to use something else # to trigger done-ness. # Since model is exported every epoch, we need some other way to # show that training is finished. if self.train_opts.debug: print(str(hof[0])) str_to_file(str(hof[0]), self.backend_opts.train_done_uri) str_to_file(str(hof[0]), self.backend_opts.model_uri) # Sync output to cloud. sync_to_dir(train_dir, self.backend_opts.train_uri)
def train(self, tmp_dir): """Train a model. This downloads any previous output saved to the train_uri, starts training (or resumes from a checkpoint), periodically syncs contents of train_dir to train_uri and after training finishes. Args: tmp_dir: (str) path to temp directory """ self.log_options() # Sync output of previous training run from cloud. train_uri = self.backend_opts.train_uri train_dir = get_local_path(train_uri, tmp_dir) make_dir(train_dir) sync_from_dir(train_uri, train_dir) # Get zip file for each group, and unzip them into chip_dir. chip_dir = join(tmp_dir, 'chips') make_dir(chip_dir) for zip_uri in list_paths(self.backend_opts.chip_uri, 'zip'): zip_path = download_if_needed(zip_uri, tmp_dir) with zipfile.ZipFile(zip_path, 'r') as zipf: zipf.extractall(chip_dir) # Setup data loader. def get_label_path(im_path): return Path(str(im_path.parent)[:-4] + '-labels') / im_path.name size = self.task_config.chip_size class_map = self.task_config.class_map classes = class_map.get_class_names() if 0 not in class_map.get_keys(): classes = ['nodata'] + classes num_workers = 0 if self.train_opts.debug else 4 data = (SegmentationItemList.from_folder(chip_dir) .split_by_folder(train='train-img', valid='val-img')) train_count = None if self.train_opts.train_count is not None: train_count = min(len(data.train), self.train_opts.train_count) elif self.train_opts.train_prop != 1.0: train_count = int(round(self.train_opts.train_prop * len(data.train))) train_items = data.train.items if train_count is not None: train_inds = np.random.permutation(np.arange(len(data.train)))[0:train_count] train_items = train_items[train_inds] items = np.concatenate([train_items, data.valid.items]) data = (SegmentationItemList(items, chip_dir) .split_by_folder(train='train-img', valid='val-img') .label_from_func(get_label_path, classes=classes) .transform(get_transforms(flip_vert=self.train_opts.flip_vert), size=size, tfm_y=True) .databunch(bs=self.train_opts.batch_sz, num_workers=num_workers)) print(data) # Setup learner. ignore_idx = 0 metrics = [ Precision(average='weighted', clas_idx=1, ignore_idx=ignore_idx), Recall(average='weighted', clas_idx=1, ignore_idx=ignore_idx), FBeta(average='weighted', clas_idx=1, beta=1, ignore_idx=ignore_idx)] model_arch = getattr(models, self.train_opts.model_arch) learn = unet_learner( data, model_arch, metrics=metrics, wd=self.train_opts.weight_decay, bottle=True, path=train_dir) learn.unfreeze() if self.train_opts.mixed_prec and torch.cuda.is_available(): # This loss_scale works for Resnet 34 and 50. You might need to adjust this # for other models. learn = learn.to_fp16(loss_scale=256) # Setup callbacks and train model. model_path = get_local_path(self.backend_opts.model_uri, tmp_dir) pretrained_uri = self.backend_opts.pretrained_uri if pretrained_uri: print('Loading weights from pretrained_uri: {}'.format( pretrained_uri)) pretrained_path = download_if_needed(pretrained_uri, tmp_dir) learn.model.load_state_dict( torch.load(pretrained_path, map_location=learn.data.device), strict=False) # Save every epoch so that resume functionality provided by # TrackEpochCallback will work. callbacks = [ TrackEpochCallback(learn), MySaveModelCallback(learn, every='epoch'), MyCSVLogger(learn, filename='log'), ExportCallback(learn, model_path, monitor='f_beta'), SyncCallback(train_dir, self.backend_opts.train_uri, self.train_opts.sync_interval) ] oversample = self.train_opts.oversample if oversample: weights = get_oversampling_weights( data.train_ds, oversample['rare_class_ids'], oversample['rare_target_prop']) oversample_callback = OverSamplingCallback(learn, weights=weights) callbacks.append(oversample_callback) if self.train_opts.debug: if oversample: oversample_callback.on_train_begin() make_debug_chips(data, class_map, tmp_dir, train_uri) if self.train_opts.log_tensorboard: callbacks.append(TensorboardLogger(learn, 'run')) if self.train_opts.run_tensorboard: log.info('Starting tensorboard process') log_dir = join(train_dir, 'logs', 'run') tensorboard_process = Popen( ['tensorboard', '--logdir={}'.format(log_dir)]) terminate_at_exit(tensorboard_process) lr = self.train_opts.lr num_epochs = self.train_opts.num_epochs if self.train_opts.one_cycle: if lr is None: learn.lr_find() learn.recorder.plot(suggestion=True, return_fig=True) lr = learn.recorder.min_grad_lr print('lr_find() found lr: {}'.format(lr)) learn.fit_one_cycle(num_epochs, lr, callbacks=callbacks) else: learn.fit(num_epochs, lr, callbacks=callbacks) if self.train_opts.run_tensorboard: tensorboard_process.terminate() # Since model is exported every epoch, we need some other way to # show that training is finished. str_to_file('done!', self.backend_opts.train_done_uri) # Sync output to cloud. sync_to_dir(train_dir, self.backend_opts.train_uri)
def train(self, tmp_dir): """Train a model.""" # Setup hyperparams. bs = int(self.config.get('bs', 8)) wd = self.config.get('wd', 1e-2) lr = self.config.get('lr', 2e-3) num_epochs = int(self.config.get('num_epochs', 10)) model_arch = self.config.get('model_arch', 'resnet50') model_arch = getattr(models, model_arch) fp16 = self.config.get('fp16', False) sync_interval = self.config.get('sync_interval', 1) debug = self.config.get('debug', False) chip_uri = self.config['chip_uri'] train_uri = self.config['train_uri'] # Sync output of previous training run from cloud. train_dir = get_local_path(train_uri, tmp_dir) make_dir(train_dir) sync_from_dir(train_uri, train_dir) # Get zip file for each group, and unzip them into chip_dir. chip_dir = join(tmp_dir, 'chips') make_dir(chip_dir) for zip_uri in list_paths(chip_uri, 'zip'): zip_path = download_if_needed(zip_uri, tmp_dir) with zipfile.ZipFile(zip_path, 'r') as zipf: zipf.extractall(chip_dir) # Setup data loader. def get_label_path(im_path): return Path(str(im_path.parent)[:-4] + '-labels') / im_path.name size = self.task_config.chip_size classes = ['nodata'] + self.task_config.class_map.get_class_names() data = (SegmentationItemList.from_folder(chip_dir).split_by_folder( train='train-img', valid='val-img').label_from_func( get_label_path, classes=classes).transform(get_transforms(), size=size, tfm_y=True).databunch(bs=bs)) print(data) if debug: # We make debug chips during the run-time of the train command # rather than the chip command # because this is a better test (see "visualize just before the net" # in https://karpathy.github.io/2019/04/25/recipe/), and because # it's more convenient since we have the databunch here. # TODO make color map based on colors in class_map # TODO get rid of white frame # TODO zip them def _make_debug_chips(split): debug_chips_dir = join(train_uri, '{}-debug-chips'.format(split)) make_dir(debug_chips_dir) ds = data.train_ds if split == 'train' else data.valid_ds for i, (x, y) in enumerate(ds): x.show(y=y) plt.savefig(join(debug_chips_dir, '{}.png'.format(i))) plt.close() _make_debug_chips('train') _make_debug_chips('val') # Setup learner. metrics = [semseg_acc] learn = unet_learner(data, model_arch, metrics=metrics, wd=wd, bottle=True) learn.unfreeze() if fp16 and torch.cuda.is_available(): # This loss_scale works for Resnet 34 and 50. You might need to adjust this # for other models. learn = learn.to_fp16(loss_scale=256) # Setup ability to resume training if model exists. # This hack won't properly set the learning as a function of epochs # when resuming. learner_path = join(train_dir, 'learner.pth') log_path = join(train_dir, 'log') start_epoch = 0 if isfile(learner_path): print('Loading saved model...') start_epoch = get_last_epoch(str(log_path) + '.csv') + 1 if start_epoch >= num_epochs: print('Training is already done. If you would like to re-train' ', delete the previous results of training in ' '{}.'.format(train_uri)) return learn.load(learner_path[:-4]) print('Resuming from epoch {}'.format(start_epoch)) print( 'Note: fastai does not support a start_epoch, so epoch 0 below ' 'corresponds to {}'.format(start_epoch)) epochs_left = num_epochs - start_epoch # Setup callbacks and train model. callbacks = [ SaveModelCallback(learn, name=learner_path[:-4]), MyCSVLogger(learn, filename=log_path, start_epoch=start_epoch), SyncCallback(train_dir, train_uri, sync_interval) ] learn.fit(epochs_left, lr, callbacks=callbacks) # Export model for inference model_uri = self.config['model_uri'] model_path = get_local_path(model_uri, tmp_dir) learn.export(model_path) # Sync output to cloud. sync_to_dir(train_dir, train_uri)
def train(self, tmp_dir): """Train a model.""" self.print_options() # Sync output of previous training run from cloud. train_uri = self.backend_opts.train_uri train_dir = get_local_path(train_uri, tmp_dir) make_dir(train_dir) sync_from_dir(train_uri, train_dir) # Get zip file for each group, and unzip them into chip_dir. chip_dir = join(tmp_dir, 'chips') make_dir(chip_dir) for zip_uri in list_paths(self.backend_opts.chip_uri, 'zip'): zip_path = download_if_needed(zip_uri, tmp_dir) with zipfile.ZipFile(zip_path, 'r') as zipf: zipf.extractall(chip_dir) # Setup data loader. def get_label_path(im_path): return Path(str(im_path.parent)[:-4] + '-labels') / im_path.name size = self.task_config.chip_size class_map = self.task_config.class_map classes = class_map.get_class_names() if 0 not in class_map.get_keys(): classes = ['nodata'] + classes num_workers = 0 if self.train_opts.debug else 4 train_img_dir = self.subset_training_data(chip_dir) def get_data(train_sampler=None): data = (SegmentationItemList.from_folder(chip_dir).split_by_folder( train=train_img_dir, valid='val-img').label_from_func( get_label_path, classes=classes).transform( get_transforms(flip_vert=self.train_opts.flip_vert), size=size, tfm_y=True).databunch(bs=self.train_opts.batch_sz, num_workers=num_workers, train_sampler=train_sampler)) return data data = get_data() oversample = self.train_opts.oversample if oversample: sampler = get_weighted_sampler(data.train_ds, oversample['rare_class_ids'], oversample['rare_target_prop']) data = get_data(train_sampler=sampler) if self.train_opts.debug: make_debug_chips(data, class_map, tmp_dir, train_uri) # Setup learner. ignore_idx = 0 metrics = [ Precision(average='weighted', clas_idx=1, ignore_idx=ignore_idx), Recall(average='weighted', clas_idx=1, ignore_idx=ignore_idx), FBeta(average='weighted', clas_idx=1, beta=1, ignore_idx=ignore_idx) ] model_arch = getattr(models, self.train_opts.model_arch) learn = unet_learner(data, model_arch, metrics=metrics, wd=self.train_opts.weight_decay, bottle=True, path=train_dir) learn.unfreeze() if self.train_opts.fp16 and torch.cuda.is_available(): # This loss_scale works for Resnet 34 and 50. You might need to adjust this # for other models. learn = learn.to_fp16(loss_scale=256) # Setup callbacks and train model. model_path = get_local_path(self.backend_opts.model_uri, tmp_dir) pretrained_uri = self.backend_opts.pretrained_uri if pretrained_uri: print('Loading weights from pretrained_uri: {}'.format( pretrained_uri)) pretrained_path = download_if_needed(pretrained_uri, tmp_dir) learn.model.load_state_dict(torch.load( pretrained_path, map_location=learn.data.device), strict=False) # Save every epoch so that resume functionality provided by # TrackEpochCallback will work. callbacks = [ TrackEpochCallback(learn), MySaveModelCallback(learn, every='epoch'), MyCSVLogger(learn, filename='log'), ExportCallback(learn, model_path, monitor='f_beta'), SyncCallback(train_dir, self.backend_opts.train_uri, self.train_opts.sync_interval) ] lr = self.train_opts.lr num_epochs = self.train_opts.num_epochs if self.train_opts.one_cycle: if lr is None: learn.lr_find() learn.recorder.plot(suggestion=True, return_fig=True) lr = learn.recorder.min_grad_lr print('lr_find() found lr: {}'.format(lr)) learn.fit_one_cycle(num_epochs, lr, callbacks=callbacks) else: learn.fit(num_epochs, lr, callbacks=callbacks) # Since model is exported every epoch, we need some other way to # show that training is finished. str_to_file('done!', self.backend_opts.train_done_uri) # Sync output to cloud. sync_to_dir(train_dir, self.backend_opts.train_uri)