آموزش الگوریتم‌های کوانتومی – پارت ۱۲: الگوریتم جستجوی گروور (Grover’s Search Algorithm)

هدف پارت دوازدهم
در این بخش، به بررسی الگوریتم جستجوی گروور می‌پردازیم که یکی از الگوریتم‌های مهم و کاربردی در دنیای محاسبات کوانتومی است. این الگوریتم به طور خاص برای جستجو در پایگاه‌های داده غیرساختاریافته استفاده می‌شود و قادر است تعداد درخواست‌ها را به طور قابل توجهی کاهش دهد.



ایده اصلی الگوریتم گروور
فرض کنید یک پایگاه داده N عنصری دارید و هدف شما این است که یک عنصر خاص را در این پایگاه داده پیدا کنید. در یک جستجوی کلاسیک، شما مجبورید هر عنصر را یکی‌یکی بررسی کنید، که این به معنای انجام N درخواست است.

اما در الگوریتم گروور، می‌توانیم این جستجو را با استفاده از عملیات کوانتومی در زمان √N انجام دهیم. این به این معنی است که تعداد درخواست‌ها به طور قابل توجهی کاهش می‌یابد.

الگوریتم گروور از یک سری گام‌های خاص استفاده می‌کند که عبارتند از:
1. آماده‌سازی وضعیت اولیه: ایجاد یک وضعیت ابرموقعیت (superposition) از تمام حالت‌های ممکن.
2. عملگر Oracle: استفاده از یک عملگر ویژه برای علامت‌گذاری حالت هدف.
3. عملگر تقویت آماری: تقویت احتمال پیدا کردن حالت هدف از طریق اعمال یک سری عملیات بازگشتی.



مراحل الگوریتم گروور
1. آماده‌سازی وضعیت اولیه:
ابتدا باید یک حالت ابرموقعیت از تمام کیوبیت‌ها ایجاد کنیم. این کار با اعمال گیت هادامارد روی همه کیوبیت‌ها انجام می‌شود. نتیجه آن یک ترکیب خطی از تمام حالات ممکن خواهد بود.

2. اعمال عملگر اوراکل (Oracle):
اوراکل یک عملگر خاص است که وضعیت ابرموقعیت را تغییر می‌دهد. این عملگر وضعیت خاصی را که هدف ما است شناسایی کرده و آن را علامت‌گذاری می‌کند.

3. اعمال تقویت آماری:
پس از اعمال اوراکل، گام بعدی تقویت آماری است. این کار از طریق اعمال گیت‌های خاصی انجام می‌شود که احتمال پیدا کردن وضعیت هدف را افزایش می‌دهند.

4. تکرار این فرآیند:
این گام‌ها (عملگر اوراکل و تقویت آماری) به طور متناوب چندین بار تکرار می‌شوند تا احتمال پیدا کردن وضعیت هدف به حداکثر برسد.

5. اندازه‌گیری:
در نهایت، پس از اعمال چندین بار این گام‌ها، وضعیت نهایی اندازه‌گیری می‌شود و نتیجه پیدا کردن وضعیت هدف در پایگاه داده استخراج می‌شود.



مثال از الگوریتم گروور
فرض کنید داریم یک پایگاه داده ۴ عنصری که از کیوبیت‌های ۲ بیت تشکیل شده است و هدف پیدا کردن وضعیت خاصی به نام |11⟩ است.

در اینجا، مراحل الگوریتم به شرح زیر است:

1. آماده‌سازی وضعیت اولیه:
ابتدا گیت هادامارد را روی هر دو کیوبیت اعمال می‌کنیم تا وضعیت ابرموقعیت ایجاد شود:
|00⟩ → (1/√4) (|00⟩ + |01⟩ + |10⟩ + |11⟩)

2. اعمال اوراکل:
اوراکل باید وضعیت |11⟩ را علامت‌گذاری کند، به این معنی که باید علامت منفی روی این وضعیت اعمال کند. پس از اعمال اوراکل، وضعیت به شکل زیر تغییر می‌کند:
(1/√4) (|00⟩ + |01⟩ + |10⟩ - |11⟩)

3. اعمال تقویت آماری:
با اعمال تقویت آماری، احتمال پیدا کردن |11⟩ تقویت می‌شود. پس از اعمال گیت‌های تقویتی، وضعیت به حالت مطلوب نزدیک‌تر می‌شود.

4. تکرار این مراحل:
این مراحل به تعداد محدودی تکرار می‌شوند تا احتمال پیدا کردن |11⟩ به حداکثر برسد.

5. اندازه‌گیری:
در نهایت، کیوبیت‌ها اندازه‌گیری شده و مقدار |11⟩ پیدا می‌شود.



پیاده‌سازی الگوریتم گروور در Qiskit
در اینجا یک مثال ساده از پیاده‌سازی الگوریتم گروور در Qiskit را می‌بینید:

from qiskit import QuantumCircuit, Aer, transpile, assemble
from qiskit.visualization import plot_histogram

# تعداد کیوبیت‌ها
n = 2
qc = QuantumCircuit(n)

# ایجاد وضعیت ابرموقعیت
qc.h([0, 1])

# اعمال اوراکل (علامت‌گذاری |11⟩)
qc.cz(0, 1)

# تقویت آماری
qc.h([0, 1])
qc.x([0, 1])
qc.h(1)
qc.cx(0, 1)
qc.h(1)
qc.x([0, 1])
qc.h([0, 1])

# اندازه‌گیری
qc.measure_all()

# اجرای مدار
backend = Aer.get_backend('qasm_simulator')
qobj = assemble(transpile(qc, backend))
result = backend.run(qobj).result()
counts = result.get_counts()

# نمایش هیستوگرام نتایج
plot_histogram(counts)

توضیح کد
1. ایجاد وضعیت ابرموقعیت:
ابتدا گیت هادامارد روی دو کیوبیت اعمال می‌شود تا یک ترکیب خطی از تمام حالات ممکن ایجاد شود.

2. اعمال اوراکل:
اوراکل به‌صورت یک گیت کنترل شده سی‌زی (CZ) برای علامت‌گذاری وضعیت |11⟩ استفاده می‌شود.

3. تقویت آماری:
بعد از اعمال اوراکل، گیت‌های تقویت آماری مانند گیت‌های X و H به کیوبیت‌ها اعمال می‌شوند تا احتمال یافتن وضعیت هدف تقویت شود.

4. اندازه‌گیری:
در نهایت، کیوبیت‌ها اندازه‌گیری شده و نتیجه به صورت هیستوگرام نمایش داده می‌شود.



نتیجه اجرای کد
خروجی به صورت یک هیستوگرام خواهد بود که نشان‌دهنده احتمال پیدا کردن وضعیت |11⟩ است. به دلیل تقویت آماری، احتمال پیدا کردن وضعیت هدف بیشتر از سایر حالات خواهد بود.



