TensorFlow中的特定线性分类器：输入元素作为向量

Question

如何在 TensorFlow 中实现这样的线性分类器：

x1*w1 + x2*w2 + x3*w3 = y_pred,

其中 x1、x2、x3 - 向量和 w1、w2 和 w3 - 标量？

对于 x1、x2、x3 - 标量 (link) 的情况，我有很好的教程，

但是对于 x1、x2、x3 是向量的情况，我没有实现的想法。

更新

也就是说我正在尝试实现以下模型：

x1*w1+ x2*w1+x3*w1+x4*w2+x5*w2+x6*w2+x7*w3+x8*w3+x9*w3=y_pred, 
where x1..x9 and w1..w9 are scalars.

Answer 1

要实现的线性多类分类器：

pred = w1 * (x1 + x2 + x3) + w2 * (x4 + x5 + x6) + w3 * (x7 + x8 + x9)

其中所有变量都是标量。

在此模型中，由于pred 是一个标量，因此您不能使用交叉熵损失来训练分类器（pred 不是分布）。 您必须将其视为回归问题。

示例数据集

import numpy as np

x1 = np.ones((100, 3)) # for w1
x2 = np.ones((100, 3)) * 2 # for w2
x3 = np.ones((100, 3)) * 3 # for w3

# set(y) is {0, 1, 2, 3}, corresponds to the four class labels 
y = np.random.randint(0, 4, 100).reshape(-1, 1)

例如tensorflow代码：

import tensorflow as tf 

tf.reset_default_graph()

f1 = tf.placeholder('float32', shape=[None, 3], name='f1')
f2 = tf.placeholder('float32', shape=[None, 3], name='f2')
f3 = tf.placeholder('float32', shape=[None, 3], name='f3')

target = tf.placeholder('float32', shape=[None, 1], name='target')

# the three scalars
w1 = tf.get_variable('w1', shape=[1], initializer=tf.random_normal_initializer())
w2 = tf.get_variable('w2', shape=[1], initializer=tf.random_normal_initializer())
w3 = tf.get_variable('w3', shape=[1], initializer=tf.random_normal_initializer())

pred_1 = tf.reduce_sum(tf.multiply(f1, w1), axis=1)
pred_2 = tf.reduce_sum(tf.multiply(f2, w2), axis=1)
pred_3 = tf.reduce_sum(tf.multiply(f3, w3), axis=1)

# till now the linear classifier has been constructed 
# pred = w1(x1 + x2 + x3) + w2(x4 + x5 + x6) + w3(x7 + x8 + x9)
pred = tf.add_n([pred_1, pred_2, pred_3])

# treat it as a regression problem
loss = tf.reduce_mean(tf.square(pred - target))

optimizer = tf.train.GradientDescentOptimizer(1e-5)
updates = optimizer.minimize(loss)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for t in range(50):
        loss_val, _ = sess.run([loss, updates], 
                               feed_dict={f1: x1, f2: x2, f3: x3, target: y})
        print(t, loss_val)

下面是一个使用交叉熵损失来训练多类分类器的简单示例。如你所见，这个模型是一个神经网络模型

import numpy as np
import tensorflow as tf 

x1 = np.ones((100, 3)) # for w1
x2 = np.ones((100, 3)) * 2 # for w2
x3 = np.ones((100, 3)) * 3 # for w3

y = np.random.randint(0, 4, 400).reshape(100, 4)

tf.reset_default_graph()

f1 = tf.placeholder('float32', shape=[None, 3], name='f1')
f2 = tf.placeholder('float32', shape=[None, 3], name='f2')
f3 = tf.placeholder('float32', shape=[None, 3], name='f3')

target = tf.placeholder('float32', shape=[None, 4], name='target')

# the three scalars
w1 = tf.get_variable('w1', shape=[1], initializer=tf.random_normal_initializer())
w2 = tf.get_variable('w2', shape=[1], initializer=tf.random_normal_initializer())
w3 = tf.get_variable('w3', shape=[1], initializer=tf.random_normal_initializer())

w = tf.get_variable('w', shape=[3, 4], initializer=tf.random_normal_initializer())

pred_1 = tf.reduce_sum(tf.multiply(f1, w1), axis=1)
pred_2 = tf.reduce_sum(tf.multiply(f2, w2), axis=1)
pred_3 = tf.reduce_sum(tf.multiply(f3, w3), axis=1)

pred = tf.stack([pred_1, pred_2, pred_3], axis=1)
pred = tf.matmul(pred, w)
loss = tf.losses.softmax_cross_entropy(onehot_labels=target, logits=pred)

