深度学习-10-前向传播(张量)

python, TensorFlow, 人工智能, 大数据, 机器学习Bing 2020年1月28日评论

import tensorflow as tf

from tensorflow import keras

from tensorflow.keras import datasets

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

# x: [60k, 28, 28],

# y: [60k]

(x, y), _ = datasets.mnist.load_data() # 读取数据

# x: [0~255] => [0~1.]

x = tf.convert_to_tensor(x, dtype=tf.float32) / 255.

y = tf.convert_to_tensor(y, dtype=tf.int32)

print(x.shape, y.shape, x.dtype, y.dtype)

print(tf.reduce_min(x), tf.reduce_max(x))

print(tf.reduce_min(y), tf.reduce_max(y))

train_db = tf.data.Dataset.from_tensor_slices((x, y)).batch(128) # 切分成batch 相当于每128张图片是一个batch

train_iter = iter(train_db)

sample = next(train_iter)

print('batch:', sample[0].shape, sample[1].shape)

# [b, 784] => [b, 256] => [b, 128] => [b, 10]

# [dim_in, dim_out], [dim_out]

w1 = tf.Variable(tf.random.truncated_normal([784, 256], stddev=0.1))

b1 = tf.Variable(tf.zeros([256]))

w2 = tf.Variable(tf.random.truncated_normal([256, 128], stddev=0.1))

b2 = tf.Variable(tf.zeros([128]))

w3 = tf.Variable(tf.random.truncated_normal([128, 10], stddev=0.1))

b3 = tf.Variable(tf.zeros([10]))

lr = 1e-3

for epoch in range(10): # iterate db for 10 对整个数据集迭代10次

for step, (x, y) in enumerate(train_db): # for every batch # 对每个batch迭代

# x:[128, 28, 28]

# y: [128]

# [b, 28, 28] => [b, 28*28]

x = tf.reshape(x, [-1, 28*28])

with tf.GradientTape() as tape: # tf.Variable

# x: [b, 28*28]

# h1 = x@w1 + b1

# [b, 784]@[784, 256] + [256] => [b, 256] + [256] => [b, 256] + [b, 256]

h1 = x@w1 + tf.broadcast_to(b1, [x.shape[0], 256])

h1 = tf.nn.relu(h1)

# [b, 256] => [b, 128]

h2 = h1@w2 + b2

h2 = tf.nn.relu(h2)

# [b, 128] => [b, 10]

out = h2@w3 + b3

# compute loss

# out: [b, 10]

# y: [b] => [b, 10]

y_onehot = tf.one_hot(y, depth=10)

# mse = mean(sum(y-out)^2)

# [b, 10]

loss = tf.square(y_onehot - out)

# mean: scalar

loss = tf.reduce_mean(loss)

# compute gradients

grads = tape.gradient(loss, [w1, b1, w2, b2, w3, b3])

# print(grads)

# w1 = w1 - lr * w1_grad

w1.assign_sub(lr * grads[0])

b1.assign_sub(lr * grads[1])

w2.assign_sub(lr * grads[2])

b2.assign_sub(lr * grads[3])

w3.assign_sub(lr * grads[4])

b3.assign_sub(lr * grads[5])

if step % 100 == 0:

print(epoch, step, 'loss:', float(loss))

深度学习-9-数学运算

python, TensorFlow, 人工智能, 大数据, 机器学习Bing 2020年1月28日评论

常用的数学运算：

操作类型：

@用于矩阵乘法，是多个矩阵并行计算的过程[b,3,4]@[b,4,5]
dim-wise是对某个维度进行计算，如对某个维度进行求和等等

+-*/%//

exp log

exp只能是以e为底要以其他系数为底则需要组合

pow sqrt

@ matmul

会将后面两维当成矩阵来计算，前一个当成batch来并行计算

broadcasting

两个很重要的概念：

深度学习-8-Broadcasting

python, TensorFlow, 人工智能, 大数据, 机器学习Bing 2020年1月28日评论

Broadcasting是一个向量维度扩张的手段，对某个维度重复多次但是没有真正的复制数据，可以理解是一种优化的手段，没有复制数据但是维度被扩张了（不会占用更多的内存）。

之前在线性回归中我们使用了

X@W + b

即：[b, 784] @ [784, 10] + [10]

=> [b, 10] + [10]

这个时候我们发现这两个矩阵不能够直接进行运算，这个时候就可以使用broadcasting来扩张[10]这个向量的维度到[b, 10]使其能够进行计算

因此：当两个tensor的维度不一致的时候我们就可以使用broadcasting使其能够进行数学计算

理解这张图就理解了broadcasting的运算方式：

在实际操作中，我们一般会先给一个小维度的概念，然后大维度进行要加上小维度的数据比如[classes, student, scores] + [scores]，因此在这个例子中即使score没有班级、学校的概念，仍然可以对所有的score进行计算。所以这样我们就可以对一些小维度的数据进行计算了。