پارت بعدی:
در پارت ۱۳، با الگوریتم سیمولاسیون هامیلتونی (Hamiltonian Simulation) آشنا خواهیم شد که در آن به شبیه‌سازی دینامیک سیستم‌های کوانتومی پرداخته می‌شود.

ادامه دارد...

[لینک کانال ما]

برنامه نویسی پایتون:
https://www.aparat.com/Amir_123_ka

✅بچه ها این چنل من در آپارات هست
دنبالش کنید تا اموزش های telebot و sqlite3 رو در اونجا بزاریم و حتی آموزش های دیگه😍

https://www.youtube.com/@LearnPythonwithAmirRM

اینم یوتیوب ما😅

پارت ۱: مقدمه، توضیحات، نکات و کاربردها ✨

سلام به همه دوستان! 🤗 امروز قراره با هم یاد بگیریم که الگوریتم مولتی کلاس کلاسیفیکیشن (Multi-Class Classification) چطور می‌تونه به ما کمک کنه تا داده‌ها رو به چند کلاس تقسیم کنیم. این الگوریتم یکی از مهم‌ترین الگوریتم‌های یادگیری ماشین هست که در مسائل مختلف کاربرد داره! 💻

🧠 مقدمه‌ای بر Multi-Class Classification
الگوریتم مولتی کلاس کلاسیفیکیشن برای پیش‌بینی کلاس‌های مختلف از داده‌های ورودی استفاده میشه. در واقع، این الگوریتم زمانی به کار میاد که شما با چندین دسته مختلف روبرو هستید و می‌خواهید پیش‌بینی کنید که داده‌های شما به کدام دسته تعلق دارند. مثلاً می‌خواهیم پیش‌بینی کنیم که یک ایمیل اسپم هست یا نه، یا یک تصویر به کدام گروه از تصاویر (گربه، سگ، ماشین و...) تعلق داره. 🐱🐶🚗

🔍 نکات مهم:
- این الگوریتم معمولاً برای مشکلاتی به کار میاد که خروجی دارای بیشتر از دو کلاس باشه.
- در بیشتر مسائل کلاسیفیکیشن، شما باید داده‌ها رو به دسته‌های مختلف تقسیم کنید.
- این الگوریتم می‌تونه از تکنیک‌هایی مثل One-vs-All یا One-vs-One برای حل این مشکلات استفاده کنه.

💡 کاربردهای الگوریتم Multi-Class Classification
- تشخیص چهره: شناسایی افراد مختلف در تصاویر.
- تشخیص دست‌خط: تشخیص اعداد یا حروف مختلف در نوشته‌های دست‌نویس.
- پیش‌بینی دسته‌بندی محصولات: دسته‌بندی انواع محصولات به گروه‌های مختلف.

در پارت‌های بعدی، با هم به پیاده‌سازی این الگوریتم در پایتون می‌پردازیم و یاد می‌گیریم که چطور میشه از Scikit-Learn برای پیاده‌سازی استفاده کرد. 🧑‍💻

ادامه آموزش اینجا

#پایتون #یادگیری_ماشین #کلاسیفیکیشن #الگوریتم #آموزش_پایتون

پارت ۲: توضیحات و آماده‌سازی داده‌ها برای Multi-Class Classification 📊

در این پارت، با هم به جزئیات بیشتری از الگوریتم مولتی کلاس کلاسیفیکیشن می‌پردازیم و یاد می‌گیریم که چطور داده‌ها رو برای استفاده در مدل آماده کنیم. 🔧

🧠 توضیحات بیشتر:
الگوریتم‌های کلاسیفیکیشن معمولاً به دو بخش نیاز دارند:
1. داده‌های ورودی (Features): این‌ها اطلاعاتی هستند که مدل برای پیش‌بینی استفاده می‌کنه. مثلا در پیش‌بینی دسته‌بندی ایمیل‌ها، ویژگی‌ها ممکنه شامل تعداد کلمات خاص، طول ایمیل یا وجود کلمات خاصی مثل "مجانی" یا "تخفیف" باشه.
2. برچسب‌ها (Labels): این‌ها نتایجی هستند که مدل باید پیش‌بینی کنه. مثلاً اگر می‌خواهیم پیش‌بینی کنیم که یک ایمیل اسپم است یا نه، برچسب‌ها می‌تونند "اسپم" و "غیراسپم" باشن.

برای مولتی کلاس کلاسیفیکیشن، برچسب‌ها بیشتر از دو دسته خواهند بود. مثلاً اگر می‌خواهیم پیش‌بینی کنیم که یک تصویر مربوط به کدام حیوان است، برچسب‌ها می‌تونند "گربه"، "سگ"، "خرگوش" و غیره باشند. 🐱🐶🐰

🔧 آماده‌سازی داده‌ها:
1. بارگذاری داده‌ها: ابتدا باید داده‌ها رو از یک فایل یا دیتابیس بارگذاری کنیم. معمولا داده‌ها در قالب‌های CSV یا Excel هستند.
2. پیش‌پردازش داده‌ها: این مرحله شامل کارهایی مثل پاکسازی داده‌ها (حذف مقادیر گمشده)، استانداردسازی یا نرمال‌سازی ویژگی‌ها و تبدیل داده‌ها به فرمت قابل قبول برای مدل‌هاست.

برای این کار، از کتابخانه‌های معروف پایتون مثل Pandas و NumPy استفاده می‌کنیم. 📚

💻 کد نمونه برای بارگذاری داده‌ها:

import pandas as pd

# بارگذاری داده‌ها از یک فایل CSV
data = pd.read_csv('data.csv')

# نمایش اولین چند ردیف از داده‌ها
print(data.head())

🧹 پیش‌پردازش داده‌ها:
قبل از آموزش مدل، ممکنه نیاز باشه داده‌ها رو پیش‌پردازش کنیم. این شامل حذف مقادیر گمشده و تغییر نوع داده‌ها به فرمت‌های مناسب می‌شه.

# حذف ردیف‌هایی که مقادیر گمشده دارند
data = data.dropna()

# تبدیل داده‌های متنی به عددی (مثلاً برچسب‌ها به اعداد)
from sklearn.preprocessing import LabelEncoder
encoder = LabelEncoder()
data['label'] = encoder.fit_transform(data['label'])

📊 تقسیم داده‌ها به مجموعه‌های آموزشی و آزمایشی:
برای ارزیابی عملکرد مدل، داده‌ها رو به دو بخش تقسیم می‌کنیم: مجموعه آموزشی (برای آموزش مدل) و مجموعه آزمایشی (برای ارزیابی مدل).

from sklearn.model_selection import train_test_split

X = data.drop('label', axis=1)  # ویژگی‌ها
y = data['label']  # برچسب‌ها

# تقسیم داده‌ها به مجموعه آموزشی و آزمایشی
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

💡 نکات مهم:
- داده‌ها باید به درستی پیش‌پردازش و آماده بشن تا مدل بهترین عملکرد رو داشته باشه.
- برای جلوگیری از overfitting (یادگیری بیش از حد مدل روی داده‌های آموزشی)، بهتره داده‌ها به درستی تقسیم بشن.

