बैश स्क्रिप्ट का उपयोग करके मशीन लर्निंग मॉडल बनाएँ

मशीन लर्निंग उन चीजों की भविष्यवाणी या पूर्वानुमान के लिए एक शक्तिशाली कंप्यूटिंग क्षमता है जिन्हें पारंपरिक एल्गोरिदम चुनौतीपूर्ण पाते हैं। मशीन लर्निंग यात्रा डेटा एकत्र करने और तैयार करने—इसका बहुत सारा—से शुरू होती है, फिर उस डेटा के आधार पर गणितीय मॉडल बनाती है। जबकि इन कार्यों के लिए कई उपकरणों का उपयोग किया जा सकता है, मुझे शेल का उपयोग करना पसंद है।

एक शेल एक परिभाषित भाषा का उपयोग करके संचालन करने के लिए एक इंटरफेस है। इस भाषा को इंटरैक्टिव रूप से या स्क्रिप्टेड रूप से लागू किया जा सकता है। शेल की अवधारणा 1970 के दशक में यूनिक्स ऑपरेटिंग सिस्टम में पेश की गई थी। कुछ सबसे लोकप्रिय शेल में बैश, tcsh, और Zsh शामिल हैं। वे लिनक्स, macOS, और विंडोज सहित सभी ऑपरेटिंग सिस्टम के लिए उपलब्ध हैं, जो उन्हें उच्च पोर्टेबिलिटी देता है। इस अभ्यास के लिए, मैं बैश का उपयोग करूँगा।

यह लेख डेटा संग्रह और डेटा तैयारी के लिए शेल का उपयोग करने का परिचय है। चाहे आप कुशल उपकरणों की तलाश में डेटा वैज्ञानिक हों या मशीन लर्निंग के लिए अपने कौशल का उपयोग करने वाले शेल विशेषज्ञ हों, मुझे आशा है कि आप यहाँ मूल्यवान जानकारी पाएंगे।

इस लेख में उदाहरण समस्या US राज्यों के लिए तापमान का पूर्वानुमान लगाने के लिए एक मशीन लर्निंग मॉडल बनाना है। यह निम्नलिखित डेटा संग्रह और डेटा तैयारी चरणों को करने के लिए शेल कमांड और स्क्रिप्ट का उपयोग करता है:

1. डेटा डाउनलोड करें
2. आवश्यक फ़ील्ड निकालें
3. डेटा एग्रीगेट करें
4. टाइम सीरीज़ बनाएं
5. ट्रेन, टेस्ट, और वैलिडेट डेटा सेट बनाएं

आप पूछ रहे होंगे कि आपको यह शेल के साथ क्यों करना चाहिए, जब आप यह सब मशीन लर्निंग प्रोग्रामिंग भाषा जैसे पायथन में कर सकते हैं। यह एक अच्छा सवाल है। यदि डेटा प्रोसेसिंग एक आसान, अनुकूल, समृद्ध तकनीक जैसे शेल के साथ की जाती है, तो एक डेटा वैज्ञानिक केवल मशीन लर्निंग मॉडलिंग पर ध्यान केंद्रित करता है न कि भाषा के विवरण पर।

पूर्वापेक्षाएँ

सबसे पहले, आपके पास एक शेल इंटरप्रेटर इंस्टॉल होना चाहिए। यदि आप लिनक्स या macOS का उपयोग करते हैं, तो यह पहले से ही इंस्टॉल होगा, और आप इससे पहले से ही परिचित हो सकते हैं। यदि आप विंडोज का उपयोग करते हैं, तो MinGW या Cygwin आज़माएँ।

अधिक जानकारी के लिए, देखें:

• opensource.com पर बैश ट्यूटोरियल
• बोर्न शेल के निर्माता स्टीव पार्कर द्वारा आधिकारिक शेल स्क्रिप्टिंग ट्यूटोरियल
• लिनक्स डॉक्यूमेंटेशन प्रोजेक्ट द्वारा शुरुआती के लिए बैश गाइड
• यदि आपको किसी विशिष्ट कमांड के साथ मदद की आवश्यकता है, तो शेल में <commandname> --help टाइप करें; उदाहरण के लिए: ls --help।

शुरू करें

अब जब आपका शेल सेट हो गया है, तो आप मशीन लर्निंग तापमान-भविष्यवाणी समस्या के लिए डेटा तैयार करना शुरू कर सकते हैं।

