இந்த கட்டுரையை எப்படி படிப்பது: உரை நீண்டதாகவும் குழப்பமாகவும் இருந்ததற்கு மன்னிப்பு கேட்டுக்கொள்கிறேன். உங்கள் நேரத்தை மிச்சப்படுத்த, ஒவ்வொரு அத்தியாயத்தையும் "நான் கற்றுக்கொண்டது" என்ற அறிமுகத்துடன் தொடங்குகிறேன், இது அத்தியாயத்தின் சாரத்தை ஒன்று அல்லது இரண்டு வாக்கியங்களில் சுருக்கமாகக் கூறுகிறது.

"தீர்வைக் காட்டுங்கள்!" நான் எங்கிருந்து வந்தேன் என்பதை நீங்கள் பார்க்க விரும்பினால், "மேலும் கண்டுபிடிப்புகளாக மாறுதல்" என்ற அத்தியாயத்திற்குச் செல்லவும், ஆனால் தோல்வியைப் பற்றி படிப்பது மிகவும் சுவாரஸ்யமாகவும் பயனுள்ளதாகவும் இருக்கும் என்று நினைக்கிறேன்.

ஒரு பெரிய அளவிலான மூல டிஎன்ஏ வரிசைகளை (தொழில்நுட்ப ரீதியாக ஒரு SNP சிப்) செயலாக்குவதற்கான ஒரு செயல்முறையை அமைக்கும் பணியை சமீபத்தில் நான் பெற்றேன். அடுத்தடுத்த மாடலிங் மற்றும் பிற பணிகளுக்கு கொடுக்கப்பட்ட மரபணு இருப்பிடம் (எஸ்என்பி என அழைக்கப்படுகிறது) பற்றிய தரவை விரைவாகப் பெறுவது அவசியம். R மற்றும் AWK ஐப் பயன்படுத்தி, என்னால் இயற்கையான முறையில் தரவை சுத்தம் செய்து ஒழுங்கமைக்க முடிந்தது, வினவல் செயலாக்கத்தை பெரிதும் துரிதப்படுத்தியது. இது எனக்கு எளிதானது அல்ல, மேலும் பல மறு செய்கைகள் தேவைப்பட்டன. எனது சில தவறுகளைத் தவிர்க்கவும், நான் என்ன செய்தேன் என்பதைக் காட்டவும் இந்தக் கட்டுரை உதவும்.

முதலில், சில அறிமுக விளக்கங்கள்.

தரவு

எங்கள் பல்கலைக்கழக மரபணு தகவல் செயலாக்க மையம் எங்களுக்கு 25 TB TSV வடிவில் தரவை வழங்கியது. நான் அவற்றை 5 தொகுப்புகளாகப் பிரித்து, Gzip ஆல் சுருக்கப்பட்டேன், ஒவ்வொன்றும் சுமார் 240 நான்கு-ஜிகாபைட் கோப்புகளைக் கொண்டிருந்தன. ஒவ்வொரு வரிசையிலும் ஒரு தனிநபரிடமிருந்து ஒரு SNPக்கான தரவு உள்ளது. மொத்தத்தில், ~ 2,5 மில்லியன் SNP கள் மற்றும் ~ 60 ஆயிரம் பேர் பற்றிய தரவு அனுப்பப்பட்டது. SNP தகவலுடன் கூடுதலாக, கோப்புகளில் பல நெடுவரிசைகள் உள்ளன, அவை பல்வேறு குணாதிசயங்களை பிரதிபலிக்கின்றன, அதாவது வாசிப்பு தீவிரம், வெவ்வேறு அல்லீல்களின் அதிர்வெண் போன்றவை. மொத்தத்தில், தனித்துவமான மதிப்புகளுடன் சுமார் 30 நெடுவரிசைகள் இருந்தன.

இலக்கு

எந்தவொரு தரவு மேலாண்மைத் திட்டத்தைப் போலவே, தரவு எவ்வாறு பயன்படுத்தப்படும் என்பதைத் தீர்மானிப்பதே மிக முக்கியமான விஷயம். இந்த வழக்கில் SNPயின் அடிப்படையில் SNPக்கான மாதிரிகள் மற்றும் பணிப்பாய்வுகளை நாங்கள் பெரும்பாலும் தேர்ந்தெடுப்போம். அதாவது, ஒரு நேரத்தில் ஒரு SNP இல் மட்டுமே தரவு தேவைப்படும். 2,5 மில்லியன் SNP களில் ஒன்றோடு தொடர்புடைய அனைத்து பதிவுகளையும் எப்படி எளிதாகவும், விரைவாகவும், மலிவாகவும் முடிந்தவரை மீட்டெடுப்பது என்பதை நான் கற்றுக் கொள்ள வேண்டியிருந்தது.

இதை எப்படி செய்யக்கூடாது

பொருத்தமான கிளிஷேவை மேற்கோள் காட்ட:

நான் ஆயிரம் முறை தோல்வியடையவில்லை, வினவலுக்கு ஏற்ற வடிவத்தில் ஒரு கொத்து தரவுகளை அலசுவதைத் தவிர்க்க ஆயிரம் வழிகளைக் கண்டுபிடித்தேன்.

முதல் முயற்சி

நான் என்ன கற்றுக்கொண்டேன்: ஒரே நேரத்தில் 25 டிபியை அலசுவதற்கு மலிவான வழி எதுவுமில்லை.

வாண்டர்பில்ட் பல்கலைக்கழகத்தில் “பெரிய தரவு செயலாக்கத்திற்கான மேம்பட்ட முறைகள்” பாடத்தை எடுத்த பிறகு, தந்திரம் பையில் இருந்தது என்பதில் உறுதியாக இருந்தேன். எல்லா தரவையும் இயக்கி முடிவைப் புகாரளிக்க ஹைவ் சேவையகத்தை அமைக்க ஒரு மணிநேரம் அல்லது இரண்டு மணிநேரம் ஆகும். எங்கள் தரவு AWS S3 இல் சேமிக்கப்பட்டுள்ளதால், நான் சேவையைப் பயன்படுத்தினேன் அதீனா, இது S3 தரவுக்கு Hive SQL வினவல்களைப் பயன்படுத்த உங்களை அனுமதிக்கிறது. ஹைவ் கிளஸ்டரை நீங்கள் அமைக்கவோ/உயர்த்தவோ தேவையில்லை, மேலும் நீங்கள் தேடும் டேட்டாவிற்கு மட்டும் பணம் செலுத்துங்கள்.

அதீனாவிடம் எனது தரவு மற்றும் அதன் வடிவமைப்பைக் காட்டிய பிறகு, இது போன்ற வினவல்களுடன் சில சோதனைகளை நடத்தினேன்:

select * from intensityData limit 10;

மற்றும் விரைவாக நன்கு கட்டமைக்கப்பட்ட முடிவுகளைப் பெற்றது. தயார்.

எங்கள் வேலையில் தரவைப் பயன்படுத்த முயற்சிக்கும் வரை...

மாதிரியை சோதிக்க அனைத்து SNP தகவல்களையும் வெளியே எடுக்கும்படி என்னிடம் கேட்கப்பட்டது. நான் வினவலை இயக்கினேன்:


select * from intensityData 
where snp = 'rs123456';

... காத்திருக்க ஆரம்பித்தான். எட்டு நிமிடங்கள் மற்றும் 4 TB க்கும் அதிகமான தரவு கோரப்பட்ட பிறகு, நான் முடிவைப் பெற்றேன். கண்டுபிடிக்கப்பட்ட தரவுகளின் அளவின் அடிப்படையில் அதீனா கட்டணம், ஒரு டெராபைட்டுக்கு $5. எனவே இந்த ஒற்றை கோரிக்கைக்கு $20 செலவாகும் மற்றும் எட்டு நிமிடங்கள் காத்திருக்க வேண்டும். எல்லா தரவுகளிலும் மாதிரியை இயக்க, நாங்கள் 38 ஆண்டுகள் காத்திருந்து $50 மில்லியன் செலுத்த வேண்டியிருந்தது. வெளிப்படையாக, இது எங்களுக்கு ஏற்றதாக இல்லை.

பார்க்வெட்டைப் பயன்படுத்துவது அவசியம் ...

நான் என்ன கற்றுக்கொண்டேன்: உங்கள் பார்க்வெட் கோப்புகளின் அளவு மற்றும் அவற்றின் அமைப்பில் கவனமாக இருங்கள்.

