使用Tensorflow构造LogisticRegression

本文详细介绍如何使用TensorFlow框架构建Logistic Regression模型,并通过MNIST数据集进行训练和测试,实现手写数字识别,展示了从数据加载到模型训练、评估的完整过程。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

使用Tensorflow构造LogisticRegression

import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data

#加载mnist数据集,one_hot=True为0,1格式
mnist      = input_data.read_data_sets('f:/data/', one_hot=True)
trainimg   = mnist.train.images
trainlabel = mnist.train.labels
testimg    = mnist.test.images
testlabel  = mnist.test.labels
print ("MNIST loaded")

print(trainimg.shape)  # 训练图片集的大小,一共有55000张图片,大小为28*28
print(trainlabel.shape)  # 训练标签集的大小,一共有0-9这10中结果
print(testimg.shape)  # 测试图片的大小
print(testlabel.shape)  # 测试标签的大小
# print (trainimg)
print(trainlabel[0]) #第一个标签代表的数据为7

输出结果为
在这里插入图片描述

#使用placeholder可以预先设计出参数的大小,而不去考虑其具体的数值
x = tf.placeholder("float", [None, 784]) #在tf中,None代表无穷
y = tf.placeholder("float", [None, 10]) #x表示图片数据集,y表示结果集
W = tf.Variable(tf.zeros([784, 10])) #W、b为回归参数
b = tf.Variable(tf.zeros([10]))
#逻辑回归模型
actv = tf.nn.softmax(tf.matmul(x, W) + b)
# 损失函数
cost = tf.reduce_mean(-tf.reduce_sum(y*tf.log(actv), reduction_indices=1))
# 梯度下降求解最优模型
learning_rate = 0.01
optm = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

# 判断预测值和真实值是否相同
pred = tf.equal(tf.argmax(actv, 1), tf.argmax(y, 1))
# 计算精度,回归建模完成
accr = tf.reduce_mean(tf.cast(pred, "float"))
# 初始化tf
init = tf.global_variables_initializer()

# argmax的用法
arr = np.array([[31, 23, 4, 24, 27, 34],
                [18, 3, 25, 0, 6, 35],
                [28, 14, 33, 22, 20, 8],
                [13, 30, 21, 19, 7, 9],
                [16, 1, 26, 32, 2, 29],
                [17, 12, 5, 11, 10, 15]])
tf.rank(arr).eval()  # 矩阵维数
tf.shape(arr).eval()  #矩阵形状
tf.argmax(arr, 0).eval() #矩阵每列的最大值索引
# 0 -> 31 (arr[0, 0])
# 3 -> 30 (arr[3, 1])
# 2 -> 33 (arr[2, 2])
tf.argmax(arr, 1).eval() #矩阵每行的最大值索引
# 5 -> 34 (arr[0, 5])
# 5 -> 35 (arr[1, 5])
# 2 -> 33 (arr[2, 2])

#模型测试
training_epochs = 50  # 迭代50次
batch_size = 100  # 批处理大小为100
display_step = 5  # 每迭代5次进行一次展示
# 初始化Session
sess = tf.Session()
sess.run(init)
# 批处理学习
for epoch in range(training_epochs):
    avg_cost = 0.  # 初始损失值为0
    num_batch = int(mnist.train.num_examples / batch_size)  # 批次数
    for i in range(num_batch):
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)  # 生成批处理X,Y数据集
        sess.run(optm, feed_dict={x: batch_xs, y: batch_ys})  # 计算损失值
        feeds = {x: batch_xs, y: batch_ys}  # 存放在批处理字典里
        avg_cost += sess.run(cost, feed_dict=feeds) / num_batch  # 每一批的损失值累加
    # DISPLAY
    if epoch % display_step == 0:
        feeds_train = {x: batch_xs, y: batch_ys}
        feeds_test = {x: mnist.test.images, y: mnist.test.labels}
        train_acc = sess.run(accr, feed_dict=feeds_train) #训练集精度
        test_acc = sess.run(accr, feed_dict=feeds_test) #测试集精度
        print("Epoch: %03d/%03d cost: %.9f train_acc: %.3f test_acc: %.3f"
              % (epoch, training_epochs, avg_cost, train_acc, test_acc))
print("DONE")

经过50次迭代后,损失函数,训练集精度,测试集精度如下
在这里插入图片描述

