Python 机器学习 基础 之 【常用机器学习库】 Pandas 数据处理库

Python 机器学习 基础 之 【常用机器学习库】 Pandas 数据处理库

目录

Python 机器学习 基础 之 【常用机器学习库】 Pandas 数据处理库

一、简单介绍

二、Pandas 基础

1、安装 Pandas

2、导入 Pandas

3、基本数据结构

3.1 Series

3.2 DataFrame

4、基本操作

4.1 查看数据

4.2 选取数据

4.3 数据过滤

4.4 添加/删除列

4.5 处理缺失值

5、数据操作

5.1 数据分组

5.2 数据合并

5.3 数据透视表

6、输入输出

6.1 读取数据

6.2 写入数据

三、在机器学习中使用到 Pandas 的简单示例

1、数据加载和探索

1.1 加载数据

1.2 数据清洗

2、特征工程

2.1 创建新特征

2.2 特征编码

3、特征选择

4、数据分割

5、简单线性回归

5.1 生成数据

5.2 训练模型

5.3 预测

6、可视化

7、时间序列分析

一、简单介绍

Python是一种跨平台的计算机程序设计语言。是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。Python是一种解释型脚本语言，可以应用于以下领域： Web 和 Internet开发、科学计算和统计、人工智能、教育、桌面界面开发、软件开发、后端开发、网络爬虫。

Python 机器学习是利用 Python 编程语言中的各种工具和库来实现机器学习算法和技术的过程。Python 是一种功能强大且易于学习和使用的编程语言，因此成为了机器学习领域的首选语言之一。Python 提供了丰富的机器学习库，如Scikit-learn、TensorFlow、Keras、PyTorch等，这些库包含了许多常用的机器学习算法和深度学习框架，使得开发者能够快速实现、测试和部署各种机器学习模型。

Python 机器学习涵盖了许多任务和技术，包括但不限于：

  1. 监督学习：包括分类、回归等任务。
  2. 无监督学习：如聚类、降维等。
  3. 半监督学习：结合了有监督和无监督学习的技术。
  4. 强化学习：通过与环境的交互学习来优化决策策略。
  5. 深度学习：利用深度神经网络进行学习和预测。

通过 Python 进行机器学习，开发者可以利用其丰富的工具和库来处理数据、构建模型、评估模型性能，并将模型部署到实际应用中。Python 的易用性和庞大的社区支持使得机器学习在各个领域都得到了广泛的应用和发展。

二、Pandas 基础

Pandas 是一个强大的 Python 数据分析库，常用于数据清洗和分析。它提供了数据结构和数据分析工具，特别是在处理表格数据时非常方便。Pandas 是机器学习数据处理的基础之一，因此熟练掌握它非常重要。本文将介绍 Pandas 的基本概念和操作。

1、安装 Pandas

在开始之前，请确保已安装 Pandas。您可以使用以下命令安装：

pip install pandas

2、导入 Pandas

在使用 Pandas 之前，需要先导入它。通常我们会用 pd 作为 Pandas 的别名：

import pandas as pd

3、基本数据结构

Pandas 主要有两个数据结构：Series 和 DataFrame。

3.1 Series

Series 是带标签的一维数组。

import pandas as pd# 创建一个 Series
s = pd.Series([1, 2, 3, 4, 5])
print(s)
# 输出结果：
# 0    1
# 1    2
# 2    3
# 3    4
# 4    5
# dtype: int64# 自定义索引
s = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])
print(s)
# 输出结果：
# a    1
# b    2
# c    3
# d    4
# e    5
# dtype: int64

在这段代码中：

  1. 首先创建了一个默认整数索引的Series对象s，包含元素1到5。
  2. 然后创建了另一个Series对象，这次提供了自定义的索引index=['a', 'b', 'c', 'd', 'e']，使得每个元素与一个特定的字符串索引相对应。

pandas.Series是一个一维数组结构，可以包含任何数据类型（整数、字符串、浮点数、Python对象等），并且可以有一个标签化的索引。在上面的示例中，第一个Series使用默认的整数索引，第二个Series使用自定义的字符串索引。

3.2 DataFrame

DataFrame 是一个带标签的二维表格数据结构，可以看作是由多个 Series 组成的字典。

import pandas as pd# 从字典创建 DataFrame
data = {'Name': ['Tom', 'Jerry', 'Mickey'],'Age': [25, 22, 23],'City': ['New York', 'Los Angeles', 'Chicago']
}df = pd.DataFrame(data)
print(df)
# 输出结果：
#    Name  Age         City
# 0   Tom   25     New York
# 1  Jerry   22  Los Angeles
# 2 Mickey   23      Chicago

在这段代码中，首先定义了一个字典data，其中包含三个键（'Name', 'Age', 'City'），每个键对应一个列表，列表中包含了相应的值。然后使用pd.DataFrame(data)从这个字典创建了一个DataFrame对象df。

DataFrame是pandas库中用于存储表格数据的主要数据结构，类似于Excel中的表格或SQL数据库中的表。在这个DataFrame中，字典的每个键成为一列的列名，每个键对应的列表成为列的值。

打印df将显示这个表格数据，其中包含了索引（默认为0, 1, 2...）和列标题（'Name', 'Age', 'City'）。每行显示一个记录，对应字典中的一个元素。

4、基本操作

4.1 查看数据
import pandas as pd# 从字典创建 DataFrame
data = {'Name': ['Tom', 'Jerry', 'Mickey'],'Age': [25, 22, 23],'City': ['New York', 'Los Angeles', 'Chicago']
}df = pd.DataFrame(data)# 查看前几行数据
print(df.head())
# 输出结果：
#    Name  Age         City
# 0   Tom   25     New York
# 1  Jerry   22  Los Angeles
# 2 Mickey   23      Chicago# 查看数据维度
print(df.shape)
# 输出结果：
# (3, 3)# 查看数据列名
print(df.columns)
# 输出结果：
# Index(['Name', 'Age', 'City'], dtype='object')# 查看数据类型
print(df.dtypes)
# 输出结果：
# Name       object
# Age        int64
# City      object
# dtype: object

