机器学习的数据准备（7 天迷你课程）

作者 Jason Brownlee 于 2020年6月30日发布于数据准备 281

机器学习快速入门课程。
在7天内掌握Python中的数据准备。

数据准备涉及将原始数据转换为更适合建模的形式。

数据准备可能是预测建模项目中最重要的部分，也是最耗时的部分，尽管它似乎是讨论最少的。相反，重点是机器学习算法，其用法和参数化已变得相当常规。

实际的数据准备需要数据清洗、特征选择、数据转换、降维等知识。

在本快速课程中，您将发现如何在七天内开始并自信地为预测建模项目准备Python数据。

这是一篇内容丰富且重要的文章。您可能想把它加入书签。

立即开始您的项目，阅读我的新书《机器学习数据准备》，其中包含分步教程和所有示例的Python源代码文件。

让我们开始吧。

更新于2020年6月：更改了马匹绞痛数据集的目标。

Data Preparation for Machine Learning (7-Day Mini-Course)

机器学习的数据准备（7 天迷你课程）
照片由Christian Collins拍摄，部分权利保留。

本速成课程适合谁？

在开始之前，让我们确保您来对了地方。

本课程面向可能了解一些应用机器学习的开发人员。也许你知道如何使用流行的工具从头到尾解决预测建模问题，或者至少是大多数主要步骤。

本课程的课程假设您具备以下几点：

您熟悉基本的Python编程。
您可能了解一些基本的NumPy用于数组操作。
您可能了解一些基本的 scikit-learn 建模知识。

您不需要是

成为数学高手！
成为机器学习专家！

本快速课程将带您从一个了解少量机器学习的开发者，转变为一个能够为预测建模项目有效且有能力准备数据的开发者。

注意：本速成课程假设您有一个可用的 Python 3 SciPy 环境，并且至少安装了 NumPy。如果您的环境需要帮助，您可以按照这里的分步教程进行操作。

如何使用 Anaconda 为机器学习设置你的 Python 环境

速成课程概览

本速成课程分为七节课。

您可以每天完成一节课（推荐），或者在一天内完成所有课程（硬核）。这真的取决于您的可用时间和热情程度。

下面列出了七节课，它们将帮助你开始并高效地使用 Python 进行数据准备

第01课：数据准备的重要性
第02课：用插补法填充缺失值
第03课：使用RFE选择特征
第04课：使用归一化对数据进行缩放
第05课：使用独热编码转换类别
第06课：使用kBins将数字转换为类别
第07课：使用PCA进行降维

每节课可能需要60秒到30分钟不等。请慢慢来，按照自己的节奏完成课程。在下面的评论中提问，甚至发布结果。

课程可能会要求您自行查找完成任务的方法。我会提供提示，但每节课的部分意义在于迫使您学习在哪里查找有关算法和Python中最佳工具的帮助。（提示：我的博客上都有答案；请使用搜索框。）

在评论中发布您的结果；我会为您加油！

坚持下去；不要放弃。

想开始学习数据准备吗？

立即参加我为期7天的免费电子邮件速成课程（附示例代码）。

点击注册，同时获得该课程的免费PDF电子书版本。

第01课：数据准备的重要性

在本课中，您将了解数据准备在机器学习预测建模中的重要性。

预测建模项目涉及从数据中学习。

数据是指领域中的示例或案例，它们描述了您要解决的问题。

在预测建模项目（例如分类或回归）中，原始数据通常不能直接使用。

这有四个主要原因

数据类型：机器学习算法要求数据是数字。
数据要求：某些机器学习算法对数据有要求。
数据错误：可能需要纠正数据中的统计噪声和错误。
数据复杂性：可以从数据中提炼出复杂的非线性关系。

在将原始数据用于拟合和评估机器学习模型之前，必须对其进行预处理。预测建模项目中的这一步骤称为“数据准备”。

在机器学习项目的“数据准备”步骤中，您可能会使用或探索一些常见的或标准的任务。

这些任务包括：

**数据清洗**：识别并纠正数据中的错误或失误。
**特征选择**：识别与正在预测的目标变量最相关的输入变量。
**数据转换**：改变变量的比例或分布。
**特征工程**：从可用数据中派生新变量。
**降维**：创建数据的紧凑投影。

这些任务中的每一个都是一个拥有专门算法的完整研究领域。

您的任务

在本课中，您必须列出三个您知道的或之前使用过的数据准备算法，并为它们的目的提供一句话的摘要。

数据准备算法的一个例子是数据归一化，它将数值变量缩放到0到1之间的范围。

请在下面的评论中发布您的答案。我很想看看您能想出什么。

在下一课中，您将了解如何修复包含缺失值的数据，称为数据插补。

第02课：用插补法填充缺失值

在本课中，您将了解如何识别和填充数据中的缺失值。

现实世界的数据经常有缺失值。

数据可能因为多种原因而存在缺失值，例如未记录的观测值和数据损坏。处理缺失数据很重要，因为许多机器学习算法不支持带有缺失值的数据。

用数据填充缺失值称为数据插补，数据插补的一种流行方法是计算每列的统计值（例如均值），然后用该统计值替换该列的所有缺失值。

该马匹绞痛数据集描述了患有绞痛的马的医疗特征以及它们是生还是死。它用问号“？”标记缺失值。我们可以使用read_csv()函数加载数据集，并确保问号值被标记为NaN。

加载后，我们可以使用SimpleImputer类来转换所有标记为NaN值的缺失值，替换为该列的均值。

完整的示例如下所示。

# statistical imputation transform for the horse colic dataset
from numpy import isnan
from pandas import read_csv
from sklearn.impute import SimpleImputer
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/horse-colic.csv'
dataframe = read_csv(url, header=None, na_values='?')
# split into input and output elements
data = dataframe.values
ix = [i for i in range(data.shape[1]) if i != 23]
X, y = data[:, ix], data[:, 23]
# print total missing
print('Missing: %d' % sum(isnan(X).flatten()))
# define imputer
imputer = SimpleImputer(strategy='mean')
# fit on the dataset
imputer.fit(X)
# transform the dataset
Xtrans = imputer.transform(X)
# print total missing
print('Missing: %d' % sum(isnan(Xtrans).flatten()))

# 马匹绞痛数据集的统计插补转换

from numpy import isnan

from pandas import read_csv

from sklearn.impute import SimpleImputer

# 加载数据集

url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/horse-colic.csv'

dataframe = read_csv(url, header=None, na_values='?')

# 分割输入和输出元素

data = dataframe.values

ix = [i for i in range(data.shape[1]) if i != 23]

X, y = data[:, ix], data[:, 23]

# 打印总缺失值

print('Missing: %d' % sum(isnan(X).flatten()))

# 定义插补器

imputer = SimpleImputer(strategy='mean')

# 拟合数据集

imputer.fit(X)

# 转换数据集

Xtrans = imputer.transform(X)

# 打印总缺失值

print('Missing: %d' % sum(isnan(Xtrans).flatten()))

您的任务

在本课中，您必须运行示例，并在数据插补转换之前和之后查看数据中的缺失值数量。

请在下面的评论中发布您的答案。我很想看看您能想出什么。

在下一课中，您将了解如何选择数据集中最重要的特征。

第03课：使用RFE选择特征

在本课中，您将了解如何选择数据集中最重要的特征。

特征选择是在开发预测模型时减少输入变量数量的过程。

为了减少建模的计算成本，并在某些情况下提高模型性能，最好减少输入变量的数量。

递归特征消除（Recursive Feature Elimination），简称RFE，是一种流行的特征选择算法。

RFE之所以流行，是因为它易于配置和使用，并且在选择训练数据集中对目标变量预测更相关或最相关的特征（列）方面非常有效。

Scikit-learn Python机器学习库提供了RFE的实现。RFE是一种转换。要使用它，首先，类通过“estimator”参数配置选定的算法，并通过“n_features_to_select”参数配置要选择的特征数量。

下面的示例定义了一个具有五个冗余输入特征的合成分类数据集。然后，使用决策树算法使用RFE选择五个特征。

# report which features were selected by RFE
from sklearn.datasets import make_classification
from sklearn.feature_selection import RFE
from sklearn.tree import DecisionTreeClassifier
# define dataset
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)
# define RFE
rfe = RFE(estimator=DecisionTreeClassifier(), n_features_to_select=5)
# fit RFE
rfe.fit(X, y)
# summarize all features
for i in range(X.shape[1]):
	print('Column: %d, Selected=%s, Rank: %d' % (i, rfe.support_[i], rfe.ranking_[i]))

# 报告RFE选择的特征

from sklearn.datasets import make_classification

从 sklearn.特征选择导入 RFE

from sklearn.tree import DecisionTreeClassifier

# 定义数据集

X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)

# 定义RFE

rfe = RFE(estimator=DecisionTreeClassifier(), n_features_to_select=5)

# 拟合RFE

rfe.fit(X, y)

# 总结所有特征

for i in range(X.shape[1]):

print('Column: %d, Selected=%s, Rank: %d' % (i, rfe.support_[i], rfe.ranking_[i]))

您的任务

在本课中，您必须运行示例，并查看哪些特征被选中，以及每个输入特征被分配的相对排名。

请在下面的评论中发布您的答案。我很想看看您能想出什么。

在下一课中，您将了解如何缩放数值数据。

第04课：使用归一化对数据进行缩放

在本课中，您将了解如何为机器学习缩放数值数据。

当数值输入变量被缩放到标准范围时，许多机器学习算法表现更好。

这包括使用输入加权和的算法，如线性回归，以及使用距离度量的算法，如 k 近邻。

在建模之前缩放数值数据最流行的方法之一是归一化。归一化将每个输入变量单独缩放到0-1的范围，这是我们拥有最高精度的浮点值范围。它要求您了解或能够准确估计每个变量的最小和最大可观测值。您可能能够从可用数据中估算这些值。

您可以使用 scikit-learn 对象 MinMaxScaler 来归一化您的数据集。

下面的示例定义了一个合成分类数据集，然后使用MinMaxScaler对输入变量进行归一化。

# example of normalizing input data
from sklearn.datasets import make_classification
from sklearn.preprocessing import MinMaxScaler
# define dataset
X, y = make_classification(n_samples=1000, n_features=5, n_informative=5, n_redundant=0, random_state=1)
# summarize data before the transform
print(X[:3, :])
# define the scaler
trans = MinMaxScaler()
# transform the data
X_norm = trans.fit_transform(X)
# summarize data after the transform
print(X_norm[:3, :])

# 示例：归一化输入数据

from sklearn.datasets import make_classification

from sklearn.preprocessing import MinMaxScaler

# 定义数据集

X, y = make_classification(n_samples=1000, n_features=5, n_informative=5, n_redundant=0, random_state=1)

# 总结转换前的数据

print(X[:3, :])

# 定义缩放器

trans = MinMaxScaler()

# 转换数据

X_norm = trans.fit_transform(X)

# 总结转换后的数据

print(X_norm[:3, :])

您的任务

在本课中，您必须运行示例，并报告归一化转换之前和之后输入变量的缩放比例。

获得奖励积分：在转换前后计算每个变量的最小值和最大值，以确认其是否按预期应用。

请在下面的评论中发布您的答案。我很想看看您能想出什么。

在下一课中，您将了解如何将分类变量转换为数字。

第05课：使用独热编码转换类别

在本课中，您将了解如何将分类输入变量编码为数字。

机器学习模型要求所有输入和输出变量都是数字。这意味着，如果您的数据包含分类数据，则必须先将其编码为数字，然后才能拟合和评估模型。

将分类变量转换为数字的最流行技术之一是独热编码。

分类数据是包含标签值而不是数值的变量。

分类变量的每个标签都可以映射到一个唯一的整数，称为序数编码。然后，可以对序数表示应用独热编码。这是数据集将为变量中的每个唯一整数值添加一个新二进制变量，而原始分类变量将从数据集中删除。

例如，假设我们有一个具有三个类别的“颜色”变量（‘红色’、‘绿色’和‘蓝色’）。在这种情况下，需要三个二进制变量。在颜色对应的二进制变量中放置“1”值，在其他颜色中放置“0”值。

例如

red,	green,	blue
1,		0,		0
0,		1,		0
0,		0,		1

红色、绿色、蓝色

1, 0, 0

0, 1, 0

0, 0, 1

此独热编码转换在scikit-learn Python机器学习库中通过OneHotEncoder类提供。

乳腺癌数据集仅包含分类输入变量。

下面的示例加载数据集并对每个分类输入变量进行独热编码。

# one-hot encode the breast cancer dataset
from pandas import read_csv
from sklearn.preprocessing import OneHotEncoder
# define the location of the dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/breast-cancer.csv"
# load the dataset
dataset = read_csv(url, header=None)
# retrieve the array of data
data = dataset.values
# separate into input and output columns
X = data[:, :-1].astype(str)
y = data[:, -1].astype(str)
# summarize the raw data
print(X[:3, :])
# define the one hot encoding transform
encoder = OneHotEncoder(sparse=False)
# fit and apply the transform to the input data
X_oe = encoder.fit_transform(X)
# summarize the transformed data
print(X_oe[:3, :])

# 对乳腺癌数据集进行独热编码

from pandas import read_csv

from sklearn.preprocessing import OneHotEncoder

# 定义数据集位置

url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/breast-cancer.csv"

# 加载数据集

dataset = read_csv(url, header=None)

# 获取数据数组

data = dataset.values

# 分割为输入和输出列

X = data[:, :-1].astype(str)

y = data[:, -1].astype(str)

# 总结原始数据

print(X[:3, :])

# 定义独热编码转换

encoder = OneHotEncoder(sparse=False)

# 拟合并应用转换到输入数据

X_oe = encoder.fit_transform(X)

# 总结转换后的数据

print(X_oe[:3, :])

您的任务

在本课中，您必须运行示例，并报告转换前的原始数据以及应用独热编码后对数据的影响。

请在下面的评论中发布您的答案。我很想看看您能想出什么。

在下一课中，您将了解如何将数值变量转换为类别。

第06课：使用kBins将数字转换为类别

在本课中，您将了解如何将数值变量转换为分类变量。

某些机器学习算法可能更喜欢或需要分类或序数输入变量，例如某些决策树和基于规则的算法。

这可能是由数据中的异常值、多峰分布、高度指数分布等引起的。

许多机器学习算法更喜欢或在数值输入变量具有非标准分布时表现更好，这些变量被转换为具有新的分布或全新的数据类型。

一种方法是使用数值变量的转换来获得离散概率分布，其中每个数值都被分配一个标签，并且这些标签具有有序（序数）关系。

