Algorithms and Improved bounds for online learning under finite hypothesis class

TL;DR

This paper introduces three algorithms that significantly improve mistake bounds in online learning for finite hypothesis classes, especially effective when input sequences are mostly realizable.

Contribution

The paper proposes three novel algorithms that enhance mistake bounds in the unrealizable case of online learning with finite hypothesis classes.

Findings

Algorithms outperform existing methods in long-term mistake bounds

Significant improvements when input sequences are mostly realizable

Enhanced performance in unrealizable scenarios

Abstract

Online learning is the process of answering a sequence of questions based on the correct answers to the previous questions. It is studied in many research areas such as game theory, information theory and machine learning. There are two main components of online learning framework. First, the learning algorithm also known as the learner and second, the hypothesis class which is essentially a set of functions which learner uses to predict answers to the questions. Sometimes, this class contains some functions which have the capability to provide correct answers to the entire sequence of questions. This case is called realizable case. And when hypothesis class does not contain such functions is called unrealizable case. The goal of the learner, in both the cases, is to make as few mistakes as that could have been made by most powerful functions in hypothesis class over the entire sequence of questions. Performance of the learners is analysed by theoretical bounds on the number of mistakes made by them. This paper proposes three algorithms to improve the mistakes bound in the unrealizable case. Proposed algorithms perform highly better than the existing ones in the long run when most of the input sequences presented to the learner are likely to be realizable.

Figures

Tables

Table 1. Table I : Predictions of ℋ = { h 1 , h 2 , h 3 , h 4 } ℋ subscript ℎ 1 subscript ℎ 2 subscript ℎ 3 subscript ℎ 4 \mathcal{H}=\{h_{1},h_{2},h_{3},h_{4}\} on the sequence of examples v 1 , v 2 , v 3 subscript 𝑣 1 subscript 𝑣 2 subscript 𝑣 3 v_{1},v_{2},v_{3} .

	$h_1$	$h_2$	$h_3$	$h_4$
$v_1$	0	0	1	1
$v_2$	0	1	*	*
$v_3$	*	*	0	1

Table 2. Table II : Summary of mistake bounds of existing algorithms for finite hypothesis class and realizable case.

Seq	Algorithms	Mistake Bound	Optimal Mistake Bound
1.	Consistent	$\left|\mathscr{H}\right|$
2.	Halving	${\text{log}}_2\left(\left|\mathscr{H}\right|\right)$	Ldim($\mathscr{H}$)
3.	SOA	Ldim($\mathscr{H}$)

Table 3. Table III : Summary of regret bounds of existing algorithms for finite Ldim hypothesis class in unrealizable case.