在这段代码中：

  • 使用df.head()打印了DataFrame的前3行，默认情况下head()显示前5行。
  • 使用df.shape打印了DataFrame的维度，格式为(行数, 列数)。
  • 使用df.columns打印了DataFrame的列名，返回一个包含列名的Index对象。
  • 使用df.dtypes打印了DataFrame中每列的数据类型，返回一个包含每列数据类型的Series。

4.2 选取数据
import pandas as pd# 从字典创建 DataFrame
data = {'Name': ['Tom', 'Jerry', 'Mickey'],'Age': [25, 22, 23],'City': ['New York', 'Los Angeles', 'Chicago']
}df = pd.DataFrame(data)# 选取列
print(df['Name'])
# 输出结果：
# 0       Tom
# 1     Jerry
# 2    Mickey
# Name: Name, dtype: object# 选取多列
print(df[['Name', 'City']])
# 输出结果：
#    Name         City
# 0   Tom     New York
# 1  Jerry  Los Angeles
# 2 Mickey      Chicago# 选取行
print(df.loc[0])
# 输出结果：
# Name    Tom
# Age       25
# City  New York
# Name: 0, dtype: object# 选取多行
print(df.loc[0:1])
# 输出结果：
#   Name  Age         City
# 0  Tom   25     New York
# 1 Jerry   22  Los Angeles# 通过索引选取
print(df.iloc[0])
# 输出结果：
# Name    Tom
# Age     25
# City  New York
# dtype: object

在这段代码中：

  • 使用df['Name']选取了DataFrame中名为'Name'的列。
  • 使用df[['Name', 'City']]选取了DataFrame中'Name'和'City'两列，返回一个新的DataFrame。
  • 使用df.loc[0]选取了DataFrame中索引为0的行，.loc是基于标签的索引。
  • 使用df.loc[0:1]选取了DataFrame中索引从0到1的行（包含0和1），返回一个新的DataFrame。
  • 使用df.iloc[0]选取了DataFrame中第一个元素（默认从0开始计数），.iloc是基于整数位置的索引。

4.3 数据过滤
import pandas as pd# 从字典创建 DataFrame
data = {'Name': ['Tom', 'Jerry', 'Mickey'],'Age': [25, 22, 23],'City': ['New York', 'Los Angeles', 'Chicago']
}df = pd.DataFrame(data)# 按条件过滤
print(df[df['Age'] > 22])
# 输出结果：
#    Name  Age         City
# 0   Tom   25     New York
# 2 Mickey   23      Chicago

在这段代码中，使用条件过滤的方式选取了DataFrame中'Age'列大于22的行。条件df['Age'] > 22生成了一个布尔序列，然后这个布尔序列被用作索引来从df中选择行。结果是一个包含满足条件的所有行的新DataFrame。在这个例子中，只有索引为0（Tom）和索引为2（Mickey）的行的'Age'大于22。

4.4 添加/删除列
import pandas as pd# 从字典创建 DataFrame
data = {'Name': ['Tom', 'Jerry', 'Mickey'],'Age': [25, 22, 23],'City': ['New York', 'Los Angeles', 'Chicago']
}df = pd.DataFrame(data)# 添加新列
df['Salary'] = [50000, 60000, 55000]
print(df)
# 输出结果：
#    Name  Age         City  Salary
# 0   Tom   25     New York  50000
# 1 Jerry   22  Los Angeles  60000
# 2 Mickey   23      Chicago  55000# 删除列
df.drop('Salary', axis=1, inplace=True)
print(df)
# 输出结果：
#    Name  Age         City
# 0   Tom   25     New York
# 1 Jerry   22  Los Angeles
# 2 Mickey   23      Chicago

在这段代码中：

  1. 首先创建了一个包含姓名、年龄和城市的DataFrame。
  2. 使用df['Salary'] = [50000, 60000, 55000]添加了一个名为'Salary'的新列，其中包含每个人的工资。
  3. 打印添加新列后的DataFrame。
  4. 使用df.drop('Salary', axis=1, inplace=True)删除了'Salary'列。参数axis=1表示操作的是列而不是行，inplace=True表示直接在原地修改df而不是创建一个新的DataFrame。
  5. 打印删除列后的DataFrame。

4.5 处理缺失值
import pandas as pd# 创建包含缺失值的 DataFrame
data = {'Name': ['Tom', 'Jerry', 'Mickey'],'Age': [25, None, 23],'City': ['New York', 'Los Angeles', None]
}df = pd.DataFrame(data)
print(df)
# 输出结果：
#    Name   Age       City
# 0   Tom  25.0  New York
# 1 Jerry   NaN  Los Angeles
# 2 Mickey  23.0       NaN# 填充缺失值
df.fillna({'Age': df['Age'].mean(), 'City': 'Unknown'}, inplace=True)
print(df)
# 输出结果：
#    Name   Age       City
# 0   Tom  25.0  New York
# 1 Jerry  24.0  Los Angeles
# 2 Mickey  23.0       Unknown# 删除包含缺失值的行
df.dropna(inplace=True)
print(df)
# 输出结果：
#     Name   Age         City
# 0     Tom  25.0     New York
# 1   Jerry  24.0  Los Angeles
# 2  Mickey  23.0      Unknown