这称为离散化转换，并且可以通过使数值输入变量的概率分布离散化来改善某些机器学习算法在数据集上的性能。

离散化转换在scikit-learn Python机器学习库中通过KBinsDiscretizer类提供。

它允许您指定要创建的离散 bin 的数量（n_bins），转换结果是序数还是独热编码（encode），以及用于划分变量值的分布（strategy），例如“uniform”。

下面的示例创建了一个包含10个数值输入变量的合成输入变量，然后将每个变量编码为10个离散 bin，并进行序数编码。

# discretize numeric input variables
from sklearn.datasets import make_classification
from sklearn.preprocessing import KBinsDiscretizer
# define dataset
X, y = make_classification(n_samples=1000, n_features=5, n_informative=5, n_redundant=0, random_state=1)
# summarize data before the transform
print(X[:3, :])
# define the transform
trans = KBinsDiscretizer(n_bins=10, encode='ordinal', strategy='uniform')
# transform the data
X_discrete = trans.fit_transform(X)
# summarize data after the transform
print(X_discrete[:3, :])

# 离散化数值输入变量

from sklearn.datasets import make_classification

from sklearn.preprocessing import KBinsDiscretizer

# 定义数据集

X, y = make_classification(n_samples=1000, n_features=5, n_informative=5, n_redundant=0, random_state=1)

# 总结转换前的数据

print(X[:3, :])

# 定义转换

trans = KBinsDiscretizer(n_bins=10, encode='ordinal', strategy='uniform')

# 转换数据

X_discrete = trans.fit_transform(X)

# 总结转换后的数据

print(X_discrete[:3, :])

您的任务

在本课中，您必须运行示例，并报告转换前的原始数据以及转换对数据的影响。

获得奖励积分：探索转换的备用配置，例如不同的策略和 bin 数量。

请在下面的评论中发布您的答案。我很想看看您能想出什么。

在下一课中，您将了解如何降低输入数据的维度。

第07课：使用PCA进行降维

在本课中，您将了解如何使用降维来减少数据集中输入变量的数量。

数据集的输入变量或特征的数量称为其维度。

降维是指减少数据集中输入变量数量的技术。

更多的输入特征通常会使预测建模任务更具挑战性，通常称为维度灾难。

尽管在高维统计中，降维技术通常用于数据可视化，但在应用机器学习中，这些技术可用于简化分类或回归数据集，以便更好地拟合预测模型。

也许机器学习中最流行的降维技术是主成分分析（Principal Component Analysis），简称PCA。这是一项源自线性代数领域的技术，可用作数据准备技术，在拟合模型之前对数据集进行投影。

生成的投影数据集可以作为输入来训练机器学习模型。

Scikit-learn库提供了PCA类，可以将其拟合到数据集中，并用于转换训练数据集以及将来任何其他数据集。

下面的示例创建了一个具有10个输入变量的合成二元分类数据集，然后使用PCA将数据集的维度降低到三个最重要的主成分。

# example of pca for dimensionality reduction
from sklearn.datasets import make_classification
from sklearn.decomposition import PCA
# define dataset
X, y = make_classification(n_samples=1000, n_features=10, n_informative=3, n_redundant=7, random_state=1)
# summarize data before the transform
print(X[:3, :])
# define the transform
trans = PCA(n_components=3)
# transform the data
X_dim = trans.fit_transform(X)
# summarize data after the transform
print(X_dim[:3, :])

# 示例：PCA用于降维

from sklearn.datasets import make_classification

from sklearn.decomposition import PCA

# 定义数据集

X, y = make_classification(n_samples=1000, n_features=10, n_informative=3, n_redundant=7, random_state=1)

# 总结转换前的数据

print(X[:3, :])

# 定义转换

trans = PCA(n_components=3)

# 转换数据

X_dim = trans.fit_transform(X)

# 总结转换后的数据

print(X_dim[:3, :])

您的任务

在本课中，您必须运行示例，并报告原始数据集的结构和形式，以及转换后数据集的结构和形式。

获得奖励积分：探索具有不同数量选定组件的转换。

请在下面的评论中发布您的答案。我很想看看您能想出什么。

这是迷你课程的最后一课。

结束！
（看看您已经走了多远）

您做到了。干得好！

花点时间回顾一下您已经走了多远。

您发现了：

数据准备在预测建模机器学习项目中的重要性。
如何标记缺失数据并使用统计插补法进行插补。
如何使用递归特征消除移除冗余输入变量。
如何将具有不同比例的输入变量转换为标准范围，称为归一化。
如何将分类输入变量转换为数字，称为独热编码。
如何将数值变量转换为离散类别，称为离散化。
如何使用PCA将数据集投影到较低的维度。

总结

您对这个迷你课程的学习情况如何？
您喜欢这个速成课程吗？

您有任何问题吗？有没有遇到什么难点？
告诉我。在下面留言。

关于此主题的更多信息

特征工程与选择（书评）

数据清洗和特征工程的8本优秀书籍

281条对《机器学习数据准备（7天迷你课程）》的回复

shravan 2020年6月29日上午9:42 #

第3课和第7课都是降维技术？还是不同？

回复
- Ricardo Angeles 2020年6月29日上午10:51 #
  
  第3课是特征选择：选择对您的模型具有统计意义的特征。
  
  第7课是降维：您有几个对您的模型有意义的特征，但这些特征太多了，甚至更糟：您的特征比数据集中的记录还多……所以您需要降维……PCA基于向量空间，最终您新的特征是特征向量，您的模型将通过这些新特征的线性组合进行拟合，但您将无法解释模型。
  
  回复
  - Jason Brownlee 2020年6月29日下午1:25 #
    
    总结得很好！
    
    回复
- Jason Brownlee 2020年6月29日下午1:22 #
  
  很好的问题。
  
  是的。从技术上讲，特征选择确实减少了输入维度。
  
  它们都是转换。
  
  区别在于，“降维”实际上指的是“特征提取”或创建较低维数据投影的方法。
  
  特征选择只是选择要保留或删除的列。
  
  回复
- KVS Setty 2020年6月29日下午3:41 #
  
  你好
  
  第3课是特征选择
  
  第7课是特征提取
  
  如果您有点数学基础，这里有一个简单的例子：
  
  y= f(X)= f(x1,x2,x3,x4,x5 ,x6,x7,x8)
  
  也就是说，您的响应y取决于x1到x8的预测变量（特征）。
  
  并且使用某种方法，您会发现特征x3和x5与响应y无关，即特征x3和x5不影响响应y，因此您在建模过程中将它们删除，现在响应变为：
  
  y= f(x1,x2,x4,x6,x7,x8)
  
  这就是所谓的“特征选择”。
  
  在特征提取中，您不直接使用任何原始特征，您将找到一组新特征，例如z1、z2、z3、z4（较少的特征），现在您的问题是：
  
  y= f(z1,z2,z3,z4)，这些新特征是从哪里来的？
  
  它们是从原始特征派生或计算出来的，它们可能是原始特征的线性组合，例如z1可以是：
  
  z1= 2.5×1 + 0.33×2 + 4.00×7
  
  PCA计算出的新特征（z）的一个重要属性是所有新特征彼此独立，也就是说，新特征绝不是其他新特征的线性组合。
  
  而且，大多数时候新特征（z）的数量少于原始特征（x）的数量，这就是为什么它被称为“降维”，最多它们的大小与原始变量相同，但它们比原始预测变量在预测响应（y）方面更好。
  
  回复
  - Jason Brownlee 2020年6月30日上午6:11 #
    
    感谢分享。
    
    回复
KVS Setty 2020年6月29日下午4:20 #

第02课：用插补法填充缺失值

执行了本课的代码，结果是：

插补前：缺失：1605

插补后：缺失：0

回复
- Jason Brownlee 2020年6月30日上午6:14 #
  
  干得好！
  
  回复
- Sifa 2020年7月9日下午4:40 #
  
  第1课：数据准备算法
  
  1. PCA：用于通过强调变化和揭示数据集中的强模式来降低大型数据集的维度。
  2. LASSO：它包含一个决定保留多少特征的惩罚因子；而“不太重要”属性的系数变为零。
  3. RFE：它旨在通过递归地考虑越来越小的特征集来选择特征。
  
  回复
  - Jason Brownlee 2020年7月10日上午5:50 #
    
    干得好！
    
    回复
kimmie 2020年6月30日上午12:52 #

先生，我使用过基于PCA的特征选择算法来选择优化特征。之后，我将GSO优化应用于深度学习……我还能如何进一步改进我的结果……有没有后处理技术？

回复
- Jason Brownlee 2020年6月30日上午6:28 #
  
  这里有一些建议。
  https://machinelearning.org.cn/machine-learning-performance-improvement-cheat-sheet/
  
  回复
KVS Setty 2020年6月30日上午12:54 #

我的结果：第03课：使用RFE选择特征

列：0，选中=False，排名：4
列：1，选中=False，排名：5
列：2，选中=True，排名：1
列：3，选中=True，排名：1
列：4，选中=True，排名：1
列：5，选中=False，排名：6
列：6，选中=True，排名：1
列：7，选中=False，排名：3
列：8，选中=True，排名：1
列：9，选中=False，排名：2

回复
- Jason Brownlee 2020年6月30日上午6:29 #
  
  干得漂亮！
  
  回复
Samiksha 2020年6月30日上午11:20 #

解释得很清楚……????

回复
- Jason Brownlee 2020年6月30日下午1:04 #
  
  谢谢！
  
  回复
Eduardo Rojas 2020年7月1日下午2:52 #

第2课

我添加了一些代码片段，以便更容易理解“SimpleImputer (strategy = ‘mean’)”的结果。

# 代码片段
import matplotlib.pyplot as plt
%matplotlib inline

# 紧接着
dataframe = read_csv(url, header=None, na_values=’?’)

# 代码片段
plt.plot(dataframe.values[:,3])
plt.plot(dataframe.values[:,4])
plt.plot(dataframe.values[:,23])
plt.show()

# 紧接着
Xtrans = imputer.transform(X)

# 代码片段
plt.plot(Xtrans[:,3])
plt.plot(Xtrans[:,4])
plt.plot(dataframe.values[:,23])
plt.show()

回复
- Jason Brownlee 2020年7月2日上午6:14 #
  
  干得漂亮！
  
  回复
Anoop Nayak 2020年7月1日下午7:28 #

第1课：三种数据准备方法
1) 去趋势化数据，尤其是在时间序列中，以理解小时间尺度过程并将其与局部强迫关联。
2) 过滤数据，如果我们关注特定时间或空间尺度上的现象，并去除其他时间尺度的方差贡献。
3) 用默认值替换非物理值，以消除其偏差。

回复
- Jason Brownlee 2020年7月2日上午6:18 #
  
  干得好！
  
  回复
Anoop Nayak 2020年7月1日下午9:36 #

第2课

我运行了代码，发现NaN值的数量从1605减少到0。

我对SimpleImputer的工作原理很感兴趣。也许我需要更多时间来研究它的代码，或者至少了解它的粗略算法。但我研究了它的输入。对于您提供的代码，我们将策略指定为“mean”。这表明NaN值将被列的均值替换。但还有其他策略，如“median”、“most frequent”或一个常数，它们指示每个策略参数的替换。

imputer还有很多自定义选项。非常好。

谢谢你。

回复
- Jason Brownlee 2020年7月2日上午6:20 #
  
  很好，是的，我建议测试不同的策略，如均值和中位数。
  
  回复
Harikrishnan P 2020年7月2日下午4:43 #

使用两个数值数据值的散点图。它有助于可视化回归。

回复
- Jason Brownlee 2020年7月2日下午5:42 #
  
  确实如此。
  
  回复
Anoop Nayak 2020年7月3日下午11:22 #

第3课

make_classification函数创建一个（1000,10）的数组。运行到代码最后一行后的输出如下：
列：0，选中=False，排名：4
列：1，选中=False，排名：5
列：2，选中=True，排名：1
列：3，选中=True，排名：1
列：4，选中=True，排名：1
列：5，选中=False，排名：6
列：6，选中=True，排名：1
列：7，选中=False，排名：3
列：8，选中=True，排名：1
列：9，选中=False，排名：2

在make_classification步骤中，我们已经确定了信息参数的数量=5。我将其更改为3，冗余参数为7。然后我发现上述排名的顺序发生了变化。

在阅读了RFE的解释后，它运行了所有特征/列的决定估计器，然后运行较少特征数量的估计器，然后为每个列生成排名。估计器是可定制的。这很好。

我尝试更改要选择的特征数量，并得到了不同的排名顺序。我想深入了解估计器类型。

谢谢你。

回复
- Jason Brownlee 2020年7月4日上午6:00 #
  
  做得很好，感谢分享您的发现！
  
  回复
Diego 2020年7月4日上午1:19 #

感谢这篇精彩的文章。

您是否建议对分类特征或分箱的连续变量使用WoE（证据权重）？

谢谢。

回复
- Jason Brownlee 2020年7月4日上午6:03 #
  
  也许可以尝试一下，并比较使用其他编码技术的结果模型的性能。
  
  回复
Aldo Materassi 2020年7月4日上午3:01 #

好的，我现在在度假，所以我现在不是一个勤奋的人！
第1课
在一个应用中，我有5个传感器，4个通过角度电位器测量角度，1个通过线性电位器测量线性响应。为了让数据同质化，我使用了模数转换后的数据，并将每个值归一化到-1和1之间（我需要处理负阈值和正阈值报警）。我通过每秒集成100个样本（每个传感器单独）来降低噪声。我使用了贝叶斯统计预测值来去除数据中的趋势，在收集了每个传感器128个数据点后，计算均值和标准差，并用最后传入的数据进行预测。

回复
- Jason Brownlee 2020年7月4日上午6:05 #
  
  干得好！
  
  另外，享受您的假期！
  
  回复
- Ruben McCarty 2020年11月7日上午5:40 #
  
  干得不错。
  如何将机器学习与 Arduino 或 Raspberry Pi 一起使用？谢谢。
  
  回复
Yahya Tamim 2020年7月4日下午6:20 #

您的迷你课程很棒，
来自孟加拉国的爱。

回复
- Jason Brownlee 2020年7月5日上午7:01 #
  
  谢谢！
  
  回复
Luiz Henrique Rodrigues 2020年7月4日下午10:57 #

第1课：三种数据准备方法

1) 数值数据离散化 – 将数值数据转换为分类数据。当范围比精确值在建模过程中更有效时，这可能很有用。例如：高温-中温-低温可能比实际温度更有趣。

