Python এ Logistic Regression মডেল তৈরি

Classification Report একটি গুরুত্বপূর্ণ মেট্রিক্স যা মডেলের পারফরম্যান্স বিশ্লেষণে সহায়ক। এটি ক্লাসিফিকেশন সমস্যায় মডেলের accuracy, precision, recall, এবং F1-score প্রদান করে। এই মেট্রিক্সগুলি মডেলের দক্ষতা এবং তার নির্ভুলতা, পুনরুদ্ধার ক্ষমতা, এবং ভারসাম্য বুঝতে সাহায্য করে।

Precision, Recall, এবং F1-score এর সংজ্ঞা নিম্নরূপ:

• Precision: কতটা সঠিকভাবে মডেল পজিটিভ ক্লাস প্রেডিক্ট করেছে।

  $$Precision = \frac{True Positives}{True Positives + False Positives}$$

• Recall: মডেল কতটা সফলভাবে আসল পজিটিভ ক্লাস শনাক্ত করতে পেরেছে।

  $$Recall = \frac{True Positives}{True Positives + False Negatives}$$

• F1-score: Precision এবং Recall এর গড় হার। এটি Precision এবং Recall এর মধ্যে ব্যালান্স বজায় রাখতে সাহায্য করে।

  $$F1-score = 2 \times \frac{Precision \times Recall}{Precision + Recall}$$

classification_report ফাংশন

scikit-learn লাইব্রেরিতে classification_report ফাংশন ব্যবহার করে এই মেট্রিক্সগুলি সহজেই বের করা যায়।

উদাহরণ:

নিচে একটি উদাহরণ দেয়া হলো যেখানে আমরা একটি Binary Classification মডেল ব্যবহার করে Classification Report তৈরি করব।

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report

# ডেটা তৈরি করা (Binary Classification)
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, random_state=42)

# ডেটা ভাগ করা
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# মডেল তৈরি এবং ট্রেনিং
model = LogisticRegression()
model.fit(X_train, y_train)

# প্রেডিকশন করা
y_pred = model.predict(X_test)

# Classification Report তৈরি করা
report = classification_report(y_test, y_pred)

# রিপোর্ট প্রিন্ট করা
print(report)

আউটপুট:

              precision    recall  f1-score   support

           0       0.97      0.99      0.98       102
           1       0.99      0.97      0.98        98

    accuracy                           0.98       200
   macro avg       0.98      0.98      0.98       200
weighted avg       0.98      0.98      0.98       200

classification_report আউটপুট ব্যাখ্যা:

1. Precision: প্রতি পজিটিভ প্রেডিকশনের জন্য কতটি সঠিক ছিল তা দেখায়।
2. Recall: মোট পজিটিভ কেসের মধ্যে মডেল কতটি সঠিকভাবে শনাক্ত করতে পেরেছে তা দেখায়।
3. F1-score: Precision এবং Recall এর সমন্বিত পরিমাপ, যেখানে দুটি মূল্যমানের ভারসাম্য রাখা হয়।
4. Support: প্রতিটি ক্লাসের জন্য কতটি আসল উদাহরণ ছিল, অর্থাৎ টেস্ট ডেটার মধ্যে ওই শ্রেণীর সংখ্যা।

এটি binary classification বা multiclass classification উভয়ের জন্য কাজ করে, এবং শ্রেণীভিত্তিক পারফরম্যান্স বিশ্লেষণ করতে সাহায্য করে।

সারাংশ:

• Classification Report মডেলের precision, recall, এবং F1-score সহ পারফরম্যান্স বিশ্লেষণ করতে ব্যবহৃত হয়।
• এটি scikit-learn এর classification_report ফাংশন দিয়ে তৈরি করা যায়।
• এটি ক্লাস ভিত্তিক মূল্যায়ন প্রদান করে, যা মডেলের শক্তি এবং দুর্বলতা শনাক্ত করতে সাহায্য করে।