நான் முதலில் அனைத்து TSVகளையும் மாற்றுவதன் மூலம் நிலைமையை சரிசெய்ய முயற்சித்தேன் பார்க்வெட் கோப்புகள். பெரிய தரவுத் தொகுப்புகளுடன் பணிபுரிய அவை வசதியானவை, ஏனெனில் அவற்றில் உள்ள தகவல்கள் நெடுவரிசை வடிவத்தில் சேமிக்கப்படுகின்றன: ஒவ்வொரு நெடுவரிசையும் அதன் சொந்த நினைவகம் / வட்டு பிரிவில் உள்ளது, உரை கோப்புகளுக்கு மாறாக, வரிசைகள் ஒவ்வொரு நெடுவரிசையின் கூறுகளையும் கொண்டிருக்கும். நீங்கள் ஏதாவது கண்டுபிடிக்க வேண்டும் என்றால், தேவையான நெடுவரிசையைப் படிக்கவும். கூடுதலாக, ஒவ்வொரு கோப்பும் ஒரு நெடுவரிசையில் மதிப்புகளின் வரம்பை சேமிக்கிறது, எனவே நீங்கள் தேடும் மதிப்பு நெடுவரிசையின் வரம்பில் இல்லை என்றால், ஸ்பார்க் முழு கோப்பையும் ஸ்கேன் செய்வதில் நேரத்தை வீணாக்காது.

நான் ஒரு எளிய பணியை நடத்தினேன் AWS பசை எங்கள் TSVகளை பார்க்வெட்டாக மாற்ற, புதிய கோப்புகளை அதீனாவில் இறக்கிவிட்டோம். இது சுமார் 5 மணி நேரம் ஆனது. ஆனால் நான் கோரிக்கையை இயக்கியபோது, அதை முடிக்க அதே நேரம் மற்றும் சிறிது குறைவான பணம் தேவைப்பட்டது. உண்மை என்னவென்றால், ஸ்பார்க், பணியை மேம்படுத்த முயற்சித்து, ஒரு TSV துண்டை அவிழ்த்து அதன் சொந்த பார்க்வெட் துண்டில் வைத்தது. மேலும் பல நபர்களின் முழுப் பதிவுகளையும் உள்ளடக்கும் அளவுக்கு ஒவ்வொரு துண்டின் அளவும் பெரியதாக இருந்ததால், ஒவ்வொரு கோப்பிலும் அனைத்து SNPகளும் இருந்தன, எனவே ஸ்பார்க் அதற்குத் தேவையான தகவல்களைப் பிரித்தெடுக்க அனைத்து கோப்புகளையும் திறக்க வேண்டியிருந்தது.

சுவாரஸ்யமாக, பார்க்வெட்டின் இயல்புநிலை (மற்றும் பரிந்துரைக்கப்பட்ட) சுருக்க வகை, ஸ்னாப்பி, பிரிக்க முடியாதது. எனவே, ஒவ்வொரு செயல்பாட்டாளரும் முழு 3,5 ஜிபி தரவுத்தொகுப்பைத் திறக்கும் மற்றும் பதிவிறக்கும் பணியில் சிக்கிக்கொண்டனர்.

சிக்கலைப் புரிந்துகொள்வோம்

நான் என்ன கற்றுக்கொண்டேன்: வரிசைப்படுத்துவது கடினம், குறிப்பாக தரவு விநியோகிக்கப்பட்டால்.

பிரச்சனையின் சாராம்சத்தை இப்போது புரிந்து கொண்டதாக எனக்குத் தோன்றியது. நான் SNP நெடுவரிசை மூலம் தரவை வரிசைப்படுத்த வேண்டும், நபர்களால் அல்ல. பின்னர் பல SNP கள் ஒரு தனி தரவு துண்டில் சேமிக்கப்படும், பின்னர் Parquet இன் "ஸ்மார்ட்" செயல்பாடு "மதிப்பு வரம்பில் இருந்தால் மட்டுமே திறக்க" அதன் அனைத்து மகிமையிலும் தன்னைக் காண்பிக்கும். துரதிர்ஷ்டவசமாக, ஒரு கொத்து முழுவதும் சிதறிய பில்லியன் கணக்கான வரிசைகளை வரிசைப்படுத்துவது கடினமான பணியாக இருந்தது.

நான் கல்லூரியில் அல்காரிதம் வகுப்பு எடுக்கிறேன்: "அச்சச்சோ, இந்த அனைத்து வரிசையாக்க வழிமுறைகளின் கணக்கீட்டு சிக்கலைப் பற்றி யாரும் கவலைப்படுவதில்லை"

நான் 20TB இல் ஒரு நெடுவரிசையில் வரிசைப்படுத்த முயற்சிக்கிறேன் # ஸ்பார்க் அட்டவணை: "இது ஏன் இவ்வளவு நேரம் எடுக்கிறது?" # டேட்டா சயின்ஸ் போராட்டங்கள்.

- நிக் ஸ்ட்ரேயர் (@NicholasStrayer) மார்ச் 11, 2019

"நான் ஒரு கவனச்சிதறல் மாணவன்" என்ற காரணத்திற்காக AWS நிச்சயமாக பணத்தைத் திரும்பப்பெற விரும்பவில்லை. நான் அமேசான் க்ளூவில் வரிசைப்படுத்திய பிறகு, அது 2 நாட்கள் ஓடி செயலிழந்தது.

பிரித்தல் பற்றி என்ன?

நான் என்ன கற்றுக்கொண்டேன்: ஸ்பார்க்கில் உள்ள பகிர்வுகள் சமநிலையில் இருக்க வேண்டும்.

குரோமோசோம்களில் தரவைப் பிரிக்கும் யோசனையை நான் கொண்டு வந்தேன். அவற்றில் 23 உள்ளன (மேலும் பல மைட்டோகாண்ட்ரியல் டிஎன்ஏ மற்றும் மேப் செய்யப்படாத பகுதிகளை கணக்கில் எடுத்துக் கொண்டால்).
இது தரவை சிறிய பகுதிகளாகப் பிரிக்க உங்களை அனுமதிக்கும். க்ளூ ஸ்கிரிப்ட்டில் ஸ்பார்க் ஏற்றுமதி செயல்பாட்டில் ஒரு வரியைச் சேர்த்தால் partition_by = "chr", பின்னர் தரவு வாளிகளாக பிரிக்கப்பட வேண்டும்.

மரபணுவானது குரோமோசோம்கள் எனப்படும் பல துண்டுகளைக் கொண்டுள்ளது.

துரதிருஷ்டவசமாக, அது வேலை செய்யவில்லை. குரோமோசோம்கள் வெவ்வேறு அளவுகளைக் கொண்டுள்ளன, அதாவது வெவ்வேறு அளவு தகவல்கள். அதாவது சில கணுக்கள் சீக்கிரம் முடிந்து சும்மா இருந்ததால், தொழிலாளர்களுக்கு ஸ்பார்க் அனுப்பிய பணிகள் சமநிலையில் இல்லை மற்றும் மெதுவாக முடிக்கப்படவில்லை. இருப்பினும், பணிகள் முடிக்கப்பட்டன. ஆனால் ஒரு SNP ஐக் கேட்கும் போது, ஏற்றத்தாழ்வு மீண்டும் சிக்கல்களை ஏற்படுத்தியது. பெரிய குரோமோசோம்களில் (அதாவது, நாம் தரவைப் பெற விரும்பும்) SNP களை செயலாக்குவதற்கான செலவு சுமார் 10 மடங்கு குறைந்துள்ளது. நிறைய, ஆனால் போதாது.

அதை இன்னும் சிறிய பகுதிகளாகப் பிரித்தால் என்ன செய்வது?

நான் என்ன கற்றுக்கொண்டேன்: 2,5 மில்லியன் பகிர்வுகளை செய்ய முயற்சிக்காதீர்கள்.

நான் அனைத்தையும் வெளியே செல்ல முடிவு செய்து ஒவ்வொரு SNP யையும் பிரித்தேன். பகிர்வுகள் சம அளவில் இருப்பதை இது உறுதி செய்தது. அது ஒரு மோசமான யோசனை. நான் பசை பயன்படுத்தினேன் மற்றும் ஒரு அப்பாவி வரியைச் சேர்த்தேன் partition_by = 'snp'. பணி தொடங்கியது மற்றும் செயல்படுத்த தொடங்கியது. ஒரு நாள் கழித்து நான் சரிபார்த்தேன், இன்னும் S3 க்கு எதுவும் எழுதப்படவில்லை என்று பார்த்தேன், அதனால் நான் பணியைக் கொன்றேன். S3 இல் ஒரு மறைக்கப்பட்ட இடத்திற்கு இடைநிலை கோப்புகளை க்ளூ எழுதுவது போல் தெரிகிறது, நிறைய கோப்புகள், ஒருவேளை இரண்டு மில்லியன்கள் இருக்கலாம். இதன் விளைவாக, எனது தவறுக்கு ஆயிரம் டாலர்களுக்கு மேல் செலவாகும் மற்றும் எனது வழிகாட்டியைப் பிரியப்படுத்தவில்லை.

