Data.table: 대형 csv(44GB)가 있는 fread는 최신 data.table dev 버전에서 많은 RAM을 사용합니다.

이것은 병렬이 아닌 fread 구현의 출력입니다(data.table 1.10.5 IN DEVELOPMENT 구축 2017-02-09).

그리고 사용된 메모리 양을 다시 확인했는데 최대 84GB까지 올라갑니다.

기예르모

네 말이 맞아. 훌륭한 보고서에 감사드립니다. 추정된 nrow는 대략 맞는 것처럼 보이지만(858,881 대 872,505) 할당은 그보다 4.2배 더 크고(3,683,116) 훨씬 더 많습니다. 계산을 개선하고 자세한 출력에 자세한 내용을 추가했습니다. 몇 가지 작업이 더 완료될 때까지 지금은 재테스트를 보류하십시오.

다시 테스트하십시오. 지금 수정해야 합니다.

방금 data.table dev를 설치했습니다.
data.table 1.10.5 IN DEVELOPMENT 구축 2017-03-27 02:50:31 UTC

동일한 44GB 파일을 읽으려고 할 때 가장 먼저 받은 메시지는 다음과 같습니다.

DT <- fread('dt.daily.4km.csv')
오류: protect(): 보호 스택 오버플로

그런 다음 동일한 명령을 다시 실행하고 제대로 작동하기 시작했습니다. 그러나 이 버전은 멀티코어 모드를 사용하지 않습니다. fread 병렬 버전을 넣기 전과 마찬가지로 로드하는 데 ~ 25분이 걸립니다.

기예르모

모든 r-세션을 닫고 테스트를 다시 실행했는데 오류가 발생합니다.

추측된 열 유형은 508개 열의 34711745개 값에 충분하지 않습니다. colClasses를 사용하여 이러한 열 클래스를 수동으로 설정하십시오.

아래를 참조하십시오. "정수를 추측했지만 <<0....>>이(가) 포함되어 있다는 몇 가지 메시지가 나타납니다.

_벽시계 시간 15:27.024에 43.772GB 파일에서 872505행 x 12785열 읽기(유휴 상태인 것처럼 보이더라도 열려 있는 다른 앱에 의해 속도가 느려질 수 있음)
171열('D_19810618')은 '정수'를 추측했지만 <<2.23000001907349>>를 포함합니다.
347열('D_19811211')은 '정수'로 추측되지만 <<1.02999997138977>>을 포함합니다.
열 348('D_19811212')이 '정수'로 추측되지만 <<3.75>>_을(를) 포함합니다.

와우 - 귀하의 파일은 정말 극단적인 경우를 테스트하고 있습니다. 엄청난. 앞으로 verbose=TRUE 실행하고 전체 출력을 제공하십시오. 그러나 이 경우에 제공한 정보를 통해 실제로 문제가 무엇인지 알 수 있습니다. 각 스레드에 대해 각 열에 대해 생성된 버퍼가 있습니다(이 경우 12,000개 이상의 열). 각각은 현재 별도로 보호됩니다. 그것을 피하는 방법이 있습니다 - 할 것입니다. 유형 추측에 대한 메시지가 정확합니다. 508개의 열이 당신에게 의미가 있고 숫자여야 한다는 데 동의하십니까? 다음과 같이 열 범위를 colClasses 전달할 수 있습니다. colClasses=list("numeric"=11:518)

이 데이터는 어느 분야의 데이터입니까? 파일을 만들고 있습니까? 일반적인 모범 사례는 긴 형식으로 작성하고 메모리에도 유지하는 것인 와이드 형식으로 뒤틀린 것처럼 느껴집니다. 일반적으로 "D_19810618"과 같은 508개의 열 이름을 열 자체가 아니라 열의 값으로 볼 것으로 예상합니다. 그래서 파일을 생성하고 있고 긴 형식으로 생성할 수 있는지 묻습니다. 그렇지 않은 경우 파일을 만드는 사람에게 더 잘할 수 있다고 제안하십시오. 아마도 .SD 및 .SDcols 사용하여 열을 통해 작업을 적용하고 있다고 생각합니다. 긴 형식과 "D_19810618"과 같은 값을 포함하는 keyby= 열이 훨씬 좋습니다.

그러나 나는 여전히 fread 를 모든 입력(12,000개 이상의 열이 포함된 매우 넓은 파일)을 처리하는 데 사용할 수 있도록 최선을 다할 것입니다.

다른 사람들이 파일을 테스트하고 전혀 문제를 찾지 않기를 바랍니다!

_ 508개의 열이 당신에게 의미가 있고 숫자여야 한다는 데 동의하십니까?

이 테이블에는 행별 시계열이 포함되어 있습니다. IDx,IDy, Time1_value, Time2_value, Time3_value... 및 모든 Time N _value 열에는 숫자 값만 포함됩니다. colClasses를 사용하는 경우 12783: list("numeric"=2:12783)에 대해 수행해야 합니다. 나는 이것을 시도할 것이다.

_이 데이터의 출처는 무엇입니까?_
지리 공간 데이터. IDx 및 IDy를 사용하여 DT 내에서 유클리드 거리 검색을 수행하고 있습니다. 행이 많을수록 검색 속도가 느려집니다. 맞나요?
지금은 꽤 빠릅니다(와이드 형식). 사용자가 영역을 클릭한 다음 주어진 클릭에 가장 가까운 위치(사용 가능한 데이터 포함)에서 csv 파일 내에서 시계열이 생성되는 지도가 있습니다. 대신 긴 형식으로 구현하겠습니다.

몇 가지 결과를 가지고 돌아오겠습니다.

그래 좋아. list("numeric"=2:12783) iiuc는 508개 열에 대한 도움만 필요하기 때문에 필요하지 않습니다. 아 - 알겠습니다 - 508이 열을 통해 흩어져 있다고 생각합니다(인접한 열 집합이 아님)?