2) 异常值检测 – 使用箱线图可以识别超出预期范围的值。异常值可能是噪声，因此无助于寻找数据集中的模式。

3) 创建新属性 – 通过组合现有属性，创建有助于建模过程的新属性可能很有趣。例如：基于最低和最高温度的温度范围。

回复
- Jason Brownlee 2020年7月5日上午7:05 #
  
  干得好！
  
  回复
Anoop Nayak 2020年7月5日上午12:05 #

第4课

我不确定您在本课中所说的“缩放”是什么意思，但我在这里复制了转换之前和之后的输出。

转换前：[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]

转换后：[[0.77608466 0.0239289 0.48251588 0.18352101 0.59830036]
[0.40400165 0.79590304 0.27369632 0.6331332 0.42104156]
[0.77065362 0.50132629 0.48207176 0.5076991 0.4293882 ]]

我看到这些值已经从同时具有符号变为仅具有正号，并且现在被限制在0-1之间（归一化）。

我在这里添加转换前后5个变量的最大值和最小值。

转换前最大值：[4.10921382, 3.98897142, 4.0536372 , 5.99438395, 5.08933368]
转换前最小值：[-3.55425829, -6.01674626, -4.92105446, -3.89605694, -4.97356645]

如果归一化是正确的，那么接下来的输出应该是1和0。

转换后最大值：[1., 1., 1., 1., 1.]
转换后最小值：[0., 0., 0., 0., 0.]

我绘制了转换前后每个变量的图，我看到变量的特性保持不变，正如预期的那样，但变异性范围已发生变化。

这很好。谢谢。

回复
- Jason Brownlee 2020年7月5日上午7:05 #
  
  做得非常棒！
  
  回复
- SRINIVASARAO K S 2020年7月15日下午3:12 #
  
  你好，Anoop sir，你能分享你的数据库吗？
  
  回复
Siddhartha Saha 2020年7月5日上午12:50 #

我看到这里有7节课。在这些课程中，哪些指的是“特征工程”？请回复。

回复
- Jason Brownlee 2020年7月5日上午7:06 #
  
  也许你可以把第7课看作是一种特征提取或工程。
  
  有些人会说所有的转换都是一种特征工程。
  
  回复
  - Siddhartha Saha 2020年7月5日下午3:42 #
    
    如果被问到特征工程的不同技术是什么，您的考虑是什么？
    
    回复
    - Jason Brownlee 2020年7月6日上午6:28 #
      
      我会问提问者他们对特征工程的定义。
      
      我会建议多项式特征是一种特征工程方法，这也将有所帮助
      https://machinelearning.org.cn/discover-feature-engineering-how-to-engineer-features-and-how-to-get-good-at-it/
      
      回复
Siddhartha Saha 2020年7月5日上午1:48 #

在第1课中有一个这样的陈述…
“数据要求：某些机器学习算法对数据有
要求”

“机器学习算法对数据有要求”是什么意思？请澄清。

回复
- Jason Brownlee 2020年7月5日上午7:06 #
  
  例如，线性回归要求输入是数值且不相关。
  
  回复
Anoop Nayak 2020年7月6日上午12:56 #

第5课

在一次阅读中，我没有理解函数的目标。然后我访问了以下网站以获取更多示例 – https://scikit-learn.cn/stable/modules/preprocessing.html#preprocessing-categorical-features

在通过更多示例后，我对代码有了一些初步了解。

以下输出是转换前的原始数据

[“’40-49′” “‘premeno'” “’15-19′” “‘0-2′” “‘yes'” “‘3′” “‘right'”
“‘left_up'” “‘no'”]
[“’50-59′” “‘ge40′” “’15-19′” “‘0-2′” “‘no'” “‘1′” “‘right'” “‘central'”
“‘no'”]
[“’50-59′” “‘ge40′” “’35-39′” “‘0-2′” “‘no'” “‘2′” “‘left'” “‘left_low'”
“‘no'”]

转换后

[0. 0. 1. 0. 0. 0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0.]

谢谢你。

回复
- Jason Brownlee 2020年7月6日上午6:37 #
  
  做得好，做得好！
  
  回复
Luiz Henrique Rodrigues 2020年7月7日下午10:25 #

第2课

根据代码，插补前有1605个缺失值。

# 打印插补前的总缺失值
print(‘Missing: %d’ % sum(isnan(X).flatten()))

在插补后检查时，可以看出没有更多的缺失值。

# 打印插补后的总缺失值
print(‘Missing: %d’ % sum(isnan(Xtrans).flatten()))

回复
- Jason Brownlee 2020年7月8日上午6:31 #
  
  干得好。
  
  回复
Pallabi Sarmah 2020年7月7日下午10:35 #

解释得很清楚。我总是喜欢阅读您的教程。
在第2课中，这是我如何用均值填充缺失值的方法
# 读取数据

import pandas as pd
url = ‘https://raw.githubusercontent.com/jbrownlee/Datasets/master/horse-colic.csv’
df = pd.read_csv(url, header=None, na_values=’?’)

# 数据框中是否有任何空值？

df.isnull().sum()

# 用列的均值填充nan值，一次一个列，针对第3列

df[3] = df[3].fillna((df[3].mean()))

# 用每列的均值填充所有空值

df_clean = df.apply(lambda x: x.fillna(x.mean()),axis=0)

回复
- Jason Brownlee 2020年7月8日上午6:31 #
  
  干得好。
  
  回复
Vikraant 2020年7月8日上午3:31 #

第1课
我使用过的三种数据预处理算法
数据标准化，它使用列的均值和标准差来标准化数值数据。

我还使用过相关性图来识别相关性，并使用VIF来识别相互依赖的列。

此外，我还使用简单的查找和替换来将垃圾值或空值替换为均值、众数或静态值。

回复
- Jason Brownlee 2020年7月8日上午6:34 #
  
  干得好！
  
  回复
- Ruben McCarty 2020年11月7日上午6:06 #
  
  抱歉，VIF是什么意思？谢谢。
  
  回复
Luiz Henrique Rodrigues 2020年7月8日上午6:51 #

第03课

我的结果
列：0，选中=False，排名：4
列：1，选中=False，排名：6
列：2，选中=True，排名：1
列：3，选中=True，排名：1
列：4，选中=True，排名：1
列：5，选中=False，排名：5
列：6，选中=True，排名：1
列：7，选中=False，排名：3
列：8，选中=True，排名：1
列：9，选中=False，排名：2

据我理解，选中的五个特征是列2、3、4、6和8。

剩余特征的排名顺序如下：
列9，列7，列0，列5，列1。

回复
- Jason Brownlee 2020年7月8日下午1:40 #
  
  做得很棒！
  
  回复
Anoop Nayak 2020年7月8日下午5:55 #

第6课

原始数据
[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]

转换后
[[7. 0. 4. 1. 5.]
[4. 7. 2. 6. 4.]
[7. 5. 4. 5. 4.]]

通过观察输出，我看到原始数据分布在最低值-5.77到最高值2.39之间。现在转换后，就像将数据分成0-7类。所以我们看到最低值被放入第0类，最高值被放入第7类。这些只是1000行中的3行。现在它取决于 bin 的大小，每个原始值将落入哪个类。这些观察结果也取决于策略（上面=uniform）在命令行中的输入。在上面的例子中，bin 的大小是统一的。

当我将其更改为 kmeans 时，我看到以下输出：
[[8. 0. 4. 1. 6.]
[4. 8. 2. 6. 4.]
[8. 4. 4. 4. 4.]]
较高的值被推到较高的 bin 号。因此，bin 的大小在变化。

当我将 encode 更改为 onehot 时，它会生成稀疏矩阵而不是早期矩阵中的 numpy 数组。它对每个条目进行编码。我不知道这如何有助于理解数据分布。以下是输出：
(0, 4) 1.0
(0, 5) 1.0
(0, 12) 1.0
(0, 15) 1.0
(0, 23) 1.0
(1, 1) 1.0
(1, 9) 1.0
(1, 11) 1.0
(1, 18) 1.0
(1, 22) 1.0

这是一个有趣的练习。谢谢。

回复
- Jason Brownlee 2020年7月9日上午6:38 #
  
  干得好！
  
  回复
Sifa 2020年7月9日下午5:11 #

第2课：识别和填充数据中的缺失值。

我执行了代码示例，这是插补之前和之后的发现：

之前：1605
之后：0

我还尝试玩弄 imputer 上可用的不同策略。

回复
- Jason Brownlee 2020年7月10日上午5:50 #
  
  干得漂亮！
  
  回复
James Hutton 2020年7月10日上午7:53 #

我对第5课有一个问题。如果我有一个只有2个类别的类别，我应该使用独热编码器，还是只需将这两个类别转换为二进制，即类别1：二进制0，类别2：二进制1？

因为据我理解，独热编码器将编码为（0 1）和（1 0）。

谢谢你

回复
- Jason Brownlee 2020年7月10日下午1:43 #
  
  这是一个绝佳的问题！
  
  你可以，但不，通常我们把二元分类建模为一个具有二项分布的变量。
  
  回复
  - James Hutton 2020年7月12日上午8:48 #
    
    谢谢你。
    
    一个问题是，如果我的问题/主题已经被回答，是否会收到电子邮件通知？
    
    回复
    - Jason Brownlee 2020年7月12日上午11:28 #
      
      目前还没有，抱歉。
      
      回复
Anoop Nayak 2020年7月11日下午10:16 #

第7课

据我理解，PCA用于减少不必要变量的数量。在这里，我们使用该方法通过PCA从10个变量/列中选择了3个变量。这些是前三个PCA轴/变量吗？

以下是使用给定输入值的计算结果：
之前-
[[-0.53448246 0.93837451 0.38969914 0.0926655 1.70876508 1.14351305
-1.47034214 0.11857673 -2.72241741 0.2953565 ]
[-2.42280473 -1.02658758 -2.34792156 -0.82422408 0.59933419 -2.44832253
0.39750207 2.0265065 1.83374105 0.72430365]
[-1.83391794 -1.1946668 -0.73806871 1.50947233 1.78047734 0.58779205
-2.78506977 -0.04163788 -1.25227833 0.99373587]]

PCA后-
[[-1.64710578 -2.11683302 1.98256096]
[ 0.92840209 4.8294997 0.22727043]
[-3.83677757 0.32300714 0.11512801]]

我注意到新变量中的数字与原始变量中的值不同。这是因为我们将10个变量中的3个定义为新变量吗？

回复
- Jason Brownlee 2020年7月12日上午5:52 #
  
  干得好！
  
  不，它们是根据原始数据构建的全新数据。
  
  回复
SRINIVASARAO K S 2020年7月15日下午3:20 #

https://github.com/ksrinivasasrao/ATL/blob/master/Untitled3.ipynb

先生，您能帮我解决我遇到的错误吗？

回复
- Jason Brownlee 2020年7月16日上午6:27 #
  
  也许您可以简要总结您遇到的问题？
  
  回复
Philani Mdlalose 2020年8月3日上午10:20 #

课程：数据准备及一些技术

数据准备是在处理和分析之前清理和转换原始数据的过程。

良好的数据准备可以实现高效的分析，限制错误，减少数据处理过程中可能出现的异常和不准确之处，并使所有处理过的数据更容易被用户访问。

其他一些技术：

a) 数据整理/清洗 – 这是清理和统一混乱复杂数据的过程，以便于访问和分析。这包括填充缺失值和消除数据集中的异常值。

b) 数据离散化 – 数据减少的一部分，但具有特别的重要性，尤其对于数值数据。在此过程中，将数值属性的原始值替换为区间标签（bins）或概念标签。

c) 数据减少 – 获取卷上的简化表示，但产生相同或相似的分析结果。其中一些技术包括高相关性过滤器、PCA、随机森林/决策树以及向后/向前特征消除。

回复
- Jason Brownlee 2020年8月3日下午1:32 #
  
  干得好！
  
  回复
Nandhini 2020年8月4日上午5:11 #

嗨，Jason，

我有以下查询。

对于回归、分类、时间序列预测模型，我们会遇到调整后的R平方、准确率_分数、MSE、RMSE、AIC、BIC等术语来评估模型性能（如果您漏掉了其他指标，请告诉我）。

对于任何模型需要使用多少上述准确率指标？使用哪些组合？这是否取决于模型？

回复
- Jason Brownlee 2020年8月4日上午6:44 #
  
  选择一个指标并进行优化。
  
  回复
Aleks 2020年8月8日上午4:39 #

你好 Jason，
我看到了1605个缺失值，在插补后当然是0个缺失值。
感谢您的教程。

回复
- Jason Brownlee 2020年8月8日上午6:06 #
  
  太棒了！
  
  回复
Dolapo Odeniyi 2020年8月19日上午8:22 #

第1课

我遇到了以下算法，我刚开始学习机器学习（微笑）

独立成分分析：用于将复杂的数据混合分离成不同的来源

主成分分析（PCA）：通过创建新特征来降低数据的维度。它这样做是为了提高其可解释性的机会，同时最大程度地减少信息丢失

前向/后向特征选择：也用于减少数据集中的特征数量，但与PCA不同，它不创建新特征。

谢谢Jason！！！

回复
- Jason Brownlee 2020年8月19日下午1:34 #
  
  干得漂亮！
  
  回复
- See Mun 2021年7月9日下午12:35 #
  
  附注：我找不到独立评论的方式，所以我将把一条作为对Dalapo的回复，因为它也会在第一课中。
  
  在创建机器学习模型之前，我将使用的数据准备方法
  
  1.使用Pandas的DataFrame.describe（）快速检查每个特征的关键统计值，该值显示了数据框中每列的最小值、最大值、中位数、平均值、标准差和每个四分位数。然后，我可以在这里检查数据集，看看是否有任何明显不正确的值和异常值。
  
  2.使用Pandas的DataFrame.corr（）函数检查每个特征与彼此之间的相关性，该函数返回变量之间的相关性矩阵，并使用seaborn的heatmap图可视化相关性。sns.heatmap(data.corr( ))
  
  3.最后，在对所有特征有了初步了解后，我将深入研究我认为重要的特征，并可视化它们的频率分布、散布情况，并进一步探索它们与其他变量的关系。
  
  谢谢！！您的博客对像我这样在家学习机器学习的人非常有帮助！！
  
  回复
  - Jason Brownlee 2021年7月10日上午6:04 #
    
    干得好！
    
    回复
Dolapo 2020年8月24日上午8:27 #

第2课

