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

4241 lines
158 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 লাইব্রেরি আমদানি করব এবং একটি আইকনিক ডেটাসেট ব্যবহার করব যা প্রতিটি ডেটা বিজ্ঞানী শত শত বার দেখেছেন: ব্রিটিশ জীববিজ্ঞানী রোনাল্ড ফিশারের *আইরিস* ডেটাসেট, যা তিনি ১৯৩৬ সালে তার \"ট্যাক্সোনমিক সমস্যায় একাধিক পরিমাপের ব্যবহার\" শীর্ষক গবেষণাপত্রে ব্যবহার করেছিলেন:\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` ভেরিয়েবলে আইরিস ডেটাসেট লোড করেছি। ডেটাতে গভীরভাবে যাওয়ার আগে, আমাদের কাছে কতগুলো ডেটাপয়েন্ট আছে এবং ডেটাসেটের সামগ্রিক আকার জানা গুরুত্বপূর্ণ। আমরা যে ডেটার পরিমাণ নিয়ে কাজ করছি তা বোঝার জন্য এটি উপকারী।\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "LOe5jQohhulf",
"outputId": "fb0577ac-3b4a-4623-cb41-20e1b264b3e9"
},
"outputs": [
{
"data": {
"text/plain": [
"(150, 4)"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.shape"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "smE7AGzOhxk2"
},
"source": [
"আমরা এখানে ১৫০টি সারি এবং ৪টি কলামের ডেটা নিয়ে কাজ করছি। প্রতিটি সারি একটি ডেটাপয়েন্টকে উপস্থাপন করে এবং প্রতিটি কলাম ডেটা ফ্রেমের সাথে সম্পর্কিত একটি বৈশিষ্ট্যকে উপস্থাপন করে। অর্থাৎ, এখানে মোট ১৫০টি ডেটাপয়েন্ট রয়েছে, প্রতিটি ডেটাপয়েন্টে ৪টি বৈশিষ্ট্য রয়েছে।\n",
"\n",
"`shape` এখানে ডেটা ফ্রেমের একটি অ্যাট্রিবিউট এবং এটি কোনো ফাংশন নয়, এজন্য এটি একটি জোড়া বন্ধনী দিয়ে শেষ হয় না।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "d3AZKs0PinGP"
},
"source": [
"### `DataFrame.columns`\n",
"এখন আমরা ডেটার ৪টি কলামে প্রবেশ করব। প্রতিটি কলাম ঠিক কী উপস্থাপন করে? `columns` অ্যাট্রিবিউট আমাদের ডেটাফ্রেমের কলামের নামগুলি প্রদান করবে।\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "YPGh_ziji-CY",
"outputId": "74e7a43a-77cc-4c80-da56-7f50767c37a0"
},
"outputs": [
{
"data": {
"text/plain": [
"Index(['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)',\n",
" 'petal width (cm)'],\n",
" dtype='object')"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.columns"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "TsobcU_VjCC_"
},
"source": [
"যেমন আমরা দেখতে পাচ্ছি, এখানে চার(৪)টি কলাম রয়েছে। `columns` অ্যাট্রিবিউট আমাদের কলামগুলোর নাম জানায় এবং মূলত আর কিছুই নয়। এই অ্যাট্রিবিউট গুরুত্বপূর্ণ হয়ে ওঠে যখন আমরা কোনো ডেটাসেটে থাকা বৈশিষ্ট্যগুলো চিহ্নিত করতে চাই।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "2UTlvkjmgRrs"
},
"source": [
"### `DataFrame.info`\n",
"ডেটার পরিমাণ (`shape` attribute দ্বারা প্রদত্ত) এবং বৈশিষ্ট্য বা কলামের নাম (`columns` attribute দ্বারা প্রদত্ত) আমাদের ডেটাসেট সম্পর্কে কিছু তথ্য দেয়। এখন, আমরা ডেটাসেটটি আরও গভীরভাবে বিশ্লেষণ করতে চাই। `DataFrame.info()` ফাংশন এই ক্ষেত্রে বেশ কার্যকর।\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "dHHRyG0_gRrt",
"outputId": "d8fb0c40-4f18-4e19-da48-c8db77d1d3a5",
"trusted": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'pandas.core.frame.DataFrame'>\n",
"RangeIndex: 150 entries, 0 to 149\n",
"Data columns (total 4 columns):\n",
" # Column Non-Null Count Dtype \n",
"--- ------ -------------- ----- \n",
" 0 sepal length (cm) 150 non-null float64\n",
" 1 sepal width (cm) 150 non-null float64\n",
" 2 petal length (cm) 150 non-null float64\n",
" 3 petal width (cm) 150 non-null float64\n",
"dtypes: float64(4)\n",
"memory usage: 4.8 KB\n"
]
}
],
"source": [
"iris_df.info()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "1XgVMpvigRru"
},
"source": [
"এখান থেকে আমরা কয়েকটি পর্যবেক্ষণ করতে পারি:\n",
"1. প্রতিটি কলামের DataType: এই ডেটাসেটে, সমস্ত ডেটা 64-বিট ফ্লোটিং-পয়েন্ট সংখ্যার আকারে সংরক্ষিত।\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",
"> **মূল কথা:** শুধুমাত্র একটি DataFrame-এর তথ্য সম্পর্কিত মেটাডেটা বা এর প্রথম এবং শেষ কয়েকটি মান দেখেই আপনি ডেটার আকার, আকৃতি এবং বিষয়বস্তু সম্পর্কে তাত্ক্ষণিক ধারণা পেতে পারেন।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "TvurZyLSDxq_"
},
"source": [
"### অনুপস্থিত ডেটা\n",
"চলুন অনুপস্থিত ডেটা নিয়ে আলোচনা করি। অনুপস্থিত ডেটা তখন ঘটে, যখন কিছু কলামে কোনো মান সংরক্ষিত থাকে না।\n",
"\n",
"একটি উদাহরণ নেওয়া যাক: ধরুন কেউ তার ওজন নিয়ে সচেতন এবং একটি জরিপে ওজনের ঘরটি পূরণ করেনি। তাহলে, সেই ব্যক্তির জন্য ওজনের মান অনুপস্থিত থাকবে।\n",
"\n",
"বাস্তব জীবনের ডেটাসেটে বেশিরভাগ সময়েই অনুপস্থিত মান দেখা যায়।\n",
"\n",
"**Pandas কীভাবে অনুপস্থিত ডেটা পরিচালনা করে**\n",
"\n",
"Pandas দুটি উপায়ে অনুপস্থিত মান পরিচালনা করে। প্রথমটি আপনি আগের অংশগুলোতে দেখেছেন: `NaN`, বা Not a Number। এটি আসলে IEEE floating-point স্পেসিফিকেশনের একটি বিশেষ মান এবং এটি শুধুমাত্র অনুপস্থিত floating-point মান নির্দেশ করার জন্য ব্যবহৃত হয়।\n",
"\n",
"ফ্লোট ছাড়া অন্যান্য অনুপস্থিত মানের জন্য, 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` বা `DataFrame`-এ যদি `None` থাকে, তাহলে সংশ্লিষ্ট অপারেশনগুলি ধীরগতির হবে। যদিও আপনি সম্ভবত এই পারফরম্যান্সের প্রভাব লক্ষ্য করবেন না, বড় ডেটাসেটের ক্ষেত্রে এটি একটি সমস্যা হয়ে উঠতে পারে।\n",
"\n",
"দ্বিতীয় পার্শ্বপ্রতিক্রিয়া প্রথমটির সাথে সম্পর্কিত। কারণ `None` মূলত `Series` বা `DataFrame`-কে সাধারণ Python-এর জগতে ফিরিয়ে নিয়ে যায়, তাই NumPy/pandas-এর মতো অ্যাগ্রিগেশন ফাংশন যেমন `sum()` বা `min()` ব্যবহার করে যদি অ্যারে-তে ``None`` থাকে, সাধারণত একটি ত্রুটি তৈরি হবে:\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 292
},
"id": "gWbx-KB9gRr8",
"outputId": "ecba710a-22ec-41d5-a39c-11f67e645b50",
"trusted": false
},
"outputs": [
{
"ename": "TypeError",
"evalue": "ignored",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-10-ce9901ad18bd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mexample1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numpy/core/_methods.py\u001b[0m in \u001b[0;36m_sum\u001b[0;34m(a, axis, dtype, out, keepdims, initial, where)\u001b[0m\n\u001b[1;32m 45\u001b[0m def _sum(a, axis=None, dtype=None, out=None, keepdims=False,\n\u001b[1;32m 46\u001b[0m initial=_NoValue, where=True):\n\u001b[0;32m---> 47\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mumr_sum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwhere\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 48\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 49\u001b[0m def _prod(a, axis=None, dtype=None, out=None, keepdims=False,\n",
"\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'NoneType'"
]
}
],
"source": [
"example1.sum()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "LcEwO8UogRr9"
},
"source": [
"**মূল কথা**: পূর্ণসংখ্যা এবং `None` মানের মধ্যে যোগ (এবং অন্যান্য অপারেশন) অনির্ধারিত, যা এমন ডেটাসেটের সাথে কাজ করার সীমাবদ্ধতা তৈরি করতে পারে যেখানে এগুলো উপস্থিত।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "pWvVHvETgRr9"
},
"source": [
"### `NaN`: অনুপস্থিত ফ্লোট মান\n",
"\n",
"`None` এর বিপরীতে, NumPy (এবং সেইসাথে pandas) তার দ্রুত, ভেক্টরাইজড অপারেশন এবং ufuncs এর জন্য `NaN` সমর্থন করে। খারাপ খবর হলো, `NaN` এর উপর যেকোনো গাণিতিক অপারেশন করলে ফলাফল সবসময় `NaN` হয়। উদাহরণস্বরূপ:\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "rcFYfMG9gRr9",
"outputId": "699e81b7-5c11-4b46-df1d-06071768690f",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"nan"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.nan + 1"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "BW3zQD2-gRr-",
"outputId": "4525b6c4-495d-4f7b-a979-efce1dae9bd0",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"nan"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.nan * 0"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "fU5IPRcCgRr-"
},
"source": [
"ভালো খবর: `NaN` থাকা অ্যারেগুলিতে অ্যাগ্রিগেশন চালালে কোনো ত্রুটি দেখায় না। খারাপ খবর: ফলাফলগুলি সর্বদা উপযোগী হয় না:\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "LCInVgSSgRr_",
"outputId": "fa06495a-0930-4867-87c5-6023031ea8b5",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"(nan, nan, nan)"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example2 = np.array([2, np.nan, 6, 8]) \n",
"example2.sum(), example2.min(), example2.max()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "nhlnNJT7gRr_"
},
"source": [
"### ব্যায়াম:\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": true,
"id": "yan3QRaOgRr_",
"trusted": false
},
"outputs": [],
"source": [
"# What happens if you add np.nan and None together?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "_iDvIRC8gRsA"
},
"source": [
"মনে রাখুন: `NaN` শুধুমাত্র অনুপস্থিত ফ্লোটিং-পয়েন্ট মানগুলির জন্য; পূর্ণসংখ্যা, স্ট্রিং বা বুলিয়ানের জন্য কোনও `NaN` সমতুল্য নেই।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "kj6EKdsAgRsA"
},
"source": [
"### `NaN` এবং `None`: pandas-এ null মান\n",
"\n",
"যদিও `NaN` এবং `None` কিছুটা ভিন্নভাবে আচরণ করতে পারে, pandas এগুলোকে একে অপরের পরিবর্তে ব্যবহার করার জন্য তৈরি করা হয়েছে। আমরা কী বোঝাতে চাই তা দেখতে, একটি পূর্ণসংখ্যার `Series` বিবেচনা করুন:\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "Nji-KGdNgRsA",
"outputId": "36aa14d2-8efa-4bfd-c0ed-682991288822",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"0 1\n",
"1 2\n",
"2 3\n",
"dtype: int64"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"int_series = pd.Series([1, 2, 3], dtype=int)\n",
"int_series"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "WklCzqb8gRsB"
},
"source": [
"### ব্যায়াম:\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"collapsed": true,
"id": "Cy-gqX5-gRsB",
"trusted": false
},
"outputs": [],
"source": [
"# Now set an element of int_series equal to None.\n",
"# How does that element show up in the Series?\n",
"# What is the dtype of the Series?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "WjMQwltNgRsB"
},
"source": [
"`Series` এবং `DataFrame`-এ ডেটার সামঞ্জস্যতা নিশ্চিত করার জন্য ডেটা টাইপ আপকাস্ট করার প্রক্রিয়ায়, pandas সহজেই `None` এবং `NaN` এর মধ্যে অনুপস্থিত মানগুলি পরিবর্তন করতে পারে। এই ডিজাইন বৈশিষ্ট্যের কারণে, pandas-এ `None` এবং `NaN` কে \"null\" এর দুটি ভিন্ন রূপ হিসেবে ভাবা সুবিধাজনক হতে পারে। প্রকৃতপক্ষে, pandas-এ অনুপস্থিত মানগুলি পরিচালনা করার জন্য আপনি যে মূল পদ্ধতিগুলি ব্যবহার করবেন, সেগুলোর নামেও এই ধারণাটি প্রতিফলিত হয়:\n",
"\n",
"- `isnull()`: অনুপস্থিত মানগুলি নির্দেশ করার জন্য একটি বুলিয়ান মাস্ক তৈরি করে\n",
"- `notnull()`: `isnull()`-এর বিপরীত\n",
"- `dropna()`: ডেটার একটি ফিল্টার করা সংস্করণ প্রদান করে\n",
"- `fillna()`: অনুপস্থিত মানগুলি পূরণ বা অনুমান করে ডেটার একটি কপি প্রদান করে\n",
"\n",
"এই পদ্ধতিগুলি আয়ত্ত করা এবং সেগুলোর সাথে স্বাচ্ছন্দ্য বোধ করা অত্যন্ত গুরুত্বপূর্ণ। তাই চলুন, প্রতিটি পদ্ধতি বিস্তারিতভাবে আলোচনা করি।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Yh5ifd9FgRsB"
},
"source": [
"### নাল মান সনাক্ত করা\n",
"\n",
"এখন যেহেতু আমরা অনুপস্থিত মানগুলোর গুরুত্ব বুঝেছি, আমাদের ডেটাসেটে সেগুলো মোকাবিলা করার আগে সনাক্ত করতে হবে। \n",
"`isnull()` এবং `notnull()` উভয়ই নাল ডেটা সনাক্ত করার জন্য আপনার প্রধান পদ্ধতি। উভয়ই আপনার ডেটার উপর বুলিয়ান মাস্ক প্রদান করে।\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 থেকে null মান প্রতিস্থাপন বা সরানো যায়।\n",
"\n",
"মেশিন লার্নিং মডেলগুলো নিজেরাই অনুপস্থিত ডেটা পরিচালনা করতে পারে না। তাই, মডেলে ডেটা পাঠানোর আগে আমাদের এই অনুপস্থিত মানগুলো মোকাবিলা করতে হবে।\n",
"\n",
"অনুপস্থিত ডেটা কীভাবে পরিচালনা করা হয় তা সূক্ষ্ম ভারসাম্য বহন করে, যা আপনার চূড়ান্ত বিশ্লেষণ এবং বাস্তব জীবনের ফলাফলে প্রভাব ফেলতে পারে।\n",
"\n",
"অনুপস্থিত ডেটা মোকাবিলা করার প্রধানত দুটি উপায় রয়েছে:\n",
"\n",
"1. অনুপস্থিত মান থাকা সারি বাদ দেওয়া\n",
"2. অনুপস্থিত মানকে অন্য কোনো মান দিয়ে প্রতিস্থাপন করা\n",
"\n",
"আমরা এই দুটি পদ্ধতি এবং তাদের সুবিধা ও অসুবিধা বিস্তারিতভাবে আলোচনা করব।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "3VaYC1TvgRsD"
},
"source": [
"### নাল মান বাদ দেওয়া\n",
"\n",
"আমাদের মডেলে যে পরিমাণ ডেটা আমরা সরবরাহ করি, তা তার কার্যকারিতার উপর সরাসরি প্রভাব ফেলে। নাল মান বাদ দেওয়া মানে আমরা ডেটাপয়েন্টের সংখ্যা কমাচ্ছি, এবং সেইসঙ্গে ডেটাসেটের আকারও কমাচ্ছি। তাই, যখন ডেটাসেট বেশ বড় হয়, তখন নাল মানযুক্ত সারি বাদ দেওয়া পরামর্শযোগ্য।\n",
"\n",
"আরেকটি উদাহরণ হতে পারে যে কোনো নির্দিষ্ট সারি বা কলামে অনেক বেশি অনুপস্থিত মান রয়েছে। সেক্ষেত্রে, সেগুলো বাদ দেওয়া যেতে পারে কারণ সেগুলো আমাদের বিশ্লেষণে খুব বেশি মূল্য যোগ করবে না যেহেতু সেই সারি/কলামের বেশিরভাগ ডেটা অনুপস্থিত।\n",
"\n",
"নাল মান সনাক্ত করার বাইরে, pandas `Series` এবং `DataFrame` থেকে নাল মান সরানোর একটি সুবিধাজনক উপায় প্রদান করে। এটি বাস্তবে দেখতে, চলুন `example3`-এ ফিরে যাই। `DataFrame.dropna()` ফাংশন নাল মানযুক্ত সারি বাদ দিতে সাহায্য করে।\n"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "7uIvS097gRsD",
"outputId": "c13fc117-4ca1-4145-a0aa-42ac89e6e218",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"0 0\n",
"2 \n",
"dtype: object"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example3 = example3.dropna()\n",
"example3"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "hil2cr64gRsD"
},
"source": [
"লক্ষ্য করুন যে এটি `example3[example3.notnull()]` এর আউটপুটের মতো দেখাবে। এখানে পার্থক্য হলো, শুধু মাস্ক করা মানগুলোর উপর ইনডেক্সিং করার পরিবর্তে, `dropna` `Series` `example3` থেকে সেই অনুপস্থিত মানগুলো সরিয়ে দিয়েছে।\n",
"\n",
"কারণ DataFrames-এর দুটি মাত্রা থাকে, এটি ডেটা বাদ দেওয়ার জন্য আরও বিকল্প প্রদান করে।\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "an-l74sPgRsE",
"outputId": "340876a0-63ad-40f6-bd54-6240cdae50ab",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>NaN</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>6.0</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 1.0 NaN 7\n",
"1 2.0 5.0 8\n",
"2 NaN 6.0 9"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4 = pd.DataFrame([[1, np.nan, 7], \n",
" [2, 5, 8], \n",
" [np.nan, 6, 9]])\n",
"example4"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "66wwdHZrgRsE"
},
"source": [
"(আপনি কি লক্ষ্য করেছেন যে pandas দুটি কলামকে `NaN` মানগুলোর জন্য ফ্লোটে আপকাস্ট করেছে?)\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` দিয়ে পূরণ করি। ধরুন, আমাদের কাছে ১০০টি ডেটা পয়েন্ট আছে, যার মধ্যে ৯০টি \"True\" বলেছে, ৮টি \"False\" বলেছে এবং ২টি পূরণ করা হয়নি। তাহলে, আমরা পুরো কলামটি বিবেচনা করে সেই ২টি \"True\" দিয়ে পূরণ করতে পারি।\n",
"\n",
"এখানে আবার আমরা ডোমেইন জ্ঞান ব্যবহার করতে পারি। আসুন, mode দিয়ে পূরণের একটি উদাহরণ বিবেচনা করি।\n"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "MY5faq4yLdpQ",
"outputId": "19ab472e-1eed-4de8-f8a7-db2a3af3cb1a"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1</td>\n",
" <td>2</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>3</td>\n",
" <td>4</td>\n",
" <td>None</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>5</td>\n",
" <td>6</td>\n",
" <td>False</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>7</td>\n",
" <td>8</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>9</td>\n",
" <td>10</td>\n",
" <td>True</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 1 2 True\n",
"1 3 4 None\n",
"2 5 6 False\n",
"3 7 8 True\n",
"4 9 10 True"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mode = pd.DataFrame([[1,2,\"True\"],\n",
" [3,4,None],\n",
" [5,6,\"False\"],\n",
" [7,8,\"True\"],\n",
" [9,10,\"True\"]])\n",
"\n",
"fill_with_mode"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "MLAoMQOfNPlA"
},
"source": [
"এখন, প্রথমে মোডটি খুঁজে বের করি তারপরে `None` মানটি মোড দিয়ে পূরণ করি।\n"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "WKy-9Y2tN5jv",
"outputId": "8da9fa16-e08c-447e-dea1-d4b1db2feebf"
},
"outputs": [
{
"data": {
"text/plain": [
"True 3\n",
"False 1\n",
"Name: 2, dtype: int64"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mode[2].value_counts()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "6iNz_zG_OKrx"
},
"source": [
"তাহলে, আমরা None এর পরিবর্তে True ব্যবহার করব।\n"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"id": "TxPKteRvNPOs"
},
"outputs": [],
"source": [
"fill_with_mode[2].fillna('True',inplace=True)"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "tvas7c9_OPWE",
"outputId": "ec3c8e44-d644-475e-9e22-c65101965850"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1</td>\n",
" <td>2</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>3</td>\n",
" <td>4</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>5</td>\n",
" <td>6</td>\n",
" <td>False</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>7</td>\n",
" <td>8</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>9</td>\n",
" <td>10</td>\n",
" <td>True</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 1 2 True\n",
"1 3 4 True\n",
"2 5 6 False\n",
"3 7 8 True\n",
"4 9 10 True"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mode"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "SktitLxxOR16"
},
"source": [
"যেমন আমরা দেখতে পাচ্ছি, null মানটি প্রতিস্থাপিত হয়েছে। বলার অপেক্ষা রাখে না, আমরা `'True'` এর জায়গায় যেকোনো কিছু লিখতে পারতাম এবং সেটি প্রতিস্থাপিত হত।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "heYe1I0dOmQ_"
},
"source": [
"### সংখ্যাগত ডেটা\n",
"এখন, সংখ্যাগত ডেটার ক্ষেত্রে আসা যাক। এখানে, অনুপস্থিত মান প্রতিস্থাপনের দুটি সাধারণ পদ্ধতি রয়েছে:\n",
"\n",
"1. সারির মধ্যম (Median) দিয়ে প্রতিস্থাপন\n",
"2. সারির গড় (Mean) দিয়ে প্রতিস্থাপন\n",
"\n",
"যখন ডেটা আউটলাইয়ারসহ বক্ররেখা (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": [
"মধ্যমান দিয়ে পূরণ করা\n"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "FzncQLmuS5jh",
"outputId": "00f74fff-01f4-4024-c261-796f50f01d2e"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>-2.0</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>-1.0</td>\n",
" <td>2</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>0.0</td>\n",
" <td>4</td>\n",
" <td>5</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>1.0</td>\n",
" <td>6</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>2.0</td>\n",
" <td>8</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 -2.0 0 1\n",
"1 -1.0 2 3\n",
"2 0.0 4 5\n",
"3 1.0 6 7\n",
"4 2.0 8 9"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mean[0].fillna(np.mean(fill_with_mean[0]),inplace=True)\n",
"fill_with_mean"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "CwpVFCrPTC5z"
},
"source": [
"যেমনটি আমরা দেখতে পাচ্ছি, অনুপস্থিত মানটি তার গড় দিয়ে প্রতিস্থাপিত হয়েছে।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "jIvF13a1i00Z"
},
"source": [
"এবার চলুন আমরা আরেকটি ডেটাফ্রেম চেষ্টা করি, এবং এইবার আমরা None মানগুলো কলামের মধ্যম মান দিয়ে প্রতিস্থাপন করব।\n"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "DA59Bqo3jBYZ",
"outputId": "85dae6ec-7394-4c36-fda0-e04769ec4a32"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>-2</td>\n",
" <td>0.0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>-1</td>\n",
" <td>2.0</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>0</td>\n",
" <td>NaN</td>\n",
" <td>5</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>1</td>\n",
" <td>6.0</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>2</td>\n",
" <td>8.0</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 -2 0.0 1\n",
"1 -1 2.0 3\n",
"2 0 NaN 5\n",
"3 1 6.0 7\n",
"4 2 8.0 9"
]
},
"execution_count": 35,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_median = pd.DataFrame([[-2,0,1],\n",
" [-1,2,3],\n",
" [0,np.nan,5],\n",
" [1,6,7],\n",
" [2,8,9]])\n",
"\n",
"fill_with_median"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "mM1GpXYmjHnc"
},
"source": [
"দ্বিতীয় কলামের মধ্যম মান হল\n"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "uiDy5v3xjHHX",
"outputId": "564b6b74-2004-4486-90d4-b39330a64b88"
},
"outputs": [
{
"data": {
"text/plain": [
"4.0"
]
},
"execution_count": 36,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_median[1].median()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "z9PLF75Jj_1s"
},
"source": [
"মিডিয়ান দিয়ে পূরণ করা\n"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "lFKbOxCMkBbg",
"outputId": "a8bd18fb-2765-47d4-e5fe-e965f57ed1f4"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>-2</td>\n",
" <td>0.0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>-1</td>\n",
" <td>2.0</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>0</td>\n",
" <td>4.0</td>\n",
" <td>5</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>1</td>\n",
" <td>6.0</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>2</td>\n",
" <td>8.0</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 -2 0.0 1\n",
"1 -1 2.0 3\n",
"2 0 4.0 5\n",
"3 1 6.0 7\n",
"4 2 8.0 9"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_median[1].fillna(fill_with_median[1].median(),inplace=True)\n",
"fill_with_median"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "8JtQ53GSkKWC"
},
"source": [
"যেমন আমরা দেখতে পাচ্ছি, NaN মানটি কলামের মধ্যমান দ্বারা প্রতিস্থাপিত হয়েছে।\n"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "0ybtWLDdgRsG",
"outputId": "b8c238ef-6024-4ee2-be2b-aa1f0fcac61d",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"a 1.0\n",
"b NaN\n",
"c 2.0\n",
"d NaN\n",
"e 3.0\n",
"dtype: float64"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example5 = pd.Series([1, np.nan, 2, None, 3], index=list('abcde'))\n",
"example5"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "yrsigxRggRsH"
},
"source": [
"আপনি সমস্ত শূন্য এন্ট্রি একটি একক মান, যেমন `0` দিয়ে পূরণ করতে পারেন:\n"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "KXMIPsQdgRsH",
"outputId": "aeedfa0a-a421-4c2f-cb0d-183ce8f0c91d",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"a 1.0\n",
"b 0.0\n",
"c 2.0\n",
"d 0.0\n",
"e 3.0\n",
"dtype: float64"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example5.fillna(0)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "RRlI5f_hkfKe"
},
"source": [
"> মূল বিষয়সমূহ:\n",
"1. অনুপস্থিত মান পূরণ করা উচিত যখন ডেটা কম থাকে বা অনুপস্থিত ডেটা পূরণের জন্য কোনো কৌশল থাকে।\n",
"2. ডোমেইন জ্ঞান ব্যবহার করে আনুমানিকভাবে অনুপস্থিত মান পূরণ করা যেতে পারে।\n",
"3. শ্রেণীবদ্ধ ডেটার ক্ষেত্রে, সাধারণত অনুপস্থিত মান কলামের মোড দিয়ে প্রতিস্থাপন করা হয়।\n",
"4. সংখ্যাসূচক ডেটার ক্ষেত্রে, অনুপস্থিত মান সাধারণত কলামের গড় (স্বাভাবিককৃত ডেটাসেটের জন্য) বা মধ্যমা দিয়ে পূরণ করা হয়।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "FI9MmqFJgRsH"
},
"source": [
"### ব্যায়াম:\n"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"collapsed": true,
"id": "af-ezpXdgRsH",
"trusted": false
},
"outputs": [],
"source": [
"# What happens if you try to fill null values with a string, like ''?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "kq3hw1kLgRsI"
},
"source": [
"আপনি **ফরওয়ার্ড-ফিল** 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": [
"আপনি **ব্যাক-ফিল** ব্যবহার করে null পূরণের জন্য পরবর্তী বৈধ মানকে পিছনের দিকে প্রসারিত করতে পারেন:\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",
"ওয়ান হট এনকোডিং একটি ভিন্ন ধরনের এনকোডিং। এই পদ্ধতিতে, কলামের প্রতিটি ক্যাটাগরি আলাদা একটি কলাম হিসেবে যুক্ত হয় এবং প্রতিটি ডেটাপয়েন্ট 0 বা 1 পায় এই ভিত্তিতে যে সেটি সেই ক্যাটাগরি ধারণ করে কিনা। সুতরাং, যদি 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",
"যদিও অনুপস্থিত মান এবং সঠিক ডুপ্লিকেট সাধারণ সমস্যা, বাস্তব-জগতের ডেটাসেটে প্রায়ই আরও সূক্ষ্ম সমস্যাগুলি থাকে:\n",
"\n",
"1. **অসঙ্গতিপূর্ণ শ্রেণীবিভাগ মান**: একই শ্রেণী বিভিন্নভাবে লেখা (যেমন, \"USA\", \"U.S.A\", \"United States\")\n",
"2. **অস্বাভাবিক সংখ্যাসূচক মান**: চরম আউটলায়ার যা ডেটা এন্ট্রি ত্রুটি নির্দেশ করে (যেমন, বয়স = 999)\n",
"3. **প্রায়-ডুপ্লিকেট সারি**: রেকর্ড যা সামান্য পরিবর্তনের সাথে একই সত্তাকে উপস্থাপন করে\n",
"\n",
"এসব সমস্যাগুলি সনাক্ত এবং পরিচালনা করার কৌশলগুলি আমরা এখন অন্বেষণ করব।\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### একটি নমুনা \"অগোছালো\" ডেটাসেট তৈরি করা\n",
"\n",
"প্রথমে, চলুন একটি নমুনা ডেটাসেট তৈরি করি যা বাস্তব জীবনের ডেটাতে আমরা সাধারণত যে ধরণের সমস্যাগুলোর সম্মুখীন হই তা ধারণ করে:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"import numpy as np\n",
"\n",
"# Create a sample dataset with quality issues\n",
"dirty_data = pd.DataFrame({\n",
" 'customer_id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],\n",
" 'name': ['John Smith', 'Jane Doe', 'John Smith', 'Bob Johnson', \n",
" 'Alice Williams', 'Charlie Brown', 'John Smith', 'Eva Martinez',\n",
" 'Bob Johnson', 'Diana Prince', 'Frank Castle', 'Alice Williams'],\n",
" 'age': [25, 32, 25, 45, 28, 199, 25, 31, 45, 27, -5, 28],\n",
" 'country': ['USA', 'UK', 'U.S.A', 'Canada', 'USA', 'United Kingdom',\n",
" 'United States', 'Mexico', 'canada', 'USA', 'UK', 'usa'],\n",
" 'purchase_amount': [100.50, 250.00, 105.00, 320.00, 180.00, 90.00,\n",
" 102.00, 275.00, 325.00, 195.00, 410.00, 185.00]\n",
"})\n",
"\n",
"print(\"Sample 'Dirty' Dataset:\")\n",
"print(dirty_data)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### ১. অসঙ্গত শ্রেণীবদ্ধ মান সনাক্ত করা\n",
"\n",
"লক্ষ করুন যে `country` কলামে একই দেশের জন্য একাধিক উপস্থাপনা রয়েছে। চলুন এই অসঙ্গতিগুলো সনাক্ত করি:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Check unique values in the country column\n",
"print(\"Unique country values:\")\n",
"print(dirty_data['country'].unique())\n",
"print(f\"\\nTotal unique values: {dirty_data['country'].nunique()}\")\n",
"\n",
"# Count occurrences of each variation\n",
"print(\"\\nValue counts:\")\n",
"print(dirty_data['country'].value_counts())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### শ্রেণীবদ্ধ মানগুলিকে মানসম্মত করা\n",
"\n",
"আমরা একটি ম্যাপিং তৈরি করে এই মানগুলোকে মানসম্মত করতে পারি। একটি সহজ পদ্ধতি হলো ছোট হাতের অক্ষরে রূপান্তর করা এবং একটি ম্যাপিং ডিকশনারি তৈরি করা:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Create a standardization mapping\n",
"country_mapping = {\n",
" 'usa': 'USA',\n",
" 'u.s.a': 'USA',\n",
" 'united states': 'USA',\n",
" 'uk': 'UK',\n",
" 'united kingdom': 'UK',\n",
" 'canada': 'Canada',\n",
" 'mexico': 'Mexico'\n",
"}\n",
"\n",
"# Standardize the country column\n",
"dirty_data['country_clean'] = dirty_data['country'].str.lower().map(country_mapping)\n",
"\n",
"print(\"Before standardization:\")\n",
"print(dirty_data['country'].value_counts())\n",
"print(\"\\nAfter standardization:\")\n",
"print(dirty_data[['country_clean']].value_counts())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**বিকল্প: ফাজি ম্যাচিং ব্যবহার করা**\n",
"\n",
"আরও জটিল ক্ষেত্রে, আমরা `rapidfuzz` লাইব্রেরি ব্যবহার করে ফাজি স্ট্রিং ম্যাচিং করতে পারি, যা স্বয়ংক্রিয়ভাবে অনুরূপ স্ট্রিং সনাক্ত করতে সাহায্য করে:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" from rapidfuzz import process, fuzz\n",
"except ImportError:\n",
" print(\"rapidfuzz is not installed. Please install it with 'pip install rapidfuzz' to use fuzzy matching.\")\n",
" process = None\n",
" fuzz = None\n",
"\n",
"# Get unique countries\n",
"unique_countries = dirty_data['country'].unique()\n",
"\n",
"# For each country, find similar matches\n",
"if process is not None and fuzz is not None:\n",
" print(\"Finding similar country names (similarity > 70%):\")\n",
" for country in unique_countries:\n",
" matches = process.extract(country, unique_countries, scorer=fuzz.ratio, limit=3)\n",
" # Filter matches with similarity > 70 and not identical\n",
" similar = [m for m in matches if m[1] > 70 and m[0] != country]\n",
" if similar:\n",
" print(f\"\\n'{country}' is similar to:\")\n",
" for match, score, _ in similar:\n",
" print(f\" - '{match}' (similarity: {score}%)\")\n",
"else:\n",
" print(\"Skipping fuzzy matching because rapidfuzz is not available.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2. অস্বাভাবিক সংখ্যাগত মান (আউটলায়ার) সনাক্ত করা\n",
"\n",
"`age` কলামটি দেখলে, আমরা কিছু সন্দেহজনক মান যেমন ১৯৯ এবং -৫ দেখতে পাই। চলুন এই আউটলায়ারগুলো সনাক্ত করতে পরিসংখ্যানগত পদ্ধতি ব্যবহার করি।\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Display basic statistics\n",
"print(\"Age column statistics:\")\n",
"print(dirty_data['age'].describe())\n",
"\n",
"# Identify impossible values using domain knowledge\n",
"print(\"\\nRows with impossible age values (< 0 or > 120):\")\n",
"impossible_ages = dirty_data[(dirty_data['age'] < 0) | (dirty_data['age'] > 120)]\n",
"print(impossible_ages[['customer_id', 'name', 'age']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### IQR (ইন্টারকোয়ার্টাইল রেঞ্জ) পদ্ধতি ব্যবহার করা\n",
"\n",
"IQR পদ্ধতি একটি শক্তিশালী পরিসংখ্যানগত কৌশল যা চরম মানগুলোর প্রতি কম সংবেদনশীল এবং বহিরাগত মান সনাক্ত করতে ব্যবহৃত হয়:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Calculate IQR for age (excluding impossible values)\n",
"valid_ages = dirty_data[(dirty_data['age'] >= 0) & (dirty_data['age'] <= 120)]['age']\n",
"\n",
"Q1 = valid_ages.quantile(0.25)\n",
"Q3 = valid_ages.quantile(0.75)\n",
"IQR = Q3 - Q1\n",
"\n",
"# Define outlier bounds\n",
"lower_bound = Q1 - 1.5 * IQR\n",
"upper_bound = Q3 + 1.5 * IQR\n",
"\n",
"print(f\"IQR-based outlier bounds for age: [{lower_bound:.2f}, {upper_bound:.2f}]\")\n",
"\n",
"# Identify outliers\n",
"age_outliers = dirty_data[(dirty_data['age'] < lower_bound) | (dirty_data['age'] > upper_bound)]\n",
"print(f\"\\nRows with age outliers:\")\n",
"print(age_outliers[['customer_id', 'name', 'age']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Z-স্কোর পদ্ধতি ব্যবহার করা\n",
"\n",
"Z-স্কোর পদ্ধতি গড় থেকে মানের মানক বিচ্যুতির উপর ভিত্তি করে অস্বাভাবিক মান নির্ধারণ করে:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" from scipy import stats\n",
"except ImportError:\n",
" print(\"scipy is required for Z-score calculation. Please install it with 'pip install scipy' and rerun this cell.\")\n",
"else:\n",
" # Calculate Z-scores for age, handling NaN values\n",
" age_nonan = dirty_data['age'].dropna()\n",
" zscores = np.abs(stats.zscore(age_nonan))\n",
" dirty_data['age_zscore'] = np.nan\n",
" dirty_data.loc[age_nonan.index, 'age_zscore'] = zscores\n",
"\n",
" # Typically, Z-score > 3 indicates an outlier\n",
" print(\"Rows with age Z-score > 3:\")\n",
" zscore_outliers = dirty_data[dirty_data['age_zscore'] > 3]\n",
" print(zscore_outliers[['customer_id', 'name', 'age', 'age_zscore']])\n",
"\n",
" # Clean up the temporary column\n",
" dirty_data = dirty_data.drop('age_zscore', axis=1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### আউটলায়ার পরিচালনা\n",
"\n",
"আউটলায়ার সনাক্ত করার পর, এগুলো বিভিন্নভাবে পরিচালনা করা যেতে পারে:\n",
"1. **অপসারণ**: আউটলায়ার থাকা সারি বাদ দিন (যদি এগুলো ত্রুটি হয়)\n",
"2. **সীমাবদ্ধ করা**: সীমার মান দিয়ে প্রতিস্থাপন করুন\n",
"3. **NaN দিয়ে প্রতিস্থাপন**: অনুপস্থিত ডেটা হিসেবে বিবেচনা করুন এবং ইম্পুটেশন কৌশল ব্যবহার করুন\n",
"4. **রাখা**: যদি এগুলো বৈধ চরম মান হয়\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Create a cleaned version by replacing impossible ages with NaN\n",
"dirty_data['age_clean'] = dirty_data['age'].apply(\n",
" lambda x: np.nan if (x < 0 or x > 120) else x\n",
")\n",
"\n",
"print(\"Age column before and after cleaning:\")\n",
"print(dirty_data[['customer_id', 'name', 'age', 'age_clean']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### ৩. কাছাকাছি সদৃশ সারি শনাক্ত করা\n",
"\n",
"লক্ষ্য করুন যে আমাদের ডেটাসেটে \"John Smith\"-এর জন্য একাধিক এন্ট্রি রয়েছে, যেগুলোর মান সামান্য ভিন্ন। চলুন নামের সাদৃশ্যের ভিত্তিতে সম্ভাব্য সদৃশগুলো শনাক্ত করি।\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# First, let's look at exact name matches (ignoring extra whitespace)\n",
"dirty_data['name_normalized'] = dirty_data['name'].str.strip().str.lower()\n",
"\n",
"print(\"Checking for duplicate names:\")\n",
"duplicate_names = dirty_data[dirty_data.duplicated(['name_normalized'], keep=False)]\n",
"print(duplicate_names.sort_values('name_normalized')[['customer_id', 'name', 'age', 'country']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### ফাজি ম্যাচিং ব্যবহার করে কাছাকাছি ডুপ্লিকেট খুঁজে বের করা\n",
"\n",
"আরও উন্নত ডুপ্লিকেট শনাক্তকরণের জন্য, আমরা ফাজি ম্যাচিং ব্যবহার করে মিলের কাছাকাছি নামগুলি খুঁজে বের করতে পারি:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" from rapidfuzz import process, fuzz\n",
"\n",
" # Function to find potential duplicates\n",
" def find_near_duplicates(df, column, threshold=90):\n",
" \"\"\"\n",
" Find near-duplicate entries in a column using fuzzy matching.\n",
" \n",
" Parameters:\n",
" - df: DataFrame\n",
" - column: Column name to check for duplicates\n",
" - threshold: Similarity threshold (0-100)\n",
" \n",
" Returns: List of potential duplicate groups\n",
" \"\"\"\n",
" values = df[column].unique()\n",
" duplicate_groups = []\n",
" checked = set()\n",
" \n",
" for value in values:\n",
" if value in checked:\n",
" continue\n",
" \n",
" # Find similar values\n",
" matches = process.extract(value, values, scorer=fuzz.ratio, limit=len(values))\n",
" similar = [m[0] for m in matches if m[1] >= threshold]\n",
" \n",
" if len(similar) > 1:\n",
" duplicate_groups.append(similar)\n",
" checked.update(similar)\n",
" \n",
" return duplicate_groups\n",
"\n",
" # Find near-duplicate names\n",
" duplicate_groups = find_near_duplicates(dirty_data, 'name', threshold=90)\n",
"\n",
" print(\"Potential duplicate groups:\")\n",
" for i, group in enumerate(duplicate_groups, 1):\n",
" print(f\"\\nGroup {i}:\")\n",
" for name in group:\n",
" matching_rows = dirty_data[dirty_data['name'] == name]\n",
" print(f\" '{name}': {len(matching_rows)} occurrence(s)\")\n",
" for _, row in matching_rows.iterrows():\n",
" print(f\" - Customer {row['customer_id']}: age={row['age']}, country={row['country']}\")\n",
"except ImportError:\n",
" print(\"rapidfuzz is not installed. Skipping fuzzy matching for near-duplicates.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### ডুপ্লিকেট পরিচালনা করা\n",
"\n",
"একবার ডুপ্লিকেট শনাক্ত করার পর, আপনাকে সিদ্ধান্ত নিতে হবে কীভাবে এগুলো পরিচালনা করবেন:\n",
"1. **প্রথম occurrence রাখুন**: `drop_duplicates(keep='first')` ব্যবহার করুন\n",
"2. **শেষ occurrence রাখুন**: `drop_duplicates(keep='last')` ব্যবহার করুন\n",
"3. **তথ্য একত্রিত করুন**: ডুপ্লিকেট সারি থেকে তথ্য একত্রিত করুন\n",
"4. **ম্যানুয়াল পর্যালোচনা**: মানুষের পর্যালোচনার জন্য চিহ্নিত করুন\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Example: Remove duplicates based on normalized name, keeping first occurrence\n",
"cleaned_data = dirty_data.drop_duplicates(subset=['name_normalized'], keep='first')\n",
"\n",
"print(f\"Original dataset: {len(dirty_data)} rows\")\n",
"print(f\"After removing name duplicates: {len(cleaned_data)} rows\")\n",
"print(f\"Removed: {len(dirty_data) - len(cleaned_data)} duplicate rows\")\n",
"\n",
"print(\"\\nCleaned dataset:\")\n",
"print(cleaned_data[['customer_id', 'name', 'age', 'country_clean']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### সারসংক্ষেপ: সম্পূর্ণ ডেটা ক্লিনিং পাইপলাইন\n",
"\n",
"চলুন সবকিছু একত্রিত করে একটি পূর্ণাঙ্গ ক্লিনিং পাইপলাইন তৈরি করি:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def clean_dataset(df):\n",
" \"\"\"\n",
" Comprehensive data cleaning function.\n",
" \"\"\"\n",
" # Create a copy to avoid modifying the original\n",
" cleaned = df.copy()\n",
" \n",
" # 1. Standardize categorical values (country)\n",
" country_mapping = {\n",
" 'usa': 'USA', 'u.s.a': 'USA', 'united states': 'USA',\n",
" 'uk': 'UK', 'united kingdom': 'UK',\n",
" 'canada': 'Canada', 'mexico': 'Mexico'\n",
" }\n",
" cleaned['country'] = cleaned['country'].str.lower().map(country_mapping)\n",
" \n",
" # 2. Clean abnormal age values\n",
" cleaned['age'] = cleaned['age'].apply(\n",
" lambda x: np.nan if (x < 0 or x > 120) else x\n",
" )\n",
" \n",
" # 3. Remove near-duplicate names (normalize whitespace)\n",
" cleaned['name'] = cleaned['name'].str.strip()\n",
" cleaned = cleaned.drop_duplicates(subset=['name'], keep='first')\n",
" \n",
" return cleaned\n",
"\n",
"# Apply the cleaning pipeline\n",
"final_cleaned_data = clean_dataset(dirty_data)\n",
"\n",
"print(\"Before cleaning:\")\n",
"print(f\" Rows: {len(dirty_data)}\")\n",
"print(f\" Unique countries: {dirty_data['country'].nunique()}\")\n",
"print(f\" Invalid ages: {((dirty_data['age'] < 0) | (dirty_data['age'] > 120)).sum()}\")\n",
"\n",
"print(\"\\nAfter cleaning:\")\n",
"print(f\" Rows: {len(final_cleaned_data)}\")\n",
"print(f\" Unique countries: {final_cleaned_data['country'].nunique()}\")\n",
"print(f\" Invalid ages: {((final_cleaned_data['age'] < 0) | (final_cleaned_data['age'] > 120)).sum()}\")\n",
"\n",
"print(\"\\nCleaned dataset:\")\n",
"print(final_cleaned_data[['customer_id', 'name', 'age', 'country', 'purchase_amount']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 🎯 চ্যালেঞ্জ অনুশীলন\n",
"\n",
"এখন আপনার পালা! নিচে একটি নতুন ডেটার সারি দেওয়া হয়েছে যেখানে একাধিক গুণগত সমস্যা রয়েছে। আপনি কি পারবেন:\n",
"\n",
"1. এই সারির সমস্ত সমস্যাগুলি চিহ্নিত করতে\n",
"2. প্রতিটি সমস্যার সমাধানের জন্য কোড লিখতে\n",
"3. পরিষ্কার করা সারিটি ডেটাসেটে যোগ করতে\n",
"\n",
"এখানে সমস্যাযুক্ত ডেটা:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# New problematic row\n",
"new_row = pd.DataFrame({\n",
" 'customer_id': [13],\n",
" 'name': [' Diana Prince '], # Extra whitespace\n",
" 'age': [250], # Impossible age\n",
" 'country': ['U.S.A.'], # Inconsistent format\n",
" 'purchase_amount': [150.00]\n",
"})\n",
"\n",
"print(\"New row to clean:\")\n",
"print(new_row)\n",
"\n",
"# TODO: Your code here to clean this row\n",
"# Hints:\n",
"# 1. Strip whitespace from the name\n",
"# 2. Check if the name is a duplicate (Diana Prince already exists)\n",
"# 3. Handle the impossible age value\n",
"# 4. Standardize the country name\n",
"\n",
"# Example solution (uncomment and modify as needed):\n",
"# new_row_cleaned = new_row.copy()\n",
"# new_row_cleaned['name'] = new_row_cleaned['name'].str.strip()\n",
"# new_row_cleaned['age'] = np.nan # Invalid age\n",
"# new_row_cleaned['country'] = 'USA' # Standardized\n",
"# print(\"\\nCleaned row:\")\n",
"# print(new_row_cleaned)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### মূল বিষয়গুলো\n",
"\n",
"1. **অসংগতিপূর্ণ বিভাগ** বাস্তব জীবনের ডেটায় সাধারণ। সবসময় ইউনিক মানগুলো পরীক্ষা করুন এবং ম্যাপিং বা ফাজি ম্যাচিং ব্যবহার করে সেগুলো মানক করুন।\n",
"\n",
"2. **আউটলায়ার** আপনার বিশ্লেষণে উল্লেখযোগ্য প্রভাব ফেলতে পারে। ডোমেইন জ্ঞান এবং পরিসংখ্যান পদ্ধতি (IQR, Z-score) একত্রে ব্যবহার করে সেগুলো সনাক্ত করুন।\n",
"\n",
"3. **প্রায়-ডুপ্লিকেট** সনাক্ত করা সঠিক ডুপ্লিকেটের তুলনায় কঠিন। ফাজি ম্যাচিং এবং ডেটা স্বাভাবিকীকরণ (লোয়ারকেসিং, হোয়াইটস্পেস সরানো) ব্যবহার করে সেগুলো চিহ্নিত করার চেষ্টা করুন।\n",
"\n",
"4. **ডেটা পরিষ্কারকরণ একটি পুনরাবৃত্তিমূলক প্রক্রিয়া**। চূড়ান্ত পরিষ্কার ডেটাসেট তৈরি করার আগে একাধিক কৌশল প্রয়োগ করতে হতে পারে এবং ফলাফল পর্যালোচনা করতে হতে পারে।\n",
"\n",
"5. **আপনার সিদ্ধান্তগুলো নথিভুক্ত করুন**। কোন পরিষ্কারকরণ ধাপগুলো প্রয়োগ করেছেন এবং কেন, তা লিপিবদ্ধ করুন, কারণ এটি পুনরুত্পাদনযোগ্যতা এবং স্বচ্ছতার জন্য গুরুত্বপূর্ণ।\n",
"\n",
"> **সেরা পদ্ধতি:** সবসময় আপনার মূল \"ডার্টি\" ডেটার একটি কপি রাখুন। কখনোই আপনার সোর্স ডেটা ফাইলগুলো ওভাররাইট করবেন না - পরিষ্কার সংস্করণ তৈরি করুন এবং স্পষ্ট নামকরণের নিয়ম অনুসরণ করুন, যেমন `data_cleaned.csv`।\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n---\n\n**অস্বীকৃতি**: \nএই নথিটি 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": "6301339d1c9a301b00639c635dc9b731",
"translation_date": "2025-10-03T19:39:02+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