Cách đọc dữ liệu lớn trong python

Pandas là thư viện phổ biến nhất trong hệ sinh thái Python cho mọi tác vụ phân tích dữ liệu. Chúng tôi đã sử dụng nó thường xuyên với Python.  

Đó là một công cụ tuyệt vời khi tập dữ liệu nhỏ, chẳng hạn như dưới 2–3 GB. Nhưng khi kích thước của tập dữ liệu tăng vượt quá 2–3 GB, bạn không nên sử dụng Pandas

Pandas tải toàn bộ dữ liệu vào bộ nhớ trước khi thực hiện bất kỳ xử lý nào trên khung dữ liệu. Vì vậy, nếu kích thước của tập dữ liệu lớn hơn bộ nhớ, bạn sẽ gặp lỗi bộ nhớ. Do đó, Pandas không phù hợp với bộ dữ liệu bộ nhớ lớn hơn.  

Đôi khi, ngay cả khi tập dữ liệu nhỏ hơn bộ nhớ, chúng tôi vẫn gặp sự cố về bộ nhớ. Bởi vì trong quá trình tiền xử lý và chuyển đổi, Pandas tạo một bản sao của khung dữ liệu do đó làm tăng dung lượng bộ nhớ, sau đó gây ra lỗi bộ nhớ

Vì bạn đang đọc bài viết này, tôi cho rằng bạn có thể muốn sử dụng Pandas để có nhiều tính năng mặc dù tập dữ liệu lớn.  

Nhưng, có thể sử dụng Pandas trên bộ dữ liệu bộ nhớ lớn hơn không? . Bạn có thể xử lý các tập dữ liệu lớn trong python bằng Pandas với một số kỹ thuật. NHƯNG, đến một mức độ nhất định.  

Hãy cùng xem một số kỹ thuật về cách xử lý các tập dữ liệu lớn hơn trong Python bằng Pandas. Những kỹ thuật này sẽ giúp bạn xử lý hàng triệu bản ghi trong Python

Các kỹ thuật xử lý tập dữ liệu lớn

Chúng tôi sẽ sử dụng Dữ liệu chuyến đi taxi màu vàng NYC cho năm 2016. Kích thước của tập dữ liệu là khoảng 1. 5 GB đủ tốt để giải thích các kỹ thuật bên dưới

Kích thước của dữ liệu bạn có thể tải và đào tạo trong máy tính cục bộ của mình thường bị giới hạn bởi bộ nhớ trong máy tính của bạn. Hãy khám phá các tùy chọn khác nhau về cách xử lý dữ liệu lớn trong python cho các dự án ML của bạn

Trong một số tình huống nhất định, bạn có thể gặp khó khăn khi làm việc với dữ liệu lớn, tức là dữ liệu đủ lớn để ngay cả các thao tác sắp xếp dữ liệu đơn giản cũng tốn nhiều thời gian và tài nguyên máy tính.

Hoặc tệ hơn, bạn thậm chí không thể tải tập dữ liệu lớn mà bạn có thể có dưới dạng tệp 'csv' hoặc các định dạng khác

Đôi khi, bạn có thể tải và sắp xếp dữ liệu, nhưng việc đào tạo mô hình mất rất nhiều thời gian, do đó làm chậm hoặc hạn chế khả năng thử nghiệm các kỹ thuật khác nhau của bạn

Hãy xem xét các tùy chọn khác nhau mà bạn có thể thử để quản lý dữ liệu lớn trong python

Các phương pháp tiếp cận chính
1. Tối ưu hóa kích thước khung dữ liệu trong Pandas
2. Chức năng giảm mức sử dụng bộ nhớ.
3. Chỉ sử dụng các cột bắt buộc
4. Chia nhỏ dữ liệu
5. Định dạng dữ liệu thưa thớt
6. Định dạng tệp dữ liệu hiệu quả
7. Pandas thay thế
– Modin
– Vaex
8. Dask – Điện toán song song hiệu quả để phân tích dữ liệu và máy học
9. Điện toán phân tán với spark
10. Tiện ích mở rộng Intel(R) dành cho sklearn
11. Các công cụ và mẹo chung mà bạn có thể khai thác
– Áp dụng hàm Vectorized
– Numba
– pd. đánh giá và pd. truy vấn
– Rapids cuDF

1. Tối ưu hóa kích thước khung dữ liệu trong Pandas

Thông thường, khi gấu trúc tạo một khung dữ liệu, nó sẽ gán một kiểu dữ liệu lớn hơn những gì thực sự cần thiết để giữ dữ liệu. Ví dụ: bạn không cần kiểu dữ liệu age int64 dtype: object Index 128 age 48 dtype: int64 3 để lưu trữ biến 'tuổi'

Tại sao?

Bởi vì, 'Tuổi' thường đi từ 0 đến 100, trong khi age int64 dtype: object Index 128 age 48 dtype: int64 3 có thể chứa số lớn hơn nhiều. Loại dữ liệu ________ 05, yêu cầu bộ nhớ ít hơn nhiều sẽ đủ để biểu thị 'Tuổi'