লজিস্টিক রিগ্রেশন একটি জনপ্রিয় এবং শক্তিশালী ক্লাসিফিকেশন অ্যালগরিদম যা সাধারণত বাইনারি ক্লাসিফিকেশন সমস্যার জন্য ব্যবহৃত হয়। Python-এ scikit-learn লাইব্রেরি ব্যবহার করে খুব সহজে একটি লজিস্টিক রিগ্রেশন মডেল তৈরি করা যায়।

নিচে একটি ধাপে ধাপে উদাহরণ দেওয়া হলো:

1. প্রয়োজনীয় লাইব্রেরি ইনস্টল করা

প্রথমে, আপনার সিস্টেমে প্রয়োজনীয় লাইব্রেরি গুলি ইনস্টল করুন। যদি আগে থেকে ইনস্টল না থাকে, তাহলে আপনি নিচের কমান্ডটি চালিয়ে scikit-learn, pandas, matplotlib ইত্যাদি লাইব্রেরি ইনস্টল করতে পারেন:

pip install numpy pandas scikit-learn matplotlib

2. লাইব্রেরি ইমপোর্ট করা

ডেটা লোড এবং মডেল তৈরি করার জন্য প্রয়োজনীয় লাইব্রেরিগুলি ইমপোর্ট করুন:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix

3. ডেটা লোড করা

এখন একটি ডেটাসেট লোড করতে হবে। এখানে আমরা উদাহরণ হিসেবে Iris ডেটাসেট ব্যবহার করছি:

# Iris ডেটাসেট লোড করা
from sklearn.datasets import load_iris
data = load_iris()

# ইনপুট ফিচার (X) এবং আউটপুট (y) আলাদা করা
X = data.data
y = data.target

# ডেটার প্রথম ৫টি রেকর্ড দেখানো
print(pd.DataFrame(X, columns=data.feature_names).head())

4. ডেটা টেস্ট এবং ট্রেনিং সেটে ভাগ করা

এখন ডেটাকে ট্রেনিং এবং টেস্ট সেটে ভাগ করা হবে। সাধারণত, ৭০%-৮০% ডেটা ট্রেনিংয়ের জন্য এবং ২০%-৩০% টেস্টের জন্য রাখা হয়।

# ডেটা ট্রেনিং এবং টেস্ট সেটে ভাগ করা
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

5. ডেটা স্কেলিং (Optional)

লজিস্টিক রিগ্রেশন মডেলটির জন্য স্কেলিং খুবই গুরুত্বপূর্ণ, বিশেষত যখন বিভিন্ন ফিচারের স্কেল ভিন্ন হয়। StandardScaler ব্যবহার করে ডেটা স্কেল করা যাবে।

# ডেটা স্কেলিং
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

6. লজিস্টিক রিগ্রেশন মডেল ট্রেনিং

এখন লজিস্টিক রিগ্রেশন মডেল তৈরি এবং ট্রেনিং করা হবে:

# লজিস্টিক রিগ্রেশন মডেল তৈরি
model = LogisticRegression(max_iter=200)

# মডেল ট্রেনিং
model.fit(X_train, y_train)

7. প্রেডিকশন এবং মডেল মূল্যায়ন

এখন মডেলটি টেস্ট ডেটা থেকে প্রেডিকশন করবে এবং তারপর accuracy এবং confusion matrix এর মাধ্যমে মডেলটির পারফরম্যান্স মূল্যায়ন করা হবে।

# প্রেডিকশন করা
y_pred = model.predict(X_test)

# accuracy চেক করা
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy * 100:.2f}%")

# Confusion matrix প্রিন্ট করা
cm = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(cm)

# Confusion matrix এর visualization
plt.matshow(cm, cmap='Blues')
plt.title("Confusion Matrix")
plt.colorbar()
plt.xlabel("Predicted")
plt.ylabel("True")
plt.show()

8. ফলাফল বিশ্লেষণ

• Accuracy: এই মেট্রিকটি মডেলের সঠিকতার পরিমাণ জানায়। এটি সঠিকভাবে প্রেডিক্ট করা ক্লাসগুলির সংখ্যা (সঠিক আউটপুট) মোট ক্লাসের সংখ্যা দ্বারা ভাগ করে বের করা হয়।
• Confusion Matrix: এটি একটি সারণী যা মডেলের পারফরম্যান্সের বিশ্লেষণ করতে সহায়ক, যেখানে আপনি দেখতে পারবেন কতটি সঠিকভাবে প্রেডিক্ট করা হয়েছে এবং কতটি ভুল হয়েছে।

9. সারাংশ

• মডেল তৈরি: প্রথমে LogisticRegression মডেল তৈরি করে, সেটি প্রশিক্ষণ ডেটার ওপর ট্রেনিং করা হয়।
• প্রেডিকশন: এরপর, মডেলটি টেস্ট ডেটার উপর প্রেডিকশন করে এবং accuracy, confusion matrix ব্যবহার করে মডেলটির পারফরম্যান্স মূল্যায়ন করা হয়।

এভাবে, Python এবং scikit-learn লাইব্রেরি ব্যবহার করে লজিস্টিক রিগ্রেশন মডেল তৈরি এবং মূল্যায়ন করা যায়।

Train/Test Split একটি গুরুত্বপূর্ণ ধাপ যেটি মেশিন লার্নিং প্রক্রিয়াতে ব্যবহৃত হয়, যাতে ডেটাকে ট্রেনিং এবং টেস্ট সেটে ভাগ করা হয়। ট্রেনিং সেটে মডেলটি প্রশিক্ষিত হয় এবং টেস্ট সেটে মডেলটির পারফরম্যান্স যাচাই করা হয়।

Scikit-learn এ train_test_split() ফাংশন ব্যবহার করে খুব সহজেই ডেটা বিভাজন করা যায়। এটি ডেটাকে স্বতঃস্ফূর্তভাবে ট্রেনিং এবং টেস্ট সেটে ভাগ করে, যা মডেল ট্রেনিং এবং মূল্যায়নে সহায়ক।

1. Train/Test Split এর প্রয়োজনীয়তা

ডেটাকে ট্রেনিং এবং টেস্ট সেটে ভাগ করার কারণ হল:

• Overfitting: যদি আপনি পুরো ডেটা ব্যবহার করেন মডেল ট্রেনিং এবং মূল্যায়নের জন্য, তাহলে মডেলটি পুরো ডেটা সিজন হয়ে যেতে পারে, যা ওভারফিটিং (Overfitting) সৃষ্টি করতে পারে।
• Generalization: ডেটা বিভাজন নিশ্চিত করে যে, মডেলটি শুধুমাত্র ট্রেনিং ডেটার উপর নির্ভর না করে নতুন, অজানা ডেটাতে সঠিকভাবে কাজ করতে পারে।
• Model Validation: টেস্ট সেটের উপর মডেল মূল্যায়ন করে এর পারফরম্যান্স যাচাই করা যায়, যাতে আপনি জানেন মডেলটি বাস্তব ক্ষেত্রে কেমন পারফর্ম করবে।

2. train_test_split() ফাংশন ব্যবহার

Scikit-learn এর train_test_split() ফাংশন ব্যবহার করে ডেটাকে ট্রেনিং এবং টেস্ট সেটে ভাগ করা যায়। এর মাধ্যমে আপনি ডেটার নির্দিষ্ট একটি শতাংশ টেস্ট সেট হিসেবে আলাদা করতে পারেন।

Syntax:

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

• X: ফিচার বা ইনপুট ডেটা
• y: লক্ষ্য বা আউটপুট ভ্যারিয়েবল
• test_size: টেস্ট সেটের আকার (এটি সাধারণত 0.2 বা 20% এর মতো থাকে, কিন্তু এটি আপনার প্রয়োজন অনুযায়ী পরিবর্তন করা যেতে পারে)
• random_state: ফলস্বরূপ ডেটার বিভাজন একই থাকবে (যদি আপনি পুনরায় কোডটি চালান)।

উদাহরণ:

import pandas as pd
from sklearn.model_selection import train_test_split

# একটি উদাহরণ ডেটাসেট তৈরি করা
data = {'feature1': [1, 2, 3, 4, 5],
        'feature2': [5, 4, 3, 2, 1],
        'target': [0, 1, 0, 1, 0]}
df = pd.DataFrame(data)

# X এবং y আলাদা করা
X = df[['feature1', 'feature2']]  # ফিচার
y = df['target']  # লক্ষ্য

# ডেটাকে ট্রেনিং এবং টেস্ট সেটে ভাগ করা
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# ট্রেনিং এবং টেস্ট সেট প্রিন্ট করা
print("X_train:\n", X_train)
print("X_test:\n", X_test)
print("y_train:\n", y_train)
print("y_test:\n", y_test)

আউটপুট:

X_train:
    feature1  feature2
4         5         1
3         4         2
1         2         4
X_test:
    feature1  feature2
2         3         3
0         1         5
y_train:
 4    0
3    1
1    1
Name: target, dtype: int64
y_test:
 2    0
0    0
Name: target, dtype: int64

এখানে:

• test_size=0.2 মানে ২০% ডেটা টেস্ট সেট হিসেবে ভাগ করা হবে এবং ৮০% ডেটা ট্রেনিং সেট হিসেবে ব্যবহার করা হবে।
• random_state=42 মানে ডেটার বিভাজন একটি নির্দিষ্ট নিয়মে করা হবে, তাই কোড পুনরায় চালালে একই বিভাজন পাবেন।

3. ডেটা বিভাজন এবং লজিস্টিক রিগ্রেশন মডেল

ধরা যাক, এখন আমরা লজিস্টিক রিগ্রেশন মডেল তৈরি করতে চাই। আগে ডেটা ভাগ করতে হবে, তারপর মডেলটি ট্রেনিং এবং টেস্ট সেটে মূল্যায়ন করা হবে।

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

# লজিস্টিক রিগ্রেশন মডেল তৈরি করা
model = LogisticRegression()

# মডেল ট্রেনিং
model.fit(X_train, y_train)

# টেস্ট সেটের উপর প্রেডিকশন করা
y_pred = model.predict(X_test)

# মডেলের পারফরম্যান্স মূল্যায়ন
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy * 100}%")

এখানে:

• model.fit(X_train, y_train): ট্রেনিং সেটে মডেল প্রশিক্ষণ দেওয়া হয়।
• model.predict(X_test): টেস্ট সেটে প্রেডিকশন করা হয়।
• accuracy_score(y_test, y_pred): প্রকৃত আউটপুট এবং প্রেডিকটেড আউটপুটের ভিত্তিতে মডেলের সঠিকতা (accuracy) পরিমাপ করা হয়।

4. Additional Tips:

• Stratified Split: যদি আপনার লক্ষ্য ভ্যারিয়েবলটি অসমভাবে বিভক্ত থাকে (যেমন: 90% শ্রেণী 1 এবং 10% শ্রেণী 2), তবে আপনি Stratified Split ব্যবহার করতে পারেন যাতে প্রতিটি শ্রেণী ট্রেনিং এবং টেস্ট সেটে সঠিক অনুপাতে থাকে।

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=42)

• Cross-Validation: আপনি যদি মডেলের পারফরম্যান্স আরও ভালোভাবে যাচাই করতে চান, তবে K-Fold Cross-Validation ব্যবহার করতে পারেন। এতে আপনার ডেটাকে একাধিক ভাগে ভাগ করা হবে এবং মডেলটি প্রতিটি ভাগে পরীক্ষিত হবে।

from sklearn.model_selection import cross_val_score

# ক্রস ভ্যালিডেশন
scores = cross_val_score(model, X, y, cv=5)  # 5-Fold Cross Validation
print("Cross-validation scores:", scores)

সারাংশ

• Train/Test Split: ডেটাকে প্রশিক্ষণ এবং পরীক্ষার জন্য ভাগ করে, যাতে মডেলের পারফরম্যান্স ভালোভাবে যাচাই করা যায়।
• train_test_split(): Scikit-learn এর একটি শক্তিশালী ফাংশন, যা ডেটাকে ট্রেনিং এবং টেস্ট সেটে ভাগ করতে সাহায্য করে।
• মডেল মূল্যায়ন: মডেলটি প্রশিক্ষণের পর টেস্ট সেটে মূল্যায়ন করা হয় এবং accuracy, cross-validation স্কোর ইত্যাদি ব্যবহার করে ফলাফল বিশ্লেষণ করা হয়।

এটি একটি অত্যন্ত গুরুত্বপূর্ণ ধাপ যেটি মেশিন লার্নিং প্রক্রিয়ার নির্ভুলতা নিশ্চিত করতে সাহায্য করে।

মেশিন লার্নিং মডেল তৈরি এবং ফিট করা হলো মডেলটিকে ডেটার উপর প্রশিক্ষণ দেওয়ার প্রক্রিয়া, যাতে এটি নতুন ডেটা থেকে সঠিক প্রেডিকশন করতে পারে। এটি সাধারণত তিনটি প্রধান ধাপে করা হয়:

1. মডেল তৈরি (Model Creation)
2. মডেল ফিট করা (Model Fitting)
3. মডেলের মূল্যায়ন (Model Evaluation)

এখানে আমরা Python এবং scikit-learn লাইব্রেরি ব্যবহার করে একটি সাধারণ মডেল তৈরি এবং ফিট করার প্রক্রিয়া দেখাবো। উদাহরণস্বরূপ, লজিস্টিক রিগ্রেশন মডেল তৈরি করা হবে।

1. লাইব্রেরি ইমপোর্ট করা

প্রথমে আমরা প্রয়োজনীয় লাইব্রেরি ইমপোর্ট করবো:

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix

2. ডেটা লোড এবং প্রিপ্রসেসিং

এখানে আমরা একটি উদাহরণ ডেটাসেট লোড করবো এবং তা ট্রেনিং ও টেস্ট ডেটাতে ভাগ করবো। ধরুন আমাদের কাছে একটি CSV ফাইল আছে যেটি ডেটাসেট নামে সংরক্ষিত।

# ডেটা লোড করা
df = pd.read_csv('path_to_your_file.csv')

# ইনপুট ফিচার এবং আউটপুট ভ্যারিয়েবল আলাদা করা
X = df.iloc[:, :-1].values  # সমস্ত কলাম ছাড়া শেষ কলাম
y = df.iloc[:, -1].values  # শেষ কলাম (লেবেল)

# ডেটাকে ট্রেনিং এবং টেস্ট সেটে ভাগ করা
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

এখানে:

• train_test_split ফাংশনটি ডেটা 80% ট্রেনিং এবং 20% টেস্ট ডেটাতে ভাগ করে দেবে।

3. মডেল তৈরি (Model Creation)

এবার, আমরা একটি লজিস্টিক রিগ্রেশন মডেল তৈরি করবো:

# লজিস্টিক রিগ্রেশন মডেল তৈরি করা
model = LogisticRegression()

এখানে, LogisticRegression() একটি ক্লাস যা মডেল তৈরি করার জন্য ব্যবহৃত হয়।

4. মডেল ফিট করা (Model Fitting)

এখন মডেলটিকে ট্রেনিং ডেটার উপর ফিট করা হবে, যা মডেলটি শিখবে:

# মডেল ট্রেনিং (ফিট করা)
model.fit(X_train, y_train)

এখানে, fit() ফাংশনটি মডেলটিকে ট্রেনিং ডেটার সাথে ফিট করবে এবং মডেলটিকে প্রেডিকশন করার জন্য প্রস্তুত করবে।

5. মডেল মূল্যায়ন (Model Evaluation)

মডেল ফিট করার পর, আমরা মডেলটির কার্যকারিতা পরীক্ষা করতে পারি। মডেলটির প্রেডিকশন করতে predict() ফাংশন ব্যবহার করা হয় এবং তার পর আমরা accuracy এবং confusion matrix চেক করতে পারি।

