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 'copilot/fix-serialize-javascript-vulnerability'
${ noResults }
Data-Science-For-Beginners/translations/ne/2-Working-With-Data/08-data-preparation/notebook.ipynb

4241 lines
160 KiB
Raw Permalink Blame History Escape

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "rQ8UhzFpgRra"
},
"source": [
"# डेटा तयारी\n",
"\n",
"[मूल नोटबुक स्रोत *डेटा साइन्स: डाटा साइन्सका लागि मेसिन लर्निङको परिचय, पायथन र मेसिन लर्निङ स्टुडियो, ली स्टटद्वारा*](https://github.com/leestott/intro-Datascience/blob/master/Course%20Materials/4-Cleaning_and_Manipulating-Reference.ipynb)\n",
"\n",
"## `DataFrame` जानकारी अन्वेषण गर्दै\n",
"\n",
"> **शिक्षण लक्ष्य:** यो उपविभागको अन्त्यसम्ममा, तपाईं pandas DataFrames मा संग्रहित डाटाको सामान्य जानकारी पत्ता लगाउन सहज हुनु पर्नेछ।\n",
"\n",
"जब तपाईंले आफ्नो डेटा pandas मा लोड गर्नुहुन्छ, यो सम्भवतः `DataFrame` मा हुनेछ। तर, यदि तपाईंको `DataFrame` मा ६०,००० पङ्क्ति र ४०० स्तम्भ छन् भने, तपाईंले काम गरिरहेको डाटाको बारेमा कसरी थाहा पाउनुहुन्छ? सौभाग्यवश, pandas ले `DataFrame` को समग्र जानकारी छिटो हेर्नका लागि केही सुविधाजनक उपकरणहरू प्रदान गर्दछ, साथै पहिलो केही र अन्तिम केही पङ्क्तिहरू पनि।\n",
"\n",
"यस कार्यक्षमता अन्वेषण गर्नका लागि, हामी Python को scikit-learn लाइब्रेरी आयात गर्नेछौं र एक प्रसिद्ध डाटासेट प्रयोग गर्नेछौं जुन प्रत्येक डेटा वैज्ञानिकले सयौं पटक देखेका छन्: ब्रिटिश जीवविज्ञानी रोनाल्ड फिशरको *Iris* डाटासेट, जुन उनले १९३६ मा \"The use of multiple measurements in taxonomic problems\" नामक कागजमा प्रयोग गरेका थिए:\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"collapsed": true,
"id": "hB1RofhdgRrp",
"trusted": false
},
"outputs": [],
"source": [
"import pandas as pd\n",
"from sklearn.datasets import load_iris\n",
"\n",
"iris = load_iris()\n",
"iris_df = pd.DataFrame(data=iris['data'], columns=iris['feature_names'])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "AGA0A_Y8hMdz"
},
"source": [
"### `DataFrame.shape`\n",
"हामीले Iris Dataset लाई `iris_df` भेरिएबलमा लोड गरेका छौं। डाटामा गहिराइमा जानु अघि, हामीसँग कति डाटापोइन्टहरू छन् र डाटासेटको कुल आकार कति छ भन्ने जान्नु महत्त्वपूर्ण हुनेछ। हामीले सामना गरिरहेको डाटाको परिमाण हेर्नु उपयोगी हुन्छ।\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "LOe5jQohhulf",
"outputId": "fb0577ac-3b4a-4623-cb41-20e1b264b3e9"
},
"outputs": [
{
"data": {
"text/plain": [
"(150, 4)"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.shape"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "smE7AGzOhxk2"
},
"source": [
"त्यसैले, हामी १५० पंक्ति र ४ स्तम्भको डेटा संग काम गरिरहेका छौं। प्रत्येक पंक्ति एक डेटा बिन्दुलाई प्रतिनिधित्व गर्दछ र प्रत्येक स्तम्भ डेटा फ्रेमसँग सम्बन्धित एकल विशेषता प्रतिनिधित्व गर्दछ। त्यसैले आधारभूत रूपमा, त्यहाँ १५० डेटा बिन्दुहरू छन् जसमा प्रत्येकमा ४ विशेषताहरू छन्।\n",
"\n",
"`shape` यहाँ डेटा फ्रेमको एक गुण हो र कुनै फङ्सन होइन, यही कारणले यसले जोडी कोष्ठकमा अन्त्य गर्दैन।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "d3AZKs0PinGP"
},
"source": [
"### `DataFrame.columns`\n",
"अब हामी डाटाका ४ स्तम्भहरूमा प्रवेश गरौं। ती प्रत्येकले वास्तवमा के प्रतिनिधित्व गर्छन्? `columns` गुणले हामीलाई डाटाफ्रेममा स्तम्भहरूको नाम दिन्छ।\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "YPGh_ziji-CY",
"outputId": "74e7a43a-77cc-4c80-da56-7f50767c37a0"
},
"outputs": [
{
"data": {
"text/plain": [
"Index(['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)',\n",
" 'petal width (cm)'],\n",
" dtype='object')"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.columns"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "TsobcU_VjCC_"
},
"source": [
"जस्तो कि हामी देख्न सक्छौं, त्यहाँ चार(४) स्तम्भहरू छन्। `columns` विशेषताले हामीलाई स्तम्भहरूको नाम बताउँछ र आधारभूत रूपमा अरू केही बताउँदैन। यो विशेषता महत्वपूर्ण हुन्छ जब हामी कुनै डेटासेटले समावेश गर्ने विशेषताहरू पहिचान गर्न चाहन्छौं।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "2UTlvkjmgRrs"
},
"source": [
"### `DataFrame.info`\n",
"डाटाको मात्रा (`shape` attribute ले दिएको) र विशेषता वा स्तम्भहरूको नाम (`columns` attribute ले दिएको) ले हामीलाई डेटासेटको बारेमा केही जानकारी दिन्छ। अब, हामी डेटासेटमा अझ गहिरो रूपमा जान चाहन्छौं। `DataFrame.info()` फंक्शन यसका लागि निकै उपयोगी छ।\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "dHHRyG0_gRrt",
"outputId": "d8fb0c40-4f18-4e19-da48-c8db77d1d3a5",
"trusted": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'pandas.core.frame.DataFrame'>\n",
"RangeIndex: 150 entries, 0 to 149\n",
"Data columns (total 4 columns):\n",
" # Column Non-Null Count Dtype \n",
"--- ------ -------------- ----- \n",
" 0 sepal length (cm) 150 non-null float64\n",
" 1 sepal width (cm) 150 non-null float64\n",
" 2 petal length (cm) 150 non-null float64\n",
" 3 petal width (cm) 150 non-null float64\n",
"dtypes: float64(4)\n",
"memory usage: 4.8 KB\n"
]
}
],
"source": [
"iris_df.info()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "1XgVMpvigRru"
},
"source": [
"यहाँबाट, हामी केही अवलोकनहरू गर्न सक्छौं:\n",
"1. प्रत्येक स्तम्भको डेटा प्रकार: यस डेटासेटमा, सबै डेटा 64-बिट फ्लोटिङ-पोइन्ट संख्याहरूको रूपमा संग्रहित गरिएको छ।\n",
"2. गैर-नल मानहरूको संख्या: नल मानहरूलाई व्यवस्थापन गर्नु डेटा तयारीको महत्त्वपूर्ण चरण हो। यसलाई पछि नोटबुकमा सम्बोधन गरिनेछ।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "IYlyxbpWFEF4"
},
"source": [
"### DataFrame.describe()\n",
"मानौं हाम्रो डेटासेटमा धेरै संख्यात्मक डाटा छ। प्रत्येक स्तम्भमा अलग-अलग रूपमा औसत, माध्यिका, चौथाई भागहरू जस्ता एकपक्षीय सांख्यिकीय गणनाहरू गर्न सकिन्छ। `DataFrame.describe()` फङ्सनले हामीलाई डेटासेटका संख्यात्मक स्तम्भहरूको सांख्यिकीय सारांश प्रदान गर्दछ।\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 297
},
"id": "tWV-CMstFIRA",
"outputId": "4fc49941-bc13-4b0c-a412-cb39e7d3f289"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>sepal length (cm)</th>\n",
" <th>sepal width (cm)</th>\n",
" <th>petal length (cm)</th>\n",
" <th>petal width (cm)</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>count</th>\n",
" <td>150.000000</td>\n",
" <td>150.000000</td>\n",
" <td>150.000000</td>\n",
" <td>150.000000</td>\n",
" </tr>\n",
" <tr>\n",
" <th>mean</th>\n",
" <td>5.843333</td>\n",
" <td>3.057333</td>\n",
" <td>3.758000</td>\n",
" <td>1.199333</td>\n",
" </tr>\n",
" <tr>\n",
" <th>std</th>\n",
" <td>0.828066</td>\n",
" <td>0.435866</td>\n",
" <td>1.765298</td>\n",
" <td>0.762238</td>\n",
" </tr>\n",
" <tr>\n",
" <th>min</th>\n",
" <td>4.300000</td>\n",
" <td>2.000000</td>\n",
" <td>1.000000</td>\n",
" <td>0.100000</td>\n",
" </tr>\n",
" <tr>\n",
" <th>25%</th>\n",
" <td>5.100000</td>\n",
" <td>2.800000</td>\n",
" <td>1.600000</td>\n",
" <td>0.300000</td>\n",
" </tr>\n",
" <tr>\n",
" <th>50%</th>\n",
" <td>5.800000</td>\n",
" <td>3.000000</td>\n",
" <td>4.350000</td>\n",
" <td>1.300000</td>\n",
" </tr>\n",
" <tr>\n",
" <th>75%</th>\n",
" <td>6.400000</td>\n",
" <td>3.300000</td>\n",
" <td>5.100000</td>\n",
" <td>1.800000</td>\n",
" </tr>\n",
" <tr>\n",
" <th>max</th>\n",
" <td>7.900000</td>\n",
" <td>4.400000</td>\n",
" <td>6.900000</td>\n",
" <td>2.500000</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n",
"count 150.000000 150.000000 150.000000 150.000000\n",
"mean 5.843333 3.057333 3.758000 1.199333\n",
"std 0.828066 0.435866 1.765298 0.762238\n",
"min 4.300000 2.000000 1.000000 0.100000\n",
"25% 5.100000 2.800000 1.600000 0.300000\n",
"50% 5.800000 3.000000 4.350000 1.300000\n",
"75% 6.400000 3.300000 5.100000 1.800000\n",
"max 7.900000 4.400000 6.900000 2.500000"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.describe()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "zjjtW5hPGMuM"
},
"source": [
"माथिको आउटपुटले प्रत्येक स्तम्भको कुल डेटा बिन्दुहरूको संख्या, औसत, मानक विचलन, न्यूनतम, तल्लो क्वार्टाइल (२५%), माध्य (५०%), माथिल्लो क्वार्टाइल (७५%) र अधिकतम मान देखाउँछ।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "-lviAu99gRrv"
},
"source": [
"### `DataFrame.head`\n",
"माथिका सबै फंक्शनहरू र एट्रिब्युटहरू प्रयोग गरेर, हामीले डेटासेटको उच्च स्तरको दृष्टिकोण प्राप्त गरेका छौं। हामीलाई थाहा छ कति डेटा पोइन्टहरू छन्, कति विशेषताहरू छन्, प्रत्येक विशेषताको डेटा प्रकार के हो, र प्रत्येक विशेषताका लागि कति गैर-शून्य मानहरू छन्।\n",
"\n",
"अब डेटा आफैं हेर्ने समय आएको छ। हाम्रो `DataFrame` का पहिलो केही पङ्क्तिहरू (पहिलो केही डेटा पोइन्टहरू) कस्तो देखिन्छन् हेर्नुहोस्:\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "DZMJZh0OgRrw",
"outputId": "d9393ee5-c106-4797-f815-218f17160e00",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>sepal length (cm)</th>\n",
" <th>sepal width (cm)</th>\n",
" <th>petal length (cm)</th>\n",
" <th>petal width (cm)</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>5.1</td>\n",
" <td>3.5</td>\n",
" <td>1.4</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>4.9</td>\n",
" <td>3.0</td>\n",
" <td>1.4</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>4.7</td>\n",
" <td>3.2</td>\n",
" <td>1.3</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>4.6</td>\n",
" <td>3.1</td>\n",
" <td>1.5</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>5.0</td>\n",
" <td>3.6</td>\n",
" <td>1.4</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n",
"0 5.1 3.5 1.4 0.2\n",
"1 4.9 3.0 1.4 0.2\n",
"2 4.7 3.2 1.3 0.2\n",
"3 4.6 3.1 1.5 0.2\n",
"4 5.0 3.6 1.4 0.2"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.head()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "EBHEimZuEFQK"
},
"source": [
"यहाँको नतिजामा, हामीले डेटासेटका पाँच(५) इन्ट्रीहरू देख्न सक्छौं। यदि हामी बायाँतिरको इन्डेक्स हेर्छौं भने, हामी पत्ता लगाउँछौं कि यी पहिलो पाँच पंक्तिहरू हुन्।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "oj7GkrTdgRry"
},
"source": [
"### अभ्यास:\n",
"\n",
"माथि दिइएको उदाहरणबाट स्पष्ट छ कि, डिफल्ट रूपमा, `DataFrame.head` ले `DataFrame` का पहिलो पाँच पङ्क्तिहरू फिर्ता गर्छ। तलको कोड सेलमा, के तपाईं पाँचभन्दा बढी पङ्क्तिहरू प्रदर्शन गर्ने तरिका पत्ता लगाउन सक्नुहुन्छ?\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": true,
"id": "EKRmRFFegRrz",
"trusted": false
},
"outputs": [],
"source": [
"# Hint: Consult the documentation by using iris_df.head?"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "BJ_cpZqNgRr1"
},
"source": [
"### `DataFrame.tail`\n",
"डेटा हेर्ने अर्को तरिका अन्त्यबाट (सुरुवातको सट्टा) हुन सक्छ। `DataFrame.head` को उल्टो पक्ष `DataFrame.tail` हो, जसले `DataFrame` का अन्तिम पाँच पंक्तिहरू फिर्ता गर्छ:\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "heanjfGWgRr2",
"outputId": "6ae09a21-fe09-4110-b0d7-1a1fbf34d7f3",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>sepal length (cm)</th>\n",
" <th>sepal width (cm)</th>\n",
" <th>petal length (cm)</th>\n",
" <th>petal width (cm)</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>145</th>\n",
" <td>6.7</td>\n",
" <td>3.0</td>\n",
" <td>5.2</td>\n",
" <td>2.3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>146</th>\n",
" <td>6.3</td>\n",
" <td>2.5</td>\n",
" <td>5.0</td>\n",
" <td>1.9</td>\n",
" </tr>\n",
" <tr>\n",
" <th>147</th>\n",
" <td>6.5</td>\n",
" <td>3.0</td>\n",
" <td>5.2</td>\n",
" <td>2.0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>148</th>\n",
" <td>6.2</td>\n",
" <td>3.4</td>\n",
" <td>5.4</td>\n",
" <td>2.3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>149</th>\n",
" <td>5.9</td>\n",
" <td>3.0</td>\n",
" <td>5.1</td>\n",
" <td>1.8</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n",
"145 6.7 3.0 5.2 2.3\n",
"146 6.3 2.5 5.0 1.9\n",
"147 6.5 3.0 5.2 2.0\n",
"148 6.2 3.4 5.4 2.3\n",
"149 5.9 3.0 5.1 1.8"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.tail()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "31kBWfyLgRr3"
},
"source": [
"व्यवहारमा, `DataFrame` का पहिलो केही पङ्क्तिहरू वा अन्तिम केही पङ्क्तिहरू सजिलैसँग जाँच गर्न सक्षम हुनु उपयोगी हुन्छ, विशेष गरी जब तपाईं क्रमबद्ध डेटासेटहरूमा असामान्य मानहरू खोज्दै हुनुहुन्छ। \n",
"\n",
"माथि कोड उदाहरणहरूको मद्दतले देखाइएका सबै कार्यहरू र विशेषताहरूले हामीलाई डेटा हेर्न र बुझ्न मद्दत गर्छ। \n",
"\n",
"> **मुख्य कुरा:** केवल `DataFrame` मा भएको जानकारीको मेटाडेटा हेरेर वा यसको पहिलो र अन्तिम केही मानहरू हेरेर पनि, तपाईंले आफूले काम गरिरहेको डेटाको आकार, संरचना, र सामग्रीको बारेमा तुरुन्तै धारणा बनाउन सक्नुहुन्छ।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "TvurZyLSDxq_"
},
"source": [
"### हराएको डेटा\n",
"आउनुहोस्, हराएको डेटा बारे छलफल गरौं। हराएको डेटा तब हुन्छ जब केही स्तम्भहरूमा कुनै मान राखिएको हुँदैन।\n",
"\n",
"उदाहरण लिऔं: मानौं कसैलाई आफ्नो तौलको बारेमा धेरै चिन्ता छ र उसले सर्वेक्षणमा तौलको क्षेत्र भर्दैन। त्यस अवस्थामा, उक्त व्यक्तिको तौलको मान हराएको हुनेछ।\n",
"\n",
"अधिकांश समय, वास्तविक संसारका डेटासेटहरूमा हराएका मानहरू देखिन्छन्।\n",
"\n",
"**Pandas ले हराएको डेटा कसरी व्यवस्थापन गर्छ**\n",
"\n",
"Pandas ले हराएका मानहरूलाई दुई तरिकाले व्यवस्थापन गर्छ। पहिलो तरिका तपाईंले पहिलेका खण्डहरूमा देख्नुभएको छ: `NaN`, अर्थात् Not a Number। यो वास्तवमा IEEE floating-point विशिष्टताको एक विशेष मान हो र यो केवल हराएका floating-point मानहरूलाई संकेत गर्न प्रयोग गरिन्छ।\n",
"\n",
"Floating-point बाहेकका हराएका मानहरूको लागि, pandas ले Python को `None` वस्तु प्रयोग गर्छ। दुई फरक प्रकारका मानहरू देख्नुपर्दा अलि भ्रमित लाग्न सक्छ, तर यो डिजाइन विकल्पका लागि ठोस प्रोग्रामिङ कारणहरू छन्। व्यवहारमा, यसले pandas लाई अधिकांश केसहरूका लागि राम्रो सन्तुलन प्रदान गर्न सक्षम बनाउँछ। यद्यपि, `None` र `NaN` दुवैसँग केही सीमाहरू छन् जसको बारेमा तपाईं सचेत हुनुपर्छ कि तिनीहरूलाई कसरी प्रयोग गर्न सकिन्छ।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "lOHqUlZFgRr5"
},
"source": [
"### `None`: गैर-फ्लोट हराएको डेटा\n",
"किनभने `None` Python बाट आउँछ, यसलाई NumPy र pandas का arrays मा प्रयोग गर्न सकिँदैन जुन डेटा प्रकार `'object'` होइन। सम्झनुहोस्, NumPy arrays (र pandas मा रहेका डेटा संरचनाहरू) मा केवल एक प्रकारको डेटा मात्र समावेश गर्न सकिन्छ। यही कारणले तिनीहरूलाई ठूलो-स्तरको डेटा र गणनात्मक कामको लागि अत्यधिक शक्ति दिन्छ, तर यसले तिनीहरूको लचिलोपनलाई सीमित पनि गर्छ। यस्ता arrays ले \"सबभन्दा सामान्य डिनोमिनेटर,\" अर्थात् डेटा प्रकार जसले array मा सबै कुरा समेट्न सक्छ, मा अपकास्ट गर्नुपर्छ। जब `None` array मा हुन्छ, यसको मतलब तपाईं Python objects सँग काम गरिरहनुभएको छ।\n",
"\n",
"यसलाई व्यवहारमा देख्नको लागि, निम्न उदाहरण array विचार गर्नुहोस् (यसको `dtype` मा ध्यान दिनुहोस्):\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "QIoNdY4ngRr7",
"outputId": "92779f18-62f4-4a03-eca2-e9a101604336",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"array([2, None, 6, 8], dtype=object)"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import numpy as np\n",
"\n",
"example1 = np.array([2, None, 6, 8])\n",
"example1"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "pdlgPNbhgRr7"
},
"source": [
"अपकास्ट डाटा प्रकारहरूको वास्तविकताले दुई प्रकारका प्रभावहरू ल्याउँछ। पहिलो, अपरेशनहरू व्याख्या गरिएको Python कोडको स्तरमा गरिन्छ, कम्पाइल गरिएको NumPy कोडको स्तरमा होइन। यसको मतलब, `Series` वा `DataFrames` मा `None` समावेश भएका अपरेशनहरू सुस्त हुनेछन्। यद्यपि तपाईंले यो प्रदर्शनमा आएको असरलाई सायद महसुस गर्नुहुने छैन, ठूला डाटासेटहरूमा यो समस्या हुन सक्छ।\n",
"\n",
"दोस्रो प्रभाव पहिलोबाट उत्पन्न हुन्छ। किनभने `None` ले `Series` वा `DataFrame`s लाई सामान्य Python को दुनियाँमा फर्काउँछ, त्यसैले NumPy/pandas को `sum()` वा `min()` जस्ता समग्र गणनाहरू प्रयोग गर्दा, यदि array मा ``None`` मान हुन्छ भने सामान्यतया त्रुटि उत्पन्न हुन्छ:\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 292
},
"id": "gWbx-KB9gRr8",
"outputId": "ecba710a-22ec-41d5-a39c-11f67e645b50",
"trusted": false
},
"outputs": [
{
"ename": "TypeError",
"evalue": "ignored",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-10-ce9901ad18bd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mexample1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numpy/core/_methods.py\u001b[0m in \u001b[0;36m_sum\u001b[0;34m(a, axis, dtype, out, keepdims, initial, where)\u001b[0m\n\u001b[1;32m 45\u001b[0m def _sum(a, axis=None, dtype=None, out=None, keepdims=False,\n\u001b[1;32m 46\u001b[0m initial=_NoValue, where=True):\n\u001b[0;32m---> 47\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mumr_sum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwhere\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 48\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 49\u001b[0m def _prod(a, axis=None, dtype=None, out=None, keepdims=False,\n",
"\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'NoneType'"
]
}
],
"source": [
"example1.sum()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "LcEwO8UogRr9"
},
"source": [
"**मुख्य कुरा**: पूर्णांक र `None` मानहरू बीचको थप (र अन्य अपरेशनहरू) अपरिभाषित हुन्छ, जसले ती समावेश गर्ने डाटासेटहरूसँग के गर्न सकिन्छ भन्ने सीमित गर्न सक्छ।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "pWvVHvETgRr9"
},
"source": [
"### `NaN`: हराएको फ्लोट मानहरू\n",
"\n",
"`None` को विपरीत, NumPy (र त्यसैले pandas) ले यसको छिटो, भेक्टराइज्ड अपरेशनहरू र ufuncs को लागि `NaN` समर्थन गर्दछ। नराम्रो समाचार भनेको `NaN` मा गरिने कुनै पनि अंकगणितीय कार्यले सधैं `NaN` नै परिणाम दिन्छ। उदाहरणका लागि:\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "rcFYfMG9gRr9",
"outputId": "699e81b7-5c11-4b46-df1d-06071768690f",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"nan"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.nan + 1"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "BW3zQD2-gRr-",
"outputId": "4525b6c4-495d-4f7b-a979-efce1dae9bd0",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"nan"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.nan * 0"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "fU5IPRcCgRr-"
},
"source": [
"राम्रो खबर: `NaN` भएको एरेहरूमा चल्ने समग्रहरू त्रुटिहरू देखाउँदैनन्। नराम्रो खबर: परिणामहरू समान रूपमा उपयोगी हुँदैनन्:\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "LCInVgSSgRr_",
"outputId": "fa06495a-0930-4867-87c5-6023031ea8b5",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"(nan, nan, nan)"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example2 = np.array([2, np.nan, 6, 8]) \n",
"example2.sum(), example2.min(), example2.max()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "nhlnNJT7gRr_"
},
"source": [
"### व्यायाम:\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": true,
"id": "yan3QRaOgRr_",
"trusted": false
},
"outputs": [],
"source": [
"# What happens if you add np.nan and None together?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "_iDvIRC8gRsA"
},
"source": [
"सम्झनुहोस्: `NaN` केवल हराइरहेका फ्लोटिङ-पोइन्ट मानहरूको लागि हो; पूर्णांक, स्ट्रिङ, वा बूलियनहरूको लागि `NaN` बराबर केही छैन।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "kj6EKdsAgRsA"
},
"source": [
"### `NaN` र `None`: pandas मा null मानहरू\n",
"\n",
"यद्यपि `NaN` र `None` केही हदसम्म फरक व्यवहार गर्न सक्छन्, pandas तिनीहरूलाई परस्पर रूपमा व्यवस्थापन गर्न बनाइएको छ। हामीले के भन्न खोजेका छौं बुझ्नको लागि, एक `Series` को पूर्णांकहरूको उदाहरण हेर्नुहोस्:\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "Nji-KGdNgRsA",
"outputId": "36aa14d2-8efa-4bfd-c0ed-682991288822",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"0 1\n",
"1 2\n",
"2 3\n",
"dtype: int64"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"int_series = pd.Series([1, 2, 3], dtype=int)\n",
"int_series"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "WklCzqb8gRsB"
},
"source": [
"### व्यायाम:\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"collapsed": true,
"id": "Cy-gqX5-gRsB",
"trusted": false
},
"outputs": [],
"source": [
"# Now set an element of int_series equal to None.\n",
"# How does that element show up in the Series?\n",
"# What is the dtype of the Series?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "WjMQwltNgRsB"
},
"source": [
"`Series` र `DataFrame` मा डाटा समानता कायम गर्न डाटा प्रकारलाई अपकास्ट गर्ने प्रक्रियामा, pandas ले हराएका मानहरूलाई `None` र `NaN` बीच सजिलै परिवर्तन गर्न सक्छ। यस डिजाइन सुविधाका कारण, pandas मा `None` र `NaN` लाई \"null\" का दुई फरक प्रकारका रूपमा सोच्नु उपयोगी हुन सक्छ। वास्तवमा, pandas मा हराएका मानहरूलाई व्यवस्थापन गर्न प्रयोग गरिने केही मुख्य विधिहरूले यस विचारलाई आफ्नो नाममा प्रतिबिम्बित गर्छन्:\n",
"\n",
"- `isnull()`: हराएका मानहरूलाई संकेत गर्ने बूलियन मास्क उत्पन्न गर्छ\n",
"- `notnull()`: `isnull()` को विपरीत\n",
"- `dropna()`: डाटाको फिल्टर गरिएको संस्करण फर्काउँछ\n",
"- `fillna()`: हराएका मानहरू भरेर वा अनुमान गरेर डाटाको प्रतिलिपि फर्काउँछ\n",
"\n",
"यी विधिहरूलाई राम्रोसँग बुझ्न र प्रयोग गर्न सिक्नु महत्त्वपूर्ण छ, त्यसैले अब हामी यी प्रत्येकलाई विस्तारमा बुझ्ने प्रयास गरौं।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Yh5ifd9FgRsB"
},
"source": [
"### शून्य मानहरू पत्ता लगाउँदै\n",
"\n",
"अब हामीले हराएका मानहरूको महत्त्व बुझिसकेपछि, तिनीहरूलाई व्यवस्थापन गर्नुअघि हाम्रो डेटासेटमा तिनीहरूलाई पत्ता लगाउन आवश्यक छ। \n",
"`isnull()` र `notnull()` दुबै शून्य डाटा पत्ता लगाउनका लागि मुख्य विधिहरू हुन्। दुबैले तपाईंको डाटामा Boolean मास्कहरू फर्काउँछन्।\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"collapsed": true,
"id": "e-vFp5lvgRsC",
"trusted": false
},
"outputs": [],
"source": [
"example3 = pd.Series([0, np.nan, '', None])"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "1XdaJJ7PgRsC",
"outputId": "92fc363a-1874-471f-846d-f4f9ce1f51d0",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"0 False\n",
"1 True\n",
"2 False\n",
"3 True\n",
"dtype: bool"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example3.isnull()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "PaSZ0SQygRsC"
},
"source": [
"आउटपुटलाई ध्यानपूर्वक हेर्नुहोस्। के यसमा कुनै कुरा तपाईंलाई अचम्म लाग्छ? जबकि `0` एक गणितीय शून्य हो, यो अझै पनि एक राम्रो पूर्णांक हो र pandas ले यसलाई त्यस्तै व्यवहार गर्छ। `''` भने अलि सूक्ष्म छ। हामीले यसलाई खण्ड १ मा खाली स्ट्रिङ मानको रूपमा प्रयोग गरेका थियौं, तर pandas को दृष्टिकोणले यो खालीको प्रतिनिधित्व होइन, यो स्ट्रिङ वस्तु हो।\n",
"\n",
"अब, यसलाई उल्ट्याएर यी विधिहरूलाई व्यवहारमा जस्तै प्रयोग गरिन्छ त्यसरी प्रयोग गरौं। तपाईं Boolean मास्कहरूलाई सिधै ``Series`` वा ``DataFrame`` को इन्डेक्सको रूपमा प्रयोग गर्न सक्नुहुन्छ, जुन छुट्टै हराएका (वा उपस्थित) मानहरूसँग काम गर्दा उपयोगी हुन सक्छ।\n",
"\n",
"यदि हामीलाई हराएका मानहरूको कुल संख्या चाहिन्छ भने, हामी `isnull()` विधिले उत्पादन गरेको मास्कमा सिधै sum गर्न सक्छौं।\n"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "JCcQVoPkHDUv",
"outputId": "001daa72-54f8-4bd5-842a-4df627a79d4d"
},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example3.isnull().sum()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "PlBqEo3mgRsC"
},
"source": [
"### व्यायाम:\n"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": true,
"id": "ggDVf5uygRsD",
"trusted": false
},
"outputs": [],
"source": [
"# Try running example3[example3.notnull()].\n",
"# Before you do so, what do you expect to see?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "D_jWN7mHgRsD"
},
"source": [
"**मुख्य कुरा**: दुवै `isnull()` र `notnull()` विधिहरूले DataFrames मा प्रयोग गर्दा समान परिणामहरू उत्पादन गर्छन्: तिनीहरूले परिणामहरू र ती परिणामहरूको सूचकांक देखाउँछन्, जसले तपाईंलाई तपाईंको डाटासँग संघर्ष गर्दा अत्यधिक मद्दत गर्नेछ।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "BvnoojWsgRr4"
},
"source": [
"### हराएको डाटासँग व्यवहार गर्ने\n",
"\n",
"> **अध्ययनको लक्ष्य:** यो उपविभागको अन्त्यसम्ममा, तपाईंले DataFrames बाट null मानहरू कहिले र कसरी प्रतिस्थापन गर्ने वा हटाउने भन्ने कुरा जान्नुपर्नेछ।\n",
"\n",
"मेसिन लर्निङ मोडेलहरूले आफैं हराएको डाटासँग व्यवहार गर्न सक्दैनन्। त्यसैले, मोडेलमा डाटा पठाउनु अघि, हामीले यी हराएका मानहरूलाई व्यवस्थापन गर्नुपर्छ।\n",
"\n",
"हराएको डाटालाई कसरी व्यवस्थापन गरिन्छ भन्ने कुराले सानो तर महत्वपूर्ण प्रभाव पार्छ, जसले तपाईंको अन्तिम विश्लेषण र वास्तविक संसारको परिणामलाई असर गर्न सक्छ।\n",
"\n",
"हराएको डाटासँग व्यवहार गर्ने मुख्यत: दुई तरिका छन्:\n",
"\n",
"1. हराएको मान भएको पङ्क्ति हटाउनुहोस्\n",
"2. हराएको मानलाई कुनै अन्य मानले प्रतिस्थापन गर्नुहोस्\n",
"\n",
"हामी यी दुवै विधिहरू र तिनका फाइदा र बेफाइदाको विस्तृत रूपमा चर्चा गर्नेछौं।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "3VaYC1TvgRsD"
},
"source": [
"### खाली मानहरू हटाउने\n",
"\n",
"हामीले हाम्रो मोडेललाई दिने डाटाको मात्रा यसको प्रदर्शनमा सीधा प्रभाव पार्छ। खाली मानहरू हटाउनु भनेको हामीले डाटापोइन्टहरूको संख्या घटाउनु हो, जसले गर्दा डेटासेटको आकार पनि घट्छ। त्यसैले, जब डेटासेट धेरै ठूलो हुन्छ, खाली मान भएका पङ्क्तिहरू हटाउनु सल्लाहयोग्य हुन्छ।\n",
"\n",
"अर्को उदाहरण हुन सक्छ कि कुनै निश्चित पङ्क्ति वा स्तम्भमा धेरै हराएका मानहरू छन्। त्यस अवस्थामा, ती हटाउन सकिन्छ किनभने ती पङ्क्ति/स्तम्भको अधिकांश डाटा हराएको हुँदा हाम्रो विश्लेषणमा धेरै मूल्य थप्दैन।\n",
"\n",
"हराएका मानहरू पहिचान गर्न बाहेक, pandas ले `Series` र `DataFrame`s बाट खाली मानहरू हटाउनको लागि सुविधाजनक उपाय प्रदान गर्दछ। यसलाई व्यवहारमा देख्नको लागि, हामी `example3` मा फर्कौं। `DataFrame.dropna()` फङ्क्सनले खाली मान भएका पङ्क्तिहरू हटाउन मद्दत गर्दछ।\n"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "7uIvS097gRsD",
"outputId": "c13fc117-4ca1-4145-a0aa-42ac89e6e218",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"0 0\n",
"2 \n",
"dtype: object"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example3 = example3.dropna()\n",
"example3"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "hil2cr64gRsD"
},
"source": [
"ध्यान दिनुहोस् कि यो `example3[example3.notnull()]` को नतिजा जस्तै देखिनु पर्छ। यहाँको फरक के छ भने, केवल मास्क गरिएको मानहरूमा इन्डेक्सिङ गर्ने सट्टा, `dropna` ले `Series` `example3` बाट ती हराएका मानहरू हटाएको छ।\n",
"\n",
"किनभने DataFrames दुई आयामहरूमा हुन्छन्, तिनीहरूले डेटा हटाउनका लागि थप विकल्पहरू प्रदान गर्छन्।\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "an-l74sPgRsE",
"outputId": "340876a0-63ad-40f6-bd54-6240cdae50ab",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>NaN</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>6.0</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 1.0 NaN 7\n",
"1 2.0 5.0 8\n",
"2 NaN 6.0 9"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4 = pd.DataFrame([[1, np.nan, 7], \n",
" [2, 5, 8], \n",
" [np.nan, 6, 9]])\n",
"example4"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "66wwdHZrgRsE"
},
"source": [
"(के तपाईंले ध्यान दिनुभयो कि pandas ले `NaN`s समायोजन गर्न दुई स्तम्भहरूलाई floats मा परिवर्तन गर्यो?)\n",
"\n",
"तपाईं `DataFrame` बाट एकल मान हटाउन सक्नुहुन्न, त्यसैले तपाईंले पूर्ण पंक्ति वा स्तम्भहरू हटाउनुपर्छ। तपाईंले के गर्दै हुनुहुन्छ भन्ने आधारमा, तपाईंले एउटा वा अर्को गर्न चाहनुहुन्छ, र त्यसैले pandas ले तपाईंलाई दुवैको विकल्प दिन्छ। किनभने डेटा विज्ञानमा, स्तम्भहरूले सामान्यतया चरहरू प्रतिनिधित्व गर्छन् र पंक्तिहरूले अवलोकनहरू प्रतिनिधित्व गर्छन्, तपाईं डेटा पंक्तिहरू हटाउन बढी सम्भावना राख्नुहुन्छ; `dropna()` को डिफल्ट सेटिङले कुनै पनि null मानहरू समावेश गर्ने सबै पंक्तिहरू हटाउँछ:\n"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 80
},
"id": "jAVU24RXgRsE",
"outputId": "0b5e5aee-7187-4d3f-b583-a44136ae5f80",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"1 2.0 5.0 8"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.dropna()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "TrQRBuTDgRsE"
},
"source": [
"यदि आवश्यक छ भने, तपाईं स्तम्भहरूबाट NA मानहरू हटाउन सक्नुहुन्छ। त्यसका लागि `axis=1` प्रयोग गर्नुहोस्:\n"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "GrBhxu9GgRsE",
"outputId": "ff4001f3-2e61-4509-d60e-0093d1068437",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>8</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 2\n",
"0 7\n",
"1 8\n",
"2 9"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.dropna(axis='columns')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "KWXiKTfMgRsF"
},
"source": [
"ध्यान दिनुहोस् कि यसले धेरै डाटा हटाउन सक्छ जुन तपाईं राख्न चाहनुहुन्छ, विशेष गरी साना डेटासेटहरूमा। यदि तपाईं केवल ती पङ्क्ति वा स्तम्भहरू हटाउन चाहनुहुन्छ जसमा धेरै वा सबै null मानहरू छन् भने के गर्ने? तपाईंले `dropna` मा `how` र `thresh` प्यारामिटरहरू सेट गरेर यो निर्दिष्ट गर्न सक्नुहुन्छ।\n",
"\n",
"डिफल्ट रूपमा, `how='any'` हुन्छ (यदि तपाईं आफैं जाँच गर्न चाहनुहुन्छ वा यो विधिमा अन्य प्यारामिटरहरू के छन् हेर्न चाहनुहुन्छ भने, कोड सेलमा `example4.dropna?` चलाउनुहोस्)। वैकल्पिक रूपमा, तपाईं `how='all'` निर्दिष्ट गर्न सक्नुहुन्छ ताकि केवल ती पङ्क्ति वा स्तम्भहरू हटाउन सकियोस् जसमा सबै null मानहरू छन्। आउँदो अभ्यासमा यो कसरी काम गर्छ भनेर हेर्नको लागि हामी हाम्रो उदाहरण `DataFrame` विस्तार गर्नेछौं।\n"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "Bcf_JWTsgRsF",
"outputId": "72e0b1b8-52fa-4923-98ce-b6fbed6e44b1",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>NaN</td>\n",
" <td>7</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>6.0</td>\n",
" <td>9</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"0 1.0 NaN 7 NaN\n",
"1 2.0 5.0 8 NaN\n",
"2 NaN 6.0 9 NaN"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4[3] = np.nan\n",
"example4"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "pNZer7q9JPNC"
},
"source": [
"> मुख्य बुँदाहरू: \n",
"1. खाली मानहरू हटाउनु राम्रो विचार हो केवल डेटा सेट पर्याप्त ठूलो भएमा। \n",
"2. पूर्ण पङ्क्ति वा स्तम्भहरू हटाउन सकिन्छ यदि तिनीहरूको अधिकांश डेटा हराएको छ भने। \n",
"3. `DataFrame.dropna(axis=)` विधिले खाली मानहरू हटाउन मद्दत गर्दछ। `axis` तर्कले पङ्क्ति हटाउने वा स्तम्भ हटाउने कुरा जनाउँछ। \n",
"4. `how` तर्क पनि प्रयोग गर्न सकिन्छ। डिफल्टमा यो `any` मा सेट गरिएको हुन्छ। त्यसैले, यो केवल ती पङ्क्ति/स्तम्भहरू हटाउँछ जसमा कुनै पनि खाली मानहरू छन्। यसलाई `all` मा सेट गर्न सकिन्छ जसले हामी केवल ती पङ्क्ति/स्तम्भहरू हटाउँछौं जहाँ सबै मानहरू खाली छन्। \n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "oXXSfQFHgRsF"
},
"source": [
"### व्यायाम:\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"collapsed": true,
"id": "ExUwQRxpgRsF",
"trusted": false
},
"outputs": [],
"source": [
"# How might you go about dropping just column 3?\n",
"# Hint: remember that you will need to supply both the axis parameter and the how parameter.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "38kwAihWgRsG"
},
"source": [
"`thresh` प्यारामिटरले तपाईंलाई सूक्ष्म नियन्त्रण दिन्छ: तपाईंले पंक्ति वा स्तम्भलाई राख्नको लागि आवश्यक *गैर-शून्य* मानहरूको संख्या सेट गर्नुहुन्छ:\n"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 80
},
"id": "M9dCNMaagRsG",
"outputId": "8093713a-54d2-4e54-c73f-4eea315cb6f2",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"1 2.0 5.0 8 NaN"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.dropna(axis='rows', thresh=3)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "fmSFnzZegRsG"
},
"source": [
"यहाँ, पहिलो र अन्तिम पंक्ति हटाइएको छ, किनभने तिनीहरूमा मात्र दुई गैर-शून्य मानहरू छन्।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "mCcxLGyUgRsG"
},
"source": [
"### खाली मानहरू भर्ने\n",
"\n",
"कहिलेकाहीँ हराएका मानहरूलाई यस्ता मानहरूद्वारा भर्नु उपयुक्त हुन्छ जुन वैध हुन सक्छ। खाली मानहरू भर्ने केही प्रविधिहरू छन्। पहिलो हो डोमेन ज्ञान (डाटासेट आधारित विषयको ज्ञान) प्रयोग गरेर हराएका मानहरूलाई कुनै प्रकारले अनुमान गर्नु।\n",
"\n",
"तपाईंले `isnull` प्रयोग गरेर यो काम गर्न सक्नुहुन्छ, तर यो धेरै श्रमसाध्य हुन सक्छ, विशेष गरी यदि तपाईंले धेरै मानहरू भर्नुपर्ने छ भने। किनकि यो डाटा विज्ञानमा धेरै सामान्य कार्य हो, pandas ले `fillna` प्रदान गर्दछ, जसले `Series` वा `DataFrame` को प्रतिलिपि फर्काउँछ जहाँ हराएका मानहरू तपाईंले रोजेको मानले प्रतिस्थापन गरिएका हुन्छन्। यसलाई व्यवहारमा कसरी काम गर्छ भनेर हेर्न अर्को उदाहरण `Series` सिर्जना गरौं।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "CE8S7louLezV"
},
"source": [
"### श्रेणीगत डेटा (गैर-संख्यात्मक)\n",
"पहिले गैर-संख्यात्मक डेटा विचार गरौं। डेटासेटहरूमा, हामीसँग श्रेणीगत डेटा भएका स्तम्भहरू हुन्छन्। जस्तै, लिङ्ग, सत्य वा असत्य आदि।\n",
"\n",
"यस्ता धेरै अवस्थामा, हामी हराएका मानहरूलाई स्तम्भको `mode` (सबभन्दा धेरै दोहोरिएको मान) द्वारा प्रतिस्थापन गर्छौं। मानौं, हामीसँग १०० डेटा बिन्दुहरू छन् र ९० जनाले सत्य भनेका छन्, ८ जनाले असत्य भनेका छन् र २ जनाले भरेका छैनन्। त्यस अवस्थामा, हामी ती २ लाई सत्यले भरिदिन सक्छौं, सम्पूर्ण स्तम्भलाई विचार गर्दै।\n",
"\n",
"फेरि, यहाँ हामी डोमेन ज्ञान प्रयोग गर्न सक्छौं। अब, `mode` द्वारा भरिदिने उदाहरणलाई विचार गरौं।\n"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "MY5faq4yLdpQ",
"outputId": "19ab472e-1eed-4de8-f8a7-db2a3af3cb1a"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1</td>\n",
" <td>2</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>3</td>\n",
" <td>4</td>\n",
" <td>None</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>5</td>\n",
" <td>6</td>\n",
" <td>False</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>7</td>\n",
" <td>8</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>9</td>\n",
" <td>10</td>\n",
" <td>True</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 1 2 True\n",
"1 3 4 None\n",
"2 5 6 False\n",
"3 7 8 True\n",
"4 9 10 True"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mode = pd.DataFrame([[1,2,\"True\"],\n",
" [3,4,None],\n",
" [5,6,\"False\"],\n",
" [7,8,\"True\"],\n",
" [9,10,\"True\"]])\n",
"\n",
"fill_with_mode"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "MLAoMQOfNPlA"
},
"source": [
"अब, पहिलोमा मोड पत्ता लगाऔं त्यसपछि `None` मानलाई मोडले भरौं।\n"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "WKy-9Y2tN5jv",
"outputId": "8da9fa16-e08c-447e-dea1-d4b1db2feebf"
},
"outputs": [
{
"data": {
"text/plain": [
"True 3\n",
"False 1\n",
"Name: 2, dtype: int64"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mode[2].value_counts()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "6iNz_zG_OKrx"
},
"source": [
"त्यसैले, हामी None लाई True संग बदल्नेछौं\n"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"id": "TxPKteRvNPOs"
},
"outputs": [],
"source": [
"fill_with_mode[2].fillna('True',inplace=True)"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "tvas7c9_OPWE",
"outputId": "ec3c8e44-d644-475e-9e22-c65101965850"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1</td>\n",
" <td>2</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>3</td>\n",
" <td>4</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>5</td>\n",
" <td>6</td>\n",
" <td>False</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>7</td>\n",
" <td>8</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>9</td>\n",
" <td>10</td>\n",
" <td>True</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 1 2 True\n",
"1 3 4 True\n",
"2 5 6 False\n",
"3 7 8 True\n",
"4 9 10 True"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mode"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "SktitLxxOR16"
},
"source": [
"जस्तो कि हामी देख्न सक्छौं, null मानलाई प्रतिस्थापन गरिएको छ। भन्नु नपर्ने कुरा हो, हामीले `'True'` को सट्टामा केही पनि लेख्न सक्थ्यौं र यो प्रतिस्थापित हुने थियो।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "heYe1I0dOmQ_"
},
"source": [
"### संख्यात्मक डेटा\n",
"अब, संख्यात्मक डेटाको कुरा गरौं। यहाँ, हराएको मानहरूलाई प्रतिस्थापन गर्ने दुई सामान्य तरिका छन्:\n",
"\n",
"1. पंक्तिको माध्यक (Median) प्रयोग गरेर प्रतिस्थापन गर्नुहोस् \n",
"2. पंक्तिको औसत (Mean) प्रयोग गरेर प्रतिस्थापन गर्नुहोस् \n",
"\n",
"यदि डेटा असमान छ र बाहिरका मानहरू (outliers) छन् भने, हामी माध्यक प्रयोग गरेर प्रतिस्थापन गर्छौं। यसको कारण, माध्यक बाहिरका मानहरू प्रति संवेदनशील हुँदैन।\n",
"\n",
"जब डेटा सामान्यीकृत (normalized) हुन्छ, हामी औसत प्रयोग गर्न सक्छौं, किनकि त्यस अवस्थामा औसत र माध्यक एकदमै नजिक हुनेछन्।\n",
"\n",
"पहिला, हामी एउटा स्तम्भ लिऔं जुन सामान्य रूपमा वितरण गरिएको छ र त्यस स्तम्भको हराएको मानलाई औसत प्रयोग गरेर भर्ने प्रयास गरौं।\n"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "09HM_2feOj5Y",
"outputId": "7e309013-9acb-411c-9b06-4de795bbeeff"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>-2.0</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>-1.0</td>\n",
" <td>2</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>4</td>\n",
" <td>5</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>1.0</td>\n",
" <td>6</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>2.0</td>\n",
" <td>8</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 -2.0 0 1\n",
"1 -1.0 2 3\n",
"2 NaN 4 5\n",
"3 1.0 6 7\n",
"4 2.0 8 9"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mean = pd.DataFrame([[-2,0,1],\n",
" [-1,2,3],\n",
" [np.nan,4,5],\n",
" [1,6,7],\n",
" [2,8,9]])\n",
"\n",
"fill_with_mean"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ka7-wNfzSxbx"
},
"source": [
"स्तम्भको औसत हो\n"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "XYtYEf5BSxFL",
"outputId": "68a78d18-f0e5-4a9a-a959-2c3676a57c70"
},
"outputs": [
{
"data": {
"text/plain": [
"0.0"
]
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.mean(fill_with_mean[0])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "oBSRGxKRS39K"
},
"source": [
"माध्यमसँग भरिरहेको।\n"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "FzncQLmuS5jh",
"outputId": "00f74fff-01f4-4024-c261-796f50f01d2e"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>-2.0</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>-1.0</td>\n",
" <td>2</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>0.0</td>\n",
" <td>4</td>\n",
" <td>5</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>1.0</td>\n",
" <td>6</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>2.0</td>\n",
" <td>8</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 -2.0 0 1\n",
"1 -1.0 2 3\n",
"2 0.0 4 5\n",
"3 1.0 6 7\n",
"4 2.0 8 9"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mean[0].fillna(np.mean(fill_with_mean[0]),inplace=True)\n",
"fill_with_mean"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "CwpVFCrPTC5z"
},
"source": [
"जस्तो कि हामी देख्न सक्छौं, हराएको मानलाई यसको औसतले प्रतिस्थापन गरिएको छ।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "jIvF13a1i00Z"
},
"source": [
"अब हामी अर्को डेटा फ्रेम प्रयास गरौं, र यस पटक हामी None मानहरूलाई स्तम्भको माध्यिका संग प्रतिस्थापन गर्नेछौं।\n"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "DA59Bqo3jBYZ",
"outputId": "85dae6ec-7394-4c36-fda0-e04769ec4a32"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>-2</td>\n",
" <td>0.0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>-1</td>\n",
" <td>2.0</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>0</td>\n",
" <td>NaN</td>\n",
" <td>5</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>1</td>\n",
" <td>6.0</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>2</td>\n",
" <td>8.0</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 -2 0.0 1\n",
"1 -1 2.0 3\n",
"2 0 NaN 5\n",
"3 1 6.0 7\n",
"4 2 8.0 9"
]
},
"execution_count": 35,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_median = pd.DataFrame([[-2,0,1],\n",
" [-1,2,3],\n",
" [0,np.nan,5],\n",
" [1,6,7],\n",
" [2,8,9]])\n",
"\n",
"fill_with_median"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "mM1GpXYmjHnc"
},
"source": [
"दोस्रो स्तम्भको मध्य मान हो\n"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "uiDy5v3xjHHX",
"outputId": "564b6b74-2004-4486-90d4-b39330a64b88"
},
"outputs": [
{
"data": {
"text/plain": [
"4.0"
]
},
"execution_count": 36,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_median[1].median()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "z9PLF75Jj_1s"
},
"source": [
"मध्य मानले भरिरहेको।\n"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "lFKbOxCMkBbg",
"outputId": "a8bd18fb-2765-47d4-e5fe-e965f57ed1f4"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>-2</td>\n",
" <td>0.0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>-1</td>\n",
" <td>2.0</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>0</td>\n",
" <td>4.0</td>\n",
" <td>5</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>1</td>\n",
" <td>6.0</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>2</td>\n",
" <td>8.0</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 -2 0.0 1\n",
"1 -1 2.0 3\n",
"2 0 4.0 5\n",
"3 1 6.0 7\n",
"4 2 8.0 9"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_median[1].fillna(fill_with_median[1].median(),inplace=True)\n",
"fill_with_median"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "8JtQ53GSkKWC"
},
"source": [
"जस्तो कि हामी देख्न सक्छौं, NaN मानलाई स्तम्भको माध्यिका द्वारा प्रतिस्थापन गरिएको छ।\n"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "0ybtWLDdgRsG",
"outputId": "b8c238ef-6024-4ee2-be2b-aa1f0fcac61d",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"a 1.0\n",
"b NaN\n",
"c 2.0\n",
"d NaN\n",
"e 3.0\n",
"dtype: float64"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example5 = pd.Series([1, np.nan, 2, None, 3], index=list('abcde'))\n",
"example5"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "yrsigxRggRsH"
},
"source": [
"तपाईंले सबै खाली प्रविष्टिहरूलाई एउटा मात्र मान, जस्तै `0` ले भर्न सक्नुहुन्छ:\n"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "KXMIPsQdgRsH",
"outputId": "aeedfa0a-a421-4c2f-cb0d-183ce8f0c91d",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"a 1.0\n",
"b 0.0\n",
"c 2.0\n",
"d 0.0\n",
"e 3.0\n",
"dtype: float64"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example5.fillna(0)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "RRlI5f_hkfKe"
},
"source": [
"> मुख्य बुँदाहरू:\n",
"1. हराएका मानहरू भर्ने काम तब मात्र गर्नुपर्छ जब डाटा कम छ वा हराएका डाटा भर्ने कुनै रणनीति छ। \n",
"2. डोमेन ज्ञान प्रयोग गरेर हराएका मानहरूलाई अनुमान गरेर भर्न सकिन्छ। \n",
"3. श्रेणीगत डाटाका लागि प्रायः हराएका मानहरू स्तम्भको मोडले प्रतिस्थापन गरिन्छ। \n",
"4. संख्यात्मक डाटाका लागि, हराएका मानहरू सामान्यत: औसत (सामान्यीकृत डाटासेटहरूका लागि) वा स्तम्भहरूको माध्यकले भर्ने गरिन्छ। \n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "FI9MmqFJgRsH"
},
"source": [
"### व्यायाम:\n"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"collapsed": true,
"id": "af-ezpXdgRsH",
"trusted": false
},
"outputs": [],
"source": [
"# What happens if you try to fill null values with a string, like ''?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "kq3hw1kLgRsI"
},
"source": [
"तपाईंले शून्य मानहरूलाई **फर्वार्ड-फिल** गर्न सक्नुहुन्छ, जसले अन्तिम मान्य मानलाई शून्य भर्न प्रयोग गर्दछ:\n"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "vO3BuNrggRsI",
"outputId": "e2bc591b-0b48-4e88-ee65-754f2737c196",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"a 1.0\n",
"b 1.0\n",
"c 2.0\n",
"d 2.0\n",
"e 3.0\n",
"dtype: float64"
]
},
"execution_count": 41,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example5.fillna(method='ffill')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "nDXeYuHzgRsI"
},
"source": [
"तपाईंले पनि **पछाडि-भर्न** गर्न सक्नुहुन्छ ताकि अर्को मान्य मानलाई पछाडि फैलाएर खाली स्थान भर्न सकिन्छ:\n"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "4M5onHcEgRsI",
"outputId": "8f32b185-40dd-4a9f-bd85-54d6b6a414fe",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"a 1.0\n",
"b 2.0\n",
"c 2.0\n",
"d 3.0\n",
"e 3.0\n",
"dtype: float64"
]
},
"execution_count": 42,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example5.fillna(method='bfill')"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true,
"id": "MbBzTom5gRsI"
},
"source": [
"जस्तो तपाईंले अनुमान गर्न सक्नुहुन्छ, यो DataFrames सँग पनि उस्तै काम गर्दछ, तर तपाईंले null मानहरू भर गर्नको लागि `axis` पनि निर्दिष्ट गर्न सक्नुहुन्छ:\n"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "aRpIvo4ZgRsI",
"outputId": "905a980a-a808-4eca-d0ba-224bd7d85955",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>NaN</td>\n",
" <td>7</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>6.0</td>\n",
" <td>9</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"0 1.0 NaN 7 NaN\n",
"1 2.0 5.0 8 NaN\n",
"2 NaN 6.0 9 NaN"
]
},
"execution_count": 43,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "VM1qtACAgRsI",
"outputId": "71f2ad28-9b4e-4ff4-f5c3-e731eb489ade",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>1.0</td>\n",
" <td>7.0</td>\n",
" <td>7.0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8.0</td>\n",
" <td>8.0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>6.0</td>\n",
" <td>9.0</td>\n",
" <td>9.0</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"0 1.0 1.0 7.0 7.0\n",
"1 2.0 5.0 8.0 8.0\n",
"2 NaN 6.0 9.0 9.0"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.fillna(method='ffill', axis=1)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ZeMc-I1EgRsI"
},
"source": [
"ध्यान दिनुहोस् कि जब अगाडिको-भराइको लागि अघिल्लो मान उपलब्ध छैन, खाली मान यथावत रहन्छ।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "eeAoOU0RgRsJ"
},
"source": [
"### व्यायाम:\n"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"collapsed": true,
"id": "e8S-CjW8gRsJ",
"trusted": false
},
"outputs": [],
"source": [
"# What output does example4.fillna(method='bfill', axis=1) produce?\n",
"# What about example4.fillna(method='ffill') or example4.fillna(method='bfill')?\n",
"# Can you think of a longer code snippet to write that can fill all of the null values in example4?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "YHgy0lIrgRsJ"
},
"source": [
"तपाईं `fillna` प्रयोग गर्ने तरिकामा सिर्जनशील हुन सक्नुहुन्छ। उदाहरणका लागि, फेरि `example4` हेर्नुहोस्, तर यस पटक `DataFrame` मा रहेका सबै मानहरूको औसतले हराएका मानहरू भर्न प्रयास गरौं:\n"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "OtYVErEygRsJ",
"outputId": "708b1e67-45ca-44bf-a5ee-8b2de09ece73",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>5.5</td>\n",
" <td>7</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>1.5</td>\n",
" <td>6.0</td>\n",
" <td>9</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"0 1.0 5.5 7 NaN\n",
"1 2.0 5.0 8 NaN\n",
"2 1.5 6.0 9 NaN"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.fillna(example4.mean())"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "zpMvCkLSgRsJ"
},
"source": [
"ध्यान दिनुहोस् कि स्तम्भ ३ अझै पनि खाली छ: डिफल्ट दिशा पङ्क्ति अनुसार मानहरू भर्ने हो।\n",
"\n",
"> **मुख्य कुरा:** तपाईंको डाटासेटमा हराएका मानहरूलाई व्यवस्थापन गर्न धेरै तरिकाहरू छन्। तपाईंले प्रयोग गर्ने विशेष रणनीति (तिनीहरू हटाउने, तिनीहरूलाई प्रतिस्थापन गर्ने, वा कसरी प्रतिस्थापन गर्ने) उक्त डाटाको विशेषताहरूले निर्धारण गर्नुपर्छ। तपाईंले जति धेरै डाटासेटहरूलाई व्यवस्थापन र अन्तरक्रिया गर्नुहुन्छ, हराएका मानहरूलाई कसरी व्यवस्थापन गर्ने भन्ने राम्रो ज्ञान विकास हुनेछ।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "bauDnESIl9FH"
},
"source": [
"### श्रेणीगत डाटा को एन्कोडिङ\n",
"\n",
"मेसिन लर्निङ मोडेलहरूले मात्र संख्यात्मक डाटासँग काम गर्छन्। यसले \"हो\" र \"होइन\" बीचको भिन्नता बुझ्न सक्दैन, तर यसले 0 र 1 बीचको भिन्नता छुट्याउन सक्छ। त्यसैले, हराएका मानहरू भरेपछि, मोडेलले बुझ्न सक्ने संख्यात्मक रूपमा श्रेणीगत डाटालाई एन्कोड गर्न आवश्यक छ।\n",
"\n",
"एन्कोडिङ दुई तरिकामा गर्न सकिन्छ। हामी अब ती तरिकाहरूको चर्चा गर्नेछौं।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "uDq9SxB7mu5i"
},
"source": [
"**लेबल एनकोडिङ**\n",
"\n",
"लेबल एनकोडिङ भनेको प्रत्येक श्रेणीलाई एउटा नम्बरमा परिवर्तन गर्नु हो। उदाहरणका लागि, मानौं हामीसँग एयरलाइन यात्रुहरूको डाटासेट छ र त्यहाँ एउटा स्तम्भ छ जसमा उनीहरूको वर्ग ['बिजनेस क्लास', 'इकोनोमी क्लास', 'फर्स्ट क्लास'] मध्ये छ। यदि यसमा लेबल एनकोडिङ गरिन्छ भने, यो [0,1,2] मा परिवर्तन हुनेछ। अब हामी कोडको माध्यमबाट एउटा उदाहरण हेर्छौं। किनकि हामी आगामी नोटबुकहरूमा `scikit-learn` सिक्दैछौं, हामी यसलाई यहाँ प्रयोग गर्नेछैनौं।\n"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "1vGz7uZyoWHL",
"outputId": "9e252855-d193-4103-a54d-028ea7787b34"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>ID</th>\n",
" <th>class</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>10</td>\n",
" <td>business class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20</td>\n",
" <td>first class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>30</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>40</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>50</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>60</td>\n",
" <td>business class</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ID class\n",
"0 10 business class\n",
"1 20 first class\n",
"2 30 economy class\n",
"3 40 economy class\n",
"4 50 economy class\n",
"5 60 business class"
]
},
"execution_count": 47,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"label = pd.DataFrame([\n",
" [10,'business class'],\n",
" [20,'first class'],\n",
" [30, 'economy class'],\n",
" [40, 'economy class'],\n",
" [50, 'economy class'],\n",
" [60, 'business class']\n",
"],columns=['ID','class'])\n",
"label"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "IDHnkwTYov-h"
},
"source": [
"पहिलो स्तम्भमा लेबल इन्कोडिङ गर्न, प्रत्येक वर्गलाई नम्बरमा म्यापिङ गर्ने विवरण दिनुपर्छ, त्यसपछि प्रतिस्थापन गर्नुपर्छ।\n"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "ZC5URJG3o1ES",
"outputId": "aab0f1e7-e0f3-4c14-8459-9f9168c85437"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>ID</th>\n",
" <th>class</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>10</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20</td>\n",
" <td>2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>30</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>40</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>50</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>60</td>\n",
" <td>0</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ID class\n",
"0 10 0\n",
"1 20 2\n",
"2 30 1\n",
"3 40 1\n",
"4 50 1\n",
"5 60 0"
]
},
"execution_count": 48,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"class_labels = {'business class':0,'economy class':1,'first class':2}\n",
"label['class'] = label['class'].replace(class_labels)\n",
"label"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ftnF-TyapOPt"
},
"source": [
"जस्तो कि हामीले देख्न सक्छौं, नतिजा हाम्रो अपेक्षासँग मेल खान्छ। त्यसो भए, लेबल इन्कोडिङ कहिले प्रयोग गर्ने? लेबल इन्कोडिङ निम्नमध्ये कुनै एक वा दुवै अवस्थामा प्रयोग गरिन्छ:\n",
"1. जब श्रेणीहरूको संख्या धेरै हुन्छ\n",
"2. जब श्रेणीहरू क्रमबद्ध हुन्छन्।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "eQPAPVwsqWT7"
},
"source": [
"**वन हट इनकोडिङ**\n",
"\n",
"अर्को प्रकारको इनकोडिङ वन हट इनकोडिङ हो। यस प्रकारको इनकोडिङमा, स्तम्भको प्रत्येक श्रेणीलाई छुट्टै स्तम्भको रूपमा थपिन्छ र प्रत्येक डाटापोइन्टले ० वा १ प्राप्त गर्दछ, यो श्रेणी समावेश छ कि छैन भन्ने आधारमा। त्यसैले, यदि n विभिन्न श्रेणीहरू छन् भने, n स्तम्भहरू डाटाफ्रेममा थपिनेछन्।\n",
"\n",
"उदाहरणका लागि, उही विमानको श्रेणीको उदाहरण लिऔं। श्रेणीहरू थिए: ['बिजनेस क्लास', 'इकोनोमी क्लास', 'फर्स्ट क्लास']। त्यसैले, यदि हामी वन हट इनकोडिङ गर्छौं भने, निम्न तीन स्तम्भहरू डेटासेटमा थपिनेछन्: ['class_business class', 'class_economy class', 'class_first class']।\n"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "ZM0eVh0ArKUL",
"outputId": "83238a76-b3a5-418d-c0b6-605b02b6891b"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>ID</th>\n",
" <th>class</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>10</td>\n",
" <td>business class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20</td>\n",
" <td>first class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>30</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>40</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>50</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>60</td>\n",
" <td>business class</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ID class\n",
"0 10 business class\n",
"1 20 first class\n",
"2 30 economy class\n",
"3 40 economy class\n",
"4 50 economy class\n",
"5 60 business class"
]
},
"execution_count": 49,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"one_hot = pd.DataFrame([\n",
" [10,'business class'],\n",
" [20,'first class'],\n",
" [30, 'economy class'],\n",
" [40, 'economy class'],\n",
" [50, 'economy class'],\n",
" [60, 'business class']\n",
"],columns=['ID','class'])\n",
"one_hot"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "aVnZ7paDrWmb"
},
"source": [
"हामी पहिलो स्तम्भमा वन हट इनकोडिङ गर्नेछौं।\n"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {
"id": "RUPxf7egrYKr"
},
"outputs": [],
"source": [
"one_hot_data = pd.get_dummies(one_hot,columns=['class'])"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "TM37pHsFr4ge",
"outputId": "7be15f53-79b2-447a-979c-822658339a9e"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>ID</th>\n",
" <th>class_business class</th>\n",
" <th>class_economy class</th>\n",
" <th>class_first class</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>10</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20</td>\n",
" <td>0</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>30</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>40</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>50</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>60</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" <td>0</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ID class_business class class_economy class class_first class\n",
"0 10 1 0 0\n",
"1 20 0 0 1\n",
"2 30 0 1 0\n",
"3 40 0 1 0\n",
"4 50 0 1 0\n",
"5 60 1 0 0"
]
},
"execution_count": 51,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"one_hot_data"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "_zXRLOjXujdA"
},
"source": [
"प्रत्येक वन हट एन्कोड गरिएको स्तम्भमा 0 वा 1 हुन्छ, जसले सो डाटापोइन्टको लागि त्यो श्रेणी रहेको छ कि छैन भन्ने निर्दिष्ट गर्दछ।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "bDnC4NQOu0qr"
},
"source": [
"हामी कहिले वन हट इनकोडिङ प्रयोग गर्छौं? वन हट इनकोडिङ निम्नमध्ये कुनै एक वा दुवै अवस्थामा प्रयोग गरिन्छ :\n",
"\n",
"1. जब श्रेणीहरूको संख्या र डेटासेटको आकार सानो हुन्छ।\n",
"2. जब श्रेणीहरूले कुनै विशेष क्रम अनुसरण गर्दैनन्।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "XnUmci_4uvyu"
},
"source": [
"> मुख्य बुँदाहरू:\n",
"1. एनकोडिङ गैर-संख्यात्मक डाटालाई संख्यात्मक डाटामा रूपान्तरण गर्न गरिन्छ।\n",
"2. एनकोडिङका दुई प्रकार छन्: लेबल एनकोडिङ र वन हट एनकोडिङ, जसलाई डाटासेटको आवश्यकताका आधारमा प्रयोग गर्न सकिन्छ।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "K8UXOJYRgRsJ"
},
"source": [
"## डुप्लिकेट डेटा हटाउने\n",
"\n",
"> **अध्ययनको लक्ष्य:** यस उपविभागको अन्त्यसम्ममा, तपाईं DataFrames बाट डुप्लिकेट मानहरू पहिचान गर्न र हटाउन सहज हुनुहुनेछ।\n",
"\n",
"हराएको डेटाको अतिरिक्त, तपाईं वास्तविक-विश्वको डेटासेटहरूमा प्रायः डुप्लिकेट डेटा भेट्नुहुनेछ। सौभाग्यवश, pandas ले डुप्लिकेट प्रविष्टिहरू पत्ता लगाउन र हटाउन सजिलो उपाय प्रदान गर्दछ।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "qrEG-Wa0gRsJ"
},
"source": [
"### डुप्लिकेटहरू पहिचान गर्ने: `duplicated`\n",
"\n",
"तपाईंले pandas को `duplicated` विधि प्रयोग गरेर सजिलै डुप्लिकेट मानहरू पत्ता लगाउन सक्नुहुन्छ, जसले Boolean मास्क फर्काउँछ जसले देखाउँछ कि `DataFrame` मा कुनै प्रविष्टि पहिलेको प्रविष्टिको डुप्लिकेट हो कि होइन। यसलाई व्यवहारमा देख्नको लागि अर्को उदाहरण `DataFrame` बनाउँ।\n"
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "ZLu6FEnZgRsJ",
"outputId": "376512d1-d842-4db1-aea3-71052aeeecaf",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>letters</th>\n",
" <th>numbers</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>A</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>B</td>\n",
" <td>2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>A</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>B</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>B</td>\n",
" <td>3</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" letters numbers\n",
"0 A 1\n",
"1 B 2\n",
"2 A 1\n",
"3 B 3\n",
"4 B 3"
]
},
"execution_count": 52,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example6 = pd.DataFrame({'letters': ['A','B'] * 2 + ['B'],\n",
" 'numbers': [1, 2, 1, 3, 3]})\n",
"example6"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "cIduB5oBgRsK",
"outputId": "3da27b3d-4d69-4e1d-bb52-0af21bae87f2",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"0 False\n",
"1 False\n",
"2 True\n",
"3 False\n",
"4 True\n",
"dtype: bool"
]
},
"execution_count": 53,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example6.duplicated()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "0eDRJD4SgRsK"
},
"source": [
"### डुप्लिकेट हटाउने: `drop_duplicates`\n",
"`drop_duplicates` ले केवल ती डाटाको प्रतिलिपि फर्काउँछ जसका लागि सबै `duplicated` मानहरू `False` छन्:\n"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "w_YPpqIqgRsK",
"outputId": "ac66bd2f-8671-4744-87f5-8b8d96553dea",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>letters</th>\n",
" <th>numbers</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>A</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>B</td>\n",
" <td>2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>B</td>\n",
" <td>3</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" letters numbers\n",
"0 A 1\n",
"1 B 2\n",
"3 B 3"
]
},
"execution_count": 54,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example6.drop_duplicates()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "69AqoCZAgRsK"
},
"source": [
"`duplicated` र `drop_duplicates` दुबैले सबै स्तम्भहरूलाई विचार गर्न डिफल्ट गर्छन् तर तपाईं आफ्नो `DataFrame` मा केवल स्तम्भहरूको उपसमूहलाई जाँच गर्न निर्दिष्ट गर्न सक्नुहुन्छ:\n"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 111
},
"id": "BILjDs67gRsK",
"outputId": "ef6dcc08-db8b-4352-c44e-5aa9e2bec0d3",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>letters</th>\n",
" <th>numbers</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>A</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>B</td>\n",
" <td>2</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" letters numbers\n",
"0 A 1\n",
"1 B 2"
]
},
"execution_count": 55,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example6.drop_duplicates(['letters'])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "GvX4og1EgRsL"
},
"source": [
"> **मुख्य कुरा:** नक्कल डेटा हटाउनु लगभग प्रत्येक डेटा-विज्ञान परियोजनाको महत्वपूर्ण भाग हो। नक्कल डेटा तपाईंको विश्लेषणको परिणाम परिवर्तन गर्न सक्छ र तपाईंलाई गलत परिणाम दिन सक्छ!\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## वास्तविक-विश्व डेटा गुणस्तर जाँच\n",
"\n",
"> **शिक्षण लक्ष्य:** यस खण्डको अन्त्यसम्ममा, तपाईं असंगत श्रेणीगत मानहरू, असामान्य संख्यात्मक मानहरू (अत्यधिक मानहरू), र भिन्नतासहितको दोहोरिएका इकाइहरू पत्ता लगाउन र सुधार गर्न सहज हुनुहुनेछ।\n",
"\n",
"यद्यपि हराएका मानहरू र ठ्याक्कै दोहोरिएका डेटा सामान्य समस्या हुन्, वास्तविक-विश्व डेटासेटहरूमा प्रायः थप सूक्ष्म समस्याहरू हुन्छन्:\n",
"\n",
"1. **असंगत श्रेणीगत मानहरू**: एउटै श्रेणी फरक-फरक तरिकाले लेखिएको (जस्तै, \"USA\", \"U.S.A\", \"United States\")\n",
"2. **असामान्य संख्यात्मक मानहरू**: डेटा प्रविष्टि त्रुटिहरूलाई जनाउने अत्यधिक मानहरू (जस्तै, उमेर = 999)\n",
"3. **निकट-दोहोरिएका पङ्क्तिहरू**: थोरै भिन्नतासहित एउटै इकाइलाई प्रतिनिधित्व गर्ने रेकर्डहरू\n",
"\n",
"यी समस्याहरू पत्ता लगाउन र समाधान गर्नका लागि प्रविधिहरू अन्वेषण गरौं।\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### \"फोहोर\" डाटासेट सिर्जना गर्दै\n",
"\n",
"पहिले, एउटा नमूना डाटासेट सिर्जना गरौं जसमा हामीले वास्तविक संसारको डाटामा सामान्यत: सामना गर्ने समस्याहरू समावेश छन्:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"import numpy as np\n",
"\n",
"# Create a sample dataset with quality issues\n",
"dirty_data = pd.DataFrame({\n",
" 'customer_id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],\n",
" 'name': ['John Smith', 'Jane Doe', 'John Smith', 'Bob Johnson', \n",
" 'Alice Williams', 'Charlie Brown', 'John Smith', 'Eva Martinez',\n",
" 'Bob Johnson', 'Diana Prince', 'Frank Castle', 'Alice Williams'],\n",
" 'age': [25, 32, 25, 45, 28, 199, 25, 31, 45, 27, -5, 28],\n",
" 'country': ['USA', 'UK', 'U.S.A', 'Canada', 'USA', 'United Kingdom',\n",
" 'United States', 'Mexico', 'canada', 'USA', 'UK', 'usa'],\n",
" 'purchase_amount': [100.50, 250.00, 105.00, 320.00, 180.00, 90.00,\n",
" 102.00, 275.00, 325.00, 195.00, 410.00, 185.00]\n",
"})\n",
"\n",
"print(\"Sample 'Dirty' Dataset:\")\n",
"print(dirty_data)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### १. असंगत श्रेणीगत मानहरू पत्ता लगाउने\n",
"\n",
"`country` स्तम्भमा एउटै देशको लागि विभिन्न प्रतिनिधित्वहरू छन्। आउनुहोस् यी असंगतताहरू पहिचान गरौं:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Check unique values in the country column\n",
"print(\"Unique country values:\")\n",
"print(dirty_data['country'].unique())\n",
"print(f\"\\nTotal unique values: {dirty_data['country'].nunique()}\")\n",
"\n",
"# Count occurrences of each variation\n",
"print(\"\\nValue counts:\")\n",
"print(dirty_data['country'].value_counts())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### श्रेणीगत मानहरूलाई मानकीकरण गर्दै\n",
"\n",
"हामी यी मानहरूलाई मानकीकरण गर्न एक म्यापिङ बनाउन सक्छौं। एउटा सरल तरिका भनेको तिनीहरूलाई सानो अक्षरमा परिवर्तन गर्नु र म्यापिङ डिक्सनरी बनाउनु हो:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Create a standardization mapping\n",
"country_mapping = {\n",
" 'usa': 'USA',\n",
" 'u.s.a': 'USA',\n",
" 'united states': 'USA',\n",
" 'uk': 'UK',\n",
" 'united kingdom': 'UK',\n",
" 'canada': 'Canada',\n",
" 'mexico': 'Mexico'\n",
"}\n",
"\n",
"# Standardize the country column\n",
"dirty_data['country_clean'] = dirty_data['country'].str.lower().map(country_mapping)\n",
"\n",
"print(\"Before standardization:\")\n",
"print(dirty_data['country'].value_counts())\n",
"print(\"\\nAfter standardization:\")\n",
"print(dirty_data[['country_clean']].value_counts())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**वैकल्पिक: फजी म्याचिङ प्रयोग गर्दै**\n",
"\n",
"अझ जटिल अवस्थामा, हामी `rapidfuzz` लाइब्रेरी प्रयोग गरेर फजी स्ट्रिङ म्याचिङको माध्यमबाट समान स्ट्रिङहरू स्वतः पत्ता लगाउन सक्छौं:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" from rapidfuzz import process, fuzz\n",
"except ImportError:\n",
" print(\"rapidfuzz is not installed. Please install it with 'pip install rapidfuzz' to use fuzzy matching.\")\n",
" process = None\n",
" fuzz = None\n",
"\n",
"# Get unique countries\n",
"unique_countries = dirty_data['country'].unique()\n",
"\n",
"# For each country, find similar matches\n",
"if process is not None and fuzz is not None:\n",
" print(\"Finding similar country names (similarity > 70%):\")\n",
" for country in unique_countries:\n",
" matches = process.extract(country, unique_countries, scorer=fuzz.ratio, limit=3)\n",
" # Filter matches with similarity > 70 and not identical\n",
" similar = [m for m in matches if m[1] > 70 and m[0] != country]\n",
" if similar:\n",
" print(f\"\\n'{country}' is similar to:\")\n",
" for match, score, _ in similar:\n",
" print(f\" - '{match}' (similarity: {score}%)\")\n",
"else:\n",
" print(\"Skipping fuzzy matching because rapidfuzz is not available.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2. असामान्य संख्यात्मक मानहरू (आउटलायर्स) पत्ता लगाउने\n",
"\n",
"`age` स्तम्भलाई हेर्दा, हामीसँग १९९ र -५ जस्ता शंकास्पद मानहरू छन्। आउटलायर्स पत्ता लगाउन सांख्यिकीय विधिहरू प्रयोग गरौं।\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Display basic statistics\n",
"print(\"Age column statistics:\")\n",
"print(dirty_data['age'].describe())\n",
"\n",
"# Identify impossible values using domain knowledge\n",
"print(\"\\nRows with impossible age values (< 0 or > 120):\")\n",
"impossible_ages = dirty_data[(dirty_data['age'] < 0) | (dirty_data['age'] > 120)]\n",
"print(impossible_ages[['customer_id', 'name', 'age']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### IQR (इन्टरक्वार्टाइल रेन्ज) विधि प्रयोग गर्दै\n",
"\n",
"IQR विधि एक बलियो सांख्यिकीय प्रविधि हो जुन बाहिरिने मानहरू पत्ता लगाउन प्रयोग गरिन्छ र यो अत्यधिक मानहरू प्रति कम संवेदनशील हुन्छ:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Calculate IQR for age (excluding impossible values)\n",
"valid_ages = dirty_data[(dirty_data['age'] >= 0) & (dirty_data['age'] <= 120)]['age']\n",
"\n",
"Q1 = valid_ages.quantile(0.25)\n",
"Q3 = valid_ages.quantile(0.75)\n",
"IQR = Q3 - Q1\n",
"\n",
"# Define outlier bounds\n",
"lower_bound = Q1 - 1.5 * IQR\n",
"upper_bound = Q3 + 1.5 * IQR\n",
"\n",
"print(f\"IQR-based outlier bounds for age: [{lower_bound:.2f}, {upper_bound:.2f}]\")\n",
"\n",
"# Identify outliers\n",
"age_outliers = dirty_data[(dirty_data['age'] < lower_bound) | (dirty_data['age'] > upper_bound)]\n",
"print(f\"\\nRows with age outliers:\")\n",
"print(age_outliers[['customer_id', 'name', 'age']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Z-स्कोर विधि प्रयोग गर्दै\n",
"\n",
"Z-स्कोर विधिले औसतबाट मानक विचलनको आधारमा बाहिरिएका मानहरू पहिचान गर्दछ:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" from scipy import stats\n",
"except ImportError:\n",
" print(\"scipy is required for Z-score calculation. Please install it with 'pip install scipy' and rerun this cell.\")\n",
"else:\n",
" # Calculate Z-scores for age, handling NaN values\n",
" age_nonan = dirty_data['age'].dropna()\n",
" zscores = np.abs(stats.zscore(age_nonan))\n",
" dirty_data['age_zscore'] = np.nan\n",
" dirty_data.loc[age_nonan.index, 'age_zscore'] = zscores\n",
"\n",
" # Typically, Z-score > 3 indicates an outlier\n",
" print(\"Rows with age Z-score > 3:\")\n",
" zscore_outliers = dirty_data[dirty_data['age_zscore'] > 3]\n",
" print(zscore_outliers[['customer_id', 'name', 'age', 'age_zscore']])\n",
"\n",
" # Clean up the temporary column\n",
" dirty_data = dirty_data.drop('age_zscore', axis=1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### बाहिरिएका डाटा (आउटलायर्स) को व्यवस्थापन\n",
"\n",
"पत्ता लागेपछि, बाहिरिएका डाटालाई विभिन्न तरिकाले व्यवस्थापन गर्न सकिन्छ:\n",
"1. **हटाउनुहोस्**: बाहिरिएका डाटासहितका पङ्क्तिहरू हटाउनुहोस् (यदि ती त्रुटिहरू हुन् भने)\n",
"2. **सीमा तोक्नुहोस्**: सीमा मानहरूद्वारा प्रतिस्थापन गर्नुहोस्\n",
"3. **NaN द्वारा प्रतिस्थापन गर्नुहोस्**: हराएको डाटा रूपमा व्यवहार गर्नुहोस् र इम्पुटेसन प्रविधिहरू प्रयोग गर्नुहोस्\n",
"4. **राख्नुहोस्**: यदि ती वैध अत्यधिक मानहरू हुन् भने\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Create a cleaned version by replacing impossible ages with NaN\n",
"dirty_data['age_clean'] = dirty_data['age'].apply(\n",
" lambda x: np.nan if (x < 0 or x > 120) else x\n",
")\n",
"\n",
"print(\"Age column before and after cleaning:\")\n",
"print(dirty_data[['customer_id', 'name', 'age', 'age_clean']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### ३. नजिकका नक्कल पङ्क्तिहरू पत्ता लगाउँदै\n",
"\n",
"ध्यान दिनुहोस् कि हाम्रो डेटासेटमा \"John Smith\" का लागि थोरै फरक मानहरू सहित धेरै प्रविष्टिहरू छन्। नामको समानताका आधारमा सम्भावित नक्कलहरू पहिचान गरौं।\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# First, let's look at exact name matches (ignoring extra whitespace)\n",
"dirty_data['name_normalized'] = dirty_data['name'].str.strip().str.lower()\n",
"\n",
"print(\"Checking for duplicate names:\")\n",
"duplicate_names = dirty_data[dirty_data.duplicated(['name_normalized'], keep=False)]\n",
"print(duplicate_names.sort_values('name_normalized')[['customer_id', 'name', 'age', 'country']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### फजी म्याचिङको प्रयोग गरेर नजिकका डुप्लिकेटहरू पत्ता लगाउने\n",
"\n",
"अधिक परिष्कृत डुप्लिकेट पहिचानको लागि, हामी फजी म्याचिङ प्रयोग गरेर मिल्दोजुल्दो नामहरू पत्ता लगाउन सक्छौं:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" from rapidfuzz import process, fuzz\n",
"\n",
" # Function to find potential duplicates\n",
" def find_near_duplicates(df, column, threshold=90):\n",
" \"\"\"\n",
" Find near-duplicate entries in a column using fuzzy matching.\n",
" \n",
" Parameters:\n",
" - df: DataFrame\n",
" - column: Column name to check for duplicates\n",
" - threshold: Similarity threshold (0-100)\n",
" \n",
" Returns: List of potential duplicate groups\n",
" \"\"\"\n",
" values = df[column].unique()\n",
" duplicate_groups = []\n",
" checked = set()\n",
" \n",
" for value in values:\n",
" if value in checked:\n",
" continue\n",
" \n",
" # Find similar values\n",
" matches = process.extract(value, values, scorer=fuzz.ratio, limit=len(values))\n",
" similar = [m[0] for m in matches if m[1] >= threshold]\n",
" \n",
" if len(similar) > 1:\n",
" duplicate_groups.append(similar)\n",
" checked.update(similar)\n",
" \n",
" return duplicate_groups\n",
"\n",
" # Find near-duplicate names\n",
" duplicate_groups = find_near_duplicates(dirty_data, 'name', threshold=90)\n",
"\n",
" print(\"Potential duplicate groups:\")\n",
" for i, group in enumerate(duplicate_groups, 1):\n",
" print(f\"\\nGroup {i}:\")\n",
" for name in group:\n",
" matching_rows = dirty_data[dirty_data['name'] == name]\n",
" print(f\" '{name}': {len(matching_rows)} occurrence(s)\")\n",
" for _, row in matching_rows.iterrows():\n",
" print(f\" - Customer {row['customer_id']}: age={row['age']}, country={row['country']}\")\n",
"except ImportError:\n",
" print(\"rapidfuzz is not installed. Skipping fuzzy matching for near-duplicates.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### डुप्लिकेटहरूलाई व्यवस्थापन गर्ने\n",
"\n",
"पहिचान गरेपछि, डुप्लिकेटहरूलाई कसरी व्यवस्थापन गर्ने भन्ने निर्णय गर्नुपर्छ:\n",
"1. **पहिलो पटकको उपस्थितिलाई राख्ने**: `drop_duplicates(keep='first')` प्रयोग गर्नुहोस्\n",
"2. **अन्तिम उपस्थितिलाई राख्ने**: `drop_duplicates(keep='last')` प्रयोग गर्नुहोस्\n",
"3. **जानकारीलाई समग्र बनाउने**: डुप्लिकेट पंक्तिहरूबाट जानकारीलाई संयोजन गर्नुहोस्\n",
"4. **म्यानुअल समीक्षा**: मानव समीक्षा गर्नको लागि झण्डा लगाउनुहोस्\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Example: Remove duplicates based on normalized name, keeping first occurrence\n",
"cleaned_data = dirty_data.drop_duplicates(subset=['name_normalized'], keep='first')\n",
"\n",
"print(f\"Original dataset: {len(dirty_data)} rows\")\n",
"print(f\"After removing name duplicates: {len(cleaned_data)} rows\")\n",
"print(f\"Removed: {len(dirty_data) - len(cleaned_data)} duplicate rows\")\n",
"\n",
"print(\"\\nCleaned dataset:\")\n",
"print(cleaned_data[['customer_id', 'name', 'age', 'country_clean']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### सारांश: पूर्ण डेटा सफाई पाइपलाइन\n",
"\n",
"अब सबैलाई एकसाथ राखेर एक व्यापक सफाई पाइपलाइन बनाउँ।\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def clean_dataset(df):\n",
" \"\"\"\n",
" Comprehensive data cleaning function.\n",
" \"\"\"\n",
" # Create a copy to avoid modifying the original\n",
" cleaned = df.copy()\n",
" \n",
" # 1. Standardize categorical values (country)\n",
" country_mapping = {\n",
" 'usa': 'USA', 'u.s.a': 'USA', 'united states': 'USA',\n",
" 'uk': 'UK', 'united kingdom': 'UK',\n",
" 'canada': 'Canada', 'mexico': 'Mexico'\n",
" }\n",
" cleaned['country'] = cleaned['country'].str.lower().map(country_mapping)\n",
" \n",
" # 2. Clean abnormal age values\n",
" cleaned['age'] = cleaned['age'].apply(\n",
" lambda x: np.nan if (x < 0 or x > 120) else x\n",
" )\n",
" \n",
" # 3. Remove near-duplicate names (normalize whitespace)\n",
" cleaned['name'] = cleaned['name'].str.strip()\n",
" cleaned = cleaned.drop_duplicates(subset=['name'], keep='first')\n",
" \n",
" return cleaned\n",
"\n",
"# Apply the cleaning pipeline\n",
"final_cleaned_data = clean_dataset(dirty_data)\n",
"\n",
"print(\"Before cleaning:\")\n",
"print(f\" Rows: {len(dirty_data)}\")\n",
"print(f\" Unique countries: {dirty_data['country'].nunique()}\")\n",
"print(f\" Invalid ages: {((dirty_data['age'] < 0) | (dirty_data['age'] > 120)).sum()}\")\n",
"\n",
"print(\"\\nAfter cleaning:\")\n",
"print(f\" Rows: {len(final_cleaned_data)}\")\n",
"print(f\" Unique countries: {final_cleaned_data['country'].nunique()}\")\n",
"print(f\" Invalid ages: {((final_cleaned_data['age'] < 0) | (final_cleaned_data['age'] > 120)).sum()}\")\n",
"\n",
"print(\"\\nCleaned dataset:\")\n",
"print(final_cleaned_data[['customer_id', 'name', 'age', 'country', 'purchase_amount']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 🎯 चुनौती अभ्यास\n",
"\n",
"अब तपाईंको पालो! तलको नयाँ पङ्क्तिमा धेरै गुणस्तर समस्याहरू छन्। के तपाईं:\n",
"\n",
"1. यस पङ्क्तिमा भएका सबै समस्याहरू पहिचान गर्न सक्नुहुन्छ\n",
"2. प्रत्येक समस्यालाई सफा गर्न कोड लेख्न सक्नुहुन्छ\n",
"3. सफा गरिएको पङ्क्तिलाई डेटासेटमा थप्न सक्नुहुन्छ\n",
"\n",
"यहाँ समस्याग्रस्त डेटा छ:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# New problematic row\n",
"new_row = pd.DataFrame({\n",
" 'customer_id': [13],\n",
" 'name': [' Diana Prince '], # Extra whitespace\n",
" 'age': [250], # Impossible age\n",
" 'country': ['U.S.A.'], # Inconsistent format\n",
" 'purchase_amount': [150.00]\n",
"})\n",
"\n",
"print(\"New row to clean:\")\n",
"print(new_row)\n",
"\n",
"# TODO: Your code here to clean this row\n",
"# Hints:\n",
"# 1. Strip whitespace from the name\n",
"# 2. Check if the name is a duplicate (Diana Prince already exists)\n",
"# 3. Handle the impossible age value\n",
"# 4. Standardize the country name\n",
"\n",
"# Example solution (uncomment and modify as needed):\n",
"# new_row_cleaned = new_row.copy()\n",
"# new_row_cleaned['name'] = new_row_cleaned['name'].str.strip()\n",
"# new_row_cleaned['age'] = np.nan # Invalid age\n",
"# new_row_cleaned['country'] = 'USA' # Standardized\n",
"# print(\"\\nCleaned row:\")\n",
"# print(new_row_cleaned)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### मुख्य बुँदाहरू\n",
"\n",
"1. **असंगत श्रेणीहरू** वास्तविक संसारको डाटामा सामान्य हुन्छन्। सधैं अनौठो मानहरू जाँच गर्नुहोस् र तिनीहरूलाई म्यापिङ वा फजी म्याचिङ प्रयोग गरेर मानकीकरण गर्नुहोस्।\n",
"\n",
"2. **आउटलायर्स**ले तपाईंको विश्लेषणमा ठूलो प्रभाव पार्न सक्छ। तिनीहरू पत्ता लगाउन डोमेन ज्ञानलाई सांख्यिकीय विधिहरू (IQR, Z-score) सँग मिलाएर प्रयोग गर्नुहोस्।\n",
"\n",
"3. **नजिकका डुप्लिकेटहरू** ठ्याक्कै मिल्ने डुप्लिकेटहरूभन्दा पत्ता लगाउन गाह्रो हुन्छ। तिनीहरूलाई पहिचान गर्न फजी म्याचिङ र डाटा सामान्यीकरण (लोअरकेसिङ, ह्वाइटस्पेस हटाउने) विचार गर्नुहोस्।\n",
"\n",
"4. **डाटा सफा गर्ने प्रक्रिया दोहोरिने हुन्छ।** तपाईंले धेरै प्रविधिहरू लागू गर्न र अन्तिम सफा गरिएको डाटासेट तयार गर्नु अघि नतिजाहरू समीक्षा गर्न आवश्यक हुन सक्छ।\n",
"\n",
"5. **आफ्नो निर्णयहरू दस्तावेज गर्नुहोस्।** तपाईंले कुन सफा गर्ने चरणहरू लागू गर्नुभयो र किन, त्यसलाई ट्र्याक गर्नुहोस् किनभने यो पुनरुत्पादनशीलता र पारदर्शिताका लागि महत्त्वपूर्ण छ।\n",
"\n",
"> **सर्वोत्तम अभ्यास:** सधैं आफ्नो मूल \"फोहोर\" डाटाको प्रतिलिपि राख्नुहोस्। कहिल्यै आफ्नो स्रोत डाटा फाइलहरू ओभरराइट नगर्नुहोस् - `data_cleaned.csv` जस्ता स्पष्ट नामकरण कन्वेन्सनसहित सफा गरिएको संस्करणहरू सिर्जना गर्नुहोस्।\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n---\n\n**अस्वीकरण**: \nयो दस्तावेज [Co-op Translator](https://github.com/Azure/co-op-translator) नामक एआई अनुवाद सेवा प्रयोग गरी अनुवाद गरिएको हो। हामी यथासम्भव सही अनुवाद प्रदान गर्न प्रयास गर्छौं, तर कृपया ध्यान दिनुहोस् कि स्वचालित अनुवादमा त्रुटिहरू वा अशुद्धताहरू हुन सक्छन्। मूल भाषामा रहेको मूल दस्तावेजलाई आधिकारिक स्रोत मानिनुपर्छ। महत्वपूर्ण जानकारीका लागि, व्यावसायिक मानव अनुवाद सिफारिस गरिन्छ। यस अनुवादको प्रयोगबाट उत्पन्न हुने कुनै पनि गलतफहमी वा गलत व्याख्याका लागि हामी जिम्मेवार हुने छैनौं।\n"
]
}
],
"metadata": {
"anaconda-cloud": {},
"colab": {
"name": "notebook.ipynb",
"provenance": []
},
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.5.4"
},
"coopTranslator": {
"original_hash": "6301339d1c9a301b00639c635dc9b731",
"translation_date": "2025-10-03T19:46:02+00:00",
"source_file": "2-Working-With-Data/08-data-preparation/notebook.ipynb",
"language_code": "ne"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
Reference in new issue View Git Blame Copy Permalink