TensorFlow中怎么实现一个多元线性回归分类器

本篇文章为大家展示了TensorFlow中怎么实现一个多元线性回归分类器，内容简明扼要并且容易理解，绝对能使你眼前一亮，通过这篇文章的详细介绍希望你能有所收获。

创新互联建站-专业网站定制、快速模板网站建设、高性价比芗城网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式芗城网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖芗城地区。费用合理售后完善，10年实体公司更值得信赖。

# 导入需要的模块

# - * - coding: utf-8 - * -
import tensorflow as tf
import numpy as np
import pandas as pd
from sklearn import datasets
import os

# 这个函数是为了利用sklearn获取iris数据，然后保存到本地后面用。

def make_iris():
   iris = datasets.load_iris()
   x = pd.DataFrame(iris.data)
   y = pd.DataFrame(iris.target).values
   y_onehot = tf.one_hot(y, 3)
   sess = tf.InteractiveSession()
   y_onehot_value = sess.run(y_onehot).reshape((150, 3))
   y_onehot_value = pd.DataFrame(y_onehot_value)
   x.to_csv("iris_x.csv", sep=',', header=None, index=None)
   y_onehot_value.to_csv("iris_y.csv", sep=',', header=None, index=None)
   

# 定义模型，这里要分清楚，in_size,out_size分别代表什么的大小，比如对于iris数据集，有4个自变量，1个因变量，但是我们把label经过one_hot编码之后，label就变成了3维。所以这里In_size就是训练数据的维度，也就是变量的个数。而out_size是输出的维度，就是因变量的维度，所以是3.

一般对于多元线性回归模型，可以写成矩阵的形式就是，Y=WX+b，这里W是4x3的，x是150x4的，b是150x3的，所以Y的维度就是（150x4）x（4x3）+（150x3）=150x3（属于某个类别的概率），模型最后输出是softmax多分类函数，所以最后每个样本都会有一个属于不同类别的概率值。

def model(inputs, in_size, out_size):
   Weights = tf.Variable(tf.random_normal([in_size, out_size]))
   biases = tf.Variable(tf.zeros([1, out_size]))
   outputs = tf.nn.softmax(tf.matmul(inputs, Weights) + biases)
   return outputs
   
 

# 定义模型训练函数
def train():
   # 首先是读取数据，用上面那个函数保存的数据，
   # 把训练数据读进来，因为pandas读取的是
   # DataFrame对象，通过values属性转换为numpy.ndarry类型。
   x_data = pd.read_csv("iris_x.csv", header=None).values
   y_data = pd.read_csv("iris_y.csv", header=None).values
   # 接下来是把数据分为训练集和测试集。
   train_x = x_data[0:120, :]
   train_y = y_data[0:120, :]

   test_x = x_data[120:151, :]
   test_y = y_data[120:151, :]

   print train_x.shape
   print test_x.shape
   print train_y.shape
   print test_y.shape
   #定义placeholder，这也可以不定义，后面就不
   # 用显示的feed了，直接run优化目标就行。这
   # 里还是要注意holder的维度代表的含义，别稀里糊涂的。
   x_data_holder = tf.placeholder(tf.float32, [None, 4])
   y_data_holder = tf.placeholder(tf.float32, [None, 3])
   # 调用模型，输出预测结果
   y_prediction = model(x_data_holder, 4, 3)
   #定义交叉熵损失函数
   cross_entropy = tf.reduce_mean(
       -tf.reduce_sum(y_data_holder *
                      tf.log(y_prediction), reduction_indices=[1]))
   # 用梯度下降法求解，使得损失函数最小。
   train_step = tf.train.GradientDescentOptimizer(0.1)\
       .minimize(cross_entropy)
   # 启动session。
   with tf.Session() as sess:
       init = tf.global_variables_initializer()
       sess.run(init)
       epoch = 2000
       for e in range(epoch):
           sess.run(train_step,
                    feed_dict={x_data_holder: train_x,
                           y_data_holder: train_y})
           # 每隔50次，计算一下损失，注意这里的损失是训
           # 练数据的损失，而且这个损失是单步的损失，
           # 不是全部数据的损失。
           if e % 50 == 0:
               train_loss = sess.run(cross_entropy,
                       feed_dict={x_data_holder: train_x,
                              y_data_holder: train_y})

               y_pre = sess.run(y_prediction,
                   feed_dict={x_data_holder: test_x})
               correct_prediction = tf.equal(tf.argmax(y_pre, 1),
                          tf.argmax(test_y, 1))
           # eval函数可以将tensor类型转换为具体的值，也可以不运行。
               # print correct_prediction.eval(session=sess)
               accuracy = tf.reduce_mean(tf.cast(correct_prediction,
                                     tf.float32))
           # 最后用测试数据，计算一下测试数据的预测精度。
               test_acc = sess.run(accuracy,
                        feed_dict={x_data_holder: test_x,
                            y_data_holder: test_y})
               print "acc: {}; loss: {}".format(test_acc, train_loss)
     # 要计算全部数据的损失，需要在最后再run一下损失。
       training_cost = sess.run(cross_entropy,
                   feed_dict={x_data_holder: train_x,
                             y_data_holder: train_y})
       print "Training cost={}".format(training_cost)

if __name__ == "__main__":
   train()

上述内容就是TensorFlow中怎么实现一个多元线性回归分类器，你们学到知识或技能了吗？如果还想学到更多技能或者丰富自己的知识储备，欢迎关注创新互联行业资讯频道。