我们在实际工作中发现有时候数据量小于内存当前容量，也有会经常出现kernel shutdown 、或者jupyter停滞，导致无法计算下去，主要原因是内存占用过大在处理中超过了当前内存，所以本文通过优化内存占用达到可以正常计算的目的。
当我们添加特征或进行训练-测试分割时，可能会消耗比某些人可用的内存更多的内存。
我们将探讨一些可以节省内存并提高整体工作流程速度的方法，从加载数据到创建数值特征。
# 导入必要的库
import numpy as np
import pandas as pd
import os
print(os.listdir("../input")) # 打印输入目录中的文件列表
from sklearn import preprocessing # 导入预处理模块
import random # 导入随机模块
为了测试某些操作需要多长时间，我们可以在单元格顶部使用%%time魔术命令。
将csv文件加载到内存中可能需要一些时间，因为pandas需要为每一行推断数据类型。
# 输出代码运行时间
%%time
# 读取训练数据集
train = pd.read_csv("../input/train.csv")
我们的目标是在加载对象时减少加载时间和内存使用量。
使用.info()我们可以检查数据类型和总内存使用量。为此，我们需要设置memory_usage=True，这会花费一些时间，但会返回更准确的大小。
# 查看训练数据的信息，包括数据类型和内存使用情况
train.info(memory_usage="deep")
每个DataFrame和Series还有一个.memory_usage属性，它显示以字节为单位的内存使用情况。
# 计算训练数据集的内存使用情况
train.memory_usage(deep=True)
为了更容易阅读，我们将所有值转换为兆字节。
# 计算训练数据的内存使用情况
# train是一个DataFrame对象，表示训练数据
# memory_usage()函数用于计算DataFrame对象的内存使用情况，参数deep=True表示深度计算，即计算每个元素的内存使用情况
# * 1e-6表示将内存使用情况转换为以兆字节（MB）为单位
train.memory_usage(deep=True) * 1e-6
总内存使用情况可以如下所示：
# 计算训练数据集的内存使用量
# 使用train.memory_usage(deep=True)函数计算每个列的内存使用量，并返回一个包含每个列的Series对象
# deep=True表示计算每个对象的内存使用量，而不仅仅是对象本身的大小
# 使用.sum()函数对每个列的内存使用量进行求和，得到总的内存使用量
# 使用* 1e-6将内存使用量转换为以兆字节为单位，方便阅读和理解
train.memory_usage(deep=True).sum() * 1e-6
我们可以看到，标题和描述栏占据了最多的空间，但是地区、城市、参数1-3和激活日期也使用了相当多的内存。
虽然2500 MB并不算太大，但是通过一些列组合、文本转换和在训练-测试拆分期间创建的新对象等操作，这个大小很容易增长到10+GB。
减小数据大小的最简单方法之一是将列转换为正确的数据类型。目前，几乎每一列都使用object类型，这基本上是非常浪费内存的字符串。
Pandas使用Numpy的数据类型以及一些自己的补充。最重要的类型包括整数、浮点数、日期时间、布尔、字符串和分类类型。
关于它们的更多信息可以在这里找到。
最简单和最常见的方法是将日期转换为datetime类型。
# 打印"activation_date"列在转换前的内存使用情况
print("转换前的内存使用情况：", train["activation_date"].memory_usage(deep=True) * 1e-6)
# 将"activation_date"列转换为日期时间格式
train["activation_date"] = pd.to_datetime(train["activation_date"])
# 打印"activation_date"列在转换后的内存使用情况
print("转换后的内存使用情况：", train["activation_date"].memory_usage(deep=True) * 1e-6)
具有大量重复值的文本列，例如region和city，应该被转换为分类列。这种特殊的数据类型基本上将所有唯一值保存在字典中，然后在每一列中放置内存高效的整数，并在使用DataFrame时显示相应的文本值。这类似于用标签编码的值覆盖列，但保持可读性。
一些工具，如XGBoost和LightGBM，也可以直接使用分类列，而无需将其转换为整数标签。然而，其他一些库在使用它们时会遇到问题，需要使用字符串或整数值。
# 打印训练集中"region"列在转换前的内存使用情况
print("转换前的大小:", train["region"].memory_usage(deep=True) * 1e-6)
# 将"region"列的数据类型转换为"category"
train["region"] = train["region"].astype("category")
# 打印训练集中"region"列在转换后的内存使用情况
print("转换后的大小:", train["region"].memory_usage(deep=True) * 1e-6)
# 打印训练集 "city" 列在转换前的内存使用情况
print("转换前的内存使用情况:", train["city"].memory_usage(deep=True) * 1e-6)
# 将训练集 "city" 列的数据类型转换为 "category"
train["city"] = train["city"].astype("category")
# 打印训练集 "city" 列在转换后的内存使用情况
print("转换后的内存使用情况:", train["city"].memory_usage(deep=True) * 1e-6)
这仅适用于基数较低的列，即具有较少唯一值的列。对于像title这样超过90%的唯一值的列，这没有帮助。
为了使这更容易，我们可以定义一个函数来帮助进行分类转换，并打印出转换前后的对象大小：
# 定义一个函数convert_columns_to_catg，用于将指定的列转换为category类型
# 参数：
# - df: 要转换的数据框
# - column_list: 要转换的列名列表
def convert_columns_to_catg(df, column_list):
# 遍历列名列表
for col in column_list:
# 打印正在转换的列名和其内存使用情况
print("converting", col.ljust(30), "size: ", round(df[col].memory_usage(deep=True)*1e-6,2), end="\t")
# 将列的数据类型转换为category类型
df[col] = df[col].astype("category")
# 打印转换后的列内存使用情况
print("->\t", round(df[col].memory_usage(deep=True)*1e-6,2))
# 定义函数convert_columns_to_catg，接收train和column_list两个参数
def convert_columns_to_catg(train, column_list):
# 遍历column_list中的每个元素
for col in column_list:
# 将train中的col列转换为category类型
train[col] = train[col].astype('category')
# 返回转换后的train数据集
return train
总内存大小已经大大减少（从2500 MB到1300 MB），现在标题和描述占据了大部分的空间：
# 打印训练数据的内存使用情况
print(train.memory_usage(deep=True)*1e-6)
# 打印训练数据的总内存使用量
print("total:", train.memory_usage(deep=True).sum()*1e-6)
在进行了这些基本改进之后，我们可以将DataFrame保存为所谓的pickle文件，这是整个Python对象保存到硬盘上，包含所有数据类型。与只存储原始字符串值的csv相比，pickle文件的大小要小得多。生成的文件将不会有相同的大小减小，但仍然会更小。
不幸的是，我们无法在Kaggle内核中保存较大的文件，因此我们将只将1300 MB与原始csv文件进行比较：
# 将train数据集保存为pickle文件，方便后续读取
train.to_pickle("train.pkl")
# 导入os模块，用于获取文件信息
import os
# 输出train.csv文件的大小，需要将字节转换为兆字节
print("train.csv:", os.stat('../input/train.csv').st_size * 1e-6)
# 输出train.pkl文件的大小，需要将字节转换为兆字节
print("train.pkl:", os.stat('train.pkl').st_size * 1e-6)
加载.pkl文件的速度也会快得多（请记住csv文件的20-25秒加载时间）。如果您只需进行一次数据类型改进，将所有内容保存为pickle文件，然后仅从这些文件加载，您每次重新加载数据时都可以节省时间。
# 删除train变量
del train
%%time
# 读取名为"train.pkl"的pickle文件，并将其存储在train变量中
train = pd.read_pickle("train.pkl")
当使用一个新的数据集时，我通常会创建一个第一个笔记本来加载所有相关的文件，转换数据类型，将DataFrame保存为pickle文件，然后只在主要的特征工程笔记本中加载它。这样在实际开始处理数据时可以节省时间和内存。
# 删除Kernels虚拟环境中的文件。
os.remove("train.pkl")
Python有一个用于控制其垃圾收集器的库，该库用于管理内存中的对象，并特别是删除不需要的对象。
在进行较大的转换、对象创建/删除或通常运行时间超过几秒钟的任何其他操作后，通过直接调用垃圾收集器可以帮助释放内存。
在您自己的计算机上，您可以使用htop、Windows任务管理器和类似的工具来监视RAM。在本笔记本中，我们可以使用psutil来显示已使用的RAM。
import gc # 导入gc模块，用于垃圾回收
import psutil # 导入psutil模块，用于获取系统信息
# 打印当前可用的内存信息
print("available RAM:", psutil.virtual_memory())
# 执行垃圾回收操作，释放内存空间
gc.collect()
# 再次打印当前可用的内存信息
print("available RAM:", psutil.virtual_memory())
虽然文本列占用了大部分内存，但如果数值列不使用最佳数据类型，随着时间的推移，它们也会逐渐增加。
我们将查看一些新创建的标签列，并探索一种同时处理高基数特征的方法。
对于基于树的模型，我们通常对分类列应用标签编码。
对于像region这样的列，这种方法效果很好，因为即使对于出现次数最少的区域，整个数据集中仍然有足够的值让树找到模式。
# 统计训练数据集中"region"列的值的频次
train["region"].value_counts()
对于像user_id这样的其他列，只有几十个用户拥有超过数百行数据，而有很多用户只有少数几行数据，这使得为每个唯一用户创建标签对于基于树的模型来说过于复杂。
# 统计训练集中每个用户的出现次数，并取出出现次数最多的前5个用户
train["user_id"].value_counts().head(5)
# 统计训练数据中每个用户的出现次数，并取出出现次数最少的5个用户
train["user_id"].value_counts().tail(5)
当对高基数列进行标签编码时，您应该仅对具有至少20/50/100行数据的类别应用这些编码，具体取决于您的偏好。
为了使这个过程更简单，让我们定义另一个函数来使用计数阈值进行标签编码：
# 定义一个函数create_label_encoding_with_min_count，用于创建具有最小计数的标签编码
# 参数df表示数据框，column表示要进行标签编码的列，min_count表示最小计数，默认为50
def create_label_encoding_with_min_count(df, column, min_count=50):
# 使用groupby函数按照column列进行分组，并计算每个分组的计数，将结果转换为整数类型
column_counts = df.groupby([column])[column].transform("count").astype(int)
# 使用np.where函数根据计数是否大于等于min_count来选择要进行标签编码的值
column_values = np.where(column_counts >= min_count, df[column], "")
# 将标签编码后的结果存储在train数据框的column+"_label"列中
train[column+"_label"] = preprocessing.LabelEncoder().fit_transform(column_values)
# 返回标签编码后的结果，即df数据框的column+"_label"列
return df[column+"_label"]
# 对train数据集中的"user_id"列进行标签编码，要求每个值出现的次数不少于50
train["user_id_label"] = create_label_encoding_with_min_count(train, "user_id", min_count=50)
# 打印训练集中唯一用户的数量
print("number of unique users :", len(train["user_id"].unique()))
# 打印训练集中唯一用户标签的数量
print("number of unique user labels:", len(train["user_id_label"].unique()))
这562个值比700k个值要容易使用得多，如果你真的会使用它们的话。
在某些情况下，先将列连接起来，然后对结果列应用标签编码是有意义的，以帮助树模型找到结构，或者避免将属于不同父类别的类别标记为相同的数字。
在Avito数据集中，这在地区-城市层次结构中发生。许多内核分别对两列应用标签编码，这会导致信息丢失。有许多具有相同名称但属于不同地区的城市。
# 首先，我们使用train.loc[]函数来选择满足条件train["city"]=="Светлый"的数据行
train.loc[train["city"]=="Светлый", "region"].value_counts().head()
为了做到这一点，我们应该将地区和城市连接起来，以便为各个城市分配更好的标签。
由于我们无法将分类列的值相加，所以我们需要使用.apply()和一个连接函数，这种方法速度较慢，并且会创建一个内存使用量较高的新列。
%%time
train["region_city"] = train.loc[:, ["region", "city"]].apply(lambda s: " ".join(s), axis=1)
# 统计"region_city"列中的唯一值数量
print("unique:", len(train["region_city"].unique()))
# 计算"region_city"列的内存使用量，并将结果转换为以MB为单位
print("size: ", train["region_city"].memory_usage(deep=True)*1e-6)
如果您想使用多个列组合，仅创建可能需要几分钟。
为了加快速度，我们可以使用groupby函数，并为每个列组合应用唯一值。使用.transform()方法，通常我们会将聚合值返回到每一行。在这种情况下，我们将为每个分组组合返回一个唯一的随机数。
%%time
train["region_city_2"] = train.groupby(["region", "city"])["region"].transform(lambda x: random.random())
# 打印出train["region_city_2"]列中的唯一值的数量
print("unique:", len(train["region_city_2"].unique()))
# 打印出train["region_city_2"]列的内存使用量
# 使用deep=True参数可以计算出对象本身使用的内存，而不仅仅是对象引用的内存
# 将内存使用量乘以1e-6，以MB为单位进行显示
print("size: ", train["region_city_2"].memory_usage(deep=True)*1e-6)
这不仅速度快了10倍，而且创建了一个更小的新列，可以在LabelEncoder()中使用。
# 将train数据集中的"region_city_2"列进行标签编码，要求标签出现的最小次数为50
train["region_city_2_label"] = create_label_encoding_with_min_count(train, "region_city_2", min_count=50)
# 执行垃圾回收操作，释放内存空间
gc.collect()
让我们添加一些更多的数值列，看看我们可以用它们的数据类型和大小做些什么。
# 给train数据集添加一个新的列"description_len"，该列记录了每个样本的"description"字段的字符长度
train["description_len"] = train["description"].fillna("").apply(len)
# 给train数据集添加一个新的列"description_count_words"，该列记录了每个样本的"description"字段的单词数量
# 使用lambda函数对每个样本的"description"字段进行处理，将其按空格分割为单词，并计算单词的数量
train["description_count_words"] = train["description"].fillna("").apply(lambda s: len(s.split(" ")))
# 输出train数据集中指定列的信息
train.loc[:, ["user_id_label", "region_city_2_label", "description_len", "description_count_words"]].info()
我们可以看到，pandas创建了所有新的列为int64，这意味着它们可以存储-9223372036854775808到9223372036854775807之间的值。
观察我们新列的最小值和最大值，很明显我们可以使用更小的数据类型，因为我们使用了较小的最小-最大范围：
# 遍历列表中的每个元素
for col in ["user_id_label", "region_city_2_label", "description_len", "description_count_words"]:
# 输出当前元素，并使用ljust()函数使输出长度为30，方便观察
print(col.ljust(30), "min:", train[col].min(), " max:", train[col].max())
# 输出当前元素在train数据集中的最小值和最大值
这些列的内存使用量目前相对较小。如果您将训练集和测试集一起使用，并创建几十个整数列，这仍然可能会快速增加数百兆字节的额外RAM使用量。
# 对于给定的数据集train，我们选择了四个特征进行处理和分析，这些特征分别是"user_id_label"、"region_city_2_label"、"description_len"和"description_count_words"。
# 使用train.loc[:, ["user_id_label", "region_city_2_label", "description_len", "description_count_words"]]可以选择这四个特征列。
# 使用memory_usage(deep=True)可以计算这四个特征列的内存使用情况。
# 乘以1e-6可以将内存使用情况转换为以兆字节（MB）为单位。
train.loc[:, ["user_id_label", "region_city_2_label", "description_len", "description_count_words"]
].memory_usage(deep=True)*1e-6
Pandas提供了.to_numeric方法，用于将列转换为数值，并同时将它们降低到给定值范围的最高效数据类型。
# 给train数据集添加一个名为"user_id_label"的新列
# 使用pd.to_numeric函数将train数据集中的"user_id_label"列转换为整数类型，并将转换结果存储在新列中
train["user_id_label"] = pd.to_numeric(train["user_id_label"], downcast="integer")
# 输出train中指定列的信息
train.loc[:, ["user_id_label", "region_city_2_label", "description_len", "description_count_words"]].info()
# 注意这里的int16类型
# 对训练数据进行操作
# 选择train数据中的"user_id_label", "region_city_2_label", "description_len", "description_count_words"这四列数据
# 使用.loc方法，通过索引标签选择指定的列
# 使用memory_usage方法计算所选列的内存使用情况，deep=True表示计算所有嵌套对象的内存使用情况
# 将内存使用情况乘以1e-6，将结果转换为兆字节（MB）单位
train.loc[:, ["user_id_label", "region_city_2_label", "description_len", "description_count_words"]
].info()
对于几十个或几百个整数列，最终减小50-75%的大小可以帮助很多。
为了将DataFrame中所有可用的整数列降低精度，我们还可以使用以下函数：
# 定义函数downcast_df_int_columns，用于将DataFrame中的整数列进行降维处理
def downcast_df_int_columns(df):
# 获取DataFrame中的整数列，并存储在list_of_columns中
list_of_columns = list(df.select_dtypes(include=["int32", "int64"]).columns)
# 如果存在整数列
if len(list_of_columns) >= 1:
# 找到整数列中最长的列名长度，用于更好的状态打印
max_string_length = max([len(col) for col in list_of_columns])
print("downcasting integers for:", list_of_columns, "\n")
# 遍历整数列
for col in list_of_columns:
# 打印降维前的内存使用情况
print("reduced memory usage for: ", col.ljust(max_string_length+2)[:max_string_length+2],
"from", str(round(df[col].memory_usage(deep=True)*1e-6,2)).rjust(8), "to", end=" ")
# 将整数列的数据类型降维为整型
df[col] = pd.to_numeric(df[col], downcast="integer")
# 打印降维后的内存使用情况
print(str(round(df[col].memory_usage(deep=True)*1e-6,2)).rjust(8))
else:
print("no columns to downcast")
# 手动进行垃圾回收，释放内存
gc.collect()
# 打印处理完成的提示信息
print("done")
downcast_df_int_columns(train)
你也可以将float64的值向下转换为float32，但是当处理大量小数位时，可能会导致数据丢失。
即使你的数据集起初较小且没有内存问题，如果将文本转换为类别、向下转换整数值，并且通常尽量避免处理大量字符串值，这也会很有帮助。