آدابوست

**آدابوست**  تطبیقی بوده و یک الگوریتم یادگیری ماشین است که توسط یاو فروند و رابرت شاپیر اختراع شد.
تطبیقی بودن آدابوست به این معناست که مدلها یکی پس از دیگری ساخته شده و عملکرد مدل‌های قبلی بر روند مدل‌سازی مدل‌های پس از آن تأثیر می‌گذارد. در واقع آدابوست یک متا الگوریتم است که به منظور ارتقاء عملکرد، و رفع مشکل رده‌های نامتوازن همراه دیگر الگوریتم‌های یادگیری استفاده می‌شود. در این الگوریتم، طبقه‌بندی هر مرحله جدید به نفع نمونه‌های غلط طبقه‌بندی شده در مراحل قبل تنظیم می‌گردد. آدابوست نسبت به داده‌های نویزی و پرت حساس است؛ ولی نسبت به مشکل بیش برازش از بیشتر الگوریتم‌های یادگیری برتری دارد. طبقه‌بندی پایه که در اینجا استفاده می‌شود فقط کافیست از طبقه‌بندی تصادفی (۵۰٪) بهتر باشد و به این ترتیب عملکرد الگوریتم در تکرارهای بیشتر بهبود می‌یابد. حتی طبقه‌بندهای با خطای بالاتر از تصادفی با گرفتن ضریب منفی عملکرد کلی را بهبود می‌بخشند. در الگوریتم آدابوست در هر دور  t = 1,\ldots,T یک طبقه‌بند ضعیف اضافه می‌شود. در هر فراخوانی بر اساس اهمیت نمونه‌ها، وزن‌ها D_{t} بروز می‌شود. در هر دور وزن نمونه‌های غلط طبقه‌بندی شده افزایش و وزن نمونه‌های درست طبقه‌بندی شده کاهش داده می‌شود؛ بنابراین طبقه‌بند جدید تمرکز بر نمونه‌هایی که سخت‌تر یادگرفته می‌شوند، خواهند داشت.
پس به‌طور خلاصه این الگوریتم منطبق بر یادگیری گروهی می‌باشد. به بیان ساده‌تر طرز کار این الگوریتم به این صورت است که عملکرد مدلهایی که به تنهایی ضعیف عمل می‌کنند را با یکدیگر ترکیب کرده و باعث بهبود عملکرد آنها می‌شود. پس در نظرگرفتن پیش‌بینی که مجموع چند الگوریتم یادگیری ضعیف ارائه می‌دهد می‌تواند در نهایت به اندازهٔ عملکرد یک الگوریتم قوی قابل اتکا باشد.

## الگوریتم طبقه‌بندی دوگانه
داده شده‌ها:
* مجموعه یادگیری: (x_{1},y_{1}),\ldots,(x_{N},y_{N}) که x_{i} \in X,\, y_{i} \in Y = \{-1, +1\}
* تعداد تکرارها: T

مقداردهی اولیه: \textstyle D_{1}(i) = \frac{1}{N}, i=1,\ldots,N. برای t = 1,\ldots,T
* برای خانواده طبقه‌بندهای ضعیف ℋ طبقه‌بند h_{t}\,\! را پیدا کن که میزان خطا نسبت به توزیع D_{t} کمینه شود، در این معادله I یک تابع نشانگر است:

h_{t} = \underset{h \in \mathcal{H}}{\operatorname{argmin}} \; \sum_{i=1}^{N} D_{t}(i)I(y_i \ne h(x_{i}))

خطای  h_t  را با  \epsilon_{t}  نمایش می‌دهیم:

 \epsilon_{t} = \sum_{i=1}^{N} D_{t}(i)I(y_i \ne h_{t}(x_{i})) 

* اگر \left\vert 0.5 - \epsilon_{t}\right\vert \leq \beta که \beta یک آستانه تعیین شده قبلی است، توقف انجام شود.
* معمولاً مقدار \alpha_{t}=\frac{1}{2}\textrm{ln}\frac{1-\epsilon_{t}}{\epsilon_{t}} برای \alpha_{t} \in \mathbb{R} در نظر گرفته می‌شود.
* بروز رسانی:

D_{t+1}(i) = \frac{ D_t(i) \exp\left(\alpha_t I(y_i\neq h_t(x_i))\right) }{ Z_t }

