grokkinDeepLearn Three

最新推荐文章于 2024-05-19 23:31:32 发布

黄朝阳98

最新推荐文章于 2024-05-19 23:31:32 发布

阅读量191

点赞数

分类专栏： Grokking Deep Learning 文章标签： python

本文链接：https://blog.csdn.net/weixin_44905574/article/details/106061397

版权

Grokking Deep Learning 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

tesorflow2的简单使用

实现代码：

import tensorflow as tf
import numpy as np

def main():

    #建立神经网络
    models = tf.keras.Sequential()

    #增加神经元结构input_dim输入维度 units输出多少个值
    models.add(tf.keras.layers.Dense(input_dim=1,units=2))
    models.add(tf.keras.layers.Dense(input_dim=2,units=1))
    models.compile(loss="mse",optimizer="sgd")

    #打印神经结构
    models.summary()

    #准备数据集
    x = np.linspace(-5,5,200)
    y = 2*x + 100 + np.random.normal(0,0.1,(200,))

    #训练模型verbose是否打印训练过程，validation_split多少百分比用来训练
    models.fit(x,y,verbose=1,epochs=200,validation_split=0.2)

    #保存训练模型
    models.save("./line_models.h5")

    # #加载保存的模型
    # models = tf.keras.models.load_model("./line_models.h5")

    #定义一个tensorslow数据
    x = tf.constant([0.5])

    #对x进行预测
    y = models.predict(x)
    print(y)




if __name__ == "__main__":
    main()

《grokking Deep Learning》第五章代码解读

多对一

多对一神经元结构：

球员的输赢预测（多个输入对一个输出进行预测）：

#coding="utf-8"

#多对一神经网络
def w_sum(a, b):
    #断言：判断是否相等不相等抛出错误
    assert (len(a) == len(b))
    output = 0
    for i in range(len(a)):
        #权重和输入相乘放回预测值
        output += (a[i] * b[i])
    return output

#初始化权重值
weights = [0.1, 0.2, -0.1]

def neural_network(input, weights=weights):
    #使用函数预测
    pred = w_sum(input,weights)
    return pred

def ele_mul(number, vector):
    output = [0, 0, 0]
    assert (len(output) == len(vector))
    for i in range(len(vector)):
        #误差与输入相乘
        output[i] = number * vector[i]
    return output

def main():
    #数据集
    toes = [8.5, 9.5, 9.9, 9.0]
    wlrec = [0.65, 0.8, 0.8, 0.9]
    nfans = [1.2, 1.3, 0.5, 1.0]
    #对应的结果
    win_or_lose_binary = [1, 1, 0, 1]
    true = win_or_lose_binary[0]
    #准备预测的数据
    input = [toes[0], wlrec[0], nfans[0]]
    # 改变率
    alpha = 0.01
    for iter in range(3):
        # 第一组数据输入进行预测
        pred = neural_network(input, weights)
        # 预测值与真实值的误差平方
        error = (pred - true) ** 2
        # 预测值与真实值的误差
        delta = pred - true
        #权重的差值
        weight_deltas = ele_mul(delta, input)
        #冻结权重（弹性固化神经网络特性）
        weight_deltas[0] = 0
        # 通过误差得到新的权重值
        for i in range(len(weights)):
            # 以alpha的学习率更新权重
            weights[i] -= alpha * weight_deltas[i]
        #输出第几次循环
        print("Iteration:" + str(iter + 1))
        #输出预测
        print("Pred:" + str(pred))
        #输出误差
        print("Error:" + str(error))
        #输出预测与真实值的差距
        print("Delta:" + str(delta))
        #输出权重误差
        print("Weights:" + str(weights))
        #输出权重与真实值的误差
        print("Weight_Deltas:")
        print(str(weight_deltas))
        print()
    #输出权重和权重误差
    print("Weights:" + str(weights))
    print("Weight Deltas:" + str(weight_deltas))

if __name__ == '__main__':
    main()

结果：

Iteration:1
Pred:0.8600000000000001
Error:0.01959999999999997
Delta:-0.1399999999999999
Weights:[0.1, 0.20091, -0.09832]
Weight_Deltas:
[0, -0.09099999999999994, -0.16799999999999987]

Iteration:2
Pred:0.8626075000000001
Error:0.018876699056249977
Delta:-0.13739249999999992
Weights:[0.1, 0.20180305125, -0.09667129]
Weight_Deltas:
[0, -0.08930512499999994, -0.1648709999999999]

Iteration:3
Pred:0.8651664353125001
Error:0.018180090166338207
Delta:-0.13483356468749985
Weights:[0.1, 0.20267946942046874, -0.09505328722375]
Weight_Deltas:
[0, -0.0876418170468749, -0.16180027762499982]

Weights:[0.1, 0.20267946942046874, -0.09505328722375]
Weight Deltas:[0, -0.0876418170468749, -0.16180027762499982]

一对多

一对多神经元结构：

一个输入对多个输出进行预测：

#coding="utf-8"

def scalar_ele_mul(number, vector):
    output = [0, 0, 0]
    assert (len(output) == len(vector))
    for i in range(len(vector)):
        output[i] = number * vector[i]
    return output

#权重值
weights = [0.3, 0.2, 0.9]

def neural_network(input, weights=weights):
    #使用函数预测
    pred = scalar_ele_mul(input,weights)
    return pred

def ele_mul(number, vector):
    output = [0, 0, 0]
    assert (len(output) == len(vector))
    for i in range(len(vector)):
        #误差与输入相乘
        output[i] = number * vector[i]
    return output