Seq	Algorithms	Regret Bound	Optimal Regret Bound
1.	\pbox20cmWeighted Majority
when
Ldim(	$\sqrt{\left(0.5\ln \left(\mathscr{H}\right)T\right)}$	O($\sqrt{\text{Ldim}\left(\mathscr{H}\right)T}$)
2.	\pbox20cmExperts when $\left|\mathscr{H}\right|$
is allowed to be $\infty$,
Ldim	\pbox20cm$\text{Ldim}\left(\mathscr{H}\right)+$
$\sqrt{0.5\text{Ldim}\left(\mathscr{H}\right)T\ln \left(T\right)}$	Same as above

Table 4. Table IV : Comparison of mistake and regret bounds of existing and proposed algorithms for realizable and unrealizable cases under finite hypothesis class .

Seq	Algorithms	\pbox20cmMistake Bound
(Realizable case)	\pbox20cmRegret Bound
(Unrealizable case)	\pbox20cmOptimal
Regret Bound
(Unrealizable
case)
1.	\pbox20cmWeighted Majority	$\sqrt{0.5\ln \left(\mathscr{H}\right)T}$	$\sqrt{0.5\ln \left(\mathscr{H}\right)T}$	($\sqrt{\text{Ldim}\left(\mathscr{H}\right)T}$)
2.	WM_Consistent	$\left|\mathscr{H}\right|-1$	\pbox20cm$\left|\mathscr{H}\right|+\sqrt{0.5\ln \left(\left|\mathscr{H}\right|\right)\left(T-\left|\mathscr{H}\right|\right)}$	Same as above
3.	WM_Halving	log${}_2{}^{}\left(\mathscr{H}\right)$	\pbox20cm ${\log }_2\left(\mathscr{H}\right)+\sqrt{0.5\ln \left(\left|\mathscr{H}\right|\right)\left(T-{\log }_2\left(\left|\mathscr{H}\right|\right)\right)}$	Same as above
4.	WM_SOA	Ldim$\left(\mathscr{H}\right)$	\pbox20cm$\text{Ldim}\left(\mathscr{H}\right)+\sqrt{0.5\ln \left(\left|\mathscr{H}\right|\right)\left(T-\text{Ldim}\left(\mathscr{H}\right)\right)}$	Same as above

Table 5. Table V : Example sequence of length 8 which is realizable by the hypothesis class constructed according to function definition given by equation 9 .

$t$	$x_t$	$y_t$
1.	$-3$	$0$
2.	$-2$	$0$
3.	$-1$	$0$
4.	$0$	$0$
5.	$1$	$1$
6.	$2$	$1$
7.	$3$	$1$
8.	$4$	$1$

Table 6. Table VI : Example sequence of length 8. This sequence is not realizable by our hypothesis class constructed according to hypotheses definition given by equation 8 . The labels have been generated by hypothesis defined in equation 11 which does not belong to our ℋ ℋ \mathcal{H} .

$t$	$x_t$	$y_t$
1.	$-3$	$1$
2.	$-2$	$1$
3.	$-1$	$1$
4.	$0$	$1$
5.	$1$	$1$
6.	$2$	$1$
7.	$3$	$1$
8.	$4$	$1$

Table 7. Table VII : Showing predictions and total mistake count of each function over the entire sequence S.

$t$	$x_t$	$y_t$	$h_0\left(x_t\right)$	$h_1\left(x_t\right)$	$h_2\left(x_t\right)$	$h_3\left(x_t\right)$	$h_4\left(x_t\right)$
1.	$-3$	$0$	$0$	$0$	$0$	$0$	$0$
2.	$-2$	$0$	$0$	$0$	$0$	$0$	$0$
3.	$-1$	$0$	$0$	$0$	$0$	$0$	$0$
4.	$0$	$0$	$0$	$0$	$0$	$0$	$0$
5.	$1$	$1$	$1$	0	0	0	0
6.	$2$	$1$	$1$	$1$	0	0	0
7.	$3$	$1$	$1$	$1$	$1$	0	0
8.	$4$	$1$	$1$	$1$	$1$	$1$	0
$𝐌\left({𝐡}_{𝐢}\right)$	$--$	$--$	0	1	2	3	4

Table 8. Table VIII : Comparison of mistake counts of existing and proposed algorithms in realizable case on both all permutations of the sequence S given in table V and some randomly generated permutations of large sequence of 1000 points. In this table, h ∗ superscript ℎ h^{*} denotes the best function. i.e. it does not make any mistake over the entire input sequence and it realizes the constructed hypothesis class ℋ ℋ \mathcal{H} .

$T$	$Permut-$ $ations$	$\left|\mathscr{H}\right|$	$M\left(h^{\ast }\right)$	WM expected mistakes	WM Max mistakes (1)	WM_ Halving expected mistakes	WM_ Halving Max mistakes (2)	Diff (1) - (2)
$1000$	$100$	$500$	$0$	$35.76$	$46$	$3.25$	$5$	$41$
$1000$	$100$	$500$	$0$	$36.63$	$49$	$3.31$	$6$	$43$
$1000$	$100$	$500$	$0$	$36.36$	$46$	$3.18$	$6$	$39$
$8$	$40,320$	$4$	$0$	$1.31$	$3$	$0.91$	$2$	$1$
$8$	$40,320$	$4$	$0$	$1.32$	$3$	$0.91$	$2$	$1$
$8$	$40,320$	$4$	$0$	$1.31$	$3$	$0.91$	$2$	$1$

Table 9. Table IX : Comparison of mistake counts of existing and proposed algorithms in unrealizable case on both all permutations of the sequence S given in table VI and some randomly generated permutations of large sequence of 1000 points generated in the same way. In this table, h ∗ superscript ℎ h^{*} denotes the best function. i.e. which makes least number of mistakes over the entire input sequence.

$T$	Permut- ations	$\left|\mathscr{H}\right|$	$M\left(h^{\ast }\right)$	WM expected regret (1)	WM_ Halving expected regret (2)	Diff (1) - (2)
$1000$	$100$	$500$	$500$	$36.15$	$35.93$	$0.22$
$1000$	$100$	$500$	$500$	$36.86$	$36.10$	$0.76$
$1000$	$100$	$500$	$500$	$35.84$	$35.84$	$0$
$8$	$40,320$	$4$	$4$	$1.31$	$1.28$	$0.03$
$8$	$40,320$	$4$	$4$	$1.32$	$1.29$	$0.03$
$8$	$40,320$	$4$	$4$	$1.32$	$1.28$	$0.04$

Equations

$${\text{Regret}}_T(h)=\sum _{t=1}^{T}l(p_t,y_t)-\sum _{t=1}^{T}l(h(x_t),y_t)$$

$${\text{Regret}}_T(\mathcal{H})=\underset{h\in \mathcal{H}}{\max }{\text{Regret}}_T(h)$$

$$\text{Ldim}(\mathcal{H})\le {\text{log}}_2(|\mathcal{H}|)$$

$$|H^{t+1}|\le |H^t|-1.$$

$$M_{Consistent}(\mathcal{H})\le |\mathcal{H}|-1$$

$$1\le |V_{t+1}|\le |\mathcal{H}|/2^M$$

$$1\le |\mathcal{H}|/2^M$$

$$2^M\le |\mathcal{H}|$$

$$M\le {\text{log}}_2(|\mathcal{H}|)$$

$$\sum _{t=1}^T\text{mathds}E[\text{mathds}1[\widehat{y_t}\ne y_t]]-\underset{i\in [d]}{\min }\sum _{t=1}^T\text{mathds}1[h_i^t(x_t)\ne y_t]\le \sqrt{0.5\ln (d)T}$$

$$M_{WM\_Consistent}(\mathcal{H},T)\le |\mathcal{H}-1|$$

$$\begin{array}{r}\sum _{t=1}^T\text{mathds}E[\text{mathds}1[\widehat{y_t}\ne y_t]]-\underset{i\in [d]}{\min }\sum _{t=1}^T\text{mathds}1[h_i^t(x_t)\ne y_t]\\ \le \sqrt{0.5\ln (|\mathcal{H}|)T}\end{array}$$

$$M_{WM\_Consistent}(\mathcal{H},T)\le |\mathcal{H}-1|$$

$$\sum _{t=1}^T\text{mathds}E[1[\widehat{y_t}\ne y_t]]-\underset{h\in \mathcal{H}}{\min }\sum _{t=1}^{T}1[h(x_t)\ne y_t]$$

$$\le \sqrt{0.5\ln (|\mathcal{H}|)(T-|\mathcal{H}|)}+|\mathcal{H}|$$

$$M_{WM\_Halving}(\mathcal{H},T)\le |{\log }_2(|\mathcal{H}|)$$

$$\begin{array}{r}\sum _{t=1}^T\text{mathds}E[\text{mathds}1[\widehat{y_t}\ne y_t]]-\underset{i\in [d]}{\min }\sum _{t=1}^T\text{mathds}1[h_i^t(x_t)\ne y_t]\\ \le \sqrt{0.5\ln (\mathcal{H})T}\end{array}$$

$$M_{WM\_Halving}(\mathcal{H},T)\le {\log }_2(|\mathcal{H}|)$$

$$\sum _{t=1}^T\text{mathds}E[1[\widehat{y_t}\ne y_t]]-\underset{h\in \mathcal{H}}{\min }\sum _{t=1}^{T}1[h(x_t)\ne y_t]$$

$$\le \sqrt{0.5\ln (|\mathcal{H}|)(T-{\log }_2|\mathcal{H}|)}+{\text{log}}_2(|\mathcal{H}|)$$

$$M_{WM\_SOA}(\mathcal{H},T)\le Ldim(\mathcal{H})$$

$$\begin{array}{r}\sum _{t=1}^T\text{mathds}E[\text{mathds}1[\widehat{y_t}\ne y_t]]-\underset{i\in [d]}{\min }\sum _{t=1}^T\text{mathds}1[h_i^t(x_t)\ne y_t]\\ \le \sqrt{0.5\ln (|\mathcal{H}|)T}\end{array}$$

$$M_{WM\_SOA}(\mathcal{H},T)\le Ldim(\mathcal{H})$$

$$\sum _{t=1}^T\text{mathds}E[\text{mathds}1[\widehat{y_t}\ne y_t]]-\underset{h\in \mathcal{H}}{\min }\sum _{t=1}^T\text{mathds}1[h(x_t)\ne y_t]$$

$$\le \sqrt{0.5\ln (|\mathcal{H}|)(T-\text{Ldim}(\mathcal{H}))}+\text{Ldim}(\mathcal{H})$$

$$h^{\ast }(x_t)=y_t;\forall t\in \left[T\right]$$

$$x_t\in [-T/2+1,T/2]$$

$$y_t\in \{0,1\}$$

$$h_{i}(x_{t})=\left\{\begin{array}[]{cl}0&\textrm{if }x_{t}\leq i\\ 1&\textrm{otherwise}\\ \end{array}\right.$$

$$\mathcal{H}=\{h_i:i\in \left[1,d\right]\}$$

Full text

There are two main components of online learning framework. First, the learning algorithm also known as the learner and second, the hypothesis class which is essentially a set of functions which learner uses to predict answers to the questions.

Sometimes, this class contains some functions which have the capability to provide correct answers to the entire sequence of questions. This case is called realizable case. And when hypothesis class does not contain such functions is called unrealizable case. The goal of the learner, in both the cases, is to make as few mistakes as that could have been made by most powerful functions in hypothesis class over the entire sequence of questions. Performance of the learners is analysed by theoretical bounds on the number of mistakes made by them.

This paper proposes three algorithms to improve the mistakes bound in the unrealizable case. Proposed algorithms perform highly better than the existing ones in the long run when most of the input sequences presented to the learner are likely to be realizable.

I Introduction

I-A Online Learning

Online learning is the process of answering a sequence of questions based on the correct answers to the previous questions. The goal here is to make as few mistakes as possible over an entire sequence of questions. It is studied in many research areas such as game theory, information theory and machine learning where settings of online learning are similar to that of these areas.

There are two main components of online learning framework. First, the learning algorithm also known as the learner and second, the hypothesis class which is essentially a set of functions. Learner tries to predict answers (labels) to the questions using this set of functions.

This hypothesis class may be finite or infinite. Sometimes, this class contains some functions which have the capability to provide correct answers to the entire sequence of questions. In this case, the goal of learner becomes to identify these functions from the hypothesis class as early as possible to avoid mistakes on further questions. This setting, when function class contains some powerful functions which can provide correct answers to the entire sequence of questions, is called realizable case.

Sometimes, it may not contain any such powerful functions which can provide correct answers to the entire sequence of questions. In such a case, learner has to rely on the available functions in the hypothesis class and use them intelligently to predict the answers. The goal of the learner, therefore, becomes to make as few mistakes as that could have been made by most powerful functions among the available functions in hypothesis class. This setting, when hypothesis class does not contain any such powerful functions which can provide correct answers to the entire sequence of questions, is called unrealizable or agnostic case.

Online learning is performed in the sequence of rounds where in each round $t$, the learner is given a question $x_{t}$ and the learner is required to predict the answer $p_{t}$ to this question. After the learner has predicted the answer $p_{t}$, the right answer $y_{t}$ is revealed to the learner. Now, depending on the discrepancy between the predicted and right answer, learner suffers a loss $l(p_{t},y_{t})$. If learner suffers a loss i.e., it has made a wrong prediction, it is said to make a mistake. When the learner receives right answer, it tries to improve the prediction mechanism for further questions. Thus, the goal of the learner is to make as few mistakes as possible over the entire sequence of questions.

Algorithm 1 demonstrate a basic framework of online learning algorithm. In general, $\mathcal{D}$ and $\mathcal{Y}$ can be different. But when $\mathcal{D}=\mathcal{Y}=\{0,1\}$, we call it online classification. And in this case, naturally, we use 0-1 loss function: $l(x_{t},y_{t})=|p_{t}-y_{t}|$.

Applications of Online Learning

The following are some real life scenarios where online learning finds its applications. [1]

1. (i)

Online Ranking: Here, the learner is required to rank the given list of elements. The learner is given a query $x_{t}$ $\in$ $\chi$, where $x_{t}$ is a list of $k$ elements (e.g. Documents). The learner is required to order these $k$ elements. Clearly, in this case $\mathcal{D}$ is the set of all permutations of these $k$ elements $\{1\cdots k\}$. So learner predicts one permutation $p_{t}$ out of the set D based on its knowledge deduced from the previous queries. Then, the learner is given the right answer $y_{t}\in\mathcal{Y}=\{1\cdots k\}$. This right answer corresponds to the document which best matches the query. This is an application of online learning in web search where online learning is used to order the documents retrieved by a search system with respect to the user input query. Right answer in this case becomes the document (web page) which user clicks on finally. 2. (ii)

Prediction with expert advice: In this case, learner has a set of hypotheses $\mathcal{H}$ (e.g. experts or functions) and at each round, learner is required to predict the answer using one or some of these hypotheses from $\mathcal{H}$. Here, the challenge before learner is to use these experts intelligently so that it does not make more mistakes in the long run. To do it, learner uses the “reward when correct and penalize when wrong” policy to weigh the experts. 3. (iii)

Choosing the best page replacement algorithm: Operating system has many algorithms like FIFO, LRU, NRU etc to choose from to replace a page at any instance of time. Using a particular algorithm may not be optimal all the time. Because, the performance of different algorithms may vary depending on the current state of the system. Therefore, prediction with expert advice form of online learning can be used to choose best algorithm at $t^{th}$ instance of time. The available page replacement algorithms can be considered as a set of experts. These experts should be chosen intelligently by the learner to reduce the number of page faults in the long run. 4. (iv)

Online email spam filtering: This is another interesting application of online learning. In this case, learner is given an email feature vector $x_{t}$ and it is required to predict the label $\hat{y_{t}}\in\{0,1\}$ of email as spam or non-spam. Then, learner is given the correct label $y_{t}$ (marked spam or non-spam by the user) and thus learner updates its prediction mechanism for the next question.

I-B Basic Settings and Terminologies

This subsection discusses basic settings and terminologies of the online learning framework.[1]

1. (i)

Input sequence: Input sequence contains $T$ points, where $T$ is finite. Another very important point is that the questions (input points) cannot be stored to be used in future. Once the algorithm has predicted the answer, point has to be discarded. 2. (ii)

Binary classification: The algorithms given in this work assumes only two classes as class [math] and class $1$ i.e. $\mathcal{Y}=\{0,1\}$. 3. (iii)

No statistical assumption on input sequence: Classical statistical theory requires strong assumptions on statistical properties of data (e.g. sampled i.i.d. according to some unknown distribution.) But online learning does not require any statistical assumptions over the input sequence. A sequence can be deterministic, stochastic, or even adversarial adaptive to the learner’s prediction mechanism. Since learner tries to deduce the knowledge from the previous correct answers, there must be some correlation between the past and the present rounds (points). If not, an adversary can make all the predictions of the learner wrong by just giving the opposite answer to what the learner had predicted. Therefore, we restrict the adversary to decide the answer to input question before the learner predicts. 4. (iv)

Hypothesis class ($\mathcal{H}$): We assume that the learner is armed with a class of hypotheses (functions). Out of these, some or all are used to predict the answer to the input point $x_{t}$. This class can be finite or infinite. But in this work, we assume that $\mathcal{H}$ is finite. 5. (v)

Realizable case: The labels of the input sequence can always be assumed to be generated by a target hypothesis $h^{*}$ such that $h^{*}:\mathcal{X}\rightarrow\mathcal{Y}$. When this $h^{*}\in\mathcal{H}$, we say that input sequence is realizable by the hypothesis class $\mathcal{H}$. 6. (vi)

Unrealizable case (agnostic case): When we no longer assume that $h^{*}\in\mathcal{H}$, we say that input sequence is unrealizable by the hypothesis class $\mathcal{H}$. 7. (vii)

Mistake bound $M_{A}(H)$: In realizable case, mistake bound $M_{A}(H)$ is the maximal number of mistakes made by the algorithm $A$ on a sequence of examples which is generated by some $h^{*}\in\mathcal{H}$. Now, in this case objective is to design an algorithm which has minimal mistake bound $M_{A}(H)$. 8. (viii)

Regret bound: In unrealizable case, where we no longer assume that all the input points are labelled by some $h^{*}\in\mathcal{H}$, the number of mistakes made by the algorithm is compared with some best hypotheses $h\in\mathcal{H}$. This is termed as regret because this captures the regret of the algorithm, which measures how “sorry” the learner is, in retrospect, not to have followed the predictions of some hypothesis $h\in\mathcal{H}$. Formally, the regret of the algorithm relative to some $h\in\mathcal{H}$ when running on a sequence of $T$ points is defined as :

[TABLE]

And the regret of the algorithm relative to the hypothesis class $\mathcal{H}$ is

[TABLE]

In this case, objective becomes to design lowest possible regret algorithms. Low regret means $\text{Regret}_{T}(h)$ grows sub-linearly with $T$. i.e. $\text{Regret}_{T}(h)\rightarrow 0$ as $T\rightarrow\infty$. There are some other variations of these settings in online learning. For example, limited feedback [1], where after each round learner is given the loss value $l(p_{t},y_{t})$ but does not given the actual label $y_{t}$ of point $x_{t}$. Discussion about the algorithms in this setting is out of the scope of this work. 9. (ix)

Online learnability of hypothesis class $\mathcal{H}$: Let $\mathcal{H}$ be a hypothesis class and let $A$ be an online learning algorithm. Given any sequence $S=(x_{1},h^{*}(y_{1})),\cdots\cdots(x_{T},h^{*}(y_{T}))$, where $T$ is a finite integer and $h^{*}\in\mathcal{H}$, let $M_{A}(S)$ be the number of mistakes $A$ makes on the sequence $S$. We denote by $M_{A}(\mathcal{H})$ the supremum of $M_{A}(S)$ over all sequences of the above form. A bound of the form $M_{A}(\mathcal{H})\leq B\leq\infty$ is called a mistake bound. We say that a hypothesis class $\mathcal{H}$ is online learnable if there exists an algorithm $A$ for which $M_{A}(\mathcal{H})\leq B<\infty$. 10. (x)

Best hypotheses: $\mathcal{H}$ is the set of some hypotheses. Given an input sequence, if we use all of them one by one, some hypotheses may make more mistakes than the others. Then, those hypotheses which make least number of mistakes are called best hypotheses. There can be more than one such hypotheses. 11. (xi)

Ldim($\mathcal{H}$): This is a dimension of hypothesis classes that characterizes the best possible achievable mistake bound for a particular hypothesis class. This measure was proposed by Nick Littlestone [2] and referred to as Ldim($\mathcal{H}$). Before explaining Ldim($\mathcal{H}$), one definition needs to be given.

• Definition 1.1

$\mathcal{H}$** Shattered tree [1]:** A shattered tree of depth $d$ is a sequence of instances $(v_{1},v_{2},\cdots,v_{2^{d}-1})$ in $\mathcal{X}$ such that for all labelling $(y_{1},y_{2},\cdots$ $,y_{d})\in\{0,1\}^{d}$, $\exists\,h^{*}\in\mathcal{H}$ such that $\forall\,t\in\left[d\right]$ we have $h(v_{i_{t}})=y_{t}$, where $i_{t}=2^{t-1}+\sum\limits_{j=1}^{t-1}y_{j}2^{t-1-j}$.

• Definition 1.2

Littlestone’s dimension (Ldim($\mathcal{H}$)) [1]: Ldim($\mathcal{H}$) is the maximal integer $T$ such that there exist a shattered tree of depth $T$.

Ldim($\mathcal{H}$) is very crucial combinatorial measure in online learning as VC dim($\mathcal{H}$) [3] is in PAC learning [4] because it provides the lower bound on the number of mistakes in the realizable case as the following lemma states:

• Lemma 1.1

: No algorithm can have a mistake bound strictly smaller than Ldim($\mathcal{H}$), namely, $\forall A$, $M_{A}(\mathcal{H})\geq$ Ldim($\mathcal{H}$) [1].

Proof.

Let $T$ = Ldim($\mathcal{H}$) and let $v_{1},\cdots,v_{2^{T}-1}$ be a sequence that satisfies the requirements in the definition of Ldim. If the environment sets $x_{t}=v_{i_{t}}$ and $y_{t}=1-p_{t}$ $\forall t\in[T]$, then the learner makes $T$ mistakes while the definition of Ldim implies that there exists a hypothesis $h\in\mathcal{H}$ such that $y_{t}=h(x_{t})$ for all $t$.

∎

We have the following relation among Ldim($\mathcal{H}$), VC-dim($\mathcal{H}$) and $\text{log}_{2}(|\mathcal{H}|$).

• Lemma 1.2

: VC-dim($\mathcal{H})\leq$ Ldim($\mathcal{H})\leq\text{log}_{2}(|\mathcal{H}|)$ [1].

1. (a)

VC-dim($\mathcal{H})\leq$ Ldim($\mathcal{H})$ and this gap can be arbitrarily large.

Proof.

Suppose VC-dim($\mathcal{H})=d$ and let $x_{1},\cdots,x_{d}$ be a shattered set. We now construct a complete binary tree of instances $v_{1},\cdots,v_{2^{d}-1}$, where all nodes at depth $i$ are set to be $x_{i}$. Now, the definition of shattered sample clearly implies that we got a valid shattered tree of depth d, and we conclude that VC-dim($\mathcal{H})\leq$ Ldim($\mathcal{H})$.

Now the following example shows that the gap can be arbitrarily large.

Example 1.1 Let $\mathcal{X}=[0,1]$ and $\mathcal{H}=\{x\rightarrow\mathbf{1}_{[x\geq a]}:a\in[0,1]\}$, namely, $\mathcal{H}$ is the class of threshold on the segment $[0,1]$. Then, Ldim($\mathcal{H})=\infty$.

Here the gap between two quantities is infinity as $\mathcal{H}$ has Ldim = $\infty$ and VC-dim = $1$. ∎ 2. (b)

Ldim$(\mathcal{H})\leq\text{log}_{2}(|\mathcal{H}|)$

Proof.

Any tree that is shattered by $\mathcal{H}$ has depth at most $\text{log}_{2}(|\mathcal{H}|)$. Therefore

[TABLE]

. ∎

II Existing methodologies

In this section, we will be describing all the related methods to this work in the literature of online learning. Before we begin, let us state the goal of a learning algorithm in online learning framework.

In realizable case, a learner should have minimal mistake bound $M_{A}(H)$ and in agnostic case, it should have $\text{Regret}_{T}(\mathcal{H})$ growing sub-linearly with $T$. Here, sub-linear implies that the difference between the $average$ loss of the learner and the average loss of the best hypothesis in $\mathcal{H}$ tends to zero as $T$ goes to infinity.

Now, based on the size of hypothesis class and realizability/unrealizability of the input sequence by hypothesis class $\mathcal{H}$, all the available methods in online learning, in standard settings, can be divided into the following categories:

1. A.

Finite hypothesis class and realizable case 2. B.

Finite hypothesis class and unrealizable case 3. C.

Infinite hypothesis class and both realizable and unrealizable cases

We describe all the methods for each category one by one as follows (for A and B), except the last one (C) as it is out of scope of this work.

II-A Finite hypothesis class and realizable case

In this setting, we assume that all target labels are generated by some target hypotheses $h^{*}\in\mathcal{H}$ such that $y_{t}=h^{*}(x_{t}),\forall t$. We also assume that $|\mathcal{H}|$ is finite.

The following are three algorithms in this setting :

II-A1 Consistent

This is given in Algorithm 2. [1]

$Consistent$ algorithm is a basic algorithm which uses very naive approach to find best hypothesis. It chooses any hypothesis randomly from the available hypothesis set to predict the label of the point. But for the future rounds, it retains only those hypotheses which have predicted correctly till the current point. By this way, if the algorithm makes a mistake in any round, it discards at least one hypothesis from the hypothesis class $\mathcal{H}$. i.e. after making a mistake in $t^{\text{th}}$ round

[TABLE]

Analysis of Consistent

The $Consistent$ algorithm maintains a set, $V_{t}$, of all the hypotheses which are consistent with $(x_{1},y_{1}),\cdots,(x_{t−1},y_{t−1})$. This set is often called the version space. It, then, picks any hypothesis from $V_{t}$ and predicts according to this hypothesis. It is clear that whenever $Consistent$ makes a mistake; at least one hypothesis is removed from the $V_{t}$. So after making $M$ mistakes, $|V_{t}|=|\mathcal{H}|-M$.

Note that $\mathcal{H}$ is never empty because of the realizability assumption that $h^{*}\in\mathcal{H}$. So, in the worst case, $Consistent$ can make at most $|\mathcal{H}|-1$ mistakes and it will not make any mistake in the best case. The best case corresponds to the situation when the learner gets hold of the best hypothesis in the very beginning itself. Therefore, based on this discussion, we have the following corollary stating the mistake bound of the $Consistent$.

Corollary 0.1**.**

: Let $\mathcal{H}$ be a finite hypothesis class. The $Consistent$ algorithm enjoys the following mistake bound [1]

[TABLE]

II-A2 Halving

This is given in Algorithm 3. [1]

Analysis of Halving

In $Consistent$ algorithm, we just use arbitrary single hypothesis to predict the label. A better idea would be to take the majority vote and then decide. This will improve the chances of correct prediction and it will also enable us to discard at least half of the hypotheses if algorithm makes a mistake in any round.

At each round, it partitions the hypothesis class into two sets. One set consists of all those hypotheses which predict [math] and other contains those which predict $1$ for the given point $x_{t}$ in the $t^{th}$ round. Then, $Halving$ chooses prediction of the set which has larger cardinality. When correct answer is revealed to the learner, it discards the set whose prediction are not same as the correct answer. Thus at any round if algorithm makes a mistake, it can safely discard at least half of the hypotheses.

We have the following theorem stating the mistake bound of the $Halving$ algorithm :

Theorem 1**.**

Let $\mathcal{H}$ be a finite hypothesis class. The Halving algorithm enjoys the mistake bound $M_{halving}(H)\leq\text{log}_{2}(|\mathcal{H}|)$.[1]

Proof.

We simply note that whenever Halving makes a mistake we have $|V_{t+1}|\leq|V_{t}|/2$. Therefore, if $M$ is the total number of mistakes upto round $t$ then we have,

[TABLE]

Now rearranging the terms, we have

[TABLE]

[TABLE]

[TABLE]

∎

II-A3 Standard Optimal Algorithm (SOA)

This is given in Algorithm 4 .[1] :

Analysis of SOA

This is the optimal algorithm in the realizable setting. The idea is same as that of Halving. It also partitions the hypothesis class into two sets. One set consists of all those hypotheses which predict [math] and other contains those which predict $1$ on the given point $x_{t}$. Then, unlike Halving, it chooses prediction of the set which has larger $Ldim$ rather than the one with larger cardinality. When correct answer is revealed to the learner, it discards the set whose prediction are not same as the correct answer.

The following Lemma proves the optimality of SOA.

Lemma 2**.**

SOA enjoys the mistake bound $M_{SOA}(\mathcal{H})\leq Ldim(\mathcal{H})$.[1]

Proof.

It suffices to prove that whenever the algorithm makes a mistake, we have Ldim($V_{t+1})\leq\text{Ldim}(V_{t})-1$. We prove this claim by assuming the contrary, that is, Ldim($V_{t+1})=\text{Ldim}(V_{t})$. If this holds true, then the definition of $p_{t}$ implies that Ldim($V_{t}^{(r)})=\text{Ldim}(V_{t})$ for both $r=1$ and $r=0$. But, then we can construct a shattered tree of depth Ldim$(V_{t})+1$ for the class $V_{t}$, which leads to the desired contradiction. ∎

Combining Lemma 1.1 and Lemma 2, we obtain:

Corollary 2.1**.**

Let $\mathcal{H}$ be any hypothesis class. Then, the standard optimal algorithm enjoys the mistake bound $M_{SOA}(\mathcal{H})$ = Ldim($\mathcal{H}$) and no other algorithm $A$ can have $M_{A}(\mathcal{H})<\text{Ldim}(\mathcal{H})$ [1].

Table II summarizes all the available algorithms and their mistake bounds described above for finite hypothesis class and realizable case.

In all of the three algorithms described above, we have initialized $\eta$ by a fixed value which requires the value of $T$ to be known beforehand. But this is not necessary and can be fixed by using Doubling trick which can be found in the literature [1].

II-B Finite hypothesis class and unrealizable case

In the unrealizable case, we do not assume that all the labels are generated from some $h^{*}\in\mathcal{H}$. Rather, we assume that there are some better hypotheses in $H$ which make lesser mistakes than others. We analyse the mistake bound with respect to these hypotheses and term this mistake bound as regret bound.

The key goal of all the algorithms described above for realizable case was to find the best hypothesis and then predict using that only. Realizability assumption gave us the liberty of discarding hypotheses which made mistake even once. We could discard the hypotheses because once they make a mistake; they can never be the target hypothesis.

But in unrealizable case, there may not be such hypotheses; we cannot discard them just because they make mistake in one or some rounds. We will have to keep track of mistake count of all the hypotheses and make our prediction based on the performance of each hypothesis so far.

Even if $\mathcal{H}$ is finite, it can be arbitrarily large. If it is too large we cannot use all the hypotheses in consideration to make prediction. Therefore, based on this, there are two different algorithms for this setting.

II-B1 Prediction with expert advice: Weighted Majority (WM) Algorithm when $|\mathcal{H}|$ is finite

All the algorithms, described so far, were deterministic in their prediction. $Weighted\,Majority$ [5, 1] is a probabilistic algorithm which uses weighing mechanism to weigh each hypothesis based on their performance so far and treats their weights as a probability vector.

Let $\mathcal{H}=\{h_{1},h_{2},\cdots,h_{d}\}$. $Weighted\,Majority$ treats this class as set of experts which helps it predicting the answer to a given question $x_{t}$. This is given in Algorithm 5.

Analysis of Weighted Majority

Basically, $Weighted\,Majority$ assigns a weight $w\in[0,1]$ to each expert and keeps updating it based on the number of mistakes made by each expert upto current round.

When a point $x_{t}$ is received by the WM, it collects weights of all those experts which predict $1$ for this $x_{t}$ and accumulate these weights in a variable $p_{t}$. Then, it predict $1$ with probability $p_{t}$ (note that $p_{t}\in[0,1]$). When the true answer of $x_{t}$ is revealed to the algorithm, it updates the weights of each expert whichever made mistake on $x_{t}$.

The following theorem analyses the regret bound for the $Weighted\,Majority$ algorithm [1]:

Theorem 3**.**

Weighted Majority satisfies the following :

[TABLE]

Proof.

Refer to the Appendix A. ∎

This work is based on the construction of an algorithm to improve this bound in realizable case.

II-B2 Expert algorithm: When $|\mathcal{H}|$ is allowed to be infinite but Ldim($\mathcal{H}$) is finite

[1]

When $\mathcal{H}$ is allowed to be infinite, we cannot use each hypothesis in each round for deciding the prediction. But we assume that Ldim($\mathcal{H}$) is finite so that we can use SOA in some way.

Since we are assuming that $\mathcal{H}$ can be infinite and we cannot use each hypothesis in each round, the challenge therefore is to define a set of experts that on one hand is not excessively large while on the other hand contains an expert that gives accurate prediction.

Here, basic idea is to simulate each expert by running SOA algorithm on a small sub-sequence of points. We define an expert for each sequence of length $L<$= Ldim($\mathcal{H})$ and then use that constructed set of experts on that sub-sequence. Further details about this algorithm can be found in literature [1].

Table III summarizes all the available algorithms and their regret bounds described above for finite Ldim hypothesis class in unrealizable case.

II-C Infinite hypothesis class with realizable and unrealizable cases

This case is out of the scope of this work. However there are some algorithms like * Perceptron* and Winnow in this setting which can be found in the literature [6, 7, 8, 1].

III Proposed methodologies and Theoretical results

III-A Problem Statement and Objectives

As mentioned earlier, in the realizable case, we assume that all the labels are generated from some $h^{*}\in\mathcal{H}$. i.e. these $h^{*}$ does not make any mistake on the entire sequence of $T$ points. In the unrealizable (agnostic) case, we no longer assume this. However, we assume that there are some better hypotheses in $\mathcal{H}$ which make lesser mistakes than others.

In the literature, there are methods which are developed for both of these cases exclusively. It’s true that the methods which are developed for unrealizable case will also work for realizable case. But existing methods do not have much better bound if the input sequence is happened to be realizable in the end.

Since, in practice, we usually do not have any definite prior information about the realizability or unrealizability of the input sequence, we can not be sure about which algorithm to use over a given input sequence. Whether we should use $SOA$ which is optimal in realizable case or $Weighted\;Majority$ which is optimal in unrealizable case in standard settings. Also, we do not have liberty to reiterate over the input sequence in online learning framework and hence we can not try out existing algorithms one after the other to figure out which one we should have used!

Particularly, can we do somewhat better if we have some prior information about the realizability of input sequence? Especially, the scenario where we observe that the input sequence is likely to be realizable. We can not use $SOA$ because it will fail if sequence is found to be unrealizable. Also, It would not be efficient to use $Weighted\,Majority$ because it does not perform that better if sequence is found to be realizable. It does not have any fixed and better mistake bound in realizable case. Therefore, we would like to devise some methods which have fixed and better mistake bound in realizable case. That is, they should perform extremely well if sequence is found to be realizable and do not perform that bad if it happens to be unrealizable.

Thus, we begin with the following objectives:

1. (i)

Devise some methods for the finite hypothesis class which perform extremely well if input sequence is found to be realizable and do not perform that bad if input sequence is found to be unrealizable. In other words, we would like to develop some methods which improve the mistake bound in realizable case greatly while lose slightly in regret bound in unrealizable case. 2. (ii)

We would also like to get hold of the best hypotheses at the end of the sequence. This might be required for various reasons. For example, an application of learning algorithm might be just to find the best hypotheses in the class for a input sequence.

III-B Approach

If we observe the algorithms described in the section II-A for the finite hypothesis class and realizable case, the mistake bound does not depend on the length $T$ of the input sequence. It depends only on the size of the hypothesis class $|\mathcal{H}|$. Further, the $Weighted\;Majority$ algorithm described in section II-B enjoys the regret bound which depends on both $T$ and $|\mathcal{H}|$, no matter the input sequence is realizable or unrealizable. This is what that drives the idea of devising the proposed methods. Therefore, the proposed algorithms combine the approaches of existing algorithms presented in section II-A and II-B. The following section presents the proposed algorithms.

These new algorithms couple the $Weighted\,Majority$ algorithm with each of the algorithm described in section II-A, namely, $Consistent,\,Halving$ and $SOA$. They improves the bound quite much in the realizable case while do not lose that much in the unrealizable case.

For all the proposed algorithms, we make following assumptions:

1. (i)

$|\mathcal{H}|$ is finite and hence Ldim($\mathcal{H}$) is finite. 2. (ii)

Ldim$(\mathcal{H})<<T$

As already mentioned, the proposed algorithms couple the $Weighted\,Majority$ algorithm with each of the algorithm described in section II-A, namely, $Consistent$, $Halving$, and $SOA$. Therefore, we name them $WM\_Consistent$, $WM\_Halving$ and $WM\_SOA$ respectively. Out of the three proposed algorithms, $WM\_SOA$ is the best algorithm in terms of mistake and regret bounds. It is described in Algorithm 8.

III-C Proposed Methodologies

All the proposed methodologies are described in detail as follows.

1. (i)

$\mathbf{Weighted\,Majority\,with\,Consistent}$

The following algorithm combines the $Weighted\,Majority$ and $Consistent$ algorithms. This is the most basic algorithm out of the proposed three algorithms. Therefore, it does not have much better bound. However, it is still better than the $Weighted\,Majority$ in realizable case. The proposed algorithm is given in Algorithm 6.

Analysis of WM_Consistent

Let $T$ be the number of input points and $|\mathcal{H}|$ be the size of the hypothesis class. We assume that $|\mathcal{H}|$ is finite. The basic idea here is to use $Consistent$ algorithm in the beginning of the sequence. Since $Consistent$ algorithm discards all the hypothesis which predict wrong on any input point, we keep using the predictions of $Consistent$ until its current hypothesis class $V_{t}$ becomes empty. Depending on whether the sequence is realizable or not, there are following two cases to be considered:

Case 1: When input sequence is realizable by $\mathcal{H}$

From section II-A, Algorithm 2, we know that mistake bound of $Consistent$ algorithm is ($|\mathcal{H}|-1$). Therefore in the worst case, instance of $Consistent$ will make at most ($|\mathcal{H}|-1$) mistakes. Thereafter, it will not make any mistake.

Because of realizability assumption, even after processing $|\mathcal{H}|$ points, $V_{t}$ will not be empty and will contain at least one hypothesis. These are those hypotheses which realize the input sequence. There can be more than one such hypotheses. Hence, $Consistent$ portion will be continuing for the rest of the ($T-|\mathcal{H}|-1$) points and will not make any mistake further. Thus, in the realizable case the mistake bound of proposed algorithm is following :

[TABLE]

Case 2: When input sequence is not realizable by $\mathcal{H}$

When the input sequence is not realizable by the hypothesis class, the $Consistent$ portion of the algorithm will make at most $|\mathcal{H}|$ mistakes . Hence, in the worst case, till or before $|\mathcal{H}|$ points, $V_{t}$ will become empty and hereafter, $Weighted\,Majority$ will start predicting the $\hat{y_{t}}$.

Note that while $Consistent$ portion remains active, whenever algorithm makes any mistake, we simultaneously update the mistake count of each hypothesis. Once $V_{t}$ becomes empty and $Weighted\,Majority$ becomes active, $Weighted\,Majority$ receives the updated mistake count list of each hypothesis on the points seen so far. This gives $Weighted\,Majority$ the same state as if it was being used for predicting $\hat{y_{t}}$ from the very beginning.

This can be guaranteed that the point where $V_{t}$ becomes empty, mistake count of each hypothesis is at least 1. If not so, algorithm would have been continued using $Consistent$ with the hypothesis whose mistake count is [math]. This way, it helps $Weighted\,Majority$ portion of $WM\_Consistent$ to distribute the initial weights of each hypothesis based on its mistake count and weigh the advice of each hypothesis accordingly.

From the Theorem 3, we know that $Weighted\,Majority$ enjoys the following expected regret bound on a given input sequence of *length $T$ *

[TABLE]

After analysing the realizable and unrealizable cases above separately, we present the following theorem which presents the regret bound of the proposed $WM\_Consistent$ algorithm.

Theorem 4**.**

Algorithm 6 enjoys the following mistake and expected regret bound

1. (a)

In realizable case, mistake bound:

[TABLE] 2. (b)

In unrealizable case, Weighted Majority will receive the input sequence of length at least $(T-|\mathcal{H}|)$. Hence, the expected regret bound becomes following:

[TABLE]

[TABLE]

Proof.

Since the input sequence either be realizable or unrealizable, we have discussed the bounds in both of the cases separately and equation 1 and 2 clearly establish the above required bound.

∎

In the following subsection, we couple the $Weighted\,Majority$ with $Halving$ algorithm described in the Algorithm 3. 2. (ii)

$\mathbf{Weighted\,Majority\,with\,Halving}$

The proposed algorithm is given in Algorithm 7.

Analysis of WM_Halving

Let $T$ be the number of input points and $|\mathcal{H}|$ be the size of the hypothesis class. We assume that $|\mathcal{H}|$ is finite. The basic idea here is to use $Halving$ algorithm in the beginning of the sequence. Since $Halving$ algorithm discards at least half of the hypothesis once it makes any mistake, we keep using the predictions of $Halving$ until its current hypothesis class $V_{t}$ becomes empty. Depending on whether the sequence is realizable or not, there are following two cases to be considered:

Case 1 : When input sequence is realizable by $\mathbf{\mathcal{H}}$

From section II-A, Algorithm 3, we know that mistake bound of Halving algorithm is $\log_{2}(|\mathcal{H}|)$. Therefore, in the worst case, instance of Halving will make at most $\log_{2}(|\mathcal{H}|)$ mistakes. Thereafter, it will not make any mistake further.

Since in this case, even after processing $\log_{2}(|\mathcal{H}|)$ points, $V_{t}$ will not be empty and will contain at least one hypothesis. These are those hypotheses which realize the input sequence. Hence, $Halving$ portion will be continuing prediction for the rest of the ($T-\log_{2}(|\mathcal{H}|)$) points and will not make any mistake further. Thus, in the realizable case, the mistake bound of the proposed algorithm is following :

[TABLE]

Case 2 : When input sequence is not realizable by $\mathbf{\mathcal{H}}$

When the input sequence is not realizable by the hypothesis class, the $Halving$ portion of the algorithm will make at most $\log_{2}(|\mathcal{H}|)$ mistakes. In the worst case, till or before $\log_{2}(|\mathcal{H}|)$ points, $V_{t}$ will become empty and hereafter, $Weighted\,Majority$ will start predicting the $\hat{y_{t}}$.

Note that while $Halving$ portion remains active, whenever algorithm makes any mistake, we simultaneously update the mistake count of each hypothesis. Once $V_{t}$ becomes empty and $Weighted\,Majority$ becomes active, $Weighted\,Majority$ receives the updated mistake count list of each hypothesis on the points seen so far. This gives $Weighted\,Majority$ the same state as if it was being used for predicting $\hat{y_{t}}$ from the very beginning.

This can be guaranteed that the point where $V_{t}$ becomes empty, mistake count of each hypothesis is at least 1. If not so, algorithm would have been continued using $Halving$ with the hypothesis whose mistake count is [math]. This way, it helps $Weighted\,Majority$ portion of $WM\_Halving$ to distribute the initial weights of each hypothesis based on its mistake count and weigh the advice of each hypothesis accordingly.

From the Theorem 3, we know that $Weighted\,Majority$ enjoys the following expected regret bound on a given input sequence of *length $T$ *

[TABLE]

After analysing the realizable and unrealizable cases above separately, we present the following theorem which presents the regret bound of the proposed $WM\_Halving$ algorithm.

Theorem 5**.**

Algorithm 9 enjoys the following expected regret bound

1. (a)

In realizable case, mistake bound:

[TABLE] 2. (b)

In unrealizable case, Weighted Majority will receive the input sequence of length at least $(T-\log_{2}(|\mathcal{H}|)$. Hence, the expected regret bound becomes following:

[TABLE]

[TABLE]

Proof.

Since the input sequence either be realizable or unrealizable, we have discussed the bounds in both of the cases separately and equation 3 and 4 clearly establish the above required bound.

∎ 3. (iii)

$\mathbf{Weighted\,Majority\,with\,SOA}$

This algorithm enjoys the best expected regret bound. This comes from the fact that unlike $Halving$, it uses Ldim of the two different sets $V_{t}^{(0)}$ and $V_{t}^{(1)}$ and uses the set for prediction which has the larger Ldim. The proposed algorithm is given in the Algorithm 8.

Analysis of WM_SOA

Let $T$ be the number of input points and $|\mathcal{H}|$ be the size of the hypothesis class. We assume that $|\mathcal{H}|$ is finite. The basic idea here is to use $SOA$ algorithm in the beginning of the sequence. From Algorithm 4, we know that $SOA$ algorithm discards at least as many as Ldim($\mathcal{H}$) hypotheses whenever it makes a mistake (From the Lemma 1.2, we also know that Ldim$(\mathcal{H})\leq\text{log}_{2}(|\mathcal{H}|)$. We keep using the predictions of $SOA$ until its current hypothesis class $V_{t}$ becomes empty. Depending on whether the sequence is realizable or not, there are following two cases to be considered:

Case 1: When input sequence is realizable by $\mathbf{\mathcal{H}}$

From Lemma 2, we know that mistake bound of $SOA$ algorithm is Ldim$(\mathcal{H})$. Therefore, in the worst case, instance of $SOA$ will make at most Ldim$(\mathcal{H})$ mistakes. Thereafter, it will not make any mistake.

Since in this case, even after processing Ldim$(\mathcal{H})$ points, $V_{t}$ will not be empty and will contain at least one hypothesis. These are those hypotheses which realize the input sequence. Hence, $SOA$ portion will be continuing prediction for the rest of the ($T-\text{Ldim}(\mathcal{H})$) points and will not make any mistake further. Thus, in the realizable case the mistake bound of proposed algorithm is following :

[TABLE]

Case 2 : When input sequence is not realizable by $\mathbf{\mathcal{H}}$

When the input sequence is not realizable by the hypothesis class, the $SOA$ portion of the algorithm will make at most as many as Ldim$(\mathcal{H})$ mistakes. In the worst case, till or before Ldim$(\mathcal{H})$ points, $V_{t}$ will become empty and hereafter, $Weighted\,Majority$ will start predicting the $\hat{y_{t}}$.

Note that while $SOA$ portion remains active, whenever algorithm makes any mistake, we simultaneously update the mistake count of each hypothesis. Once $V_{t}$ becomes empty and $Weighted\,Majority$ becomes active, $Weighted\,Majority$ receives the updated mistake count list of each hypothesis on the points seen so far. This gives $Weighted\,Majority$ the same state as if it was being used for predicting $\hat{y_{t}}$ from the very beginning.

This can be guaranteed that the point where $V_{t}$ becomes empty, mistake count of each hypothesis is at least 1. If not so, algorithm would have been continued using $SOA$ with the hypothesis whose mistake count is [math]. This way, it helps $Weighted\,Majority$ portion of $WM\_SOA$ to distribute the initial weights of each hypothesis based on its mistake count and weigh the advice of each hypothesis accordingly.

From the Theorem 3, we know that $Weighted\,Majority$ enjoys the following expected regret bound on a given input sequence of length $T$

[TABLE]

After analysing the realizable and unrealizable cases above separately, we present the following theorem which presents the regret bound of the proposed $WM{\_}SOA$ algorithm.

Theorem 6**.**

Algorithm 9 enjoys the following expected regret bound

1. (a)

In realizable case:

[TABLE] 2. (b)

In unrealizable case, Weighted Majority will receive the input sequence of length at least $(T-\text{Ldim}(\mathcal{H}))$. Hence, the expected regret bound becomes following:

[TABLE]

[TABLE]

Proof.

Since the input sequence either be realizable or unrealizable, we have discussed the bounds in both of the cases separately and equation 5 and 6 clearly establish the above required bound. ∎

Our second objective was to get hold of best functions at the end of the sequence. It can be seen that it has also been achieved in all three proposed algorithms by keeping mistake count of each function. The functions which have least number of mistake count at the end; are best functions. Note that, in realizable case, the functions which have mistake count equals to 0 are best functions.

In this section, we described several methods for the finite hypothesis class and both realizable and unrealizable case settings. In particular, we presented three methods to improve the mistake bound for these setting using Weighted Majority with other methods picked up from finite hypothesis class and realizable case setting. Proposed methods do not improve the regret bound in general but they greatly improve the mistake bound for the realizable case while losing a little in unrealizable case.

Contributions

Firstly, table IV summarize the mistake and regret bounds of proposed algorithms and compare them with that of existing ones.

It can be observed that the mistake and regret bounds of $Weighted\,Majority$ are same. Proposed algorithms reduces the mistake bound by a large factor while lose very little in regret bound.

For example, In case of WM_SOA, the mistake bound is reduced from $\sqrt{0.5\,\ln(|\mathcal{H}|)\,T}$ to Ldim$(\mathcal{H})$ which is no more even a function of $T$. On the other hand, the regret bound is increased from $\sqrt{0.5\,\ln(|\mathcal{H}|)\,T}$ to just $\text{Ldim}(\mathcal{H})+\sqrt{0.5\,\ln(|\mathcal{H}|)\,(T-\text{Ldim}(\mathcal{H}))}$ with and additional quantity of $\text{Ldim}(\mathcal{H})$. Note that, with the assumption mentioned earlier that Ldim$(\mathcal{H})<<T$, this additional quantity does not incur much loss to the regret bound. Also note that, at the same time, the $\sqrt{T}$ term has also reduced to $\sqrt{(T-\text{Ldim}(\mathcal{H}))}$.

IV Simulations

This section gives supplementary backing to the results claimed in proposed methodologies in section three. Since implementation of all the three proposed algorithms is very much similar to that of one another and Algorithm 7 is easy to implement, we are going to simulate only this WM_Halving algorithm.

Although, the simulations presented in this chapter are neither necessary nor sufficient to prove bounds for any proposed algorithm. In fact, the performance of an online learning algorithms is analysed solely by theoretical proofs for mistake and regret bounds. Still, the simulations are presented in this chapter with the following objectives:

• •

To show that the proposed algorithms indeed conform to the given regret bound.

• •

To present a simple implementation scenario for the online learning framework.

For implementing proposed algorithms, we need the following :

1. (i)

Input sequence of $T$ labelled points (realizable or unrealizable by $\mathcal{H}$ based on the scenario under consideration) 2. (ii)

Finite hypothesis class $\mathcal{H}$

IV-A Construction of hypothesis class $\mathcal{H}$ and input sequence $S$:

This section describes the process of constructing hypothesis class and input sequence. This constructed input sequence may be realizable or unrealizable depending on the hypothesis class $\mathcal{H}$.

For implementation purpose, we need to generate both types of input sequences. To analyse the realizable case, we need to generate it in such a way that $\exists\,h^{*}\in\mathcal{H}$ such that

[TABLE]

We generate points $(x_{t},\,y_{t})$ of sequence S satisfying the following :

[TABLE]

and

[TABLE]

1. (i)

**Generating hypothesis class $\mathcal{H}$: **

Since we have $T$ many points and all $x_{t}\in[-T/2+1,\,T/2]$, the following is the way adopted for generating functions such that neither all of them make correct predictions on all the $x_{t}$’s (except the realizable case) nor all the functions make mistakes on all the $x_{t}$’s.

[TABLE]

That is, $i^{th}$ function will assign label [math] to all the $x_{t}$’s which are $\leq i$ and assigns $1$ to all those $x_{t}$’s which are greater than $i$. Naturally, $i$ is an integer and should lie in $\left[1,d\right]$, where $d$ is the number of functions in hypothesis class (i.e. $d=|\mathcal{H}|$) and for this example $d\leq T$

So our hypothesis class becomes the set of these $h_{i}$’s:

[TABLE]

where $h_{i}$ is defined in eq 7. 2. (ii)

Generating input sequence $S$ labeled by some $h$:

We will generate realizable and unrealizable sequences $S$ of length $T$ in the following way.

1. (a.)

Constructing Realizable Sequence: For realizable sequence, we have generated the labels of $x_{t}$’s of sequence $S$ using a hypothesis $h^{*}$ defined below:

[TABLE]

That is, it assigns label [math] to all non positive points and label $1$ to all positive points. Table V demonstrate an example of a sequence generated by the function in equation 9 with $T=8$.

So the sequence is

[TABLE]

Note that $h_{0}$ defined in eq (9) realizes this sequence.

Table VII shows the prediction of each function in $\mathcal{H}$ constructed by equation 8 with $d=5$ over the sequence defined in eq (10).

In this table, $M(h_{i})$ denotes the total number of mistakes made by the hypothesis $i$ on the entire sequence $S$. (Red coloured number shows the wrong prediction.)

It can be seen that $h_{0}$ does not make any mistake. Hence, it realizes the sequence S. 2. (b.)

Constructing Unrealizable Sequence: To obtain an unrealizable sequence, labels of $x_{t}$’s of sequence $S$ are generated by the following function.

[TABLE]

That is, it assigns label $1$ to all the points. Since some $x_{t}$’s of the sequence are negative and some of them are positive and neither function in our constructed hypothesis class $\mathcal{H}$ provides the label $1$ to all the $x_{t}$’s of the sequence, this sequence will never be realizable by our $\mathcal{H}$.

Table VI presents an example of a sequence generated by the function in equation 11 with $T=8$.

IV-B *Simulation of WM_Halving Algorithm *

As already mentioned, we are going to simulate only Algorithm 7 named WM_Halving. From theorem 5, Algorithm 7 enjoys the following bounds:

1. (a)

In realizable case:

[TABLE] 2. (b)

In unrealizable case:

[TABLE]

[TABLE]

[TABLE]

In unrealizable case, we analyse the ”expected” regret bound of learner which can be described in terms of expected mistake bound as follows :

$\mathbf{Expected\,number\,of\,mistakes}$

[TABLE]

$\mathbf{Expected\,Regret=Expected\,number\,of}$

$\mathbf{mistakes-\,Number\,of\,mistakes\,made\,by\,best}$ $\mathbf{functions}$

Here, we are interested in “expected” regret bound of the learner. Then, naturally, we need to count mistakes made by the learner over all possible permutations of an input sequence. It is extremely time consuming or in fact computationally infeasible to check the expected mistake count of any learning algorithm over all possible sequences of a long input sequence. Therefore, we have computed expected mistakes count on all possible permutations of very short sequence (e.g. $T=8\;\text{or}\;9$) as well as we have also generated few random permutations of a long input sequence (when $T\sim 1000\,\text{or}\,10,000$).

Simulation results

This section presents the simulation results for the realizable and unrealizable cases separately.

1. (a.)

Realizable case:

In realizable case, we assume that $\exists\,h^{*}\in\mathcal{H}$ such that

[TABLE]

hence,

[TABLE]

But depending on the order in which points of input sequence are presented to the algorithm, algorithm can make any number of mistakes ranging from 0 to $\log({\mathcal{H}})$. i.e.

[TABLE]

These mistakes are essentially the mistakes made by the algorithm to find that best hypothesis $h^{*}$.

Table VIII presents some simulation results where sequence $S$ is realizable by the constructed hypothesis class $\mathcal{H}$ defined in equation 8.

Observations

It can be seen that there is huge difference between the maximum mistakes made by $Weighted\,Majority$ and $WM{\_}Halving$ in realizable case and $WM{\_}Halving$ algorithm really outperforms in this case. 2. (b.)

Unrealizable case:

In unrealizable case, we analyse the regret bound rather than the mistake bound. In other words, regret bound is essentially a mistake bound when mistakes are counted w.r.t the best hypothesis in the class.

Table IX presents some simulation results where sequence $S$ is not realizable by the constructed hypothesis class $\mathcal{H}$ defined in equation 8.

Observations

If we observe the values in ”$Diff$” column in table IX and compare the ”$Diff$” values from table VIII, we see that we are still gaining very minimal or at least not loosing anything in the unrealizable case. But, in general, we are not guaranteed to gain anything in the unrealizable case using the proposed algorithms as stated in Theorem 5. This unexpected gain shows that, in general, we will lose very little in the unrealizable case.

Note that regret values in this table are obtained by subtracting mistakes of best expert from the total mistakes made by the algorithms. i.e.

[TABLE]

[TABLE]

$\textbf{in}\;\mathcal{H}.$

For example, expected regret of WM in the first row is actually $500+36.15=536.15$

V Conclusion and Future work

In this work, we proposed three algorithms for the finite hypothesis class and both realizable and unrealizable cases. Proposed algorithms are designed by coupling the existing best algorithms available for realizable and unrealizable cases.

The motivation behind proposed algorithms was to reduce the mistakes which $Weighted\,Majority$ makes in realizable case. Because, no matter the sequence is realizable or not, the expected regret bound was same. This was exploited by running $Weighted\,Majority$ in parallel. By doing so, if the input sequence is found to be realizable, algorithm will make very less mistake. If not, then we updated mistake count of each function in parallel which helped $Weighted\,Majority$ take over later on and predict optimally thereafter.

The major contribution of this work is to propose algorithms which perform really outstanding in realizable case but slightly worse in unrealizable case. This nature of performance of the proposed algorithms is very useful in the scenarios where we are likely to get realizable input sequences. If input sequences are likely to be realizable than proposed algorithms will always be far better than the existing ones.

The way in which $Weighted\,Majority$ runs in parallel indicates the scope of further improvement in theoretical bound of proposed algorithms in the unrealizable case. Further, the same approach has the potential to be applied in the other setting also of online learning; such as limited feedback model, stochastic noise model etc.

Acknowledgements

First of all, we would like to thank the Almighty, who has always guided us to work on the right path of the life. We are also thankful to the entire faculty and staff members of Indian Statistical Institute (ISI) for their direct-indirect help, cooperation, love and affection.

Last but not the least, we would like to thank our family without whose blessings none of this would have been possible.

Appendix A Proof of the Weighted Majority Algorithm [1], [5]

Theorem 7**.**

Weighted Majority satisfies the following:

[TABLE]

Proof.

[1] The algorithm maintains the number of prediction mistakes each expert made so far in $M_{i}^{t-1}$ , and assign a probability weight to each expert accordingly. Then, the learner sets $\hat{p_{t}}$ to be the total mass of the experts which predict 1. The definition of $\hat{y_{t}}$ clearly implies that

[TABLE]

That is, the probability to make a mistake equals to the expected error of experts in $t^{th}$ round, where expectation is with respect to the probability vector $\mathbf{w}^{t}$.

Now, we begin the proof.

Define $Z_{t}=\sum_{i}e^{-\eta M_{i}^{t}}$. We have

[TABLE]

[TABLE]

Note that $\mathbf{w}^{t}$ is a probability vector and $\mathbf{1}[h_{i}^{t}(x_{t})\neq y_{t}]\in[0,1]$. Therefore, we can apply Hoeffding’s inequality on the right-hand side of the above to get

[TABLE]

where the last equality follows from Eq. 12. Summing the above inequality over t we get

[TABLE]

Next, we note that $\ln(Z_{0})=\ln(d)$ and that

[TABLE]

Substituting the values of $\ln(Z_{T})$ and $\ln(Z_{0})$ in Eq. 13

[TABLE]

Dividing both sides by $\eta$ and rearranging the terms, we get

[TABLE]

Putting $\eta=\sqrt{8\ln(d)/T}$, we get the desired result

[TABLE]

∎