msb-public
/
Data-Science-For-Beginners
mirror of https://github.com/microsoft/Data-Science-For-Beginners.git
1
0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'main'
${ noResults }
Data-Science-For-Beginners/translations/ml/2-Working-With-Data/08-data-preparation/README.md

340 lines
37 KiB
Raw Permalink Blame History

# ഡാറ്റയുമായി പ്രവർത്തിക്കൽ: ഡാറ്റ തയ്യാറാക്കൽ
|![ Sketchnote by [(@sketchthedocs)](https://sketchthedocs.dev) ](../../sketchnotes/08-DataPreparation.png)|
|:---:|
|ഡാറ്റ തയ്യാറാക്കൽ - _Sketchnote by [@nitya](https://twitter.com/nitya)_ |
## [പ്രീ-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ds/quiz/14)
തന്റെ ഉറവിടം അനുസരിച്ച്, റോ ഡാറ്റയിൽ ചില അസംഘടിതത്വങ്ങൾ ഉണ്ടാകാം, അവ വിശകലനത്തിലും മോഡലിംഗിലും വെല്ലുവിളികൾ സൃഷ്ടിക്കും. മറ്റൊരു വാക്കിൽ, ഈ ഡാറ്റ "അഴുക്കായ" എന്ന് വർഗ്ഗീകരിക്കാം, അത് ശുദ്ധീകരിക്കേണ്ടതുണ്ട്. ഈ പാഠം നഷ്ടപ്പെട്ട, തെറ്റായ, അല്ലെങ്കിൽ അപൂർണ്ണമായ ഡാറ്റയുടെ വെല്ലുവിളികൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഡാറ്റ ശുദ്ധീകരണവും പരിവർത്തനവും സംബന്ധിച്ച സാങ്കേതിക വിദ്യകളിൽ കേന്ദ്രീകരിക്കുന്നു. ഈ പാഠത്തിൽ ഉൾപ്പെടുത്തിയ വിഷയങ്ങൾ Python-ഉം Pandas ലൈബ്രറിയും ഉപയോഗിച്ച് [ഈ ഡയറക്ടറിയിലുള്ള നോട്ട്‌ബുക്കിൽ](notebook.ipynb) പ്രദർശിപ്പിക്കും.
## ഡാറ്റ ശുദ്ധീകരണത്തിന്റെ പ്രാധാന്യം
- **ഉപയോഗവും പുനരുപയോഗവും എളുപ്പമാക്കൽ**: ഡാറ്റ ശരിയായി ക്രമീകരിക്കുകയും സാധാരണ രൂപത്തിലാക്കുകയും ചെയ്താൽ അത് തിരയാനും ഉപയോഗിക്കാനും മറ്റുള്ളവരുമായി പങ്കിടാനും എളുപ്പമാകും.
- **സമരൂപത**: ഡാറ്റ സയൻസ് പലപ്പോഴും ഒന്നിലധികം ഡാറ്റാസെറ്റുകളുമായി പ്രവർത്തിക്കേണ്ടതുണ്ട്, വ്യത്യസ്ത ഉറവിടങ്ങളിൽ നിന്നുള്ള ഡാറ്റാസെറ്റുകൾ ചേർക്കേണ്ടതുണ്ട്. ഓരോ ഡാറ്റാസെറ്റിനും സാധാരണ മാനദണ്ഡം ഉറപ്പാക്കുന്നത്, അവ എല്ലാം ഒന്നായി ചേർക്കുമ്പോഴും ഡാറ്റ ഉപയോഗപ്രദമായിരിക്കുമെന്ന് ഉറപ്പാക്കും.
- **മോഡൽ കൃത്യത**: ശുദ്ധീകരിച്ച ഡാറ്റ മോഡലുകളുടെ കൃത്യത മെച്ചപ്പെടുത്തുന്നു.
## സാധാരണ ശുദ്ധീകരണ ലക്ഷ്യങ്ങളും തന്ത്രങ്ങളും
- **ഡാറ്റാസെറ്റ് പരിശോധിക്കൽ**: ഡാറ്റ എക്സ്പ്ലോറേഷൻ, [പിന്നീട് വരുന്ന പാഠത്തിൽ](https://github.com/microsoft/Data-Science-For-Beginners/tree/main/4-Data-Science-Lifecycle/15-analyzing) ഉൾപ്പെടുത്തിയിരിക്കുന്നു, ശുദ്ധീകരിക്കേണ്ട ഡാറ്റ കണ്ടെത്താൻ സഹായിക്കും. ഒരു ഡാറ്റാസെറ്റിലെ മൂല്യങ്ങൾ ദൃശ്യമായി നിരീക്ഷിക്കുന്നത് ബാക്കി ഡാറ്റ എങ്ങനെ കാണപ്പെടും എന്ന് പ്രതീക്ഷകൾ സജ്ജമാക്കാനും പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ ആശയങ്ങൾ നൽകാനും സഹായിക്കും. എക്സ്പ്ലോറേഷൻ അടിസ്ഥാന ക്വെറിയിംഗ്, ദൃശ്യീകരണങ്ങൾ, സാമ്പിളിംഗ് എന്നിവ ഉൾക്കൊള്ളാം.
- **ഫോർമാറ്റിംഗ്**: ഉറവിടം അനുസരിച്ച്, ഡാറ്റയുടെ അവതരണത്തിൽ അസംഘടിതത്വങ്ങൾ ഉണ്ടാകാം. ഇത് മൂല്യം തിരയുന്നതിലും പ്രതിനിധാനം ചെയ്യുന്നതിലും പ്രശ്നങ്ങൾ സൃഷ്ടിക്കും, ഡാറ്റാസെറ്റിൽ കാണപ്പെടുന്നെങ്കിലും ദൃശ്യീകരണങ്ങളിലും ക്വെറി ഫലങ്ങളിലും ശരിയായി പ്രതിനിധാനം ചെയ്യപ്പെടാത്തത്. സാധാരണ ഫോർമാറ്റിംഗ് പ്രശ്നങ്ങൾ വെളിച്ചം, തീയതികൾ, ഡാറ്റാ ടൈപ്പുകൾ എന്നിവ പരിഹരിക്കുന്നതാണ്. ഫോർമാറ്റിംഗ് പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നത് സാധാരണയായി ഡാറ്റ ഉപയോഗിക്കുന്നവരുടെ ഉത്തരവാദിത്വമാണ്. ഉദാഹരണത്തിന്, തീയതികളും സംഖ്യകളും എങ്ങനെ അവതരിപ്പിക്കപ്പെടണം എന്നതിൽ രാജ്യങ്ങൾ വ്യത്യാസപ്പെടാം.
- **പുനരാവൃത്തി**: ഒരേ ഡാറ്റ പല തവണ ഉണ്ടാകുന്നത് തെറ്റായ ഫലങ്ങൾ നൽകും, സാധാരണയായി നീക്കം ചെയ്യണം. രണ്ട് അല്ലെങ്കിൽ കൂടുതൽ ഡാറ്റാസെറ്റുകൾ ചേർക്കുമ്പോൾ ഇത് സാധാരണമാണ്. എന്നാൽ, ചേർന്ന ഡാറ്റാസെറ്റുകളിൽ പുനരാവൃത്തി ചില അധിക വിവരങ്ങൾ നൽകുന്ന ഭാഗങ്ങൾ ഉൾക്കൊള്ളാം, അവ സംരക്ഷിക്കേണ്ടതുണ്ടാകാം.
- **നഷ്ടപ്പെട്ട ഡാറ്റ**: നഷ്ടപ്പെട്ട ഡാറ്റ തെറ്റായതും ദുർബലവുമായ ഫലങ്ങൾ സൃഷ്ടിക്കാം. ചിലപ്പോൾ ഡാറ്റ "പുനഃലോഡ്" ചെയ്യലിലൂടെ, കണക്കുകൂട്ടലും Python പോലുള്ള കോഡും ഉപയോഗിച്ച് നഷ്ടപ്പെട്ട മൂല്യങ്ങൾ പൂരിപ്പിച്ച്, അല്ലെങ്കിൽ മൂല്യം നീക്കം ചെയ്ത് പരിഹരിക്കാം. ഡാറ്റ നഷ്ടപ്പെടാനുള്ള നിരവധി കാരണങ്ങൾ ഉണ്ട്, നഷ്ടപ്പെട്ട മൂല്യങ്ങൾ പരിഹരിക്കുന്ന നടപടികൾ അവ എങ്ങനെ, എന്തുകൊണ്ട് നഷ്ടപ്പെട്ടുവെന്ന് ആശ്രയിച്ചിരിക്കും.
## DataFrame വിവരങ്ങൾ പരിശോധിക്കൽ
> **പഠനലക്ഷ്യം:** ഈ ഉപവിഭാഗം അവസാനിക്കുമ്പോൾ, pandas DataFrame-കളിൽ സൂക്ഷിച്ചിരിക്കുന്ന ഡാറ്റയുടെ പൊതുവായ വിവരങ്ങൾ കണ്ടെത്തുന്നതിൽ നിങ്ങൾ സുഖകരമായി പ്രവർത്തിക്കണം.
നിങ്ങൾ ഡാറ്റ pandas-ലേക്ക് ലോഡ് ചെയ്താൽ, അത് DataFrame ആയിരിക്കാനുള്ള സാധ്യത കൂടുതലാണ് ([മുൻപത്തെ പാഠം](https://github.com/microsoft/Data-Science-For-Beginners/tree/main/2-Working-With-Data/07-python#dataframe) വിശദമായ അവലോകനത്തിന്). എന്നാൽ നിങ്ങളുടെ DataFrame-ൽ 60,000 വരികളും 400 കോളങ്ങളുമുള്ള ഡാറ്റാസെറ്റ് ഉണ്ടെങ്കിൽ, നിങ്ങൾ എന്തിനൊപ്പം പ്രവർത്തിക്കുകയാണ് എന്ന് എങ്ങനെ മനസ്സിലാക്കും? ഭാഗ്യവശാൽ, [pandas](https://pandas.pydata.org/) DataFrame-ന്റെ പൊതുവായ വിവരങ്ങൾ, ആദ്യ കുറച്ച് വരികളും അവസാന കുറച്ച് വരികളും കാണാൻ സൗകര്യപ്രദമായ ഉപകരണങ്ങൾ നൽകുന്നു.
ഈ പ്രവർത്തനം പരിശോധിക്കാൻ, Python scikit-learn ലൈബ്രറി ഇറക്കുമതി ചെയ്ത് ഒരു പ്രശസ്ത ഡാറ്റാസെറ്റ് ഉപയോഗിക്കും: **Iris ഡാറ്റാസെറ്റ്**.
```python
import pandas as pd
from sklearn.datasets import load_iris
iris = load_iris()
iris_df = pd.DataFrame(data=iris['data'], columns=iris['feature_names'])
```
| |sepal length (cm)|sepal width (cm)|petal length (cm)|petal width (cm)|
|----------------------------------------|-----------------|----------------|-----------------|----------------|
|0 |5.1 |3.5 |1.4 |0.2 |
|1 |4.9 |3.0 |1.4 |0.2 |
|2 |4.7 |3.2 |1.3 |0.2 |
|3 |4.6 |3.1 |1.5 |0.2 |
|4 |5.0 |3.6 |1.4 |0.2 |
- **DataFrame.info**: ആരംഭിക്കാൻ, `info()` മെത്തഡ് ഉപയോഗിച്ച് ഒരു `DataFrame`-ൽ ഉള്ള ഉള്ളടക്കത്തിന്റെ സംഗ്രഹം പ്രിന്റ് ചെയ്യാം. ഈ ഡാറ്റാസെറ്റ് നോക്കാം:
```python
iris_df.info()
```
```
RangeIndex: 150 entries, 0 to 149
Data columns (total 4 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 sepal length (cm) 150 non-null float64
1 sepal width (cm) 150 non-null float64
2 petal length (cm) 150 non-null float64
3 petal width (cm) 150 non-null float64
dtypes: float64(4)
memory usage: 4.8 KB
```
ഇതിൽ നിന്ന്, *Iris* ഡാറ്റാസെറ്റിൽ നാല് കോളങ്ങളിലായി 150 എൻട്രികൾ ഉണ്ടെന്നും, നൾ എൻട്രികൾ ഒന്നും ഇല്ലെന്നും അറിയാം. എല്ലാ ഡാറ്റയും 64-ബിറ്റ് ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറുകളായി സൂക്ഷിച്ചിരിക്കുന്നു.
- **DataFrame.head()**: തുടർന്ന്, `DataFrame`-ന്റെ യഥാർത്ഥ ഉള്ളടക്കം പരിശോധിക്കാൻ `head()` മെത്തഡ് ഉപയോഗിക്കുന്നു. നമ്മുടെ `iris_df`-ന്റെ ആദ്യ കുറച്ച് വരികൾ കാണാം:
```python
iris_df.head()
```
```
sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)
0 5.1 3.5 1.4 0.2
1 4.9 3.0 1.4 0.2
2 4.7 3.2 1.3 0.2
3 4.6 3.1 1.5 0.2
4 5.0 3.6 1.4 0.2
```
- **DataFrame.tail()**: മറുവശത്ത്, `DataFrame`-ന്റെ അവസാന കുറച്ച് വരികൾ പരിശോധിക്കാൻ `tail()` മെത്തഡ് ഉപയോഗിക്കുന്നു:
```python
iris_df.tail()
```
```
sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)
145 6.7 3.0 5.2 2.3
146 6.3 2.5 5.0 1.9
147 6.5 3.0 5.2 2.0
148 6.2 3.4 5.4 2.3
149 5.9 3.0 5.1 1.8
```
> **പാഠം:** DataFrame-ലെ വിവരങ്ങളുടെ മെറ്റാഡാറ്റയും ആദ്യവും അവസാനവും കുറച്ച് മൂല്യങ്ങളും നോക്കിയാൽ പോലും, നിങ്ങൾ കൈകാര്യം ചെയ്യുന്ന ഡാറ്റയുടെ വലിപ്പം, ആകൃതി, ഉള്ളടക്കം എന്നിവയെക്കുറിച്ച് ഉടൻ ഒരു ആശയം ലഭിക്കും.
## നഷ്ടപ്പെട്ട ഡാറ്റ കൈകാര്യം ചെയ്യൽ
> **പഠനലക്ഷ്യം:** ഈ ഉപവിഭാഗം അവസാനിക്കുമ്പോൾ, DataFrame-കളിൽ നിന്നുള്ള നൾ മൂല്യങ്ങൾ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യുന്നത് അറിയണം.
നിങ്ങൾ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന (അല്ലെങ്കിൽ ഉപയോഗിക്കേണ്ട) ഡാറ്റാസെറ്റുകളിൽ പലപ്പോഴും നഷ്ടപ്പെട്ട മൂല്യങ്ങൾ ഉണ്ടാകും. നഷ്ടപ്പെട്ട ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതിൽ സൂക്ഷ്മമായ തുല്യങ്ങൾ ഉണ്ട്, അവ നിങ്ങളുടെ അന്തിമ വിശകലനത്തെയും യാഥാർത്ഥ്യ ഫലങ്ങളെയും ബാധിക്കാം.
Pandas നഷ്ടപ്പെട്ട മൂല്യങ്ങൾ രണ്ട് രീതികളിൽ കൈകാര്യം ചെയ്യുന്നു. ആദ്യത്തേത് നിങ്ങൾ മുമ്പ് കണ്ടിട്ടുണ്ട്: `NaN`, അല്ലെങ്കിൽ Not a Number. ഇത് IEEE ഫ്ലോട്ടിംഗ് പോയിന്റ് സ്പെസിഫിക്കേഷനിലെ പ്രത്യേക മൂല്യമാണ്, നഷ്ടപ്പെട്ട ഫ്ലോട്ടിംഗ് പോയിന്റ് മൂല്യങ്ങൾ സൂചിപ്പിക്കാൻ മാത്രമാണ് ഉപയോഗിക്കുന്നത്.
ഫ്ലോട്ടുകൾ ഒഴികെയുള്ള നഷ്ടപ്പെട്ട മൂല്യങ്ങൾക്ക് pandas Python `None` ഒബ്ജക്റ്റ് ഉപയോഗിക്കുന്നു. രണ്ടും ഒരേ കാര്യം പറയുന്ന രണ്ട് വ്യത്യസ്ത മൂല്യങ്ങൾ കാണുന്നത് ആശയക്കുഴപ്പമുണ്ടാക്കാം, എന്നാൽ ഈ ഡിസൈൻ തിരഞ്ഞെടുപ്പിന് പ്രോഗ്രാമാറ്റിക് കാരണങ്ങൾ ഉണ്ട്, പ്രായോഗികമായി pandas ഭൂരിഭാഗം കേസുകൾക്കായി നല്ല സമന്വയം നൽകുന്നു. എന്നിരുന്നാലും, `None`-ക്കും `NaN`-ക്കും ഉപയോഗത്തിൽ ശ്രദ്ധിക്കേണ്ട നിയന്ത്രണങ്ങൾ ഉണ്ട്.
`NaN`-നും `None`-നും കുറിച്ച് കൂടുതൽ അറിയാൻ [നോട്ട്‌ബുക്ക്](https://github.com/microsoft/Data-Science-For-Beginners/blob/main/4-Data-Science-Lifecycle/15-analyzing/notebook.ipynb) കാണുക!
- **നൾ മൂല്യങ്ങൾ കണ്ടെത്തൽ**: `pandas`-ൽ, `isnull()` ഉം `notnull()` ഉം നൾ ഡാറ്റ കണ്ടെത്താനുള്ള പ്രധാന മെത്തഡുകളാണ്. ഇരുവരും നിങ്ങളുടെ ഡാറ്റയിൽ ബൂളിയൻ മാസ്കുകൾ നൽകുന്നു. `NaN` മൂല്യങ്ങൾക്ക് `numpy` ഉപയോഗിക്കും:
```python
import numpy as np
example1 = pd.Series([0, np.nan, '', None])
example1.isnull()
```
```
0 False
1 True
2 False
3 True
dtype: bool
```
ഫലങ്ങൾ ശ്രദ്ധാപൂർവ്വം നോക്കുക. ഇതിൽ ഏതെങ്കിലും നിങ്ങൾക്ക് അത്ഭുതം ഉണ്ടാക്കുന്നുണ്ടോ? `0` ഒരു ഗണിത നൾ ആണെങ്കിലും, അത് പൂർണ്ണസംഖ്യയായി pandas പരിഗണിക്കുന്നു. `''` (ശൂന്യ സ്ട്രിംഗ്) കുറച്ച് സൂക്ഷ്മമാണ്. സെക്ഷൻ 1-ൽ ഇത് ശൂന്യ സ്ട്രിംഗ് മൂല്യമായി ഉപയോഗിച്ചെങ്കിലും, pandas-നു ഇത് നൾ പ്രതിനിധാനം ചെയ്യാത്ത ഒരു സ്ട്രിംഗ് ഒബ്ജക്റ്റാണ്.
ഇപ്പോൾ, ഈ മെത്തഡുകൾ പ്രായോഗികമായി ഉപയോഗിക്കുന്ന രീതിയിൽ ഉപയോഗിക്കാം. ബൂളിയൻ മാസ്കുകൾ നേരിട്ട് ``Series`` അല്ലെങ്കിൽ ``DataFrame`` ഇൻഡക്സായി ഉപയോഗിക്കാം, ഇത് നഷ്ടപ്പെട്ട (അല്ലെങ്കിൽ ഉള്ള) മൂല്യങ്ങളുമായി പ്രവർത്തിക്കുമ്പോൾ സഹായകരമാണ്.
> **പാഠം**: `isnull()` ഉം `notnull()` ഉം DataFrame-കളിൽ ഉപയോഗിക്കുമ്പോൾ സമാന ഫലങ്ങൾ നൽകുന്നു: ഫലങ്ങളും അവയുടെ ഇൻഡക്സും കാണിക്കുന്നു, ഇത് നിങ്ങളുടെ ഡാറ്റ കൈകാര്യം ചെയ്യുമ്പോൾ വളരെ സഹായകമാണ്.
- **നൾ മൂല്യങ്ങൾ നീക്കം ചെയ്യൽ**: നഷ്ടപ്പെട്ട മൂല്യങ്ങൾ തിരിച്ചറിയുന്നതിന് പുറമേ, pandas `Series`-ലും `DataFrame`-ലും നിന്നുള്ള നൾ മൂല്യങ്ങൾ നീക്കം ചെയ്യാനുള്ള സൗകര്യം നൽകുന്നു. (വലിയ ഡാറ്റാസെറ്റുകളിൽ, നഷ്ടപ്പെട്ട [NA] മൂല്യങ്ങൾ നീക്കം ചെയ്യുന്നത് അവയെ കൈകാര്യം ചെയ്യുന്നതിന് പകരം കൂടുതൽ ശുപാർശ ചെയ്യപ്പെടുന്നു.) ഇത് കാണാൻ `example1`-ലേക്ക് മടങ്ങാം:
```python
example1 = example1.dropna()
example1
```
```
0 0
2
dtype: object
```
ഇത് `example3[example3.notnull()]`-ന്റെ ഔട്ട്പുട്ട് പോലെയാണ്. വ്യത്യാസം, മാസ്ക് ചെയ്ത മൂല്യങ്ങളിൽ ഇൻഡക്സിംഗ് ചെയ്യുന്നതിന് പകരം, `dropna` ആ നഷ്ടപ്പെട്ട മൂല്യങ്ങൾ `Series` `example1`-ൽ നിന്ന് നീക്കം ചെയ്തിരിക്കുന്നു.
DataFrame-കൾക്ക് രണ്ട് ഡൈമെൻഷനുകൾ ഉള്ളതിനാൽ, ഡാറ്റ നീക്കം ചെയ്യാനുള്ള കൂടുതൽ ഓപ്ഷനുകൾ ഉണ്ട്.
```python
example2 = pd.DataFrame([[1, np.nan, 7],
[2, 5, 8],
[np.nan, 6, 9]])
example2
```
| | 0 | 1 | 2 |
|------|---|---|---|
|0 |1.0|NaN|7 |
|1 |2.0|5.0|8 |
|2 |NaN|6.0|9 |
(നിങ്ങൾ ശ്രദ്ധിച്ചോ, pandas `NaN`-കൾ ഉൾക്കൊള്ളാൻ രണ്ട് കോളങ്ങൾ ഫ്ലോട്ടുകളായി അപ്കാസ്റ്റ് ചെയ്തിട്ടുണ്ട്?)
DataFrame-ൽ ഒരു മൂല്യം മാത്രം നീക്കം ചെയ്യാനാകില്ല, അതിനാൽ പൂർണ്ണ വരികളോ കോളങ്ങളോ നീക്കം ചെയ്യണം. നിങ്ങൾ എന്ത് ചെയ്യുകയാണെന്ന് ആശ്രയിച്ച്, ഒരോതും ചെയ്യാം, pandas ഇരുവിധ ഓപ്ഷനുകളും നൽകുന്നു. ഡാറ്റ സയൻസിൽ, കോളങ്ങൾ സാധാരണയായി വേരിയബിളുകളായി, വരികൾ നിരീക്ഷണങ്ങളായി പ്രതിനിധാനം ചെയ്യുന്നതിനാൽ, വരികൾ നീക്കം ചെയ്യാൻ സാധ്യത കൂടുതലാണ്; `dropna()`-യുടെ ഡിഫോൾട്ട് ക്രമീകരണം ഏതെങ്കിലും നൾ മൂല്യം ഉള്ള എല്ലാ വരികളും നീക്കം ചെയ്യുകയാണ്:
```python
example2.dropna()
```
```
0 1 2
1 2.0 5.0 8
```
ആവശ്യമായാൽ, കോളങ്ങളിൽ നിന്നുമുള്ള NA മൂല്യങ്ങൾ നീക്കം ചെയ്യാം. അതിന് `axis=1` ഉപയോഗിക്കുക:
```python
example2.dropna(axis='columns')
```
```
2
0 7
1 8
2 9
```
ഇത് നിങ്ങൾക്ക് സൂക്ഷിക്കേണ്ട ഡാറ്റയുടെ വലിയൊരു ഭാഗം നീക്കം ചെയ്യാം, പ്രത്യേകിച്ച് ചെറിയ ഡാറ്റാസെറ്റുകളിൽ. നിങ്ങൾക്ക് എങ്കിൽ, നൾ മൂല്യങ്ങൾ ഉള്ള ചില വരികളോ കോളങ്ങളോ മാത്രം നീക്കം ചെയ്യണമെങ്കിൽ? `dropna`-യിൽ `how` ഉം `thresh` ഉം പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് ഇത് നിർദ്ദേശിക്കാം.
ഡിഫോൾട്ട് ആയി, `how='any'` ആണ് (സ്വയം പരിശോധിക്കാൻ അല്ലെങ്കിൽ മെത്തഡിന്റെ മറ്റ് പാരാമീറ്ററുകൾ കാണാൻ, കോഡ് സെല്ലിൽ `example4.dropna?` റൺ ചെയ്യുക). നിങ്ങൾക്ക് `how='all'` എന്നത് നിർദ്ദേശിക്കാം, ഇത് മുഴുവൻ നൾ മൂല്യങ്ങൾ ഉള്ള വരികളോ കോളങ്ങളോ മാത്രം നീക്കം ചെയ്യും. ഈ പ്രവർത്തനം കാണാൻ നമ്മുടെ ഉദാഹരണ DataFrame വിപുലീകരിക്കാം.
```python
example2[3] = np.nan
example2
```
| |0 |1 |2 |3 |
|------|---|---|---|---|
|0 |1.0|NaN|7 |NaN|
|1 |2.0|5.0|8 |NaN|
|2 |NaN|6.0|9 |NaN|
`thresh` പാരാമീറ്റർ കൂടുതൽ സൂക്ഷ്മ നിയന്ത്രണം നൽകുന്നു: ഒരു വരിയിലോ കോളത്തിലോ സൂക്ഷിക്കേണ്ട *നൺ-നൾ* മൂല്യങ്ങളുടെ എണ്ണം നിങ്ങൾ സജ്ജമാക്കുന്നു:
```python
example2.dropna(axis='rows', thresh=3)
```
```
0 1 2 3
1 2.0 5.0 8 NaN
```
ഇവിടെ, ആദ്യവും അവസാനവും വരികളും നീക്കം ചെയ്തിരിക്കുന്നു, കാരണം അവയിൽ രണ്ട് മാത്രമാണ് നൺ-നൾ മൂല്യങ്ങൾ.
- **നൾ മൂല്യങ്ങൾ പൂരിപ്പിക്കൽ**: നിങ്ങളുടെ ഡാറ്റാസെറ്റിന്റെ അടിസ്ഥാനത്തിൽ, നൾ മൂല്യങ്ങൾ നീക്കം ചെയ്യുന്നതിന് പകരം സാധുവായ മൂല്യങ്ങൾ കൊണ്ട് പൂരിപ്പിക്കുന്നത് കൂടുതൽ ബുദ്ധിമുട്ടില്ല. `isnull` ഉപയോഗിച്ച് ഇത് ചെയ്യാം, പക്ഷേ ഇത് പ്രയാസകരമായിരിക്കും, പ്രത്യേകിച്ച് പൂരിപ്പിക്കേണ്ട മൂല്യങ്ങൾ 많으면. ഡാറ്റ സയൻസിൽ ഇത് സാധാരണ പ്രവർത്തനമാണെന്ന് കൊണ്ട്, pandas `fillna` നൽകുന്നു, ഇത് `Series` അല്ലെങ്കിൽ `DataFrame`-ന്റെ ഒരു കോപ്പി നൽകുന്നു, നഷ്ടപ്പെട്ട മൂല്യങ്ങൾ നിങ്ങൾ തിരഞ്ഞെടുക്കുന്ന മൂല്യത്തോടെ പകരം വയ്ക്കുന്നു. പ്രായോഗികമായി ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് കാണാൻ മറ്റൊരു ഉദാഹരണ `Series` സൃഷ്ടിക്കാം.
```python
example3 = pd.Series([1, np.nan, 2, None, 3], index=list('abcde'))
example3
```
```
a 1.0
b NaN
c 2.0
d NaN
e 3.0
dtype: float64
```
നൽകിയ മൂല്യമായ `0` ഉപയോഗിച്ച് എല്ലാ നൾ എൻട്രികളും പൂരിപ്പിക്കാം:
```python
example3.fillna(0)
```
```
a 1.0
b 0.0
c 2.0
d 0.0
e 3.0
dtype: float64
```
നൾ മൂല്യങ്ങൾ **ഫോർവേഡ്-ഫിൽ** ചെയ്യാം, അതായത് അവസാനത്തെ സാധുവായ മൂല്യം ഉപയോഗിച്ച് നൾ പൂരിപ്പിക്കുക:
```python
example3.fillna(method='ffill')
```
```
a 1.0
b 1.0
c 2.0
d 2.0
e 3.0
dtype: float64
```
നൽകിയ മൂല്യമായ അടുത്ത സാധുവായ മൂല്യം പിൻവശത്തേക്ക് പ്രചരിപ്പിച്ച് **ബാക്ക്-ഫിൽ** ചെയ്യാം:
```python
example3.fillna(method='bfill')
```
```
a 1.0
b 2.0
c 2.0
d 3.0
e 3.0
dtype: float64
```
ഇത് DataFrame-കളിലും സമാനമായി പ്രവർത്തിക്കുന്നു, പക്ഷേ നൾ മൂല്യങ്ങൾ പൂരിപ്പിക്കാൻ ഒരു `axis` നിർദ്ദേശിക്കാം. മുമ്പ് ഉപയോഗിച്ച `example2` വീണ്ടും എടുത്ത് നോക്കാം:
```python
example2.fillna(method='ffill', axis=1)
```
```
0 1 2 3
0 1.0 1.0 7.0 7.0
1 2.0 5.0 8.0 8.0
2 NaN 6.0 9.0 9.0
```
ഫോർവേഡ്-ഫില്ലിംഗിന് മുമ്പത്തെ മൂല്യം ലഭ്യമല്ലെങ്കിൽ, നൾ മൂല്യം നിലനിൽക്കുന്നതായി ശ്രദ്ധിക്കുക.
> **Takeaway:** നിങ്ങളുടെ ഡാറ്റാസെറ്റുകളിൽ കാണാനാകാത്ത മൂല്യങ്ങൾ കൈകാര്യം ചെയ്യാനുള്ള പല മാർഗ്ഗങ്ങളുമുണ്ട്. നിങ്ങൾ ഉപയോഗിക്കുന്ന പ്രത്യേക തന്ത്രം (അവ നീക്കം ചെയ്യുക, മാറ്റിസ്ഥാപിക്കുക, അല്ലെങ്കിൽ എങ്ങനെ മാറ്റിസ്ഥാപിക്കണം എന്നത്) ആ ഡാറ്റയുടെ പ്രത്യേകതകൾ അനുസരിച്ച് നിർണ്ണയിക്കപ്പെടണം. നിങ്ങൾ കൂടുതൽ ഡാറ്റാസെറ്റുകൾ കൈകാര്യം ചെയ്ത് ഇടപഴകുമ്പോൾ കാണാനാകാത്ത മൂല്യങ്ങൾ എങ്ങനെ കൈകാര്യം ചെയ്യാമെന്ന് നിങ്ങൾക്ക് മെച്ചപ്പെട്ട ധാരണ ഉണ്ടാകും.
## പകർപ്പുകൾ നീക്കം ചെയ്യൽ
> **Learning goal:** ഈ ഉപവിഭാഗത്തിന്റെ അവസാനം, നിങ്ങൾ ഡാറ്റാഫ്രെയിമുകളിൽ നിന്ന് പകർപ്പുകൾ തിരിച്ചറിയാനും നീക്കം ചെയ്യാനും സുഖകരമായി കഴിയണം.
കാണാനാകാത്ത ഡാറ്റയ്ക്ക് പുറമേ, നിങ്ങൾക്ക് യാഥാർത്ഥ്യ ഡാറ്റാസെറ്റുകളിൽ പകർപ്പുകൾ പലപ്പോഴും കാണാം. ഭാഗ്യവശാൽ, `pandas` പകർപ്പുകൾ കണ്ടെത്താനും നീക്കം ചെയ്യാനും എളുപ്പമുള്ള മാർഗ്ഗം നൽകുന്നു.
- **പകർപ്പുകൾ തിരിച്ചറിയൽ: `duplicated`**: pandas-ലെ `duplicated` മെത്തഡ് ഉപയോഗിച്ച് പകർപ്പുകൾ എളുപ്പത്തിൽ കണ്ടെത്താം, ഇത് ഒരു ബൂളിയൻ മാസ്ക് നൽകുന്നു, ഒരു `DataFrame`-ലെ ഒരു എൻട്രി മുമ്പത്തെ ഒരു പകർപ്പാണോ എന്ന് സൂചിപ്പിക്കുന്നു. ഇത് പ്രവർത്തനത്തിൽ കാണാൻ മറ്റൊരു ഉദാഹരണ `DataFrame` സൃഷ്ടിക്കാം.
```python
example4 = pd.DataFrame({'letters': ['A','B'] * 2 + ['B'],
'numbers': [1, 2, 1, 3, 3]})
example4
```
| |letters|numbers|
|------|-------|-------|
|0 |A |1 |
|1 |B |2 |
|2 |A |1 |
|3 |B |3 |
|4 |B |3 |
```python
example4.duplicated()
```
```
0 False
1 False
2 True
3 False
4 True
dtype: bool
```
- **പകർപ്പുകൾ നീക്കം ചെയ്യൽ: `drop_duplicates`:** `duplicated` മൂല്യങ്ങൾ `False` ആയ എല്ലാ ഡാറ്റയുടെ ഒരു പകർപ്പ് മടങ്ങി നൽകുന്നു:
```python
example4.drop_duplicates()
```
```
letters numbers
0 A 1
1 B 2
3 B 3
```
`duplicated` ഉം `drop_duplicates` ഉം ഡിഫോൾട്ടായി എല്ലാ കോളങ്ങളെയും പരിഗണിക്കുന്നു, പക്ഷേ നിങ്ങൾക്ക് നിങ്ങളുടെ `DataFrame`-ലെ ചില കോളങ്ങൾ മാത്രം പരിശോധിക്കാൻ നിർദ്ദേശിക്കാം:
```python
example4.drop_duplicates(['letters'])
```
```
letters numbers
0 A 1
1 B 2
```
> **Takeaway:** പകർപ്പുകൾ നീക്കം ചെയ്യൽ ഏകദേശം എല്ലാ ഡാറ്റാ സയൻസ് പ്രോജക്റ്റുകളുടെയും അനിവാര്യ ഭാഗമാണ്. പകർപ്പുകൾ നിങ്ങളുടെ വിശകലന ഫലങ്ങൾ മാറ്റുകയും തെറ്റായ ഫലങ്ങൾ നൽകുകയും ചെയ്യാം!
## 🚀 ചലഞ്ച്
ചർച്ച ചെയ്ത എല്ലാ വസ്തുക്കളും [Jupyter Notebook](https://github.com/microsoft/Data-Science-For-Beginners/blob/main/2-Working-With-Data/08-data-preparation/notebook.ipynb) ആയി ലഭ്യമാണ്. കൂടാതെ, ഓരോ വിഭാഗത്തിനും ശേഷം വ്യായാമങ്ങൾ ഉണ്ട്, അവ പരീക്ഷിച്ച് നോക്കൂ!
## [പോസ്റ്റ്-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ds/quiz/15)
## അവലോകനം & സ്വയം പഠനം
നിങ്ങളുടെ ഡാറ്റ വിശകലനത്തിനും മോഡലിംഗിനും തയ്യാറാക്കുന്നതും ഡാറ്റ ശുദ്ധീകരണവും കണ്ടെത്താനും സമീപിക്കാനും നിരവധി മാർഗ്ഗങ്ങളുണ്ട്, ഡാറ്റ ശുദ്ധീകരണം ഒരു "ഹാൻഡ്‌സ് ഓൺ" അനുഭവമാണ്. ഈ പാഠം ഉൾക്കൊള്ളാത്ത സാങ്കേതിക വിദ്യകൾ അന്വേഷിക്കാൻ Kaggle-ൽ നിന്നുള്ള ഈ ചലഞ്ചുകൾ പരീക്ഷിക്കൂ.
- [ഡാറ്റ ശുദ്ധീകരണ ചലഞ്ച്: തീയതികൾ പാഴ്‌സിംഗ്](https://www.kaggle.com/rtatman/data-cleaning-challenge-parsing-dates/)
- [ഡാറ്റ ശുദ്ധീകരണ ചലഞ്ച്: ഡാറ്റ സ്കെയിൽ ചെയ്യൽ, നോർമലൈസ് ചെയ്യൽ](https://www.kaggle.com/rtatman/data-cleaning-challenge-scale-and-normalize-data)
## അസൈൻമെന്റ്
[ഫോമിൽ നിന്നുള്ള ഡാറ്റ വിലയിരുത്തൽ](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കപ്പെടണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
Reference in new issue View Git Blame Copy Permalink