Logistics回归、Softmax代码实现--Tensorflow部分

最新推荐文章于 2022-12-31 17:30:37 发布
最新推荐文章于 2022-12-31 17:30:37 发布
阅读量598 收藏
点赞数 1
分类专栏： Tensorflow 文章标签： tensorflow 回归 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52185313/article/details/121155720
版权

Logistics回归、Softmax代码实现–Tensorflow部分–潘登同学的机器学习笔记

python版本–3.6 ; Tensorflow版本–1.15.0 ;编辑器–Pycharm

文章目录

  • 任务：

对mnist手写数据集进行分类, mnist是入门级的数据集， 我们会经常使用他

导入必要的库和数据集

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow_core.examples.tutorials.mnist import input_data
from tensorflow.python.framework import ops
ops.reset_default_graph()
# 创建会话
sess = tf.Session()
mnist = input_data.read_data_sets(r'C:\Users\潘登\PycharmProjects\神经网络\MNIST_data_bak', one_hot=True)

声明学习率, 批量大小, 占位符和模型变量

learning_rate = 0.01
batch_size = 500
x_data = tf.placeholder(shape=[None, 784], dtype=tf.float32)
y_target = tf.placeholder(shape=[None, 10], dtype=tf.float32)  # 因为是one_hot编码所以占位符的宽度是10
W = tf.Variable(tf.zeros(shape=[784, 10]))  # W初始化为0
b = tf.Variable(tf.zeros(shape=[10]))  # b初始化为0

Sotfmax模型

model_output = tf.nn.softmax(tf.add(tf.matmul(x_data, W), b))

声明损失函数(交叉熵）, 初始化变量, 声明优化器

cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=y_target, logits=model_output)
init = tf.global_variables_initializer()
my_opt = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
train_step = my_opt.minimize(cross_entropy)
sess.run(init)

保存并绘制计算图

writer = tf.summary.FileWriter(r"C:\Users\潘登\PycharmProjects\神经网络\Tensorflow深度学习与实战\graph_softmax",sess.graph) # 保存计算图

Softmax计算图

注： 如何查看计算图, 在线性回归代码实现–Tensorflow部分讲过

训练模型

# 迭代遍历, 并在随机选择的数据上进行模型训练， 迭代1000次 每100次迭代输出变量值和损失值, 将其用于之后的可视化
loss_vec = []
for i in range(1000):
    rand_x, rand_y = mnist.train.next_batch(batch_size)
    # 目标：最优化损失
    sess.run(train_step, feed_dict={x_data:rand_x,
                                    y_target:rand_y})
    # 更新loss值
    temp_loss = sess.run(cross_entropy, feed_dict={x_data:rand_x,
                                                   y_target:rand_y})
    loss_vec.append(temp_loss.mean())
    # 每100次打印
    if (i+1) % 100 == 0:
        print('Step:', i+1)
        print('Loss为:', temp_loss.mean())

查看训练结果

plt.figure(2)
plt.plot(loss_vec, 'k--')
plt.title('cross_entropy per Generation')
plt.xlabel('Generation')
plt.ylabel('cross_entropy')
plt.show()

Softmax的loss函数图

从训练集中挑一组进行检验

# 从训练集中挑一组进行检验
images = mnist.test.images
labels = mnist.test.labels

# 测试刚刚训练好的模型
y = tf.nn.softmax(model_output)

# 打印图片
plt.figure(figsize=(12, 8))
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
for test_num in range(1877, 1883):
    image = images[test_num]
    label = labels[test_num]
    a = np.array(image).reshape(1, 784)
    result = sess.run(y, feed_dict={x_data:a})
    plt.subplot(2, 3, test_num - 1876)
    plt.imshow(image.reshape(28,28))
    plt.title('这张照片的实际数字是：%d\n 预测结果为:%d'%(np.argwhere(label == 1), np.argmax(result)))
plt.show()

结果如下：

Softmax测试结果

完整代码

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow_core.examples.tutorials.mnist import input_data
from tensorflow.python.framework import ops
ops.reset_default_graph()
# 创建会话
sess = tf.Session()
mnist = input_data.read_data_sets(r'C:\Users\潘登\PycharmProjects\神经网络\MNIST_data_bak', one_hot=True)