با آماده شدن داده‌ها، می‌تونیم وارد مرحله بعدی یعنی انتخاب مدل و آموزش آن بشیم. در پارت بعدی به آموزش مدل می‌پردازیم و نحوه استفاده از الگوریتم‌ها رو یاد می‌گیریم. 🏆

[آموزش های بیشتر اینجا]

#پایتون #یادگیری_ماشین #کلاسیفیکیشن #آماده‌سازی_داده‌ها #پیش‌پردازش #داده #ScikitLearn

پارت ۳: انتخاب مدل و آموزش آن برای Multi-Class Classification 📈

حالا که داده‌ها رو آماده کردیم، وقتشه که مدل رو انتخاب کنیم و شروع به آموزش بدیم! در این پارت، با هم می‌بینیم که چطور می‌تونیم از Scikit-Learn برای پیاده‌سازی یک مدل مولتی کلاس کلاسیفیکیشن استفاده کنیم. 🚀

🧠 انتخاب مدل:
یکی از محبوب‌ترین مدل‌ها برای Multi-Class Classification، مدل‌های دسته‌بندی‌کننده مانند Logistic Regression، K-Nearest Neighbors (KNN)، Random Forest و Support Vector Machine (SVM) هستند. در این پارت، از Random Forest استفاده می‌کنیم چون هم دقت بالایی داره و هم می‌تونه به خوبی در برابر overfitting مقاومت کنه. 🌲

🛠️ آموزش مدل:
برای آموزش مدل، ابتدا باید مدل رو تعریف کنیم، سپس از داده‌های آموزشی برای آموزش آن استفاده کنیم.

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# ایجاد مدل Random Forest
model = RandomForestClassifier(n_estimators=100, random_state=42)

# آموزش مدل
model.fit(X_train, y_train)

# پیش‌بینی بر روی داده‌های آزمایشی
y_pred = model.predict(X_test)

# ارزیابی دقت مدل
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy * 100:.2f}%')

🧑‍🏫 توضیح کد:
1. ابتدا مدل RandomForestClassifier رو از Scikit-Learn ایمپورت می‌کنیم.
2. سپس مدل رو با داده‌های آموزشی X_train و y_train آموزش می‌دیم.
3. بعد از آموزش مدل، می‌خواهیم پیش‌بینی‌هایی برای داده‌های آزمایشی انجام بدیم و دقت مدل رو با استفاده از accuracy_score محاسبه کنیم.

📊 ارزیابی مدل:
حالا که مدل رو آموزش دادیم، باید عملکردش رو بررسی کنیم. علاوه بر دقت، می‌تونیم از Confusion Matrix برای بررسی اینکه مدل چطور پیش‌بینی کرده و چه مقدار اشتباه کرده استفاده کنیم.

from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

# محاسبه Confusion Matrix
cm = confusion_matrix(y_test, y_pred)

# نمایش آن به صورت تصویری
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=encoder.classes_, yticklabels=encoder.classes_)
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.show()

🧹 نکات مهم:
- در Random Forest، با استفاده از تعداد زیادی درخت تصمیم‌گیری، مدل می‌تونه از چندین مسیر مختلف به پیش‌بینی برسه و خطاها رو کاهش بده.
- Confusion Matrix به شما کمک می‌کنه تا ببینید مدل چطور در پیش‌بینی هر کدام از کلاس‌ها عمل کرده.
- Cross-validation رو فراموش نکنید! این روش به شما کمک می‌کنه تا از overfitting جلوگیری کنید و مدل رو روی داده‌های مختلف تست کنید.

💡 نکات:
- برای مدل‌های مختلف، می‌تونید از GridSearchCV برای پیدا کردن بهترین ترکیب از هایپرپارامترها استفاده کنید.
- استفاده از Random Forest، SVM یا KNN به تناسب پیچیدگی داده‌ها و حجم داده‌ها می‌تونه به شما کمک کنه تا مدل بهتری بسازید.

حالا که مدل رو آموزش دادیم، می‌تونیم در پارت بعدی به نحوه استفاده از آن برای پیش‌بینی‌های جدید و انجام تست‌های نهایی بپردازیم! 🔮

[آموزش های بیشتر اینجا]

#پایتون #یادگیری_ماشین #RandomForest #کلاسیفیکیشن #ScikitLearn #مدل_آموزش

پارت ۴: پیش‌بینی با مدل و ارزیابی نهایی 🏁

در این پارت، با هم به نحوه استفاده از مدل آموزش‌داده‌شده برای پیش‌بینی داده‌های جدید و انجام ارزیابی نهایی می‌پردازیم. همچنین به بررسی عملکرد مدل خواهیم پرداخت و نکات مهم در ارزیابی مدل را یاد می‌گیریم. 🎯

🧠 پیش‌بینی با مدل:
حالا که مدل رو آموزش دادیم، می‌خواهیم از اون برای پیش‌بینی داده‌های جدید استفاده کنیم. پیش‌بینی‌ها ممکنه شامل دسته‌بندی‌هایی از داده‌هایی باشند که قبلاً دیده نشده‌اند. در واقع، این مرحله به شما این امکان رو می‌ده که از مدل برای تصمیم‌گیری در دنیای واقعی استفاده کنید! 🌍

برای پیش‌بینی، تنها کافی‌ست که داده‌های جدید رو به مدل بدید و نتیجه رو دریافت کنید.

# پیش‌بینی با داده‌های جدید
new_data = [[2.3, 3.1, 0.8, 1.5]]  # ویژگی‌های جدید
prediction = model.predict(new_data)

# نمایش پیش‌بینی
predicted_class = encoder.inverse_transform(prediction)
print(f'Predicted Class: {predicted_class[0]}')

🧑‍🏫 توضیح کد:
1. داده‌های جدید که می‌خواهیم پیش‌بینی کنیم رو به صورت یک لیست وارد می‌کنیم.
2. با استفاده از مدل آموزش‌داده‌شده، پیش‌بینی رو انجام می‌دهیم.
3. چون خروجی مدل ممکنه به صورت عددی باشه (برچسب‌ها به عدد تبدیل شدن)، از inverse_transform برای تبدیل این عددها به کلاس‌های اصلی استفاده می‌کنیم.

📊 ارزیابی نهایی:
برای ارزیابی نهایی عملکرد مدل، معمولاً از معیارهای مختلفی استفاده می‌کنیم. یکی از این معیارها F1-Score هست که ترکیبی از دقت و بازیابی (Precision and Recall) رو نمایش می‌ده و مخصوصاً در مشکلات با داده‌های نامتوازن مفید هست.

from sklearn.metrics import classification_report

# ارزیابی عملکرد مدل
print(classification_report(y_test, y_pred, target_names=encoder.classes_))