1. डेटा डाउनलोड करें

इस ट्यूटोरियल के लिए डेटा US नेशनल ओशनिक एंड एटमॉस्फेरिक एडमिनिस्ट्रेशन (NOAA) से आता है। आप अपने मॉडल को प्रशिक्षित करने के लिए पिछले 10 पूर्ण वर्षों के डेटा का उपयोग करेंगे। डेटा स्रोत https://www1.ncdc.noaa.gov/pub/data/ghcn/daily/by_year/ पर है, और डेटा .csv फॉर्मेट में है और gzipped है।

शेल स्क्रिप्ट का उपयोग करके डेटा डाउनलोड और अनज़िप करें। अपना पसंदीदा टेक्स्ट एडिटर उपयोग करके download.sh नामक एक फाइल बनाएं और नीचे दिए गए कोड को पेस्ट करें। कोड में टिप्पणियां बताती हैं कि कमांड क्या करते हैं:

#!/bin/sh
# इसे हैशबैंग कहा जाता है। यह इस फाइल को चलाने के लिए उपयोग किए जाने वाले एक्जीक्यूटर की पहचान करता है।
# इस मामले में, स्क्रिप्ट को शेल द्वारा ही निष्पादित किया जाता है।
# यदि निर्दिष्ट नहीं है, तो स्क्रिप्ट को निष्पादित करने के लिए एक प्रोग्राम निर्दिष्ट किया जाना चाहिए।
# हैशबैंग के साथ: ./download.sh; बिना हैशबैंग: sh ./download.sh;

FROM_YEAR=2010
TO_YEAR=2019

year=$FROM_YEAR
# FROM_YEAR=2010 से TO_YEAR=2019 तक एक-एक करके सभी वर्षों के लिए
while [ $year -le $TO_YEAR ]
do
# वर्तमान में डाउनलोड किए जा रहे वर्ष को दिखाएँ
echo $year
# डाउनलोड
wget https://www1.ncdc.noaa.gov/pub/data/ghcn/daily/by_year/${year}.csv.gz
# अनज़िप
gzip -d ${year}.csv.gz
# इंक्रीमेंट करके अगले वर्ष पर जाएँ
year=$(($year+1))
done

नोट्स:

• यदि आप प्रॉक्सी सर्वर के पीछे हैं, तो मार्क ग्रेनन के हाउ-टू से परामर्श करें, और उपयोग करें:
  

  export http_proxy=https://username:password@proxyhost:port/
  export https_proxy=https://username:password@proxyhost:port/

• सुनिश्चित करें कि सभी मानक कमांड पहले से ही आपके PATH में हैं (जैसे /bin या /usr/bin)। यदि नहीं, तो अपना PATH सेट करें।
• Wget कमांड लाइन से वेब सर्वर से कनेक्ट करने के लिए एक उपयोगिता है। यदि Wget आपके सिस्टम पर इंस्टॉल नहीं है, तो इसे डाउनलोड करें।
• सुनिश्चित करें कि आपके पास gzip है, संपीड़न और डीकंप्रेशन के लिए उपयोग की जाने वाली उपयोगिता।

इस स्क्रिप्ट को चलाकर 10 वर्षों के डेटा को डाउनलोड, निकालें, और CSV के रूप में उपलब्ध कराएँ:

$ ./download.sh
2010
--2020-10-30 19:10:47-- https://www1.ncdc.noaa.gov/pub/data/ghcn/daily/by_year/2010.csv.gz
Resolving www1.ncdc.noaa.gov (www1.ncdc.noaa.gov)... 205.167.25.171, 205.167.25.172, 205.167.25.178, ...
Connecting to www1.ncdc.noaa.gov (www1.ncdc.noaa.gov)|205.167.25.171|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 170466817 (163M) [application/gzip]
Saving to: '2010.csv.gz'

0K .......... .......... .......... .......... .......... 0% 69.4K 39m57s
50K .......... .......... .......... .......... .......... 0% 202K 26m49s
100K .......... .......... .......... .......... .......... 0% 1.08M 18m42s
...

ls कमांड फोल्डर की सामग्री को सूचीबद्ध करता है। ls 20*.csv का उपयोग करके 20 से शुरू होने वाले और .csv पर समाप्त होने वाले नामों वाली सभी फाइलों को सूचीबद्ध करें।