아니오 - data.table이 넓을 때 더 빠르지 않습니다! Long은 거의 항상 더 빠르고 더 편리합니다. roll="nearest" 를 보았고 시도한 적이 있습니까? 지금 어떻게 하고 있나요? 우리가 이해할 수 있도록 코드를 보여주세요. 거의 확실히 긴 형식이 더 낫지만 가장 가까운 2D에 대해 몇 가지 개선 사항이 필요할 수 있습니다. 타이밍도 보여주세요. "매우 빠름"이라고 말하면 사람들은 "매우 빠름"이 무엇인지에 대해 매우 다른 생각을 가지고 있음이 밝혀졌습니다.

이 테이블을 녹이면 2^31 한계에 도달합니다. "음수 길이 벡터는 허용되지 않습니다"라는 오류가 발생합니다.

긴 형식으로 생성할 수 있는지 확인하기 위해 소스로 돌아가겠습니다.

# Read Data 
DT <- fread('dt.daily.4km.csv', showProgress = FALSE)
# Add two columns with truncated values of x and y (these are geog. coords.)
DT[,y_tr:=trunc(y)]
DT[,x_tr:=trunc(x)]

# For using on plotting (x-axis values)
xaxis<-seq.Date(as.Date("1981-01-01"),as.Date("2015-12-31"), "day") 

# subset by truncated coordinates to avoid full-table search. Now searches
# will happen in a smaller subset
DT2 <- DT[y_tr==trunc(y_clicked) & x_tr==trunc(x_clicked),]
# Add distance from each point in the data.table to the provided location, "gdist" is from
# Imap package for euclidean distance. 
DT2[,DIST:=gdist(lat.1 = DT2$y,
                       lon.1 = DT2$x,
                       lat.2 = y_clicked,
                       lon.2 = x_clicked, units="miles")]
# Get the minimum distance 
minDist <- min(DT2[,DIST])