Điều này hữu ích nhất nếu bạn có thể tải dữ liệu lớn vào máy tính xách tay jupyter/python nhưng các thao tác sắp xếp dữ liệu mà bạn thực hiện dường như mất rất nhiều thời gian

Rất có thể bạn đang phải đối mặt với các hạn chế về bộ nhớ và khung dữ liệu bạn đang sử dụng đang tiêu tốn một lượng lớn

Có thể giảm kích thước của khung dữ liệu bằng cách thay đổi kiểu dữ liệu của các cột

Điều này áp dụng cho rất nhiều dữ liệu xảy ra trong thế giới thực. Bằng cách kiểm tra các giá trị tối đa và tối thiểu có thể có của các cột tương ứng, bạn có thể sử dụng kiểu dữ liệu phù hợp và tiết kiệm bộ nhớ, do đó có thể thực hiện các hoạt động sắp xếp dữ liệu khác của mình

Bây giờ làm cách nào để tối ưu hóa một khung dữ liệu trong Python?

Chỉ cần sử dụng hàm age int64 dtype: object Index 128 age 48 dtype: int64 6 được xác định bên dưới. Rất hữu ích

Nhận khóa học Python hoàn chỉnh miễn phí

Đối mặt với tình huống tương tự như những người khác?

Xây dựng sự nghiệp khoa học dữ liệu của bạn với bằng cấp được ngành công nhận trên toàn cầu. Có được tư duy, sự tự tin và các kỹ năng khiến Nhà khoa học dữ liệu trở nên có giá trị

Nhận khóa học Python miễn phí

Nhận khóa học Python hoàn chỉnh miễn phí

Xây dựng sự nghiệp khoa học dữ liệu của bạn với bằng cấp được ngành công nhận trên toàn cầu. Có được tư duy, sự tự tin và các kỹ năng khiến Nhà khoa học dữ liệu trở nên có giá trị

Nhận khóa học Python miễn phí

# Show max and min values a datatype can hold import numpy as np, pandas as pd print(np.iinfo('int8')) print(np.iinfo('int16')) print(np.iinfo('int32')) print(np.iinfo('int64'))

đầu ra

Machine parameters for int8 --------------------------------------------------------------- min = -128 max = 127 --------------------------------------------------------------- Machine parameters for int16 --------------------------------------------------------------- min = -32768 max = 32767 --------------------------------------------------------------- Machine parameters for int32 --------------------------------------------------------------- min = -2147483648 max = 2147483647 --------------------------------------------------------------- Machine parameters for int64 --------------------------------------------------------------- min = -9223372036854775808 max = 9223372036854775807 ---------------------------------------------------------------

Chức năng giảm mức sử dụng bộ nhớ

# Reduce memory usage def reduce_mem_usage(df, verbose=True): numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64'] start_mem = df.memory_usage(deep=True).sum() / 1024**2 for col in df.columns: col_type = df[col].dtypes if col_type in numerics: c_min = df[col].min() c_max = df[col].max() if str(col_type)[:3] == 'int': if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max: df[col] = df[col].astype(np.int8) elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max: df[col] = df[col].astype(np.int16) elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max: df[col] = df[col].astype(np.int32) elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max: df[col] = df[col].astype(np.int64) else: if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max: df[col] = df[col].astype(np.float16) elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max: df[col] = df[col].astype(np.float32) else: df[col] = df[col].astype(np.float64) end_mem = df.memory_usage(deep=True).sum() / 1024**2 if verbose: print('Mem. usage decreased to {:5.2f} Mb ({:.1f}% reduction)'.format(end_mem, 100 * (start_mem - end_mem) / start_mem)) return df

Tạo khung dữ liệu

df = pd.DataFrame({'age':[1,2,3,4,5,6]}) print(df.dtypes) df.memory_usage() # 64 bits per item

Kết quả

age int64 dtype: object Index 128 age 48 dtype: int64

Nén khung dữ liệu

Bây giờ, hãy nén nó và kiểm tra kích thước

df_compressed = reduce_mem_usage(df) print(df_compressed.dtypes) df.memory_usage() # 8 bits per item

Kết quả

age int64 dtype: object Index 128 age 48 dtype: int64 0

Đó là mức giảm từ 48 byte xuống 6 byte. Khi được ngoại suy cho các tập dữ liệu lớn trong thế giới thực, điều đó rất quan trọng

2. Chỉ sử dụng các cột bắt buộc

Khi bạn đang nhập khung dữ liệu, hãy sử dụng đối số age int64 dtype: object Index 128 age 48 dtype: int64 7 trong age int64 dtype: object Index 128 age 48 dtype: int64 8 để chỉ tải các cột bạn sẽ sử dụng

Điều này phù hợp hơn khi bạn sử dụng tập dữ liệu rộng chứa nhiều cột, nhưng bạn chỉ cần một số cột trong số đó

