乐趣区

关于人工智能:10个Pandas的另类数据处理技巧

本文所整顿的技巧与以前整顿过 10 个 Pandas 的罕用技巧不同,你可能并不会常常的应用它,然而有时候当你遇到一些十分辣手的问题时,这些技巧能够帮你疾速解决一些不常见的问题。

1、Categorical 类型

默认状况下,具备无限数量选项的列都会被调配 object 类型。然而就内存来说并不是一个无效的抉择。咱们能够这些列建设索引,并仅应用对对象的援用而理论值。Pandas 提供了一种称为 Categorical 的 Dtype 来解决这个问题。

例如一个带有图片门路的大型数据集组成。每行有三列:anchor, positive, and negative.。

如果类别列应用 Categorical 能够显着缩小内存使用量。

 # raw data
 +----------+------------------------+
 |  class   |        filename        |
 +----------+------------------------+
 |Bathroom|Bathroom\bath_1.jpg    |
 |Bathroom|Bathroom\bath_100.jpg  |
 |Bathroom|Bathroom\bath_1003.jpg|
 |Bathroom|Bathroom\bath_1004.jpg|
 |Bathroom|Bathroom\bath_1005.jpg|
 +----------+------------------------+
 
 # target
 +------------------------+------------------------+----------------------------+
 |         anchor         |        positive        |          negative          |
 +------------------------+------------------------+----------------------------+
 |Bathroom\bath_1.jpg    |Bathroom\bath_100.jpg  |Dinning\din_540.jpg        |
 |Bathroom\bath_100.jpg  |Bathroom\bath_1003.jpg|Dinning\din_1593.jpg       |
 |Bathroom\bath_1003.jpg|Bathroom\bath_1004.jpg|Bedroom\bed_329.jpg        |
 |Bathroom\bath_1004.jpg|Bathroom\bath_1005.jpg|Livingroom\living_1030.jpg|
 |Bathroom\bath_1005.jpg|Bathroom\bath_1007.jpg|Bedroom\bed_1240.jpg       |
 +------------------------+------------------------+----------------------------+

filename 列的值会常常被复制反复。因而,所以通过应用 Categorical 能够极大的缩小内存使用量。

让咱们读取指标数据集,看看内存的差别:

 triplets.info(memory_usage="deep")
 
 #   Column    Non-Null Count   Dtype   
 # ---  ------    --------------   -----   
 #  0   anchor    525000 non-null  category
 #  1   positive  525000 non-null  category
 #  2   negative  525000 non-null  category
 # dtypes: category(3)
 # memory usage: 4.6 MB
 
 # without categories
 triplets_raw.info(memory_usage="deep")
 
 #   Column    Non-Null Count   Dtype 
 # ---  ------    --------------   ----- 
 #  0   anchor    525000 non-null  object
 #  1   positive  525000 non-null  object
 #  2   negative  525000 non-null  object
 # dtypes: object(3)
 # memory usage: 118.1 MB

差别十分大,并且随着反复次数的减少,差别呈非线性增长。

2、行列转换

sql 中常常会遇到行列转换的问题,Pandas 有时候也须要,让咱们看看来自 Kaggle 较量的数据集。census_start .csv 文件:

能够看到,这些按年来保留的,如果有一个列 year 和 pct_bb,并且每一行有相应的值,则会好得多,对吧。

 cols=sorted([colforcolinoriginal_df.columns \
               ifcol.startswith("pct_bb")])
 df=original_df[(["cfips"] +cols)]
 df=df.melt(id_vars="cfips",
              value_vars=cols,
              var_name="year",
              value_name="feature").sort_values(by=["cfips", "year"])

看看后果,这样是不是就好很多了:

3、apply()很慢

咱们上次曾经介绍过,最好不要应用这个办法,因为它遍历每行并调用指定的办法。然而要是咱们没有别的抉择,那还有没有方法进步速度呢?

能够应用 swifter 或 pandarallew 这样的包,使过程并行化。

Swifter

 importpandasaspd
 importswifter
 
 deftarget_function(row):
     returnrow*10
 
 deftraditional_way(data):
     data['out'] =data['in'].apply(target_function)
 
 defswifter_way(data):
     data['out'] =data['in'].swifter.apply(target_function)

Pandarallel

 importpandasaspd
 frompandarallelimportpandarallel
 
 deftarget_function(row):
     returnrow*10
 
 deftraditional_way(data):
     data['out'] =data['in'].apply(target_function)
 
 defpandarallel_way(data):
     pandarallel.initialize()
     data['out'] =data['in'].parallel_apply(target_function)

通过多线程,能够进步计算的速度,当然当然,如果有集群,那么最好应用 dask 或 pyspark

4、空值,int, Int64

规范整型数据类型不反对空值,所以会主动转换为浮点数。所以如果数据要求在整数字段中应用空值,请思考应用 Int64 数据类型,因为它会应用 pandas.NA 来示意空值。

5、Csv, 压缩还是 parquet?

尽可能抉择 parquet。parquet 会保留数据类型,在读取数据时就不须要指定 dtypes。parquet 文件默认曾经应用了 snappy 进行压缩,所以占用的磁盘空间小。上面能够看看几个的比照

 |        file            |  size   |
 +------------------------+---------+
 |triplets_525k.csv      |38.4MB|
 |triplets_525k.csv.gzip|  4.3MB|
 |triplets_525k.csv.zip  |  4.5MB|
 |triplets_525k.parquet  |  1.9MB|
 +------------------------+---------+

