Question

我们的团队正在研究NLP问题。我们有一个带有一些标记句子的数据集，我们必须将它们分为两个类，0或1。

我们预处理数据并使用词嵌入，以便每个句子具有 300个功能，然后使用简单的神经网络训练模型。

由于数据非常偏斜，因此我们使用F1分数来衡量模型得分，并同时在训练集（80％）和测试集（20％）上进行计算。

火花

我们使用了PySpark的MLlib中的multilayer perceptron classifier：

layers = [300, 600, 2]

trainer = MultilayerPerceptronClassifier(featuresCol='features', labelCol='target',
                                         predictionCol='prediction', maxIter=10, layers=layers,
                                         blockSize=128)
model = trainer.fit(train_df)
result = model.transform(test_df)

predictionAndLabels = result.select("prediction", "target").withColumnRenamed("target", "label")
evaluator = MulticlassClassificationEvaluator(metricName="f1")
f1_score = evaluator.evaluate(predictionAndLabels)

这样，我们得到的F1分数在0.91至0.93之间。

TensorFlow

然后我们选择（主要用于学习目的）切换到TensorFlow，因此我们使用与MLlib相同的架构和公式来实现神经网络：

# Network Parameters
n_input = 300
n_hidden_1 = 600
n_classes = 2

# TensorFlow graph input
features = tf.placeholder(tf.float32, shape=(None, n_input), name='inputs')
labels = tf.placeholder(tf.float32, shape=(None, n_classes), name='labels')

# Initializes weights and biases
init_biases_and_weights()

# Layers definition
layer_1 = tf.add(tf.matmul(features, weights['h1']), biases['b1'])
layer_1 = tf.nn.sigmoid(layer_1)

out_layer = tf.matmul(layer_1, weights['out']) + biases['out']
out_layer = tf.nn.softmax(out_layer)

# Optimizer definition
learning_rate_ph = tf.placeholder(tf.float32, shape=(), name='learning_rate')
loss_function = tf.losses.log_loss(labels=labels, predictions=out_layer)
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate_ph).minimize(loss_function)

# Start TensorFlow session
init = tf.global_variables_initializer()
tf_session = tf.InteractiveSession()
tf_session.run(init)

# Train Neural Network
learning_rate = 0.01
iterations = 100
batch_size = 256

total_batch = int(len(y_train) / batch_size)
for epoch in range(iterations):
    avg_cost = 0.0
    for block in range(total_batch):
        batch_x = x_train[block * batch_size:min(block * batch_size + batch_size, len(x_train)), :]
        batch_y = y_train[block * batch_size:min(block * batch_size + batch_size, len(y_train)), :]
        _, c = tf_session.run([optimizer, loss_function], feed_dict={learning_rate_ph: learning_rate,
                                                                     features: batch_x,
                                                                     labels: batch_y})
        avg_cost += c
    avg_cost /= total_batch
    print("Iteration " + str(epoch + 1) + " Logistic-loss=" + str(avg_cost))

# Make predictions
predictions_train = tf_session.run(out_layer, feed_dict={features: x_train, labels: y_train})
predictions_test = tf_session.run(out_layer, feed_dict={features: x_test, labels: y_test})

# Compute F1-score
f1_score = f1_score_tf(y_test, predictions_test)

支持功能：

def initialize_weights_and_biases():
    global weights, biases
    epsilon_1 = sqrt(6) / sqrt(n_input + n_hidden_1)
    epsilon_2 = sqrt(6) / sqrt(n_classes + n_hidden_1)
    weights = {
        'h1': tf.Variable(tf.random_uniform([n_input, n_hidden_1],
                                        minval=0 - epsilon_1, maxval=epsilon_1, dtype=tf.float32)),
        'out': tf.Variable(tf.random_uniform([n_hidden_1, n_classes],
                                         minval=0 - epsilon_2, maxval=epsilon_2, dtype=tf.float32))
    }
    biases = {
        'b1': tf.Variable(tf.constant(1, shape=[n_hidden_1], dtype=tf.float32)),
        'out': tf.Variable(tf.constant(1, shape=[n_classes], dtype=tf.float32))
    }

def f1_score_tf(actual, predicted):
    actual = np.argmax(actual, 1)
    predicted = np.argmax(predicted, 1)

    tp = tf.count_nonzero(predicted * actual)
    fp = tf.count_nonzero(predicted * (actual - 1))
    fn = tf.count_nonzero((predicted - 1) * actual)
    precision = tp / (tp + fp)
    recall = tp / (tp + fn)

    f1 = 2 * precision * recall / (precision + recall)
    return tf.Tensor.eval(f1)

这样，我们得到的F1分数在0.24和0.25之间。

问题

我能看到的两个神经网络之间的唯一区别是：

优化器：Spark中的L-BFGS，TensorFlow中的梯度下降
权衡并偏重初始化：当我们在TensorFlow中手动初始化时，Spark会进行自己的初始化

我认为这两个参数不会在模型之间造成如此大的性能差异，但是Spark似乎在很少的迭代中就获得了很高的分数。

我不明白TensorFlow的表现是否很差，或者Spark的分数并不真实。而且在两种情况下，我认为我们都没有看到重要的东西。

Answer 1

将权重初始化为统一且偏差为1肯定不是一个好主意，这很可能是造成这种差异的原因。

使用normal或truncated_normal代替，默认为零均值，权重为small variance：

weights = {
        'h1': tf.Variable(tf.truncated_normal([n_input, n_hidden_1],
                                        stddev=0.01, dtype=tf.float32)),
        'out': tf.Variable(tf.truncated_normal([n_hidden_1, n_classes],
                                         stddev=0.01, dtype=tf.float32))
    }

和零用于偏差：

biases = {
        'b1': tf.Variable(tf.constant(0, shape=[n_hidden_1], dtype=tf.float32)),
        'out': tf.Variable(tf.constant(0, shape=[n_classes], dtype=tf.float32))
    }

也就是说，对于二进制分类问题，我不确定使用MulticlassClassificationEvaluator的正确性，我建议进一步做一些手动检查，以确认该函数确实返回了您认为的返回值。

为什么Spark ML感知器分类器的F1分数很高，而TensorFlow上的相同模型却表现很差？

火花

TensorFlow

问题

1 个答案: