Module 5: Data Cleaning (Data Preprocessing) | Data Analytics සිංහලෙන්

Pandas භාවිතයෙන් දත්ත අපගේ Python පරිසරයට ලබා ගන්නා ආකාරය ඔබ දැන් දන්නවා. නමුත් සැබෑ ලෝකයේ දත්ත කිසිවිටෙකත් 100%ක් පරිපූර්ණව අපට ලැබෙන්නේ නැහැ. ඒවායේ හිස්තැන් (missing values), අනුපිටපත් (duplicates), වැරදි දත්ත වර්ග (incorrect data types) වැනි බොහෝ ගැටලු අඩංගු විය හැකියි. අපගේ විශ්ලේෂණය නිවැරදි සහ විශ්වාසදායක වීමට නම්, මෙම "අපිරිසිදු" දත්ත පළමුව පිරිසිදු කළ යුතුය. මෙම ක්‍රියාවලිය **Data Cleaning** বা **Data Preprocessing** ලෙස හඳුන්වයි.

"Garbage In, Garbage Out" (GIGO)

මෙය දත්ත විද්‍යාවේ ඉතා වැදගත් සංකල්පයකි. මෙහි අර්ථය නම්, ඔබ විශ්ලේෂණය සඳහා වැරදි හෝ අපිරිසිදු දත්ත යෙදවුවහොත්, ඔබට ලැබෙන ප්‍රතිඵල සහ නිගමනද වැරදි සහ විශ්වාස කළ නොහැකි ඒවා වනු ඇති බවයි. එබැවින්, දත්ත පිරිසිදු කිරීම විශ්ලේෂණ ක්‍රියාවලියේ අත්‍යවශ්‍ය සහ වැදගත්ම පියවරකි.

1. Missing Values (හිස්තැන්) Handle කිරීම

Dataset එකක සමහර තැන්වල දත්ත නොමැති වීම (හිස් වීම) ඉතා සුලභ තත්වයකි. Pandas වල මේවා `NaN` (Not a Number) ලෙස නිරූපණය වේ. මෙම හිස්තැන් සමඟ කටයුතු කිරීමට ප්‍රධාන ක්‍රම දෙකක් තිබේ.

හිස්තැන් හඳුනාගැනීම

පළමුව, අපගේ DataFrame එකේ හිස්තැන් කොපමණ තිබේදැයි සහ ඒවා කොහේදැයි සොයාගත යුතුය. `isnull().sum()` යන function chain එක මේ සඳහා යොදාගත හැක.

                        # උදාහරණයක් ලෙස DataFrame එකක් සාදාගනිමු
                        import pandas as pd
                        import numpy as np

                        data = {'Name': ['Kasun', 'Nimali', 'Ruwan', 'Fathima', 'John'],
                                'Age': [21, np.nan, 22, 24, 21],
                                'Score': [85, 92, 78, np.nan, 95]}
                        df = pd.DataFrame(data)

                        # එක් එක් තීරුවේ ඇති හිස්තැන් (NaN) ගණන සෙවීම
                        print(df.isnull().sum())
                    

ක්‍රමය 1: හිස්තැන් ඇති පේළි ඉවත් කිරීම (Dropping)

යම් පේළියක හිස්තැන් එකක් හෝ කිහිපයක් තිබේ නම්, එම සම්පූර්ණ පේළියම DataFrame එකෙන් ඉවත් කිරීමට `dropna()` ශ්‍රිතය භාවිතා කළ හැක. ඔබගේ dataset එක ඉතා විශාල නම් සහ හිස්තැන් ඇත්තේ ඉතා සුළු පේළි ගණනක නම් මෙම ක්‍රමය සුදුසු වේ.

                        # හිස්තැන් ඇති ඕනෑම පේළියක් ඉවත් කිරීම
                        df_cleaned = df.dropna()
                        print(df_cleaned)
                    

ක්‍රමය 2: හිස්තැන් පිරවීම (Imputation)

