Bash . के साथ मशीन लर्निंग मॉडल बनाएं

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

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

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

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

डेटा डाउनलोड करें
आवश्यक फ़ील्ड निकालें
कुल डेटा
समय श्रृंखला बनाएं
ट्रेन बनाएं, परीक्षण करें और डेटा सेट सत्यापित करें

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

आवश्यकताएं

सबसे पहले, आपको एक शेल दुभाषिया स्थापित करने की आवश्यकता है। यदि आप Linux या macOS का उपयोग करते हैं, तो यह पहले से ही स्थापित होगा, और आप पहले से ही इससे परिचित हो सकते हैं। यदि आप Windows का उपयोग करते हैं, तो MinGW या Cygwin आज़माएं।

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

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

आरंभ करें

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

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

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

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

#!/bin/sh

# This is called hashbang. It identifies the executor used to run this file.

# In this case, the script is executed by shell itself.

# If not specified, a program to execute the script must be specified. 

# With hashbang: ./download.sh;  Without hashbang: sh ./download.sh;



FROM_YEAR=2010

TO_YEAR=2019



year=$FROM_YEAR

# For all years one by one starting from FROM_YEAR=2010 upto TO_YEAR=2019

while [ $year -le $TO_YEAR ]

do

    # show the year being downloaded now

    echo $year

    # Download

    wget https://www1.ncdc.noaa.gov/pub/data/ghcn/daily/by_year/${year}.csv.gz

    # Unzip

    gzip -d ${year}.csv.gz

    # Move to next year by incrementing

    year=$(($year+1))

done

नोट:

यदि आप प्रॉक्सी सर्वर के पीछे हैं, तो मार्क ग्रेनन के हाउ-टू से परामर्श लें और इसका उपयोग करें:
```
export http_proxy=https://username:password@proxyhost:port/

export https_proxy=https://username:password@proxyhost:port/
```
सुनिश्चित करें कि सभी मानक आदेश पहले से ही आपके PATH में हैं (जैसे /bin या /usr/bin ) यदि नहीं, तो अपना पथ सेट करें।
Wget कमांड लाइन से वेब सर्वर से कनेक्ट करने के लिए एक उपयोगिता है। यदि आपके सिस्टम पर Wget स्थापित नहीं है, तो इसे डाउनलोड करें।
सुनिश्चित करें कि आपके पास gzip है, जो संपीड़न और डीकंप्रेसन के लिए उपयोग की जाने वाली उपयोगिता है।

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

$ ./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 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. औसत तापमान निकालें

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

extract_tavg_us.sh

#!/bin/sh



# For each file with name that starts with "20" and ens with ".csv"

for csv_file in `ls 20*.csv`

do

    # Message that says file name $csv_file is extracted to file TAVG_US_$csv_file

    # Example: 2010.csv extracted to TAVG_US_2010.csv

    echo "$csv_file -> TAVG_US_$csv_file"

    # grep "TAVG" $csv_file: Extract lines in file with text "TAVG"

    # |: pipe

    # grep "^US": From those extract lines that begin with text "US"

    # > TAVG_US_$csv_file: Save xtracted lines to 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,

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

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

key_columns.sh

#!/bin/sh



# For each file with name that starts with "TAVG_US_" and ens with ".csv"

for csv_file in `ls TAVG_US_*.csv`

do

    echo "Exractiing columns $csv_file"

    # cat $csv_file: 'cat' is to con'cat'enate files - here used to show one year csv file

    # |: pipe

    # cut -d',' -f1,2,4: Cut columns 1,2,4 with , delimitor

    # > $csv_file.cut: Save to temporary file

    | > $csv_file.cut: 

    cat $csv_file | cut -d',' -f1,2,4 > $csv_file.cut

    # mv $csv_file.cut $csv_file: Rename temporary file to original file

    mv $csv_file.cut $csv_file

    # File is processed and saved back into the same

    # There are other ways to do this

    # Using intermediate file is the most reliable method.

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

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

date_format.sh

for csv_file in `ls TAVG_*.csv`

do

    echo Date formatting $csv_file

    # This inserts , after year

    sed -i 's/,..../&,/' $csv_file

    # This inserts , after month

    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. कुल राज्यों का औसत तापमान डेटा

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

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

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

यूएस लिस्टिंग खोजने के लिए grep उपयोगिता के साथ यूएस स्टेशनों को निकालें। निम्न कमांड उन पंक्तियों की खोज करता है जो "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

...

फ़ाइल को प्रिंट करने के लिए बिल्ली का उपयोग करके, दोहराव और आउटपुट को एक अस्थायी फ़ाइल में निचोड़ने के लिए 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

...

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

$ 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

...

इसे एक CSV बनाएं और sed का उपयोग करके रिक्त स्थान को अल्पविराम विभाजक में बदलें:

$ 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

यहाँ इन मापदंडों का क्या अर्थ है:

`-F,`	फ़ील्ड विभाजक है `,`
`FNR`	प्रत्येक फ़ाइल में पंक्ति संख्या
`NR`	दोनों फाइलों में एक साथ लाइन नंबर
`FNR==NR`	क्या केवल पहली फ़ाइल `${PATTERN_FILE}` में TRUE है
`{ x[$1]=$2; next; }`	यदि `FNR==NR` TRUE है (`$PATTERN_FILE` . की सभी पंक्तियों के लिए) केवल)
`- x`	स्टोर करने के लिए वेरिएबल `station=state` नक्शा
`- x[$1]=$2`	`station=state` का डेटा जोड़ता है मैप करने के लिए
`- $1`	पहली फ़ाइल में पहला कॉलम (स्टेशन कोड)
`- $2`	पहली फ़ाइल में दूसरा कॉलम (राज्य कोड)
`- x`	सभी स्टेशनों का मानचित्र उदा., `x[US009052008]=SD` , `x[US10RMHS145]=CO` , ..., `x[USW00096409]=AK`
`- next`	मिलती हुई अगली पंक्ति पर जाएं `FNR==NR` (अनिवार्य रूप से, यह `${PATTERN_FILE}` से सभी स्टेशनों-राज्यों का नक्शा बनाता है।
`{ $1=x[$1]; print $0 }`	यदि `FNR==NR` FALSE है (सभी पंक्तियों के लिए `in $DATA_FILE` केवल)
`- $1=x[$1]`	पहले फ़ील्ड को `x[$1]` . से बदलें; अनिवार्य रूप से, स्टेशन कोड को राज्य कोड से बदलें
`- print $0`	सभी कॉलम प्रिंट करें (बदले गए `$1` . सहित) )
`OFS=,`	आउटपुट फ़ील्ड विभाजक है `,`

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

$ 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 का उपयोग करें, यह सुनिश्चित करने के लिए सॉर्ट करें कि अंतिम परिणाम तार्किक क्रम में हैं, और प्रोसेसिंग के बाद अस्थायी फ़ाइल को हटाने के लिए 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 मापदंडों का क्या अर्थ है:

`FILE=$DATA_FILE`	CSV फ़ाइल को `FILE` के रूप में संसाधित किया जाता है
`-F,`	फ़ील्ड विभाजक है `,`
`state_day_sum[$1 "," $2 "," $3 "," $4] = $5 state_day_sum[$1 "," $2 "," $3 "," $4] + $5`	तापमान का योग (`$5` ) राज्य के लिए `($1` ) वर्ष पर (`$2` ), महीना (`$3` ), दिन (`$4` )
`state_day_num[$1 "," $2 "," $3 "," $4] = $5 state_day_num[$1 "," $2 "," $3 "," $4] + 1`	राज्य के लिए तापमान रीडिंग की संख्या (`$1` ) वर्ष पर (`$2` ), महीना (`$3` ), दिन (`$4` )
`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`	इनपुट फ़ाइल (`TAVG_US_` से शुरू होने वाले नाम वाली सभी फाइलें) और `.csv` . के साथ समाप्त होता है , एक के बाद एक)
`> STATE_DAY_${DATA_FILE}.tmp`	परिणाम को एक अस्थायी फ़ाइल में सहेजें

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

$ ./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 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 (input – 20 weeks):

AK,2010,01,01,-181.934

AK,2010,01,02,-199.531

...

AK,2010,01,20,-157.273



y (21st week, prediction for these 20 weeks):

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

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

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

timeslice.sh

#!/bin/sh



TIME_SLICE_PERIOD=20



file=TAVG_US_2010-2019.csv



# For each state in file

for state in `cut -d',' -f1 $file | sort | uniq`

do

    # Get all temperature values for the state

    state_tavgs=`grep $state $file | cut -d',' -f5`

    # How many time slices will this result in?

    # mber of temperatures recorded minus size of one timeslice

    num_slices=`echo $state_tavgs | wc -w`

    num_slices=$((${num_slices} - ${TIME_SLICE_PERIOD}))

    # Initialize

    slice_start=1; num_slice=0;

    # For each timeslice

    while [ $num_slice -lt $num_slices ]

    do

        # One timeslice is from slice_start to slice_end

        slice_end=$(($slice_start + $TIME_SLICE_PERIOD - 1))

        # X (1-20)

        sliceX="$slice_start-$slice_end"

        # y (21)

        slicey=$(($slice_end + 1))

        # Print state and timeslice temperature values (column 1-20 and 21)

        echo $state `echo $state_tavgs | cut -d' ' -f$sliceX,$slicey`

        # Increment 

        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



    # Train set

    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



    # Test set

    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



    # Validate set

    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 स्क्रिप्ट में, और आप डेटा को शफ़ के साथ शफ़ल कर सकते हैं।

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

$ ./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

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

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

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