我得到了以下结果
运行代码前总缺失值 = 1605，插补后为零。

我遇到了其他数据插补方法，例如演绎插补、回归插补和随机回归插补。

第3课

结果

列：0，已选=False，排名：5
列：1，已选=False，排名：4
列：2，选中=True，排名：1
列：3，选中=True，排名：1
列：4，选中=True，排名：1
列：5，选中=False，排名：6
列：6，选中=True，排名：1
列：7，已选=False，排名：2
列：8，选中=True，排名：1
列：9，已选=False，排名：3

选定的列是2、3、4、6和8。

注意：我使用Pycharm的结果与上述不同（我使用了Jupyter得到上述结果）。

对此有什么解释吗？

回复
- Jason Brownlee 2020年8月24日下午1:40 #
  
  干得好！
  
  这可能有助于解释不同的结果
  https://machinelearning.org.cn/different-results-each-time-in-machine-learning/
  
  回复
  - Dolapo 2020年8月24日下午6:25 #
    
    非常感谢！！！这很有帮助
    
    回复
    - Jason Brownlee 2020年8月25日上午6:39 #
      
      不客气！
      
      回复
Joachim Rives 2020年8月27日下午1:32 #

起初，我以为使用独热编码会扭曲结果，因为很难确定类别特征对数值特征的影响程度。然后我意识到，系数可以解决决定任何特征（包括类别独热编码或其他）对输出影响程度的问题。

回复
Sanjay Ray 2020年9月3日下午10:58 #

3种数据准备算法——标准化、编码（标签编码、独热编码）和（均值0，方差1）、降维（PCA、LDA）。

回复
- Jason Brownlee 2020年9月4日上午6:31 #
  
  干得好！
  
  回复
M.Osama 2020年10月13日下午5:49 #

数据准备算法
1）归一化：将数值列的范围归一化到同一尺度，以减小范围之间的差异。

2）标准化：将数值输入值与均值和标准差标准化，以减小值之间的差异。

3）NominalToBinary：将名义值转换为二进制值。

我只是个初学者，如果我说错了请纠正我。

回复
- Jason Brownlee 2020年10月14日上午6:14 #
  
  干得好！
  
  回复
Aasawari D 2020年10月23日下午5:41 #

正如数据准备第一课中提到的，这里有一些数据准备算法的列表

数据准备算法有
PCA——主要用于降维
数据转换——独热转换用于将分类变量编码为二进制变量。
数据挖掘与聚合

回复
- Jason Brownlee 2020年10月24日上午6:55 #
  
  干得好！
  
  回复
Yolande Athaide 2020年10月24日上午4:55 #

第1课回复

尽量想一些还没有提到且不属于本课程后续章节的内容，所以这是我的想法

1.清理数据以合并同一观测值的多个实例，这些实例具有不同的拼写，例如，客户名字Mike、Michael或M都与同一客户ID相关。这为我们提供了每个观测值属性值的真实图景。例如，如果我们通过给定客户的购买次数来衡量客户忠诚度，我们需要将Michael的所有记录合并为一个。

2.将数据透视为长格式，通过移除字段属性来合并本应为一个字段的属性（例如，2018年、2019年、2020年作为单独的属性，而不是透视为一个“年份”属性）。这使得对数据集的分析更加容易。

3.删除在所有记录中具有恒定值的特征。这些对预测模型没有价值。

回复
- Jason Brownlee 2020年10月24日上午7:12 #
  
  干得好！
  
  回复
Yolande Athaide 2020年10月24日上午6:44 #

第2课回复

插补前缺失1605
之后没有

第3课回复：要求随机选择5个冗余特征，因此只保留了其余的非冗余特征，并将其排名为1。

列：0，选中=False，排名：4
列：1，选中=False，排名：6
列：2，选中=True，排名：1
列：3，选中=True，排名：1
列：4，选中=True，排名：1
列：5，选中=False，排名：5
列：6，选中=True，排名：1
列：7，选中=False，排名：3
列：8，选中=True，排名：1
列：9，选中=False，排名：2

第4课回复：保持值在[0, 1]范围内。虽然此数据集的优势可能不那么明显，但当我们需要处理值可以无限制的数据集时，这使得分析更加可管理。

转换前：[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]

转换后：[[0.77608466 0.0239289 0.48251588 0.18352101 0.59830036]
[0.40400165 0.79590304 0.27369632 0.6331332 0.42104156]
[0.77065362 0.50132629 0.48207176 0.5076991 0.4293882 ]]

第5课回复：与原始格式或字符串格式相比，这使得变量更容易用于分析。