$ ls 20*.csv
2010.csv 2011.csv 2012.csv 2013.csv 2014.csv 2015.csv 2016.csv 2017.csv 2018.csv 2019.csv

2. औसत तापमान निकालें

US क्षेत्रों के लिए CSVs से TAVG (औसत तापमान) डेटा निकालें:

extract_tavg_us.sh

#!/bin/sh

# प्रत्येक फाइल के लिए जिसका नाम "20" से शुरू होता है और ".csv" पर समाप्त होता है
for csv_file in `ls 20*.csv`
do
# संदेश जो कहता है कि फाइल नाम $csv_file को फाइल TAVG_US_$csv_file में निकाला गया है
# उदाहरण: 2010.csv निकाला गया TAVG_US_2010.csv
echo "$csv_file -> TAVG_US_$csv_file"
# grep "TAVG" $csv_file: फाइल में "TAVG" टेक्स्ट वाली लाइनें निकालें
# |: पाइप
# grep "^US": उनमें से "US" टेक्स्ट से शुरू होने वाली लाइनें निकालें
# > TAVG_US_$csv_file: निकाली गई लाइनों को फाइल TAVG_US_$csv_file में सहेजें
grep "TAVG" $csv_file | grep "^US" > TAVG_US_$csv_file
done

यह स्क्रिप्ट:

$ ./extract_tavg_us.sh
2010.csv -> TAVG_US_2010.csv
...
2019.csv -> TAVG_US_2019.csv

ये फाइलें बनाती है:

$ ls TAVG_US*.csv
TAVG_US_2010.csv TAVG_US_2011.csv TAVG_US_2012.csv TAVG_US_2013.csv
TAVG_US_2014.csv TAVG_US_2015.csv TAVG_US_2016.csv TAVG_US_2017.csv
TAVG_US_2018.csv TAVG_US_2019.csv

TAVG_US_2010.csv के लिए पहली कुछ लाइनें यहाँ हैं:

$ head TAVG_US_2010.csv
USR0000AALC,20100101,TAVG,-220,,,U,
USR0000AALP,20100101,TAVG,-9,,,U,
USR0000ABAN,20100101,TAVG,12,,,U,
USR0000ABCA,20100101,TAVG,16,,,U,
USR0000ABCK,20100101,TAVG,-309,,,U,
USR0000ABER,20100101,TAVG,-81,,,U,
USR0000ABEV,20100101,TAVG,-360,,,U,
USR0000ABEN,20100101,TAVG,-224,,,U,
USR0000ABNS,20100101,TAVG,89,,,U,
USR0000ABLA,20100101,TAVG,59,,,U,

head कमांड एक फाइल की पहली कई लाइनें (डिफ़ॉल्ट रूप से, 10 लाइनें) प्रदर्शित करने के लिए एक उपयोगिता है।

डेटा में आपकी आवश्यकता से अधिक जानकारी है। कॉलम 3 को हटाकर (चूंकि सभी डेटा औसत तापमान है) और कॉलम 5 को आगे हटाकर कॉलम की संख्या सीमित करें। दूसरे शब्दों में, कॉलम 1 (जलवायु स्टेशन), 2 (तारीख), और 4 (रिकॉर्ड किया गया तापमान) रखें।

key_columns.sh

#!/bin/sh

# प्रत्येक फाइल के लिए जिसका नाम "TAVG_US_" से शुरू होता है और ".csv" पर समाप्त होता है
for csv_file in `ls TAVG_US_*.csv`
do
echo "Exractiing columns $csv_file"
# cat $csv_file: 'cat' फाइलों को कॉनकैटेनेट करने के लिए है - यहाँ एक वर्ष की csv फाइल दिखाने के लिए उपयोग किया जाता है
# |: पाइप
# cut -d',' -f1,2,4: , डिलीमीटर के साथ कॉलम 1,2,4 काटें
# > $csv_file.cut: अस्थायी फाइल में सहेजें
| > $csv_file.cut: 
cat $csv_file | cut -d',' -f1,2,4 > $csv_file.cut
# mv $csv_file.cut $csv_file: अस्थायी फाइल का नाम बदलकर मूल फाइल करें
mv $csv_file.cut $csv_file
# फाइल प्रोसेस हो गई और उसी में वापस सहेजी गई
# ऐसा करने के अन्य तरीके हैं
# मध्यवर्ती फाइल का उपयोग करना सबसे विश्वसनीय विधि है।
done