读取 parquet 须要额定的包,比方 pyarrow 或 fastparquet。chatgpt 说 pyarrow 比 fastparquet 要快,然而我在小数据集上测试时 fastparquet 比 pyarrow 要快,然而这里倡议应用 pyarrow,因为 pandas 2.0 也是默认的应用这个。

6、value_counts ()

计算绝对频率,包含取得绝对值、计数和除以总数是很简单的,然而应用 value_counts,能够更容易地实现这项工作,并且该办法提供了蕴含或排除空值的选项。

 df = pd.DataFrame({"a": [1, 2, None], "b": [4., 5.1, 14.02]})
 df["a"] = df["a"].astype("Int64")
 print(df.info())
 print(df["a"].value_counts(normalize=True, dropna=False),
       df["a"].value_counts(normalize=True, dropna=True), sep="\n\n")

这样是不是就简略很多了

7、Modin

留神:Modin 当初还在测试阶段。

pandas 是单线程的,但 Modin 能够通过缩放 pandas 来放慢工作流程,它在较大的数据集上工作得特地好,因为在这些数据集上,pandas 会变得十分迟缓或内存占用过大导致 OOM。

 !pip install modin[all] 
 
 import modin.pandas as pd
 df = pd.read_csv("my_dataset.csv")

以下是 modin 官网的架构图,有趣味的钻研把:

8、extract()

如果常常遇到简单的半结构化的数据,并且须要从中拆散出独自的列,那么能够应用这个办法:

 importpandasaspd
 
 regex= (r'(?P<title>[A-Za-z\'\s]+),'r'(?P<author>[A-Za-z\s\']+),'
          r'(?P<isbn>[\d-]+),'
          r'(?P<year>\d{4}),'
          r'(?P<publisher>.+)')
 addr=pd.Series([
     "The Lost City of Amara,Olivia Garcia,978-1-234567-89-0,2023,HarperCollins",
     "The Alchemist's Daughter,Maxwell Greene,978-0-987654-32-1,2022,Penguin Random House","The Last Voyage of the HMS Endeavour,Jessica Kim,978-5-432109-87-6,2021,Simon & Schuster","The Ghosts of Summer House,Isabella Lee,978-3-456789-12-3,2000,Macmillan Publishers","The Secret of the Blackthorn Manor,Emma Chen,978-9-876543-21-0,2023,Random House Children's Books"
  ])
 addr.str.extract(regex)

9、读写剪贴板

这个技巧有人一次也用不到,然而有人可能就是须要,比方:在剖析中蕴含 PDF 文件中的表格时。通常的办法是复制数据,粘贴到 Excel 中,导出到 csv 文件中,而后导入 Pandas。然而,这里有一个更简略的解决方案:pd.read_clipboard()。咱们所须要做的就是复制所需的数据并执行一个办法。

有读就能够写,所以还能够应用 to_clipboard()办法导出到剪贴板。

然而要记住,这里的剪贴板是你运行 python/jupyter 主机的剪切板,并不可能跨主机粘贴,肯定不要搞混了。

10、数组列分成多列

假如咱们有这样一个数据集,这是一个相当典型的状况:

 import pandas as pd
 df = pd.DataFrame({"a": [1, 2, 3],
               "b": [4, 5, 6],
               "category": [["foo", "bar"], ["foo"], ["qux"]]})
 
 # let's increase the number of rows in a dataframe
 df = pd.concat([df]*10000, ignore_index=True)

咱们想将 category 分成多列显示,例如上面的

先看看最慢的 apply:

 def dummies_series_apply(df):
     return df.join(df['category'].apply(pd.Series) \
                                  .stack() \
                                  .str.get_dummies() \
                                  .groupby(level=0) \
                                  .sum()) \
              .drop("category", axis=1)
 %timeit dummies_series_apply(df.copy())
 #5.96 s ± 66.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

sklearn 的 MultiLabelBinarizer

 from sklearn.preprocessing import MultiLabelBinarizer
 def sklearn_mlb(df):
     mlb = MultiLabelBinarizer()
     return df.join(pd.DataFrame(mlb.fit_transform(df['category']), columns=mlb.classes_)) \
              .drop("category", axis=1)
 %timeit sklearn_mlb(df.copy())
 #35.1 ms ± 1.31 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

是不是快了很多,咱们还能够应用个别的向量化操作对其求和:

 def dummies_vectorized(df):
     return pd.get_dummies(df.explode("category"), prefix="cat") \
              .groupby(["a", "b"]) \
              .sum() \
              .reset_index()
 %timeit dummies_vectorized(df.copy())
 #29.3 ms ± 1.22 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

应用第一个办法 (在 StackOverflow 上的答复中十分常见) 会给出一个十分慢的后果。而其余两个优化的办法的工夫是十分疾速的。

总结

我心愿每个人都能从这些技巧中学到一些新的货色。重要的是要记住尽可能应用向量化操作而不是 apply()。此外,除了 csv 之外,还有其余乏味的存储数据集的办法。不要遗记应用分类数据类型,它能够节俭大量内存。感激浏览!

https://avoid.overfit.cn/post/bf6e2fa626494a3789aa6b4d49657448

作者:Dmytro Samchuk

退出移动版