def main():
    #数据集
    wlrec = [0.65, 1.0, 1.0, 0.9]
    #对应的结果
    hurt = [0.1, 0.0, 0.0, 0.1]
    win = [1, 1, 0, 1]
    sad = [0.1, 0.0, 0.1, 0.2]
    true = [hurt[0], win[0], sad[0]]
    #准备预测的数据
    input = wlrec[0]
    for iter in range(3):
        # 第一组数据输入进行预测
        pred = neural_network(input, weights)
        #定义误差变量
        error = [0, 0, 0]
        delta = [0, 0, 0]
        for i in range(len(true)):
            # 预测值与真实值的误差平方
            error[i] = (pred[i] - true[i]) ** 2
            # 预测值与真实值的误差
            delta[i] = pred[i] - true[i]
        #权重的差值
        weight_deltas = scalar_ele_mul(input, weights)
    #改变率
    alpha = 0.01
    # 通过误差得到新的权重值
    for i in range(len(weights)):
        #以alpha的学习率更新权重
        weights[i] -= alpha * weight_deltas[i]
    print("Weights:" + str(weights))
    print("Weight Deltas:" + str(weight_deltas))

if __name__ == '__main__':
    main()

输出结果：

Weights:[0.29805, 0.19870000000000002, 0.89415]
Weight Deltas:[0.195, 0.13, 0.5850000000000001]

多对多

多对多神经元结构：

多个输入对多个输出进行预测:

#coding="utf-8"

#多对一神经网络
def w_sum(a, b):
    #断言：判断是否相等不相等抛出错误
    assert (len(a) == len(b))
    output = 0
    for i in range(len(a)):
        #权重和输入相乘放回预测值
        output += (a[i] * b[i])
    return output

def vect_mat_mul(vect,matrix):
     assert (len(vect) == len(matrix))
     output = [0,0,0]
     for i in range(len(vect)):
        output[i] = w_sum(vect,matrix[i])
     return output

#初始化输出
def zeros_matrix(a,b):
    out = []
    for i in range(a):
        x = []
        for i in range(b):
            x.append(0)
        out.append(x)
    return out

def outer_prod(vec_a, vec_b):
    #初始化输出也可以认为是构造初始化列表
    out = zeros_matrix(len(vec_a), len(vec_b))
    for i in range(len(vec_a)):
        for j in range(len(vec_b)):
            out[i][j] = vec_a[i] * vec_b[j]
    return out

#权重值
weights = [ [0.1, 0.1, -0.3],# hurt?
             [0.1, 0.2, 0.0], # win?
             [0.0, 1.3, 0.1] ]# sad?

def neural_network(input, weights=weights):
    #使用函数预测
    pred = vect_mat_mul(input,weights)
    return pred

def main():
    #数据集
    toes = [8.5, 9.5, 9.9, 9.0]
    wlrec = [0.65, 0.8, 0.8, 0.9]
    nfans = [1.2, 1.3, 0.5, 1.0]
    #对应的结果
    hurt = [0.1, 0.0, 0.0, 0.1]
    win = [1, 1, 0, 1]
    sad = [0.1, 0.0, 0.1, 0.2]
    #结果
    true = [hurt[0], win[0], sad[0]]
    #准备预测的数据
    input = [toes[0], wlrec[0], nfans[0]]
    # 第一组数据输入进行预测
    pred = neural_network(input, weights)
    #定义误差变量
    error = [0, 0, 0]
    delta = [0, 0, 0]
    for i in range(len(true)):
        # 预测值与真实值的误差平方
        error[i] = (pred[i] - true[i]) ** 2
        # 预测值与真实值的误差
        delta[i] = pred[i] - true[i]
    #权重的差值
    weight_deltas = outer_prod(input, delta)
    #改变率
    alpha = 0.01
    # 通过误差得到新的权重值
    for i in range(len(weights)):
        for j in range(len(weights[0])):
            weights[i][j] -= alpha * weight_deltas[i][j]
    print(weights)


if __name__ == '__main__':
    main()

输出结果：

Weights:[[0.061325, 0.1017, -0.373525], [0.0970425, 0.20013, -0.005622500000000002], [-0.0054600000000000004, 1.30024, 0.08962]]
Weight Deltas:[[3.8675000000000006, -0.1699999999999992, 7.352500000000001], [0.29575000000000007, -0.01299999999999994, 0.5622500000000001], [0.546, -0.023999999999999886, 1.038]]

知识了解

权重冻结

使一个权重为0，即相当于没有这个权重，这种方法叫做冻结权重。这是弹性固化权重神经网络（最近研发的最牛的神经网络之一）诞生由来。
四维图的2D切片视角，其中三个为权重，一个为error。这个是error平面：

在a权重被冻结的情况下，a的error正在同b、c降低，但是这并不是a点移动，而是曲线的移动，

深度学习和深度神经网络方面最顶尖的创新

1.神经元的创新（循环神经网络这一分支）

2.神经元之间的创新（残缺网络、卷积网络、胶囊网络等）

几乎所有的黑科技都是围绕着两个方面突破

此文为本人学习所创，如有错误请多多指教

联系QQ1135999353

黄朝阳98

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
grokkinDeepLearn Three

tesorflow2的简单使用实现代码：import tensorflow as tfimport numpy as npdef main(): #建立神经网络 models = tf.keras.Sequential() #增加神经元结构input_dim输入维度 units输出多少个值 models.add(tf.keras.layers.Dense(input_dim=1,units=2)) models.add(tf.keras.layers.D
复制链接

扫一扫