स्क्रिप्ट चलाएँ:

$ ./key_columns.sh
Extracting columns TAVG_US_2010.csv
...
Extracting columns TAVG_US_2019.csv

TAVG_US_2010.csv की पहली कुछ लाइनें अनावश्यक डेटा हटाने के बाद:

$ head TAVG_US_2010.csv
USR0000AALC,20100101,-220
USR0000AALP,20100101,-9
USR0000ABAN,20100101,12
USR0000ABCA,20100101,16
USR0000ABCK,20100101,-309
USR0000ABER,20100101,-81
USR0000ABEV,20100101,-360
USR0000ABEN,20100101,-224
USR0000ABNS,20100101,89
USR0000ABLA,20100101,59

तारीखें स्ट्रिंग फॉर्म (YMD) में हैं। अपने मॉडल को सही ढंग से प्रशिक्षित करने के लिए, आपके एल्गोरिदम को कॉमा-सेपरेटेड Y,M,D फॉर्म में डेट फील्ड को पहचानने की आवश्यकता है (उदाहरण के लिए, 20100101 बन जाता है 2010,01,01)। आप उन्हें sed उपयोगिता से परिवर्तित कर सकते हैं।

date_format.sh

for csv_file in `ls TAVG_*.csv`
do
echo Date formatting $csv_file
# यह वर्ष के बाद , डालता है
sed -i 's/,..../&,/' $csv_file
# यह महीने के बाद , डालता है
sed -i 's/,....,../&,/' $csv_file
done

स्क्रिप्ट चलाएँ:

$ ./date_format.sh
Date formatting TAVG_US_2010.csv
...
Date formatting TAVG_US_2019.csv

TAVG_US_2010.csv की पहली कुछ लाइनें कॉमा-सेपरेटेड डेट फॉर्मेट के साथ:

$ head TAVG_US_2010.csv
USR0000AALC,2010,01,01,-220
USR0000AALP,2010,01,01,-9
USR0000ABAN,2010,01,01,12
USR0000ABCA,2010,01,01,16
USR0000ABCK,2010,01,01,-309
USR0000ABER,2010,01,01,-81
USR0000ABEV,2010,01,01,-360
USR0000ABEN,2010,01,01,-224
USR0000ABNS,2010,01,01,89
USR0000ABLA,2010,01,01,59

3. राज्यों के औसत तापमान डेटा को एग्रीगेट करें

मौसम डेटा US शहरों में स्थित जलवायु स्टेशनों से आता है, लेकिन आप पूरे राज्यों के तापमान का पूर्वानुमान लगाना चाहते हैं। जलवायु-स्टेशन डेटा को राज्य डेटा में बदलने के लिए, पहले जलवायु स्टेशनों को उनके राज्यों से मैप करें।

wget का उपयोग करके जलवायु स्टेशनों की सूची डाउनलोड करें:

$ wget ftp://ftp.ncdc.noaa.gov/pub/data/ghcn/daily/ghcnd-stations.txt

US स्टेशनों को grep उपयोगिता का उपयोग करके US लिस्टिंग खोजकर निकालें। निम्न कमांड उन लाइनों को खोजता है जो टेक्स्ट "US से शुरू होती हैं। > एक रीडायरेक्शन है जो आउटपुट को एक फाइल में लिखता है—इस मामले में, us_stations.txt नामक फाइल में:

$ grep "^US" ghcnd-stations.txt > us_stations.txt

यह फाइल प्रिटी प्रिंट के लिए बनाई गई थी, इसलिए कॉलम सेपरेटर असंगत हैं:

$ head us_stations.txt
US009052008 43.7333 -96.6333 482.0 SD SIOUX FALLS (ENVIRON. CANADA)
US10RMHS145 40.5268 -105.1113 1569.1 CO RMHS 1.6 SSW
US10adam001 40.5680 -98.5069 598.0 NE JUNIATA 1.5 S
...

cat का उपयोग करके फाइल प्रिंट करके, tr का उपयोग करके रिपीट को स्क्वीज़ करके और अस्थायी फाइल में आउटपुट करके, और अस्थायी फाइल का नाम वापस मूल पर रखकर—सभी एक लाइन में—उन्हें सुसंगत बनाएं:

$ cat us_stations.txt | tr -s ' ' > us_stations.txt.tmp; cp us_stations.txt.tmp us_stations.txt;

