Panda를 사용한 "대용량 데이터" 워크플로우
나는 판다를 배우면서 몇 달 동안 이 질문에 대한 답을 알아내려고 노력했다.일상 업무에 SAS를 사용하고 있기 때문에, 코어외의 서포트에 최적입니다.그러나 SAS는 여러 가지 이유로 소프트웨어로서 끔찍합니다.
언젠가는 SAS를 Python 및 Pander로 대체하고 싶지만, 현재 대규모 데이터셋을 위한 핵심 외 워크플로우가 없습니다.분산형 네트워크를 필요로 하는 "빅 데이터"를 말하는 것이 아니라, 파일을 메모리에 넣기에는 너무 크지만 하드 드라이브에 넣기에는 충분히 작다는 것입니다.
는 ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★HDFStore디스크에 대용량 데이터 세트를 보관하고 분석을 위해 필요한 부분만 데이터 프레임에 가져올 수 있습니다.다른 사람들은 MongoDB를 사용하기 쉬운 대안으로 언급하고 있다.
다음을 달성하기 위한 모범 사례 워크플로우는 다음과 같습니다.
- 영구적인 온디스크 데이터베이스 구조에 플랫 파일 로드
- 해당 데이터베이스에 문의하여 Panda 데이터 구조에 입력할 데이터 검색
- 판다 조각 조작 후 데이터베이스 업데이트
특히 "대용량 데이터"에 판다를 사용하는 사람이라면, 실제 사례도 매우 감사할 것입니다.
편집 - 이 작업을 수행하는 방법의 예:
- 큰 플랫 파일을 반복적으로 Import하여 영구적인 온디스크 데이터베이스 구조에 저장합니다.일반적으로 이러한 파일은 너무 커서 메모리에 넣을 수 없습니다.
- Panda를 사용하기 위해 이 데이터의 서브셋(보통 한 번에 몇 컬럼만)을 메모리에 저장할 수 있는 것을 읽고 싶습니다.
- 선택한 열에 대해 다양한 작업을 수행하여 새 열을 만듭니다.
- 그런 다음 이 새 열을 데이터베이스 구조에 추가해야 합니다.
이러한 순서를 실행하는 베스트 프랙티스 방법을 찾고 있습니다.팬더와 표범에 관한 링크들을 읽어보면 새로운 칼럼을 추가하는 것은 문제가 될 수 있다.
편집 -- Jeff의 질문에 대한 답변:
- 나는 소비자 신용위험 모델을 만들고 있다.데이터의 종류에는 전화, SSN 및 주소 특성, 재산 가치, 범죄 기록, 파산 등과 같은 모욕적인 정보가 포함됩니다.매일 사용하는 데이터 세트에는 숫자 및 문자 데이터의 연속형, 공칭형 및 서수형 변수와 같은 혼합 데이터 유형이 평균 1,000~2,000개 가까이 있습니다.행을 추가하는 일은 거의 없지만 새 열을 만드는 작업은 많이 수행합니다.
- 일반적인 연산은 조건부 논리를 사용하여 여러 열을 새로운 복합 열로 결합하는 것을 포함합니다.를 들어, 「」라고 하는 것은,
if var1 > 2 then newvar = 'A' elif var2 = 4 then newvar = 'B'이 작업의 결과는 데이터 세트의 모든 레코드에 대해 새로운 컬럼이 됩니다. - 마지막으로 이 새로운 컬럼을 온디스크 데이터 구조에 추가하겠습니다.2단계를 반복하여 크로스탭과 기술 통계로 데이터를 탐색하고 모델에 대한 흥미롭고 직관적인 관계를 찾습니다.
- 보통 프로젝트 파일은 약 1GB입니다.파일은 행이 소비자 데이터의 레코드로 구성되도록 구성됩니다.각 행에는 각 레코드에 대해 동일한 수의 열이 있습니다.항상 이런 식입니다.
- 새 열을 만들 때 행 단위로 하위 집합을 작성하는 경우는 거의 없습니다.그러나 보고서를 작성하거나 기술 통계 정보를 생성할 때 행에 하위 집합을 지정하는 것은 매우 일반적입니다.예를 들어, 소매 신용 카드와 같은 특정 사업 부문을 위한 간단한 빈도를 만들고 싶을 수 있습니다.그러기 위해서는, 보고하는 칼럼에 가세해, line of business=소매하는 레코드만을 선택합니다.그러나 새 열을 만들 때는 모든 데이터 행과 작업에 필요한 열만 가져옵니다.
- 모델링 프로세스에서는 모든 열을 분석하고, 결과 변수와 흥미로운 관계를 찾고, 이러한 관계를 설명하는 새로운 복합 열을 생성해야 합니다.제가 탐색하는 기둥은 보통 작은 세트로 이루어집니다.예를 들어 부동산 가치만을 다루는 20개의 열에 초점을 맞추고 대출 불이행과 어떤 관계가 있는지 관찰합니다.그런 것들이 탐색되고 새로운 칼럼이 만들어지면, 저는 다른 칼럼 그룹으로 넘어가서 대학교육이라고 말하고, 그 과정을 반복합니다.제가 하고 있는 일은 제 데이터와 결과 간의 관계를 설명하는 후보 변수를 만드는 것입니다.이 과정의 맨 마지막에, 저는 복합 열에서 방정식을 만드는 몇 가지 학습 기술을 적용했습니다.
데이터 세트에 행을 추가하는 경우는 거의 없습니다.거의 항상 새로운 열(통계/기계 학습 용어의 변수 또는 기능)을 만듭니다.
이런 식으로 수십 기가바이트의 데이터를 일상적으로 사용하고 있습니다.쿼리를 통해 읽고 데이터를 만든 후 다시 추가하는 테이블이 디스크에 있습니다.
이 문서의 후반부에서 데이터 저장 방법에 대한 몇 가지 제안을 읽어볼 가치가 있습니다.
데이터 저장 방법에 영향을 미치는 다음과 같은 세부 정보:
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★ 그러면 구조를 개발하는 데 도움을 드릴 수 있습니다.
- 데이터 크기, 행 수, 열, 열 유형. 행을 추가하시겠습니까, 아니면 열만 추가하시겠습니까?
- 쿼리를 행한 후 작업 내하고 새예를 들어 열에 대한 쿼리를 수행하여 행 묶음과 특정 열을 선택한 다음 작업(메모리 내)을 수행하고 새 열을 만들고 저장합니다.
(장난감 예시를 제시하면 보다 구체적인 권장사항을 제시할 수 있습니다.) - 그 처리가 끝나면 어떻게 해야 하나요?스텝 2는 애드혹 또는 반복 가능합니까?
- 입력 플랫 파일: 대략적인 총 크기(Gb 단위)입니다.예를 들어 기록별로 어떻게 정리되어 있습니까?각 필드에 다른 필드가 포함되어 있습니까, 아니면 각 파일의 모든 필드가 포함된 파일당 레코드가 포함되어 있습니까?
- 기준에 따라 행(레코드)의 서브셋을 선택한 후(예를 들어 필드 A > 5의 행을 선택) 작업을 수행하거나 모든 레코드가 포함된 필드 A, B, C를 선택한 후 작업을 수행합니까?
- 모든 컬럼(그룹별로)을 '작업'하고 있습니까?아니면 보고서에만 사용할 수 있는 비율이 높습니까?(예를 들어 데이터를 주변에 보관하고 싶지만 최종 결과 시간까지 해당 컬럼의 설명을 가져올 필요는 없습니다.)
솔루션
파일 청크 바이 청크 및 여러 테이블 쿼리를 반복합니다.
pytables는 행 단위(쿼리 대상)에서 작동하도록 최적화되어 있으므로 각 필드 그룹에 대한 테이블을 만듭니다.이렇게 하면 작은 필드 그룹을 쉽게 선택할 수 있습니다(큰 테이블과 함께 사용할 수 있지만 이렇게 하는 것이 더 효율적입니다).더 입니다.의
(미국의)
import numpy as np
import pandas as pd
# create a store
store = pd.HDFStore('mystore.h5')
# this is the key to your storage:
# this maps your fields to a specific group, and defines
# what you want to have as data_columns.
# you might want to create a nice class wrapping this
# (as you will want to have this map and its inversion)
group_map = dict(
A = dict(fields = ['field_1','field_2',.....], dc = ['field_1',....,'field_5']),
B = dict(fields = ['field_10',...... ], dc = ['field_10']),
.....
REPORTING_ONLY = dict(fields = ['field_1000','field_1001',...], dc = []),
)
group_map_inverted = dict()
for g, v in group_map.items():
group_map_inverted.update(dict([ (f,g) for f in v['fields'] ]))
읽기 및 생성(으로 "Doing that" ("Doing the files in files and storage (본질적으로 " that" (실행)append_to_multipledoes : ) :
for f in files:
# read in the file, additional options may be necessary here
# the chunksize is not strictly necessary, you may be able to slurp each
# file into memory in which case just eliminate this part of the loop
# (you can also change chunksize if necessary)
for chunk in pd.read_table(f, chunksize=50000):
# we are going to append to each table by group
# we are not going to create indexes at this time
# but we *ARE* going to create (some) data_columns
# figure out the field groupings
for g, v in group_map.items():
# create the frame for this group
frame = chunk.reindex(columns = v['fields'], copy = False)
# append it
store.append(g, frame, index=False, data_columns = v['dc'])
이제 파일 내의 모든 테이블이 있습니다(실제로 원하는 경우 별도의 파일에 저장할 수 있습니다.파일명을 group_map에 추가해야 하지만 이는 필요하지 않을 수 있습니다).
열을 가져오고 새 열을 만드는 방법은 다음과 같습니다.
frame = store.select(group_that_I_want)
# you can optionally specify:
# columns = a list of the columns IN THAT GROUP (if you wanted to
# select only say 3 out of the 20 columns in this sub-table)
# and a where clause if you want a subset of the rows
# do calculations on this frame
new_frame = cool_function_on_frame(frame)
# to 'add columns', create a new group (you probably want to
# limit the columns in this new_group to be only NEW ones
# (e.g. so you don't overlap from the other tables)
# add this info to the group_map
store.append(new_group, new_frame.reindex(columns = new_columns_created, copy = False), data_columns = new_columns_created)
post_processing 준비가 되면:
# This may be a bit tricky; and depends what you are actually doing.
# I may need to modify this function to be a bit more general:
report_data = store.select_as_multiple([groups_1,groups_2,.....], where =['field_1>0', 'field_1000=foo'], selector = group_1)
data_columns에 대해서는 실제로 data_columns를 정의할 필요가 없습니다.이것에 의해, 열에 근거해 행을 선택할 수 있습니다.예:
store.select(group, where = ['field_1000=foo', 'field_1001>0'])
최종 보고서 생성 단계에서 가장 흥미로울 수 있습니다(기본적으로 데이터 열은 다른 열과 분리되므로 로트를 정의하면 효율성에 다소 영향을 미칠 수 있습니다).
다음과 같은 경우도 있습니다.
- 필드 목록을 가져와 groups_map 내의 그룹을 검색한 후 결과를 연결하여 결과 프레임을 얻는 함수를 만듭니다(기본적으로 이것이 select_as_map이 수행하는 작업입니다).이렇게 하면 구조가 상당히 투명해집니다.
- 특정 데이터 열의 인덱스(행 변환 속도가 훨씬 빠릅니다).
- 압축을 유효하게 합니다.
궁금한 거 있으면 알려줘!
위의 답변에는 매우 유용하다고 생각되는 간단한 접근법이 결여되어 있다고 생각합니다.
용량이 너무 커서 메모리에 로드할 수 없는 파일이 있는 경우 파일을 여러 개의 작은 파일(행 또는 콜)로 분할합니다.
예:30일간 거래되는 30GB 이하의 데이터의 경우, 1일당 1GB 이하의 파일로 분할합니다.그 후 각 파일을 개별적으로 처리하여 마지막에 결과를 집계합니다.
가장 큰 장점 중 하나는 파일(복수의 스레드 또는 프로세스)을 병렬 처리할 수 있다는 것입니다.
또 다른 장점은 파일 조작(예시의 날짜 추가/삭제 등)을 일반 셸 명령으로 실행할 수 있다는 것입니다.이것은, 보다 고도의 파일 형식이나 복잡한 파일 형식에서는 실행할 수 없습니다.
이 접근방식은 모든 시나리오를 망라하는 것은 아니지만 많은 시나리오에서 매우 유용합니다.
그 질문으로부터 2년이 지난 지금, '핵심 밖의' 판다와 동등한 '대스크'가 있다.훌륭해!모든 판다의 기능을 지원하는 것은 아니지만, 충분히 사용할 수 있습니다.업데이트: 지난 2년간 지속적으로 유지되어 왔으며, Dask와 함께 작업하는 사용자 커뮤니티가 상당합니다.
그리고 4년이 지난 지금, Vaex에는 또 다른 고성능 '핵심 외' 판다들이 있다.「메모리 매핑, 제로 메모리 카피 폴리시, 저속한 연산을 사용해 최고의 퍼포먼스를 실현합니다(메모리 낭비가 없습니다).수십억 행의 데이터 세트를 처리할 수 있으며 메모리에 저장하지 않습니다(최적화되지 않은 하드웨어에 대한 분석도 가능).
데이터셋이 1~20GB 사이인 경우 RAM이 48GB인 워크스테이션을 구입해야 합니다.그러면 Panda는 전체 데이터 세트를 RAM에 저장할 수 있습니다.여러분이 찾고 있는 답은 아니지만, 4GB의 RAM을 탑재한 노트북으로 과학 컴퓨팅을 하는 것은 합리적이지 않습니다.
이것이 오래된 정보라는 것을 알지만 Blaze 도서관은 확인해 볼 가치가 있다고 생각한다.이런 상황에 맞게 설계되어 있습니다.
문서에서:
Blaze는 NumPy와 Panda의 사용성을 분산형 및 코어 외 컴퓨팅으로 확장합니다.Blaze는 NumPy ND-Array 또는 Panda DataFrame과 유사한 인터페이스를 제공하지만 이러한 익숙한 인터페이스를 Postgres 또는 Spark와 같은 다른 다양한 계산 엔진에 매핑합니다.
편집: 덧붙여서 Continuum에서 지원됩니다.IO와 NumPy의 저자 Travis Oliphant.
이치노sql server, sqlite, HDF, ORM(SQL Chemy)의 sql server, sqlite, HDF, ORM(SQL Chemy)의 sql server.DB이므로 가.dict속성)을 참조해 주세요.많은 사람들이 컬렉션을 형성하고 당신은 많은 컬렉션(사람, 주식 시장, 수입)을 가질 수 있다.
>pd.dateframe -> pymongo 사용: 저는 pymongo를 합니다.chunksizeread_csv5~10,000 레코드 (피몽고가 크면 소켓을 떨어뜨린다)
aCollection.insert((a[1].to_dict() for a in df.iterrows()))
쿼리: gt = 다음보다 큼...
pd.DataFrame(list(mongoCollection.find({'anAttribute':{'$gt':2887000, '$lt':2889000}})))
.find()를 반환하기 에 나는 으로 ''를 사용합니다.ichunked더 작은 반복기로 자릅니다.
보통 10개의 데이터 소스를 붙여 넣기 때문에 조인하는 것은 어떻습니까?)
aJoinDF = pandas.DataFrame(list(mongoCollection.find({'anAttribute':{'$in':Att_Keys}})))
내 경우엔 () 화를 할 가 있다.)aJoinDF의
df = pandas.merge(df, aJoinDF, on=aKey, how='left')
그런 다음 아래 업데이트 방법을 통해 새 정보를 메인 컬렉션에 쓸 수 있습니다.(논리 수집과 물리 데이터 소스).
collection.update({primarykey:foo},{key:change})
소규모 검색에서는 정규화 해제만 하면 됩니다. 문서 내에 필드 하여 ", ", ", ", ", "dict문서를 작성할 때 검색합니다.
이제 한 사람을 중심으로 한 훌륭한 데이터셋이 제공되므로 각 사례에 대한 논리를 풀어 더 많은 속성을 만들 수 있습니다.마지막으로 팬더에게 3개의 최대 메모리 키 지표를 읽고 피벗/agg/데이터 탐색을 수행할 수 있습니다.숫자/큰 텍스트/카테고리/코드/플로트/...를 포함한 300만 레코드에 사용할 수 있습니다.
MongoDB(MapReduce 및 Aggregate Framework)에 내장된 두 가지 메서드를 사용할 수도 있습니다.Aggregate 프레임워크는 MapReduce보다 쉽고 빠른 Aggregate 작업에 편리하므로 자세한 내용은 여기를 참조하십시오.필드나 관계를 정의할 필요가 없으며 문서에 항목을 추가할 수 있습니다.numpy, panda, python toolset, MongoDB가 빠르게 변화하는 현재 상황에서 저는 바로 업무를 시작할 수 있습니다.
대규모 데이터 사용 사례에서 유용한 방법 중 하나는 플로트 정밀도를 32비트로 줄여 데이터 볼륨을 줄이는 것입니다.모든 경우에 적용되는 것은 아니지만 대부분의 애플리케이션에서 64비트 정밀도는 과잉이며 2배의 메모리 절약을 기대할 수 있습니다.보다 명확한 점을 강조하기 위해:
>>> df = pd.DataFrame(np.random.randn(int(1e8), 5))
>>> df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 100000000 entries, 0 to 99999999
Data columns (total 5 columns):
...
dtypes: float64(5)
memory usage: 3.7 GB
>>> df.astype(np.float32).info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 100000000 entries, 0 to 99999999
Data columns (total 5 columns):
...
dtypes: float32(5)
memory usage: 1.9 GB
조금 늦었지만, 같은 문제(모기지 선불 모델)로 일하고 있습니다.제 해결책은 팬더 HDFStore 층을 건너뛰고 스트레이트 피테이블을 사용하는 것이었습니다.각 열을 개별 HDF5 배열로 최종 파일에 저장합니다.
기본 워크플로우는 먼저 데이터베이스에서 CSV 파일을 가져오는 것입니다.제가 지퍼를 올렸기 때문에 그렇게 크지는 않아요.그런 다음 python에서 반복하여 각 행을 실제 데이터 유형으로 변환하고 HDF5 파일에 씁니다.수십 분 정도 걸리지만, 한 줄 한 줄로 작동하기 때문에 메모리를 사용하지 않습니다.그런 다음 행 지향 HDF5 파일을 열 지향 HDF5 파일로 "변환"합니다.
테이블 전치는 다음과 같습니다.
def transpose_table(h_in, table_path, h_out, group_name="data", group_path="/"):
# Get a reference to the input data.
tb = h_in.getNode(table_path)
# Create the output group to hold the columns.
grp = h_out.createGroup(group_path, group_name, filters=tables.Filters(complevel=1))
for col_name in tb.colnames:
logger.debug("Processing %s", col_name)
# Get the data.
col_data = tb.col(col_name)
# Create the output array.
arr = h_out.createCArray(grp,
col_name,
tables.Atom.from_dtype(col_data.dtype),
col_data.shape)
# Store the data.
arr[:] = col_data
h_out.flush()
다시 읽어보면 다음과 같습니다.
def read_hdf5(hdf5_path, group_path="/data", columns=None):
"""Read a transposed data set from a HDF5 file."""
if isinstance(hdf5_path, tables.file.File):
hf = hdf5_path
else:
hf = tables.openFile(hdf5_path)
grp = hf.getNode(group_path)
if columns is None:
data = [(child.name, child[:]) for child in grp]
else:
data = [(child.name, child[:]) for child in grp if child.name in columns]
# Convert any float32 columns to float64 for processing.
for i in range(len(data)):
name, vec = data[i]
if vec.dtype == np.float32:
data[i] = (name, vec.astype(np.float64))
if not isinstance(hdf5_path, tables.file.File):
hf.close()
return pd.DataFrame.from_items(data)
저는 보통 메모리를 많이 탑재한 머신에서 실행하고 있기 때문에 메모리 사용에 충분히 주의하지 않을 수 있습니다.예를 들어 기본적으로 로드 작업은 전체 데이터 세트를 읽습니다.
이건 보통 나한테는 먹히는데 좀 투박해서 화려한 피테이블 마법을 쓸 수가 없어.
편집: 이 접근법의 진정한 장점은 레코드 배열 pytables 기본값에 비해 테이블을 처리할 수 없는h5r을 사용하여 데이터를 R에 로드할 수 있다는 것입니다.또는 적어도 이종 테이블을 로드할 수 없었습니다.
다른 사람들이 지적했듯이, 몇 년 후 '핵심 밖' 판다에 상당하는 '대스크'가 등장했습니다.Dask는 팬더와 그 모든 기능을 대체하지는 않지만 몇 가지 이유로 눈에 띈다.
Dask는 분석 컴퓨팅을 위한 유연한 병렬 컴퓨팅 라이브러리로서 병렬 어레이, 데이터 프레임, NumPy, Panders 또는 Python 반복기 등의 공통 인터페이스를 메모리보다 큰 용량 또는 분산 환경 및노트북에서 클러스터로 이동합니다.
Dask는 다음과 같은 장점을 강조합니다.
- 익숙함: 병렬화된 NumPy 어레이 및 Panda DataFrame 객체 제공
- 유연성:더 많은 사용자 지정 워크로드 및 다른 프로젝트와의 통합을 위한 작업 스케줄링 인터페이스를 제공합니다.
- 네이티브: PyData 스택에 액세스하여 Pure Python에서 분산 컴퓨팅을 활성화합니다.
- 고속: 고속 수치 알고리즘에 필요한 낮은 오버헤드, 낮은 레이텐시 및 최소한의 시리얼라이제이션으로 동작합니다.
- 스케일업: 1,000개의 코어가 있는 클러스터에서 탄력적으로 실행.스케일다운:노트북으로 한 번의 프로세스로 셋업 및 실행이 간단함
- 응답성:인터랙티브 컴퓨팅을 염두에 두고 설계된 이 제품은 신속한 피드백과 진단 기능을 제공하여 인간을 지원합니다.
간단한 코드 샘플을 추가하려면:
import dask.dataframe as dd
df = dd.read_csv('2015-*-*.csv')
df.groupby(df.user_id).value.mean().compute()
다음과 같은 일부 판다 코드를 대체합니다.
import pandas as pd
df = pd.read_csv('2015-01-01.csv')
df.groupby(df.user_id).value.mean()
할 만한은 을 한다는 것입니다.concurrent.futures커스텀 태스크의 제출을 위한 일반적인 인프라스트럭처의 인터페이스:
from dask.distributed import Client
client = Client('scheduler:port')
futures = []
for fn in filenames:
future = client.submit(load, fn)
futures.append(future)
summary = client.submit(summarize, futures)
summary.result()
여기서도 언급할 가치가 있어 레이
분산된 계산 프레임워크로, 판다를 위한 자체 구현 방식을 가지고 있습니다.
팬더 수입품을 대체하기만 하면 코드는 그대로 작동합니다.
# import pandas as pd
import ray.dataframe as pd
# use pd as usual
자세한 내용은 여기를 참조하십시오.
https://rise.cs.berkeley.edu/blog/pandas-on-ray/
업데이트: 판다의 유통을 취급하는 부분이 Modin 프로젝트에 추출되었습니다.
현재 적절한 사용 방법은 다음과 같습니다.
# import pandas as pd
import modin.pandas as pd
하나 더 변형이 하나 더
팬더에서 수행되는 작업의 대부분은 DB 쿼리로도 수행할 수 있습니다(sql, mongo).
RDBMS 또는 mongodb를 사용하면 DB Query에서 집약을 수행할 수 있습니다(대용량 데이터에 최적화되어 캐시 및 인덱스를 효율적으로 사용).
나중에 판다를 사용하여 후처리를 할 수 있습니다.
이 방법의 장점은 대용량의 데이터를 사용하기 위한 DB 최적화를 얻으면서도 높은 수준의 선언적 구문에서 논리를 정의할 수 있다는 것입니다. 메모리에서 수행할 작업과 코어에서 수행할 작업을 결정하는 세부 사항을 처리할 필요가 없습니다.
질문어와 팬더는 다르지만논리의 일부를 다른 언어로 번역하는 것은 보통 복잡하지 않습니다
여러 개의 작은 파일로 분할된 데이터 파이프라인을 만드는 단순한 경로를 택한다면 Ruffus를 고려해 보십시오.
백스 패키지를 지적하고 싶습니다.
Vaex는 큰 표 형식의 데이터셋을 시각화하고 탐색할 수 있도록 느린 Out-of-Core DataFrames(Panda와 유사)를 위한 파이썬 라이브러리입니다.초당 최대 10억 개의 객체/행의9 N차원 그리드에서 평균, 합계, 카운트, 표준 편차 등의 통계를 계산할 수 있습니다.시각화는 히스토그램, 밀도 플롯 및 3D 볼륨 렌더링을 사용하여 수행되므로 빅데이터를 인터랙티브하게 탐색할 수 있습니다.Vaex는 메모리 매핑, 제로 메모리 복사 정책 및 느린 계산을 사용하여 최고의 성능을 제공합니다(메모리 낭비가 없음).
다음 문서를 참조하십시오.https://vaex.readthedocs.io/en/latest/ 이 API는 판다의 API에 매우 가깝습니다.
나는 최근에 비슷한 문제에 부딪쳤다.데이터를 청크로 읽고 같은 csv에 청크로 쓸 때 추가하는 것만으로 충분하다는 것을 알았습니다.나의 문제는 다음과 같은 특정 열의 값을 사용하여 다른 표의 정보를 바탕으로 날짜 열을 추가하는 것이었습니다.이것은 dask와 hdf5로 혼란스러워하는 사람들에게 도움이 될 수 있지만, 나처럼 판다에게 더 친숙하다.
def addDateColumn():
"""Adds time to the daily rainfall data. Reads the csv as chunks of 100k
rows at a time and outputs them, appending as needed, to a single csv.
Uses the column of the raster names to get the date.
"""
df = pd.read_csv(pathlist[1]+"CHIRPS_tanz.csv", iterator=True,
chunksize=100000) #read csv file as 100k chunks
'''Do some stuff'''
count = 1 #for indexing item in time list
for chunk in df: #for each 100k rows
newtime = [] #empty list to append repeating times for different rows
toiterate = chunk[chunk.columns[2]] #ID of raster nums to base time
while count <= toiterate.max():
for i in toiterate:
if i ==count:
newtime.append(newyears[count])
count+=1
print "Finished", str(chunknum), "chunks"
chunk["time"] = newtime #create new column in dataframe based on time
outname = "CHIRPS_tanz_time2.csv"
#append each output to same csv, using no header
chunk.to_csv(pathlist[2]+outname, mode='a', header=None, index=None)
사용 합니다. 해서 수 .pd.read_parquet(path_to_file, columns=["foo", "bar"])
https://pandas.pydata.org/docs/reference/api/pandas.read_parquet.html
현재 저는 고객님과 같이 낮은 규모로 일하고 있기 때문에 제안서에 PoC가 없습니다.
그러나, 나는 피클을 캐싱 시스템으로 사용하고, 나의 특공대/메인 파일로부터 이러한 파일을 실행하는 등, 다양한 기능의 실행을 파일에 아웃소싱 하는 것에 성공했다고 생각한다.예를 들면, 오브젝트 타입의 변환, 데이터 세트의 테스트, 검증, 예측 데이터 세트로 분할하는 등.
피클을 사용한 캐싱은 어떻게 작동합니까?전달된 파라미터와 데이터셋에 따라 동적으로 생성되는 피클파일에 액세스하기 위해 문자열을 사용합니다(데이터셋에는 .shape, 전달된 파라미터에는 dict를 사용하여 프로그램이 이미 실행되었는지 캡처하고 판단합니다).이러한 방법으로 .pickle 파일을 검색 및 읽어보려고 String이 필요합니다.파일이 발견되면 처리 시간을 건너뛰고 현재 작업 중인 실행으로 이동할 수 있습니다.
데이터베이스를 사용하다가 비슷한 문제가 발생했기 때문에 이 솔루션을 사용하는 것이 즐거웠는데, 예를 들어 중복으로 인해 큰 피클 세트를 저장하는 등 많은 제약이 있습니다.변환 전후의 테이블 갱신은 적절한 인덱싱으로 실행할 수 있습니다.정보 검증은 전혀 다른 책을 엽니다(크롤링 렌트 데이터를 통합하려고 했지만 기본적으로는 2시간 후에 데이터베이스 사용을 중지했습니다.변환 프로세스마다 다시 되돌리고 싶었기 때문입니다).
제 2센트가 당신에게 도움이 됐으면 좋겠어요.
인사말.
언급URL : https://stackoverflow.com/questions/14262433/large-data-workflows-using-pandas
'programing' 카테고리의 다른 글
| gem install: gem 네이티브 확장을 빌드하지 못했습니다(헤더 파일을 찾을 수 없습니다). (0) | 2022.12.26 |
|---|---|
| 연쇄 비교의 단순화 (0) | 2022.12.26 |
| palindrome 문자열 확인 (0) | 2022.12.26 |
| Galera에서 마스터가 다운된 경우 마스터/슬레이브 리플리케이션 로드밸런싱 (0) | 2022.12.26 |
| Big Decimal을 정수로 변환 (0) | 2022.12.26 |