标签: transformer-model

我已经使用标准进程工作了API,但我想data从JSON输出中删除命名空间.我看到我需要实现ArraySerializer,我已经完成了分形文档,但我无法找到我需要在Laravel 5.2中添加它的地方

我找到了这个答案,但我只是在我注释掉的代码行中得到了相同的输出:

class TrackController extends ApiController
{
    public function index()
    {
        $tracks = Track::all();
        //return $this->respondWithCollection($tracks, new TrackTransformer);
        // Same response as the commented out line above
        $response = new \League\Fractal\Resource\Collection($tracks, new TrackTransformer);
        $manager = new \League\Fractal\Manager();
        $manager->setSerializer(new \League\Fractal\Serializer\ArraySerializer());
        return response()->json($manager->createData($response)->toArray());
    }

    public function show($id)
    {
        $track = Track::find($id);
        return $this->respondWithItem($track, new TrackTransformer);
    }
}

另外,我在一个特定的控制器上实现它,即使我有这个工作,我在哪里添加代码/类,以便我可以获得所有控制器的ArraySerializer输出？

如果有帮助的话,我已经在Github上发布了这个.

我的sklearn管道中有一个自定义 Transformer，我想知道如何将参数传递给我的 Transformer ：

在下面的代码中，您可以看到我在 Transformer 中使用了字典“权重”。我不希望在我的 Transformer 中定义这个字典，而是从管道传递它，这样我就可以在网格搜索中包含这个字典。是否可以将字典作为参数传递给我的 Transformer ？

# My custom Transformer
  class TextExtractor(BaseEstimator, TransformerMixin):
        """Concat the 'title', 'body' and 'code' from the results of 
        Stackoverflow query
        Keys are 'title', 'body' and 'code'.
        """
        def fit(self, x, y=None):
            return self

        def transform(self, x):
            # here is the parameter  I want to pass to my transformer
            weight ={'title' : 10, 'body': 1, 'code' : 1}
            x['text'] = weight['title']*x['Title'] +  
            weight['body']*x['Body'] +  
            weight['code']*x['Code']

            return x['text']

param_grid = …

我正在尝试使用 nn.Transformer 类训练 Transformer Seq2Seq 模型。我相信我的实现是错误的，因为当我训练它时，它似乎适应得太快了，并且在推理过程中它经常重复。这似乎是解码器中的掩码问题，当我移除目标掩码时，训练性能是相同的。这让我相信我做的目标屏蔽是错误的。这是我的模型代码：

