def __init__( self, infer_model, encoder_name='resnet34', encoder_weights='imagenet', decoder_use_batchnorm=True, decoder_channels=(256, 128, 64, 32, 16), classes=1, activation=None, center=None, # usefull for VGG models attention_type=None, tta=False, adapt_input=1, preprocess=True, classification=False, ): encoder = get_encoder(encoder_name, encoder_weights=encoder_weights) decoder = UnetDecoder( encoder_channels=encoder.out_shapes, decoder_channels=decoder_channels, final_channels=classes, use_batchnorm=decoder_use_batchnorm, center=center, attention_type=attention_type, classification=classification, ) super().__init__(infer_model, encoder, decoder, activation, tta, adapt_input, preprocess) self.name = 'ref-u-{}'.format(encoder_name)
def __init__( self, encoder_name='resnet34', encoder_weights='imagenet', input_shape=(3, 384), classes=1, activation='sigmoid', features = 256, tta=False ): encoder = get_encoder( encoder_name, encoder_weights=encoder_weights ) decoder =RefineNetPoolingImproveDecoder( input_shape, encoder_channels=encoder.out_shapes, num_classes=classes, features=features ) super().__init__(encoder, decoder, activation, tta) self.name = 'refinenet-pooling-improve-{}'.format(encoder_name)
def __init__(self, encoder_name='resnet34', encoder_weights='imagenet', decoder_pyramid_channels=256, decoder_segmentation_channels=128, classes=1, dropout=0.2, activation='sigmoid', final_upsampling=4, decoder_merge_policy='add', tta=False): encoder = get_encoder(encoder_name, encoder_weights=encoder_weights) decoder = FPNDecoder( encoder_channels=encoder.out_shapes, pyramid_channels=decoder_pyramid_channels, segmentation_channels=decoder_segmentation_channels, final_channels=classes, dropout=dropout, final_upsampling=final_upsampling, merge_policy=decoder_merge_policy) super().__init__(encoder, decoder, activation, tta) self.name = 'fpn-{}'.format(encoder_name)
def __init__( self, encoder_name='resnet34', encoder_weights='imagenet', decoder_use_batchnorm=True, decoder_channels=(256, 128, 64, 32, 16), classes=1, activation='sigmoid', center=False, # usefull for VGG models ): encoder = get_encoder( encoder_name, encoder_weights=encoder_weights ) decoder = UnetDecoder( encoder_channels=encoder.out_shapes, decoder_channels=decoder_channels, final_channels=classes, use_batchnorm=decoder_use_batchnorm, center=center, ) super().__init__(encoder, decoder, activation) self.name = 'u-{}'.format(encoder_name) self.name = 'u-{}'.format(encoder_name)
def __init__(self, encoder_name='resnet34', encoder_weights='imagenet', psp_in_factor=8, psp_out_channels=512, psp_use_batchnorm=True, psp_aux_output=False, classes=21, dropout=0.2, activation='softmax', tta=False): encoder = get_encoder(encoder_name, encoder_weights=encoder_weights) decoder = PSPDecoder( encoder_channels=encoder.out_shapes, downsample_factor=psp_in_factor, psp_out_channels=psp_out_channels, final_channels=classes, dropout=dropout, aux_output=psp_aux_output, use_batchnorm=psp_use_batchnorm, ) super().__init__(encoder, decoder, activation, tta) self.name = 'psp-{}'.format(encoder_name)
def embed_sentences(sentences, args): """Create sentence embeddings from raw sentences. Save the output to disk, either as ```nmslib.index``` or ``np.array``. Args: sentences (np.array): input sentences. args (argparse.Namespace): command line arguments. """ encoder = get_encoder(args.encoder) start = time.time() embeddings = encoder.encode(sentences) encoding_time = time.time() - start embeddings_dim = embeddings[0].shape[0] print(f'-I- Done in {encoding_time} seconds.') if args.indices: embeddings_ids = np.loadtxt(args.indices, dtype=int, delimiter='\n') else: embeddings_ids = None # remove principal components if args.encoder == 'simple_encoder' and args.remove_components > 0 and encoder.components_ is None: components_ = svd_components(embeddings, n_components=args.remove_components) embeddings -= embeddings.dot(components_.transpose()).dot(components_) components_fname = os.path.join( args.output_dir, f'{args.encoder.replace("_", "-")}-{embeddings_dim}d-components.npy' ) print(f'-I- Saving PCA components to {components_fname}') np.save(components_fname, components_) # persist to disk (either .npy / nmslib / annoy ) if args.index: target = os.path.join( args.output_dir, f'{args.encoder.replace("_", "-")}-{args.index}-{embeddings_dim}d.bin' ) index = NMSLibCorpusIndex(dim=embeddings_dim) print(f'-I- Building {args.index} ANN Index: {target}') start = time.time() index.add_dense(embeddings, ids=embeddings_ids) index.save(target) indexing_time = time.time() - start print(f'-I- Done in {int(indexing_time / 60)} minutes.') else: target = os.path.join( args.output_dir, f'{args.encoder.replace("_", "-")}-{embeddings_dim}d.npy') print(f'-I- Saving embeddings to file: {target}') np.save(target, embeddings)
def __init__( self, encoder_name: str = "resnet34", encoder_depth: int = 5, encoder_weights: Optional[str] = "imagenet", decoder_pyramid_channels: int = 256, decoder_segmentation_channels: int = 128, decoder_merge_policy: str = "add", decoder_dropout: float = 0.2, in_channels: int = 3, classes: int = 1, activation: Optional[str] = None, upsampling: int = 4, aux_params: Optional[dict] = None, ): super().__init__() self.encoder = get_encoder( encoder_name, in_channels=in_channels, depth=encoder_depth, weights=encoder_weights, ) self.decoder = FPNDecoder( encoder_channels=self.encoder.out_channels, encoder_depth=encoder_depth, pyramid_channels=decoder_pyramid_channels, segmentation_channels=decoder_segmentation_channels, dropout=decoder_dropout, merge_policy=decoder_merge_policy, ) self.segmentation_head = SegmentationHead( in_channels=self.decoder.out_channels, out_channels=classes, activation=activation, kernel_size=1, upsampling=upsampling, ) if aux_params is not None: self.classification_head = ClassificationHead( in_channels=self.encoder.out_channels[-1], **aux_params ) else: self.classification_head = None self.name = "fpn-{}".format(encoder_name) self.initialize()
def __init__(self, encoder_name='resnet34', encoder_weights='imagenet', decoder_use_batchnorm=True, classes=1, activation='sigmoid', tta=False): encoder = get_encoder(encoder_name, encoder_weights=encoder_weights) decoder = LinknetDecoder( encoder_channels=encoder.out_shapes, prefinal_channels=32, final_channels=classes, use_batchnorm=decoder_use_batchnorm, ) super().__init__(encoder, decoder, activation, tta) self.name = 'link-{}'.format(encoder_name)
def create_app(env=None): """Create falcon WSGI application. Args: env (dict-like): environment variables. Returns: falcon.API """ # By default we use the system environment. env = env or os.environ # Init encoder encoder_name = env.get('ENCODER', 'simple_encoder') print(f"Init Simple Encoder - {encoder_name}") sentence_encoder = get_encoder(encoder_name) # Init corpus index corpus_index_fname = env.get( 'CORPUS_INDEX', os.path.join(data_dir, 'simple-encoder-nmslib-100d.bin')) print(f"Init Corpus Index - {corpus_index_fname}") corpus_index = load_corpus_index(corpus_index_fname) # Init DB print('Init Covid DB') db_session = get_session(conn=os.getenv( 'DB_CONNECTION', os.path.join(data_dir, 'covid19.sqlite'))) # Create WSGI application app = falcon.API() # pylint: disable=invalid-name # Init routes app.add_route( '/similar', CovidSimilarityResource(corpus_index, sentence_encoder, db_session)) print('*** WSGI application is ready ***') return app
def __init__( self, encoder_name='resnet34', encoder_weights='imagenet', decoder_use_batchnorm=True, classes=1, activation='sigmoid', mid_channel=128, tta=False, ): encoder = get_encoder(encoder_name, encoder_weights=encoder_weights) decoder = FastFCNDecoder( encoder_channels=encoder.out_shapes, final_channels=classes, use_batchnorm=decoder_use_batchnorm, mid_channel=mid_channel, ) super().__init__(encoder, decoder, activation, tta) self.name = 'fastfcn-{}'.format(encoder_name)
def init_specific_model(model_type, img_size, latent_dim, hidden_dim=None): """ Return an instance of a VAE with encoder and decoder from `model_type`. Parameters ---------- img_size : tuple of ints for model_type=Burgess, int for model_type=Lin Size or Dimension of images """ model_type = model_type.lower().capitalize() get_enc = get_encoder(model_type) get_dec = get_decoder(model_type) if model_type == "Burgess": encoder = get_enc(img_size, latent_dim) decoder = get_dec(img_size, latent_dim) elif model_type == "Lin": encoder = get_enc(img_size, latent_dim, hidden_dim) decoder = get_dec(img_size, latent_dim, hidden_dim) else: err = "Unkown model_type={}. Possible values: {}" raise ValueError(err.format(model_type, MODELS)) model = VAE(encoder, decoder) model.model_type = model_type # store to help reloading return model
def __init__( self, encoder_name='resnet34', encoder_weights='imagenet', decoder_use_batchnorm=True, decoder_channels=(256, 128, 64, 32, 16), classes=1, activation='sigmoid', center=None, # usefull for VGG models attention_type=None, tta=False, ): encoder = get_encoder(encoder_name, encoder_weights=encoder_weights) decoder = HyperColumnsDecoder(encoder_channels=encoder.out_shapes, decoder_channels=decoder_channels, final_channels=classes, use_batchnorm=decoder_use_batchnorm, center=center, attention_type=attention_type) super().__init__(encoder, decoder, activation, tta) self.name = 'HyperColumns-{}'.format(encoder_name)
def __init__( self, encoder_type, shape_decoder_type, texture_decoder_type, discriminator_type, vertex_scaling, texture_scaling, silhouette_loss_levels, lambda_silhouettes, lambda_textures, lambda_perceptual, lambda_inflation, lambda_discriminator, lambda_discriminator2, lambda_graph_laplacian, single_view_training, class_conditional, no_texture, num_views, dim_hidden=512, anti_aliasing=False, ): super(ShapeNetModel, self).__init__() self.trainer = None self.dataset_name = 'shapenet' # model size self.dim_hidden = dim_hidden # loss weights self.silhouette_loss_levels = silhouette_loss_levels self.lambda_silhouettes = lambda_silhouettes self.lambda_textures = lambda_textures self.lambda_perceptual = lambda_perceptual self.lambda_discriminator = lambda_discriminator self.lambda_discriminator2 = lambda_discriminator2 self.lambda_inflation = lambda_inflation self.lambda_graph_laplacian = lambda_graph_laplacian # others self.single_view_training = single_view_training self.class_conditional = class_conditional self.no_texture = no_texture self.num_views = num_views self.use_depth = False # setup renderer self.renderer = neural_renderer.Renderer() self.renderer.image_size = 224 self.renderer.anti_aliasing = anti_aliasing self.renderer.perspective = True self.renderer.viewing_angle = self.xp.degrees(self.xp.arctan(16. / 60.)) self.renderer.camera_mode = 'look_at' self.renderer.blur_size = 0 with self.init_scope(): # setup links dim_in_encoder = 3 if no_texture: texture_decoder_type = 'dummy' dim_in_discriminator = 1 else: dim_in_discriminator = 4 self.encoder = encoders.get_encoder(encoder_type, dim_in_encoder, self.dim_hidden) self.shape_decoder = decoders.get_shape_decoder(shape_decoder_type, self.dim_hidden, vertex_scaling) self.texture_decoder = decoders.get_texture_decoder(texture_decoder_type, self.dim_hidden, texture_scaling) self.discriminator = discriminators.get_discriminator(discriminator_type, dim_in_discriminator) self.shape_encoder = self.encoder
def __init__(self, opt, lexicon, pretrained_wembs=None, pretrained_user=None, lang_model=None): """Constructor :param input_dim: Embedding dimension :param hidden_dim: Dimension of the recurrent layers :param att_dim: Dimension of the hidden layer in the attention MLP :param lexicon: Lexicon object containing dictionaries/bilingual discrete lexicons... :param enc_type: Type of encoder :param att_type: Type of attention mechanism :param dec_type: Type of decoder :param model_file: File where the model should be saved (default: (None)) :param label_smoothing: interpolation coefficient with second output distribution :param dropout: dropout rate for parameters :param word_dropout: dropout rate for words in the decoder :param max_len: Maximum length allowed when generating translations (default: (60)) """ # Store config self.nl = opt.num_layers self.dr, self.wdr = opt.dropout_rate, opt.word_dropout_rate self.ls, self.ls_eps = (opt.label_smoothing > 0), opt.label_smoothing self.max_len = opt.max_len self.src_sos, self.src_eos = lexicon.w2ids['SOS'], lexicon.w2ids['EOS'] self.trg_sos, self.trg_eos = lexicon.w2idt['SOS'], lexicon.w2idt['EOS'] # Dimensions self.vs, self.vt = len(lexicon.w2ids), len(lexicon.w2idt) self.du = opt.usr_dim self.nu = len(lexicon.usr2id) self.di, self.dh, self.da = opt.emb_dim, opt.hidden_dim, opt.att_dim # Model self.pc = dy.ParameterCollection() self.model_file = opt.model # Encoder self.enc = encoders.get_encoder(opt.encoder, self.nl, self.di, self.dh, self.du, self.vs, self.pc, dr=self.dr, pre_embs=pretrained_wembs) # Attention module self.att = attention.get_attention(opt.attention, self.enc.dim, self.dh, self.da, self.pc) # Decoder self.dec = decoders.get_decoder(opt.decoder, self.nl, self.di, self.enc.dim, self.dh, self.vt, self.du, self.pc, pre_embs=pretrained_wembs, dr=self.dr, wdr=self.wdr) # User recognizer parameters self.usr = user.ZeroVocabUserRecognizer(self.vt, self.nu, self.enc.dim, self.pc) # Target language model (for label smoothing) self.lm = lang_model self.lex = lexicon self.unk_replace = opt.unk_replacement self.user_token = opt.user_token self.test = True self.update = True
def decode_anchor(anchor: AnchorCfg): enc = get_encoder(anchor.encoder_id) if enc == None: raise Exception(f'unknown encoder: {anchor.encoder_id}') for var in anchor.variants: enc.decode_variant(var)
tokenizer=tokenizer, # TODO: token_indexer 的 key token_indexers={'tokens': token_indexers}) train_ds, test_ds = [reader.read(fname) for fname in ['train', 'test']] val_ds = None voc = Vocabulary() iterator = BucketIterator(batch_size=config.batch_size, sorting_keys=[('sentence', 'num_tokens')]) iterator.index_with(vocab=voc) # 2. 搭建模型 word_embeddings = get_embedder() encoder = get_encoder(voc, word_embeddings.get_output_dim()) model = BaseModelWithoutKnowledge(voc=voc, word_embeddings=word_embeddings, encoder=encoder, out_sz=reader.label_length, multi=False) model = model.cuda(cuda_device) if cuda_device > -1 else model # 3. 训练 optimizer = optim.Adam(model.parameters(), lr=config.lr) trainer = Trainer( model=model, optimizer=optimizer, iterator=iterator, train_dataset=train_ds,
def __init__( self, encoder_type, shape_decoder_type, texture_decoder_type, discriminator_type, silhouette_loss_type, vertex_scaling, texture_scaling, silhouette_loss_levels, lambda_silhouettes, lambda_perceptual, lambda_inflation, lambda_graph_laplacian, lambda_discriminator, no_texture, class_conditional, symmetric, dim_hidden=512, image_size=224, anti_aliasing=False, ): super(PascalModel, self).__init__() self.trainer = None self.dataset_name = 'pascal' # model size self.dim_hidden = dim_hidden # loss type self.silhouette_loss_type = silhouette_loss_type self.silhouette_loss_levels = silhouette_loss_levels # loss weights self.lambda_silhouettes = lambda_silhouettes self.lambda_perceptual = lambda_perceptual self.lambda_discriminator = lambda_discriminator self.lambda_inflation = lambda_inflation self.lambda_graph_laplacian = lambda_graph_laplacian # others self.no_texture = no_texture self.class_conditional = class_conditional self.symmetric = symmetric self.use_depth = False # setup renderer self.renderer = neural_renderer.Renderer() self.renderer.image_size = image_size self.renderer.anti_aliasing = anti_aliasing self.renderer.perspective = False self.renderer.camera_mode = 'none' with self.init_scope(): # setup links dim_in_encoder = 3 if no_texture: texture_decoder_type = 'dummy' dim_in_discriminator = 1 else: dim_in_discriminator = 4 self.encoder = encoders.get_encoder(encoder_type, dim_in_encoder, self.dim_hidden) self.shape_decoder = decoders.get_shape_decoder( shape_decoder_type, self.dim_hidden, vertex_scaling, symmetric) self.texture_decoder = decoders.get_texture_decoder( texture_decoder_type, self.dim_hidden, texture_scaling, self.symmetric) self.discriminator = discriminators.get_discriminator( discriminator_type, dim_in_discriminator)