දත්ත ඉවත් කිරීමෙන් වටිනා තොරතුරු නැති වී යා හැකි නිසා, බොහෝ විට වඩාත් සුදුසු ක්‍රමය වන්නේ හිස්තැන් වෙනත් අගයකින් පිරවීමයි. `fillna()` ශ්‍රිතය මේ සඳහා යොදා ගැනේ.

සංඛ්‍යාත්මක තීරු සඳහා: සාමාන්‍යයෙන් එම තීරුවේ මධ්‍යන්‍යය (mean) හෝ මධ්‍යස්ථය (median) වැනි අගයකින් පුරවනු ලැබේ.
වර්ගීකරණ (Categorical) තීරු සඳහා: එම තීරුවේ බහුලවම පවතින අගය (mode) මගින් පුරවනු ලැබේ.

                        # 'Age' තීරුවේ හිස්තැන්, එම තීරුවේ මධ්‍යන්‍යයෙන් (mean) පිරවීම
                        age_mean = df['Age'].mean()
                        df['Age'].fillna(age_mean, inplace=True)

                        # 'Score' තීරුවේ හිස්තැන් 0 න් පිරවීම
                        df['Score'].fillna(0, inplace=True)
                        
                        print(df)
                    

2. Duplicates (අනුපිටපත්) Remove කිරීම

දත්ත එකතු කිරීමේදී ඇතිවන දෝෂ නිසා එකම පේළිය කිහිප වරක් dataset එකට ඇතුළත් විය හැකිය. මෙම අනුපිටපත් අපගේ විශ්ලේෂණයන්ගේ ප්‍රතිඵල විකෘති කළ හැකි බැවින්, ඒවා හඳුනාගෙන ඉවත් කිරීම වැදගත් වේ.

                        # ඉහත DataFrame එකට අනුපිටපතක් එකතු කරමු
                        duplicate_row = pd.DataFrame([{'Name': 'Kasun', 'Age': 21.0, 'Score': 85.0}])
                        df_with_duplicates = pd.concat([df, duplicate_row], ignore_index=True)
                        
                        # අනුපිටපත් පේළි හඳුනාගැනීම
                        print("Duplicates found:")
                        print(df_with_duplicates.duplicated())

                        # අනුපිටපත් ඉවත් කිරීම
                        df_no_duplicates = df_with_duplicates.drop_duplicates()
                        print("\nAfter dropping duplicates:")
                        print(df_no_duplicates)
                    

3. Data Type Conversions (දත්ත වර්ග පරිවර්තනය)

සමහර විට, දත්ත import කිරීමේදී Pandas විසින් තීරුවක දත්ත වර්ගය වැරදියට හඳුනාගත හැකිය. උදාහරණයක් ලෙස, සංඛ්‍යාත්මක විය යුතු තීරුවක් object (string) ලෙස හඳුනාගත හැක. `astype()` ශ්‍රිතය භාවිතයෙන් අපට මෙම දත්ත වර්ග නිවැරදි කළ හැක.

උදාහරණයක් ලෙස, අපගේ 'Age' තීරුව දැන් float (දශම සංඛ්‍යා) වර්ගයේ පවතී, මන්ද අප mean අගය යෙදූ නිසා. නමුත් වයස පූර්ණ සංඛ්‍යාවක් (integer) වීම වඩාත් සුදුසුය.

                        # දත්ත වර්ග පරීක්ෂා කිරීම
                        print("Data types before conversion:")
                        print(df.dtypes)
                        
                        # 'Age' තීරුව integer බවට පරිවර්තනය කිරීම
                        df['Age'] = df['Age'].astype(int)

                        # පරිවර්තනයෙන් පසු දත්ත වර්ග පරීක්ෂා කිරීම
                        print("\nData types after conversion:")
                        print(df.dtypes)
                    

Module 04 වෙත Module 06 වෙත යන්න

මෙම Module එකේදී...

"Garbage In, Garbage Out" සංකල්පය.
`isnull()` සහ `sum()` මගින් හිස්තැන් සෙවීම.
`dropna()` සහ `fillna()` භාවිතය.
`duplicated()` සහ `drop_duplicates()` භාවිතය.
`astype()` මගින් දත්ත වර්ග නිවැරදි කිරීම.