编码前：[[“’40-49′” “‘premeno'” “’15-19′” “‘0-2′” “‘yes'” “‘3′” “‘right'”
“‘left_up'” “‘no'”]
[“’50-59′” “‘ge40′” “’15-19′” “‘0-2′” “‘no'” “‘1′” “‘right'” “‘central'”
“‘no'”]
[“’50-59′” “‘ge40′” “’35-39′” “‘0-2′” “‘no'” “‘2′” “‘left'” “‘left_low'”
“‘no'”]]

编码后：[[0. 0. 1. 0. 0. 0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0.]]

第6课回复：转换后，浮点数现在是离散的桶。当一个特征可以取几乎任何连续值时，将它们的值范围分组到桶中可以使分析更容易。

转换前：[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]

转换后：[[7. 0. 4. 1. 5.]
[4. 7. 2. 6. 4.]
[7. 5. 4. 5. 4.]]

第7课回复：转换将数据集的维度降低到所需的3个主要特征，实现了转换，而不是像第3课那样仅仅选择特征。我需要进一步探索才能更好地理解它。

转换前：[[ -0.53448246 0.93837451 0.38969914 0.0926655 1.70876508 1.14351305
-1.47034214 0.11857673 -2.72241741 0.2953565 ]
[-2.42280473 -1.02658758 -2.34792156 -0.82422408 0.59933419 -2.44832253
0.39750207 2.0265065 1.83374105 0.72430365]
[-1.83391794 -1.1946668 -0.73806871 1.50947233 1.78047734 0.58779205
-2.78506977 -0.04163788 -1.25227833 0.99373587]]

转换后：[[ -1.64710578 -2.11683302 1.98256096]
[ 0.92840209 4.8294997 0.22727043]
[-3.83677757 0.32300714 0.11512801]]

单独处理奖励问题。

回复
- Jason Brownlee 2020年10月24日上午7:13 #
  
  干得好！
  
  回复
Owais 2020年10月25日下午5:02 #

对于第2课，打印输出为；

缺失：%d 1605
缺失：%d 0

回复
- Jason Brownlee 2020年10月26日上午6:48 #
  
  做得不错。
  
  回复
Mpafane 2020年10月30日下午11:55 #

列出你所知道或可能使用过的三种数据准备算法，并对其用途给出单行摘要。

1.主成分分析
通过创建与多个原始特征相关的新的特征来降低数据集的维度。

2.决策树集成
用于特征选择

3.前向特征选择和后向特征选择
应用于减少特征数量。

回复
- Jason Brownlee 2020年10月31日上午6:49 #
  
  干得好！
  
  回复
Shehu 2020年10月31日下午1:34 #

第1课

1.二元编码：将非数值数据转换为0到1之间的数值。

2.数据标准化：将不同数据集的结构转换为通用数据格式。

回复
- Jason Brownlee 2020年10月31日下午1:56 #
  
  干得好！
  
  回复
Shehu 2020年10月31日下午2:28 #

第2课

插补前缺失值：1605
插补后缺失值：0

回复
- Jason Brownlee 2020年11月1日上午7:29 #
  
  干得好！
  
  回复
Shehu 2020年10月31日下午4:20 #

第3课

列：0，已选=False，排名：6
列：1，已选=False，排名：4
列：2，选中=True，排名：1
列：3，选中=True，排名：1
列：4，选中=True，排名：1
列：5，选中=False，排名：5
列：6，选中=True，排名：1
列：7，选中=False，排名：3
列：8，选中=True，排名：1
列：9，选中=False，排名：2

从上面可以看出，选择了列2、3、4、6和8的特征，而其余的被丢弃了。选定的特征排名均为1，而列9、7、1、0和5的排名分别为2、3、4、5和6。

回复
- Jason Brownlee 2020年11月1日上午7:30 #
  
  干得漂亮！
  
  回复
jagadeswar rao devarasetti 2020年11月3日下午7:19 #

关于第2天

缺失：1605
缺失：0

回复
- Jason Brownlee 2020年11月4日上午6:37 #
  
  干得好！
  
  回复
Ruben McCarty 2020年11月7日上午8:05 #

第02课

缺失：1605
缺失：0

谢谢 Jason

我只是个初学者。

你能给我解释一下这一行吗。
ix = [i for i in range(data.shape[1]) if i != 23]
X, y = data[:, ix], data[:, 23]

谢谢

回复
- Jason Brownlee 2020年11月7日上午8:17 #
  
  干得好。
  
  好问题，所有不属于第23列的列都作为输入，而第23列作为输出。
  
  回复
Ruben McCarty 2020年11月9日下午4:19 #

第5课
之前
array([[“’50-59′”, “‘ge40′”, “’15-19′”, …, “‘central'”, “‘no'”,
“‘no-recurrence-events'”],
[“’50-59′”, “‘ge40′”, “’35-39′”, …, “‘left_low'”, “‘no'”,
“‘recurrence-events'”],
[“’40-49′”, “‘premeno'”, “’35-39′”, …, “‘left_low'”, “‘yes'”,
“‘no-recurrence-events'”],
……,
[“’30-39′”, “‘premeno'”, “’30-34′”, …, “‘right_up'”, “‘no'”,
“‘no-recurrence-events'”],
[“’50-59′”, “‘premeno'”, “’15-19′”, …, “‘left_low'”, “‘no'”,
“‘no-recurrence-events'”],
[“’50-59′”, “‘ge40′”, “’40-44′”, …, “‘right_up'”, “‘no'”,
“‘no-recurrence-events'”]], dtype=object)

应用独热编码后
[[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0.]
[0. 0. 1. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 1. 0. 0. 0. 0. 0. 1.]]

非常感谢您，Jason先生，分享这个教程

回复
- Jason Brownlee 2020年11月10日上午6:36 #
  
  干得好！
  
  回复
deepa 2020年11月10日上午2:32 #

第3课输出：所以选择了5、4、6、2

列：0，已选=False，排名：5
列：1，已选=False，排名：4
列：2，选中=True，排名：1
列：3，选中=True，排名：1
列：4，选中=True，排名：1
列：5，选中=False，排名：6
列：6，选中=True，排名：1
列：7，选中=False，排名：3
列：8，选中=True，排名：1
列：9，选中=False，排名：2

回复
- Jason Brownlee 2020年11月10日上午6:45 #
  
  干得好！
  
  回复
DEEPA 2020年11月10日上午2:36 #

#第4课

[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]

回复
- Jason Brownlee 2020年11月10日上午6:45 #
  
  干得不错。
  
  回复
deepa 2020年11月10日上午2:44 #

#第5课

[[“’40-49′” “‘premeno'” “’15-19′” “‘0-2′” “‘yes'” “‘3′” “‘right'”
“‘left_up'” “‘no'”]
[“’50-59′” “‘ge40′” “’15-19′” “‘0-2′” “‘no'” “‘1′” “‘right'” “‘central'”
“‘no'”]
[“’50-59′” “‘ge40′” “’35-39′” “‘0-2′” “‘no'” “‘2′” “‘left'” “‘left_low'”
“‘no'”]]
[[0. 0. 1. 0. 0. 0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0.]]

回复
- Jason Brownlee 2020年11月10日上午6:46 #
  
  干得好！
  
  回复
DEEPA 2020年11月10日上午3:05 #

#第6课
[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]
[[7. 0. 4. 1. 5.]
[4. 7. 2. 6. 4.]
[7. 5. 4. 5. 4.]]

回复
DEEPA 2020年11月10日上午3:13 #

第7课

[[-1.64710578 -2.11683302 1.98256096]
[ 0.92840209 4.8294997 0.22727043]
[-3.83677757 0.32300714 0.11512801]]

回复
Ruben McCarty 2020年11月12日上午5:03 #

转换我的数据之前
[[-0.53448246 0.93837451 0.38969914 0.0926655 1.70876508 1.14351305
-1.47034214 0.11857673 -2.72241741 0.2953565 ]
[-2.42280473 -1.02658758 -2.34792156 -0.82422408 0.59933419 -2.44832253
0.39750207 2.0265065 1.83374105 0.72430365]
[-1.83391794 -1.1946668 -0.73806871 1.50947233 1.78047734 0.58779205
-2.78506977 -0.04163788 -1.25227833 0.99373587]]
转换数据之后

[[-1.64710578 -2.11683302 1.98256096]
[ 0.92840209 4.8294997 0.22727043]
[-3.83677757 0.32300714 0.11512801]]

这里我们将变量减少到3个。
我的问题是，我怎么知道要减少多少变量，或者我是否不需要减少，或者我应该始终减少输入变量？
也可以减少目标变量或因变量吗？
请Jason先生。
非常感谢。

回复
- Jason Brownlee 2020年11月12日上午6:41 #
  
  好问题，需要通过反复试验来找出最适合您数据集的方法。
  
  你只有一个目标。你可以转换它，但不能减少它。
  
  回复
Rob 2020年12月2日下午3:57 #

很棒的“课程”！
对于特征选择和特征提取（第3课和第7课），两者都需要一些先验知识来选择正确的箱或组件。例如，对于PCA，我们选择3个特征向量，是否有选择正确数量的好方法？我知道我们可以只训练3个或5个或7个向量的模型来找出答案，但是否有更好的理解方法？

谢谢，

回复
- Jason Brownlee 2020年12月3日上午8:13 #
  
  谢谢！
  
  是的，网格搜索是处理这些选项的好方法。
  
  回复
Anna 2020年12月4日下午4:58 #

第02课
处理imputer前缺失：1605，之后为0

回复
- Jason Brownlee 2020年12月5日上午8:02 #
  
  干得好。
  
  回复
Anna 2020年12月9日下午3:46 #

第04课

[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]
[[0.77608466 0.0239289 0.48251588 0.18352101 0.59830036]
[0.40400165 0.79590304 0.27369632 0.6331332 0.42104156]
[0.77065362 0.50132629 0.48207176 0.5076991 0.4293882 ]]

回复
- Jason Brownlee 2020年12月10日上午6:21 #
  
  干得漂亮！
  
  回复
Anna 2020年12月9日下午3:50 #

第05课

#对乳腺癌数据集进行独热编码
from pandas import read_csv
from sklearn.preprocessing import OneHotEncoder
# 定义数据集位置
url = “https://raw.githubusercontent.com/jbrownlee/Datasets/master/breast-cancer.csv”
# 加载数据集
dataset = read_csv(url, header=None)
# 获取数据数组
data = dataset.values
# 分割为输入和输出列
X = data[:, :-1].astype(str)
y = data[:, -1].astype(str)
# 总结原始数据
print(X[:3, :])
# 定义独热编码转换
encoder = OneHotEncoder(sparse=False)
# 拟合并应用转换到输入数据
X_oe = encoder.fit_transform(X)
# 总结转换后的数据
print(X_oe[:3, :])

回复
- Jason Brownlee 2020年12月10日上午6:21 #
  
  非常好。
  
  回复
Borena 2020年12月19日下午9:51 #

第1课

我之前使用SQL和Pandas进行数据清理，但现在我开始研究您的书籍并使用它们来帮助。
请问，如果您能告诉我是否理解正确，我将不胜感激。谢谢。

标准化：将变量缩放到标准的高斯概率分布（均值为零，标准差为一）。

幂变换：消除变量概率分布的偏斜，使其更像高斯分布，这意味着它在两侧更均匀。

分位数变换：将特征转换为服从正态分布，并减小异常值的影响。

我理解它们都以高斯分布为目标？非常感谢您的帮助。

回复
- Jason Brownlee 2020年12月20日上午5:57 #
  
  干得好！
  
  回复
Borena 2020年12月22日上午4:06 #

第2课

之前1605，之后0。谢谢。

回复
- Jason Brownlee 2020年12月22日上午6:50 #
  
  干得好！
  
  回复
Borena 2020年12月24日上午2:41 #

第3课

列：0，已选=False，排名：4
列：1，已选=False，排名：6
列：2，已选=True，排名：1
列：3，已选=True，排名：1
列：4，已选=True，排名：1
列：5，已选=False，排名：5
列：6，已选=True，排名：1
列：7，已选=False，排名：2
列：8，已选=True，排名：1
列：9，已选=False，排名：3

一切正常，谢谢。

回复
- Jason Brownlee 2020年12月24日上午5:32 #
  
  干得不错。
  
  回复
Borena 2020年12月24日上午8:12 #

第4课：归一化

转换前的数据
[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]

转换后的数据
[[0.77608466 0.0239289 0.48251588 0.18352101 0.59830036]
[0.40400165 0.79590304 0.27369632 0.6331332 0.42104156]
[0.77065362 0.50132629 0.48207176 0.5076991 0.4293882 ]]

都在0-1的范围内

回复
- Jason Brownlee 2020年12月24日上午9:05 #
  
  干得好！
  
  回复
Ebi 2020年12月24日下午3:17 #

第3课：RFE
只选择了列2、3、4、6和8中的5个特征。

回复
- Jason Brownlee 2020年12月24日下午4:33 #
  
  干得好！
  
  回复
Borena 2020年12月24日下午8:55 #

第5课：独热编码

原始数据

[[“’40-49′” “‘premeno'” “’15-19′” “‘0-2′” “‘yes'” “‘3′” “‘right'”
“‘left_up'” “‘no'”]
[“’50-59′” “‘ge40′” “’15-19′” “‘0-2′” “‘no'” “‘1′” “‘right'” “‘central'”
“‘no'”]
[“’50-59′” “‘ge40′” “’35-39′” “‘0-2′” “‘no'” “‘2′” “‘left'” “‘left_low'”
“‘no'”]]

转换后的数据

[[0. 0. 1. 0. 0. 0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0.]]

回复
- Borena 2020年12月24日下午8:58 #
  
  这也奏效了。
  
  我有一个快速问题，关于y：我们是否也应该转换它？
  
  # 分割为输入和输出列
  X = data[:, :-1].astype(str)
  y = data[:, -1].astype(str)
  
  谢谢，圣诞快乐。
  
  回复
  - Jason Brownlee 2020年12月25日上午5:21 #
    
    是的，最好单独转换输入和输出，这样以后可以单独地对预测进行逆转换。
    
    回复
- Jason Brownlee 2020年12月25日上午5:20 #
  
  干得好！
  
  回复
Borena 2020年12月25日下午10:39 #

第6课：KBinsDiscretizer

之前
[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]

离散化之后
[[7. 0. 4. 1. 5.]
[4. 7. 2. 6. 4.]
[7. 5. 4. 5. 4.]]

n_bins=20
[[15. 0. 9. 3. 11.]
[ 8. 15. 5. 12. 8.]
[15. 10. 9. 10. 8.]]

strategy=’kmeans’
[[8. 0. 4. 1. 6.]
[4. 8. 2. 6. 4.]
[8. 4. 4. 4. 4.]]

strategy=’quantile’
[[9. 0. 4. 0. 8.]
[4. 8. 1. 8. 4.]
[9. 1. 4. 5. 4.]]

谢谢你。

回复
- Jason Brownlee 2020年12月26日上午5:11 #
  
  干得好。
  
  回复
Borena 2020年12月27日上午3:13 #

第7课：使用PCA进行降维

之前
[[-0.53448246 0.93837451 0.38969914 0.0926655 1.70876508 1.14351305
-1.47034214 0.11857673 -2.72241741 0.2953565 ]
[-2.42280473 -1.02658758 -2.34792156 -0.82422408 0.59933419 -2.44832253
0.39750207 2.0265065 1.83374105 0.72430365]
[-1.83391794 -1.1946668 -0.73806871 1.50947233 1.78047734 0.58779205
-2.78506977 -0.04163788 -1.25227833 0.99373587]]

之后
[[-1.64710578 -2.11683302 1.98256096]
[ 0.92840209 4.8294997 0.22727043]
[-3.83677757 0.32300714 0.11512801]]

两个组件
[[ 0.16205607 0.682448 ]
[-2.73725 -0.90545667]
[-2.86555495 -5.344142 ]]

四个组件
[[-1.64710578e+00 -2.11683302e+00 1.98256096e+00 -3.00364400e-16]
[ 9.28402085e-01 4.82949970e+00 2.27270432e-01 1.95852098e-15]
[-3.83677757e+00 3.23007138e-01 1.15128013e-01 -1.33926993e-16]]

非常感谢。

回复
- Jason Brownlee 2020年12月27日上午5:03 #
  
  干得不错。
  
  回复
Sarah B 2021年1月11日上午8:15 #

异常值——使用matplotlib和seaborn的散点图。异常值可以识别异常的或不属于数据集的数据，并可以识别数据中的错误，例如数据输入错误。还可以揭示超出范围的值以及由计算和数据清理引起超出范围的值

数据标准化：标准化值以确保一致性，并计算唯一值和值计数的适当和正确数量。检查拼写错误，可以将值组合在一起使数据更容易处理

填充空值和删除值——删除不会影响数据的数值，并填充空值，因为一些机器学习算法在没有值或像.、,或空格这样的字符时无法执行。

回复
- Jason Brownlee 2021年1月11日上午10:26 #
  
  干得好！
  
  回复
Vinodkumar 2021年1月12日上午4:57 #

####第1课
以下三种我用于数据准备的算法

1.数据标准化，它使用列的均值和标准差来标准化数值数据。

2.相关性，用于识别数据点之间的相关性。

3.我使用简单的查找和替换来替换数据中的垃圾值、NaN、空白或空值，用该列的均值、模式或静态值来填充。

回复
- Jason Brownlee 2021年1月12日上午7:53 #
  
  干得好。
  
  回复
Vinodkumar 2021年1月12日上午5:12 #

###第2课

插补前1605
插补后0

回复
- Jason Brownlee 2021年1月12日上午7:55 #
  
  干得好！
  
  回复
Vinodkumar 2021年1月12日上午5:20 #

###第3课

列：0，已选=False，排名：6
列：1，已选=False，排名：4
列：2，选中=True，排名：1
列：3，选中=True，排名：1
列：4，选中=True，排名：1
列：5，选中=False，排名：5
列：6，选中=True，排名：1
列：7，选中=False，排名：3
列：8，选中=True，排名：1
列：9，选中=False，排名：2

从上面可以看出，选择了列2、3、4、6和8的特征，而其余的被丢弃了。选定的特征排名均为1，而列9、7、1、0和5的排名分别为2、3、4、5和6。

回复
- Jason Brownlee 2021年1月12日上午7:55 #
  
  太棒了！
  
  回复
Vinodkumar 2021年1月13日上午6:00 #

###第4课

转换前的数据
[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]

转换后的数据
[[0.77608466 0.0239289 0.48251588 0.18352101 0.59830036]
[0.40400165 0.79590304 0.27369632 0.6331332 0.42104156]
[0.77065362 0.50132629 0.48207176 0.5076991 0.4293882 ]]

回复
- Jason Brownlee 2021年1月13日上午6:18 #
  
  干得好！
  
  回复
Vinodkumar 2021年1月13日上午6:17 #

###第5课

原始数据之前
[[“’40-49′” “‘premeno'” “’15-19′” “‘0-2′” “‘yes'” “‘3′” “‘right'”
“‘left_up'” “‘no'”]
[“’50-59′” “‘ge40′” “’15-19′” “‘0-2′” “‘no'” “‘1′” “‘right'” “‘central'”
“‘no'”]
[“’50-59′” “‘ge40′” “’35-39′” “‘0-2′” “‘no'” “‘2′” “‘left'” “‘left_low'”
“‘no'”]]

转换后的数据
[[0. 0. 1. 0. 0. 0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0.]]

回复
- Jason Brownlee 2021年1月13日上午6:18 #
  
  太棒了！
  
  回复
Vinodkumar 2021年1月13日上午6:30 #

###第6课：KBinsDiscretizer

之前
[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]

离散化之后
[[7. 0. 4. 1. 5.]
[4. 7. 2. 6. 4.]
[7. 5. 4. 5. 4.]]

n_bins=5
[[3. 0. 2. 0. 2.]
[2. 3. 1. 3. 2.]
[3. 2. 2. 2. 2.]]

n_bins=20
[[15. 0. 9. 3. 11.]
[ 8. 15. 5. 12. 8.]
[15. 10. 9. 10. 8.]]

strategy=’quantile’
[[9. 0. 4. 0. 8.]
[4. 8. 1. 8. 4.]
[9. 1. 4. 5. 4.]]

strategy=’kmeans’
[[8. 0. 4. 1. 6.]
[4. 8. 2. 6. 4.]
[8. 4. 4. 4. 4.]]

encode=’onehot-dense’, strategy=’kmeans’
[[0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.
1. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0.
0. 0.]
[0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 1. 0.
0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0.
1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0.]]

回复
- Jason Brownlee 2021年1月13日上午7:53 #
  
  干得漂亮！
  
  回复
Nithya 2021年1月19日下午9:10 #

第1课数据准备

岭回归：L2正则化也称为岭回归或Tikhonov正则化。岭回归几乎与线性回归（平方和）相同，只是我们引入了少量偏差。

遗传算法：此算法可用于查找特征子集。

线性判别分析（LDA）：LDA假设数据服从正态分布且类协方差相等。

回复
- Jason Brownlee 2021年1月20日上午5:42 #
  
  干得好！
  
  回复
Nithya 2021年2月1日下午8:22 #

第2课填充缺失值

插补前缺失值：408
插补后缺失值：0

回复
- Jason Brownlee 2021年2月2日上午5:43 #
  
  干得好！
  
  回复
Nithya 2021年2月1日下午8:31 #

第3课

列：0，选中=False，排名：4
列：1，选中=False，排名：5
列：2，选中=True，排名：1
列：3，选中=True，排名：1
列：4，选中=True，排名：1
列：5，选中=False，排名：6
列：6，选中=True，排名：1
列：7，已选=False，排名：2
列：8，选中=True，排名：1
列：9，已选=False，排名：3

选定的特征排名为1

回复
- Jason Brownlee 2021年2月2日上午5:43 #
  
  干得漂亮！
  
  回复
CraigH 2021年2月25日下午7:04 #

第1课–第3课（基础）数据清理方法
1.删除没有值或只有一个值的变量/字段。
2.修改具有空白值的变量/字段，使其适合为Null或NaN。
3.标准化具有相同含义的响应，例如，CA或Calif或California

回复
- Jason Brownlee 2021年2月26日上午4:56 #
  
  干得好！
  
  回复
fernando romero montalvo 2021年2月25日下午9:44 #

第1课
-通过替换为中位数或其他特征值来消除空值，或者删除数据集中的这些行，如果您有大型数据集。
-通过创建虚拟变量将分类变量转换为数值变量

回复
- Jason Brownlee 2021年2月26日上午4:58 #
  
  干得好！
  
  回复
fernando romero montalvo 2021年2月26日上午1:47 #

第2课
无imputer的数据框中的缺失值：1605
imputer后数据框中的缺失值：0

回复
- Jason Brownlee 2021年2月26日上午5:01 #
  
  干得好！
  
  回复
fernando romero montalvo 2021年2月27日上午2:14 #

第3课
代码提到的输出是

列：0，选中=False，排名：4
列：1，选中=False，排名：5
列：2，选中=True，排名：1
列：3，选中=True，排名：1
列：4，选中=True，排名：1
列：5，选中=False，排名：6
列：6，选中=True，排名：1
列：7，已选=False，排名：2
列：8，选中=True，排名：1
列：9，已选=False，排名：3

将RFE应用于马匹结肠数据集，我们得到
列：0，已选=False，排名：20
列：1，已选=False，排名：21
列：2，选中=True，排名：1
列：3，选中=True，排名：1
列：4，已选=False，排名：6
列：5，已选=False，排名：8
列：6，已选=False，排名：13
列：7，已选=False，排名：10
列：8，已选=False，排名：12
列：9，已选=False，排名：11
列：10，已选=False，排名：14
列：11，已选=False，排名：16
列：12，已选=False，排名：7
列：13，已选=False，排名：19
列：14，已选=False，排名：4
列：15，已选=False，排名：9
列：16，已选=False，排名：17
列：17，已选=False，排名：18
列：18，已选=False，排名：2
列：19，已选=True，排名：1
列：20，已选=True，排名：1
列：21，已选=True，排名：1
列：22，已选=False，排名：5
列：23，已选=False，排名：15
列：24，已选=False，排名：3
列：25，已选=False，排名：22

回复
- Jason Brownlee 2021年2月27日上午6:06 #
  
  干得好。
  
  回复
fernando romero montalvo 2021年2月27日上午2:41 #

第4课#

[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]
列的最大值：[4.10921382 3.98897142 4.0536372 5.99438395 5.08933368]
[[0.77608466 0.0239289 0.48251588 0.18352101 0.59830036]
[0.40400165 0.79590304 0.27369632 0.6331332 0.42104156]
[0.77065362 0.50132629 0.48207176 0.5076991 0.4293882 ]]
列的最大值：[1. 1. 1. 1. 1.]

回复
- Jason Brownlee 2021年2月27日上午6:06 #
  
  干得漂亮！
  
  回复
fernando romero montalvo 2021年2月27日上午2:56 #

第5课#

输出是
[[“’40-49′” “‘premeno'” “’15-19′” “‘0-2′” “‘yes'” “‘3′” “‘right'”
“‘left_up'” “‘no'”]
[“’50-59′” “‘ge40′” “’15-19′” “‘0-2′” “‘no'” “‘1′” “‘right'” “‘central'”
“‘no'”]
[“’50-59′” “‘ge40′” “’35-39′” “‘0-2′” “‘no'” “‘2′” “‘left'” “‘left_low'”
“‘no'”]]
[[0. 0. 1. 0. 0. 0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0.]]

经过独热编码过程后，我们有9列转换为40列

回复
- Jason Brownlee 2021年2月27日上午6:06 #
  
  非常好。
  
  回复
fernando romero montalvo 2021年3月3日上午2:03 #

[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]
n_bins=10, encode=’ordinal’, strategy=’uniform’
[[7. 0. 4. 1. 5.]
[4. 7. 2. 6. 4.]
[7. 5. 4. 5. 4.]]
n_bins=10, encode=’ordinal’, strategy=’quantile’
[[9. 0. 4. 0. 8.]
[4. 8. 1. 8. 4.]
[9. 1. 4. 5. 4.]]
n_bins=10, encode=’ordinal’, strategy=’kmeans’
[[8. 0. 4. 1. 6.]
[4. 8. 2. 6. 4.]
[8. 4. 4. 4. 4.]]
n_bins=3, encode=’ordinal’, strategy=’uniform’
[[2. 0. 1. 0. 1.]
[1. 2. 0. 1. 1.]
[2. 1. 1. 1. 1.]]
n_bins=3, encode=’ordinal’, strategy=’quantile’
[[2. 0. 1. 0. 2.]
[1. 2. 0. 2. 1.]
[2. 0. 1. 1. 1.]]
n_bins=3, encode=’ordinal’, strategy=’kmeans’
[[2. 0. 1. 0. 2.]
[1. 2. 0. 2. 1.]
[2. 1. 1. 1. 1.]]

结论是，可以看出，如果减少分箱的数量，所有策略的结果都相似

回复
- Jason Brownlee 2021年3月3日上午5:37 #
  
  干得好！
  
  回复
fernando romero montalvo 2021年3月3日上午3:11 #

第6课#
[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]
n_bins=10, encode=’ordinal’, strategy=’uniform’
[[7. 0. 4. 1. 5.]
[4. 7. 2. 6. 4.]
[7. 5. 4. 5. 4.]]
n_bins=10, encode=’ordinal’, strategy=’quantile’
[[9. 0. 4. 0. 8.]
[4. 8. 1. 8. 4.]
[9. 1. 4. 5. 4.]]
n_bins=10, encode=’ordinal’, strategy=’kmeans’
[[8. 0. 4. 1. 6.]
[4. 8. 2. 6. 4.]
[8. 4. 4. 4. 4.]]
n_bins=3, encode=’ordinal’, strategy=’uniform’
[[2. 0. 1. 0. 1.]
[1. 2. 0. 1. 1.]
[2. 1. 1. 1. 1.]]
n_bins=3, encode=’ordinal’, strategy=’quantile’
[[2. 0. 1. 0. 2.]
[1. 2. 0. 2. 1.]
[2. 0. 1. 1. 1.]]
n_bins=3, encode=’ordinal’, strategy=’kmeans’
[[2. 0. 1. 0. 2.]
[1. 2. 0. 2. 1.]
[2. 1. 1. 1. 1.]]

作为结论，可以看出，如果减少分箱的数量，所有策略的结果都相似

回复
- Jason Brownlee 2021年3月3日上午5:37 #
  
  干得好！
  
  回复
fernando romero montalvo 2021年3月3日上午3:12 #

[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]
n_bins=10, encode=’ordinal’, strategy=’uniform’
[[7. 0. 4. 1. 5.]
[4. 7. 2. 6. 4.]
[7. 5. 4. 5. 4.]]
n_bins=10, encode=’ordinal’, strategy=’quantile’
[[9. 0. 4. 0. 8.]
[4. 8. 1. 8. 4.]
[9. 1. 4. 5. 4.]]
n_bins=10, encode=’ordinal’, strategy=’kmeans’
[[8. 0. 4. 1. 6.]
[4. 8. 2. 6. 4.]
[8. 4. 4. 4. 4.]]
n_bins=3, encode=’ordinal’, strategy=’uniform’
[[2. 0. 1. 0. 1.]
[1. 2. 0. 1. 1.]
[2. 1. 1. 1. 1.]]
n_bins=3, encode=’ordinal’, strategy=’quantile’
[[2. 0. 1. 0. 2.]
[1. 2. 0. 2. 1.]
[2. 0. 1. 1. 1.]]
n_bins=3, encode=’ordinal’, strategy=’kmeans’
[[2. 0. 1. 0. 2.]
[1. 2. 0. 2. 1.]
[2. 1. 1. 1. 1.]]

作为结论，可以看出，如果减少分箱的数量，所有策略的结果都相似

回复
- Jason Brownlee 2021年3月3日上午5:37 #
  
  很棒。
  
  回复
fernando romero montalvo 2021年3月3日上午3:13 #

作为结论，可以看出，如果减少分箱的数量，所有策略的结果都相似

回复
Nithya 2021年4月19日下午9:23 #

转换前
[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]

归一化后
[[0.77608466 0.0239289 0.48251588 0.18352101 0.59830036]
[0.40400165 0.79590304 0.27369632 0.6331332 0.42104156]
[0.77065362 0.50132629 0.48207176 0.5076991 0.4293882 ]]

回复
- Jason Brownlee 2021年4月20日上午5:57 #
  
  干得好！
  
  回复
Nithya 2021年4月19日下午9:49 #

第5课

[[“’40-49′” “‘premeno'” “’15-19′” “‘0-2′” “‘yes'” “‘3′” “‘right'”
“‘left_up'” “‘no'”]
[“’50-59′” “‘ge40′” “’15-19′” “‘0-2′” “‘no'” “‘1′” “‘right'” “‘central'”
“‘no'”]
[“’50-59′” “‘ge40′” “’35-39′” “‘0-2′” “‘no'” “‘2′” “‘left'” “‘left_low'”
“‘no'”]]
[[0. 0. 1. 0. 0. 0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0.]]

回复
- Jason Brownlee 2021年4月20日上午5:57 #
  
  干得好。
  
  回复
Nithya 2021年4月19日下午9:55 #

第6课

转换前

[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]

转换后：我选择了20个分箱

[[15. 0. 9. 3. 11.]
[ 8. 15. 5. 12. 8.]
[15. 10. 9. 10. 8.]]

回复
- Jason Brownlee 2021年4月20日上午5:57 #
  
  干得漂亮！
  
  回复
Nithya 2021年4月19日下午10:01 #

第7课

我将组件更改为5

[[-0.53448246 0.93837451 0.38969914 0.0926655 1.70876508 1.14351305
-1.47034214 0.11857673 -2.72241741 0.2953565 ]
[-2.42280473 -1.02658758 -2.34792156 -0.82422408 0.59933419 -2.44832253
0.39750207 2.0265065 1.83374105 0.72430365]
[-1.83391794 -1.1946668 -0.73806871 1.50947233 1.78047734 0.58779205
-2.78506977 -0.04163788 -1.25227833 0.99373587]]
[[-1.64710578e+00 -2.11683302e+00 1.98256096e+00 2.05848176e-15
6.57302581e-16]
[ 9.28402085e-01 4.82949970e+00 2.27270432e-01 1.12515298e-15
-5.70714602e-16]
[-3.83677757e+00 3.23007138e-01 1.15128013e-01 -3.85082150e-16
-2.59561787e-16]]

回复
- Jason Brownlee 2021年4月20日上午5:58 #
  
  干得漂亮！
  
  回复
Johnny 2021年5月2日上午1:10 #

嗨，Jason！

我可以只做特征选择或降维吗？因为如果我两者都做了，可能会导致信息丢失。在什么情况下我只需要特征选择或降维，而不是两者都需要？

回复
- Jason Brownlee 2021年5月2日上午5:33 #
  
  可以，两者都可以，但不能同时使用。
  
  回复
Cirsti 2021年5月6日下午5:41 #

我是这个领域的新手，还在学习算法。

我学会了搜索缺失的记录或数据；这有助于精简或清理数据（排除缺失值）。
我使用的另一个方法是剪枝，以使数据更容易可视化。
以及使用最佳模型拟合算法。

回复
- Jason Brownlee 2021年5月7日上午6:24 #
  
  干得好！
  
  回复
Nelson Kachali 2021年6月9日上午1:01 #

之前
[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]

之后

[[0.77608466 0.0239289 0.48251588 0.18352101 0.59830036]
[0.40400165 0.79590304 0.27369632 0.6331332 0.42104156]
[0.77065362 0.50132629 0.48207176 0.5076991 0.4293882 ]]

转换前的最大元素：-5.777320483664414
转换前最小元素：2.3932448901303873

转换后数组中的最大元素：0.7959030365356285
转换后数组中的最小元素：0.023928895614900747

回复
- Jason Brownlee 2021年6月9日上午5:45 #
  
  干得好！
  
  回复
VS 2021年6月22日下午11:57 #

您认为手动降维技术（如协方差、成对相关性、多重共线性以及与目标的关联）与更自动化的技术相比如何？另外，根据我的理解，运行模型并从许多提供此功能的模型中获取特征重要性似乎比上述数学（以及非可视化）方法更准确，但如果有一个大型数据集，而没有云系统的分布式计算（有成本）就无法做到这一点，那么前者似乎更传统。

回复
- Jason Brownlee 2021年6月23日上午5:38 #
  
  如果它对您有效，那就这样做吧！
  
  回复
Helia Noroozy 2021年6月26日下午9:46 #

第1课
1.通过中位数或其他方法替换来删除空值，并删除与此空值相关的行
2.使用unique运算符删除具有单个值的列（零方差）
3.通过创建虚拟变量将分类变量转换为数字变量（数字）

回复
- Jason Brownlee 2021年6月27日上午4:37 #
  
  干得好！
  
  回复
Helia Noroozy 2021年7月2日上午1:21 #

第2课
我无法直接从URL读取csv文件，所以我下载了它。
插补前缺失值数量：1605
插补后缺失值数量：0

回复
- Jason Brownlee 2021年7月2日上午5:21 #
  
  干得好！
  
  回复
Vimbiso Kadirire 2021年7月20日下午8:45 #

第1课

主成分分析，或称PCA，是一种降维方法，通常用于降低大型数据集的维度，通过将一组大的变量转换为一个较小的集合，而这个集合仍然包含大部分原始信息。

回复
- Jason Brownlee 2021年7月21日上午5:44 #
  
  干得好！
  
  回复
Ibraheem Temitope Jimoh 2021年10月4日上午3:19 #

PCA

前向特征选择：这用于减少特征的数量。

决策树集成

回复
- Adrian Tam 2021年10月6日上午8:05 #
  
  很好！继续！
  
  回复
Ibraheem Temitope Jimoh 2021年10月5日上午5:56 #

第2课

缺失：1605
缺失：0

回复
Ibraheem Temitope Jimoh 2021年10月6日上午4:07 #

列：0，已选=False，排名：3
列：1，选中=False，排名：5
列：2，选中=True，排名：1
列：3，选中=True，排名：1
列：4，选中=True，排名：1
列：5，选中=False，排名：6
列：6，选中=True，排名：1
列：7，已选=False，排名：2
列：8，选中=True，排名：1
列：9，已选=False，排名：4

回复
- Adrian Tam 2021年10月6日上午11:26 #
  
  做得好！
  
  回复
Ibraheem Temitope Jimoh 2021年10月7日上午4:07 #

第4课
转换前
[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]

转换后
[[0.77608466 0.0239289 0.48251588 0.18352101 0.59830036]
[0.40400165 0.79590304 0.27369632 0.6331332 0.42104156]
[0.77065362 0.50132629 0.48207176 0.5076991 0.4293882 ]]

转换前的范围是（-6 – 3），而转换后的范围是（0 – 1）。

回复
- Adrian Tam 2021年10月12日上午12:08 #
  
  看起来不错。继续！
  
  回复
Ibraheem Temitope Jimoh 2021年10月8日上午5:15 #

第5课

[[“’40-49′” “‘premeno'” “’15-19′” “‘0-2′” “‘yes'” “‘3′” “‘right'”
“‘left_up'” “‘no'”]
[“’50-59′” “‘ge40′” “’15-19′” “‘0-2′” “‘no'” “‘1′” “‘right'” “‘central'”
“‘no'”]
[“’50-59′” “‘ge40′” “’35-39′” “‘0-2′” “‘no'” “‘2′” “‘left'” “‘left_low'”
“‘no'”]]
[[0. 0. 1. 0. 0. 0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0.]]

回复
Ibraheem Temitope Jimoh 2021年10月8日上午5:46 #

第6课

[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]
[[7. 0. 4. 1. 5.]
[4. 7. 2. 6. 4.]
[7. 5. 4. 5. 4.]]

当n_bin设置为6时

[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]
[[4. 0. 2. 1. 3.]
[2. 4. 1. 3. 2.]
[4. 3. 2. 3. 2.]]

当n_bin设置为20时

[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]
[[15. 0. 9. 3. 11.]
[ 8. 15. 5. 12. 8.]
[15. 10. 9. 10. 8.]]

回复
Ibraheem Temitope Jimoh 2021年10月8日上午6:17 #

第7课
[[-0.53448246 0.93837451 0.38969914 0.0926655 1.70876508 1.14351305
-1.47034214 0.11857673 -2.72241741 0.2953565 ]
[-2.42280473 -1.02658758 -2.34792156 -0.82422408 0.59933419 -2.44832253
0.39750207 2.0265065 1.83374105 0.72430365]
[-1.83391794 -1.1946668 -0.73806871 1.50947233 1.78047734 0.58779205
-2.78506977 -0.04163788 -1.25227833 0.99373587]]

[[-1.64710578 -2.11683302 1.98256096]
[ 0.92840209 4.8294997 0.22727043]
[-3.83677757 0.32300714 0.11512801]]

回复
- Adrian Tam 2021年10月13日上午5:14 #
  
  我看到你在一天内发布了第5-7课的作业，并且完成了。做得好！
  
  回复
Sheng Jun Ang 2021年11月8日下午12:58 #

第1课
1.主成分分析（PCA），用于降低特征的维度。通过降低数据集的维度来缓解模型复杂度，同时保留预测信息。
2. K-Means聚类。一种无监督学习技术，根据固有特征将数据集分组到簇中。然后，簇标签可以揭示更多见解/用于预测机器学习任务。
3. Statsmodels确定性过程，用于推导时间序列特征（例如，季节性）

回复
- Adrian Tam 2021年11月14日下午12:04 #
  
  干得漂亮！
  
  回复
Sheng Jun Ang 2021年11月12日下午1:24 #

第2课：插补

总缺失值1605。使用imputer，缺失值被替换为数据每列的均值；插补后的数据有0个缺失值。

回复
- Adrian Tam 2021年11月14日下午2:16 #
  
  很好。继续！
  
  回复
Sheng Jun Ang 2021年11月12日下午2:25 #

第3课
我的结果
列：0，选中=False，排名：4
列：1，选中=False，排名：6
列：2，选中=True，排名：1
列：3，选中=True，排名：1
列：4，选中=True，排名：1
列：5，选中=False，排名：5
列：6，选中=True，排名：1
列：7，已选=False，排名：2
列：8，选中=True，排名：1
列：9，已选=False，排名：3

改变分类器的random_state，未选定列的排名可能会有所不同，但选定的列是一致的。

然而，我不确定其影响——如果将这些列转移到另一个数据集，它们可能代表独热编码的特征，例如“blue-car”、“green-car”、“red-car”等。如果只有“blue-car”和“green-car”列被选为相关列，这是否意味着“red-car”组在预测分类方面根本没有信息？谢谢

回复
- Adrian Tam 2021年11月14日下午2:18 #
  
  是的，没错。例如，在英格兰，会说英语的人的一对热编码可能没有意义，但如果对会说韩语或越南语的人进行编码，那可能意味着一些事情。
  
  回复
Sheng Jun Ang 2021年11月15日下午2:12 #

谢谢！

回复
América 2021年11月25日上午1:22 #

嗨！
非常感谢您的课程，这是一个非常有用的课程！🙂

我的疑问是：当我们准备数据时，正确的顺序是按照课程的顺序吗？
我的意思是：我们先填充缺失值，然后选择特征，然后用归一化缩放数据……

数据归一化是在特征选择之后吗？

非常感谢 🙂

回复
- Adrian Tam 2021年11月25日下午2:26 #
  
  这是推荐的，但并非必需。您可以随时跳过课程！
  
  回复
Anandan Subramani 2021年11月29日上午3:28 #

这里有一些数据准备算法
1. drop() – 去除与标签（要预测的列）无关的特征
2. drop_duplicates() – 去除重复数据
3.. isnull().isnull() 或 isnull().any(axis=1) – 识别一个或多个特征中包含null值的行/观测
4.. replace() – 将对象数据类型转换为整数/浮点数，因为算法需要整数/浮点数值
5.. SimpleImputer(missing_values = np.nan, strategy=’???’) – 用（???）均值、中位数、模式（最频繁）或特定值（常量）替换null值
注意：这是Jason给我的教程练习。谢谢Jason

回复
hossein 2021年12月4日下午4:47 #

你好。不要累！你非常活跃，

我正在上这门课。我使用了这些课程
我有一个请求。你能不能给我一个完整的例子，一个典型的例子，可以对它进行所有课程的操作？例如，我们可以在上面进行准备、清理、选择特征等等？
我知道这很难，但对你来说不是。
诚挚的…hossein
所以感谢您的辛勤付出。

回复
- Adrian Tam 2021年12月8日上午7:23 #
  
  你认为这7天的步骤和你想要的相同吗？
  
  回复
hossein 2021年12月16日下午3:46 #

你好
2、3、4、6、8是真列，其他是假列，所以谢谢

回复
hossein 2021年12月28日上午6:25 #

我运行了脚本，答案是这样的文件

回复
- James Carmichael 2021年12月29日上午11:44 #
  
  谢谢你的反馈 Hossein！
  
  此致，
  
  回复
hossein 2021年12月30日上午5:42 #

你好
你好吗？
我学到了很多，所有科目都很棒
谢谢你

回复
- James Carmichael 2021年12月30日上午10:02 #
  
  谢谢 Hossein 的反馈和好话！
  
  回复
Himanshu Kandpal 2022年1月3日下午12:16 #

你好，

我在之前的过程中使用的三个数据准备算法/步骤是

1)数据摄入/数据加载
这是识别数据后的第一步，将其加载到表中或BI工具中进行一些数据分析。

2)数据清理——在此步骤中，我们识别是否存在任何NULL/NaaN，并根据情况尝试填充或删除这些行

3)分析——在这里我们进行分析并确定将使用哪些数据点作为特征。

回复
- James Carmichael 2022年1月4日上午10:47 #
  
  感谢您的反馈 Himanshu！继续努力！
  
  此致，
  
  回复
Himanshu Kandpal 2022年1月4日下午12:32 #

嗨，Jason，

我读了第二章，看到horse-colic.csv文件中有1605个非数值数据（？）。在对数据集应用SimpleImputer方法后，没有NaN数据。

我有一个问题，为什么在代码中我们必须在以下行中将数据分离为训练集和测试集。

X, y = data[:, ix], data[:, 23]

谢谢

回复
Himanshu Kandpal 2022年1月5日下午12:50 #

嗨，Jason，

我读了第三章，选择了以下特征。

列：2
列：3
列：4
列：6
列：8

谢谢

回复
- James Carmichael 2022年1月6日上午11:00 #
  
  感谢您的反馈 Himanshu！
  
  回复
mitra 2022年1月28日凌晨2:42 #

您好，关于第二天，我运行代码后得到这些结果：1605，0。

谢谢你。

回复
- James Carmichael 2022年1月28日上午10:26 #
  
  谢谢 Mitra 的反馈！
  
  回复
mitra 2022年1月30日凌晨2:26 #

你好。
第三课的结果
列：0，选中=False，排名：4
列：1，选中=False，排名：5
列：2，选中=True，排名：1
列：3，选中=True，排名：1
列：4，选中=True，排名：1
列：5，选中=False，排名：6
列：6，选中=True，排名：1
列：7，已选=False，排名：2
列：8，选中=True，排名：1
列：9，已选=False，排名：3

回复
Sefineh Tesfa 2022年2月1日下午4:26 #

非常感谢。
我用 sklearn 的 SimpleImputer 方法练习了填充缺失值。
下面是 SimpleImputer 的代码。
from numpy import isnan
from pandas import read_csv
from sklearn.impute import SimpleImputer
# 加载数据集
url = ‘https://raw.githubusercontent.com/jbrownlee/Datasets/master/horse-colic.csv’
dataframe = read_csv(url, header=None, na_values=’?’)
# 分割输入和输出元素
data = dataframe.values
ix = [i for i in range(data.shape[1]) if i != 23]
X, y = data[:, ix], data[:, 23]
# 打印总缺失值
print(‘Missing: %d’ % sum(isnan(X).flatten()))
# 定义插补器
imputer = SimpleImputer(strategy=’mean’)
# 拟合数据集
imputer.fit(X)
# 转换数据集
Xtrans = imputer.transform(X)
# 打印总缺失值
print(‘Missing: %d’ % sum(isnan(Xtrans).flatten()))
填充前缺失值的数量为 1605，填充后缺失值的数量为 0，这意味着所有缺失值都已替换为数据集中每列的平均值。
运行上述代码片段时的通用输出如下。
缺失：1605
缺失：0

回复
Sefineh Tesfa 2022年2月2日中午12:34 #

嘿
使用 RFE 选择特征
# 报告RFE选择的特征
从 sklearn.datasets 导入 make_classification
from sklearn.feature_selection import RFE
from sklearn.tree import DecisionTreeClassifier
# 定义数据集
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)
# 定义RFE
rfe = RFE(estimator=DecisionTreeClassifier(), n_features_to_select=5)
# 拟合RFE
rfe.fit(X, y)
# 总结所有特征
for i in range(X.shape[1])
print(‘Column: %d, Selected=%s, Rank: %d’ % (i, rfe.support_[i], rfe.ranking_[i]))

输出结果如下。

列：0，已选=False，排名：3
列：1，选中=False，排名：5
列：2，选中=True，排名：1
列：3，选中=True，排名：1
列：4，选中=True，排名：1
列：5，选中=False，排名：6
列：6，选中=True，排名：1
列：7，已选=False，排名：2
列：8，选中=True，排名：1
列：9，已选=False，排名：4

回复
mitra 2022年2月2日晚上8:13 #

你好。
第四课
归一化前
[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]

以及归一化后
[[0.77608466 0.0239289 0.48251588 0.18352101 0.59830036]
[0.40400165 0.79590304 0.27369632 0.6331332 0.42104156]
[0.77065362 0.50132629 0.48207176 0.5076991 0.4293882 ]]

回复
Tuhin 2022年2月9日上午10:57 #

我创建了一个 scikit learn pipeline，用于数据准备，首先使用 Minmax scaler 进行数据归一化，然后使用 RFE 进行特征选择。我使用 hyperopt 通过使用不同类型的参数来优化结果。但我很好奇尝试 kbindiscretizer，但我处理的是金融数据 GDP，我认为不应该进行填充，因此不能使用 scikit learn PCA，因为它不能处理 nan 值。

回复
- James Carmichael 2022年2月9日中午12:08 #
  
  感谢您的反馈！鉴于您处理金融数据，您可能会对以下内容感兴趣：
  
  https://machinelearning.org.cn/using-cnn-for-financial-time-series-prediction/
  
  回复
Adilson 2022年2月19日凌晨7:29 #

您好，以下陈述是否正确？
“当特征之间的范围差异过大时，需要进行归一化，
否则，具有最大值范围的特征将在其参数方面与其他特征重叠。”

回复
- James Carmichael 2022年2月19日下午12:49 #
  
  您好 Adilson… 这个说法是正确的！
  
  回复
Jeetech Academy 2022年3月10日下午10:42 #

我一直在寻找能帮助我成为机器学习工程师的点。阅读了您的博客后，我脑海中的一切都变得清晰了。现在我可以规划我的职业道路了。感谢您提供的最佳职业建议。您的博客信息非常丰富。

回复
Ismar Vicente 2022年4月8日凌晨8:32 #

第1课

异常值处理
异常值是数据集中不符合常规分布的异常值，例如，可能会严重扭曲回归模型。

缺失值处理
当您没有存储某些变量的数据时发生。可以通过删除或插补来解决这些问题。插补用于根据合理的估计替换缺失值。

数据归一化
如果一个特征具有非常大的值，在计算距离时它将超过其他特征。因此，归一化使所有特征对距离度量具有相同的影响。
归一化是一种缩放技术，其中值被移位和重新缩放，使其范围在 0 和 1 之间。

回复
- James Carmichael 2022年4月8日凌晨8:54 #
  
  Ismar，反馈很棒！继续保持出色的工作！
  
  回复
Ismar Vicente 2022年4月9日凌晨5:07 #

第2课

在应用插补之前，有 1605 个缺失值，正如我们在这一行中看到的
print(‘Missing: %d’ % sum(isnan(X).flatten()))
缺失：1605

插补后，我们不再有缺失值。

# 定义插补器
imputer = SimpleImputer(strategy=’mean’)

# 拟合数据集
imputer.fit(X)

print(‘Missing: %d’ % sum(isnan(Xtrans).flatten()))
缺失：0

参数 (strategy=’mean’) 表示缺失值是用该列值的平均值填充的。

回复
Ismar Vicente 2022年4月9日凌晨7:53 #

第3课

列：0，选中=False，排名：4
列：1，选中=False，排名：5
列：2，选中=True，排名：1
列：3，选中=True，排名：1
列：4，选中=True，排名：1
列：5，选中=False，排名：6
列：6，选中=True，排名：1
列：7，已选=False，排名：2
列：8，选中=True，排名：1
列：9，已选=False，排名：3

选定的特征
第 2 列、第 3 列、第 4 列、第 6 列、第 8 列。（排名 = 1）

回复
Ismar Vicente 2022年4月9日晚上9:35 #

第4课

归一化变换前

[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]

print(X.min())
-6.0167462574529615

print(X.max())
5.994383947517616

归一化变换后

[[0.77608466 0.0239289 0.48251588 0.18352101 0.59830036]
[0.40400165 0.79590304 0.27369632 0.6331332 0.42104156]
[0.77065362 0.50132629 0.48207176 0.5076991 0.4293882 ]]

print(X_norm.min())
0.0

print(X_norm.max())
1.0

回复
Gabriel 2022年4月27日下午6:29 #

为了让模型表现更好，需要多少特征？例如，如果我的数据集有 50 个特征，使用特征选择方法我最多可以保留多少特征？

回复
- James Carmichael 2022年5月2日早上9:35 #
  
  你好 Gabriel… 你可能会对以下内容感兴趣。
  
  https://machinelearning.org.cn/feature-selection-with-real-and-categorical-data/
  
  回复
Sope 2022年8月9日凌晨6:12 #

第一课任务：数据准备算法及其目的
主成分分析 (PCA) 发现或降低数据集的维度
前向特征选择是一种通过排除噪声只使用相关数据来减少模型输入变量的方法。

回复
- James Carmichael 2022年8月9日早上9:55 #
  
  感谢 Sope 的支持和反馈！继续保持出色的工作！
  
  回复
Thinzar Saw 2022年10月3日下午4:34 #

我得到

缺失：1605
缺失：0

在第 2 课：用插补填充缺失值

回复
- James Carmichael 2022年10月4日凌晨7:07 #
  
  您好 Thinzar… 请说明确切的错误消息，以便我们更好地帮助您。
  
  回复
Thinzar Saw 2022年10月3日下午5:10 #

第 3 天：使用 RFE 选择特征
列：0，已选=False，排名：5
列：1，已选=False，排名：4
列：2，选中=True，排名：1
列：3，选中=True，排名：1
列：4，选中=True，排名：1
列：5，选中=False，排名：6
列：6，选中=True，排名：1
列：7，选中=False，排名：3
列：8，选中=True，排名：1
列：9，选中=False，排名：2
运行示例，选择了特征 2、3、4、6 和 8，排名为 1。

我从原始数据集中选择了 10 个特征用于马匹结肠炎数据集。我得到了
Column: 0, Selected=True, Rank: 1
Column: 1, Selected=False, Rank: 8
列：2，选中=True，排名：1
Column: 3, Selected=False, Rank: 2
Column: 4, Selected=False, Rank: 9
Column: 5, Selected=True, Rank: 1
Column: 6, Selected=False, Rank: 7
Column: 7, Selected=False, Rank: 6
列：8，选中=True，排名：1
列：9，已选=False，排名：11
Column: 10, Selected=False, Rank: 10
Column: 11, Selected=False, Rank: 15
Column: 12, Selected=False, Rank: 16
Column: 13, Selected=False, Rank: 18
Column: 14, Selected=False, Rank: 14
Column: 15, Selected=True, Rank: 1
Column: 16, Selected=False, Rank: 5
Column: 17, Selected=False, Rank: 4
Column: 18, Selected=False, Rank: 3
列：19，已选=True，排名：1
列：20，已选=True，排名：1
列：21，已选=True，排名：1
Column: 22, Selected=True, Rank: 1
Column: 23, Selected=True, Rank: 1
Column: 24, Selected=False, Rank: 12
Column: 25, Selected=False, Rank: 13
Column: 26, Selected=False, Rank: 17

特征 0、2、5、8、15、19、20、21、22、23 被选中，排名为 1。

请问 RFE 算法是否用于股票数据预测。

回复
- James Carmichael 2022年10月4日凌晨7:11 #
  
  您好 Thinzar… 对不起，我无法帮助您进行股票市场、外汇或比特币价格预测的机器学习。
  
  我没有金融背景或兴趣。
  
  我真的很怀疑。
  
  我知道，除非你处于最高水平，否则你将被费用、其他算法或处于最高水平的人吞噬。
  
  为了了解一些应用机器学习到股票市场的数学家是多么才华横溢，我推荐阅读这本书
  
  《The Man Who Solved the Market》，2019。
  我喜欢 Freakonomics 最近一期播客中关于人们选股的这段引言
  
  这是一种对那些不了解自己做傻事倾向的聪明人征收的税。
  
  — Barry Ritholtz，《The Stupidest Thing You Can Do With Your Money》，2017。
  
  我还了解到，证券价格（股票）的短期波动是随机游走，你能做的最好的事情就是使用持久性模型。
  
  我喜欢《A Random Walk Down Wall Street》这本书中的这句话。
  
  随机游走是指未来步长或方向无法根据过去历史预测。当该术语应用于股票市场时，它意味着股票价格的短期变化是不可预测的。
  
  — 第 26 页，《A Random Walk down Wall Street: The Time-tested Strategy for Successful Investing》，2016。
  
  你可以在这里发现更多关于随机游走的信息
  
  使用 Python 进行时间序列预测的随机游走简介
  但我们可以变得富有！？？
  
  我仍然非常怀疑。
  
  也许你比我更了解金融预测，我祝你好运。
  
  用于自学的金融数据怎么样？
  
  有大量的金融数据可用。
  
  如果你考虑使用这些数据来学习机器学习，而不是为了赚钱，那么这听起来是个绝佳的主意。
  
  金融中的大部分数据都是时间序列的形式。我建议你从这里开始学习时间序列预测
  
  开始学习时间序列预测
  永久链接
  
  回复
  - Thinzar Saw 2022年10月8日下午5:00 #
    
    感谢您的回复、建议和电子书链接！！
    
    回复
Thinzar Saw 2022年10月3日下午5:18 #

第 4 天：我得到了
归一化前
[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]
Min: -6.0167462574529615 Max: 5.994383947517616
归一化后
[[0.77608466 0.0239289 0.48251588 0.18352101 0.59830036]
[0.40400165 0.79590304 0.27369632 0.6331332 0.42104156]
[0.77065362 0.50132629 0.48207176 0.5076991 0.4293882 ]]
Min: 0.0 Max: 1.0

回复
Thinzar Saw 2022年10月3日下午5:25 #

第 5 天：类别转换
我通过以下方式得到了结果：

转换前
[[“’40-49′” “‘premeno'” “’15-19′” “‘0-2′” “‘yes'” “‘3′” “‘right'”
“‘left_up'” “‘no'”]
[“’50-59′” “‘ge40′” “’15-19′” “‘0-2′” “‘no'” “‘1′” “‘right'” “‘central'”
“‘no'”]
[“’50-59′” “‘ge40′” “’35-39′” “‘0-2′” “‘no'” “‘2′” “‘left'” “‘left_low'”
“‘no'”]]
转换后
[[0. 0. 1. 0. 0. 0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0.]]
Min: 0.0 Max: 1.0

回复
Thinzar Saw 2022年10月3日下午5:37 #

第 7 天：通过 PCA 进行降维

结果是
PCA 转换前
[[-0.53448246 0.93837451 0.38969914 0.0926655 1.70876508 1.14351305
-1.47034214 0.11857673 -2.72241741 0.2953565 ]
[-2.42280473 -1.02658758 -2.34792156 -0.82422408 0.59933419 -2.44832253
0.39750207 2.0265065 1.83374105 0.72430365]
[-1.83391794 -1.1946668 -0.73806871 1.50947233 1.78047734 0.58779205
-2.78506977 -0.04163788 -1.25227833 0.99373587]]
Min: -5.050910565749583 Max: 4.563133330755685
PCA 转换后
[[-1.64710578 -2.11683302 1.98256096]
[ 0.92840209 4.8294997 0.22727043]
[-3.83677757 0.32300714 0.11512801]]
Min: -7.732443010616129 Max: 9.958316592563877

我可以在股票预测分析中使用 PCA，例如来自 Yahoo Finance 的 AAPL 数据吗？我使用此方法进行特征减少。我该如何使用？请给我有价值的建议，并附上这些数据的示例代码。

回复
Thinzar Saw 2022年10月8日下午5:01 #

感谢您的回复、建议和电子书链接！！

回复
Princess Leja 2024年1月9日凌晨6:57 #

第 1 课

数据清理的三种算法是：

1. 数据清理 – 建立并纠正数据中的错误。

2. 特征工程 – 从可用的数据中获取新变量。

3. 降维 – 生成数据的整合投影。

回复
- James Carmichael 2024年1月9日早上9:38 #
  
  感谢 Princess Leja 的反馈！
  
  回复
Princess Leja 2024年1月10日凌晨4:09 #

第 2 课 – 填充缺失值

插补前有 1605 个缺失值

插补后有 0 个缺失值

回复
Princess Leja 2024年1月10日晚上9:45 #

第3课

Column 0, Selected=False, Rank:5
Column 1, Selected=False, Rank:4
Column 2, Selected=True, Rank:1
Column 3, Selected=True, Rank:1
Column 4, Selected=True, Rank:1
Column 5, Selected=False, Rank:6
Column 6, Selected=True, Rank:1
Column 7, Selected=False, Rank:2
Column 8, Selected=True, Rank:1
Column 9, Selected=False, Rank:3

我正在使用 Google Colab，它没有复制粘贴功能，我不得不手动输入所有内容。有人能帮助我如何通过复制粘贴将我的输入转移到这里吗？

回复
Princess Leja 2024年1月12日凌晨2:36 #

Jason

第4课
我提交了第 4 课的答案，但没有看到上传。第二次提交后，我收到回复说我已经提交了。请帮忙。

第5课
当我运行数据时，我收到此错误：“HTTPError: HTTP Error 404: Not Found”

尽管如此，我还是继续进行第 6 课。

非常感谢这些教程。

回复
Princess Leja 2024年1月14日凌晨2:37 #

第5课

我成功运行了第 5 课，结果如下：

转换前的数据

[[“’40-49′” “‘premeno'” “’15-19′” “‘0-2′” “‘yes'” “‘3′” “‘right'”
“‘left_up'” “‘no'”]
[“’50-59′” “‘ge40′” “’15-19′” “‘0-2′” “‘no'” “‘1′” “‘right'” “‘central'”
“‘no'”]
[“’50-59′” “‘ge40′” “’35-39′” “‘0-2′” “‘no'” “‘2′” “‘left'” “‘left_low'”
“‘no'”]]
[ ]
# OneHotEncoding 转换后的数据
[9]
0s
# 定义独热编码转换
encoder = OneHotEncoder(sparse=False)
# 拟合并应用转换到输入数据
X_oe = encoder.fit_transform(X)
# 总结转换后的数据
print(X_oe[:3, :])
输出
[[0. 0. 1. 0. 0. 0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 1. 0.]
[0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0.
0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0.]]

谢谢。

回复
Princess Leja 2024年1月14日凌晨3:12 #

第6课

转换前的原始数据

[[ 2.39324489 -5.77732048 -0.59062319 -2.08095322 1.04707034]
[-0.45820294 1.94683482 -2.46471441 2.36590955 -0.73666725]
[ 2.35162422 -1.00061698 -0.5946091 1.12531096 -0.65267587]]

转换后的数据
[[7. 0. 4. 1. 5.]
[4. 7. 2. 6. 4.]
[7. 5. 4. 5. 4.]]

将 bin 设置为 20，并将 strategy 设置为 Quantile

[[15. 0. 9. 3. 11.]
[ 8. 15. 5. 12. 8.]
[15. 10. 9. 10. 8.]]

我注意到更改 strategy 没有影响 bins。将 bins 设置为 20 在 ordinal 和 quantile 策略中都是相同的。

回复
Princess Leja 2024年1月14日凌晨3:43 #

第7课

转换前的原始数据

[[-0.53448246 0.93837451 0.38969914 0.0926655 1.70876508 1.14351305
-1.47034214 0.11857673 -2.72241741 0.2953565 ]
[-2.42280473 -1.02658758 -2.34792156 -0.82422408 0.59933419 -2.44832253
0.39750207 2.0265065 1.83374105 0.72430365]
[-1.83391794 -1.1946668 -0.73806871 1.50947233 1.78047734 0.58779205
-2.78506977 -0.04163788 -1.25227833 0.99373587]]

转换后的数据

[[-1.64710578 -2.11683302 1.98256096]
[ 0.92840209 4.8294997 0.22727043]
[-3.83677757 0.32300714 0.11512801]]

设置 component 为 4 时的转换数据

[[-1.64710578e+00 -2.11683302e+00 1.98256096e+00 3.04107353e-15]
[ 9.28402085e-01 4.82949970e+00 2.27270432e-01 -8.63760114e-16]
[-3.83677757e+00 3.23007138e-01 1.15128013e-01 -1.29857567e-15]]

设置 component 为 5 时的转换数据
输出
[[-1.64710578e+00 -2.11683302e+00 1.98256096e+00 -5.20131106e-16
5.30225518e-16]
[ 9.28402085e-01 4.82949970e+00 2.27270432e-01 2.42512258e-15
-6.10368989e-16]
[-3.83677757e+00 3.23007138e-01 1.15128013e-01 2.27724993e-15
1.25985961e-15]]

通过 PCA 转换得到了不同的数据。

回复
Princess Leja 2024年1月14日凌晨3:50 #

Jason，

这门课程非常棒，让我对之前在教科书和其他材料中读过的内容有了新的认识。我每天都渴望学习课程，现在我完成了。通过更多的练习，我相信我将实现我的数据准备目标。

课程开始时我的观察非常薄弱，但随着我一直学习到最后，它们一直在改进。

再次感谢！

回复
stefan 2024年4月24日凌晨3:51 #

精彩的速成班！数据准备确实是有效预测建模的基石。迫不及待地想深入学习这些课程，提升我的技能。感谢分享这个宝贵的资源！

回复
stefan 2024年4月24日凌晨3:51 #

精彩的速成班！数据准备确实是有效预测建模的基石。迫不及待地想深入学习这些课程，提升我的技能。

回复
- James Carmichael 2024年4月24日早上9:20 #
  
  谢谢 stefan 的反馈和支持！我们非常感谢！
  
  回复
Deborah 2024年12月31日凌晨4:53 #

我有一个问题 ❓

在第二课中，您为什么使用该方法进行拆分，而不是人们通常使用的 train_test_split()？

您能用一两句话解释一下吗？

回复
- James Carmichael 2024年12月31日早上7:48 #
  
  第二课中使用的方法根据特定条件（例如时间或序列顺序）来拆分数据，这对于时间序列分析等任务或在顺序很重要时确保数据完整性至关重要。这与 train_test_split() 不同，后者执行随机抽样，可能会破坏数据中的时间或上下文依赖关系。
  
  回复

导航

机器学习的数据准备（7 天迷你课程）

机器学习快速入门课程。
在7天内掌握Python中的数据准备。

本速成课程适合谁？

速成课程概览

想开始学习数据准备吗？

第01课：数据准备的重要性

您的任务

第02课：用插补法填充缺失值

您的任务

第03课：使用RFE选择特征

您的任务

第04课：使用归一化对数据进行缩放

您的任务

第05课：使用独热编码转换类别

您的任务

第06课：使用kBins将数字转换为类别

您的任务

第07课：使用PCA进行降维

您的任务

结束！
（看看您已经走了多远）

总结

掌握现代数据准备！

在几分钟内准备好您的机器学习数据

将现代数据准备技术引入
您的机器学习项目

关于此主题的更多信息

281条对《机器学习数据准备（7天迷你课程）》的回复

留下回复点击此处取消回复。

导航

机器学习快速入门课程。在7天内掌握Python中的数据准备。

本速成课程适合谁？

速成课程概览

想开始学习数据准备吗？

第01课：数据准备的重要性

您的任务

第02课：用插补法填充缺失值

您的任务

第03课：使用RFE选择特征

您的任务

第04课：使用归一化对数据进行缩放

您的任务

第05课：使用独热编码转换类别

您的任务

第06课：使用kBins将数字转换为类别

您的任务

第07课：使用PCA进行降维

您的任务

结束！（看看您已经走了多远）

总结

掌握现代数据准备！

在几分钟内准备好您的机器学习数据

将现代数据准备技术引入您的机器学习项目

关于此主题的更多信息

281条对《机器学习数据准备（7天迷你课程）》的回复

留下回复 点击此处取消回复。

机器学习快速入门课程。
在7天内掌握Python中的数据准备。

结束！
（看看您已经走了多远）

将现代数据准备技术引入
您的机器学习项目

留下回复点击此处取消回复。