我已经使用 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()))

选择 BPE 与 WordPiece 标记化之间的一般权衡是什么？什么时候其中一个比另一个更好？两者之间的模型性能有什么差异吗？我正在寻找一个普遍的整体答案，并辅以具体的例子。谢谢！

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

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,

）

我使用XPath来解析由URL返回的XML文档,当我使用给定的输入运行我的代码时它可以工作但是当它作为用户输入提供输入时它会引发异常. 代码:

    class{
        private String generalQuery =  "//@*";
    method(){
        System.out.println("Enter URL");
        url = scan.nextLine();
        URL oracle = new URL(url);
        InputStream is = oracle.openStream();

        org.w3c.dom.Document doc = null;
        DocumentBuilderFactory domFactory;
        DocumentBuilder builder;

        try {
            domFactory = DocumentBuilderFactory.newInstance();
            domFactory.setNamespaceAware(true);
            builder = domFactory.newDocumentBuilder();
            doc = builder.parse(is);
        } catch (Exception ex) {
            System.err.println("unable to load XML: " + ex);
        }

    Map <String, String> params = new HashMap<String, String> ();

            XPathFactory factory = XPathFactory.newInstance();
            XPath xpath = factory.newXPath();
            xpath.setNamespaceContext(new NameSpaces(doc));
            XPathExpression expr = xpath.compile(generalQuery);
            Object …

我是骡子的新手.

我尝试使用SOAP创建一个简单的登录流程,它将返回XML Response.我的方法是用XML发送数据,然后我将登录数据保存在转换代码中,保存数据后,返回数据将生成为xml响应.但我有错误"有两个变压器完全匹配输入".我不明白为什么会这样.请帮我解决这个问题.

这是我的流程代码:

<http:listener-config name="HTTP_Listener_Configuration" host="0.0.0.0" 

port="8081" doc:name="HTTP Listener Configuration"/>
<cxf:configuration name="CXF_Configuration" enableMuleSoapHeaders="true" initializeStaticBusInstance="true" doc:name="CXF Configuration"/>
<mulexml:jaxb-context name="myJaxb" packageNames="com.test.service" doc:name="JAXB Context"/>

<flow name="LoginFlow" initialState="started">
<http:listener config-ref="HTTP_Listener_Configuration" path="/Login" doc:name="HTTP"/>
<cxf:proxy-service configuration-ref="CXF_Configuration" doc:name="CXF" namespace="http://www.test.co.id/SOA/service/1.0" payload="body" port="LoginPort" service="LoginService" wsdlLocation="service/login-test.wsdl"/>
<logger message="#[payload]" level="INFO" doc:name="Logger"/>
<mulexml:dom-to-xml-transformer returnClass="java.lang.String" doc:name="DOM to XML"/>
<logger message="#[payload]" level="INFO" doc:name="Logger"/>
<custom-transformer class="com.test.transform.XMLTransform" doc:name="XML To Java" returnClass="com.test.service.LoginResponse"/>
<mulexml:jaxb-object-to-xml-transformer jaxbContext-ref="myJaxb" doc:name="JAXB Object to XML"/>
<mulexml:xml-to-dom-transformer doc:name="XML to DOM"/>
</flow>

错误堆栈:

1. There are two transformers that are an exact match for input: …

编写我的第一个sk-learn管道时,我只是遇到一些问题,只有一部分列被放入管道:

mydf = pd.DataFrame({'classLabel':[0,0,0,1,1,0,0,0],
                   'categorical':[7,8,9,5,7,5,6,4],
                   'numeric1':[7,8,9,5,7,5,6,4],
                   'numeric2':[7,8,9,5,7,5,6,"N.A"]})
columnsNumber = ['numeric1']
XoneColumn = X[columnsNumber]

我用的functionTransformer是:

def extractSpecificColumn(X, columns):
    return X[columns]

pipeline = Pipeline([
    ('features', FeatureUnion([
        ('continuous', Pipeline([
            ('numeric', FunctionTransformer(columnsNumber)),
            ('scale', StandardScaler())
        ]))
    ], n_jobs=1)),
    ('estimator', RandomForestClassifier(n_estimators=50, criterion='entropy', n_jobs=-1))
])

cv.cross_val_score(pipeline, XoneColumn, y, cv=folds, scoring=kappaScore)

这导致:TypeError: 'list' object is not callable启用功能转换器时.

编辑:

如果我在ColumnExtractor下面实例化,则不会返回错误.但这不仅仅functionTransformer意味着像这样的简单案例,应该只是工作吗？

class ColumnExtractor(TransformerMixin):
    def __init__(self, columns):
        self.columns = columns

    def transform(self, X, *_):
        return X[self.columns]

    def fit(self, *_):
        return self

我最近一直在尝试堆叠语言模型，并注意到一些有趣的事情：BERT 和 XLNet 的输出嵌入与输入嵌入不同。例如，这个代码片段：

bert = transformers.BertForMaskedLM.from_pretrained("bert-base-cased")
tok = transformers.BertTokenizer.from_pretrained("bert-base-cased")

sent = torch.tensor(tok.encode("I went to the store the other day, it was very rewarding."))
enc = bert.get_input_embeddings()(sent)
dec = bert.get_output_embeddings()(enc)

print(tok.decode(dec.softmax(-1).argmax(-1)))

为我输出这个：

,,,,,,,,,,,,,,,,,

我本来期望返回（格式化的）输入序列，因为我的印象是输入和输出令牌嵌入是绑定的。

有趣的是，大多数其他模型没有表现出这种行为。例如，如果您在 GPT2、Albert 或 Roberta 上运行相同的代码片段，它将输出输入序列。

这是一个错误吗？或者是 BERT/XLNet 的预期？

背景：

遵循这个问题，当使用 bert 对序列进行分类时，模型使用表示分类任务的“[CLS]”标记。据该论文称：

每个序列的第一个标记始终是一个特殊的分类标记（[CLS]）。与该标记对应的最终隐藏状态用作分类任务的聚合序列表示。

查看 Huggingfaces 存储库，他们的 BertForSequenceClassification 使用 bert pooler 方法：

class BertPooler(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
        self.activation = nn.Tanh()

    def forward(self, hidden_states):
        # We "pool" the model by simply taking the hidden state corresponding
        # to the first token.
        first_token_tensor = hidden_states[:, 0]
        pooled_output = self.dense(first_token_tensor)
        pooled_output = self.activation(pooled_output)
        return pooled_output

我们可以看到他们采用第一个标记（CLS）并将其用作整个句子的表示。具体来说，他们执行的操作hidden_states[:, 0]看起来很像从每个状态中获取第一个元素，而不是获取第一个标记隐藏状态？

我的问题：

我不明白的是他们如何将整个句子的信息编码到这个标记中？CLS 标记是一个常规标记，它有自己的嵌入向量来“学习”句子级别表示吗？为什么我们不能只使用隐藏状态的平均值（编码器的输出）并用它来分类？

编辑：经过一番思考：因为我们使用 CLS 令牌隐藏状态来预测，所以 CLS 令牌嵌入是否正在接受分类任务的训练，因为这是用于分类的令牌（因此是导致错误的主要因素）哪个会传播到它的权重？）

https://colab.research.google.com/drive/11u6leEKvqE0CCbvDHHKmCxmW5GxyjlBm?usp=sharing

setup.py 文件位于 Transformers 文件夹（根目录）中。但是当我运行时出现这个错误

!git clone https://github.com/huggingface/transformers
!cd transformers
!pip install -e .
!pip install -r transformers/examples/pytorch/translation/requirements.txt

谁能告诉我为什么会发生这种情况？