Theory
એ સરેરાશ જેણે જવાબ આપવાની ના પાડી
ગયા પાઠની સફાઈ પછી, roll 121 નો અશક્ય screen time NA બન્યો. હવે તમે સરેરાશ માંગો છો:
mean(survey$screen)
[1] NA
R જવાબ આપવાની ના પાડે છે. ભૂલ નહીં, અટકળ નહીં: સપાટ "અજ્ઞાત".
હેરાન કરે એવું? આ course નું સૌથી પ્રામાણિક વર્તન છે: એક મૂલ્ય અજ્ઞાત છે, એટલે ચોક્કસ સરેરાશ જાણી શકાય એવી નથી, અને R એ કહી દે છે. આજે: કાણાં કેવી રીતે શોધવાં, અને એમની આસપાસ કામ કરવાની ત્રણ કાયદેસર રીતો.
Theory
હાજરીના રજિસ્ટરમાંની ખાલી જગ્યા
રજિસ્ટરની એક હરોળ દેખાડે છે: હાજર, હાજર, ખાલી, હાજર. ખાલી જગ્યાનો અર્થ શું? "ગેરહાજર" નહીં: ગેરહાજરીનું પોતાનું નિશાન છે. ખાલી જગ્યાનો અર્થ છે કોઈએ નોંધ્યું નથી: અજ્ઞાત.
NA એ જ ખાલી જગ્યા છે. એ 0 નથી (ખરેખર માપેલું શૂન્ય), "" નથી (ખાલી લખાણ), NULL નથી (ખાનું જ નહીં): એ એવું ખાનું છે જેની અંદર શું છે એ કોઈ જાણતું નથી. અને ખાલી જગ્યા પર ગણાયેલો કોઈ પણ સરવાળો પોતે... ખાલી છે. R એ તર્કને ગંભીરતાથી લે છે.
Theory
NA ફેલાય છે, અને == એને જોઈ શકતું નથી
NA પર બે નિયમ રાજ કરે છે:
ફેલાવો: NA ને અડતું કોઈ પણ ગણિત NA આપે છે: mean, sum, sd, 5 + NA પણ. ખૂટતાપણું પરિણામોને ચેપ લગાડે છે, જોરથી, રચનાથી જ.
સરખામણીનું અંધત્વ: x == NA NA આપે છે, ક્યારેય TRUE નહીં: "શું આ અજ્ઞાત અજ્ઞાત બરાબર છે?" પૂછવાનો કોઈ જવાબ નથી. તમે બરાબર આ જ તર્ક BCA303માં મળ્યા હતા: SQL નું = NULL એ જ રીતે, એ જ કારણે નિષ્ફળ ગયું હતું.
એકમાત્ર પ્રામાણિક શોધક એક ખાસ function છે: is.na().
Practical
શોધો, પછી વ્યૂહ પસંદ કરો
screen <- c(120, 90, NA, 240, 150, NA)
# DETECT
is.na(screen) # FALSE FALSE TRUE FALSE FALSE TRUE
sum(is.na(screen)) # [1] 2 how many holes
mean(is.na(screen)) # [1] 0.333 what fraction is missing
# the wrong way (comparison blindness):
screen == NA # NA NA NA NA NA NA never TRUE!
# STRATEGY 1: compute around the holes
mean(screen, na.rm = TRUE) # [1] 150 NAs removed for this calc
# STRATEGY 2: keep only complete rows (whole data frame)
survey_complete <- na.omit(survey)
# per-column hole count for a data frame:
colSums(is.na(survey))
# STRATEGY 3 (advanced, use with care): impute
# screen[is.na(screen)] <- median(screen, na.rm = TRUE)
Quiz
એક student survey$screen[is.na(survey$screen)] <- 0 થી NA ની સમસ્યા "સુધારે" છે અને ગર્વથી નવી સરેરાશ જણાવે છે. શું ખોટું છે?
- શૂન્ય એ એક દાવો છે (student બિલકુલ screen વાપરતો નથી), ગેરહાજરી નહીં: નકલી શૂન્ય સરેરાશને નીચે ખેંચે છે અને દરેક આંકડાને પક્ષપાતી કરે છે
- કશું નહીં: 0 અને NA એક જ અર્થ ધરાવે છે
- Syntax અમાન્ય છે: NA પર assign કરી શકાતું નથી
- એ ત્યારે જ નિષ્ફળ જાય જ્યારે અડધાથી વધુ મૂલ્યો NA હોય
Show the answer
શૂન્ય એ એક દાવો છે (student બિલકુલ screen વાપરતો નથી), ગેરહાજરી નહીં: નકલી શૂન્ય સરેરાશને નીચે ખેંચે છે અને દરેક આંકડાને પક્ષપાતી કરે છે
NA કહે છે "આપણે જાણતા નથી"; 0 કહે છે "આપણે જાણીએ છીએ, અને એ શૂન્ય છે": એકની જગ્યાએ બીજું મૂકવાથી data ઉપજાવાય છે, અને દરેક નકલી 0 સરેરાશને શૂન્ય તરફ ખેંચે છે (આપણાં છ મૂલ્યોમાં બે નકલી શૂન્ય 150 ને બદલે 100 જણાવે). યાંત્રિક રીતે સાચા ઉકેલ na.rm = TRUE કે na.omit() છે; મધ્યસ્થથી ભરવું એ બચાવી શકાય એવો અદ્યતન વિકલ્પ છે: અહેવાલમાં નોંધ સાથે. પ્રશ્નમાંનું syntax માન્ય R છે: ગુનો આંકડાકીય છે, syntax નો નહીં.
Think first
ચાર outputs ધારો
x <- c(10, NA, 30) સાથે, tap કરતાં પહેલાં દરેક કાઢો:
1. sum(x)
2. sum(x, na.rm = TRUE)
3. x == NA
4. sum(is.na(x))
Show the answer
1. NA: ફેલાવો: એક અજ્ઞાત આખા સરવાળાને અજ્ઞાત બનાવે છે.
2. 40: આ ગણતરી માટે કાણું બાજુએ મુકાય છે.
3. NA NA NA: NA સાથેની સરખામણી ક્યારેય ઉકેલાતી નથી: અંધત્વનો નિયમ.
4. 1: is.na() એ પ્રામાણિક શોધક છે, અને એના TRUE નો સરવાળો કાણાં ગણે છે.
ચાર લીટી, NA ના ચારેય નિયમ: પરીક્ષાઓ આ વિષય બરાબર આ ચોકડીથી ચકાસે છે, અને કોઈ પણ dataset માંથી આંકડા પર ભરોસો કરતાં પહેલાં તમારે પણ આ જ રીતે જાતતપાસ કરવી જોઈએ.
Watch out
વ્યૂહ પ્રામાણિકપણે પસંદ કરવો
na.rm = TRUE: કાણાં થોડાં અને આકસ્મિક હોય ત્યારે ઝડપી આંકડા માટે.
na.omit(): પૂરી હરોળ માંગતાં વિશ્લેષણ માટે: પણ તમે કેટલી હરોળ ગુમાવો છો એ તપાસો (પહેલાં અને પછીનું nrow): અડધું survey ચૂપચાપ ફેંકી દેવું એ પોતે એક ગુનો છે.
ભરવું: NA ની જગ્યાએ સરેરાશ/મધ્યસ્થ મૂકવાથી હરોળ બચે છે પણ મૂલ્ય ઉપજાવાય છે: વ્યવહારમાં સ્વીકાર્ય, હંમેશા જાહેર કરાય.
ક્યારેય નહીં: NA → 0. અને કોઈ પણ આંકડાની બાજુમાં કાણાંની સંખ્યા હંમેશા જણાવો.
Theory
એ ખ્યાલ જેને તમે હવે ત્રણ વાર મળ્યા
SQLite એ એને NULL કહ્યું (IS NULL, = NULL નો ફાંદો), pandas એ એને NaN તરીકે દેખાડ્યું, R એ NA લખે છે: ત્રણ ભાષા, એક વિચાર: અજ્ઞાત એ મૂલ્ય નથી, અને સમાનતા એને જોઈ શકતી નથી. ભાષાઓ પારની એ ઓળખ કોઈ પણ એક syntax કરતાં વધુ મૂલ્યવાન છે: મુલાકાત લેનારા બરાબર આ જ ખોદે છે. આગલો પાઠ: પ્રકારો બદલવા અને ફરીથી કોડ કરવા: એ factor ના ફાંદા સહિત જે શ્રેણીઓને ખોટી સંખ્યાઓમાં ફેરવે છે.
Summary
Key takeaways
- NA = અજ્ઞાત: 0 (ખરેખરું શૂન્ય), "" (ખાલી લખાણ) અને NULL (કોઈ પદાર્થ નહીં) થી અલગ.
- NA ફેલાય છે: કોઈ પણ NA પરની mean/sum/sd એ NA આપે છે: રચનાથી જ જોરથી.
- x == NA ક્યારેય ચાલતું નથી (NA આપે છે): is.na() થી શોધો; sum(is.na(x)) થી ગણો.
- na.rm = TRUE થી કાણાંની આસપાસ ગણો; na.omit() થી અધૂરી હરોળ કાઢો (હરોળનું નુકસાન તપાસો).
- ભરવું (મધ્યસ્થ/સરેરાશ) data ઉપજાવે છે: ઓછું વાપરો, હંમેશા જાહેર કરો; NA → 0 ક્યારેય નહીં.
- SQL ના NULL અને pandas ના NaN જેવો જ ખ્યાલ.
- Memory hook: રજિસ્ટરમાંની ખાલી જગ્યા એ શૂન્ય નથી.