Nhưng, Làm thế nào để biết tên cột ngay từ đầu?

Chỉ tải một mẫu dữ liệu, giả sử 5 cột đầu tiên bằng cách đặt age int64 dtype: object Index 128 age 48 dtype: int64 9. Lấy tên cột và quyết định cái nào bạn muốn giữ lại

age int64 dtype: object Index 128 age 48 dtype: int64 4

3. Chia nhỏ dữ liệu

Nếu bạn phải nhập tất cả các cột và bạn muốn có thể xử lý tất cả dữ liệu, NHƯNG, dữ liệu đã xử lý của bạn sẽ chỉ có một phần nhỏ các hàng có thể được lưu trong bộ nhớ, thì phương pháp chunking có thể hữu ích

Nghĩa là, đọc dữ liệu của bạn theo khối số lượng hàng đã xác định, thực hiện các phép tính và giữ lại kết quả đã xử lý

age int64 dtype: object Index 128 age 48 dtype: int64 5

đầu ra

age int64 dtype: object Index 128 age 48 dtype: int64 6

4. Định dạng dữ liệu thưa thớt

Nếu dữ liệu của bạn thưa thớt, nghĩa là phần lớn các giá trị có trong dữ liệu là số không, thì thay vì lưu trữ dữ liệu đó trong khung dữ liệu, bạn có thể lưu trữ dữ liệu ở định dạng thưa thớt

Loại định dạng này được cung cấp trong thư viện df_compressed = reduce_mem_usage(df) print(df_compressed.dtypes) df.memory_usage() # 8 bits per item 0. Sự khác biệt giữa khung dữ liệu và ma trận thưa thớt là, trong khi khung dữ liệu lưu trữ giá trị thực trong các ô ma trận, thì ma trận thưa thớt chỉ lưu trữ vị trí của các giá trị khác không

Vì tỷ lệ của các giá trị khác 0 chỉ là một phần nhỏ, bạn có thể tiết kiệm được việc không phải lưu các số 0 trong bộ nhớ

Bạn có thể tạo ma trận thưa bằng phương pháp df_compressed = reduce_mem_usage(df) print(df_compressed.dtypes) df.memory_usage() # 8 bits per item 1 từ df_compressed = reduce_mem_usage(df) print(df_compressed.dtypes) df.memory_usage() # 8 bits per item 2

Machine parameters for int8 --------------------------------------------------------------- min = -128 max = 127 --------------------------------------------------------------- Machine parameters for int16 --------------------------------------------------------------- min = -32768 max = 32767 --------------------------------------------------------------- Machine parameters for int32 --------------------------------------------------------------- min = -2147483648 max = 2147483647 --------------------------------------------------------------- Machine parameters for int64 --------------------------------------------------------------- min = -9223372036854775808 max = 9223372036854775807 --------------------------------------------------------------- 0

đầu ra

Machine parameters for int8 --------------------------------------------------------------- min = -128 max = 127 --------------------------------------------------------------- Machine parameters for int16 --------------------------------------------------------------- min = -32768 max = 32767 --------------------------------------------------------------- Machine parameters for int32 --------------------------------------------------------------- min = -2147483648 max = 2147483647 --------------------------------------------------------------- Machine parameters for int64 --------------------------------------------------------------- min = -9223372036854775808 max = 9223372036854775807 --------------------------------------------------------------- 1

Chuyển đổi một ma trận thưa thớt thành một mảng dày đặc

Machine parameters for int8 --------------------------------------------------------------- min = -128 max = 127 --------------------------------------------------------------- Machine parameters for int16 --------------------------------------------------------------- min = -32768 max = 32767 --------------------------------------------------------------- Machine parameters for int32 --------------------------------------------------------------- min = -2147483648 max = 2147483647 --------------------------------------------------------------- Machine parameters for int64 --------------------------------------------------------------- min = -9223372036854775808 max = 9223372036854775807 --------------------------------------------------------------- 2

đầu ra

Machine parameters for int8 --------------------------------------------------------------- min = -128 max = 127 --------------------------------------------------------------- Machine parameters for int16 --------------------------------------------------------------- min = -32768 max = 32767 --------------------------------------------------------------- Machine parameters for int32 --------------------------------------------------------------- min = -2147483648 max = 2147483647 --------------------------------------------------------------- Machine parameters for int64 --------------------------------------------------------------- min = -9223372036854775808 max = 9223372036854775807 --------------------------------------------------------------- 3

Chuyển đổi mảng dày đặc trở lại ma trận thưa thớt

Machine parameters for int8 --------------------------------------------------------------- min = -128 max = 127 --------------------------------------------------------------- Machine parameters for int16 --------------------------------------------------------------- min = -32768 max = 32767 --------------------------------------------------------------- Machine parameters for int32 --------------------------------------------------------------- min = -2147483648 max = 2147483647 --------------------------------------------------------------- Machine parameters for int64 --------------------------------------------------------------- min = -9223372036854775808 max = 9223372036854775807 --------------------------------------------------------------- 4