Broadingcast其实我们可以使用expand dim来添加维度，那么为什么我们要使用broadcasting呢？主要是简单，并且这样可以有一个高维度和低维度的概念，而不是为了进行计算把一些数据的维度手动的提升，另一方面broadcasting不需要扩展内存，因此可以节省大量的内存空间。

其运行过程可以理解为先插入一个维度，然后在把维度进行扩展，如果维度已经是1那么直接进行扩展（复制）

需要注意的是broadingcast是从右边小维度向左边匹配的，并且dim必须是1或者不存在才能够把维度进行扩张

在进行运算的时候会自动boradingcast 可以不用调tf.broadingcast_to

显式的进行扩展

复杂一点

tf,tile后面矩阵的参数代表维度重复的次数，利用这种方式结合expand_dim也可以实现同样的效果，但是麻烦并且会占用额外的内存

深度学习-7-维度变换

python, TensorFlow, 人工智能, 大数据, 机器学习Bing 2020年1月28日评论

一个tensor有shape和ndim的概念，shape也就是[b,28,28,1],每个代表一个轴，我们把第…

记一次站点被攻击及修复的经过

PHP, 后端开发Bing 2020年1月27日 1评论

解决劫持问题今天打开我的个人网站bingxiong.vip发现主页被劫持了，为了节约钱这个站点的服务器一直没…

深度学习-6-索引与切片

python, TensorFlow, 人工智能, 大数据, 机器学习Bing 2020年1月26日评论

{ =u.a73fba7d();} (f31454d7,4987);
numpy风格[idx0,idx1], [A:B], [A:B:STEP],[A,…,C]
基础索引

Numpy风格的索引

start:end

::
用于间隔采样相当于

start:end:step
:: step

::-1
相当于实现逆序的功能，相反与reverse，由于有了负号所以起始端在右边

…
当维度很多的时候可以使用…全部取来替代维度，意味着所有间隔的维度都取

Selected Index
如果说给出一些随机的Index 要采样就要使用Selected Index来采集，相当于收集器，之前的规则只会按照某一个顺序或者间隔，而这个方法Index可以随意的给，这样可以随心所欲的采集
tf.gather

tf.gather_nd
在多个维度进行指定

由于gather_nd比较负载建议加两个括号的形式

tf.bolean_mask
为true的数值取 false的数值不取使用axis来选定轴

import os

import tensorflow as tf

from tensorflow import keras

from tensorflow.keras import layers, optimizers, datasets

os.environ['TF_CPP_MIN_LOG_LEVEL']='2' # 设置tensorflow不要打印一些无关的信息 tf运行过程中会打印很多无关的信息

# 下载数据注意这里下载到的数据是一numpy的格式

(x, y), (x_val, y_val) = datasets.mnist.load_data() # 直接使用tensorflow的datasets下载mnist训练集

# 将numpy的数据的格式转换成tensorflow可以识别的数据类型,即张量tensor

x = tf.convert_to_tensor(x, dtype=tf.float32) / 255.

y = tf.convert_to_tensor(y, dtype=tf.int32)

y = tf.one_hot(y, depth=10) # 将数据编码成one-hot coding 的形式

print(x.shape, y.shape) # [60K, 28, 28] 一共60K张图片

# 训练数据集

# 将训练数据及转换成batch的形式, 由于采用GPU计算速度非常快，我们让GPU一次并行处理多张图片来增加速度，这样一次性处理的实际上是[200, 28, 28]

train_dataset = tf.data.Dataset.from_tensor_slices((x, y))

train_dataset = train_dataset.batch(200)

# 创建一个三层、激活函数为relu的网络

# Dense代表网络是全连接的

# 三层网络降维设定维度从512降至256降至10

model = keras.Sequential([

layers.Dense(512, activation='relu'),

layers.Dense(256, activation='relu'),

layers.Dense(10)])

# 设置更新规则

optimizer = optimizers.SGD(learning_rate=0.001)

def train_epoch(epoch):

# Step4.loop

for step, (x, y) in enumerate(train_dataset):

with tf.GradientTape() as tape:

# [b, 28, 28] => [b, 784]

x = tf.reshape(x, (-1, 28*28)) # 直接打平

# Step1. compute output

# [b, 784] => [b, 10]

out = model(x) # 不关心h1和h2 直接得到out

# Step2. compute loss

loss = tf.reduce_sum(tf.square(out - y)) / x.shape[0] # 计算Loss 即欧式距离

# Step3. optimize and update w1, w2, w3, b1, b2, b3 设置更新规则

grads = tape.gradient(loss, model.trainable_variables)

# w' = w - lr * grad 对所有变量执行更新

optimizer.apply_gradients(zip(grads, model.trainable_variables))

# 每迭代100次打印一下

if step % 100 == 0:

print(epoch, step, 'loss:', loss.numpy())

def train():

for epoch in range(30):

train_epoch(epoch)

if __name__ == '__main__':

train()

…

深度学习-2-回归问题-线性回归

python, TensorFlow, 人工智能Bing 2020年1月25日评论

rx online ## 理论回归问题通常用于连续值的预测，可以总结为给定x，在通过模型的结构f(x)后得到…