本教程深入探讨使用 Matplotlib 库创建不同类型的条形图。引入了创建条形图的专用函数“bar”，它将每个条形的 x 坐标和每个条形的高度作为输入参数。通过调整可选参数，用户可以创建各种效果，甚至使用“barh”功能生成水平条。本教程还介绍了在同一个图表上绘制多个条形图以及使用“bar”函数中的特殊参数创建堆叠条形图。此外，该视频还简要介绍了使用“饼图”功能创建饼图。
本教程中解释了 Matplotlib 数据可视化中使用的各种函数。第一个函数是直方图，它是概率分布的图形表示。讨论了“hist”函数及其参数，使用户可以轻松地将数据绘制为直方图。涵盖的第二个功能是箱线图，它有助于比较值分布。该视频解释了箱线图的组成部分，包括数据集的四分位数、中位数、平均值和统计量，并演示了如何使用“箱线图”函数生成它们。最后，本教程介绍了通过使用不同的颜色和样式来更改绘图，例如使用三元组、四元组或 HTML 颜色名称定义颜色，以及设置曲线图的颜色。
00:10:00 该视频教程介绍了如何使用 Matplotlib 库创建不同类型的条形图。 bar函数是创建条形图的专用函数，它以每个条形的x坐标和每个条形的高度作为输入参数。通过调整可选参数，我们可以创建不同的效果，甚至使用 bar h 函数创建水平条。本教程还介绍了如何在同一个图表上绘制多个条形图以及如何使用 bar 函数中的特殊参数绘制堆叠条形图。最后，本教程涉及使用 pie 函数创建饼图。
In this FREE course let's learn the basics of creating data visualizations with the grandfather of visualization libraries in Python, matplotlib.LogikBot - A...
An updated deep learning introduction using Python, TensorFlow, and Keras.Text-tutorial and notes: https://pythonprogramming.net/introduction-deep-learning-p...
Welcome to a tutorial where we'll be discussing how to load in our own outside datasets, which comes with all sorts of challenges!First, we need a dataset. L...
Welcome to a tutorial where we'll be discussing Convolutional Neural Networks (Convnets and CNNs), using one to classify dogs and cats with the dataset we bu...
Welcome to part 4 of the deep learning basics with Python, TensorFlow, and Keras tutorial series. In this part, what we're going to be talking about is Tenso...
Welcome to part 5 of the Deep learning with Python, TensorFlow and Keras tutorial series. In the previous tutorial, we introduced TensorBoard, which is an ap...
In this part, we're going to cover how to actually use your model. We will us our cats vs dogs neural network that we've been perfecting.Text tutorial and sa...
In this part we're going to be covering recurrent neural networks. The idea of a recurrent neural network is that sequences and order matters. For many opera...
Welcome to part 8 of the Deep Learning with Python, Keras, and Tensorflow series. In this tutorial, we're going to work on using a recurrent neural network t...
for i in DF.values: # Create a deque object with a maximum length of max_len if len(prev_days) < max_len: prev_days.append([n for n in i[:-1]]) else: # Append the current values to prev_days prev_days.append([n for n in i[:-1]]) # Add the sequence to the sequential_data list sequential_data.append([np.array(prev_days), i[-1]]) # Remove the oldest sequence from prev_days prev_days.popleft()
# Normalize the data scaler = MinMaxScaler() train_x = scaler.fit_transform(train_x.reshape(train_x.shape[0], -1)) val_x = scaler.transform(val_x.reshape(val_x.shape[0], -1))
# Reshape the data back to its original shape train_x = train_x.reshape(train_x.shape[0], train_x.shape[1], -1) val_x = val_x.reshape(val_x.shape[0], val_x.shape[1], -1)
# Define the optimizer and compile the model optimizer = tf.keras.optimizers.Adam(learning_rate=0.001) model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
# Define early stopping early_stopping = tf.keras.callbacks.EarlyStopping(patience=3)
# Train the model history = model.fit(train_x, train_y, validation_data=(val_x, val_y), epochs=20, callbacks=[early_stopping])
import numpy as np import tensorflow as tf from sklearn.preprocessing import MinMaxScaler from tensorflow.keras.models import Sequential from tensorflow.keras.layers import LSTM, Dropout, BatchNormalization, Dense
Leading up to this tutorial, we've learned about recurrent neural networks, deployed one on a simpler dataset, and now we are working on doing it with a more...
1 小时内使用 matplotlib 实现数据可视化
1 小时内使用 matplotlib 实现数据可视化
在本视频中，讲师介绍了数据可视化在机器学习中的重要性，并解释了它如何帮助理解大量收集的数据。本课程涵盖了用于数据可视化的两个主要 Python 库 Matplotlib 和 Seaborn。
讲师表示，该课程主要是为想要学习Python的机器学习工程师、数据工程师和数据科学家而设计的。为了说明 Matplotlib 的用法，提供了绘制曲线的简单示例。 Matplotlib 的理念围绕利用现有语言 Python 展开，Python 已成为构建机器学习模型和处理数据的标准。通过将 Matplotlib 与其他 Python 软件包相结合，用户可以利用可用于各种任务的众多软件包。
该视频强调了将 NumPy 包与 Matplotlib 一起使用进行科学计算的重要性。虽然 Matplotlib 可以在没有 NumPy 的情况下工作，但利用 NumPy 可以显着节省时间和精力。 NumPy 提供了强大的多维数组对象和用于操作它的函数。视频中演示了一个示例，其中使用 NumPy 生成具有 100 个点的曲线来计算 x 和 y 坐标。事实证明，这种方法比使用纯 Python 执行操作要快得多。此外，该视频还介绍了在同一个图表上绘制两条曲线以进行比较、通过使用 Python 代码提取和组织数据来绘制文件中的数据，以及以线性方式绘制点而不是项目。
本教程深入探讨使用 Matplotlib 库创建不同类型的条形图。引入了创建条形图的专用函数“bar”，它将每个条形的 x 坐标和每个条形的高度作为输入参数。通过调整可选参数，用户可以创建各种效果，甚至使用“barh”功能生成水平条。本教程还介绍了在同一个图表上绘制多个条形图以及使用“bar”函数中的特殊参数创建堆叠条形图。此外，该视频还简要介绍了使用“饼图”功能创建饼图。
本教程中解释了 Matplotlib 数据可视化中使用的各种函数。第一个函数是直方图，它是概率分布的图形表示。讨论了“hist”函数及其参数，使用户可以轻松地将数据绘制为直方图。涵盖的第二个功能是箱线图，它有助于比较值分布。该视频解释了箱线图的组成部分，包括数据集的四分位数、中位数、平均值和统计量，并演示了如何使用“箱线图”函数生成它们。最后，本教程介绍了通过使用不同的颜色和样式来更改绘图，例如使用三元组、四元组或 HTML 颜色名称定义颜色，以及设置曲线图的颜色。
该视频继续解释如何使用“颜色”参数向散点图、条形图和饼图添加颜色。此参数使用户能够控制单个点的颜色或更改所有点的公共颜色。该视频还涉及将库作为模块导入、使用别名以简化编码以及阐明变量的表示。需要强调的是，Matplotlib 和 Python 中几乎所有内容都涉及函数，例如“pi”函数和“show”函数。
接下来，本教程将介绍创建箱形图、标记和线条形状时的自定义配色方案和线条图案。它演示了使用预定义形状创建自定义标记以及使用数学文本符号定义自定义标记。此外，它还解释了如何使用集中配置对象轻松更改 Matplotlib 的默认设置，使用户能够适应不同的使用环境的视觉样式，例如具有黑色背景和白色注释。
演示者解释了如何使用 Matplotlib 中的“savefig”函数将图形保存到文件中。它们还包括向图表添加注释，包括标题、x 轴和 y 轴标签、边界框和箭头。该视频演示了添加这些注释以增强图形的视觉清晰度和理解的过程。此外，它还展示了如何在 Matplotlib 中手动控制刻度间距以进行精确调整。该视频重点介绍了 Matplotlib 中用于注释图形的各种函数，并使它们对读者来说更加不言自明。
接下来，讲师讨论了 Matplotlib 的数据可视化，并介绍了 Seaborn——Matplotlib 的高级接口。与 Matplotlib 相比，Seaborn 提供了不同的参数和功能。讲师展示如何使用 Seaborn 的内置数据集和颜色图创建可视化。该视频最后展示了创建因子图和利用彩色图绘制数据的示例。通过这些示例，观众可以深入了解如何使用 Matplotlib 和 Seaborn 中的不同功能和工具来增强数据可视化技能。
该视频解释了如何使用 Seaborn 的“set_context”函数缩放绘图。此功能允许用户根据绘图显示的上下文来控制绘图元素，例如大小。然后它阐明了 Seaborn 两种函数之间的区别：轴级函数和图形级函数。轴级别函数在轴级别上运行并返回轴对象，而图形级别函数创建包含以有意义的方式组织的轴的绘图。最后，该视频提供了有关使用 Matplotlib 轴子图对象设置箱线图轴的指导。
这个综合视频教程涵盖了与使用 Matplotlib 和 Seaborn 进行数据可视化相关的广泛主题。首先介绍数据可视化在机器学习中的重要性以及 Matplotlib 作为强大库的使用。它演示了如何绘制曲线、创建条形图、生成直方图和箱线图以及自定义颜色、标记和线条样式。本教程还介绍了保存图表、添加注释和操作刻度间距。此外，它还引入了 Seaborn 作为替代可视化工具，具有自己的一组特性和功能。通过学习本教程，观看者可以增强他们的数据可视化技能，并使用这些强大的 Python 库有效地传达他们的发现。
使用 Python、TensorFlow 和 Keras 进行深度学习教程
使用 Python、TensorFlow 和 Keras 进行深度学习教程
大家好，欢迎来到备受期待的关于深度学习和 Python with TensorFlow 的更新，以及新的 Chaos 教程。距离我上次介绍 Python 的基础深度学习已经过去两年多了，在这段时间里，已经取得了重大进展。进入深度学习和使用深度学习模型变得更加简单和容易。
如果您有兴趣深入研究较低级别的 TensorFlow 代码和复杂的细节，您仍然可以参考旧视频。但是，如果您的目标是开始深度学习，则不再需要经历这些，因为我们现在拥有用户友好的高级 API，例如位于 TensorFlow 之上的 Chaos。这些 API 使深度学习变得异常简单，即使没有深度学习的先验知识，任何人都可以跟进。
在本教程中，我们将快速浏览神经网络。首先，让我们了解神经网络的核心组件。任何机器学习模型（包括神经网络）的主要目标是将输入映射到输出。例如，给定输入 X1、X2 和 X3，我们的目标是确定输出是否对应于狗或猫。在这种情况下，输出层由两个代表狗或猫可能性的神经元组成。
为了实现这种映射，我们可以采用单个隐藏层，其中每个输入 X1、X2 和 X3 连接到隐藏层中的神经元。这些连接中的每一个都具有与其关联的唯一权重。然而，如果我们将自己限制在单个隐藏层，则输入和输出之间的关系将是线性的。为了捕获复杂问题中常见的非线性关系，我们需要两个或更多隐藏层。具有两个或多个隐藏层的神经网络通常称为深度神经网络。
让我们添加另一个隐藏层，将其与前一层完全连接。层之间的每个连接都有其独特的权重。最终，输出来自最后一层，其中与输出层的每个连接都拥有唯一的权重。在单个神经元级别上，神经元接收输入，这些输入可以是输入层值（X1、X2、X3）或来自其他神经元的输入。考虑到这些输入的相关权重，对这些输入进行求和。此外，还应用激活函数来模拟神经元是否放电。常见的激活函数包括阶跃函数或 sigmoid 函数，它们返回 0 到 1 之间的值。在我们的神经网络中，输出层使用 sigmoid 激活函数，为每个类别（狗或猫）分配概率。然后使用 Arg max 函数根据最高概率确定预测类别。
现在我们对神经网络有了基本的了解，让我们继续使用 TensorFlow 构建一个神经网络。首先，通过运行命令“pip install --upgrade tensorflow”确保您已安装 TensorFlow。您可以将 TensorFlow 导入为“tf”并使用“tf.version”检查当前版本。对于本教程，建议使用 Python 3.6 或更高版本，尽管 TensorFlow 预计将来支持 Python 3.7 及更高版本。
接下来，我们将导入要使用的数据集。我们将利用 MNIST 数据集，该数据集由 28x28 的手写数字图像组成，范围从 0 到 9。这些图像将输入神经网络，网络将预测相应的数字。我们将数据集分为训练和测试变量：X_train、Y_train、X_test 和 Y_test。
为了确保更好的性能，我们将对数据进行标准化。图像的像素值当前范围为 0 到 255，因此我们将使用 TF.keras.utils.normalize 函数将它们缩放到 0 到 1 之间。
为了构建模型，我们将使用高级 API Chaos，它简化了在 TensorFlow 中创建和训练神经网络的过程。 Chaos 提供了一种称为 Sequential 的顺序模型，它允许我们逐层堆叠。
以下是如何使用 Chaos 创建神经网络模型的示例：
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense
# Create a sequential model
model = Sequential()
# Add a flatten layer to convert the input into a 1D array
model.add(Flatten(input_shape=(28, 28)))
# Add a dense layer with 128 neurons and ReLU activation
model.add(Dense(128, activation='relu'))
# Add another dense layer with 10 neurons for the output and softmax activation
model.add(Dense(10, activation='softmax'))
# Compile the model
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
在上面的代码中，我们从 TensorFlow 和 Chaos 导入必要的模块。我们创建一个 Sequential 模型并使用 add 方法向其添加层。第一层是 Flatten 层，它将 2D 输入（28x28 图像）转换为 1D 数组。然后我们添加一个包含 128 个神经元和 ReLU 激活的密集层。最后，我们添加一个具有 10 个神经元（对应于 10 个数字）和 softmax 激活的输出层。
定义模型后，我们使用compile方法对其进行编译。我们指定优化器（在本例中为“adam”）、损失函数（用于多类分类的“sparse_categorical_crossentropy”）以及在训练期间评估的指标。
现在我们已经定义并编译了模型，我们可以继续在 MNIST 数据集上训练它。我们将使用 fit 方法来训练模型。
# Train the model model.fit(X_train, Y_train, epochs= 10 , validation_data=(X_test, Y_test))
在上面的代码中，我们将训练数据（X_train 和 Y_train）以及要训练的纪元数传递给 fit 方法。我们还提供验证数据（X_test 和 Y_test）来评估模型在训练期间未见过的数据上的性能。
训练完模型后，我们可以使用predict方法进行预测：
# Make predictions predictions = model.predict(X_test)
在上面的代码中，我们将测试数据（X_test）传递给预测方法，它返回每个类的预测概率。
这是在 TensorFlow 中使用 Chaos 构建和训练神经网络的简要概述。您可以进一步探索不同的层、激活函数、优化器和其他参数来自定义您的模型。
与构建和训练神经网络相关的其他技术和概念。
正则化技术：
Dropout：Dropout是一种用于防止过度拟合的正则化技术。它在训练期间的每次更新时随机将一部分输入单元设置为 0，这有助于防止模型过于依赖任何特定的特征集。
L1 和 L2 正则化：L1 和 L2 正则化是用于向损失函数添加惩罚以防止网络中权重过大的技术。 L1 正则化将权重的绝对值添加到损失函数中，鼓励稀疏性，而 L2 正则化将平方权重添加到损失函数中，鼓励使用较小的权重。
高级激活功能：
Leaky ReLU：Leaky ReLU 是一种激活函数，通过允许负输入的斜率较小来解决“垂死 ReLU”问题。当输入为负时，它会引入一个小的负斜率，这有助于防止神经元在训练过程中死亡。
指数线性单元 (ELU)：ELU 是一种激活函数，可平滑负输入的输出，从而允许激活呈现负值。它已被证明有助于改善神经网络的学习并减少对积极价值观的偏见。
Swish：Swish 是一种激活函数，可在线性函数和 sigmoid 函数之间执行平滑插值。事实证明，在某些情况下，与 ReLU 和 sigmoid 等其他激活函数相比，它可以提供更好的结果。
迁移学习：迁移学习是一种利用预先训练的模型来解决新任务或提高模型在相关任务上的性能的技术。您可以使用预先训练的模型作为起点，并根据您的特定任务或数据集对其进行微调，而不是从头开始训练模型。当您的特定任务的数据有限时，这特别有用。
超参数调优：超参数是模型不学习但影响学习过程的参数，例如学习率、批量大小、层数等。调整这些超参数可以显着影响模型的性能。网格搜索、随机搜索和贝叶斯优化等技术可用于系统地搜索超参数空间并找到最佳组合。
模型评估：评估模型的性能对于评估其有效性至关重要。分类任务的常见评估指标包括准确率、精确率、召回率、F1 分数和受试者工作特征曲线下面积 (ROC AUC)。根据当前的问题和数据的性质选择适当的指标非常重要。
处理不平衡的数据集：当类的分布不均匀时，就会出现不平衡的数据集，这可能会导致模型出现偏差。对少数类进行过采样、对多数类进行欠采样或结合使用两者等技术可以帮助解决此问题。此外，利用精度、召回率和 F1 分数等评估指标可以更好地了解模型在不平衡数据集上的性能。
请记住，构建和训练神经网络是一个迭代过程。它涉及实验、微调和持续改进，以达到预期的结果。
加载您自己的数据 - Python、TensorFlow 和 Keras 的深度学习基础知识 p.2
加载您自己的数据 - Python、TensorFlow 和 Keras 的深度学习基础知识 p.2
欢迎大家来到 Karros 中有关 Python TensorFlow 的深度学习教程的第 2 部分。在本教程中，我们将重点关注加载外部数据集。具体来说，我们将使用 Microsoft 的猫和狗数据集，该数据集最初是 Kaggle 挑战赛。目标是训练神经网络来识别图像中是否包含猫或狗。
首先，请从 Microsoft 下载猫和狗数据集。下载并解压数据集后，您应该看到两个目录：“cat”和“dog”。这些目录分别包含猫和狗的图像。每个目录应该有大量样本，大约 12,500 个，为训练我们的模型提供充足的例子。
现在让我们继续编码部分。我们需要导入几个库：numpy 作为 np、matplotlib.pyplot 作为 plt、OpenCV 作为 cv2。如果您没有安装这些库，可以使用 pip 来安装它们。
接下来，我们将定义数据集所在的数据目录。您可以相应地指定数据集的路径。我们还将类别定义为“狗”和“猫”以匹配数据集中的目录。
我们将使用操作系统库迭代每个类别和相应的图像。对于每个图像，我们将使用 cv2 库将其转换为灰度。我们选择灰度是因为我们相信在这个特定任务中颜色对于区分猫和狗来说并不重要。
为了可视化图像，我们将使用 matplotlib.pyplot。我们将使用 plt.imshow 和灰度颜色图显示示例图像。此步骤允许我们确认图像已正确加载。
验证图像后，我们将继续将它们调整为统一的形状。我们需要确定目标尺寸，例如 50x50 像素，以确保一致性。我们将使用 cv2.resize 函数调整图像大小并存储调整大小的图像数组。
现在，我们将创建训练数据集。我们初始化一个名为“training_data”的空列表，并定义一个名为“create_training_data”的函数。在此函数中，我们迭代图像并使用“类别”列表中类别的索引分配数字标签（0 表示狗，1 表示猫）。
对于每个图像，我们将其大小调整为所选的目标大小。我们将调整大小的图像数组及其相应的标签附加到training_data列表中。我们还处理与数据集中损坏图像相关的任何潜在异常。
创建训练数据集后，我们应该检查数据的平衡。在这样的二元分类任务中，每个类别的样本数量必须相同（50% 的狗和 50% 的猫）。不平衡的数据可能导致模型预测出现偏差。如果您的数据不平衡，您可以在训练期间使用类别权重来缓解此问题。
为了确保随机性并防止模型学习图像的顺序，我们使用 random.shuffle 函数对训练数据进行打乱。
现在我们的数据已经打乱，我们可以将其打包到特征（X）和标签（Y）的变量中。我们初始化 X 和 Y 的空列表，并迭代训练数据，将特征和标签附加到各自的列表中。最后，我们将 X 转换为 NumPy 数组，并使用 np.array 和每个特征的形状对其进行重塑。
至此，我们已经准备好用于训练神经网络的数据。我们现在准备好继续进行进一步的步骤，例如将数据拆分为训练集和验证集、构建模型并使用 TensorFlow 对其进行训练。
负1是一个占位符，它根据数组的长度和每个元素的形状自动计算大小。因此，在本例中，我们将 X 数组重塑为 (-1, image_size, image_size) 的形状。这确保了数据以正确的格式输入神经网络。
接下来，我们需要标准化图像的像素值。目前，像素值的范围是0到255，代表灰度的强度。当输入数据标准化时，神经网络通常表现更好，这意味着值被缩放到更小的范围。我们可以通过将像素值除以 255.0 来实现此目的，这会将它们缩放到 0 到 1.0 之间。这可以使用以下代码来完成：
x = x / 255.0
卷积神经网络 - Python、TensorFlow 和 Keras 的深度学习基础知识 p.3
卷积神经网络 - Python、TensorFlow 和 Keras 的深度学习基础知识 p.3
大家好，欢迎来到我们使用 Python、TensorFlow 和 Keras 进行深度学习教程系列的第三部分。在本视频中，我们将重点介绍卷积神经网络 (CNN) 以及如何使用我们在上一个视频中构建的数据集应用它们对狗和猫进行分类。
在深入研究 CNN 之前，我们先快速了解一下它们的工作原理以及它们为何对图像数据有用。 CNN 涉及几个步骤：卷积、池化，然后是更多的卷积和池化。卷积背后的主要思想是从图像中提取有用的特征。我们使用卷积窗口（通常表示为矩阵（例如，3x3））来扫描图像并将窗口内的信息简化为单个值。然后窗口移动并重复此过程多次。步幅决定了窗口移动的程度，也可以调整。
使用 Keras，我们可以指定窗口大小，并且大多数其他细节都会自动处理。如果您想更深入地研究深度学习的复杂性，我建议您查看“实用机器学习”教程系列，其中更详细地解释了内部工作原理，特别是对于原始 TensorFlow 代码。
卷积层的输出是从图像中提取的一组特征。然后，这些特征通常会通过池化层，最常见的类型是最大池化。最大池化选择窗口内的最大值并重复移动它，从而有效地对数据进行下采样。
CNN 背后的更高层次的想法是，随着网络的深入，它们逐渐从图像中提取更复杂的特征。初始层可能识别边缘和线条，而更深的层可能识别更复杂的形状，如圆形或正方形。最终，网络可以学习识别特定的对象或模式。
为了实现 CNN，我们需要导入必要的库。我们导入 TensorFlow 和我们将使用的 Keras 模块，例如 Sequential、Dense、Dropout、Activation、Conv2D 和 MaxPooling2D。我们还导入 pickle 来加载我们的数据集。
在将数据输入神经网络之前，我们应该考虑对其进行标准化。在我们的例子中，我们可以通过除以 255 来缩放像素数据，因为像素值的范围从 0 到 255。或者，我们可以使用 Chaos.utils 中的归一化函数来实现更复杂的归一化场景。
接下来，我们开始使用 Sequential API 构建模型。我们添加一个包含 64 个单元和 3x3 窗口大小的 Conv2D 层。 input_shape 使用 X.shape 动态设置。然后，我们使用修正线性激活函数 (ReLU) 添加激活层。接下来，我们添加一个窗口大小为 2x2 的最大池化层。
我们通过添加另一个 Conv2D 层和相应的最大池化层来重复此过程。至此，我们就有了一个 2D 卷积神经网络。
为了将提取的特征传递到全连接层，我们需要展平数据。我们在添加具有 64 个节点的最终 Dense 层之前添加 Flatten 层。最后，我们添加一个具有单个节点的输出层并指定激活函数，该函数可以是分类函数或二进制函数。
我们通过指定损失函数（分类或二元交叉熵）、优化器（例如 Adam）和评估模型性能的指标（例如准确性）来编译模型。
为了训练模型，我们使用 fit 方法，传入输入数据 X 和标签 Y。我们还可以指定批量大小（例如 32）。
我们将使用以下代码来训练模型：
model.fit(X, Y, batch_size= 32 , validation_split= 0.1 )
此代码将使用输入数据 X 和相应的标签 Y 来训练模型。我们将批量大小设置为 32，这意味着模型在训练期间一次将处理 32 个样本。 validation_split 参数设置为 0.1，这意味着在训练模型时将使用 10% 的数据进行验证。
模型训练完成后，我们可以使用测试数据评估其性能。我们可以使用以下代码来评估模型：
model.evaluate(X_test, Y_test)
这里，X_test和Y_test分别代表测试数据和标签。此代码将返回模型在测试数据上的损失值和准确性。
评估模型后，我们可以用它来对新的、未见过的数据进行预测。我们可以使用predict()函数来获取新数据的预测标签。这是一个例子：
predictions = model.predict(X_new)
predicted_labels = np.argmax(predictions, axis= 1 )
就是这样！您现在已经训练了一个卷积神经网络模型来对狗和猫进行分类，并使用它来对新数据进行预测。请记住保存训练后的模型以供将来需要时使用。
使用 TensorBoard 分析模型 - 使用 Python、TensorFlow 和 Keras 进行深度学习 p.4
使用 TensorBoard 分析模型 - 使用 Python、TensorFlow 和 Keras 进行深度学习 p.4
欢迎大家来到“Python 深度学习：TensorFlow 和 Keras”教程系列的第 4 部分。在本视频和下一个视频中，我们将讨论如何使用 TensorBoard 分析和优化我们的模型。 TensorBoard 是一个强大的工具，使我们能够可视化模型随时间的训练情况。其主要目的是帮助我们了解模型性能的各个方面，例如准确性、验证准确性、损失和验证损失。此外，TensorBoard 中还有更多高级功能，我们可能会在未来的教程中探索。
在深入研究 TensorBoard 之前，让我们先讨论一个小细节。尽管对于本教程来说并不重要，但我想指出，即使是小型模型也往往会消耗大量 GPU 内存。如果您计划同时运行多个模型，则可以指定每个模型应使用的 GPU 内存的一部分。通过这样做，您可以避免运行多个模型或遇到内存限制时的潜在问题。例如，我通常将模型设置为使用三分之一的 GPU 内存。事实证明，这种方法在同时运行多个模型时非常有用，例如在涉及对象检测和自动驾驶的“Python Plays GTA”系列中。这只是一个方便的技巧，可以为您节省一些时间并减少麻烦。
现在，让我们继续主题。我要解决的第一件事是在密集层之后添加激活函数。最初没有将其包括在内是我的一个疏忽。添加激活函数是必不可少的，因为如果没有它，致密层就会变成线性激活函数，这不适合我们的目的。我们希望避免回归并确保我们的模型表现最佳。因此，让我们通过在致密层之前插入激活函数来快速解决这个问题。
进行修正后，我们应该观察到准确性的显着提高。在训练模型时，让我们花点时间浏览 TensorFlow 文档并了解各种可用的 Keras 回调。在我们的例子中，我们将使用 TensorBoard 回调与 TensorBoard 进行交互。然而，值得注意的是，还有其他有用的回调，例如基于特定参数的提前停止、学习率调度和模型检查点。当您想要以特定时间间隔（例如最佳损失或验证准确性）保存模型时，模型检查点特别有价值。现在，让我们重点关注 TensorBoard 回调，但我可能会在以后的视频中简要介绍其他回调。
要使用 TensorBoard 回调，我们需要从 TensorFlow 的 Keras 回调模块导入它。添加以下代码行以导入 TensorBoard：
from tensorflow.keras.callbacks import TensorBoard
现在我们已经导入了必要的模块，让我们执行一些内务处理。给模型起一个有意义的名称始终是一个好习惯，尤其是在使用多个模型时。在这种情况下，我们可以将模型命名为“cats_vs_dogs_CNN_64x2”。此外，我们在名称中添加时间戳以确保唯一性。在重新训练模型或避免与模型版本混淆时，包含时间戳非常有用。因此，在代码的开头，我们定义模型名称和时间戳，如下所示：
import time model_name = f"cats_vs_dogs_CNN_64x2_ { int (time.time())} "
tensorboard_callback = TensorBoard(log_dir= f"logs/ {model_name} " )
此外，张量板允许我们通过提供训练过程的可视化来分析和优化我们的模型。它主要关注准确性、验证准确性、损失和验证损失等指标。这些指标帮助我们了解模型随着时间的推移表现如何，并确定需要改进的领域。虽然准确性和损耗通常受到监控，但张量板提供了我们将来可能会探索的更高级的功能。
要开始使用张量板，我们首先需要对代码进行少量添加。虽然对于本教程来说并不重要，但值得一提。通过添加几行代码，我们可以为我们的模型分配特定部分的 GPU 内存。当同时运行多个模型或遇到 VRAM 问题时，这非常有用。它允许我们控制 GPU 分配并避免潜在的崩溃或内存溢出。在我们的例子中，我们为模型分配了三分之一的 GPU。这可以确保顺利执行并防止在与其他模型或项目一起使用时出现任何冲突。
接下来，让我们重点关注张量板的实现。首先，我们需要导入必要的依赖项。我们从“tensorflow.keras.callbacks”包中导入“tensorboard”模块。该模块提供张量板的回调功能。
接下来，我们要为我们的模型指定一个有意义的名称。使用多个模型时，为每个模型指定一个不同的名称至关重要。它帮助我们跟踪实验并避免任何混乱。在本例中，我们将模型命名为“cat's_first_dog_CNN_64x2_good_enough”。此外，我们使用当前时间值向名称添加时间戳。这确保了唯一性并防止模型的任何意外覆盖。
命名模型后，我们可以定义张量板回调对象。我们创建“TensorBoard”类的实例并将其分配给变量“tensorboard”。我们将日志目录路径传递给构造函数。日志目录是张量板存储与我们的模型相关的日志和数据的地方。我们使用字符串格式将模型名称包含在日志目录路径中。
一旦我们准备好回调对象，我们就可以将其合并到我们的模型训练过程中。在模型的“fit”方法中，我们将回调对象作为列表传递给“callbacks”参数。在这种情况下，我们只有一个回调，即张量板回调。但是，值得注意的是，如果需要，您可以在列表中包含多个回调。
集成回调后，我们现在可以训练我们的模型。在此示例中，我们将纪元数设置为 10。但是，您可以根据您的要求随意调整纪元数。当模型训练时，张量板将开始根据指定的指标生成日志和可视化结果。
要查看运行中的张量板，我们需要打开命令窗口或终端并导航到包含日志文件的目录。进入正确的目录后，我们通过在命令提示符中键入“tensorboard --logdir messages”来运行张量板命令。此命令启动张量板服务器并提供一个本地 URL，我们可以在其中访问张量板接口。
启动 Tensor Board 后，我们可以打开 Web 浏览器并输入命令提示符提供的 URL。这将显示张量板界面，我们可以在其中可视化模型的训练进度。该界面显示各种图表，包括样本内准确率、样本内损失、样本外准确度和样本外损失。我们分析这些指标来监控模型的性能并就其优化做出明智的决策。
通过观察图表，我们可以识别模型行为的模式和趋势。例如，如果验证损失开始增加，而验证准确性保持稳定或下降，则表明过度拟合。另一方面，如果验证准确性和损失随着时间的推移而提高，则表明模型正在有效地学习。
Tensor board 为分析和优化模型提供了强大的平台。其可视化为培训过程提供了宝贵的见解并促进决策。通过利用张量板，我们可以简化模型开发流程并取得更好的结果。
在本教程系列的下一部分中，我们将深入研究张量板的高级功能，包括直方图、分布和嵌入。这些功能提供了进一步的粒度，使我们能够更全面地了解我们的模型。请继续关注下一个视频，我们将在其中探索这些令人兴奋的功能。
这就是本教程的内容。感谢您的观看，我们将在下一个视频中见到您！
使用 TensorBoard 进行优化 - 使用 Python、TensorFlow 和 Keras 进行深度学习 p.5
使用 TensorBoard 进行优化 - 使用 Python、TensorFlow 和 Keras 进行深度学习 p.5
大家好，欢迎来到 Python TensorBoard 和 Keras 深度学习教程系列的第五部分。在本教程中，我们将重点关注 TensorBoard 以及如何使用它通过可视化不同的模型尝试来优化模型。让我们深入了解一下吧！
首先，让我们分析模型并确定可以调整以提高其性能的方面。虽然我们当前的模型准确率达到了 79% 左右，但我们相信我们可以做得更好。一些潜在的优化领域包括优化器、学习率、密集层数量、每层单元、激活单元、内核大小、步幅、衰减率等。由于有多种选择可供探索，我们最终可能会测试数千个模型。那么，我们从哪里开始呢？
为了让事情变得更容易，让我们从最简单的修改开始。我们将重点调整层数、每层节点以及是否在末尾包含密集层。对于密集层的数量，我们将考虑零、一或二。关于图层大小，我们将使用 32、64 和 128 的值。这些值只是约定，您可以根据自己的喜好选择不同的值。
现在，让我们在代码中实现这些更改。我们将为我们想要做出的选择定义一些变量，例如密集层的数量和层的大小。我们将迭代这些变量来创建不同的模型组合。此外，我们将为每个模型创建一个反映其配置的名称。
一旦我们有了模型配置，我们就可以继续将它们应用到我们的代码中。我们将相应地更新模型结构，考虑输入形状、卷积层、密集层和输出层。我们还将确保适当调整图层大小。
完成所有更改后，就可以运行代码了。但是，由于训练大量模型可能非常耗时，因此我已经运行了代码并保存了结果。让我们继续使用 TensorBoard 分析结果。
我们加载 TensorBoard 日志并观察不同的模型组合。这些模型是根据其性能（特别是验证损失）进行组织的。我们关注性能最佳的型号并记录它们的配置。
从结果中可以看出，具有三个卷积层和零密集层的模型始终表现良好。每层的具体节点数似乎不太重要。然而，值得注意的是，更大的密集层，例如 512 或 256 个节点，可能会产生更好的结果。为了验证这一点，您可以测试不同的密集层大小。
总而言之，我们首先使用 TensorBoard 探索各种模型配置。我们发现具有三个卷积层且没有密集层的模型始终表现良好。我们还发现每层的节点数量可以进一步优化。通过测试不同的密集层大小，我们有可能进一步提高模型的准确性。
请记住，这只是一个起点，您可以调整许多其他方面来优化模型。 TensorBoard 提供了一个有价值的工具来可视化和分析这些模型变化，帮助您做出明智的模型改进决策。
如何使用经过训练的模型 - Python、TensorFlow 和 Keras 的深度学习基础知识 p.6
如何使用经过训练的模型 - Python、TensorFlow 和 Keras 的深度学习基础知识 p.6
大家好，欢迎来到使用 TensorFlow 和 Keras 进行 Python 深度学习教程系列的第 6 部分！
在本视频中，我们将讨论如何使用经过训练的模型对新图像进行预测。许多人一直在问这个问题，因为他们已经成功地训练和测试了他们的数据集，但不确定如何使用该模型来预测外部图像。那么，让我们深入研究一下吧！
首先，我们需要导入必要的库。我们将导入 cv2 进行图像处理，导入 TensorFlow 作为 TF 来处理我们的模型。我们还需要类别列表，其中包含我们在训练期间使用的类标签“狗”和“猫”。
接下来，我们将定义一个名为prepare的函数，它将文件路径作为参数。该函数将处理输入图像所需的预处理步骤。我们将图像调整为特定尺寸并将其转换为灰度。然后图像将作为重塑的 numpy 数组返回。
之后，我们将使用 TF.keras.models.load_model() 函数加载经过训练的模型。之前，我们将模型保存为“64 x 3 CNN 模型”，因此我们将使用相同的名称加载它。
现在，我们准备做出预测。我们将定义一个名为预测的变量，并将在准备好的图像上调用 model.predict() 的结果分配给它。值得注意的是，predict() 方法需要一个列表作为输入，即使我们是在单个图像上进行预测。因此，我们需要将准备好的图像作为列表传递。
一旦我们得到了预测结果，我们就可以将其打印出来。然而，预测目前采用嵌套列表的形式。为了使其更具可读性，我们可以将预测值转换为整数，并将其用作索引，从类别列表中检索相应的类标签。
最后，我们可以打印预测的类别标签，它表示图像被分类为狗还是猫。
在本教程中，我们使用了两个外部图像来测试我们的模型：一个是带有耻辱锥的狗，另一个是未知生物。这些图像不是我们训练数据集的一部分，确保我们对看不见的数据进行预测。
要尝试使用您自己的狗和猫图像，请按照代码中概述的步骤操作。请记住，准确度可能会有所不同，但平均而言，应该在 80% 左右。
目前为止就这样了！我要感谢我们最近的赞助商：Michael、Nick、Rodrigo 和 Papasan E。非常感谢您的支持。如果您对未来的教程有任何问题、意见或建议，请在下面留下。我也乐于接受使用循环神经网络的想法，所以如果您有一个简单的数据集，请告诉我。
我们将在下一个教程中见到您，我们将在其中探索循环神经网络。在那之前，祝您编码愉快！
循环神经网络 (RNN) - 使用 Python、TensorFlow 和 Keras 进行深度学习 p.7
循环神经网络 (RNN) - 使用 Python、TensorFlow 和 Keras 进行深度学习 p.7
大家好，欢迎来到混沌教程系列中使用 Python TensorFlow 进行深度学习的第 7 部分。在这一部分中，我们将重点关注循环神经网络（RNN）。 RNN 的目的是捕获数据顺序的意义和重要性。这在时间序列数据（数据按时间组织）和自然语言处理（句子中的单词顺序具有含义）中尤其相关。
为了说明这个概念，让我们考虑一个句子的例子：“有些人做了一个神经网络。”当这个句子由深度神经网络处理时（通常通过将数据分割成单独的单词来标记数据），网络可能无法捕获正确的含义。例如，“神经网络造就了一些人”这句话就具有完全不同的含义。这强调了词序在确定句子含义方面的重要性。
现在，让我们深入研究循环神经网络的工作原理。 RNN 的基本构建块是循环单元，通常使用长短期记忆 (LSTM) 单元来实现。尽管存在门控循环单元 (GRU) 等其他选项，但通常使用 LSTM 单元。在 RNN 中，每个单元将顺序数据作为输入，并输出到下一层或循环层中的下一个单元。
细胞的输出可以通过不同的方式进行引导。它可以以单向或双向的方式进入下一层或下一个小区。在本教程中，我们将重点关注基本的单向 RNN。为了说明这一点，想象一个代表循环单元的绿色框。来自前一个单元的数据进入当前单元，当前单元执行诸如忘记前一个节点的不相关信息、合并新的输入数据以及决定将哪些信息输出到下一层或节点等操作。
为了更好地可视化此过程，让我们考虑层中的特定单元。绿色框代表当前单元格。数据从前一个单元流入，环绕并进入 LSTM 单元。在单元内，存在用于忘记前一个节点的信息、合并新的输入数据以及确定要传递到下一层或节点的输出的操作。这些操作共同使 LSTM 单元能够保留重要信息并将其传递到后续层或节点。
实现 RNN 可能很复杂，尤其是在处理标量值时。如果您对 LSTM 单元如何工作的详细解释感兴趣，我建议您查看一份深入解释它们的综合指南。我在教程的文本版本中包含了本指南的链接，供您参考。
现在，让我们继续构建一个基本的循环神经网络。在本教程中，我们将从使用 M-NIST 数据集的简单示例开始。在下一个教程中，我们将使用更真实的时间序列数据，特别关注加密货币价格。
首先，让我们导入必要的库。我们将导入 TensorFlow 作为 tf、tensorflow.keras.models 中的顺序模型、tensorflow.keras.layers 中的 Dense 层以及 Dropout 和 LSTM 单元。请注意，如果您使用 GPU 版本的 TensorFlow，还有一个优化的 LSTM 单元，称为 KU DNN LSTM 单元。然而，在本教程中，我们将坚持使用常规 LSTM 单元。如果您使用的是 CPU 版本的 TensorFlow，计算可能会花费大量时间。
接下来，我们需要加载数据集。对于本示例，我们将使用 M-NIST 数据集。我们可以使用 tf.keras.datasets.mnist.load_data() 函数轻松加载它，该函数返回训练和测试数据。让我们将数据解压到变量中：X_train、Y_train、X_test 和 Y_test。
首先，我们通过将每个像素值除以 255 来标准化输入数据。这会将像素值缩放到 0 到 1 之间的范围，这适合神经网络训练。我们可以通过将训练数据和测试数据除以 255 来实现这一点。
X_train = X_train / 255.0 X_test = X_test / 255.0
接下来，我们需要将目标标签转换为 one-hot 编码向量。在M-NIST数据集中，标签是0到9之间的整数，代表数字。 One-hot 编码将每个标签转换为长度为 10 的二进制向量，其中与数字对应的索引设置为 1，所有其他索引设置为 0。我们可以使用 tensorflow.keras.utils 中的 to_categorical 函数来执行一个-热编码。
Y_train = to_categorical(Y_train, num_classes=10)
Y_test = to_categorical(Y_test, num_classes=10)
现在，让我们定义循环神经网络的架构。我们将使用tensorflow.keras.models 中的顺序模型并向其添加层。
from tensorflow.keras.layers import LSTM, Dense
model = Sequential()
model.add(LSTM(128, input_shape=(X_train.shape[1:]), activation='relu', return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(128, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))
现在，让我们通过指定损失函数、优化器和评估指标来编译模型。
model. compile (loss= 'categorical_crossentropy' , optimizer= 'adam' , metrics=[ 'accuracy' ])
最后，让我们使用训练数据训练模型并根据测试数据对其进行评估。
model.fit(X_train, Y_train, batch_size= 32 , epochs= 10 , validation_data=(X_test, Y_test))
就是这样！您现在已经使用 LSTM 单元为 M-NIST 数据集构建了一个循环神经网络。您可以尝试不同的架构、超参数和数据集，以进一步探索 RNN 的功能。
加密货币预测 RNN 简介 - 使用 Python、TensorFlow 和 Keras 进行深度学习 p.8
加密货币预测 RNN 简介 - 使用 Python、TensorFlow 和 Keras 进行深度学习 p.8
大家好，欢迎观看另一个Python深度学习教程视频。在本视频和接下来的视频中，我们将讨论如何将循环神经网络 (RNN) 应用到处理顺序数据的更现实的示例中。具体来说，我们将使用一个由加密货币的价格和交易量组成的时间序列数据集。
在我们深入了解细节之前，我想澄清一下，您可以将相同的概念应用于其他类型的顺序数据，例如股票价格或传感器数据。因此，即使您对金融不感兴趣，您仍然可以遵循并理解这些概念。
本教程的目标是使用循环神经网络根据加密货币过去的价格和数量来预测其未来价格。我们将重点关注四种主要的加密货币：比特币、莱特币、以太坊和比特币现金。这个想法是获取每种加密货币最后 60 分钟的价格和交易量数据，并将其用作预测莱特币价格的输入，例如未来三分钟的价格。
这种类型的预测问题也可以应用于其他领域，例如根据时间和使用数据预测服务器故障或网站流量。最终目标是预测分类（例如，价格是否会上涨或下跌）或执行回归（例如，预测实际价格或百分比变化）。
处理顺序数据带来了独特的挑战。首先，我们需要对数据进行预处理，并将其转换为递归神经网络可以处理的序列。此外，考虑到不同加密货币的价格和数量可能有不同的规模，我们需要对数据进行平衡和标准化。缩放数据比其他领域更复杂，例如图像数据，我们只需除以 255。
此外，在处理顺序数据时，使用样本外数据评估模型的性能是一个不同的挑战。我们需要涵盖几个方面，包括数据准备、标准化和评估。
首先，我提供了一个数据集供您下载。您可以在教程的说明中找到下载链接。解压下载的 zip 文件后，您会发现四个文件，每个文件对应一种加密货币的价格和数量数据。
我们将使用 Python 中的 pandas 库来读取和操作数据集。如果您没有安装 pandas，可以通过在终端或命令提示符中运行命令 pip install pandas 来安装。
接下来，我们将使用 pandas 读取数据集并检查数据。我们将重点关注每种加密货币的“收盘”价格和交易量列。为了合并来自不同文件的数据，我们将设置“时间”列作为每个数据帧的索引。然后，我们将根据共享索引连接数据帧。
一旦我们有了合并的数据框，我们需要定义一些参数。其中包括序列长度（要考虑的过去时期的数量）、未来时期（要预测的未来时期的数量）和要预测的比率（我们想要预测的加密货币）。
在我们的例子中，我们将重点根据过去 60 分钟的数据预测莱特币 (LTC) 的未来价格，并且我们将预测未来 3 分钟的价格。我们还将定义一个分类规则，根据当前和未来的价格将预测分类为价格上涨或下跌。
完成这些初始步骤后，我们现在准备预处理数据、创建序列并训练循环神经网络。我们将在接下来的视频中介绍这些主题，敬请期待。
如果您想继续操作，请确保下载数据集并设置所需的库。您可以在本教程的文本版本中找到完整的代码和说明，该版本可在说明中找到。
我们有很多内容要涵盖，所以我们将其分类为 1，表示价格上涨。否则，如果未来价格低于当前价格，我们将其分类为 0，表示价格下跌。这是我们用于分类的简单规则，但您可以尝试不同的规则，甚至使用回归来预测实际价格变化。
现在，让我们在主 DataFrame 中创建目标列。我们将使用 pandas 的 shift 函数将“LTCUSD_close”列的值移动到未来的周期。这将为我们提供未来价格，我们将其与当前价格进行比较以确定分类。我们将把结果分配给一个名为“target”的新列。
main_df[ 'target' ] = main_df[ 'LTCUSD_close' ].shift(-future_period)
main_df.dropna(inplace= True )
接下来，让我们创建输入序列。我们将迭代DataFrame并创建长度为sequence_length的序列，其中包含比特币、莱特币、以太坊和比特币现金的先前价格和交易量。我们将把这些序列存储在一个名为“sequences”的列表中。
for i in range(len(main_df) - sequence_length + 1):
sequence = main_df.iloc[i:i+sequence_length, 1:-1].values.flatten()
sequences.append(sequence)
最后，我们将序列和目标转换为 numpy 数组，以便于操作和训练。
sequences = np.array(sequences)
targets = np.array(main_df['target'])
请注意，此处提供的代码是部分实现，重点关注数据预处理步骤。您将需要进一步开发模型架构、训练模型并评估其性能。此外，您可能需要调整超参数并尝试不同的技术来提高模型的准确性。
请记住在训练模型之前导入必要的库、处理丢失的数据、预处理特征（标准化、缩放等），并将数据拆分为训练集和测试集。
我希望这可以帮助您了解使用顺序数据并应用循环神经网络来预测未来价格的过程。祝你的深度学习项目好运！
标准化和创建序列 Crypto RNN - 使用 Python、TensorFlow 和 Keras 进行深度学习 p.9
标准化和创建序列 Crypto RNN - 使用 Python、TensorFlow 和 Keras 进行深度学习 p.9
大家好，欢迎回到 Python、TensorFlow 和混沌深度学习教程系列的另一集。在本视频中，我们将继续致力于实施循环神经网络（RNN）来预测加密货币未来价格走势的小型项目。我们将使用货币价格和交易量的序列，以及其他三种加密货币的价格和交易量。
到目前为止，我们已经获取了数据，合并了数据，并创建了目标。现在，让我们继续下一步。我们需要从数据创建序列并执行平衡、标准化和缩放等任务。然而，在深入研究这些任务之前，解决样本外测试问题至关重要。
在处理时间和时间序列数据时，改组和随机选择一部分作为样本外数据可能会导致模型出现偏差。在我们的例子中，序列为 60 分钟，预测窗口为 3 分钟，随机选择样本外数据可能会导致样本内和样本外集合中都出现类似的示例。这将使模型更容易过度拟合并且在未见过的数据上表现不佳。
为了解决这个问题，我们需要仔细选择样本外数据。对于时间序列数据，建议选择未来的一大块数据作为样本外集。在我们的例子中，我们将把最后 5% 的历史数据作为我们的样本外数据。这种方法模拟 5% 前构建模型并对其进行前向测试。
现在，让我们实现样本外数据的分离。我们将根据时间戳对数据进行排序，并找到最后 5% 次的阈值。通过这种方式分离数据，我们确保样本外集合包含来自未来的数据，防止数据泄漏和有偏差的测试。一旦分离，我们将获得验证数据和训练数据。
在继续之前，需要注意的是，我们需要预处理验证数据和训练数据。我们将创建序列、平衡数据、标准化、缩放并执行其他必要的任务。为了简化此过程，我们创建一个名为 preprocess_df 的函数，该函数将 DataFrame 作为输入并执行所有这些预处理步骤。
首先，我们从 sklearn 库导入预处理模块。如果您尚未安装它，可以通过运行 pip install sklearn 来安装。然后，我们定义以 DataFrame 作为参数的 preprocess_df 函数。
在该函数中，我们首先从 DataFrame 中删除不必要的未来列。接下来，我们迭代 DataFrame 的列并应用百分比变化转换。这一标准化步骤有助于处理不同加密货币的价格和交易量。
对数据进行标准化后，我们删除包含 NaN 值的所有行，因为它们可能会在训练期间引起问题。然后，我们使用 preprocessing.scale 函数将值缩放到 0 到 1 之间。或者，您可以实现自己的缩放逻辑。
现在我们已经预处理了数据，让我们继续处理顺序数据。我们创建一个名为equential_data的空列表，并初始化一个名为prev_days的双端队列对象，最大长度为60。双端队列对象允许我们有效地追加新项目，并在达到最大长度时自动删除旧项目。
接下来，我们迭代 DataFrame 的值，其中现在包含标准化和缩放后的数据。对于每一行，我们将值附加到 prev_days 双端队列中。一旦双端队列的长度达到至少 60，我们就开始填充equential_data
# Create a deque object with a maximum length of max_len
if len(prev_days) < max_len:
prev_days.append([n for n in i[:-1]])
else:
# Append the current values to prev_days
prev_days.append([n for n in i[:-1]])
# Add the sequence to the sequential_data list
sequential_data.append([np.array(prev_days), i[-1]])
# Remove the oldest sequence from prev_days
prev_days.popleft()
现在我们已经生成了序列，我们可以继续平衡数据。平衡对于防止我们的训练数据中的特定类别出现任何偏见非常重要。在这种情况下，我们的类别是不同的价格变动（向上或向下）。为了平衡数据，我们将计算每个类的出现次数，并限制多数类的序列数量以匹配少数类。
sells = []
for seq, target in sequential_data:
if target == 0:
sells.append([seq, target])
elif target == 1:
buys.append([seq, target])
# Determine the minimum number of sequences in buys and sells
lower = min(len(buys), len(sells))
# Balance the data by randomly selecting the required number of sequences from buys and sells
buys = buys[:lower]
sells = sells[:lower]
# Concatenate buys and sells to create balanced_data
balanced_data = buys + sells
# Shuffle the balanced_data
random.shuffle(balanced_data)
平衡数据后，我们可以将其拆分为输入特征（X）和目标标签（y）数组。
y = []
for seq, target in balanced_data:
X.append(seq)
y.append(target)
# Convert X and y to numpy arrays
X = np.array(X)
y = np.array(y)
现在我们有 X 作为输入特征，y 作为目标标签，我们可以继续将数据分成训练集和验证集。
train_x, val_x, train_y, val_y = train_test_split(X, y, test_size=0.2, random_state=42)
在上面的代码中，我们使用 scikit-learn 中的 train_test_split 函数将数据拆分为训练集和验证集。我们将 80% 的数据分配给训练集（train_x 和 train_y），将 20% 的数据分配给训练集
scaler = MinMaxScaler()
train_x = scaler.fit_transform(train_x.reshape(train_x.shape[0], -1))
val_x = scaler.transform(val_x.reshape(val_x.shape[0], -1))
# Reshape the data back to its original shape
train_x = train_x.reshape(train_x.shape[0], train_x.shape[1], -1)
val_x = val_x.reshape(val_x.shape[0], val_x.shape[1], -1)
准备好数据后，我们现在可以构建和训练 LSTM 模型：
model.add(LSTM(units=128, input_shape=(train_x.shape[1:]), return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(LSTM(units=128, return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(LSTM(units=128))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(Dense(units=32, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(units=2, activation='softmax'))
# Define the optimizer and compile the model
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
# Define early stopping
early_stopping = tf.keras.callbacks.EarlyStopping(patience=3)
# Train the model
history = model.fit(train_x, train_y, validation_data=(val_x, val_y), epochs=20, callbacks=[early_stopping])
我们将优化器定义为学习率为 0.001 的 Adam，并使用稀疏分类交叉熵作为损失函数和准确性作为度量来编译模型。
提前停止是使用 EarlyStopping 回调来定义的，用于监控验证损失，如果 3 个时期后没有改善，则停止训练。
使用 fit 函数训练模型，传递训练数据（train_x 和 train_y）、验证数据（val_x 和 val_y）以及定义的回调。训练进行 20 个 epoch。
您可以根据您的具体要求调整模型架构、超参数和训练配置。
test_x = scaler.transform(test_x.reshape(test_x.shape[0], -1))
test_x = test_x.reshape(test_x.shape[0], test_x.shape[1], -1)
loss, accuracy = model.evaluate(test_x, test_y)
print(f'Test Loss: {loss:.4f}')
print(f'Test Accuracy: {accuracy*100:.2f}%')
然后，我们使用模型的评估方法来计算测试数据上的损失和准确性。评估方法采用测试输入数据（test_x）和相应的地面实况标签（test_y）。计算出的损失和准确性将打印到控制台。
请记住在脚本开头导入必要的模块：
import tensorflow as tf
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dropout, BatchNormalization, Dense
此代码将允许您为买卖分类任务训练 LSTM 模型、标准化数据并评估模型在测试集上的性能。请随意根据您的具体要求进行任何调整或修改。