# 声明学习率, 批量大小, 占位符和模型变量
learning_rate = 0.01
batch_size = 500
x_data = tf.placeholder(shape=[None, 784], dtype=tf.float32)
y_target = tf.placeholder(shape=[None, 10], dtype=tf.float32)  # 因为是one_hot编码所以占位符的宽度是10
W = tf.Variable(tf.zeros(shape=[784, 10]))  # W初始化为0
b = tf.Variable(tf.zeros(shape=[10]))  # b初始化为0

# 增加softmax模型
model_output = tf.nn.softmax(tf.add(tf.matmul(x_data, W), b))

# 声明损失函数(交叉熵）, 其为批量损失的平均值, 初始化变量, 声明优化器
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=y_target, logits=model_output)
init = tf.global_variables_initializer()
my_opt = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
train_step = my_opt.minimize(cross_entropy)
sess.run(init)

writer = tf.summary.FileWriter(r"C:\Users\潘登\PycharmProjects\神经网络\Tensorflow深度学习与实战\graph_softmax",sess.graph) # 保存计算图
# 迭代遍历, 并在随机选择的数据上进行模型训练， 迭代1000次 每100次迭代输出变量值和损失值, 将其用于之后的可视化
loss_vec = []
for i in range(1000):
    rand_x, rand_y = mnist.train.next_batch(batch_size)
    # 目标：最优化损失
    sess.run(train_step, feed_dict={x_data:rand_x,
                                    y_target:rand_y})
    # 更新loss值
    temp_loss = sess.run(cross_entropy, feed_dict={x_data:rand_x,
                                                   y_target:rand_y})
    loss_vec.append(temp_loss.mean())
    # 每100次打印
    if (i+1) % 100 == 0:
        print('Step:', i+1)
        print('Loss为:', temp_loss.mean())

# 绘图查看结果
plt.figure(2)
plt.plot(loss_vec, 'k--')
plt.title('cross_entropy per Generation')
plt.xlabel('Generation')
plt.ylabel('cross_entropy')
plt.show()

# 从训练集中挑一组进行检验
images = mnist.test.images
labels = mnist.test.labels

# 测试刚刚训练好的模型
y = tf.nn.softmax(model_output)

# 打印图片
plt.figure(figsize=(12, 8))
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
for test_num in range(1877, 1883):
    image = images[test_num]
    label = labels[test_num]
    a = np.array(image).reshape(1, 784)
    result = sess.run(y, feed_dict={x_data:a})
    plt.subplot(2, 3, test_num - 1876)
    plt.imshow(image.reshape(28,28))
    plt.title('这张照片的实际数字是：%d\n 预测结果为:%d'%(np.argwhere(label == 1), np.argmax(result)))
plt.show()

Logistics回归、Softmax代码实现–Tensorflow部分就是这样了, 继续下一章吧！pd的Machine Learning

