小编use*_*402的帖子

我试图重现本文的结果:https://arxiv.org/pdf/1607.06520.pdf

特别是这部分:

为了识别性别子空间,我们采用了十个性别对差异向量并计算了其主要成分(PC).如图6所示,有一个方向可以解释这些向量中的大部分方差.第一个特征值明显大于其余特征值.

我使用与作者相同的单词向量集(Google News Corpus,300维度),我将其加载到word2vec中.

作者引用的"十个性别对差异向量"是根据以下单词对计算得出的:

我用以下方式计算了每个规范化向量之间的差异:

model = gensim.models.KeyedVectors.load_word2vec_format('GoogleNews-vectors-
negative300.bin', binary = True)
model.init_sims()

pairs = [('she', 'he'),
('her', 'his'),
('woman', 'man'),
('Mary', 'John'),
('herself', 'himself'),
('daughter', 'son'),
('mother', 'father'),
('gal', 'guy'),
('girl', 'boy'),
('female', 'male')]

difference_matrix = np.array([model.word_vec(a[0], use_norm=True) - model.word_vec(a[1], use_norm=True) for a in pairs])

然后我根据论文在得到的矩阵上执行PCA,包含10个组件:

from sklearn.decomposition import PCA
pca = PCA(n_components=10)
pca.fit(difference_matrix)

但是当我看到时,我得到了非常不同的结果pca.explained_variance_ratio_:

array([  2.83391436e-01,   2.48616155e-01,   1.90642492e-01,
         9.98411858e-02,   5.61260498e-02,   5.29706681e-02,
         2.75670634e-02,   2.21957722e-02,   1.86491774e-02,
         1.99108478e-32])

或用图表:

当应该超过60%时,第一个组件占差异的不到30%!

我得到的结果类似于当我尝试在随机选择的向量上进行PCA时得到的结果,所以我一定做错了,但我无法弄清楚是什么.

注意:我试过没有规范化向量,但我得到了相同的结果.

我正在处理不平衡类的顺序标签问题，我想用它sample_weight来解决不平衡问题。基本上，如果我训练模型约10个时期，我会得到很好的结果。如果我训练更多的纪元，val_loss会不断下降，但结果会更糟。我猜测该模型只会检测到更多的主导类，从而损害较小的类。

该模型有两个输入，分别用于单词嵌入和字符嵌入，并且输入是从0到6的7种可能的类之一。

使用填充，我的词嵌入输入层的形状为，而词嵌入的输入层的形状(3000, 150)为(3000, 150, 15)。我将0.3拆分用于测试和训练数据，这意味着X_train用于单词嵌入(2000, 150)和(2000, 150, 15)用于char嵌入。y包含每个单词的正确类，并以7维的单热点向量编码，因此其形状为(3000, 150, 7)。y同样分为训练和测试集。然后将每个输入馈入双向LSTM。

输出是一个矩阵，为2000个训练样本的每个单词分配了7个类别之一，因此大小为(2000, 150, 7)。

首先，我只是尝试将长度定义sample_weight为np.array7，其中包含每个类的权重：

count = [list(array).index(1) for arrays in y for array in arrays]
count = dict(Counter(count))
count[0] = 0
total = sum([count[key] for key in count])
count = {k: count[key] / total for key in count}
category_weights = np.zeros(7)
for f …

我想在struct将 JSON 对象解组到 a 后迭代 a 的字段，并检查其值未设置的字段（即为空）。

我可以获取每个字段的值并将其与reflect.Zero相应类型的值进行比较

json.Unmarshal([]byte(str), &res)
s := reflect.ValueOf(&res).Elem()
typeOfT := s.Type()
for i := 0; i < s.NumField(); i++ {
    f := s.Field(i)
    v := reflect.ValueOf(f.Interface())
    if (reflect.DeepEqual(v.Interface(), reflect.Zero(v.Type()).Interface())) {
    ....

但问题当然是这对于bool或int值来说效果不佳。如果JSON 中的bool字段设置为或字段设置为，则它们将等于其类型的零值。上述检查将认为这些字段未初始化，即使它们实际上设置了值。falseint0

我知道解决这个问题的一种方法是使用指针，但我只是不知道在这种情况下这是如何可能的，因为我正在使用reflect.Value类型，而不是实际的struct.

我正在尝试在 Keras中实现本文中描述的字符级嵌入类型。字符嵌入是使用双向 LSTM 计算的。

为了重新创建这个，我首先创建了一个矩阵，其中包含每个单词的组成单词的字符的索引：

char2ind = {char: index for index, char in enumerate(chars)}
max_word_len = max([len(word) for sentence in sentences for word in sentence])
X_char = []
for sentence in X:
    for word in sentence:
        word_chars = []
        for character in word:
            word_chars.append(char2ind[character])

        X_char.append(word_chars)
X_char = sequence.pad_sequences(X_char, maxlen = max_word_len)

然后我定义了一个 BiLSTM 模型，其中包含一个词-字符矩阵的嵌入层。我假设 input_dimension 必须等于字符数。我希望字符嵌入的大小为 64，因此我将 BiLSTM 的隐藏大小设置为 32：

char_lstm = Sequential()
char_lstm.add(Embedding(len(char2ind) + 1, 64))    
char_lstm.add(Bidirectional(LSTM(hidden_size, return_sequences=True)))

这就是我感到困惑的地方。如何从模型中检索嵌入？我猜我必须编译模型并拟合它然后检索权重以获得嵌入，但是我应该使用什么参数来拟合它？

额外细节：

这是针对 NER 任务的，因此数据集在技术上可以是 word-label 格式的任何内容，尽管我专门使用此处提供的 WikiGold ConLL …

我有一个简单的问题.我有一些文本文件,其中的单词已在行尾分割(连字符号).像这样的东西:

toward an emotionless evalu-
ation of objectively gained

我想摆脱连字并再次加入这些词.这可以使用该replace()功能简单快速地完成.但是在某些情况下,连字符后面会有一些额外的换行符.像这样:

end up as a first rate con-


tribution, but that was not

replace()我只是切换到正则表达式而不是堆积几次调用,而是使用re.sub('\-\n+', '', text):

def replace_hyphens(text):
    return re.sub('\-\n+', '', text)

这很有效,但我想知道如何用直接在Python中编码的函数实现相同的结果.这就是我想出的:

def join_hyphens(text):
    processed = ''
    i = 0
    while i < len(text):
        if text[i] == '-':
            while text[i+1] == '\n':
                i += 1
            i += 1
        processed += text[i]
        i += 1
    return processed

但是,与正则表达式相比,当然表现糟糕.如果我在相当长的字符串上超过100次迭代计时,结果就是这里.

join_hyphens done in 2.398ms
replace_hyphens done in 0.021ms …

我有一个简单的结构：

type MyWriter struct {
    io.Writer
}

然后按以下方式使用：

writer = MyWriter{io.Stdout}

运行时，go vet这给了我一个composite literal uses unkeyed fields。

为了解决这个问题，我必须MyWriter通过添加密钥将io.Reader转换为结构中的字段？

type MyWriter struct {
    w io.Writer
}

还有其他解决方法吗？我在这里找到的唯一其他答案建议完全禁用该检查，但我宁愿不这样做并找到合适的解决方案。