TensorFlow by Google神经网络深度学习的 Hello World Machine Learning Foundations: Ep #1

本文链接：https://blog.csdn.net/zgpeace/article/details/120170895

在这里插入图片描述
传统的编码逻辑，写股票价格/营收的实现

传统的游戏逻辑

传统编码逻辑和机器学习逻辑

传统编码模式去识别运动类型：速度判断

机器学习识别运动模式：图片识别

入参X，计算出参Y，传统的方法是，先找到规律 Y = 2X - 1 ,实现编码。
在这里插入图片描述
TensorFlow 实现。

在这里插入图片描述

在这里插入图片描述

bit.ly/tfw-lab1

1. 神经网络深度学习的 Hello World

就像每一个第一个应用程序一样，你应该从一些超级简单的东西开始，展示你的代码如何工作的整体脚手架。

在创建神经网络的情况下，我喜欢使用的样本是学习两个数字之间关系的样本。因此，例如，如果您正在为这样的函数编写代码，那么您已经知道“规则”——

float my_function(float x){
    float y = (3 * x) + 1;
    return y;
}

那么你将如何训练一个神经网络来完成同样的任务呢？使用数据！通过用一组 X 和一组 Y 喂养它，它应该能够弄清楚它们之间的关系。

这显然是一个与您可能习惯的范式截然不同的范式，所以让我们一步一步地了解它。

1.1 导入依赖库

让我们从我们的导入依赖库开始。在这里，我们导入 TensorFlow 并将其称为 tf 以方便使用。

然后我们导入一个名为 numpy 的库，它帮助我们轻松快速地将数据表示为列表。

将神经网络定义为一组 Sequential 层的框架称为 keras，因此我们也将其导入。

import tensorflow as tf
import numpy as np
from tensorflow import keras

1.2 定义和编译神经网络

接下来我们将创建最简单的神经网络。它有 1 层，该层有 1 个神经元，它的输入形状只有 1 个值。

model = tf.keras.Sequential([keras.layers.Dense(units=1, input_shape=[1])])

现在我们编译我们的神经网络。当我们这样做时，我们必须指定 2 个函数，一个损失函数和一个优化器。

如果你看过很多机器学习数学，这里是它通常使用的地方，但在这种情况下，它很好地封装在函数中。但是这里发生了什么——让我们解释一下……

我们知道，在我们的函数中，数字之间的关系是 y=3x+1。

当计算机试图“学习”这一点时，它会进行猜测……也许 y=10x+10。LOSS 函数根据已知的正确答案来衡量猜测的答案，并衡量它的表现好坏。

然后它使用 OPTIMIZER 函数进行另一个猜测。根据损失函数的运行情况，它将尝试最小化损失。那时它可能会想出像 y=5x+5 这样的东西，虽然仍然很糟糕，但更接近正确的结果（即损失更低）

它将为您将很快看到的 EPOCHS 数量重复此操作。但首先，我们告诉它如何使用“均方误差”作为损失和“随机梯度下降”作为优化器。您还不需要了解这些的数学原理，但您可以看到它们是有效的！😃

随着时间的推移，您将学习针对不同场景的不同且适当的损失和优化器函数。

model.compile(optimizer='sgd', loss='mean_squared_error')

1.3 提供数据

接下来我们将输入一些数据。在这种情况下，我们采用 6 xs 和 6ys。你可以看到它们之间的关系是y=2x-1，所以x=-1，y=-3等等。

一个名为“Numpy”的 Python 库提供了许多数组类型的数据结构，这些数据结构是事实上的标准方法。我们通过将值指定为 np.array[] 来声明我们要使用这些

xs = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-2.0, 1.0, 4.0, 7.0, 10.0, 13.0], dtype=float)

1.4 训练神经网络

训练神经网络的过程，它“学习”Xs 和 Ys 之间的关系是在model.fit 调用中。这是它将通过我们上面谈到的循环的地方，进行猜测，测量它的好坏（也就是损失），使用优化器进行另一个猜测等。它将按照您的时代数进行指定。运行此代码时，您会在右侧看到损失。

model.fit(xs, ys, epochs=500)

Epoch 1/500
6/6 [==============================] - 0s 16ms/step - loss: 57.4875
Epoch 2/500
6/6 [==============================] - 0s 173us/step - loss: 45.2285
Epoch 3/500
6/6 [==============================] - 0s 171us/step - loss: 35.5836
Epoch 4/500
6/6 [==============================] - 0s 195us/step - loss: 27.9955
Epoch 5/500

好的，现在你有一个经过训练的模型来学习 X 和 Y 之间的关系。你可以使用model.predict方法让它为以前未知的 X 计算出 Y。所以，例如，如果 X = 10 ，你认为 Y 会是什么？在运行此代码之前先猜测一下：

print(model.predict([10.0]))

[[ 31.00025749]]

你可能已经想到了 31，对吧？但它最终有点结束。你认为这是为什么？

请记住，神经网络处理概率，因此给定我们提供给 NN 的数据，它计算出 X 和 Y 之间的关系为 Y=3X+1 的概率非常高，但只有 6 个数据点我们可以不知道。因此，10 的结果非常接近 31，但不一定是 31。

当您使用神经网络时，您会看到这种模式反复出现。您几乎总是处理概率，而不是确定性，并且会进行一些编码以根据概率确定结果是什么，尤其是在分类方面。

2. 预测房价

bit.ly/tfw-ex1a

在本练习中，您将尝试构建一个神经网络，根据一个简单的公式预测房屋的价格。

所以，想象一下，如果房子定价像每间卧室的房子成本 50k + 50k 一样简单，那么 1 居室的房子成本 100k，2 居室的房子成本 150k 等等。

您将如何创建一个学习这种关系的神经网络，以便预测 7 间卧室的房子的成本接近 40 万等。

提示：如果您降低房价，您的网络可能会运行得更好。你不必给出 400 的答案…创建一些预测数字 4 的东西可能会更好，然后你的答案是“成百上千”等等。

import tensorflow as tf
import numpy as np
from tensorflow import keras
model = tf.keras.Sequential([keras.layers.Dense(units=1, input_shape=[1])])
model.compile(optimizer='sgd', loss='mean_squared_error')
xs = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], dtype=float)
ys = np.array([1.0, 1.5, 2.0, 2.5, 3.0, 3.5], dtype=float)
model.fit(xs, ys, epochs=1000)
print(model.predict([7.0]))

Epoch 995/1000
1/1 [==============================] - 0s 4ms/step - loss: 1.8491e-06
Epoch 996/1000
1/1 [==============================] - 0s 10ms/step - loss: 1.8357e-06
Epoch 997/1000
1/1 [==============================] - 0s 4ms/step - loss: 1.8222e-06
Epoch 998/1000
1/1 [==============================] - 0s 4ms/step - loss: 1.8090e-06
Epoch 999/1000
1/1 [==============================] - 0s 5ms/step - loss: 1.7958e-06
Epoch 1000/1000
1/1 [==============================] - 0s 5ms/step - loss: 1.7828e-06
[[4.001926]]