Machine parameters for int8 --------------------------------------------------------------- min = -128 max = 127 --------------------------------------------------------------- Machine parameters for int16 --------------------------------------------------------------- min = -32768 max = 32767 --------------------------------------------------------------- Machine parameters for int32 --------------------------------------------------------------- min = -2147483648 max = 2147483647 --------------------------------------------------------------- Machine parameters for int64 --------------------------------------------------------------- min = -9223372036854775808 max = 9223372036854775807 --------------------------------------------------------------- 5

đầu ra

Machine parameters for int8 --------------------------------------------------------------- min = -128 max = 127 --------------------------------------------------------------- Machine parameters for int16 --------------------------------------------------------------- min = -32768 max = 32767 --------------------------------------------------------------- Machine parameters for int32 --------------------------------------------------------------- min = -2147483648 max = 2147483647 --------------------------------------------------------------- Machine parameters for int64 --------------------------------------------------------------- min = -9223372036854775808 max = 9223372036854775807 --------------------------------------------------------------- 1

5. Định dạng tệp dữ liệu hiệu quả

Thông thường, khi lưu trữ dữ liệu, mọi người có xu hướng lưu trữ dưới dạng tệp 'csv' hoặc tệp được phân định bằng tab, v.v.

Mặc dù, những thứ này được xem rất thuận tiện bằng phần mềm bảng tính, nhưng chúng không tuyệt vời để lưu trữ dữ liệu lớn

Tại sao?

Bởi vì (i) Chúng chiếm nhiều bộ nhớ. (ii) Thời gian tải và xuất của các bộ dữ liệu được lưu trữ ở định dạng này lớn.
Đây có thể là một vấn đề khi làm việc với khối lượng dữ liệu lớn.

Có một số định dạng tệp thuận tiện khắc phục được những vấn đề này. Những cái quan trọng nhất trong số các định dạng như vậy là

1. Sàn gỗ
2. Lông vũ
3. HDF5

Hãy xem một ví dụ

Machine parameters for int8 --------------------------------------------------------------- min = -128 max = 127 --------------------------------------------------------------- Machine parameters for int16 --------------------------------------------------------------- min = -32768 max = 32767 --------------------------------------------------------------- Machine parameters for int32 --------------------------------------------------------------- min = -2147483648 max = 2147483647 --------------------------------------------------------------- Machine parameters for int64 --------------------------------------------------------------- min = -9223372036854775808 max = 9223372036854775807 --------------------------------------------------------------- 7

Tải dữ liệu với df_compressed = reduce_mem_usage(df) print(df_compressed.dtypes) df.memory_usage() # 8 bits per item 3

Machine parameters for int8 --------------------------------------------------------------- min = -128 max = 127 --------------------------------------------------------------- Machine parameters for int16 --------------------------------------------------------------- min = -32768 max = 32767 --------------------------------------------------------------- Machine parameters for int32 --------------------------------------------------------------- min = -2147483648 max = 2147483647 --------------------------------------------------------------- Machine parameters for int64 --------------------------------------------------------------- min = -9223372036854775808 max = 9223372036854775807 --------------------------------------------------------------- 8

đầu ra

Machine parameters for int8 --------------------------------------------------------------- min = -128 max = 127 --------------------------------------------------------------- Machine parameters for int16 --------------------------------------------------------------- min = -32768 max = 32767 --------------------------------------------------------------- Machine parameters for int32 --------------------------------------------------------------- min = -2147483648 max = 2147483647 --------------------------------------------------------------- Machine parameters for int64 --------------------------------------------------------------- min = -9223372036854775808 max = 9223372036854775807 --------------------------------------------------------------- 9

Bây giờ hãy xuất nó sang định dạng sàn gỗ và tải lại. Nhưng để lưu nó dưới dạng sàn gỗ, bạn sẽ cần thư viện 'pyarrow'. Vì vậy, hãy cài đặt nó

# Reduce memory usage def reduce_mem_usage(df, verbose=True): numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64'] start_mem = df.memory_usage(deep=True).sum() / 1024**2 for col in df.columns: col_type = df[col].dtypes if col_type in numerics: c_min = df[col].min() c_max = df[col].max() if str(col_type)[:3] == 'int': if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max: df[col] = df[col].astype(np.int8) elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max: df[col] = df[col].astype(np.int16) elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max: df[col] = df[col].astype(np.int32) elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max: df[col] = df[col].astype(np.int64) else: if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max: df[col] = df[col].astype(np.float16) elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max: df[col] = df[col].astype(np.float32) else: df[col] = df[col].astype(np.float64) end_mem = df.memory_usage(deep=True).sum() / 1024**2 if verbose: print('Mem. usage decreased to {:5.2f} Mb ({:.1f}% reduction)'.format(end_mem, 100 * (start_mem - end_mem) / start_mem)) return df 0

