🔸 در مواردی که ستون تارگت عددی باشد، مسئله بجای classification از نوع regression میباشد.

▫️ جایی که تارگت عددی پیوسته بود مسئله از نوع Regression، و جایی که تارگت عدد غیر پیوسته بود مسئله از نوع Classification میباشد.

🔹 برای مثال در الگوریتم KNNR، لیبل نمونه جدید میانگینی میشه از kتا همسایه نزدیک به خودش.

🔻 الگوریتم CatBoost مثل XGBoost و RF کار میکنه، منتها نیاز به هایپرپارامتر tuning نداره. همچنین برای ویژگی های Categorical کافیه که شماره ش رو بهش بدیم تا OHE رو انجام بده.
!pip install -U catboost

▫️ اگر اکثریت داده ها در یک نقطه جمع شده باشن، الگوریتم بایاس پیدا میکنه به حالتی که تجمیع داده صورت گرفته. بهتره که داده های ستون تارگت وقتی به الگوریتم Regression میخواد داده بشه از توزیع نرمالی پیروی کنه. اگه روی داده ها sqrt یا log اعمال کنیم توزیع نرمال میشه. بعد از اینکه الگوریتم یاد گرفت و پیش بینی کرد، باید معکوس تابع رو (به توان رسیدن) اعمال کنیم.

from catboost import CatBoostRegressor
from sklearn.model_selection import train_test_split

model = CatBoostRegressor(iterations=120, learning_rate=0.05, depth=6, eval_metric='MAE', verbose=10)

X = data_train.drop(['id', 'loss'], axis=1)
y = np.log(data_train['loss'])
X_train, X_test, y_train, y_test = train_test_split(X, y)

model.fit(X_train, y_train, np.asarray(cat_index) - 1, eval_set=(X_test, y_test))

✳️ دسته مسائل Classification و Regression در دسته بندی Supervised Learning قرار میگیرند. یعنی در این مسائل ما تارگت داریم. اگر ستون تارگت نداشته باشیم مسائل به زیر حوزه Unsupervised Learning مربوط میشن.

⭕️ در حوزه Unsupervised میتونیم از الگوریتم های Clustering یا خوشه بندی استفاده کنیم. این الگوریتم ها میتوانند داده ها رو به گروه های شبیه به هم تقسیم کنند.

❇️ الگوریتم های حوزه خوشه بندی:

- الگوریتم K-Means: این الگوریتم داده ها رو دریافت میکنه و نمونه هایی که بهم نزدیک باشند رو میندازه داخل یک گروه. فقط در ابتدای کار تعداد گروه های نهایی رو از ما میخواد. این الگوریتم در مثال یسری ضربدر رنگی روی جاهای مختلف میزنه و هر نمونه ای که به اون ضربدر نزدیک تر باشه رو جزو اون گروه میگیره. سپس اون ضربدرها رو میبره به مرکز نمونه های خودش. بعد دسته ها پاک میشه و مجددا هر کدوم از نمونه ها به ضربدرهای موردنظر نزدیک تر باشند توی یک دسته قرار میگیرند. و همین کار رو چندین مرتبه تکرار میکنه تا توی دور های آخر نمونه هایی که به ضربدرها نزدیک تر باشن همون رنگ ضربدر رو به خودشون بگیرن. الگوریتم وقتی بفهمه همگرا شده دیگه ادامه نمیده.

⁉️ الگوریتم K-Means دو مشکل اساسی داره. مشکل اول سرعت الگوریتم هست. سرعت هرچقدر مجموعه داده ها بیشتر بشه کند میشه. مشکل بعدی انتخاب تعداد k هست.

- الگوریتم DBSCAN: این الگوریتم خودش تعداد خوشه ها رو حساب میکنه. فقط دو پارامتر دارد، یکی اپسیلون و یک min points. میاد اول یکی از نمونه ها رو به صورت تصادفی انتخاب میکنه و به اندازه اپسیلون، یک شعاع روی اون میزنه و چک میکنه توی شعاع زده شده، حداقل به اندازه mp نمونه وجود داره یا نه. این کار رو انقدر برای همسایه ها ادامه میده تا تمام نمونه هایی که نزدیک به هم هستند توی یه خوشه بیفتن. این الگوریتم نمونه هایی که توی هیچ خوشه ای نیفتادن رو به عنوان outlier شناسایی میکنه.

🔸 یکی از نقاط ضعف الگوریتم DBSCAN اینه که نمیشه پارامترها رو راحت مشخص کرد.

💭 در بازاریابی متدی داریم به اسم RFM. کلمه R یعنی Recency (آخرین زمانی که مشتری خرید کرده)، کلمه F یعنی Frequency (تعداد دفعات خرید مشتری از ما) و کلمه M یعنی Monetary (مجموع مبلغی که مشتری از ما خرید کرده).

🔔 روش Q Cut: در این روش، مقادیر یک ستون رو از کوچک به بزرگ مرتب میکنه، و به q قسمت مساوی تقسیم میکنه (مثلا q=4). هر کدوم از داده ها توی قسمت اول افتاده باشن، بجای عددشون یک میزاره. اونهایی که توی قسمت دوم افتاده باشن بجای عددشون دو میزاره و... . به قولی داده ها رو scale میکنه در بازه یک تا چهار.

r_labels = range(4, 0, -1) #[4, 3, 2, 1]
r_groups = pd.qcut(rfm['Recency'], q=4, labels=r_labels)
f_labels = range(1, 5) # [1, 2, 3, 4]
f_groups = pd.qcut(rfm['Frequency'], q=4, labels=f_labels)
m_labels = range(1, 5)
m_groups = pd.qcut(rfm['Monetary'], q=4, labels=m_labels)

rfm['R'] = r_groups.values
rfm['F'] = f_groups.values
rfm['M'] = m_groups.values

🟡 دلیل اینکه ستون R رو بر عکس عدد دادیم (از 4 به 1) اینه که مشتری که تازه خرید کرده ارزش بیشتری برامون داره.

X = rfm[['R', 'F', 'M']]
kmeans = KMeans(n_clusters=5, init='k-means++', max_iter=300)
kmeans.fit(X)

rfm['kmeans_cluster'] = kmeans.labels_

🔹 وقتی که خوشه بندی کردیم، روی اونها مدل های Classification پیاده سازی میکنیم که داده ها رو صحت سنجی یا evaluate کنیم.

⁉️ از روش elbow استفاده میکنیم که بفهمیم خوشه بندی مون خوب هست یا نه، و آیا تعداد خوشه ها مناسبه یا خیر.

✳️ مفهوم inertia (wcss): فاصله هر نمونه رو با مرکز خوشه خودش بدست میاره، و همه اون مقادیر رو باهم جمع میکنه. فاصله بدست اومده رو به توان دو میرسونه. عدد inertia باید متناسب باشد.

🔹 الگوریتم HDBSCAN: مثل همون DBSCAN است منتها به صورت سلسله مراتبی خوشه بندی رو انجام میده. یکی از خوبی های این الگوریتم اینه که خیلی احتیاج نداریم مقدار اپسیلون یا mp رو تشخیص بدیم.

‼️ الگوریتم DBSCAN بعضی از نمونه ها که نتونن در هیچ خوشه ای جای بگیرن رو 1- میده، یعنی اونها داده های outlier هستند.

❎ معیار silhouette چیست؟ در این معیار تراکم درون هر خوشه اهمیت دارد (تراکم درونی خوشه ها). همچنین فاصله خوشه ها از همدیگر تا جای ممکن زیاد باشد. silhouette عددی بین 1- تا 1 برمیگردونه. اگر به 1- نزدیک باشه، یعنی خوشه هایی که ساختیم خوب نیستند و اگر عدد برگردونده شده نزدیک به 1 باشه یعنی خوشه ها خوب هستند. اگر عدد به 0 نزدیک باشد، یعنی خوشه ها مقداری به همدیگر نزدیک هستند. مقدار silhouette معمولا باید بالای 0.3 باشه که بگیم خوشه های خوبی ساختیم.


🔸 دسته الگوریتم های Outlier Detection:

- DBSCAN
- ABOD
- Isolation Forest
- OneClass SVM
- LOF

⭕️ یکی از مشکلات accuracy اینه که برای داده های غیر متوازن یا Imbalanced مناسب نیست.

🔸 پکیجی در پایتون موجود هست به اسم imblearn که وظیفه بالانس کردن داده ها رو بر عهده داره.
pip install imbalanced-learn

🔻 روش های مختلفی برای بالانس کردن داده ها وجود دارد. کاهش داده های کلاس اکثریت تا اینکه به اندازه داده های کلاس اقلیت برسه، یا افزایش داده های کلاس اقلیت تا به اندازه داده های کلاس اکثریت برسه. در پایین به چند مورد از این روش ها میپردازیم:

🔵 روش Random Under Sampler: این روش به صورت رندوم آنقدر از کلاس اکثریت داده حذف میکنه تا با کلاس اقلیت برابر بشه.

from imblearn.under_sampling import RandomUnderSampler
rus = RandomUnderSampler()
X_rus, y_rus = rus.fit_resample(X, y)

X_train, X_test, y_train, y_test = train_test_split(X_rus, y_rus)

🟢 یکی از بدی های روش RUS اینه که خیلی از نمونه ها رو حذف میکنه و ممکنه خیلی از الگوها از دست بره.

▫️ ما فقط باید روی داده های train عملیات بالانس کردن دیتا رو انجام بدیم. اول داده ها رو به دو بخش تقسیم کنیم سپس روی X_train و y_train عملیات بالانس کردن رو انجام بدیم.

🔴 روش Random Over Sampler: در این روش آنقدر به نمونه های کلاس اقلیت اضافه میکنه تا نزدیک به کلاس اکثریت بشه.

◾️ مشکل روش ROS اینه که داده مصنوعی زیاد داریم.

✳️ روش Tomek Links: این روش مرز بین کلاس اقلیت و اکثریت رو شناسایی میکنه، و مرز رو به نفع کلاس اقلیت خالی میکنه تا فاصله بین مرز داده اقلیت و داده اکثریت زیاد بشه.

⁉️ روش SMOTE: در این روش بین کلاس اقلیت یال میکشه و گراف کامل رسم میکنه. سپس روی یال ها انقدر نمونه جدید اضافه میکنه تا کلاس اقلیت و اکثریت با هم برابر بشه.

from imblearn.over_sampling import SMOTE

sm = SMOTE()
X_sm, y_sm = sm.fit_resample(X, y)

✳️ دیپ لرنینگ قادر به یادگیری الگوهای پیچیده تری به نسبت ماشین لرنینگ است. استفاده از دیپ لرنینگ به دو شرط نیاز دارد:
🔸 حجم بالای داده ها
🔸 توان پردازش بالاتر

🔻 الگوریتم های دیپ لرنینگ نیاز زیادی به Feature Extraction ندارند و خودشون اینکار رو انجام میدهند.

🔹 Deep Learning: Deep Neural Networks (DNN)

▫️ شبکه های عصبی الگوریتم هایی هستند که از مغز موجودات زنده الهام گرفته اند. این شبکه ها سه جز اصلی دارند:
📌 نورون ها
📌 وزن ها
📌 لایه ها

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

💡 به لایه های بین لایه ورودی و لایه خروجی، لایه مخفی (Hidden) میگویند. ما میتوانیم n تا لایه مخفی در شبکه عصبی داشته باشیم. نورون های هر لایه توسط وزن ها به نورون های لایه بعدی اتصال پیدا میکنند.

📍 تعداد نورون های لایه اول، به تعداد ویژگی های داده (ستون ها) بستگی دارد. لایه های پنهان اختیاری هستند. تعداد نورون های لایه آخر هم با توجه به تارگت مشخص میگردد. اگر تارگت بصورت 0 و 1 بود، دو نورون در لایه آخر کافی است.

🔍 به فازی که از لایه اول به لایه آخر حرکت میکنیم، Feed Forward گفته میشود. وقتی به لایه آخر رسیدیم خطا را محاسبه میکند و بر اساس خطا، فاز آپدیت را شروع میکند. فاز آپدیت از لایه آخر به اول است که به اصطلاح میگویند Back Propagation. بر اساس خطا، وزن ها طوری آپدیت میشوند که خطا کمتر بشود.

📝 الگوریتم های شبکه عصبی، یکبار مجموعه داده رو از اول تا آخر میبینند و بر میگردند و دو مرتبه از ابتدا تا انتها میبینند. به هر باری که داده ها از ابتدا تا انتها دیده بشه در اصطلاح میگویند یک epoch یا دور اتفاق افتاده.

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

⁉️ ممکن است واگرایی در اعداد رخ بدهد و از دست شبکه خارج شود. در اصطلاح میگویند در شبکه عصبی آشوب اتفاق افتاده.

❕ طراحی شبکه عصبی نیز چالش است.

⭕️ در شبکه عصبی با استفاده از اندازه ی دسته (batchsize)، میتونیم کاری کنیم که الگوریتم وزن خودش رو به ازای میانگین مقدار خطای اندازه دسته آپدیت کند.

📖 وزن های شبکه عصبی با یک ضریب آپدیت میشوند که به آن ضریب نرخ یادگیری (Learning Rate) میگویند. هرچقدر مقدار LR کمتر باشد، الگوریتم در یادگیری صبور‌تر است. و بالعکس.

📑 در طراحی شبکه های عصبی، معمولا توی هر لایه یک نورون دیگر اضافه میکنند که مقدارش یک است و وزن جدیدی هم اضافه میکنند. معمولا میگویند با اینکار باعث میشود لایه مد نظر از لحاظ یادگیری تقویت بشود. به نورون اضافه شده بایاس میگویند.

📍 چند کتابخانه معروف برای کار در حوزه شبکه عصبی موجود است. یکی از آنها کتابخانه TensorFlow Keras میباشد. کتابخانه قوی دیگری به نام PyTorch نیز موجود است.

- نصب tensorflow از طریق anaconda prompt:
conda install tensorflow

- یا میتونیم داخل یک cell در Jupyter Notebook دستور زیر را وارد کنیم:
!conda install tensorflow

import tensorflow as tf

💭 همان پیش پردازش هایی که قبلا انجام میدادیم رو نیز باید در پروژه های مربوط به دیپ لرنینگ نیز انجام بدیم.

🔴 در اینجا باید ستون تارگت رو OHE کنیم. چون معماری شبکه عصبی این کار رو از ما میخواد.

y = pd.get_dummies(y)

🗂 ساخت شبکه عصبی:

model = tf.keras.models.Sequential([
        tf.keras.layers.Dense(11, activation='relu', input_shape=(11,)),
        tf.keras.layers.Dense(30, activation='relu'),
        tf.keras.layers.Dense(2, activation='softmax'),

model.summary()

📊 لایه Dense (غلیظ) یعنی از تمامی نورون های لایه قبل به تمامی نورون های لایه بعد وزن متصل است.

🔹 رسم plot برای مدل:

from tensorflow.keras.utils import plot_model

plot_model(model, show_layer_activations=True, show_shapes=True)

🔔 بعد از ساختن مدل باید اون رو compile کنیم.

mode.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss=tf.keras.losses.CategoricalCrossentropy(), metrics=[tf.keras.metrics.CategoricalAccuracy()])

▫️ الگوریتم آپدیت وزن ها رو در optimizer مشخص میکنیم. معمولا از Adam استفاده میکنند.
▪️ خطایی که الگوریتم محاسبه میکند با استفاده از فرمول loss انجام میگردد.
🔻 میتونیم metrics رو در هنگام compile کردن نزاریم، اما optimizer و loss رو حتما باید مشخص کنیم.

🔸 سپس مدل رو بر روی داده ها فیت میکنیم:

model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test), batch_size=100)

🔹 اگر دقت شبکه عصبی عمیق خیلی نبود، میتونیم لایه های بیشتری اضافه کنیم و تعداد نورون ها رو افزایش بدیم.

🟧 الگوریتم های شبکه عصبی به مرور همگرا میشن و دقت افزایش پیدا نمیکنه.

- وقتی مدل یاد گرفت میتونیم اونها رو predict کنیم.

model.predict(X_test)[3]

📐 تابع فعال ساز softmax که بالاتر ازش استفاده کردیم، معمولا توی نورون لایه آخر استفاده میشه و با استفاده از یک فرمولی، جمع تمامی نورون ها در لایه آخر رو 1 میکنه.

🧮 دلیل اینکه از softmax در لایه های وسط استفاده نمیکنیم بخاطر اینه که حجم پردازشی بالایی نیاز داره.

🧷 چند مورد از توابع فعال ساز:
- Linear
- Sigmoid
- Tanh
- ReLu
- LeakyReLu
- Softmax

📚 در طراحی شبکه عصبی معمولا میگن اول با لایه های تقریبا مساوی با لایه ورودی شروع کنیم، بعد شبکه رو چاق کنیم و در نهایت شبکه رو لاغر کنیم.

✳️ یادگیری در شبکه های عصبی = پیدا کردن اعداد داخل وزن ها

🔸 اگر مشکل overfit در الگوریتم های دیپ لرنینگ اتفاق افتاده بود، میتونیم از لایه drop out استفاده کنیم. لایه drop out بین لایه ها در هنگام train یکسری از وزن ها و نورون ها رو به صورت رندوم غیرفعال میکنه. این کار از overfit جلوگیری میکنه.

model = tf.keras.models.Sequential([
        tf.keras.layers.Dense(11, activation='relu', input_shape=(11,)),
        tf.keras.layers.DropOut(0.3),
        tf.keras.layers.Dense(30, activation='relu'),
        tf.keras.layers.Dense(2, activation='softmax')
])

🔹 معماری های مختلف شبکه های عصبی:
- CNN: Convolutional Neural Networks

▫️ اگر حجم داده ها زیاد باشه اون ها رو به صورت incremental میخونیم.

🔻 اگر داده ها کم بود از روش Data Augmentation (افزایش مصنوعی داده ها) استفاده میکنیم. از این روش فقط برای داده های train استفاده میکنیم. به هیچ وجه نباید روی داده های train این کار رو انجام بدیم.

🟠 با استفاده از ImageDataGenerator میتونیم بر روی داده های ورودی از جنس تصویر تغییراتی اعمال کنیم.

import pandas as pd
import matplotlib.pyplot as plt
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPool2D, Flatten, Dense
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
from tensorflow.keras.utils import plot_model
from sklearn.utils.class_weight import compute_class_weight
from tensorflow.keras.callbacks import ModelCheckpoint

image_generator = ImageDataGenerator(
       rescale=1./255.,
       shear_range=0.1,
       zoom_range=0.3,
)
image_generator_test = ImageDataGenerator(
       rescale=1./255.
)

‼️ پکیج ImageDataGenerator قابلیت جالبی به نام FlowFromDirectory داره. در این قابلیت، یک دایرکتوری میسازیم و به ازای هر کلاس، یک فولدر ایجاد میکنه. داخل هر فولدر فقط تصاویری که مربوط به اون کلاس هستند قرار داده میشه.

train_data = image_generator.flow_from_directory(
       'data',
       target_size=(500, 500),
       color_mode='grayscale',
       class_mode='binary',
       batch_size=10
)

test_data = image_generator.flow_from_directory(
       'test_data',
       target_size=(500, 500),
       color_mode='grayscale',
       class_mode='binary',
       batch_size=10
)

✳️ ساخت مدل:

model = Sequential()
model.add(Conv2D(32, (3,  3), activation='relu', input_shape=(500, 500, 1)))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Conv2D(32, (3,  3), activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Conv2D(64, (3,  3), activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Conv2D(64, (3,  3), activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

⭕️ کامپایل کردن مدل:

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']

❇️ در فیت کردن مدل، موردی داریم به اسم callbacks. این مجموعه‌ی callbacks یک سری فانکشن هستن که بعد از هر ایپاک فراخوانی میشن.

🔸 یکی از اون callbacks ها، es یا early stopping میباشد. این تابع بعد از هر ایپاک چک میکند اگر در سه ایپاک پشت سر هم (مقدار دلخواه هست)، مقدار validation loss کاهش پیدا نکرد، دیگه ادامه نده. در واقع الگوریتم همگرا شده است.

es = EarlyStopping(monitor='val_loss', mode='min', patience=3)

🔹 مورد بعدی در callbacks ها، rlrop یا reduce learning rate on plateau میباشد. این تابع، وقتی الگوریتم جلو میرود به مرور نرخ یادگیری را با ضریب خاص کاهش داده.

rlrop = ReduceLROnPlateaue(monitor='val_loss', patience=2, factor=0.2, min_lr=0.001)

🔻 مورد بعدی model checkpoint میباشد. این تابع بعد از هر ایپاک، اگر بهترین (کمترین) loss رو پیدا کرد، وزن ها رو ذخیره میکند.

mch = ModelCheckpoint('chestxray.h5', monitor='val_loss', mode='min', save_best_only=True)

🟢 شبکه های عصبی قابلیت جالبی به نام class weight دارند. معمولا کلاسی که از لحاظ تعداد در هنگام train کمتر هست، وزن بیشتری داشته باشد.

weights = compute_class_weight(class_weight='balanced', classes=np.unique(train_data.classes), y=train_data.classes)

class_weights = dict(zip(np.unique(train_data.classes), weights))

⭕️ تکنیک Transfer Learning (یادگیری انتقالی): در این روش، وزن های اولیه شبکه به جای اینکه تصادفی باشند، از همون وزن هایی که قبلا یاد گرفته استفاده میکنند.

از مشکلات این روش، اول از همه اینه که مجموعه داده ای پیدا کنیم که خیلی شبیه به پروژه ای که ما قصد انجام اون رو داریم باشه. سپس، معماری ای رو پیدا کنیم که روی مجموعه داده ما train شده باشه و وزن ها به صورت عمومی در دسترس باشه.

⁉️ در Transfer Learning معمولا نیازی به Data Augmentation نداریم.

🔍 اگر مسئله ما ساده بود و تعداد کمی داده داشتیم، در صورتی که به تعداد کافی ایپاک تعریف نکنیم ممکن است الگوریتم overift بشه. برای همین قسمتی از وزن ها رو freez میکنیم تا از این مشکل جلوگیری کنیم. سرعت یادگیری هم با این روش افزایش پیدا میکند.

❇️ اکثر اوقات بهتره که بجای اینکه داده‌ها رو به دو قسمت train و test تقسیم کنیم، به سه قسمت train و test و validation تقسیم کنیم.

⁉️ گاهی ممکنه معماری‌ای که طراحی کردیم روی داده‌های test دقت خوبی نده و مجبور بشیم معماری رو عوض کنیم که اینکار خیلی درست نیست. چون ما داریم معماری مدل رو برای داده‌های test بیش از اندازه تیون میکنیم.

⭕️ اگر سه دسته داده داشته باشیم، طبق معمول که از روی دسته train یادگیری انجام میده. اگه بخوایم هایپر پارامترها یا همون معماری مدل‌مون جوری عوض کنیم که روی داده‌های validation خوب کار کنه، اجازه‌ش رو داریم.

🔸 بعد ازینکه معماری نهایی رو ساختیم و تموم شد، و روی داده‌های validation بهترین دقت رو گرفتیم، یبار دیگه روی داده‌های test که کنار گذاشتیم و تا حالا ندیدیمش به عنوان آخرین بار دو مرتبه predict میکنیم.

🔻 دسته‌ی test حالت double check برای داده‌های validation رو داره.

🔹 لایه Batch Normalization نورون‌هایی که توی آخرین لایه (لایه قبلی) بودن رو نرمالایز میکنه (مثلا تقسیم بر ماکسیموم). اینکار باعث میشه نورون‌ها توی لایه‌های مختلف خیلی واگرا نشن و الگوریتم بهتر و دقیق‌تر یاد بگیره.

▫️ اگر دقت روی داده‌های train بالا باشه و روی داده‌های test پایین باشه یعنی مدل overfit شده. 🔹 لایه Batch Normalization نورون‌هایی که توی آخرین لایه (لایه قبلی) بودن رو نرمالایز میکنه (مثلا تقسیم بر ماکسیموم). اینکار باعث میشه نورون‌ها توی لایه‌های مختلف خیلی واگرا نشن و الگوریتم بهتر و دقیق‌تر یاد بگیره.

▫️ اگر دقت روی داده‌های train بالا باشه و روی داده‌های test پایین باشه یعنی مدل overfit شده.

⭕️ شبکه های عصبی چند کاناله (Multi Channel)

❎ این شبکه های عصبی برای وقتی هستن که ما چند ورودی داریم (مثلا یکسری ورودی عددی، و یکسری ورودی تصویری). حال برای هر کدوم ازین ورودی ها یک شبکه عصبی جدا طراحی میکنیم (به هر مدل طراحی شده یک کانال میگن). سپس خروجی کانال اول رو با خروجی کانال دوم concat میکنیم و در نهایت اون رو به یک شبکه Dense دیگه میدیم یا فقط یک نورون قرار میدیم که پیش بینی رو انجام بده.

🔹 در شبکه های عصبی چند کاناله به ازای هر ورودی میتونیم یک کانال جدا داشته باشیم که هر کدوم یادگیری رو مستقل انجام بدن.

🔸 معماری Recurrent یا RNN (شبکه عصبی بازگشتی)

‼️ در شبکه های عصبی Dense ما یه مشکلی داریم، و اونم اینه که شبکه حافظه نداره. یعنی نمیتونیم داده ها رو به صورت ترتیبی بهشون بدیم. (ترتیب داده ها براش مهم نیست)

❇️ جاهایی که داده ها ترتیبی باشن (داده های سری زمانی یا داده های متنی و...) به مشکل برمیخوریم.

⭕️ شبکه عصبی بازگشتی، یک شبکه عصبی هست که هر نمونه عادی ای که بهش میدیم رو n بار به خودش برمیگردونه. درواقع این شبکه عصبی یک ورودی در زمان t داره، و یک خروجی به ما میده. همچنین یک خروجی هم به خودش برای زمان بعدی میده.

📍 الگوریتم های RNN یک مشکلی دارن و اونم اینه که وقتی Sequence طولانی بشه، به آخر که میرسه اولی ها رو از یاد میبره.

🔍 معماری RNN چهار نوع اصلی دارد:
- One 2 One
- One 2 Many
- Many 2 One
- Many 2 Many: Sync , Async

📚 وقتی Sequence ای از داده ها داریم، باید از یجایی به قبل رو به داده های train اختصاص بدیم، و از یک جایی به بعد رو به داده های test اختصاص بدیم. در اینجا نباید نمونه ها رو shuffle کنیم زیرا ترتیب برای ما اهمیت دارد.

📌 داده ها رو باید در سه بعد به RNN بدیم. بعد اول تعداد نمونه ها، بعد دوم توالی یا Sequence ای است که میخوایم پشت سر هم رخ بده، بعد سوم تعداد متغیرهایی است که در اون توالی میخوایم داشته باشیم.

📈 در RNN ما وقتی Xt رو از کاربر میگیریم، میتونیم برای مثال nتا بلوک Sequence رو بصورت تکرار شونده پشت سر هم داشته باشیم. (تصویر بلوک در پست بعدی ارسال میشه)

🧮 برای حل مشکل فراموشی که در Simple RNN ها داشتیم، مدل Long Short Term Memory یا LSTM به وجود اومد. این مدل برای توالی های بلند مدت خیلی بهتر عمل میکند و اون ها رو حفظ میکند.

💭 از مشکلات LSTM بخاطر محاسبات سنگین میشه به پایین اومدن سرعت یادگیری و پیش بینی، و قاطی کردن الگوریتم اشاره کرد. اگر الگوریتم قاطی کنه یا vanish میشه یا explode رخ میده.

⭕️ برای حل مشکلات LSTM مدل GRU یا Gated Recurrent Unit به وجود اومد. مثل همون LSTM هست منتهی یکم ساده تر. هم سرعت بهتری داره هم پیچیدگی کمتری داره.

⭕️ اگر مقدار return sequence رو برابر True قرار بدیم، خروجی تمام تایم‌ها رو به ما میده نه فقط تایم آخر.

❇️ وقتی که بخوایم RNN رو به dense وصل کنیم، یا یک خروجی باید بهش بدیم یا nتا خروجی که در این صورت باید اونها رو به TimeDistributedDense بدیم.

📌 یکی دیگر از معماری های RNN، نوع Encoder-Decoder است. (حالتی از Many 2 Many است)

🔸 معماری sequence to sequence دو بلوک دارد. بلوک Encoder و بلوک Decoder.

📚 عنصر embedding در یادگیری عمیق، با استفاده از یکسری تکنیک ورودی رو به یک فضای برداری معنایی (vector) تبدیل میکند. کلماتی که از لحاظ معنایی نزدیک بهم باشند در فضای اقلیدسی نزدیک هم میافتند. این روش سرعت پایینی دارد. همچنین حجم بسیار زیادی از داده ها رو نیاز دارد.

🟡 ترانسفورمرها (Transformers) یک Encoder-Decoder است که از Attension Mechanism استفاده میکنه.

🔵 مدل BERT نوعی از همین ترانسفورمرهاست که یک متن رو دریافت میکنه و تبدیلش میکنه به یک فضای مثلا 1024 بعدی. (به صورت معنایی اینکار رو انجام میده)

💭 در وبسایت huggingface.co افراد مختلف شبکه هایی رو که طراحی میکنند، آپلود میکنند.

▫️ از CNN 1D برای متون استفاده میشه.

⭕️ در مسائلی که پیچیدگی زیادی داریم، استفاده از elu به عنوان activation function پیشنهاد میشه.

✳️ روش های مختلفی برای Segmentation هست. یکی از معروف ترین روش ها، روشی به نام Segment anything می باشد.

🔸 مدل Segment Anything توسط شرکت فیسبوک ساخته شده. این مدل یک تصویر رو دریافت میکنه و با استفاده از encoder موجود در ترانسفورمر، تصویر رو به حالت embed تبدیل میکنه و با استفاده از masking قسمت های مختلف تصویر رو جدا میکنه.

✳️ معماری Multi Modal که زیر مجموعه Transformers ها هستند، وقتی استفاده میشن که ما چند جنس داده داشته باشیم. الگوریتم های زیر مجموعه Multi Modal میتونن رابطه ی بین دو جنس داده رو متوجه بشن (مثلا متن و تصویر).

💡 الگوریتم CLIP ارتباط بین تصاویر و متن رو میفهمه و مثالی از Multi Modal هاست.

📚 لایه Convolution Transpose برعکس لایه Covolution عمل میکنه. یعنی یک حالت فیلتر شده رو دریافت میکنه و تصویرش رو تحویل میده.

🔍 در Docker دو مفهوم اولیه داریم، محفظه ها (Container) و Image ها. این Image ها معادل یه CD یا فایل ISO هستن که میتونیم روی سیستم عامل های مختلف باز کنیم و نصب کنیم. Container یک Image هست که بالا اومده و اجرا شده.

📝 انواع Image های آماده روی سایت hub.docker.com پیدا میشن.

📍 بالا آوردن یک Container از روی یک Image:
docker run image name

🗄 برای مشاهده Container هایی که اجرا کردیم:
docker ps

💭 برای توقف یک Container (پایین آوردن):
docker stop port

❇️ برای اجرای مجدد یک Container:
docker start port

❎ برای دیدن لیست Container های متوقف شده:
docker ps -a

⁉️ برای حذف یکی از Container های متوقف شده:
docker rm port

🧮 برای ساختن Image راه های مختلفی وجود داره که یکی از اونها استفاده از Dockerfile هست