# Get the y-axis values
yt <- transpose(DT2[DIST==minDist,3:(ncol(DT2)-3)])$V1`

# Ready to plot xaxis vs yt 
...
...

공개 서버에 애플리케이션이 없습니다. 기본적으로 사용자는 지도를 클릭한 다음 해당 좌표를 캡처하고 위의 검색을 수행하고 시계열을 가져오고 플롯을 생성할 수 있습니다.

매우 많은 수의 열에 대한 또 다른 스택 오버플로를 찾아 수정했습니다. https://github.com/Rdatatable/data.table/commit/d0469e670961dcdea115d433c0f2dce596d65906. 커밋 메시지에서 이 문제 번호에 태그를 지정하는 것을 잊었습니다.

오. 그게 포인트입니다. 872505행 * 12780열은 110억 행입니다. 따라서 긴 형식을 사용하라는 내 제안은 > 2^31이므로 작동하지 않습니다. 죄송합니다 - 내가 그것을 발견했어야 합니다. 총알을 깨물고 > 2^31로 이동하면 됩니다. 그동안 작업하고 있는 와이드 형식을 계속 사용하고 이에 대해 설명하겠습니다.

다시 시도해 주세요. 메모리 사용량은 정상으로 돌아가야 하며 샘플 외 유형 예외가 있는 12,785개 열 중 508개 열을 자동으로 다시 읽어야 합니다. 자동 재실행 시간을 피하려면 colClasses 설정할 수 있습니다.
수정되지 않은 경우 전체 상세 출력을 붙여넣으십시오. 손가락이 교차!

확인...
최신 data.table dev: data.table 1.10.5 IN DEVELOPMENT 구축 결과 요약

언급할 4가지 주요 사항:

1. fread는 토론에서 파일을 잘 읽었습니다.
2. 읽는 데 ~ 5.5분이 걸렸고 이전 버전은 ~1.3분이 걸렸습니다.
3. 이 버전은 내가 테스트했던 이전 버전처럼 RAM 할당을 늘리지 않습니다.
4. 코어가 "덜 활성화된" 것 같습니다(아래 스크린샷 참조).

몇 가지 의견/질문:
1.
코어의 사용량 비율이 이전만큼 활성화되지 않았습니다(스크린샷 참조).

fread의 이전 버전에서 코어의 활동은 항상 ~ 90-80%였습니다. 이 버전에서는 위의 이미지와 같이 각 코어의 약 2-3%를 유지했습니다.

1. 
   fread가 정수에서 숫자로 범프를 수행하는 이유를 이해할 수 없습니다. 예

Column 1489 ("D_19850126") bumped from 'integer' to 'numeric' due to <<0.949999988079071>> somewhere between row 6041 and row 24473

해당 행을 두 번 확인했는데 괜찮은 것 같습니다. 가 이미 숫자인 경우 정수로 감지되고 '숫자'로 '범프'해야 하는 이유는 무엇입니까(아래 제안된 행에 대한 요약 참조)? 아니면 내가이 줄을 잘못 이해하고 있습니까? 이것은 508 라인에서 발생합니다. NA가 문제를 일으키는가?

summary(DT[6041:24473,.(D_19850126)])
   D_19850126   
 Min.   :0.750  
 1st Qu.:0.887  
 Median :0.945  
 Mean   :0.966  
 3rd Qu.:1.045  
 Max.   :1.210  
 NA's   :18393 

아래는 테스트 중 장황한 것입니다.

DT<-fread('dt.daily.4km.ver032917.csv', verbose=TRUE)

산출

Parameter na.strings == <<NA>>
None of the 0 na.strings are numeric (such as '-9999').Input contains no \n. Taking this to be a filename to open
File opened, filesize is 43.772296 GB.
Memory mapping ... ok
Detected eol as \n only (no \r afterwards), the UNIX and Mac standard.
Positioned on line 1 starting: <<x,y,D_19810101,D_19810102,D_19810103,D_19810104,D_19810105,D_19810106,D_19810107,D_19810108,D_19810109,D_19810110,D_19810111,D_19810112,D_19810113,
...  
...
All the fields on line 1 are character fields. Treating as the column names.
Number of sampling jump points  = 11 because 1281788 startSize * 10 NJUMPS * 2 = 25635760 <= -244636240 bytes from line 2 to eof
Type codes (jump 00)    : 441111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...1111111111  Quote rule 0
Type codes (jump 01)    : 444422222222222222242444424444442222222222424444424442224424222244222222222242422222224422...4442244422  Quote rule 0
Type codes (jump 02)    : 444422222222222222242444424444442422222242424444424442224424222244222222222242424222424424...4442444442  Quote rule 0
Type codes (jump 03)    : 444422222222222224242444424444444422222244424444424442224424222244222222222244424442424424...4442444442  Quote rule 0
Type codes (jump 04)    : 444444244422222224442444424444444444242244444444444444424444442244444222222244424442444444...4444444444  Quote rule 0
Type codes (jump 05)    : 444444244422222224442444424444444444242244444444444444424444442244444222222244424442444444...4444444444  Quote rule 0
Type codes (jump 06)    : 444444444422222224442444424444444444242244444444444444424444444444444244444444424442444444...4444444444  Quote rule 0
Type codes (jump 07)    : 444444444422222224442444424444444444242244444444444444444444444444444244444444424444444444...4444444444  Quote rule 0
Type codes (jump 08)    : 444444444442222224444444424444444444242244444444444444444444444444444444444444424444444444...4444444444  Quote rule 0
Type codes (jump 09)    : 444444444442222424444444424444444444244444444444444444444444444444444444444444424444444444...4444444444  Quote rule 0
Type codes (jump 10)    : 444444444442222424444444424444444444244444444444444444444444444444444444444444424444444444...4444444444  Quote rule 0
=====
 Sampled 305 rows (handled \n inside quoted fields) at 11 jump points including middle and very end
 Bytes from first data row on line 2 to the end of last row: 47000004016
 Line length: mean=45578.20 sd=33428.37 min=12815 max=108497
 Estimated nrow: 47000004016 / 45578.20 = 1031195
 Initial alloc = 2062390 rows (1031195 + 100%) using bytes/max(mean-2*sd,min) clamped between [1.1*estn, 2.0*estn]
=====
Type codes (colClasses) : 444444444442222424444444424444444444244444444444444444444444444444444444444444424444444444...4444444444
Type codes (drop|select): 444444444442222424444444424444444444244444444444444444444444444444444444444444424444444444...4444444444
Allocating 12785 column slots (12785 - 0 dropped)
Reading 44928 chunks of 0.998MB (22 rows) using 144 threads
Read 872505 rows x 12785 columns from 43.772GB file in 05:26.908 wall clock time (can be slowed down by any other open apps even if seemingly idle)
Final type counts
         0 : drop     
         0 : logical  
         0 : integer  
         0 : integer64
     12785 : numeric  
         0 : character
Rereading 508 columns due to out-of-sample type exceptions.
Column 171 ("D_19810618") bumped from 'integer' to 'numeric' due to <<2.23000001907349>> somewhere between row 6041 and row 24473
Column 347 ("D_19811211") bumped from 'integer' to 'numeric' due to <<1.02999997138977>> somewhere between row 6041 and row 24473
Column 348 ("D_19811212") bumped from 'integer' to 'numeric' due to <<3.75>> somewhere between row 6041 and row 24473
Column 643 ("D_19821003") bumped from 'integer' to 'numeric' due to <<1.04999995231628>> somewhere between row 6041 and row 24473
Column 1066 ("D_19831130") bumped from 'integer' to 'numeric' due to <<1.46000003814697>> somewhere between row 6041 and row 24473
Column 1102 ("D_19840105") bumped from 'integer' to 'numeric' due to <<0.959999978542328>> somewhere between row 6041 and row 24473
Column 1124 ("D_19840127") bumped from 'integer' to 'numeric' due to <<0.620000004768372>> somewhere between row 6041 and row 24473
Column 1130 ("D_19840202") bumped from 'integer' to 'numeric' due to <<0.540000021457672>> somewhere between row 6041 and row 24473
Column 1489 ("D_19850126") bumped from 'integer' to 'numeric' due to <<0.949999988079071>> somewhere between row 6041 and row 24473
Column 1508 ("D_19850214") bumped from 'integer' to 'numeric' due to <<0.360000014305115>> somewhere between row 6041 and row 24473

... 
...

Reread 872505 rows x 508 columns in 05:29.167
Read 872505 rows. Exactly what was estimated and allocated up front
Thread buffers were grown 0 times (if all 144 threads each grew once, this figure would be 144)
=============================
   0.000s (  0%) Memory map
   0.093s (  0%) sep, ncol and header detection
   0.186s (  0%) Column type detection using 305 sample rows from 44928 jump points
   0.600s (  0%) Allocation of 872505 rows x 12785 cols (192.552GB) plus 1.721GB of temporary buffers
 326.029s ( 50%) Reading data
 329.167s ( 50%) Rereading 508 columns due to out-of-sample type exceptions
 656.075s        Total

이 마지막 요약은 완료하는 데 많은 시간이 걸렸습니다(~6분). 이 장황한 요약을 계산하면 전체 fread가 ~ 11분이 걸렸습니다. 해당 508개 열을 다시 읽고 있으며 verbose=TRUE를 사용하지 않고 "샘플 유형 예외로 인해 508개 열을 다시 읽는 중"이라는 메시지도 볼 수 있습니다.

"verbose=TRUE" 없이 확인하십시오.

ptm<-proc.time() 
DT<-fread('dt.daily.4km.ver032917.csv')

Read 872505 rows x 12785 columns from 43.772GB file in 05:26.647 wall clock time (can be slowed down by any other open apps even if seemingly idle)
Rereading 508 columns due to out-of-sample type exceptions.

Reread 872505 rows x 508 columns in 05:30.276
proc.time() - ptm 
    user   system  elapsed 
2113.100   85.919  657.870

쓰기 테스트
그것은 잘 작동합니다. 정말 빠릅니다. 요즘은 글이 읽기보다 느리다는 생각이 들었습니다.

fwrite(DT,'dt.daily.4km.ver032917.csv', verbose=TRUE)
No list columns are present. Setting sep2='' otherwise quote='auto' would quote fields containing sep2.
maxLineLen=151187 from sample. Found in 1.890s
Writing column names ... done in 0.000s
Writing 872505 rows in 32315 batches of 27 rows (each buffer size 8MB, showProgress=1, nth=144) ... 
done (actual nth=144, anyBufferGrown=no, maxBuffUsed=46%) 

"다시 읽기"는 시간이 꽤 걸립니다. 파일을 두 번 읽는 것과 같습니다.

훌륭한! 모든 정보를 주셔서 감사합니다.

1. 네 맞습니다. 다시 읽어서는 안됩니다. colClasses=list("numeric"=1:12785) 했으므로 Type code (colClasses) 시작하는 출력 행은 모두 값 4여야 합니다. 누락된 테스트를 수정하고 추가합니다.
2. 5.5m 대 1.3m에서는 흥미롭습니다. 각 스레드의 버퍼는 현재 1MB입니다. 캐시에 맞게 작아야 한다는 아이디어. 그러나 귀하의 경우 1MB / 12785 열 = 82 바이트입니다. 따라서 그 선택으로 캐시가 50배나 비효율적입니다. 어쨌든 같아요. 당신의 테스트가 없었다면 나는 그런 생각을 해본 적이 없었을 것입니다. 1.3m 속도로 작동할 때 1MB 크기가 없었습니다.
3. 305줄만 샘플링한 이유도 매우 이상합니다. 1,000개를 샘플링했어야 합니다. 그것이 고정되면 아마도 당신이 할 필요없이 508 열을 감지 할 것입니다. 샘플에 시간(0.186초)이 걸리지 않으므로 샘플 크기를 늘릴 수 있습니다.

lscpu 유닉스 명령의 출력을 붙여넣을 수 있습니까? 이것은 당신의 캐시 크기를 알려줄 것이고 나는 거기에서 생각할 수 있습니다. buffMB 에 매개변수로 fread 하여 그것이 맞는지 확인할 수 있습니다. 그렇다면 더 나은 계산을 할 수 있습니다.

내 이전 게시물의 한 지점에서 내 실수. colClasses=list("numeric"=1:12785) 이(가) 잘 작동합니다. "colClasses"를 지정하지 않으면 "다시 읽기"가 수행됩니다. 혼란을 드려 죄송합니다.
내가 알아차린 한 가지는 "colClasses"를 지정하지 않으면 테이블이 NA로 생성되고 RAM이 DT가 정상적으로 로드된 것처럼 표시된다는 것입니다(RAM에서 ~106MB).

다음은 lscpu 출력입니다.

Architecture:          x86_64                                               
CPU op-mode(s):        32-bit, 64-bit                                       
Byte Order:            Little Endian                                        
CPU(s):                144                                                  
On-line CPU(s) list:   0-143                                                      
Thread(s) per core:    2                                                          
Core(s) per socket:    18                                                         
Socket(s):             4                                                          
NUMA node(s):          4                                                             
Vendor ID:             GenuineIntel                                                  
CPU family:            6                                                             
Model:                 63                                                             
Model name:            Intel(R) Xeon(R) CPU E7-8870 v3 @ 2.10GHz                      
Stepping:              4                                                              
CPU MHz:               2898.328                                                          
BogoMIPS:              4195.66                                                           
Virtualization:        VT-x                                                              
L1d cache:             32K                                                                  
L1i cache:             32K                                                                  
L2 cache:              256K                                                                       
L3 cache:              46080K                                                                     
NUMA node0 CPU(s):     0,4,8,12,16,20,24,28,32,36,40,44,48,52,56,60,64,68,72,76,80,84,88,92,96,100,104,108,112,116,120,124,128,132,136,140                                                                                    
NUMA node1 CPU(s):     1,5,9,13,17,21,25,29,33,37,41,45,49,53,57,61,65,69,73,77,81,85,89,93,97,101,105,109,113,117,121,125,129,133,137,141                                                                                                        
NUMA node2 CPU(s):     2,6,10,14,18,22,26,30,34,38,42,46,50,54,58,62,66,70,74,78,82,86,90,94,98,102,106,110,114,118,122,126,130,134,138,142                                                                                                             
NUMA node3 CPU(s):     3,7,11,15,19,23,27,31,35,39,43,47,51,55,59,63,67,71,75,79,83,87,91,95,99,103,107,111,115,119,123,127,131,135,139,143   

알겠습니다. 감사 해요.

첫 번째 의견을 다시 읽으면 "정수에서 숫자로 범핑"이 아니라 "정수에서 이중으로 범핑"이라고 말하면 더 이해가 될까요?

'NA로 생성됨'은 무슨 뜻인가요? 모든 테이블이 NA로 가득 차 있고 508개의 열만 있습니까?

'DT가 정상적으로 로드되었습니다(RAM에서 ~106MB)'는 무엇입니까? 44GB 파일인데 어떻게 106MB가 정상일 수 있습니까?

• 글쎄, 이 파일에서 내가 가진 모든 것은 실수와 NA입니다. 정수 값이 없습니다. "datatypeA에서 datatypeB로 범핑"이라는 메시지가 언제 발생합니까?

• 그게 바로 내가 의미하는 바입니다. 내가 설치한 현재 버전의 data.table에서 colClasses를 생략하면 DT는 로드되지만 NA는 가득 차 있습니다. DT[!is.na(D_19821001),] 는 0개의 레코드를 생성하고 colClasses가 있는 테이블을 로드하고 동일한 필터링을 수행하면 실제로 레코드가 표시됩니다.

• 글쎄, 이 파일은 디스크에 csv로 47GB이지만, 일단 R에 로드하면 RAM에서 두 배 이상 걸립니다... 값의 정밀도와 관련이 없습니다. 일단 로드되면 실제 메모리 할당이 로드됩니다. 숫자가 증가를 유발합니까?

그렇다면 또 다른 오타가 있을 수 있습니다. 106MB는 106GB여야 합니다.
나는 NA 측면을 따르지 않습니다. 그러나 도중에 몇 가지 수정한 다음 새로 다시 시도하십시오 ...

알겠습니다. 다시 시도해 주세요. 추측 샘플이 10,000으로 증가했으며(시간이 얼마나 걸리는지 확인하는 것이 흥미로울 것입니다) 이제 버퍼 크기에 최소값이 적용됩니다.
drat 패키지 파일이 승격될 때까지 최소 30분을 기다려야 할 수 있습니다.

죄송합니다. "MB"가 아니라 "GB"였습니다. 커피가 부족했어요.
업데이트 받아서 테스트 해보겠습니다.

최신 data.table dev.로 테스트: data.table 1.10.5 IN DEVELOPMENT 구축 2017-03-30 16:31:45 UTC :

요약:
그것은 빠르게 작동하고(csv를 읽는 데 1.43분) 메모리 할당도 잘 작동합니다. RAM 할당이 이전처럼 증가하지 않는 것 같습니다. 디스크의 44GB csv는 로드되면 RAM의 ~112(+ 37GB 임시 버퍼)GB로 변환됩니다. 이것은 파일에 있는 값의 데이터 유형과 관련이 있습니까?

테스트 1 :

colClasses=list("numeric"=1:12785) 사용하지 않고

DT<-fread('dt.daily.4km.csv', verbose=TRUE)

Parameter na.strings == <<NA>>
None of the 1 na.strings are numeric (such as '-9999').
Input contains no \n. Taking this to be a filename to open
File opened, filesize is 43.772296 GB.
Memory mapping ... ok
Detected eol as \n only (no \r afterwards), the UNIX and Mac standard.
Positioned on line 1 starting: <<x,y,D_19810101,D_19810102,D_19810103,D_19810104,D_19810105,D_19810106,D_19810107,
D_19810108,D_19810109,D_19810110,D_19810111,D_19810112,
...
All the fields on line 1 are character fields. Treating as the column names.
Number of sampling jump points  = 101 because 47000004016 bytes from row 1 to eof / (2 * 1281788 jump0size) == 18333
Type codes (jump 000)    : 441111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...1111111111  Quote rule 0
Type codes (jump 001)    : 444222422222222224442444444444442222444444444444444444442444444444444222224444444444444444...4444444442  Quote rule 0
Type codes (jump 002)    : 444222444444222244442444444444444422444444444444444444442444444444444222224444444444444444...4444444442  Quote rule 0
...
Type codes (jump 034)    : 444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444...4444444444  Quote rule 0
Type codes (jump 100)    : 444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444...4444444444  Quote rule 0
=====
 Sampled 10049 rows (handled \n inside quoted fields) at 101 jump points including middle and very end
 Bytes from first data row on line 2 to the end of last row: 47000004016
 Line length: mean=79727.22 sd=32260.00 min=12804 max=153029
 Estimated nrow: 47000004016 / 79727.22 = 589511
 Initial alloc = 1179022 rows (589511 + 100%) using bytes/max(mean-2*sd,min) clamped between [1.1*estn, 2.0*estn]
=====
Type codes (colClasses)  : 444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444...4444444444
Type codes (drop|select) : 444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444...4444444444
Allocating 12785 column slots (12785 - 0 dropped)
Reading 432 chunks of 103.756MB (1364 rows) using 144 threads
Read 872505 rows x 12785 columns from 43.772GB file in 02:17.726 wall clock time (can be slowed down by any other open apps even if seemingly idle)
Final type counts
         0 : drop     
         0 : logical  
         0 : integer  
         0 : integer64
     12785 : double   
         0 : character
Thread buffers were grown 67 times (if all 144 threads each grew once, this figure would be 144)
=============================
   0.000s (  0%) Memory map
   0.099s (  0%) sep, ncol and header detection
  11.057s (  8%) Column type detection using 10049 sample rows
   0.899s (  1%) Allocation of 872505 rows x 12785 cols (112.309GB) plus 37.433GB of temporary buffers
 125.671s ( 91%) Reading data
   0.000s (  0%) Rereading 0 columns due to out-of-sample type exceptions
 137.726s        Total

테스트 2 :

지금 colClasses=list("numeric"=1:12785)
타이밍이 몇 초 개선되었습니다 ...

DT<-fread('dt.daily.4km.csv', colClasses=list("numeric"=1:12785), verbose=TRUE)

Allocating 12785 column slots (12785 - 0 dropped)
Reading 432 chunks of 103.756MB (1364 rows) using 144 threads
Read 872505 rows x 12785 columns from 43.772GB file in 01:43.028 wall clock time (can be slowed down by any other open apps even if seemingly idle)
Final type counts
         0 : drop     
         0 : logical  
         0 : integer  
         0 : integer64
     12785 : double   
         0 : character
Thread buffers were grown 67 times (if all 144 threads each grew once, this figure would be 144)
=============================
   0.000s (  0%) Memory map
   0.092s (  0%) sep, ncol and header detection
  11.009s ( 11%) Column type detection using 10049 sample rows
   0.332s (  0%) Allocation of 872505 rows x 12785 cols (112.309GB) plus 37.433GB of temporary buffers
  91.595s ( 89%) Reading data
   0.000s (  0%) Rereading 0 columns due to out-of-sample type exceptions
 103.028s        Total

좋아 - 우리는 거기에 도달하고 있습니다. 수정된 샘플 크기와 100개 포인트(10,000개 샘플 라인)에서 100개 라인으로 늘리면 유형을 올바르게 추측하기에 충분했습니다. 훌륭합니다. 44GB 파일은 열이 12,875개이고 행 길이가 평균 80,000자이므로 샘플링하는 데 11초가 걸렸습니다. 그러나 그 시간은 90초가 더 걸렸을 다시 읽기를 피할 수 있었기 때문에 가치가 있었습니다. 우리는 그때 그것을 고수할 것입니다.

두 번째 시간이고 운영 체제가 워밍업되어 파일을 캐시했기 때문에 두 번째 시간이 더 빠르다고 생각합니다. 상자에서 실행되는 다른 모든 것은 벽시계 타이밍에 영향을 미칩니다. 이는 1차 테스트의 동일한 연속 3회 실행으로 해결됩니다. 그런 다음 한 가지만 변경하고 3개의 동일한 연속 실행을 다시 실행합니다. 44GB 크기에서는 많은 자연스러운 차이를 볼 수 있습니다. 일반적으로 3개의 실행으로 결론을 내리기에 충분하지만 블랙 아트가 될 수 있습니다.

예, 메모리의 112GB와 디스크의 44GB는 부분적으로 모든 열이 이중 유형이기 때문에 메모리의 데이터가 더 크기 때문입니다. R에는 메모리 내 압축이 없으며 이 CSV(단지 ",," )에는 공간을 차지하지 않지만 메모리에는 8바이트의 NA 값이 많이 있습니다. 그러나 112GB가 아닌 83GB여야 합니다(872505행 x 12785열 x 8바이트 2배 / 1024^3 = 83GB). 그 112GB는 라인 길이의 평균과 표준편차를 기반으로 할당된 것입니다. 평균 행 길이를 기준으로 589,511행으로 추정하여 너무 짧았습니다. 선 길이 편차가 너무 커서 클램프가 +100%에서 적용되었습니다. 58,9511 * 2 = 1,179,022 * 12785 * 8 / 1024^3 = 112GB입니다. 결국 파일에 872,505개가 있음을 발견했습니다. 그러나 그것은 여유 공간을 확보하지 않습니다. 수정하겠습니다. (TODO1)

모든 열에 대해 열 유형을 지정해도 여전히 샘플링됩니다. 사용자가 모든 열을 지정한 경우 샘플링을 건너뛰어야 합니다. (TODO2)

모든 데이터가 2배이기 때문에 C 라이브러리 함수 strtod()를 110억 번 호출합니다. 그 기능의 전문화에 대한 오랜 염원은 이론적으로 이 파일의 속도를 크게 높여야 합니다. (완료)

좋은 설명 감사합니다. 이 파일로 다른 것을 테스트하고 싶다면 알려주세요. 저는 ~2,100만 행 x 1432개의 열이 있는 긴 형식에 더 가까운 다른 데이터 세트를 작업 중입니다.

     NAME       NROW  NCOL      MB                                                                                                                                                     
[1,] DT   21,812,625 1,432 238,310  

여기에 추가 데이터 포인트를 추가합니다. 89G .tsv , 로드 중 최대 메모리 사용량은 ~180G입니다. NA와 더블이 많기 때문에 기대되는 부분이라고 생각합니다.

나는 또한 이것에 대해 테스트하게되어 기쁩니다.

Ubuntu 16.04 64bit / Linux 4.4.0-71-generic
R version 3.3.2 (2016-10-31)
data.table 1.10.5 IN DEVELOPMENT built 2017-04-04 14:27:46 UTC

Architecture:          x86_64
CPU op-mode(s):        32-bit, 64-bit
Byte Order:            Little Endian
CPU(s):                64
On-line CPU(s) list:   0-63
Thread(s) per core:    2
Core(s) per socket:    16
Socket(s):             2
NUMA node(s):          2
Vendor ID:             GenuineIntel
CPU family:            6
Model:                 79
Model name:            Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz
Stepping:              1
CPU MHz:               2699.984
CPU max MHz:           3000.0000
CPU min MHz:           1200.0000
BogoMIPS:              4660.70
Hypervisor vendor:     Xen
Virtualization type:   full
L1d cache:             32K
L1i cache:             32K
L2 cache:              256K
L3 cache:              46080K
NUMA node0 CPU(s):     0-15,32-47
NUMA node1 CPU(s):     16-31,48-63
Flags:                 fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx pdpe1gb rdtscp lm constant_tsc rep_good nopl xtopology nonstop_tsc aperfmperf eagerfpu pni pclmulqdq monitor est ssse3 fma cx16 pcid sse4_1 sse4_2 x2apic movbe popcnt tsc_deadline_timer aes xsave avx f16c rdrand hypervisor lahf_lm abm fsgsbase bmi1 hle avx2 smep bmi2 erms invpcid rtm xsaveopt ida

Parameter na.strings == <<NA>>
None of the 1 na.strings are numeric (such as '-9999').
Input contains no \n. Taking this to be a filename to open
File opened, filesize is 88.603947 GB.
Memory mapping ... ok
Detected eol as \n only (no \r afterwards), the UNIX and Mac standard.
Positioned on line 1 starting: <<allele prediction_uuid sample_>>
Detecting sep ...
  sep=='\t'  with 101 lines of 76 fields using quote rule 0
Detected 76 columns on line 1. This line is either column names or first data row (first 30 chars): <<allele    prediction_uuid sample_>>
All the fields on line 1 are character fields. Treating as the column names.
Number of sampling jump points  = 101 because 95137762779 bytes from row 1 to eof / (2 * 24414 jump0size) == 1948426
Type codes (jump 000)    : 5555542444111145424441111444111111111111111111111111111111111111111111111111  Quote rule 0
Type codes (jump 009)    : 5555542444114445424441144444111111111111111111111111111111111111111111111111  Quote rule 0
Type codes (jump 042)    : 5555542444444445424444444444111111111111111111111111111111111111111111111111  Quote rule 0
Type codes (jump 048)    : 5555544444444445444444444444225225522555545111111111111111111111111111111111  Quote rule 0
Type codes (jump 083)    : 5555544444444445444444444444225225522555545254452454411154454452454411154455  Quote rule 0
Type codes (jump 085)    : 5555544444444445444444444444225225522555545254452454454454454452454454454455  Quote rule 0
Type codes (jump 100)    : 5555544444444445444444444444225225522555545254452454454454454452454454454455  Quote rule 0
=====
 Sampled 10028 rows (handled \n inside quoted fields) at 101 jump points including middle and very end
 Bytes from first data row on line 2 to the end of last row: 95137762779
 Line length: mean=465.06 sd=250.27 min=198 max=929
 Estimated nrow: 95137762779 / 465.06 = 204571280
 Initial alloc = 409142560 rows (204571280 + 100%) using bytes/max(mean-2*sd,min) clamped between [1.1*estn, 2.0*estn]
=====
Type codes (colClasses)  : 5555544444444445444444444444225225522555545254452454454454454452454454454455
Type codes (drop|select) : 5555544444444445444444444444225225522555545254452454454454454452454454454455
Allocating 76 column slots (76 - 0 dropped)
Reading 90752 chunks of 1.000MB (2254 rows) using 64 threads

도움이 된다면 다음은 매우 긴 데이터베이스에 대한 결과입니다: 419,124,196 x 42(~2^34) 하나의 헤더 행과 colClasses가 전달되었습니다.

> library(data.table)
data.table 1.10.5 IN DEVELOPMENT built 2017-09-27 17:12:56 UTC; travis
  The fastest way to learn (by data.table authors): https://www.datacamp.com/courses/data-analysis-the-data-table-way
  Documentation: ?data.table, example(data.table) and browseVignettes("data.table")
  Release notes, videos and slides: http://r-datatable.com
> CC <- c(rep('integer', 2), rep('character', 3),
+      rep('numeric', 2), rep('integer', 3),
+      rep('character', 2), 'integer', 'character', 'integer',
+      rep('character', 4), rep('numeric', 11), 'character',
+      'numeric', 'character', rep('numeric', 2),
+      rep('integer', 3), rep('numeric', 2), 'integer',
+      'numeric')
> P <- fread('XXXX.csv', colClasses = CC, header = TRUE, verbose = TRUE)
Input contains no \n. Taking this to be a filename to open
[01] Check arguments
  Using 40 threads (omp_get_max_threads()=40, nth=40)
  NAstrings = [<<NA>>]
  None of the NAstrings look like numbers.
  show progress = 1
  0/1 column will be read as boolean
[02] Opening the file
  Opening file XXXXcsv
  File opened, size = 51.71GB (55521868868 bytes).
  Memory mapping ... ok
[03] Detect and skip BOM
[04] Arrange mmap to be \0 terminated
  \r-only line endings are not allowed because \n is found in the data
[05] Skipping initial rows if needed
  Positioned on line 1 starting: <<X,X,X,X>>
[06] Detect separator, quoting rule, and ncolumns
  Detecting sep ...
  sep=','  with 100 lines of 42 fields using quote rule 0
  Detected 42 columns on line 1. This line is either column names or first data row. Line starts as: <<X,X,X,X>>
  Quote rule picked = 0
  fill=false and the most number of columns found is 42
[07] Detect column types, good nrow estimate and whether first row is column names
  'header' changed by user from 'auto' to true
  Number of sampling jump points = 101 because (55521868866 bytes from row 1 to eof) / (2 * 13006 jump0size) == 2134471
  Type codes (jump 000)    : 5161010775551055105101111111111111110110771117717  Quote rule 0
  Type codes (jump 022)    : 5561010775551055105101111111111111110110771117717  Quote rule 0
  Type codes (jump 030)    : 5561010775551055105101010107517171151110110771117717  Quote rule 0
  Type codes (jump 037)    : 5561010775551055105101010107517771171110110771117717  Quote rule 0
  Type codes (jump 073)    : 5561010775551055105101010107517771177110110771117717  Quote rule 0
  Type codes (jump 093)    : 5561010775551055105101010107717771177110110771117717  Quote rule 0
  Type codes (jump 100)    : 5561010775551055105101010107717771177110110771117717  Quote rule 0
  =====
  Sampled 10049 rows (handled \n inside quoted fields) at 101 jump points
  Bytes from first data row on line 1 to the end of last row: 55521868866
  Line length: mean=132.68 sd=6.00 min=118 max=425
  Estimated number of rows: 55521868866 / 132.68 = 418453923
  Initial alloc = 460299315 rows (418453923 + 9%) using bytes/max(mean-2*sd,min) clamped between [1.1*estn, 2.0*estn]
  =====
[08] Assign column names
[09] Apply user overrides on column types
  After 11 type and 0 drop user overrides : 551010107755510105105101010107777777777710710775557757
[10] Allocate memory for the datatable
  Allocating 42 column slots (42 - 0 dropped) with 460299315 rows
[11] Read the data
  jumps=[0..52960), chunk_size=1048373, total_size=55521868441
Read 98%. ETA 00:00 
[12] Finalizing the datatable
Read 419124195 rows x 42 columns from 51.71GB (55521868868 bytes) file in 13:42.935 wall clock time
Thread buffers were grown 0 times (if all 40 threads each grew once, this figure would be 40)
Final type counts
         0 : drop     
         0 : bool8    
         0 : bool8    
         0 : bool8    
         0 : bool8    
        11 : int32    
         0 : int64    
        19 : float64  
         0 : float64  
         0 : float64  
        12 : string   
=============================
   0.000s (  0%) Memory map 51.709GB file
   0.016s (  0%) sep=',' ncol=42 and header detection
   0.016s (  0%) Column type detection using 10049 sample rows
 188.153s ( 23%) Allocation of 419124195 rows x 42 cols (125.177GB)
 634.751s ( 77%) Reading 52960 chunks of 1.000MB (7901 rows) using 40 threads
   =    0.121s (  0%) Finding first non-embedded \n after each jump
   +   17.036s (  2%) Parse to row-major thread buffers
   +  616.184s ( 75%) Transpose
   +    1.410s (  0%) Waiting
   0.000s (  0%) Rereading 0 columns due to out-of-sample type exceptions
 822.935s        Total
> memory.size()
[1] 134270.3
> rm(P)
> gc()
             used    (Mb)  gc trigger     (Mb)    max used     (Mb)
Ncells     585532    31.3     5489235    293.2     6461124    345.1
Vcells 1508139082 11506.2 20046000758 152938.9 25028331901 190951.1
> memory.size()
[1] 87.56
> P <- fread('XXXX.csv', colClasses = CC, header = TRUE, verbose = TRUE)
Input contains no \n. Taking this to be a filename to open
[01] Check arguments
  Using 40 threads (omp_get_max_threads()=40, nth=40)
  NAstrings = [<<NA>>]
  None of the NAstrings look like numbers.
  show progress = 1
  0/1 column will be read as boolean
[02] Opening the file
  Opening file XXXX.csv
  File opened, size = 51.71GB (55521868868 bytes).
  Memory mapping ... ok
[03] Detect and skip BOM
[04] Arrange mmap to be \0 terminated
  \r-only line endings are not allowed because \n is found in the data
[05] Skipping initial rows if needed
  Positioned on line 1 starting: <<X,X,X,X>>
[06] Detect separator, quoting rule, and ncolumns
  Detecting sep ...
  sep=','  with 100 lines of 42 fields using quote rule 0
  Detected 42 columns on line 1. This line is either column names or first data row. Line starts as: <<X,X,X,X>>
  Quote rule picked = 0
  fill=false and the most number of columns found is 42
[07] Detect column types, good nrow estimate and whether first row is column names
  'header' changed by user from 'auto' to true
  Number of sampling jump points = 101 because (55521868866 bytes from row 1 to eof) / (2 * 13006 jump0size) == 2134471
  Type codes (jump 000)    : 5161010775551055105101111111111111110110771117717  Quote rule 0
  Type codes (jump 022)    : 5561010775551055105101111111111111110110771117717  Quote rule 0
  Type codes (jump 030)    : 5561010775551055105101010107517171151110110771117717  Quote rule 0
  Type codes (jump 037)    : 5561010775551055105101010107517771171110110771117717  Quote rule 0
  Type codes (jump 073)    : 5561010775551055105101010107517771177110110771117717  Quote rule 0
  Type codes (jump 093)    : 5561010775551055105101010107717771177110110771117717  Quote rule 0
  Type codes (jump 100)    : 5561010775551055105101010107717771177110110771117717  Quote rule 0
  =====
  Sampled 10049 rows (handled \n inside quoted fields) at 101 jump points
  Bytes from first data row on line 1 to the end of last row: 55521868866
  Line length: mean=132.68 sd=6.00 min=118 max=425
  Estimated number of rows: 55521868866 / 132.68 = 418453923
  Initial alloc = 460299315 rows (418453923 + 9%) using bytes/max(mean-2*sd,min) clamped between [1.1*estn, 2.0*estn]
  =====
[08] Assign column names
[09] Apply user overrides on column types
  After 11 type and 0 drop user overrides : 551010107755510105105101010107777777777710710775557757
[10] Allocate memory for the datatable
  Allocating 42 column slots (42 - 0 dropped) with 460299315 rows
[11] Read the data
  jumps=[0..52960), chunk_size=1048373, total_size=55521868441
Read 98%. ETA 00:00 
[12] Finalizing the datatable
Read 419124195 rows x 42 columns from 51.71GB (55521868868 bytes) file in 05:04.910 wall clock time
Thread buffers were grown 0 times (if all 40 threads each grew once, this figure would be 40)
Final type counts
         0 : drop     
         0 : bool8    
         0 : bool8    
         0 : bool8    
         0 : bool8    
        11 : int32    
         0 : int64    
        19 : float64  
         0 : float64  
         0 : float64  
        12 : string   
=============================
   0.000s (  0%) Memory map 51.709GB file
   0.031s (  0%) sep=',' ncol=42 and header detection
   0.000s (  0%) Column type detection using 10049 sample rows
  28.437s (  9%) Allocation of 419124195 rows x 42 cols (125.177GB)
 276.442s ( 91%) Reading 52960 chunks of 1.000MB (7901 rows) using 40 threads
   =    0.017s (  0%) Finding first non-embedded \n after each jump
   +   12.941s (  4%) Parse to row-major thread buffers
   +  262.989s ( 86%) Transpose
   +    0.495s (  0%) Waiting
   0.000s (  0%) Rereading 0 columns due to out-of-sample type exceptions
 304.910s        Total
> memory.size()
[1] 157049.7

> sessionInfo()
R version 3.4.2 beta (2017-09-17 r73296)
Platform: x86_64-w64-mingw32/x64 (64-bit)
Running under: Windows Server >= 2012 x64 (build 9200)

Matrix products: default

locale:
[1] LC_COLLATE=English_United States.1252  LC_CTYPE=English_United States.1252   
[3] LC_MONETARY=English_United States.1252 LC_NUMERIC=C                          
[5] LC_TIME=English_United States.1252    

attached base packages:
[1] stats     graphics  grDevices utils     datasets  methods   base     

other attached packages:
[1] data.table_1.10.5

loaded via a namespace (and not attached):
[1] compiler_3.4.2 tools_3.4.2   

몇 가지 메모입니다. colClasses가 전달되면 확인할 이유가 없다는 점에서 [09]를 [07] 앞에 두는 것이 좋습니다. 또한 Windows는 각 실행 후 약 160GB를 사용하는 것으로 나타났습니다. memory.size()는 아마도 청소를 할 것입니다. 이 서버에 532GB RAM이 있는 경우 메모리 캐싱은 두 번째 실행 시 속도 증가와 관련이 있을 수 있습니다. 도움이 되기를 바랍니다.

광범위한 "실제" 테이블(병원 데이터)에서 테스트: 30M 행 × 125열 v readr '1.2.0' 및 read.csv 3.4.3.

문제를 확인할 기회가 1.11.4에서도 여전히 유효합니까? 또는 예제 데이터를 생성하는 코드.

이것은 내가 아는 한 모두 해결되었습니다. @geponce 그렇지 않은 경우 업데이트하십시오.
위의 TODO1은 이제 #3024로 제출되었습니다.
위의 TODO2는 이제 #3025로 제출되었습니다.