Xuất dữ liệu dưới dạng tệp csv, tệp sàn gỗ và tệp lông vũ và xem mất bao lâu

# Reduce memory usage def reduce_mem_usage(df, verbose=True): numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64'] start_mem = df.memory_usage(deep=True).sum() / 1024**2 for col in df.columns: col_type = df[col].dtypes if col_type in numerics: c_min = df[col].min() c_max = df[col].max() if str(col_type)[:3] == 'int': if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max: df[col] = df[col].astype(np.int8) elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max: df[col] = df[col].astype(np.int16) elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max: df[col] = df[col].astype(np.int32) elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max: df[col] = df[col].astype(np.int64) else: if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max: df[col] = df[col].astype(np.float16) elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max: df[col] = df[col].astype(np.float32) else: df[col] = df[col].astype(np.float64) end_mem = df.memory_usage(deep=True).sum() / 1024**2 if verbose: print('Mem. usage decreased to {:5.2f} Mb ({:.1f}% reduction)'.format(end_mem, 100 * (start_mem - end_mem) / start_mem)) return df 1

đầu ra

# Reduce memory usage def reduce_mem_usage(df, verbose=True): numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64'] start_mem = df.memory_usage(deep=True).sum() / 1024**2 for col in df.columns: col_type = df[col].dtypes if col_type in numerics: c_min = df[col].min() c_max = df[col].max() if str(col_type)[:3] == 'int': if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max: df[col] = df[col].astype(np.int8) elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max: df[col] = df[col].astype(np.int16) elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max: df[col] = df[col].astype(np.int32) elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max: df[col] = df[col].astype(np.int64) else: if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max: df[col] = df[col].astype(np.float16) elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max: df[col] = df[col].astype(np.float32) else: df[col] = df[col].astype(np.float64) end_mem = df.memory_usage(deep=True).sum() / 1024**2 if verbose: print('Mem. usage decreased to {:5.2f} Mb ({:.1f}% reduction)'.format(end_mem, 100 * (start_mem - end_mem) / start_mem)) return df 2

Xuất sang sàn gỗ

# Reduce memory usage def reduce_mem_usage(df, verbose=True): numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64'] start_mem = df.memory_usage(deep=True).sum() / 1024**2 for col in df.columns: col_type = df[col].dtypes if col_type in numerics: c_min = df[col].min() c_max = df[col].max() if str(col_type)[:3] == 'int': if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max: df[col] = df[col].astype(np.int8) elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max: df[col] = df[col].astype(np.int16) elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max: df[col] = df[col].astype(np.int32) elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max: df[col] = df[col].astype(np.int64) else: if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max: df[col] = df[col].astype(np.float16) elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max: df[col] = df[col].astype(np.float32) else: df[col] = df[col].astype(np.float64) end_mem = df.memory_usage(deep=True).sum() / 1024**2 if verbose: print('Mem. usage decreased to {:5.2f} Mb ({:.1f}% reduction)'.format(end_mem, 100 * (start_mem - end_mem) / start_mem)) return df 3

đầu ra

# Reduce memory usage def reduce_mem_usage(df, verbose=True): numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64'] start_mem = df.memory_usage(deep=True).sum() / 1024**2 for col in df.columns: col_type = df[col].dtypes if col_type in numerics: c_min = df[col].min() c_max = df[col].max() if str(col_type)[:3] == 'int': if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max: df[col] = df[col].astype(np.int8) elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max: df[col] = df[col].astype(np.int16) elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max: df[col] = df[col].astype(np.int32) elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max: df[col] = df[col].astype(np.int64) else: if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max: df[col] = df[col].astype(np.float16) elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max: df[col] = df[col].astype(np.float32) else: df[col] = df[col].astype(np.float64) end_mem = df.memory_usage(deep=True).sum() / 1024**2 if verbose: print('Mem. usage decreased to {:5.2f} Mb ({:.1f}% reduction)'.format(end_mem, 100 * (start_mem - end_mem) / start_mem)) return df 4

Xuất sang định dạng Feather

# Reduce memory usage def reduce_mem_usage(df, verbose=True): numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64'] start_mem = df.memory_usage(deep=True).sum() / 1024**2 for col in df.columns: col_type = df[col].dtypes if col_type in numerics: c_min = df[col].min() c_max = df[col].max() if str(col_type)[:3] == 'int': if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max: df[col] = df[col].astype(np.int8) elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max: df[col] = df[col].astype(np.int16) elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max: df[col] = df[col].astype(np.int32) elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max: df[col] = df[col].astype(np.int64) else: if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max: df[col] = df[col].astype(np.float16) elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max: df[col] = df[col].astype(np.float32) else: df[col] = df[col].astype(np.float64) end_mem = df.memory_usage(deep=True).sum() / 1024**2 if verbose: print('Mem. usage decreased to {:5.2f} Mb ({:.1f}% reduction)'.format(end_mem, 100 * (start_mem - end_mem) / start_mem)) return df 5