在这段代码中：

  1. 首先创建了一个包含缺失值的DataFrame。None表示数据缺失。
  2. 使用df.fillna()方法填充缺失值。df['Age'].mean()计算了'Age'列的平均值，并将该值用于填充'Age'列的缺失值。'Unknown'用于填充'City'列的缺失值。inplace=True表示直接在原地修改df。
  3. 打印填充缺失值后的DataFrame。
  4. 使用df.dropna()方法删除包含缺失值的行。inplace=True表示直接在原地修改df。

5、数据操作

5.1 数据分组
import pandas as pddata = {'Name': ['Tom', 'Jerry', 'Mickey', 'Tom', 'Jerry'],'Age': [25, 22, 23, 25, 22],'City': ['New York', 'Los Angeles', 'Chicago', 'New York', 'Los Angeles'],'Score': [85, 90, 88, 92, 95]
}df = pd.DataFrame(data)
print(df)
# 输出结果：
#    Name  Age         City  Score
# 0   Tom   25     New York     85
# 1 Jerry   22  Los Angeles     90
# 2 Mickey   23      Chicago     88
# 3   Tom   25     New York     92
# 4 Jerry   22  Los Angeles     95# 按名字分组并计算平均成绩
grouped = df.groupby('Name')['Score'].mean()
print(grouped)
# 输出结果：
# Name
# Jerry    92.5
# Mickey   88.0
# Tom      88.5
# Name: Score, dtype: float64

在这段代码中：

  1. 首先创建了一个包含姓名、年龄、城市和分数的DataFrame。
  2. 打印了原始的DataFrame。
  3. 使用df.groupby('Name')按'Name'列对数据进行分组，并使用['Score'].mean()计算每个分组的'Score'列的平均值。
  4. 打印了按名字分组后计算的平均成绩。结果是一个Series，索引是名字，值是对应的平均分数。

5.2 数据合并
import pandas as pddata1 = {'Name': ['Tom', 'Jerry', 'Mickey'],'Age': [25, 22, 23]
}data2 = {'Name': ['Tom', 'Jerry', 'Mickey'],'Score': [85, 90, 88]
}df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)# 按名字合并
merged = pd.merge(df1, df2, on='Name')
print(merged)
# 输出结果：
#    Name  Age  Score
# 0   Tom   25     85
# 1 Jerry   22     90
# 2 Mickey   23     88

在这段代码中：

  1. 创建了两个不同的字典data1和data2，分别包含姓名、年龄和姓名、分数的信息。
  2. 将这两个字典转换为两个DataFrame对象df1和df2。
  3. 使用pd.merge(df1, df2, on='Name')按'Name'列合并这两个DataFrame。on='Name'指定了合并的依据是'Name'列。
  4. 打印了合并后的DataFrame``merged，其中包含了每个名字对应的年龄和分数。

5.3 数据透视表
import pandas as pd# 从字典创建 DataFrame
data = {'Name': ['Tom', 'Jerry', 'Mickey'],'Age': [25, 22, 23],'City': ['New York', 'Los Angeles', 'Chicago'],'Score': [85, 90, 88]
}df = pd.DataFrame(data)# 创建透视表
pivot = df.pivot_table(index='Name', columns='City', values='Score', aggfunc='mean')
print(pivot)
# 输出结果：
# 由于透视表中每个Name和City的组合应该是唯一的，并且这里的数据不是这样的，
# 所以实际的输出结果会是最后一个匹配的值，具体如下：
# City  Chicago  Los Angeles  New York
# Name
# Jerry       NaN         90.0       NaN
# Mickey     88.0          NaN       NaN
# Tom         NaN          NaN      85.0

在这段代码中：

  1. 创建了一个包含姓名、年龄、城市和分数的DataFrame。
  2. 使用pivot_table方法创建了一个透视表，其中index='Name'指定了透视表的行索引为姓名，columns='City'指定了列索引为城市，values='Score'指定了透视表的值来自分数列，aggfunc='mean'指定了聚合函数为平均值。
  3. 打印了透视表的结果。然而，由于数据中每个姓名只对应一个城市和一个分数，透视表将显示NaN（不是数字）值，因为每个姓名和城市的组合在数据中只出现了一次。

请注意，透视表通常用于将数据从长格式转换为宽格式，其中每个行索引和列索引的组合对应一个值。在这个例子中，由于数据中没有重复的姓名和城市组合，透视表将只显示最后一个匹配的值，其他组合将为NaN。如果数据中有多个相同的姓名和城市组合，透视表将显示这些组合的分数的平均值。

6、输入输出

6.1 读取数据
import pandas as pd# 从 CSV 文件读取数据
# 假设 'data.csv' 文件存在于当前工作目录中
df_csv = pd.read_csv('data.csv')
print(df_csv)
# 输出结果将取决于 'data.csv' 文件的内容# 从 Excel 文件读取数据
# 假设 'data.xlsx' 文件存在于当前工作目录中
df_excel = pd.read_excel('data.xlsx')
print(df_excel)
# 输出结果将取决于 'data.xlsx' 文件的内容

当你运行这段代码时，它将打印出data.csv和data.xlsx文件的内容。输出结果将取决于这些文件中实际的数据。例如：

# 输出结果示例（CSV文件内容）
#   Column1 Column2 Column3
# 0      A      B      C
# 1      D      E      F
# 2      G      H      I

# 输出结果示例（Excel文件内容）
#   Column1 Column2 Column3
# 0      A      B      C
# 1      D      E      F
# 2      G      H      I

请注意，你需要将'data.csv'和'data.xlsx'替换为你实际要读取的文件路径。如果文件位于不同的目录，需要提供相对或绝对路径。此外，如果Excel文件有多个工作表，你可以通过sheet_name参数指定要读取的工作表。