कमांड के आउटपुट की पहली लाइनें:

$ head us_stations.txt
US009052008 43.7333 -96.6333 482.0 SD SIOUX FALLS (ENVIRON. CANADA)
US10RMHS145 40.5268 -105.1113 1569.1 CO RMHS 1.6 SSW
US10adam001 40.5680 -98.5069 598.0 NE JUNIATA 1.5 S
...

इसमें बहुत सारी जानकारी है—GPS निर्देशांक और ऐसा—लेकिन आपको केवल स्टेशन कोड और राज्य की आवश्यकता है। cut का उपयोग करें:

$ cut -d' ' -f1,5 us_stations.txt > us_stations.txt.tmp; mv us_stations.txt.tmp us_stations.txt;

कमांड के आउटपुट की पहली लाइनें:

$ head us_stations.txt
US009052008 SD
US10RMHS145 CO
US10adam001 NE
US10adam002 NE
...

$ sed -i s/' '/,/g us_stations.txt

कमांड के आउटपुट की पहली लाइनें:

$ head us_stations.txt
US009052008,SD
US10RMHS145,CO
US10adam001,NE
US10adam002,NE
...

हालांकि आपने इन कार्यों के लिए कई कमांड का उपयोग किया, लेकिन सभी चरणों को एक रन में करना संभव है। इसे स्वयं आज़माएँ।

अब, AWK का उपयोग करके स्टेशन कोड को उनके राज्य स्थानों से बदलें, जो बड़े डेटा प्रोसेसिंग के लिए कार्यात्मक रूप से उच्च प्रदर्शन वाला है।

station_to_state_data.sh

#!/bin/sh

for DATA_FILE in `ls TAVG_US_*.csv`

do
echo ${DATA_FILE}
awk -v FILE=$DATA_FILE -F, '
{
state_day_sum[$1 "," $2 "," $3 "," $4] = state_day_sum[$1 "," $2 "," $3 "," $4] + $5
state_day_num[$1 "," $2 "," $3 "," $4] = state_day_num[$1 "," $2 "," $3 "," $4] + 1
}
END {
for (state_day_key in state_day_sum) {
print state_day_key "," state_day_sum[state_day_key]/state_day_num[state_day_key]
}
}
' OFS=, $DATA_FILE > STATE_DAY_${DATA_FILE}.tmp
sort -k1 -k2 -k3 -k4 < STATE_DAY_${DATA_FILE}.tmp > STATE_DAY_$DATA_FILE
rm -f STATE_DAY_${DATA_FILE}.tmp
done

यहाँ इन पैरामीटर का अर्थ है:

स्टेशन कोड वाली CSV:

$ head TAVG_US_2010.csv
USR0000AALC,2010,01,01,-220
USR0000AALP,2010,01,01,-9
USR0000ABAN,2010,01,01,12
USR0000ABCA,2010,01,01,16
USR0000ABCK,2010,01,01,-309
USR0000ABER,2010,01,01,-81
USR0000ABEV,2010,01,01,-360
USR0000ABEN,2010,01,01,-224
USR0000ABNS,2010,01,01,89
USR0000ABLA,2010,01,01,59

कमांड चलाएँ:

$ ./station_to_state_data.sh
TAVG_US_2010.csv
...
TAVG_US_2019.csv

स्टेशन अब राज्यों से मैप हैं:

$ head TAVG_US_2010.csv
AK,2010,01,01,-220
AZ,2010,01,01,-9
AL,2010,01,01,12
AK,2010,01,01,16
AK,2010,01,01,-309
AK,2010,01,01,-81
AK,2010,01,01,-360
AK,2010,01,01,-224
AZ,2010,01,01,59
AK,2010,01,01,-68

प्रत्येक राज्य में प्रत्येक दिन के लिए कई तापमान रीडिंग हैं, इसलिए आपको प्रत्येक राज्य की रीडिंग के औसत की गणना करने की आवश्यकता है। टेक्स्ट प्रोसेसिंग के लिए AWK का उपयोग करें, अंतिम परिणामों को तार्किक क्रम में सुनिश्चित करने के लिए sort, और प्रोसेसिंग के बाद अस्थायी फाइल को हटाने के लिए rm।

station_to_state_data.sh

PATTERN_FILE=us_stations.txt

for DATA_FILE in `ls TAVG_US_*.csv`
do
echo ${DATA_FILE}