đầu ra

# Reduce memory usage def reduce_mem_usage(df, verbose=True): numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64'] start_mem = df.memory_usage(deep=True).sum() / 1024**2 for col in df.columns: col_type = df[col].dtypes if col_type in numerics: c_min = df[col].min() c_max = df[col].max() if str(col_type)[:3] == 'int': if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max: df[col] = df[col].astype(np.int8) elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max: df[col] = df[col].astype(np.int16) elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max: df[col] = df[col].astype(np.int32) elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max: df[col] = df[col].astype(np.int64) else: if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max: df[col] = df[col].astype(np.float16) elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max: df[col] = df[col].astype(np.float32) else: df[col] = df[col].astype(np.float64) end_mem = df.memory_usage(deep=True).sum() / 1024**2 if verbose: print('Mem. usage decreased to {:5.2f} Mb ({:.1f}% reduction)'.format(end_mem, 100 * (start_mem - end_mem) / start_mem)) return df 6

Hóa ra sàn gỗ và lông vũ nhanh hơn 15 lần, trong đó lông vũ là nhanh nhất

Hãy thử đọc lại chúng trong

# Reduce memory usage def reduce_mem_usage(df, verbose=True): numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64'] start_mem = df.memory_usage(deep=True).sum() / 1024**2 for col in df.columns: col_type = df[col].dtypes if col_type in numerics: c_min = df[col].min() c_max = df[col].max() if str(col_type)[:3] == 'int': if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max: df[col] = df[col].astype(np.int8) elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max: df[col] = df[col].astype(np.int16) elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max: df[col] = df[col].astype(np.int32) elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max: df[col] = df[col].astype(np.int64) else: if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max: df[col] = df[col].astype(np.float16) elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max: df[col] = df[col].astype(np.float32) else: df[col] = df[col].astype(np.float64) end_mem = df.memory_usage(deep=True).sum() / 1024**2 if verbose: print('Mem. usage decreased to {:5.2f} Mb ({:.1f}% reduction)'.format(end_mem, 100 * (start_mem - end_mem) / start_mem)) return df 7

đầu ra

# Reduce memory usage def reduce_mem_usage(df, verbose=True): numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64'] start_mem = df.memory_usage(deep=True).sum() / 1024**2 for col in df.columns: col_type = df[col].dtypes if col_type in numerics: c_min = df[col].min() c_max = df[col].max() if str(col_type)[:3] == 'int': if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max: df[col] = df[col].astype(np.int8) elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max: df[col] = df[col].astype(np.int16) elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max: df[col] = df[col].astype(np.int32) elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max: df[col] = df[col].astype(np.int64) else: if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max: df[col] = df[col].astype(np.float16) elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max: df[col] = df[col].astype(np.float32) else: df[col] = df[col].astype(np.float64) end_mem = df.memory_usage(deep=True).sum() / 1024**2 if verbose: print('Mem. usage decreased to {:5.2f} Mb ({:.1f}% reduction)'.format(end_mem, 100 * (start_mem - end_mem) / start_mem)) return df 8

Đọc lại tập tin lông vũ

# Reduce memory usage def reduce_mem_usage(df, verbose=True): numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64'] start_mem = df.memory_usage(deep=True).sum() / 1024**2 for col in df.columns: col_type = df[col].dtypes if col_type in numerics: c_min = df[col].min() c_max = df[col].max() if str(col_type)[:3] == 'int': if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max: df[col] = df[col].astype(np.int8) elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max: df[col] = df[col].astype(np.int16) elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max: df[col] = df[col].astype(np.int32) elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max: df[col] = df[col].astype(np.int64) else: if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max: df[col] = df[col].astype(np.float16) elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max: df[col] = df[col].astype(np.float32) else: df[col] = df[col].astype(np.float64) end_mem = df.memory_usage(deep=True).sum() / 1024**2 if verbose: print('Mem. usage decreased to {:5.2f} Mb ({:.1f}% reduction)'.format(end_mem, 100 * (start_mem - end_mem) / start_mem)) return df 9

đầu ra

df = pd.DataFrame({'age':[1,2,3,4,5,6]}) print(df.dtypes) df.memory_usage() # 64 bits per item 0

Nhập các định dạng Parquet và Feather cũng nhanh hơn nhiều khi nhập dữ liệu, so với csv. Vì vậy, rõ ràng khi làm việc với dữ liệu lớn, sàn gỗ và lông vũ được ưu tiên hơn. Sàn gỗ được áp dụng tương đối rộng hơn, vì vậy bạn có thể muốn xem xét điều đó

Một giải pháp thay thế khác mà bạn có thể muốn khám phá là lưu trữ dữ liệu ở định dạng HDF5 trong đó tải dữ liệu thường diễn ra tức thời

6. gấu trúc thay thế

Mặc dù gấu trúc là loại thư viện mặc định mà mọi người sử dụng để sắp xếp dữ liệu với python, nhưng cũng có những tùy chọn đáng gờm khác