பிரித்தல் + வரிசைப்படுத்துதல்

நான் என்ன கற்றுக்கொண்டேன்: ஸ்பார்க்கை ட்யூனிங் செய்வது போல் வரிசைப்படுத்துவது இன்னும் கடினம்.

பகிர்வதற்கான எனது கடைசி முயற்சியில் குரோமோசோம்களைப் பிரித்து ஒவ்வொரு பகிர்வையும் வரிசைப்படுத்தினேன். கோட்பாட்டில், இது ஒவ்வொரு வினவலையும் வேகப்படுத்தும், ஏனெனில் விரும்பிய SNP தரவு கொடுக்கப்பட்ட வரம்பிற்குள் சில பார்க்வெட் துகள்களுக்குள் இருக்க வேண்டும். துரதிர்ஷ்டவசமாக, பகிர்ந்த தரவை வரிசைப்படுத்துவது கடினமான பணியாக மாறியது. இதன் விளைவாக, நான் தனிப்பயன் கிளஸ்டருக்காக EMRக்கு மாறினேன், மேலும் நெகிழ்வான பணிப்பாய்வுகளை உருவாக்க எட்டு சக்திவாய்ந்த நிகழ்வுகள் (C5.4xl) மற்றும் Sparklyr ஐப் பயன்படுத்தினேன்...

# Sparklyr snippet to partition by chr and sort w/in partition
# Join the raw data with the snp bins
raw_data
  group_by(chr) %>%
  arrange(Position) %>% 
  Spark_write_Parquet(
    path = DUMP_LOC,
    mode = 'overwrite',
    partition_by = c('chr')
  )

இருப்பினும், பணி இன்னும் முடிக்கப்படவில்லை. நான் அதை வெவ்வேறு வழிகளில் கட்டமைத்தேன்: ஒவ்வொரு வினவல் நிறைவேற்றுபவருக்கும் நினைவக ஒதுக்கீட்டை அதிகரித்தது, அதிக அளவு நினைவகத்துடன் முனைகளைப் பயன்படுத்தியது, ஒளிபரப்பு மாறிகள் (ஒளிபரப்பு மாறிகள்) பயன்படுத்தப்பட்டது, ஆனால் ஒவ்வொரு முறையும் இவை அரை-நடவடிக்கைகளாக மாறியது, படிப்படியாக செயல்படுத்துபவர்கள் தொடங்கினர். எல்லாம் நிற்கும் வரை தோல்வி அடையும்.

புதுப்பி: எனவே அது தொடங்குகிறது. pic.twitter.com/agY4GU2ru5

- நிக் ஸ்ட்ரேயர் (@NicholasStrayer) 15 மே, 2019

நான் மேலும் படைப்பாளியாகி வருகிறேன்

நான் என்ன கற்றுக்கொண்டேன்: சில நேரங்களில் சிறப்பு தரவுகளுக்கு சிறப்பு தீர்வுகள் தேவைப்படுகின்றன.

ஒவ்வொரு SNP க்கும் ஒரு நிலை மதிப்பு உள்ளது. இது அதன் குரோமோசோமில் உள்ள அடிப்படைகளின் எண்ணிக்கையுடன் தொடர்புடைய எண். எங்கள் தரவை ஒழுங்கமைக்க இது ஒரு நல்ல மற்றும் இயற்கையான வழியாகும். முதலில் நான் ஒவ்வொரு குரோமோசோமின் பகுதிகளையும் பிரிக்க விரும்பினேன். எடுத்துக்காட்டாக, நிலைகள் 1 - 2000, 2001 - 4000, முதலியன. ஆனால் பிரச்சனை என்னவென்றால், SNP கள் குரோமோசோம்கள் முழுவதும் சமமாக விநியோகிக்கப்படவில்லை, எனவே குழு அளவுகள் பெரிதும் மாறுபடும்.

இதன் விளைவாக, நிலைகளை வகைகளாக (ரேங்க்) பிரித்தேன். ஏற்கனவே பதிவிறக்கம் செய்யப்பட்ட தரவைப் பயன்படுத்தி, தனிப்பட்ட SNPகள், அவற்றின் நிலைகள் மற்றும் குரோமோசோம்களின் பட்டியலைப் பெறுவதற்கான கோரிக்கையை இயக்கினேன். பின்னர் ஒவ்வொரு குரோமோசோமிலும் உள்ள தரவை வரிசைப்படுத்தி, SNP களை கொடுக்கப்பட்ட அளவிலான குழுக்களாக (பின்) சேகரித்தேன். ஒவ்வொன்றும் 1000 SNP என்று வைத்துக்கொள்வோம். இது எனக்கு SNP-க்கு-குரூப்-க்கு-குரோமோசோம் உறவைக் கொடுத்தது.

இறுதியில், நான் 75 SNP களின் குழுக்களை (பின்) உருவாக்கினேன், காரணம் கீழே விவரிக்கப்படும்.

snp_to_bin <- unique_snps %>% 
  group_by(chr) %>% 
  arrange(position) %>% 
  mutate(
    rank = 1:n()
    bin = floor(rank/snps_per_bin)
  ) %>% 
  ungroup()

முதலில் ஸ்பார்க்குடன் முயற்சிக்கவும்

நான் என்ன கற்றுக்கொண்டேன்: ஸ்பார்க் ஒருங்கிணைப்பு வேகமானது, ஆனால் பகிர்வு இன்னும் விலை உயர்ந்தது.

நான் இந்த சிறிய (2,5 மில்லியன் வரிசைகள்) தரவு சட்டகத்தை ஸ்பார்க்கில் படிக்க விரும்பினேன், அதை மூல தரவுகளுடன் இணைத்து, பின்னர் அதை புதிதாக சேர்க்கப்பட்ட நெடுவரிசையில் பிரிக்க விரும்பினேன். bin.


# Join the raw data with the snp bins
data_w_bin <- raw_data %>%
  left_join(sdf_broadcast(snp_to_bin), by ='snp_name') %>%
  group_by(chr_bin) %>%
  arrange(Position) %>% 
  Spark_write_Parquet(
    path = DUMP_LOC,
    mode = 'overwrite',
    partition_by = c('chr_bin')
  )

நான் பயன்படுத்தினேன் sdf_broadcast(), எனவே ஸ்பார்க் அனைத்து முனைகளுக்கும் தரவு சட்டத்தை அனுப்ப வேண்டும் என்று தெரியும். தரவு அளவு சிறியதாகவும், எல்லாப் பணிகளுக்கும் தேவைப்பட்டால் இது பயனுள்ளதாக இருக்கும். இல்லையெனில், ஸ்பார்க் புத்திசாலியாக இருக்க முயற்சிக்கிறது மற்றும் தேவைக்கேற்ப தரவை விநியோகம் செய்கிறது, இது மந்தநிலையை ஏற்படுத்தும்.

மீண்டும், எனது யோசனை வேலை செய்யவில்லை: பணிகள் சிறிது நேரம் வேலை செய்தன, தொழிற்சங்கத்தை முடித்தன, பின்னர், பகிர்வு மூலம் தொடங்கப்பட்ட நிர்வாகிகளைப் போலவே, அவை தோல்வியடையத் தொடங்கின.

AWK ஐச் சேர்க்கிறது

நான் என்ன கற்றுக்கொண்டேன்: உங்களுக்கு அடிப்படைகள் கற்பிக்கப்படும் போது தூங்க வேண்டாம். நிச்சயமாக 1980 களில் உங்கள் பிரச்சினையை யாரோ ஏற்கனவே தீர்த்து வைத்திருக்கிறார்கள்.

இது வரை, ஸ்பார்க் உடனான எனது அனைத்து தோல்விகளுக்கும் காரணம் கிளஸ்டரில் உள்ள தரவுகளின் குழப்பம்தான். ஒருவேளை முன் சிகிச்சை மூலம் நிலைமையை மேம்படுத்தலாம். மூல உரைத் தரவை குரோமோசோம்களின் நெடுவரிசைகளாகப் பிரிக்க முயற்சிக்க முடிவு செய்தேன், எனவே ஸ்பார்க்கிற்கு "முன்-பகிர்வு" தரவை வழங்குவேன் என்று நம்புகிறேன்.