awk -F, \
'FNR==NR { x[$1]=$2; next; } { $1=x[$1]; print $0 }' \
OFS=, \
${PATTERN_FILE} ${DATA_FILE} > ${DATA_FILE}.tmp

mv ${DATA_FILE}.tmp ${DATA_FILE}
done

यहाँ AWK पैरामीटर का अर्थ है:

स्क्रिप्ट चलाएँ:

$ ./TAVG_avg.sh
TAVG_US_2010.csv
TAVG_US_2011.csv
TAVG_US_2012.csv
TAVG_US_2013.csv
TAVG_US_2014.csv
TAVG_US_2015.csv
TAVG_US_2016.csv
TAVG_US_2017.csv
TAVG_US_2018.csv
TAVG_US_2019.csv

ये फाइलें बनाई गई हैं:

$ ls STATE_DAY_TAVG_US_20*.csv
STATE_DAY_TAVG_US_2010.csv STATE_DAY_TAVG_US_2015.csv
STATE_DAY_TAVG_US_2011.csv STATE_DAY_TAVG_US_2016.csv
STATE_DAY_TAVG_US_2012.csv STATE_DAY_TAVG_US_2017.csv
STATE_DAY_TAVG_US_2013.csv STATE_DAY_TAVG_US_2018.csv
STATE_DAY_TAVG_US_2014.csv STATE_DAY_TAVG_US_2019.csv

सभी राज्यों के लिए एक वर्ष का डेटा देखें (less आउटपुट को एक पेज पर देखने के लिए एक उपयोगिता है):

$ less STATE_DAY_TAVG_US_2010.csv
AK,2010,01,01,-181.934
...
AK,2010,01,31,-101.068
AK,2010,02,01,-107.11
...
AK,2010,02,28,-138.834
...
WY,2010,01,01,-43.5625
...
WY,2010,12,31,-215.583

सभी डेटा फाइलों को एक में मर्ज करें:

$ cat STATE_DAY_TAVG_US_20*.csv > TAVG_US_2010-2019.csv

अब आपके पास एक फाइल है, सभी राज्यों के लिए, सभी वर्षों के लिए:

$ cat TAVG_US_2010-2019.csv
AK,2010,01,01,-181.934
...
WY,2018,12,31,-167.421
AK,2019,01,01,-32.3386
...
WY,2019,12,30,-131.028
WY,2019,12,31,-79.8704

4. टाइम-सीरीज़ डेटा बनाएं

इस तरह की समस्या को टाइम-सीरीज़ मॉडल जैसे लॉन्ग शॉर्ट-टर्म मेमोरी (LSTM) के साथ उचित रूप से संबोधित किया जाता है, जो एक रिकरिंग न्यूरल नेटवर्क (RNN) है। यह इनपुट डेटा टाइम स्लाइस में व्यवस्थित है; 20 दिनों को एक स्लाइस मानें।

यह एक वन-टाइम स्लाइस है (जैसे STATE_DAY_TAVG_US_2010.csv में):

X (इनपुट – 20 सप्ताह):
AK,2010,01,01,-181.934
AK,2010,01,02,-199.531
...
AK,2010,01,20,-157.273

y (21वां सप्ताह, इन 20 सप्ताह के लिए भविष्यवाणी):
AK,2010,01,21,-165.31

इस टाइम स्लाइस को इस रूप में दर्शाया गया है (तापमान मान जहां पहले 20 सप्ताह X हैं, और 21 y है):

AK, -181.934,-199.531, ... ,
-157.273,-165.3

स्लाइस टाइम-सन्निकट हैं। उदाहरण के लिए, 2010 का अंत 2011 में जारी रहता है:

AK,2010,12,22,-209.92
...
AK,2010,12,31,-79.8523
AK,2011,01,01,-59.5658
...
AK,2011,01,10,-100.623

जिसके परिणामस्वरूप भविष्यवाणी होती है:

AK,2011,01,11,-106.851

इस टाइम स्लाइस को इस रूप में लिया जाता है:

AK, -209.92, ... ,-79.8523,-59.5658, ... ,-100.623,-106.851

और इसी तरह, सभी राज्यों, वर्षों, महीनों, और तारीखों के लिए। अधिक व्याख्या के लिए, टाइम-सीरीज़ पूर्वानुमान पर इस ट्यूटोरियल को देखें।