Tôi đã khá ấn tượng với

1. Modin – Cho phép bạn làm việc trên dữ liệu lớn. Thông qua Modin, bạn có thể làm việc với các thư viện hiệu suất cao khác như 'dask' và 'ray' bằng chính cú pháp pandas. Bạn có thể sử dụng chính xác cú pháp pandas bằng cách thay đổi chỉ một dòng mã

2. Vaex – Sử dụng ánh xạ bộ nhớ để cho phép bạn làm việc với các bộ dữ liệu lớn mà bạn không thể tải vào bộ nhớ RAM

3. Dask – Thực hiện hiệu quả xử lý song song cho các nhiệm vụ phân tích dữ liệu. Rất khuyến khích

Ghi chú. Tôi dạy Pandas, các thư viện thay thế và các phương pháp khác để tăng tốc mã trong khóa học Pandas cho Khoa học dữ liệu, một phần của Khóa học trực tuyến đại học ML+

7. dask

Dask yêu cầu một đề cập đặc biệt vì có nhiều gói đa luồng và song song khác nhau trong Python. Nhưng khi nói đến Sắp xếp và phân tích dữ liệu, Dask rất tuyệt

Dask dataframes sử dụng đánh giá chậm, tính toán song song và đồ thị tính toán để cho phép bạn làm việc với các tập dữ liệu lớn

Hướng dẫn dask này sẽ cung cấp cho bạn tổng quan nhanh về các chức năng của dask và hiểu rõ các ý tưởng cốt lõi

Dask cũng hoạt động tốt với các thư viện máy học phổ biến khác như sklearn, XGBoost, LightGBM, PyTorch và TensorFlow

Bạn cũng có thể xây dựng các mô hình máy học bằng cách sử dụng Dask và song song hóa nó

Dưới đây là một ví dụ nhanh về cách bạn có thể xây dựng mô hình SVM và tìm kiếm mô hình tốt nhất bằng cách sử dụng RandomizedSearch

df = pd.DataFrame({'age':[1,2,3,4,5,6]}) print(df.dtypes) df.memory_usage() # 64 bits per item 1

8. Điện toán phân tán với Spark

Khi bạn muốn làm việc trên dữ liệu lớn, nơi kích thước của dữ liệu không ngừng tăng lên, các công ty sử dụng điện toán phân tán với tia lửa nơi dữ liệu được lưu trữ trong các cụm khác nhau

Apache Spark là một khung nguồn mở có thể mở rộng quy mô khi dữ liệu của bạn lớn lên. Hai nhà cung cấp thương mại chính triển khai Apache Spark là Databricks và Cloudera

Điều gì là tuyệt vời về Spark?

Ngày nay, nó là một công cụ không thể thiếu cho Data Engineers. Spark tương tác độc đáo với Python và SQL, nơi bạn có thể kết hợp liền mạch các truy vấn SQL với mã Python/Spark

df = pd.DataFrame({'age':[1,2,3,4,5,6]}) print(df.dtypes) df.memory_usage() # 64 bits per item 2

Bạn có thể nhập dữ liệu từ nhiều nguồn dữ liệu khác nhau, chạy các truy vấn HIVE và với các gói như Koalas, bạn có thể viết mã như gấu trúc và vẫn sử dụng pyspark trong phần phụ trợ

Đối với các Nhà khoa học dữ liệu, một cách sử dụng quan trọng là triển khai phiên bản phân tán của các thuật toán ML khác nhau trong Spark

9. Tiện ích mở rộng Intel(R) cho sklearn

Một cách khả thi để xử lý dữ liệu lớn là sử dụng một mẫu nhỏ hơn trong tập dữ liệu của bạn để xây dựng các mô hình máy học

Trong khi làm điều đó, bạn có thể muốn xây dựng các mô hình của mình trên nhiều mẫu thay vì chỉ một mẫu để khái quát hóa các dự đoán. Trong quy trình này, điều quan trọng là có thể đào tạo các mô hình ML của bạn khá nhanh

Có thể tăng tốc độ đào tạo các mô hình ML của bạn được xây dựng bằng scikit-learning bằng tiện ích mở rộng Intel(R) cho thư viện scikit-learning

Tăng tốc các thuật toán đến mức 3000 lần đã được báo cáo

Điều tuyệt vời là để sử dụng tính năng tăng tốc này, bạn không cần phải thay đổi mã scikit-learning hiện có của mình

Cài đặt tiện ích mở rộng

df = pd.DataFrame({'age':[1,2,3,4,5,6]}) print(df.dtypes) df.memory_usage() # 64 bits per item 3

Nhập triển khai cụ thể của thuật toán ML

df = pd.DataFrame({'age':[1,2,3,4,5,6]}) print(df.dtypes) df.memory_usage() # 64 bits per item 4

Ngoài ra, bạn có thể vá mọi thứ để tất cả các mô hình scikit-learning hiện tại của bạn sẽ sử dụng tiện ích mở rộng Inter(R) thay thế