📊 گزارش ارزیابی:
- Precision: درصد پیش‌بینی‌های درست از کل پیش‌بینی‌های انجام‌شده برای هر کلاس.
- Recall: درصد پیش‌بینی‌های درست از کل داده‌هایی که مربوط به یک کلاس خاص بوده‌اند.
- F1-Score: میانگین هماهنگ دقت و بازیابی که معیار جامع‌تری برای ارزیابی مدل هست.

🔄 Cross-validation:
برای اطمینان از اینکه مدل به طور عمومی کار می‌کنه و در برابر داده‌های مختلف مقاوم هست، می‌تونیم از Cross-validation استفاده کنیم. این روش داده‌ها رو به بخش‌های مختلف تقسیم می‌کنه و مدل رو چندین بار آموزش می‌ده تا از overfitting جلوگیری کنه.

from sklearn.model_selection import cross_val_score

# ارزیابی مدل با Cross-validation
cv_scores = cross_val_score(model, X, y, cv=5)  # تقسیم به 5 بخش
print(f'Cross-validation scores: {cv_scores}')
print(f'Mean CV score: {cv_scores.mean()}')

💡 نکات:
- Model Tuning: همیشه می‌تونید با تنظیم هایپرپارامترها مثل تعداد درخت‌ها یا عمق درخت‌ها، عملکرد مدل رو بهبود بدید.
- Ensemble Methods: ترکیب چند مدل می‌تونه باعث افزایش دقت و مقاوم‌تر شدن مدل بشه.
- تست مدل بر روی داده‌های جدید: اطمینان حاصل کنید که مدل شما می‌تونه پیش‌بینی‌های دقیقی برای داده‌های جدید و دیده‌نشده انجام بده.

🎉 نتیجه‌گیری:
حالا شما آماده‌اید که مدل‌های Multi-Class Classification رو در پروژه‌های مختلف خودتون پیاده‌سازی کنید! این الگوریتم یکی از کاربردی‌ترین روش‌ها برای دسته‌بندی داده‌ها به چندین کلاس مختلف هست و می‌تونه در انواع مشکلات یادگیری ماشین به شما کمک کنه. 🎓

[آموزش های بیشتر اینجا]

#پایتون #یادگیری_ماشین #پیش‌بینی #کلاسیفیکیشن #F1Score #ارزیابی #CrossValidation

پروژه سطح متوسط: پیش‌بینی نوع گل با استفاده از آغازگر Iris Dataset 🌸

در این پروژه، از الگوریتم مولتی کلاس کلاسیفیکیشن برای پیش‌بینی نوع گل‌ها با استفاده از مجموعه داده‌های معروف Iris Dataset استفاده می‌کنیم. این پروژه به شما کمک می‌کند تا مفهوم استفاده از الگوریتم‌ها برای حل مشکلات دنیای واقعی رو بیشتر درک کنید. 🧠

مراحل پروژه:

1. وارد کردن و آماده‌سازی داده‌ها
2. آموزش مدل
3. پیش‌بینی و ارزیابی مدل

۱. وارد کردن و آماده‌سازی داده‌ها:
در ابتدا، از مجموعه داده Iris که شامل اطلاعاتی مانند طول و عرض گلبرگ‌ها و ساقه است، برای پیش‌بینی نوع گل استفاده می‌کنیم.

# وارد کردن کتابخانه‌های لازم
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, accuracy_score

# بارگذاری داده‌های Iris
data = load_iris()

# تبدیل داده‌ها به DataFrame برای راحتی بیشتر
df = pd.DataFrame(data.data, columns=data.feature_names)
df['target'] = data.target

# نمایش چند ردیف اول داده‌ها
print(df.head())

توضیح:
- ما از کتابخانه sklearn.datasets برای بارگذاری مجموعه داده Iris استفاده کردیم.
- ویژگی‌های گل (طول و عرض گلبرگ و ساقه) در data.data و برچسب‌ها (نوع گل) در data.target قرار دارند.

۲. آموزش مدل:
حالا که داده‌ها رو آماده کردیم، مدل Random Forest رو برای آموزش انتخاب می‌کنیم.

# تقسیم داده‌ها به ویژگی‌ها و برچسب‌ها
X = df.drop('target', axis=1)
y = df['target']

# تقسیم داده‌ها به مجموعه‌های آموزشی و آزمایشی
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# ایجاد مدل Random Forest
model = RandomForestClassifier(n_estimators=100, random_state=42)

# آموزش مدل
model.fit(X_train, y_train)

توضیح:
- train_test_split داده‌ها رو به دو بخش آموزشی و آزمایشی تقسیم می‌کنه. 70% داده‌ها برای آموزش و 30% برای ارزیابی مدل استفاده می‌شود.
- مدل Random Forest رو با 100 درخت برای آموزش انتخاب می‌کنیم.

۳. پیش‌بینی و ارزیابی مدل:
بعد از آموزش مدل، از داده‌های آزمایشی برای پیش‌بینی استفاده می‌کنیم و سپس دقت مدل رو بررسی می‌کنیم.

# پیش‌بینی با داده‌های آزمایشی
y_pred = model.predict(X_test)

# نمایش دقت مدل
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy * 100:.2f}%')

# نمایش گزارش کامل ارزیابی
print(classification_report(y_test, y_pred))

توضیح:
- با استفاده از predict پیش‌بینی‌ها رو روی داده‌های آزمایشی انجام می‌دیم.
- از accuracy_score برای محاسبه دقت مدل استفاده می‌کنیم.
- گزارش کامل ارزیابی با استفاده از classification_report شامل دقت، بازیابی و F1-Score برای هر کلاس نمایش داده می‌شود.

۴. نتیجه‌گیری:
در این پروژه، مدل Random Forest رو برای دسته‌بندی انواع گل‌های موجود در مجموعه داده Iris آموزش دادیم. پس از آموزش، پیش‌بینی‌هایی برای داده‌های آزمایشی انجام دادیم و دقت مدل رو بررسی کردیم.

خروجی‌های ممکن:
- دقت مدل ممکنه حدود 97-99% باشه، که نشان‌دهنده دقت بالای مدل برای این مجموعه داده خاص است.
- گزارش ارزیابی مدل شامل معیارهایی مثل Precision، Recall و F1-Score برای هر کلاس (در اینجا، هر نوع گل) ارائه می‌شود.

نکات پیشرفته:
- شما می‌توانید از GridSearchCV برای تنظیم هایپرپارامترهای مدل استفاده کنید.
- در پروژه‌های بزرگ‌تر، باید از Cross-validation استفاده کنید تا مدل رو روی داده‌های مختلف تست کنید.

نتیجه نهایی:
این پروژه به شما کمک می‌کنه تا الگوریتم مولتی کلاس کلاسیفیکیشن رو در عمل تجربه کنید و ببینید چطور می‌تونید مدل‌هایی بسازید که بتونند داده‌های پیچیده رو به دسته‌های مختلف تقسیم کنند. 🌱


#پایتون #یادگیری_ماشین #کلاسیفیکیشن #RandomForest #IrisDataset #پیش‌بینی #ScikitLearn