# মডেল থেকে প্রেডিকশন করা
y_pred = model.predict(X_test)

# Accuracy চেক করা
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy * 100}%")

# Confusion Matrix
cm = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(cm)

এখানে:

• accuracy_score ফাংশনটি মডেলের সঠিকতার শতাংশ হিসাব করবে।
• confusion_matrix ফাংশনটি মডেলের পারফরম্যান্সের বিস্তারিত দেখাবে, যেমন কিভাবে সঠিক এবং ভুল শ্রেণীভুক্ত হয়েছে।

6. সারাংশ

এই প্রক্রিয়া অনুসরণ করে, আপনি যে কোনো মেশিন লার্নিং মডেল তৈরি এবং ফিট করতে পারেন। এখানে লজিস্টিক রিগ্রেশন মডেল ব্যবহার করা হয়েছে, তবে আপনি Decision Tree, Random Forest, SVM বা অন্যান্য মডেলও ব্যবহার করতে পারেন। প্রতিটি মডেলের জন্য scikit-learn লাইব্রেরিতে একই ধরনের পদ্ধতি ব্যবহৃত হয়: মডেল তৈরি, ট্রেনিং (ফিটিং), এবং মূল্যায়ন।

মডেল প্রেডিকশন হল মেশিন লার্নিং মডেল ব্যবহার করে ইনপুট ডেটার উপর ভিত্তি করে আউটপুট বা ফলাফল নির্ধারণ করা। এই প্রক্রিয়ায় মডেলটি শিখে নেয় যে, কোন ইনপুটের জন্য কী আউটপুট আসবে এবং নতুন ইনপুটের জন্য পূর্বাভাস বা প্রেডিকশন তৈরি করে।

নিচে মডেল প্রেডিকশন এবং প্রেডিক্ট করার বিস্তারিত ধাপগুলো দেওয়া হলো।

1. মডেল ট্রেনিং এবং প্রেডিকশন

মডেল প্রেডিকশন করতে হলে প্রথমে একটি মডেল তৈরি করতে হবে, তারপর ডেটা ট্রেনিং করতে হবে। এর পর মডেলটি প্রেডিকশন করবে নতুন বা অজানা ডেটার উপর।

(a) মডেল তৈরি করা:

প্রথমে মডেলটি তৈরি করতে হবে, যেমন লজিস্টিক রিগ্রেশন, ডিসিশন ট্রি, সাপোর্ট ভেক্টর মেশিন (SVM) ইত্যাদি।

(b) ডেটা ট্রেনিং করা:

ট্রেনিং ডেটাসেট ব্যবহার করে মডেলটি শিখবে কিভাবে আউটপুট নির্ধারণ করতে হয়।

(c) প্রেডিকশন করা:

মডেলটি যখন প্রশিক্ষিত হয়ে যাবে, তখন এটি নতুন ডেটা ব্যবহার করে প্রেডিকশন করবে এবং আউটপুট প্রদান করবে।

উদাহরণ: Logistic Regression - মডেল ট্রেনিং এবং প্রেডিকশন

এখানে একটি সাধারণ উদাহরণ দেওয়া হলো যেখানে আমরা Logistic Regression মডেল ব্যবহার করে একটি Binary Classification সমস্যা সমাধান করব। এই উদাহরণে আমরা scikit-learn লাইব্রেরি ব্যবহার করব।

# প্রয়োজনীয় লাইব্রেরি ইমপোর্ট করা
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

# ডেটাসেট তৈরি করা (Binary Classification)
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, random_state=42)

# ডেটাকে ট্রেনিং এবং টেস্ট সেটে ভাগ করা
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# মডেল তৈরি করা
model = LogisticRegression()

# মডেল ট্রেনিং
model.fit(X_train, y_train)

# টেস্ট ডেটার উপর প্রেডিকশন করা
y_pred = model.predict(X_test)

# প্রেডিকশন এর সঠিকতা মূল্যায়ন
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy * 100)

ব্যাখ্যা:

