tensorflow - 多目标和多类预测

Question

我对机器学习和 TensorFlow 都比较陌生。我想训练数据，以便可以对 2 个目标和多个类进行预测。这是可以做到的吗？我能够为 1 个目标实现该算法，但不知道我还需要如何为第二个目标实现该算法。

示例数据集: DayOfYear 温度流量可见性

316 8   1   4
285 -1  1   4
326 8   2   5
323 -1  0   3
10  7   3   6
62  8   0   3
56  8   1   4
347 7   2   5
363 7   0   3
77  7   3   6
1   7   1   4
308 -1  2   5
364 7   3   6

如果我训练(DayOfYear Temperature Flow)，我可以很好地预测能见度。但我也需要以某种方式预测 Flow。我很确定 Flow 会影响 Visibility，所以我不确定如何处理它。

这是我的实现

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import os
import urllib

import numpy as np
import tensorflow as tf

# Data sets
TRAINING = "/ml_baetterich_learn.csv"
TEST = "/ml_baetterich_test.csv"
VALIDATION = "/ml_baetterich_validation.csv"

def main():

  # Load datasets.
  training_set = tf.contrib.learn.datasets.base.load_csv_without_header(
      filename=TRAINING,
      target_dtype=np.int,
      features_dtype=np.int,
      target_column=-1)
  test_set = tf.contrib.learn.datasets.base.load_csv_without_header(
      filename=TEST,
      target_dtype=np.int,
      features_dtype=np.int,
      target_column=-1)
  validation_set = tf.contrib.learn.datasets.base.load_csv_without_header(
      filename=VALIDATION,
      target_dtype=np.int,
      features_dtype=np.int,
      target_column=-1)

  # Specify that all features have real-value data
  feature_columns = [tf.contrib.layers.real_valued_column("", dimension=3)]

  # Build 3 layer DNN with 10, 20, 10 units respectively.
  classifier = tf.contrib.learn.DNNClassifier(feature_columns=feature_columns,
                                              hidden_units=[10, 20, 10],
                                              n_classes=9,
                                              model_dir="/tmp/iris_model")
  # Define the training inputs
  def get_train_inputs():
    x = tf.constant(training_set.data)
    y = tf.constant(training_set.target)

    return x, y

  # Fit model.
  classifier.fit(input_fn=get_train_inputs, steps=4000)

  # Define the test inputs
  def get_test_inputs():
    x = tf.constant(test_set.data)
    y = tf.constant(test_set.target)

    return x, y

  # Define the test inputs
  def get_validation_inputs():
    x = tf.constant(validation_set.data)
    y = tf.constant(validation_set.target)

    return x, y

  # Evaluate accuracy.
  accuracy_test_score = classifier.evaluate(input_fn=get_test_inputs,
                                       steps=1)["accuracy"]

  accuracy_validation_score = classifier.evaluate(input_fn=get_validation_inputs,
                                       steps=1)["accuracy"]

  print ("\nValidation Accuracy: {0:0.2f}\nTest Accuracy: {1:0.2f}\n".format(accuracy_validation_score,accuracy_test_score))

  # Classify two new flower samples.
  def new_samples():
    return np.array(
      [[327,8,3],
       [47,8,0]], dtype=np.float32)

  predictions = list(classifier.predict_classes(input_fn=new_samples))

  print(
      "New Samples, Class Predictions:    {}\n"
      .format(predictions))

if __name__ == "__main__":
    main()

Answer 1

选项 1:多头模型

您可以使用多头 DNNEstimator 模型。这将 Flow 和 Visibility 视为两个独立的 softmax 分类目标，每个都有自己的一组类。我不得不修改 load_csv_without_header 辅助函数以支持多个目标(这可能更清晰，但这不是重点 - 请随意忽略其细节)。

import numpy as np
import tensorflow as tf
from tensorflow.python.platform import gfile
import csv
import collections

num_flow_classes = 4
num_visib_classes = 7

Dataset = collections.namedtuple('Dataset', ['data', 'target'])

def load_csv_without_header(fn, target_dtype, features_dtype, target_columns):
    with gfile.Open(fn) as csv_file:
        data_file = csv.reader(csv_file)
        data = []
        targets = {
            target_cols: []
            for target_cols in target_columns.keys()
        }
        for row in data_file:
            cols = sorted(target_columns.items(), key=lambda tup: tup[1], reverse=True)
            for target_col_name, target_col_i in cols:
                targets[target_col_name].append(row.pop(target_col_i))
            data.append(np.asarray(row, dtype=features_dtype))

        targets = {
            target_col_name: np.array(val, dtype=target_dtype)
            for target_col_name, val in targets.items()
        }
        data = np.array(data)
        return Dataset(data=data, target=targets)