நெடுவரிசை மதிப்புகளால் எவ்வாறு பிரிப்பது என்பதை StackOverflow இல் தேடி கண்டுபிடித்தேன் அத்தகைய ஒரு சிறந்த பதில். AWK மூலம், முடிவுகளை அனுப்புவதற்குப் பதிலாக, ஸ்கிரிப்ட்டில் எழுதுவதன் மூலம், நெடுவரிசை மதிப்புகளால் உரைக் கோப்பைப் பிரிக்கலாம். stdout.

அதை முயற்சிக்க ஒரு பாஷ் ஸ்கிரிப்ட் எழுதினேன். தொகுக்கப்பட்ட TSVகளில் ஒன்றைப் பதிவிறக்கம் செய்து, அதைப் பயன்படுத்தி அதைத் திறக்கவும் gzip மற்றும் அனுப்பப்பட்டது awk.

gzip -dc path/to/chunk/file.gz |
awk -F 't' 
'{print $1",..."$30">"chunked/"$chr"_chr"$15".csv"}'

அது வேலை செய்தது!

கோர்களை நிரப்புதல்

நான் என்ன கற்றுக்கொண்டேன்: gnu parallel - இது ஒரு மந்திர விஷயம், எல்லோரும் அதைப் பயன்படுத்த வேண்டும்.

நான் தொடங்கியபோது பிரிப்பு மிகவும் மெதுவாக இருந்தது htopசக்திவாய்ந்த (மற்றும் விலையுயர்ந்த) EC2 நிகழ்வைப் பயன்படுத்துவதைச் சரிபார்க்க, நான் ஒரு கோர் மற்றும் 200 MB நினைவகத்தை மட்டுமே பயன்படுத்தினேன். சிக்கலைத் தீர்க்கவும், நிறைய பணத்தை இழக்காமல் இருக்கவும், வேலையை எவ்வாறு இணைப்பது என்பதை நாங்கள் கண்டுபிடிக்க வேண்டியிருந்தது. அதிர்ஷ்டவசமாக, முற்றிலும் அற்புதமான புத்தகத்தில் கட்டளை வரியில் தரவு அறிவியல் இணையாக்கம் பற்றிய ஜெரோன் ஜான்சென்ஸின் ஒரு அத்தியாயத்தை நான் கண்டேன். அதிலிருந்து நான் கற்றுக்கொண்டேன் gnu parallel, Unix இல் மல்டித்ரெடிங்கைச் செயல்படுத்த மிகவும் நெகிழ்வான முறை.

நான் புதிய செயல்முறையைப் பயன்படுத்தி பகிர்வைத் தொடங்கியபோது, எல்லாம் நன்றாக இருந்தது, ஆனால் இன்னும் ஒரு இடையூறு இருந்தது - S3 பொருட்களை வட்டில் பதிவிறக்குவது மிக வேகமாக இல்லை மற்றும் முழுமையாக இணையாக இல்லை. இதை சரிசெய்ய, நான் இதைச் செய்தேன்:

வட்டில் உள்ள இடைநிலை சேமிப்பகத்தை முற்றிலுமாக நீக்கி, S3 பதிவிறக்க கட்டத்தை நேரடியாக பைப்லைனில் செயல்படுத்துவது சாத்தியம் என்பதை நான் கண்டுபிடித்தேன். இதன் பொருள், மூலத் தரவை வட்டில் எழுதுவதைத் தவிர்க்கலாம் மற்றும் AWS இல் இன்னும் சிறிய மற்றும் மலிவான சேமிப்பகத்தைப் பயன்படுத்தலாம்.
குழு aws configure set default.s3.max_concurrent_requests 50 AWS CLI பயன்படுத்தும் நூல்களின் எண்ணிக்கையை பெரிதும் அதிகரித்தது (இயல்புநிலையாக 10 உள்ளன).
பெயரில் n என்ற எழுத்துடன், நெட்வொர்க் வேகத்திற்கு உகந்ததாக EC2 நிகழ்விற்கு மாறினேன். n-நிகழ்வுகளைப் பயன்படுத்தும் போது செயலாக்க சக்தியின் இழப்பு, ஏற்றுதல் வேகத்தின் அதிகரிப்பால் ஈடுசெய்யப்படுவதை விட அதிகமாக இருப்பதைக் கண்டேன். பெரும்பாலான பணிகளுக்கு நான் c5n.4xl ஐப் பயன்படுத்தினேன்.
மாற்றப்பட்டது gzip மீது pigz, இது ஒரு gzip கருவியாகும், இது கோப்புகளை டிகம்ப்ரஸ் செய்யும் தொடக்கத்தில் இணையாக இல்லாத பணியை இணையாகச் செய்ய சிறந்த விஷயங்களைச் செய்ய முடியும் (இது குறைந்த பட்சம் உதவியது).

# Let S3 use as many threads as it wants
aws configure set default.s3.max_concurrent_requests 50