🚀 منتظر چی هستی، کدنویس؟! گوگل سنتر با 59 دستیار هوشمند، یه انقلاب تو دنیای برنامه‌نویسی به پا کرده! 💻


خسته شدی از ساعت‌ها کلنجار رفتن با یه باگ کوچیک؟ 🤯 دیگه لازم نیست! دستیار برنامه نویسی Python، PHP، Visual Basic، C/C++ و ASP.NET اینجاست تا مثل یه دوست حرفه‌ای، تو پروژه‌هات کمکت کنه. از دیباگ کردن کدها بگیر تا نوشتن الگوریتم‌های پیچیده، همه رو به هوش مصنوعی بسپار و خودت روی خلاقیت تمرکز کن. 💡


فکر می‌کنی هوش مصنوعی فقط یه ابزار ساده‌ست؟ دستیار ارسلان فول استک، دستیار لینوکس، دستیار اندرویدیار و دستیار بازی‌سازی بهت ثابت می‌کنن که اشتباه می‌کنی! با این دستیارها می‌تونی اپلیکیشن‌های موبایل بسازی، بازی‌های جذاب طراحی کنی، و حتی سیستم‌عامل لینوکس رو بهینه کنی. دیگه چی می‌خوای؟! 🤩

اطلاعات بیشتر

gglct.com

@gglct2024

@gglct_ad

09109977710

09044139986

📌 پارت ۱: مقدمه و مفاهیم پایه‌ای درخت تصمیم و جنگل تصادفی

🔍 مقدمه:
در این بخش، قراره مفهوم Random Forest رو کاملاً درک کنیم و بفهمیم چرا این الگوریتم یکی از قوی‌ترین روش‌های دسته‌بندی (Classification) و پیش‌بینی (Regression) در یادگیری ماشین محسوب می‌شه. همچنین، نگاهی به درخت تصمیم (Decision Tree) که پایه و اساس Random Forest هست، خواهیم داشت.


🌲 Random Forest چیه؟
جنگل تصادفی (Random Forest) یه مدل یادگیری ماشین مبتنی بر مجموعه‌ای از درخت‌های تصمیم هست. این الگوریتم از چندین درخت تصمیم مستقل استفاده می‌کنه و برای پیش‌بینی رأی‌گیری اکثریت (Majority Voting) رو انجام می‌ده. ویژگی‌های کلیدی این مدل:

✅ از چندین درخت تصمیم برای افزایش دقت استفاده می‌کنه.
✅ مدل رو در برابر Overfitting مقاوم می‌کنه.
✅ هم در کلاسیفیکیشن (طبقه‌بندی) و هم در رگرسیون (پیش‌بینی عددی) قابل استفاده است.



🌳 درخت تصمیم (Decision Tree) چیه؟
قبل از اینکه Random Forest رو بسازیم، باید بدونیم درخت تصمیم چیه. درخت تصمیم یه مدل ساده و شهودی برای دسته‌بندی و پیش‌بینی هست که شبیه به یه نمودار درختی کار می‌کنه.

🔹 هر گره (Node) یه ویژگی داده رو بررسی می‌کنه.
🔹 هر شاخه (Branch) یه مسیر تصمیم‌گیری رو نشون می‌ده.
🔹 هر برگ (Leaf) یه خروجی نهایی برای پیش‌بینی رو مشخص می‌کنه.

✅ درخت‌های تصمیم سریع هستن، اما به تنهایی ممکنه دقت کمی داشته باشن و دچار Overfitting بشن. اینجاست که جنگل تصادفی وارد عمل می‌شه!



🚀 چرا Random Forest بهتر از یک درخت تصمیم است؟
حالا که مفهوم درخت تصمیم رو فهمیدیم، بذار ببینیم چرا Random Forest کارآمدتره:

🔹 کاهش Overfitting: درخت‌های تصمیم به‌تنهایی ممکنه بیش از حد روی داده‌های آموزش تنظیم بشن، اما ترکیب چندین درخت باعث می‌شه خطاهای تصادفی کاهش پیدا کنه.
🔹 دقت بالاتر: چون از چندین مدل استفاده می‌کنه، معمولاً دقت بیشتری نسبت به یه درخت تصمیم داره.
🔹 مقاوم در برابر داده‌های نویزی: چون مجموعه‌ای از درخت‌ها تصمیم‌گیری می‌کنن، مدل تأثیر داده‌های غیرعادی رو کاهش می‌ده.



💡 جمع‌بندی پارت ۱:
📌 توی این پارت یاد گرفتیم که:
✔️ Random Forest یه مجموعه از درخت‌های تصمیمه که با ترکیب چند مدل، دقت پیش‌بینی رو افزایش می‌ده.
✔️ درخت تصمیم یه مدل پایه برای دسته‌بندی داده‌هاست اما ممکنه دچار Overfitting بشه.
✔️ جنگل تصادفی با رأی‌گیری بین درخت‌ها، خطای مدل رو کاهش می‌ده.

[لینک کانال ما]

⏭ پارت ۲: پیاده‌سازی گره‌های درخت تصمیم و تابع تقسیم داده‌ها

🌟 پارت ۲: پیاده‌سازی گره‌های درخت تصمیم و تابع تقسیم داده‌ها

📌 مقدمه:
در این بخش، می‌خوایم اولین قدم در پیاده‌سازی دستی Random Forest رو برداریم: ساخت گره‌های درخت تصمیم و پیاده‌سازی تابع تقسیم داده‌ها (Splitting Function). این کار پایه‌ی تمام محاسباتیه که درخت‌های تصمیم و در نهایت جنگل تصادفی بر اساس اون ساخته می‌شن.



🔍 ۱. گره (Node) در درخت تصمیم چیه؟
درخت تصمیم از گره‌ها تشکیل شده که در هر گره، یک ویژگی انتخاب می‌شه و داده‌ها به دو بخش تقسیم می‌شن.

🔹 گره ریشه (Root Node): اولین گره که داده‌های اصلی از اونجا شروع به تقسیم شدن می‌کنن.
🔹 گره داخلی (Internal Node): گره‌هایی که داده‌ها رو به زیرمجموعه‌های کوچک‌تر تقسیم می‌کنن.
🔹 گره برگ (Leaf Node): گره‌های انتهایی که کلاس نهایی یا مقدار خروجی رو مشخص می‌کنن.

👀 هدف ما اینه که بتونیم بهترین ویژگی برای تقسیم داده‌ها رو پیدا کنیم و درخت رو رشد بدیم.



⚡ ۲. تابع تقسیم داده‌ها چطور کار می‌کنه؟
برای اینکه درخت تصمیم بتونه به‌درستی کار کنه، باید بهترین ویژگی رو برای تقسیم داده‌ها انتخاب کنیم. این کار رو با استفاده از معیارهایی مثل Gini Impurity یا Entropy (برای اطلاعات متقابل) انجام می‌دیم.