6.2 写入数据
import pandas as pd# 假设 df 是一个已存在的DataFrame对象# 写入 CSV 文件
# 假设 'output.csv' 文件将被创建或覆盖
df.to_csv('output.csv', index=False)
# 假设 'output.csv' 文件的内容如下（取决于df的内容）：
# Column1,Column2,Column3,...
# A,B,C,...
# D,E,F,...
# G,H,I,...
# 注意：实际内容将取决于df的具体数据。# 写入 Excel 文件
# 假设 'output.xlsx' 文件将被创建或覆盖
df.to_excel('output.xlsx', index=False)
# 假设 'output.xlsx' 文件的内容如下（取决于df的内容）：
# +------------+-----------+-----------+
# | Column1    | Column2   | Column3   |
# +------------+-----------+-----------+
# | A          | B         | C         |
# | D          | E         | F         |
# | G          | H         | I         |
# +------------+-----------+-----------+
# 注意：实际内容将取决于df的具体数据，并且Excel文件可能包含多个工作表。

请注意，这些代码示例中的注释只是假设的输出，实际写入的文件内容将取决于df变量中的数据。index=False参数的作用是在写入文件时不包括行索引。如果df包含行索引，并且你希望将其写入文件，可以省略这个参数或将其设置为True。

以上是 Pandas 的一些基础知识和操作。掌握这些内容可以帮助您更好地进行数据处理和机器学习任务。通过不断实践，您会发现 Pandas 是一个非常强大且高效的工具。

三、在机器学习中使用到 Pandas 的简单示例

下面是一些在机器学习中使用Pandas的简单示例。这些示例展示了Pandas在数据处理、特征工程和简单模型实现中的作用。

1、数据加载和探索

在机器学习项目中，第一步通常是加载和探索数据。Pandas提供了强大的功能来完成这些任务。

1.1 加载数据

我们使用Pandas从CSV文件中加载数据。

import pandas as pd# 从CSV文件加载数据
df = pd.read_csv('path/to/your/dataset.csv')# 查看前几行数据
print(df.head())
# 输出结果示例：
#    Column1 Column2 Column3 ... ColumnN
# 0      A      B        C  ... X
# 1      D      E        F  ... Y
# 2      G      H        I  ... Z
# 3      J      K        L  ... A
# 4      M      N        O  ... B# 查看数据基本信息
print(df.info())
# 输出结果示例：
# <class 'pandas.core.frame.DataFrame'>
# RangeIndex: 150 entries, 0 to 149
# Data columns (total 5 columns):
#  Column1    150 non-null int64
#  Column2    150 non-null int64
#  Column3    150 non-null int64
#  Column4    150 non-null int64
#  ColumnN    150 non-null int64
# dtypes: int64(5)
# memory usage: X KB# 查看数据描述性统计
print(df.describe())
# 输出结果示例：
#       Column1     Column2     Column3     ... Column(N-1)     ColumnN
# count     150         150         150         ...           150         150
# mean    67.933333  55.266667  54.666667  ...       Xmean        Ymean
# std     38.197868  32.055245  31.104511  ...       Xstddev       Ystddev
# min     2           2           2           ...       Xmin         Ymin
# 25%     38.0        31.0        32.0        ...       X25th        Y25th
# 50%     68.0        54.0        55.0        ...       X50th        Y50th
# 75%     96.5        79.0        77.0        ...       X75th        Y75th
# max     190         172         173         ...       Xmax         Ymax

请注意，上面的注释中提到的输出结果只是示例，实际输出会根据CSV文件中的数据而有所不同。df.head()将显示DataFrame的前5行，df.info()将提供DataFrame的基本信息，包括列名、数据类型和非空值的数量等，而df.describe()将提供数值型列的描述性统计信息，如计数、平均值、标准差、最小值、第25百分位数、第50百分位数（中位数）、第75百分位数和最大值。如果CSV文件包含非数值列，这些列将不会出现在描述性统计输出中。

1.2 数据清洗

处理缺失值、重复数据和异常值是数据清洗的重要步骤。

import pandas as pd# 假设 df 是一个已存在的DataFrame对象# 检查缺失值
print(df.isnull().sum())
# 输出结果示例：
# Column1     0
# Column2     5
# Column3     0
# ...        ..
# ColumnN    2
# dtype: int64# 填充缺失值
df.fillna(df.mean(), inplace=True)
# 没有打印结果，但是 df 中的缺失值已被相应列的平均值填充# 删除重复行
df.drop_duplicates(inplace=True)
# 没有打印结果，但是 df 中的重复行已被删除# 检查和处理异常值（例如，移除离群值）
q1 = df['column_name'].quantile(0.25)
q3 = df['column_name'].quantile(0.75)
iqr = q3 - q1
lower_bound = q1 - 1.5 * iqr
upper_bound = q3 + 1.5 * iqr
df = df[(df['column_name'] >= lower_bound) & (df['column_name'] <= upper_bound)]# 假设操作后需要打印结果来验证
print(df)
# 输出结果示例：
#    Column1 Column2 Column3 ... ColumnN
# 0       A       B        C  ...      X
# 1       D       E        F  ...      Y
# ...    ...     ...      ...  ...    ...
# last    Z       Y        X  ...      W

请注意，上面的注释中提到的输出结果只是示例，实际输出会根据DataFrame df 中的数据而有所不同。df.isnull().sum() 将显示每个列的缺失值数量，df.fillna(df.mean(), inplace=True) 将填充缺失值但不会打印结果，df.drop_duplicates(inplace=True) 将删除重复行但不会打印结果。异常值处理部分首先计算了四分位数、四分位距、上下界，然后根据这些界限过滤了DataFrame df。

在实际使用中，你需要将 'column_name' 替换为DataFrame中实际的列名。此外，异常值的处理策略可能因具体情况而异，上述示例仅展示了基于IQR的一种常见方法。

2、特征工程

特征工程是从原始数据中提取有用特征的过程。

2.1 创建新特征

根据现有数据创建新的特征。