: که Z_{t} یک عامل نرمال‌سازی با مقدار \sum_{i} D_{t}(i)\exp(-\alpha_t y_i h_t(x_i))\,\! است که موجب می‌شود D_{t+1} یک توزیع احتمالاتی مجاز را نشان دهد (مجموع روی همه x‌ها یک شود)
: خروجی نهایی طبقه‌بند

H(x) = \textrm{sign}\left(\sum_{t=1}^{T} \alpha_{t}h_{t}(x)\right)

: توجه شود که معادله بروز رسانی توزیع D_{t} بگونه‌ای بروز می‌شود که

: - \alpha_{t} y_{i} h_{t}(x_{i}) \begin{cases} 0, & y(i) \ne h_{t}(x_{i}) \end{cases}

بنابراین بعد از انتخاب بهینه طبقه‌بند h_{t} \, برای توزیع D_{t} \, آندسته از نمونه‌ها x_{i} \, که طبقه‌بند h_{t} \, آن‌ها را غلط طبقه‌بندی می‌کند وزن بیشتری نسبت به بقیه داده می‌شود؛ بنابراین وقتی الگوریتم طبقه‌بندها را براساس توزیع D_{t+1} \, تست می‌کند، طبقه‌بندی انتخاب می‌شود که نمونه‌های غلط طبقه‌بندی شده را بهتر تشخیص دهد.

## مراحل الگوریتم آدابوست
الگوریتم آدابوست مطابق مراحل زیر به صورت مکرر کار می‌کند
* در ابتدا برای این الگوریتم الزامی است یک زیرمجموعه آموزشی انتخاب شود.
* با استفاده از مجموعه آموزشی که بر اساس پیش‌بینی صحیح آخرین آموزش ایجاد شده به صورت مکرر مدل یادگیری‌ماشینی آدابوست را آموزش می‌دهیم.
* تمام نمونه‌های آموزشی در فرایند آموزش دارای وزنی خواهند بود که براساس خطای ناشی از مدل یادگیری‌ماشین به‌دست می‌آید. این الگوریتم وزن بالاتری را به مشاهداتی که به صورت اشتباه طبقه‌بندی شده‌اند اختصاص می‌دهد تا در تکرارهای بعدی این مشاهدات برای فرایند طبقه‌بندی احتمال بالاتری را به‌دست آورند.
* در مرحله بعد طبقه‌بندهایی که آموزش دیده شده‌اند وزن‌دهی می‌شوند. هرچه طبقه‌بندی دقیق‌تر باشد وزن بالاتری خواهد داشت.
* این مراحل تا زمانی تکرار می‌شوند که داده‌های آموزشی کامل و بدون هیچ خطایی توسط مدل آموزش ببیند.
* برای انجام طبقه‌بندی کافی است یک رای به ازای هر الگوریتم یادگیری ساخته‌شده در نظر گرفته شود.

## ایجاد مدل در پایتون
در این مرحله مطابق کد زیر کتابخانه‌های مورد نیاز را وارد می‌کنیم.

# Load libraries
from sklearn.ensemble import AdaBoostClassifier
from sklearn import datasets
# Import train_test_split function
from sklearn.model_selection import train_test_split
# Import scikit-learn metrics module for accuracy calculation
from sklearn import metrics

در مرحله بعد از یک مجموعه‌داده برای بررسی مدل روی آن استفاده می‌کنیم.

# Load data
iris = datasets.load_iris()
X = iris.data
y = iris.target

سپس مجموعه‌داده را به دو قسمت آموزش و تست تقسیم می‌کنیم.

# Split dataset into training set and test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3) # 70% training and 30% test


در نهایت یک مدل آدابوست روی مجموعه‌داده اجرا می‌کنیم.


# Create adaboost classifer object
abc = AdaBoostClassifier(n_estimators=۵۰,
  learning_rate=۱)
# Train Adaboost Classifer
model = abc.fit(X_train, y_train)
# Predict the response for test dataset
y_pred = model.predict(X_test)


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

E = \sum_{i=1}^N \mbox{exp}({-y_i\times f_m(x_i)})

و ما به‌دنبال تابعی به شکل زیر هستیم:

f_m(x) = \frac{1}{2}\sum_{t=1}^m \alpha_t h_t(x)\,\!

مجهولِ تابع هزینه E، f_m(\cdot) است که خود به \alpha_1,\cdots, \alpha_m, h_1, \cdots, \alpha_m بستگی دارد. در نتیجه بهینه‌سازی تابع هزینه در نهایت باید نسبت به \alpha_1,\cdots, \alpha_m, h_1, \cdots, h_m صورت بگیرد.

