def __init__(self, input_size,
vocab_size,
embedding_dim,
use_word2vec = False,
embedding_weight_path = None,
kernel_nums=(100, 100, 100),
kernel_sizes=(3, 4, 5),
padding=0,
dropout=0.5):
super(CNNModel, self).__init__()
# no support for pre-trained embedding currently
self.embeddings = torch.nn.Embedding(input_size, embedding_dim)
if use_word2vec:
self.embeddings.weight.data.copy_(
torch.from_numpy(
load_embedding_matrix(embedding_weight_path)
))
self.conv_pool = encoder.ConvMaxpool(
in_channels=embedding_dim,
out_channels=kernel_nums,
kernel_sizes=kernel_sizes,
padding=padding)
self.dropout = nn.Dropout(dropout)
self.fc1 = torch.nn.Linear(sum(kernel_nums), sum(kernel_nums))
self.fc2 = torch.nn.Linear(sum(kernel_nums), vocab_size)
self.fc = torch.nn.Linear(sum(kernel_nums), vocab_size)
def __init__(self, init_embed,
num_classes,
hidden_size=64,
num_layers=1,
kernel_nums=(3, 4, 5),
kernel_sizes=(3, 4, 5),
padding=0,
dropout=0.5):
super(RCNNText, self).__init__()
#embedding
self.embed = encoder.Embedding(init_embed)
self.conv_pool = encoder.ConvMaxpool(
in_channels=self.embed.embedding_dim+hidden_size*2,
out_channels=kernel_nums,
kernel_sizes=kernel_sizes,
padding=padding)
# #RNN layer
self.lstm = nn.LSTM(
input_size=self.embed.embedding_dim,
hidden_size=hidden_size,
num_layers=num_layers,
bias=True,
bidirectional=True
)
self.dropout = nn.Dropout(dropout)
self.fc = nn.Linear(sum(kernel_nums), num_classes)
def __init__(self,
src_embed,
num_classes,
kernel_nums=(25, 25, 25),
kernel_sizes=(3, 4, 5),
padding=0,
dropout=0.5):
super(CNNText, self).__init__()
self.src_embed = src_embed
self.conv_pool = encoder.ConvMaxpool(in_channels=src_embed.embed_dim,
out_channels=kernel_nums,
kernel_sizes=kernel_sizes,
padding=padding)
self.dropout = nn.Dropout(dropout)
self.fc = nn.Linear(sum(kernel_nums), num_classes)
def __init__(self, init_embed,
num_classes,
kernel_nums=(10, 10, 10, 10),
kernel_sizes=(2, 3, 4, 5),
padding=0,
dropout=0.5):
super(CNNText, self).__init__()
# no support for pre-trained embedding currently
self.embed = encoder.Embedding(init_embed)
self.conv_pool = encoder.ConvMaxpool(
in_channels=self.embed.embedding_dim,
out_channels=kernel_nums,
kernel_sizes=kernel_sizes,
padding=padding)
self.dropout = nn.Dropout(dropout)
self.fc = nn.Linear(sum(kernel_nums), num_classes)
def __init__(self,
init_embed,
num_classes,
kernel_nums=(4, 5, 6),
kernel_sizes=(3, 4, 5),
padding=0,
dropout=0.5):
super(CNN, self).__init__()
self.embed = encoder.Embedding(init_embed)
self.conv_pool = encoder.ConvMaxpool(
in_channels=self.embed.embedding_dim,
out_channels=kernel_nums,
kernel_sizes=kernel_sizes,
padding=padding)
self.dropout = nn.Dropout(dropout)
self.fc = nn.Linear(sum(kernel_nums), num_classes)
def __init__(self,
vocab_size,
input_size,
target_size,
kernel_num=(3, 4, 5),
kernel_size=(3, 4, 5),
padding=0,
dropout=0.2):
super(CNN_Text, self).__init__()
self.embed = encoder.Embedding((vocab_size, input_size))
self.conv = encoder.ConvMaxpool(in_channels=input_size,
out_channels=kernel_num,
kernel_sizes=kernel_size,
padding=padding)
self.dropout = nn.Dropout(dropout)
self.linear = nn.Linear(sum(kernel_num), target_size)
def __init__(self,
vocab_size,
embedding_dim,
num_classes,
kernel_nums=(4, 5, 6),
kernel_sizes=(4, 5, 6),
padding=2,
dropout=0.1):
super().__init__()
self.embedding = nn.Embedding(vocab_size, embedding_dim)
self.conv_pool = encoder.ConvMaxpool(
in_channels=self.embedding.embedding_dim,
out_channels=kernel_nums,
kernel_sizes=kernel_sizes,
padding=padding)
self.dropout = nn.Dropout(dropout)
self.fc = nn.Linear(sum(kernel_nums), num_classes)
def __init__(self,
vocab_size,
embed_dim,
num_classes,
padding=0,
dropout=0.5,
kernel_nums=(50, 50, 50),
kernel_sizes=(3, 4, 5)):
super(CNN, self).__init__()
self.embed_dim = embed_dim
self.embedding = nn.Embedding(vocab_size, self.embed_dim)
self.conv_pool = encoder.ConvMaxpool(in_channels=self.embed_dim,
out_channels=kernel_nums,
kernel_sizes=kernel_sizes,
padding=padding)
self.dropout = nn.Dropout(dropout)
self.fc = nn.Linear(sum(kernel_nums), num_classes)
def __init__(self,
embed_num,
embed_dim,
num_classes,
kernel_nums=(3, 4, 5),
kernel_sizes=(3, 4, 5),
padding=0,
dropout=0.5):
super(CNNText, self).__init__()
# no support for pre-trained embedding currently
self.embed = encoder.Embedding(embed_num, embed_dim)
self.conv_pool = encoder.ConvMaxpool(in_channels=embed_dim,
out_channels=kernel_nums,
kernel_sizes=kernel_sizes,
padding=padding)
self.dropout = nn.Dropout(dropout)
self.fc = encoder.Linear(sum(kernel_nums), num_classes)
self._loss = nn.CrossEntropyLoss()
def __init__(self,
init_embed,
num_classes,
vocab,
pretrained_weight,
kernel_nums=(10, 10, 10, 10),
kernel_sizes=(2, 3, 4, 5),
padding=0,
dropout=0.5):
super(w2vCNNText, self).__init__()
# no support for pre-trained embedding currently
self.word_embeds = nn.Embedding(init_embed[0], init_embed[1])
pretrained_weight = np.array(pretrained_weight)
self.word_embeds.weight.data.copy_(torch.from_numpy(pretrained_weight))
self.conv_pool = encoder.ConvMaxpool(in_channels=init_embed[1],
out_channels=kernel_nums,
kernel_sizes=kernel_sizes,
padding=padding)
self.dropout = nn.Dropout(dropout)
self.fc = nn.Linear(sum(kernel_nums), num_classes)
def __init__(self,
embed,
num_classes,
kernel_nums=(30, 40, 50),
kernel_sizes=(1, 3, 5),
dropout=0.5):
r"""
:param tuple(int,int),torch.FloatTensor,nn.Embedding,numpy.ndarray embed: Embedding的大小(传入tuple(int, int),
第一个int为vocab_zie, 第二个int为embed_dim); 如果为Tensor, Embedding, ndarray等则直接使用该值初始化Embedding
:param int num_classes: 一共有多少类
:param int,tuple(int) kernel_sizes: 输出channel的kernel大小。
:param float dropout: Dropout的大小
"""
super(CNNText, self).__init__()
# no support for pre-trained embedding currently
self.embed = embedding.Embedding(embed)
self.conv_pool = encoder.ConvMaxpool(
in_channels=self.embed.embedding_dim,
out_channels=kernel_nums,
kernel_sizes=kernel_sizes)
self.dropout = nn.Dropout(dropout)
self.fc = nn.Linear(sum(kernel_nums), num_classes)
