趣闲赚,seo是什么意思教程,科技布沙发脏了用什么办法清洗,社区团购appHi, 你好。我是茶桁。
前面几节课中#xff0c;我们从最初的理解神经网络#xff0c;到讲解函数#xff0c;多层神经网络#xff0c;拓朴排序以及自动求导。 可以说#xff0c;最难的部分已经过去了#xff0c;这节课到了我们来收尾的阶段#xff0c;没错#xff0c;生…
Hi, 你好。我是茶桁。
前面几节课中我们从最初的理解神经网络到讲解函数多层神经网络拓朴排序以及自动求导。 可以说最难的部分已经过去了这节课到了我们来收尾的阶段没错生长了这么久终于到迎接成果的时候了。
好让我们开始。 我们还是用上一节课的代码:21.ipynb。 我们上一节课中实现了自动计算的部分。
for node in sorted_nodes[::-1]:print(\n{}.format(node.name))node.backward()结果我就不打印了节省篇幅。
那我们到这一步之后咱们就已经获得了偏导现在要考虑的问题就是去更新它去优化它的值。
learning_rate 1e-5for node in sorted_nodes:node.value node.value -1 * node.gradients[node] * learning_ratenode的值去更新就应该等于它本身的值加上一个-1乘以它的偏导在乘以一个learning_rate, 我们对这个是不是已经很熟悉了我们从第8节线性回归的时候就一直在接触这个公式。
只不过在这个地方x, y的值也要更新吗 它们的值是不应该去更新的那要更新的应该是k, b的值。
那么在这个地方该怎么办呢其实很简单我们添加一个判断就可以了
for node in sorted_nodes:if node.is_trainable:node.value node.value -1 * node.gradients[node] * learning_rate然后我们给之前定义的类上加一个变量用于判断。
class Node:def __init__(..., is_trainableFalse):...self.is_trainable is_trainable
在这里我们默认是不可以训练的只有少数的一些是需要训练的。
然后我们在初始化的部分把这个定义的值加上
node_k Placeholder(namek, is_trainableTrue)
node_b Placeholder(nameb, is_trainableTrue)对了我们还需要将Placeholder做些改变
class Placeholder(Node):def __init__(..., is_trainableFalse):Node.__init__(.., is_trainableis_trainable)......这就意味着运行for循环的时候只有k和b的值会更新我们再加几句话
for node in sorted_nodes:if node.is_trainable:...cmp large if node.gradients[node] 0 else smallprint({}的值{}需要更新。.format(node.name, cmp))---
k的值small需要更新。
b的值small需要更新。我们现在将forward, backward和optimize的三个循环封装乘三个方法
def forward(graph_sorted_nodes):# Forwardfor node in sorted_nodes:node.forward()def backward(graph_sorted_nodes):# Backwardfor node in sorted_nodes[::-1]:print(\n{}.format(node.name))node.backward()def optimize(graph_sorted_nodes, learning_rate1e-3):# optimizefor node in sorted_nodes:if node.is_trainable:node.value node.value -1 * node.gradients[node] * learning_ratecmp large if node.gradients[node] 0 else smallprint({}的值{}需要更新。.format(node.name, cmp))
然后我们再来定义一个epoch方法将forward和backward放进去一起执行
def run_one_epoch(graph_sorted_nodes):forward(graph_sorted_nodes)backward(graph_sorted_nodes)这样我们完成一次完整的求值-求导-更新就可以写成这样
run_one_epoch(sorted_nodes)
optimize(sorted_nodes)为了更好的观察我们将所有的print都删掉然后在backward方法中写一个观察loss的打印函数
def backward(graph_sorted_nodes):# Backwardfor node in sorted_nodes[::-1]:if isinstance(node, Loss):print(loss value: {}.format(node.value))node.backward()然后我们来对刚才完整的过程做个循环
# 完整的一次求值-求导-更新
for _ in range(10):run_one_epoch(sorted_nodes)optimize(sorted_nodes, learning_rate1e-1)---
loss value: 0.12023025149136042
loss value: 0.11090709486917472
loss value: 0.10118818479676453
loss value: 0.09120180962480523
loss value: 0.08111466190584131
loss value: 0.0711246044819575
loss value: 0.061446239826641165
loss value: 0.05229053883349982
loss value: 0.043842158831920566
loss value: 0.036239620745126可以看到loss在一点点的下降。当然这样循环10次我们还能观察出来但是我们如果要成百上千次的去计算它这样可就不行了 那我们需要将history存下来然后用图来显示出来
loss_history []
for _ in range(100):..._loss_node sorted_nodes[-1]assert isinstance(_loss_node, Loss)loss_history.append(_loss_node.value)optimize(sorted_nodes, learning_rate1e-1)plt.plot(loss_history)我们现在可以验证一下我们拟合的yhat和真实的y之间差距有多大首先我们当然是要获取到每个值的下标然后用sigmoid函数来算一下
sorted_nodes---
[k, y, x, b, Linear, Sigmoid, Loss]通过下标来进行计算, k是0 x是2 b是3 y是1
def sigmoid(x):return 1/(1np.exp(-x))# k*xb
sigmoid_x sorted_nodes[0].value * sorted_nodes[2].value sorted_nodes[3].value
print(sigmoid(sigmoid_x))# y
print(sorted_nodes[1].value)---
0.891165479601981
0.8988713384533658可以看到非常的接近。那说明我们拟合的情况还是不错的。
好这里总结一下就是我们有了拓朴排序就能向前去计算它的值通过向前计算的值就可以向后计算它的值。那现在其实我们已经完成了一个mini的深度学习框架的核心内容咱们能够定义节点能够前向传播运算能够反向传播运算能更新梯度了。
那接下来是不是就结束了呢很遗憾并没有接着咱们还要考虑如何处理多维数据。咱们现在看到的数据都是x、k、b的输入也就是都是一维的。
然而咱们真实世界中大多数场景下其实都是多维度的其实都是多维数组。那么多维数组的还需要更新些什么和现在有什么区别呢
我们来接着往后看因为基本上写法和现在这些几乎完全一样那我也就不这么细致的讲了。
为了和之前代码做一个区分所以我将多维向量计算的代码从新开了个文件放在了23.ipynb里小伙伴可以去下载到本地研习。
那么多维和现在最大的区别在哪里呢就在于计算的时候我们就要用到矩阵运算了。只是值变成了矩阵运算变成的了矩阵运算。好我们从Node开始来改动它没什么变化的地方我就直接用...来省略了
class Node:def __init__(self, input[]):...def forward(self):raise NotImplementeddef backward(self):raise NotImplementedclass Placeholder(Node):def __init__(self):Node.__init__(self)def forward(self, valueNone):...def backward(self):self.gradients {self:0}for n in self.outputs:grad_cost n.gradients[self]self.gradients[self] grad_cost * 1class Linear(Node):def __init__(self, x, k, b):...def forward(self):...def backward(self):self.gradients {n: np.zeros_like(n.value) for n in self.inputs}for n in self.outputs:grad_cost n.gradients[self]self.gradients[self.inputs[0]] np.dot(grad_cost, self.inputs[1].value.T)self.gradients[self.inputs[1]] np.dot(self.inputs[0].value.T, grad_cost)self.gradients[self.inputs[2]] np.sum(grad_cost, axis0, keepdimsFalse)class Sigmoid(Node):def __init__(self, node):Node.__init__(self, [node])def _sigmoid(self, x):...def forward(self):...def backward(self):self.partial self._sigmoid(self.x) * (1 - self._sigmoid(self.x))self.gradients {n: np.zeros_like(n.value) for n in self.inputs}for n in self.outputs:grad_cost n.gradients[self] self.gradients[self.inputs[0]] grad_cost * self.partialclass MSE(Node): # 也就是之前的Loss类def __init__(self, y, a):Node.__init__(self, [y, a])def forward(self):y self.inputs[0].value.reshape(-1, 1)a self.inputs[1].value.reshape(-1, 1)assert(y.shape a.shape)self.m self.inputs[0].value.shape[0]self.diff y - aself.value np.mean(self.diff**2)def backward(self):self.gradients[self.inputs[0]] (2 / self.m) * self.diffself.gradients[self.inputs[1]] (-2 / self.m) * self.diff类完成之后我们还有一些其他的方法
def forward_and_backward(graph): # run_one_epochfor n in graph:n.forward()for n in graph[::-1]:n.backward()
def toplogic(graph):...
def convert_feed_dict_to_graph(feed_dict):...
# 将sorted_nodes赋值从新定义了一个方法
def topological_sort_feed_dict(feed_dict):graph convert_feed_dict_to_graph(feed_dict)return toplogic(graph)def optimize(trainables, learning_rate1e-2):for node in trainables:node.value -1 * learning_rate * node.gradients[node]这样就完成了。可以发现基本上代码没有什么变动变化比较大的都是各个类中的backward方法因为要将其变成使用矩阵运算。
我们来尝试着用一下这个多维算法我们还是用波士顿房价的那个数据来做一下尝试
X_ data[data]
y_ data[target]# Normalize data
X_ (X_ - np.mean(X_, axis0)) / np.std(X_, axis0)n_features X_.shape[1]
n_hidden 10
W1_ np.random.randn(n_features, n_hidden)
b1_ np.zeros(n_hidden)
W2_ np.random.randn(n_hidden, 1)
b2_ np.zeros(1)# Neural network
X, y Placeholder(), Placeholder()
W1, b1 Placeholder(), Placeholder()
W2, b2 Placeholder(), Placeholder()l1 Linear(X, W1, b1)
s1 Sigmoid(l1)
l2 Linear(s1, W2, b2)
cost MSE(y, l2)feed_dict {X: X_,y: y_,W1: W1_,b1: b1_,W2: W2_,b2: b2_
}epochs 5000
# Total number of examples
m X_.shape[0]
batch_size 16
steps_per_epoch m // batch_sizegraph topological_sort_feed_dict(feed_dict)
trainables [W1, b1, W2, b2]print(Total number of examples {}.format(m))我们在中间定义了l1, s1, l2, cost, 分别来实例化四个类。然后我们就需要根据数据来进行迭代计算了定义一个losses来保存历史数据
losses []epochs 100for i in range(epochs):loss 0for j in range(steps_per_epoch):# Step 1X_batch, y_batch resample(X_, y_, n_samplesbatch_size)X.value X_batchy.value y_batch# Step 2forward_and_backward(graph) # set output node not important.# Step 3rate 1e-2optimize(trainables, rate)loss graph[-1].valueif i % 100 0: print(Epoch: {}, Loss: {:.3f}.format(i1, loss/steps_per_epoch))losses.append(loss/steps_per_epoch)---
Epoch: 1, Loss: 194.170
...
Epoch: 4901, Loss: 3.137可以看到它loss下降的非常快还记得咱们刚开始的时候在训练波士顿房价数据的时候那个loss下降到多少 最低是不是就下降到在第一节课的时候我们的lose最多下降到了多少47.34对吧那现在呢直接下降到了3这是为什么 因为我们的维度多了维度多了它就准确了。这说明什么 说明大家去谈恋爱的时候不要盯着对象的一个方面多方面考察才能知道这个人是否合适。
好现在看起来效果是很好但是我们想知道到底拟合出来的什么函数那怎么办咱们把这个维度降低成三维空间就可以看了。
现在咱们这个波士顿的所有数据实际上是一个15维的数据15维的数据你根本看不了咱们现在只要把x这个里边取一点值在这个里边稍微把值给它变一下。
X_ dataframe[[RM, LSTAT]]
y_ data[target]在咱们之前的课程中对其进行计算的时候就分析过RM和LSTAT是影响最大的两个特征我们还是来用这个。然后我们将刚才的代码从新运行一遍
losses []for i in tqdm_notebook(range(epochs)):...---
Epoch: 1, Loss: 150.122
...
Epoch: 4901, Loss: 16.181这次下降的就没上次好了。
现在我们可视化一下这个三维空间来看看
from mpl_toolkits.mplot3d import Axes3Dpredicate_results []
for rm, ls in X_.values:X.value np.array([[rm, ls]])forward_and_backward(graph)predicate_results.append(graph[-2].value[0][0])%matplotlib widgetfig plt.figure(figsize(10, 10))
ax fig.add_subplot(111, projection3d)X_ dataframe[[RM, LSTAT]].values[:, 0]
Y_ dataframe[[RM, LSTAT]].values[:, 1]Z predicate_resultsrm_and_lstp_price ax.plot_trisurf(X_, Y_, Z, colorgreen)ax.set_xlabel(RM)
ax.set_ylabel(% of lower state)
ax.set_zlabel(Predicated-Price)然后我们就能看到一个数据的三维图形因为我们开启了widget 所以可以进行拖动。 从图形上看确实符合房间越多低收入人群越少房价越高的特性。
那现在计算机确实帮我们自动的去找到了一个函数这个函数到底怎么设置咱们都不用关心它自动就给你求解出来这个就是深度学习的意义。咱们经过这一系列写出来的东西其实就已经能够做到。
我觉得这个真的有一种数学之美它从最简单的东西出发最后做成了这样一个复杂的东西。确实很深其并且还都在我们的掌握之中。
好大家下来以后记得要多多自己敲代码多分析其中的一些过程和原理。