💡 معیار Gini Impurity:
یک معیار برای سنجش میزان خلوص یک دسته از داده‌ها. مقدار اون بین ۰ تا ۱ هست:
- ۰: کاملاً خالص (یعنی همه داده‌ها متعلق به یک کلاس هستن).
- ۱: بیشترین اختلاط بین کلاس‌ها (یعنی کلاس‌های مختلف زیادی توی این گره هست).

🔢 فرمول Gini Impurity:


فرومول رو توی یه عکس پایین همین پست گزاشتم


🚀 ۳. پیاده‌سازی تابع محاسبه‌ی Gini Impurity در پایتون
حالا بریم تابع Gini Impurity رو پیاده‌سازی کنیم تا بتونیم میزان خلوص داده‌های هر گره رو محاسبه کنیم:

import numpy as np

# تابع محاسبه Gini Impurity
def gini_impurity(labels):
    """
    محاسبه میزان ناخالصی Gini برای یک دسته از داده‌ها
    """
    unique_classes, counts = np.unique(labels, return_counts=True)
    probabilities = counts / len(labels)
    gini = 1 - np.sum(probabilities ** 2)
    return gini

# تست تابع با یک لیست از کلاس‌ها
labels = [0, 0, 1, 1, 1, 0, 1, 1, 0, 0]
print("Gini Impurity:", gini_impurity(labels))

✅ این تابع، میزان Gini رو برای یک مجموعه از برچسب‌های کلاس محاسبه می‌کنه. هر چقدر مقدار Gini کمتر باشه، داده‌ها در اون گره خالص‌تر هستن.



📌 ۴. تابع تقسیم داده‌ها بر اساس یک ویژگی
بعد از محاسبه Gini، حالا باید یک تابع برای تقسیم داده‌ها بنویسیم که با بررسی هر ویژگی، داده‌ها رو به دو گروه جدا تقسیم کنه.

def split_data(data, feature_index, threshold):
    """
    تقسیم داده‌ها به دو گروه بر اساس مقدار یک ویژگی
    """
    left_split = data[data[:, feature_index] <= threshold]
    right_split = data[data[:, feature_index] > threshold]
    return left_split, right_split

🔹 این تابع، یک ویژگی (Feature) رو دریافت می‌کنه و داده‌ها رو به دو دسته تقسیم می‌کنه:
- داده‌هایی که مقدارشون کمتر یا مساوی آستانه‌ی موردنظر (Threshold) هست.
- داده‌هایی که مقدارشون بیشتر از Threshold هست.

📌 در مرحله بعد، باید بهترین تقسیم‌بندی رو پیدا کنیم. برای این کار، باید مقدار Gini Impurity رو بعد از هر تقسیم حساب کنیم و بهترین حالت رو انتخاب کنیم.



📢 جمع‌بندی پارت ۲:
✔️ فهمیدیم که گره‌های درخت تصمیم چطور داده‌ها رو به دو دسته تقسیم می‌کنن.
✔️ Gini Impurity رو محاسبه کردیم تا میزان خلوص هر گره رو بسنجیم.
✔️ تابعی برای تقسیم داده‌ها بر اساس مقدار یک ویژگی نوشتیم.

[لینک کانال ما]

⏭ پارت ۳: ساخت کامل یک درخت تصمیم و پیاده‌سازی پیش‌بینی

🔴فرمولش

🌟 پارت ۳: ساخت کامل یک درخت تصمیم و پیاده‌سازی پیش‌بینی

📌 مقدمه:
حالا که تونستیم Gini Impurity رو محاسبه کنیم و داده‌ها رو تقسیم کنیم، وقتشه که یه درخت تصمیم کامل بسازیم! در این پارت، قراره درخت تصمیم رو از ابتدا پیاده‌سازی کنیم و در نهایت یه تابع برای پیش‌بینی خروجی بنویسیم.



📌 ۱. چطور درخت تصمیم ساخته می‌شه؟
درخت تصمیم از تعدادی گره (Node) تشکیل شده. هر گره:
1️⃣ بهترین ویژگی (Feature) برای تقسیم داده‌ها رو انتخاب می‌کنه.
2️⃣ داده‌ها رو به دو گروه تقسیم می‌کنه (بر اساس مقدار آستانه).
3️⃣ اگر داده‌های یک گره کاملاً از یک کلاس بودن، اون گره رو به گره برگ (Leaf Node) تبدیل می‌کنه.
4️⃣ اگر داده‌ها همچنان نیاز به تقسیم شدن داشتن، همین فرآیند رو برای هر دو زیرمجموعه تکرار می‌کنه.

💡 این فرآیند به‌صورت بازگشتی (Recursive) اجرا می‌شه تا زمانی که شرایط توقف برقرار بشه.



📌 ۲. پیاده‌سازی انتخاب بهترین تقسیم‌بندی
برای ساخت درخت تصمیم، باید بفهمیم کدوم ویژگی و کدوم مقدار تقسیم، بهترین نتیجه رو می‌ده.
ما قبلاً تابع split_data() رو نوشتیم که داده‌ها رو بر اساس یک مقدار تقسیم می‌کنه. حالا باید تابعی بنویسیم که بهترین تقسیم ممکن رو انتخاب کنه!

def best_split(data, labels):
    """
    پیدا کردن بهترین ویژگی و مقدار آستانه برای تقسیم داده‌ها
    """
    best_gini = 1  # مقدار بالای اولیه برای مقایسه
    best_feature = None
    best_threshold = None
    best_splits = None
    
    num_features = data.shape[1]  # تعداد ویژگی‌ها
    
    for feature in range(num_features):  # بررسی همه ویژگی‌ها
        thresholds = np.unique(data[:, feature])  # مقدارهای منحصربه‌فرد در ویژگی
    
        for threshold in thresholds:  # بررسی همه مقادیر ویژگی
            left_mask = data[:, feature] <= threshold
            right_mask = ~left_mask
            
            left_labels, right_labels = labels[left_mask], labels[right_mask]
            
            if len(left_labels) == 0 or len(right_labels) == 0:
                continue  # تقسیم بی‌معنی رو رد کن
            
            # محاسبه Gini برای این تقسیم
            left_gini = gini_impurity(left_labels)
            right_gini = gini_impurity(right_labels)
            
            # میانگین وزنی Gini برای این تقسیم
            weighted_gini = (len(left_labels) * left_gini + len(right_labels) * right_gini) / len(labels)
            
            # به‌روزرسانی بهترین تقسیم در صورت یافتن مقدار Gini بهتر
            if weighted_gini < best_gini:
                best_gini = weighted_gini
                best_feature = feature
                best_threshold = threshold
                best_splits = (left_mask, right_mask)
    
    return best_feature, best_threshold, best_splits

✅ این تابع ویژگی‌ها رو بررسی می‌کنه و بهترین تقسیم رو بر اساس کمترین مقدار Gini Impurity انتخاب می‌کنه.