optimizer = tf.train.GradientDescentOptimizer(1e-5)
updates = optimizer.minimize(loss)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for t in range(50):
        loss_val, _ = sess.run([loss, updates], 
                               feed_dict={f1: x1, f2: x2, f3: x3, target: y})
        print(t, loss_val)

Answer 2

我使用创建了一个看起来像 [w1, w1, w1, w2, w2, w2 ...] 的数组，并在将所有项相加之前将它（按元素）乘以 x。我无法让 model.fit 工作，所以我从 https://www.tensorflow.org/tutorials/quickstart/advanced 复制了 train_step 代码。它似乎工作得很好。我把我的测试代码留在了底部供你检查。

这利用了 tensorlfow 2.0 以及与 keras 模型的集成

import numpy as np 
import tensorflow as tf

from tensorflow.keras import Model
from tensorflow.keras.losses import MeanSquaredError
from tensorflow.keras.optimizers import Adam

print(tf.executing_eagerly())

class ProductAdd(Model):
    def __init__(self):
        super(ProductAdd, self).__init__()
        self.vars = list(np.empty([3])) # Creates an empty list (same as [ , , ])
        for i in range(3):
            self.vars[i] = tf.Variable(      # Creates 3 variables to act as weights 
                np.random.standard_normal(), # Assigns variables random value to start
                 name='var'+str(i))          # Names them var0 var1...

    def call(self, x):
        extended_vars = [self.vars[int(np.floor(i/3))] # "Extends" var array to look like:
                          for i in range(9)]           # [w1, w1, w1, w2, w2, w2, w3, w3, w3]
        return np.sum(np.multiply(x, extended_vars))   # Perfoms element-wise multiplication on x and sums

loss_object = MeanSquaredError()    # Create loss and optimizer
optimizer = Adam()

@tf.function                                        # This function perfoms trains the model
def train_step(images, labels):                     # I got it from https://www.tensorflow.org/tutorials/quickstart/advanced
  with tf.GradientTape() as tape:                   
    predictions = model(images)                     
    loss = loss_object(labels, predictions)
  gradients = tape.gradient(loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))

model = ProductAdd()

for _ in range(100):
    train_step([1.0, 2.0 ,3.0 ,4.0, 5.0, 6.0, 7.0, 8.0, 9.0], [0.0])

print(model([1.0, 2.0 ,3.0 ,4.0, 5.0, 6.0, 7.0, 8.0, 9.0]).numpy())

Answer 3

这个问题不恰当。您说您希望 x_1、x_2、x_3 成为向量，但是尚不清楚您将如何处理 w_1、w_2、w_3。有两种可能。

• 如果您想将它们保留为标量，正如您的问题似乎暗示的那样，那么该模型并不是真正的矢量模型，您只是对所有条目进行相同的标量操作x 向量，但一次。这相当于一个标量模型。

• 否则，如果标签是标量，您可以将 w_1、w_2、w_3 定义为矩阵或行向量。在这种情况下，没有理由像你写的那样写方程，因为你可以将 xs 堆叠在一个向量中，将 ws 堆叠在一个向量中并写为 wx = y。无论如何，这是一个多元线性回归，您可以在其中找到许多示例，以及如何在 Tensorflow 和 Torch 中解决它的教程。

更新，鉴于 OP 的澄清

在您的评论中，您现在说您有兴趣解决以下等式：

w1*(x1 + x2 + x3) + w2*(x4 + x5 + x6) + w3*(x7 + x8 + x9) == y

所有变量都是标量。注意 x 变量是已知的，所以我们可以定义（一个简单的算术运算）：

z1 = x1 + x2 + x3; z2 = x4 + x5 + x6; z3 = x7 + x8 + x9

等式变成了

w1*z1 + w2*z2 + w3*z3 = y.

所以这更像是一个线性代数问题而不是张量流/火炬问题，因为这个方程可以解析求解，不需要数值拟合。然而，它仍然是不明确的，因为它对于一个线性方程有 3 个未知数（w1、w2、w3）。所以它不会有唯一的解决方案，而是一个二维线性空间的解决方案（它标识了 3 维 w 空间中的一个平面）。要得到一些解，你可以任意决定设置，例如w1 = w2 = 0，从中你会自动得到w3 = z3/y。然后对另外两个做同样的事情，你会得到三个不同的线性独立的解决方案。

希望这会有所帮助。总之，你根本不需要代码。

第二次更新（来自评论）

为什么需要使用优化来解决？如果问题是您提出的问题，那么显然不是。除非你的意思是你有很多 Xs 和 Ys 的值。在这种情况下，您正在执行多元线性回归。 MLR 可以使用普通最小二乘法求解，例如https://towardsdatascience.com/simple-and-multiple-linear-regression-in-python-c928425168f9