import pandas as pd# 假设 df 是一个已存在的DataFrame对象，并且包含 'Age' 和 'Date' 列# 创建一个新的特征 'AgeGroup'
df['AgeGroup'] = pd.cut(df['Age'], bins=[0, 12, 19, 35, 60, 100], labels=['Child', 'Teen', 'YoungAdult', 'Adult', 'Senior'])
print(df[['Age', 'AgeGroup']].head())
# 输出结果示例：
#   Age AgeGroup
# 0   5     Child
# 1  20    Teen
# 2  25  YoungAdult
# 3  40      Adult
# 4  65     Senior# 使用日期特征
df['Year'] = pd.to_datetime(df['Date']).dt.year
df['Month'] = pd.to_datetime(df['Date']).dt.month
print(df[['Date', 'Year', 'Month']].head())
# 输出结果示例：
#         Date  Year  Month
# 0  2024-01-01  2024      1
# 1  2024-01-15  2024      1
# 2  2024-02-01  2024      2
# 3  2024-02-15  2024      2
# 4  2024-03-01  2024      3

请注意，上面的注释中提到的输出结果只是示例，实际输出会根据DataFrame df 中的数据而有所不同。pd.cut 函数用于根据给定的区间 bins 对 'Age' 列中的值进行分组，并赋予相应的标签 'AgeGroup'。pd.to_datetime 转换 'Date' 列为日期时间格式，然后使用 .dt.year 和 .dt.month 提取年份和月份信息。

在实际使用中，你需要确保 'Age' 和 'Date' 列存在于DataFrame df 中，并且 'Date' 列包含有效的日期格式。如果 'Date' 列不存在或者列名不同，你需要相应地调整代码中的列名。

2.2 特征编码

将分类变量转换为数值格式，以便模型能够处理。

import pandas as pd
from sklearn.preprocessing import LabelEncoder# 假设 df 是一个已存在的DataFrame对象，并且包含 'Category' 列# 使用One-Hot编码处理分类特征
df = pd.get_dummies(df, columns=['Category'], drop_first=True)
print(df.head())
# 输出结果示例：
#     Category_1  Category_2  Category_3  ...  其他列名
# 0            1           0           0  ...
# 1            0           1           0  ...
# 2            0           0           1  ...
# 3            1           0           0  ...
# 4            0           1           0  ...# 使用Label编码处理分类特征
label_encoder = LabelEncoder()
df['Category'] = label_encoder.fit_transform(df['Category'])
print(df[['Category']].head())
# 输出结果示例：
#   Category
# 0        0
# 1        1
# 2        2
# 3        0
# 4        1

请注意，上面的注释中提到的输出结果只是示例，实际输出会根据DataFrame df 中的 'Category' 列的数据而有所不同。

  1. pd.get_dummies 函数用于对分类特征 'Category' 进行One-Hot编码。drop_first=True 参数表示丢弃第一个虚拟变量以避免完全多重共线性。
  2. LabelEncoder 用于将分类特征 'Category' 转换为标签编码。fit_transform 方法首先拟合标签编码器，然后转换 'Category' 列中的类别为整数。

在实际使用中，你需要确保 'Category' 列存在于DataFrame df 中，并且包含分类数据。One-Hot编码和Label编码是处理分类特征的两种常见方法，选择哪一种取决于具体问题和模型的需求。

3、特征选择

选择对模型有帮助的特征可以提高模型性能。

import pandas as pd# 假设 df 是一个已存在的DataFrame对象，并且包含 'target' 列# 相关性矩阵
corr_matrix = df.corr()
print(corr_matrix)
# 输出结果示例：
#          Column1  Column2  Column3  ...  ColumnN  target
# Column1  1.000000 -0.123456  0.045678  ...  0.000000  0.789012
# Column2 -0.123456  1.000000 -0.987654  ...  0.000000 -0.654321
# Column3  0.045678 -0.987654  1.000000  ...  0.000000  0.123456
# ...             ...       ...       ...       ...      ...
# ColumnN  0.000000  0.000000  0.000000  ...  1.000000 -0.123456
# target   0.789012 -0.654321  0.123456  ... -0.123456  1.000000# 根据相关性选择特征
target_corr = corr_matrix['target'].sort_values(ascending=False)
print(target_corr)
# 输出结果示例：
# target    1.000000
# ColumnX   0.789012
# ColumnY   0.123456
# ColumnZ  -0.654321
# ...             ...
# dtype: float64

请注意，上面的注释中提到的输出结果只是示例，实际输出会根据DataFrame df 中的数据而有所不同。

  1. df.corr() 函数计算了DataFrame中所有数值型列之间的相关性矩阵。
  2. corr_matrix['target'].sort_values(ascending=False) 首先获取了与目标列 'target' 相关性的所有列，然后按相关系数的绝对值降序排序，以确定与目标列最相关的特征。

在实际使用中，你需要确保 'target' 列存在于DataFrame df 中，并且 df.corr() 计算的相关性矩阵中包含了目标列。此外，特征选择是一个复杂的决策过程，仅基于相关性系数可能不足以做出最佳选择，还需要考虑其他因素，如模型的复杂度、可解释性等。

4、数据分割

将数据分为训练集和测试集是机器学习模型训练的必要步骤。

from sklearn.model_selection import train_test_split# 假设 df 是一个已存在的DataFrame对象，并且包含 'target' 列# 分割数据
X = df.drop('target', axis=1)
y = df['target']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)print("训练集大小:", X_train.shape)
# 输出结果示例：
# 训练集大小: (行数*0.8, 特征数)print("测试集大小:", X_test.shape)
# 输出结果示例：
# 测试集大小: (行数*0.2, 特征数)