1. make_classification: একটি সিমুলেটেড ক্লাসিফিকেশন ডেটাসেট তৈরি করে, যেখানে ২০টি ফিচার এবং ২টি ক্লাস আছে।
2. train_test_split: ডেটাসেটটি ট্রেনিং এবং টেস্ট সেটে ভাগ করে।
3. LogisticRegression(): Logistic Regression মডেল তৈরি করে।
4. fit(): মডেলটি ট্রেনিং ডেটাতে ফিট (শিক্ষিত) করা হয়।
5. predict(): মডেলটি টেস্ট ডেটার উপর প্রেডিকশন করে এবং এর আউটপুট আনে।
6. accuracy_score(): মডেলের প্রেডিকশন এবং প্রকৃত আউটপুটের মধ্যে সঠিকতার হার গণনা করে।

2. Multiclass Classification - মডেল প্রেডিকশন

যদি আপনার Multiclass Classification সমস্যা থাকে, যেমন বিভিন্ন শ্রেণী নির্বাচন করা (যেমন, কুকুর, বিড়াল, পাখি), তবে মডেলটি একইভাবে প্রেডিকশন করবে, তবে এখানে আউটপুটটি একাধিক শ্রেণী হতে পারে।

উদাহরণ: Multiclass Classification with Logistic Regression

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

# Iris ডেটাসেট লোড করা
data = load_iris()
X = data.data
y = data.target

# ডেটাকে ট্রেনিং এবং টেস্ট সেটে ভাগ করা
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# মডেল তৈরি করা
model = LogisticRegression(max_iter=200)

# মডেল ট্রেনিং
model.fit(X_train, y_train)

# টেস্ট ডেটার উপর প্রেডিকশন করা
y_pred = model.predict(X_test)

# প্রেডিকশন এর সঠিকতা মূল্যায়ন
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy * 100)

ব্যাখ্যা:

• Iris ডেটাসেট: তিনটি শ্রেণীর (ক্লাস) ডেটাসেট, যেখানে প্রতিটি ফুলের প্রকার শনাক্ত করা হয়।
• Multiclass Classification: এখানে তিনটি সম্ভাব্য শ্রেণী রয়েছে (0, 1, 2)।
• predict(): এটি প্রতিটি ইনপুটের জন্য শ্রেণী নির্বাচন করবে (কুকুর, বিড়াল, পাখি)।

3. প্রেডিকশন সংক্রান্ত কিছু গুরুত্বপূর্ণ বিষয়

1. প্রেডিকশন প্রক্রিয়া:
   • fit() ফাংশন দ্বারা মডেল প্রশিক্ষিত হয়।
   • মডেলটি শিখে নেয় ইনপুট থেকে আউটপুট কিভাবে নির্ধারণ করতে হয়।
   • predict() ফাংশনটি নতুন ডেটার উপর আউটপুট বা ক্লাস প্রেডিক্ট করে।

2. সম্ভাবনা প্রেডিকশন: কিছু মডেল, যেমন Logistic Regression বা Random Forest, predict_proba() ফাংশন দিয়ে ইনপুট ডেটার জন্য সম্ভাবনা (probability) প্রেডিক্ট করতে পারে, যেখানে আউটপুট 0 এবং 1 এর মধ্যে একটি সম্ভাবনা প্রদান করা হয়।

   উদাহরণ:

   y_prob = model.predict_proba(X_test)
   print(y_prob)
   

   এটি মডেলটির প্রেডিকশন সম্ভাবনা প্রদান করবে, যেমন একটি নির্দিষ্ট ইনপুটের জন্য 0 অথবা 1 হওয়ার সম্ভাবনা।

সারাংশ:

• প্রেডিকশন হল মডেলটিকে ইনপুট ডেটা দেওয়ার পর সেই ইনপুটের জন্য প্রেডিক্টেড আউটপুট বা ক্লাস পাওয়া।
• predict() ফাংশনটি আউটপুট শ্রেণী প্রেডিক্ট করে, এবং কিছু মডেল predict_proba() দিয়ে সম্ভাবনা হিসেবেও আউটপুট প্রদান করতে পারে।