📌 ۳. پیاده‌سازی درخت تصمیم (به‌صورت بازگشتی)
حالا باید یه کلاس برای درخت تصمیم بسازیم که گره‌های درخت رو ایجاد کنه و داده‌ها رو تا جایی که ممکنه تقسیم کنه.

class DecisionTree:
    def init(self, max_depth=None, min_samples_split=2):
        self.max_depth = max_depth
        self.min_samples_split = min_samples_split
        self.tree = None

    def build_tree(self, data, labels, depth=0):
        """
        ساخت درخت تصمیم به‌صورت بازگشتی
        """
        num_samples, num_features = data.shape
        
        # شرط توقف: اگر به حداکثر عمق برسیم یا تعداد داده‌ها کم باشد
        if depth == self.max_depth or num_samples < self.min_samples_split or len(set(labels)) == 1:
            leaf_value = self.most_common_label(labels)
            return {"leaf": leaf_value}
        
        # پیدا کردن بهترین تقسیم
        best_feature, best_threshold, best_splits = best_split(data, labels)
        if best_feature is None:
            return {"leaf": self.most_common_label(labels)}

👇

left_mask, right_mask = best_splits
        left_subtree = self.build_tree(data[left_mask], labels[left_mask], depth + 1)
        right_subtree = self.build_tree(data[right_mask], labels[right_mask], depth + 1)
        
        return {
            "feature": best_feature,
            "threshold": best_threshold,
            "left": left_subtree,
            "right": right_subtree,
        }

    def most_common_label(self, labels):
        """
        پیدا کردن رایج‌ترین کلاس در گره برگ
        """
        unique_classes, counts = np.unique(labels, return_counts=True)
        return unique_classes[np.argmax(counts)]

    def fit(self, data, labels):
        """
        یادگیری مدل با داده‌های آموزشی
        """
        self.tree = self.build_tree(data, labels)

    def predict_single(self, x, node):
        """
        پیش‌بینی کلاس برای یک نمونه داده
        """
        if "leaf" in node:
            return node["leaf"]
        
        if x[node["feature"]] <= node["threshold"]:
            return self.predict_single(x, node["left"])
        else:
            return self.predict_single(x, node["right"])
    
    def predict(self, X):
        """
        پیش‌بینی کلاس برای چند نمونه داده
        """
        return np.array([self.predict_single(x, self.tree) for x in X])

📌 ۴. تست درخت تصمیم با یک دیتاست ساده
حالا وقتشه درخت تصمیم خودمون رو روی یه مجموعه داده تست کنیم!

# ساخت یک دیتاست نمونه
X_train = np.array([
    [2.7, 2.5],
    [1.3, 1.2],
    [3.6, 3.9],
    [1.1, 1.0],
    [3.0, 3.2]
])

y_train = np.array([0, 0, 1, 0, 1])

# ایجاد مدل و آموزش درخت تصمیم
tree = DecisionTree(max_depth=3)
tree.fit(X_train, y_train)

# تست پیش‌بینی
X_test = np.array([[3.5, 3.4], [1.5, 1.3]])
predictions = tree.predict(X_test)
print("پیش‌بینی‌ها:", predictions)