请注意，上面的注释中提到的输出结果只是示例，实际输出会根据DataFrame df 中的行数和特征数而有所不同。

  • X = df.drop('target', axis=1) 表示从 df 中移除 'target' 列，以创建特征集 X。
  • y = df['target'] 表示选取 'target' 列作为目标变量。
  • train_test_split 函数用于将数据集分割为训练集和测试集。test_size=0.2 表示测试集占总数据集的20%，random_state=42 用于确保每次分割的结果都是一致的。

在实际使用中，你需要确保 'target' 列存在于DataFrame df 中，并且 df 至少包含这一列和一些其他特征列。X_train 和 X_test 将是特征集的子集，而 y_train 和 y_test 将是对应目标变量的子集。

5、简单线性回归

使用Pandas和Scikit-learn实现简单的线性回归模型。

5.1 生成数据
import pandas as pd# 生成示例数据
data = {'Hours': [1, 2, 3, 4, 5],'Scores': [1, 2, 1.3, 3.75, 2.25]
}
df = pd.DataFrame(data)
print(df)
# 输出结果：
#   Hours  Scores
# 0      1      1.0
# 1      2      2.0
# 2      3      1.3
# 3      4      3.75
# 4      5      2.25

在这段代码中，首先定义了一个字典 data，其中包含两个键（'Hours', 'Scores'），每个键对应一个列表，列表中包含了相应的值。然后使用 pd.DataFrame(data) 从这个字典创建了一个 DataFrame 对象 df。

打印 df 将显示这个表格数据，其中包含了索引（默认为0, 1, 2, 3, 4...）和列标题（'Hours', 'Scores'）。每行显示一个记录，对应字典中的一个元素。

5.2 训练模型
from sklearn.linear_model import LinearRegression
import pandas as pd# 生成示例数据
data = {'Hours': [1, 2, 3, 4, 5],'Scores': [1, 2, 1.3, 3.75, 2.25]
}
df = pd.DataFrame(data)# 准备数据
X = df[['Hours']]  # 特征集，包括 'Hours' 列
y = df['Scores']   # 目标变量# 创建模型
model = LinearRegression()# 训练模型
model.fit(X, y)# 查看回归系数
print("截距:", model.intercept_)
# 输出结果示例：
# 截距: -0.6print("系数:", model.coef_)
# 输出结果示例：
# 系数: [0.96]

请注意，上面的注释中提到的输出结果只是示例，实际输出会根据 df 中的数据而有所不同。model.intercept_ 将给出线性回归的截距项，而 model.coef_ 将给出与特征 'Hours' 相关的系数。

在这段代码中，我们首先创建了一个包含 'Hours' 和 'Scores' 列的DataFrame df。然后，我们准备了特征集 X 和目标变量 y，用于训练线性回归模型。LinearRegression() 创建了线性回归模型的一个实例，fit 方法用于根据特征集 X 和目标变量 y 训练模型。最后，我们打印了模型的截距和系数。

5.3 预测
from sklearn.linear_model import LinearRegression
import pandas as pd# 生成示例数据
data = {'Hours': [1, 2, 3, 4, 5],'Scores': [1, 2, 1.3, 3.75, 2.25]
}
df = pd.DataFrame(data)# 准备数据
X = df[['Hours']]  # 特征集，包括 'Hours' 列
y = df['Scores']   # 目标变量# 创建模型
model = LinearRegression()# 训练模型
model.fit(X, y)# 进行预测
predictions = model.predict(X)# 将预测结果加入到DataFrame中
df['Predicted_Scores'] = predictionsprint(df)
# 输出结果：
#   Hours  Scores  Predicted_Scores
# 0      1      1               0.4
# 1      2      2               1.3
# 2      3      1.3             2.2
# 3      4      3.75            3.1
# 4      5      2.25            4.0

请注意，上面的注释中提到的输出结果只是示例，实际输出会根据 df 中的数据和模型训练的结果而有所不同。model.predict(X) 用于对特征集 X 进行预测，预测结果随后被加入到 df 中，创建了一个新的列 'Predicted_Scores'。

在这段代码中，我们首先创建了一个包含 'Hours' 和 'Scores' 列的DataFrame df。然后，我们准备了特征集 X 和目标变量 y，用于训练线性回归模型。LinearRegression() 创建了线性回归模型的一个实例，fit 方法用于训练模型。接着，我们使用训练好的模型对特征集 X 进行预测，并将预测结果作为新列添加到 df 中。最后，我们打印了包含实际分数和预测分数的完整DataFrame。

6、可视化

使用Pandas和Matplotlib进行数据可视化。

import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
import pandas as pd# 生成示例数据
data = {'Hours': [1, 2, 3, 4, 5],'Scores': [1, 2, 1.3, 3.75, 2.25]
}
df = pd.DataFrame(data)# 准备数据
X = df[['Hours']]  # 特征集，包括 'Hours' 列
y = df['Scores']   # 目标变量# 创建模型
model = LinearRegression()# 训练模型
model.fit(X, y)# 进行预测
df['Predicted_Scores'] = model.predict(X)# 绘制数据
plt.scatter(df['Hours'], df['Scores'], color='blue')      # 实际分数的散点图
plt.plot(df['Hours'], df['Predicted_Scores'], color='red')  # 预测分数的折线图
plt.xlabel('Hours')                                       # X轴标签
plt.ylabel('Scores')                                      # Y轴标签
plt.title('Hours vs Scores')                              # 图表标题
plt.show()                                                # 显示图表

执行上述代码后，假设的输出结果（图表）将如下所示：

  • 散点图（使用蓝色点表示）将展示 'Hours' 与 'Scores' 的实际数据点。
  • 折线图（使用红色线表示）将展示 'Hours' 与 'Predicted_Scores' 的预测数据点。
  • 图表的X轴标签为 'Hours'，Y轴标签为 'Scores'，图表标题为 'Hours vs Scores'。