df = pd.DataFrame({'age':[1,2,3,4,5,6]}) print(df.dtypes) df.memory_usage() # 64 bits per item 5

Các công cụ và mẹo chung bạn có thể khai thác

1. Áp dụng các chức năng Vectorized

Bất cứ khi nào có thể, hãy sử dụng các hàm tích hợp sẵn trong pandas hoặc numpy để thực hiện các thao tác

Nếu bạn phải sử dụng hàm df_compressed = reduce_mem_usage(df) print(df_compressed.dtypes) df.memory_usage() # 8 bits per item 4, hãy xem liệu thao tác đó có thể được thực hiện bằng hàm dựng sẵn không. Điều này là do, df_compressed = reduce_mem_usage(df) print(df_compressed.dtypes) df.memory_usage() # 8 bits per item 5 và những người anh em họ của nó như df_compressed = reduce_mem_usage(df) print(df_compressed.dtypes) df.memory_usage() # 8 bits per item 6, v.v. sẽ lặp trên toàn bộ khung dữ liệu

Trong khi các hàm dựng sẵn (như df_compressed = reduce_mem_usage(df) print(df_compressed.dtypes) df.memory_usage() # 8 bits per item 7, v.v.) thường được tối ưu hóa về tốc độ và thường chạy nhanh hơn nhiều

2. tê liệt

Numba cho phép bạn tăng tốc các chức năng python thuần túy bằng cách JIT kết hợp chúng thành các chức năng máy gốc

Trong một số trường hợp, bạn có thể thấy những cải tiến đáng kể về tốc độ chỉ bằng cách thêm một trình trang trí df_compressed = reduce_mem_usage(df) print(df_compressed.dtypes) df.memory_usage() # 8 bits per item 8

df = pd.DataFrame({'age':[1,2,3,4,5,6]}) print(df.dtypes) df.memory_usage() # 64 bits per item 6

Đó là nó. Chỉ cần thêm df_compressed = reduce_mem_usage(df) print(df_compressed.dtypes) df.memory_usage() # 8 bits per item 9 vào chức năng của bạn. Bạn cũng có thể song song hóa các chức năng của mình bằng cách sử dụng age int64 dtype: object Index 128 age 48 dtype: int64 00

Để biết thêm, đây là hướng dẫn 5 phút về Numba

3. pd. đánh giá và pd. truy vấn

Mã gấu trúc điển hình của bạn sẽ nhanh hơn nếu bạn sử dụng age int64 dtype: object Index 128 age 48 dtype: int64 01 hoặc age int64 dtype: object Index 128 age 48 dtype: int64 02 thay vì sử dụng các phương thức khung dữ liệu tương ứng

df = pd.DataFrame({'age':[1,2,3,4,5,6]}) print(df.dtypes) df.memory_usage() # 64 bits per item 7

ABC0110101289236834474526

df = pd.DataFrame({'age':[1,2,3,4,5,6]}) print(df.dtypes) df.memory_usage() # 64 bits per item 8

ABC4526

Điều này về cơ bản giống như mã pandas sau

df = pd.DataFrame({'age':[1,2,3,4,5,6]}) print(df.dtypes) df.memory_usage() # 64 bits per item 9

ABC4526

Bây giờ nếu bạn muốn sử dụng một giá trị biến không phải là một cột trong khung dữ liệu, bạn có thể làm như sau

age int64 dtype: object Index 128 age 48 dtype: int64 0

ABC34474526

Bây giờ, age int64 dtype: object Index 128 age 48 dtype: int64 01 rất giống với age int64 dtype: object Index 128 age 48 dtype: int64 02, chỉ khác là nó hoạt động như một chức năng gấu trúc cấp cao nhất

age int64 dtype: object Index 128 age 48 dtype: int64 1

động vật0chó101lợn20

Đọc thêm. Nâng cao hiệu suất của Pandas

age int64 dtype: object Index 128 age 48 dtype: int64 2

animalagedouble_age0dog10201pig2040

4. Rapids cuDF

Thư viện cudf của Rapids cho phép bạn sử dụng sức mạnh của GPU trong khi làm việc với các chú gấu trúc quen thuộc như api

Nó cho phép bạn thực hiện các tác vụ sắp xếp dữ liệu điển hình cũng như xây dựng các mô hình ML như xgboost và huấn luyện chúng trên GPU

Selva Prabhakaran

Selva là Tác giả chính và Biên tập viên của Machine Learning Plus, với hơn 4 triệu độc giả. Anh ấy là tác giả của các khóa học và sách với hơn 100 nghìn sinh viên và là Nhà khoa học dữ liệu chính của một công ty toàn cầu

Làm cách nào để phân tích Dữ liệu lớn trong Python?

Python có thể xử lý Dữ liệu lớn không?

Làm thế nào để đọc Dữ liệu lớn?

Python có thể xử lý 1 tỷ hàng không?