feature_columns = [
    tf.contrib.layers.real_valued_column("", dimension=1),
    tf.contrib.layers.real_valued_column("", dimension=2),
]
head = tf.contrib.learn.multi_head([
    tf.contrib.learn.multi_class_head(
        num_flow_classes, label_name="Flow", head_name="Flow"),
    tf.contrib.learn.multi_class_head(
        num_visib_classes, label_name="Visibility", head_name="Visibility"),
])
classifier = tf.contrib.learn.DNNEstimator(
    feature_columns=feature_columns,
    hidden_units=[10, 20, 10],
    model_dir="iris_model",
    head=head,
)

def get_input_fn(filename):
    def input_fn():
        dataset = load_csv_without_header(
            fn=filename,
            target_dtype=np.int,
            features_dtype=np.int,
            target_columns={"Flow": 2, "Visibility": 3}
        )
        x = tf.constant(dataset.data)
        y = {k: tf.constant(v) for k, v in dataset.target.items()}
        return x, y
    return input_fn

classifier.fit(input_fn=get_input_fn("tmp_train.csv"), steps=4000)
res = classifier.evaluate(input_fn=get_input_fn("tmp_test.csv"), steps=1)

print("Validation:", res)

选项2:多标签头

如果您将 CSV 数据用逗号分隔，并保留一行可能包含的所有类的最后一列(用空格等标记分隔)，您可以使用以下代码:

import numpy as np
import tensorflow as tf

all_classes = ["0", "1", "2", "3", "4", "5", "6"]

def k_hot(classes_col, all_classes, delimiter=' '):
    table = tf.contrib.lookup.index_table_from_tensor(
        mapping=tf.constant(all_classes)
    )
    classes = tf.string_split(classes_col, delimiter)
    ids = table.lookup(classes)
    num_items = tf.cast(tf.shape(ids)[0], tf.int64)
    num_entries = tf.shape(ids.indices)[0]

    y = tf.SparseTensor(
        indices=tf.stack([ids.indices[:, 0], ids.values], axis=1),
        values=tf.ones(shape=(num_entries,), dtype=tf.int32),
        dense_shape=(num_items, len(all_classes)),
    )
    y = tf.sparse_tensor_to_dense(y, validate_indices=False)
    return y

def feature_engineering_fn(features, labels):
    labels = k_hot(labels, all_classes)
    return features, labels

feature_columns = [
    tf.contrib.layers.real_valued_column("", dimension=1), # DayOfYear
    tf.contrib.layers.real_valued_column("", dimension=2), # Temperature
]
classifier = tf.contrib.learn.DNNEstimator(
    feature_columns=feature_columns,
    hidden_units=[10, 20, 10],
    model_dir="iris_model",
    head=tf.contrib.learn.multi_label_head(n_classes=len(all_classes)),
    feature_engineering_fn=feature_engineering_fn,
)

def get_input_fn(filename):
    def input_fn():
        dataset = tf.contrib.learn.datasets.base.load_csv_without_header(
            filename=filename,
            target_dtype="S100", # strings of length up to 100 characters
            features_dtype=np.int,
            target_column=-1
        )
        x = tf.constant(dataset.data)
        y = tf.constant(dataset.target)
        return x, y
    return input_fn

classifier.fit(input_fn=get_input_fn("tmp_train.csv"), steps=4000)
res = classifier.evaluate(input_fn=get_input_fn("tmp_test.csv"), steps=1)

print("Validation:", res)

我们将 DNNEstimator 与 multi_label_head 一起使用，它使用 sigmoid 交叉熵而不是 softmax 交叉熵作为损失函数。这意味着每个输出单位/logits 都通过 sigmoid 函数传递，它给出了数据点属于该类的可能性，即这些类是独立计算的，并不像 softmax 交叉熵那样相互排斥。这意味着您可以为训练集中的每一行和最终预测设置 0 到 len(all_classes) 类。

另请注意，类表示为字符串(k_hot 转换为标记索引)，因此您可以在电子商务设置中使用任意类标识符，例如类别 UUID。如果第 3 列和第 4 列中的类别不同(Flow ID 1 != Visibility ID 1)，您可以将列名称添加到每个类 ID 之前，例如

316,8,flow1 visibility4
285,-1,flow1 可见度4
326,8,flow2 能见度5


有关k_hot 工作原理的描述，请参阅my other SO answer .我决定使用 k_hot 作为一个单独的函数(而不是直接在 feature_engineering_fn 中定义它，因为它是一个独特的功能，并且 TensorFlow 可能很快就会有一个类似的实用函数。

请注意，如果您现在使用前两列来预测最后两列，您的准确性肯定会下降，因为最后两列高度相关并且使用其中一列会为您提供很多关于另一个。实际上，您的代码仅使用了第 3 列，如果目标是预测第 3 列和第 4 列，这无论如何都是一种欺骗。