`این کد یه درخت تصمیم رو روی داده‌های ساده آموزش می‌ده و خروجی کلاس‌ها رو برای داده‌های جدید پیش‌بینی می‌کنه.
📢 جمع‌بندی پارت ۳:
✔️ تابعی نوشتیمبهترین ویژگی و مقدار آستانه رو برای تقسیم داده‌ها انتخاب می‌کنه.
✔️ درخت تصمیم رو به‌صبازگشتی پیاده‌سازی کردیم.
✔️ پیش‌بینینوشتیم که بر اساس درخت، خروجی هر نمونه داده رو مشخص می‌کنه.
✔️ در نهایت، درخت تصمیم خودمون رو داده‌های تست اجرا کردیم!

[لینک کانال ما]

پارت ۴:ترکیب چندین درخت برای ایجاد Random Forest و پیاده‌سازی مکانیزم رأی‌گیری

⏭ آموزش بعدی: پیاده‌سازی الگوریتم‌های دسته‌بندی دیگه از جمله SVM و KNN!
💡 نظرت چیه که الگوریتم بعدی رو تو انتخاب کنی؟ 🤔

🔥 پروژه کامل: تشخیص بیماری قلبی با جنگل تصادفی (Random Forest) 🔥

💡 هدف پروژه:
توی این پروژه، قراره یه مدل جنگل تصادفی (Random Forest) رو از صفر پیاده‌سازی کنیم و ازش برای پیش‌بینی بیماری قلبی استفاده کنیم.
ما از یه دیتاست واقعی Heart Disease Dataset استفاده می‌کنیم که شامل اطلاعات بیماران هست و باید تشخیص بدیم که فرد در خطر بیماری قلبی قرار داره یا نه! 🏥❤️



📌 ۱. نصب کتابخانه‌های موردنیاز

📌 اول از همه باید کتابخانه‌های لازم رو نصب کنیم:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
from sklearn.ensemble import RandomForestClassifier

📌 ۲. دریافت دیتاست و بررسی اولیه

🔍 دیتاست ما شامل اطلاعات مختلفی مثل سن، جنسیت، فشار خون، کلسترول و ... هست.
برای شروع، دیتاست رو می‌گیریم و یه نگاهی بهش می‌ندازیم:

# دانلود دیتاست (اگر از Kaggle یا Google Colab استفاده می‌کنید)
url = "https://raw.githubusercontent.com/ahmedbesbes/heart-disease-prediction/master/dataset.csv"
df = pd.read_csv(url)

# نمایش ۵ ردیف اول دیتاست
print(df.head())

# بررسی اطلاعات کلی دیتاست
print(df.info())

# بررسی میزان داده‌های خالی
print(df.isnull().sum())

📌 نکته: اگر دیتای خالی داشتیم، باید قبل از مدل‌سازی اون‌ها رو مدیریت کنیم.



📌 ۳. پردازش داده‌ها (Data Preprocessing)

✔️ تبدیل داده‌های متنی به عددی: بعضی ستون‌ها ممکنه مقدار متنی داشته باشن که باید اون‌ها رو عددی کنیم.
✔️ نرمال‌سازی داده‌ها: داده‌ها باید روی یه مقیاس استاندارد باشن تا مدل بهتر یاد بگیره.
✔️ تقسیم داده‌ها: دیتاست رو به دو بخش Train و Test تقسیم می‌کنیم.

# تبدیل مقادیر متنی به عددی (در صورت وجود)
df = pd.get_dummies(df, drop_first=True)

# جدا کردن ویژگی‌ها و برچسب‌ها
X = df.drop(columns=['target'])  # ویژگی‌ها (Attributes)
y = df['target']  # برچسب (Class Label)

# تقسیم دیتاست به ۸۰٪ آموزش و ۲۰٪ تست
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# نمایش تعداد نمونه‌ها
print("تعداد نمونه‌های آموزش:", X_train.shape[0])
print("تعداد نمونه‌های تست:", X_test.shape[0])

📌 ۴. ساخت و آموزش مدل Random Forest

حالا مدل جنگل تصادفی رو می‌سازیم و آموزش می‌دیم! 🚀🌳

# ساخت مدل جنگل تصادفی
model = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=42)

# آموزش مدل
model.fit(X_train, y_train)

# پیش‌بینی روی داده‌های تست
y_pred = model.predict(X_test)

# محاسبه دقت مدل
accuracy = accuracy_score(y_test, y_pred)
print(f"🎯 دقت مدل: {accuracy * 100:.2f}%")

📌 ۵. تحلیل نتایج و ارزیابی مدل

حالا بریم ببینیم مدل ما چقدر دقیق و قابل اعتماد هست:

# نمایش گزارش کامل دسته‌بندی
print(classification_report(y_test, y_pred))

# رسم ماتریس سردرگمی
plt.figure(figsize=(6, 5))
sns.heatmap(pd.crosstab(y_test, y_pred), annot=True, fmt='d', cmap="Blues")
plt.xlabel("پیش‌بینی شده")
plt.ylabel("واقعی")
plt.title("📊 ماتریس سردرگمی")
plt.show()

✅ اگر مدل دقت بالایی داشته باشه، یعنی خوب کار می‌کنه و می‌تونیم ازش برای تشخیص بیماری استفاده کنیم! 🚀



📌 ۶. تست مدل با ورودی جدید

حالا یه نمونه داده جدید می‌سازیم و تست می‌کنیم که مدل بیماری قلبی رو درست پیش‌بینی می‌کنه یا نه:

# یک نمونه بیمار جدید (به جای اعداد، مقادیر مناسب دیتاست رو قرار بدید)
new_patient = np.array([[63, 1, 3, 145, 233, 1, 0, 150, 0, 2.3, 0, 0, 1]])

# پیش‌بینی
prediction = model.predict(new_patient)
print("نتیجه مدل برای بیمار جدید:", "⚠️ بیماری قلبی دارد" if prediction[0] == 1 else "✅ سالم است")

📌 ۷. جمع‌بندی پروژه

✔️ یاد گرفتیم که چطور با داده‌های واقعی پزشکی کار کنیم.
✔️ با استفاده از جنگل تصادفی (Random Forest) یه مدل قوی برای تشخیص بیماری قلبی ساختیم.
✔️ مدل رو ارزیابی کردیم و دقتش رو بررسی کردیم.
✔️ در نهایت، یه نمونه داده جدید رو تست کردیم تا ببینیم مدل چطور کار می‌کنه.

🎯 این یه نمونه کاربردی و واقعی از الگوریتم‌های یادگیری ماشین بود! 🚀

💡 چالش برای شما:
🔹 می‌تونید تعداد درخت‌ها (n_estimators) رو تغییر بدید و ببینید چقدر روی دقت مدل تاثیر داره؟
🔹 مدل رو با الگوریتم‌های دیگه مثل SVM یا KNN مقایسه کنید!
🔹 تست کنید ببینید کدوم ویژگی‌ها (Feature Importance) مهم‌ترین تاثیر رو روی نتیجه دارند!

لینک کانال ما

🔥 اسکریپت کامل پیاده‌سازی Random Forest با دیتابیس داخلی 🔥
💡 این اسکریپت یک دیتاست پیش‌فرض (ساختگی) را درون خود دارد و از آن برای آموزش و تست مدل جنگل تصادفی استفاده می‌کند.

📌 ویژگی‌های اسکریپت:
✅ دیتاست به‌صورت داخلی در کد تعریف شده است.
✅ از کتابخانه sklearn برای پیاده‌سازی Random Forest استفاده شده است.
✅ داده‌ها به Train/Test تقسیم شده و مدل آموزش داده می‌شود.
✅ دقت مدل محاسبه شده و یک نمونه داده جدید تست می‌شود.



📌 اسکریپت کامل:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

# 🚀 ۱. ایجاد دیتاست داخلی (ساختگی)
data = {
    "سن": [25, 34, 45, 23, 42, 51, 60, 48, 37, 29, 41, 53, 39, 58, 30],
    "فشار_خون": [120, 130, 140, 110, 135, 145, 150, 138, 132, 125, 136, 148, 128, 152, 122],
    "کلسترول": [180, 190, 220, 160, 210, 230, 250, 240, 200, 185, 215, 245, 195, 260, 175],
    "قند_خون": [0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0],  # 0 = نرمال، 1 = بالا
    "بیماری_قلبی": [0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0]  # 0 = سالم، 1 = بیمار
}

# تبدیل دیتاست به DataFrame
df = pd.DataFrame(data)

# 🚀 ۲. آماده‌سازی داده‌ها
X = df.drop(columns=["بیماری_قلبی"])  # ویژگی‌ها (Feature)
y = df["بیماری_قلبی"]  # برچسب (Label)

# تقسیم داده‌ها به آموزش (80٪) و تست (20٪)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 🚀 ۳. ساخت مدل جنگل تصادفی و آموزش آن
model = RandomForestClassifier(n_estimators=10, max_depth=5, random_state=42)
model.fit(X_train, y_train)

# 🚀 ۴. ارزیابی مدل
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"🎯 دقت مدل: {accuracy * 100:.2f}%")
print("\n📊 گزارش دسته‌بندی:\n", classification_report(y_test, y_pred))

# 🚀 ۵. رسم ماتریس سردرگمی
plt.figure(figsize=(5, 4))
sns.heatmap(pd.crosstab(y_test, y_pred), annot=True, fmt='d', cmap="Blues")
plt.xlabel("پیش‌بینی شده")
plt.ylabel("واقعی")
plt.title("📊 ماتریس سردرگمی")
plt.show()

# 🚀 ۶. تست مدل با یک نمونه جدید
new_patient = np.array([[50, 140, 220, 1]])  # مثال: فردی با فشار خون بالا و کلسترول زیاد
prediction = model.predict(new_patient)
print("🔍 نتیجه برای بیمار جدید:", "⚠️ بیمار است" if prediction[0] == 1 else "✅ سالم است")

📌 توضیحات کد:
✔️ یک دیتاست ساختگی ایجاد شده که شامل اطلاعات بیماران مثل سن، فشار خون، کلسترول و قند خون است.
✔️ داده‌ها به دو بخش آموزشی و تست تقسیم شده‌اند.
✔️ مدل جنگل تصادفی (Random Forest) ساخته و آموزش داده شده است.
✔️ دقت مدل محاسبه شده و یک گزارش دسته‌بندی نمایش داده شده است.
✔️ ماتریس سردرگمی برای نمایش عملکرد مدل رسم شده است.
✔️ یک نمونه داده جدید تست شده و پیش‌بینی انجام شده است.

✅ این اسکریپت آماده اجراست و هیچ دیتابیس خارجی نیاز ندارد! 🚀🔥