PD我是你的真爱粉
关注
专栏目录
Logistic回归以及其Python代码实现
qq_41770617的博客
08-01 389
参考链接：https://blog.csdn.net/ziqu5721/article/details/88186629 假设函数： 代价函数： import numpy as np import pandas as pd import matplotlib as mpl import matplotlib.pyplot as plt import seaborn as sns sns.set(style="whitegrid",color_codes=True) data = pd.read_csv(
机器学习实战(基于scikit-learn和TensorFlow)学习心得(25)--softmax回归及其计算公式
Tomswordyan的博客
03-12 395
softmax regission 好,接下来说一说softmax,上一个随笔介绍了logistic 回归,但是logistic基本上都是用在二分类问题上,也就是他能分辨出一个样本究竟是A还是B,但如果多出一个C选项的话系统就不能很好的工作了.而softmax就是用来处理多分类问题得. softmax regression的思想是这样的,当给定实例x时，Softmax回归模型首先为每个类别k计...
tensorflow_softmax代码解析
07-29 248
## 步骤 ### 开启 InteractiveSession import tensorflow as tf sess = tf.InteractiveSession() tensorflow依靠c++后端来计算。连接着后端的部分称为session。tensorflow的一般用法是，首先...
吴恩达《机器学习》——Logistics回归代码实现
Ace2NoU的博客
12-31 2072
吴恩达《机器学习》之Logistic回归原理讲解与Python代码实现，服数据集
python sklearn库logistics_python sklearn库实现简单逻辑回归的实例代码
weixin_39759182的博客
02-09 220
Sklearn简介Scikit-learn(sklearn)是机器学习中常用的第三方模块，对常用的机器学习方法进行了封装，包括回归(Regression)、降维(Dimensionality Reduction)、分类(Classfication)、聚类(Clustering)等方法。当我们面临机器学习问题时，便可根据下图来选择相应的方法。Sklearn具有以下特点：简单高效的数据挖掘和数据分析工...
logistic regression源代码(含数据集)
04-04
压缩包里含有logistic regression逻辑回归的Python源代码，训练数据集和测试训练集，最后也用Python画了结构示意图。只需要有Numpy和Matplotlib两个包即可。
简单探索MNIST（Softmax回归和两层CNN）-Tensorflow学习
肥宅Sean
03-10 771
简述 这次是在看《21个项目玩转深度学习》那本书的第一章节后做的笔记。 这段时间，打算把TensorFlow再补补，提升一下技术水平~ 希望我能坚持下来，抽空把这本书刷下来吧~ 导入数据 下面的代码会直接下载数据，如果没有那个文件夹的话，但是，如果有这个文件夹而且里面有那几个文件的话，就会直接调用那个数据。 这次直接在网上搜MNIST下载，就知道怎么下载啦~ 这里我更关注TensorFlow...
机器学习实战(基于scikit-learn和TensorFlow)学习心得(24)--CROSS ENTROPY 交叉熵和logit
Tomswordyan的博客
03-10 534
1. logit logit又称为log-odds,odds又译为胜算.他的含义是事件发生的概率与事件不发生的概率之比 如果一个事件发生的概率是p,那么不发生的概率就是1-p.则这个事件的odds是p/(1-p) 那么log-odds就是log(p / (1 – p)). 2.CROSS ENTROPY 交叉熵 交叉熵起源于信息论。假设你想每天高效地传输有关天气的信息。如果有八个选项（...
tensorflow
xuchuyan的专栏
07-04 595
1 部署flask报错 1.1 ValueError: Tensor Tensor("fc1000/Softmax:0", shape=(?, 1000), dtype=float32) is not an element of this graph. 在将keras部署在flask时，使用https://github.com/jrosebr1/simple-keras-rest-api这个例程时...
logistic 算法 及其代码实现
Glory 的 博客
11-08 6552
logistic regression model 这个模型是用来解决分类问题的一种常用的模型，当然在解决这个种模型的时候仍然需要用到梯度下降法。 在这个模型中 我们设置一个个 cost function (x,y); 它等于下面的一个等式 关于这个公式的来源，并不是没有他内在的数学原理，他的数学原理需要用到概率论中的极大似然估计法，以及高等数学中的微积分，如果感兴趣的话可以看一下这
TensorFlow实现Logistic回归
12-24
本文实例为大家分享了TensorFlow实现Logistic回归的具体代码，供大家参考，具体内容如下 1.导入模块 import numpy as np import pandas as pd from pandas import Series,DataFrame from matplotlib import pyplot as plt %matplotlib inline #导入tensorflow import tensorflow as tf #导入MNIST(手写数字数据集) from tensorflow.examples.tutorials.mnist import input_
鸢尾花 softmax tensorflow 实例
11-23
鸢尾花经典案例，采用 softmax 分类，使用tensorflow实现
logistics回归测试数据集
04-26
用于logistics回归的测试数据集，其中logistics回归的Python实现和MATLAB实现在另一篇博文里
TensorFlow - Softmax
二分掌柜的
09-19 1124
TensorFlow - Softmax flyfish 公式 sigma(z)j=ezj∑Kk=1ezksigma(z)j=ezj∑k=1Kezksigma (\mathbf {z} )_{j}={\frac {e^{z_{j}}}{\sum _{k=1}^{K}e^{z_{k}}}} 解释 K表示K维向量 类似一个向量里面有K个实数值，通过Softmax函数输出另一个向量，另一个向量...
TensorFlow 学习 - MNIST 之 SoftMax Regression 实现（完整代码，拷贝可运行）
Xcy的博客
06-02 911
数据集以及模型介绍MNIST 数据集： Google实验室的Corinna Cortes和纽约大学柯朗研究所的Yann LeCun建的手写数字数据库，训练库有60,000张手写数字图像，测试库有10,000张。每一个MNIST数据单元有两部分组成：一张包含手写数字的图片和一个对应的标签。我们把这些图片设为“xs”，把这些标签设为“ys”。训练数据集和测试数据集都包含xs和ys，比如训练数据集的图片是
tensorflow程序-最简单softmax模型
一花一世界 一叶一菩提
04-26 1163
#-*- coding=utf-8 -*- import numpy import tensorflow as tf import input_data #读取手写字体数据源 [None,28*28] mnist = input_data.read_data_sets("/home/tensorflow/tensorflow_workspace/data/", one_hot=True);
TensorFlow实现Softmax
louishao的博客
07-26 6875
TensorFlow实现Softmax Regression识别手写数字。本文从相关原理讲起，讲解了Softmax回归算法，之后使用TensorFlow进行编程实现，最后展现实验结果。虽然算法简单，但是经过整理总结，编程实现，学习得更加深刻！
tensorflow开发之 基于softmax的手写数字识别（含源码）
真相很简单
11-06 4767
基于softmax的全链接层模型，使用mnist训练集进行手写数字的识别
从零开始softmax的实现-tensorflow
qq_34928047的博客
12-26 413
从零开始softmax的实现1.softmax的数学公式1.1softmax的公式1.2softmax的损失函数1.3小结2.softmax的python代码2.1 导入库3.softmax的keras代码 1.softmax的数学公式 1.1softmax的公式 1.2softmax的损失函数 softmax使用是损失函数是交叉熵（cross entropy），数学公式表现如下 也就是说，交叉熵只关心对正确类别的预测概率，因为只要其值足够大，就可以确保分类结果正确。当然，遇到一个样本有多个标签时，例如
self-attention代码tensorflow
最新发布
06-28
### 回答1： 以下是一个简单的 self-attention 代码示例，使用 TensorFlow 实现： ```python import tensorflow as tf class SelfAttention(tf.keras.layers.Layer): def __init__(self, units): super(SelfAttention, self).__init__() self.W1 = tf.keras.layers.Dense(units) self.W2 = tf.keras.layers.Dense(units) self.V = tf.keras.layers.Dense(1) def call(self, inputs): # inputs shape: (batch_size, seq_len, embedding_dim) # hidden shape: (batch_size, seq_len, units) hidden = tf.nn.tanh(self.W1(inputs) + self.W2(inputs)) # score shape: (batch_size, seq_len, 1) score = self.V(hidden) # attention_weights shape: (batch_size, seq_len, 1) attention_weights = tf.nn.softmax(score, axis=1) # context_vector shape: (batch_size, units) context_vector = attention_weights * inputs context_vector = tf.reduce_sum(context_vector, axis=1) return context_vector ``` 这个 self-attention 层接受一个形状为 (batch_size, seq_len, embedding_dim) 的输入张量，其中 batch_size 是批量大小，seq_len 是序列长度，embedding_dim 是嵌入维度。它通过两个全连接层 W1 和 W2 将输入映射到一个隐藏表示，然后使用另一个全连接层 V 计算每个时间步的得分。得分通过 softmax 函数进行归一化，得到每个时间步的注意力权重。最后，将注意力权重乘以输入张量，得到上下文向量，作为 self-attention 层的输出。 使用这个 self-attention 层的示例代码： ```python import numpy as np # 创建一个 self-attention 层 attention_layer = SelfAttention(units=32) # 创建一个输入张量 inputs = tf.keras.Input(shape=(10, 16)) # 在输入张量上应用 self-attention 层 context_vector = attention_layer(inputs) # 创建一个模型 model = tf.keras.Model(inputs=inputs, outputs=context_vector) # 生成一些随机输入数据 x = np.random.randn(32, 10, 16) # 在模型上进行推理 output = model(x) print(output.shape) # 输出 (32, 32) ``` ### 回答2： 自注意力机制（self-attention）是目前在自然语言处理领域广泛应用的一种机制。自注意力机制在BERT、GPT-2等模型中占据了非常重要的位置，因此，掌握自注意力机制的实现方法对进行文本处理任务非常重要。 而在TensorFlow中，实现自注意力机制也非常简单。下面是一个简单的TensorFlow代码示例： ```python import tensorflow as tf class SelfAttention(tf.keras.layers.Layer): def __init__(self, dim, num_heads): super(SelfAttention, self).__init__() # 创建查询、键、值的权重矩阵 self.query_weights = tf.keras.layers.Dense(units=dim) self.key_weights = tf.keras.layers.Dense(units=dim) self.value_weights = tf.keras.layers.Dense(units=dim) # 查询的分组数：即头的数量 self.num_heads = num_heads # 定义multi-head softmax层 self.multihead_softmax = tf.keras.layers.Dense(units=dim) def call(self, inputs): # inputs的shape：(batch_size, seq_len, embedding_size) # 生成查询、键、值 queries = self.query_weights(inputs) keys = self.key_weights(inputs) values = self.value_weights(inputs) # 将最后一维embedding_size分成num_heads份 queries = tf.reshape(queries, shape=(tf.shape(queries)[0], -1, self.num_heads, queries.shape[-1] // self.num_heads)) keys = tf.reshape(keys, shape=(tf.shape(keys)[0], -1, self.num_heads, keys.shape[-1] // self.num_heads)) values = tf.reshape(values, shape=(tf.shape(values)[0], -1, self.num_heads, values.shape[-1] // self.num_heads)) # 经过matmul计算得到attention分布 attention_matmul = tf.matmul(queries, keys, transpose_b=True) attention_score = tf.nn.softmax(attention_matmul / tf.math.sqrt(tf.cast(keys.shape[-1], dtype=tf.float32))) attention_output = tf.matmul(attention_score, values) # 对前两维进行reshape，再经过全连接层得到结果 attention_output = tf.reshape(attention_output, shape=(tf.shape(attention_output)[0], -1, attention_output.shape[-2] * attention_output.shape[-1])) output = self.multihead_softmax(attention_output) return output ``` 以上函数中，我们首先定义了一个SelfAttention类，该类继承了TensorFlow中的keras.layers.Layer类。在该类中，我们定义了查询、键、值的权重矩阵，以及多头softmax层。然后在call函数中，我们将输入进行查询、键、值的计算，然后分成多个头，经过matmul计算得到attention分布，最后将前两维进行reshape后再经过全连接层得到输出。 使用该SelfAttention类时，只需要在定义model时添加该层即可。例如： ```python import tensorflow as tf input = tf.keras.layers.Input(shape=(None, 512)) self_attention = SelfAttention(dim=512, num_heads=8)(input) model = tf.keras.models.Model(input, self_attention) ``` 以上代码示例可以将输入通过定义的SelfAttention层进行处理，然后输出self-attention后的结果。 ### 回答3： Self-attention（自注意力）是一种用于自然语言处理和计算机视觉领域的自监督学习方法，它通过允许模型在输入序列中关注不同位置的信息来实现对序列数据的建模。代码tensorflow实现了自注意力模型，使得开发者可以使用tensorflow库快速部署自注意力应用。 在代码tensorflow中，首先需要定义一个自注意力层。在该层中，输入数据被表示为一个矩阵，我们可以使用矩阵点积和softmax函数来计算每个注意头的输出: ```python class SelfAttention(tf.keras.layers.Layer): def __init__(self, units): super(SelfAttention, self).__init__() self.units = units self.W_q = tf.keras.layers.Dense(units=self.units) self.W_k = tf.keras.layers.Dense(units=self.units) self.W_v = tf.keras.layers.Dense(units=self.units) self.dense = tf.keras.layers.Dense(units=self.units) def call(self, inputs): Q = self.W_q(inputs) #[batch_size, query_length, depth] K = self.W_k(inputs) #[batch_size, key_length, depth] V = self.W_v(inputs) #[batch_size, value_length, depth] #计算分数，通过矩阵相乘 score = tf.matmul(Q, K, transpose_b=True) #缩放得分 depth = tf.cast(tf.shape(K)[-1], tf.float32) scaled_score = score / tf.math.sqrt(depth) #使用softmax函数计算权重 weights = tf.nn.softmax(scaled_score, axis=-1) #计算加权和 attention_output = tf.matmul(weights, V) #拼接所有头的输出 heads = tf.concat(tf.split(attention_output, num_or_size_splits=self.num_heads, axis=-1), axis=0) return self.dense(heads) ``` 然后，我们可以使用定义好的自注意力层来构建一个自注意力模型。该模型使用多头注意力，允许模型同时关注多个位置的信息。 ```python class SelfAttentionModel(tf.keras.Model): def __init__(self, num_heads, units, output_units): super(SelfAttentionModel, self).__init__() self.num_heads = num_heads self.self_attention = SelfAttention(units=units) self.output_layer = tf.keras.layers.Dense(units=output_units, activation='softmax') def call(self, inputs): self_attention_output = self.self_attention(inputs) return self.output_layer(self_attention_output) ``` 最后，我们可以使用tensorflow的训练方法来训练自注意力模型，并在测试集上评估其性能。同时，我们也可以使用训练好的模型来执行不同的自然语言处理和计算机视觉任务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

PD我是你的真爱粉

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值