{ "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` में 60,000 पंक्तियाँ और 400 कॉलम हैं, तो आप यह समझना कैसे शुरू करेंगे कि आप किसके साथ काम कर रहे हैं? सौभाग्य से, pandas कुछ सुविधाजनक टूल प्रदान करता है जो `DataFrame` की समग्र जानकारी के साथ-साथ शुरुआती और अंतिम कुछ पंक्तियों को जल्दी से देखने में मदद करते हैं।\n", "\n", "इस कार्यक्षमता का अन्वेषण करने के लिए, हम Python की scikit-learn लाइब्रेरी को इम्पोर्ट करेंगे और एक प्रसिद्ध डेटा सेट का उपयोग करेंगे जिसे हर डेटा वैज्ञानिक ने सैकड़ों बार देखा है: ब्रिटिश जीवविज्ञानी रोनाल्ड फिशर का *Iris* डेटा सेट, जिसे उन्होंने 1936 के अपने पेपर \"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": [ "हम 150 पंक्तियों और 4 स्तंभों के डेटा के साथ काम कर रहे हैं। प्रत्येक पंक्ति एक डेटा पॉइंट का प्रतिनिधित्व करती है और प्रत्येक स्तंभ डेटा फ्रेम से संबंधित एकल विशेषता को दर्शाता है। तो मूल रूप से, 150 डेटा पॉइंट्स हैं, जिनमें प्रत्येक में 4 विशेषताएँ शामिल हैं।\n", "\n", "`shape` यहाँ डेटा फ्रेम का एक गुण है और कोई फ़ंक्शन नहीं है, यही कारण है कि यह कोष्ठकों की एक जोड़ी के साथ समाप्त नहीं होता।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "d3AZKs0PinGP" }, "source": [ "### `DataFrame.columns`\n", "अब हम डेटा की 4 कॉलम्स में चलते हैं। इनमें से प्रत्येक वास्तव में क्या दर्शाता है? `columns` attribute हमें डेटा फ्रेम में कॉलम्स के नाम देगा।\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": [ "जैसा कि हम देख सकते हैं, चार(4) कॉलम हैं। `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": [ "\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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
sepal length (cm)sepal width (cm)petal length (cm)petal width (cm)
count150.000000150.000000150.000000150.000000
mean5.8433333.0573333.7580001.199333
std0.8280660.4358661.7652980.762238
min4.3000002.0000001.0000000.100000
25%5.1000002.8000001.6000000.300000
50%5.8000003.0000004.3500001.300000
75%6.4000003.3000005.1000001.800000
max7.9000004.4000006.9000002.500000
\n", "
" ], "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": [ "ऊपर दिया गया आउटपुट प्रत्येक कॉलम के कुल डेटा पॉइंट्स, औसत, मानक विचलन, न्यूनतम, निचला चतुर्थक (25%), माध्यिका (50%), ऊपरी चतुर्थक (75%) और अधिकतम मान को दिखाता है।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "-lviAu99gRrv" }, "source": [ "### `DataFrame.head`\n", "ऊपर दिए गए सभी फ़ंक्शन्स और एट्रिब्यूट्स के साथ, हमने डेटासेट का एक उच्च-स्तरीय अवलोकन प्राप्त कर लिया है। हमें पता है कि इसमें कितने डेटा पॉइंट्स हैं, कितनी विशेषताएँ (features) हैं, प्रत्येक विशेषता का डेटा प्रकार क्या है, और प्रत्येक विशेषता के लिए कितने non-null मान हैं।\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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
sepal length (cm)sepal width (cm)petal length (cm)petal width (cm)
05.13.51.40.2
14.93.01.40.2
24.73.21.30.2
34.63.11.50.2
45.03.61.40.2
\n", "
" ], "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": [ "यहाँ आउटपुट में, हम डेटा सेट के पाँच(5) प्रविष्टियाँ देख सकते हैं। यदि हम बाईं ओर के इंडेक्स को देखें, तो हमें पता चलता है कि ये पहली पाँच पंक्तियाँ हैं।\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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
sepal length (cm)sepal width (cm)petal length (cm)petal width (cm)
1456.73.05.22.3
1466.32.55.01.9
1476.53.05.22.0
1486.23.45.42.3
1495.93.05.11.8
\n", "
" ], "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 फ्लोटिंग-पॉइंट स्पेसिफिकेशन का हिस्सा है और इसे केवल गायब फ्लोटिंग-पॉइंट मानों को दर्शाने के लिए उपयोग किया जाता है। \n", "\n", "फ्लोट्स के अलावा अन्य गायब मानों के लिए, pandas Python के `None` ऑब्जेक्ट का उपयोग करता है। हालांकि यह थोड़ा भ्रमित कर सकता है कि आपको दो अलग-अलग प्रकार के मान मिलेंगे जो मूल रूप से एक ही बात कहते हैं, लेकिन इस डिज़ाइन विकल्प के पीछे ठोस प्रोग्रामिंग कारण हैं। व्यवहार में, इस दृष्टिकोण को अपनाने से pandas अधिकांश मामलों के लिए एक अच्छा संतुलन प्रदान करता है। \n", "\n", "इसके बावजूद, `None` और `NaN` दोनों में कुछ सीमाएँ होती हैं, जिनका उपयोग करते समय आपको ध्यान रखना होगा।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "lOHqUlZFgRr5" }, "source": [ "### `None`: गैर-फ्लोट गायब डेटा\n", "क्योंकि `None` Python से आता है, इसे उन NumPy और pandas arrays में उपयोग नहीं किया जा सकता जो डेटा प्रकार `'object'` के नहीं हैं। याद रखें, NumPy arrays (और pandas में डेटा संरचनाएं) केवल एक प्रकार के डेटा को ही समाहित कर सकते हैं। यही उन्हें बड़े पैमाने पर डेटा और गणनात्मक कार्यों के लिए उनकी जबरदस्त शक्ति देता है, लेकिन यह उनकी लचीलापन को भी सीमित करता है। ऐसे arrays को \"सबसे सामान्य हर प्रकार\" में बदलना पड़ता है, यानी ऐसा डेटा प्रकार जो array में सब कुछ समाहित कर सके। जब array में `None` होता है, तो इसका मतलब है कि आप 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()` का उपयोग उन arrays पर जिनमें ``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\u001b[0m in \u001b[0;36m\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": [] }, { "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` वाले arrays पर चलने वाले समूहन त्रुटियाँ उत्पन्न नहीं करते। बुरी खबर: परिणाम समान रूप से उपयोगी नहीं हैं:\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": [] }, { "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": [] }, { "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": [] }, { "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`s में अपकास्टिंग प्रक्रिया के दौरान, 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": [ "### null मानों का पता लगाना\n", "\n", "अब जब हमने गायब मानों के महत्व को समझ लिया है, तो हमें उन्हें संभालने से पहले अपने डेटा सेट में उनका पता लगाना होगा। \n", "`isnull()` और `notnull()` दोनों null डेटा का पता लगाने के लिए आपके प्राथमिक तरीके हैं। दोनों आपके डेटा पर 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 इसे उसी रूप में मानता है। `''` थोड़ा अधिक सूक्ष्म है। जबकि हमने इसे सेक्शन 1 में एक खाली स्ट्रिंग मान को दर्शाने के लिए उपयोग किया था, यह फिर भी एक स्ट्रिंग ऑब्जेक्ट है और pandas के दृष्टिकोण से इसे null का प्रतिनिधित्व नहीं माना जाता।\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": [] }, { "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": [] }, { "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": [ "### null मानों को हटाना\n", "\n", "हमारे मॉडल को दी जाने वाली डेटा की मात्रा उसके प्रदर्शन पर सीधे प्रभाव डालती है। null मानों को हटाने का मतलब है कि हम डेटा पॉइंट्स की संख्या कम कर रहे हैं, और इस प्रकार डेटासेट का आकार भी कम कर रहे हैं। इसलिए, जब डेटासेट काफी बड़ा हो, तो null मानों वाली पंक्तियों को हटाना उचित होता है।\n", "\n", "एक और स्थिति हो सकती है कि किसी विशेष पंक्ति या स्तंभ में बहुत सारे missing values हों। ऐसे में उन्हें हटाया जा सकता है क्योंकि वे हमारे विश्लेषण में ज्यादा मूल्य नहीं जोड़ेंगे, क्योंकि उस पंक्ति/स्तंभ के अधिकांश डेटा गायब हैं।\n", "\n", "missing values की पहचान करने के अलावा, pandas `Series` और `DataFrame`s से null मानों को हटाने का एक सुविधाजनक तरीका प्रदान करता है। इसे क्रियान्वित होते हुए देखने के लिए, चलिए `example3` पर वापस चलते हैं। `DataFrame.dropna()` फ़ंक्शन null मानों वाली पंक्तियों को हटाने में मदद करता है।\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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
01.0NaN7
12.05.08
2NaN6.09
\n", "
" ], "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 को समायोजित करने के लिए दो कॉलम को फ्लोट्स में अपकास्ट कर दिया?)\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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
12.05.08
\n", "
" ], "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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
2
07
18
29
\n", "
" ], "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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123
01.0NaN7NaN
12.05.08NaN
2NaN6.09NaN
\n", "
" ], "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. केवल तभी null मानों को हटाना एक अच्छा विचार है जब डेटा सेट पर्याप्त बड़ा हो। \n", "2. पूरी पंक्तियों या स्तंभों को हटाया जा सकता है यदि उनमें से अधिकांश डेटा गायब हो। \n", "3. `DataFrame.dropna(axis=)` विधि null मानों को हटाने में मदद करती है। `axis` तर्क यह दर्शाता है कि पंक्तियों को हटाना है या स्तंभों को। \n", "4. `how` तर्क का भी उपयोग किया जा सकता है। डिफ़ॉल्ट रूप से यह `any` पर सेट होता है। इसलिए, यह केवल उन पंक्तियों/स्तंभों को हटाता है जिनमें कोई भी null मान होता है। इसे `all` पर सेट किया जा सकता है ताकि यह निर्दिष्ट किया जा सके कि हम केवल उन पंक्तियों/स्तंभों को हटाएंगे जहां सभी मान null हैं। \n" ] }, { "cell_type": "markdown", "metadata": { "id": "oXXSfQFHgRsF" }, "source": [] }, { "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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123
12.05.08NaN
\n", "
" ], "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": [] }, { "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` से बदलते हैं। मान लीजिए, हमारे पास 100 डेटा पॉइंट्स हैं और उनमें से 90 ने सत्य कहा है, 8 ने असत्य कहा है और 2 ने कुछ नहीं भरा है। तो, हम उन 2 को सत्य से भर सकते हैं, पूरे कॉलम को ध्यान में रखते हुए।\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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
012True
134None
256False
378True
4910True
\n", "
" ], "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": [] }, { "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": [] }, { "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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
012True
134True
256False
378True
4910True
\n", "
" ], "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": [] }, { "cell_type": "markdown", "metadata": { "id": "heYe1I0dOmQ_" }, "source": [ "### संख्यात्मक डेटा\n", "अब, संख्यात्मक डेटा की बात करते हैं। यहां, हमारे पास गायब मानों को भरने के दो सामान्य तरीके हैं:\n", "\n", "1. पंक्ति के माध्यिका (Median) से बदलें \n", "2. पंक्ति के औसत (Mean) से बदलें \n", "\n", "हम माध्यिका का उपयोग करते हैं, जब डेटा में बाहरी मान (Outliers) के साथ असंतुलन होता है। इसका कारण यह है कि माध्यिका बाहरी मानों के प्रति संवेदनशील नहीं होती है।\n", "\n", "जब डेटा सामान्यीकृत होता है, तो हम औसत का उपयोग कर सकते हैं, क्योंकि उस स्थिति में औसत और माध्यिका लगभग समान होते हैं।\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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
0-2.001
1-1.023
2NaN45
31.067
42.089
\n", "
" ], "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": [] }, { "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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
0-2.001
1-1.023
20.045
31.067
42.089
\n", "
" ], "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": [] }, { "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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
0-20.01
1-12.03
20NaN5
316.07
428.09
\n", "
" ], "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": [] }, { "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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
0-20.01
1-12.03
204.05
316.07
428.09
\n", "
" ], "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": [] }, { "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": [] }, { "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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123
01.0NaN7NaN
12.05.08NaN
2NaN6.09NaN
\n", "
" ], "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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123
01.01.07.07.0
12.05.08.08.0
2NaN6.09.09.0
\n", "
" ], "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": [] }, { "cell_type": "markdown", "metadata": { "id": "eeAoOU0RgRsJ" }, "source": [] }, { "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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123
01.05.57NaN
12.05.08NaN
21.56.09NaN
\n", "
" ], "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": [ "ध्यान दें कि कॉलम 3 अभी भी खाली है: डिफ़ॉल्ट दिशा पंक्ति-वार मान भरने की है।\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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
IDclass
010business class
120first class
230economy class
340economy class
450economy class
560business class
\n", "
" ], "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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
IDclass
0100
1202
2301
3401
4501
5600
\n", "
" ], "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", "वन हॉट एनकोडिंग एक और प्रकार का एनकोडिंग है। इस प्रकार के एनकोडिंग में, कॉलम की प्रत्येक श्रेणी को एक अलग कॉलम के रूप में जोड़ा जाता है और प्रत्येक डेटा पॉइंट को 0 या 1 मिलता है, इस आधार पर कि उसमें वह श्रेणी है या नहीं। तो, यदि 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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
IDclass
010business class
120first class
230economy class
340economy class
450economy class
560business class
\n", "
" ], "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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
IDclass_business classclass_economy classclass_first class
010100
120001
230010
340010
450010
560100
\n", "
" ], "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` मेथड का उपयोग करके आसानी से डुप्लिकेट मानों को पहचान सकते हैं। यह एक बूलियन मास्क लौटाता है, जो यह दर्शाता है कि `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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
lettersnumbers
0A1
1B2
2A1
3B3
4B3
\n", "
" ], "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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
lettersnumbers
0A1
1B2
3B3
\n", "
" ], "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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
lettersnumbers
0A1
1B2
\n", "
" ], "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": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n---\n\n**अस्वीकरण**: \nयह दस्तावेज़ AI अनुवाद सेवा [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": "8533b3a2230311943339963fc7f04c21", "translation_date": "2025-09-01T21:51:47+00:00", "source_file": "2-Working-With-Data/08-data-preparation/notebook.ipynb", "language_code": "hi" } }, "nbformat": 4, "nbformat_minor": 0 }