حال برای راحتتر شدن کار فرض می‌کنیم که مقادیر \alpha_1,\cdots, \alpha_{m-1}, h_1, \cdots, h_{m-1} ثابت هستند و هدف ما پیدا کردن  \alpha_m و h_m است. با این اوصاف تابع Eرا می‌توان به شکل پایین نوشت:

E = \sum_{i=1}^N \mbox{exp}\left({-y_i\times \left(f_{m-1}(x_i) + \frac{1}{2}\alpha_m h_m(x_i)\right)}\right) = \sum_{i=1}^N \mbox{exp}\left({-y_i\times f_{m-1}(x_i) }\right)\mbox{exp}\left({-\frac{1}{2}y_i\times \alpha_m h_m(x_i)}\right)

اگر \mbox{exp}({-y_i\times f_{m-1}(x_i) }) را با w^{(m)}_i نمایش دهیم، تابع هزینه ما به شکل پایین تغییر شکل خواهد داد:

E = \sum_{i=1}^N  w_i^{(m)} e^{-\frac{1}{2}y_i\times \alpha_m h_m(x_i)}

اگر مجموعه تمام داده‌هایی که توسط h_m(\cdot) به درستی پیش‌بینی می‌شوند را با \Tau_m و مجموعه تمام داده‌هایی که توسط h_m(\cdot) نادرست پیش‌بینی می‌شوند را با M_m نمایش دهیم. تابع هزینه به شکل پایین تغییر خواهد کرد:


\begin{align}
E &= \mbox{exp}\left({-\frac{\alpha_m}{2}}\right)\sum_{i\in\Tau_m}  w_i^{(m)} + \mbox{exp}\left({\frac{\alpha_m}{2}}\right)\sum_{i\in M_m}  w_i^{(m)} \\ &= \left(\mbox{exp}\left({\frac{\alpha_m}{2}}\right) - \mbox{exp}\left({-\frac{\alpha_m}{2}}\right)\right)\sum_{i=1}^N w^{(m)}_i I \left(h_m(x_i) \neq y_i\right) + \mbox{exp}\left({-\frac{\alpha_m}{2}} \right)\sum_{i=1}^N w_i^{(m)}
\end{align}


حال اگر  E  را نسبت به h_m  بهینه کنیم، از آنجا که \mbox{exp}\left({-\frac{\alpha_m}{2}} \right)\sum_{i=1}^N w_i^{(m)}  و \left(\mbox{exp}\left({\frac{\alpha_m}{2}}\right) - \mbox{exp}\left({-\frac{\alpha_m}{2}}\right)\right)  نسبت به h_m  ثابت هستند، فقط باید \sum_{i=1}^N w^{(m)}_i I \left(h_m(x_i) \neq y_i\right)   را نسبت به h_m  کمینه کنیم؛ یعنی h_{m} = \underset{h \in \mathcal{H}}{\operatorname{argmin}} \; \sum_{i=1}^{N} w_{i}^{(m)}I(h(x_{i}) \ne y_i)

بعد از پیدا کردن h_m  باید \alpha_m  را پیدا کنیم اگر \frac{\sum_{i=1}^{N} w_{i}^{(m)}I(h(x_{i} )\ne y_i)}{\sum_{i=1}^{N} w_{i}^{(m)}} را \epsilon_{m} بنامیم تابع هزینه ما تبدیل می‌شود به \left(\left(\mbox{exp}\left({\frac{\alpha_m}{2}}\right) - \mbox{exp}\left({-\frac{\alpha_m}{2}}\right)\right)\epsilon_m + \mbox{exp}\left({-\frac{\alpha_m}{2}}\right)\right) \sum_{i=1}^N w_i^{(m)} که اگر از آن نسبت به \alpha_m  مشتق بگیریم و جواب را در نقطه صفر به‌دست بیاوریم به این جواب می‌رسیم: \alpha_{m}=\frac{1}{2}\textrm{ln}\frac{1-\epsilon_{m}}{\epsilon_{m}}.

حال که \alpha_{m} و h_{m} را پیدا کردیم باید ببینیم که w^{(m+1)}_i به چه شکل نسبت به w^{(m)}_i بروز می‌شود. w^{(m+1)}_i همان \mbox{exp}\left({-y_i\times f_{m}(x_i) }\right) است یعنی