class TransformerModel(nn.Module):
    def __init__(self, 
        vocab_size, input_dim, heads, feedforward_dim, encoder_layers, decoder_layers, 
        sos_token, eos_token, pad_token, max_len=200, dropout=0.5, 
        device=(torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu"))):

        super(TransformerModel, self).__init__()
        self.target_mask = None
        self.embedding = nn.Embedding(vocab_size, input_dim, padding_idx=pad_token)
        self.pos_embedding = nn.Embedding(max_len, input_dim, padding_idx=pad_token)
        self.transformer = nn.Transformer(
            d_model=input_dim, nhead=heads, num_encoder_layers=encoder_layers, 
            num_decoder_layers=decoder_layers, dim_feedforward=feedforward_dim, 
            dropout=dropout)
        self.out = nn.Sequential(
            nn.Linear(input_dim, feedforward_dim), 
            nn.ReLU(), 
            nn.Linear(feedforward_dim, vocab_size))

        self.device = device
        self.max_len = max_len
        self.sos_token = sos_token
        self.eos_token = eos_token

    # Initialize all weights to be uniformly distributed between -initrange …

我尝试了以下标记化示例：

tokenizer = BertTokenizer.from_pretrained(MODEL_TYPE, do_lower_case=True)
sent = "I hate this. Not that.",        
_tokenized = tokenizer(sent, padding=True, max_length=20, truncation=True)
print(_tknzr.decode(_tokenized['input_ids'][0]))
print(len(_tokenized['input_ids'][0]))

输出是：

[CLS] i hate this. not that. [SEP]
9

tokenizer注意:的参数max_length=20。如何让 Bert 分词器将 11 个[PAD]分词附加到这句话中以使其总计20？

我最近正在阅读huggingface项目的bert源代码。我注意到所谓的“可学习位置编码”在实现时似乎指的是特定的 nn.Parameter 层。

def __init__(self):\n    super()\n    positional_encoding = nn.Parameter()\ndef forward(self, x):\n    x += positional_encoding\n

\xe2\x86\x91 可能是这种感觉，然后进行了可学习的位置编码。不管是不是这么简单，我不确定我理解是否正确，我想请教有经验的人。

此外，我注意到一个经典的 bert 结构，其位置实际上仅在初始输入时编码一次。这是否意味着后续的bert层，对于彼此来说，失去了捕获位置信息的能力？

BertModel(\n  (embeddings): BertEmbeddings(\n    (word_embeddings): Embedding(30522, 768, padding_idx=0)\n    (position_embeddings): Embedding(512, 768)\n    (token_type_embeddings): Embedding(2, 768)\n    (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n    (dropout): Dropout(p=0.1, inplace=False)\n  )\n  (encoder): BertEncoder(\n    (layer): ModuleList(\n      (0): BertLayer(...)\n      ...\n  (pooler): BertPooler(...)\n

如果在下一个 BERT 层之前对上一层的结果进行重新位置编码，我会得到更好的结果吗？

BERT 输出不是确定性的。当我输入相同的输入时，我希望输出值是确定性的，但是我的 bert 模型中的值正在发生变化。听起来很尴尬，相同的值被返回两次，一次。也就是说，一旦出现另一个值，就会出现相同的值并重复。如何使输出具有确定性？让我展示我的代码片段。我使用的模型如下。

对于 BERT 实现，我使用了 Huggingface 实现的 BERT pytorch 实现。这是 pytorch 领域非常有名的模型 ri 实现。[链接] https://github.com/huggingface/pytorch-pretrained-BERT/

        tokenizer = BertTokenizer.from_pretrained(self.bert_type, do_lower_case=self.do_lower_case, cache_dir=self.bert_cache_path)
        pretrain_bert = BertModel.from_pretrained(self.bert_type, cache_dir=self.bert_cache_path)
        bert_config = pretrain_bert.config

得到这样的输出

        all_encoder_layer, pooled_output = self.model_bert(all_input_ids, all_segment_ids, all_input_mask)

        # all_encoder_layer: BERT outputs from all layers.
        # pooled_output: output of [CLS] vec.

pooled_output

tensor([[-3.3997e-01,  2.6870e-01, -2.8109e-01, -2.0018e-01, -8.6849e-02,

tensor([[ 7.4340e-02, -3.4894e-03, -4.9583e-03,  6.0806e-02,  8.5685e-02,

tensor([[-3.3997e-01,  2.6870e-01, -2.8109e-01, -2.0018e-01, -8.6849e-02,

tensor([[ 7.4340e-02, -3.4894e-03, -4.9583e-03,  6.0806e-02,  8.5685e-02,

对于所有编码器层，情况是相同的， - 一次两次相同。

我从bert中提取词嵌入特征，情况是一样的。

wemb_n
tensor([[[ 0.1623,  0.4293, …

我正在关注这个关于变压器的博客

http://jalammar.github.io/illustrated-transformer/

我唯一不明白的是为什么需要一堆编码器或解码器。我知道多头注意力层捕获了问题的不同表示空间。我不明白为什么需要垂直堆叠的编码器和解码器。一个编码器/解码器层不能工作吗？

我已经使用 tf.keras 创建了一个自定义计划，并且在保存模型时遇到了这个错误：

NotImplementedError：学习率计划必须覆盖 get_config

这个类看起来像这样：

class CustomSchedule(tf.keras.optimizers.schedules.LearningRateSchedule):

    def __init__(self, d_model, warmup_steps=4000):
        super(CustomSchedule, self).__init__()

        self.d_model = d_model
        self.d_model = tf.cast(self.d_model, tf.float32)

        self.warmup_steps = warmup_steps

    def __call__(self, step):
        arg1 = tf.math.rsqrt(step)
        arg2 = step * (self.warmup_steps**-1.5)

        return tf.math.rsqrt(self.d_model) * tf.math.minimum(arg1, arg2)

    def get_config(self):
        config = {
            'd_model':self.d_model,
            'warmup_steps':self.warmup_steps

        }
        base_config = super(CustomSchedule, self).get_config()
        return dict(list(base_config.items()) + list(config.items()))

我试图理解为什么变压器使用多个注意力头。我找到了以下引用：

Transformer 使用多个注意力头，而不是使用单个注意力函数（其中注意力可以由实际单词本身主导）。

“注意力由单词本身主导”是什么意思？使用多个头如何解决这个问题？

错误：add_nan=True在 pytorch 预测中创建时间序列数据集时，“遇到未知类别 '2'。设置为允许未知类别”。

training = TimeSeriesDataSet(
train,
time_idx="index",
target=dni,
group_ids=["Solar Zenith Angle", "Relative Humidity","Dew 
Point","Temperature","Precipitable Water", "Wind Speed"],
min_encoder_length=max_encoder_length // 2,  # keep encoder length long (as it is in the 
validation set)
max_encoder_length=max_encoder_length,
min_prediction_length=1,
max_prediction_length=max_prediction_length,
static_reals=["Wind Direction"],
time_varying_known_reals=["index", "Solar Zenith Angle", "Relative Humidity","Dew 
Point","Temperature","Precipitable Water"],
#     time_varying_unknown_categoricals=[],
time_varying_unknown_reals=[dhi,dni,ghi],
categorical_encoders={data.columns[2]: NaNLabelEncoder(add_nan=True)},
target_normalizer=GroupNormalizer(
    groups=["Solar Zenith Angle", "Relative Humidity","Dew 
Point","Temperature","Precipitable Water", "Wind Speed"], transformation="softplus"
),  # use softplus and normalize by group
add_relative_time_idx=True,
add_target_scales=True,
add_encoder_length=True,

）