टाइम स्लाइस बनाने के लिए एक स्क्रिप्ट लिखें:

timeslices.sh

#!/bin/sh

TIME_SLICE_PERIOD=20

file=TAVG_US_2010-2019.csv

# फाइल में प्रत्येक राज्य के लिए
for state in `cut -d',' -f1 $file | sort | uniq`
do
# राज्य के लिए सभी तापमान मान प्राप्त करें
state_tavgs=`grep $state $file | cut -d',' -f5`
# इसका परिणाम कितने टाइम स्लाइस में होगा?
# रिकॉर्ड किए गए तापमान की संख्या घटा एक टाइमस्लाइस का आकार
num_slices=`echo $state_tavgs | wc -w`
num_slices=$((${num_slices} - ${TIME_SLICE_PERIOD}))
# इनिशियलाइज़ करें
slice_start=1; num_slice=0;
# प्रत्येक टाइमस्लाइस के लिए
while [ $num_slice -lt $num_slices ]
do
# एक टाइमस्लाइस slice_start से slice_end तक है
slice_end=$(($slice_start + $TIME_SLICE_PERIOD - 1))
# X (1-20)
sliceX="$slice_start-$slice_end"
# y (21)
slicey=$(($slice_end + 1))
# राज्य और टाइमस्लाइस तापमान मान प्रिंट करें (कॉलम 1-20 और 21)
echo $state `echo $state_tavgs | cut -d' ' -f$sliceX,$slicey`
# इंक्रीमेंट
slice_start=$(($slice_start + 1)); num_slice=$(($num_slice + 1));
done
done

स्क्रिप्ट चलाएँ। यह कॉलम सेपरेटर के रूप में स्पेस का उपयोग करता है; उन्हें sed के साथ कॉमा बनाएं:

$ ./timeslices.sh > TIMESLICE_TAVG_US_2010-2019.csv; sed -i s/' '/,/g TIME_VARIANT_TAVG_US_2010-2019.csv

आउटपुट .csv की पहली कुछ लाइनें और अंतिम कुछ लाइनें यहाँ हैं:

$ head -3 TIME_VARIANT_TAVG_US_2009-2019.csv
AK,-271.271,-290.057,-300.324,-277.603,-270.36,-293.152,-292.829,-270.413,-256.674,-241.546,-217.757,-158.379,-102.585,-24.9517,-1.7973,15.9597,-5.78231,-33.932,-44.7655,-92.5694,-123.338
AK,-290.057,-300.324,-277.603,-270.36,-293.152,-292.829,-270.413,-256.674,-241.546,-217.757,-158.379,-102.585,-24.9517,-1.7973,15.9597,-5.78231,-33.932,-44.7655,-92.5694,-123.338,-130.829
AK,-300.324,-277.603,-270.36,-293.152,-292.829,-270.413,-256.674,-241.546,-217.757,-158.379,-102.585,-24.9517,-1.7973,15.9597,-5.78231,-33.932,-44.7655,-92.5694,-123.338,-130.829,-123.979

$ tail -3 TIME_VARIANT_TAVG_US_2009-2019.csv
WY,-76.9167,-66.2315,-45.1944,-27.75,-55.3426,-81.5556,-124.769,-137.556,-90.213,-54.1389,-55.9907,-30.9167,-9.59813,7.86916,-1.09259,-13.9722,-47.5648,-83.5234,-98.2963,-124.694,-142.898
WY,-66.2315,-45.1944,-27.75,-55.3426,-81.5556,-124.769,-137.556,-90.213,-54.1389,-55.9907,-30.9167,-9.59813,7.86916,-1.09259,-13.9722,-47.5648,-83.5234,-98.2963,-124.694,-142.898,-131.028
WY,-45.1944,-27.75,-55.3426,-81.5556,-124.769,-137.556,-90.213,-54.1389,-55.9907,-30.9167,-9.59813,7.86916,-1.09259,-13.9722,-47.5648,-83.5234,-98.2963,-124.694,-142.898,-131.028,-79.8704

हालांकि यह काम करता है, यह बहुत प्रदर्शनकारी नहीं है। इसे अनुकूलित किया जा सकता है—क्या आप कोशिश कर सकते हैं? नीचे टिप्पणियों में रिपोर्ट करें कि आपने यह कैसे किया।

5. ट्रेन, टेस्ट, और वैलिडेट डेटा सेट बनाएं