请注意，实际的图表显示效果取决于您的具体数据和执行环境。上述代码中的注释和输出结果仅为示例。

7、时间序列分析

处理和分析时间序列数据。

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt# 创建时间序列数据
date_rng = pd.date_range(start='2020-01-01', end='2020-01-10', freq='D')
df = pd.DataFrame(date_rng, columns=['date'])
df['data'] = np.random.randint(0, 100, size=(len(date_rng)))# 设置日期为索引
df.set_index('date', inplace=True)# 查看时间序列数据
print(df)
# 输出结果示例：
#            data
# date         
# 2020-01-01   72
# 2020-01-02   12
# 2020-01-03   65
# ...          ...
# 2020-01-09   47
# 2020-01-10   88# 滚动平均
df['rolling_mean'] = df['data'].rolling(window=2).mean()
print(df)
# 输出结果示例：
#            data  rolling_mean
# date                          
# 2020-01-01   72         NaN
# 2020-01-02   12         42.0
# 2020-01-03   65         38.5
# ...          ...          ...
# 2020-01-09   47         57.5
# 2020-01-10   88         67.5

请注意，上面的注释中提到的输出结果只是示例，实际输出会根据 np.random.randint(0, 100, size=(len(date_rng))) 生成的随机数据而有所不同。

  1. pd.date_range 用于生成日期范围。
  2. pd.DataFrame 创建了一个包含日期的 DataFrame。
  3. np.random.randint 生成了一个与日期范围长度相同的随机整数数组，作为时间序列数据。
  4. df.set_index 将 'date' 列设为 DataFrame 的索引。
  5. df['data'].rolling(window=2).mean() 计算了 'data' 列的 2 日滚动平均值，window=2 表示考虑当前和前一日的数据进行平均。

在实际使用中，由于 rolling() 函数在窗口大小内的数据不足时会返回 NaN，因此在窗口的第一行（本例中为 '2020-01-01'）的滚动平均值将为 NaN。随着窗口的滑动，后续行将显示计算出的滚动平均值。

通过以上示例，我们可以看到Pandas在机器学习中的广泛应用。从数据加载、清洗、特征工程到简单的模型实现，Pandas都发挥了重要作用。掌握Pandas可以帮助您更好地进行数据处理和机器学习任务。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/diannao/23231.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

后知后觉发现美国又开始上升了

后知后觉发现美国又开始上升了

1. **美国人均GDP增长**&#xff1a; 美国经济近年来表现强劲&#xff0c;物价低,人收入持续增加,人均GDP直接奔向10万美元上方去了,目前已经接近10万美元。打破了固定认知,美国人口3亿多.说明人口多,人均GDP就低在逻辑学上是不成立的 2. 美墨移暴增&#xff1a; 美墨边…
阅读更多...
插入排序—Java

插入排序—Java

插入排序 基本思想 &#xff1a;代码实现 基本思想 &#xff1a; 实现数组从小到大排从第二个数开始跟前面的数比较 找到合适的位置插入 后面的数往后推移 但推移不会超过原来插入的数的下标 代码实现 public static void InsertSort(int[] arr) {for(int i 1;i<arr.len…
阅读更多...
GAN相关知识

GAN相关知识

GAN训练tricks generator的最后一层一般使用tanh激活函数&#xff0c;这样可以使训练更加稳定。但是我在实际用的时候&#xff0c;使用sigmoid和tanh的效果是差不多的&#xff1b;需要注意&#xff1a;discriminator的最后一层的输出的激活函数选择tanh&#xff0c;会导致cuda…
阅读更多...
新手上路：Linux虚拟机创建与Hadoop集群配置指南①（未完）

新手上路：Linux虚拟机创建与Hadoop集群配置指南①（未完）

一、基础阶段 Linux操作系统： 创建虚拟机 1.创建虚拟机 打开VM，点击文件，新建虚拟机，点击自定义，下一步 下一步 这里可以选择安装程序光盘映像文件，我选择稍后安装 选择linux系统 位置不选C盘，创建一个新的文件夹VM来放置虚拟机，将虚拟机名字改为master方便后续识别…
阅读更多...
在Java单元测试后自动打印方法调用堆栈

在Java单元测试后自动打印方法调用堆栈

单元测试是确保代码质量的关键环节。有时候，为了更深入地理解测试执行过程或定位难以捉摸的问题，查看测试执行期间的方法调用堆栈变得尤为重要。本文将介绍一种简单而有效的方法，在Java使用JUnit框架执行单元测试后，自动打印出当前线程的调用堆栈信息。 技术背景 Java标准…
阅读更多...
期望24K，商汤科技golang开发 社招一二三 + hr 面

期望24K，商汤科技golang开发 社招一二三 + hr 面

商汤科技对数据库和中间件相关的东西问的比其他的大厂要少很多&#xff0c;可能他们更多是和算法相关&#xff0c;没有什么高并发的场景。总体感觉对技术的要求不是特别高。当时问了他们主管&#xff0c;我面试的部门的工作是主要去实现他们算法部门研究的算法&#xff0c;感觉…
阅读更多...
在LabVIEW项目管理中，如何确保团队之间的有效沟通和协作

在LabVIEW项目管理中，如何确保团队之间的有效沟通和协作

在LabVIEW项目管理中&#xff0c;确保团队之间的有效沟通和协作对于项目成功至关重要。以下是一些方法和工具&#xff0c;可以帮助团队实现这一目标。 一、建立清晰的沟通渠道 1.1 项目启动会议 召开项目启动会议&#xff0c;让所有团队成员了解项目的背景、目标、范围和时间…
阅读更多...
postgres数据库报错无法写入文件 “base/pgsql_tmp/pgsql_tmp215574.97“: 设备上没有空间