好的,那我可以为您提供一些使用Python、Tensorflow、sklearn、numpy、pytorch和matplotlib等工具库进行机器学习项目开发时所需的算法实现示例和建议。 1. 最小二乘法:最小二乘法是一种常见的线性回归算法,可以用来拟合数据集并预测新的数据点。在Python中,可以使用NumPy库实现最小二乘法。例如: ```python import numpy as np # 构造数据集 x = np.arange(0, 10, 0.1) y = 2 * x + 1 + np.random.randn(len(x)) # 最小二乘法拟合 A = np.vstack([x, np.ones(len(x))]).T w = np.linalg.lstsq(A, y, rcond=None)[0] # 输出拟合结果 print('斜率:', w[0]) print('截距:', w[1]) ``` 2. 梯度下降法:梯度下降法是一种常见的优化算法,可以用于训练神经网络等模型的参数。在Python中,可以使用TensorFlow库实现梯度下降法。例如: ```python import tensorflow as tf import numpy as np # 构造数据集 x = np.random.randn(100) y = 3 * x + 2 + np.random.randn(100) * 0.5 # 定义模型参数 w = tf.Variable(0.0) b = tf.Variable(0.0) # 定义损失函数和优化器 loss = tf.reduce_mean(tf.square(y - w * x - b)) optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(loss) # 训练模型 with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for i in range(100): sess.run(optimizer) if i % 10 == 0: print('第 %d 次训练,损失值为:%.4f,斜率为:%.4f,截距为:%.4f' % (i, sess.run(loss), sess.run(w), sess.run(b))) ``` 3. 分类:分类是机器学习中的一个重要任务,可以用于识别图像、语音等数据。在Python中,可以使用Scikit-learn库实现分类算法。例如: ```python from sklearn.datasets import load_iris from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression from sklearn.metrics import accuracy_score # 加载数据集 iris = load_iris() # 划分训练集和测试集 X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=0) # 定义模型并训练 clf = LogisticRegression() clf.fit(X_train, y_train) # 预测并评估模型 y_pred = clf.predict(X_test) print('准确率为:%.4f' % accuracy_score(y_test, y_pred)) ``` 4. 聚类:聚类是一种无监督学习算法,可以将数据集中的样本分为若干个类别。在Python中,可以使用Scikit-learn库实现聚类算法。例如: ```python from sklearn.datasets import make_blobs from sklearn.cluster import KMeans import matplotlib.pyplot as plt # 生成数据集 X, y = make_blobs(n_samples=100, centers=3, random_state=0) # 定义模型并训练 clf = KMeans(n_clusters=3) clf.fit(X) # 可视化结果 plt.scatter(X[:, 0], X[:, 1], c=clf.labels_) plt.scatter(clf.cluster_centers_[:, 0], clf.cluster_centers_[:, 1], marker='x', color='r') plt.show() ``` 5. 支持向量机:支持向量机是一种常见的分类算法,可以用于处理线性和非线性分类问题。在Python中,可以使用Scikit-learn库实现支持向量机算法。例如: ```python from sklearn.datasets import make_classification from sklearn.svm import SVC from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score # 生成样本数据 X, y = make_classification(n_samples=100, n_features=2, n_informative=2, n_redundant=0, random_state=0) # 划分训练集和测试集 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0) # 定义模型并训练 clf = SVC(kernel='rbf') clf.fit(X_train, y_train) # 预测并评估模型 y_pred = clf.predict(X_test) print('准确率为:%.4f' % accuracy_score(y_test, y_pred)) ``` 6. 决策树:决策树是一种常见的分类和回归算法,可以用于处理离散型和连续型的数据。在Python中,可以使用Scikit-learn库实现决策树算法。例如: ```python from sklearn.datasets import load_iris from sklearn.tree import DecisionTreeClassifier from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score # 加载数据集 iris = load_iris() # 划分训练集和测试集 X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=0) # 定义模型并训练 clf = DecisionTreeClassifier() clf.fit(X_train, y_train) # 预测并评估模型 y_pred = clf.predict(X_test) print('准确率为:%.4f' % accuracy_score(y_test, y_pred)) ``` 7. 神经网络:神经网络是一种常见的深度学习算法,可以用于处理图像、语音等复杂的数据。在Python中,可以使用TensorFlow或PyTorch库实现神经网络算法。例如: ```python import tensorflow as tf import numpy as np # 构造数据集 X = np.random.randn(100, 10) y = np.random.randint(0, 2, size=(100, 1)) # 定义模型参数 inputs = tf.keras.layers.Input(shape=(10,)) x = tf.keras.layers.Dense(64, activation='relu')(inputs) x = tf.keras.layers.Dense(32, activation='relu')(x) outputs = tf.keras.layers.Dense(1, activation='sigmoid')(x) # 定义模型并训练 model = tf.keras.models.Model(inputs=inputs, outputs=outputs) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) model.fit(X, y, epochs=10, batch_size=32) # 预测并评估模型 X_test = np.random.randn(10, 10) y_pred = model.predict(X_test) print(y_pred) ``` 以上是一些使用Python、Tensorflow、sklearn、numpy、pytorch和matplotlib等工具库进行机器学习项目开发时所需的算法实现示例和建议,希望对您有所帮助。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值