def train_hold_out(model, criterion, optimizer, args, train_set, val_set, test_set, single_view=False): """ Perform a train with validation train split on the given model. Use args.val_split_size to set the percentage of data for the validation set. Keep in mind the two validation sets are genereted. One for early stopping and one to evaluate the model. All the data are sent to wandb or logged on a text file Parameters ---------- model : RotaitonNet model criterion : Pytorch criterion (CrossEntropy for RotationNet) optimizer : Pytorch optimizer (e.g. SGD) args : Input args from the parser Returns ------- Nothing """ # Generate loaders test_loader = DataLoader(test_set, batch_size=args.batch_size, shuffle=single_view, num_workers=args.workers, pin_memory=True, drop_last=True) val_loader = DataLoader(val_set, batch_size=args.batch_size, shuffle=single_view, num_workers=args.workers, pin_memory=True, drop_last=True) train_loader = DataLoader(train_set, batch_size=args.batch_size, shuffle=single_view, num_workers=args.workers, pin_memory=True, drop_last=True) # Track model in wandb #wandb.init(project="MVCNN", config=args, reinit=True) # wandb.watch(model) train(model, criterion, optimizer, train_loader, val_loader, args, single_view) load_model(model, args.fname_best) val_statistics = validate(test_loader, model, criterion, args, single_view) log_summary(val_statistics, "val", test_loader.dataset.dataset.classes)
def predict(environ, start_response): # Load input image data from the HTTP request request = Request(environ) if not request.files: return Response('no file uploaded', 400)(environ, start_response) image_file = next(request.files.values()) image, inverted = process_image(Image.open(image_file)) # The predictor must be lazily instantiated; # the TensorFlow graph can apparently not be shared # between processes. global model if not model: model = load_model('model.h5') prediction = predict_image(model, image, inverted) # The following line allows Valohai to track endpoint predictions # while the model is deployed. Here we remove the full predictions # details as we are only interested in tracking the rest of the results. print( json.dumps({ 'vh_metadata': {k: v for k, v in prediction.items() if k != 'predictions'} })) # Return a JSON response response = Response(json.dumps(prediction), content_type='application/json') return response(environ, start_response)
def main(page_title, page_icon, layout='centered', initial_sidebar_state='expanded'): # Config the streamlit app st.set_page_config(page_title=page_title, page_icon=page_icon, layout=layout, initial_sidebar_state=initial_sidebar_state) # Load styles/assets load_remote_css( "https://cdn.jsdelivr.net/gh/rastikerdar/vazir-font/dist/font-face.css" ) load_local_css(BASE_DIR + '/assets/style.css') load_local_css(BASE_DIR + '/assets/rtl.css') # Sidebar # st.sidebar.image(logo, width=120) st.sidebar.markdown('<h1 class="text-center">WikiSummary</h1>', unsafe_allow_html=True) st.sidebar.markdown(MODEL_DESC, unsafe_allow_html=True) # Load examples ex_names, ex_map = load_examples(BASE_DIR + '/assets/example.json') # Main example = st.selectbox('Choose an example', ex_names) if ex_map[example][1]: link = st.markdown( f'<a class="rtl" href="{ex_map[example][1]}">{example}</a>', unsafe_allow_html=True) height = min((len(ex_map[example][0].split()) + 1) * 2, 200) sequence = st.text_area('Text', ex_map[example][0], key='sequence', height=height) if len(sequence) == 0: st.write('Enter some text to see summarization.') return with st.spinner('Loading the components ...'): config = load_config(MODEL_NAME_OR_PATH) tokenizer = load_tokenizer(MODEL_NAME_OR_PATH) model = load_model(MODEL_NAME_OR_PATH, config=config) # model = load_model(MODEL_NAME_OR_PATH) with st.spinner('Summarizing ...'): summary = generate_output(model, tokenizer, cleaning(sequence)) summary = summary[0] if len(summary) > 0 else summary st.markdown(DISABLED_TEXTAREA.format( **{ 'attributes': 'class="generated-headline rtl"', 'value': f'<span class="r-label">خلاصه سازی</span> {summary}' }), unsafe_allow_html=True)
def eval_dataset(dataset, model_path, cfg): model = SqueezeDet(cfg) model = load_model(model, model_path) detector = Detector(model, cfg) results = detector.detect_dataset(dataset) dataset.save_results(results) aps = dataset.evaluate() return aps
def main(): # valohai.prepare enables us to update the valohai.yaml configuration file with # the Valohai command-line client by running `valohai yaml step batch_inference.py` valohai.prepare( step='batch-inference', image='tensorflow/tensorflow:2.6.0', default_inputs={ 'model': { 'default': None, 'optional': False, }, 'images': [ 'https://valohaidemo.blob.core.windows.net/mnist/four-inverted.png', 'https://valohaidemo.blob.core.windows.net/mnist/five-inverted.png', 'https://valohaidemo.blob.core.windows.net/mnist/five-normal.jpg', ], }, ) print('Loading model') model_path = valohai.inputs('model').path() model = load_model(model_path) json_blob = {} for image_path in valohai.inputs('images').paths(): filename = os.path.basename(image_path) extension = os.path.splitext(image_path)[1].lower() if extension not in ['.png', '.jpg', '.jpeg', '.bmp', '.gif', '.tiff']: print(f'{filename} is not an image file') continue print(f'Running inference for {filename}') try: image, inverted = process_image(Image.open(image_path)) prediction = predict_image(model, image, inverted) json_blob[filename] = prediction print(filename, prediction) except Exception as exc: json_blob[filename] = {'error': exc} print(f'Unable to process {filename}: {exc}', file=sys.stderr) print('Saving predictions') suffix = '' try: suffix = f'-{model_path.split("model-")[1].split(".h5")[0]}' except IndexError: print(f'Unable to get suffix from {model_path}') json_path = os.path.join( valohai.outputs().path(f'predictions{suffix}.json')) with open(json_path, 'w') as json_file: json.dump(json_blob, json_file, sort_keys=True)
def do_sentiment(task_title, task_config_filename, do_print_code=False): st.title(task_title) config_names, config_map = task_configuration('assets/%s.json' % task_config_filename) example = st.selectbox('Choose an example', config_names) # st.markdown(config_map[example][2], unsafe_allow_html=True) height = min((len(config_map[example][0].split()) + 1) * 2, 200) if config_map[example][4] == 'rtl': local_css('assets/rtl.css') sequence = st.text_area('Text', config_map[example][0], key='sequence', height=height) labels = st.text_input('Labels (comma-separated)', config_map[example][1], max_chars=1000) original_labels = config_map[example][1].split(', ') labels = list( set([ x.strip() for x in labels.strip().split(',') if len(x.strip()) > 0 ])) if len(labels) == 0 or len(sequence) == 0: st.write('Enter some text and at least one label to see predictions.') return if not is_identical(labels, original_labels, 'list'): st.write('Your labels must be as same as the NLP task `%s`' % task_title) return if st.button('Analyze'): if do_print_code: load_snippet('snippets/sentiment_analysis_code.txt', 'python') s = st.info('Predicting ...') model_config = load_config(config_map[example][3]) labels = model_config.id2label tokenizer = load_tokenizer(config_map[example][3]) model = load_model(config_map[example][3], 'TFAlbertForSequenceClassification') scores, prediction = sequence_predicting(model, tokenizer, sequence, labels) time.sleep(1) s.empty() plot_result(list(labels.values()), scores, prediction)
def transcribe_file(): if os.path.exists(os.path.join(FLAGS.model_dir, 'hparams.json')): _hparams = model_utils.load_hparams(FLAGS.model_dir) encoder_fn, vocab_size = encoding.load_encoder(FLAGS.model_dir, hparams=_hparams) model, loss_fn = model_utils.load_model(FLAGS.model_dir, vocab_size=vocab_size, hparams=_hparams) optimizer = tf.keras.optimizers.Adam(_hparams[HP_LEARNING_RATE.name]) model.compile(loss=loss_fn, optimizer=optimizer, experimental_run_tf_function=False) else: print('need afford model_dir ') return transcription = model.predict(FLAGS.test_file) print('Input file: {}'.format(FLAGS.input)) print('Transcription: {}'.format(transcription))
def main(args): hparams = model_utils.load_hparams(args.model_dir) model, _ = model_utils.load_model(args.model_dir, hparams, stateful=True) model.summary() converter = tf.lite.TFLiteConverter.from_keras_model(model) converter.experimental_new_converter = True # converter.experimental_new_quantizer = True converter.target_spec.supported_ops = [ tf.lite.OpsSet.TFLITE_BUILTINS, tf.lite.OpsSet.SELECT_TF_OPS ] # converter.optimizations = [tf.lite.Optimize.DEFAULT] tflite_quant_model = converter.convert() tflite_dir = os.path.join(args.model_dir, 'tflite') os.makedirs(tflite_dir, exist_ok=True) with open(os.path.join(tflite_dir, 'model.tflite'), 'wb') as f: f.write(tflite_quant_model)
def demo(cfg): # prepare configurations cfg.load_model = '../models/squeezedet_kitti_epoch280.pth' cfg.gpus = [-1] # -1 to use CPU cfg.debug = 2 # to visualize detection boxes dataset = KITTI('val', cfg) cfg = Config().update_dataset_info(cfg, dataset) # preprocess image to match model's input resolution preprocess_func = dataset.preprocess del dataset # prepare model & detector model = SqueezeDet(cfg) model = load_model(model, cfg.load_model) detector = Detector(model.to(cfg.device), cfg) # prepare images sample_images_dir = '../data/samples/kitti/testing/image_2' sample_image_paths = glob.glob(os.path.join(sample_images_dir, '*.png')) # detection for path in tqdm.tqdm(sample_image_paths): image = skimage.io.imread(path).astype(np.float32) image_meta = {'image_id': os.path.basename(path)[:-4], 'orig_size': np.array(image.shape, dtype=np.int32)} image, image_meta, _ = preprocess_func(image, image_meta) image = torch.from_numpy(image.transpose(2, 0, 1)).unsqueeze(0).to(cfg.device) image_meta = {k: torch.from_numpy(v).unsqueeze(0).to(cfg.device) if isinstance(v, np.ndarray) else [v] for k, v in image_meta.items()} inp = {'image': image, 'image_meta': image_meta} _ = detector.detect(inp)
def train(cfg): Dataset = load_dataset(cfg.dataset) train_dataset = Dataset('train', cfg) val_dataset = Dataset('val', cfg) cfg = Config().update_dataset_info(cfg, train_dataset) Config().print(cfg) logger = Logger(cfg) model = SqueezeDetWithLoss(cfg) if cfg.load_model != '': if cfg.load_model.endswith('f364aa15.pth') or cfg.load_model.endswith( 'a815701f.pth'): model = load_official_model(model, cfg.load_model) else: model = load_model(model, cfg.load_model) optimizer = torch.optim.SGD(model.parameters(), lr=cfg.lr, momentum=cfg.momentum, weight_decay=cfg.weight_decay) lr_scheduler = StepLR(optimizer, 60, gamma=0.5) trainer = Trainer(model, optimizer, lr_scheduler, cfg) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=cfg.batch_size, num_workers=cfg.num_workers, pin_memory=True, shuffle=True, drop_last=True) val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=cfg.batch_size, num_workers=cfg.num_workers, pin_memory=True) metrics = trainer.metrics if cfg.no_eval else trainer.metrics + ['mAP'] best = 1E9 if cfg.no_eval else 0 better_than = operator.lt if cfg.no_eval else operator.gt for epoch in range(1, cfg.num_epochs + 1): train_stats = trainer.train_epoch(epoch, train_loader) logger.update(train_stats, phase='train', epoch=epoch) save_path = os.path.join(cfg.save_dir, 'model_last.pth') save_model(model, save_path, epoch) if epoch % cfg.save_intervals == 0: save_path = os.path.join(cfg.save_dir, 'model_{}.pth'.format(epoch)) save_model(model, save_path, epoch) if cfg.val_intervals > 0 and epoch % cfg.val_intervals == 0: val_stats = trainer.val_epoch(epoch, val_loader) logger.update(val_stats, phase='val', epoch=epoch) if not cfg.no_eval: aps = eval_dataset(val_dataset, save_path, cfg) logger.update(aps, phase='val', epoch=epoch) value = val_stats['loss'] if cfg.no_eval else aps['mAP'] if better_than(value, best): best = value save_path = os.path.join(cfg.save_dir, 'model_best.pth') save_model(model, save_path, epoch) logger.plot(metrics) logger.print_bests(metrics) torch.cuda.empty_cache()
def do_text_generation(task_title, task_config_filename, do_print_code=False): st.title(task_title) config_names, config_map = task_configuration('assets/%s.json' % task_config_filename) example = st.selectbox('Choose an example', config_names) # st.markdown(config_map[example][2], unsafe_allow_html=True) height = min((len(config_map[example][0].split()) + 1) * 2, 200) if config_map[example][4] == 'rtl': local_css('assets/rtl.css') sequence = st.text_area('Text', config_map[example][0], key='sequence', height=height) labels = st.text_input('Mask (placeholder)', config_map[example][1], max_chars=1000) original_labels = config_map[example][1].split(', ') labels = list( set([ x.strip() for x in labels.strip().split(',') if len(x.strip()) > 0 ])) if len(labels) == 0 or len(sequence) == 0: st.write('Enter some text and at least one label to see predictions.') return if not is_identical(labels, original_labels, 'list'): st.write('Your labels must be as same as the NLP task `%s`' % task_title) return if st.button('Analyze'): if do_print_code: load_snippet('snippets/text_generation_code.txt', 'python') s = st.info('Predicting ...') tokenizer = load_tokenizer(config_map[example][3]) model = load_model(config_map[example][3], 'TFAlbertForMaskedLM', from_pt=True) masked_words, words = text_generation(model, tokenizer, sequence) new_sequence = [] for index, word in enumerate(words): if index in masked_words: masks_sequence = [] for mi in masked_words[index]: masks_sequence.append( '<span class="masked" style="background-color: %s;">%s</span>' % (mi['color'], mi['token_str'])) new_sequence.append( '<span class="token"><span class="masks-start">[</span><span class="token-masks">%s</span><span class="masks-end">]</span></span>' % (''.join(masks_sequence))) else: new_sequence.append('<span class="token">%s</span>' % word) new_sequence = ' '.join(new_sequence) time.sleep(1) s.empty() st.markdown(f'<p class="masked-box">{new_sequence}</p>', unsafe_allow_html=True)
def do_ner(task_title, task_config_filename, do_print_code=False): st.title(task_title) config_names, config_map = task_configuration('assets/%s.json' % task_config_filename) example = st.selectbox('Choose an example', config_names) # st.markdown(config_map[example][2], unsafe_allow_html=True) height = min((len(config_map[example][0].split()) + 1) * 2, 200) if config_map[example][4] == 'rtl': local_css('assets/rtl.css') sequence = st.text_area('Text', config_map[example][0], key='sequence', height=height) labels = st.text_input('Labels (comma-separated)', config_map[example][1], max_chars=1000) original_labels = config_map[example][1].split(', ') labels = list( set([ x.strip() for x in labels.strip().split(',') if len(x.strip()) > 0 ])) if len(labels) == 0 or len(sequence) == 0: st.write('Enter some text and at least one label to see predictions.') return if not is_identical(labels, original_labels, 'list'): st.write('Your labels must be as same as the NLP task `%s`' % task_title) return if st.button('Analyze'): if do_print_code: load_snippet('snippets/named_entity_recognition_code.txt', 'python') s = st.info('Predicting ...') model_config = load_config(config_map[example][3]) labels = model_config.id2label mapper = config_map[example][5] # labels = {k: labels_mapper[v] for k, v in model_config.id2label.items()} tokenizer = load_tokenizer(config_map[example][3]) model = load_model(config_map[example][3], 'TFAlbertForTokenClassification') predictions = token_predicting(model, tokenizer, sequence, labels) ner_color = [] ner_tags = [] for tag, translate in mapper.items(): if tag != 'O': if translate[0] not in ner_tags: ner_color.append( '<span style="background-color: %s;">%s</span>' % (translate[1], translate[0])) ner_tags.append(translate[0]) ner_color = ' '.join(ner_color) ner_sequence = [] for token, label in predictions: if token not in ['[CLS]', '[SEP]']: label = mapper[label] if label[0]: ner_sequence.append( '<span style="background-color: %s;" class="token token-ner">%s <span class="ner-label">%s</span></span>' % (label[1], token, label[0])) else: ner_sequence.append('<span class="token">%s</span>' % token) time.sleep(1) s.empty() st.markdown(f'<p class="ner-color">{ner_color}</p>', unsafe_allow_html=True) ner_sequence = ' '.join(ner_sequence) st.markdown(f'<p class="ner-box">{ner_sequence}</p>', unsafe_allow_html=True)
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0 log = logging.getLogger('werkzeug') log.setLevel(logging.ERROR) _ROOT_PATH = str(pathlib.PurePath(__file__).parent) _DATA = [TMA1, TMA2, TMA3] _JSON_DATA = [ df.head(10000).to_json(orient='table', index=False) for df in _DATA ] _DEAD_KNN_MODEL, _INJURED_KNN_MODEL = analyse.KNN(TMA1) # _DEAD_KNN_MODEL, _INJURED_KNN_MODEL = analyse.KNN(pd.concat([TMA1, TMA2], ignore_index=True)) _SVM_MODEL = analyse.SVM(pd.concat([TMA1, TMA2], ignore_index=True)) _RNN_MODEL = model.load_model('./static/data/model') _KMEANS_MODEL = analyse.kmeans(TMA1) @app.route('/', methods=['GET']) def index(): return render_template('index.html', dataSize=[len(d) for d in (TMA1, TMA2, TMA3)]) ''' @app.route('/buttons', methods=['GET']) def buttons(): return render_template('buttons.html') ''' '''
import pandas as pd from feature_generation.feature_annotator import FeatureAnnotator from constants.paths import PRETRAINED_BEST_MODEL_PATH from constants.model import PAIR_FILTER_TYPE, FEATURE_FILTER_TYPE from utils.model import load_model, load_word_vec, load_one_hot_encoder, load_label_encoder # Feature generations from feature_generation.dependency_pair import create_dependency_parser_feature_from_sentence from preprocessing.model_feature import feature_selection, preprocess, filter_pair # Post process from postprocess.amr_graph import create_pediction_dict, create_amr_graph_from_prediction annotator = FeatureAnnotator() model = load_model(PRETRAINED_BEST_MODEL_PATH) word_vec = load_word_vec() one_hot_encoder = load_one_hot_encoder() label_encoder = load_label_encoder() def process_sentence(sentence, sentence_id=0): dependency_parser_feature = create_dependency_parser_feature_from_sentence( annotator, sentence) X = pd.DataFrame(dependency_parser_feature) filtered_X = filter_pair(X, PAIR_FILTER_TYPE) return filtered_X def predict_and_process(filtered_X): selected_X = feature_selection(filtered_X, FEATURE_FILTER_TYPE) X_preprocessed = preprocess(selected_X, word_vec, one_hot_encoder) y_pred = model.predict(X_preprocessed)
def getStyleBased(subModel): return load_model('STYLE-BASED', subModel);
from utils.utils import get_acc parser = argparse.ArgumentParser() parser.add_argument('--dataset', type=str, default='chestx') parser.add_argument('--model', type=str, default='inceptionv3') parser.add_argument('--gpu', type=str, default='0') args = parser.parse_args() set_gpu(args.gpu) X_train, X_test, y_train, y_test = load_data( dataset=args.dataset, normalize=True) model = load_model( dataset=args.dataset, nb_class=y_train.shape[1], model_type=args.model, mode='train' ) def step_decay(epoch): lr = 1e-3 if epoch > 45: lr = 1e-5 elif epoch > 40: lr = 1e-4 print('Learning rate: ', lr) return lr epoch = 50
default=416, type=int, help="Width of network's input image") parser.add_argument("--inpHeight", default=416, type=int, help="Height of network's input image") parser.add_argument("--image", default=None, type=str, help="path of image") parser.add_argument("--video", default=None, type=str, help="path of video") args = parser.parse_args() return args if __name__ == '__main__': # load model args = getargs() net, classes = model.load_model(args) if args.image: image = cv.imread(args.image) utils.process_img(args, net, image, classes) elif args.video: utils.process_video(args, net, classes)
def main(): args = parser.parse_args() torch.manual_seed(0) np.random.seed(0) # Set the cuda device if torch.cuda.is_available(): device = torch.device("cuda:0") torch.cuda.set_device(device) else: device = torch.device("cpu") if args.net_version == 1: from view_net import Model else: from view_net2 import Model # Initialize an OpenGL perspective camera. cameras = OpenGLPerspectiveCameras(device=device) # To blend the 100 faces we set a few parameters which control the opacity and the sharpness of # edges. Refer to blending.py for more details. # blend_params = BlendParams(sigma=1e-4, gamma=1e-4) # We will also create a phong renderer. This is simpler and only needs to render one face per pixel. raster_settings = RasterizationSettings( image_size=224, blur_radius=0.0, # np.log(1. / 1e-4 - 1.) * blend_params.sigma, faces_per_pixel=args.faces_per_pixel, # 100 ) # We can add a point light in front of the object. # lights = PointLights(device=device) # lights = DirectionalLights(device=device, direction=self.camera_position) phong_renderer = MeshRenderer( rasterizer=MeshRasterizer(cameras=cameras, raster_settings=raster_settings), shader=HardFlatShader(device=device, cameras=cameras) # , lights=lights) ) dataset = ClassificationData(args.data, "train", device) test_idx, train_idx = dataset.train_test_split(dataset.paths, range(len(dataset)), 20, True) val_idx, train_idx = dataset.train_test_split( [dataset.paths[i] for i in train_idx], train_idx, 20, True) test_set = torch.utils.data.Subset(dataset, test_idx) val_set = torch.utils.data.Subset(dataset, val_idx) train_set = torch.utils.data.Subset(dataset, train_idx) train_loader = DataLoader(train_set, batch_size=args.batch_size // args.nviews, shuffle=False, num_workers=0, pin_memory=True, drop_last=True, collate_fn=my_collate) val_loader = DataLoader(val_set, batch_size=args.batch_size // args.nviews, shuffle=False, num_workers=1, pin_memory=True, drop_last=True, collate_fn=my_collate) test_loader = DataLoader(test_set, batch_size=args.batch_size // args.nviews, shuffle=False, num_workers=1, pin_memory=True, drop_last=True, collate_fn=my_collate) model = Model(device, phong_renderer, dataset.nclasses, args) args.num_classes = dataset.nclasses # Multi GPUs if torch.cuda.device_count() > 1: model = torch.nn.DataParallel(model) model = model.to(device=device) optimizer = Adam( [ { 'params': model.camera_position, 'lr': args.learning_rate_camera }, # {'params': model.light_position, 'lr': args.learning_rate_camera}, { 'params': model.net_1.parameters() }, { 'params': model.net_2.parameters() } ], lr=args.learning_rate, weight_decay=args.weight_decay) criterion = nn.CrossEntropyLoss().to(device=device) wandb.init(project="views_net", config=args) args.fname_best = 'views_net{}_model_best{}.pth.tar'.format( args.nviews, datetime.now().strftime("%d_%b_%Y_%H_%M_%S")) args.device = device args.obj_path = train_set.dataset.paths[0][0] train(model, criterion, optimizer, train_loader, val_loader, args) load_model(model, args.fname_best) val_statistics = validate(test_loader, model, criterion, device) log_summary(val_statistics, "val", test_loader.dataset.dataset.classes)
def train_hold_out_aligned(model, criterion, optimizer, args): """ Perform a train with validation train split on the given model. Use args.val_split_size to set the percentage of data for the validation set. Keep in mind the two validation sets are genereted. One for early stopping and one to evaluate the model. All the data are sent to wandb or logged on a text file Parameters ---------- model : RotaitonNet model criterion : Pytorch criterion (CrossEntropy for RotationNet) optimizer : Pytorch optimizer (e.g. SGD) args : Input args from the parser Returns ------- Nothing """ # create one element tuple to be consistent with ImageFolder dataset of Pytorch full_set_train = (AlignedDataset(args.data_aligned, 'train', []),) # validation data is on normal dataset full_set_val = generate_dataset(args.data, 'train') # full_set_val = (AlignedDataset(args.data_aligned, 'train', []),) # Get test train split. The test set here is intended as validation set but because we need also a validation set # for the early stopping we call it test test_idx, train_idx = train_test_split(full_set_train[0].samples, range(len(full_set_train[0].samples)), args.nview, args.val_split_size, True) # Get val train split val_idx, train_idx = train_test_split([full_set_train[0].samples[i] for i in train_idx], train_idx, args.nview, args.val_split_size, True) _, classes = zip(*[full_set_train[0].samples[i] for i in train_idx]) # Get subsets test_set = torch.utils.data.Subset(full_set_val[0], test_idx) val_set = torch.utils.data.Subset(full_set_val[0], val_idx) train_set = torch.utils.data.Subset(full_set_train[0], train_idx) # Generate loaders test_loader = generate_loader(test_set, args.batch_size, args.workers) val_loader = generate_loader(val_set, args.batch_size, args.workers) train_loader = generate_loader(train_set, args.batch_size, args.workers) # load already trained model from single image classification # load_model(model, "for_rotation_net.pth.tar") # Track model in wandb wandb.init(project="RotationNet", config=args) # wandb.watch(model) train(model, criterion, optimizer, train_loader, val_loader, args) # Load best model before validating load_model(model, args.fname_best) # permute indices # indices = test_loader.dataset.indices # inds = random_permute_indices(np.array(indices), args.nview, True) # test_loader.dataset.indices = np.asarray(inds) # del indices # del inds val_statistics = validate(test_loader, model, criterion, args) log_summary(val_statistics, "val", test_loader.dataset.dataset.classes)
def train_k_fold(model, criterion, optimizer, args): """ Perform a k-fold cross validation on the given model. Use args.fold to set the number of total folds and args.ntest_fold to set the number of folds dedicated for the validation. Keep in mind that each training step uses also an extra validation set for early stopping (the size of this subset is set via args.val_split_size). All the data are sent to wandb or logged on a text file Parameters ---------- model : RotaitonNet model criterion : Pytorch criterion (CrossEntropy for RotationNet) optimizer : Pytorch optimizer (e.g. SGD) args : Input args from the parser Returns ------- Nothing """ # Save clean model to reload at each fold save_model(args.arch, model, optimizer, args.fname) # Get full train dataset full_set = generate_dataset(args.data, 'train') # Get folds folds = k_fold(full_set[0].samples, args.nview, True, args.fold) # List of top1 and top5 accuracies to get the average and std of the model performance top1 = [] top5 = [] # K-fold cross validation for i in range(args.fold): test_idx = [] # Use ntest_folds folds for the test set for j in range(args.ntest_folds): test_idx.extend(folds[i]) folds = np.delete(folds, i, 0) # Use rest of the data for the train set train_idx = np.hstack(folds) val_idx, train_idx = train_test_split([full_set[0].samples[i] for i in train_idx], train_idx, args.nview, args.val_split_size, True) # Get subsets test_set = torch.utils.data.Subset(full_set[0], test_idx) val_set = torch.utils.data.Subset(full_set[0], val_idx) train_set = torch.utils.data.Subset(full_set[0], train_idx) # Generate loaders test_loader = generate_loader(test_set, args.batch_size, args.workers) val_loader = generate_loader(val_set, args.batch_size, args.workers) train_loader = generate_loader(train_set, args.batch_size, args.workers) logger.debug("Start train on fold {}/{}".format(i, args.fold)) # Track model in wandb wandb.init(project="RotationNet", name="Fold " + str(i), config=args, reinit=True) # The model can be analyzed only once # if i == 0: # wandb.watch(model) train(model, criterion, optimizer, train_loader, val_loader, args) # Load best model before validating load_model(model, args.fname_best) val_statistics = validate(test_loader, model, criterion, args) log_summary(val_statistics, "val", test_loader.dataset.dataset.classes) # Load fresh model for next train load_model(model, args.fname) logger.info('Val prec@1 {top1:.3f} +- {std1:.3f} \t' 'Val prec@5 {top5:.3f} +- {std5:.3f} \t'.format(top1=np.mean(top1), std1=np.std(top1), top5=np.mean(top5), std5=np.std(top5)))
# sample_rate_list=[32000] n = 0 for sample_rate in sample_rate_list: # resample audio and put them into a single h5 file. util.make_h5('./audio_test', sr=sample_rate) #load test data from h5 file. X_test = util.load_test_data(sample_rate) # load trained 5 models' path (same models but 5-fold cross validated) model_list = glob.glob('saved_models/%s/**/*.h5' % sample_rate) for model_name in model_list: #load each model m = model.load_model(model_name) # model predict pred = model.predict(m, X_test, n_class=41) # ensemble with geometric mean if n == 0: total_pred = pred else: total_pred *= pred n += 1 result = total_pred**(1 / float(n)) ####################################### # save submission by the format for MAP@3 evaluation.
def train_hold_out(model, criterion, optimizer, args): """ Perform a train with validation train split on the given model. Use args.val_split_size to set the percentage of data for the validation set. Keep in mind the two validation sets are genereted. One for early stopping and one to evaluate the model. All the data are sent to wandb or logged on a text file Parameters ---------- model : RotaitonNet model criterion : Pytorch criterion (CrossEntropy for RotationNet) optimizer : Pytorch optimizer (e.g. SGD) args : Input args from the parser Returns ------- Nothing """ trans = [] if args.flip: # flip is with 0.5 probability trans.append(transforms.RandomHorizontalFlip()) trans.append(transforms.RandomVerticalFlip()) if args.rotation: trans.append(transforms.RandomRotation((0, 90), expand=args.rotation_expand)) # if expand is true then resize the image to the right size if args.rotation_expand: trans.append(transforms.Resize(224)) # Get full train dataset # Create two different sets but one with and one without transformations (random rotation and flip) if args.depth: # create one element tuple to be consistent with ImageFolder dataset of Pytorch full_set_train = (DepthDataset(args.data, 'train', trans),) full_set_val = (DepthDataset(args.data, 'train'),) else: full_set_train = generate_dataset(args.data, 'train', trans) full_set_val = generate_dataset(args.data, 'train',[]) # Get test train split. The test set here is intended as validation set but because we need also a validation set # for the early stopping we call it test test_idx, train_idx = train_test_split(full_set_train[0].samples, range(len(full_set_train[0].samples)), args.nview, args.val_split_size, True) # Get val train split val_idx, train_idx = train_test_split([full_set_train[0].samples[i] for i in train_idx], train_idx, args.nview, args.val_split_size, True) if args.nelements != 0: train_idx = under_sampler_to([full_set_train[0].samples[i] for i in train_idx], train_idx, args.nview, args.nelements) _, classes = zip(*[full_set_train[0].samples[i] for i in train_idx]) if args.sampling == "oversampling": train_idx = random_over_sampler(classes, train_idx, args.nview) elif args.sampling == "undersampling": train_idx = random_under_sampler(classes, train_idx, args.nview) # Get subsets test_set = torch.utils.data.Subset(full_set_val[0], test_idx) val_set = torch.utils.data.Subset(full_set_val[0], val_idx) train_set = torch.utils.data.Subset(full_set_train[0], train_idx) # Generate loaders test_loader = generate_loader(test_set, args.batch_size, args.workers) val_loader = generate_loader(val_set, args.batch_size, args.workers) train_loader = generate_loader(train_set, args.batch_size, args.workers) # load already trained model from single image classification # load_model(model, "for_rotation_net.pth.tar") # Track model in wandb wandb.init(project="RotationNet", config=args) # wandb.watch(model) train(model, criterion, optimizer, train_loader, val_loader, args) # Load best model before validating load_model(model, args.fname_best) # permute indices # indices = test_loader.dataset.indices # inds = random_permute_indices(np.array(indices), args.nview, True) # test_loader.dataset.indices = np.asarray(inds) # del indices # del inds val_statistics = validate(test_loader, model, criterion, args) log_summary(val_statistics, "val", test_loader.dataset.dataset.classes)
def train(): hparams = { HP_TOKEN_TYPE: HP_TOKEN_TYPE.domain.values[0], HP_VOCAB_SIZE: HP_VOCAB_SIZE.domain.values[0], # Preprocessing HP_MEL_BINS: HP_MEL_BINS.domain.values[0], HP_FRAME_LENGTH: HP_FRAME_LENGTH.domain.values[0], HP_FRAME_STEP: HP_FRAME_STEP.domain.values[0], HP_HERTZ_LOW: HP_HERTZ_LOW.domain.values[0], HP_HERTZ_HIGH: HP_HERTZ_HIGH.domain.values[0], # Model HP_EMBEDDING_SIZE: HP_EMBEDDING_SIZE.domain.values[0], HP_ENCODER_LAYERS: HP_ENCODER_LAYERS.domain.values[0], HP_ENCODER_SIZE: HP_ENCODER_SIZE.domain.values[0], HP_TIME_REDUCT_INDEX: HP_TIME_REDUCT_INDEX.domain.values[0], HP_TIME_REDUCT_FACTOR: HP_TIME_REDUCT_FACTOR.domain.values[0], HP_PRED_NET_LAYERS: HP_PRED_NET_LAYERS.domain.values[0], HP_JOINT_NET_SIZE: HP_JOINT_NET_SIZE.domain.values[0], HP_SOFTMAX_SIZE: HP_SOFTMAX_SIZE.domain.values[0], HP_LEARNING_RATE: HP_LEARNING_RATE.domain.values[0] } if os.path.exists(os.path.join(FLAGS.model_dir, 'hparams.json')): _hparams = model_utils.load_hparams(FLAGS.model_dir) encoder_fn, vocab_size = encoding.load_encoder(FLAGS.model_dir, hparams=_hparams) model, loss_fn = model_utils.load_model(FLAGS.model_dir, vocab_size=vocab_size, hparams=_hparams) else: _hparams = {k.name: v for k, v in hparams.items()} texts_gen = common_voice.texts_generator(FLAGS.data_dir) encoder_fn, vocab_size = encoding.build_encoder( texts_gen, model_dir=FLAGS.model_dir, hparams=_hparams) model, loss_fn = build_keras_model(vocab_size, _hparams) logging.info('Using {} encoder with vocab size: {}'.format( _hparams[HP_TOKEN_TYPE.name], vocab_size)) dataset_fn = get_dataset_fn(FLAGS.data_dir, encoder_fn=encoder_fn, batch_size=FLAGS.batch_size, hparams=hparams) train_dataset, train_steps = dataset_fn('train') dev_dataset, dev_steps = dataset_fn('dev') optimizer = tf.keras.optimizers.Adam(_hparams[HP_LEARNING_RATE.name]) model.compile(loss=loss_fn, optimizer=optimizer, experimental_run_tf_function=False) os.makedirs(FLAGS.model_dir, exist_ok=True) checkpoint_fp = os.path.join(FLAGS.model_dir, 'model.{epoch:03d}-{val_loss:.4f}.hdf5') model_utils.save_hparams(_hparams, FLAGS.model_dir) model.fit(train_dataset, epochs=FLAGS.n_epochs, steps_per_epoch=train_steps, validation_data=dev_dataset, validation_steps=dev_steps, callbacks=[ tf.keras.callbacks.TensorBoard(FLAGS.tb_log_dir), tf.keras.callbacks.ModelCheckpoint(checkpoint_fp, save_weights_only=True) ])
def main(): args = parser.parse_args() # REPRODUCIBILITY torch.manual_seed(0) np.random.seed(0) args.vcand = np.load('view_candidates/vcand_case2.npy') args.nview = 20 if torch.cuda.is_available(): args.device = torch.device('cuda') else: args.device = torch.device('cpu') # Create RotationNet model based on the given architecture. # The output size is (num_classes + wrong_view class) * the number of views model = RotationNet("alexnet", True, (args.num_classes + 1) * args.nview) # Multi GPUs if torch.cuda.device_count() > 1: model = torch.nn.DataParallel(model) # Send model to GPU or keep it to the CPU model = model.to(device=args.device) # switch to evaluate mode model.eval() model = torch.nn.DataParallel(model) load_model(model, args.model_path, 'cpu') in_dir = "../../others/separate_meshes/results/non_dirty1" out_dir = "../../others/separate_meshes/results/recognition" if os.path.exists(out_dir): shutil.rmtree(out_dir) os.mkdir(out_dir) for filename in os.listdir(in_dir): if filename.endswith(".obj"): args.data = os.path.join(in_dir, filename) # delete previous folder if os.path.exists('inference_img'): shutil.rmtree('inference_img') os.mkdir("inference_img") os.mkdir("inference_img/train/") os.mkdir("inference_img/train/class") args.folder = os.path.abspath("inference_img/train/class") render_images(args) test_set = (generate_dataset("inference_img", 'train', trans=[]), ) test_set = torch.utils.data.Subset(test_set[0], range(len(test_set[0].samples))) test_loader = generate_loader(test_set, args.nview, workers=0) with torch.no_grad(): # input_val, target_val = next(iter(test_loader)) for batch_idx, (input_val, target_val) in enumerate(test_loader): prediction, score, _, _ = execute_inference( model, input_val, target_val, args) if score[0] < args.threshold: cat = "outlier" else: cat = classes[prediction[0]] input_val = None del input_val target_val = None del target_val test_set = None del test_set test_loader = None del test_loader print(cat) if not os.path.exists(os.path.join(out_dir, cat)): os.mkdir(os.path.join(out_dir, cat)) os.rename(os.path.join(in_dir, filename), os.path.join(out_dir, cat, filename)) # sys.exit() else: continue