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

3719 lines
132 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 DataFrame-এ সংরক্ষিত ডেটা সম্পর্কে সাধারণ তথ্য খুঁজে পেতে স্বাচ্ছন্দ্যবোধ করবেন।\n",
"\n",
"যখন আপনি pandas-এ আপনার ডেটা লোড করবেন, এটি সম্ভবত একটি `DataFrame` আকারে থাকবে। তবে, যদি আপনার `DataFrame`-এ থাকা ডেটাসেটে ৬০,০০০ সারি এবং ৪০০ কলাম থাকে, তাহলে আপনি কীভাবে কাজ শুরু করবেন? সৌভাগ্যবশত, pandas কিছু সুবিধাজনক টুল সরবরাহ করে যা একটি `DataFrame`-এর সামগ্রিক তথ্য এবং প্রথম কয়েকটি ও শেষ কয়েকটি সারি দ্রুত দেখার সুযোগ দেয়।\n",
"\n",
"এই কার্যকারিতা অনুসন্ধান করার জন্য, আমরা Python-এর scikit-learn লাইব্রেরি ইম্পোর্ট করব এবং একটি আইকনিক ডেটাসেট ব্যবহার করব যা প্রতিটি ডেটা সায়েন্টিস্ট শত শত বার দেখেছেন: ব্রিটিশ জীববিজ্ঞানী রোনাল্ড ফিশারের *আইরিস* ডেটাসেট, যা তিনি ১৯৩৬ সালে তার \"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_df` ভেরিয়েবলে Iris Dataset লোড করেছি। ডেটাতে গভীরভাবে যাওয়ার আগে, আমাদের কাছে কতগুলো ডেটাপয়েন্ট আছে এবং ডেটাসেটের সামগ্রিক আকার জানা গুরুত্বপূর্ণ। আমরা যে ডেটার পরিমাণ নিয়ে কাজ করছি তা বোঝার জন্য এটি উপকারী।\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` অ্যাট্রিবিউট দ্বারা প্রদত্ত) এবং ফিচার বা কলামের নামসমূহ (`columns` অ্যাট্রিবিউট দ্বারা প্রদত্ত) আমাদের ডেটাসেট সম্পর্কে কিছু ধারণা দেয়। এখন, আমরা ডেটাসেটটি আরও গভীরভাবে বিশ্লেষণ করতে চাই। এ ক্ষেত্রে, `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. প্রতিটি কলামের DataType: এই ডেটাসেটে, সমস্ত ডেটা ৬৪-বিট ফ্লোটিং-পয়েন্ট সংখ্যার আকারে সংরক্ষিত। \n",
"2. Non-Null মানের সংখ্যা: ডেটা প্রস্তুতির ক্ষেত্রে null মানগুলোর সাথে কাজ করা একটি গুরুত্বপূর্ণ ধাপ। এটি নোটবুকে পরে আলোচনা করা হবে। \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",
"> **মূল কথা:** শুধুমাত্র ডেটাফ্রেমের তথ্য সম্পর্কিত মেটাডেটা বা এর প্রথম এবং শেষ কয়েকটি মান দেখেই আপনি ডেটার আকার, গঠন এবং বিষয়বস্তু সম্পর্কে তাৎক্ষণিক ধারণা পেতে পারেন।\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` পাইথন থেকে আসে, এটি এমন NumPy এবং pandas অ্যারেতে ব্যবহার করা যায় না যেগুলোর ডেটা টাইপ `'object'` নয়। মনে রাখবেন, NumPy অ্যারে (এবং pandas-এর ডেটা স্ট্রাকচারগুলো) শুধুমাত্র এক ধরনের ডেটা ধারণ করতে পারে। এটি তাদের বৃহৎ পরিসরের ডেটা এবং গণনামূলক কাজের জন্য অসাধারণ ক্ষমতা প্রদান করে, তবে এটি তাদের নমনীয়তাকে সীমিত করে। এমন অ্যারেগুলোকে \"সর্বনিম্ন সাধারণ গুণ\" অর্থাৎ এমন ডেটা টাইপে আপকাস্ট করতে হয় যা অ্যারেতে থাকা সবকিছুকে অন্তর্ভুক্ত করতে পারে। যখন `None` অ্যারেতে থাকে, এর অর্থ আপনি পাইথন অবজেক্ট নিয়ে কাজ করছেন।\n",
"\n",
"এটি বাস্তবে দেখতে, নিচের উদাহরণ অ্যারেটি বিবেচনা করুন (এর `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": [
"আপকাস্ট ডেটা টাইপের বাস্তবতা দুটি পার্শ্বপ্রতিক্রিয়া নিয়ে আসে। প্রথমত, অপারেশনগুলো সংকলিত NumPy কোডের পরিবর্তে ব্যাখ্যামূলক Python কোডের স্তরে সম্পন্ন হবে। মূলত, এর অর্থ হলো `Series` বা `DataFrames`-এ যদি `None` থাকে, তাহলে সংশ্লিষ্ট অপারেশনগুলো ধীরগতির হবে। যদিও আপনি সম্ভবত এই পারফরম্যান্সের প্রভাব লক্ষ্য করবেন না, বড় ডেটাসেটের ক্ষেত্রে এটি একটি সমস্যা হয়ে উঠতে পারে।\n",
"\n",
"দ্বিতীয় পার্শ্বপ্রতিক্রিয়া প্রথমটির থেকে উদ্ভূত। কারণ `None` মূলত `Series` বা `DataFrame`-কে সাধারণ Python-এর জগতে ফিরিয়ে নিয়ে যায়, তাই যদি কোনো অ্যারে-তে `None` মান থাকে, NumPy/pandas-এর মতো অ্যাগ্রিগেশন ফাংশন যেমন `sum()` বা `min()` ব্যবহার করলে সাধারণত একটি ত্রুটি তৈরি হবে:\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()` উভয়ই নাল ডেটা সনাক্ত করার জন্য আপনার প্রধান পদ্ধতি। উভয়ই আপনার ডেটার উপর বুলিয়ান মাস্ক প্রদান করে।\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()` পদ্ধতির মাধ্যমে তৈরি হওয়া মাস্কের উপর একটি যোগফল করতে পারি।\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()` পদ্ধতি DataFrame-এ ব্যবহার করলে একই ধরনের ফলাফল প্রদান করে: এগুলো ফলাফল এবং সেই ফলাফলের সূচক প্রদর্শন করে, যা আপনার ডেটা নিয়ে কাজ করার সময় আপনাকে অত্যন্ত সাহায্য করবে।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "BvnoojWsgRr4"
},
"source": [
"### অনুপস্থিত ডেটা সামলানো\n",
"\n",
"> **শিক্ষার লক্ষ্য:** এই উপ-অধ্যায়ের শেষে, আপনি জানতে পারবেন কীভাবে এবং কখন DataFrames থেকে শূন্য মান প্রতিস্থাপন বা সরিয়ে ফেলা যায়।\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` থেকে নাল মান সরানোর একটি সুবিধাজনক উপায় প্রদান করে। এটি বাস্তবে দেখতে, চলুন `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",
"যেহেতু DataFrame-গুলোর দুটি মাত্রা রয়েছে, তাই ডেটা বাদ দেওয়ার জন্য এগুলো আরও বেশি বিকল্প প্রদান করে।\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` এর কারণে ফ্লোটে আপকাস্ট করেছে?)\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. শুধুমাত্র তখনই 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": [
"### ব্যায়াম:\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": []
},
{
"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": [
"<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",
"যখন ডেটা আউটলাইয়ারসহ তির্যক (skewed) হয়, তখন আমরা মধ্যম দিয়ে প্রতিস্থাপন করি। কারণ মধ্যম আউটলাইয়ারের প্রতি সংবেদনশীল নয়।\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": [
"<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": []
},
{
"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": [
"আপনি **forward-fill** পদ্ধতিতে null মান পূরণ করতে পারেন, যা হল শেষ বৈধ মানটি ব্যবহার করে null পূরণ করা:\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",
"উদাহরণস্বরূপ, চলুন আগের বিমান শ্রেণির উদাহরণটি দেখি। ক্যাটেগরিগুলো ছিল: ['business class', 'economy class', 'first class']। সুতরাং, যদি আমরা ওয়ান হট এনকোডিং করি, তাহলে ডেটাসেটে নিম্নলিখিত তিনটি কলাম যুক্ত হবে: ['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` মেথড ব্যবহার করে, যা একটি বুলিয়ান মাস্ক প্রদান করে যা নির্দেশ করে যে একটি `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এই নথিটি 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:18:36+00:00",
"source_file": "2-Working-With-Data/08-data-preparation/notebook.ipynb",
"language_code": "bn"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
Reference in new issue View Git Blame Copy Permalink