def __init__(self, state_dim, action_dim, seq_len): super(Actor, self).__init__() # self.tcn = TCN(state_dim, state_dim, num_channels, kernel_size=kernel_size, dropout=dropout).to(device) # 预测所有状态 self.bn1 = nn.BatchNorm1d(state_dim) self.tcn = TemporalConvNet(input_channels, num_channels, kernel_size=kernel_size, dropout=dropout) self.fc1 = nn.Linear(num_channels[-1], state_dim) self.fc2 = nn.Linear(num_channels[-1], action_dim)
def __init__(self, input_size, output_size, num_channels, kernel_size=2, dropout=0.3, emb_dropout=0.1, tied_weights=False): super(TCN, self).__init__() self.encoder = nn.Embedding(output_size, input_size) self.tcn = TemporalConvNet(input_size, num_channels, kernel_size, dropout=dropout) self.decoder = nn.Linear(num_channels[-1], output_size) if tied_weights: if num_channels[-1] != input_size: raise ValueError( 'When using the tied flag, nhid must be equal to emsize') self.decoder.weight = self.encoder.weight print("Weight tied") self.drop = nn.Dropout(emb_dropout) self.emb_dropout = emb_dropout self.init_weights()
def __init__(self, input_size, output_size, num_channels, kernel_size=2, dropout=0.3, emb_dropout=0.1, tied_weights=False): super(TCN, self).__init__() # 将one-hot encoding 部分送入编码器作为一个批量的词嵌入向量 # output_size为词汇量,input_size是词向量的长度 self.encoder = nn.Embedding(output_size, input_size) self.tcn = TemporalConvNet(input_size, num_channels, kernel_size, dropout=dropout) # 定义最后线性变换的维度,即最后一个卷积层的通道数到所有词汇的映射 self.decoder = nn.Linear(num_channels[-1], output_size) if tied_weights: # 是否共享编码器与解码器的权重,默认值为共享 # 共享时需要保持隐藏单元数等于词嵌入的长度 # 此时将预测的向量认为是词嵌入向量 if num_channels[-1] != input_size: raise ValueError( 'When using the tied flag, nhid must be equal to emsize') self.decoder.weight = self.encoder.weight print("Weight tied") self.drop = nn.Dropout(emb_dropout) # 对输入词嵌入进行dropout self.emb_dropout = emb_dropout self.init_weights()
def __init__(self, input_size, output_size, num_channels, kernel_size, dropout): super(TCN, self).__init__() # 构建tcn网络 self.tcn = TemporalConvNet(input_size, num_channels, kernel_size=kernel_size, dropout=dropout) # 将网络输出映射到实际输出,使用线性映射 self.linear = nn.Linear(num_channels[-1], output_size) self.init_weights()
def __init__(self, input_size, output_size, num_channels, kernel_size=2, dropout=0.3, emb_dropout=0.1, tied_weights=False): #input_size = 600 #output_size = 10000 vocab_size 不重复单词个数 #num_channels = [600,600,600,600] #kernel_size = 3 #dropout = 0.45 #emb_dropout = 0.25 #tied_weights= True super(TCN, self).__init__() self.encoder = nn.Embedding(output_size, input_size) #vocab_10000 * 600 随机初始化 self.tcn = TemporalConvNet(input_size, num_channels, kernel_size, dropout=dropout) self.decoder = nn.Linear(num_channels[-1], output_size) if tied_weights: if num_channels[-1] != input_size: raise ValueError( 'When using the tied flag, nhid must be equal to emsize') self.decoder.weight = self.encoder.weight print("Weight tied") self.drop = nn.Dropout(emb_dropout) self.emb_dropout = emb_dropout self.init_weights()
def __init__(self, input_size, output_size, num_channels, kernel_size, dropout): super(TCN, self).__init__() self.tcn = TemporalConvNet(input_size, num_channels, kernel_size=kernel_size, dropout=dropout) self.linear = nn.Linear(num_channels[-1], output_size)
def __init__(self, input_size, output_size, num_channels, kernel_size, dropout, use_fixup_init): super(TCN, self).__init__() self.tcn = TemporalConvNet(input_size, num_channels, kernel_size, dropout=dropout, use_fixup_init=use_fixup_init) self.linear = nn.Linear(num_channels[-1], output_size) self.sig = nn.Sigmoid()
def __init__(self, args, num_inputs, num_actions, hidden_size, action_range=1., init_w=3e-3, log_std_min=-20, log_std_max=2): super(PolicyNetwork, self).__init__() # # Example of using Sequential # model = nn.Sequential( # nn.Conv2d(1,20,5), # nn.ReLU(), # nn.Conv2d(20,64,5), # nn.ReLU() # ) self.log_std_min = log_std_min self.log_std_max = log_std_max self.num_inputs = num_inputs # self.output_dim = num_actions # self.hidden_dim = hidden_size # self.bn1 = nn.BatchNorm1d(state_dim) self.tcn = TemporalConvNet(input_channels, [args['nhid']] * args['levels'], kernel_size=kernel_size, dropout=args['dropout']) # self.fc1 = nn.Linear(num_channels[-1], hidden_size) self.model = nn.Sequential( nn.Linear(num_channels[-1], hidden_size), # 输入10维,隐层20维 # nn.BatchNorm1d(hidden_size, affine=True, track_running_stats=True), # BN层,参数为隐层的个数 nn.LayerNorm(hidden_size, elementwise_affine=True), nn.ReLU(), # 激活函数 # nn.Linear(hidden_size, hidden_size), # 输入10维,隐层20维 # # nn.BatchNorm1d(hidden_size, affine=True, track_running_stats=True), # BN层,参数为隐层的个数 # nn.LayerNorm(hidden_size, elementwise_affine=True), # nn.ReLU(), ) self.mean_linear = nn.Linear(hidden_size, num_actions) self.mean_linear.weight.data.uniform_(-init_w, init_w) self.mean_linear.bias.data.uniform_(-init_w, init_w) self.log_std_linear = nn.Linear(hidden_size, num_actions) self.log_std_linear.weight.data.uniform_(-init_w, init_w) self.log_std_linear.bias.data.uniform_(-init_w, init_w) self.action_range = action_range self.num_actions = num_actions
def __init__(self, input_size, output_size, num_channels, kernel_size, dropout): # input_size = 88, output_size = 88, num_channels = [150] * 4, kernel_size = 5 super(TCN, self).__init__() # With Batch size as N, Seq len as L and Number of features as C, initial data is N x L x C (C = 88) self.tcn = TemporalConvNet(input_size, num_channels, kernel_size, dropout=dropout) self.linear = nn.Linear(num_channels[-1], output_size) self.sig = nn.Sigmoid()
def build_tcn(inputs, tcn_dropout, kernel_size, num_channels): # inputs = placeholder # self.dropout = tf.placeholder_with_default(0., shape=()) # num_channels = [hidden1, hidden2, ...., outputchannel] # kernel_size tcn = TemporalConvNet(num_channels, stride=1, kernel_size=kernel_size, dropout=tcn_dropout) outputs = tcn(inputs) return outputs
class TCN(nn.Module): def __init__(self, input_size=1, output_size=10, num_channels=None, kernel_size=7, dropout=0.05): super(TCN, self).__init__() num_channels = [25] * 8 if num_channels is None else num_channels self.tcn = TemporalConvNet(input_size, num_channels, kernel_size=kernel_size, dropout=dropout) self.linear = nn.Linear(num_channels[-1], output_size) self.receptive_field = self.tcn.receptive_field def forward(self, inputs): """Inputs have to have dimension (N, C_in, L_in)""" y1 = self.tcn(inputs) # input should have dimension (N, C, L) o = self.linear(y1[:, :, -1]) return F.log_softmax(o, dim=1) def single_forward(self, input): return F.log_softmax(self.linear(self.tcn.single_forward(input).squeeze(dim=2)), dim=1) def fast_inference(self, batch_size): self.tcn.fast_inference(batch_size) def compare(self, inputs): y1 = self.tcn(inputs) y2 = torch.zeros(y1.size()).to(y1.device) for i in range(inputs.size()[2]): y2[:,:,i] = self.tcn.single_forward(inputs[:,:,i].view(inputs.size()[0], inputs.size()[1], 1)).squeeze() return (y1 == y2).all().item() def reset_cache(self): self.tcn.reset_cache()
def __init__(self, input_size, output_size, num_channels, kernel_size, dropout): # input_size = 1, output_size = 10, num_channels = [nhid] * levels = [10] * 8, kernel_size = 8 super(TCN, self).__init__() # With Batch size as N, Seq len as L and 1 feature, initial data is 32 x 1 x 1020 self.tcn = TemporalConvNet(input_size, num_channels, kernel_size=kernel_size, dropout=dropout) # input to linear is N x L x nhid = 32 x 1020 x 10 self.linear = nn.Linear(num_channels[-1], output_size) # input of linear is N x L x nhid = 32 x 1020 x 10 self.init_weights()
def __init__(self, input_size, output_size, num_channels, kernel_size, dropout): # input_size = 2, output_size = 1, num_channels = [nhid] * levels = [30] * 4, kernel_size = 7 super(TCN, self).__init__() # With Batch size as N, Seq len as L and 2 features, initial data is N x 2 x L self.tcn = TemporalConvNet(input_size, num_channels, kernel_size=kernel_size, dropout=dropout) # input to linear is N x nhid x l = N x 30 x 1 where l is last element of sequence self.linear = nn.Linear(num_channels[-1], output_size) # output of linear is N x 1 x 1 self.init_weights()
def __init__(self, input_size, output_size, num_channels, window_size, num_fingers, kernel_size, dropout): super(TCN, self).__init__() self.tcn = TemporalConvNet(input_size, num_channels, kernel_size=kernel_size, dropout=dropout) self.linear1 = nn.Linear( (8 + (window_size - 1) * num_fingers) * num_channels[-1], (8 + (window_size - 1) * num_fingers) * num_channels[-1]) self.linear2 = nn.Linear( (8 + (window_size - 1) * num_fingers) * num_channels[-1], output_size)
def __init__(self, output_size: int, seq_length: int, num_channels: list, kernel_size: int, dropout: float, dt): super(LowResolutionTCN, self).__init__() self.tcn = TemporalConvNet(output_size, num_channels, kernel_size=kernel_size, dropout=dropout) self.linear1 = nn.Linear(num_channels[-1] + 2, output_size) # self.linear2 = nn.Linear(output_size, output_size) # self.fc = nn.Sequential(self.linear1, nn.Sigmoid(), self.linear2) self.euler_clock = TimePassing(dt) self.output_size = output_size self.init_weights()
def __init__(self, word2vec_model, embedding_dim, hidden_dim, output_dim, num_layers=1, dropout=0.2, use_gdelt=False, use_TCN=False, effective_history=91): """ :param word2vec_model: the actual model that would embed the tweets :param embedding_dim: :param hidden_dim: :param num_layers: :param dropout: """ super().__init__() self.word2vec_model = word2vec_model self.embedding_dim = embedding_dim self.hidden_dim = hidden_dim self.output_dim = output_dim self.use_gdelt = use_gdelt self.use_TCN = use_TCN if use_TCN: num_levels, kernel_size = get_TCN_params_from_effective_history( effective_history) num_channels = [hidden_dim] * num_levels self.temporal_extractor = TemporalConvNet(embedding_dim, num_channels, kernel_size, dropout) else: self.temporal_extractor = nn.LSTM(embedding_dim, hidden_dim, num_layers, batch_first=True, dropout=dropout) # at the moment this is without considering additional info about the tweets like the number of mentions, etc... # also the structure is arbitrary at the moment self.num_handmade_features = 4 self.feature_extractor = nn.Linear( hidden_dim + self.num_handmade_features, output_dim) self.means = torch.Tensor([1.0901, 0.0135, 0.8929, 2.8000]) self.stds = torch.Tensor([17.6291, 0.1156, 0.3092, 1.9421])
def __init__(self, input_size, output_size, num_channels, kernel_size=2, dropout=0.2, emb_dropout=0.2): super(TCN, self).__init__() self.encoder = nn.Embedding(output_size, input_size) self.tcn = TemporalConvNet(input_size, num_channels, kernel_size=kernel_size, dropout=dropout) self.decoder = nn.Linear(input_size, output_size) self.decoder.weight = self.encoder.weight self.drop = nn.Dropout(emb_dropout) self.init_weights()
def __init__(self, input_size=1, output_size=10, num_channels=None, kernel_size=7, dropout=0.05): super(TCN, self).__init__() num_channels = [25] * 8 if num_channels is None else num_channels self.tcn = TemporalConvNet(input_size, num_channels, kernel_size=kernel_size, dropout=dropout) self.linear = nn.Linear(num_channels[-1], output_size) self.receptive_field = self.tcn.receptive_field