\begin{align}
w_i^{(m+1)} &= \mbox{exp}\left({-y_i\times f_{m}(x_i)}\right) \\ &= \mbox{exp}\left({-y_i \times \left(f_{m-1}(x_i) + \frac{1}{2} \alpha_m h_m(x_i)\right)
}\right) \\ &= \mbox{exp}\left({-y_i f_{m-1}(x_i)
}\right)\mbox{exp}\left({-\frac{1}{2}y_i\alpha_m h_m(x_i)}\right) \\ &= w_i^{(m)}\mbox{exp}\left({-\frac{1}{2}y_i\alpha_m h_m(x_i)}\right)
\end{align}


پس ارتباط w^{(m+1)}_i با w^{(m)}_i به این شکل خواهد بود:

w_i^{(m+1)} = w_i^{(m)}\mbox{exp}\left({-\frac{1}{2}y_i\alpha_m h_m(x_i)}\right)

از آنجا که y_i h_m(x_i) = 1-2I(h(x_{i}) \ne y_i) به‌روز کردن w^{(m+1)}_i به این شکل تغییر خواهد کرد:

w_i^{(m+1)} = w_i^{(m)}\mbox{exp}\left({-\frac{\alpha_m}{2}}\right)\mbox{exp}\left({\alpha_m I\left(h_m(x_i) \neq y_i\right)}\right)

اگر تمام w^{(m+1)}_i‌ها را در یک مقدار ثابتی ضرب کنیم تأثیری در جواب نهایی \epsilon_{m+1} و  \alpha_{m+1} و  h_{m+1} نخواهد داشت. ازین رو همیشه می‌توان مقدار آن‌ها را نرمال‌سازی کرد. با نرمال‌سازی w^{(m+1)}_i به معادله بازگشتی پایین می‌رسیم، در این معادله Z_m = \sum_i w_i^{(m)} :

w_i^{(m+1)} = \frac{w_i^{(m)}\mbox{exp}\left({\alpha_m I\left(h_m(x_i) \neq y_i\right)}\right)}{Z_m}

w^{(m+1)}_i همان D_{m+1}(i)است، و از آنجا که \frac{1}{2}در جواب sign(f_m(x)) تأثیری ندارد، می‌توان آن را حذف کرد. حال اگر m را همان T بگیریم به الگوریتم آدابوست خواهیم رسید.

## جستارهای وابسته
* تقویت گرادیان
* ال پی بوست

## منابع

## پیاده‌سازی‌ها

* AdaBoost and the Super Bowl of Classifiers - A Tutorial on AdaBoost.
* Adaboost in C++, an implementation of Adaboost in C++ and boost by Antonio Gulli
* icsiboost, an open source implementation of Boostexter
* JBoost, a site offering a classification and visualization package, implementing AdaBoost among other boosting algorithms.
* MATLAB AdaBoost toolbox. Includes Real AdaBoost, Gentle AdaBoost and Modest AdaBoost implementations.
* A Matlab Implementation of AdaBoost 
* milk  for Python implements AdaBoost.
* MPBoost++, a C++ implementation of the original AdaBoost.MH algorithm and of an improved variant, the MPBoost algorithm.
* NPatternRecognizer , a fast machine learning algorithm library written in C#. It contains support vector machine, neural networks, bayes, boost, k-nearest neighbor, decision tree, … , etc.
* OpenCV implementation of several boosting variants
* Into contains open source implementations of many AdaBoost and FloatBoost variants in C++.

## پیوند به بیرون

* Boosting.org, a site on boosting and related ensemble learning methods
* AdaBoost Presentation summarizing Adaboost (see page 4 for an illustrated example of performance)
* A Short Introduction to Boosting Introduction to Adaboost by Freund and Schapire from 1999
* A decision-theoretic generalization of on-line learning and an application to boosting *Journal of Computer and System Sciences*, no. 55. 1997 (Original paper of Yoav Freund and Robert E.Schapire where Adaboost is first introduced.)
* An applet demonstrating AdaBoost
* Ensemble Based Systems in Decision Making, R. Polikar, IEEE Circuits and Systems Magazine, vol.6, no.3, pp.&nbsp;21–45, 2006. A tutorial article on ensemble systems including pseudocode, block diagrams and implementation issues for AdaBoost and other ensemble learning algorithms.
* Additive logistic regression: a statistical view of boosting by Jerome Friedman, Trevor Hastie, Robert Tibshirani. Paper introducing probabilistic theory for AdaBoost, and introducing GentleBoost

رده:الگوریتم‌های دسته‌بندی
رده:یادگیری گروهی