postgres数据库报错无法写入文件 “base/pgsql_tmp/pgsql_tmp215574.97“: 设备上没有空间

解决思路&#xff1a; base/pgsql_tmp下临时表空间不够 需要新建一个临时表空间指定到根目录之外的其他目录 并且修改默认临时表空间参数 解决方法&#xff1a; select * from pg_settings where name temp_tablespaces;mkdir /home/postgres/tbs_tmp CREATE TABLESPACE tbs_t…
阅读更多...
[图解]企业应用架构模式2024新译本讲解09-领域模型2

[图解]企业应用架构模式2024新译本讲解09-领域模型2

1 00:00:01,750 --> 00:00:03,030 代码还是一样的 2 00:00:03,040 --> 00:00:12,640 我们还是从前面人家做的复刻案例来看 3 00:00:14,170 --> 00:00:15,200 这个是它的类图 4 00:00:15,640 --> 00:00:20,650 我们同样用UModel逆转&#xff0c;这个太小了&#…
阅读更多...
Codeforces Round 950 (Div. 3) 题解分享

Codeforces Round 950 (Div. 3) 题解分享

A. Problem Generator 思路 A&#xff1a;纯纯模拟&#xff0c;不多解释。 code inline void solve() {int n, m; cin >> n >> m;vector<int> cnt(26);string s; cin >> s;for (char c : s) cnt[c - A] 1;ll ans 0;for (int i 0; i < 7; i …
阅读更多...
Spring （41）Eureka

Spring （41）Eureka

Eureka是Netflix开发的服务发现框架&#xff0c;后来成为了Spring Cloud Netflix组件之一。它主要用于AWS云环境中管理服务间的注册与发现&#xff0c;但也可以在非AWS环境中工作。Eureka包含两个主要组件&#xff1a;Eureka Server和Eureka Client。 Eureka Server Eureka S…
阅读更多...
windows RNDIS开发-概念

windows RNDIS开发-概念

远程 NDIS (RNDIS) 是一种独立于总线的类&#xff0c;适用于动态 即插即用 (PnP) 总线&#xff08;例如 USB、1394、蓝牙和 InfiniBand&#xff09;上的以太网 (802.3) 网络设备。 远程 NDIS 通过抽象控制和数据通道在主计算机与远程 NDIS 设备之间定义与总线无关的消息协议。 …
阅读更多...
【微信小程序】页面导航

【微信小程序】页面导航

声明式导航 导航到 tabbar 页 tabBar页面指的是被配置为tabBar的页面。 在使用<navigator>组件跳转到指定的tabBar页面时&#xff0c;需要指定url属性和open-type属性&#xff0c;其中&#xff1a; url 表示要跳转的页面的地址&#xff0c;必须以/开头open-type表示跳…
阅读更多...
Java 18 新特性

Java 18 新特性

Java 作为一门广泛应用于企业级开发和系统编程的编程语言&#xff0c;一直以来都在不断进化和改进。2022 年发布的 Java 18 版本为开发者带来了一些新的特性和改进&#xff0c;这些特性不仅提升了开发效率&#xff0c;还进一步增强了 Java 语言的功能和灵活性。本文将深入探讨 …
阅读更多...
spring boot3登录开发-2(3邮件验证码接口实现)

spring boot3登录开发-2(3邮件验证码接口实现)

⛰️个人主页: 蒾酒 &#x1f525;系列专栏&#xff1a;《spring boot实战》 目录 写在前面 上文衔接 接口设计与实现 1.接口分析 2.实现思路 3.代码实现 1.定义验证码短信HTML模板枚举类 2.定义验证码业务接口 3. 验证码业务接口实现 4.控制层代码 4.测试 写…
阅读更多...
场外个股期权标的有哪些？

场外个股期权标的有哪些？

今天带你了解场外个股期权标的有哪些&#xff1f;场外个股期权是一种金融衍生品&#xff0c;它不在交易所内进行交割&#xff0c;而是在交易所以外的场所进行交易的股票期权合约。 场外个股期权标的有哪些&#xff1f; 场外个股期权的标的通常包括A股市场上的融资融券标的&…
阅读更多...
63、背包问题

63、背包问题

背包问题 题目描述 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi&#xff0c;价值是 wi。 求解将哪些物品装入背包&#xff0c;可使这些物品的总体积不超过背包容量&#xff0c;且总价值最大。 输出最大价值。 输入格式&#xff1a;…
阅读更多...
spring中那些地方使用了反射

spring中那些地方使用了反射

1、依赖注入&#xff08;Dependency Injection&#xff09; Spring Boot通过反射机制将bean注入到相应的属性或构造函数中。当我们在Spring Boot中使用如Autowired这样的注解时&#xff0c;Spring容器会利用反射机制找到相应的bean并注入到对应的属性或构造函数中。 2、Bean的…
阅读更多...
ARM服务器在云手机中可以提供哪些支持

ARM服务器在云手机中可以提供哪些支持

ARM服务器作为云手机的底层支撑&#xff0c;在很多社媒APP或者电商APP平台都有着很多看不见的功劳&#xff0c;可以说ARM扮演着至关重要的底层支持角色&#xff1b; 首先&#xff0c;ARM 服务器为云手机提供了强大的计算能力基础。云手机需要处理大量的数据和复杂的运算&#x…
阅读更多...
Java Web框架使用经验

Java Web框架使用经验

在Java Web开发领域&#xff0c;框架的使用极大地提高了开发效率和代码的可维护性。我个人的开发经验中&#xff0c;涉及了多个Java Web框架&#xff0c;其中最为常用和熟悉的包括Spring MVC、Spring Boot以及Struts2。下面我将从技术难点、面试官关注点、回答吸引力以及代码举…
阅读更多...
最新文章

Copyright @ 2022~2023