for chunk_file in $(aws s3 ls $DATA_LOC | awk '{print $4}' | grep 'chr'$DESIRED_CHR'.csv') ; do

        aws s3 cp s3://$batch_loc$chunk_file - |
        pigz -dc |
        parallel --block 100M --pipe  
        "awk -F 't' '{print $1",..."$30">"chunked/{#}_chr"$15".csv"}'"

       # Combine all the parallel process chunks to single files
        ls chunked/ |
        cut -d '_' -f 2 |
        sort -u |
        parallel 'cat chunked/*_{} | sort -k5 -n -S 80% -t, | aws s3 cp - '$s3_dest'/batch_'$batch_num'_{}'
        
         # Clean up intermediate data
       rm chunked/*
done

எல்லாவற்றையும் மிக விரைவாகச் செய்ய இந்த படிகள் ஒன்றோடொன்று இணைக்கப்பட்டுள்ளன. பதிவிறக்க வேகத்தை அதிகரிப்பதன் மூலமும், டிஸ்க் ரைட்களை நீக்குவதன் மூலமும், இப்போது சில மணிநேரங்களில் 5 டெராபைட் தொகுப்பை செயலாக்க முடியும்.

AWS இல் நீங்கள் செலுத்தும் அனைத்து கோர்களும் பயன்படுத்தப்படுவதை விட இனிமையானது எதுவுமில்லை. gnu-parallelக்கு நன்றி, என்னால் 19gig csv ஐ எவ்வளவு வேகமாக பதிவிறக்கம் செய்ய முடியுமோ அவ்வளவு வேகமாக அன்ஜிப் செய்து பிரிக்க முடியும். இதை இயக்க என்னால் தீப்பொறி கூட முடியவில்லை. # டேட்டா சயின்ஸ் # லினக்ஸ் pic.twitter.com/Nqyba2zqEk

- நிக் ஸ்ட்ரேயர் (@NicholasStrayer) 17 மே, 2019

இந்த ட்வீட் 'TSV' என்று குறிப்பிட்டிருக்க வேண்டும். ஐயோ.

புதிதாக பாகுபடுத்தப்பட்ட தரவைப் பயன்படுத்துதல்

நான் என்ன கற்றுக்கொண்டேன்: ஸ்பார்க் சுருக்கப்படாத தரவை விரும்புகிறது மற்றும் பகிர்வுகளை இணைப்பதை விரும்பவில்லை.

இப்போது தரவு S3 இல் தொகுக்கப்படாத (படிக்க: பகிரப்பட்ட) மற்றும் அரை-வரிசைப்படுத்தப்பட்ட வடிவத்தில் இருந்தது, மேலும் நான் மீண்டும் ஸ்பார்க்கிற்கு திரும்ப முடியும். எனக்கு ஒரு ஆச்சரியம் காத்திருந்தது: நான் மீண்டும் நான் விரும்பியதை அடையத் தவறிவிட்டேன்! தரவு எவ்வாறு பிரிக்கப்பட்டது என்பதை ஸ்பார்க்கிற்குச் சொல்வது மிகவும் கடினமாக இருந்தது. நான் இதைச் செய்தபோதும், பல பகிர்வுகள் (95 ஆயிரம்) இருந்தன, நான் பயன்படுத்தியபோது coalesce அவற்றின் எண்ணிக்கையை நியாயமான வரம்புகளுக்குக் குறைத்தது, இது எனது பகிர்வை அழித்துவிட்டது. இதை சரிசெய்ய முடியும் என்று நான் நம்புகிறேன், ஆனால் இரண்டு நாட்கள் தேடியும் என்னால் தீர்வு காண முடியவில்லை. நான் ஸ்பார்க்கில் அனைத்து பணிகளையும் முடித்தேன், இருப்பினும் சிறிது நேரம் எடுத்தது மற்றும் எனது பிளவு பார்க்வெட் கோப்புகள் மிகவும் சிறியதாக இல்லை (~200 KB). இருப்பினும், தரவு தேவைப்படும் இடத்தில் இருந்தது.

மிகவும் சிறிய மற்றும் சீரற்ற, அற்புதமான!

உள்ளூர் ஸ்பார்க் வினவல்களை சோதிக்கிறது

நான் என்ன கற்றுக்கொண்டேன்: எளிய பிரச்சனைகளை தீர்க்கும் போது தீப்பொறி அதிகமாக உள்ளது.

ஒரு புத்திசாலித்தனமான வடிவத்தில் தரவைப் பதிவிறக்குவதன் மூலம், வேகத்தை சோதிக்க முடிந்தது. உள்ளூர் ஸ்பார்க் சேவையகத்தை இயக்க R ஸ்கிரிப்டை அமைக்கவும், பின்னர் குறிப்பிட்ட பார்க்வெட் குழு சேமிப்பகத்திலிருந்து (பின்) ஸ்பார்க் தரவு சட்டத்தை ஏற்றவும். நான் எல்லா தரவையும் ஏற்ற முயற்சித்தேன், ஆனால் பகிர்வை அடையாளம் காண ஸ்பார்க்லைரைப் பெற முடியவில்லை.

sc <- Spark_connect(master = "local")

desired_snp <- 'rs34771739'

# Start a timer
start_time <- Sys.time()

# Load the desired bin into Spark
intensity_data <- sc %>% 
  Spark_read_Parquet(
    name = 'intensity_data', 
    path = get_snp_location(desired_snp),
    memory = FALSE )

# Subset bin to snp and then collect to local
test_subset <- intensity_data %>% 
  filter(SNP_Name == desired_snp) %>% 
  collect()

print(Sys.time() - start_time)

மரணதண்டனை 29,415 வினாடிகள் எடுத்தது. மிகவும் சிறந்தது, ஆனால் எதையும் வெகுஜன சோதனைக்கு மிகவும் நல்லதல்ல. கூடுதலாக, 50 க்கும் குறைவான எடையுள்ள டேட்டாசெட்டிற்கு 15 GB க்கும் அதிகமான நினைவகத்தை நான் ஒதுக்கியபோதும் கூட, நினைவகத்தில் டேட்டா ஃபிரேமை தேக்ககப்படுத்த முயற்சித்தபோது, ஸ்பார்க் எப்போதும் செயலிழந்துவிடும் என்பதால், கேச்சிங் மூலம் விஷயங்களை வேகப்படுத்த முடியவில்லை.

AWK பக்கத்துக்குத் திரும்பு

நான் என்ன கற்றுக்கொண்டேன்: AWK இல் உள்ள துணை வரிசைகள் மிகவும் திறமையானவை.

நான் அதிக வேகத்தை அடைய முடியும் என்பதை உணர்ந்தேன். நான் அதை அற்புதமாக நினைவு கூர்ந்தேன் புரூஸ் பார்னெட்டின் AWK டுடோரியல் "என்ற ஒரு சிறந்த அம்சத்தைப் பற்றி நான் படித்தேன்.துணை வரிசைகள்" அடிப்படையில், இவை முக்கிய-மதிப்பு ஜோடிகள், அவை சில காரணங்களால் AWK இல் வித்தியாசமாக அழைக்கப்பட்டன, எனவே நான் எப்படியாவது அவற்றைப் பற்றி அதிகம் சிந்திக்கவில்லை. ரோமன் செப்லியாகா "அசோசியேட்டிவ் அணிகள்" என்ற சொல் "முக்கிய மதிப்பு ஜோடி" என்ற சொல்லை விட மிகவும் பழமையானது என்பதை நினைவு கூர்ந்தார். நீங்களாக இருந்தாலும் கூகுள் என்கிராமில் முக்கிய மதிப்பைப் பார்க்கவும், இந்த வார்த்தையை நீங்கள் அங்கு பார்க்க மாட்டீர்கள், ஆனால் நீங்கள் துணை வரிசைகளைக் காண்பீர்கள்! கூடுதலாக, "முக்கிய மதிப்பு ஜோடி" பெரும்பாலும் தரவுத்தளங்களுடன் தொடர்புடையது, எனவே அதை ஹாஷ்மேப்புடன் ஒப்பிடுவது மிகவும் அர்த்தமுள்ளதாக இருக்கிறது. Spark ஐப் பயன்படுத்தாமலேயே எனது SNPகளை பின் அட்டவணை மற்றும் மூலத் தரவுகளுடன் இணைக்க இந்த துணை அணிவரிசைகளைப் பயன்படுத்தலாம் என்பதை உணர்ந்தேன்.

இதைச் செய்ய, AWK ஸ்கிரிப்ட்டில் நான் தொகுதியைப் பயன்படுத்தினேன் BEGIN. இது ஸ்கிரிப்ட்டின் முக்கிய பகுதிக்கு தரவுகளின் முதல் வரி அனுப்பப்படுவதற்கு முன் செயல்படுத்தப்படும் குறியீட்டின் ஒரு பகுதி.

join_data.awk
BEGIN {
  FS=",";
  batch_num=substr(chunk,7,1);
  chunk_id=substr(chunk,15,2);
  while(getline < "snp_to_bin.csv") {bin[$1] = $2}
}
{
  print $0 > "chunked/chr_"chr"_bin_"bin[$1]"_"batch_num"_"chunk_id".csv"
}

அணி while(getline...) CSV குழுவிலிருந்து (பின்) அனைத்து வரிசைகளையும் ஏற்றியது, முதல் நெடுவரிசையை (SNP பெயர்) துணை வரிசைக்கான விசையாக அமைக்கவும் bin மற்றும் இரண்டாவது மதிப்பு (குழு) மதிப்பாக. பின்னர் தொகுதியில் { }, இது பிரதான கோப்பின் அனைத்து வரிகளிலும் செயல்படுத்தப்படுகிறது, ஒவ்வொரு வரியும் வெளியீட்டு கோப்பிற்கு அனுப்பப்படுகிறது, இது அதன் குழுவைப் பொறுத்து ஒரு தனித்துவமான பெயரைப் பெறுகிறது (பின்): ..._bin_"bin[$1]"_....

மாறிகள் batch_num и chunk_id பைப்லைன் வழங்கிய தரவுகளுடன் பொருந்தியது, பந்தய நிலையைத் தவிர்க்கிறது, மேலும் ஒவ்வொரு த்ரெட் இயங்கும் parallel, அதன் சொந்த தனிப்பட்ட கோப்பில் எழுதப்பட்டது.

AWK உடனான எனது முந்தைய பரிசோதனையில் இருந்து மீதமுள்ள அனைத்து மூலத் தரவையும் குரோமோசோம்களில் உள்ள கோப்புறைகளில் சிதறடித்ததால், இப்போது ஒரு நேரத்தில் ஒரு குரோமோசோமைச் செயலாக்க மற்றும் ஆழமான பகிர்வு தரவை S3 க்கு அனுப்ப மற்றொரு பாஷ் ஸ்கிரிப்டை எழுத முடியும்.

DESIRED_CHR='13'

# Download chromosome data from s3 and split into bins
aws s3 ls $DATA_LOC |
awk '{print $4}' |
grep 'chr'$DESIRED_CHR'.csv' |
parallel "echo 'reading {}'; aws s3 cp "$DATA_LOC"{} - | awk -v chr=""$DESIRED_CHR"" -v chunk="{}" -f split_on_chr_bin.awk"

# Combine all the parallel process chunks to single files and upload to rds using R
ls chunked/ |
cut -d '_' -f 4 |
sort -u |
parallel "echo 'zipping bin {}'; cat chunked/*_bin_{}_*.csv | ./upload_as_rds.R '$S3_DEST'/chr_'$DESIRED_CHR'_bin_{}.rds"
rm chunked/*

ஸ்கிரிப்ட் இரண்டு பிரிவுகளைக் கொண்டுள்ளது parallel.

முதல் பிரிவில், விரும்பிய குரோமோசோம் பற்றிய தகவல்களைக் கொண்ட அனைத்து கோப்புகளிலிருந்தும் தரவு படிக்கப்படுகிறது, பின்னர் இந்தத் தரவு நூல்கள் முழுவதும் விநியோகிக்கப்படுகிறது, இது கோப்புகளை பொருத்தமான குழுக்களாக (பின்) விநியோகிக்கிறது. ஒரே கோப்பில் பல இழைகள் எழுதும் போது ரேஸ் நிலைமைகளைத் தவிர்க்க, AWK வெவ்வேறு இடங்களுக்கு தரவை எழுத கோப்பு பெயர்களை அனுப்புகிறது, எ.கா. chr_10_bin_52_batch_2_aa.csv. இதன் விளைவாக, பல சிறிய கோப்புகள் வட்டில் உருவாக்கப்படுகின்றன (இதற்காக நான் டெராபைட் EBS தொகுதிகளைப் பயன்படுத்தினேன்).

இரண்டாவது பிரிவில் இருந்து கன்வேயர் parallel குழுக்கள் (பின்) வழியாகச் சென்று அவற்றின் தனிப்பட்ட கோப்புகளை பொதுவான CSV c ஆக இணைக்கிறது catபின்னர் அவற்றை ஏற்றுமதிக்கு அனுப்புகிறது.

R இல் ஒளிபரப்பா?

நான் என்ன கற்றுக்கொண்டேன்: நீங்கள் தொடர்பு கொள்ளலாம் stdin и stdout R ஸ்கிரிப்டில் இருந்து, எனவே அதை பைப்லைனில் பயன்படுத்தவும்.

உங்கள் பாஷ் ஸ்கிரிப்ட்டில் இந்த வரியை நீங்கள் கவனித்திருக்கலாம்: ...cat chunked/*_bin_{}_*.csv | ./upload_as_rds.R.... இது அனைத்து இணைக்கப்பட்ட குழு கோப்புகளை (பின்) கீழே உள்ள R ஸ்கிரிப்ட்டில் மொழிபெயர்க்கிறது. {} ஒரு சிறப்பு நுட்பமாகும் parallel, இது குறிப்பிட்ட ஸ்ட்ரீமிற்கு அனுப்பும் எந்த தரவையும் நேரடியாக கட்டளைக்குள் செருகும். விருப்பம் {#} தனிப்பட்ட நூல் ஐடியை வழங்குகிறது, மற்றும் {%} வேலை வாய்ப்பு எண்ணைக் குறிக்கிறது (மீண்டும், ஆனால் ஒரே நேரத்தில் அல்ல). அனைத்து விருப்பங்களின் பட்டியலையும் காணலாம் ஆவணங்கள்.

#!/usr/bin/env Rscript
library(readr)
library(aws.s3)

# Read first command line argument
data_destination <- commandArgs(trailingOnly = TRUE)[1]

data_cols <- list(SNP_Name = 'c', ...)

s3saveRDS(
  read_csv(
        file("stdin"), 
        col_names = names(data_cols),
        col_types = data_cols 
    ),
  object = data_destination
)

ஒரு மாறி போது file("stdin") அனுப்பப்பட்டது readr::read_csv, R ஸ்கிரிப்ட்டில் மொழிபெயர்க்கப்பட்ட தரவு ஒரு சட்டத்தில் ஏற்றப்படுகிறது, அது பின்னர் வடிவத்தில் உள்ளது .rds- கோப்பு பயன்படுத்தி aws.s3 S3க்கு நேரடியாக எழுதப்பட்டது.

ஆர்டிஎஸ் என்பது ஸ்பீக்கர் சேமிப்பக வசதிகள் இல்லாமல், பார்க்வெட்டின் ஜூனியர் பதிப்பு போன்றது.

பாஷ் ஸ்கிரிப்டை முடித்த பிறகு எனக்கு ஒரு மூட்டை கிடைத்தது .rdsS3 இல் அமைந்துள்ள கோப்புகள், இது திறமையான சுருக்க மற்றும் உள்ளமைக்கப்பட்ட வகைகளைப் பயன்படுத்த என்னை அனுமதித்தது.

பிரேக் ஆர் பயன்பாடு இருந்தபோதிலும், எல்லாம் மிக விரைவாக வேலை செய்தது. தரவைப் படிக்கும் மற்றும் எழுதும் R இன் பகுதிகள் மிகவும் உகந்ததாக இருப்பதில் ஆச்சரியமில்லை. ஒரு நடுத்தர அளவிலான குரோமோசோமில் சோதனை செய்த பிறகு, இரண்டு மணிநேரத்தில் C5n.4xl நிகழ்வில் வேலை முடிந்தது.

S3 வரம்புகள்

நான் என்ன கற்றுக்கொண்டேன்: ஸ்மார்ட் பாதை செயலாக்கத்திற்கு நன்றி, S3 பல கோப்புகளை கையாள முடியும்.

S3க்கு மாற்றப்பட்ட பல கோப்புகளை கையாள முடியுமா என்று நான் கவலைப்பட்டேன். நான் கோப்பு பெயர்களை அர்த்தமுள்ளதாக மாற்ற முடியும், ஆனால் S3 அவற்றை எவ்வாறு தேடும்?

S3 இல் உள்ள கோப்புறைகள் காட்சிக்காக மட்டுமே உள்ளன, உண்மையில் கணினிக்கு சின்னத்தில் ஆர்வம் இல்லை /. S3 FAQ பக்கத்திலிருந்து.

S3 ஒரு குறிப்பிட்ட கோப்பிற்கான பாதையை ஒரு வகையான ஹாஷ் அட்டவணை அல்லது ஆவண அடிப்படையிலான தரவுத்தளத்தில் ஒரு எளிய விசையாகக் குறிக்கிறது. ஒரு வாளியை ஒரு அட்டவணையாகக் கருதலாம், மேலும் கோப்புகளை அந்த அட்டவணையில் உள்ள பதிவுகளாகக் கருதலாம்.

அமேசானில் லாபம் ஈட்டுவதற்கு வேகமும் செயல்திறனும் முக்கியம் என்பதால், இந்த கீ-ஆஸ்-எ-ஃபைல்-பாத் சிஸ்டம் அதிவேகமாக மேம்படுத்தப்பட்டதில் ஆச்சரியமில்லை. நான் ஒரு சமநிலையைக் கண்டறிய முயற்சித்தேன்: அதனால் நான் நிறைய பெற கோரிக்கைகளைச் செய்ய வேண்டியதில்லை, ஆனால் கோரிக்கைகள் விரைவாகச் செயல்படுத்தப்பட்டன. சுமார் 20 ஆயிரம் பின் கோப்புகளை உருவாக்குவது சிறந்தது என்று மாறியது. நாங்கள் தொடர்ந்து மேம்படுத்தினால், வேகத்தை அதிகரிக்க முடியும் என்று நினைக்கிறேன் (உதாரணமாக, தரவுக்காக ஒரு சிறப்பு வாளியை உருவாக்குகிறது, இதனால் தேடல் அட்டவணையின் அளவைக் குறைக்கிறது). ஆனால் மேலதிக பரிசோதனைகளுக்கு நேரமோ பணமோ இல்லை.

குறுக்கு இணக்கத்தன்மை பற்றி என்ன?

நான் கற்றுக்கொண்டது: நேரத்தை வீணடிப்பதற்கான முதல் காரணம் உங்கள் சேமிப்பக முறையை முன்கூட்டியே மேம்படுத்துவதாகும்.

இந்த கட்டத்தில், உங்களை நீங்களே கேட்டுக்கொள்வது மிகவும் முக்கியம்: "ஏன் தனியுரிம கோப்பு வடிவமைப்பைப் பயன்படுத்த வேண்டும்?" காரணம் ஏற்றுதல் வேகம் (ஜிஜிப் செய்யப்பட்ட CSV கோப்புகளை ஏற்றுவதற்கு 7 மடங்கு அதிக நேரம் எடுத்தது) மற்றும் எங்கள் பணிப்பாய்வுகளுடன் இணக்கம். ஸ்பார்க் சுமை இல்லாமல் பார்க்வெட் (அல்லது அம்பு) கோப்புகளை R எளிதாக ஏற்ற முடியுமா என்பதை நான் மறுபரிசீலனை செய்யலாம். எங்கள் ஆய்வகத்தில் உள்ள அனைவரும் R ஐப் பயன்படுத்துகின்றனர், மேலும் நான் தரவை வேறொரு வடிவத்திற்கு மாற்ற வேண்டும் என்றால், அசல் உரைத் தரவு இன்னும் என்னிடம் உள்ளது, எனவே என்னால் மீண்டும் பைப்லைனை இயக்க முடியும்.

வேலை பிரிவு

நான் என்ன கற்றுக்கொண்டேன்: வேலைகளை கைமுறையாக மேம்படுத்த முயற்சிக்காதீர்கள், கணினி அதைச் செய்யட்டும்.

நான் ஒரு குரோமோசோமில் பணிப்பாய்வு பிழைதிருத்தம் செய்துள்ளேன், இப்போது மற்ற எல்லா தரவையும் செயலாக்க வேண்டும்.
நான் மாற்றுவதற்கு பல EC2 நிகழ்வுகளை உயர்த்த விரும்பினேன், ஆனால் அதே நேரத்தில் வெவ்வேறு செயலாக்க வேலைகளில் (ஸ்பார்க் சமநிலையற்ற பகிர்வுகளால் பாதிக்கப்பட்டது போல்) மிகவும் சமநிலையற்ற சுமைகளைப் பெறுவதற்கு நான் பயந்தேன். கூடுதலாக, ஒரு குரோமோசோமுக்கு ஒரு நிகழ்வை உயர்த்துவதில் எனக்கு ஆர்வம் இல்லை, ஏனெனில் AWS கணக்குகளுக்கு 10 நிகழ்வுகளின் இயல்புநிலை வரம்பு உள்ளது.

செயலாக்க வேலைகளை மேம்படுத்த R இல் ஒரு ஸ்கிரிப்டை எழுத முடிவு செய்தேன்.

முதலில், ஒவ்வொரு குரோமோசோமும் எவ்வளவு சேமிப்பக இடத்தை ஆக்கிரமித்துள்ளது என்பதைக் கணக்கிட S3 ஐக் கேட்டேன்.

library(aws.s3)
library(tidyverse)

chr_sizes <- get_bucket_df(
  bucket = '...', prefix = '...', max = Inf
) %>% 
  mutate(Size = as.numeric(Size)) %>% 
  filter(Size != 0) %>% 
  mutate(
    # Extract chromosome from the file name 
    chr = str_extract(Key, 'chr.{1,4}.csv') %>%
             str_remove_all('chr|.csv')
  ) %>% 
  group_by(chr) %>% 
  summarise(total_size = sum(Size)/1e+9) # Divide to get value in GB



# A tibble: 27 x 2
   chr   total_size
   <chr>      <dbl>
 1 0           163.
 2 1           967.
 3 10          541.
 4 11          611.
 5 12          542.
 6 13          364.
 7 14          375.
 8 15          372.
 9 16          434.
10 17          443.
# … with 17 more rows

பின்னர் நான் ஒரு செயல்பாட்டை எழுதினேன், இது மொத்த அளவை எடுக்கும், குரோமோசோம்களின் வரிசையை மாற்றுகிறது, அவற்றை குழுக்களாக பிரிக்கிறது. num_jobs மற்றும் அனைத்து செயலாக்க வேலைகளின் அளவுகள் எவ்வளவு வேறுபட்டவை என்பதை உங்களுக்குக் கூறுகிறது.

num_jobs <- 7
# How big would each job be if perfectly split?
job_size <- sum(chr_sizes$total_size)/7

shuffle_job <- function(i){
  chr_sizes %>%
    sample_frac() %>% 
    mutate(
      cum_size = cumsum(total_size),
      job_num = ceiling(cum_size/job_size)
    ) %>% 
    group_by(job_num) %>% 
    summarise(
      job_chrs = paste(chr, collapse = ','),
      total_job_size = sum(total_size)
    ) %>% 
    mutate(sd = sd(total_job_size)) %>% 
    nest(-sd)
}

shuffle_job(1)



# A tibble: 1 x 2
     sd data            
  <dbl> <list>          
1  153. <tibble [7 × 3]>

பின்னர் நான் purrr ஐப் பயன்படுத்தி ஆயிரம் ஷஃபிள்களில் ஓடி சிறந்ததைத் தேர்ந்தெடுத்தேன்.

1:1000 %>% 
  map_df(shuffle_job) %>% 
  filter(sd == min(sd)) %>% 
  pull(data) %>% 
  pluck(1)

எனவே அளவில் மிகவும் ஒத்த பணிகளின் தொகுப்புடன் முடித்தேன். எனது முந்தைய பேஷ் ஸ்கிரிப்டை ஒரு பெரிய வளையத்தில் மடிப்பதுதான் மிச்சம் for. இந்த தேர்வுமுறை எழுதுவதற்கு சுமார் 10 நிமிடங்கள் எடுத்தது. இது சமநிலையற்றதாக இருந்தால், பணிகளை கைமுறையாக உருவாக்குவதற்கு நான் செலவழிப்பதை விட இது மிகவும் குறைவு. எனவே, இந்த பூர்வாங்க தேர்வுமுறையில் நான் சரியாக இருந்தேன் என்று நினைக்கிறேன்.

for DESIRED_CHR in "16" "9" "7" "21" "MT"
do
# Code for processing a single chromosome
fi

முடிவில் நான் பணிநிறுத்தம் கட்டளையைச் சேர்க்கிறேன்:

sudo shutdown -h now

... மற்றும் எல்லாம் வேலை செய்தது! AWS CLI ஐப் பயன்படுத்தி, விருப்பத்தைப் பயன்படுத்தி நிகழ்வுகளை எழுப்பினேன் user_data செயலாக்கத்திற்கான அவர்களின் பணிகளின் பாஷ் ஸ்கிரிப்ட்களை அவர்களுக்கு வழங்கினார். அவை தானாகவே இயங்கி மூடப்பட்டன, எனவே கூடுதல் செயலாக்க சக்திக்கு நான் பணம் செலுத்தவில்லை.

aws ec2 run-instances ...
--tag-specifications "ResourceType=instance,Tags=[{Key=Name,Value=<<job_name>>}]" 
--user-data file://<<job_script_loc>>

பேக் செய்வோம்!

நான் என்ன கற்றுக்கொண்டேன்: API எளிதாகவும், பயன்படுத்துவதற்கான நெகிழ்வுத்தன்மைக்காகவும் எளிமையாக இருக்க வேண்டும்.

இறுதியாக நான் தரவுகளை சரியான இடத்தில் மற்றும் படிவத்தில் பெற்றேன். எஞ்சியிருப்பது, எனது சக ஊழியர்களுக்குத் தரவை எளிதாகப் பயன்படுத்துவதற்கான செயல்முறையை முடிந்தவரை எளிதாக்குவதுதான். கோரிக்கைகளை உருவாக்க எளிய API ஐ உருவாக்க விரும்பினேன். எதிர்காலத்தில் நான் மாற முடிவு செய்தால் .rds பார்க்வெட் கோப்புகளுக்கு, இது எனக்கு ஒரு பிரச்சனையாக இருக்க வேண்டும், என் சக ஊழியர்களுக்கு அல்ல. இதற்காக நான் ஒரு உள் R தொகுப்பை உருவாக்க முடிவு செய்தேன்.

ஒரு செயல்பாட்டைச் சுற்றி ஒழுங்கமைக்கப்பட்ட சில தரவு அணுகல் செயல்பாடுகளைக் கொண்ட மிக எளிய தொகுப்பை உருவாக்கி ஆவணப்படுத்தவும் get_snp. எனது சகாக்களுக்காக ஒரு வலைத்தளத்தையும் உருவாக்கினேன் pkgdown, எனவே அவர்கள் எளிதாக எடுத்துக்காட்டுகள் மற்றும் ஆவணங்களைப் பார்க்க முடியும்.

ஸ்மார்ட் கேச்சிங்

நான் என்ன கற்றுக்கொண்டேன்: உங்கள் தரவு நன்கு தயாரிக்கப்பட்டிருந்தால், தற்காலிக சேமிப்பு எளிதாக இருக்கும்!

முக்கிய பணிப்பாய்வுகளில் ஒன்று SNP தொகுப்பிற்கு அதே பகுப்பாய்வு மாதிரியைப் பயன்படுத்தியதால், எனது நன்மைக்காக பின்னிங்கைப் பயன்படுத்த முடிவு செய்தேன். SNP வழியாக தரவை அனுப்பும் போது, குழுவிலிருந்து (பின்) அனைத்து தகவல்களும் திரும்பிய பொருளுடன் இணைக்கப்படும். அதாவது, பழைய வினவல்கள் (கோட்பாட்டில்) புதிய வினவல்களின் செயலாக்கத்தை விரைவுபடுத்தும்.

# Part of get_snp()
...
  # Test if our current snp data has the desired snp.
  already_have_snp <- desired_snp %in% prev_snp_results$snps_in_bin

  if(!already_have_snp){
    # Grab info on the bin of the desired snp
    snp_results <- get_snp_bin(desired_snp)

    # Download the snp's bin data
    snp_results$bin_data <- aws.s3::s3readRDS(object = snp_results$data_loc)
  } else {
    # The previous snp data contained the right bin so just use it
    snp_results <- prev_snp_results
  }
...

தொகுப்பை உருவாக்கும் போது, வெவ்வேறு முறைகளைப் பயன்படுத்தும் போது வேகத்தை ஒப்பிட பல வரையறைகளை இயக்கினேன். இதை புறக்கணிக்க வேண்டாம் என்று நான் பரிந்துரைக்கிறேன், ஏனென்றால் சில நேரங்களில் முடிவுகள் எதிர்பாராதவை. உதாரணத்திற்கு, dplyr::filter அட்டவணைப்படுத்தல் அடிப்படையிலான வடிகட்டலைப் பயன்படுத்தி வரிசைகளைப் பிடிப்பதை விட மிக வேகமாக இருந்தது, மேலும் வடிகட்டப்பட்ட தரவு சட்டகத்திலிருந்து ஒரு நெடுவரிசையை மீட்டெடுப்பது அட்டவணைப்படுத்தல் தொடரியல் பயன்படுத்துவதை விட மிக வேகமாக இருந்தது.

பொருள் என்பதை கவனத்தில் கொள்ளவும் prev_snp_results திறவுகோலைக் கொண்டுள்ளது snps_in_bin. இது ஒரு குழுவில் (பின்) உள்ள அனைத்து தனித்துவமான SNP களின் வரிசையாகும், இது முந்தைய வினவலிலிருந்து உங்களிடம் ஏற்கனவே தரவு உள்ளதா என்பதை விரைவாகச் சரிபார்க்க அனுமதிக்கிறது. இந்தக் குறியீட்டைக் கொண்டு ஒரு குழுவில் (பின்) உள்ள அனைத்து SNP களையும் இது எளிதாக்குகிறது:

# Get bin-mates
snps_in_bin <- my_snp_results$snps_in_bin

for(current_snp in snps_in_bin){
  my_snp_results <- get_snp(current_snp, my_snp_results)
  # Do something with results 
}

Результаты

முன்பு நம்மால் அணுக முடியாத மாதிரிகள் மற்றும் காட்சிகளை இப்போது நாம் (தீவிரமாக இயக்கத் தொடங்கியுள்ளோம்). சிறந்த விஷயம் என்னவென்றால், எனது ஆய்வக சகாக்கள் எந்த சிக்கல்களையும் பற்றி சிந்திக்க வேண்டியதில்லை. அவர்கள் வேலை செய்யும் ஒரு செயல்பாடு உள்ளது.

தொகுப்பு அவர்களுக்கு விவரங்களைத் தவிர்த்தாலும், நான் டேட்டா வடிவமைப்பை எளிமையாக்க முயற்சித்தேன், நாளை நான் திடீரென்று காணாமல் போனால் அவர்கள் அதைக் கண்டுபிடிக்க முடியும்.

வேகம் குறிப்பிடத்தக்க அளவில் அதிகரித்துள்ளது. பொதுவாக செயல்பாட்டில் குறிப்பிடத்தக்க மரபணு துண்டுகளை ஸ்கேன் செய்கிறோம். முன்பு, எங்களால் இதைச் செய்ய முடியவில்லை (அது மிகவும் விலை உயர்ந்ததாக மாறியது), ஆனால் இப்போது, குழு (பின்) அமைப்பு மற்றும் தேக்ககத்திற்கு நன்றி, ஒரு SNP க்கான கோரிக்கை சராசரியாக 0,1 வினாடிகளுக்கும் குறைவாகவே ஆகும், மேலும் தரவு பயன்பாடு மிகவும் அதிகமாக உள்ளது. S3க்கான விலை நிலக்கடலையை விடக் குறைவு.

சமீபத்தில் எனது ஆய்வகத்திற்கான 25+ TB மூல மரபணு வகை தரவை மாற்றினேன். நான் தொடங்கும் போது, SNP ஐ வினவ, ஸ்பார்க்கைப் பயன்படுத்த 8 நிமிடம் ஆனது & $20 செலவாகும். AWK+ ஐப் பயன்படுத்திய பிறகு #rstats செயலாக்க, இப்போது ஒரு வினாடியில் 10வது பங்கிற்கும் குறைவாகவே ஆகும் மற்றும் $0.00001 செலவாகும். என்னுடைய தனிப்பட்ட #பெரிய தரவு வெற்றி. pic.twitter.com/ANOXVGrmkk

- நிக் ஸ்ட்ரேயர் (@NicholasStrayer) 30 மே, 2019

முடிவுக்கு

இந்த கட்டுரை ஒரு வழிகாட்டி அல்ல. தீர்வு தனிப்பட்டதாக மாறியது, நிச்சயமாக உகந்ததாக இல்லை. மாறாக, இது ஒரு பயணக் குறிப்பு. இதுபோன்ற முடிவுகள் தலையில் முழுமையாக உருவாகவில்லை என்பதை மற்றவர்கள் புரிந்து கொள்ள வேண்டும் என்று நான் விரும்புகிறேன், அவை சோதனை மற்றும் பிழையின் விளைவாகும். மேலும், நீங்கள் ஒரு தரவு விஞ்ஞானியைத் தேடுகிறீர்களானால், இந்தக் கருவிகளை திறம்பட பயன்படுத்த அனுபவம் தேவை என்பதையும், அனுபவத்திற்கு பணம் செலவாகும் என்பதையும் நினைவில் கொள்ளுங்கள். பணம் செலுத்தும் வழி என்னிடம் இருந்ததில் நான் மகிழ்ச்சியடைகிறேன், ஆனால் அதே வேலையை என்னை விட சிறப்பாக செய்யக்கூடிய பலருக்கு பணம் இல்லாததால் முயற்சி செய்ய கூட வாய்ப்பு கிடைக்காது.

பெரிய தரவுக் கருவிகள் பல்துறை சார்ந்தவை. உங்களுக்கு நேரம் இருந்தால், ஸ்மார்ட் டேட்டாவை சுத்தம் செய்தல், சேமிப்பகம் மற்றும் பிரித்தெடுத்தல் நுட்பங்களைப் பயன்படுத்தி, நீங்கள் நிச்சயமாக விரைவான தீர்வை எழுதலாம். இறுதியில் இது செலவு-பயன் பகுப்பாய்வுக்கு வருகிறது.

நான் கற்றுக்கொண்டது:

ஒரே நேரத்தில் 25 டிபியை அலசுவதற்கு மலிவான வழி இல்லை;
உங்கள் பார்க்வெட் கோப்புகளின் அளவு மற்றும் அவற்றின் அமைப்பில் கவனமாக இருங்கள்;
ஸ்பார்க்கில் உள்ள பகிர்வுகள் சமநிலையில் இருக்க வேண்டும்;
பொதுவாக, 2,5 மில்லியன் பகிர்வுகளை உருவாக்க முயற்சிக்காதீர்கள்;
ஸ்பார்க் அமைப்பது போல் வரிசைப்படுத்துவது இன்னும் கடினமாக உள்ளது;
சில நேரங்களில் சிறப்பு தரவுகளுக்கு சிறப்பு தீர்வுகள் தேவைப்படுகின்றன;
ஸ்பார்க் திரட்டுதல் வேகமானது, ஆனால் பகிர்வு இன்னும் விலை உயர்ந்தது;
அவர்கள் உங்களுக்கு அடிப்படைகளை கற்பிக்கும்போது தூங்க வேண்டாம், 1980 களில் யாராவது உங்கள் பிரச்சினையை ஏற்கனவே தீர்த்திருக்கலாம்;
gnu parallel - இது ஒரு மந்திர விஷயம், எல்லோரும் அதைப் பயன்படுத்த வேண்டும்;
ஸ்பார்க் சுருக்கப்படாத தரவை விரும்புகிறது மற்றும் பகிர்வுகளை இணைப்பதை விரும்பவில்லை;
எளிய பிரச்சனைகளை தீர்க்கும் போது தீப்பொறி அதிக மேல்நிலை உள்ளது;
AWK இன் துணை வரிசைகள் மிகவும் திறமையானவை;
நீங்கள் தொடர்பு கொள்ளலாம் stdin и stdout R ஸ்கிரிப்டில் இருந்து, எனவே அதை பைப்லைனில் பயன்படுத்தவும்;
ஸ்மார்ட் பாதை செயலாக்கத்திற்கு நன்றி, S3 பல கோப்புகளை செயலாக்க முடியும்;
நேரத்தை வீணடிப்பதற்கான முக்கிய காரணம், உங்கள் சேமிப்பக முறையை முன்கூட்டியே மேம்படுத்துவதாகும்;
பணிகளை கைமுறையாக மேம்படுத்த முயற்சிக்காதீர்கள், கணினி அதைச் செய்யட்டும்;
பயன்பாட்டின் எளிமை மற்றும் நெகிழ்வுத்தன்மைக்காக API எளிமையாக இருக்க வேண்டும்;
உங்கள் தரவு நன்கு தயாரிக்கப்பட்டிருந்தால், தற்காலிக சேமிப்பு எளிதாக இருக்கும்!

ஆதாரம்: www.habr.com

AWK மற்றும் R ஐப் பயன்படுத்தி 25TB பாகுபடுத்துகிறது