डेटा को ट्रेन, टेस्ट, और वैलिडेट सेट में विभाजित करें।

data_sets.sh

#!/bin/sh

GEN=SEQ
# GEN=RAN

FILE=TIMESLICE_TAVG_US_2010-2019.csv

TRAIN_SET_PERCENT=70
TEST_SET_PERCENT=20
VAL_SET_PERCENT=$(( 100 - $TRAIN_SET_PERCENT - $TEST_SET_PERCENT ))

TRAIN_DATA=TRAIN_$FILE
TEST_DATA=TEST_$FILE
VAL_DATA=VAL_$FILE

> $TRAIN_DATA
> $TEST_DATA
> $VAL_DATA

for state in `cut -d',' -f1 $FILE | sort | uniq`
do
NUM_STATE_DATA=`grep "$state" $FILE | wc -l`
echo "$state: $NUM_STATE_DATA"

TRAIN_NUM_DATA=$(( $NUM_STATE_DATA * $TRAIN_SET_PERCENT / 100 ))
TEST_NUM_DATA=$(( $NUM_STATE_DATA * $TEST_SET_PERCENT / 100 ))
VAL_NUM_DATA=$(( $NUM_STATE_DATA - $TRAIN_NUM_DATA - $TEST_NUM_DATA ))

if [ $GEN == "SEQ" ]
then
echo "Sequential"
STATE_DATA=`grep $state $FILE`
elif [ $GEN == "RAN" ]
then
echo "Randomized"
STATE_DATA=`grep $state $FILE | shuf`
else
echo "Unknown data gen type: " $GEN
exit 1
fi

# ट्रेन सेट
per=$TRAIN_SET_PERCENT
num=$TRAIN_NUM_DATA; from=1; to=$(($from + $num - 1));
echo Train set: $per% $num from=$from to=$to
echo "$STATE_DATA" | head -$to >> $TRAIN_DATA

# टेस्ट सेट
per=$TEST_SET_PERCENT
num=$TEST_NUM_DATA; from=$(($to + 1)); to=$(($from + $num - 1));
echo Test set: $per% $num from=$from to=$to
echo "$STATE_DATA" | head -$to | tail -$num >> $TEST_DATA

# वैलिडेट सेट
per=$VAL_SET_PERCENT
num=$VAL_NUM_DATA; from=$(($to + 1)); to=$NUM_STATE_DATA;
echo Validate set: $per% $num from=$from to=$to
echo "$STATE_DATA" | tail -$num >> $VAL_DATA

echo
done

यह डेटा सेट उत्पन्न करता है जो GEN=SEQ या GEN=RAN को स्क्रिप्ट में सेट करके क्रमिक या यादृच्छिक हो सकते हैं, और आप shuf के साथ डेटा को शफ़ल कर सकते हैं।

स्क्रिप्ट चलाएँ:

$ ./data_sets.sh
AK: 3652
Sequential
Train set: 70% 2556 from=1 to=2556
Test set: 20% 730 from=2557 to=3286
Validate set: 10% 366 from=3287 to=3652

...

WY: 3352
Sequential
Train set: 70% 2346 from=1 to=2346
Test set: 20% 670 from=2347 to=3016
Validate set: 10% 336 from=3017 to=3352

ये डेटा फाइलें बनाने के लिए:

$ ls *_TIMESLICE_TAVG_US_2010-2019.csv
TEST_TIMESLICE_TAVG_US_2010-2019.csv VAL_TIMESLICE_TAVG_US_2010-2019.csv
TRAIN_TIMESLICE_TAVG_US_2010-2019.csv

शेल के साथ डेटा प्रोसेसिंग

जब आपको अपने अगले मशीन लर्निंग प्रोजेक्ट के लिए भारी मात्रा में डेटा प्रोसेस करने की आवश्यकता हो, तो शेल कमांड और स्क्रिप्ट के बारे में सोचें। यह सिद्ध है और उपयोग के लिए तैयार है, जिसमें आपका मार्गदर्शन और मदद करने के लिए अनुकूल समुदाय हैं।

यह लेख डेटा प्रोसेसिंग के लिए एक शेल का परिचय देता है, और स्क्रिप्ट अवसरों को प्रदर्शित करती हैं। बहुत कुछ संभव है। क्या आप इसे आगे ले जाना चाहते हैं? नीचे टिप्पणियों में हमें बताएं।