ECLR - User contributions [en]

Probability Intro

2022-06-02T09:59:18Z

Rb:

= Introducing Probability =

So far we have been looking at ways of summarising samples of data drawn from an underlying population of interest. Although at times tedious, all such arithmetic calculations are fairly mechanical and straightforward to apply. To remind ourselves, one of the primary reasons for wishing to summarise data is so assist in the development of inferences about the population from which the data were taken. That is to say, we would like to elicit some information about the mechanism which generated the observed data.

We now start on the process of developing mathematical ways of formulating inferences and this requires the use of ''probability''. This becomes clear if we think back to one of the early questions posed in this course: ''prior to sampling is it possible to predict with absolute certainty what will be observed''? The answer to this question is ''no''; although it would be of interest to know how ''likely'' it is that certain values would be observed. Or, what is the ''probability'' of observing certain values?

Before proceeding, we need some more tools:

= Venn diagrams =

Venn diagrams (and diagrams in general) are of enormous help in trying to understand, and manipulate probability. We begin with some basic definitions, some of which we have encountered before.

* '''Experiment:''' any process which, when applied, provides data or an outcome; e.g., rolling a die and observing the number of dots on the upturned face; recording the amount of rainfall in Manchester over a period of time.
* '''Sample Space:''' set of possible outcomes of an experiment; e.g., <math>S</math> (or <math>\Omega </math>) <math>=</math> <math>\{1,2,3,4,5,6\}</math>, which is the sample space of rolling a dice. Or <math>S</math> <math>=</math> <math>\{x;x\geq 0\}</math>, which is the sample space of an experiment where the outcomes can be any real non-negative number, or ‘''the set of real non-negative real numbers''’.
* '''Simple Event''': just one of the possible outcomes on <math>S</math>
* '''Event:''' a ''subset'' of <math>S</math>, denoted <math>E\subset S</math>; e.g., <math>E=\left\{ 2,4,6\right\}</math> (i.e. any even number on a dice) or <math>E=\left\{ x;4<x\leq 10\right\} ,</math> which means ‘''the set of real numbers which are strictly bigger than'' <math>4</math> ''but less than or equal to ''<math>10</math>’. Note that an event, <math>E</math>, is a collection of simple events.

Such concepts can be represented by means of the following Venn Diagram:

[[File:Venn_1.jpg|frameless|600px]]

The sample space, <math>S,</math> is depicted as a closed rectangle, and the event <math>E</math> is a closed loop wholly contained within <math>S</math> and we write (in set notation) <math>E\subset S</math>.

In dealing with probability, and in particular the probability of an event (or events) occurring, we shall need to be familiar with '''UNIONS, INTERSECTIONS''' and '''COMPLEMENTS'''.

To illustrate these concepts, consider the sample space <math>S=\{x;x\geq 0\},\,</math> with the following events defined on <math>S,</math> as depicted in Figure 3.2:

<math>E=\{x;4<x\leq 10\},\,F=\{x;7<x\leq 17\},\,G=\{x;x>15\},\,H=\{x;9<x\leq
13\}. </math>

{| class="wikitable"
|-
| (a) Event <math>E</math>: A subset
| (b) Union: <math>E\cup F</math>
|-
| [[File:Venn_2a.jpg|frameless|300px]]
| [[File:Venn_2b.jpg|frameless|300px]]
|-
| (c) Intersection: <math>E\cap F</math>
| (d) The Null set/event: <math>E\cap G=\emptyset </math>
|-
| [[File:Venn_2c.jpg|frameless|300px]]
| [[File:Venn_2d.jpg|frameless|300px]]
|-
| (e) Complement of <math>E</math>: <math>\bar{E}</math>
| (f) Subset of <math>F</math>: <math>H\subset F</math> and <math>H\cap F=H</math>
|-
| [[File:Venn_2e.jpg|frameless|300px]]
| [[File:Venn_2f.jpg|frameless|300px]]
|}

* The ''union'' of <math>E</math> and <math>F</math> is denoted <math>E\cup F,</math> with <math>E\cup F=\{x;4<x\leq 17\};</math> i.e., it contains elements (simple events) which are either in <math>E</math> or in <math>F</math> or (perhaps) in both. This is illustrated on the Venn diagram by the dark shaded area in diagram (b).
* The'' intersection'' of <math>E</math> and <math>F</math> is denoted <math>E\cap F,</math> with <math>E\cap F=\left\{ x;7\leq x\leq 10\right\} ;</math> i.e., it contains elements (simple events) which are common to both <math>E</math> and <math>F.</math> Again this is depicted by the dark shaded area in (c). If events have no elements in common (as, for example, <math>E</math> and <math>G</math>) then they are said to be ''mutually exclusive'', and we can write <math>E\cap G=\emptyset ,</math> meaning the ''null set'' which contains no elements. Such a situation is illustrated on the Venn Diagram by events (the two shaded closed loops in (d)) which do not overlap. Notice however that <math>G\cap F\neq \emptyset ,</math> since <math>G</math> and <math>F</math> have elements in common.
* The ''complement'' of an event <math>E,</math> say, is everything defined on the sample space which is not in <math>E.</math> This event is denoted <math>\bar{E}</math>, the dark shaded area in (e); here <math>\bar{E}=\left\{ x;x\leq 4\right\} \cup \left\{ x;x>10\right\}</math>.
* Finally note that <math>H</math> is a sub-set of <math>F;</math> see (f). It is depicted as the dark closed loop wholly contained within <math>F,</math> the lighter shaded area, so that <math>H\cap F=H;</math> if an element in the sample space is a member of <math>H</math> then it must also be member of <math>F.</math> (In mathematical logic, we employ this scenario to indicate that “<math>H</math> implies <math>F</math>”, but not necessarily vice-versa.) Notice that <math>G\cap H=\emptyset </math> but <math>H\cap E\neq \emptyset</math>.

= Probability =

The term ''probability'' (or some equivalent) is used in everyday conversation and so can not be unfamiliar to the reader. We talk of the probability, or chance, of rain; the likelihood of England winning the World Cup; or, perhaps more scientifically, the chance of getting a <math>6</math> when rolling a die. What we shall now do is develop a coherent theory of probability; a theory which allows us to combine and manipulate probabilities in a consistent and meaningful manner. We shall describe ways of dealing with, and describing, uncertainty. This will involve ''rules'' which govern our use of terms like probability.

There have been a number of different approaches (interpretations) of probability. Most depend, at least to some extent, on the notion of relative frequency as now described:

* Suppose an experiment has an outcome of interest <math>E</math>. The ''relative frequency interpretation'' of probability says that assuming the experiment can be repeated a large number of times then the relative frequency of observing the outcome <math>E</math> will settle down to a ''number'', denoted <math>\Pr (E),</math> <math>P(E)</math> or Prob<math>(E),</math> called the '''probability''' of <math>E</math>.

This is illustrated in the next Figure where the proportion of heads obtained after <math>n</math> flips of a fair coin is plotted against <math>n</math>, as <math>n</math> increases; e.g., of the first 100 flips, 46 were heads (<math>46\%</math>). Notice that the plot becomes less ‘wobbly’ after about <math>n=</math>140 and appears to be settling down to the value of <math>\frac{1}{2}</math>.

[[File:Prob_coin.jpg|frameless|600px]]

Due to this interpretation of probability, we often use observed sample proportions to approximate underlying probabilities of interest; see, for example, Question 4 of Exercise 2. There are, of course, other interpretations of probability; e.g., the subjective interpretation which simply expresses the strength of one’s belief about an event of interest such as whether Manchester United will win the European Cup! Any one of these interpretations can be used in practical situations provided the implied notion of probability follows a simple set of ''axioms'' or ''rules''.

== The axioms of probability ==

There are just ''three ''basic rules that must be obeyed when dealing with probabilities:

<ol>
<li>For any event <math>E</math> defined on <math>S,</math> i.e., <math>E\subset S,\,\,\Pr (E)\geq 0</math>; ''probabilities are non-negative''.</li>
<li><math>\Pr (S)=1;</math> ''having defined the sample space of outcomes, one of these outcomes must be observed''.</li>
<li>If events <math>E</math> and <math>F</math> are mutually exclusive defined on <math>S</math>, so that <math>E\cap F=\emptyset </math>, then <math>\Pr \left( E\cup F\right) =\Pr \left( E\right)+\Pr \left( F\right) .</math> In general, for any set of mutually exclusive events, <math>E_{1},E_{2},\ldots ,E_{k},</math> defined on <math>S:</math>
<math>\Pr (E_{1}\cup E_{2}\cup \ldots \cup E_{k})=\Pr (E_{1})+\Pr (E_{2})+\ldots\Pr (E_{k})</math>
i.e., <math>\Pr \left( \bigcup_{j=1}^{k}E_{j}\right) =\sum_{j=1}^{k}\Pr (E_{j}).</math></li></ol>

In terms of the Venn Diagram, one can (and should) usefully think of the area of <math>E,</math> relative to that of <math>S,</math> as providing an indication of probability. (Note, from axiom 2, that the area of <math>S</math> is implicitly normalised to be unity).

Also observe that, contrary to what you may have believed, it is not one of the rules that <math>\Pr (E)\leq 1</math> for any event <math>E</math>. Rather, this is an implication of the <math>3</math> rules given:

* '''implications: '''it must be that for any event <math>E,</math> defined on <math>S</math>, <math>E\cap \bar{E}=\emptyset </math> and <math>E\cup \bar{E}=S.</math> By Axiom <math>1,</math> <math>\Pr (E)\geq 0</math> and <math>\Pr \left( \bar{E}\right) \geq 0</math> and by Axiom <math>3</math> <math>\Pr(E)+\Pr (\bar{E})=\Pr (S).</math> So <math>\Pr \left( E\right) +\Pr \left( \bar{E}\right) =1,</math> by Axiom <math>2.</math> This implies that

# <math>0\leq \Pr (E)\leq 1</math>
# <math>\Pr (\bar{E})=1-\Pr (E)</math>

The first of these is what we might have expected from probability (a number lying between <math>0</math> and <math>1</math>). The second implication is also very important; it says that the probability of <math>E</math> not happening is ‘''one minus the probability of it happening''’. Thus when rolling a die, the probability of getting <math>6</math> is one minus the probability of getting either a <math>1</math>, <math>2</math>, <math>3</math>, <math>4</math> or <math>5.</math>

These axioms imply how to calculate probabilities on a sample space of equally likely outcomes. For example, and as we have already noted, the experiment of rolling a fair die defines a sample space of six, mutually exclusive and equally likely outcomes (<math>1</math> to <math>6</math> dots on the up-turned face). The axioms then say that each of the six probabilities are positive, add to 1 and are all the same. Thus, the probability of any one of the outcomes must be simply <math>\frac{1}{6};</math> which may accord with your intuition. A similar sort of analysis reveals that the probability of drawing a club from a deck of <math>52</math> cards is <math>\frac{13}{52},</math> since any one of the <math>52</math> cards has an equal chance of being drawn and <math>13</math> of them are clubs; i.e., <math>13</math> of the <math>52</math> are clubs, so the probability of drawing a club is <math>\frac{13}{52}.</math> Notice the importance of the assumption of equally likely outcomes here.

In this, and the next section of notes, we shall see how these axioms can be used. Firstly, consider the construction of a probability for the ''union'' of two events; i.e., the probability that ''either ''<math>E</math> or <math>F</math> or (perhaps) ''both ''will occur. Such a probability is embodied in the ''addition rule of probability''.

== The addition rule of probability ==

When rolling a fair die, let <math>E</math> denote the event of an “odd number of dots” and <math>F</math> the event of the “number of dots being greater than, or equal, to <math>4</math>”<math>.</math> What is the probability of the event <math>E\cup F</math>? To calculate this we can collect together all the mutually exclusive (simple) events which comprise <math>E\cup F</math>, and then add up the probabilities (by axiom 3). These simple events are <math>1,3,4,5</math> or <math>6</math> dots. Each has a probability of <math>\frac{1}{6},</math> so the required total probability is: <math>\Pr \left( E\cup F\right) =\frac{5}{6}</math>. Consider carefully how this probability is constructed and note, in particular, that <math>\Pr \left( E\cup F\right) \neq \Pr \left( E\right) +\Pr \left( F\right) </math> since <math>E</math> and <math>F</math> have a simple event in common (namely <math>5</math> dots).

In general, we can calculate the probability of the union of events using the ''addition rule of probability'', as follows.

* For any events, <math>E\subset S</math> and <math>F\subset S:\Pr (E\cup F)=\Pr (E)+\Pr (F)-\Pr (E\cap F).</math> So, in general, <math>\Pr \left( E\cup F\right) \leq \Pr (E)+\Pr (F).</math>

This generalises to three events, <math>E_{1},E_{2}</math> and <math>E_{3}</math> as

<math>\begin{aligned}
\Pr (E_{1}\cup E_{2}\cup E_{3}) &=&\Pr (E_{1})+\Pr (E_{2})+\Pr (E_{3}) \\
&&-\Pr (E_{1}\cap E_{2})-\Pr (E_{1}\cap E_{3})-\Pr (E_{2}\cap E_{3}) \\
&&+\Pr (E_{1}\cap E_{2}\cap E_{3}).\end{aligned}</math>

We can demonstrate this as follows.

Note that

<math>E\cup F=\left( E\cap \bar{F}\right) \cup \left( E\cap F\right) \cup \left(\bar{E}\cap F\right)</math>

the union of <math>3</math> mutually exclusive events. These mutually exclusive events are depicted by the shaded areas <math>\mathbf{a,}</math> <math>\mathbf{b}</math> and <math>\mathbf{c}</math>, respectively, in the next Figure.

[[File:Prob_add.jpg|frameless|500px]]

Then by Axiom <math>3</math>, and from the fact that the three events <math>\left( E\cap\bar{F}\right) </math>, <math>\left( E\cap F\right) </math> and <math>\left( \bar{E}\cap F\right)</math> are mutually exclusive so that the “area” occupied by <math>E\cup F</math> is simply <math>\mathbf{a+b+c,}</math>

<math>\Pr \left( E\cup F\right) =\Pr \left( E\cap \bar{F}\right) +\Pr \left( \bar{E}\cap F\right) +\Pr \left( E\cap F\right) .</math>

But also by Axiom <math>3</math>, since <math>E=\left( E\cap \bar{F}\right) \cup \left(E\cap F\right) </math>, it must be that <math>\Pr (E)=\Pr \left( E\cap \bar{F}\right)+\Pr (E\cap F);</math> similarly, <math>\Pr \left( \bar{E}\cap F\right) =\Pr \left(F\right) -\Pr \left( E\cap F\right)</math>. Putting all of this together gives

<math>\Pr (E\cup F)=\Pr (E)+\Pr (F)-\Pr (E\cap F).</math>

When <math>E</math> and <math>F</math> are mutually exclusive, so that <math>E\cap F=\emptyset</math>, this rule reveals Axiom 2: <math>\Pr (E\cup F)=\Pr (E)+\Pr (F)</math>.

<ul>
<li>''Example: ''What is the probability of drawing a Queen (<math>Q </math>) or a Club (<math>C</math>) in a single draw from a pack of cards? Now, <math>4</math> out of <math>52 </math> cards are Queens, so <math>\Pr \left( Q\right) =\frac{4}{52},</math> whilst <math>\Pr\left( C\right) =\frac{13}{52}.</math> The probability of drawing the Queen of Clubs is simply <math>\frac{1}{52};</math> i.e., <math>\Pr \left( Q\cap C\right) =\frac{1}{52}</math>. What we require is a Club or a Queen, for which the probability is
<math>\begin{aligned}
\Pr \left( Q\cup C\right) &=&\Pr \left( Q\right) +\Pr \left( C\right) -\Pr\left( Q\cap C\right) \\
&=&\frac{4}{52}+\frac{13}{52}-\frac{1}{52} \\
&=&\frac{16}{52}=\frac{4}{13}.\end{aligned}</math></li>
<li>''Example: ''Consider a car journey from Manchester to London via the M6 and M1. Let <math>E=</math> ''heavy traffic somewhere on route'' and <math>F=</math> ''roadworks somewhere on route''. It is estimated that <math>\Pr (E)=0.8</math> and <math>\Pr (F)=0.4,</math> whilst the probability of NOT encountering both is <math>\Pr (\overline{E\cap F})=0.6.</math> What is the probability of encountering heavytraffic or roadworks?
We require <math>\Pr \left( E\cup F\right) .</math>
<math>\begin{aligned}
\Pr (E\cup F) &=&\Pr (E)+\Pr (F)-\Pr (E\cap F) \\
&=&\Pr (E)+\Pr (F)-(1-\Pr (\overline{E\cap F})) \\
&=&0.8+0.4-1+0.6 \\
&=&0.8=\Pr (E)\end{aligned}</math>
Notice that this implies, in this case, that <math>F\subset E</math> (why?). This ''model ''then implies that when there are roadworks somewhere on route you are bound to encounter heavy traffic; on the other hand, you can encounter heavy traffic on route without ever passing through roadworks. (My own experience of this motorway inclines me towards this implication!)</li></ul>

Similar concepts apply when manipulating proportions as follows:

<ul>
<li>''Example'': A sample of 1000 undergraduates were asked whether they took either Mathematics, Physics or Chemistry at A-level. The following responses were obtained: 100 just took Mathematics; 70 just took Physics; 100 just took Chemistry; 150 took Mathematics and Physics, but not Chemistry; 40 took Mathematics and Chemistry, but not Physics; and, 240 took Physics and Chemistry, but not Mathematics. What proportion took all three?
This can be addressed with the following diagram:
[[File:Prob_Alevels.jpg|frameless|500px]]
The shaded area contains the number who took all three, which can be deduced from the above information (since the total of the numbers assigned to each part of the Venn diagram must be <math>1000</math>). The answer is therefore <math>30\%</math> (being <math>300</math> out of <math>1000</math>).</li>
<li>Two further results on unions, intersections and complements which are of use (and which are fairly easy to demonstrate using Venn diagrams) are '''de Morgan Laws''':
<ul>
<li><math>\left( \bar{A}\cap \bar{B}\right) =\left( \overline{A\cup B}\right) </math></li>
<li><math>\bar{A}\cup \bar{B}=\left( \overline{A\cap B}\right) </math></li></ul>
</li></ul>

= Additional resources =

Khan Academy

* Basic Probability and Venn Diagram [https://www.khanacademy.org/math/probability/independent-dependent-probability/addition_rule_probability/v/probability-with-playing-cards-and-venn-diagrams]
* Addition Rule [https://www.khanacademy.org/math/probability/independent-dependent-probability/addition_rule_probability/v/addition-rule-for-probability]

= Footnotes =

MATLAB

2022-02-08T08:43:07Z

Rb: /* Special Econometric Topics */

== <div id="Essential"></div>The Essential MATLAB Programming Techniques ==

In this section we will introduce a number of basic and intermediate programming techniques. Whatever language you program in you will encounter these techniques, although the details will, of course, vary. We recommend that you ensure that you are familiar with these before you progress to [[#SpecEcmtrTopics| Special Econometric Topics ]].

=== Basic Programming ===

{| class="wikitable"
|-
! scope="col"| Basics and Matrices
! scope="col"| Loading Data and Date Formats
! scope="col"| Program Flow and Logicals
! scope="col"| Functions
! scope="col"| Saving Data and Screen Output
|-
| [[Discussion]] [http://www.youtube.com/watch?v=av5MgVpybT0&feature=youtu.be&hd=1 Example Clip]
| [[LoadingData|Discussion]] [http://youtu.be/jyb68zGM2ik?hd=1 ExampleClip]
| [[Program Flow and Logicals|Discussion]]
| [[Function|Discussion]] [[FctExampleCode|Example Code]] [[media:OLSexample.xls|OLSexample.xls]] [http://youtu.be/FPw9DH8pfiU?hd=1 Example Clip]
| [[SavingData|Discussion]]
|}

After having gone through these basic techniques you may want to test your newly acquired skills with the following examples.

{| class="wikitable"
|-
! scope="col"| Example 1
! scope="col"| Example 2
|-
| [[Example 1]]
| [[Example 2|Example2a]] [[Example 2b|Example2b]]
|}

=== Intermediate Programming ===

{| class="wikitable"
|-
! scope="col"| Statistical Functions
! scope="col"| Arrays and Structures
! scope="col"| Debugging
! scope="col"| Graphing Data
! scope="col"| Function Handlers Anonymous Functions
|-
| [[StatFunct|Discussion]]
| [[ArrayStructures|Discussion]]
| coming soon
| [[Graphing|Discussion]]
| [[Anonym|Discussion]]
|}

=== Advanced Programming ===

Sorry, but this cannot be taught! It will come with experience. Find someone who has experience in MATLAB programming and let him or her look over your code.

== Nonlinear Optimisation ==

The optimal parameters in a linear econometric model (assuming certain assumptions) can be found analytically. We call them the Ordinary Least Squares (OLS) estimates and they are easily calculated with a certain formula (see the [[FctExampleCode#OLSestm|OLSest.m]] function). When econometric models do not have such an analytical solution, an alternative parameter estimation strategy is required. In essence it is a clever "trial and error" strategy. This is often called nonlinear optimisation.

Nonlinear optimisation is a very important, but also a very tricky area of econometric computing. It certainly helps to understand some of the underlying theory and therefore we have below separate sections on the theory and implementation.

{| class="wikitable"
|-
! scope="col"| Theory
! scope="col"| Implementation
! scope="col"| Constrained Optimisation
|-
| [[NonlinOptTheory| Discussion]]
| [[NonlinOptImp| Discussion]]
| [[ConNonlinOptImp| Discussion]]
|}

== <div id="SpecEcmtrTopics"></div> Special Econometric Topics ==

Topics in this Section will assume that you have mastered all the techniques covered in the [[#Essential| Essential Programming Section ]]

{| class="wikitable"
|-
! scope="col"| Robust standard errors
! scope="col"| Univariate Time Series
! scope="col"| Unit Root and Stationarity Testing
! scope="col"| Forecasting
|-
| [[RobInf|Discussion]] [[ExampleCodeOLShac|Example Code]]
| [[UniTS|Discussion]] [[media:FXrateUSEU.xls|FXrateUSEU.xls]] [[media:USGDP.xls|USGDP.xls]]
| coming soon
| [[Forecasting|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Maximum Likelihood
! scope="col"| Generalized Methods of Moments
! scope="col"| Instrumental Variables
! scope="col"| Bayesian Estimation
|-
| [[MaxLik|Discussion]] [[MaxLikCode|Example Code]]
| [[GMM|2-step est]] [[GMM_over|2-step est (overident)]] [[numgrad_m|numgrad.m]] [https://youtu.be/qwDPOomNG1c YouTube (1h 45min)] [[media:US3monthRate.xlsx|US3monthRate.xlsx]]
| [[IV|Discussion]] [[ExampleCodeIV|Example Code]]
| [[Bayes|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Monte-Carlo/ Simulation Techniques
! scope="col"| Binary Response Models
! scope="col"| Handling High Frequency Data
|-
| coming soon
| coming soon
| coming soon

|}

== Other useful MATLAB resources ==

=== The MATLAB Software ===

The software is available on University of Manchester Computer Labs. If you make regular use of MATLAB you should consider purchasing your own software. The Student Version of MATLAB is available, for instance, from [http://www.amazon.co.uk/MATLAB-Simulink-Student-Version-R2014a/dp/0989614026/ref=sr_1_1?s=software&ie=UTF8&qid=1411983990&sr=1-1&keywords=matlab+2014 Amazon] for £66. This is a real bargain, considering that the equivalent non-discounted package would come in at about £4,000.

=== Freely available toolboxes ===

The following toolboxes are freely available and contain extremely useful procedures

* Spatial Econometrics by James P. LeSage [http://www.spatial-econometrics.com/]. This toolbox contains a wide variety of useful econometrics functions. It also contains an excellent documentation. In addition to quite general econometric functions you will, as the name suggests, find a huge list of functions relevant if you are working with spatial data.
* <div id="MFEtoolbox"></div>Oxford MFE toolbox by Kevin Sheppard [https://bitbucket.org/kevinsheppard/mfe_toolbox]. Use the download link in the box on the right that starts with "Owner: Kevin Sheppard". This toolbox contains many useful functions for uni- and multivariate volatility models.

You need to copy these toolboxes into your MATLAB toolbox folder and add the respective path to the MATLAB list of folders it searches for functions. (In the main menu select FILE and then SET PATH where you can add the folders you added.) If you work on a computer for which you have no administrator rights, this strategy may not work. This [http://youtu.be/_32OqcW9WoY?hd=1 Example Clip] demonstrates what to do in that case. It is just a matter of adding one line into your code! Piece of cake.

=== Literature and other learning resources ===
* [http://www.kevinsheppard.com/wiki/MFE_Toolbox: Kevin Sheppard's MATLAB introduction].
* Martin V., Hurn S. and Harris D. (2012) Econometric Modelling with Time Series: Specification, Estimation and Testing (Themes in Modern Econometrics).[http://www.amazon.co.uk/Econometric-Modelling-Time-Specification-Econometrics/dp/0521196604/ref=sr_1_1?s=books&ie=UTF8&qid=1345214275&sr=1-1] This book contains an extensive library of relevant MATLAB codes.
* Higham, D.J. and Higham, N.J. (2005) MATLAB Guide, Society for Industrial and Applied Mathematics [http://www.amazon.co.uk/MATLAB-Guide-Desmond-J-Higham/dp/0898715784/ref=sr_1_1?s=books&ie=UTF8&qid=1347377409&sr=1-1]
This website does not cover any theoretical ground and is no substitute for any Econometric Textbook. There is a wide range of very good Econometric Textbooks available. If you are concerned about programming in MATLAB than you are likely to appreciate textbooks that use matrix notation. Here are two very good books that fit that bill:
* Heij C., de Boer P., Franses P.H., Kloek T. and van Dijk H.K (2004) Econometric Methods with Applications in Business and Economics, Oxford University Press, New York.[http://www.amazon.co.uk/Econometric-Methods-Applications-Business-Economics/dp/0199268010/ref=sr_1_1?s=books&ie=UTF8&qid=1354473313&sr=1-1]
* Greene W.H. (2012) Econometric Analysis, Pearson, Harlow.[http://www.amazon.co.uk/Econometric-Analysis-William-H-Greene/dp/0273753568/ref=sr_1_1?ie=UTF8&qid=1354473593&sr=8-1]

GMM over

2022-02-08T08:41:24Z

Rb:

This code illustrates an overidentified (number of moments > number of parameters) 2-step GMM estimation.
This code requires numgrad.m in your working directory. This is a function to calculate numerical gradients.

<source>
%=========================================================================
%
% Program to estimate level effect in interest rates by GMM
%
% Code based on Martin, Hurn and Harris, Econometric Time Series Modelling
% Specification, Estimation and Testing
% https://www.cambridge.org/features/econmodelling/chapter10.htm
%=========================================================================

clear all;
clc;
cd 'C:\Users\YOUR_WORKING_DIRECTORY'

% Load data --- monthly December 1946 to February 1991
% 3 month maturity
% extracted from the datafile provided by
% Martin, Hurn and Harris
% https://www.cambridge.org/features/econmodelling/chapter10.htm

[rt, ~, ~] = xlsread('US3monthRate.xlsx');

drt = trimr(rt,2,0) - trimr(rt,1,1); % creates \Delta r_{t+1}
r1t = trimr(rt,1,1); % creates r_t
r2t = trimr(rt,0,2);
t = length(drt);

%% It is typically good practice to visualise the data
tt = seqa(1946+12/12,1/12,t); % Creates year sequence

subplot(1,2,1);
plot(tt,r1t);
title('r_t')
box off
axis tight

subplot(1,2,2);
plot(tt,drt);
title('\Delta r_{t+1}')
box off
axis tight

%% Estimate the model in the first stage with idendity weighting matrix

ops = optimset('LargeScale','off','Display','off');
b0 = [0.1;0.1;0.1;1.0];
w0 = eye(6);
bgmm1 = fminunc(@(b) qw(b,drt,r1t,r2t,w0),b0,ops);

disp('First Stage GMM estimates')
disp(bgmm1)

%% Now estimate the optimal weighting matrix
% using Newey-West estimator
lmax = 5; % lag for the NW estimate
d = meqn(bgmm1,drt,r1t,r2t);

% this will calculate Newey-West VCM using lmax lags
s = d'*d;
tau = 1;
while tau <= lmax
wtau = d((tau+1):size(d,1),:)'*d(1:(size(d,1)-tau),:);
s = s + (1.0-tau/(lmax+1))*(wtau + wtau');
tau = tau + 1;
end
w1 = s./t;

% Use this as the weighting matrix for the next pass to the optimisation
% function

%% 2nd Stage

bgmm2 = fminunc(@(b) qw(b,drt,r1t,r2t,w1),bgmm1,ops);

disp('Second Stage GMM estimates')
disp(bgmm2)

%% Further Iterations
% You could run further iterations
% 1) Re-calculate d
% 2) Re-calculate the optimal weighting matrix w based on the new d
% 3) Re-estimate using the new w
%
% For now we stop here
bgmm = bgmm2;
obj = qw(bgmm,drt,r1t,r2t,w1);

%% Calculate standard errors
% Compute optimal weigthing matrix at GMM estimates
% using Newey-West estimator
lmax = 5; % lag for the NW estimate
d = meqn(bgmm,drt,r1t,r2t);

% this will calculate Newey-West VCM using lmax lags
s = d'*d;
tau = 1;
while tau <= lmax
wtau = d((tau+1):size(d,1),:)'*d(1:(size(d,1)-tau),:);
s = s + (1.0-tau/(lmax+1))*(wtau + wtau');
tau = tau + 1;
end
s = s./t;

% Compute standard errors of GMM estimates
dg = numgrad(@meaneqn,bgmm,drt,r1t,r2t);
v = dg'*inv(s)*dg;
cov = inv(v)/t;
se = sqrt(diag(cov));

disp(' ');
disp(['The value of the objective function = ', num2str(obj) ]);
disp(['J-test = ', num2str(t*obj) ]);
disp('Estimates Std err. t-stats');
disp( [ bgmm se bgmm./se ])
disp(['Newey-West estimator with max lag = ', num2str(lmax) ]);
disp(' ');

%% Inference t-tests

% Test of gam = 0.0
stat = (bgmm(4) - 0.0)/se(4);
disp(['Test of (gam=0.0) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 0.5
stat = (bgmm(4) - 0.5)/se(4);
disp(['Test of (gam=0.5) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 1.0
stat = (bgmm(4) - 1.0)/se(4);
disp(['Test of (gam=1.0) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 1.5
stat = (bgmm(4) - 1.5)/se(4);
disp(['Test of (gam=1.5) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

%% Inference - Overidentifying restrictions
J = t*obj;
Jdof = size(s,1)-size(b0,1);
disp(['J-Test of overidentifying restrictions = ', num2str(J) ]);
disp(['p-value = ', num2str(1-chi2cdf(J,2)) ]);
disp(' ');

%% Plot volatility function for alternative values of gam
tt = seqa(1946+12/12,1/12,t);
figure(1)

subplot(2,2,1);
plot(tt,drt./r1t.^0.0);
title('$\gamma=0.0$')
box off
axis tight

subplot(2,2,2);
plot(tt,drt./r1t.^0.5);
title('$\gamma=0.5$')
box off
axis tight

subplot(2,2,3);
plot(tt,drt./r1t.^1.0);
title('$\gamma=1.0$')
box off
axis tight

subplot(2,2,4);
plot(tt,drt./r1t.^1.5);
title('$\gamma=1.5$')
box off
axis tight

%
%------------------------- Functions -------------------------------------%
%
%-------------------------------------------------------------------------%
% Define the moment equations
%-------------------------------------------------------------------------%
function dt = meqn(b,drt,r1t,r2t)

ut = drt - b(1) - b(2)*r1t;
zt = [ones(size(ut,1),1),r1t,r2t];
dt = repmat(ut,1,3).*zt;
dt = [dt,repmat((ut.^2 - (b(3)^2)*r1t.^(2*b(4)) ),1,3).*zt];

end
%-------------------------------------------------------------------------%
% Defines the mean of the moment conditions
%-------------------------------------------------------------------------%
function ret = meaneqn(b,drt,r1t,r2t)

ret = (mean(meqn(b,drt,r1t,r2t)))';

end

%-------------------------------------------------------------------------%
% GMM objective function with user defined
% weighting matrix, w
%-------------------------------------------------------------------------%
function ret = qw(b,drt,r1t,r2t,w)

t = length(drt);
d = meqn(b,drt,r1t,r2t);
g = mean(d)';

ret = g'*inv(w)*g;
end

</source>

GMM over

2022-02-08T08:40:35Z

Rb:

This code illustrates an overidentified (number of moments > number of parameters) 2-step GMM estimation.

<source>
%=========================================================================
%
% Program to estimate level effect in interest rates by GMM
%
% Code based on Martin, Hurn and Harris, Econometric Time Series Modelling
% Specification, Estimation and Testing
% https://www.cambridge.org/features/econmodelling/chapter10.htm
%=========================================================================

clear all;
clc;
cd 'C:\Users\YOUR_WORKING_DIRECTORY'

% Load data --- monthly December 1946 to February 1991
% 3 month maturity
% extracted from the datafile provided by
% Martin, Hurn and Harris
% https://www.cambridge.org/features/econmodelling/chapter10.htm

[rt, ~, ~] = xlsread('US3monthRate.xlsx');

drt = trimr(rt,2,0) - trimr(rt,1,1); % creates \Delta r_{t+1}
r1t = trimr(rt,1,1); % creates r_t
r2t = trimr(rt,0,2);
t = length(drt);

%% It is typically good practice to visualise the data
tt = seqa(1946+12/12,1/12,t); % Creates year sequence

subplot(1,2,1);
plot(tt,r1t);
title('r_t')
box off
axis tight

subplot(1,2,2);
plot(tt,drt);
title('\Delta r_{t+1}')
box off
axis tight

%% Estimate the model in the first stage with idendity weighting matrix

ops = optimset('LargeScale','off','Display','off');
b0 = [0.1;0.1;0.1;1.0];
w0 = eye(6);
bgmm1 = fminunc(@(b) qw(b,drt,r1t,r2t,w0),b0,ops);

disp('First Stage GMM estimates')
disp(bgmm1)

%% Now estimate the optimal weighting matrix
% using Newey-West estimator
lmax = 5; % lag for the NW estimate
d = meqn(bgmm1,drt,r1t,r2t);

% this will calculate Newey-West VCM using lmax lags
s = d'*d;
tau = 1;
while tau <= lmax
wtau = d((tau+1):size(d,1),:)'*d(1:(size(d,1)-tau),:);
s = s + (1.0-tau/(lmax+1))*(wtau + wtau');
tau = tau + 1;
end
w1 = s./t;

% Use this as the weighting matrix for the next pass to the optimisation
% function

%% 2nd Stage

bgmm2 = fminunc(@(b) qw(b,drt,r1t,r2t,w1),bgmm1,ops);

disp('Second Stage GMM estimates')
disp(bgmm2)

%% Further Iterations
% You could run further iterations
% 1) Re-calculate d
% 2) Re-calculate the optimal weighting matrix w based on the new d
% 3) Re-estimate using the new w
%
% For now we stop here
bgmm = bgmm2;
obj = qw(bgmm,drt,r1t,r2t,w1);

%% Calculate standard errors
% Compute optimal weigthing matrix at GMM estimates
% using Newey-West estimator
lmax = 5; % lag for the NW estimate
d = meqn(bgmm,drt,r1t,r2t);

% this will calculate Newey-West VCM using lmax lags
s = d'*d;
tau = 1;
while tau <= lmax
wtau = d((tau+1):size(d,1),:)'*d(1:(size(d,1)-tau),:);
s = s + (1.0-tau/(lmax+1))*(wtau + wtau');
tau = tau + 1;
end
s = s./t;

% Compute standard errors of GMM estimates
dg = numgrad(@meaneqn,bgmm,drt,r1t,r2t);
v = dg'*inv(s)*dg;
cov = inv(v)/t;
se = sqrt(diag(cov));

disp(' ');
disp(['The value of the objective function = ', num2str(obj) ]);
disp(['J-test = ', num2str(t*obj) ]);
disp('Estimates Std err. t-stats');
disp( [ bgmm se bgmm./se ])
disp(['Newey-West estimator with max lag = ', num2str(lmax) ]);
disp(' ');

%% Inference t-tests

% Test of gam = 0.0
stat = (bgmm(4) - 0.0)/se(4);
disp(['Test of (gam=0.0) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 0.5
stat = (bgmm(4) - 0.5)/se(4);
disp(['Test of (gam=0.5) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 1.0
stat = (bgmm(4) - 1.0)/se(4);
disp(['Test of (gam=1.0) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 1.5
stat = (bgmm(4) - 1.5)/se(4);
disp(['Test of (gam=1.5) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

%% Inference - Overidentifying restrictions
J = t*obj;
Jdof = size(s,1)-size(b0,1);
disp(['J-Test of overidentifying restrictions = ', num2str(J) ]);
disp(['p-value = ', num2str(1-chi2cdf(J,2)) ]);
disp(' ');

%% Plot volatility function for alternative values of gam
tt = seqa(1946+12/12,1/12,t);
figure(1)

subplot(2,2,1);
plot(tt,drt./r1t.^0.0);
title('$\gamma=0.0$')
box off
axis tight

subplot(2,2,2);
plot(tt,drt./r1t.^0.5);
title('$\gamma=0.5$')
box off
axis tight

subplot(2,2,3);
plot(tt,drt./r1t.^1.0);
title('$\gamma=1.0$')
box off
axis tight

subplot(2,2,4);
plot(tt,drt./r1t.^1.5);
title('$\gamma=1.5$')
box off
axis tight

%
%------------------------- Functions -------------------------------------%
%
%-------------------------------------------------------------------------%
% Define the moment equations
%-------------------------------------------------------------------------%
function dt = meqn(b,drt,r1t,r2t)

ut = drt - b(1) - b(2)*r1t;
zt = [ones(size(ut,1),1),r1t,r2t];
dt = repmat(ut,1,3).*zt;
dt = [dt,repmat((ut.^2 - (b(3)^2)*r1t.^(2*b(4)) ),1,3).*zt];

end
%-------------------------------------------------------------------------%
% Defines the mean of the moment conditions
%-------------------------------------------------------------------------%
function ret = meaneqn(b,drt,r1t,r2t)

ret = (mean(meqn(b,drt,r1t,r2t)))';

end

%-------------------------------------------------------------------------%
% GMM objective function with user defined
% weighting matrix, w
%-------------------------------------------------------------------------%
function ret = qw(b,drt,r1t,r2t,w)

t = length(drt);
d = meqn(b,drt,r1t,r2t);
g = mean(d)';

ret = g'*inv(w)*g;
end

</source>

GMM over

2022-02-08T08:40:00Z

Rb: Created page with "This code illustrates an overidentified (number of moments > number of parameters) 2-step GMM estimation. <source> %=========================================================..."

This code illustrates an overidentified (number of moments > number of parameters) 2-step GMM estimation.

<source>
%=========================================================================
%
% Program to estimate level effect in interest rates by GMM
%
% Code based on Martin, Hurn and Harris, Econometric Time Series Modelling
% Specification, Estimation and Testing
% https://www.cambridge.org/features/econmodelling/chapter10.htm
%=========================================================================

clear all;
clc;
cd 'C:\Users\msassrb2\Dropbox (The University of Manchester)\ECON80021\201920\GMM'

% Load data --- monthly December 1946 to February 1991
% 3 month maturity
% extracted from the datafile provided by
% Martin, Hurn and Harris
% https://www.cambridge.org/features/econmodelling/chapter10.htm

[rt, ~, ~] = xlsread('US3monthRate.xlsx');

drt = trimr(rt,2,0) - trimr(rt,1,1); % creates \Delta r_{t+1}
r1t = trimr(rt,1,1); % creates r_t
r2t = trimr(rt,0,2);
t = length(drt);

%% It is typically good practice to visualise the data
tt = seqa(1946+12/12,1/12,t); % Creates year sequence

subplot(1,2,1);
plot(tt,r1t);
title('r_t')
box off
axis tight

subplot(1,2,2);
plot(tt,drt);
title('\Delta r_{t+1}')
box off
axis tight

%% Estimate the model in the first stage with idendity weighting matrix

ops = optimset('LargeScale','off','Display','off');
b0 = [0.1;0.1;0.1;1.0];
w0 = eye(6);
bgmm1 = fminunc(@(b) qw(b,drt,r1t,r2t,w0),b0,ops);

disp('First Stage GMM estimates')
disp(bgmm1)

%% Now estimate the optimal weighting matrix
% using Newey-West estimator
lmax = 5; % lag for the NW estimate
d = meqn(bgmm1,drt,r1t,r2t);

% this will calculate Newey-West VCM using lmax lags
s = d'*d;
tau = 1;
while tau <= lmax
wtau = d((tau+1):size(d,1),:)'*d(1:(size(d,1)-tau),:);
s = s + (1.0-tau/(lmax+1))*(wtau + wtau');
tau = tau + 1;
end
w1 = s./t;

% Use this as the weighting matrix for the next pass to the optimisation
% function

%% 2nd Stage

bgmm2 = fminunc(@(b) qw(b,drt,r1t,r2t,w1),bgmm1,ops);

disp('Second Stage GMM estimates')
disp(bgmm2)

%% Further Iterations
% You could run further iterations
% 1) Re-calculate d
% 2) Re-calculate the optimal weighting matrix w based on the new d
% 3) Re-estimate using the new w
%
% For now we stop here
bgmm = bgmm2;
obj = qw(bgmm,drt,r1t,r2t,w1);

%% Calculate standard errors
% Compute optimal weigthing matrix at GMM estimates
% using Newey-West estimator
lmax = 5; % lag for the NW estimate
d = meqn(bgmm,drt,r1t,r2t);

% this will calculate Newey-West VCM using lmax lags
s = d'*d;
tau = 1;
while tau <= lmax
wtau = d((tau+1):size(d,1),:)'*d(1:(size(d,1)-tau),:);
s = s + (1.0-tau/(lmax+1))*(wtau + wtau');
tau = tau + 1;
end
s = s./t;

% Compute standard errors of GMM estimates
dg = numgrad(@meaneqn,bgmm,drt,r1t,r2t);
v = dg'*inv(s)*dg;
cov = inv(v)/t;
se = sqrt(diag(cov));

disp(' ');
disp(['The value of the objective function = ', num2str(obj) ]);
disp(['J-test = ', num2str(t*obj) ]);
disp('Estimates Std err. t-stats');
disp( [ bgmm se bgmm./se ])
disp(['Newey-West estimator with max lag = ', num2str(lmax) ]);
disp(' ');

%% Inference t-tests

% Test of gam = 0.0
stat = (bgmm(4) - 0.0)/se(4);
disp(['Test of (gam=0.0) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 0.5
stat = (bgmm(4) - 0.5)/se(4);
disp(['Test of (gam=0.5) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 1.0
stat = (bgmm(4) - 1.0)/se(4);
disp(['Test of (gam=1.0) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 1.5
stat = (bgmm(4) - 1.5)/se(4);
disp(['Test of (gam=1.5) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

%% Inference - Overidentifying restrictions
J = t*obj;
Jdof = size(s,1)-size(b0,1);
disp(['J-Test of overidentifying restrictions = ', num2str(J) ]);
disp(['p-value = ', num2str(1-chi2cdf(J,2)) ]);
disp(' ');

%% Plot volatility function for alternative values of gam
tt = seqa(1946+12/12,1/12,t);
figure(1)

subplot(2,2,1);
plot(tt,drt./r1t.^0.0);
title('$\gamma=0.0$')
box off
axis tight

subplot(2,2,2);
plot(tt,drt./r1t.^0.5);
title('$\gamma=0.5$')
box off
axis tight

subplot(2,2,3);
plot(tt,drt./r1t.^1.0);
title('$\gamma=1.0$')
box off
axis tight

subplot(2,2,4);
plot(tt,drt./r1t.^1.5);
title('$\gamma=1.5$')
box off
axis tight

%
%------------------------- Functions -------------------------------------%
%
%-------------------------------------------------------------------------%
% Define the moment equations
%-------------------------------------------------------------------------%
function dt = meqn(b,drt,r1t,r2t)

ut = drt - b(1) - b(2)*r1t;
zt = [ones(size(ut,1),1),r1t,r2t];
dt = repmat(ut,1,3).*zt;
dt = [dt,repmat((ut.^2 - (b(3)^2)*r1t.^(2*b(4)) ),1,3).*zt];

end
%-------------------------------------------------------------------------%
% Defines the mean of the moment conditions
%-------------------------------------------------------------------------%
function ret = meaneqn(b,drt,r1t,r2t)

ret = (mean(meqn(b,drt,r1t,r2t)))';

end

%-------------------------------------------------------------------------%
% GMM objective function with user defined
% weighting matrix, w
%-------------------------------------------------------------------------%
function ret = qw(b,drt,r1t,r2t,w)

t = length(drt);
d = meqn(b,drt,r1t,r2t);
g = mean(d)';

ret = g'*inv(w)*g;
end

</source>

MATLAB

2022-02-08T08:38:41Z

Rb: /* Special Econometric Topics */

== <div id="Essential"></div>The Essential MATLAB Programming Techniques ==

In this section we will introduce a number of basic and intermediate programming techniques. Whatever language you program in you will encounter these techniques, although the details will, of course, vary. We recommend that you ensure that you are familiar with these before you progress to [[#SpecEcmtrTopics| Special Econometric Topics ]].

=== Basic Programming ===

{| class="wikitable"
|-
! scope="col"| Basics and Matrices
! scope="col"| Loading Data and Date Formats
! scope="col"| Program Flow and Logicals
! scope="col"| Functions
! scope="col"| Saving Data and Screen Output
|-
| [[Discussion]] [http://www.youtube.com/watch?v=av5MgVpybT0&feature=youtu.be&hd=1 Example Clip]
| [[LoadingData|Discussion]] [http://youtu.be/jyb68zGM2ik?hd=1 ExampleClip]
| [[Program Flow and Logicals|Discussion]]
| [[Function|Discussion]] [[FctExampleCode|Example Code]] [[media:OLSexample.xls|OLSexample.xls]] [http://youtu.be/FPw9DH8pfiU?hd=1 Example Clip]
| [[SavingData|Discussion]]
|}

After having gone through these basic techniques you may want to test your newly acquired skills with the following examples.

{| class="wikitable"
|-
! scope="col"| Example 1
! scope="col"| Example 2
|-
| [[Example 1]]
| [[Example 2|Example2a]] [[Example 2b|Example2b]]
|}

=== Intermediate Programming ===

{| class="wikitable"
|-
! scope="col"| Statistical Functions
! scope="col"| Arrays and Structures
! scope="col"| Debugging
! scope="col"| Graphing Data
! scope="col"| Function Handlers Anonymous Functions
|-
| [[StatFunct|Discussion]]
| [[ArrayStructures|Discussion]]
| coming soon
| [[Graphing|Discussion]]
| [[Anonym|Discussion]]
|}

=== Advanced Programming ===

Sorry, but this cannot be taught! It will come with experience. Find someone who has experience in MATLAB programming and let him or her look over your code.

== Nonlinear Optimisation ==

The optimal parameters in a linear econometric model (assuming certain assumptions) can be found analytically. We call them the Ordinary Least Squares (OLS) estimates and they are easily calculated with a certain formula (see the [[FctExampleCode#OLSestm|OLSest.m]] function). When econometric models do not have such an analytical solution, an alternative parameter estimation strategy is required. In essence it is a clever "trial and error" strategy. This is often called nonlinear optimisation.

Nonlinear optimisation is a very important, but also a very tricky area of econometric computing. It certainly helps to understand some of the underlying theory and therefore we have below separate sections on the theory and implementation.

{| class="wikitable"
|-
! scope="col"| Theory
! scope="col"| Implementation
! scope="col"| Constrained Optimisation
|-
| [[NonlinOptTheory| Discussion]]
| [[NonlinOptImp| Discussion]]
| [[ConNonlinOptImp| Discussion]]
|}

== <div id="SpecEcmtrTopics"></div> Special Econometric Topics ==

Topics in this Section will assume that you have mastered all the techniques covered in the [[#Essential| Essential Programming Section ]]

{| class="wikitable"
|-
! scope="col"| Robust standard errors
! scope="col"| Univariate Time Series
! scope="col"| Unit Root and Stationarity Testing
! scope="col"| Forecasting
|-
| [[RobInf|Discussion]] [[ExampleCodeOLShac|Example Code]]
| [[UniTS|Discussion]] [[media:FXrateUSEU.xls|FXrateUSEU.xls]] [[media:USGDP.xls|USGDP.xls]]
| coming soon
| [[Forecasting|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Maximum Likelihood
! scope="col"| Generalized Methods of Moments
! scope="col"| Instrumental Variables
! scope="col"| Bayesian Estimation
|-
| [[MaxLik|Discussion]] [[MaxLikCode|Example Code]]
| [[GMM|2-step est]] [[GMM_over|2-step est (overident)]] [[numgrad_m|numgrad.m]] [https://youtu.be/qwDPOomNG1c video] [[media:US3monthRate.xlsx|US3monthRate.xlsx]]
| [[IV|Discussion]] [[ExampleCodeIV|Example Code]]
| [[Bayes|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Monte-Carlo/ Simulation Techniques
! scope="col"| Binary Response Models
! scope="col"| Handling High Frequency Data
|-
| coming soon
| coming soon
| coming soon

|}

== Other useful MATLAB resources ==

=== The MATLAB Software ===

The software is available on University of Manchester Computer Labs. If you make regular use of MATLAB you should consider purchasing your own software. The Student Version of MATLAB is available, for instance, from [http://www.amazon.co.uk/MATLAB-Simulink-Student-Version-R2014a/dp/0989614026/ref=sr_1_1?s=software&ie=UTF8&qid=1411983990&sr=1-1&keywords=matlab+2014 Amazon] for £66. This is a real bargain, considering that the equivalent non-discounted package would come in at about £4,000.

=== Freely available toolboxes ===

The following toolboxes are freely available and contain extremely useful procedures

* Spatial Econometrics by James P. LeSage [http://www.spatial-econometrics.com/]. This toolbox contains a wide variety of useful econometrics functions. It also contains an excellent documentation. In addition to quite general econometric functions you will, as the name suggests, find a huge list of functions relevant if you are working with spatial data.
* <div id="MFEtoolbox"></div>Oxford MFE toolbox by Kevin Sheppard [https://bitbucket.org/kevinsheppard/mfe_toolbox]. Use the download link in the box on the right that starts with "Owner: Kevin Sheppard". This toolbox contains many useful functions for uni- and multivariate volatility models.

You need to copy these toolboxes into your MATLAB toolbox folder and add the respective path to the MATLAB list of folders it searches for functions. (In the main menu select FILE and then SET PATH where you can add the folders you added.) If you work on a computer for which you have no administrator rights, this strategy may not work. This [http://youtu.be/_32OqcW9WoY?hd=1 Example Clip] demonstrates what to do in that case. It is just a matter of adding one line into your code! Piece of cake.

=== Literature and other learning resources ===
* [http://www.kevinsheppard.com/wiki/MFE_Toolbox: Kevin Sheppard's MATLAB introduction].
* Martin V., Hurn S. and Harris D. (2012) Econometric Modelling with Time Series: Specification, Estimation and Testing (Themes in Modern Econometrics).[http://www.amazon.co.uk/Econometric-Modelling-Time-Specification-Econometrics/dp/0521196604/ref=sr_1_1?s=books&ie=UTF8&qid=1345214275&sr=1-1] This book contains an extensive library of relevant MATLAB codes.
* Higham, D.J. and Higham, N.J. (2005) MATLAB Guide, Society for Industrial and Applied Mathematics [http://www.amazon.co.uk/MATLAB-Guide-Desmond-J-Higham/dp/0898715784/ref=sr_1_1?s=books&ie=UTF8&qid=1347377409&sr=1-1]
This website does not cover any theoretical ground and is no substitute for any Econometric Textbook. There is a wide range of very good Econometric Textbooks available. If you are concerned about programming in MATLAB than you are likely to appreciate textbooks that use matrix notation. Here are two very good books that fit that bill:
* Heij C., de Boer P., Franses P.H., Kloek T. and van Dijk H.K (2004) Econometric Methods with Applications in Business and Economics, Oxford University Press, New York.[http://www.amazon.co.uk/Econometric-Methods-Applications-Business-Economics/dp/0199268010/ref=sr_1_1?s=books&ie=UTF8&qid=1354473313&sr=1-1]
* Greene W.H. (2012) Econometric Analysis, Pearson, Harlow.[http://www.amazon.co.uk/Econometric-Analysis-William-H-Greene/dp/0273753568/ref=sr_1_1?ie=UTF8&qid=1354473593&sr=8-1]

GMM

2022-02-08T08:37:30Z

Rb:

The code below performs a standard 2 step GMM estimation.
In this code the estimation is exactly identified (number of moments = number of parameters).
This code requires numgrad.m in your working directory. This is a function to calculate numerical gradients.

<source>
%=========================================================================
%
% Program to estimate level effect in interest rates by GMM
%
% Code based on Martin, Hurn and Harris, Econometric Time Series Modelling
% Specification, Estimation and Testing
% https://www.cambridge.org/features/econmodelling/chapter10.htm
%
% This code by Ralf Becker, March 2021
% http://eclr.humanities.manchester.ac.uk/index.php/MATLAB
%=========================================================================

clear all;
clc;
cd 'YOUR DIRECTORY'

% Load data --- monthly December 1946 to February 1991
% 3 month maturity
% extracted from the datafile provided by
% Martin, Hurn and Harris
% https://www.cambridge.org/features/econmodelling/chapter10.htm

[rt, ~, ~] = xlsread('US3monthRate.xlsx');

drt = trimr(rt,2,0) - trimr(rt,1,1); % creates \Delta r_{t+1}
r1t = trimr(rt,1,1); % creates r_t
r2t = trimr(rt,0,2);
t = length(drt);

%% It is typically good practice to visualise the data
tt = seqa(1946+12/12,1/12,t); % Creates year sequence

subplot(1,2,1);
plot(tt,r1t);
title('r_t')
box off
axis tight

subplot(1,2,2);
plot(tt,drt);
title('\Delta r_{t+1}')
box off
axis tight

%% Estimate the model in the first stage with idendity weighting matrix

ops = optimset('LargeScale','off','Display','off');
b0 = [0.1;0.1;0.1;1.0];
w0 = eye(length(b0));
bgmm1 = fminunc(@(b) qw(b,drt,r1t,w0),b0,ops);

disp('First Stage GMM estimates')
disp(bgmm1)

%% Now estimate the optimal weighting matrix
% using Newey-West estimator
lmax = 5; % lag for the NW estimate
d = meqn(bgmm1,drt,r1t);

% this will calculate Newey-West VCM using lmax lags
s = d'*d;
tau = 1;
while tau <= lmax
wtau = d((tau+1):size(d,1),:)'*d(1:(size(d,1)-tau),:);
s = s + (1.0-tau/(lmax+1))*(wtau + wtau');
tau = tau + 1;
end
w1 = s./t;

% Use this as the weighting matrix for the next pass to the optimisation
% function

%% 2nd Stage

bgmm2 = fminunc(@(b) qw(b,drt,r1t,w1),bgmm1,ops);

disp('Second Stage GMM estimates')
disp(bgmm2)

%% Further Iterations
% You could run further iterations
% 1) Re-calculate d
% 2) Re-calculate the optimal weighting matrix w based on the new d
% 3) Re-estimate using the new w
%
% For now we stop here
bgmm = bgmm2;
obj = qw(bgmm,drt,r1t,w1);

%% Calculate standard errors
% Compute optimal weigthing matrix at GMM estimates
% using Newey-West estimator
lmax = 5; % lag for the NW estimate
d = meqn(bgmm,drt,r1t);

% this will calculate Newey-West VCM using lmax lags
s = d'*d;
tau = 1;
while tau <= lmax
wtau = d((tau+1):size(d,1),:)'*d(1:(size(d,1)-tau),:);
s = s + (1.0-tau/(lmax+1))*(wtau + wtau');
tau = tau + 1;
end
s = s./t;

% Compute standard errors of GMM estimates
dg = numgrad(@meaneqn,bgmm,drt,r1t);
v = dg'*inv(s)*dg;
cov = inv(v)/t;
se = sqrt(diag(cov));

disp(' ');
disp(['The value of the objective function = ', num2str(obj) ]);
disp(['J-test = ', num2str(t*obj) ]);
disp('Estimates Std err. t-stats');
disp( [ bgmm se bgmm./se ])
disp(['Newey-West estimator with max lag = ', num2str(lmax) ]);
disp(' ');

%% Inference t-tests

% Test of gam = 0.0
stat = (bgmm(4) - 0.0)/se(4);
disp(['Test of (gam=0.0) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 0.5
stat = (bgmm(4) - 0.5)/se(4);
disp(['Test of (gam=0.5) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 1.0
stat = (bgmm(4) - 1.0)/se(4);
disp(['Test of (gam=1.0) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 1.5
stat = (bgmm(4) - 1.5)/se(4);
disp(['Test of (gam=1.5) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

%% Inference - Overidentifying restrictions

%% Plot volatility function for alternative values of gam
tt = seqa(1946+12/12,1/12,t);
figure(1)

subplot(2,2,1);
plot(tt,drt./r1t.^0.0);
title('$\gamma=0.0$')
box off
axis tight

subplot(2,2,2);
plot(tt,drt./r1t.^0.5);
title('$\gamma=0.5$')
box off
axis tight

subplot(2,2,3);
plot(tt,drt./r1t.^1.0);
title('$\gamma=1.0$')
box off
axis tight

subplot(2,2,4);
plot(tt,drt./r1t.^1.5);
title('$\gamma=1.5$')
box off
axis tight

%
%------------------------- Functions -------------------------------------%
%
%-------------------------------------------------------------------------%
% Define the moment equations
%-------------------------------------------------------------------------%
function dt = meqn(b,drt,r1t)

ut = drt - b(1) - b(2)*r1t;
zt = [ones(size(ut,1),1),r1t];
dt = repmat(ut,1,2).*zt;
dt = [dt,repmat((ut.^2 - (b(3)^2)*r1t.^(2*b(4)) ),1,2).*zt];

end
%-------------------------------------------------------------------------%
% Defines the mean of the moment conditions
%-------------------------------------------------------------------------%
function ret = meaneqn(b,drt,r1t)

ret = (mean(meqn(b,drt,r1t)))';

end

%-------------------------------------------------------------------------%
% GMM objective function with user defined
% weighting matrix, w
%-------------------------------------------------------------------------%
function ret = qw(b,drt,r1t,w)

t = length(drt);
d = meqn(b,drt,r1t);
g = mean(d)';

ret = g'*inv(w)*g;
end

</source>

Numgrad m

2022-02-08T08:36:47Z

Rb:

Save the code below as numgrad.m in your working folder. This is required to make the GMM code work.

<source>
%-------------------------------------------------------------------------
% Computes numerical gradient at each observation
%-------------------------------------------------------------------------
function G = numgrad( f,x,varargin )

f0 = feval( f,x,varargin{:} ); % n by 1
n = length( f0 );
k = length( x );
fdf = zeros( n,k );

% Compute step size
dx = sqrt( eps )*( abs( x ) + eps );
xh = x + dx;
dx = xh - x;
ind = dx < sqrt(eps);
dx(ind) = sqrt(eps);

% Compute gradient
xdx = bsxfun( @plus, diag( dx ), x );
for i=1:k;

fdf(:,i) = feval( f, xdx(:,i), varargin{:} );
end

G0 = repmat( f0, 1, k ); % n by k
G1 = repmat( dx', n, 1 );
G = ( fdf-G0 )./G1;

end

</source>

Numgrad m

2022-02-08T08:36:06Z

Rb:

<source>
%-------------------------------------------------------------------------
% Computes numerical gradient at each observation
%-------------------------------------------------------------------------
function G = numgrad( f,x,varargin )

f0 = feval( f,x,varargin{:} ); % n by 1
n = length( f0 );
k = length( x );
fdf = zeros( n,k );

% Compute step size
dx = sqrt( eps )*( abs( x ) + eps );
xh = x + dx;
dx = xh - x;
ind = dx < sqrt(eps);
dx(ind) = sqrt(eps);

% Compute gradient
xdx = bsxfun( @plus, diag( dx ), x );
for i=1:k;

fdf(:,i) = feval( f, xdx(:,i), varargin{:} );
end

G0 = repmat( f0, 1, k ); % n by k
G1 = repmat( dx', n, 1 );
G = ( fdf-G0 )./G1;

end

</source>

Numgrad m

2022-02-08T08:35:21Z

Rb: Created page with "<source> %------------------------------------------------------------------------- % Computes numerical gradient at each observation %-------------------------------------..."

MATLAB

2022-02-08T08:34:54Z

Rb: /* Special Econometric Topics */

== <div id="Essential"></div>The Essential MATLAB Programming Techniques ==

In this section we will introduce a number of basic and intermediate programming techniques. Whatever language you program in you will encounter these techniques, although the details will, of course, vary. We recommend that you ensure that you are familiar with these before you progress to [[#SpecEcmtrTopics| Special Econometric Topics ]].

=== Basic Programming ===

{| class="wikitable"
|-
! scope="col"| Basics and Matrices
! scope="col"| Loading Data and Date Formats
! scope="col"| Program Flow and Logicals
! scope="col"| Functions
! scope="col"| Saving Data and Screen Output
|-
| [[Discussion]] [http://www.youtube.com/watch?v=av5MgVpybT0&feature=youtu.be&hd=1 Example Clip]
| [[LoadingData|Discussion]] [http://youtu.be/jyb68zGM2ik?hd=1 ExampleClip]
| [[Program Flow and Logicals|Discussion]]
| [[Function|Discussion]] [[FctExampleCode|Example Code]] [[media:OLSexample.xls|OLSexample.xls]] [http://youtu.be/FPw9DH8pfiU?hd=1 Example Clip]
| [[SavingData|Discussion]]
|}

After having gone through these basic techniques you may want to test your newly acquired skills with the following examples.

{| class="wikitable"
|-
! scope="col"| Example 1
! scope="col"| Example 2
|-
| [[Example 1]]
| [[Example 2|Example2a]] [[Example 2b|Example2b]]
|}

=== Intermediate Programming ===

{| class="wikitable"
|-
! scope="col"| Statistical Functions
! scope="col"| Arrays and Structures
! scope="col"| Debugging
! scope="col"| Graphing Data
! scope="col"| Function Handlers Anonymous Functions
|-
| [[StatFunct|Discussion]]
| [[ArrayStructures|Discussion]]
| coming soon
| [[Graphing|Discussion]]
| [[Anonym|Discussion]]
|}

=== Advanced Programming ===

Sorry, but this cannot be taught! It will come with experience. Find someone who has experience in MATLAB programming and let him or her look over your code.

== Nonlinear Optimisation ==

The optimal parameters in a linear econometric model (assuming certain assumptions) can be found analytically. We call them the Ordinary Least Squares (OLS) estimates and they are easily calculated with a certain formula (see the [[FctExampleCode#OLSestm|OLSest.m]] function). When econometric models do not have such an analytical solution, an alternative parameter estimation strategy is required. In essence it is a clever "trial and error" strategy. This is often called nonlinear optimisation.

Nonlinear optimisation is a very important, but also a very tricky area of econometric computing. It certainly helps to understand some of the underlying theory and therefore we have below separate sections on the theory and implementation.

{| class="wikitable"
|-
! scope="col"| Theory
! scope="col"| Implementation
! scope="col"| Constrained Optimisation
|-
| [[NonlinOptTheory| Discussion]]
| [[NonlinOptImp| Discussion]]
| [[ConNonlinOptImp| Discussion]]
|}

== <div id="SpecEcmtrTopics"></div> Special Econometric Topics ==

Topics in this Section will assume that you have mastered all the techniques covered in the [[#Essential| Essential Programming Section ]]

{| class="wikitable"
|-
! scope="col"| Robust standard errors
! scope="col"| Univariate Time Series
! scope="col"| Unit Root and Stationarity Testing
! scope="col"| Forecasting
|-
| [[RobInf|Discussion]] [[ExampleCodeOLShac|Example Code]]
| [[UniTS|Discussion]] [[media:FXrateUSEU.xls|FXrateUSEU.xls]] [[media:USGDP.xls|USGDP.xls]]
| coming soon
| [[Forecasting|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Maximum Likelihood
! scope="col"| Generalized Methods of Moments
! scope="col"| Instrumental Variables
! scope="col"| Bayesian Estimation
|-
| [[MaxLik|Discussion]] [[MaxLikCode|Example Code]]
| [[GMM|2-step est]] [[numgrad_m|numgrad.m]] [https://youtu.be/qwDPOomNG1c video] [[media:US3monthRate.xlsx|US3monthRate.xlsx]] [[media: gradp.m|gradp.m]]
| [[IV|Discussion]] [[ExampleCodeIV|Example Code]]
| [[Bayes|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Monte-Carlo/ Simulation Techniques
! scope="col"| Binary Response Models
! scope="col"| Handling High Frequency Data
|-
| coming soon
| coming soon
| coming soon

|}

== Other useful MATLAB resources ==

=== The MATLAB Software ===

The software is available on University of Manchester Computer Labs. If you make regular use of MATLAB you should consider purchasing your own software. The Student Version of MATLAB is available, for instance, from [http://www.amazon.co.uk/MATLAB-Simulink-Student-Version-R2014a/dp/0989614026/ref=sr_1_1?s=software&ie=UTF8&qid=1411983990&sr=1-1&keywords=matlab+2014 Amazon] for £66. This is a real bargain, considering that the equivalent non-discounted package would come in at about £4,000.

=== Freely available toolboxes ===

The following toolboxes are freely available and contain extremely useful procedures

* Spatial Econometrics by James P. LeSage [http://www.spatial-econometrics.com/]. This toolbox contains a wide variety of useful econometrics functions. It also contains an excellent documentation. In addition to quite general econometric functions you will, as the name suggests, find a huge list of functions relevant if you are working with spatial data.
* <div id="MFEtoolbox"></div>Oxford MFE toolbox by Kevin Sheppard [https://bitbucket.org/kevinsheppard/mfe_toolbox]. Use the download link in the box on the right that starts with "Owner: Kevin Sheppard". This toolbox contains many useful functions for uni- and multivariate volatility models.

You need to copy these toolboxes into your MATLAB toolbox folder and add the respective path to the MATLAB list of folders it searches for functions. (In the main menu select FILE and then SET PATH where you can add the folders you added.) If you work on a computer for which you have no administrator rights, this strategy may not work. This [http://youtu.be/_32OqcW9WoY?hd=1 Example Clip] demonstrates what to do in that case. It is just a matter of adding one line into your code! Piece of cake.

=== Literature and other learning resources ===
* [http://www.kevinsheppard.com/wiki/MFE_Toolbox: Kevin Sheppard's MATLAB introduction].
* Martin V., Hurn S. and Harris D. (2012) Econometric Modelling with Time Series: Specification, Estimation and Testing (Themes in Modern Econometrics).[http://www.amazon.co.uk/Econometric-Modelling-Time-Specification-Econometrics/dp/0521196604/ref=sr_1_1?s=books&ie=UTF8&qid=1345214275&sr=1-1] This book contains an extensive library of relevant MATLAB codes.
* Higham, D.J. and Higham, N.J. (2005) MATLAB Guide, Society for Industrial and Applied Mathematics [http://www.amazon.co.uk/MATLAB-Guide-Desmond-J-Higham/dp/0898715784/ref=sr_1_1?s=books&ie=UTF8&qid=1347377409&sr=1-1]
This website does not cover any theoretical ground and is no substitute for any Econometric Textbook. There is a wide range of very good Econometric Textbooks available. If you are concerned about programming in MATLAB than you are likely to appreciate textbooks that use matrix notation. Here are two very good books that fit that bill:
* Heij C., de Boer P., Franses P.H., Kloek T. and van Dijk H.K (2004) Econometric Methods with Applications in Business and Economics, Oxford University Press, New York.[http://www.amazon.co.uk/Econometric-Methods-Applications-Business-Economics/dp/0199268010/ref=sr_1_1?s=books&ie=UTF8&qid=1354473313&sr=1-1]
* Greene W.H. (2012) Econometric Analysis, Pearson, Harlow.[http://www.amazon.co.uk/Econometric-Analysis-William-H-Greene/dp/0273753568/ref=sr_1_1?ie=UTF8&qid=1354473593&sr=8-1]

MATLAB

2022-02-08T08:33:50Z

Rb: /* Special Econometric Topics */

== <div id="Essential"></div>The Essential MATLAB Programming Techniques ==

In this section we will introduce a number of basic and intermediate programming techniques. Whatever language you program in you will encounter these techniques, although the details will, of course, vary. We recommend that you ensure that you are familiar with these before you progress to [[#SpecEcmtrTopics| Special Econometric Topics ]].

=== Basic Programming ===

{| class="wikitable"
|-
! scope="col"| Basics and Matrices
! scope="col"| Loading Data and Date Formats
! scope="col"| Program Flow and Logicals
! scope="col"| Functions
! scope="col"| Saving Data and Screen Output
|-
| [[Discussion]] [http://www.youtube.com/watch?v=av5MgVpybT0&feature=youtu.be&hd=1 Example Clip]
| [[LoadingData|Discussion]] [http://youtu.be/jyb68zGM2ik?hd=1 ExampleClip]
| [[Program Flow and Logicals|Discussion]]
| [[Function|Discussion]] [[FctExampleCode|Example Code]] [[media:OLSexample.xls|OLSexample.xls]] [http://youtu.be/FPw9DH8pfiU?hd=1 Example Clip]
| [[SavingData|Discussion]]
|}

After having gone through these basic techniques you may want to test your newly acquired skills with the following examples.

{| class="wikitable"
|-
! scope="col"| Example 1
! scope="col"| Example 2
|-
| [[Example 1]]
| [[Example 2|Example2a]] [[Example 2b|Example2b]]
|}

=== Intermediate Programming ===

{| class="wikitable"
|-
! scope="col"| Statistical Functions
! scope="col"| Arrays and Structures
! scope="col"| Debugging
! scope="col"| Graphing Data
! scope="col"| Function Handlers Anonymous Functions
|-
| [[StatFunct|Discussion]]
| [[ArrayStructures|Discussion]]
| coming soon
| [[Graphing|Discussion]]
| [[Anonym|Discussion]]
|}

=== Advanced Programming ===

Sorry, but this cannot be taught! It will come with experience. Find someone who has experience in MATLAB programming and let him or her look over your code.

== Nonlinear Optimisation ==

The optimal parameters in a linear econometric model (assuming certain assumptions) can be found analytically. We call them the Ordinary Least Squares (OLS) estimates and they are easily calculated with a certain formula (see the [[FctExampleCode#OLSestm|OLSest.m]] function). When econometric models do not have such an analytical solution, an alternative parameter estimation strategy is required. In essence it is a clever "trial and error" strategy. This is often called nonlinear optimisation.

Nonlinear optimisation is a very important, but also a very tricky area of econometric computing. It certainly helps to understand some of the underlying theory and therefore we have below separate sections on the theory and implementation.

{| class="wikitable"
|-
! scope="col"| Theory
! scope="col"| Implementation
! scope="col"| Constrained Optimisation
|-
| [[NonlinOptTheory| Discussion]]
| [[NonlinOptImp| Discussion]]
| [[ConNonlinOptImp| Discussion]]
|}

== <div id="SpecEcmtrTopics"></div> Special Econometric Topics ==

Topics in this Section will assume that you have mastered all the techniques covered in the [[#Essential| Essential Programming Section ]]

{| class="wikitable"
|-
! scope="col"| Robust standard errors
! scope="col"| Univariate Time Series
! scope="col"| Unit Root and Stationarity Testing
! scope="col"| Forecasting
|-
| [[RobInf|Discussion]] [[ExampleCodeOLShac|Example Code]]
| [[UniTS|Discussion]] [[media:FXrateUSEU.xls|FXrateUSEU.xls]] [[media:USGDP.xls|USGDP.xls]]
| coming soon
| [[Forecasting|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Maximum Likelihood
! scope="col"| Generalized Methods of Moments
! scope="col"| Instrumental Variables
! scope="col"| Bayesian Estimation
|-
| [[MaxLik|Discussion]] [[MaxLikCode|Example Code]]
| [[GMM|2-step est]] [https://youtu.be/qwDPOomNG1c video] [[media:US3monthRate.xlsx|US3monthRate.xlsx]] [[media: gradp.m|gradp.m]]
| [[IV|Discussion]] [[ExampleCodeIV|Example Code]]
| [[Bayes|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Monte-Carlo/ Simulation Techniques
! scope="col"| Binary Response Models
! scope="col"| Handling High Frequency Data
|-
| coming soon
| coming soon
| coming soon

|}

== Other useful MATLAB resources ==

=== The MATLAB Software ===

The software is available on University of Manchester Computer Labs. If you make regular use of MATLAB you should consider purchasing your own software. The Student Version of MATLAB is available, for instance, from [http://www.amazon.co.uk/MATLAB-Simulink-Student-Version-R2014a/dp/0989614026/ref=sr_1_1?s=software&ie=UTF8&qid=1411983990&sr=1-1&keywords=matlab+2014 Amazon] for £66. This is a real bargain, considering that the equivalent non-discounted package would come in at about £4,000.

=== Freely available toolboxes ===

The following toolboxes are freely available and contain extremely useful procedures

* Spatial Econometrics by James P. LeSage [http://www.spatial-econometrics.com/]. This toolbox contains a wide variety of useful econometrics functions. It also contains an excellent documentation. In addition to quite general econometric functions you will, as the name suggests, find a huge list of functions relevant if you are working with spatial data.
* <div id="MFEtoolbox"></div>Oxford MFE toolbox by Kevin Sheppard [https://bitbucket.org/kevinsheppard/mfe_toolbox]. Use the download link in the box on the right that starts with "Owner: Kevin Sheppard". This toolbox contains many useful functions for uni- and multivariate volatility models.

You need to copy these toolboxes into your MATLAB toolbox folder and add the respective path to the MATLAB list of folders it searches for functions. (In the main menu select FILE and then SET PATH where you can add the folders you added.) If you work on a computer for which you have no administrator rights, this strategy may not work. This [http://youtu.be/_32OqcW9WoY?hd=1 Example Clip] demonstrates what to do in that case. It is just a matter of adding one line into your code! Piece of cake.

=== Literature and other learning resources ===
* [http://www.kevinsheppard.com/wiki/MFE_Toolbox: Kevin Sheppard's MATLAB introduction].
* Martin V., Hurn S. and Harris D. (2012) Econometric Modelling with Time Series: Specification, Estimation and Testing (Themes in Modern Econometrics).[http://www.amazon.co.uk/Econometric-Modelling-Time-Specification-Econometrics/dp/0521196604/ref=sr_1_1?s=books&ie=UTF8&qid=1345214275&sr=1-1] This book contains an extensive library of relevant MATLAB codes.
* Higham, D.J. and Higham, N.J. (2005) MATLAB Guide, Society for Industrial and Applied Mathematics [http://www.amazon.co.uk/MATLAB-Guide-Desmond-J-Higham/dp/0898715784/ref=sr_1_1?s=books&ie=UTF8&qid=1347377409&sr=1-1]
This website does not cover any theoretical ground and is no substitute for any Econometric Textbook. There is a wide range of very good Econometric Textbooks available. If you are concerned about programming in MATLAB than you are likely to appreciate textbooks that use matrix notation. Here are two very good books that fit that bill:
* Heij C., de Boer P., Franses P.H., Kloek T. and van Dijk H.K (2004) Econometric Methods with Applications in Business and Economics, Oxford University Press, New York.[http://www.amazon.co.uk/Econometric-Methods-Applications-Business-Economics/dp/0199268010/ref=sr_1_1?s=books&ie=UTF8&qid=1354473313&sr=1-1]
* Greene W.H. (2012) Econometric Analysis, Pearson, Harlow.[http://www.amazon.co.uk/Econometric-Analysis-William-H-Greene/dp/0273753568/ref=sr_1_1?ie=UTF8&qid=1354473593&sr=8-1]

MATLAB

2022-02-08T08:30:57Z

Rb: /* Special Econometric Topics */

== <div id="Essential"></div>The Essential MATLAB Programming Techniques ==

In this section we will introduce a number of basic and intermediate programming techniques. Whatever language you program in you will encounter these techniques, although the details will, of course, vary. We recommend that you ensure that you are familiar with these before you progress to [[#SpecEcmtrTopics| Special Econometric Topics ]].

=== Basic Programming ===

{| class="wikitable"
|-
! scope="col"| Basics and Matrices
! scope="col"| Loading Data and Date Formats
! scope="col"| Program Flow and Logicals
! scope="col"| Functions
! scope="col"| Saving Data and Screen Output
|-
| [[Discussion]] [http://www.youtube.com/watch?v=av5MgVpybT0&feature=youtu.be&hd=1 Example Clip]
| [[LoadingData|Discussion]] [http://youtu.be/jyb68zGM2ik?hd=1 ExampleClip]
| [[Program Flow and Logicals|Discussion]]
| [[Function|Discussion]] [[FctExampleCode|Example Code]] [[media:OLSexample.xls|OLSexample.xls]] [http://youtu.be/FPw9DH8pfiU?hd=1 Example Clip]
| [[SavingData|Discussion]]
|}

After having gone through these basic techniques you may want to test your newly acquired skills with the following examples.

{| class="wikitable"
|-
! scope="col"| Example 1
! scope="col"| Example 2
|-
| [[Example 1]]
| [[Example 2|Example2a]] [[Example 2b|Example2b]]
|}

=== Intermediate Programming ===

{| class="wikitable"
|-
! scope="col"| Statistical Functions
! scope="col"| Arrays and Structures
! scope="col"| Debugging
! scope="col"| Graphing Data
! scope="col"| Function Handlers Anonymous Functions
|-
| [[StatFunct|Discussion]]
| [[ArrayStructures|Discussion]]
| coming soon
| [[Graphing|Discussion]]
| [[Anonym|Discussion]]
|}

=== Advanced Programming ===

Sorry, but this cannot be taught! It will come with experience. Find someone who has experience in MATLAB programming and let him or her look over your code.

== Nonlinear Optimisation ==

The optimal parameters in a linear econometric model (assuming certain assumptions) can be found analytically. We call them the Ordinary Least Squares (OLS) estimates and they are easily calculated with a certain formula (see the [[FctExampleCode#OLSestm|OLSest.m]] function). When econometric models do not have such an analytical solution, an alternative parameter estimation strategy is required. In essence it is a clever "trial and error" strategy. This is often called nonlinear optimisation.

Nonlinear optimisation is a very important, but also a very tricky area of econometric computing. It certainly helps to understand some of the underlying theory and therefore we have below separate sections on the theory and implementation.

{| class="wikitable"
|-
! scope="col"| Theory
! scope="col"| Implementation
! scope="col"| Constrained Optimisation
|-
| [[NonlinOptTheory| Discussion]]
| [[NonlinOptImp| Discussion]]
| [[ConNonlinOptImp| Discussion]]
|}

== <div id="SpecEcmtrTopics"></div> Special Econometric Topics ==

Topics in this Section will assume that you have mastered all the techniques covered in the [[#Essential| Essential Programming Section ]]

{| class="wikitable"
|-
! scope="col"| Robust standard errors
! scope="col"| Univariate Time Series
! scope="col"| Unit Root and Stationarity Testing
! scope="col"| Forecasting
|-
| [[RobInf|Discussion]] [[ExampleCodeOLShac|Example Code]]
| [[UniTS|Discussion]] [[media:FXrateUSEU.xls|FXrateUSEU.xls]] [[media:USGDP.xls|USGDP.xls]]
| coming soon
| [[Forecasting|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Maximum Likelihood
! scope="col"| Generalized Methods of Moments
! scope="col"| Instrumental Variables
! scope="col"| Bayesian Estimation
|-
| [[MaxLik|Discussion]] [[MaxLikCode|Example Code]]
| [[GMM|2-step est]] [https://youtu.be/qwDPOomNG1c video] [[media:US3monthRate.xlsx|US3monthRate.xlsx]] [[media: gradp.m|gradp.m]]
| [[IV|Discussion]] [[ExampleCodeIV|Example Code]]
| [[Bayes|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Monte-Carlo/ Simulation Techniques
! scope="col"| Binary Response Models
! scope="col"| Handling High Frequency Data
|-
| coming soon
| coming soon
| coming soon

|}

== Other useful MATLAB resources ==

=== The MATLAB Software ===

The software is available on University of Manchester Computer Labs. If you make regular use of MATLAB you should consider purchasing your own software. The Student Version of MATLAB is available, for instance, from [http://www.amazon.co.uk/MATLAB-Simulink-Student-Version-R2014a/dp/0989614026/ref=sr_1_1?s=software&ie=UTF8&qid=1411983990&sr=1-1&keywords=matlab+2014 Amazon] for £66. This is a real bargain, considering that the equivalent non-discounted package would come in at about £4,000.

=== Freely available toolboxes ===

The following toolboxes are freely available and contain extremely useful procedures

* Spatial Econometrics by James P. LeSage [http://www.spatial-econometrics.com/]. This toolbox contains a wide variety of useful econometrics functions. It also contains an excellent documentation. In addition to quite general econometric functions you will, as the name suggests, find a huge list of functions relevant if you are working with spatial data.
* <div id="MFEtoolbox"></div>Oxford MFE toolbox by Kevin Sheppard [https://bitbucket.org/kevinsheppard/mfe_toolbox]. Use the download link in the box on the right that starts with "Owner: Kevin Sheppard". This toolbox contains many useful functions for uni- and multivariate volatility models.

You need to copy these toolboxes into your MATLAB toolbox folder and add the respective path to the MATLAB list of folders it searches for functions. (In the main menu select FILE and then SET PATH where you can add the folders you added.) If you work on a computer for which you have no administrator rights, this strategy may not work. This [http://youtu.be/_32OqcW9WoY?hd=1 Example Clip] demonstrates what to do in that case. It is just a matter of adding one line into your code! Piece of cake.

=== Literature and other learning resources ===
* [http://www.kevinsheppard.com/wiki/MFE_Toolbox: Kevin Sheppard's MATLAB introduction].
* Martin V., Hurn S. and Harris D. (2012) Econometric Modelling with Time Series: Specification, Estimation and Testing (Themes in Modern Econometrics).[http://www.amazon.co.uk/Econometric-Modelling-Time-Specification-Econometrics/dp/0521196604/ref=sr_1_1?s=books&ie=UTF8&qid=1345214275&sr=1-1] This book contains an extensive library of relevant MATLAB codes.
* Higham, D.J. and Higham, N.J. (2005) MATLAB Guide, Society for Industrial and Applied Mathematics [http://www.amazon.co.uk/MATLAB-Guide-Desmond-J-Higham/dp/0898715784/ref=sr_1_1?s=books&ie=UTF8&qid=1347377409&sr=1-1]
This website does not cover any theoretical ground and is no substitute for any Econometric Textbook. There is a wide range of very good Econometric Textbooks available. If you are concerned about programming in MATLAB than you are likely to appreciate textbooks that use matrix notation. Here are two very good books that fit that bill:
* Heij C., de Boer P., Franses P.H., Kloek T. and van Dijk H.K (2004) Econometric Methods with Applications in Business and Economics, Oxford University Press, New York.[http://www.amazon.co.uk/Econometric-Methods-Applications-Business-Economics/dp/0199268010/ref=sr_1_1?s=books&ie=UTF8&qid=1354473313&sr=1-1]
* Greene W.H. (2012) Econometric Analysis, Pearson, Harlow.[http://www.amazon.co.uk/Econometric-Analysis-William-H-Greene/dp/0273753568/ref=sr_1_1?ie=UTF8&qid=1354473593&sr=8-1]

MATLAB

2022-02-08T08:29:16Z

Rb: /* Special Econometric Topics */

== <div id="Essential"></div>The Essential MATLAB Programming Techniques ==

In this section we will introduce a number of basic and intermediate programming techniques. Whatever language you program in you will encounter these techniques, although the details will, of course, vary. We recommend that you ensure that you are familiar with these before you progress to [[#SpecEcmtrTopics| Special Econometric Topics ]].

=== Basic Programming ===

{| class="wikitable"
|-
! scope="col"| Basics and Matrices
! scope="col"| Loading Data and Date Formats
! scope="col"| Program Flow and Logicals
! scope="col"| Functions
! scope="col"| Saving Data and Screen Output
|-
| [[Discussion]] [http://www.youtube.com/watch?v=av5MgVpybT0&feature=youtu.be&hd=1 Example Clip]
| [[LoadingData|Discussion]] [http://youtu.be/jyb68zGM2ik?hd=1 ExampleClip]
| [[Program Flow and Logicals|Discussion]]
| [[Function|Discussion]] [[FctExampleCode|Example Code]] [[media:OLSexample.xls|OLSexample.xls]] [http://youtu.be/FPw9DH8pfiU?hd=1 Example Clip]
| [[SavingData|Discussion]]
|}

After having gone through these basic techniques you may want to test your newly acquired skills with the following examples.

{| class="wikitable"
|-
! scope="col"| Example 1
! scope="col"| Example 2
|-
| [[Example 1]]
| [[Example 2|Example2a]] [[Example 2b|Example2b]]
|}

=== Intermediate Programming ===

{| class="wikitable"
|-
! scope="col"| Statistical Functions
! scope="col"| Arrays and Structures
! scope="col"| Debugging
! scope="col"| Graphing Data
! scope="col"| Function Handlers Anonymous Functions
|-
| [[StatFunct|Discussion]]
| [[ArrayStructures|Discussion]]
| coming soon
| [[Graphing|Discussion]]
| [[Anonym|Discussion]]
|}

=== Advanced Programming ===

Sorry, but this cannot be taught! It will come with experience. Find someone who has experience in MATLAB programming and let him or her look over your code.

== Nonlinear Optimisation ==

The optimal parameters in a linear econometric model (assuming certain assumptions) can be found analytically. We call them the Ordinary Least Squares (OLS) estimates and they are easily calculated with a certain formula (see the [[FctExampleCode#OLSestm|OLSest.m]] function). When econometric models do not have such an analytical solution, an alternative parameter estimation strategy is required. In essence it is a clever "trial and error" strategy. This is often called nonlinear optimisation.

Nonlinear optimisation is a very important, but also a very tricky area of econometric computing. It certainly helps to understand some of the underlying theory and therefore we have below separate sections on the theory and implementation.

{| class="wikitable"
|-
! scope="col"| Theory
! scope="col"| Implementation
! scope="col"| Constrained Optimisation
|-
| [[NonlinOptTheory| Discussion]]
| [[NonlinOptImp| Discussion]]
| [[ConNonlinOptImp| Discussion]]
|}

== <div id="SpecEcmtrTopics"></div> Special Econometric Topics ==

Topics in this Section will assume that you have mastered all the techniques covered in the [[#Essential| Essential Programming Section ]]

{| class="wikitable"
|-
! scope="col"| Robust standard errors
! scope="col"| Univariate Time Series
! scope="col"| Unit Root and Stationarity Testing
! scope="col"| Forecasting
|-
| [[RobInf|Discussion]] [[ExampleCodeOLShac|Example Code]]
| [[UniTS|Discussion]] [[media:FXrateUSEU.xls|FXrateUSEU.xls]] [[media:USGDP.xls|USGDP.xls]]
| coming soon
| [[Forecasting|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Maximum Likelihood
! scope="col"| Generalized Methods of Moments
! scope="col"| Instrumental Variables
! scope="col"| Bayesian Estimation
|-
| [[MaxLik|Discussion]] [[MaxLikCode|Example Code]]
| [[GMM|2-step est]] [https://youtu.be/NeUiDYr3ML0 video] [[media:US3monthRate.xlsx|US3monthRate.xlsx]] [[media: gradp.m|gradp.m]]
| [[IV|Discussion]] [[ExampleCodeIV|Example Code]]
| [[Bayes|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Monte-Carlo/ Simulation Techniques
! scope="col"| Binary Response Models
! scope="col"| Handling High Frequency Data
|-
| coming soon
| coming soon
| coming soon

|}

== Other useful MATLAB resources ==

=== The MATLAB Software ===

The software is available on University of Manchester Computer Labs. If you make regular use of MATLAB you should consider purchasing your own software. The Student Version of MATLAB is available, for instance, from [http://www.amazon.co.uk/MATLAB-Simulink-Student-Version-R2014a/dp/0989614026/ref=sr_1_1?s=software&ie=UTF8&qid=1411983990&sr=1-1&keywords=matlab+2014 Amazon] for £66. This is a real bargain, considering that the equivalent non-discounted package would come in at about £4,000.

=== Freely available toolboxes ===

The following toolboxes are freely available and contain extremely useful procedures

* Spatial Econometrics by James P. LeSage [http://www.spatial-econometrics.com/]. This toolbox contains a wide variety of useful econometrics functions. It also contains an excellent documentation. In addition to quite general econometric functions you will, as the name suggests, find a huge list of functions relevant if you are working with spatial data.
* <div id="MFEtoolbox"></div>Oxford MFE toolbox by Kevin Sheppard [https://bitbucket.org/kevinsheppard/mfe_toolbox]. Use the download link in the box on the right that starts with "Owner: Kevin Sheppard". This toolbox contains many useful functions for uni- and multivariate volatility models.

You need to copy these toolboxes into your MATLAB toolbox folder and add the respective path to the MATLAB list of folders it searches for functions. (In the main menu select FILE and then SET PATH where you can add the folders you added.) If you work on a computer for which you have no administrator rights, this strategy may not work. This [http://youtu.be/_32OqcW9WoY?hd=1 Example Clip] demonstrates what to do in that case. It is just a matter of adding one line into your code! Piece of cake.

=== Literature and other learning resources ===
* [http://www.kevinsheppard.com/wiki/MFE_Toolbox: Kevin Sheppard's MATLAB introduction].
* Martin V., Hurn S. and Harris D. (2012) Econometric Modelling with Time Series: Specification, Estimation and Testing (Themes in Modern Econometrics).[http://www.amazon.co.uk/Econometric-Modelling-Time-Specification-Econometrics/dp/0521196604/ref=sr_1_1?s=books&ie=UTF8&qid=1345214275&sr=1-1] This book contains an extensive library of relevant MATLAB codes.
* Higham, D.J. and Higham, N.J. (2005) MATLAB Guide, Society for Industrial and Applied Mathematics [http://www.amazon.co.uk/MATLAB-Guide-Desmond-J-Higham/dp/0898715784/ref=sr_1_1?s=books&ie=UTF8&qid=1347377409&sr=1-1]
This website does not cover any theoretical ground and is no substitute for any Econometric Textbook. There is a wide range of very good Econometric Textbooks available. If you are concerned about programming in MATLAB than you are likely to appreciate textbooks that use matrix notation. Here are two very good books that fit that bill:
* Heij C., de Boer P., Franses P.H., Kloek T. and van Dijk H.K (2004) Econometric Methods with Applications in Business and Economics, Oxford University Press, New York.[http://www.amazon.co.uk/Econometric-Methods-Applications-Business-Economics/dp/0199268010/ref=sr_1_1?s=books&ie=UTF8&qid=1354473313&sr=1-1]
* Greene W.H. (2012) Econometric Analysis, Pearson, Harlow.[http://www.amazon.co.uk/Econometric-Analysis-William-H-Greene/dp/0273753568/ref=sr_1_1?ie=UTF8&qid=1354473593&sr=8-1]

GMM

2022-02-08T08:25:57Z

Rb:

The code below performs a standard 2 step GMM estimation.
In this code the estimation is exactly identified (number of moments = number of parameters)

<source>
%=========================================================================
%
% Program to estimate level effect in interest rates by GMM
%
% Code based on Martin, Hurn and Harris, Econometric Time Series Modelling
% Specification, Estimation and Testing
% https://www.cambridge.org/features/econmodelling/chapter10.htm
%
% This code by Ralf Becker, March 2021
% http://eclr.humanities.manchester.ac.uk/index.php/MATLAB
%=========================================================================

clear all;
clc;
cd 'YOUR DIRECTORY'

% Load data --- monthly December 1946 to February 1991
% 3 month maturity
% extracted from the datafile provided by
% Martin, Hurn and Harris
% https://www.cambridge.org/features/econmodelling/chapter10.htm

[rt, ~, ~] = xlsread('US3monthRate.xlsx');

drt = trimr(rt,2,0) - trimr(rt,1,1); % creates \Delta r_{t+1}
r1t = trimr(rt,1,1); % creates r_t
r2t = trimr(rt,0,2);
t = length(drt);

%% It is typically good practice to visualise the data
tt = seqa(1946+12/12,1/12,t); % Creates year sequence

subplot(1,2,1);
plot(tt,r1t);
title('r_t')
box off
axis tight

subplot(1,2,2);
plot(tt,drt);
title('\Delta r_{t+1}')
box off
axis tight

%% Estimate the model in the first stage with idendity weighting matrix

ops = optimset('LargeScale','off','Display','off');
b0 = [0.1;0.1;0.1;1.0];
w0 = eye(length(b0));
bgmm1 = fminunc(@(b) qw(b,drt,r1t,w0),b0,ops);

disp('First Stage GMM estimates')
disp(bgmm1)

%% Now estimate the optimal weighting matrix
% using Newey-West estimator
lmax = 5; % lag for the NW estimate
d = meqn(bgmm1,drt,r1t);

% this will calculate Newey-West VCM using lmax lags
s = d'*d;
tau = 1;
while tau <= lmax
wtau = d((tau+1):size(d,1),:)'*d(1:(size(d,1)-tau),:);
s = s + (1.0-tau/(lmax+1))*(wtau + wtau');
tau = tau + 1;
end
w1 = s./t;

% Use this as the weighting matrix for the next pass to the optimisation
% function

%% 2nd Stage

bgmm2 = fminunc(@(b) qw(b,drt,r1t,w1),bgmm1,ops);

disp('Second Stage GMM estimates')
disp(bgmm2)

%% Further Iterations
% You could run further iterations
% 1) Re-calculate d
% 2) Re-calculate the optimal weighting matrix w based on the new d
% 3) Re-estimate using the new w
%
% For now we stop here
bgmm = bgmm2;
obj = qw(bgmm,drt,r1t,w1);

%% Calculate standard errors
% Compute optimal weigthing matrix at GMM estimates
% using Newey-West estimator
lmax = 5; % lag for the NW estimate
d = meqn(bgmm,drt,r1t);

% this will calculate Newey-West VCM using lmax lags
s = d'*d;
tau = 1;
while tau <= lmax
wtau = d((tau+1):size(d,1),:)'*d(1:(size(d,1)-tau),:);
s = s + (1.0-tau/(lmax+1))*(wtau + wtau');
tau = tau + 1;
end
s = s./t;

% Compute standard errors of GMM estimates
dg = numgrad(@meaneqn,bgmm,drt,r1t);
v = dg'*inv(s)*dg;
cov = inv(v)/t;
se = sqrt(diag(cov));

disp(' ');
disp(['The value of the objective function = ', num2str(obj) ]);
disp(['J-test = ', num2str(t*obj) ]);
disp('Estimates Std err. t-stats');
disp( [ bgmm se bgmm./se ])
disp(['Newey-West estimator with max lag = ', num2str(lmax) ]);
disp(' ');

%% Inference t-tests

% Test of gam = 0.0
stat = (bgmm(4) - 0.0)/se(4);
disp(['Test of (gam=0.0) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 0.5
stat = (bgmm(4) - 0.5)/se(4);
disp(['Test of (gam=0.5) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 1.0
stat = (bgmm(4) - 1.0)/se(4);
disp(['Test of (gam=1.0) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 1.5
stat = (bgmm(4) - 1.5)/se(4);
disp(['Test of (gam=1.5) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

%% Inference - Overidentifying restrictions

%% Plot volatility function for alternative values of gam
tt = seqa(1946+12/12,1/12,t);
figure(1)

subplot(2,2,1);
plot(tt,drt./r1t.^0.0);
title('$\gamma=0.0$')
box off
axis tight

subplot(2,2,2);
plot(tt,drt./r1t.^0.5);
title('$\gamma=0.5$')
box off
axis tight

subplot(2,2,3);
plot(tt,drt./r1t.^1.0);
title('$\gamma=1.0$')
box off
axis tight

subplot(2,2,4);
plot(tt,drt./r1t.^1.5);
title('$\gamma=1.5$')
box off
axis tight

%
%------------------------- Functions -------------------------------------%
%
%-------------------------------------------------------------------------%
% Define the moment equations
%-------------------------------------------------------------------------%
function dt = meqn(b,drt,r1t)

ut = drt - b(1) - b(2)*r1t;
zt = [ones(size(ut,1),1),r1t];
dt = repmat(ut,1,2).*zt;
dt = [dt,repmat((ut.^2 - (b(3)^2)*r1t.^(2*b(4)) ),1,2).*zt];

end
%-------------------------------------------------------------------------%
% Defines the mean of the moment conditions
%-------------------------------------------------------------------------%
function ret = meaneqn(b,drt,r1t)

ret = (mean(meqn(b,drt,r1t)))';

end

%-------------------------------------------------------------------------%
% GMM objective function with user defined
% weighting matrix, w
%-------------------------------------------------------------------------%
function ret = qw(b,drt,r1t,w)

t = length(drt);
d = meqn(b,drt,r1t);
g = mean(d)';

ret = g'*inv(w)*g;
end

</source>

GMM

2022-02-08T08:24:56Z

Rb:

<source>
%=========================================================================
%
% Program to estimate level effect in interest rates by GMM
%
% Code based on Martin, Hurn and Harris, Econometric Time Series Modelling
% Specification, Estimation and Testing
% https://www.cambridge.org/features/econmodelling/chapter10.htm
%
% This code by Ralf Becker, March 2021
% http://eclr.humanities.manchester.ac.uk/index.php/MATLAB
%=========================================================================

clear all;
clc;
cd 'YOUR DIRECTORY'

% Load data --- monthly December 1946 to February 1991
% 3 month maturity
% extracted from the datafile provided by
% Martin, Hurn and Harris
% https://www.cambridge.org/features/econmodelling/chapter10.htm

[rt, ~, ~] = xlsread('US3monthRate.xlsx');

drt = trimr(rt,2,0) - trimr(rt,1,1); % creates \Delta r_{t+1}
r1t = trimr(rt,1,1); % creates r_t
r2t = trimr(rt,0,2);
t = length(drt);

%% It is typically good practice to visualise the data
tt = seqa(1946+12/12,1/12,t); % Creates year sequence

subplot(1,2,1);
plot(tt,r1t);
title('r_t')
box off
axis tight

subplot(1,2,2);
plot(tt,drt);
title('\Delta r_{t+1}')
box off
axis tight

%% Estimate the model in the first stage with idendity weighting matrix

ops = optimset('LargeScale','off','Display','off');
b0 = [0.1;0.1;0.1;1.0];
w0 = eye(length(b0));
bgmm1 = fminunc(@(b) qw(b,drt,r1t,w0),b0,ops);

disp('First Stage GMM estimates')
disp(bgmm1)

%% Now estimate the optimal weighting matrix
% using Newey-West estimator
lmax = 5; % lag for the NW estimate
d = meqn(bgmm1,drt,r1t);

% this will calculate Newey-West VCM using lmax lags
s = d'*d;
tau = 1;
while tau <= lmax
wtau = d((tau+1):size(d,1),:)'*d(1:(size(d,1)-tau),:);
s = s + (1.0-tau/(lmax+1))*(wtau + wtau');
tau = tau + 1;
end
w1 = s./t;

% Use this as the weighting matrix for the next pass to the optimisation
% function

%% 2nd Stage

bgmm2 = fminunc(@(b) qw(b,drt,r1t,w1),bgmm1,ops);

disp('Second Stage GMM estimates')
disp(bgmm2)

%% Further Iterations
% You could run further iterations
% 1) Re-calculate d
% 2) Re-calculate the optimal weighting matrix w based on the new d
% 3) Re-estimate using the new w
%
% For now we stop here
bgmm = bgmm2;
obj = qw(bgmm,drt,r1t,w1);

%% Calculate standard errors
% Compute optimal weigthing matrix at GMM estimates
% using Newey-West estimator
lmax = 5; % lag for the NW estimate
d = meqn(bgmm,drt,r1t);

% this will calculate Newey-West VCM using lmax lags
s = d'*d;
tau = 1;
while tau <= lmax
wtau = d((tau+1):size(d,1),:)'*d(1:(size(d,1)-tau),:);
s = s + (1.0-tau/(lmax+1))*(wtau + wtau');
tau = tau + 1;
end
s = s./t;

% Compute standard errors of GMM estimates
dg = numgrad(@meaneqn,bgmm,drt,r1t);
v = dg'*inv(s)*dg;
cov = inv(v)/t;
se = sqrt(diag(cov));

disp(' ');
disp(['The value of the objective function = ', num2str(obj) ]);
disp(['J-test = ', num2str(t*obj) ]);
disp('Estimates Std err. t-stats');
disp( [ bgmm se bgmm./se ])
disp(['Newey-West estimator with max lag = ', num2str(lmax) ]);
disp(' ');

%% Inference t-tests

% Test of gam = 0.0
stat = (bgmm(4) - 0.0)/se(4);
disp(['Test of (gam=0.0) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 0.5
stat = (bgmm(4) - 0.5)/se(4);
disp(['Test of (gam=0.5) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 1.0
stat = (bgmm(4) - 1.0)/se(4);
disp(['Test of (gam=1.0) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 1.5
stat = (bgmm(4) - 1.5)/se(4);
disp(['Test of (gam=1.5) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

%% Inference - Overidentifying restrictions

%% Plot volatility function for alternative values of gam
tt = seqa(1946+12/12,1/12,t);
figure(1)

subplot(2,2,1);
plot(tt,drt./r1t.^0.0);
title('$\gamma=0.0$')
box off
axis tight

subplot(2,2,2);
plot(tt,drt./r1t.^0.5);
title('$\gamma=0.5$')
box off
axis tight

subplot(2,2,3);
plot(tt,drt./r1t.^1.0);
title('$\gamma=1.0$')
box off
axis tight

subplot(2,2,4);
plot(tt,drt./r1t.^1.5);
title('$\gamma=1.5$')
box off
axis tight

%
%------------------------- Functions -------------------------------------%
%
%-------------------------------------------------------------------------%
% Define the moment equations
%-------------------------------------------------------------------------%
function dt = meqn(b,drt,r1t)

ut = drt - b(1) - b(2)*r1t;
zt = [ones(size(ut,1),1),r1t];
dt = repmat(ut,1,2).*zt;
dt = [dt,repmat((ut.^2 - (b(3)^2)*r1t.^(2*b(4)) ),1,2).*zt];

end
%-------------------------------------------------------------------------%
% Defines the mean of the moment conditions
%-------------------------------------------------------------------------%
function ret = meaneqn(b,drt,r1t)

ret = (mean(meqn(b,drt,r1t)))';

end

%-------------------------------------------------------------------------%
% GMM objective function with user defined
% weighting matrix, w
%-------------------------------------------------------------------------%
function ret = qw(b,drt,r1t,w)

t = length(drt);
d = meqn(b,drt,r1t);
g = mean(d)';

ret = g'*inv(w)*g;
end

</source>

Diff in Diff

2021-04-15T08:16:23Z

Rb: Created page with "An excellent example of a Difference-in-Difference application is the one where changes in the Minimum Legal Drinking Age are related to casualties resulting from traffic acci..."

An excellent example of a Difference-in-Difference application is the one where changes in the Minimum Legal Drinking Age are related to casualties resulting from traffic accidents. A walkthrough such an application is available from [https://github.com/datasquad/RforQM/blob/master/Diff_in_Diff/mlda-dd.pdf Ralf Becker's github page]. The data used in this example are available from here: [https://github.com/datasquad/RforQM/blob/master/Diff_in_Diff/deaths.Rdata deaths.Rdata] and here [https://github.com/datasquad/RforQM/blob/master/Diff_in_Diff/USstate_pop_1980.xlsx USstate_pop_1980.xlsx].

R

2021-04-15T08:10:00Z

Rb: /* Intermediate Techniques */

R is an open source software that has been been adopted by the statistical community as its standard software package. It is a command driven software, meaning that you will have to give the software written commands to indicate what you do. On first sight this is not as convenient as a menu driven software, but it has the huge advantage that you can collect a large set of commands in a file (script file) and then have R execute all these commands in one go. This then serves as a great documentation of the work you have done and most importantly it makes it easy to change a small aspect of your work and rerun the entire project on the press of a button rather than having to laboriously retrace all your steps through menus.

The fixed cost of learning this software is higher than learning a menu driven statistical software package. But if you engage with this process the rewards will be great.

Last not least, R has a killer advantage. It is free!!!

== Installing the Software ==

[https://youtu.be/EHjakj38Nnw?hd=1 Installation Demonstration]

To work with R you will have to install the basic software package R, but we also advise you to install RStudio, which is an add-on to R (formally called an Integrated Development Environment - IDE) which makes working with R easier.

As this is open-source software that you get for free it is perhaps understandable that the webpages from which you get the R software aren't as slick as you expect. And the language tends to be somewhat more techy, but don't worry, you'll be fine.

So here are the steps you should take.

# Download and install the R software, which is available from the [http://cran.rstudio.com/ CRAN] website. Follow the "Download and Install R" link (and do not be tempted to download the source code!) for your operating system. If you have a window OS only choose the "base" package on the following screen. Then follow the usual installation instructions. You could now already work with R, but we recommend that you first undertake the next step.
# Once we have installed R, we can download and install RStudio. You can download it from the [http://www.rstudio.com/products/rstudio/download/ RStudio] download page.

The basic R software has some basic functionality, but the power of R comes from the ability to use code written to perform statistical and econometric techniques that has been written by other people. These additional pieces of software are called packages and the next step will be to learn how ot use these.

== Data Sets ==

We use a number of datasets on this page. For convenience they are listed here:

{| class="wikitable"
|-
! scope="col"|
! scope="col"| Women's wages
! scope="col"| Crime Statistics
! scope="col"| Baseball Wages
|-
| '''Description'''
| Observations for 753 females on wages, familiar and work circumstances hours worked and wages
| Crime Statistics for 90 counties in North Carolina (US) for Years 1981 to 1987 (Panel Data); includes a number of variables to characterise the counties
| Salary and other information (such as race, position and performance information) for 353 Baseball Players in 1993
|-
| '''Files'''
| [[media:mroz.xls|mroz.xls]] [[media:mroz.csv|mroz.csv]] [[MROZ_Variable_Description|Variable Description]]
| [[media:crim4.xls|crime4.xls]] [[media:crim4.csv|crime4.csv]] [[Crim4_Variable_Description|Variable Description]]
| [[media:mlb1.xls|mlb1.xls]] [[media:mlb1.csv|mlb1.csv]] [[MLB1_Variable_Description|Variable Description]]
|-
| '''Source'''
| [http://www.cengagebrain.com/cgi-wadsworth/course_products_wp.pl?fid=M20b&product_isbn_issn=9781111531041&token=8D04240DC39B22D05B49B265F2C8E62C6876DDE99FE979BC4A500075EC976963ED1045639B2C75C4B5B2337F07088998 Wooldridge Book Companion Page]
| [http://www.cengagebrain.com/cgi-wadsworth/course_products_wp.pl?fid=M20b&product_isbn_issn=9781111531041&token=8D04240DC39B22D05B49B265F2C8E62C6876DDE99FE979BC4A500075EC976963ED1045639B2C75C4B5B2337F07088998 Wooldridge Book Companion Page]
| [http://www.cengagebrain.com/cgi-wadsworth/course_products_wp.pl?fid=M20b&product_isbn_issn=9781111531041&token=8D04240DC39B22D05B49B265F2C8E62C6876DDE99FE979BC4A500075EC976963ED1045639B2C75C4B5B2337F07088998 Wooldridge Book Companion Page]
|}

Following the links in the above table you will also be able to download R data files for these datasets.

== Basic Tasks ==

To illustrate how to perform basic tasks in R we will use the Women's wages dataset ([[media:mroz.csv|mroz.csv]]). This is a comma separated value (csv) file that contains a dataset which we will use for our first steps in R. It is a well used cross-sectional dataset with 753 observations of female members of the labour force in the US (in 1975). It contains variables such as the number of children, the wage, the hours worked etc.

{| class="wikitable"
|-
! scope="col"| First Steps
! scope="col"| Loading Data and Date Formats
! scope="col"| Using Packages

|-
| [[R_FirstSteps|Discussion]]
| [[R_Data|Discussion]]
| [[R_Packages|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Basic Data Analysis
! scope="col"| Data Analysis Tidyverse
! scope="col"| A Regression
|-
| [[R_Analysis|Discussion]]
| [[R_AnalysisTidy|Discussion]]
| [[R_Regression|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Creating Graphics
! scope="col"| Saving Data and Screen Output
|-
| [[R_Graphing|Discussion]] [[R_Graphing_Treat|Treat Yourself]]
| [[R_SavingData|Discussion]]
|}

== Bread and Butter Techniques ==

These are standard econometric problems tasks that any applied econometrician, and indeed aspiring economics students, should be familiar with.

{| class="wikitable"
|-
! scope="col"| Dummy variables
! scope="col"| Predicting from a Regression

|-
| [[Dummy Variables in R|Discussion]]
| [[Predicting from Regression in R|Discussion]]

|}

{| class="wikitable"
|-
! scope="col"| Standard inference
! scope="col"| Regression diagnostics
! scope="col"| Robust standard errors
|-
| [[Regression Inference in R|Discussion]]
| [[R_reg_diag|Discussion]]
| [[R_robust_se|Discussion]]
|}

== Intermediate Techniques ==

{| class="wikitable"
|-
! scope="col"| Panel Data
! scope="col"| Instrumental Variables Estimation
! scope="col"| Matching
! scope="col"| Difference-in-Difference
|-
| [[Panel in R|Discussion]]
| [[IV in R|Discussion]]
| [[R_Matching|Discussion]]
| [[Diff_in_Diff|Discussion]]
|}

{| class="wikitable"
|-

! scope="col"| Univariate Time Series Modelling
! scope="col"| Multivariate Time Series Modelling VAR
! scope="col"| Time Series Plotting
! scope="col"| Univariate and Multivariate GARCH Modelling
|-
| [[R_TimeSeries|Discussion]]
| [[R_TS_VAR|Discussion]]
| [[R_TSplots|Discussion]] uses the following data files: [[Media:AggInfl.csv|AggInfl.csv]],[[Media:CoreInfl.csv|CoreInfl.csv]] [[Media:EnergInfl.csv|EnergInfl.csv]],[[Media:FoodInfl.csv|FoodInfl.csv]]
| [[R_GARCH|Discussion]]
|}

{| class="wikitable"
|-

! scope="col"| Bayesian Estimation Principle
|-
| [[R_BayesGrid|Discussion]]

|}

== Some Fun Stuff ==

{| class="wikitable"
|-
! scope="col"| Plotting Maps
! scope="col"| Scraping the internet
|-
| [[Maps in R|Discussion]]
| [[Scraping in R|Discussion]]
|}

== Econometric Demonstrations ==

In this section you can find code that can be useful to demonstrate a few econometric issues.

{| class="wikitable"
|-
! scope="col"| Sampling and LLN and CLT
! scope="col"| Demonstrating OLS estimator unbiasedness
! scope="col"| Demonstrating OLS estimator asymptotic behaviour
|-
| [[R_Sampling|Discussion]]
| [[R_Unbiasedness|Discussion]]
| [[R_Asymptotics|Discussion]]
|}

== Authors, Maintenance and Contributions ==

This wiki was created by [mailto:ralf.becker@manchester.ac.uk Ralf Becker] and [mailto:james.lincoln@manchester.ac.uk James Lincoln] with the financial support of a University of Manchester CHERIL grant. If you have any suggestions please contact us by email. Contributions to this wiki are encouraged. Please contact us if you are interested.

An easy way to create content for this page is to write RMarkdown documents which can then easily be translated, thanks to pandoc, to MediaWiki format (see [http://nicercode.github.io/guides/reports/]). From the command window call "pandoc -f markdown -t MediaWiki FILENAME.md -o FILENAME.mediawiki".

== More references ==

There is a plethora of resources if you want to learn R (which is one reason why this resource does not go into too much detail). Here are a few places to start.

* A dedicated tweet channel for Econometrics with R [https://twitter.com/Rstats4Econ]
* Rob Hyndman has great material [http://robjhyndman.com/publications/software/], some of which will be referred to here.
* My colleague Junanjo Medina has material for criminologists that includes good intros to graphing and some basic statistics [http://jjmedinaariza.github.io/R-for-Criminologists/]
* [http://www.computerworld.com/article/2497143/business-intelligence-beginner-s-guide-to-r-introduction.html?null A Beginner's Guide to R]
* Florian Heiss has written an R companion book to Wooldridge's Introductory Econometrics. It is available for free [http://www.urfie.net/read/mobile/index.html#p=1 online] but you can also get a [http://www.urfie.net/index.html hardcopy]
* Some R resources provided by [http://www.ats.ucla.edu/stat/r/ UCLA]
* [http://www.statmethods.net Quick-R] web-site and [http://www.manning.com/kabacoff2/RiA2E_meap_ch1.pdf first chapter of R in Action]
* Just TryR it! [http://tryr.codeschool.com/levels/1/challenges/1]
* Some resource by the UCLA [http://www.ats.ucla.edu/stat/r/]
* A practice RData file [https://drive.google.com/file/d/0B-eFeuIjpKsOWmdpOUsxT2Via3M/view?usp=sharing], use this to load required packages [https://drive.google.com/file/d/0B-eFeuIjpKsOc3VYYnh1bEtZcnM/view?usp=sharing]

MATLAB

2021-03-20T21:34:27Z

Rb: /* Special Econometric Topics */

== <div id="Essential"></div>The Essential MATLAB Programming Techniques ==

In this section we will introduce a number of basic and intermediate programming techniques. Whatever language you program in you will encounter these techniques, although the details will, of course, vary. We recommend that you ensure that you are familiar with these before you progress to [[#SpecEcmtrTopics| Special Econometric Topics ]].

=== Basic Programming ===

{| class="wikitable"
|-
! scope="col"| Basics and Matrices
! scope="col"| Loading Data and Date Formats
! scope="col"| Program Flow and Logicals
! scope="col"| Functions
! scope="col"| Saving Data and Screen Output
|-
| [[Discussion]] [http://www.youtube.com/watch?v=av5MgVpybT0&feature=youtu.be&hd=1 Example Clip]
| [[LoadingData|Discussion]] [http://youtu.be/jyb68zGM2ik?hd=1 ExampleClip]
| [[Program Flow and Logicals|Discussion]]
| [[Function|Discussion]] [[FctExampleCode|Example Code]] [[media:OLSexample.xls|OLSexample.xls]] [http://youtu.be/FPw9DH8pfiU?hd=1 Example Clip]
| [[SavingData|Discussion]]
|}

After having gone through these basic techniques you may want to test your newly acquired skills with the following examples.

{| class="wikitable"
|-
! scope="col"| Example 1
! scope="col"| Example 2
|-
| [[Example 1]]
| [[Example 2|Example2a]] [[Example 2b|Example2b]]
|}

=== Intermediate Programming ===

{| class="wikitable"
|-
! scope="col"| Statistical Functions
! scope="col"| Arrays and Structures
! scope="col"| Debugging
! scope="col"| Graphing Data
! scope="col"| Function Handlers Anonymous Functions
|-
| [[StatFunct|Discussion]]
| [[ArrayStructures|Discussion]]
| coming soon
| [[Graphing|Discussion]]
| [[Anonym|Discussion]]
|}

=== Advanced Programming ===

Sorry, but this cannot be taught! It will come with experience. Find someone who has experience in MATLAB programming and let him or her look over your code.

== Nonlinear Optimisation ==

The optimal parameters in a linear econometric model (assuming certain assumptions) can be found analytically. We call them the Ordinary Least Squares (OLS) estimates and they are easily calculated with a certain formula (see the [[FctExampleCode#OLSestm|OLSest.m]] function). When econometric models do not have such an analytical solution, an alternative parameter estimation strategy is required. In essence it is a clever "trial and error" strategy. This is often called nonlinear optimisation.

Nonlinear optimisation is a very important, but also a very tricky area of econometric computing. It certainly helps to understand some of the underlying theory and therefore we have below separate sections on the theory and implementation.

{| class="wikitable"
|-
! scope="col"| Theory
! scope="col"| Implementation
! scope="col"| Constrained Optimisation
|-
| [[NonlinOptTheory| Discussion]]
| [[NonlinOptImp| Discussion]]
| [[ConNonlinOptImp| Discussion]]
|}

== <div id="SpecEcmtrTopics"></div> Special Econometric Topics ==

Topics in this Section will assume that you have mastered all the techniques covered in the [[#Essential| Essential Programming Section ]]

{| class="wikitable"
|-
! scope="col"| Robust standard errors
! scope="col"| Univariate Time Series
! scope="col"| Unit Root and Stationarity Testing
! scope="col"| Forecasting
|-
| [[RobInf|Discussion]] [[ExampleCodeOLShac|Example Code]]
| [[UniTS|Discussion]] [[media:FXrateUSEU.xls|FXrateUSEU.xls]] [[media:USGDP.xls|USGDP.xls]]
| coming soon
| [[Forecasting|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Maximum Likelihood
! scope="col"| Generalized Methods of Moments
! scope="col"| Instrumental Variables
! scope="col"| Bayesian Estimation
|-
| [[MaxLik|Discussion]] [[MaxLikCode|Example Code]]
| [[GMM|Basic Code]] [https://youtu.be/NeUiDYr3ML0 video] [[media:US3monthRate.xlsx|US3monthRate.xlsx]] [[media: gradp.m|gradp.m]]
| [[IV|Discussion]] [[ExampleCodeIV|Example Code]]
| [[Bayes|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Monte-Carlo/ Simulation Techniques
! scope="col"| Binary Response Models
! scope="col"| Handling High Frequency Data
|-
| coming soon
| coming soon
| coming soon

|}

== Other useful MATLAB resources ==

=== The MATLAB Software ===

The software is available on University of Manchester Computer Labs. If you make regular use of MATLAB you should consider purchasing your own software. The Student Version of MATLAB is available, for instance, from [http://www.amazon.co.uk/MATLAB-Simulink-Student-Version-R2014a/dp/0989614026/ref=sr_1_1?s=software&ie=UTF8&qid=1411983990&sr=1-1&keywords=matlab+2014 Amazon] for £66. This is a real bargain, considering that the equivalent non-discounted package would come in at about £4,000.

=== Freely available toolboxes ===

The following toolboxes are freely available and contain extremely useful procedures

* Spatial Econometrics by James P. LeSage [http://www.spatial-econometrics.com/]. This toolbox contains a wide variety of useful econometrics functions. It also contains an excellent documentation. In addition to quite general econometric functions you will, as the name suggests, find a huge list of functions relevant if you are working with spatial data.
* <div id="MFEtoolbox"></div>Oxford MFE toolbox by Kevin Sheppard [https://bitbucket.org/kevinsheppard/mfe_toolbox]. Use the download link in the box on the right that starts with "Owner: Kevin Sheppard". This toolbox contains many useful functions for uni- and multivariate volatility models.

You need to copy these toolboxes into your MATLAB toolbox folder and add the respective path to the MATLAB list of folders it searches for functions. (In the main menu select FILE and then SET PATH where you can add the folders you added.) If you work on a computer for which you have no administrator rights, this strategy may not work. This [http://youtu.be/_32OqcW9WoY?hd=1 Example Clip] demonstrates what to do in that case. It is just a matter of adding one line into your code! Piece of cake.

=== Literature and other learning resources ===
* [http://www.kevinsheppard.com/wiki/MFE_Toolbox: Kevin Sheppard's MATLAB introduction].
* Martin V., Hurn S. and Harris D. (2012) Econometric Modelling with Time Series: Specification, Estimation and Testing (Themes in Modern Econometrics).[http://www.amazon.co.uk/Econometric-Modelling-Time-Specification-Econometrics/dp/0521196604/ref=sr_1_1?s=books&ie=UTF8&qid=1345214275&sr=1-1] This book contains an extensive library of relevant MATLAB codes.
* Higham, D.J. and Higham, N.J. (2005) MATLAB Guide, Society for Industrial and Applied Mathematics [http://www.amazon.co.uk/MATLAB-Guide-Desmond-J-Higham/dp/0898715784/ref=sr_1_1?s=books&ie=UTF8&qid=1347377409&sr=1-1]
This website does not cover any theoretical ground and is no substitute for any Econometric Textbook. There is a wide range of very good Econometric Textbooks available. If you are concerned about programming in MATLAB than you are likely to appreciate textbooks that use matrix notation. Here are two very good books that fit that bill:
* Heij C., de Boer P., Franses P.H., Kloek T. and van Dijk H.K (2004) Econometric Methods with Applications in Business and Economics, Oxford University Press, New York.[http://www.amazon.co.uk/Econometric-Methods-Applications-Business-Economics/dp/0199268010/ref=sr_1_1?s=books&ie=UTF8&qid=1354473313&sr=1-1]
* Greene W.H. (2012) Econometric Analysis, Pearson, Harlow.[http://www.amazon.co.uk/Econometric-Analysis-William-H-Greene/dp/0273753568/ref=sr_1_1?ie=UTF8&qid=1354473593&sr=8-1]

GMM

2021-03-20T15:52:57Z

Rb:

<source>

%=========================================================================
%
% Program to estimate level effect in interest rates by GMM
%
% Code based on Martin, Hurn and Harris, Econometric Time Series Modelling
% Specification, Estimation and Testing
% https://www.cambridge.org/features/econmodelling/chapter10.htm
%
% This code by Ralf Becker, March 2021
% http://eclr.humanities.manchester.ac.uk/index.php/MATLAB
%=========================================================================

clear all;
clc;
cd 'YOUR DIRECTORY'

% Load data --- monthly December 1946 to February 1991
% 3 month maturity
% extracted from the datafile provided by
% Martin, Hurn and Harris
% https://www.cambridge.org/features/econmodelling/chapter10.htm

[rt, ~, ~] = xlsread('US3monthRate.xlsx');

drt = trimr(rt,2,0) - trimr(rt,1,1); % creates \Delta r_{t+1}
r1t = trimr(rt,1,1); % creates r_t
r2t = trimr(rt,0,2);
t = length(drt);

%% It is typically good practice to visualise the data
tt = seqa(1946+12/12,1/12,t); % Creates year sequence

subplot(1,2,1);
plot(tt,r1t);
title('r_t')
box off
axis tight

subplot(1,2,2);
plot(tt,drt);
title('\Delta r_{t+1}')
box off
axis tight

%% Estimate the model in the first stage with idendity weighting matrix

ops = optimset('LargeScale','off','Display','off');
b0 = [0.1;0.1;0.1;1.0];
w0 = eye(length(b0));
bgmm1 = fminunc(@(b) qw(b,drt,r1t,w0),b0,ops);

disp('First Stage GMM estimates')
disp(bgmm1)

%% Now estimate the optimal weighting matrix
% using Newey-West estimator
lmax = 5; % lag for the NW estimate
d = meqn(bgmm1,drt,r1t);

% this will calculate Newey-West VCM using lmax lags
s = d'*d;
tau = 1;
while tau <= lmax
wtau = d((tau+1):size(d,1),:)'*d(1:(size(d,1)-tau),:);
s = s + (1.0-tau/(lmax+1))*(wtau + wtau');
tau = tau + 1;
end
w1 = s./t;

% Use this as the weighting matrix for the next pass to the optimisation
% function

%% 2nd Stage

bgmm2 = fminunc(@(b) qw(b,drt,r1t,w1),bgmm1,ops);

disp('Second Stage GMM estimates')
disp(bgmm2)

%% Further Iterations
% You could run further iterations
% 1) Re-calculate d
% 2) Re-calculate the optimal weighting matrix w based on the new d
% 3) Re-estimate using the new w
%
% For now we stop here
bgmm = bgmm2;
obj = qw(bgmm,drt,r1t,w1);

%% Calculate standard errors
% Compute optimal weigthing matrix at GMM estimates
% using Newey-West estimator
lmax = 5; % lag for the NW estimate
d = meqn(bgmm,drt,r1t);

% this will calculate Newey-West VCM using lmax lags
s = d'*d;
tau = 1;
while tau <= lmax
wtau = d((tau+1):size(d,1),:)'*d(1:(size(d,1)-tau),:);
s = s + (1.0-tau/(lmax+1))*(wtau + wtau');
tau = tau + 1;
end
s = s./t;

% Compute standard errors of GMM estimates
dg = numgrad(@meaneqn,bgmm,drt,r1t);
v = dg'*inv(s)*dg;
cov = inv(v)/t;
se = sqrt(diag(cov));

disp(' ');
disp(['The value of the objective function = ', num2str(obj) ]);
disp(['J-test = ', num2str(t*obj) ]);
disp('Estimates Std err. t-stats');
disp( [ bgmm se bgmm./se ])
disp(['Newey-West estimator with max lag = ', num2str(lmax) ]);
disp(' ');

%% Inference t-tests

% Test of gam = 0.0
stat = (bgmm(4) - 0.0)/se(4);
disp(['Test of (gam=0.0) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 0.5
stat = (bgmm(4) - 0.5)/se(4);
disp(['Test of (gam=0.5) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 1.0
stat = (bgmm(4) - 1.0)/se(4);
disp(['Test of (gam=1.0) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 1.5
stat = (bgmm(4) - 1.5)/se(4);
disp(['Test of (gam=1.5) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

%% Inference - Overidentifying restrictions

%% Plot volatility function for alternative values of gam
tt = seqa(1946+12/12,1/12,t);
figure(1)

subplot(2,2,1);
plot(tt,drt./r1t.^0.0);
title('$\gamma=0.0$')
box off
axis tight

subplot(2,2,2);
plot(tt,drt./r1t.^0.5);
title('$\gamma=0.5$')
box off
axis tight

subplot(2,2,3);
plot(tt,drt./r1t.^1.0);
title('$\gamma=1.0$')
box off
axis tight

subplot(2,2,4);
plot(tt,drt./r1t.^1.5);
title('$\gamma=1.5$')
box off
axis tight

%
%------------------------- Functions -------------------------------------%
%
%-------------------------------------------------------------------------%
% Define the moment equations
%-------------------------------------------------------------------------%
function dt = meqn(b,drt,r1t)

ut = drt - b(1) - b(2)*r1t;
zt = [ones(size(ut,1),1),r1t];
dt = repmat(ut,1,2).*zt;
dt = [dt,repmat((ut.^2 - (b(3)^2)*r1t.^(2*b(4)) ),1,2).*zt];

end
%-------------------------------------------------------------------------%
% Defines the mean of the moment conditions
%-------------------------------------------------------------------------%
function ret = meaneqn(b,drt,r1t)

ret = (mean(meqn(b,drt,r1t)))';

end

%-------------------------------------------------------------------------%
% GMM objective function with user defined
% weighting matrix, w
%-------------------------------------------------------------------------%
function ret = qw(b,drt,r1t,w)

t = length(drt);
d = meqn(b,drt,r1t);
g = mean(d)';

ret = g'*inv(w)*g;
end

</source>

GMM

2021-03-20T15:51:50Z

Rb: Created page with "%========================================================================= % % Program to estimate level effect in interest rates by GMM % % Code based on Martin, Hurn and Har..."

%=========================================================================
%
% Program to estimate level effect in interest rates by GMM
%
% Code based on Martin, Hurn and Harris, Econometric Time Series Modelling
% Specification, Estimation and Testing
% https://www.cambridge.org/features/econmodelling/chapter10.htm
%
% This code by Ralf Becker, March 2021
% http://eclr.humanities.manchester.ac.uk/index.php/MATLAB
%=========================================================================

clear all;
clc;
cd 'YOUR DIRECTORY'

% Load data --- monthly December 1946 to February 1991
% 3 month maturity
% extracted from the datafile provided by
% Martin, Hurn and Harris
% https://www.cambridge.org/features/econmodelling/chapter10.htm

[rt, ~, ~] = xlsread('US3monthRate.xlsx');

drt = trimr(rt,2,0) - trimr(rt,1,1); % creates \Delta r_{t+1}
r1t = trimr(rt,1,1); % creates r_t
r2t = trimr(rt,0,2);
t = length(drt);

%% It is typically good practice to visualise the data
tt = seqa(1946+12/12,1/12,t); % Creates year sequence

subplot(1,2,1);
plot(tt,r1t);
title('r_t')
box off
axis tight

subplot(1,2,2);
plot(tt,drt);
title('\Delta r_{t+1}')
box off
axis tight

%% Estimate the model in the first stage with idendity weighting matrix

ops = optimset('LargeScale','off','Display','off');
b0 = [0.1;0.1;0.1;1.0];
w0 = eye(length(b0));
bgmm1 = fminunc(@(b) qw(b,drt,r1t,w0),b0,ops);

disp('First Stage GMM estimates')
disp(bgmm1)

%% Now estimate the optimal weighting matrix
% using Newey-West estimator
lmax = 5; % lag for the NW estimate
d = meqn(bgmm1,drt,r1t);

% this will calculate Newey-West VCM using lmax lags
s = d'*d;
tau = 1;
while tau <= lmax
wtau = d((tau+1):size(d,1),:)'*d(1:(size(d,1)-tau),:);
s = s + (1.0-tau/(lmax+1))*(wtau + wtau');
tau = tau + 1;
end
w1 = s./t;

% Use this as the weighting matrix for the next pass to the optimisation
% function

%% 2nd Stage

bgmm2 = fminunc(@(b) qw(b,drt,r1t,w1),bgmm1,ops);

disp('Second Stage GMM estimates')
disp(bgmm2)

%% Further Iterations
% You could run further iterations
% 1) Re-calculate d
% 2) Re-calculate the optimal weighting matrix w based on the new d
% 3) Re-estimate using the new w
%
% For now we stop here
bgmm = bgmm2;
obj = qw(bgmm,drt,r1t,w1);

%% Calculate standard errors
% Compute optimal weigthing matrix at GMM estimates
% using Newey-West estimator
lmax = 5; % lag for the NW estimate
d = meqn(bgmm,drt,r1t);

% this will calculate Newey-West VCM using lmax lags
s = d'*d;
tau = 1;
while tau <= lmax
wtau = d((tau+1):size(d,1),:)'*d(1:(size(d,1)-tau),:);
s = s + (1.0-tau/(lmax+1))*(wtau + wtau');
tau = tau + 1;
end
s = s./t;

% Compute standard errors of GMM estimates
dg = numgrad(@meaneqn,bgmm,drt,r1t);
v = dg'*inv(s)*dg;
cov = inv(v)/t;
se = sqrt(diag(cov));

disp(' ');
disp(['The value of the objective function = ', num2str(obj) ]);
disp(['J-test = ', num2str(t*obj) ]);
disp('Estimates Std err. t-stats');
disp( [ bgmm se bgmm./se ])
disp(['Newey-West estimator with max lag = ', num2str(lmax) ]);
disp(' ');

%% Inference t-tests

% Test of gam = 0.0
stat = (bgmm(4) - 0.0)/se(4);
disp(['Test of (gam=0.0) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 0.5
stat = (bgmm(4) - 0.5)/se(4);
disp(['Test of (gam=0.5) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 1.0
stat = (bgmm(4) - 1.0)/se(4);
disp(['Test of (gam=1.0) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

% Test of gam = 1.5
stat = (bgmm(4) - 1.5)/se(4);
disp(['Test of (gam=1.5) = ', num2str(stat) ]);
disp(['p-value = ', num2str(2*(1-normcdf(abs(stat)))) ]);
disp(' ');

%% Inference - Overidentifying restrictions

%% Plot volatility function for alternative values of gam
tt = seqa(1946+12/12,1/12,t);
figure(1)

subplot(2,2,1);
plot(tt,drt./r1t.^0.0);
title('$\gamma=0.0$')
box off
axis tight

subplot(2,2,2);
plot(tt,drt./r1t.^0.5);
title('$\gamma=0.5$')
box off
axis tight

subplot(2,2,3);
plot(tt,drt./r1t.^1.0);
title('$\gamma=1.0$')
box off
axis tight

subplot(2,2,4);
plot(tt,drt./r1t.^1.5);
title('$\gamma=1.5$')
box off
axis tight

%
%------------------------- Functions -------------------------------------%
%
%-------------------------------------------------------------------------%
% Define the moment equations
%-------------------------------------------------------------------------%
function dt = meqn(b,drt,r1t)

ut = drt - b(1) - b(2)*r1t;
zt = [ones(size(ut,1),1),r1t];
dt = repmat(ut,1,2).*zt;
dt = [dt,repmat((ut.^2 - (b(3)^2)*r1t.^(2*b(4)) ),1,2).*zt];

end
%-------------------------------------------------------------------------%
% Defines the mean of the moment conditions
%-------------------------------------------------------------------------%
function ret = meaneqn(b,drt,r1t)

ret = (mean(meqn(b,drt,r1t)))';

end

%-------------------------------------------------------------------------%
% GMM objective function with user defined
% weighting matrix, w
%-------------------------------------------------------------------------%
function ret = qw(b,drt,r1t,w)

t = length(drt);
d = meqn(b,drt,r1t);
g = mean(d)';

ret = g'*inv(w)*g;
end

MATLAB

2021-03-20T15:51:18Z

Rb: /* Special Econometric Topics */

== <div id="Essential"></div>The Essential MATLAB Programming Techniques ==

In this section we will introduce a number of basic and intermediate programming techniques. Whatever language you program in you will encounter these techniques, although the details will, of course, vary. We recommend that you ensure that you are familiar with these before you progress to [[#SpecEcmtrTopics| Special Econometric Topics ]].

=== Basic Programming ===

{| class="wikitable"
|-
! scope="col"| Basics and Matrices
! scope="col"| Loading Data and Date Formats
! scope="col"| Program Flow and Logicals
! scope="col"| Functions
! scope="col"| Saving Data and Screen Output
|-
| [[Discussion]] [http://www.youtube.com/watch?v=av5MgVpybT0&feature=youtu.be&hd=1 Example Clip]
| [[LoadingData|Discussion]] [http://youtu.be/jyb68zGM2ik?hd=1 ExampleClip]
| [[Program Flow and Logicals|Discussion]]
| [[Function|Discussion]] [[FctExampleCode|Example Code]] [[media:OLSexample.xls|OLSexample.xls]] [http://youtu.be/FPw9DH8pfiU?hd=1 Example Clip]
| [[SavingData|Discussion]]
|}

After having gone through these basic techniques you may want to test your newly acquired skills with the following examples.

{| class="wikitable"
|-
! scope="col"| Example 1
! scope="col"| Example 2
|-
| [[Example 1]]
| [[Example 2|Example2a]] [[Example 2b|Example2b]]
|}

=== Intermediate Programming ===

{| class="wikitable"
|-
! scope="col"| Statistical Functions
! scope="col"| Arrays and Structures
! scope="col"| Debugging
! scope="col"| Graphing Data
! scope="col"| Function Handlers Anonymous Functions
|-
| [[StatFunct|Discussion]]
| [[ArrayStructures|Discussion]]
| coming soon
| [[Graphing|Discussion]]
| [[Anonym|Discussion]]
|}

=== Advanced Programming ===

Sorry, but this cannot be taught! It will come with experience. Find someone who has experience in MATLAB programming and let him or her look over your code.

== Nonlinear Optimisation ==

The optimal parameters in a linear econometric model (assuming certain assumptions) can be found analytically. We call them the Ordinary Least Squares (OLS) estimates and they are easily calculated with a certain formula (see the [[FctExampleCode#OLSestm|OLSest.m]] function). When econometric models do not have such an analytical solution, an alternative parameter estimation strategy is required. In essence it is a clever "trial and error" strategy. This is often called nonlinear optimisation.

Nonlinear optimisation is a very important, but also a very tricky area of econometric computing. It certainly helps to understand some of the underlying theory and therefore we have below separate sections on the theory and implementation.

{| class="wikitable"
|-
! scope="col"| Theory
! scope="col"| Implementation
! scope="col"| Constrained Optimisation
|-
| [[NonlinOptTheory| Discussion]]
| [[NonlinOptImp| Discussion]]
| [[ConNonlinOptImp| Discussion]]
|}

== <div id="SpecEcmtrTopics"></div> Special Econometric Topics ==

Topics in this Section will assume that you have mastered all the techniques covered in the [[#Essential| Essential Programming Section ]]

{| class="wikitable"
|-
! scope="col"| Robust standard errors
! scope="col"| Univariate Time Series
! scope="col"| Unit Root and Stationarity Testing
! scope="col"| Forecasting
|-
| [[RobInf|Discussion]] [[ExampleCodeOLShac|Example Code]]
| [[UniTS|Discussion]] [[media:FXrateUSEU.xls|FXrateUSEU.xls]] [[media:USGDP.xls|USGDP.xls]]
| coming soon
| [[Forecasting|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Maximum Likelihood
! scope="col"| Generalized Methods of Moments
! scope="col"| Instrumental Variables
! scope="col"| Bayesian Estimation
|-
| [[MaxLik|Discussion]] [[MaxLikCode|Example Code]]
| [[GMM|Basic Code]] Video [[media:US3monthRate.xlsx|US3monthRate.xlsx]] [[media: gradp.m|gradp.m]]
| [[IV|Discussion]] [[ExampleCodeIV|Example Code]]
| [[Bayes|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Monte-Carlo/ Simulation Techniques
! scope="col"| Binary Response Models
! scope="col"| Handling High Frequency Data
|-
| coming soon
| coming soon
| coming soon

|}

== Other useful MATLAB resources ==

=== The MATLAB Software ===

The software is available on University of Manchester Computer Labs. If you make regular use of MATLAB you should consider purchasing your own software. The Student Version of MATLAB is available, for instance, from [http://www.amazon.co.uk/MATLAB-Simulink-Student-Version-R2014a/dp/0989614026/ref=sr_1_1?s=software&ie=UTF8&qid=1411983990&sr=1-1&keywords=matlab+2014 Amazon] for £66. This is a real bargain, considering that the equivalent non-discounted package would come in at about £4,000.

=== Freely available toolboxes ===

The following toolboxes are freely available and contain extremely useful procedures

* Spatial Econometrics by James P. LeSage [http://www.spatial-econometrics.com/]. This toolbox contains a wide variety of useful econometrics functions. It also contains an excellent documentation. In addition to quite general econometric functions you will, as the name suggests, find a huge list of functions relevant if you are working with spatial data.
* <div id="MFEtoolbox"></div>Oxford MFE toolbox by Kevin Sheppard [https://bitbucket.org/kevinsheppard/mfe_toolbox]. Use the download link in the box on the right that starts with "Owner: Kevin Sheppard". This toolbox contains many useful functions for uni- and multivariate volatility models.

You need to copy these toolboxes into your MATLAB toolbox folder and add the respective path to the MATLAB list of folders it searches for functions. (In the main menu select FILE and then SET PATH where you can add the folders you added.) If you work on a computer for which you have no administrator rights, this strategy may not work. This [http://youtu.be/_32OqcW9WoY?hd=1 Example Clip] demonstrates what to do in that case. It is just a matter of adding one line into your code! Piece of cake.

=== Literature and other learning resources ===
* [http://www.kevinsheppard.com/wiki/MFE_Toolbox: Kevin Sheppard's MATLAB introduction].
* Martin V., Hurn S. and Harris D. (2012) Econometric Modelling with Time Series: Specification, Estimation and Testing (Themes in Modern Econometrics).[http://www.amazon.co.uk/Econometric-Modelling-Time-Specification-Econometrics/dp/0521196604/ref=sr_1_1?s=books&ie=UTF8&qid=1345214275&sr=1-1] This book contains an extensive library of relevant MATLAB codes.
* Higham, D.J. and Higham, N.J. (2005) MATLAB Guide, Society for Industrial and Applied Mathematics [http://www.amazon.co.uk/MATLAB-Guide-Desmond-J-Higham/dp/0898715784/ref=sr_1_1?s=books&ie=UTF8&qid=1347377409&sr=1-1]
This website does not cover any theoretical ground and is no substitute for any Econometric Textbook. There is a wide range of very good Econometric Textbooks available. If you are concerned about programming in MATLAB than you are likely to appreciate textbooks that use matrix notation. Here are two very good books that fit that bill:
* Heij C., de Boer P., Franses P.H., Kloek T. and van Dijk H.K (2004) Econometric Methods with Applications in Business and Economics, Oxford University Press, New York.[http://www.amazon.co.uk/Econometric-Methods-Applications-Business-Economics/dp/0199268010/ref=sr_1_1?s=books&ie=UTF8&qid=1354473313&sr=1-1]
* Greene W.H. (2012) Econometric Analysis, Pearson, Harlow.[http://www.amazon.co.uk/Econometric-Analysis-William-H-Greene/dp/0273753568/ref=sr_1_1?ie=UTF8&qid=1354473593&sr=8-1]

File:US3monthRate.xlsx

2021-03-20T15:31:59Z

Rb:

MATLAB

2021-03-20T15:31:19Z

Rb: /* Special Econometric Topics */

== <div id="Essential"></div>The Essential MATLAB Programming Techniques ==

In this section we will introduce a number of basic and intermediate programming techniques. Whatever language you program in you will encounter these techniques, although the details will, of course, vary. We recommend that you ensure that you are familiar with these before you progress to [[#SpecEcmtrTopics| Special Econometric Topics ]].

=== Basic Programming ===

{| class="wikitable"
|-
! scope="col"| Basics and Matrices
! scope="col"| Loading Data and Date Formats
! scope="col"| Program Flow and Logicals
! scope="col"| Functions
! scope="col"| Saving Data and Screen Output
|-
| [[Discussion]] [http://www.youtube.com/watch?v=av5MgVpybT0&feature=youtu.be&hd=1 Example Clip]
| [[LoadingData|Discussion]] [http://youtu.be/jyb68zGM2ik?hd=1 ExampleClip]
| [[Program Flow and Logicals|Discussion]]
| [[Function|Discussion]] [[FctExampleCode|Example Code]] [[media:OLSexample.xls|OLSexample.xls]] [http://youtu.be/FPw9DH8pfiU?hd=1 Example Clip]
| [[SavingData|Discussion]]
|}

After having gone through these basic techniques you may want to test your newly acquired skills with the following examples.

{| class="wikitable"
|-
! scope="col"| Example 1
! scope="col"| Example 2
|-
| [[Example 1]]
| [[Example 2|Example2a]] [[Example 2b|Example2b]]
|}

=== Intermediate Programming ===

{| class="wikitable"
|-
! scope="col"| Statistical Functions
! scope="col"| Arrays and Structures
! scope="col"| Debugging
! scope="col"| Graphing Data
! scope="col"| Function Handlers Anonymous Functions
|-
| [[StatFunct|Discussion]]
| [[ArrayStructures|Discussion]]
| coming soon
| [[Graphing|Discussion]]
| [[Anonym|Discussion]]
|}

=== Advanced Programming ===

Sorry, but this cannot be taught! It will come with experience. Find someone who has experience in MATLAB programming and let him or her look over your code.

== Nonlinear Optimisation ==

The optimal parameters in a linear econometric model (assuming certain assumptions) can be found analytically. We call them the Ordinary Least Squares (OLS) estimates and they are easily calculated with a certain formula (see the [[FctExampleCode#OLSestm|OLSest.m]] function). When econometric models do not have such an analytical solution, an alternative parameter estimation strategy is required. In essence it is a clever "trial and error" strategy. This is often called nonlinear optimisation.

Nonlinear optimisation is a very important, but also a very tricky area of econometric computing. It certainly helps to understand some of the underlying theory and therefore we have below separate sections on the theory and implementation.

{| class="wikitable"
|-
! scope="col"| Theory
! scope="col"| Implementation
! scope="col"| Constrained Optimisation
|-
| [[NonlinOptTheory| Discussion]]
| [[NonlinOptImp| Discussion]]
| [[ConNonlinOptImp| Discussion]]
|}

== <div id="SpecEcmtrTopics"></div> Special Econometric Topics ==

Topics in this Section will assume that you have mastered all the techniques covered in the [[#Essential| Essential Programming Section ]]

{| class="wikitable"
|-
! scope="col"| Robust standard errors
! scope="col"| Univariate Time Series
! scope="col"| Unit Root and Stationarity Testing
! scope="col"| Forecasting
|-
| [[RobInf|Discussion]] [[ExampleCodeOLShac|Example Code]]
| [[UniTS|Discussion]] [[media:FXrateUSEU.xls|FXrateUSEU.xls]] [[media:USGDP.xls|USGDP.xls]]
| coming soon
| [[Forecasting|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Maximum Likelihood
! scope="col"| Generalized Methods of Moments
! scope="col"| Instrumental Variables
! scope="col"| Bayesian Estimation
|-
| [[MaxLik|Discussion]] [[MaxLikCode|Example Code]]
| Video [[media:US3monthRate.xlsx|US3monthRate.xlsx]] [[media:gmm_level_RB_2stage.m|gmm_level_RB_2stage.m]] [[media: gradp.m|gradp.m]]
| [[IV|Discussion]] [[ExampleCodeIV|Example Code]]
| [[Bayes|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Monte-Carlo/ Simulation Techniques
! scope="col"| Binary Response Models
! scope="col"| Handling High Frequency Data
|-
| coming soon
| coming soon
| coming soon

|}

== Other useful MATLAB resources ==

=== The MATLAB Software ===

The software is available on University of Manchester Computer Labs. If you make regular use of MATLAB you should consider purchasing your own software. The Student Version of MATLAB is available, for instance, from [http://www.amazon.co.uk/MATLAB-Simulink-Student-Version-R2014a/dp/0989614026/ref=sr_1_1?s=software&ie=UTF8&qid=1411983990&sr=1-1&keywords=matlab+2014 Amazon] for £66. This is a real bargain, considering that the equivalent non-discounted package would come in at about £4,000.

=== Freely available toolboxes ===

The following toolboxes are freely available and contain extremely useful procedures

* Spatial Econometrics by James P. LeSage [http://www.spatial-econometrics.com/]. This toolbox contains a wide variety of useful econometrics functions. It also contains an excellent documentation. In addition to quite general econometric functions you will, as the name suggests, find a huge list of functions relevant if you are working with spatial data.
* <div id="MFEtoolbox"></div>Oxford MFE toolbox by Kevin Sheppard [https://bitbucket.org/kevinsheppard/mfe_toolbox]. Use the download link in the box on the right that starts with "Owner: Kevin Sheppard". This toolbox contains many useful functions for uni- and multivariate volatility models.

You need to copy these toolboxes into your MATLAB toolbox folder and add the respective path to the MATLAB list of folders it searches for functions. (In the main menu select FILE and then SET PATH where you can add the folders you added.) If you work on a computer for which you have no administrator rights, this strategy may not work. This [http://youtu.be/_32OqcW9WoY?hd=1 Example Clip] demonstrates what to do in that case. It is just a matter of adding one line into your code! Piece of cake.

=== Literature and other learning resources ===
* [http://www.kevinsheppard.com/wiki/MFE_Toolbox: Kevin Sheppard's MATLAB introduction].
* Martin V., Hurn S. and Harris D. (2012) Econometric Modelling with Time Series: Specification, Estimation and Testing (Themes in Modern Econometrics).[http://www.amazon.co.uk/Econometric-Modelling-Time-Specification-Econometrics/dp/0521196604/ref=sr_1_1?s=books&ie=UTF8&qid=1345214275&sr=1-1] This book contains an extensive library of relevant MATLAB codes.
* Higham, D.J. and Higham, N.J. (2005) MATLAB Guide, Society for Industrial and Applied Mathematics [http://www.amazon.co.uk/MATLAB-Guide-Desmond-J-Higham/dp/0898715784/ref=sr_1_1?s=books&ie=UTF8&qid=1347377409&sr=1-1]
This website does not cover any theoretical ground and is no substitute for any Econometric Textbook. There is a wide range of very good Econometric Textbooks available. If you are concerned about programming in MATLAB than you are likely to appreciate textbooks that use matrix notation. Here are two very good books that fit that bill:
* Heij C., de Boer P., Franses P.H., Kloek T. and van Dijk H.K (2004) Econometric Methods with Applications in Business and Economics, Oxford University Press, New York.[http://www.amazon.co.uk/Econometric-Methods-Applications-Business-Economics/dp/0199268010/ref=sr_1_1?s=books&ie=UTF8&qid=1354473313&sr=1-1]
* Greene W.H. (2012) Econometric Analysis, Pearson, Harlow.[http://www.amazon.co.uk/Econometric-Analysis-William-H-Greene/dp/0273753568/ref=sr_1_1?ie=UTF8&qid=1354473593&sr=8-1]

Confidence Intervals

2020-04-20T15:56:41Z

Rb: /* Sampling Variability */

= Point and Interval Estimation =

In [[Point_Estimation|Section]], it was noted that an estimate of a population parameter is a single number. Bearing in mind the fact that in general, the values of population parameters are unknown, it is easy to fall into the trap of treating the estimated value as if it were actually the “true” population value. After all, the estimate is derived from a single sample out of all the possible samples that might be drawn. Different samples will yield different estimates of the population parameter: this is the idea of '''sampling variability'''. One can see the usefulness of obtaining from a '''single sample''', some idea of the range of values of the estimate that might be obtained in different samples. This is the purpose of an ''interval estimate''. There is an alternative and more popular name, ''confidence interval''. Initially this name is not used because it does not permit the distinction between an '''interval estimator '''and an '''interval estimate.'''

== Sampling Variability ==

Consider the simplest case of sampling from a normal distribution, <math>X\sim N\left( \mu ,\sigma ^{2}\right) </math> with the intention of estimating <math>\mu </math>. The obvious estimator is the sample mean, <math>\bar{X},</math> with sampling distribution <math>\bar{X}\sim N\left( \mu ,\sigma^{2}/n\right)</math> (see this [[Statistics_SamplingDistributions#The_Sampling_Distribution|section]] for details). Here, <math>\mu </math> is unknown: one issue will be whether the population parameter <math>\sigma ^{2}</math> is also unknown. From the general principle that population parameters are unknown, the answer should be “yes”, but it will be convenient to (initially) assume, for simplicity, that <math>\sigma ^{2}</math> is actually known.

The variance of the distribution of <math>\bar{X}</math> measures the dispersion of this distribution, and thus gives some idea of the range of values of <math>\bar{X}</math> that might be obtained in drawing different samples of size <math>n</math>. The question is, though, what is an extreme or untypical value of <math>\bar{X}</math>? The conventional way to define this is by using a multiple of the '''standard error '''of <math>\bar{X},</math> <math>SE\left( \bar{X}\right)</math>, as a measure of sampling variability. Then, extreme values do not belong to the interval

<math>\bar{x}\pm k SE\left( \bar{X}\right) ,</math>

with the value <math>k</math> chosen suitably. Then, the factor <math>\pm k SE \left( \bar{X}\right) </math> is the measure of sampling variability around <math>\bar{x}</math>. Clearly, the parameter <math>SE\left( \bar{X}\right) </math> has to be known in order for the measure of ‘sampling variability to be computed. This is why we make the initial assumption of a known <math>\sigma</math>, such that we can easily calculate <math>SE\left( \bar{X}\right) = \sqrt(\sigma^2 / n)</math>. As you can see this measure partially reflects the inherent variability in the population, as represented by the population variance <math>\sigma ^{2}</math>. <ref>Usually <math>\sigma^2</math> is, as <math>\mu</math>, unknown and it has to be estimated by using the sample variance <math>s^{2}</math> instead. It is via the use of <math>s^{2}</math> that the measure of sampling variability is being calculated from a single sample. This will be discussed below.
</ref>

How should <math>k</math> be chosen? A conventional value is <math>k=2:</math> why this might be popular will be seen shortly.

To illustrate the reasoning here, we use an example that also appears later in a later Section. Suppose that a random sample of size <math>50</math> is drawn from the distribution of household incomes, where the latter is supposed to be <math>N\left( \mu ,5\right) </math>, and that the mean of the sample is <math>\bar{x}=18</math>. If we choose <math>k=2</math>, the measure of sampling variability is

<math>\pm 2SE\left( \bar{X}\right) =\pm \left( 2\right) \sqrt{\frac{5}{50}}=\pm 0.6325,</math>

which is, relative to <math>SE(X) = \sqrt{5}</math>, rather small.

= Interval Estimators =

It is simplest to see how an interval estimator is constructed within the context of estimating the mean <math>\mu </math> of a normal distribution <math>N\left( \mu ,\sigma ^{2}\right) </math> using the sample mean <math>\bar{X}</math> of a random sample of size <math>n</math>. An interval has to have two endpoints, and an estimator is a random variable, so we seek two random variables <math>C_{L}</math> and <math>C_{U}</math> such that the closed interval <math>\left[ C_{L},C_{U}\right] </math> contains the parameter <math>\mu </math> with a pre-specified probability. Rather obviously, this is a '''random interval''' because its endpoints are random variables.

This interval estimator <math>\left[ C_{L},C_{U}\right] </math> is also called a '''confidence interval''', and the pre-specified probability is called the '''confidence coefficient''' or '''confidence level'''. The corresponding interval estimate is then the sample value of this random interval: <math>\left[ c_{L},c_{U}\right] </math>. The sample values <math>c_{L},c_{U}</math> are called the '''lower '''and '''upper confidence bounds''' or '''limits'''.

== Construction of the Interval Estimator ==

From the sampling distribution of <math>\bar{X}</math>, for any given value <math>k</math> we can find the probability that

<math>\Pr \left( -k\leqslant \dfrac{\bar{X}-\mu }{SE\left( \bar{X}\right) }\leqslant k\right)</math>

as

<math>\Pr \left( -k\leqslant \dfrac{\bar{X}-\mu }{SE\left( \bar{X}\right) }\leqslant k\right) =\Pr \left(Z\leqslant k\right) -\Pr \left(Z\leqslant -k\right)</math>

for <math>Z\thicksim N\left( 0,1\right) </math>, just as in this [[Point_Estimation#How_close_is_.5C.28.5Cbar.7BX.7D.5C.29_to_.5C.28.5Cmu.5C.29.3F|Section]]. So, if we choose <math>k=1.96</math>, and consult the Normal Probability [[media:NormalTable.pdf|table]], we find that

<math>\Pr \left( -1.96\leqslant \dfrac{\bar{X}-\mu }{SE\left( \bar{X}\right) }\leqslant 1.96\right) =0.95.</math>

By manipulating the '''two''' inequalities inside the brackets, but '''without''' changing the truth content of the inequalities, we can rewrite this so that the centre of the inequalities is the unknown parameter <math>\mu </math>. The sequence is to

<ol>
<li>multiply across by <math>SE\left( \bar{X}\right) </math> to give
<math>\Pr \left\{ -1.96SE\left( \bar{X}\right) \leqslant \bar{X}-\mu
\leqslant 1.96SE\left( \bar{X}\right) \right\} =0.95;</math></li>
<li>move <math>\bar{X}</math> from the centre:
<math>\Pr \left\{ -\bar{X}-1.96SE\left( \bar{X}\right) \leqslant -\mu
\leqslant -\bar{X}+1.96SE\left( \bar{X}\right) \right\} =0.95;</math></li>
<li>multiply through by <math>-1:</math>
<math>\Pr \left\{ \bar{X}+1.96SE\left( \bar{X}\right) \geqslant \mu
\geqslant \bar{X}-1.96SE\left( \bar{X}\right) \right\} =0.95;</math></li>
<li>tidy up:
<math>\Pr \left\{ \bar{X}-1.96SE\left( \bar{X}\right) \leqslant \mu
\leqslant \bar{X}+1.96SE\left( \bar{X}\right) \right\} =0.95.</math></li></ol>

Notice that because the manipulations do not change the truth content of the inequalities, the probability of the <math>\bar{X}</math> event defined by the inequalities is not changed.

If we identify the endpoints <math>C_{L},C_{U}</math> of the interval estimator with the endpoints of the interval in part (4),

<math>C_{L}=\bar{X}-1.96SE\left( \bar{X}\right) ,\;\;\;\;\;C_{U}=\bar{X}+1.96SE\left( \bar{X}\right) ,</math>

we will have constructed a random interval with the desired properties:

<math>\Pr \left( C_{L}\leqslant \mu \leqslant C_{U}\right) =0.95.</math>

Now we can also see why we previously stated that the sampling variability is often expressed as <math>\pm 2SE\left( \bar{X}\right)</math>. As 2 is pretty close to the above value of 1.96, this will deliver an approximate 95% confidence interval.

An alternative expression for this confidence interval uses membership of the interval:

<math>\Pr \left( \mu \in \left[ C_{L},C_{U}\right] \right) =0.95.</math>

In both expressions, <math>\mu </math> is fixed and unknown. It is the random variables <math>C_{L}</math> and <math>C_{U}</math> which supply the chance behaviour, giving the possibility that <math>\mu </math> <math>\notin \left[ C_{L},C_{U}\right] </math> with some non-zero probability. Indeed, '''by construction, '''the interval estimator '''fails '''to contain (more strictly, '''cover''') the unknown value <math>\mu </math> with probability <math>0.05</math>:

<math>\Pr \left( \mu \notin \left[ C_{L},C_{U}\right] \right) =0.05.</math>

To summarise, in the standard jargon:

<ul>
<li>a 95% confidence interval for <math>\mu </math> is given by the random interval or interval estimator
<math>\left[ \bar{X}-1.96SE\left( \bar{X}\right) ,\;\bar{X}+1.96 SE\left( \bar{X}\right) \right]</math></li></ul>

== The Interval Estimate ==

This interval is defined by the sample values of <math>C_{L}</math> and <math>C_{U}:</math> these are the lower and upper confidence bounds

<math>c_{L}=\bar{x}-1.96SE\left( \bar{X}\right) ,\;\;\;c_{U}=\bar{x}+1.96 SE\left( \bar{X}\right) .</math>

The interval estimate

<math>\bar{x}\pm 1.96SE\left( \bar{X}\right)</math>

contains the measure of sampling variability discussed in the Sampling Variability Section above. The choice of <math>k</math> as <math>k=1.96</math> is now determined by the desired confidence level. Why choose the latter to be <math>0.95</math> or <math>95\%?</math> This is really a matter of convention.

It is a common abuse of language to call the interval

<math>\bar{x}\pm 1.96SE\left( \bar{X}\right)</math>

'''the''' confidence interval - indeed it is so common that this abuse will be allowed. Strictly, this is an interval estimate, which is now seen to be a combination of a point estimate, <math>\bar{x}</math>, of <math>\mu </math>, and a measure of sampling variability determined by the constant <math>k</math>, which sets the confidence coefficient or level, in this case, 0.95.

There is a common misinterpretation of a confidence interval, based on this abuse of language, which says that ''the confidence interval ''

<math>\bar{x}\pm 1.96SE\left( \bar{X}\right)</math>

''contains ''<math>\mu </math> ''with'' <math>95\%</math> ''confidence.'' Why is this a misinterpretation? For the following reasons:

* <math>\mu </math> is unknown<math>;</math>
* so this “confidence interval” may or may not contain <math>\mu</math>;
* since <math>\mu </math> is unknown, we will '''never''' know which is true;
* the “confidence level” is either <math>0</math> or <math>1</math>, not <math>0.95</math>.

A better interpretation is based on the relative frequency interpretation of probability. If samples are repeatedly drawn from the population, say <math>X\thicksim N\left( \mu ,\sigma ^{2}\right) </math>, and the interval estimates (“confidence interval”) for a <math>95\%</math> confidence level calculated for each sample, about <math>95\%</math> of them will contain <math>\mu </math>. However, this doesn’t help when only a single sample is drawn. In any case, this interpretation is only a relative frequency restatement of the principle behind the construction of the interval estimator.

Ultimately, we have to abandon interpretations like this and return to the idea of obtaining from a single sample, a point estimate of a population parameter and a measure of sampling variability. An interval estimate (“confidence interval”) does precisely this, in a specific way.

== An Example ==

As in the Sampling Variability Section above, suppose that a random sample of size <math>50</math> is drawn from the distribution of household incomes, where the latter is supposed to be <math>N\left( \mu ,5\right)</math>. Notice that <math>\sigma ^{2}</math> here is supposed to be '''known''' to equal <math>5</math>. Suppose that the mean of the sample is <math>\bar{x}=18</math>. Then, the <math>95\%</math> confidence interval for <math>\mu </math> is (allowing the abuse of language)

<math>\begin{aligned}
\bar{x}\pm 1.96SE\left( \bar{X}\right) &=&18\pm 1.96\sqrt{\dfrac{5}{50}} \\
&=&18\pm 0.62 \\
&=&\left[ 17.38,18.62\right] .\end{aligned}</math>

Here the measure of sampling variability around <math>\bar{x}=18</math> is <math>\pm 0.62</math>. One might reasonably conclude that since this measure of sampling variability is small compared to <math>\bar{x}</math>, <math>\bar{x}=18</math> is a relatively precise estimate of <math>\mu </math>. To refer to ''precision ''here is fair, since we are utilising the variance of the sampling distribution of <math>\bar{X}</math>.

== Other Confidence Levels ==

Instead of choosing <math>k</math> so that

<math>\Pr \left( -k\leqslant \dfrac{\bar{X}-\mu }{SE\left( \bar{X}\right) }\leqslant k\right) =0.95,</math>

we choose it to deliver the desired probability, usually expressed as <math>1-\alpha </math>:

<math>\Pr \left( -k\leqslant \dfrac{\bar{X}-\mu }{SE\left( \bar{X}\right) }\leqslant k\right) =1-\alpha .</math>

The reason for the use of <math>1-\alpha </math> is explained later. Since

<math>Z=\dfrac{\bar{X}-\mu }{SE\left( \bar{X}\right) }\thicksim N\left(0,1\right) ,</math>

we can find from the [[media:NormalTable.pdf|tables]] of the standard normal distribution the value (''percentage point'') <math>z_{\alpha /2}</math> such that

<math>\Pr \left( Z>z_{\alpha /2}\right) =\dfrac{\alpha }{2}.</math>

This implies that

<math>\Pr \left( -z_{\alpha /2}\leqslant Z\leqslant z_{\alpha /2}\right) =1-\alpha.</math>

This is clear from the familiar picture in the Figure below.

[[File:norm01.jpg|frameless|500px]]

To find a confidence interval for <math>\mu </math> with confidence level <math>1-\alpha </math>, or equivalently, <math>100\left( 1-\alpha \right) \%</math>, we can follow through the derivation in section above in which we derived the construction of the interval estimator, replacing <math>1.96</math> by <math>z_{\alpha /2}</math> to give

<math>\Pr \left\{ \bar{X}-z_{\alpha /2}SE\left( \bar{X}\right) \leqslant \mu \leqslant \bar{X}+z_{\alpha /2}SE\left( \bar{X}\right) \right\} =1-\alpha .</math>

That is, the random variables <math>C_{L}</math> and <math>C_{U}</math> defining the interval estimator are

<math>C_{L}=\bar{X}-z_{\alpha /2}SE\left( \bar{X}\right) ,\;\;\;C_{U}=\bar{X}+z_{\alpha /2}SE\left( \bar{X}\right)</math>

The sample value of this confidence interval (the confidence interval) is then

<math>\bar{x}\pm z_{\alpha /2}SE\left( \bar{X}\right) .</math>

Using the example of the previous section, we can calculate, for example, a <math>99\%</math> confidence interval for <math>\mu </math>. Here,

<math>1-\alpha =0.99,\;\;\;\alpha =0.01,\;\;\;\alpha /2=0.005,</math>

and then from tables,

<math>z_{\alpha /2}=2.58.</math>

This gives the lower and upper confidence bounds as

<math>\begin{aligned}
\left[ c_{L},c_{U}\right] &=&\bar{x}\pm z_{\alpha /2}SE\left( \bar{X}\right) \\
&=&18\pm 2.58\sqrt{\dfrac{5}{50}} \\
&=&18\pm 0.82 \\
&=&\left[ 17.18,18.82\right] .\end{aligned}</math>

Notice that the measure of sampling variability has increased from <math>0.62</math> for a <math>95\%</math> confidence interval to <math>0.82</math> for a <math>99\%</math> confidence interval. This illustrates the general proposition that the confidence interval gets wider as the confidence coefficient is increased. There has been no change in the precision of estimation here.

Why the use of <math>1-\alpha </math> in the probability statement underlying the confidence interval? The random variables <math>C_{L}</math> and <math>C_{U}</math> are designed here to make

<math>\Pr \left( \mu \in \left[ C_{L},C_{U}\right] \right) =1-\alpha</math>

and therefore

<math>\Pr \left( \mu \notin \left[ C_{L},C_{U}\right] \right) =\alpha .</math>

This probability that <math>\mu </math> does '''not '''belong to the confidence interval turns out to be very important for the topic of ''hypothesis testing'' which will be discussed in Section [htsect]. As a result, <math>\alpha </math> is considered to be “important”, and the confidence coefficient is then stated in terms of <math>\alpha </math>. Again, this is largely due to convention.

== A small table of percentage points ==

For the <math>N\left( 0,1\right) </math> distribution, it is possible in principle to find the appropriate <math>z_{\alpha }</math> or <math>z_{\alpha /2}</math> from the [[media:NormalTable.pdf|table]] of the standard normal distribution. But, this soon becomes tiresome. The table below gives <math>z_{\alpha /2}</math> to four decimal places for a range of common confidence levels. With some care, it can be used for <math>z_{\alpha }</math> as well - this will be useful for later work.

<table border="1">

<tr class="header">
<th align="center"><math>1-\alpha </math></th>
<th align="center"><math>\alpha </math></th>
<th align="center"><math>\alpha /2</math></th>
<th align="center"><math>z_{\alpha /2}</math></th>
</tr>

<tr class="odd">
<td align="center"><math>0.80</math></td>
<td align="center"><math>0.2</math></td>
<td align="center"><math>0.10</math></td>
<td align="center"><math>1.2816</math></td>
</tr>
<tr class="even">
<td align="center"><math>0.90</math></td>
<td align="center"><math>0.1</math></td>
<td align="center"><math>0.05</math></td>
<td align="center"><math>1.6449</math></td>
</tr>
<tr class="odd">
<td align="center"><math>0.95</math></td>
<td align="center"><math>0.05</math></td>
<td align="center"><math>0.025</math></td>
<td align="center"><math>1.9600</math></td>
</tr>
<tr class="even">
<td align="center"><math>0.98</math></td>
<td align="center"><math>0.02</math></td>
<td align="center"><math>0.01</math></td>
<td align="center"><math>2.3263</math></td>
</tr>
<tr class="odd">
<td align="center"><math>0.99</math></td>
<td align="center"><math>0.01</math></td>
<td align="center"><math>0.005</math></td>
<td align="center"><math>2.5758</math></td>
</tr>

</table>

The Figure below shows the notation graphically.

[[File:normsinv.jpg|frameless|500px]]

== A small but important point ==

We have assumed that a random sample of size <math>n</math> has been drawn from a normal population, where <math>X\thicksim N\left( \mu ,\sigma ^{2}\right)</math>, and it is clear that an important role in a confidence interval for <math>\mu</math> is played by

<math>SE\left( \bar{X}\right) =\sqrt{\dfrac{\sigma ^{2}}{n}}.</math>

This standard error has to be known in order to calculate the interval estimate. But, it has frequently been emphasised that population parameters are in general unknown. So, '''assuming''' that <math>\sigma ^{2}</math> '''is known''' has to be seen as an unrealistic but simplifying assumption. This assumption allows us to see the principles behind the construction of an interval estimator or confidence interval without other complications. We shall now have to investigate the consequences of relaxing this assumption.

=== Additional Resources ===

* Khan Academy on this type of confidence interval [https://www.khanacademy.org/math/probability/statistics-inferential/confidence-intervals/v/confidence-interval-1].

= Unknown <math>\sigma</math> and the <math>t</math> distribution =

What happens if the parameter <math>\sigma ^{2}</math> is unknown, as is likely to be the case usually? Underlying the construction of a <math>95\%</math> confidence interval for <math>\mu </math> is the sampling distribution for <math>\bar{X},\bar{X} \thicksim N\left( \mu ,\sigma^{2}/n\right) </math> and a true probability statement,

<math>\Pr \left( -1.96\leqslant \dfrac{\bar{X}-\mu }{\sqrt{\dfrac{\sigma ^{2}}{n}}}\leqslant 1.96\right) =0.95.</math>

This is still true when <math>\sigma ^{2}</math> is unknown, but it is of no help, since we cannot construct the confidence interval (i.e. interval estimate)

<math>\bar{x}\pm 1.96\sqrt{\dfrac{\sigma ^{2}}{n}}.</math>

In the light of the discussion starting in [[PointEstimation|Section]] on the role of ''estimation'' in statistics, there is what seems to be an obvious solution. This is to replace the unknown <math>\sigma ^{2}</math> by an estimate, <math>s^{2}</math>, derived from the same sample that was used to obtain <math>\bar{x}</math>. However, one has to be a little careful. First, <math>s^{2}</math> is the '''estimate''' of the (population) variance , and is the sample value of the '''estimator '''<math>S^{2}</math>. The probability statement above is based on the fact that

<math>Z=\dfrac{\bar{X}-\mu }{\sqrt{\dfrac{\sigma ^{2}}{n}}}\thicksim N\left(0,1\right) ,</math>

and in this one has to replace <math>\sigma ^{2}</math> by <math>S^{2}</math>, not by <math>s^{2}</math>. In effect, we are talking about the estimator and the estimate of <math>SE\left( \bar{X}\right) :</math>

* the estimator of <math>SE\left( \bar{X}\right) </math> is <math>\sqrt{\dfrac{S^{2}}{n}};</math>
* the estimate of <math>SE\left( \bar{X}\right) </math> is <math>\sqrt{\dfrac{s^{2}}{n}}</math>.

Sometimes the estimator of <math>SE\left( \bar{X}\right) </math> is denoted <math>\widehat{SE}\left( \bar{X}\right) </math>, with estimate <math>\widehat{se}\left( \bar{X}\right) </math>, but these are a bit clumsy to use in general.

== Using <math>\widehat{SE}\left( \bar{X}\right)</math> ==

So, instead of using

<math>Z=\dfrac{\bar{X}-\mu }{SE\left( \bar{X}\right) }\thicksim N\left(0,1\right) ,</math>

we should use

<math>T=\dfrac{\bar{X}-\mu }{\widehat{SE}\left( \bar{X}\right) }.</math>

This seems like a simple solution, but unfortunately it is not an innocuous solution. This is because the distribution of the random variable <math>T</math> combines two sources of randomness, <math>\bar{X}</math> and <math>S^{2}</math>. As a result, the distribution of <math>T</math> is '''NOT''' <math>N\left( 0,1\right) </math>.

The distribution of <math>T</math> was discovered by a statistician called W.S. Gossett who worked at the Guinness Brewery in Dublin, and wrote under the pen name ‘Student’. The distribution of <math>T</math> is called ''Student''‘''s'' <math>t</math> ''distribution'', or more commonly, just the <math>t</math> ''distribution''. This distribution depends on a parameter, just like other distributions: here, the parameter is called the ''degrees of freedom''. Before discussing the properties of this distribution, we summarise the distribution statement:

<ul>
<li>in random sampling from <math>N\left( \mu ,\sigma ^{2}\right) </math>,
<math>T=\dfrac{\bar{X}-\mu }{\widehat{SE}\left( \bar{X}\right) }\thicksim t_{n-1},</math></li>
<li>the <math>t</math> distribution with <math>n-1</math> degrees of freedom.</li></ul>

The presence of <math>n-1</math> degrees of freedom can be explained in a number of ways. One explanation is based on the expression for the estimator <math>S^{2}</math>:

<math>S^{2}=\dfrac{1}{n-1}\sum\limits_{i=1}^{n}\left( X_{i}-\bar{X}\right) ^{2}.</math>

Here, the divisor <math>n-1</math> in this expression leads to the degrees of freedom for <math>T</math>. This is actually the main justification for using a divisor <math>n-1</math> in a sample variance <math>S^{2}</math> rather than <math>n</math>, although using <math>n-1</math> also leads to an unbiased estimator.

== Properties of the <math>t</math> distribution ==

In general, the parameter <math>\nu </math> of the <math>t</math> distribution is a positive real number, although in most applications, it is an integer, as here:

<math>\nu =n-1.</math>

Unlike many (population) parameters, this one has a known value once the sample size is known. The Figure below shows a plot of the <math>N\left(0,1\right) </math> distribution, a <math>t</math> distribution with <math>\nu =2</math> and a <math>t</math> distribution with <math>\nu =5</math> degrees of freedom.

[[File:tnorm.jpg|frameless|500px]]

It can be seen from the Figure above that the <math>t</math> distribution is

* symmetric about zero, like the <math>N\left( 0,1\right) </math> distribution
* more dispersed than <math>N\left( 0,1\right) ;</math>
* as <math>\nu </math> increases, approaches the <math>N\left( 0,1\right) </math> distribution.

One can show that if

<math>T\thicksim t_{\nu },</math>

then

<math>E\left[ T\right] =0,\;\;\;\;\;var\left[ T\right] =\dfrac{\nu }{\nu-2}.</math>

So, the variance is only defined for <math>\nu \geqslant 2</math>, and

<math>var\left[ T\right] \geqslant 1,</math>

which explains the extra dispersion of the <math>t</math> distribution relative to <math>N\left( 0,1\right) </math>.

== Comparing the <math>t</math> and <math>N\left( 0,1\right) </math> distributions ==

One way of doing this is to compare some “typical” probabilities. The difficulty with this is that one cannot produce a table of <math>t</math> distribution probabilities

<math>\Pr \left( T\leqslant t\right) \;\;\;\text{for }T\thicksim t_{\nu }</math>

to compare with those for

<math>\Pr \left( Z\leqslant z\right) \;\;\;\text{for }Z\thicksim N\left(0,1\right) :</math>

there would have to be a table for each value of <math>\nu</math>. If you need a precise probabilities form the t-distribution you need to use a software like EXCEL. The following table gives some numerical values:

<table border="1">

<tr class="header">
<th align="center"></th>
<th align="center"><math>\Pr \left( T\leqslant 1.96\right) </math></th>
<th align="center"><math>\Pr \left( T>1.96\right) </math></th>
<th align="center"><math>\Pr
\left( \left| T\right| >1.96\right) </math></th>
</tr>

<tr class="odd">
<td align="center"><math>t_{2}</math></td>
<td align="center"><math>0.9055</math></td>
<td align="center"><math>0.0945</math></td>
<td align="center"><math>0.1891</math></td>
</tr>
<tr class="even">
<td align="center"><math>t_{4}</math></td>
<td align="center"><math>0.9464</math></td>
<td align="center"><math>0.0536</math></td>
<td align="center"><math>0.1073</math></td>
</tr>
<tr class="odd">
<td align="center"><math>t_{40}</math></td>
<td align="center"><math>0.9715</math></td>
<td align="center"><math>0.0285</math></td>
<td align="center"><math>0.0570</math></td>
</tr>
<tr class="even">
<td align="center"><math>t_{100}</math></td>
<td align="center"><math>0.9736</math></td>
<td align="center"><math>0.0264</math></td>
<td align="center"><math>0.0528</math></td>
</tr>
<tr class="odd">
<td align="center"><math>N\left( 0,1\right) </math></td>
<td align="center"><math>0.9750</math></td>
<td align="center"><math>0.0250</math></td>
<td align="center"><math>0.0500</math></td>
</tr>

</table>

One can see that the tail probabilities for the <math>t_{\nu }</math> distribution actually approach those of the <math>N\left( 0,1\right) </math> distribution as <math>\nu </math> increases, although the rate of convergence is quite slow in fact. Conventionally, one treats <math>N\left( 0,1\right) </math> as if it were <math>t_{\infty }</math>, as in the tables in the Appendix to this book.

An alternative comparison is in terms of ''percentage points'' - values <math>t </math> and <math>z</math> such that, for example,

<math>\begin{aligned}
\Pr \left( T\leqslant t\right) &=&0.975\;\;\;\text{for\ \ \ }T\thicksim t_{\nu }, \\
\Pr \left( Z\leqslant z\right) &=&0.975\;\;\;\text{for\ \ \ }Z\thicksim N\left( 0,1\right) .\end{aligned}</math>

More generally, <math>z_{\alpha }</math> is the percentage point such that

<math>\Pr \left( Z>z_{\alpha }\right) =\alpha ,</math>

and, for the <math>t</math> distribution, <math>t_{\nu ,\alpha }</math> is the percentage point such that

<math>\Pr \left( T>t_{\nu ,\alpha }\right) =\alpha .</math>

This [[media:TTable.pdf|table]] gives values of <math>t_{\nu ,\alpha }</math> for various combinations of <math>\nu </math> and <math>\alpha </math> such that

<math>\Pr \left( T\leqslant t_{\nu ,\alpha }\right) =1-\alpha</math>

where the <math>\alpha</math> is the value stated in the row labeled "1-tailed". <ref>The meaning of 1-tailed and indeed 2-tailed will become obvious from the sections on hypothesis testing.
</ref>

The table below shows some of these values:

<table border="1">

<tr class="odd">
<td align="center"></td>
<td align="center">Appendix</td>
<td align="center">''Other Texts''</td>
<td align="center"><code>tinv(0.05,df)</code></td>
</tr>
<tr class="even">
<td align="center"></td>
<td align="center"><math>\Pr \left( T\leqslant t_{\nu ,0.025}\right) </math></td>
<td align="center"><math>\Pr \left( T>t_{\nu
,0.025}\right) </math></td>
<td align="center"><math>\Pr \left( \left\vert T\right\vert >t_{\nu
,0.025}\right) </math></td>
</tr>
<tr class="odd">
<td align="center"><math>t_{2}</math></td>
<td align="center"><math>4.303</math></td>
<td align="center"><math>4.3</math></td>
<td align="center"><math>4.303</math></td>
</tr>
<tr class="even">
<td align="center"><math>t_{5}</math></td>
<td align="center"><math>2.571</math></td>
<td align="center"><math>2.57</math></td>
<td align="center"><math>2.571</math></td>
</tr>
<tr class="odd">
<td align="center"><math>t_{40}</math></td>
<td align="center"><math>2.021</math></td>
<td align="center"><math>2.02</math></td>
<td align="center"><math>2.021</math></td>
</tr>
<tr class="even">
<td align="center"><math>t_{100}</math></td>
<td align="center"><math>1.984</math></td>
<td align="center"><math>1.98</math></td>
<td align="center"><math>1.984</math></td>
</tr>
<tr class="odd">
<td align="center"><math>N\left( 0,1\right) </math></td>
<td align="center"><math>1.96</math></td>
<td align="center"><math>1.96</math></td>
<td align="center"><math>1.96</math></td>
</tr>

</table>

One can see the same sort of effects: the value that puts <math>2.5\%</math> in the upper tail of a <math>t_{\nu }</math> distribution approaches that for the <math>N\left(0,1\right) </math> distribution. There is a conventional textbook presumption that for <math>\nu </math> sufficiently large, one can use the <math>N\left( 0,1\right) </math> percentage points as good enough practical approximations to those from the <math>t_{\nu }</math> distribution. The figure <math>\nu =40</math> is often mentioned for this purpose.

== Confidence intervals using the <math>t</math> distribution ==

Suppose that a <math>100\left( 1-\alpha \right) \%</math> interval estimator or confidence interval is wanted for the mean of a normal distribution, <math>N\left( \mu ,\sigma ^{2}\right) </math>, where <math>\sigma ^{2}</math> is unknown. A random sample of size <math>n</math> will be drawn from this distribution. In the case that <math>\sigma^2</math> was known, the facts that

<math>\begin{aligned}
\bar{X} &\thicksim &N\left( \mu ,\dfrac{\sigma ^{2}}{n}\right) , \\
Z &=&\dfrac{\bar{X}-\mu }{\sqrt{\dfrac{\sigma ^{2}}{n}}}\thicksim N\left(0,1\right)\end{aligned}</math>

were used to derive the interval estimator from the probability statement

<math>\Pr \left( -z_{\alpha /2}\leqslant Z\leqslant z_{\alpha /2}\right) =1-\alpha,</math>

where

<math>\Pr \left( Z>z_{\alpha /2}\right) =\alpha /2.</math>

We cannot use this argument when <math>\sigma ^{2}</math> is unknown. Instead, <math>\sigma ^{2}</math> is replaced by its estimator <math>S^{2}</math>, and the random variable

<math>T=\dfrac{\bar{X}-\mu }{\sqrt{\dfrac{S^{2}}{n}}}\thicksim t_{n-1}</math>

used rather than <math>Z</math>. The replacement probability statement is

<math>\Pr \left( -t_{n-1,\alpha /2}\leqslant T\leqslant t_{n-1,\alpha /2}\right)=1-\alpha ,</math>

in the form

<math>\Pr \left( -t_{n-1,\alpha /2}\leqslant \dfrac{\bar{X}-\mu }{S/\sqrt{n}}\leqslant t_{n-1,\alpha /2}\right) =1-\alpha .</math>

As previously we cab again rearrange this to generate the probability statement which defines the endpoints of the interval estimator as

<math>\Pr \left( \bar{X}-t_{n-1,\alpha /2}\sqrt{\dfrac{S^{2}}{n}}\leqslant \mu \leqslant \bar{X}+t_{n-1,\alpha /2}\sqrt{\dfrac{S^{2}}{n}}\right) =1-\alpha .</math>

That is, the interval estimator or confidence interval is

<math>\begin{aligned}
\left[ C_{L},C_{U}\right] &=&\left[ \bar{X}-t_{n-1,\alpha /2}\sqrt{\dfrac{S^{2}}{n}},\bar{X}+t_{n-1,\alpha /2}\sqrt{\dfrac{S^{2}}{n}}\right] \\
&=&\bar{X}\pm t_{n-1,\alpha /2}\sqrt{\dfrac{S^{2}}{n}}.\end{aligned}</math>

The sample value of this confidence interval (“the” confidence interval) is then

<math>\bar{x}\pm t_{n-1,\alpha /2}\sqrt{\dfrac{s^{2}}{n}}:</math>

notice the use of the sample value <math>s^{2}</math> of <math>S^{2}</math> in this expression. This can be usefully compared with the corresponding confidence interval for the case where <math>\sigma ^{2}</math> is known:

<math>\bar{x}\pm z_{\alpha /2}\sqrt{\dfrac{\sigma ^{2}}{n}.}</math>

Two things are different in the <math>t</math> based confidence interval: the use of <math>t_{n-1,\alpha /2}</math> rather than <math>z_{\alpha /2}</math>, and the use of <math>s^{2}</math> rather than <math>\sigma ^{2}</math>.

== Example ==

This is the same as the previous example, but now assuming that the population variance <math>\sigma ^{2}</math> is unknown. Household income in £’000 is <math>X\thicksim N\left( \mu ,\sigma ^{2}\right) </math>, where '''both''' <math>\mu </math> and <math>\sigma ^{2}</math> are unknown. A random sample of size <math>n=5</math> (previously 50) yields <math>\bar{x}=18</math> (as before) and <math>s^{2}=4.5</math>. Here,

<math>T=\dfrac{\bar{X}-\mu }{\sqrt{\dfrac{S^{2}}{n}}}\thicksim t_{4}.</math>

For a 95% confidence interval for <math>\mu </math>, we need the percentage point <math>t_{4,0.025}</math> such that

<math>\Pr \left( T\leqslant t_{4,0.025}\right) =0.975.</math>

From the the t-distribution [[media:TTable.pdf|table]] this is found to be

<math>t_{4,0.025}=2.776.</math>

The confidence interval for <math>\mu </math> is then

<math>\begin{aligned}
\bar{x}\pm t_{n-1,\alpha /2}\sqrt{\dfrac{s^{2}}{n}} &=&18\pm \left(2.776\right) \sqrt{\dfrac{4.5}{5}} \\
&=&18\pm 2.634 \\
&=&\left[ 15.366,20.634\right] .\end{aligned}</math>

For comparison with the original example, if we had used <math>\sigma ^{2}=5</math> with a sample of size <math>5</math>, the resulting normal-based confidence interval would be

<math>\begin{aligned}
\bar{x}\pm z_{\alpha /2}\sqrt{\dfrac{\sigma ^{2}}{n}} &=&18\pm \left(1.96\right) \sqrt{\dfrac{5}{5}} \\
&=&18\pm 1.96 \\
&=&\left[ 16.04,19.96\right] .\end{aligned}</math>

This normal-based confidence interval is narrower than the <math>t</math> based one: this is the consequence of the extra dispersion of the <math>t</math> distribution compared with the <math>N\left( 0,1\right) </math> distribution. The underlying reason for the increased dispersion is, of course, the fact that we do not know the value of <math>\sigma^2</math>. Although we have a sampel estimate <math>s^2</math> we need to acknowledge that there is sampling variation with respect to this estimate on top of the sampling variation we have for <math>\bar{x}</math>.

=== Additional Resources ===

* Salman Khan on such a confidence interval [https://www.khanacademy.org/math/probability/statistics-inferential/confidence-intervals/v/small-sample-size-confidence-intervals].

= Realationships between Normal, <math>t</math> and <math>\chi ^{2}</math> distributions =

As this point we offer a digression an report some well known properties that link normal, Student <math>t</math> and <math>\chi ^{2}</math> distributions. Some of the following results have been discussed above, but all are included for completeness:

<ol>
<li>Let <math>X\sim N(\mu ,\sigma ^{2});</math> i.e., a normally distributed random variable with mean <math>\mu </math> and variance <math>\sigma ^{2}</math>. Then <math>Z=\left( X-\mu \right) /\sigma \sim N(0,1)</math>, standard normal, and <math>W=Z^{2}\sim \chi_{1}^{2}</math>, chi-squared with <math>1</math> degree of freedom. Generally, <math>\chi _{v}^{2}</math> denotes a chi-squared distribution with <math>v</math> degrees of freedom.</li>
<li>Let <math>X_{i}</math>, <math>i=1,\ldots ,n</math>, be ''iid ''(independently and identically distributed) <math>N\left( \mu ,\sigma ^{2}\right) </math> variates, then
<math>\sum_{i=1}^{n}Z_{i}^{2}\sim \chi _{n}^{2},</math>
where <math>Z_{i}=\left( X_{i}-\mu \right) /\sigma </math>, and
<math>\frac{1}{\sigma ^{2}}\sum_{i=1}^{n}\left( X_{i}-\bar{X}\right) ^{2}\sim \chi_{n-1}^{2},</math>
where <math>\bar{X}=\frac{1}{n}\sum_{i=1}^{n}X_{i}</math>.
Furthermore,
<math>\sqrt{n}\left( \bar{X}-\mu \right) /\sigma \sim N(0,1)</math>
and
<math>\sqrt{n}\left( \bar{X}-\mu \right) /s\sim t_{n-1},\quad \quad \text{\emph{Student-t distribution }with }n-1\text{ degrees of freedom,}</math>
where <math>s^{2}=\frac{1}{n-1}\sum_{i=1}^{n}(X_{i}-\bar{X})^{2}</math> is distributed ''independently ''of <math>\bar{X}</math>.</li>
<li>Let <math>Z\sim N(0,1)</math> independently of <math>Y\sim \chi _{v}^{2}</math>. Then, <math>S=\frac{Z}{\sqrt{Y/v}}\sim t_{v}</math>.</li>
<li>Let <math>W\sim \chi _{m}^{2}</math> independently of <math>V\sim \chi _{p}^{2}</math>, then <math>U=W+V\sim \chi _{m+p}^{2}</math> and <math>R=\frac{W/m}{V/p}\sim F_{m,p};</math> i.e., <math>R</math> has an ''F-distribution'' with <math>m</math> and <math>p</math> degrees of freedom. Hence,
<ol>
<li><math>R^{-1}\sim F_{p,m};</math> and,</li>
<li>using previous results, if <math>S\sim t_{q}</math> then <math>S^{2}\sim F_{1,q}</math>.</li></ol>
</li></ol>

= Large Sample Confidence Intervals =

The discussion so far has been based on the idea that we are sampling from a normal distribution, <math>N\left( \mu ,\sigma ^{2}\right) </math>, in which both <math>\mu </math> and <math>\sigma ^{2}</math> may have to be estimated. However, in practice there will only be few occasions on which we can be certain that the type of distribution is Normal. Therefore this assumptions of normality need not be true: what can be done if the '''assumption of normality''' is false?

== Impact of Central Limit Theorem ==

The usual sampling distribution of the sample mean <math>\bar{X}</math> also assumes sampling from a normal distribution. In an earlier [[Statistics_SamplingDistributions#Sampling_from_Non-Normal_distributions| Section]], the effect of sampling from a non-normal distribution was discussed. Provided that one draws a random sample from a population with mean <math>\mu </math> and variance <math>\sigma ^{2}</math>, the Central Limit Theorem assures us that

<math>\dfrac{\bar{X}-\mu }{\sigma /\sqrt{n}}\thicksim N\left( 0,1\right) \;\;\;\;\;\text{approximately,}</math>

or, equivalently,

<math>\bar{X}\thicksim N\left( \mu ,\dfrac{\sigma ^{2}}{n}\right) \;\;\;\;\;\text{approximately.}</math>

There is the presumption that the quality of the approximation improves as <math>n\rightarrow \infty </math>, that is, as the sample size increases. The larger the <math>n</math>, the better.

If <math>\sigma ^{2}</math> is known, then we are '''approximately''' back in the context of Section [ci]. That is, we proceed as if <math>\sigma ^{2}</math> is known, and simply qualify the confidence level as an '''approximate''' confidence level.

If <math>\sigma ^{2}</math> is unknown, we can use <math>S^{2}</math> to estimate <math>\sigma ^{2}</math>. However, unless we sample from a normal distribution, it will '''not''' be true that

<math>T=\dfrac{\bar{X}-\mu }{\sqrt{\dfrac{S^{2}}{n}}}\thicksim t_{n-1}.</math>

Rather,

<math>T=\dfrac{\bar{X}-\mu }{\sqrt{\dfrac{S^{2}}{n}}}\thicksim N\left( 0,1\right) \;\;\;\;\;\text{\textbf{approximately}.}</math>

That is, replacing <math>\sigma ^{2}</math> by an estimator still allows the '''large sample normal approximation''' to hold. Only an intuitive justification for this can be given here. This is simply that as <math>n\rightarrow \infty </math>,

<math>S^{2}\rightarrow \sigma ^{2}:</math>

<math>S^{2}</math> gets so close to <math>\sigma ^{2}</math> that its influence on the distribution of <math>T</math> disappears.

== The large sample confidence interval for <math>\mu </math> ==

From the initial probability statement

<math>\Pr \left( -z_{\alpha /2}\leqslant \dfrac{\bar{X}-\mu }{\sqrt{\dfrac{S^{2}}{n}}}\leqslant z_{\alpha /2}\right) =1-\alpha \;\;\;\;\;\text{approximately,}</math>

we derive, as previously, the interval estimator or confidence interval

<math>\left[ C_{L},C_{U}\right] =\bar{X}\pm z_{\alpha /2}\sqrt{\dfrac{S^{2}}{n}}</math>

having '''approximate''' confidence level <math>100\left( 1-\alpha \right) \%</math>. The sample value of this confidence interval is

<math>\bar{x}\pm z_{\alpha /2}\sqrt{\dfrac{s^{2}}{n}}.</math>

Consider the earlier example (using <math>n=50</math>), but now not assuming that sampling takes place from a normal distribution. We assume that the sample information is <math>n=50</math>, <math>\bar{x}=18</math> and <math>s^{2}=4.5</math>. Then, an approximate <math>95\%</math> confidence interval is

<math>\begin{aligned}
\bar{x}\pm z_{\alpha /2}\sqrt{\dfrac{s^{2}}{n}} &=&18\pm 1.96\sqrt{\dfrac{4.5}{50}} \\
&=&18\pm 0.588 \\
&=&\left[ 17.412,18.588\right] .\end{aligned}</math>

In general, how this compares with the exact confidence interval based on knowledge of <math>\sigma ^{2}</math> depends on how good <math>s^{2}</math> is as an estimate of <math>\sigma ^{2}</math>. Nothing can be said about this usually.

== Confidence intervals for population proportions ==

In the Section on [[Point_Estimation#Estimating_the_population_proportion|estimating a population proportion]] <math>\pi </math> we assumed that a random sample is obtained from the distribution of a Bernoulli random variable, a random variable <math>X</math> taking on values <math>0</math> and <math>1</math> with probabilities <math>1-\pi </math> and <math>\pi </math> respectively. The sample mean <math>\bar{X}</math> here is the random variable representing the sample proportion of <math>1^{\prime }s</math>, and so is usually denoted <math>P</math>, “the” sample proportion. It was shown in that [[Point_Estimation#Estimating_the_population_proportion|Section]] that the sampling distribution of <math>P</math> is related to a Binomial distribution, and that the Central Limit Theorem can be used to provide an approximate normal sampling distribution.

Since

<math>E\left[ P\right] =\pi ,\;\;\;\;var\left[ P\right] =\dfrac{\pi \left( 1-\pi \right) }{n},</math>

<math>\dfrac{P-\pi }{\sqrt{var\left[ P\right] }}\thicksim N\left(0,1\right) \;\;\;\;\;\text{approximately.}</math>

So, one could hope to use this to provide an approximate confidence interval for <math>\pi </math>. There is a minor complication here in that <math>var\left[ P\right] </math> depends on the unknown parameter <math>\pi </math>, but, there is an obvious estimator (<math>P)</math> available which could used to provide an estimator of <math>var\left[ P\right] </math>.

Following the previous reasoning, we argue that

<math>\dfrac{P-\pi }{\sqrt{\dfrac{P\left( 1-P\right) }{n}}}\thicksim N\left(0,1\right) \;\;\;\;\;\text{approximately.}</math>

By analogy with the case of the population mean, an approximate <math>100\left(1-\alpha \right) \%</math> confidence interval for <math>\pi </math> is

<math>\left[ C_{L},C_{U}\right] =P\pm z_{\alpha /2}\sqrt{\dfrac{P\left( 1-P\right)}{n}},</math>

with sample value

<math>p\pm z_{\alpha /2}\sqrt{\dfrac{p\left( 1-p\right) }{n}}.</math>

== Example ==

A random sample of 300 households is obtained, with 28% of the sample owning a tablet computer. An approximate <math>95\%</math> confidence interval for the population proportion of households owning a tablet computer is

<math>\begin{aligned}
p\pm z_{\alpha /2}\sqrt{\dfrac{p\left( 1-p\right) }{n}} &=&0.28\pm \left(1.96\right) \sqrt{\dfrac{0.28\left( 1-0.28\right) }{300}} \\
&=&0.28\pm 0.0508 \\
&=&\left[ 0.229,0.331\right] .\end{aligned}</math>

For such an apparently large sample size, this is quite a wide confidence interval. Better precision of estimation would require a larger sample size.

=== Additional resources ===

* This is the Khan Academy example of a confidence interval for a proportion [https://www.khanacademy.org/math/probability/statistics-inferential/confidence-intervals/v/confidence-interval-example].

= Footnotes =

<references />

Point Estimation Exercises

2019-09-16T13:35:41Z

Rb: /* Exercises */

= Exercises =

Worked solutions to these questions can be found here: [http://youtu.be/TCHG3mP3q1g?hd=1 Q1], [http://youtu.be/iXwkvtZpjm8?hd=1 Q2], [http://youtu.be/mQymVsrxmPU?hd=1 Q3], [http://youtu.be/x4lzkCx3bNw?hd=1 Q4], [http://youtu.be/PqZko0Yi8Fc?hd=1 Q5] and [http://youtu.be/8-uQdtCZdlA?hd=1 Q6]

<ol>
<li><math>[L1,L2]</math>Suppose that <math>Y\sim N\left( 6,2\right) </math>, and that <math>\bar{Y}</math> is the sample mean of a (simple) random sample of size <math>n</math>. Find:
<ol>
<li><math>\Pr \left( Y>8\right)</math>; {0.0793}</li>
<li><math>\Pr \left( \bar{Y}>8\right) \;</math>when <math>n=1;</math> {0.0793}</li>
<li><math>\Pr \left( \bar{Y}>8\right) \;</math>when <math>n=2;</math> {0.0228}</li>
<li><math>\Pr \left( \bar{Y}>8\right) \;</math>when <math>n=5;</math> {0.0000}</li></ol>

Sketch, on the same axes, the sampling distribution of <math>\bar{Y}</math> for <math>n=1,2,5</math>.</li>
<li><math>[L1,L2]</math> In a certain population, 60% of all adults own a car. If a simple random sample of 100 adults is taken, what is the probability that at least 70% of the sample will be car owners? (Optional: use EXCEL to find the exact probability.) {0.0207 and 0.0262 are both approximations}</li>
<li><math>[L1,L2]</math>When set correctly, a machine produces hamburgers of mean weight <math>100g</math> each and standard deviation <math>5g</math> each. The weight of hamburgers is known to be normally distributed. The hamburgers are sold in packets of four.
<ol>
<li>What is the sampling distribution of the total weight of hamburgers in a packet? In stating this sampling distribution, state carefully what results you using and any assumptions you have to make. {N(400,400), independence}</li>
<li>A customer claims that packets of hamburgers are underweight. A trading standards officer is sent to investigate. He selects one packet of four hamburgers and finds that the weight of hamburgers in it is <math>390g</math>. What is the probability of a packet weighing as little as <math>390g</math> if the machine is set correctly? Do you consider that this finding constitutes evidence that the machine has been set to deliver underweight hamburgers? {0.3085}</li></ol>
</li>
<li>A discrete random variable, <math>Y</math>, has the following probability distribution:
<table border="1">

<tr class="header">
<th align="center"><math>y</math></th>
<th align="center"><math>0</math></th>
<th align="center"><math>1</math></th>
<th align="center"><math>2</math></th>
</tr>

<tr class="odd">
<td align="center"><math>p\left( y\right) </math></td>
<td align="center"><math>0.3</math></td>
<td align="center"><math>0.4</math></td>
<td align="center"><math>0.3</math></td>
</tr>

</table>

<ol>
<li><math>[L2]</math> What are <math>E\left[ Y\right] </math> and <math>y_{\min }</math>, where <math>y_{\min }</math> is the smallest possible value of <math>Y?</math></li>
<li><math>[L1,L2]</math> Simple random samples of two observations are to be drawn with replacement from this population. Write down all possible samples, and the probability of each sample. {e.g. (<math>P(y_1=0, y_2=2)=0.09</math>} Use this to obtain the sampling distribution of each of the following statistics:
<ol>
<li>the sample mean, <math>\bar{Y};</math> {e.g. <math>P(\bar{Y}=0.5)=0.24)</math>}</li>
<li>the minimum of the two observations, <math>M</math>. {<math>P(M=1)=0.4</math>}</li></ol>
</li>
<li><math>[L2]</math> Calculate <math>E\left[ \bar{Y}\right] </math> and <math>E\left[ M\right] </math>. State whether each is an unbiased estimator of the corresponding population parameter. {<math>\bar{Y}</math> yes, <math>M</math> no}</li></ol>
</li>
<li>A random sample of size three is drawn from the distribution of a Bernoulli random variable <math>X</math>, where
<math>\Pr \left( X=0\right) =0.3,\;\;\;\Pr \left( X=1\right) =0.7.</math>
<ol>
<li><math>[L1,L2]</math> Enumerate all the possible samples, and find their probabilities of being drawn. You should have eight possible samples. {e.g. <math>P(1,0,1)=0.3*0.7^2)</math>}</li>
<li><math>[L1,L2]</math> Find the sampling distribution of the random variable <math>T</math>, the total number of ones in each sample. {e.g. <math>P(T=1)=0.189)</math>}</li>
<li><math>[L2]</math> Check that the probability distribution of <math>T</math> is the Binomial distribution for <math>n=3</math> and <math>\pi =0.7</math>, by calculating
<math>\Pr \left( T=t\right) =\binom{3}{t}\left( 0.7\right) ^{t}\left( 0.3\right)^{3-t}</math>
for <math>t=0,1,2,3</math>.</li>
<li><math>[L1,L2]</math> Find the probability distribution of <math>P</math>, the sample proportion of ones. How is this probability distribution related to that of <math>T?</math> {e.g. <math>Pr(P=2/3)=0.441)</math>}</li>
<li><math>[L2]</math> Is <math>P</math> an unbiased estimator of <math>\Pr \left( X=1\right) ?</math> {yes}</li></ol>
</li>
<li><math>[L2]</math> A simple random sample of three observations is taken from a population with mean <math>\mu </math> and variance <math>\sigma ^{2}</math>. The three sample random variables are denoted <math>Y_{1},Y_{2},Y_{3}</math>. A sample statistic is being sought to estimate <math>\mu </math>. The statistics being considered are
<ol>
<li><ol>
<li><math>A_{1}=\dfrac{1}{3}\left( Y_{1}+Y_{2}+Y_{3}\right) ;</math></li>
<li><math>A_{2}=\dfrac{1}{2}\left( Y_{1}+Y_{2}\right) ;</math></li>
<li><math>A_{3}=\dfrac{1}{2}\left( Y_{1}+Y_{2}+Y_{3}\right) ;</math></li>
<li><math>A_{4}=0.75Y_{1}+0.75Y_{2}-0.5Y_{3}</math>.</li></ol>
</li>
<li>Which of these statistics yields an unbiased estimator of <math>\mu ?</math> {<math>A_1,A_2</math> and <math>A_4</math>}</li>
<li>Of those that are unbiased, which is the most efficient? {<math>Var(A_1)=Var(Y)/3</math>}</li>
<li>Of those that are unbiased, find the efficiency with respect to <math>A_{1}. </math></li></ol>
</li></ol>

= Footnotes =

Panel in R

2019-03-03T22:13:33Z

Rb: /* Set-up of Panel */

In this section we shall discuss how to deal with panel data and how to use econometric techniques that exploit the additional analysis that can be performed due to the Panel character of data.

A lot of this material repeats material that is discussed in this YouTube clip [https://www.youtube.com/watch?v=1pST2lUx6QM].

== The plm package ==

To deal efficiently with panel data we will need the <source enclose=none>plm</source> package and you need to downlaod it (<source enclose=none>install.packages("plm")</source>) and load it into the workspace (<source enclose=none>library(plm)</source>) in the usual manner.

Details for this package can be found [http://cran.r-project.org/web/packages/plm/vignettes/plm.pdf here].

== Example Data ==

Here we are using the [[R#Data_Sets|Crime Statistics]] dataset for illustration. It is used in Example 13.9 in Wooldridge's Introductory Econometrics. The dependent variable we will be looking at here is the crime rate (<source enclose = none>crmrte</source> and we will use a range of explanatory variables that describe features of the local enforcement setting, like the probability of arrest (<source enclose = none>prbarr</source>), probability of conviction (<source enclose = none>prbconv</source>), probability of prison if convicted (<source enclose = none>prbpris</source>), average sentence length (<source enclose = none>avgsen</source>) and the number of police officers per person (<source enclose = none>polpc</source>). The data are for 90 counties in North Carolina and for each we have observations for the years 1081 to 1987.

These type of models are usually estimated in log-log form to obtain elasticities and the for this reason the dataset already includes the logged variables (the above names preceded with the letter <source enclose = none>"l"</source>, e.g. <source enclose = none>lcrmrte</source>. Further, and in anticipation of time-differenced series often being used, the data-set also includes the differenced log variables. These are the variables preceded with the letter <source enclose = none>"c"</source>, e.g. <source enclose = none>clcrmrte</source>.

Often original data-files do only come with the original variables and without the logged and differenced variables and as it turns out you will often not need these extra variables.

When using panel data we will often want to allow for time period effects and for this reason the dataset also includes time dummy variables, e.g. <source enclose = none> d83</source>, which takes a value of 1 for observations from 1983 and 0 otherwise.

== Set-up of Panel ==

Here is our initial data load-up

library(plm)
setwd("X:/ECLR/R/PanelData") # This sets the working directory
# Opens crime4.csv from working directory
# converts variables with "." entries to num with NA instead of "."
mydata <- read.csv("crime4.csv",na.strings = ".")

So far we have merely uploaded the csv file. It is worth having a look at the data at this stage

[[File:Panel_bic1.jpg|frameless|500px]]

The distinctive Panel feature of this dataset is that we have several periods of observations (year) for each county. At this stage R does not yet know that these are Panel Data and now we need to let it know about this feature. This is what the following function does:

pdata <- pdata.frame(mydata, index = c("county","year")) # defines the panel dimensions

The first input into the <source enclose=none>pdata.frame</source> function is the original data frame (here <source enclose = none>mydata</source>). The second input specifies which variable indexes the individual (here <source enclose = none>"county"</source>.) and the variable which indexes the time (here <source enclose = none>"year"</source>.). Both these are collected in a list and handed over to the function as <source enclose = none>index = c("county","year")</source>.

== Estimation Methods ==

This is not the right place to discuss the merits of the range of different estimation methods that exist for Panel Data sets. Let's assume we want to explain variation in the dependent variable <source enclose = none>lcrmrte</source> as a function of logs of all the other variables listed above (<source enclose = none>lprbarr, lprbconv, lprbpris, lavgsen and lpolpc</source>) and time dummy variables.

A range of estimation methods exist to make use of the panel character of data. Here I will only introduce pooled estimation and first difference estimation. If you want to use any of the other available methods you should consult the [http://cran.r-project.org/web/packages/plm/vignettes/plm.pdf documentation] of the plm package.

=== Pooled OLS ===

This is the most straightforward way to estimate a model. Essentially we are just chucking all the observations into one big pot and apply a straightforward OLS estimation. The way to do this is as follows:

pooling <- plm(formula = lcrmrte ~ d83 + d84 + d85 + d86 + d87
+ prbarr + prbconv + prbpris + avgsen + polpc,
data = pdata, model = "pooling")
print(summary(pooling))

As you can see, calling a panel data estimation method using the <source enclose = none>plm</source> function is not unlike calling a normal OLS regression using the <source enclose = none>lm</source> function. The first input is the model representation (the dependent variable followed by all explanatory variables) and the second is the dataframe which is being used, and importantly here we are using the panel data version we defined previously <source enclose = none>pdata</source>. A difference is that here we need a third input which specifies how we estimate the Panel Data model. If we want to pool all observation then we call <source enclose = none>model = "pooling"</source>. <ref>Other available methods are "within", "between", "random", "fd" and "ht". For details see the plm documentation.</ref>

This delivers

Oneway (individual) effect Pooling Model

Call:
plm(formula = lcrmrte ~ d82 + d83 + d84 + d85 + d86 + d87 + prbarr +
prbconv + prbpris + avgsen + polpc, data = pdata, model = "pooling")

Balanced Panel: n=90, T=7, N=630

Residuals :
Min. 1st Qu. Median 3rd Qu. Max.
-2.0000 -0.2840 0.0328 0.3110 1.4800

Coefficients :
Estimate Std. Error t-value Pr(>|t|)
(Intercept) -3.3529108 0.1385095 -24.2071 < 2.2e-16 ***
d82 -0.0118914 0.0723975 -0.1643 0.8695870
d83 -0.0465997 0.0720681 -0.6466 0.5181272
d84 -0.1524940 0.0725012 -2.1033 0.0358405 *
d85 -0.1180270 0.0728541 -1.6200 0.1057325
d86 -0.0838222 0.0723015 -1.1593 0.2467644
d87 0.0027029 0.0709855 0.0381 0.9696382
prbarr -1.7873016 0.1163001 -15.3680 < 2.2e-16 ***
prbconv -0.0958937 0.0126226 -7.5970 1.127e-13 ***
prbpris 0.8453609 0.2193194 3.8545 0.0001281 ***
avgsen -0.0057214 0.0074539 -0.7676 0.4430340
polpc 56.9623752 8.1233886 7.0121 6.173e-12 ***
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Total Sum of Squares: 206.38
Residual Sum of Squares: 137.88
R-Squared : 0.33191
Adj. R-Squared : 0.32559
F-statistic: 27.9113 on 11 and 618 DF, p-value: < 2.22e-16

Here we have included 6 time dummies to allow for different intercepts for the seven different years.

=== First Difference ===

One issue with simple models like the pooled model is that it is quite likely that there will be unobserved heterogeneity which is, while not explicitly modelled and hence contained in the error term, it to be expected that some of this county to county variation is correlated with some of the explanatory variables and consequently violating the zero-conditional mean assumption.

The perhaps easiest way to deal with this is to estimate a model in (time-)differenced form, as this differencing will eliminate the (time-invariant) elements of this heterogeneity. To estimte the model in differenced form. This is done as follows:

fd3 <- plm(lcrmrte ~ d82 + d83 + d84 + d85 + d86 + d87
+ lprbarr + lprbconv + lprbpris + lavgsen + lpolpc - 1,
data = pdata, model = "fd")
print(summary(fd3))

Most of this function call is identical to the above call, but for two differences. First, the method now indicates that we need a first difference estimation model = "fd". Second, as we are taking first differences we need to estimate the model without a constant, which is why we include the term - 1 into the model specification.

This model basically replicates the model estimated in Wooldridge's Example 13.9:

Oneway (individual) effect First-Difference Model

Call:
plm(formula = lcrmrte ~ d82 + d83 + d84 + d85 + d86 + d87 + lprbarr +
lprbconv + lprbpris + lavgsen + lpolpc - 1, data = pdata,
model = "fd")

Balanced Panel: n=90, T=7, N=630

Residuals :
Min. 1st Qu. Median 3rd Qu. Max.
-0.65900 -0.07840 0.00296 0.07500 0.68300

Coefficients :
Estimate Std. Error t-value Pr(>|t|)
d82 0.0077133 0.0170579 0.4522 0.6513202
d83 -0.0844391 0.0234564 -3.5998 0.0003484 ***
d84 -0.1246632 0.0287464 -4.3367 1.733e-05 ***
d85 -0.1215609 0.0331500 -3.6670 0.0002702 ***
d86 -0.0863332 0.0366763 -2.3539 0.0189411 *
d87 -0.0377932 0.0399728 -0.9455 0.3448481
lprbarr -0.3274943 0.0299801 -10.9237 < 2.2e-16 ***
lprbconv -0.2381068 0.0182341 -13.0583 < 2.2e-16 ***
lprbpris -0.1650464 0.0259690 -6.3555 4.488e-10 ***
lavgsen -0.0217606 0.0220909 -0.9850 0.3250509
lpolpc 0.3984266 0.0268820 14.8213 < 2.2e-16 ***
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Total Sum of Squares: 22.197
Residual Sum of Squares: 12.596
R-Squared : 0.43251
Adj. R-Squared : 0.4237
F-statistic: 36.6529 on 11 and 529 DF, p-value: < 2.22e-16

As you can see we now have lost a constant. When interpreting you should keep in mind that all variables are used in differences. To see this you will have to refer to the note in the title of the regression output (First-Difference Model).

The marginal effects of the explanatory variable effects are negative as expected for all but the police number variable<ref>The reason for that is most likely the endogeneity of that variable.</ref> and are exactly as those reported in the Wooldridge textbook example 13.9. What differs are the estimated values for the dummy variables. Recall that the model reported here uses the time-differences and hence also the time differences of the time dummy variables which are slightly unintuitive. An alternative way to include these dummy variables is to drop one of the dummy variables (so only include 5 here), but use these in their actual levels and add a constant back. That is what is done in Wooldridge, but it only changes the estimated values for the dummy variable parameters, leaving the model fit and the estimated coefficients for all other explanatory variables unchanged.

== Literature ==

* Wooldridge, J.M. (2015) Introductory Econometrics, 6th edition
* Angrist and Pischke, Mostly Harmless Econometrics
* The documentation to the plm package [http://cran.r-project.org/web/packages/plm/vignettes/plm.pdf found here]

== References ==
<references />

R GARCH

2018-05-04T00:41:32Z

Rb: /* Introduction */

= Introduction =

When you are dealing with financial time-series we often have relatively high frequency observations available. It is very common for instance to have daily observations available. In fact it is now possible to obtain hourly, minute, second or even millisecond observations. But here we will restrict ourselves to daily observations. For some assets these will be 7 days a week observations, but for others these will be work-day observations, so typically 5 days a week of observations.

A video walk-through is available from https://youtu.be/8VXmRl5gzEU

= Packages used =

There are a number of packages that can enable us to estimate volatility models. The packages we will use are the <code>rugarch</code> for univariate GARCH models and the <code>rmgarch</code> (for multivariate models) package both written by Alexios Ghalanos. We shall also use the <code>quantmod</code> package as it will give us some easy access to some standard financial data.

So please ensure that you install these packes and then load them,

<pre class="r">#install.packages(c("quantmod","rugarch","rmgarch")) # only needed in case you have not yet installed these packages
library(quantmod)
library(rugarch)
library(rmgarch)</pre>
Next we set our working directory

<pre class="r"># replace with your directory and uncomment
# setwd("YOUR/COPLETE/DIRECTORY/PATH") </pre>
= Data upload =

Here we will use a convenient data retrieval function (<code>getSymbols</code>) delivered by the <code>quantmod</code> package in order to retrieve some data. This function works, for instance, to retrieve stock data. The default source is [https://finance.yahoo.com/ Yahoo Finance]. If you want to find out what stock has which symbol you should be able to search the internet to find a list of ticker symbols. The following shows how to use the function. But note that my experience is that sometimes the connection does not work and you may get an error message. In that case just retry a few seconds later and it may well work.

<pre class="r">startDate = as.Date("2007-01-03") #Specify period of time we are interested in
endDate = as.Date("2018-04-30")

getSymbols("IBM", from = startDate, to = endDate)</pre>
<pre>## [1] "IBM"</pre>
<pre class="r">getSymbols("GOOG", from = startDate, to = endDate)</pre>
<pre>## [1] "GOOG"</pre>
<pre class="r">getSymbols("BP", from = startDate, to = endDate)</pre>
<pre>## [1] "BP"</pre>
In your environment you can see that each of these commands loads an object with the respective ticker symbol name. Let's have a look at one of these dataframes to understand what data these are:

<pre class="r">head(IBM)</pre>
<pre>## IBM.Open IBM.High IBM.Low IBM.Close IBM.Volume IBM.Adjusted
## 2007-01-03 97.18 98.40 96.26 97.27 9196800 73.41806
## 2007-01-04 97.25 98.79 96.88 98.31 10524500 74.20306
## 2007-01-05 97.60 97.95 96.91 97.42 7221300 73.53130
## 2007-01-08 98.50 99.50 98.35 98.90 10340000 74.64834
## 2007-01-09 99.08 100.33 99.07 100.07 11108200 75.53147
## 2007-01-10 98.50 99.05 97.93 98.89 8744800 74.64082</pre>
<pre class="r">str(IBM)</pre>
<pre>## An 'xts' object on 2007-01-03/2018-04-27 containing:
## Data: num [1:2850, 1:6] 97.2 97.2 97.6 98.5 99.1 ...
## - attr(*, "dimnames")=List of 2
## ..$ : NULL
## ..$ : chr [1:6] "IBM.Open" "IBM.High" "IBM.Low" "IBM.Close" ...
## Indexed by objects of class: [Date] TZ: UTC
## xts Attributes:
## List of 2
## $ src : chr "yahoo"
## $ updated: POSIXct[1:1], format: "2018-05-03 22:21:00"</pre>
You can see that this object contains a range of daily observations (<code>Open</code>, <code>High</code>, <code>Close</code>, <code>Volume</code> and <code>Adjusted</code> share price). We also learn that the object is formatted as an <code>xts</code> object. <code>xts</code> is a type of time-series format and indeed we learn that the data range from 2007-01-03 to 2018-04-30.

You can in fact produce a somewhat fancy looking chart with the following command (also part of the <code>quantmod</code> package)

<pre class="r">chartSeries(GOOG)</pre>
[[File:GoogleChart1.png]]

When we are estimating volatility models we work with returns. There is a function that transforms the data to returns.

<pre class="r">rIBM <- dailyReturn(IBM)
rBP <- dailyReturn(BP)
rGOOG <- dailyReturn(GOOG)

# We put all data into a data frame for use in the multivariate model
rX <- data.frame(rIBM, rBP, rGOOG)
names(rX)[1] <- "rIBM"
names(rX)[2] <- "rBP"
names(rX)[3] <- "rGOOG"</pre>
There is also a <code>weeklyReturn</code> function in case that is what you are interested in.

= Univariate GARCH Model =

Here we are using the functionality provided by the <code>rugarch</code> package written by Alexios Galanos.

== Model Specification ==

The first thing you need to do is to ensure you know what type of GARCH model you want to estimate and then let R know about this. It is the <code>ugarchspec( )</code> function which is used to let R know about the model type. There is in fact a default specification and the way to invoke this is as follows

<pre class="r">ug_spec = ugarchspec()</pre>
<code>ug_spec</code> is now a list which contains all the relevant model specifications. Let's look at them:

<pre class="r">ug_spec</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Spec *
## *---------------------------------*
##
## Conditional Variance Dynamics
## ------------------------------------
## GARCH Model : sGARCH(1,1)
## Variance Targeting : FALSE
##
## Conditional Mean Dynamics
## ------------------------------------
## Mean Model : ARFIMA(1,0,1)
## Include Mean : TRUE
## GARCH-in-Mean : FALSE
##
## Conditional Distribution
## ------------------------------------
## Distribution : norm
## Includes Skew : FALSE
## Includes Shape : FALSE
## Includes Lambda : FALSE</pre>
The key issues here are the spec for the <code>Mean Model</code> (here an ARMA(1,1) model) and the specification for the <code>GARCH Model</code>, here an <code>sGARCH(1,1)</code> which is basically a GARCH(1,1). To get details on all the possible specifications and how to change them it is best to consult the [https://cran.r-project.org/web/packages/rugarch/vignettes/Introduction_to_the_rugarch_package.pdf documentation] of the <code>rugarch</code> package.

Let's say you want to change the mean model from an ARMA(1,1) to an ARMA(1,0), i.e. an AR(1) model.

<pre class="r">ug_spec <- ugarchspec(mean.model=list(armaOrder=c(1,0)))</pre>
You could call <code>ug_spec</code> again to check that the model specification has actually changed.

The following is the specification for an # an example of the EWMA Model (although we will not use it below).

<pre class="r">ewma_spec = ugarchspec(variance.model=list(model="iGARCH", garchOrder=c(1,1)),
mean.model=list(armaOrder=c(0,0), include.mean=TRUE),
distribution.model="norm", fixed.pars=list(omega=0))</pre>

== Model Estimation ==

Now that we have specified a model to estimate we need to find the best arameters, i.e. we need to estimate the model. This step is achieved by the <code>ugarchfit</code> function.

<pre class="r">ugfit = ugarchfit(spec = ug_spec, data = rIBM)</pre>
<code>fit</code> is now a list that contains a range of results from the estimation. Let's have a look at the results

<pre class="r">ugfit</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Fit *
## *---------------------------------*
##
## Conditional Variance Dynamics
## -----------------------------------
## GARCH Model : sGARCH(1,1)
## Mean Model : ARFIMA(1,0,0)
## Distribution : norm
##
## Optimal Parameters
## ------------------------------------
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000220 1.55666 0.11955
## ar1 -0.013463 0.021425 -0.62835 0.52978
## omega 0.000015 0.000002 6.56888 0.00000
## alpha1 0.111158 0.006440 17.25930 0.00000
## beta1 0.809517 0.005883 137.59775 0.00000
##
## Robust Standard Errors:
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000230 1.48654 0.137136
## ar1 -0.013463 0.019583 -0.68748 0.491782
## omega 0.000015 0.000012 1.25867 0.208150
## alpha1 0.111158 0.054637 2.03450 0.041901
## beta1 0.809517 0.082783 9.77876 0.000000
##
## LogLikelihood : 8364.692
##
## Information Criteria
## ------------------------------------
##
## Akaike -5.8665
## Bayes -5.8560
## Shibata -5.8665
## Hannan-Quinn -5.8627
##
## Weighted Ljung-Box Test on Standardized Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.03483 0.8519
## Lag[2*(p+q)+(p+q)-1][2] 0.03492 1.0000
## Lag[4*(p+q)+(p+q)-1][5] 1.39601 0.8712
## d.o.f=1
## H0 : No serial correlation
##
## Weighted Ljung-Box Test on Standardized Squared Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.2509 0.6165
## Lag[2*(p+q)+(p+q)-1][5] 1.2795 0.7938
## Lag[4*(p+q)+(p+q)-1][9] 1.9518 0.9107
## d.o.f=2
##
## Weighted ARCH LM Tests
## ------------------------------------
## Statistic Shape Scale P-Value
## ARCH Lag[3] 1.295 0.500 2.000 0.2551
## ARCH Lag[5] 1.603 1.440 1.667 0.5656
## ARCH Lag[7] 1.935 2.315 1.543 0.7312
##
## Nyblom stability test
## ------------------------------------
## Joint Statistic: 26.6709
## Individual Statistics:
## mu 0.42613
## ar1 0.06712
## omega 0.89209
## alpha1 0.55216
## beta1 0.15390
##
## Asymptotic Critical Values (10% 5% 1%)
## Joint Statistic: 1.28 1.47 1.88
## Individual Statistic: 0.35 0.47 0.75
##
## Sign Bias Test
## ------------------------------------
## t-value prob sig
## Sign Bias 0.2134 0.8310
## Negative Sign Bias 1.0137 0.3108
## Positive Sign Bias 0.4427 0.6580
## Joint Effect 1.6909 0.6390
##
##
## Adjusted Pearson Goodness-of-Fit Test:
## ------------------------------------
## group statistic p-value(g-1)
## 1 20 135.6 1.285e-19
## 2 30 139.3 2.301e-16
## 3 40 161.8 6.871e-17
## 4 50 166.2 1.164e-14
##
##
## Elapsed time : 0.7440431</pre>
If you are familiar with GARCH models you will recognise some of the parameters. <code>ar1</code> is the AR1 coefficient of the mean model (here very small and basically insignificant), <code>alpha1</code> is the coefficient to the squared residuals in the GARCH equation and <code>beta1</code> is the coefficient to the lagged variance.

Often you will want to use model output for some further analysis. It is therefore important to understand how to extract information such as the parameter estimates, their standard errors or the residuals. The object <code>ugfit</code> contains all the information. In that object you can find two drawers (or in technical speak slots, @fit and @model). Each of these drawers contains a range of different things. What they contain you can figure out by asking for the element names

<pre class="r">paste("Elements in the @model slot")</pre>
<pre>## [1] "Elements in the @model slot"</pre>
<pre class="r">names(ugfit@model)</pre>
<pre>## [1] "modelinc" "modeldesc" "modeldata" "pars" "start.pars"
## [6] "fixed.pars" "maxOrder" "pos.matrix" "fmodel" "pidx"
## [11] "n.start"</pre>
<pre class="r">paste("Elements in the @fit slot")</pre>
<pre>## [1] "Elements in the @fit slot"</pre>
<pre class="r">names(ugfit@fit)</pre>
<pre>## [1] "hessian" "cvar" "var"
## [4] "sigma" "condH" "z"
## [7] "LLH" "log.likelihoods" "residuals"
## [10] "coef" "robust.cvar" "A"
## [13] "B" "scores" "se.coef"
## [16] "tval" "matcoef" "robust.se.coef"
## [19] "robust.tval" "robust.matcoef" "fitted.values"
## [22] "convergence" "kappa" "persistence"
## [25] "timer" "ipars" "solver"</pre>
If you wanted to extract the estimated coefficients you would do that in the following way:

<pre class="r">ugfit@fit$coef</pre>
<pre>## mu ar1 omega alpha1 beta1
## 3.419000e-04 -1.346260e-02 1.516946e-05 1.111584e-01 8.095171e-01</pre>
<pre class="r">ug_var <- ugfit@fit$var # save the estimated conditional variances
ug_res2 <- (ugfit@fit$residuals)^2 # save the estimated squared residuals</pre>
Let's plot the squared residuals and the estimated conditional variance:

<pre class="r">plot(ug_res2, type = "l")
lines(ug_var, col = "green")</pre>
[[File:CondVar2.png]]

== Model Forecasting ==

Often you will want to use an estimated model to subsequently forecast the conditional variance. The function used for this purpose is the <code>ugarchforecast</code> function. The application is rather straightforward:

<pre class="r">ugfore <- ugarchforecast(ugfit, n.ahead = 10)
ugfore</pre>
<pre>##
## *------------------------------------*
## * GARCH Model Forecast *
## *------------------------------------*
## Model: sGARCH
## Horizon: 10
## Roll Steps: 0
## Out of Sample: 0
##
## 0-roll forecast [T0=2018-04-27]:
## Series Sigma
## T+1 0.0003685 0.01640
## T+2 0.0003415 0.01621
## T+3 0.0003419 0.01604
## T+4 0.0003419 0.01587
## T+5 0.0003419 0.01572
## T+6 0.0003419 0.01558
## T+7 0.0003419 0.01545
## T+8 0.0003419 0.01533
## T+9 0.0003419 0.01521
## T+10 0.0003419 0.01511</pre>
As you can see we have produced forecasts for the next ten days, both for the expected returns (<code>Series</code>) and for the conditional volatility (square root of the conditional variance). Similar to the object created for model fitting, <code>ugfore</code> contains two slots (@model and @forecast) and you can use <code>names(ugfore@forecast)</code> to figure out under which names the elements are saved. For instance you can extract the conditional volatility forecast as follows:

<pre class="r">ug_f <- ugfore@forecast$sigmaFor
plot(ug_f, type = "l")</pre>
[[File:ug_forecast3.png]]

Note that the volatility is the square root of the conditional variance.

To put these forecasts into context let's display them together with the last 50 observations used in the estimation.

<pre class="r">ug_var_t <- c(tail(ug_var,20),rep(NA,10)) # gets the last 20 observations
ug_res2_t <- c(tail(ug_res2,20),rep(NA,10)) # gets the last 20 observations
ug_f <- c(rep(NA,20),(ug_f)^2)

plot(ug_res2_t, type = "l")
lines(ug_f, col = "orange")
lines(ug_var_t, col = "green")</pre>
[[File:ug_forecast4.png]]

You can see how the forecast of the conditional variance picks up from the last estimated conditional variance. In fact it decreases from there, slowly, towards the unconditional variance value.

The <code>rugarch</code> package has a lot of additional functionality which you can explore through the documentation.

= Multivariate GARCH models =

Often you will want to model the volatility of a vector of assets. This can be done with the multivariate equivalent of the univariate GARCH model. Estimating multivariate GARCH models turns out to be significantly more difficult than univariate GARCH models, but fortunately procedures have been developed that deal with most of these issues.

Here we are using the <code>rmgarch</code> package which has a lot of useful functionality. We are applying it to estimate a multivariate volatility model for the returns of BP, Google/Alphabet and IBM shares.

As for the <code>rugarch</code> package we first need to specify the model we want to estimate. Here we stick with a Dynamic Conditional Correlation (DCC) model (see the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for details.). When estimating DCC models one basically estimates individual GARCH-type models (which could differ for each individual asset). These are then used to standardise the individual residuals. As a second step one then has to specify the correlation dynamics of these standardised residuals. It is possible to estimate the parameters of the univariate and the correlation model in one big swoop. however, my experience with this, and other packages, is that it is beneficial to separate the two steps.

== Model Setup ==

Here we assume that we are using the same univariate volatility model specification for each of the three assets.

<pre class="r"># DCC (MVN)
uspec.n = multispec(replicate(3, ugarchspec(mean.model = list(armaOrder = c(1,0)))))</pre>
What does this command do? You will recognise that <code>ugarchspec(mean.model = list(armaOrder = c(1,0)))</code> specifies an AR(1)-GARCH(1,1) model. By using <code>replicate(3, ugarchspec...)</code> we replicate this model 3 times (as we have three assets, IBM, Google/Alphabet and BP).

We now estimate these univariate GARCH models using the <code>multifit</code> command.

<pre class="r">multf = multifit(uspec.n, rX)</pre>
The results are saved in <code>multf</code> and you can type <code>multf</code> into the command window to see the estimated parameters for these three models. But we will here proceed to specify the DCC model (I assume that you know what a DCC model is. This is not the place to elaborate on this and many textbooks or indeed the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] to this package provide details). To specify the correlation specification we use the <code>dccspec</code> function.

<pre class="r">spec1 = dccspec(uspec = uspec.n, dccOrder = c(1, 1), distribution = 'mvnorm')</pre>
In this specification we have to state how the univariate volatilities are modeled (as per <code>uspec.n</code>) and how complex the dynamic structure of the correlation matrix is (here we are using the most standard <code>dccOrder = c(1, 1)</code> specification).

== Model Estimation ==

Now we are in a position to estimate the model using the <code>dccfit</code> function.

<pre class="r">fit1 = dccfit(spec1, data = rX, fit.control = list(eval.se = TRUE), fit = multf)</pre>
We want to estimate the model as specified in <code>spec1</code>, using the data in <code>rX</code>. The option <code>fit.control = list(eval.se = TRUE)</code> ensures that the estimation procedure produces standard errors for estimated parameters. Importantly <code>fit = multf</code> indicates that we ought to use the already estimated univariate models as they were saved in <code>multf</code>. The way to learn how to use these functions is by a combination of looking at the functions's help (<code>?dccfit</code>) and googling.

When you estimate a multivariate volatility model like the DCC model you are typically interested in the estimated covariance or correlation matrices. After all it is at the core of these models that you allow for time-variation in the correlation between the assets (there are also constant correlation models, but we do not discuss this here). Therefore we will now learn how we extract these.

<pre class="r"># Get the model based time varying covariance (arrays) and correlation matrices
cov1 = rcov(fit1) # extracts the covariance matrix
cor1 = rcor(fit1) # extracts the correlation matrix</pre>
To understand the object we have at our hands here we can have a look at the imension:

<pre class="r">dim(cor1)</pre>
<pre>## [1] 3 3 2850</pre>
We get three outputs which tells us that we have a three dimensional object. The firts two dimensions have 3 elements each (think a <math>3\times3</math> correlation matrix) and then there is a third dimension with 2850 elements. This tells us that <code>cor1</code> stores 2850 (<math>3\times3</math>) sorrelation matrices, one for each day of data.

Let's have a look at the correlation matrix for the last day, day 2853;

<pre class="r">cor1[,,dim(cor1)[3]]</pre>
<pre>## rIBM rBP rGOOG
## rIBM 1.0000000 0.2424297 0.353591
## rBP 0.2424297 1.0000000 0.275244
## rGOOG 0.3535910 0.2752440 1.000000</pre>
So let's say we want to plot the time-varying correlation between Google and BP, which is 0.275244 on that last day. In our matrix with returns <code>rX</code> BP is the second asset and Google the 3rd. So in any particular correlation matrix we want the element in row 2 and column 3.

<pre class="r">cor_BG <- cor1[2,1,] # leaving the last dimension empty implies that we want all elements
cor_BG <- as.xts(cor_BG) # imposes the xts time series format - useful for plotting</pre>
And now we plot this.

<pre class="r">plot(cor_BG)</pre>
[[File:correlation1.png]]

If you transformed <code>cor_BG</code> to be a <code>xts</code> series the <code>plot</code> function automatically picks up the date information. As you can see there is significant variation through time with the correaltion typically varying between 0.2 and 0.5.

Let's plot all three correlations between the three assets.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
plot(as.xts(cor1[1,2,]),main="IBM and BP")
plot(as.xts(cor1[1,3,]),main="IBM and Google")
plot(as.xts(cor1[2,3,]),main="BP and Google")</pre>
[[File:correlation2.png]]

== Forecasts ==

Often you will want to use your estimated model to produce forecasts for the covariance or correlation matrix

<pre class="r">dccf1 <- dccforecast(fit1, n.ahead = 10)
dccf1</pre>
<pre>##
## *---------------------------------*
## * DCC GARCH Forecast *
## *---------------------------------*
##
## Distribution : mvnorm
## Model : DCC(1,1)
## Horizon : 10
## Roll Steps : 0
## -----------------------------------
##
## 0-roll forecast:
##
## First 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2539 0.3562
## [2,] 0.2539 1.0000 0.2883
## [3,] 0.3562 0.2883 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2658 0.3587
## [2,] 0.2658 1.0000 0.2909
## [3,] 0.3587 0.2909 1.0000
##
## . . .
## . . .
##
## Last 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3202 0.3703
## [2,] 0.3202 1.0000 0.3027
## [3,] 0.3703 0.3027 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3250 0.3714
## [2,] 0.3250 1.0000 0.3037
## [3,] 0.3714 0.3037 1.0000</pre>
The actual forecasts for the correlation can be addresse via

<pre class="r">Rf <- dccf1@mforecast$R # use H for the covariance forecast</pre>
When checking the structure of <code>Rf</code>

<pre class="r">str(Rf)</pre>
<pre>## List of 1
## $ : num [1:3, 1:3, 1:10] 1 0.254 0.356 0.254 1 ...</pre>
you realise that the object <code>Rf</code> is a list with one element. It turns out that this one list item is then a 3 dimensional matrix/array which contains the the 10 forecasts of <math>3 \times 3</math> correlation matrices. If we want to extract, say, the 10 forecasts for the correlation between IBM (1st asset) and BP (2nd asset), we have to do this in the following way:

<pre class="r">corf_IB <- Rf[[1]][1,2,] # Correlation forecasts between IBM and BP
corf_IG <- Rf[[1]][1,3,] # Correlation forecasts between IBM and Google
corf_BG <- Rf[[1]][2,3,] # Correlation forecasts between BP and Google</pre>
<code>[ [1] ]</code> tells R to go to the first (and here only) list item and then <code>[1,2,]</code> instructs R to select the (1,2) element of all available correlation matrices.

As for the univariate volatililty model let us display the forecast along with the last in-sample estimates of correlation.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
c_IB <- c(tail(cor1[1,2,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IB <- c(rep(NA,20),corf_IB) # gets the 10 forecasts
plot(c_IB,type = "l",main="Correlation IBM and BP")
lines(cf_IB,type = "l", col = "orange")

c_IG <- c(tail(cor1[1,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IG <- c(rep(NA,20),corf_IG) # gets the 10 forecasts
plot(c_IG,type = "l",main="Correlation IBM and Google")
lines(cf_IG,type = "l", col = "orange")

c_BG <- c(tail(cor1[2,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_BG <- c(rep(NA,20),corf_BG) # gets the 10 forecasts
plot(c_BG,type = "l",main="Correlation BP and Google")
lines(cf_BG,type = "l", col = "orange")</pre>
[[File:mg_forecast.png]]

= Further thoughts =

If you are looking at using pseudo-out-of sample forecasting (i.e. pretend to forecast values that actually have already occured) you should explore the <code>out.sample</code> option of the <code>dccfit</code> function.

The <code>rmgarch</code> package also allows you to estimate multivariate factor GARCH models and copula GARCH models (check the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for more details.

An alternative package with a slightly different set of multivariate volatility models is the `<code>ccgarch</code> package.

R GARCH

2018-05-03T23:24:13Z

Rb: /* Forecasts */

= Introduction =

When you are dealing with financial time-series we often have relatively high frequency observations available. It is very common for instance to have daily observations available. In fact it is now possible to obtain hourly, minute, second or even millisecond observations. But here we will restrict ourselves to daily observations. For some assets these will be 7 days a week observations, but for others these will be work-day observations, so typically 5 days a week of observations.

= Packages used =

There are a number of packages that can enable us to estimate volatility models. The packages we will use are the <code>rugarch</code> for univariate GARCH models and the <code>rmgarch</code> (for multivariate models) package both written by Alexios Ghalanos. We shall also use the <code>quantmod</code> package as it will give us some easy access to some standard financial data.

So please ensure that you install these packes and then load them,

<pre class="r">#install.packages(c("quantmod","rugarch","rmgarch")) # only needed in case you have not yet installed these packages
library(quantmod)
library(rugarch)
library(rmgarch)</pre>
Next we set our working directory

<pre class="r"># replace with your directory and uncomment
# setwd("YOUR/COPLETE/DIRECTORY/PATH") </pre>
= Data upload =

Here we will use a convenient data retrieval function (<code>getSymbols</code>) delivered by the <code>quantmod</code> package in order to retrieve some data. This function works, for instance, to retrieve stock data. The default source is [https://finance.yahoo.com/ Yahoo Finance]. If you want to find out what stock has which symbol you should be able to search the internet to find a list of ticker symbols. The following shows how to use the function. But note that my experience is that sometimes the connection does not work and you may get an error message. In that case just retry a few seconds later and it may well work.

<pre class="r">startDate = as.Date("2007-01-03") #Specify period of time we are interested in
endDate = as.Date("2018-04-30")

getSymbols("IBM", from = startDate, to = endDate)</pre>
<pre>## [1] "IBM"</pre>
<pre class="r">getSymbols("GOOG", from = startDate, to = endDate)</pre>
<pre>## [1] "GOOG"</pre>
<pre class="r">getSymbols("BP", from = startDate, to = endDate)</pre>
<pre>## [1] "BP"</pre>
In your environment you can see that each of these commands loads an object with the respective ticker symbol name. Let's have a look at one of these dataframes to understand what data these are:

<pre class="r">head(IBM)</pre>
<pre>## IBM.Open IBM.High IBM.Low IBM.Close IBM.Volume IBM.Adjusted
## 2007-01-03 97.18 98.40 96.26 97.27 9196800 73.41806
## 2007-01-04 97.25 98.79 96.88 98.31 10524500 74.20306
## 2007-01-05 97.60 97.95 96.91 97.42 7221300 73.53130
## 2007-01-08 98.50 99.50 98.35 98.90 10340000 74.64834
## 2007-01-09 99.08 100.33 99.07 100.07 11108200 75.53147
## 2007-01-10 98.50 99.05 97.93 98.89 8744800 74.64082</pre>
<pre class="r">str(IBM)</pre>
<pre>## An 'xts' object on 2007-01-03/2018-04-27 containing:
## Data: num [1:2850, 1:6] 97.2 97.2 97.6 98.5 99.1 ...
## - attr(*, "dimnames")=List of 2
## ..$ : NULL
## ..$ : chr [1:6] "IBM.Open" "IBM.High" "IBM.Low" "IBM.Close" ...
## Indexed by objects of class: [Date] TZ: UTC
## xts Attributes:
## List of 2
## $ src : chr "yahoo"
## $ updated: POSIXct[1:1], format: "2018-05-03 22:21:00"</pre>
You can see that this object contains a range of daily observations (<code>Open</code>, <code>High</code>, <code>Close</code>, <code>Volume</code> and <code>Adjusted</code> share price). We also learn that the object is formatted as an <code>xts</code> object. <code>xts</code> is a type of time-series format and indeed we learn that the data range from 2007-01-03 to 2018-04-30.

You can in fact produce a somewhat fancy looking chart with the following command (also part of the <code>quantmod</code> package)

<pre class="r">chartSeries(GOOG)</pre>
[[File:GoogleChart1.png]]

When we are estimating volatility models we work with returns. There is a function that transforms the data to returns.

<pre class="r">rIBM <- dailyReturn(IBM)
rBP <- dailyReturn(BP)
rGOOG <- dailyReturn(GOOG)

# We put all data into a data frame for use in the multivariate model
rX <- data.frame(rIBM, rBP, rGOOG)
names(rX)[1] <- "rIBM"
names(rX)[2] <- "rBP"
names(rX)[3] <- "rGOOG"</pre>
There is also a <code>weeklyReturn</code> function in case that is what you are interested in.

= Univariate GARCH Model =

Here we are using the functionality provided by the <code>rugarch</code> package written by Alexios Galanos.

== Model Specification ==

The first thing you need to do is to ensure you know what type of GARCH model you want to estimate and then let R know about this. It is the <code>ugarchspec( )</code> function which is used to let R know about the model type. There is in fact a default specification and the way to invoke this is as follows

<pre class="r">ug_spec = ugarchspec()</pre>
<code>ug_spec</code> is now a list which contains all the relevant model specifications. Let's look at them:

<pre class="r">ug_spec</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Spec *
## *---------------------------------*
##
## Conditional Variance Dynamics
## ------------------------------------
## GARCH Model : sGARCH(1,1)
## Variance Targeting : FALSE
##
## Conditional Mean Dynamics
## ------------------------------------
## Mean Model : ARFIMA(1,0,1)
## Include Mean : TRUE
## GARCH-in-Mean : FALSE
##
## Conditional Distribution
## ------------------------------------
## Distribution : norm
## Includes Skew : FALSE
## Includes Shape : FALSE
## Includes Lambda : FALSE</pre>
The key issues here are the spec for the <code>Mean Model</code> (here an ARMA(1,1) model) and the specification for the <code>GARCH Model</code>, here an <code>sGARCH(1,1)</code> which is basically a GARCH(1,1). To get details on all the possible specifications and how to change them it is best to consult the [https://cran.r-project.org/web/packages/rugarch/vignettes/Introduction_to_the_rugarch_package.pdf documentation] of the <code>rugarch</code> package.

Let's say you want to change the mean model from an ARMA(1,1) to an ARMA(1,0), i.e. an AR(1) model.

<pre class="r">ug_spec <- ugarchspec(mean.model=list(armaOrder=c(1,0)))</pre>
You could call <code>ug_spec</code> again to check that the model specification has actually changed.

The following is the specification for an # an example of the EWMA Model (although we will not use it below).

<pre class="r">ewma_spec = ugarchspec(variance.model=list(model="iGARCH", garchOrder=c(1,1)),
mean.model=list(armaOrder=c(0,0), include.mean=TRUE),
distribution.model="norm", fixed.pars=list(omega=0))</pre>

== Model Estimation ==

Now that we have specified a model to estimate we need to find the best arameters, i.e. we need to estimate the model. This step is achieved by the <code>ugarchfit</code> function.

<pre class="r">ugfit = ugarchfit(spec = ug_spec, data = rIBM)</pre>
<code>fit</code> is now a list that contains a range of results from the estimation. Let's have a look at the results

<pre class="r">ugfit</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Fit *
## *---------------------------------*
##
## Conditional Variance Dynamics
## -----------------------------------
## GARCH Model : sGARCH(1,1)
## Mean Model : ARFIMA(1,0,0)
## Distribution : norm
##
## Optimal Parameters
## ------------------------------------
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000220 1.55666 0.11955
## ar1 -0.013463 0.021425 -0.62835 0.52978
## omega 0.000015 0.000002 6.56888 0.00000
## alpha1 0.111158 0.006440 17.25930 0.00000
## beta1 0.809517 0.005883 137.59775 0.00000
##
## Robust Standard Errors:
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000230 1.48654 0.137136
## ar1 -0.013463 0.019583 -0.68748 0.491782
## omega 0.000015 0.000012 1.25867 0.208150
## alpha1 0.111158 0.054637 2.03450 0.041901
## beta1 0.809517 0.082783 9.77876 0.000000
##
## LogLikelihood : 8364.692
##
## Information Criteria
## ------------------------------------
##
## Akaike -5.8665
## Bayes -5.8560
## Shibata -5.8665
## Hannan-Quinn -5.8627
##
## Weighted Ljung-Box Test on Standardized Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.03483 0.8519
## Lag[2*(p+q)+(p+q)-1][2] 0.03492 1.0000
## Lag[4*(p+q)+(p+q)-1][5] 1.39601 0.8712
## d.o.f=1
## H0 : No serial correlation
##
## Weighted Ljung-Box Test on Standardized Squared Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.2509 0.6165
## Lag[2*(p+q)+(p+q)-1][5] 1.2795 0.7938
## Lag[4*(p+q)+(p+q)-1][9] 1.9518 0.9107
## d.o.f=2
##
## Weighted ARCH LM Tests
## ------------------------------------
## Statistic Shape Scale P-Value
## ARCH Lag[3] 1.295 0.500 2.000 0.2551
## ARCH Lag[5] 1.603 1.440 1.667 0.5656
## ARCH Lag[7] 1.935 2.315 1.543 0.7312
##
## Nyblom stability test
## ------------------------------------
## Joint Statistic: 26.6709
## Individual Statistics:
## mu 0.42613
## ar1 0.06712
## omega 0.89209
## alpha1 0.55216
## beta1 0.15390
##
## Asymptotic Critical Values (10% 5% 1%)
## Joint Statistic: 1.28 1.47 1.88
## Individual Statistic: 0.35 0.47 0.75
##
## Sign Bias Test
## ------------------------------------
## t-value prob sig
## Sign Bias 0.2134 0.8310
## Negative Sign Bias 1.0137 0.3108
## Positive Sign Bias 0.4427 0.6580
## Joint Effect 1.6909 0.6390
##
##
## Adjusted Pearson Goodness-of-Fit Test:
## ------------------------------------
## group statistic p-value(g-1)
## 1 20 135.6 1.285e-19
## 2 30 139.3 2.301e-16
## 3 40 161.8 6.871e-17
## 4 50 166.2 1.164e-14
##
##
## Elapsed time : 0.7440431</pre>
If you are familiar with GARCH models you will recognise some of the parameters. <code>ar1</code> is the AR1 coefficient of the mean model (here very small and basically insignificant), <code>alpha1</code> is the coefficient to the squared residuals in the GARCH equation and <code>beta1</code> is the coefficient to the lagged variance.

Often you will want to use model output for some further analysis. It is therefore important to understand how to extract information such as the parameter estimates, their standard errors or the residuals. The object <code>ugfit</code> contains all the information. In that object you can find two drawers (or in technical speak slots, @fit and @model). Each of these drawers contains a range of different things. What they contain you can figure out by asking for the element names

<pre class="r">paste("Elements in the @model slot")</pre>
<pre>## [1] "Elements in the @model slot"</pre>
<pre class="r">names(ugfit@model)</pre>
<pre>## [1] "modelinc" "modeldesc" "modeldata" "pars" "start.pars"
## [6] "fixed.pars" "maxOrder" "pos.matrix" "fmodel" "pidx"
## [11] "n.start"</pre>
<pre class="r">paste("Elements in the @fit slot")</pre>
<pre>## [1] "Elements in the @fit slot"</pre>
<pre class="r">names(ugfit@fit)</pre>
<pre>## [1] "hessian" "cvar" "var"
## [4] "sigma" "condH" "z"
## [7] "LLH" "log.likelihoods" "residuals"
## [10] "coef" "robust.cvar" "A"
## [13] "B" "scores" "se.coef"
## [16] "tval" "matcoef" "robust.se.coef"
## [19] "robust.tval" "robust.matcoef" "fitted.values"
## [22] "convergence" "kappa" "persistence"
## [25] "timer" "ipars" "solver"</pre>
If you wanted to extract the estimated coefficients you would do that in the following way:

<pre class="r">ugfit@fit$coef</pre>
<pre>## mu ar1 omega alpha1 beta1
## 3.419000e-04 -1.346260e-02 1.516946e-05 1.111584e-01 8.095171e-01</pre>
<pre class="r">ug_var <- ugfit@fit$var # save the estimated conditional variances
ug_res2 <- (ugfit@fit$residuals)^2 # save the estimated squared residuals</pre>
Let's plot the squared residuals and the estimated conditional variance:

<pre class="r">plot(ug_res2, type = "l")
lines(ug_var, col = "green")</pre>
[[File:CondVar2.png]]

== Model Forecasting ==

Often you will want to use an estimated model to subsequently forecast the conditional variance. The function used for this purpose is the <code>ugarchforecast</code> function. The application is rather straightforward:

<pre class="r">ugfore <- ugarchforecast(ugfit, n.ahead = 10)
ugfore</pre>
<pre>##
## *------------------------------------*
## * GARCH Model Forecast *
## *------------------------------------*
## Model: sGARCH
## Horizon: 10
## Roll Steps: 0
## Out of Sample: 0
##
## 0-roll forecast [T0=2018-04-27]:
## Series Sigma
## T+1 0.0003685 0.01640
## T+2 0.0003415 0.01621
## T+3 0.0003419 0.01604
## T+4 0.0003419 0.01587
## T+5 0.0003419 0.01572
## T+6 0.0003419 0.01558
## T+7 0.0003419 0.01545
## T+8 0.0003419 0.01533
## T+9 0.0003419 0.01521
## T+10 0.0003419 0.01511</pre>
As you can see we have produced forecasts for the next ten days, both for the expected returns (<code>Series</code>) and for the conditional volatility (square root of the conditional variance). Similar to the object created for model fitting, <code>ugfore</code> contains two slots (@model and @forecast) and you can use <code>names(ugfore@forecast)</code> to figure out under which names the elements are saved. For instance you can extract the conditional volatility forecast as follows:

<pre class="r">ug_f <- ugfore@forecast$sigmaFor
plot(ug_f, type = "l")</pre>
[[File:ug_forecast3.png]]

Note that the volatility is the square root of the conditional variance.

To put these forecasts into context let's display them together with the last 50 observations used in the estimation.

<pre class="r">ug_var_t <- c(tail(ug_var,20),rep(NA,10)) # gets the last 20 observations
ug_res2_t <- c(tail(ug_res2,20),rep(NA,10)) # gets the last 20 observations
ug_f <- c(rep(NA,20),(ug_f)^2)

plot(ug_res2_t, type = "l")
lines(ug_f, col = "orange")
lines(ug_var_t, col = "green")</pre>
[[File:ug_forecast4.png]]

You can see how the forecast of the conditional variance picks up from the last estimated conditional variance. In fact it decreases from there, slowly, towards the unconditional variance value.

The <code>rugarch</code> package has a lot of additional functionality which you can explore through the documentation.

= Multivariate GARCH models =

Often you will want to model the volatility of a vector of assets. This can be done with the multivariate equivalent of the univariate GARCH model. Estimating multivariate GARCH models turns out to be significantly more difficult than univariate GARCH models, but fortunately procedures have been developed that deal with most of these issues.

Here we are using the <code>rmgarch</code> package which has a lot of useful functionality. We are applying it to estimate a multivariate volatility model for the returns of BP, Google/Alphabet and IBM shares.

As for the <code>rugarch</code> package we first need to specify the model we want to estimate. Here we stick with a Dynamic Conditional Correlation (DCC) model (see the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for details.). When estimating DCC models one basically estimates individual GARCH-type models (which could differ for each individual asset). These are then used to standardise the individual residuals. As a second step one then has to specify the correlation dynamics of these standardised residuals. It is possible to estimate the parameters of the univariate and the correlation model in one big swoop. however, my experience with this, and other packages, is that it is beneficial to separate the two steps.

== Model Setup ==

Here we assume that we are using the same univariate volatility model specification for each of the three assets.

<pre class="r"># DCC (MVN)
uspec.n = multispec(replicate(3, ugarchspec(mean.model = list(armaOrder = c(1,0)))))</pre>
What does this command do? You will recognise that <code>ugarchspec(mean.model = list(armaOrder = c(1,0)))</code> specifies an AR(1)-GARCH(1,1) model. By using <code>replicate(3, ugarchspec...)</code> we replicate this model 3 times (as we have three assets, IBM, Google/Alphabet and BP).

We now estimate these univariate GARCH models using the <code>multifit</code> command.

<pre class="r">multf = multifit(uspec.n, rX)</pre>
The results are saved in <code>multf</code> and you can type <code>multf</code> into the command window to see the estimated parameters for these three models. But we will here proceed to specify the DCC model (I assume that you know what a DCC model is. This is not the place to elaborate on this and many textbooks or indeed the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] to this package provide details). To specify the correlation specification we use the <code>dccspec</code> function.

<pre class="r">spec1 = dccspec(uspec = uspec.n, dccOrder = c(1, 1), distribution = 'mvnorm')</pre>
In this specification we have to state how the univariate volatilities are modeled (as per <code>uspec.n</code>) and how complex the dynamic structure of the correlation matrix is (here we are using the most standard <code>dccOrder = c(1, 1)</code> specification).

== Model Estimation ==

Now we are in a position to estimate the model using the <code>dccfit</code> function.

<pre class="r">fit1 = dccfit(spec1, data = rX, fit.control = list(eval.se = TRUE), fit = multf)</pre>
We want to estimate the model as specified in <code>spec1</code>, using the data in <code>rX</code>. The option <code>fit.control = list(eval.se = TRUE)</code> ensures that the estimation procedure produces standard errors for estimated parameters. Importantly <code>fit = multf</code> indicates that we ought to use the already estimated univariate models as they were saved in <code>multf</code>. The way to learn how to use these functions is by a combination of looking at the functions's help (<code>?dccfit</code>) and googling.

When you estimate a multivariate volatility model like the DCC model you are typically interested in the estimated covariance or correlation matrices. After all it is at the core of these models that you allow for time-variation in the correlation between the assets (there are also constant correlation models, but we do not discuss this here). Therefore we will now learn how we extract these.

<pre class="r"># Get the model based time varying covariance (arrays) and correlation matrices
cov1 = rcov(fit1) # extracts the covariance matrix
cor1 = rcor(fit1) # extracts the correlation matrix</pre>
To understand the object we have at our hands here we can have a look at the imension:

<pre class="r">dim(cor1)</pre>
<pre>## [1] 3 3 2850</pre>
We get three outputs which tells us that we have a three dimensional object. The firts two dimensions have 3 elements each (think a <math>3\times3</math> correlation matrix) and then there is a third dimension with 2850 elements. This tells us that <code>cor1</code> stores 2850 (<math>3\times3</math>) sorrelation matrices, one for each day of data.

Let's have a look at the correlation matrix for the last day, day 2853;

<pre class="r">cor1[,,dim(cor1)[3]]</pre>
<pre>## rIBM rBP rGOOG
## rIBM 1.0000000 0.2424297 0.353591
## rBP 0.2424297 1.0000000 0.275244
## rGOOG 0.3535910 0.2752440 1.000000</pre>
So let's say we want to plot the time-varying correlation between Google and BP, which is 0.275244 on that last day. In our matrix with returns <code>rX</code> BP is the second asset and Google the 3rd. So in any particular correlation matrix we want the element in row 2 and column 3.

<pre class="r">cor_BG <- cor1[2,1,] # leaving the last dimension empty implies that we want all elements
cor_BG <- as.xts(cor_BG) # imposes the xts time series format - useful for plotting</pre>
And now we plot this.

<pre class="r">plot(cor_BG)</pre>
[[File:correlation1.png]]

If you transformed <code>cor_BG</code> to be a <code>xts</code> series the <code>plot</code> function automatically picks up the date information. As you can see there is significant variation through time with the correaltion typically varying between 0.2 and 0.5.

Let's plot all three correlations between the three assets.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
plot(as.xts(cor1[1,2,]),main="IBM and BP")
plot(as.xts(cor1[1,3,]),main="IBM and Google")
plot(as.xts(cor1[2,3,]),main="BP and Google")</pre>
[[File:correlation2.png]]

== Forecasts ==

Often you will want to use your estimated model to produce forecasts for the covariance or correlation matrix

<pre class="r">dccf1 <- dccforecast(fit1, n.ahead = 10)
dccf1</pre>
<pre>##
## *---------------------------------*
## * DCC GARCH Forecast *
## *---------------------------------*
##
## Distribution : mvnorm
## Model : DCC(1,1)
## Horizon : 10
## Roll Steps : 0
## -----------------------------------
##
## 0-roll forecast:
##
## First 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2539 0.3562
## [2,] 0.2539 1.0000 0.2883
## [3,] 0.3562 0.2883 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2658 0.3587
## [2,] 0.2658 1.0000 0.2909
## [3,] 0.3587 0.2909 1.0000
##
## . . .
## . . .
##
## Last 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3202 0.3703
## [2,] 0.3202 1.0000 0.3027
## [3,] 0.3703 0.3027 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3250 0.3714
## [2,] 0.3250 1.0000 0.3037
## [3,] 0.3714 0.3037 1.0000</pre>
The actual forecasts for the correlation can be addresse via

<pre class="r">Rf <- dccf1@mforecast$R # use H for the covariance forecast</pre>
When checking the structure of <code>Rf</code>

<pre class="r">str(Rf)</pre>
<pre>## List of 1
## $ : num [1:3, 1:3, 1:10] 1 0.254 0.356 0.254 1 ...</pre>
you realise that the object <code>Rf</code> is a list with one element. It turns out that this one list item is then a 3 dimensional matrix/array which contains the the 10 forecasts of <math>3 \times 3</math> correlation matrices. If we want to extract, say, the 10 forecasts for the correlation between IBM (1st asset) and BP (2nd asset), we have to do this in the following way:

<pre class="r">corf_IB <- Rf[[1]][1,2,] # Correlation forecasts between IBM and BP
corf_IG <- Rf[[1]][1,3,] # Correlation forecasts between IBM and Google
corf_BG <- Rf[[1]][2,3,] # Correlation forecasts between BP and Google</pre>
<code>[ [1] ]</code> tells R to go to the first (and here only) list item and then <code>[1,2,]</code> instructs R to select the (1,2) element of all available correlation matrices.

As for the univariate volatililty model let us display the forecast along with the last in-sample estimates of correlation.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
c_IB <- c(tail(cor1[1,2,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IB <- c(rep(NA,20),corf_IB) # gets the 10 forecasts
plot(c_IB,type = "l",main="Correlation IBM and BP")
lines(cf_IB,type = "l", col = "orange")

c_IG <- c(tail(cor1[1,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IG <- c(rep(NA,20),corf_IG) # gets the 10 forecasts
plot(c_IG,type = "l",main="Correlation IBM and Google")
lines(cf_IG,type = "l", col = "orange")

c_BG <- c(tail(cor1[2,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_BG <- c(rep(NA,20),corf_BG) # gets the 10 forecasts
plot(c_BG,type = "l",main="Correlation BP and Google")
lines(cf_BG,type = "l", col = "orange")</pre>
[[File:mg_forecast.png]]

= Further thoughts =

If you are looking at using pseudo-out-of sample forecasting (i.e. pretend to forecast values that actually have already occured) you should explore the <code>out.sample</code> option of the <code>dccfit</code> function.

The <code>rmgarch</code> package also allows you to estimate multivariate factor GARCH models and copula GARCH models (check the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for more details.

An alternative package with a slightly different set of multivariate volatility models is the `<code>ccgarch</code> package.

File:Mg forecast.png

2018-05-03T23:23:32Z

Rb:

R GARCH

2018-05-03T23:23:07Z

Rb: /* Forecasts */

= Introduction =

When you are dealing with financial time-series we often have relatively high frequency observations available. It is very common for instance to have daily observations available. In fact it is now possible to obtain hourly, minute, second or even millisecond observations. But here we will restrict ourselves to daily observations. For some assets these will be 7 days a week observations, but for others these will be work-day observations, so typically 5 days a week of observations.

= Packages used =

There are a number of packages that can enable us to estimate volatility models. The packages we will use are the <code>rugarch</code> for univariate GARCH models and the <code>rmgarch</code> (for multivariate models) package both written by Alexios Ghalanos. We shall also use the <code>quantmod</code> package as it will give us some easy access to some standard financial data.

So please ensure that you install these packes and then load them,

<pre class="r">#install.packages(c("quantmod","rugarch","rmgarch")) # only needed in case you have not yet installed these packages
library(quantmod)
library(rugarch)
library(rmgarch)</pre>
Next we set our working directory

<pre class="r"># replace with your directory and uncomment
# setwd("YOUR/COPLETE/DIRECTORY/PATH") </pre>
= Data upload =

Here we will use a convenient data retrieval function (<code>getSymbols</code>) delivered by the <code>quantmod</code> package in order to retrieve some data. This function works, for instance, to retrieve stock data. The default source is [https://finance.yahoo.com/ Yahoo Finance]. If you want to find out what stock has which symbol you should be able to search the internet to find a list of ticker symbols. The following shows how to use the function. But note that my experience is that sometimes the connection does not work and you may get an error message. In that case just retry a few seconds later and it may well work.

<pre class="r">startDate = as.Date("2007-01-03") #Specify period of time we are interested in
endDate = as.Date("2018-04-30")

getSymbols("IBM", from = startDate, to = endDate)</pre>
<pre>## [1] "IBM"</pre>
<pre class="r">getSymbols("GOOG", from = startDate, to = endDate)</pre>
<pre>## [1] "GOOG"</pre>
<pre class="r">getSymbols("BP", from = startDate, to = endDate)</pre>
<pre>## [1] "BP"</pre>
In your environment you can see that each of these commands loads an object with the respective ticker symbol name. Let's have a look at one of these dataframes to understand what data these are:

<pre class="r">head(IBM)</pre>
<pre>## IBM.Open IBM.High IBM.Low IBM.Close IBM.Volume IBM.Adjusted
## 2007-01-03 97.18 98.40 96.26 97.27 9196800 73.41806
## 2007-01-04 97.25 98.79 96.88 98.31 10524500 74.20306
## 2007-01-05 97.60 97.95 96.91 97.42 7221300 73.53130
## 2007-01-08 98.50 99.50 98.35 98.90 10340000 74.64834
## 2007-01-09 99.08 100.33 99.07 100.07 11108200 75.53147
## 2007-01-10 98.50 99.05 97.93 98.89 8744800 74.64082</pre>
<pre class="r">str(IBM)</pre>
<pre>## An 'xts' object on 2007-01-03/2018-04-27 containing:
## Data: num [1:2850, 1:6] 97.2 97.2 97.6 98.5 99.1 ...
## - attr(*, "dimnames")=List of 2
## ..$ : NULL
## ..$ : chr [1:6] "IBM.Open" "IBM.High" "IBM.Low" "IBM.Close" ...
## Indexed by objects of class: [Date] TZ: UTC
## xts Attributes:
## List of 2
## $ src : chr "yahoo"
## $ updated: POSIXct[1:1], format: "2018-05-03 22:21:00"</pre>
You can see that this object contains a range of daily observations (<code>Open</code>, <code>High</code>, <code>Close</code>, <code>Volume</code> and <code>Adjusted</code> share price). We also learn that the object is formatted as an <code>xts</code> object. <code>xts</code> is a type of time-series format and indeed we learn that the data range from 2007-01-03 to 2018-04-30.

You can in fact produce a somewhat fancy looking chart with the following command (also part of the <code>quantmod</code> package)

<pre class="r">chartSeries(GOOG)</pre>
[[File:GoogleChart1.png]]

When we are estimating volatility models we work with returns. There is a function that transforms the data to returns.

<pre class="r">rIBM <- dailyReturn(IBM)
rBP <- dailyReturn(BP)
rGOOG <- dailyReturn(GOOG)

# We put all data into a data frame for use in the multivariate model
rX <- data.frame(rIBM, rBP, rGOOG)
names(rX)[1] <- "rIBM"
names(rX)[2] <- "rBP"
names(rX)[3] <- "rGOOG"</pre>
There is also a <code>weeklyReturn</code> function in case that is what you are interested in.

= Univariate GARCH Model =

Here we are using the functionality provided by the <code>rugarch</code> package written by Alexios Galanos.

== Model Specification ==

The first thing you need to do is to ensure you know what type of GARCH model you want to estimate and then let R know about this. It is the <code>ugarchspec( )</code> function which is used to let R know about the model type. There is in fact a default specification and the way to invoke this is as follows

<pre class="r">ug_spec = ugarchspec()</pre>
<code>ug_spec</code> is now a list which contains all the relevant model specifications. Let's look at them:

<pre class="r">ug_spec</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Spec *
## *---------------------------------*
##
## Conditional Variance Dynamics
## ------------------------------------
## GARCH Model : sGARCH(1,1)
## Variance Targeting : FALSE
##
## Conditional Mean Dynamics
## ------------------------------------
## Mean Model : ARFIMA(1,0,1)
## Include Mean : TRUE
## GARCH-in-Mean : FALSE
##
## Conditional Distribution
## ------------------------------------
## Distribution : norm
## Includes Skew : FALSE
## Includes Shape : FALSE
## Includes Lambda : FALSE</pre>
The key issues here are the spec for the <code>Mean Model</code> (here an ARMA(1,1) model) and the specification for the <code>GARCH Model</code>, here an <code>sGARCH(1,1)</code> which is basically a GARCH(1,1). To get details on all the possible specifications and how to change them it is best to consult the [https://cran.r-project.org/web/packages/rugarch/vignettes/Introduction_to_the_rugarch_package.pdf documentation] of the <code>rugarch</code> package.

Let's say you want to change the mean model from an ARMA(1,1) to an ARMA(1,0), i.e. an AR(1) model.

<pre class="r">ug_spec <- ugarchspec(mean.model=list(armaOrder=c(1,0)))</pre>
You could call <code>ug_spec</code> again to check that the model specification has actually changed.

The following is the specification for an # an example of the EWMA Model (although we will not use it below).

<pre class="r">ewma_spec = ugarchspec(variance.model=list(model="iGARCH", garchOrder=c(1,1)),
mean.model=list(armaOrder=c(0,0), include.mean=TRUE),
distribution.model="norm", fixed.pars=list(omega=0))</pre>

== Model Estimation ==

Now that we have specified a model to estimate we need to find the best arameters, i.e. we need to estimate the model. This step is achieved by the <code>ugarchfit</code> function.

<pre class="r">ugfit = ugarchfit(spec = ug_spec, data = rIBM)</pre>
<code>fit</code> is now a list that contains a range of results from the estimation. Let's have a look at the results

<pre class="r">ugfit</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Fit *
## *---------------------------------*
##
## Conditional Variance Dynamics
## -----------------------------------
## GARCH Model : sGARCH(1,1)
## Mean Model : ARFIMA(1,0,0)
## Distribution : norm
##
## Optimal Parameters
## ------------------------------------
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000220 1.55666 0.11955
## ar1 -0.013463 0.021425 -0.62835 0.52978
## omega 0.000015 0.000002 6.56888 0.00000
## alpha1 0.111158 0.006440 17.25930 0.00000
## beta1 0.809517 0.005883 137.59775 0.00000
##
## Robust Standard Errors:
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000230 1.48654 0.137136
## ar1 -0.013463 0.019583 -0.68748 0.491782
## omega 0.000015 0.000012 1.25867 0.208150
## alpha1 0.111158 0.054637 2.03450 0.041901
## beta1 0.809517 0.082783 9.77876 0.000000
##
## LogLikelihood : 8364.692
##
## Information Criteria
## ------------------------------------
##
## Akaike -5.8665
## Bayes -5.8560
## Shibata -5.8665
## Hannan-Quinn -5.8627
##
## Weighted Ljung-Box Test on Standardized Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.03483 0.8519
## Lag[2*(p+q)+(p+q)-1][2] 0.03492 1.0000
## Lag[4*(p+q)+(p+q)-1][5] 1.39601 0.8712
## d.o.f=1
## H0 : No serial correlation
##
## Weighted Ljung-Box Test on Standardized Squared Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.2509 0.6165
## Lag[2*(p+q)+(p+q)-1][5] 1.2795 0.7938
## Lag[4*(p+q)+(p+q)-1][9] 1.9518 0.9107
## d.o.f=2
##
## Weighted ARCH LM Tests
## ------------------------------------
## Statistic Shape Scale P-Value
## ARCH Lag[3] 1.295 0.500 2.000 0.2551
## ARCH Lag[5] 1.603 1.440 1.667 0.5656
## ARCH Lag[7] 1.935 2.315 1.543 0.7312
##
## Nyblom stability test
## ------------------------------------
## Joint Statistic: 26.6709
## Individual Statistics:
## mu 0.42613
## ar1 0.06712
## omega 0.89209
## alpha1 0.55216
## beta1 0.15390
##
## Asymptotic Critical Values (10% 5% 1%)
## Joint Statistic: 1.28 1.47 1.88
## Individual Statistic: 0.35 0.47 0.75
##
## Sign Bias Test
## ------------------------------------
## t-value prob sig
## Sign Bias 0.2134 0.8310
## Negative Sign Bias 1.0137 0.3108
## Positive Sign Bias 0.4427 0.6580
## Joint Effect 1.6909 0.6390
##
##
## Adjusted Pearson Goodness-of-Fit Test:
## ------------------------------------
## group statistic p-value(g-1)
## 1 20 135.6 1.285e-19
## 2 30 139.3 2.301e-16
## 3 40 161.8 6.871e-17
## 4 50 166.2 1.164e-14
##
##
## Elapsed time : 0.7440431</pre>
If you are familiar with GARCH models you will recognise some of the parameters. <code>ar1</code> is the AR1 coefficient of the mean model (here very small and basically insignificant), <code>alpha1</code> is the coefficient to the squared residuals in the GARCH equation and <code>beta1</code> is the coefficient to the lagged variance.

Often you will want to use model output for some further analysis. It is therefore important to understand how to extract information such as the parameter estimates, their standard errors or the residuals. The object <code>ugfit</code> contains all the information. In that object you can find two drawers (or in technical speak slots, @fit and @model). Each of these drawers contains a range of different things. What they contain you can figure out by asking for the element names

<pre class="r">paste("Elements in the @model slot")</pre>
<pre>## [1] "Elements in the @model slot"</pre>
<pre class="r">names(ugfit@model)</pre>
<pre>## [1] "modelinc" "modeldesc" "modeldata" "pars" "start.pars"
## [6] "fixed.pars" "maxOrder" "pos.matrix" "fmodel" "pidx"
## [11] "n.start"</pre>
<pre class="r">paste("Elements in the @fit slot")</pre>
<pre>## [1] "Elements in the @fit slot"</pre>
<pre class="r">names(ugfit@fit)</pre>
<pre>## [1] "hessian" "cvar" "var"
## [4] "sigma" "condH" "z"
## [7] "LLH" "log.likelihoods" "residuals"
## [10] "coef" "robust.cvar" "A"
## [13] "B" "scores" "se.coef"
## [16] "tval" "matcoef" "robust.se.coef"
## [19] "robust.tval" "robust.matcoef" "fitted.values"
## [22] "convergence" "kappa" "persistence"
## [25] "timer" "ipars" "solver"</pre>
If you wanted to extract the estimated coefficients you would do that in the following way:

<pre class="r">ugfit@fit$coef</pre>
<pre>## mu ar1 omega alpha1 beta1
## 3.419000e-04 -1.346260e-02 1.516946e-05 1.111584e-01 8.095171e-01</pre>
<pre class="r">ug_var <- ugfit@fit$var # save the estimated conditional variances
ug_res2 <- (ugfit@fit$residuals)^2 # save the estimated squared residuals</pre>
Let's plot the squared residuals and the estimated conditional variance:

<pre class="r">plot(ug_res2, type = "l")
lines(ug_var, col = "green")</pre>
[[File:CondVar2.png]]

== Model Forecasting ==

Often you will want to use an estimated model to subsequently forecast the conditional variance. The function used for this purpose is the <code>ugarchforecast</code> function. The application is rather straightforward:

<pre class="r">ugfore <- ugarchforecast(ugfit, n.ahead = 10)
ugfore</pre>
<pre>##
## *------------------------------------*
## * GARCH Model Forecast *
## *------------------------------------*
## Model: sGARCH
## Horizon: 10
## Roll Steps: 0
## Out of Sample: 0
##
## 0-roll forecast [T0=2018-04-27]:
## Series Sigma
## T+1 0.0003685 0.01640
## T+2 0.0003415 0.01621
## T+3 0.0003419 0.01604
## T+4 0.0003419 0.01587
## T+5 0.0003419 0.01572
## T+6 0.0003419 0.01558
## T+7 0.0003419 0.01545
## T+8 0.0003419 0.01533
## T+9 0.0003419 0.01521
## T+10 0.0003419 0.01511</pre>
As you can see we have produced forecasts for the next ten days, both for the expected returns (<code>Series</code>) and for the conditional volatility (square root of the conditional variance). Similar to the object created for model fitting, <code>ugfore</code> contains two slots (@model and @forecast) and you can use <code>names(ugfore@forecast)</code> to figure out under which names the elements are saved. For instance you can extract the conditional volatility forecast as follows:

<pre class="r">ug_f <- ugfore@forecast$sigmaFor
plot(ug_f, type = "l")</pre>
[[File:ug_forecast3.png]]

Note that the volatility is the square root of the conditional variance.

To put these forecasts into context let's display them together with the last 50 observations used in the estimation.

<pre class="r">ug_var_t <- c(tail(ug_var,20),rep(NA,10)) # gets the last 20 observations
ug_res2_t <- c(tail(ug_res2,20),rep(NA,10)) # gets the last 20 observations
ug_f <- c(rep(NA,20),(ug_f)^2)

plot(ug_res2_t, type = "l")
lines(ug_f, col = "orange")
lines(ug_var_t, col = "green")</pre>
[[File:ug_forecast4.png]]

You can see how the forecast of the conditional variance picks up from the last estimated conditional variance. In fact it decreases from there, slowly, towards the unconditional variance value.

The <code>rugarch</code> package has a lot of additional functionality which you can explore through the documentation.

= Multivariate GARCH models =

Often you will want to model the volatility of a vector of assets. This can be done with the multivariate equivalent of the univariate GARCH model. Estimating multivariate GARCH models turns out to be significantly more difficult than univariate GARCH models, but fortunately procedures have been developed that deal with most of these issues.

Here we are using the <code>rmgarch</code> package which has a lot of useful functionality. We are applying it to estimate a multivariate volatility model for the returns of BP, Google/Alphabet and IBM shares.

As for the <code>rugarch</code> package we first need to specify the model we want to estimate. Here we stick with a Dynamic Conditional Correlation (DCC) model (see the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for details.). When estimating DCC models one basically estimates individual GARCH-type models (which could differ for each individual asset). These are then used to standardise the individual residuals. As a second step one then has to specify the correlation dynamics of these standardised residuals. It is possible to estimate the parameters of the univariate and the correlation model in one big swoop. however, my experience with this, and other packages, is that it is beneficial to separate the two steps.

== Model Setup ==

Here we assume that we are using the same univariate volatility model specification for each of the three assets.

<pre class="r"># DCC (MVN)
uspec.n = multispec(replicate(3, ugarchspec(mean.model = list(armaOrder = c(1,0)))))</pre>
What does this command do? You will recognise that <code>ugarchspec(mean.model = list(armaOrder = c(1,0)))</code> specifies an AR(1)-GARCH(1,1) model. By using <code>replicate(3, ugarchspec...)</code> we replicate this model 3 times (as we have three assets, IBM, Google/Alphabet and BP).

We now estimate these univariate GARCH models using the <code>multifit</code> command.

<pre class="r">multf = multifit(uspec.n, rX)</pre>
The results are saved in <code>multf</code> and you can type <code>multf</code> into the command window to see the estimated parameters for these three models. But we will here proceed to specify the DCC model (I assume that you know what a DCC model is. This is not the place to elaborate on this and many textbooks or indeed the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] to this package provide details). To specify the correlation specification we use the <code>dccspec</code> function.

<pre class="r">spec1 = dccspec(uspec = uspec.n, dccOrder = c(1, 1), distribution = 'mvnorm')</pre>
In this specification we have to state how the univariate volatilities are modeled (as per <code>uspec.n</code>) and how complex the dynamic structure of the correlation matrix is (here we are using the most standard <code>dccOrder = c(1, 1)</code> specification).

== Model Estimation ==

Now we are in a position to estimate the model using the <code>dccfit</code> function.

<pre class="r">fit1 = dccfit(spec1, data = rX, fit.control = list(eval.se = TRUE), fit = multf)</pre>
We want to estimate the model as specified in <code>spec1</code>, using the data in <code>rX</code>. The option <code>fit.control = list(eval.se = TRUE)</code> ensures that the estimation procedure produces standard errors for estimated parameters. Importantly <code>fit = multf</code> indicates that we ought to use the already estimated univariate models as they were saved in <code>multf</code>. The way to learn how to use these functions is by a combination of looking at the functions's help (<code>?dccfit</code>) and googling.

When you estimate a multivariate volatility model like the DCC model you are typically interested in the estimated covariance or correlation matrices. After all it is at the core of these models that you allow for time-variation in the correlation between the assets (there are also constant correlation models, but we do not discuss this here). Therefore we will now learn how we extract these.

<pre class="r"># Get the model based time varying covariance (arrays) and correlation matrices
cov1 = rcov(fit1) # extracts the covariance matrix
cor1 = rcor(fit1) # extracts the correlation matrix</pre>
To understand the object we have at our hands here we can have a look at the imension:

<pre class="r">dim(cor1)</pre>
<pre>## [1] 3 3 2850</pre>
We get three outputs which tells us that we have a three dimensional object. The firts two dimensions have 3 elements each (think a <math>3\times3</math> correlation matrix) and then there is a third dimension with 2850 elements. This tells us that <code>cor1</code> stores 2850 (<math>3\times3</math>) sorrelation matrices, one for each day of data.

Let's have a look at the correlation matrix for the last day, day 2853;

<pre class="r">cor1[,,dim(cor1)[3]]</pre>
<pre>## rIBM rBP rGOOG
## rIBM 1.0000000 0.2424297 0.353591
## rBP 0.2424297 1.0000000 0.275244
## rGOOG 0.3535910 0.2752440 1.000000</pre>
So let's say we want to plot the time-varying correlation between Google and BP, which is 0.275244 on that last day. In our matrix with returns <code>rX</code> BP is the second asset and Google the 3rd. So in any particular correlation matrix we want the element in row 2 and column 3.

<pre class="r">cor_BG <- cor1[2,1,] # leaving the last dimension empty implies that we want all elements
cor_BG <- as.xts(cor_BG) # imposes the xts time series format - useful for plotting</pre>
And now we plot this.

<pre class="r">plot(cor_BG)</pre>
[[File:correlation1.png]]

If you transformed <code>cor_BG</code> to be a <code>xts</code> series the <code>plot</code> function automatically picks up the date information. As you can see there is significant variation through time with the correaltion typically varying between 0.2 and 0.5.

Let's plot all three correlations between the three assets.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
plot(as.xts(cor1[1,2,]),main="IBM and BP")
plot(as.xts(cor1[1,3,]),main="IBM and Google")
plot(as.xts(cor1[2,3,]),main="BP and Google")</pre>
[[File:correlation2.png]]

== Forecasts ==

Often you will want to use your estimated model to produce forecasts for the covariance or correlation matrix

<pre class="r">dccf1 <- dccforecast(fit1, n.ahead = 10)
dccf1</pre>
<pre>##
## *---------------------------------*
## * DCC GARCH Forecast *
## *---------------------------------*
##
## Distribution : mvnorm
## Model : DCC(1,1)
## Horizon : 10
## Roll Steps : 0
## -----------------------------------
##
## 0-roll forecast:
##
## First 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2539 0.3562
## [2,] 0.2539 1.0000 0.2883
## [3,] 0.3562 0.2883 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2658 0.3587
## [2,] 0.2658 1.0000 0.2909
## [3,] 0.3587 0.2909 1.0000
##
## . . .
## . . .
##
## Last 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3202 0.3703
## [2,] 0.3202 1.0000 0.3027
## [3,] 0.3703 0.3027 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3250 0.3714
## [2,] 0.3250 1.0000 0.3037
## [3,] 0.3714 0.3037 1.0000</pre>
The actual forecasts for the correlation can be addresse via

<pre class="r">Rf <- dccf1@mforecast$R # use H for the covariance forecast</pre>
When checking the structure of <code>Rf</code>

<pre class="r">str(Rf)</pre>
<pre>## List of 1
## $ : num [1:3, 1:3, 1:10] 1 0.254 0.356 0.254 1 ...</pre>
you realise that the object <code>Rf</code> is a list with one element. It turns out that this one list item is then a 3 dimensional matrix/array which contains the the 10 forecasts of <math>3 \times 3</math> correlation matrices. If we want to extract, say, the 10 forecasts for the correlation between IBM (1st asset) and BP (2nd asset), we have to do this in the following way:

<pre class="r">corf_IB <- Rf[[1]][1,2,] # Correlation forecasts between IBM and BP
corf_IG <- Rf[[1]][1,3,] # Correlation forecasts between IBM and Google
corf_BG <- Rf[[1]][2,3,] # Correlation forecasts between BP and Google</pre>
<code>[[1]]</code> tells R to go to the first (and here only) list item and then <code>[1,2,]</code> instructs R to select the (1,2) element of all available correlation matrices.

As for the univariate volatililty model let us display the forecast along with the last in-sample estimates of correlation.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
c_IB <- c(tail(cor1[1,2,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IB <- c(rep(NA,20),corf_IB) # gets the 10 forecasts
plot(c_IB,type = "l",main="Correlation IBM and BP")
lines(cf_IB,type = "l", col = "orange")

c_IG <- c(tail(cor1[1,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IG <- c(rep(NA,20),corf_IG) # gets the 10 forecasts
plot(c_IG,type = "l",main="Correlation IBM and Google")
lines(cf_IG,type = "l", col = "orange")

c_BG <- c(tail(cor1[2,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_BG <- c(rep(NA,20),corf_BG) # gets the 10 forecasts
plot(c_BG,type = "l",main="Correlation BP and Google")
lines(cf_BG,type = "l", col = "orange")</pre>
[[File:mg_forecast.png]]

= Further thoughts =

If you are looking at using pseudo-out-of sample forecasting (i.e. pretend to forecast values that actually have already occured) you should explore the <code>out.sample</code> option of the <code>dccfit</code> function.

The <code>rmgarch</code> package also allows you to estimate multivariate factor GARCH models and copula GARCH models (check the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for more details.

An alternative package with a slightly different set of multivariate volatility models is the `<code>ccgarch</code> package.

File:Correlation2.png

2018-05-03T23:22:10Z

Rb:

File:Correlation1.png

2018-05-03T23:21:52Z

Rb:

R GARCH

2018-05-03T23:20:51Z

Rb: /* Model Estimation */

= Introduction =

When you are dealing with financial time-series we often have relatively high frequency observations available. It is very common for instance to have daily observations available. In fact it is now possible to obtain hourly, minute, second or even millisecond observations. But here we will restrict ourselves to daily observations. For some assets these will be 7 days a week observations, but for others these will be work-day observations, so typically 5 days a week of observations.

= Packages used =

There are a number of packages that can enable us to estimate volatility models. The packages we will use are the <code>rugarch</code> for univariate GARCH models and the <code>rmgarch</code> (for multivariate models) package both written by Alexios Ghalanos. We shall also use the <code>quantmod</code> package as it will give us some easy access to some standard financial data.

So please ensure that you install these packes and then load them,

<pre class="r">#install.packages(c("quantmod","rugarch","rmgarch")) # only needed in case you have not yet installed these packages
library(quantmod)
library(rugarch)
library(rmgarch)</pre>
Next we set our working directory

<pre class="r"># replace with your directory and uncomment
# setwd("YOUR/COPLETE/DIRECTORY/PATH") </pre>
= Data upload =

Here we will use a convenient data retrieval function (<code>getSymbols</code>) delivered by the <code>quantmod</code> package in order to retrieve some data. This function works, for instance, to retrieve stock data. The default source is [https://finance.yahoo.com/ Yahoo Finance]. If you want to find out what stock has which symbol you should be able to search the internet to find a list of ticker symbols. The following shows how to use the function. But note that my experience is that sometimes the connection does not work and you may get an error message. In that case just retry a few seconds later and it may well work.

<pre class="r">startDate = as.Date("2007-01-03") #Specify period of time we are interested in
endDate = as.Date("2018-04-30")

getSymbols("IBM", from = startDate, to = endDate)</pre>
<pre>## [1] "IBM"</pre>
<pre class="r">getSymbols("GOOG", from = startDate, to = endDate)</pre>
<pre>## [1] "GOOG"</pre>
<pre class="r">getSymbols("BP", from = startDate, to = endDate)</pre>
<pre>## [1] "BP"</pre>
In your environment you can see that each of these commands loads an object with the respective ticker symbol name. Let's have a look at one of these dataframes to understand what data these are:

<pre class="r">head(IBM)</pre>
<pre>## IBM.Open IBM.High IBM.Low IBM.Close IBM.Volume IBM.Adjusted
## 2007-01-03 97.18 98.40 96.26 97.27 9196800 73.41806
## 2007-01-04 97.25 98.79 96.88 98.31 10524500 74.20306
## 2007-01-05 97.60 97.95 96.91 97.42 7221300 73.53130
## 2007-01-08 98.50 99.50 98.35 98.90 10340000 74.64834
## 2007-01-09 99.08 100.33 99.07 100.07 11108200 75.53147
## 2007-01-10 98.50 99.05 97.93 98.89 8744800 74.64082</pre>
<pre class="r">str(IBM)</pre>
<pre>## An 'xts' object on 2007-01-03/2018-04-27 containing:
## Data: num [1:2850, 1:6] 97.2 97.2 97.6 98.5 99.1 ...
## - attr(*, "dimnames")=List of 2
## ..$ : NULL
## ..$ : chr [1:6] "IBM.Open" "IBM.High" "IBM.Low" "IBM.Close" ...
## Indexed by objects of class: [Date] TZ: UTC
## xts Attributes:
## List of 2
## $ src : chr "yahoo"
## $ updated: POSIXct[1:1], format: "2018-05-03 22:21:00"</pre>
You can see that this object contains a range of daily observations (<code>Open</code>, <code>High</code>, <code>Close</code>, <code>Volume</code> and <code>Adjusted</code> share price). We also learn that the object is formatted as an <code>xts</code> object. <code>xts</code> is a type of time-series format and indeed we learn that the data range from 2007-01-03 to 2018-04-30.

You can in fact produce a somewhat fancy looking chart with the following command (also part of the <code>quantmod</code> package)

<pre class="r">chartSeries(GOOG)</pre>
[[File:GoogleChart1.png]]

When we are estimating volatility models we work with returns. There is a function that transforms the data to returns.

<pre class="r">rIBM <- dailyReturn(IBM)
rBP <- dailyReturn(BP)
rGOOG <- dailyReturn(GOOG)

# We put all data into a data frame for use in the multivariate model
rX <- data.frame(rIBM, rBP, rGOOG)
names(rX)[1] <- "rIBM"
names(rX)[2] <- "rBP"
names(rX)[3] <- "rGOOG"</pre>
There is also a <code>weeklyReturn</code> function in case that is what you are interested in.

= Univariate GARCH Model =

Here we are using the functionality provided by the <code>rugarch</code> package written by Alexios Galanos.

== Model Specification ==

The first thing you need to do is to ensure you know what type of GARCH model you want to estimate and then let R know about this. It is the <code>ugarchspec( )</code> function which is used to let R know about the model type. There is in fact a default specification and the way to invoke this is as follows

<pre class="r">ug_spec = ugarchspec()</pre>
<code>ug_spec</code> is now a list which contains all the relevant model specifications. Let's look at them:

<pre class="r">ug_spec</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Spec *
## *---------------------------------*
##
## Conditional Variance Dynamics
## ------------------------------------
## GARCH Model : sGARCH(1,1)
## Variance Targeting : FALSE
##
## Conditional Mean Dynamics
## ------------------------------------
## Mean Model : ARFIMA(1,0,1)
## Include Mean : TRUE
## GARCH-in-Mean : FALSE
##
## Conditional Distribution
## ------------------------------------
## Distribution : norm
## Includes Skew : FALSE
## Includes Shape : FALSE
## Includes Lambda : FALSE</pre>
The key issues here are the spec for the <code>Mean Model</code> (here an ARMA(1,1) model) and the specification for the <code>GARCH Model</code>, here an <code>sGARCH(1,1)</code> which is basically a GARCH(1,1). To get details on all the possible specifications and how to change them it is best to consult the [https://cran.r-project.org/web/packages/rugarch/vignettes/Introduction_to_the_rugarch_package.pdf documentation] of the <code>rugarch</code> package.

Let's say you want to change the mean model from an ARMA(1,1) to an ARMA(1,0), i.e. an AR(1) model.

<pre class="r">ug_spec <- ugarchspec(mean.model=list(armaOrder=c(1,0)))</pre>
You could call <code>ug_spec</code> again to check that the model specification has actually changed.

The following is the specification for an # an example of the EWMA Model (although we will not use it below).

<pre class="r">ewma_spec = ugarchspec(variance.model=list(model="iGARCH", garchOrder=c(1,1)),
mean.model=list(armaOrder=c(0,0), include.mean=TRUE),
distribution.model="norm", fixed.pars=list(omega=0))</pre>

== Model Estimation ==

Now that we have specified a model to estimate we need to find the best arameters, i.e. we need to estimate the model. This step is achieved by the <code>ugarchfit</code> function.

<pre class="r">ugfit = ugarchfit(spec = ug_spec, data = rIBM)</pre>
<code>fit</code> is now a list that contains a range of results from the estimation. Let's have a look at the results

<pre class="r">ugfit</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Fit *
## *---------------------------------*
##
## Conditional Variance Dynamics
## -----------------------------------
## GARCH Model : sGARCH(1,1)
## Mean Model : ARFIMA(1,0,0)
## Distribution : norm
##
## Optimal Parameters
## ------------------------------------
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000220 1.55666 0.11955
## ar1 -0.013463 0.021425 -0.62835 0.52978
## omega 0.000015 0.000002 6.56888 0.00000
## alpha1 0.111158 0.006440 17.25930 0.00000
## beta1 0.809517 0.005883 137.59775 0.00000
##
## Robust Standard Errors:
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000230 1.48654 0.137136
## ar1 -0.013463 0.019583 -0.68748 0.491782
## omega 0.000015 0.000012 1.25867 0.208150
## alpha1 0.111158 0.054637 2.03450 0.041901
## beta1 0.809517 0.082783 9.77876 0.000000
##
## LogLikelihood : 8364.692
##
## Information Criteria
## ------------------------------------
##
## Akaike -5.8665
## Bayes -5.8560
## Shibata -5.8665
## Hannan-Quinn -5.8627
##
## Weighted Ljung-Box Test on Standardized Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.03483 0.8519
## Lag[2*(p+q)+(p+q)-1][2] 0.03492 1.0000
## Lag[4*(p+q)+(p+q)-1][5] 1.39601 0.8712
## d.o.f=1
## H0 : No serial correlation
##
## Weighted Ljung-Box Test on Standardized Squared Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.2509 0.6165
## Lag[2*(p+q)+(p+q)-1][5] 1.2795 0.7938
## Lag[4*(p+q)+(p+q)-1][9] 1.9518 0.9107
## d.o.f=2
##
## Weighted ARCH LM Tests
## ------------------------------------
## Statistic Shape Scale P-Value
## ARCH Lag[3] 1.295 0.500 2.000 0.2551
## ARCH Lag[5] 1.603 1.440 1.667 0.5656
## ARCH Lag[7] 1.935 2.315 1.543 0.7312
##
## Nyblom stability test
## ------------------------------------
## Joint Statistic: 26.6709
## Individual Statistics:
## mu 0.42613
## ar1 0.06712
## omega 0.89209
## alpha1 0.55216
## beta1 0.15390
##
## Asymptotic Critical Values (10% 5% 1%)
## Joint Statistic: 1.28 1.47 1.88
## Individual Statistic: 0.35 0.47 0.75
##
## Sign Bias Test
## ------------------------------------
## t-value prob sig
## Sign Bias 0.2134 0.8310
## Negative Sign Bias 1.0137 0.3108
## Positive Sign Bias 0.4427 0.6580
## Joint Effect 1.6909 0.6390
##
##
## Adjusted Pearson Goodness-of-Fit Test:
## ------------------------------------
## group statistic p-value(g-1)
## 1 20 135.6 1.285e-19
## 2 30 139.3 2.301e-16
## 3 40 161.8 6.871e-17
## 4 50 166.2 1.164e-14
##
##
## Elapsed time : 0.7440431</pre>
If you are familiar with GARCH models you will recognise some of the parameters. <code>ar1</code> is the AR1 coefficient of the mean model (here very small and basically insignificant), <code>alpha1</code> is the coefficient to the squared residuals in the GARCH equation and <code>beta1</code> is the coefficient to the lagged variance.

Often you will want to use model output for some further analysis. It is therefore important to understand how to extract information such as the parameter estimates, their standard errors or the residuals. The object <code>ugfit</code> contains all the information. In that object you can find two drawers (or in technical speak slots, @fit and @model). Each of these drawers contains a range of different things. What they contain you can figure out by asking for the element names

<pre class="r">paste("Elements in the @model slot")</pre>
<pre>## [1] "Elements in the @model slot"</pre>
<pre class="r">names(ugfit@model)</pre>
<pre>## [1] "modelinc" "modeldesc" "modeldata" "pars" "start.pars"
## [6] "fixed.pars" "maxOrder" "pos.matrix" "fmodel" "pidx"
## [11] "n.start"</pre>
<pre class="r">paste("Elements in the @fit slot")</pre>
<pre>## [1] "Elements in the @fit slot"</pre>
<pre class="r">names(ugfit@fit)</pre>
<pre>## [1] "hessian" "cvar" "var"
## [4] "sigma" "condH" "z"
## [7] "LLH" "log.likelihoods" "residuals"
## [10] "coef" "robust.cvar" "A"
## [13] "B" "scores" "se.coef"
## [16] "tval" "matcoef" "robust.se.coef"
## [19] "robust.tval" "robust.matcoef" "fitted.values"
## [22] "convergence" "kappa" "persistence"
## [25] "timer" "ipars" "solver"</pre>
If you wanted to extract the estimated coefficients you would do that in the following way:

<pre class="r">ugfit@fit$coef</pre>
<pre>## mu ar1 omega alpha1 beta1
## 3.419000e-04 -1.346260e-02 1.516946e-05 1.111584e-01 8.095171e-01</pre>
<pre class="r">ug_var <- ugfit@fit$var # save the estimated conditional variances
ug_res2 <- (ugfit@fit$residuals)^2 # save the estimated squared residuals</pre>
Let's plot the squared residuals and the estimated conditional variance:

<pre class="r">plot(ug_res2, type = "l")
lines(ug_var, col = "green")</pre>
[[File:CondVar2.png]]

== Model Forecasting ==

Often you will want to use an estimated model to subsequently forecast the conditional variance. The function used for this purpose is the <code>ugarchforecast</code> function. The application is rather straightforward:

<pre class="r">ugfore <- ugarchforecast(ugfit, n.ahead = 10)
ugfore</pre>
<pre>##
## *------------------------------------*
## * GARCH Model Forecast *
## *------------------------------------*
## Model: sGARCH
## Horizon: 10
## Roll Steps: 0
## Out of Sample: 0
##
## 0-roll forecast [T0=2018-04-27]:
## Series Sigma
## T+1 0.0003685 0.01640
## T+2 0.0003415 0.01621
## T+3 0.0003419 0.01604
## T+4 0.0003419 0.01587
## T+5 0.0003419 0.01572
## T+6 0.0003419 0.01558
## T+7 0.0003419 0.01545
## T+8 0.0003419 0.01533
## T+9 0.0003419 0.01521
## T+10 0.0003419 0.01511</pre>
As you can see we have produced forecasts for the next ten days, both for the expected returns (<code>Series</code>) and for the conditional volatility (square root of the conditional variance). Similar to the object created for model fitting, <code>ugfore</code> contains two slots (@model and @forecast) and you can use <code>names(ugfore@forecast)</code> to figure out under which names the elements are saved. For instance you can extract the conditional volatility forecast as follows:

<pre class="r">ug_f <- ugfore@forecast$sigmaFor
plot(ug_f, type = "l")</pre>
[[File:ug_forecast3.png]]

Note that the volatility is the square root of the conditional variance.

To put these forecasts into context let's display them together with the last 50 observations used in the estimation.

<pre class="r">ug_var_t <- c(tail(ug_var,20),rep(NA,10)) # gets the last 20 observations
ug_res2_t <- c(tail(ug_res2,20),rep(NA,10)) # gets the last 20 observations
ug_f <- c(rep(NA,20),(ug_f)^2)

plot(ug_res2_t, type = "l")
lines(ug_f, col = "orange")
lines(ug_var_t, col = "green")</pre>
[[File:ug_forecast4.png]]

You can see how the forecast of the conditional variance picks up from the last estimated conditional variance. In fact it decreases from there, slowly, towards the unconditional variance value.

The <code>rugarch</code> package has a lot of additional functionality which you can explore through the documentation.

= Multivariate GARCH models =

Often you will want to model the volatility of a vector of assets. This can be done with the multivariate equivalent of the univariate GARCH model. Estimating multivariate GARCH models turns out to be significantly more difficult than univariate GARCH models, but fortunately procedures have been developed that deal with most of these issues.

Here we are using the <code>rmgarch</code> package which has a lot of useful functionality. We are applying it to estimate a multivariate volatility model for the returns of BP, Google/Alphabet and IBM shares.

As for the <code>rugarch</code> package we first need to specify the model we want to estimate. Here we stick with a Dynamic Conditional Correlation (DCC) model (see the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for details.). When estimating DCC models one basically estimates individual GARCH-type models (which could differ for each individual asset). These are then used to standardise the individual residuals. As a second step one then has to specify the correlation dynamics of these standardised residuals. It is possible to estimate the parameters of the univariate and the correlation model in one big swoop. however, my experience with this, and other packages, is that it is beneficial to separate the two steps.

== Model Setup ==

Here we assume that we are using the same univariate volatility model specification for each of the three assets.

<pre class="r"># DCC (MVN)
uspec.n = multispec(replicate(3, ugarchspec(mean.model = list(armaOrder = c(1,0)))))</pre>
What does this command do? You will recognise that <code>ugarchspec(mean.model = list(armaOrder = c(1,0)))</code> specifies an AR(1)-GARCH(1,1) model. By using <code>replicate(3, ugarchspec...)</code> we replicate this model 3 times (as we have three assets, IBM, Google/Alphabet and BP).

We now estimate these univariate GARCH models using the <code>multifit</code> command.

<pre class="r">multf = multifit(uspec.n, rX)</pre>
The results are saved in <code>multf</code> and you can type <code>multf</code> into the command window to see the estimated parameters for these three models. But we will here proceed to specify the DCC model (I assume that you know what a DCC model is. This is not the place to elaborate on this and many textbooks or indeed the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] to this package provide details). To specify the correlation specification we use the <code>dccspec</code> function.

<pre class="r">spec1 = dccspec(uspec = uspec.n, dccOrder = c(1, 1), distribution = 'mvnorm')</pre>
In this specification we have to state how the univariate volatilities are modeled (as per <code>uspec.n</code>) and how complex the dynamic structure of the correlation matrix is (here we are using the most standard <code>dccOrder = c(1, 1)</code> specification).

== Model Estimation ==

Now we are in a position to estimate the model using the <code>dccfit</code> function.

<pre class="r">fit1 = dccfit(spec1, data = rX, fit.control = list(eval.se = TRUE), fit = multf)</pre>
We want to estimate the model as specified in <code>spec1</code>, using the data in <code>rX</code>. The option <code>fit.control = list(eval.se = TRUE)</code> ensures that the estimation procedure produces standard errors for estimated parameters. Importantly <code>fit = multf</code> indicates that we ought to use the already estimated univariate models as they were saved in <code>multf</code>. The way to learn how to use these functions is by a combination of looking at the functions's help (<code>?dccfit</code>) and googling.

When you estimate a multivariate volatility model like the DCC model you are typically interested in the estimated covariance or correlation matrices. After all it is at the core of these models that you allow for time-variation in the correlation between the assets (there are also constant correlation models, but we do not discuss this here). Therefore we will now learn how we extract these.

<pre class="r"># Get the model based time varying covariance (arrays) and correlation matrices
cov1 = rcov(fit1) # extracts the covariance matrix
cor1 = rcor(fit1) # extracts the correlation matrix</pre>
To understand the object we have at our hands here we can have a look at the imension:

<pre class="r">dim(cor1)</pre>
<pre>## [1] 3 3 2850</pre>
We get three outputs which tells us that we have a three dimensional object. The firts two dimensions have 3 elements each (think a <math>3\times3</math> correlation matrix) and then there is a third dimension with 2850 elements. This tells us that <code>cor1</code> stores 2850 (<math>3\times3</math>) sorrelation matrices, one for each day of data.

Let's have a look at the correlation matrix for the last day, day 2853;

<pre class="r">cor1[,,dim(cor1)[3]]</pre>
<pre>## rIBM rBP rGOOG
## rIBM 1.0000000 0.2424297 0.353591
## rBP 0.2424297 1.0000000 0.275244
## rGOOG 0.3535910 0.2752440 1.000000</pre>
So let's say we want to plot the time-varying correlation between Google and BP, which is 0.275244 on that last day. In our matrix with returns <code>rX</code> BP is the second asset and Google the 3rd. So in any particular correlation matrix we want the element in row 2 and column 3.

<pre class="r">cor_BG <- cor1[2,1,] # leaving the last dimension empty implies that we want all elements
cor_BG <- as.xts(cor_BG) # imposes the xts time series format - useful for plotting</pre>
And now we plot this.

<pre class="r">plot(cor_BG)</pre>
[[File:correlation1.png]]

If you transformed <code>cor_BG</code> to be a <code>xts</code> series the <code>plot</code> function automatically picks up the date information. As you can see there is significant variation through time with the correaltion typically varying between 0.2 and 0.5.

Let's plot all three correlations between the three assets.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
plot(as.xts(cor1[1,2,]),main="IBM and BP")
plot(as.xts(cor1[1,3,]),main="IBM and Google")
plot(as.xts(cor1[2,3,]),main="BP and Google")</pre>
[[File:correlation2.png]]

== Forecasts ==

Often you will want to use your estimated model to produce forecasts for the covariance or correlation matrix

<pre class="r">dccf1 <- dccforecast(fit1, n.ahead = 10)
dccf1</pre>
<pre>##
## *---------------------------------*
## * DCC GARCH Forecast *
## *---------------------------------*
##
## Distribution : mvnorm
## Model : DCC(1,1)
## Horizon : 10
## Roll Steps : 0
## -----------------------------------
##
## 0-roll forecast:
##
## First 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2539 0.3562
## [2,] 0.2539 1.0000 0.2883
## [3,] 0.3562 0.2883 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2658 0.3587
## [2,] 0.2658 1.0000 0.2909
## [3,] 0.3587 0.2909 1.0000
##
## . . .
## . . .
##
## Last 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3202 0.3703
## [2,] 0.3202 1.0000 0.3027
## [3,] 0.3703 0.3027 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3250 0.3714
## [2,] 0.3250 1.0000 0.3037
## [3,] 0.3714 0.3037 1.0000</pre>
The actual forecasts for the correlation can be addresse via

<pre class="r">Rf <- dccf1@mforecast$R # use H for the covariance forecast</pre>
When checking the structure of <code>Rf</code>

<pre class="r">str(Rf)</pre>
<pre>## List of 1
## $ : num [1:3, 1:3, 1:10] 1 0.254 0.356 0.254 1 ...</pre>
you realise that the object <code>Rf</code> is a list with one element. It turns out that this one list item is then a 3 dimensional matrix/array which contains the the 10 forecasts of <math>3 \times 3</math> correlation matrices. If we want to extract, say, the 10 forecasts for the correlation between IBM (1st asset) and BP (2nd asset), we have to do this in the following way:

<pre class="r">corf_IB <- Rf[[1]][1,2,] # Correlation forecasts between IBM and BP
corf_IG <- Rf[[1]][1,3,] # Correlation forecasts between IBM and Google
corf_BG <- Rf[[1]][2,3,] # Correlation forecasts between BP and Google</pre>
<code>[[1]]</code> tells R to go to the first (and here only) list item and then <code>[1,2,]</code> instructs R to select the (1,2) element of all available correlation matrices.

As for the univariate volatililty model let us display the forecast along with the last in-sample estimates of correlation.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
c_IB <- c(tail(cor1[1,2,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IB <- c(rep(NA,20),corf_IB) # gets the 10 forecasts
plot(c_IB,type = "l",main="Correlation IBM and BP")
lines(cf_IB,type = "l", col = "orange")

c_IG <- c(tail(cor1[1,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IG <- c(rep(NA,20),corf_IG) # gets the 10 forecasts
plot(c_IG,type = "l",main="Correlation IBM and Google")
lines(cf_IG,type = "l", col = "orange")

c_BG <- c(tail(cor1[2,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_BG <- c(rep(NA,20),corf_BG) # gets the 10 forecasts
plot(c_BG,type = "l",main="Correlation BP and Google")
lines(cf_BG,type = "l", col = "orange")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-34-1.png]]

= Further thoughts =

If you are looking at using pseudo-out-of sample forecasting (i.e. pretend to forecast values that actually have already occured) you should explore the <code>out.sample</code> option of the <code>dccfit</code> function.

The <code>rmgarch</code> package also allows you to estimate multivariate factor GARCH models and copula GARCH models (check the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for more details.

An alternative package with a slightly different set of multivariate volatility models is the `<code>ccgarch</code> package.

File:Ug forecast4.png

2018-05-03T23:19:46Z

Rb:

R GARCH

2018-05-03T23:19:20Z

Rb: /* Model Forecasting */

= Introduction =

When you are dealing with financial time-series we often have relatively high frequency observations available. It is very common for instance to have daily observations available. In fact it is now possible to obtain hourly, minute, second or even millisecond observations. But here we will restrict ourselves to daily observations. For some assets these will be 7 days a week observations, but for others these will be work-day observations, so typically 5 days a week of observations.

= Packages used =

There are a number of packages that can enable us to estimate volatility models. The packages we will use are the <code>rugarch</code> for univariate GARCH models and the <code>rmgarch</code> (for multivariate models) package both written by Alexios Ghalanos. We shall also use the <code>quantmod</code> package as it will give us some easy access to some standard financial data.

So please ensure that you install these packes and then load them,

<pre class="r">#install.packages(c("quantmod","rugarch","rmgarch")) # only needed in case you have not yet installed these packages
library(quantmod)
library(rugarch)
library(rmgarch)</pre>
Next we set our working directory

<pre class="r"># replace with your directory and uncomment
# setwd("YOUR/COPLETE/DIRECTORY/PATH") </pre>
= Data upload =

Here we will use a convenient data retrieval function (<code>getSymbols</code>) delivered by the <code>quantmod</code> package in order to retrieve some data. This function works, for instance, to retrieve stock data. The default source is [https://finance.yahoo.com/ Yahoo Finance]. If you want to find out what stock has which symbol you should be able to search the internet to find a list of ticker symbols. The following shows how to use the function. But note that my experience is that sometimes the connection does not work and you may get an error message. In that case just retry a few seconds later and it may well work.

<pre class="r">startDate = as.Date("2007-01-03") #Specify period of time we are interested in
endDate = as.Date("2018-04-30")

getSymbols("IBM", from = startDate, to = endDate)</pre>
<pre>## [1] "IBM"</pre>
<pre class="r">getSymbols("GOOG", from = startDate, to = endDate)</pre>
<pre>## [1] "GOOG"</pre>
<pre class="r">getSymbols("BP", from = startDate, to = endDate)</pre>
<pre>## [1] "BP"</pre>
In your environment you can see that each of these commands loads an object with the respective ticker symbol name. Let's have a look at one of these dataframes to understand what data these are:

<pre class="r">head(IBM)</pre>
<pre>## IBM.Open IBM.High IBM.Low IBM.Close IBM.Volume IBM.Adjusted
## 2007-01-03 97.18 98.40 96.26 97.27 9196800 73.41806
## 2007-01-04 97.25 98.79 96.88 98.31 10524500 74.20306
## 2007-01-05 97.60 97.95 96.91 97.42 7221300 73.53130
## 2007-01-08 98.50 99.50 98.35 98.90 10340000 74.64834
## 2007-01-09 99.08 100.33 99.07 100.07 11108200 75.53147
## 2007-01-10 98.50 99.05 97.93 98.89 8744800 74.64082</pre>
<pre class="r">str(IBM)</pre>
<pre>## An 'xts' object on 2007-01-03/2018-04-27 containing:
## Data: num [1:2850, 1:6] 97.2 97.2 97.6 98.5 99.1 ...
## - attr(*, "dimnames")=List of 2
## ..$ : NULL
## ..$ : chr [1:6] "IBM.Open" "IBM.High" "IBM.Low" "IBM.Close" ...
## Indexed by objects of class: [Date] TZ: UTC
## xts Attributes:
## List of 2
## $ src : chr "yahoo"
## $ updated: POSIXct[1:1], format: "2018-05-03 22:21:00"</pre>
You can see that this object contains a range of daily observations (<code>Open</code>, <code>High</code>, <code>Close</code>, <code>Volume</code> and <code>Adjusted</code> share price). We also learn that the object is formatted as an <code>xts</code> object. <code>xts</code> is a type of time-series format and indeed we learn that the data range from 2007-01-03 to 2018-04-30.

You can in fact produce a somewhat fancy looking chart with the following command (also part of the <code>quantmod</code> package)

<pre class="r">chartSeries(GOOG)</pre>
[[File:GoogleChart1.png]]

When we are estimating volatility models we work with returns. There is a function that transforms the data to returns.

<pre class="r">rIBM <- dailyReturn(IBM)
rBP <- dailyReturn(BP)
rGOOG <- dailyReturn(GOOG)

# We put all data into a data frame for use in the multivariate model
rX <- data.frame(rIBM, rBP, rGOOG)
names(rX)[1] <- "rIBM"
names(rX)[2] <- "rBP"
names(rX)[3] <- "rGOOG"</pre>
There is also a <code>weeklyReturn</code> function in case that is what you are interested in.

= Univariate GARCH Model =

Here we are using the functionality provided by the <code>rugarch</code> package written by Alexios Galanos.

== Model Specification ==

The first thing you need to do is to ensure you know what type of GARCH model you want to estimate and then let R know about this. It is the <code>ugarchspec( )</code> function which is used to let R know about the model type. There is in fact a default specification and the way to invoke this is as follows

<pre class="r">ug_spec = ugarchspec()</pre>
<code>ug_spec</code> is now a list which contains all the relevant model specifications. Let's look at them:

<pre class="r">ug_spec</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Spec *
## *---------------------------------*
##
## Conditional Variance Dynamics
## ------------------------------------
## GARCH Model : sGARCH(1,1)
## Variance Targeting : FALSE
##
## Conditional Mean Dynamics
## ------------------------------------
## Mean Model : ARFIMA(1,0,1)
## Include Mean : TRUE
## GARCH-in-Mean : FALSE
##
## Conditional Distribution
## ------------------------------------
## Distribution : norm
## Includes Skew : FALSE
## Includes Shape : FALSE
## Includes Lambda : FALSE</pre>
The key issues here are the spec for the <code>Mean Model</code> (here an ARMA(1,1) model) and the specification for the <code>GARCH Model</code>, here an <code>sGARCH(1,1)</code> which is basically a GARCH(1,1). To get details on all the possible specifications and how to change them it is best to consult the [https://cran.r-project.org/web/packages/rugarch/vignettes/Introduction_to_the_rugarch_package.pdf documentation] of the <code>rugarch</code> package.

Let's say you want to change the mean model from an ARMA(1,1) to an ARMA(1,0), i.e. an AR(1) model.

<pre class="r">ug_spec <- ugarchspec(mean.model=list(armaOrder=c(1,0)))</pre>
You could call <code>ug_spec</code> again to check that the model specification has actually changed.

The following is the specification for an # an example of the EWMA Model (although we will not use it below).

<pre class="r">ewma_spec = ugarchspec(variance.model=list(model="iGARCH", garchOrder=c(1,1)),
mean.model=list(armaOrder=c(0,0), include.mean=TRUE),
distribution.model="norm", fixed.pars=list(omega=0))</pre>

== Model Estimation ==

Now that we have specified a model to estimate we need to find the best arameters, i.e. we need to estimate the model. This step is achieved by the <code>ugarchfit</code> function.

<pre class="r">ugfit = ugarchfit(spec = ug_spec, data = rIBM)</pre>
<code>fit</code> is now a list that contains a range of results from the estimation. Let's have a look at the results

<pre class="r">ugfit</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Fit *
## *---------------------------------*
##
## Conditional Variance Dynamics
## -----------------------------------
## GARCH Model : sGARCH(1,1)
## Mean Model : ARFIMA(1,0,0)
## Distribution : norm
##
## Optimal Parameters
## ------------------------------------
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000220 1.55666 0.11955
## ar1 -0.013463 0.021425 -0.62835 0.52978
## omega 0.000015 0.000002 6.56888 0.00000
## alpha1 0.111158 0.006440 17.25930 0.00000
## beta1 0.809517 0.005883 137.59775 0.00000
##
## Robust Standard Errors:
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000230 1.48654 0.137136
## ar1 -0.013463 0.019583 -0.68748 0.491782
## omega 0.000015 0.000012 1.25867 0.208150
## alpha1 0.111158 0.054637 2.03450 0.041901
## beta1 0.809517 0.082783 9.77876 0.000000
##
## LogLikelihood : 8364.692
##
## Information Criteria
## ------------------------------------
##
## Akaike -5.8665
## Bayes -5.8560
## Shibata -5.8665
## Hannan-Quinn -5.8627
##
## Weighted Ljung-Box Test on Standardized Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.03483 0.8519
## Lag[2*(p+q)+(p+q)-1][2] 0.03492 1.0000
## Lag[4*(p+q)+(p+q)-1][5] 1.39601 0.8712
## d.o.f=1
## H0 : No serial correlation
##
## Weighted Ljung-Box Test on Standardized Squared Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.2509 0.6165
## Lag[2*(p+q)+(p+q)-1][5] 1.2795 0.7938
## Lag[4*(p+q)+(p+q)-1][9] 1.9518 0.9107
## d.o.f=2
##
## Weighted ARCH LM Tests
## ------------------------------------
## Statistic Shape Scale P-Value
## ARCH Lag[3] 1.295 0.500 2.000 0.2551
## ARCH Lag[5] 1.603 1.440 1.667 0.5656
## ARCH Lag[7] 1.935 2.315 1.543 0.7312
##
## Nyblom stability test
## ------------------------------------
## Joint Statistic: 26.6709
## Individual Statistics:
## mu 0.42613
## ar1 0.06712
## omega 0.89209
## alpha1 0.55216
## beta1 0.15390
##
## Asymptotic Critical Values (10% 5% 1%)
## Joint Statistic: 1.28 1.47 1.88
## Individual Statistic: 0.35 0.47 0.75
##
## Sign Bias Test
## ------------------------------------
## t-value prob sig
## Sign Bias 0.2134 0.8310
## Negative Sign Bias 1.0137 0.3108
## Positive Sign Bias 0.4427 0.6580
## Joint Effect 1.6909 0.6390
##
##
## Adjusted Pearson Goodness-of-Fit Test:
## ------------------------------------
## group statistic p-value(g-1)
## 1 20 135.6 1.285e-19
## 2 30 139.3 2.301e-16
## 3 40 161.8 6.871e-17
## 4 50 166.2 1.164e-14
##
##
## Elapsed time : 0.7440431</pre>
If you are familiar with GARCH models you will recognise some of the parameters. <code>ar1</code> is the AR1 coefficient of the mean model (here very small and basically insignificant), <code>alpha1</code> is the coefficient to the squared residuals in the GARCH equation and <code>beta1</code> is the coefficient to the lagged variance.

Often you will want to use model output for some further analysis. It is therefore important to understand how to extract information such as the parameter estimates, their standard errors or the residuals. The object <code>ugfit</code> contains all the information. In that object you can find two drawers (or in technical speak slots, @fit and @model). Each of these drawers contains a range of different things. What they contain you can figure out by asking for the element names

<pre class="r">paste("Elements in the @model slot")</pre>
<pre>## [1] "Elements in the @model slot"</pre>
<pre class="r">names(ugfit@model)</pre>
<pre>## [1] "modelinc" "modeldesc" "modeldata" "pars" "start.pars"
## [6] "fixed.pars" "maxOrder" "pos.matrix" "fmodel" "pidx"
## [11] "n.start"</pre>
<pre class="r">paste("Elements in the @fit slot")</pre>
<pre>## [1] "Elements in the @fit slot"</pre>
<pre class="r">names(ugfit@fit)</pre>
<pre>## [1] "hessian" "cvar" "var"
## [4] "sigma" "condH" "z"
## [7] "LLH" "log.likelihoods" "residuals"
## [10] "coef" "robust.cvar" "A"
## [13] "B" "scores" "se.coef"
## [16] "tval" "matcoef" "robust.se.coef"
## [19] "robust.tval" "robust.matcoef" "fitted.values"
## [22] "convergence" "kappa" "persistence"
## [25] "timer" "ipars" "solver"</pre>
If you wanted to extract the estimated coefficients you would do that in the following way:

<pre class="r">ugfit@fit$coef</pre>
<pre>## mu ar1 omega alpha1 beta1
## 3.419000e-04 -1.346260e-02 1.516946e-05 1.111584e-01 8.095171e-01</pre>
<pre class="r">ug_var <- ugfit@fit$var # save the estimated conditional variances
ug_res2 <- (ugfit@fit$residuals)^2 # save the estimated squared residuals</pre>
Let's plot the squared residuals and the estimated conditional variance:

<pre class="r">plot(ug_res2, type = "l")
lines(ug_var, col = "green")</pre>
[[File:CondVar2.png]]

== Model Forecasting ==

Often you will want to use an estimated model to subsequently forecast the conditional variance. The function used for this purpose is the <code>ugarchforecast</code> function. The application is rather straightforward:

<pre class="r">ugfore <- ugarchforecast(ugfit, n.ahead = 10)
ugfore</pre>
<pre>##
## *------------------------------------*
## * GARCH Model Forecast *
## *------------------------------------*
## Model: sGARCH
## Horizon: 10
## Roll Steps: 0
## Out of Sample: 0
##
## 0-roll forecast [T0=2018-04-27]:
## Series Sigma
## T+1 0.0003685 0.01640
## T+2 0.0003415 0.01621
## T+3 0.0003419 0.01604
## T+4 0.0003419 0.01587
## T+5 0.0003419 0.01572
## T+6 0.0003419 0.01558
## T+7 0.0003419 0.01545
## T+8 0.0003419 0.01533
## T+9 0.0003419 0.01521
## T+10 0.0003419 0.01511</pre>
As you can see we have produced forecasts for the next ten days, both for the expected returns (<code>Series</code>) and for the conditional volatility (square root of the conditional variance). Similar to the object created for model fitting, <code>ugfore</code> contains two slots (@model and @forecast) and you can use <code>names(ugfore@forecast)</code> to figure out under which names the elements are saved. For instance you can extract the conditional volatility forecast as follows:

<pre class="r">ug_f <- ugfore@forecast$sigmaFor
plot(ug_f, type = "l")</pre>
[[File:ug_forecast3.png]]

Note that the volatility is the square root of the conditional variance.

To put these forecasts into context let's display them together with the last 50 observations used in the estimation.

<pre class="r">ug_var_t <- c(tail(ug_var,20),rep(NA,10)) # gets the last 20 observations
ug_res2_t <- c(tail(ug_res2,20),rep(NA,10)) # gets the last 20 observations
ug_f <- c(rep(NA,20),(ug_f)^2)

plot(ug_res2_t, type = "l")
lines(ug_f, col = "orange")
lines(ug_var_t, col = "green")</pre>
[[File:ug_forecast4.png]]

You can see how the forecast of the conditional variance picks up from the last estimated conditional variance. In fact it decreases from there, slowly, towards the unconditional variance value.

The <code>rugarch</code> package has a lot of additional functionality which you can explore through the documentation.

= Multivariate GARCH models =

Often you will want to model the volatility of a vector of assets. This can be done with the multivariate equivalent of the univariate GARCH model. Estimating multivariate GARCH models turns out to be significantly more difficult than univariate GARCH models, but fortunately procedures have been developed that deal with most of these issues.

Here we are using the <code>rmgarch</code> package which has a lot of useful functionality. We are applying it to estimate a multivariate volatility model for the returns of BP, Google/Alphabet and IBM shares.

As for the <code>rugarch</code> package we first need to specify the model we want to estimate. Here we stick with a Dynamic Conditional Correlation (DCC) model (see the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for details.). When estimating DCC models one basically estimates individual GARCH-type models (which could differ for each individual asset). These are then used to standardise the individual residuals. As a second step one then has to specify the correlation dynamics of these standardised residuals. It is possible to estimate the parameters of the univariate and the correlation model in one big swoop. however, my experience with this, and other packages, is that it is beneficial to separate the two steps.

== Model Setup ==

Here we assume that we are using the same univariate volatility model specification for each of the three assets.

<pre class="r"># DCC (MVN)
uspec.n = multispec(replicate(3, ugarchspec(mean.model = list(armaOrder = c(1,0)))))</pre>
What does this command do? You will recognise that <code>ugarchspec(mean.model = list(armaOrder = c(1,0)))</code> specifies an AR(1)-GARCH(1,1) model. By using <code>replicate(3, ugarchspec...)</code> we replicate this model 3 times (as we have three assets, IBM, Google/Alphabet and BP).

We now estimate these univariate GARCH models using the <code>multifit</code> command.

<pre class="r">multf = multifit(uspec.n, rX)</pre>
The results are saved in <code>multf</code> and you can type <code>multf</code> into the command window to see the estimated parameters for these three models. But we will here proceed to specify the DCC model (I assume that you know what a DCC model is. This is not the place to elaborate on this and many textbooks or indeed the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] to this package provide details). To specify the correlation specification we use the <code>dccspec</code> function.

<pre class="r">spec1 = dccspec(uspec = uspec.n, dccOrder = c(1, 1), distribution = 'mvnorm')</pre>
In this specification we have to state how the univariate volatilities are modeled (as per <code>uspec.n</code>) and how complex the dynamic structure of the correlation matrix is (here we are using the most standard <code>dccOrder = c(1, 1)</code> specification).

== Model Estimation ==

Now we are in a position to estimate the model using the <code>dccfit</code> function.

<pre class="r">fit1 = dccfit(spec1, data = rX, fit.control = list(eval.se = TRUE), fit = multf)</pre>
We want to estimate the model as specified in <code>spec1</code>, using the data in <code>rX</code>. The option <code>fit.control = list(eval.se = TRUE)</code> ensures that the estimation procedure produces standard errors for estimated parameters. Importantly <code>fit = multf</code> indicates that we ought to use the already estimated univariate models as they were saved in <code>multf</code>. The way to learn how to use these functions is by a combination of looking at the functions's help (<code>?dccfit</code>) and googling.

When you estimate a multivariate volatility model like the DCC model you are typically interested in the estimated covariance or correlation matrices. After all it is at the core of these models that you allow for time-variation in the correlation between the assets (there are also constant correlation models, but we do not discuss this here). Therefore we will now learn how we extract these.

<pre class="r"># Get the model based time varying covariance (arrays) and correlation matrices
cov1 = rcov(fit1) # extracts the covariance matrix
cor1 = rcor(fit1) # extracts the correlation matrix</pre>
To understand the object we have at our hands here we can have a look at the imension:

<pre class="r">dim(cor1)</pre>
<pre>## [1] 3 3 2850</pre>
We get three outputs which tells us that we have a three dimensional object. The firts two dimensions have 3 elements each (think a <math>3\times3</math> correlation matrix) and then there is a third dimension with 2850 elements. This tells us that <code>cor1</code> stores 2850 (<math>3\times3</math>) sorrelation matrices, one for each day of data.

Let's have a look at the correlation matrix for the last day, day 2853;

<pre class="r">cor1[,,dim(cor1)[3]]</pre>
<pre>## rIBM rBP rGOOG
## rIBM 1.0000000 0.2424297 0.353591
## rBP 0.2424297 1.0000000 0.275244
## rGOOG 0.3535910 0.2752440 1.000000</pre>
So let's say we want to plot the time-varying correlation between Google and BP, which is 0.275244 on that last day. In our matrix with returns <code>rX</code> BP is the second asset and Google the 3rd. So in any particular correlation matrix we want the element in row 2 and column 3.

<pre class="r">cor_BG <- cor1[2,1,] # leaving the last dimension empty implies that we want all elements
cor_BG <- as.xts(cor_BG) # imposes the xts time series format - useful for plotting</pre>
And now we plot this.

<pre class="r">plot(cor_BG)</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-28-1.png]]

If you transformed <code>cor_BG</code> to be a <code>xts</code> series the <code>plot</code> function automatically picks up the date information. As you can see there is significant variation through time with the correaltion typically varying between 0.2 and 0.5.

Let's plot all three correlations between the three assets.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
plot(as.xts(cor1[1,2,]),main="IBM and BP")
plot(as.xts(cor1[1,3,]),main="IBM and Google")
plot(as.xts(cor1[2,3,]),main="BP and Google")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-29-1.png]]

== Forecasts ==

Often you will want to use your estimated model to produce forecasts for the covariance or correlation matrix

<pre class="r">dccf1 <- dccforecast(fit1, n.ahead = 10)
dccf1</pre>
<pre>##
## *---------------------------------*
## * DCC GARCH Forecast *
## *---------------------------------*
##
## Distribution : mvnorm
## Model : DCC(1,1)
## Horizon : 10
## Roll Steps : 0
## -----------------------------------
##
## 0-roll forecast:
##
## First 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2539 0.3562
## [2,] 0.2539 1.0000 0.2883
## [3,] 0.3562 0.2883 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2658 0.3587
## [2,] 0.2658 1.0000 0.2909
## [3,] 0.3587 0.2909 1.0000
##
## . . .
## . . .
##
## Last 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3202 0.3703
## [2,] 0.3202 1.0000 0.3027
## [3,] 0.3703 0.3027 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3250 0.3714
## [2,] 0.3250 1.0000 0.3037
## [3,] 0.3714 0.3037 1.0000</pre>
The actual forecasts for the correlation can be addresse via

<pre class="r">Rf <- dccf1@mforecast$R # use H for the covariance forecast</pre>
When checking the structure of <code>Rf</code>

<pre class="r">str(Rf)</pre>
<pre>## List of 1
## $ : num [1:3, 1:3, 1:10] 1 0.254 0.356 0.254 1 ...</pre>
you realise that the object <code>Rf</code> is a list with one element. It turns out that this one list item is then a 3 dimensional matrix/array which contains the the 10 forecasts of <math>3 \times 3</math> correlation matrices. If we want to extract, say, the 10 forecasts for the correlation between IBM (1st asset) and BP (2nd asset), we have to do this in the following way:

<pre class="r">corf_IB <- Rf[[1]][1,2,] # Correlation forecasts between IBM and BP
corf_IG <- Rf[[1]][1,3,] # Correlation forecasts between IBM and Google
corf_BG <- Rf[[1]][2,3,] # Correlation forecasts between BP and Google</pre>
<code>[[1]]</code> tells R to go to the first (and here only) list item and then <code>[1,2,]</code> instructs R to select the (1,2) element of all available correlation matrices.

As for the univariate volatililty model let us display the forecast along with the last in-sample estimates of correlation.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
c_IB <- c(tail(cor1[1,2,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IB <- c(rep(NA,20),corf_IB) # gets the 10 forecasts
plot(c_IB,type = "l",main="Correlation IBM and BP")
lines(cf_IB,type = "l", col = "orange")

c_IG <- c(tail(cor1[1,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IG <- c(rep(NA,20),corf_IG) # gets the 10 forecasts
plot(c_IG,type = "l",main="Correlation IBM and Google")
lines(cf_IG,type = "l", col = "orange")

c_BG <- c(tail(cor1[2,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_BG <- c(rep(NA,20),corf_BG) # gets the 10 forecasts
plot(c_BG,type = "l",main="Correlation BP and Google")
lines(cf_BG,type = "l", col = "orange")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-34-1.png]]

= Further thoughts =

If you are looking at using pseudo-out-of sample forecasting (i.e. pretend to forecast values that actually have already occured) you should explore the <code>out.sample</code> option of the <code>dccfit</code> function.

The <code>rmgarch</code> package also allows you to estimate multivariate factor GARCH models and copula GARCH models (check the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for more details.

An alternative package with a slightly different set of multivariate volatility models is the `<code>ccgarch</code> package.

File:Ug forecast3.png

2018-05-03T23:18:31Z

Rb:

File:Unnamed-chunk-18-1.png

2018-05-03T23:17:46Z

Rb:

R GARCH

2018-05-03T23:16:50Z

Rb: /* Model Estimation */

= Introduction =

When you are dealing with financial time-series we often have relatively high frequency observations available. It is very common for instance to have daily observations available. In fact it is now possible to obtain hourly, minute, second or even millisecond observations. But here we will restrict ourselves to daily observations. For some assets these will be 7 days a week observations, but for others these will be work-day observations, so typically 5 days a week of observations.

= Packages used =

There are a number of packages that can enable us to estimate volatility models. The packages we will use are the <code>rugarch</code> for univariate GARCH models and the <code>rmgarch</code> (for multivariate models) package both written by Alexios Ghalanos. We shall also use the <code>quantmod</code> package as it will give us some easy access to some standard financial data.

So please ensure that you install these packes and then load them,

<pre class="r">#install.packages(c("quantmod","rugarch","rmgarch")) # only needed in case you have not yet installed these packages
library(quantmod)
library(rugarch)
library(rmgarch)</pre>
Next we set our working directory

<pre class="r"># replace with your directory and uncomment
# setwd("YOUR/COPLETE/DIRECTORY/PATH") </pre>
= Data upload =

Here we will use a convenient data retrieval function (<code>getSymbols</code>) delivered by the <code>quantmod</code> package in order to retrieve some data. This function works, for instance, to retrieve stock data. The default source is [https://finance.yahoo.com/ Yahoo Finance]. If you want to find out what stock has which symbol you should be able to search the internet to find a list of ticker symbols. The following shows how to use the function. But note that my experience is that sometimes the connection does not work and you may get an error message. In that case just retry a few seconds later and it may well work.

<pre class="r">startDate = as.Date("2007-01-03") #Specify period of time we are interested in
endDate = as.Date("2018-04-30")

getSymbols("IBM", from = startDate, to = endDate)</pre>
<pre>## [1] "IBM"</pre>
<pre class="r">getSymbols("GOOG", from = startDate, to = endDate)</pre>
<pre>## [1] "GOOG"</pre>
<pre class="r">getSymbols("BP", from = startDate, to = endDate)</pre>
<pre>## [1] "BP"</pre>
In your environment you can see that each of these commands loads an object with the respective ticker symbol name. Let's have a look at one of these dataframes to understand what data these are:

<pre class="r">head(IBM)</pre>
<pre>## IBM.Open IBM.High IBM.Low IBM.Close IBM.Volume IBM.Adjusted
## 2007-01-03 97.18 98.40 96.26 97.27 9196800 73.41806
## 2007-01-04 97.25 98.79 96.88 98.31 10524500 74.20306
## 2007-01-05 97.60 97.95 96.91 97.42 7221300 73.53130
## 2007-01-08 98.50 99.50 98.35 98.90 10340000 74.64834
## 2007-01-09 99.08 100.33 99.07 100.07 11108200 75.53147
## 2007-01-10 98.50 99.05 97.93 98.89 8744800 74.64082</pre>
<pre class="r">str(IBM)</pre>
<pre>## An 'xts' object on 2007-01-03/2018-04-27 containing:
## Data: num [1:2850, 1:6] 97.2 97.2 97.6 98.5 99.1 ...
## - attr(*, "dimnames")=List of 2
## ..$ : NULL
## ..$ : chr [1:6] "IBM.Open" "IBM.High" "IBM.Low" "IBM.Close" ...
## Indexed by objects of class: [Date] TZ: UTC
## xts Attributes:
## List of 2
## $ src : chr "yahoo"
## $ updated: POSIXct[1:1], format: "2018-05-03 22:21:00"</pre>
You can see that this object contains a range of daily observations (<code>Open</code>, <code>High</code>, <code>Close</code>, <code>Volume</code> and <code>Adjusted</code> share price). We also learn that the object is formatted as an <code>xts</code> object. <code>xts</code> is a type of time-series format and indeed we learn that the data range from 2007-01-03 to 2018-04-30.

You can in fact produce a somewhat fancy looking chart with the following command (also part of the <code>quantmod</code> package)

<pre class="r">chartSeries(GOOG)</pre>
[[File:GoogleChart1.png]]

When we are estimating volatility models we work with returns. There is a function that transforms the data to returns.

<pre class="r">rIBM <- dailyReturn(IBM)
rBP <- dailyReturn(BP)
rGOOG <- dailyReturn(GOOG)

# We put all data into a data frame for use in the multivariate model
rX <- data.frame(rIBM, rBP, rGOOG)
names(rX)[1] <- "rIBM"
names(rX)[2] <- "rBP"
names(rX)[3] <- "rGOOG"</pre>
There is also a <code>weeklyReturn</code> function in case that is what you are interested in.

= Univariate GARCH Model =

Here we are using the functionality provided by the <code>rugarch</code> package written by Alexios Galanos.

== Model Specification ==

The first thing you need to do is to ensure you know what type of GARCH model you want to estimate and then let R know about this. It is the <code>ugarchspec( )</code> function which is used to let R know about the model type. There is in fact a default specification and the way to invoke this is as follows

<pre class="r">ug_spec = ugarchspec()</pre>
<code>ug_spec</code> is now a list which contains all the relevant model specifications. Let's look at them:

<pre class="r">ug_spec</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Spec *
## *---------------------------------*
##
## Conditional Variance Dynamics
## ------------------------------------
## GARCH Model : sGARCH(1,1)
## Variance Targeting : FALSE
##
## Conditional Mean Dynamics
## ------------------------------------
## Mean Model : ARFIMA(1,0,1)
## Include Mean : TRUE
## GARCH-in-Mean : FALSE
##
## Conditional Distribution
## ------------------------------------
## Distribution : norm
## Includes Skew : FALSE
## Includes Shape : FALSE
## Includes Lambda : FALSE</pre>
The key issues here are the spec for the <code>Mean Model</code> (here an ARMA(1,1) model) and the specification for the <code>GARCH Model</code>, here an <code>sGARCH(1,1)</code> which is basically a GARCH(1,1). To get details on all the possible specifications and how to change them it is best to consult the [https://cran.r-project.org/web/packages/rugarch/vignettes/Introduction_to_the_rugarch_package.pdf documentation] of the <code>rugarch</code> package.

Let's say you want to change the mean model from an ARMA(1,1) to an ARMA(1,0), i.e. an AR(1) model.

<pre class="r">ug_spec <- ugarchspec(mean.model=list(armaOrder=c(1,0)))</pre>
You could call <code>ug_spec</code> again to check that the model specification has actually changed.

The following is the specification for an # an example of the EWMA Model (although we will not use it below).

<pre class="r">ewma_spec = ugarchspec(variance.model=list(model="iGARCH", garchOrder=c(1,1)),
mean.model=list(armaOrder=c(0,0), include.mean=TRUE),
distribution.model="norm", fixed.pars=list(omega=0))</pre>

== Model Estimation ==

Now that we have specified a model to estimate we need to find the best arameters, i.e. we need to estimate the model. This step is achieved by the <code>ugarchfit</code> function.

<pre class="r">ugfit = ugarchfit(spec = ug_spec, data = rIBM)</pre>
<code>fit</code> is now a list that contains a range of results from the estimation. Let's have a look at the results

<pre class="r">ugfit</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Fit *
## *---------------------------------*
##
## Conditional Variance Dynamics
## -----------------------------------
## GARCH Model : sGARCH(1,1)
## Mean Model : ARFIMA(1,0,0)
## Distribution : norm
##
## Optimal Parameters
## ------------------------------------
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000220 1.55666 0.11955
## ar1 -0.013463 0.021425 -0.62835 0.52978
## omega 0.000015 0.000002 6.56888 0.00000
## alpha1 0.111158 0.006440 17.25930 0.00000
## beta1 0.809517 0.005883 137.59775 0.00000
##
## Robust Standard Errors:
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000230 1.48654 0.137136
## ar1 -0.013463 0.019583 -0.68748 0.491782
## omega 0.000015 0.000012 1.25867 0.208150
## alpha1 0.111158 0.054637 2.03450 0.041901
## beta1 0.809517 0.082783 9.77876 0.000000
##
## LogLikelihood : 8364.692
##
## Information Criteria
## ------------------------------------
##
## Akaike -5.8665
## Bayes -5.8560
## Shibata -5.8665
## Hannan-Quinn -5.8627
##
## Weighted Ljung-Box Test on Standardized Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.03483 0.8519
## Lag[2*(p+q)+(p+q)-1][2] 0.03492 1.0000
## Lag[4*(p+q)+(p+q)-1][5] 1.39601 0.8712
## d.o.f=1
## H0 : No serial correlation
##
## Weighted Ljung-Box Test on Standardized Squared Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.2509 0.6165
## Lag[2*(p+q)+(p+q)-1][5] 1.2795 0.7938
## Lag[4*(p+q)+(p+q)-1][9] 1.9518 0.9107
## d.o.f=2
##
## Weighted ARCH LM Tests
## ------------------------------------
## Statistic Shape Scale P-Value
## ARCH Lag[3] 1.295 0.500 2.000 0.2551
## ARCH Lag[5] 1.603 1.440 1.667 0.5656
## ARCH Lag[7] 1.935 2.315 1.543 0.7312
##
## Nyblom stability test
## ------------------------------------
## Joint Statistic: 26.6709
## Individual Statistics:
## mu 0.42613
## ar1 0.06712
## omega 0.89209
## alpha1 0.55216
## beta1 0.15390
##
## Asymptotic Critical Values (10% 5% 1%)
## Joint Statistic: 1.28 1.47 1.88
## Individual Statistic: 0.35 0.47 0.75
##
## Sign Bias Test
## ------------------------------------
## t-value prob sig
## Sign Bias 0.2134 0.8310
## Negative Sign Bias 1.0137 0.3108
## Positive Sign Bias 0.4427 0.6580
## Joint Effect 1.6909 0.6390
##
##
## Adjusted Pearson Goodness-of-Fit Test:
## ------------------------------------
## group statistic p-value(g-1)
## 1 20 135.6 1.285e-19
## 2 30 139.3 2.301e-16
## 3 40 161.8 6.871e-17
## 4 50 166.2 1.164e-14
##
##
## Elapsed time : 0.7440431</pre>
If you are familiar with GARCH models you will recognise some of the parameters. <code>ar1</code> is the AR1 coefficient of the mean model (here very small and basically insignificant), <code>alpha1</code> is the coefficient to the squared residuals in the GARCH equation and <code>beta1</code> is the coefficient to the lagged variance.

Often you will want to use model output for some further analysis. It is therefore important to understand how to extract information such as the parameter estimates, their standard errors or the residuals. The object <code>ugfit</code> contains all the information. In that object you can find two drawers (or in technical speak slots, @fit and @model). Each of these drawers contains a range of different things. What they contain you can figure out by asking for the element names

<pre class="r">paste("Elements in the @model slot")</pre>
<pre>## [1] "Elements in the @model slot"</pre>
<pre class="r">names(ugfit@model)</pre>
<pre>## [1] "modelinc" "modeldesc" "modeldata" "pars" "start.pars"
## [6] "fixed.pars" "maxOrder" "pos.matrix" "fmodel" "pidx"
## [11] "n.start"</pre>
<pre class="r">paste("Elements in the @fit slot")</pre>
<pre>## [1] "Elements in the @fit slot"</pre>
<pre class="r">names(ugfit@fit)</pre>
<pre>## [1] "hessian" "cvar" "var"
## [4] "sigma" "condH" "z"
## [7] "LLH" "log.likelihoods" "residuals"
## [10] "coef" "robust.cvar" "A"
## [13] "B" "scores" "se.coef"
## [16] "tval" "matcoef" "robust.se.coef"
## [19] "robust.tval" "robust.matcoef" "fitted.values"
## [22] "convergence" "kappa" "persistence"
## [25] "timer" "ipars" "solver"</pre>
If you wanted to extract the estimated coefficients you would do that in the following way:

<pre class="r">ugfit@fit$coef</pre>
<pre>## mu ar1 omega alpha1 beta1
## 3.419000e-04 -1.346260e-02 1.516946e-05 1.111584e-01 8.095171e-01</pre>
<pre class="r">ug_var <- ugfit@fit$var # save the estimated conditional variances
ug_res2 <- (ugfit@fit$residuals)^2 # save the estimated squared residuals</pre>
Let's plot the squared residuals and the estimated conditional variance:

<pre class="r">plot(ug_res2, type = "l")
lines(ug_var, col = "green")</pre>
[[File:CondVar2.png]]

== Model Forecasting ==

Often you will want to use an estimated model to subsequently forecast the conditional variance. The function used for this purpose is the <code>ugarchforecast</code> function. The application is rather straightforward:

<pre class="r">ugfore <- ugarchforecast(ugfit, n.ahead = 10)
ugfore</pre>
<pre>##
## *------------------------------------*
## * GARCH Model Forecast *
## *------------------------------------*
## Model: sGARCH
## Horizon: 10
## Roll Steps: 0
## Out of Sample: 0
##
## 0-roll forecast [T0=2018-04-27]:
## Series Sigma
## T+1 0.0003685 0.01640
## T+2 0.0003415 0.01621
## T+3 0.0003419 0.01604
## T+4 0.0003419 0.01587
## T+5 0.0003419 0.01572
## T+6 0.0003419 0.01558
## T+7 0.0003419 0.01545
## T+8 0.0003419 0.01533
## T+9 0.0003419 0.01521
## T+10 0.0003419 0.01511</pre>
As you can see we have produced forecasts for the next ten days, both for the expected returns (<code>Series</code>) and for the conditional volatility (square root of the conditional variance). Similar to the object created for model fitting, <code>ugfore</code> contains two slots (@model and @forecast) and you can use <code>names(ugfore@forecast)</code> to figure out under which names the elements are saved. For instance you can extract the conditional volatility forecast as follows:

<pre class="r">ug_f <- ugfore@forecast$sigmaFor
plot(ug_f, type = "l")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-18-1.png]]

Note that the volatility is the square root of the conditional variance.

To put these forecasts into context let's display them together with the last 50 observations used in the estimation.

<pre class="r">ug_var_t <- c(tail(ug_var,20),rep(NA,10)) # gets the last 20 observations
ug_res2_t <- c(tail(ug_res2,20),rep(NA,10)) # gets the last 20 observations
ug_f <- c(rep(NA,20),(ug_f)^2)

plot(ug_res2_t, type = "l")
lines(ug_f, col = "orange")
lines(ug_var_t, col = "green")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-19-1.png]]

You can see how the forecast of the conditional variance picks up from the last estimated conditional variance. In fact it decreases from there, slowly, towards the unconditional variance value.

The <code>rugarch</code> package has a lot of additional functionality which you can explore through the documentation.

= Multivariate GARCH models =

Often you will want to model the volatility of a vector of assets. This can be done with the multivariate equivalent of the univariate GARCH model. Estimating multivariate GARCH models turns out to be significantly more difficult than univariate GARCH models, but fortunately procedures have been developed that deal with most of these issues.

Here we are using the <code>rmgarch</code> package which has a lot of useful functionality. We are applying it to estimate a multivariate volatility model for the returns of BP, Google/Alphabet and IBM shares.

As for the <code>rugarch</code> package we first need to specify the model we want to estimate. Here we stick with a Dynamic Conditional Correlation (DCC) model (see the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for details.). When estimating DCC models one basically estimates individual GARCH-type models (which could differ for each individual asset). These are then used to standardise the individual residuals. As a second step one then has to specify the correlation dynamics of these standardised residuals. It is possible to estimate the parameters of the univariate and the correlation model in one big swoop. however, my experience with this, and other packages, is that it is beneficial to separate the two steps.

== Model Setup ==

Here we assume that we are using the same univariate volatility model specification for each of the three assets.

<pre class="r"># DCC (MVN)
uspec.n = multispec(replicate(3, ugarchspec(mean.model = list(armaOrder = c(1,0)))))</pre>
What does this command do? You will recognise that <code>ugarchspec(mean.model = list(armaOrder = c(1,0)))</code> specifies an AR(1)-GARCH(1,1) model. By using <code>replicate(3, ugarchspec...)</code> we replicate this model 3 times (as we have three assets, IBM, Google/Alphabet and BP).

We now estimate these univariate GARCH models using the <code>multifit</code> command.

<pre class="r">multf = multifit(uspec.n, rX)</pre>
The results are saved in <code>multf</code> and you can type <code>multf</code> into the command window to see the estimated parameters for these three models. But we will here proceed to specify the DCC model (I assume that you know what a DCC model is. This is not the place to elaborate on this and many textbooks or indeed the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] to this package provide details). To specify the correlation specification we use the <code>dccspec</code> function.

<pre class="r">spec1 = dccspec(uspec = uspec.n, dccOrder = c(1, 1), distribution = 'mvnorm')</pre>
In this specification we have to state how the univariate volatilities are modeled (as per <code>uspec.n</code>) and how complex the dynamic structure of the correlation matrix is (here we are using the most standard <code>dccOrder = c(1, 1)</code> specification).

== Model Estimation ==

Now we are in a position to estimate the model using the <code>dccfit</code> function.

<pre class="r">fit1 = dccfit(spec1, data = rX, fit.control = list(eval.se = TRUE), fit = multf)</pre>
We want to estimate the model as specified in <code>spec1</code>, using the data in <code>rX</code>. The option <code>fit.control = list(eval.se = TRUE)</code> ensures that the estimation procedure produces standard errors for estimated parameters. Importantly <code>fit = multf</code> indicates that we ought to use the already estimated univariate models as they were saved in <code>multf</code>. The way to learn how to use these functions is by a combination of looking at the functions's help (<code>?dccfit</code>) and googling.

When you estimate a multivariate volatility model like the DCC model you are typically interested in the estimated covariance or correlation matrices. After all it is at the core of these models that you allow for time-variation in the correlation between the assets (there are also constant correlation models, but we do not discuss this here). Therefore we will now learn how we extract these.

<pre class="r"># Get the model based time varying covariance (arrays) and correlation matrices
cov1 = rcov(fit1) # extracts the covariance matrix
cor1 = rcor(fit1) # extracts the correlation matrix</pre>
To understand the object we have at our hands here we can have a look at the imension:

<pre class="r">dim(cor1)</pre>
<pre>## [1] 3 3 2850</pre>
We get three outputs which tells us that we have a three dimensional object. The firts two dimensions have 3 elements each (think a <math>3\times3</math> correlation matrix) and then there is a third dimension with 2850 elements. This tells us that <code>cor1</code> stores 2850 (<math>3\times3</math>) sorrelation matrices, one for each day of data.

Let's have a look at the correlation matrix for the last day, day 2853;

<pre class="r">cor1[,,dim(cor1)[3]]</pre>
<pre>## rIBM rBP rGOOG
## rIBM 1.0000000 0.2424297 0.353591
## rBP 0.2424297 1.0000000 0.275244
## rGOOG 0.3535910 0.2752440 1.000000</pre>
So let's say we want to plot the time-varying correlation between Google and BP, which is 0.275244 on that last day. In our matrix with returns <code>rX</code> BP is the second asset and Google the 3rd. So in any particular correlation matrix we want the element in row 2 and column 3.

<pre class="r">cor_BG <- cor1[2,1,] # leaving the last dimension empty implies that we want all elements
cor_BG <- as.xts(cor_BG) # imposes the xts time series format - useful for plotting</pre>
And now we plot this.

<pre class="r">plot(cor_BG)</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-28-1.png]]

If you transformed <code>cor_BG</code> to be a <code>xts</code> series the <code>plot</code> function automatically picks up the date information. As you can see there is significant variation through time with the correaltion typically varying between 0.2 and 0.5.

Let's plot all three correlations between the three assets.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
plot(as.xts(cor1[1,2,]),main="IBM and BP")
plot(as.xts(cor1[1,3,]),main="IBM and Google")
plot(as.xts(cor1[2,3,]),main="BP and Google")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-29-1.png]]

== Forecasts ==

Often you will want to use your estimated model to produce forecasts for the covariance or correlation matrix

<pre class="r">dccf1 <- dccforecast(fit1, n.ahead = 10)
dccf1</pre>
<pre>##
## *---------------------------------*
## * DCC GARCH Forecast *
## *---------------------------------*
##
## Distribution : mvnorm
## Model : DCC(1,1)
## Horizon : 10
## Roll Steps : 0
## -----------------------------------
##
## 0-roll forecast:
##
## First 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2539 0.3562
## [2,] 0.2539 1.0000 0.2883
## [3,] 0.3562 0.2883 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2658 0.3587
## [2,] 0.2658 1.0000 0.2909
## [3,] 0.3587 0.2909 1.0000
##
## . . .
## . . .
##
## Last 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3202 0.3703
## [2,] 0.3202 1.0000 0.3027
## [3,] 0.3703 0.3027 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3250 0.3714
## [2,] 0.3250 1.0000 0.3037
## [3,] 0.3714 0.3037 1.0000</pre>
The actual forecasts for the correlation can be addresse via

<pre class="r">Rf <- dccf1@mforecast$R # use H for the covariance forecast</pre>
When checking the structure of <code>Rf</code>

<pre class="r">str(Rf)</pre>
<pre>## List of 1
## $ : num [1:3, 1:3, 1:10] 1 0.254 0.356 0.254 1 ...</pre>
you realise that the object <code>Rf</code> is a list with one element. It turns out that this one list item is then a 3 dimensional matrix/array which contains the the 10 forecasts of <math>3 \times 3</math> correlation matrices. If we want to extract, say, the 10 forecasts for the correlation between IBM (1st asset) and BP (2nd asset), we have to do this in the following way:

<pre class="r">corf_IB <- Rf[[1]][1,2,] # Correlation forecasts between IBM and BP
corf_IG <- Rf[[1]][1,3,] # Correlation forecasts between IBM and Google
corf_BG <- Rf[[1]][2,3,] # Correlation forecasts between BP and Google</pre>
<code>[[1]]</code> tells R to go to the first (and here only) list item and then <code>[1,2,]</code> instructs R to select the (1,2) element of all available correlation matrices.

As for the univariate volatililty model let us display the forecast along with the last in-sample estimates of correlation.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
c_IB <- c(tail(cor1[1,2,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IB <- c(rep(NA,20),corf_IB) # gets the 10 forecasts
plot(c_IB,type = "l",main="Correlation IBM and BP")
lines(cf_IB,type = "l", col = "orange")

c_IG <- c(tail(cor1[1,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IG <- c(rep(NA,20),corf_IG) # gets the 10 forecasts
plot(c_IG,type = "l",main="Correlation IBM and Google")
lines(cf_IG,type = "l", col = "orange")

c_BG <- c(tail(cor1[2,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_BG <- c(rep(NA,20),corf_BG) # gets the 10 forecasts
plot(c_BG,type = "l",main="Correlation BP and Google")
lines(cf_BG,type = "l", col = "orange")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-34-1.png]]

= Further thoughts =

If you are looking at using pseudo-out-of sample forecasting (i.e. pretend to forecast values that actually have already occured) you should explore the <code>out.sample</code> option of the <code>dccfit</code> function.

The <code>rmgarch</code> package also allows you to estimate multivariate factor GARCH models and copula GARCH models (check the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for more details.

An alternative package with a slightly different set of multivariate volatility models is the `<code>ccgarch</code> package.

File:CondVar2.png

2018-05-03T23:16:24Z

Rb: Rb uploaded a new version of File:CondVar2.png

File:CondVar2.png

2018-05-03T23:15:56Z

Rb: Rb uploaded a new version of File:CondVar2.png

File:CondVar2.png

2018-05-03T23:14:47Z

Rb:

R GARCH

2018-05-03T23:13:04Z

Rb: /* Model Estimation */

= Introduction =

When you are dealing with financial time-series we often have relatively high frequency observations available. It is very common for instance to have daily observations available. In fact it is now possible to obtain hourly, minute, second or even millisecond observations. But here we will restrict ourselves to daily observations. For some assets these will be 7 days a week observations, but for others these will be work-day observations, so typically 5 days a week of observations.

= Packages used =

There are a number of packages that can enable us to estimate volatility models. The packages we will use are the <code>rugarch</code> for univariate GARCH models and the <code>rmgarch</code> (for multivariate models) package both written by Alexios Ghalanos. We shall also use the <code>quantmod</code> package as it will give us some easy access to some standard financial data.

So please ensure that you install these packes and then load them,

<pre class="r">#install.packages(c("quantmod","rugarch","rmgarch")) # only needed in case you have not yet installed these packages
library(quantmod)
library(rugarch)
library(rmgarch)</pre>
Next we set our working directory

<pre class="r"># replace with your directory and uncomment
# setwd("YOUR/COPLETE/DIRECTORY/PATH") </pre>
= Data upload =

Here we will use a convenient data retrieval function (<code>getSymbols</code>) delivered by the <code>quantmod</code> package in order to retrieve some data. This function works, for instance, to retrieve stock data. The default source is [https://finance.yahoo.com/ Yahoo Finance]. If you want to find out what stock has which symbol you should be able to search the internet to find a list of ticker symbols. The following shows how to use the function. But note that my experience is that sometimes the connection does not work and you may get an error message. In that case just retry a few seconds later and it may well work.

<pre class="r">startDate = as.Date("2007-01-03") #Specify period of time we are interested in
endDate = as.Date("2018-04-30")

getSymbols("IBM", from = startDate, to = endDate)</pre>
<pre>## [1] "IBM"</pre>
<pre class="r">getSymbols("GOOG", from = startDate, to = endDate)</pre>
<pre>## [1] "GOOG"</pre>
<pre class="r">getSymbols("BP", from = startDate, to = endDate)</pre>
<pre>## [1] "BP"</pre>
In your environment you can see that each of these commands loads an object with the respective ticker symbol name. Let's have a look at one of these dataframes to understand what data these are:

<pre class="r">head(IBM)</pre>
<pre>## IBM.Open IBM.High IBM.Low IBM.Close IBM.Volume IBM.Adjusted
## 2007-01-03 97.18 98.40 96.26 97.27 9196800 73.41806
## 2007-01-04 97.25 98.79 96.88 98.31 10524500 74.20306
## 2007-01-05 97.60 97.95 96.91 97.42 7221300 73.53130
## 2007-01-08 98.50 99.50 98.35 98.90 10340000 74.64834
## 2007-01-09 99.08 100.33 99.07 100.07 11108200 75.53147
## 2007-01-10 98.50 99.05 97.93 98.89 8744800 74.64082</pre>
<pre class="r">str(IBM)</pre>
<pre>## An 'xts' object on 2007-01-03/2018-04-27 containing:
## Data: num [1:2850, 1:6] 97.2 97.2 97.6 98.5 99.1 ...
## - attr(*, "dimnames")=List of 2
## ..$ : NULL
## ..$ : chr [1:6] "IBM.Open" "IBM.High" "IBM.Low" "IBM.Close" ...
## Indexed by objects of class: [Date] TZ: UTC
## xts Attributes:
## List of 2
## $ src : chr "yahoo"
## $ updated: POSIXct[1:1], format: "2018-05-03 22:21:00"</pre>
You can see that this object contains a range of daily observations (<code>Open</code>, <code>High</code>, <code>Close</code>, <code>Volume</code> and <code>Adjusted</code> share price). We also learn that the object is formatted as an <code>xts</code> object. <code>xts</code> is a type of time-series format and indeed we learn that the data range from 2007-01-03 to 2018-04-30.

You can in fact produce a somewhat fancy looking chart with the following command (also part of the <code>quantmod</code> package)

<pre class="r">chartSeries(GOOG)</pre>
[[File:GoogleChart1.png]]

When we are estimating volatility models we work with returns. There is a function that transforms the data to returns.

<pre class="r">rIBM <- dailyReturn(IBM)
rBP <- dailyReturn(BP)
rGOOG <- dailyReturn(GOOG)

# We put all data into a data frame for use in the multivariate model
rX <- data.frame(rIBM, rBP, rGOOG)
names(rX)[1] <- "rIBM"
names(rX)[2] <- "rBP"
names(rX)[3] <- "rGOOG"</pre>
There is also a <code>weeklyReturn</code> function in case that is what you are interested in.

= Univariate GARCH Model =

Here we are using the functionality provided by the <code>rugarch</code> package written by Alexios Galanos.

== Model Specification ==

The first thing you need to do is to ensure you know what type of GARCH model you want to estimate and then let R know about this. It is the <code>ugarchspec( )</code> function which is used to let R know about the model type. There is in fact a default specification and the way to invoke this is as follows

<pre class="r">ug_spec = ugarchspec()</pre>
<code>ug_spec</code> is now a list which contains all the relevant model specifications. Let's look at them:

<pre class="r">ug_spec</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Spec *
## *---------------------------------*
##
## Conditional Variance Dynamics
## ------------------------------------
## GARCH Model : sGARCH(1,1)
## Variance Targeting : FALSE
##
## Conditional Mean Dynamics
## ------------------------------------
## Mean Model : ARFIMA(1,0,1)
## Include Mean : TRUE
## GARCH-in-Mean : FALSE
##
## Conditional Distribution
## ------------------------------------
## Distribution : norm
## Includes Skew : FALSE
## Includes Shape : FALSE
## Includes Lambda : FALSE</pre>
The key issues here are the spec for the <code>Mean Model</code> (here an ARMA(1,1) model) and the specification for the <code>GARCH Model</code>, here an <code>sGARCH(1,1)</code> which is basically a GARCH(1,1). To get details on all the possible specifications and how to change them it is best to consult the [https://cran.r-project.org/web/packages/rugarch/vignettes/Introduction_to_the_rugarch_package.pdf documentation] of the <code>rugarch</code> package.

Let's say you want to change the mean model from an ARMA(1,1) to an ARMA(1,0), i.e. an AR(1) model.

<pre class="r">ug_spec <- ugarchspec(mean.model=list(armaOrder=c(1,0)))</pre>
You could call <code>ug_spec</code> again to check that the model specification has actually changed.

The following is the specification for an # an example of the EWMA Model (although we will not use it below).

<pre class="r">ewma_spec = ugarchspec(variance.model=list(model="iGARCH", garchOrder=c(1,1)),
mean.model=list(armaOrder=c(0,0), include.mean=TRUE),
distribution.model="norm", fixed.pars=list(omega=0))</pre>

== Model Estimation ==

Now that we have specified a model to estimate we need to find the best arameters, i.e. we need to estimate the model. This step is achieved by the <code>ugarchfit</code> function.

<pre class="r">ugfit = ugarchfit(spec = ug_spec, data = rIBM)</pre>
<code>fit</code> is now a list that contains a range of results from the estimation. Let's have a look at the results

<pre class="r">ugfit</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Fit *
## *---------------------------------*
##
## Conditional Variance Dynamics
## -----------------------------------
## GARCH Model : sGARCH(1,1)
## Mean Model : ARFIMA(1,0,0)
## Distribution : norm
##
## Optimal Parameters
## ------------------------------------
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000220 1.55666 0.11955
## ar1 -0.013463 0.021425 -0.62835 0.52978
## omega 0.000015 0.000002 6.56888 0.00000
## alpha1 0.111158 0.006440 17.25930 0.00000
## beta1 0.809517 0.005883 137.59775 0.00000
##
## Robust Standard Errors:
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000230 1.48654 0.137136
## ar1 -0.013463 0.019583 -0.68748 0.491782
## omega 0.000015 0.000012 1.25867 0.208150
## alpha1 0.111158 0.054637 2.03450 0.041901
## beta1 0.809517 0.082783 9.77876 0.000000
##
## LogLikelihood : 8364.692
##
## Information Criteria
## ------------------------------------
##
## Akaike -5.8665
## Bayes -5.8560
## Shibata -5.8665
## Hannan-Quinn -5.8627
##
## Weighted Ljung-Box Test on Standardized Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.03483 0.8519
## Lag[2*(p+q)+(p+q)-1][2] 0.03492 1.0000
## Lag[4*(p+q)+(p+q)-1][5] 1.39601 0.8712
## d.o.f=1
## H0 : No serial correlation
##
## Weighted Ljung-Box Test on Standardized Squared Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.2509 0.6165
## Lag[2*(p+q)+(p+q)-1][5] 1.2795 0.7938
## Lag[4*(p+q)+(p+q)-1][9] 1.9518 0.9107
## d.o.f=2
##
## Weighted ARCH LM Tests
## ------------------------------------
## Statistic Shape Scale P-Value
## ARCH Lag[3] 1.295 0.500 2.000 0.2551
## ARCH Lag[5] 1.603 1.440 1.667 0.5656
## ARCH Lag[7] 1.935 2.315 1.543 0.7312
##
## Nyblom stability test
## ------------------------------------
## Joint Statistic: 26.6709
## Individual Statistics:
## mu 0.42613
## ar1 0.06712
## omega 0.89209
## alpha1 0.55216
## beta1 0.15390
##
## Asymptotic Critical Values (10% 5% 1%)
## Joint Statistic: 1.28 1.47 1.88
## Individual Statistic: 0.35 0.47 0.75
##
## Sign Bias Test
## ------------------------------------
## t-value prob sig
## Sign Bias 0.2134 0.8310
## Negative Sign Bias 1.0137 0.3108
## Positive Sign Bias 0.4427 0.6580
## Joint Effect 1.6909 0.6390
##
##
## Adjusted Pearson Goodness-of-Fit Test:
## ------------------------------------
## group statistic p-value(g-1)
## 1 20 135.6 1.285e-19
## 2 30 139.3 2.301e-16
## 3 40 161.8 6.871e-17
## 4 50 166.2 1.164e-14
##
##
## Elapsed time : 0.7440431</pre>
If you are familiar with GARCH models you will recognise some of the parameters. <code>ar1</code> is the AR1 coefficient of the mean model (here very small and basically insignificant), <code>alpha1</code> is the coefficient to the squared residuals in the GARCH equation and <code>beta1</code> is the coefficient to the lagged variance.

Often you will want to use model output for some further analysis. It is therefore important to understand how to extract information such as the parameter estimates, their standard errors or the residuals. The object <code>ugfit</code> contains all the information. In that object you can find two drawers (or in technical speak slots, @fit and @model). Each of these drawers contains a range of different things. What they contain you can figure out by asking for the element names

<pre class="r">paste("Elements in the @model slot")</pre>
<pre>## [1] "Elements in the @model slot"</pre>
<pre class="r">names(ugfit@model)</pre>
<pre>## [1] "modelinc" "modeldesc" "modeldata" "pars" "start.pars"
## [6] "fixed.pars" "maxOrder" "pos.matrix" "fmodel" "pidx"
## [11] "n.start"</pre>
<pre class="r">paste("Elements in the @fit slot")</pre>
<pre>## [1] "Elements in the @fit slot"</pre>
<pre class="r">names(ugfit@fit)</pre>
<pre>## [1] "hessian" "cvar" "var"
## [4] "sigma" "condH" "z"
## [7] "LLH" "log.likelihoods" "residuals"
## [10] "coef" "robust.cvar" "A"
## [13] "B" "scores" "se.coef"
## [16] "tval" "matcoef" "robust.se.coef"
## [19] "robust.tval" "robust.matcoef" "fitted.values"
## [22] "convergence" "kappa" "persistence"
## [25] "timer" "ipars" "solver"</pre>
If you wanted to extract the estimated coefficients you would do that in the following way:

<pre class="r">ugfit@fit$coef</pre>
<pre>## mu ar1 omega alpha1 beta1
## 3.419000e-04 -1.346260e-02 1.516946e-05 1.111584e-01 8.095171e-01</pre>
<pre class="r">ug_var <- ugfit@fit$var # save the estimated conditional variances
ug_res2 <- (ugfit@fit$residuals)^2 # save the estimated squared residuals</pre>
Let's plot the squared residuals and the estimated conditional variance:

<pre class="r">plot(ug_res2, type = "l")
lines(ug_var, col = "green")</pre>
[[File:GarchModelling_files/figure-html/CondVar2.png]]

== Model Forecasting ==

Often you will want to use an estimated model to subsequently forecast the conditional variance. The function used for this purpose is the <code>ugarchforecast</code> function. The application is rather straightforward:

<pre class="r">ugfore <- ugarchforecast(ugfit, n.ahead = 10)
ugfore</pre>
<pre>##
## *------------------------------------*
## * GARCH Model Forecast *
## *------------------------------------*
## Model: sGARCH
## Horizon: 10
## Roll Steps: 0
## Out of Sample: 0
##
## 0-roll forecast [T0=2018-04-27]:
## Series Sigma
## T+1 0.0003685 0.01640
## T+2 0.0003415 0.01621
## T+3 0.0003419 0.01604
## T+4 0.0003419 0.01587
## T+5 0.0003419 0.01572
## T+6 0.0003419 0.01558
## T+7 0.0003419 0.01545
## T+8 0.0003419 0.01533
## T+9 0.0003419 0.01521
## T+10 0.0003419 0.01511</pre>
As you can see we have produced forecasts for the next ten days, both for the expected returns (<code>Series</code>) and for the conditional volatility (square root of the conditional variance). Similar to the object created for model fitting, <code>ugfore</code> contains two slots (@model and @forecast) and you can use <code>names(ugfore@forecast)</code> to figure out under which names the elements are saved. For instance you can extract the conditional volatility forecast as follows:

<pre class="r">ug_f <- ugfore@forecast$sigmaFor
plot(ug_f, type = "l")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-18-1.png]]

Note that the volatility is the square root of the conditional variance.

To put these forecasts into context let's display them together with the last 50 observations used in the estimation.

<pre class="r">ug_var_t <- c(tail(ug_var,20),rep(NA,10)) # gets the last 20 observations
ug_res2_t <- c(tail(ug_res2,20),rep(NA,10)) # gets the last 20 observations
ug_f <- c(rep(NA,20),(ug_f)^2)

plot(ug_res2_t, type = "l")
lines(ug_f, col = "orange")
lines(ug_var_t, col = "green")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-19-1.png]]

You can see how the forecast of the conditional variance picks up from the last estimated conditional variance. In fact it decreases from there, slowly, towards the unconditional variance value.

The <code>rugarch</code> package has a lot of additional functionality which you can explore through the documentation.

= Multivariate GARCH models =

Often you will want to model the volatility of a vector of assets. This can be done with the multivariate equivalent of the univariate GARCH model. Estimating multivariate GARCH models turns out to be significantly more difficult than univariate GARCH models, but fortunately procedures have been developed that deal with most of these issues.

Here we are using the <code>rmgarch</code> package which has a lot of useful functionality. We are applying it to estimate a multivariate volatility model for the returns of BP, Google/Alphabet and IBM shares.

As for the <code>rugarch</code> package we first need to specify the model we want to estimate. Here we stick with a Dynamic Conditional Correlation (DCC) model (see the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for details.). When estimating DCC models one basically estimates individual GARCH-type models (which could differ for each individual asset). These are then used to standardise the individual residuals. As a second step one then has to specify the correlation dynamics of these standardised residuals. It is possible to estimate the parameters of the univariate and the correlation model in one big swoop. however, my experience with this, and other packages, is that it is beneficial to separate the two steps.

== Model Setup ==

Here we assume that we are using the same univariate volatility model specification for each of the three assets.

<pre class="r"># DCC (MVN)
uspec.n = multispec(replicate(3, ugarchspec(mean.model = list(armaOrder = c(1,0)))))</pre>
What does this command do? You will recognise that <code>ugarchspec(mean.model = list(armaOrder = c(1,0)))</code> specifies an AR(1)-GARCH(1,1) model. By using <code>replicate(3, ugarchspec...)</code> we replicate this model 3 times (as we have three assets, IBM, Google/Alphabet and BP).

We now estimate these univariate GARCH models using the <code>multifit</code> command.

<pre class="r">multf = multifit(uspec.n, rX)</pre>
The results are saved in <code>multf</code> and you can type <code>multf</code> into the command window to see the estimated parameters for these three models. But we will here proceed to specify the DCC model (I assume that you know what a DCC model is. This is not the place to elaborate on this and many textbooks or indeed the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] to this package provide details). To specify the correlation specification we use the <code>dccspec</code> function.

<pre class="r">spec1 = dccspec(uspec = uspec.n, dccOrder = c(1, 1), distribution = 'mvnorm')</pre>
In this specification we have to state how the univariate volatilities are modeled (as per <code>uspec.n</code>) and how complex the dynamic structure of the correlation matrix is (here we are using the most standard <code>dccOrder = c(1, 1)</code> specification).

== Model Estimation ==

Now we are in a position to estimate the model using the <code>dccfit</code> function.

<pre class="r">fit1 = dccfit(spec1, data = rX, fit.control = list(eval.se = TRUE), fit = multf)</pre>
We want to estimate the model as specified in <code>spec1</code>, using the data in <code>rX</code>. The option <code>fit.control = list(eval.se = TRUE)</code> ensures that the estimation procedure produces standard errors for estimated parameters. Importantly <code>fit = multf</code> indicates that we ought to use the already estimated univariate models as they were saved in <code>multf</code>. The way to learn how to use these functions is by a combination of looking at the functions's help (<code>?dccfit</code>) and googling.

When you estimate a multivariate volatility model like the DCC model you are typically interested in the estimated covariance or correlation matrices. After all it is at the core of these models that you allow for time-variation in the correlation between the assets (there are also constant correlation models, but we do not discuss this here). Therefore we will now learn how we extract these.

<pre class="r"># Get the model based time varying covariance (arrays) and correlation matrices
cov1 = rcov(fit1) # extracts the covariance matrix
cor1 = rcor(fit1) # extracts the correlation matrix</pre>
To understand the object we have at our hands here we can have a look at the imension:

<pre class="r">dim(cor1)</pre>
<pre>## [1] 3 3 2850</pre>
We get three outputs which tells us that we have a three dimensional object. The firts two dimensions have 3 elements each (think a <math>3\times3</math> correlation matrix) and then there is a third dimension with 2850 elements. This tells us that <code>cor1</code> stores 2850 (<math>3\times3</math>) sorrelation matrices, one for each day of data.

Let's have a look at the correlation matrix for the last day, day 2853;

<pre class="r">cor1[,,dim(cor1)[3]]</pre>
<pre>## rIBM rBP rGOOG
## rIBM 1.0000000 0.2424297 0.353591
## rBP 0.2424297 1.0000000 0.275244
## rGOOG 0.3535910 0.2752440 1.000000</pre>
So let's say we want to plot the time-varying correlation between Google and BP, which is 0.275244 on that last day. In our matrix with returns <code>rX</code> BP is the second asset and Google the 3rd. So in any particular correlation matrix we want the element in row 2 and column 3.

<pre class="r">cor_BG <- cor1[2,1,] # leaving the last dimension empty implies that we want all elements
cor_BG <- as.xts(cor_BG) # imposes the xts time series format - useful for plotting</pre>
And now we plot this.

<pre class="r">plot(cor_BG)</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-28-1.png]]

If you transformed <code>cor_BG</code> to be a <code>xts</code> series the <code>plot</code> function automatically picks up the date information. As you can see there is significant variation through time with the correaltion typically varying between 0.2 and 0.5.

Let's plot all three correlations between the three assets.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
plot(as.xts(cor1[1,2,]),main="IBM and BP")
plot(as.xts(cor1[1,3,]),main="IBM and Google")
plot(as.xts(cor1[2,3,]),main="BP and Google")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-29-1.png]]

== Forecasts ==

Often you will want to use your estimated model to produce forecasts for the covariance or correlation matrix

<pre class="r">dccf1 <- dccforecast(fit1, n.ahead = 10)
dccf1</pre>
<pre>##
## *---------------------------------*
## * DCC GARCH Forecast *
## *---------------------------------*
##
## Distribution : mvnorm
## Model : DCC(1,1)
## Horizon : 10
## Roll Steps : 0
## -----------------------------------
##
## 0-roll forecast:
##
## First 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2539 0.3562
## [2,] 0.2539 1.0000 0.2883
## [3,] 0.3562 0.2883 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2658 0.3587
## [2,] 0.2658 1.0000 0.2909
## [3,] 0.3587 0.2909 1.0000
##
## . . .
## . . .
##
## Last 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3202 0.3703
## [2,] 0.3202 1.0000 0.3027
## [3,] 0.3703 0.3027 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3250 0.3714
## [2,] 0.3250 1.0000 0.3037
## [3,] 0.3714 0.3037 1.0000</pre>
The actual forecasts for the correlation can be addresse via

<pre class="r">Rf <- dccf1@mforecast$R # use H for the covariance forecast</pre>
When checking the structure of <code>Rf</code>

<pre class="r">str(Rf)</pre>
<pre>## List of 1
## $ : num [1:3, 1:3, 1:10] 1 0.254 0.356 0.254 1 ...</pre>
you realise that the object <code>Rf</code> is a list with one element. It turns out that this one list item is then a 3 dimensional matrix/array which contains the the 10 forecasts of <math>3 \times 3</math> correlation matrices. If we want to extract, say, the 10 forecasts for the correlation between IBM (1st asset) and BP (2nd asset), we have to do this in the following way:

<pre class="r">corf_IB <- Rf[[1]][1,2,] # Correlation forecasts between IBM and BP
corf_IG <- Rf[[1]][1,3,] # Correlation forecasts between IBM and Google
corf_BG <- Rf[[1]][2,3,] # Correlation forecasts between BP and Google</pre>
<code>[[1]]</code> tells R to go to the first (and here only) list item and then <code>[1,2,]</code> instructs R to select the (1,2) element of all available correlation matrices.

As for the univariate volatililty model let us display the forecast along with the last in-sample estimates of correlation.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
c_IB <- c(tail(cor1[1,2,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IB <- c(rep(NA,20),corf_IB) # gets the 10 forecasts
plot(c_IB,type = "l",main="Correlation IBM and BP")
lines(cf_IB,type = "l", col = "orange")

c_IG <- c(tail(cor1[1,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IG <- c(rep(NA,20),corf_IG) # gets the 10 forecasts
plot(c_IG,type = "l",main="Correlation IBM and Google")
lines(cf_IG,type = "l", col = "orange")

c_BG <- c(tail(cor1[2,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_BG <- c(rep(NA,20),corf_BG) # gets the 10 forecasts
plot(c_BG,type = "l",main="Correlation BP and Google")
lines(cf_BG,type = "l", col = "orange")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-34-1.png]]

= Further thoughts =

If you are looking at using pseudo-out-of sample forecasting (i.e. pretend to forecast values that actually have already occured) you should explore the <code>out.sample</code> option of the <code>dccfit</code> function.

The <code>rmgarch</code> package also allows you to estimate multivariate factor GARCH models and copula GARCH models (check the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for more details.

An alternative package with a slightly different set of multivariate volatility models is the `<code>ccgarch</code> package.

R GARCH

2018-05-03T23:11:24Z

Rb: /* Model Specification */

= Introduction =

When you are dealing with financial time-series we often have relatively high frequency observations available. It is very common for instance to have daily observations available. In fact it is now possible to obtain hourly, minute, second or even millisecond observations. But here we will restrict ourselves to daily observations. For some assets these will be 7 days a week observations, but for others these will be work-day observations, so typically 5 days a week of observations.

= Packages used =

There are a number of packages that can enable us to estimate volatility models. The packages we will use are the <code>rugarch</code> for univariate GARCH models and the <code>rmgarch</code> (for multivariate models) package both written by Alexios Ghalanos. We shall also use the <code>quantmod</code> package as it will give us some easy access to some standard financial data.

So please ensure that you install these packes and then load them,

<pre class="r">#install.packages(c("quantmod","rugarch","rmgarch")) # only needed in case you have not yet installed these packages
library(quantmod)
library(rugarch)
library(rmgarch)</pre>
Next we set our working directory

<pre class="r"># replace with your directory and uncomment
# setwd("YOUR/COPLETE/DIRECTORY/PATH") </pre>
= Data upload =

Here we will use a convenient data retrieval function (<code>getSymbols</code>) delivered by the <code>quantmod</code> package in order to retrieve some data. This function works, for instance, to retrieve stock data. The default source is [https://finance.yahoo.com/ Yahoo Finance]. If you want to find out what stock has which symbol you should be able to search the internet to find a list of ticker symbols. The following shows how to use the function. But note that my experience is that sometimes the connection does not work and you may get an error message. In that case just retry a few seconds later and it may well work.

<pre class="r">startDate = as.Date("2007-01-03") #Specify period of time we are interested in
endDate = as.Date("2018-04-30")

getSymbols("IBM", from = startDate, to = endDate)</pre>
<pre>## [1] "IBM"</pre>
<pre class="r">getSymbols("GOOG", from = startDate, to = endDate)</pre>
<pre>## [1] "GOOG"</pre>
<pre class="r">getSymbols("BP", from = startDate, to = endDate)</pre>
<pre>## [1] "BP"</pre>
In your environment you can see that each of these commands loads an object with the respective ticker symbol name. Let's have a look at one of these dataframes to understand what data these are:

<pre class="r">head(IBM)</pre>
<pre>## IBM.Open IBM.High IBM.Low IBM.Close IBM.Volume IBM.Adjusted
## 2007-01-03 97.18 98.40 96.26 97.27 9196800 73.41806
## 2007-01-04 97.25 98.79 96.88 98.31 10524500 74.20306
## 2007-01-05 97.60 97.95 96.91 97.42 7221300 73.53130
## 2007-01-08 98.50 99.50 98.35 98.90 10340000 74.64834
## 2007-01-09 99.08 100.33 99.07 100.07 11108200 75.53147
## 2007-01-10 98.50 99.05 97.93 98.89 8744800 74.64082</pre>
<pre class="r">str(IBM)</pre>
<pre>## An 'xts' object on 2007-01-03/2018-04-27 containing:
## Data: num [1:2850, 1:6] 97.2 97.2 97.6 98.5 99.1 ...
## - attr(*, "dimnames")=List of 2
## ..$ : NULL
## ..$ : chr [1:6] "IBM.Open" "IBM.High" "IBM.Low" "IBM.Close" ...
## Indexed by objects of class: [Date] TZ: UTC
## xts Attributes:
## List of 2
## $ src : chr "yahoo"
## $ updated: POSIXct[1:1], format: "2018-05-03 22:21:00"</pre>
You can see that this object contains a range of daily observations (<code>Open</code>, <code>High</code>, <code>Close</code>, <code>Volume</code> and <code>Adjusted</code> share price). We also learn that the object is formatted as an <code>xts</code> object. <code>xts</code> is a type of time-series format and indeed we learn that the data range from 2007-01-03 to 2018-04-30.

You can in fact produce a somewhat fancy looking chart with the following command (also part of the <code>quantmod</code> package)

<pre class="r">chartSeries(GOOG)</pre>
[[File:GoogleChart1.png]]

When we are estimating volatility models we work with returns. There is a function that transforms the data to returns.

<pre class="r">rIBM <- dailyReturn(IBM)
rBP <- dailyReturn(BP)
rGOOG <- dailyReturn(GOOG)

# We put all data into a data frame for use in the multivariate model
rX <- data.frame(rIBM, rBP, rGOOG)
names(rX)[1] <- "rIBM"
names(rX)[2] <- "rBP"
names(rX)[3] <- "rGOOG"</pre>
There is also a <code>weeklyReturn</code> function in case that is what you are interested in.

= Univariate GARCH Model =

Here we are using the functionality provided by the <code>rugarch</code> package written by Alexios Galanos.

== Model Specification ==

The first thing you need to do is to ensure you know what type of GARCH model you want to estimate and then let R know about this. It is the <code>ugarchspec( )</code> function which is used to let R know about the model type. There is in fact a default specification and the way to invoke this is as follows

<pre class="r">ug_spec = ugarchspec()</pre>
<code>ug_spec</code> is now a list which contains all the relevant model specifications. Let's look at them:

<pre class="r">ug_spec</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Spec *
## *---------------------------------*
##
## Conditional Variance Dynamics
## ------------------------------------
## GARCH Model : sGARCH(1,1)
## Variance Targeting : FALSE
##
## Conditional Mean Dynamics
## ------------------------------------
## Mean Model : ARFIMA(1,0,1)
## Include Mean : TRUE
## GARCH-in-Mean : FALSE
##
## Conditional Distribution
## ------------------------------------
## Distribution : norm
## Includes Skew : FALSE
## Includes Shape : FALSE
## Includes Lambda : FALSE</pre>
The key issues here are the spec for the <code>Mean Model</code> (here an ARMA(1,1) model) and the specification for the <code>GARCH Model</code>, here an <code>sGARCH(1,1)</code> which is basically a GARCH(1,1). To get details on all the possible specifications and how to change them it is best to consult the [https://cran.r-project.org/web/packages/rugarch/vignettes/Introduction_to_the_rugarch_package.pdf documentation] of the <code>rugarch</code> package.

Let's say you want to change the mean model from an ARMA(1,1) to an ARMA(1,0), i.e. an AR(1) model.

<pre class="r">ug_spec <- ugarchspec(mean.model=list(armaOrder=c(1,0)))</pre>
You could call <code>ug_spec</code> again to check that the model specification has actually changed.

The following is the specification for an # an example of the EWMA Model (although we will not use it below).

<pre class="r">ewma_spec = ugarchspec(variance.model=list(model="iGARCH", garchOrder=c(1,1)),
mean.model=list(armaOrder=c(0,0), include.mean=TRUE),
distribution.model="norm", fixed.pars=list(omega=0))</pre>

== Model Estimation ==

Now that we have specified a model to estimate we need to find the best arameters, i.e. we need to estimate the model. This step is achieved by the <code>ugarchfit</code> function.

<pre class="r">ugfit = ugarchfit(spec = ug_spec, data = rIBM)</pre>
<code>fit</code> is now a list that contains a range of results from the estimation. Let's have a look at the results

<pre class="r">ugfit</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Fit *
## *---------------------------------*
##
## Conditional Variance Dynamics
## -----------------------------------
## GARCH Model : sGARCH(1,1)
## Mean Model : ARFIMA(1,0,0)
## Distribution : norm
##
## Optimal Parameters
## ------------------------------------
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000220 1.55666 0.11955
## ar1 -0.013463 0.021425 -0.62835 0.52978
## omega 0.000015 0.000002 6.56888 0.00000
## alpha1 0.111158 0.006440 17.25930 0.00000
## beta1 0.809517 0.005883 137.59775 0.00000
##
## Robust Standard Errors:
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000230 1.48654 0.137136
## ar1 -0.013463 0.019583 -0.68748 0.491782
## omega 0.000015 0.000012 1.25867 0.208150
## alpha1 0.111158 0.054637 2.03450 0.041901
## beta1 0.809517 0.082783 9.77876 0.000000
##
## LogLikelihood : 8364.692
##
## Information Criteria
## ------------------------------------
##
## Akaike -5.8665
## Bayes -5.8560
## Shibata -5.8665
## Hannan-Quinn -5.8627
##
## Weighted Ljung-Box Test on Standardized Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.03483 0.8519
## Lag[2*(p+q)+(p+q)-1][2] 0.03492 1.0000
## Lag[4*(p+q)+(p+q)-1][5] 1.39601 0.8712
## d.o.f=1
## H0 : No serial correlation
##
## Weighted Ljung-Box Test on Standardized Squared Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.2509 0.6165
## Lag[2*(p+q)+(p+q)-1][5] 1.2795 0.7938
## Lag[4*(p+q)+(p+q)-1][9] 1.9518 0.9107
## d.o.f=2
##
## Weighted ARCH LM Tests
## ------------------------------------
## Statistic Shape Scale P-Value
## ARCH Lag[3] 1.295 0.500 2.000 0.2551
## ARCH Lag[5] 1.603 1.440 1.667 0.5656
## ARCH Lag[7] 1.935 2.315 1.543 0.7312
##
## Nyblom stability test
## ------------------------------------
## Joint Statistic: 26.6709
## Individual Statistics:
## mu 0.42613
## ar1 0.06712
## omega 0.89209
## alpha1 0.55216
## beta1 0.15390
##
## Asymptotic Critical Values (10% 5% 1%)
## Joint Statistic: 1.28 1.47 1.88
## Individual Statistic: 0.35 0.47 0.75
##
## Sign Bias Test
## ------------------------------------
## t-value prob sig
## Sign Bias 0.2134 0.8310
## Negative Sign Bias 1.0137 0.3108
## Positive Sign Bias 0.4427 0.6580
## Joint Effect 1.6909 0.6390
##
##
## Adjusted Pearson Goodness-of-Fit Test:
## ------------------------------------
## group statistic p-value(g-1)
## 1 20 135.6 1.285e-19
## 2 30 139.3 2.301e-16
## 3 40 161.8 6.871e-17
## 4 50 166.2 1.164e-14
##
##
## Elapsed time : 0.7440431</pre>
If you are familiar with GARCH models you will recognise some of the parameters. <code>ar1</code> is the AR1 coefficient of the mean model (here very small and basically insignificant), <code>alpha1</code> is the coefficient to the squared residuals in the GARCH equation and <code>beta1</code> is the coefficient to the lagged variance.

Often you will want to use model output for some further analysis. It is therefore important to understand how to extract information such as the parameter estimates, their standard errors or the residuals. The object <code>ugfit</code> contains all the information. In that object you can find two drawers (or in technical speak slots, @fit and @model). Each of these drawers contains a range of different things. What they contain you can figure out by asking for the element names

<pre class="r">paste("Elements in the @model slot")</pre>
<pre>## [1] "Elements in the @model slot"</pre>
<pre class="r">names(ugfit@model)</pre>
<pre>## [1] "modelinc" "modeldesc" "modeldata" "pars" "start.pars"
## [6] "fixed.pars" "maxOrder" "pos.matrix" "fmodel" "pidx"
## [11] "n.start"</pre>
<pre class="r">paste("Elements in the @fit slot")</pre>
<pre>## [1] "Elements in the @fit slot"</pre>
<pre class="r">names(ugfit@fit)</pre>
<pre>## [1] "hessian" "cvar" "var"
## [4] "sigma" "condH" "z"
## [7] "LLH" "log.likelihoods" "residuals"
## [10] "coef" "robust.cvar" "A"
## [13] "B" "scores" "se.coef"
## [16] "tval" "matcoef" "robust.se.coef"
## [19] "robust.tval" "robust.matcoef" "fitted.values"
## [22] "convergence" "kappa" "persistence"
## [25] "timer" "ipars" "solver"</pre>
If you wanted to extract the estimated coefficients you would do that in the following way:

<pre class="r">ugfit@fit$coef</pre>
<pre>## mu ar1 omega alpha1 beta1
## 3.419000e-04 -1.346260e-02 1.516946e-05 1.111584e-01 8.095171e-01</pre>
<pre class="r">ug_var <- ugfit@fit$var # save the estimated conditional variances
ug_res2 <- (ugfit@fit$residuals)^2 # save the estimated squared residuals</pre>
Let's plot the squared residuals and the estimated conditional variance:

<pre class="r">plot(ug_res2, type = "l")
lines(ug_var, col = "green")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-16-1.png]]

== Model Forecasting ==

Often you will want to use an estimated model to subsequently forecast the conditional variance. The function used for this purpose is the <code>ugarchforecast</code> function. The application is rather straightforward:

<pre class="r">ugfore <- ugarchforecast(ugfit, n.ahead = 10)
ugfore</pre>
<pre>##
## *------------------------------------*
## * GARCH Model Forecast *
## *------------------------------------*
## Model: sGARCH
## Horizon: 10
## Roll Steps: 0
## Out of Sample: 0
##
## 0-roll forecast [T0=2018-04-27]:
## Series Sigma
## T+1 0.0003685 0.01640
## T+2 0.0003415 0.01621
## T+3 0.0003419 0.01604
## T+4 0.0003419 0.01587
## T+5 0.0003419 0.01572
## T+6 0.0003419 0.01558
## T+7 0.0003419 0.01545
## T+8 0.0003419 0.01533
## T+9 0.0003419 0.01521
## T+10 0.0003419 0.01511</pre>
As you can see we have produced forecasts for the next ten days, both for the expected returns (<code>Series</code>) and for the conditional volatility (square root of the conditional variance). Similar to the object created for model fitting, <code>ugfore</code> contains two slots (@model and @forecast) and you can use <code>names(ugfore@forecast)</code> to figure out under which names the elements are saved. For instance you can extract the conditional volatility forecast as follows:

<pre class="r">ug_f <- ugfore@forecast$sigmaFor
plot(ug_f, type = "l")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-18-1.png]]

Note that the volatility is the square root of the conditional variance.

To put these forecasts into context let's display them together with the last 50 observations used in the estimation.

<pre class="r">ug_var_t <- c(tail(ug_var,20),rep(NA,10)) # gets the last 20 observations
ug_res2_t <- c(tail(ug_res2,20),rep(NA,10)) # gets the last 20 observations
ug_f <- c(rep(NA,20),(ug_f)^2)

plot(ug_res2_t, type = "l")
lines(ug_f, col = "orange")
lines(ug_var_t, col = "green")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-19-1.png]]

You can see how the forecast of the conditional variance picks up from the last estimated conditional variance. In fact it decreases from there, slowly, towards the unconditional variance value.

The <code>rugarch</code> package has a lot of additional functionality which you can explore through the documentation.

= Multivariate GARCH models =

Often you will want to model the volatility of a vector of assets. This can be done with the multivariate equivalent of the univariate GARCH model. Estimating multivariate GARCH models turns out to be significantly more difficult than univariate GARCH models, but fortunately procedures have been developed that deal with most of these issues.

Here we are using the <code>rmgarch</code> package which has a lot of useful functionality. We are applying it to estimate a multivariate volatility model for the returns of BP, Google/Alphabet and IBM shares.

As for the <code>rugarch</code> package we first need to specify the model we want to estimate. Here we stick with a Dynamic Conditional Correlation (DCC) model (see the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for details.). When estimating DCC models one basically estimates individual GARCH-type models (which could differ for each individual asset). These are then used to standardise the individual residuals. As a second step one then has to specify the correlation dynamics of these standardised residuals. It is possible to estimate the parameters of the univariate and the correlation model in one big swoop. however, my experience with this, and other packages, is that it is beneficial to separate the two steps.

== Model Setup ==

Here we assume that we are using the same univariate volatility model specification for each of the three assets.

<pre class="r"># DCC (MVN)
uspec.n = multispec(replicate(3, ugarchspec(mean.model = list(armaOrder = c(1,0)))))</pre>
What does this command do? You will recognise that <code>ugarchspec(mean.model = list(armaOrder = c(1,0)))</code> specifies an AR(1)-GARCH(1,1) model. By using <code>replicate(3, ugarchspec...)</code> we replicate this model 3 times (as we have three assets, IBM, Google/Alphabet and BP).

We now estimate these univariate GARCH models using the <code>multifit</code> command.

<pre class="r">multf = multifit(uspec.n, rX)</pre>
The results are saved in <code>multf</code> and you can type <code>multf</code> into the command window to see the estimated parameters for these three models. But we will here proceed to specify the DCC model (I assume that you know what a DCC model is. This is not the place to elaborate on this and many textbooks or indeed the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] to this package provide details). To specify the correlation specification we use the <code>dccspec</code> function.

<pre class="r">spec1 = dccspec(uspec = uspec.n, dccOrder = c(1, 1), distribution = 'mvnorm')</pre>
In this specification we have to state how the univariate volatilities are modeled (as per <code>uspec.n</code>) and how complex the dynamic structure of the correlation matrix is (here we are using the most standard <code>dccOrder = c(1, 1)</code> specification).

== Model Estimation ==

Now we are in a position to estimate the model using the <code>dccfit</code> function.

<pre class="r">fit1 = dccfit(spec1, data = rX, fit.control = list(eval.se = TRUE), fit = multf)</pre>
We want to estimate the model as specified in <code>spec1</code>, using the data in <code>rX</code>. The option <code>fit.control = list(eval.se = TRUE)</code> ensures that the estimation procedure produces standard errors for estimated parameters. Importantly <code>fit = multf</code> indicates that we ought to use the already estimated univariate models as they were saved in <code>multf</code>. The way to learn how to use these functions is by a combination of looking at the functions's help (<code>?dccfit</code>) and googling.

When you estimate a multivariate volatility model like the DCC model you are typically interested in the estimated covariance or correlation matrices. After all it is at the core of these models that you allow for time-variation in the correlation between the assets (there are also constant correlation models, but we do not discuss this here). Therefore we will now learn how we extract these.

<pre class="r"># Get the model based time varying covariance (arrays) and correlation matrices
cov1 = rcov(fit1) # extracts the covariance matrix
cor1 = rcor(fit1) # extracts the correlation matrix</pre>
To understand the object we have at our hands here we can have a look at the imension:

<pre class="r">dim(cor1)</pre>
<pre>## [1] 3 3 2850</pre>
We get three outputs which tells us that we have a three dimensional object. The firts two dimensions have 3 elements each (think a <math>3\times3</math> correlation matrix) and then there is a third dimension with 2850 elements. This tells us that <code>cor1</code> stores 2850 (<math>3\times3</math>) sorrelation matrices, one for each day of data.

Let's have a look at the correlation matrix for the last day, day 2853;

<pre class="r">cor1[,,dim(cor1)[3]]</pre>
<pre>## rIBM rBP rGOOG
## rIBM 1.0000000 0.2424297 0.353591
## rBP 0.2424297 1.0000000 0.275244
## rGOOG 0.3535910 0.2752440 1.000000</pre>
So let's say we want to plot the time-varying correlation between Google and BP, which is 0.275244 on that last day. In our matrix with returns <code>rX</code> BP is the second asset and Google the 3rd. So in any particular correlation matrix we want the element in row 2 and column 3.

<pre class="r">cor_BG <- cor1[2,1,] # leaving the last dimension empty implies that we want all elements
cor_BG <- as.xts(cor_BG) # imposes the xts time series format - useful for plotting</pre>
And now we plot this.

<pre class="r">plot(cor_BG)</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-28-1.png]]

If you transformed <code>cor_BG</code> to be a <code>xts</code> series the <code>plot</code> function automatically picks up the date information. As you can see there is significant variation through time with the correaltion typically varying between 0.2 and 0.5.

Let's plot all three correlations between the three assets.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
plot(as.xts(cor1[1,2,]),main="IBM and BP")
plot(as.xts(cor1[1,3,]),main="IBM and Google")
plot(as.xts(cor1[2,3,]),main="BP and Google")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-29-1.png]]

== Forecasts ==

Often you will want to use your estimated model to produce forecasts for the covariance or correlation matrix

<pre class="r">dccf1 <- dccforecast(fit1, n.ahead = 10)
dccf1</pre>
<pre>##
## *---------------------------------*
## * DCC GARCH Forecast *
## *---------------------------------*
##
## Distribution : mvnorm
## Model : DCC(1,1)
## Horizon : 10
## Roll Steps : 0
## -----------------------------------
##
## 0-roll forecast:
##
## First 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2539 0.3562
## [2,] 0.2539 1.0000 0.2883
## [3,] 0.3562 0.2883 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2658 0.3587
## [2,] 0.2658 1.0000 0.2909
## [3,] 0.3587 0.2909 1.0000
##
## . . .
## . . .
##
## Last 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3202 0.3703
## [2,] 0.3202 1.0000 0.3027
## [3,] 0.3703 0.3027 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3250 0.3714
## [2,] 0.3250 1.0000 0.3037
## [3,] 0.3714 0.3037 1.0000</pre>
The actual forecasts for the correlation can be addresse via

<pre class="r">Rf <- dccf1@mforecast$R # use H for the covariance forecast</pre>
When checking the structure of <code>Rf</code>

<pre class="r">str(Rf)</pre>
<pre>## List of 1
## $ : num [1:3, 1:3, 1:10] 1 0.254 0.356 0.254 1 ...</pre>
you realise that the object <code>Rf</code> is a list with one element. It turns out that this one list item is then a 3 dimensional matrix/array which contains the the 10 forecasts of <math>3 \times 3</math> correlation matrices. If we want to extract, say, the 10 forecasts for the correlation between IBM (1st asset) and BP (2nd asset), we have to do this in the following way:

<pre class="r">corf_IB <- Rf[[1]][1,2,] # Correlation forecasts between IBM and BP
corf_IG <- Rf[[1]][1,3,] # Correlation forecasts between IBM and Google
corf_BG <- Rf[[1]][2,3,] # Correlation forecasts between BP and Google</pre>
<code>[[1]]</code> tells R to go to the first (and here only) list item and then <code>[1,2,]</code> instructs R to select the (1,2) element of all available correlation matrices.

As for the univariate volatililty model let us display the forecast along with the last in-sample estimates of correlation.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
c_IB <- c(tail(cor1[1,2,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IB <- c(rep(NA,20),corf_IB) # gets the 10 forecasts
plot(c_IB,type = "l",main="Correlation IBM and BP")
lines(cf_IB,type = "l", col = "orange")

c_IG <- c(tail(cor1[1,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IG <- c(rep(NA,20),corf_IG) # gets the 10 forecasts
plot(c_IG,type = "l",main="Correlation IBM and Google")
lines(cf_IG,type = "l", col = "orange")

c_BG <- c(tail(cor1[2,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_BG <- c(rep(NA,20),corf_BG) # gets the 10 forecasts
plot(c_BG,type = "l",main="Correlation BP and Google")
lines(cf_BG,type = "l", col = "orange")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-34-1.png]]

= Further thoughts =

If you are looking at using pseudo-out-of sample forecasting (i.e. pretend to forecast values that actually have already occured) you should explore the <code>out.sample</code> option of the <code>dccfit</code> function.

The <code>rmgarch</code> package also allows you to estimate multivariate factor GARCH models and copula GARCH models (check the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for more details.

An alternative package with a slightly different set of multivariate volatility models is the `<code>ccgarch</code> package.

R GARCH

2018-05-03T23:10:49Z

Rb: /* Data upload */

= Introduction =

When you are dealing with financial time-series we often have relatively high frequency observations available. It is very common for instance to have daily observations available. In fact it is now possible to obtain hourly, minute, second or even millisecond observations. But here we will restrict ourselves to daily observations. For some assets these will be 7 days a week observations, but for others these will be work-day observations, so typically 5 days a week of observations.

= Packages used =

There are a number of packages that can enable us to estimate volatility models. The packages we will use are the <code>rugarch</code> for univariate GARCH models and the <code>rmgarch</code> (for multivariate models) package both written by Alexios Ghalanos. We shall also use the <code>quantmod</code> package as it will give us some easy access to some standard financial data.

So please ensure that you install these packes and then load them,

<pre class="r">#install.packages(c("quantmod","rugarch","rmgarch")) # only needed in case you have not yet installed these packages
library(quantmod)
library(rugarch)
library(rmgarch)</pre>
Next we set our working directory

<pre class="r"># replace with your directory and uncomment
# setwd("YOUR/COPLETE/DIRECTORY/PATH") </pre>
= Data upload =

Here we will use a convenient data retrieval function (<code>getSymbols</code>) delivered by the <code>quantmod</code> package in order to retrieve some data. This function works, for instance, to retrieve stock data. The default source is [https://finance.yahoo.com/ Yahoo Finance]. If you want to find out what stock has which symbol you should be able to search the internet to find a list of ticker symbols. The following shows how to use the function. But note that my experience is that sometimes the connection does not work and you may get an error message. In that case just retry a few seconds later and it may well work.

<pre class="r">startDate = as.Date("2007-01-03") #Specify period of time we are interested in
endDate = as.Date("2018-04-30")

getSymbols("IBM", from = startDate, to = endDate)</pre>
<pre>## [1] "IBM"</pre>
<pre class="r">getSymbols("GOOG", from = startDate, to = endDate)</pre>
<pre>## [1] "GOOG"</pre>
<pre class="r">getSymbols("BP", from = startDate, to = endDate)</pre>
<pre>## [1] "BP"</pre>
In your environment you can see that each of these commands loads an object with the respective ticker symbol name. Let's have a look at one of these dataframes to understand what data these are:

<pre class="r">head(IBM)</pre>
<pre>## IBM.Open IBM.High IBM.Low IBM.Close IBM.Volume IBM.Adjusted
## 2007-01-03 97.18 98.40 96.26 97.27 9196800 73.41806
## 2007-01-04 97.25 98.79 96.88 98.31 10524500 74.20306
## 2007-01-05 97.60 97.95 96.91 97.42 7221300 73.53130
## 2007-01-08 98.50 99.50 98.35 98.90 10340000 74.64834
## 2007-01-09 99.08 100.33 99.07 100.07 11108200 75.53147
## 2007-01-10 98.50 99.05 97.93 98.89 8744800 74.64082</pre>
<pre class="r">str(IBM)</pre>
<pre>## An 'xts' object on 2007-01-03/2018-04-27 containing:
## Data: num [1:2850, 1:6] 97.2 97.2 97.6 98.5 99.1 ...
## - attr(*, "dimnames")=List of 2
## ..$ : NULL
## ..$ : chr [1:6] "IBM.Open" "IBM.High" "IBM.Low" "IBM.Close" ...
## Indexed by objects of class: [Date] TZ: UTC
## xts Attributes:
## List of 2
## $ src : chr "yahoo"
## $ updated: POSIXct[1:1], format: "2018-05-03 22:21:00"</pre>
You can see that this object contains a range of daily observations (<code>Open</code>, <code>High</code>, <code>Close</code>, <code>Volume</code> and <code>Adjusted</code> share price). We also learn that the object is formatted as an <code>xts</code> object. <code>xts</code> is a type of time-series format and indeed we learn that the data range from 2007-01-03 to 2018-04-30.

You can in fact produce a somewhat fancy looking chart with the following command (also part of the <code>quantmod</code> package)

<pre class="r">chartSeries(GOOG)</pre>
[[File:GoogleChart1.png]]

When we are estimating volatility models we work with returns. There is a function that transforms the data to returns.

<pre class="r">rIBM <- dailyReturn(IBM)
rBP <- dailyReturn(BP)
rGOOG <- dailyReturn(GOOG)

# We put all data into a data frame for use in the multivariate model
rX <- data.frame(rIBM, rBP, rGOOG)
names(rX)[1] <- "rIBM"
names(rX)[2] <- "rBP"
names(rX)[3] <- "rGOOG"</pre>
There is also a <code>weeklyReturn</code> function in case that is what you are interested in.

= Univariate GARCH Model =

Here we are using the functionality provided by the <code>rugarch</code> package written by Alexios Galanos.

== Model Specification ==

The first thing you need to do is to ensure you know what type of GARCH model you want to estimate and then let R know about this. It is the <code>ugarchspec( )</code> function which is used to let R know about the model type. There is in fact a default specification and the way to invoke this is as follows

<pre class="r">ug_spec = ugarchspec()</pre>
<code>ug_spec</code> is now a list which contains all the relevant model specifications. Let's look at them:

<pre class="r">ug_spec</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Spec *
## *---------------------------------*
##
## Conditional Variance Dynamics
## ------------------------------------
## GARCH Model : sGARCH(1,1)
## Variance Targeting : FALSE
##
## Conditional Mean Dynamics
## ------------------------------------
## Mean Model : ARFIMA(1,0,1)
## Include Mean : TRUE
## GARCH-in-Mean : FALSE
##
## Conditional Distribution
## ------------------------------------
## Distribution : norm
## Includes Skew : FALSE
## Includes Shape : FALSE
## Includes Lambda : FALSE</pre>
The key issues here are the spec for the <code>Mean Model</code> (here an ARMA(1,1) model) and the specification for the <code>GARCH Model</code>, here an <code>sGARCH(1,1)</code> which is basically a GARCH(1,1). To get details on all the possible specifications and how to change them it is best to consult the [https://cran.r-project.org/web/packages/rugarch/vignettes/Introduction_to_the_rugarch_package.pdf documentation] of the <code>rugarch</code> package.

Let's say you want to change the mean model from an ARMA(1,1) to an ARMA(1,0), i.e. an AR(1) model.

<pre class="r">ug_spec <- ugarchspec(mean.model=list(armaOrder=c(1,0)))</pre>
You could call <code>ug_spec</code> again to check that the model specification has actually changed.

The following is the specification for an # an example of the EWMA Model (although we will not se it below).

<pre class="r">ewma_spec = ugarchspec(variance.model=list(model="iGARCH", garchOrder=c(1,1)),
mean.model=list(armaOrder=c(0,0), include.mean=TRUE),
distribution.model="norm", fixed.pars=list(omega=0))</pre>
== Model Estimation ==

Now that we have specified a model to estimate we need to find the best arameters, i.e. we need to estimate the model. This step is achieved by the <code>ugarchfit</code> function.

<pre class="r">ugfit = ugarchfit(spec = ug_spec, data = rIBM)</pre>
<code>fit</code> is now a list that contains a range of results from the estimation. Let's have a look at the results

<pre class="r">ugfit</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Fit *
## *---------------------------------*
##
## Conditional Variance Dynamics
## -----------------------------------
## GARCH Model : sGARCH(1,1)
## Mean Model : ARFIMA(1,0,0)
## Distribution : norm
##
## Optimal Parameters
## ------------------------------------
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000220 1.55666 0.11955
## ar1 -0.013463 0.021425 -0.62835 0.52978
## omega 0.000015 0.000002 6.56888 0.00000
## alpha1 0.111158 0.006440 17.25930 0.00000
## beta1 0.809517 0.005883 137.59775 0.00000
##
## Robust Standard Errors:
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000230 1.48654 0.137136
## ar1 -0.013463 0.019583 -0.68748 0.491782
## omega 0.000015 0.000012 1.25867 0.208150
## alpha1 0.111158 0.054637 2.03450 0.041901
## beta1 0.809517 0.082783 9.77876 0.000000
##
## LogLikelihood : 8364.692
##
## Information Criteria
## ------------------------------------
##
## Akaike -5.8665
## Bayes -5.8560
## Shibata -5.8665
## Hannan-Quinn -5.8627
##
## Weighted Ljung-Box Test on Standardized Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.03483 0.8519
## Lag[2*(p+q)+(p+q)-1][2] 0.03492 1.0000
## Lag[4*(p+q)+(p+q)-1][5] 1.39601 0.8712
## d.o.f=1
## H0 : No serial correlation
##
## Weighted Ljung-Box Test on Standardized Squared Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.2509 0.6165
## Lag[2*(p+q)+(p+q)-1][5] 1.2795 0.7938
## Lag[4*(p+q)+(p+q)-1][9] 1.9518 0.9107
## d.o.f=2
##
## Weighted ARCH LM Tests
## ------------------------------------
## Statistic Shape Scale P-Value
## ARCH Lag[3] 1.295 0.500 2.000 0.2551
## ARCH Lag[5] 1.603 1.440 1.667 0.5656
## ARCH Lag[7] 1.935 2.315 1.543 0.7312
##
## Nyblom stability test
## ------------------------------------
## Joint Statistic: 26.6709
## Individual Statistics:
## mu 0.42613
## ar1 0.06712
## omega 0.89209
## alpha1 0.55216
## beta1 0.15390
##
## Asymptotic Critical Values (10% 5% 1%)
## Joint Statistic: 1.28 1.47 1.88
## Individual Statistic: 0.35 0.47 0.75
##
## Sign Bias Test
## ------------------------------------
## t-value prob sig
## Sign Bias 0.2134 0.8310
## Negative Sign Bias 1.0137 0.3108
## Positive Sign Bias 0.4427 0.6580
## Joint Effect 1.6909 0.6390
##
##
## Adjusted Pearson Goodness-of-Fit Test:
## ------------------------------------
## group statistic p-value(g-1)
## 1 20 135.6 1.285e-19
## 2 30 139.3 2.301e-16
## 3 40 161.8 6.871e-17
## 4 50 166.2 1.164e-14
##
##
## Elapsed time : 0.7440431</pre>
If you are familiar with GARCH models you will recognise some of the parameters. <code>ar1</code> is the AR1 coefficient of the mean model (here very small and basically insignificant), <code>alpha1</code> is the coefficient to the squared residuals in the GARCH equation and <code>beta1</code> is the coefficient to the lagged variance.

Often you will want to use model output for some further analysis. It is therefore important to understand how to extract information such as the parameter estimates, their standard errors or the residuals. The object <code>ugfit</code> contains all the information. In that object you can find two drawers (or in technical speak slots, @fit and @model). Each of these drawers contains a range of different things. What they contain you can figure out by asking for the element names

<pre class="r">paste("Elements in the @model slot")</pre>
<pre>## [1] "Elements in the @model slot"</pre>
<pre class="r">names(ugfit@model)</pre>
<pre>## [1] "modelinc" "modeldesc" "modeldata" "pars" "start.pars"
## [6] "fixed.pars" "maxOrder" "pos.matrix" "fmodel" "pidx"
## [11] "n.start"</pre>
<pre class="r">paste("Elements in the @fit slot")</pre>
<pre>## [1] "Elements in the @fit slot"</pre>
<pre class="r">names(ugfit@fit)</pre>
<pre>## [1] "hessian" "cvar" "var"
## [4] "sigma" "condH" "z"
## [7] "LLH" "log.likelihoods" "residuals"
## [10] "coef" "robust.cvar" "A"
## [13] "B" "scores" "se.coef"
## [16] "tval" "matcoef" "robust.se.coef"
## [19] "robust.tval" "robust.matcoef" "fitted.values"
## [22] "convergence" "kappa" "persistence"
## [25] "timer" "ipars" "solver"</pre>
If you wanted to extract the estimated coefficients you would do that in the following way:

<pre class="r">ugfit@fit$coef</pre>
<pre>## mu ar1 omega alpha1 beta1
## 3.419000e-04 -1.346260e-02 1.516946e-05 1.111584e-01 8.095171e-01</pre>
<pre class="r">ug_var <- ugfit@fit$var # save the estimated conditional variances
ug_res2 <- (ugfit@fit$residuals)^2 # save the estimated squared residuals</pre>
Let's plot the squared residuals and the estimated conditional variance:

<pre class="r">plot(ug_res2, type = "l")
lines(ug_var, col = "green")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-16-1.png]]

== Model Forecasting ==

Often you will want to use an estimated model to subsequently forecast the conditional variance. The function used for this purpose is the <code>ugarchforecast</code> function. The application is rather straightforward:

<pre class="r">ugfore <- ugarchforecast(ugfit, n.ahead = 10)
ugfore</pre>
<pre>##
## *------------------------------------*
## * GARCH Model Forecast *
## *------------------------------------*
## Model: sGARCH
## Horizon: 10
## Roll Steps: 0
## Out of Sample: 0
##
## 0-roll forecast [T0=2018-04-27]:
## Series Sigma
## T+1 0.0003685 0.01640
## T+2 0.0003415 0.01621
## T+3 0.0003419 0.01604
## T+4 0.0003419 0.01587
## T+5 0.0003419 0.01572
## T+6 0.0003419 0.01558
## T+7 0.0003419 0.01545
## T+8 0.0003419 0.01533
## T+9 0.0003419 0.01521
## T+10 0.0003419 0.01511</pre>
As you can see we have produced forecasts for the next ten days, both for the expected returns (<code>Series</code>) and for the conditional volatility (square root of the conditional variance). Similar to the object created for model fitting, <code>ugfore</code> contains two slots (@model and @forecast) and you can use <code>names(ugfore@forecast)</code> to figure out under which names the elements are saved. For instance you can extract the conditional volatility forecast as follows:

<pre class="r">ug_f <- ugfore@forecast$sigmaFor
plot(ug_f, type = "l")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-18-1.png]]

Note that the volatility is the square root of the conditional variance.

To put these forecasts into context let's display them together with the last 50 observations used in the estimation.

<pre class="r">ug_var_t <- c(tail(ug_var,20),rep(NA,10)) # gets the last 20 observations
ug_res2_t <- c(tail(ug_res2,20),rep(NA,10)) # gets the last 20 observations
ug_f <- c(rep(NA,20),(ug_f)^2)

plot(ug_res2_t, type = "l")
lines(ug_f, col = "orange")
lines(ug_var_t, col = "green")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-19-1.png]]

You can see how the forecast of the conditional variance picks up from the last estimated conditional variance. In fact it decreases from there, slowly, towards the unconditional variance value.

The <code>rugarch</code> package has a lot of additional functionality which you can explore through the documentation.

= Multivariate GARCH models =

Often you will want to model the volatility of a vector of assets. This can be done with the multivariate equivalent of the univariate GARCH model. Estimating multivariate GARCH models turns out to be significantly more difficult than univariate GARCH models, but fortunately procedures have been developed that deal with most of these issues.

Here we are using the <code>rmgarch</code> package which has a lot of useful functionality. We are applying it to estimate a multivariate volatility model for the returns of BP, Google/Alphabet and IBM shares.

As for the <code>rugarch</code> package we first need to specify the model we want to estimate. Here we stick with a Dynamic Conditional Correlation (DCC) model (see the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for details.). When estimating DCC models one basically estimates individual GARCH-type models (which could differ for each individual asset). These are then used to standardise the individual residuals. As a second step one then has to specify the correlation dynamics of these standardised residuals. It is possible to estimate the parameters of the univariate and the correlation model in one big swoop. however, my experience with this, and other packages, is that it is beneficial to separate the two steps.

== Model Setup ==

Here we assume that we are using the same univariate volatility model specification for each of the three assets.

<pre class="r"># DCC (MVN)
uspec.n = multispec(replicate(3, ugarchspec(mean.model = list(armaOrder = c(1,0)))))</pre>
What does this command do? You will recognise that <code>ugarchspec(mean.model = list(armaOrder = c(1,0)))</code> specifies an AR(1)-GARCH(1,1) model. By using <code>replicate(3, ugarchspec...)</code> we replicate this model 3 times (as we have three assets, IBM, Google/Alphabet and BP).

We now estimate these univariate GARCH models using the <code>multifit</code> command.

<pre class="r">multf = multifit(uspec.n, rX)</pre>
The results are saved in <code>multf</code> and you can type <code>multf</code> into the command window to see the estimated parameters for these three models. But we will here proceed to specify the DCC model (I assume that you know what a DCC model is. This is not the place to elaborate on this and many textbooks or indeed the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] to this package provide details). To specify the correlation specification we use the <code>dccspec</code> function.

<pre class="r">spec1 = dccspec(uspec = uspec.n, dccOrder = c(1, 1), distribution = 'mvnorm')</pre>
In this specification we have to state how the univariate volatilities are modeled (as per <code>uspec.n</code>) and how complex the dynamic structure of the correlation matrix is (here we are using the most standard <code>dccOrder = c(1, 1)</code> specification).

== Model Estimation ==

Now we are in a position to estimate the model using the <code>dccfit</code> function.

<pre class="r">fit1 = dccfit(spec1, data = rX, fit.control = list(eval.se = TRUE), fit = multf)</pre>
We want to estimate the model as specified in <code>spec1</code>, using the data in <code>rX</code>. The option <code>fit.control = list(eval.se = TRUE)</code> ensures that the estimation procedure produces standard errors for estimated parameters. Importantly <code>fit = multf</code> indicates that we ought to use the already estimated univariate models as they were saved in <code>multf</code>. The way to learn how to use these functions is by a combination of looking at the functions's help (<code>?dccfit</code>) and googling.

When you estimate a multivariate volatility model like the DCC model you are typically interested in the estimated covariance or correlation matrices. After all it is at the core of these models that you allow for time-variation in the correlation between the assets (there are also constant correlation models, but we do not discuss this here). Therefore we will now learn how we extract these.

<pre class="r"># Get the model based time varying covariance (arrays) and correlation matrices
cov1 = rcov(fit1) # extracts the covariance matrix
cor1 = rcor(fit1) # extracts the correlation matrix</pre>
To understand the object we have at our hands here we can have a look at the imension:

<pre class="r">dim(cor1)</pre>
<pre>## [1] 3 3 2850</pre>
We get three outputs which tells us that we have a three dimensional object. The firts two dimensions have 3 elements each (think a <math>3\times3</math> correlation matrix) and then there is a third dimension with 2850 elements. This tells us that <code>cor1</code> stores 2850 (<math>3\times3</math>) sorrelation matrices, one for each day of data.

Let's have a look at the correlation matrix for the last day, day 2853;

<pre class="r">cor1[,,dim(cor1)[3]]</pre>
<pre>## rIBM rBP rGOOG
## rIBM 1.0000000 0.2424297 0.353591
## rBP 0.2424297 1.0000000 0.275244
## rGOOG 0.3535910 0.2752440 1.000000</pre>
So let's say we want to plot the time-varying correlation between Google and BP, which is 0.275244 on that last day. In our matrix with returns <code>rX</code> BP is the second asset and Google the 3rd. So in any particular correlation matrix we want the element in row 2 and column 3.

<pre class="r">cor_BG <- cor1[2,1,] # leaving the last dimension empty implies that we want all elements
cor_BG <- as.xts(cor_BG) # imposes the xts time series format - useful for plotting</pre>
And now we plot this.

<pre class="r">plot(cor_BG)</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-28-1.png]]

If you transformed <code>cor_BG</code> to be a <code>xts</code> series the <code>plot</code> function automatically picks up the date information. As you can see there is significant variation through time with the correaltion typically varying between 0.2 and 0.5.

Let's plot all three correlations between the three assets.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
plot(as.xts(cor1[1,2,]),main="IBM and BP")
plot(as.xts(cor1[1,3,]),main="IBM and Google")
plot(as.xts(cor1[2,3,]),main="BP and Google")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-29-1.png]]

== Forecasts ==

Often you will want to use your estimated model to produce forecasts for the covariance or correlation matrix

<pre class="r">dccf1 <- dccforecast(fit1, n.ahead = 10)
dccf1</pre>
<pre>##
## *---------------------------------*
## * DCC GARCH Forecast *
## *---------------------------------*
##
## Distribution : mvnorm
## Model : DCC(1,1)
## Horizon : 10
## Roll Steps : 0
## -----------------------------------
##
## 0-roll forecast:
##
## First 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2539 0.3562
## [2,] 0.2539 1.0000 0.2883
## [3,] 0.3562 0.2883 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2658 0.3587
## [2,] 0.2658 1.0000 0.2909
## [3,] 0.3587 0.2909 1.0000
##
## . . .
## . . .
##
## Last 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3202 0.3703
## [2,] 0.3202 1.0000 0.3027
## [3,] 0.3703 0.3027 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3250 0.3714
## [2,] 0.3250 1.0000 0.3037
## [3,] 0.3714 0.3037 1.0000</pre>
The actual forecasts for the correlation can be addresse via

<pre class="r">Rf <- dccf1@mforecast$R # use H for the covariance forecast</pre>
When checking the structure of <code>Rf</code>

<pre class="r">str(Rf)</pre>
<pre>## List of 1
## $ : num [1:3, 1:3, 1:10] 1 0.254 0.356 0.254 1 ...</pre>
you realise that the object <code>Rf</code> is a list with one element. It turns out that this one list item is then a 3 dimensional matrix/array which contains the the 10 forecasts of <math>3 \times 3</math> correlation matrices. If we want to extract, say, the 10 forecasts for the correlation between IBM (1st asset) and BP (2nd asset), we have to do this in the following way:

<pre class="r">corf_IB <- Rf[[1]][1,2,] # Correlation forecasts between IBM and BP
corf_IG <- Rf[[1]][1,3,] # Correlation forecasts between IBM and Google
corf_BG <- Rf[[1]][2,3,] # Correlation forecasts between BP and Google</pre>
<code>[[1]]</code> tells R to go to the first (and here only) list item and then <code>[1,2,]</code> instructs R to select the (1,2) element of all available correlation matrices.

As for the univariate volatililty model let us display the forecast along with the last in-sample estimates of correlation.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
c_IB <- c(tail(cor1[1,2,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IB <- c(rep(NA,20),corf_IB) # gets the 10 forecasts
plot(c_IB,type = "l",main="Correlation IBM and BP")
lines(cf_IB,type = "l", col = "orange")

c_IG <- c(tail(cor1[1,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IG <- c(rep(NA,20),corf_IG) # gets the 10 forecasts
plot(c_IG,type = "l",main="Correlation IBM and Google")
lines(cf_IG,type = "l", col = "orange")

c_BG <- c(tail(cor1[2,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_BG <- c(rep(NA,20),corf_BG) # gets the 10 forecasts
plot(c_BG,type = "l",main="Correlation BP and Google")
lines(cf_BG,type = "l", col = "orange")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-34-1.png]]

= Further thoughts =

If you are looking at using pseudo-out-of sample forecasting (i.e. pretend to forecast values that actually have already occured) you should explore the <code>out.sample</code> option of the <code>dccfit</code> function.

The <code>rmgarch</code> package also allows you to estimate multivariate factor GARCH models and copula GARCH models (check the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for more details.

An alternative package with a slightly different set of multivariate volatility models is the `<code>ccgarch</code> package.

File:GoogleChart1.png

2018-05-03T23:06:34Z

Rb:

R GARCH

2018-05-03T23:05:29Z

Rb: /* Data upload */

= Introduction =

When you are dealing with financial time-series we often have relatively high frequency observations available. It is very common for instance to have daily observations available. In fact it is now possible to obtain hourly, minute, second or even millisecond observations. But here we will restrict ourselves to daily observations. For some assets these will be 7 days a week observations, but for others these will be work-day observations, so typically 5 days a week of observations.

= Packages used =

There are a number of packages that can enable us to estimate volatility models. The packages we will use are the <code>rugarch</code> for univariate GARCH models and the <code>rmgarch</code> (for multivariate models) package both written by Alexios Ghalanos. We shall also use the <code>quantmod</code> package as it will give us some easy access to some standard financial data.

So please ensure that you install these packes and then load them,

<pre class="r">#install.packages(c("quantmod","rugarch","rmgarch")) # only needed in case you have not yet installed these packages
library(quantmod)
library(rugarch)
library(rmgarch)</pre>
Next we set our working directory

<pre class="r"># replace with your directory and uncomment
# setwd("YOUR/COPLETE/DIRECTORY/PATH") </pre>
= Data upload =

Here we will use a convenient data retrieval function (<code>getSymbols</code>) delivered by the <code>quantmod</code> package in order to retrieve some data. This function works, for instance, to retrieve stock data. The default source is [https://finance.yahoo.com/ Yahoo Finance]. If you want to find out what stock has which symbol you should be able to search the internet to find a list of ticker symbols. The following shows how to use the function. But note that my experience is that sometimes the connection does not work and you may get an error message. In that case just retry a few seconds later and it may well work.

<pre class="r">startDate = as.Date("2007-01-03") #Specify period of time we are interested in
endDate = as.Date("2018-04-30")

getSymbols("IBM", from = startDate, to = endDate)</pre>
<pre>## [1] "IBM"</pre>
<pre class="r">getSymbols("GOOG", from = startDate, to = endDate)</pre>
<pre>## [1] "GOOG"</pre>
<pre class="r">getSymbols("BP", from = startDate, to = endDate)</pre>
<pre>## [1] "BP"</pre>
In your environment you can see that each of these commands loads an object with the respective ticker symbol name. Let's have a look at one of these dataframes to understand what data these are:

<pre class="r">head(IBM)</pre>
<pre>## IBM.Open IBM.High IBM.Low IBM.Close IBM.Volume IBM.Adjusted
## 2007-01-03 97.18 98.40 96.26 97.27 9196800 73.41806
## 2007-01-04 97.25 98.79 96.88 98.31 10524500 74.20306
## 2007-01-05 97.60 97.95 96.91 97.42 7221300 73.53130
## 2007-01-08 98.50 99.50 98.35 98.90 10340000 74.64834
## 2007-01-09 99.08 100.33 99.07 100.07 11108200 75.53147
## 2007-01-10 98.50 99.05 97.93 98.89 8744800 74.64082</pre>
<pre class="r">str(IBM)</pre>
<pre>## An 'xts' object on 2007-01-03/2018-04-27 containing:
## Data: num [1:2850, 1:6] 97.2 97.2 97.6 98.5 99.1 ...
## - attr(*, "dimnames")=List of 2
## ..$ : NULL
## ..$ : chr [1:6] "IBM.Open" "IBM.High" "IBM.Low" "IBM.Close" ...
## Indexed by objects of class: [Date] TZ: UTC
## xts Attributes:
## List of 2
## $ src : chr "yahoo"
## $ updated: POSIXct[1:1], format: "2018-05-03 22:21:00"</pre>
You can see that this object contains a range of daily observations (<code>Open</code>, <code>High</code>, <code>Close</code>, <code>Volume</code> and <code>Adjusted</code> share price). We also learn that the object is formatted as an <code>xts</code> object. <code>xts</code> is a type of time-series format and indeed we learn that the data range from 2007-01-03 to 2018-04-30.

You can in fact produce a somewhat fancy looking chart with the following command (also part of the <code>quantmod</code> package)

<pre class="r">chartSeries(GOOG)</pre>
[[File:GarchModelling_files/figure-html/GoogleChart1.png]]

When we are estimating volatility models we work with returns. There is a function that transforms the data to returns.

<pre class="r">rIBM <- dailyReturn(IBM)
rBP <- dailyReturn(BP)
rGOOG <- dailyReturn(GOOG)

# We put all data into a data frame for use in the multivariate model
rX <- data.frame(rIBM, rBP, rGOOG)
names(rX)[1] <- "rIBM"
names(rX)[2] <- "rBP"
names(rX)[3] <- "rGOOG"</pre>
There is also a <code>weeklyReturn</code> function in case that is what you are interested in.

= Univariate GARCH Model =

Here we are using the functionality provided by the <code>rugarch</code> package written by Alexios Galanos.

== Model Specification ==

The first thing you need to do is to ensure you know what type of GARCH model you want to estimate and then let R know about this. It is the <code>ugarchspec( )</code> function which is used to let R know about the model type. There is in fact a default specification and the way to invoke this is as follows

<pre class="r">ug_spec = ugarchspec()</pre>
<code>ug_spec</code> is now a list which contains all the relevant model specifications. Let's look at them:

<pre class="r">ug_spec</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Spec *
## *---------------------------------*
##
## Conditional Variance Dynamics
## ------------------------------------
## GARCH Model : sGARCH(1,1)
## Variance Targeting : FALSE
##
## Conditional Mean Dynamics
## ------------------------------------
## Mean Model : ARFIMA(1,0,1)
## Include Mean : TRUE
## GARCH-in-Mean : FALSE
##
## Conditional Distribution
## ------------------------------------
## Distribution : norm
## Includes Skew : FALSE
## Includes Shape : FALSE
## Includes Lambda : FALSE</pre>
The key issues here are the spec for the <code>Mean Model</code> (here an ARMA(1,1) model) and the specification for the <code>GARCH Model</code>, here an <code>sGARCH(1,1)</code> which is basically a GARCH(1,1). To get details on all the possible specifications and how to change them it is best to consult the [https://cran.r-project.org/web/packages/rugarch/vignettes/Introduction_to_the_rugarch_package.pdf documentation] of the <code>rugarch</code> package.

Let's say you want to change the mean model from an ARMA(1,1) to an ARMA(1,0), i.e. an AR(1) model.

<pre class="r">ug_spec <- ugarchspec(mean.model=list(armaOrder=c(1,0)))</pre>
You could call <code>ug_spec</code> again to check that the model specification has actually changed.

The following is the specification for an # an example of the EWMA Model (although we will not se it below).

<pre class="r">ewma_spec = ugarchspec(variance.model=list(model="iGARCH", garchOrder=c(1,1)),
mean.model=list(armaOrder=c(0,0), include.mean=TRUE),
distribution.model="norm", fixed.pars=list(omega=0))</pre>
== Model Estimation ==

Now that we have specified a model to estimate we need to find the best arameters, i.e. we need to estimate the model. This step is achieved by the <code>ugarchfit</code> function.

<pre class="r">ugfit = ugarchfit(spec = ug_spec, data = rIBM)</pre>
<code>fit</code> is now a list that contains a range of results from the estimation. Let's have a look at the results

<pre class="r">ugfit</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Fit *
## *---------------------------------*
##
## Conditional Variance Dynamics
## -----------------------------------
## GARCH Model : sGARCH(1,1)
## Mean Model : ARFIMA(1,0,0)
## Distribution : norm
##
## Optimal Parameters
## ------------------------------------
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000220 1.55666 0.11955
## ar1 -0.013463 0.021425 -0.62835 0.52978
## omega 0.000015 0.000002 6.56888 0.00000
## alpha1 0.111158 0.006440 17.25930 0.00000
## beta1 0.809517 0.005883 137.59775 0.00000
##
## Robust Standard Errors:
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000230 1.48654 0.137136
## ar1 -0.013463 0.019583 -0.68748 0.491782
## omega 0.000015 0.000012 1.25867 0.208150
## alpha1 0.111158 0.054637 2.03450 0.041901
## beta1 0.809517 0.082783 9.77876 0.000000
##
## LogLikelihood : 8364.692
##
## Information Criteria
## ------------------------------------
##
## Akaike -5.8665
## Bayes -5.8560
## Shibata -5.8665
## Hannan-Quinn -5.8627
##
## Weighted Ljung-Box Test on Standardized Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.03483 0.8519
## Lag[2*(p+q)+(p+q)-1][2] 0.03492 1.0000
## Lag[4*(p+q)+(p+q)-1][5] 1.39601 0.8712
## d.o.f=1
## H0 : No serial correlation
##
## Weighted Ljung-Box Test on Standardized Squared Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.2509 0.6165
## Lag[2*(p+q)+(p+q)-1][5] 1.2795 0.7938
## Lag[4*(p+q)+(p+q)-1][9] 1.9518 0.9107
## d.o.f=2
##
## Weighted ARCH LM Tests
## ------------------------------------
## Statistic Shape Scale P-Value
## ARCH Lag[3] 1.295 0.500 2.000 0.2551
## ARCH Lag[5] 1.603 1.440 1.667 0.5656
## ARCH Lag[7] 1.935 2.315 1.543 0.7312
##
## Nyblom stability test
## ------------------------------------
## Joint Statistic: 26.6709
## Individual Statistics:
## mu 0.42613
## ar1 0.06712
## omega 0.89209
## alpha1 0.55216
## beta1 0.15390
##
## Asymptotic Critical Values (10% 5% 1%)
## Joint Statistic: 1.28 1.47 1.88
## Individual Statistic: 0.35 0.47 0.75
##
## Sign Bias Test
## ------------------------------------
## t-value prob sig
## Sign Bias 0.2134 0.8310
## Negative Sign Bias 1.0137 0.3108
## Positive Sign Bias 0.4427 0.6580
## Joint Effect 1.6909 0.6390
##
##
## Adjusted Pearson Goodness-of-Fit Test:
## ------------------------------------
## group statistic p-value(g-1)
## 1 20 135.6 1.285e-19
## 2 30 139.3 2.301e-16
## 3 40 161.8 6.871e-17
## 4 50 166.2 1.164e-14
##
##
## Elapsed time : 0.7440431</pre>
If you are familiar with GARCH models you will recognise some of the parameters. <code>ar1</code> is the AR1 coefficient of the mean model (here very small and basically insignificant), <code>alpha1</code> is the coefficient to the squared residuals in the GARCH equation and <code>beta1</code> is the coefficient to the lagged variance.

Often you will want to use model output for some further analysis. It is therefore important to understand how to extract information such as the parameter estimates, their standard errors or the residuals. The object <code>ugfit</code> contains all the information. In that object you can find two drawers (or in technical speak slots, @fit and @model). Each of these drawers contains a range of different things. What they contain you can figure out by asking for the element names

<pre class="r">paste("Elements in the @model slot")</pre>
<pre>## [1] "Elements in the @model slot"</pre>
<pre class="r">names(ugfit@model)</pre>
<pre>## [1] "modelinc" "modeldesc" "modeldata" "pars" "start.pars"
## [6] "fixed.pars" "maxOrder" "pos.matrix" "fmodel" "pidx"
## [11] "n.start"</pre>
<pre class="r">paste("Elements in the @fit slot")</pre>
<pre>## [1] "Elements in the @fit slot"</pre>
<pre class="r">names(ugfit@fit)</pre>
<pre>## [1] "hessian" "cvar" "var"
## [4] "sigma" "condH" "z"
## [7] "LLH" "log.likelihoods" "residuals"
## [10] "coef" "robust.cvar" "A"
## [13] "B" "scores" "se.coef"
## [16] "tval" "matcoef" "robust.se.coef"
## [19] "robust.tval" "robust.matcoef" "fitted.values"
## [22] "convergence" "kappa" "persistence"
## [25] "timer" "ipars" "solver"</pre>
If you wanted to extract the estimated coefficients you would do that in the following way:

<pre class="r">ugfit@fit$coef</pre>
<pre>## mu ar1 omega alpha1 beta1
## 3.419000e-04 -1.346260e-02 1.516946e-05 1.111584e-01 8.095171e-01</pre>
<pre class="r">ug_var <- ugfit@fit$var # save the estimated conditional variances
ug_res2 <- (ugfit@fit$residuals)^2 # save the estimated squared residuals</pre>
Let's plot the squared residuals and the estimated conditional variance:

<pre class="r">plot(ug_res2, type = "l")
lines(ug_var, col = "green")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-16-1.png]]

== Model Forecasting ==

Often you will want to use an estimated model to subsequently forecast the conditional variance. The function used for this purpose is the <code>ugarchforecast</code> function. The application is rather straightforward:

<pre class="r">ugfore <- ugarchforecast(ugfit, n.ahead = 10)
ugfore</pre>
<pre>##
## *------------------------------------*
## * GARCH Model Forecast *
## *------------------------------------*
## Model: sGARCH
## Horizon: 10
## Roll Steps: 0
## Out of Sample: 0
##
## 0-roll forecast [T0=2018-04-27]:
## Series Sigma
## T+1 0.0003685 0.01640
## T+2 0.0003415 0.01621
## T+3 0.0003419 0.01604
## T+4 0.0003419 0.01587
## T+5 0.0003419 0.01572
## T+6 0.0003419 0.01558
## T+7 0.0003419 0.01545
## T+8 0.0003419 0.01533
## T+9 0.0003419 0.01521
## T+10 0.0003419 0.01511</pre>
As you can see we have produced forecasts for the next ten days, both for the expected returns (<code>Series</code>) and for the conditional volatility (square root of the conditional variance). Similar to the object created for model fitting, <code>ugfore</code> contains two slots (@model and @forecast) and you can use <code>names(ugfore@forecast)</code> to figure out under which names the elements are saved. For instance you can extract the conditional volatility forecast as follows:

<pre class="r">ug_f <- ugfore@forecast$sigmaFor
plot(ug_f, type = "l")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-18-1.png]]

Note that the volatility is the square root of the conditional variance.

To put these forecasts into context let's display them together with the last 50 observations used in the estimation.

<pre class="r">ug_var_t <- c(tail(ug_var,20),rep(NA,10)) # gets the last 20 observations
ug_res2_t <- c(tail(ug_res2,20),rep(NA,10)) # gets the last 20 observations
ug_f <- c(rep(NA,20),(ug_f)^2)

plot(ug_res2_t, type = "l")
lines(ug_f, col = "orange")
lines(ug_var_t, col = "green")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-19-1.png]]

You can see how the forecast of the conditional variance picks up from the last estimated conditional variance. In fact it decreases from there, slowly, towards the unconditional variance value.

The <code>rugarch</code> package has a lot of additional functionality which you can explore through the documentation.

= Multivariate GARCH models =

Often you will want to model the volatility of a vector of assets. This can be done with the multivariate equivalent of the univariate GARCH model. Estimating multivariate GARCH models turns out to be significantly more difficult than univariate GARCH models, but fortunately procedures have been developed that deal with most of these issues.

Here we are using the <code>rmgarch</code> package which has a lot of useful functionality. We are applying it to estimate a multivariate volatility model for the returns of BP, Google/Alphabet and IBM shares.

As for the <code>rugarch</code> package we first need to specify the model we want to estimate. Here we stick with a Dynamic Conditional Correlation (DCC) model (see the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for details.). When estimating DCC models one basically estimates individual GARCH-type models (which could differ for each individual asset). These are then used to standardise the individual residuals. As a second step one then has to specify the correlation dynamics of these standardised residuals. It is possible to estimate the parameters of the univariate and the correlation model in one big swoop. however, my experience with this, and other packages, is that it is beneficial to separate the two steps.

== Model Setup ==

Here we assume that we are using the same univariate volatility model specification for each of the three assets.

<pre class="r"># DCC (MVN)
uspec.n = multispec(replicate(3, ugarchspec(mean.model = list(armaOrder = c(1,0)))))</pre>
What does this command do? You will recognise that <code>ugarchspec(mean.model = list(armaOrder = c(1,0)))</code> specifies an AR(1)-GARCH(1,1) model. By using <code>replicate(3, ugarchspec...)</code> we replicate this model 3 times (as we have three assets, IBM, Google/Alphabet and BP).

We now estimate these univariate GARCH models using the <code>multifit</code> command.

<pre class="r">multf = multifit(uspec.n, rX)</pre>
The results are saved in <code>multf</code> and you can type <code>multf</code> into the command window to see the estimated parameters for these three models. But we will here proceed to specify the DCC model (I assume that you know what a DCC model is. This is not the place to elaborate on this and many textbooks or indeed the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] to this package provide details). To specify the correlation specification we use the <code>dccspec</code> function.

<pre class="r">spec1 = dccspec(uspec = uspec.n, dccOrder = c(1, 1), distribution = 'mvnorm')</pre>
In this specification we have to state how the univariate volatilities are modeled (as per <code>uspec.n</code>) and how complex the dynamic structure of the correlation matrix is (here we are using the most standard <code>dccOrder = c(1, 1)</code> specification).

== Model Estimation ==

Now we are in a position to estimate the model using the <code>dccfit</code> function.

<pre class="r">fit1 = dccfit(spec1, data = rX, fit.control = list(eval.se = TRUE), fit = multf)</pre>
We want to estimate the model as specified in <code>spec1</code>, using the data in <code>rX</code>. The option <code>fit.control = list(eval.se = TRUE)</code> ensures that the estimation procedure produces standard errors for estimated parameters. Importantly <code>fit = multf</code> indicates that we ought to use the already estimated univariate models as they were saved in <code>multf</code>. The way to learn how to use these functions is by a combination of looking at the functions's help (<code>?dccfit</code>) and googling.

When you estimate a multivariate volatility model like the DCC model you are typically interested in the estimated covariance or correlation matrices. After all it is at the core of these models that you allow for time-variation in the correlation between the assets (there are also constant correlation models, but we do not discuss this here). Therefore we will now learn how we extract these.

<pre class="r"># Get the model based time varying covariance (arrays) and correlation matrices
cov1 = rcov(fit1) # extracts the covariance matrix
cor1 = rcor(fit1) # extracts the correlation matrix</pre>
To understand the object we have at our hands here we can have a look at the imension:

<pre class="r">dim(cor1)</pre>
<pre>## [1] 3 3 2850</pre>
We get three outputs which tells us that we have a three dimensional object. The firts two dimensions have 3 elements each (think a <math>3\times3</math> correlation matrix) and then there is a third dimension with 2850 elements. This tells us that <code>cor1</code> stores 2850 (<math>3\times3</math>) sorrelation matrices, one for each day of data.

Let's have a look at the correlation matrix for the last day, day 2853;

<pre class="r">cor1[,,dim(cor1)[3]]</pre>
<pre>## rIBM rBP rGOOG
## rIBM 1.0000000 0.2424297 0.353591
## rBP 0.2424297 1.0000000 0.275244
## rGOOG 0.3535910 0.2752440 1.000000</pre>
So let's say we want to plot the time-varying correlation between Google and BP, which is 0.275244 on that last day. In our matrix with returns <code>rX</code> BP is the second asset and Google the 3rd. So in any particular correlation matrix we want the element in row 2 and column 3.

<pre class="r">cor_BG <- cor1[2,1,] # leaving the last dimension empty implies that we want all elements
cor_BG <- as.xts(cor_BG) # imposes the xts time series format - useful for plotting</pre>
And now we plot this.

<pre class="r">plot(cor_BG)</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-28-1.png]]

If you transformed <code>cor_BG</code> to be a <code>xts</code> series the <code>plot</code> function automatically picks up the date information. As you can see there is significant variation through time with the correaltion typically varying between 0.2 and 0.5.

Let's plot all three correlations between the three assets.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
plot(as.xts(cor1[1,2,]),main="IBM and BP")
plot(as.xts(cor1[1,3,]),main="IBM and Google")
plot(as.xts(cor1[2,3,]),main="BP and Google")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-29-1.png]]

== Forecasts ==

Often you will want to use your estimated model to produce forecasts for the covariance or correlation matrix

<pre class="r">dccf1 <- dccforecast(fit1, n.ahead = 10)
dccf1</pre>
<pre>##
## *---------------------------------*
## * DCC GARCH Forecast *
## *---------------------------------*
##
## Distribution : mvnorm
## Model : DCC(1,1)
## Horizon : 10
## Roll Steps : 0
## -----------------------------------
##
## 0-roll forecast:
##
## First 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2539 0.3562
## [2,] 0.2539 1.0000 0.2883
## [3,] 0.3562 0.2883 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2658 0.3587
## [2,] 0.2658 1.0000 0.2909
## [3,] 0.3587 0.2909 1.0000
##
## . . .
## . . .
##
## Last 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3202 0.3703
## [2,] 0.3202 1.0000 0.3027
## [3,] 0.3703 0.3027 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3250 0.3714
## [2,] 0.3250 1.0000 0.3037
## [3,] 0.3714 0.3037 1.0000</pre>
The actual forecasts for the correlation can be addresse via

<pre class="r">Rf <- dccf1@mforecast$R # use H for the covariance forecast</pre>
When checking the structure of <code>Rf</code>

<pre class="r">str(Rf)</pre>
<pre>## List of 1
## $ : num [1:3, 1:3, 1:10] 1 0.254 0.356 0.254 1 ...</pre>
you realise that the object <code>Rf</code> is a list with one element. It turns out that this one list item is then a 3 dimensional matrix/array which contains the the 10 forecasts of <math>3 \times 3</math> correlation matrices. If we want to extract, say, the 10 forecasts for the correlation between IBM (1st asset) and BP (2nd asset), we have to do this in the following way:

<pre class="r">corf_IB <- Rf[[1]][1,2,] # Correlation forecasts between IBM and BP
corf_IG <- Rf[[1]][1,3,] # Correlation forecasts between IBM and Google
corf_BG <- Rf[[1]][2,3,] # Correlation forecasts between BP and Google</pre>
<code>[[1]]</code> tells R to go to the first (and here only) list item and then <code>[1,2,]</code> instructs R to select the (1,2) element of all available correlation matrices.

As for the univariate volatililty model let us display the forecast along with the last in-sample estimates of correlation.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
c_IB <- c(tail(cor1[1,2,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IB <- c(rep(NA,20),corf_IB) # gets the 10 forecasts
plot(c_IB,type = "l",main="Correlation IBM and BP")
lines(cf_IB,type = "l", col = "orange")

c_IG <- c(tail(cor1[1,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IG <- c(rep(NA,20),corf_IG) # gets the 10 forecasts
plot(c_IG,type = "l",main="Correlation IBM and Google")
lines(cf_IG,type = "l", col = "orange")

c_BG <- c(tail(cor1[2,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_BG <- c(rep(NA,20),corf_BG) # gets the 10 forecasts
plot(c_BG,type = "l",main="Correlation BP and Google")
lines(cf_BG,type = "l", col = "orange")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-34-1.png]]

= Further thoughts =

If you are looking at using pseudo-out-of sample forecasting (i.e. pretend to forecast values that actually have already occured) you should explore the <code>out.sample</code> option of the <code>dccfit</code> function.

The <code>rmgarch</code> package also allows you to estimate multivariate factor GARCH models and copula GARCH models (check the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for more details.

An alternative package with a slightly different set of multivariate volatility models is the `<code>ccgarch</code> package.

R GARCH

2018-05-03T23:02:24Z

Rb: Created page with "= Introduction = When you are dealing with financial time-series we often have relatively high frequency observations available. It is very common for instance to have daily..."

= Introduction =

When you are dealing with financial time-series we often have relatively high frequency observations available. It is very common for instance to have daily observations available. In fact it is now possible to obtain hourly, minute, second or even millisecond observations. But here we will restrict ourselves to daily observations. For some assets these will be 7 days a week observations, but for others these will be work-day observations, so typically 5 days a week of observations.

= Packages used =

There are a number of packages that can enable us to estimate volatility models. The packages we will use are the <code>rugarch</code> for univariate GARCH models and the <code>rmgarch</code> (for multivariate models) package both written by Alexios Ghalanos. We shall also use the <code>quantmod</code> package as it will give us some easy access to some standard financial data.

So please ensure that you install these packes and then load them,

<pre class="r">#install.packages(c("quantmod","rugarch","rmgarch")) # only needed in case you have not yet installed these packages
library(quantmod)
library(rugarch)
library(rmgarch)</pre>
Next we set our working directory

<pre class="r"># replace with your directory and uncomment
# setwd("YOUR/COPLETE/DIRECTORY/PATH") </pre>
= Data upload =

Here we will use a convenient data retrieval function (<code>getSymbols</code>) delivered by the <code>quantmod</code> package in order to retrieve some data. This function works, for instance, to retrieve stock data. The default source is [https://finance.yahoo.com/ Yahoo Finance]. If you want to find out what stock has which symbol you should be able to search the internet to find a list of ticker symbols. The following shows how to use the function. But note that my experience is that sometimes the connection does not work and you may get an error message. In that case just retry a few seconds later and it may well work.

<pre class="r">startDate = as.Date("2007-01-03") #Specify period of time we are interested in
endDate = as.Date("2018-04-30")

getSymbols("IBM", from = startDate, to = endDate)</pre>
<pre>## [1] "IBM"</pre>
<pre class="r">getSymbols("GOOG", from = startDate, to = endDate)</pre>
<pre>## [1] "GOOG"</pre>
<pre class="r">getSymbols("BP", from = startDate, to = endDate)</pre>
<pre>## [1] "BP"</pre>
In your environment you can see that each of these commands loads an object with the respective ticker symbol name. Let's have a look at one of these dataframes to understand what data these are:

<pre class="r">head(IBM)</pre>
<pre>## IBM.Open IBM.High IBM.Low IBM.Close IBM.Volume IBM.Adjusted
## 2007-01-03 97.18 98.40 96.26 97.27 9196800 73.41806
## 2007-01-04 97.25 98.79 96.88 98.31 10524500 74.20306
## 2007-01-05 97.60 97.95 96.91 97.42 7221300 73.53130
## 2007-01-08 98.50 99.50 98.35 98.90 10340000 74.64834
## 2007-01-09 99.08 100.33 99.07 100.07 11108200 75.53147
## 2007-01-10 98.50 99.05 97.93 98.89 8744800 74.64082</pre>
<pre class="r">str(IBM)</pre>
<pre>## An 'xts' object on 2007-01-03/2018-04-27 containing:
## Data: num [1:2850, 1:6] 97.2 97.2 97.6 98.5 99.1 ...
## - attr(*, "dimnames")=List of 2
## ..$ : NULL
## ..$ : chr [1:6] "IBM.Open" "IBM.High" "IBM.Low" "IBM.Close" ...
## Indexed by objects of class: [Date] TZ: UTC
## xts Attributes:
## List of 2
## $ src : chr "yahoo"
## $ updated: POSIXct[1:1], format: "2018-05-03 22:21:00"</pre>
You can see that this object contains a range of daily observations (<code>Open</code>, <code>High</code>, <code>Close</code>, <code>Volume</code> and <code>Adjusted</code> share price). We also learn that the object is formatted as an <code>xts</code> object. <code>xts</code> is a type of time-series format and indeed we learn that the data range from 2007-01-03 to 2018-04-30.

You can in fact produce a somewhat fancy looking chart with the following command (also part of the <code>quantmod</code> package)

<pre class="r">chartSeries(GOOG)</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-6-1.png]]

When we are estimating volatility models we work with returns. There is a function that transforms the data to returns.

<pre class="r">rIBM <- dailyReturn(IBM)
rBP <- dailyReturn(BP)
rGOOG <- dailyReturn(GOOG)

# We put all data into a data frame for use in the multivariate model
rX <- data.frame(rIBM, rBP, rGOOG)
names(rX)[1] <- "rIBM"
names(rX)[2] <- "rBP"
names(rX)[3] <- "rGOOG"</pre>
There is also a <code>weeklyReturn</code> function in case that is what you are interested in.

= Univariate GARCH Model =

Here we are using the functionality provided by the <code>rugarch</code> package written by Alexios Galanos.

== Model Specification ==

The first thing you need to do is to ensure you know what type of GARCH model you want to estimate and then let R know about this. It is the <code>ugarchspec( )</code> function which is used to let R know about the model type. There is in fact a default specification and the way to invoke this is as follows

<pre class="r">ug_spec = ugarchspec()</pre>
<code>ug_spec</code> is now a list which contains all the relevant model specifications. Let's look at them:

<pre class="r">ug_spec</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Spec *
## *---------------------------------*
##
## Conditional Variance Dynamics
## ------------------------------------
## GARCH Model : sGARCH(1,1)
## Variance Targeting : FALSE
##
## Conditional Mean Dynamics
## ------------------------------------
## Mean Model : ARFIMA(1,0,1)
## Include Mean : TRUE
## GARCH-in-Mean : FALSE
##
## Conditional Distribution
## ------------------------------------
## Distribution : norm
## Includes Skew : FALSE
## Includes Shape : FALSE
## Includes Lambda : FALSE</pre>
The key issues here are the spec for the <code>Mean Model</code> (here an ARMA(1,1) model) and the specification for the <code>GARCH Model</code>, here an <code>sGARCH(1,1)</code> which is basically a GARCH(1,1). To get details on all the possible specifications and how to change them it is best to consult the [https://cran.r-project.org/web/packages/rugarch/vignettes/Introduction_to_the_rugarch_package.pdf documentation] of the <code>rugarch</code> package.

Let's say you want to change the mean model from an ARMA(1,1) to an ARMA(1,0), i.e. an AR(1) model.

<pre class="r">ug_spec <- ugarchspec(mean.model=list(armaOrder=c(1,0)))</pre>
You could call <code>ug_spec</code> again to check that the model specification has actually changed.

The following is the specification for an # an example of the EWMA Model (although we will not se it below).

<pre class="r">ewma_spec = ugarchspec(variance.model=list(model="iGARCH", garchOrder=c(1,1)),
mean.model=list(armaOrder=c(0,0), include.mean=TRUE),
distribution.model="norm", fixed.pars=list(omega=0))</pre>
== Model Estimation ==

Now that we have specified a model to estimate we need to find the best arameters, i.e. we need to estimate the model. This step is achieved by the <code>ugarchfit</code> function.

<pre class="r">ugfit = ugarchfit(spec = ug_spec, data = rIBM)</pre>
<code>fit</code> is now a list that contains a range of results from the estimation. Let's have a look at the results

<pre class="r">ugfit</pre>
<pre>##
## *---------------------------------*
## * GARCH Model Fit *
## *---------------------------------*
##
## Conditional Variance Dynamics
## -----------------------------------
## GARCH Model : sGARCH(1,1)
## Mean Model : ARFIMA(1,0,0)
## Distribution : norm
##
## Optimal Parameters
## ------------------------------------
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000220 1.55666 0.11955
## ar1 -0.013463 0.021425 -0.62835 0.52978
## omega 0.000015 0.000002 6.56888 0.00000
## alpha1 0.111158 0.006440 17.25930 0.00000
## beta1 0.809517 0.005883 137.59775 0.00000
##
## Robust Standard Errors:
## Estimate Std. Error t value Pr(>|t|)
## mu 0.000342 0.000230 1.48654 0.137136
## ar1 -0.013463 0.019583 -0.68748 0.491782
## omega 0.000015 0.000012 1.25867 0.208150
## alpha1 0.111158 0.054637 2.03450 0.041901
## beta1 0.809517 0.082783 9.77876 0.000000
##
## LogLikelihood : 8364.692
##
## Information Criteria
## ------------------------------------
##
## Akaike -5.8665
## Bayes -5.8560
## Shibata -5.8665
## Hannan-Quinn -5.8627
##
## Weighted Ljung-Box Test on Standardized Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.03483 0.8519
## Lag[2*(p+q)+(p+q)-1][2] 0.03492 1.0000
## Lag[4*(p+q)+(p+q)-1][5] 1.39601 0.8712
## d.o.f=1
## H0 : No serial correlation
##
## Weighted Ljung-Box Test on Standardized Squared Residuals
## ------------------------------------
## statistic p-value
## Lag[1] 0.2509 0.6165
## Lag[2*(p+q)+(p+q)-1][5] 1.2795 0.7938
## Lag[4*(p+q)+(p+q)-1][9] 1.9518 0.9107
## d.o.f=2
##
## Weighted ARCH LM Tests
## ------------------------------------
## Statistic Shape Scale P-Value
## ARCH Lag[3] 1.295 0.500 2.000 0.2551
## ARCH Lag[5] 1.603 1.440 1.667 0.5656
## ARCH Lag[7] 1.935 2.315 1.543 0.7312
##
## Nyblom stability test
## ------------------------------------
## Joint Statistic: 26.6709
## Individual Statistics:
## mu 0.42613
## ar1 0.06712
## omega 0.89209
## alpha1 0.55216
## beta1 0.15390
##
## Asymptotic Critical Values (10% 5% 1%)
## Joint Statistic: 1.28 1.47 1.88
## Individual Statistic: 0.35 0.47 0.75
##
## Sign Bias Test
## ------------------------------------
## t-value prob sig
## Sign Bias 0.2134 0.8310
## Negative Sign Bias 1.0137 0.3108
## Positive Sign Bias 0.4427 0.6580
## Joint Effect 1.6909 0.6390
##
##
## Adjusted Pearson Goodness-of-Fit Test:
## ------------------------------------
## group statistic p-value(g-1)
## 1 20 135.6 1.285e-19
## 2 30 139.3 2.301e-16
## 3 40 161.8 6.871e-17
## 4 50 166.2 1.164e-14
##
##
## Elapsed time : 0.7440431</pre>
If you are familiar with GARCH models you will recognise some of the parameters. <code>ar1</code> is the AR1 coefficient of the mean model (here very small and basically insignificant), <code>alpha1</code> is the coefficient to the squared residuals in the GARCH equation and <code>beta1</code> is the coefficient to the lagged variance.

Often you will want to use model output for some further analysis. It is therefore important to understand how to extract information such as the parameter estimates, their standard errors or the residuals. The object <code>ugfit</code> contains all the information. In that object you can find two drawers (or in technical speak slots, @fit and @model). Each of these drawers contains a range of different things. What they contain you can figure out by asking for the element names

<pre class="r">paste("Elements in the @model slot")</pre>
<pre>## [1] "Elements in the @model slot"</pre>
<pre class="r">names(ugfit@model)</pre>
<pre>## [1] "modelinc" "modeldesc" "modeldata" "pars" "start.pars"
## [6] "fixed.pars" "maxOrder" "pos.matrix" "fmodel" "pidx"
## [11] "n.start"</pre>
<pre class="r">paste("Elements in the @fit slot")</pre>
<pre>## [1] "Elements in the @fit slot"</pre>
<pre class="r">names(ugfit@fit)</pre>
<pre>## [1] "hessian" "cvar" "var"
## [4] "sigma" "condH" "z"
## [7] "LLH" "log.likelihoods" "residuals"
## [10] "coef" "robust.cvar" "A"
## [13] "B" "scores" "se.coef"
## [16] "tval" "matcoef" "robust.se.coef"
## [19] "robust.tval" "robust.matcoef" "fitted.values"
## [22] "convergence" "kappa" "persistence"
## [25] "timer" "ipars" "solver"</pre>
If you wanted to extract the estimated coefficients you would do that in the following way:

<pre class="r">ugfit@fit$coef</pre>
<pre>## mu ar1 omega alpha1 beta1
## 3.419000e-04 -1.346260e-02 1.516946e-05 1.111584e-01 8.095171e-01</pre>
<pre class="r">ug_var <- ugfit@fit$var # save the estimated conditional variances
ug_res2 <- (ugfit@fit$residuals)^2 # save the estimated squared residuals</pre>
Let's plot the squared residuals and the estimated conditional variance:

<pre class="r">plot(ug_res2, type = "l")
lines(ug_var, col = "green")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-16-1.png]]

== Model Forecasting ==

Often you will want to use an estimated model to subsequently forecast the conditional variance. The function used for this purpose is the <code>ugarchforecast</code> function. The application is rather straightforward:

<pre class="r">ugfore <- ugarchforecast(ugfit, n.ahead = 10)
ugfore</pre>
<pre>##
## *------------------------------------*
## * GARCH Model Forecast *
## *------------------------------------*
## Model: sGARCH
## Horizon: 10
## Roll Steps: 0
## Out of Sample: 0
##
## 0-roll forecast [T0=2018-04-27]:
## Series Sigma
## T+1 0.0003685 0.01640
## T+2 0.0003415 0.01621
## T+3 0.0003419 0.01604
## T+4 0.0003419 0.01587
## T+5 0.0003419 0.01572
## T+6 0.0003419 0.01558
## T+7 0.0003419 0.01545
## T+8 0.0003419 0.01533
## T+9 0.0003419 0.01521
## T+10 0.0003419 0.01511</pre>
As you can see we have produced forecasts for the next ten days, both for the expected returns (<code>Series</code>) and for the conditional volatility (square root of the conditional variance). Similar to the object created for model fitting, <code>ugfore</code> contains two slots (@model and @forecast) and you can use <code>names(ugfore@forecast)</code> to figure out under which names the elements are saved. For instance you can extract the conditional volatility forecast as follows:

<pre class="r">ug_f <- ugfore@forecast$sigmaFor
plot(ug_f, type = "l")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-18-1.png]]

Note that the volatility is the square root of the conditional variance.

To put these forecasts into context let's display them together with the last 50 observations used in the estimation.

<pre class="r">ug_var_t <- c(tail(ug_var,20),rep(NA,10)) # gets the last 20 observations
ug_res2_t <- c(tail(ug_res2,20),rep(NA,10)) # gets the last 20 observations
ug_f <- c(rep(NA,20),(ug_f)^2)

plot(ug_res2_t, type = "l")
lines(ug_f, col = "orange")
lines(ug_var_t, col = "green")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-19-1.png]]

You can see how the forecast of the conditional variance picks up from the last estimated conditional variance. In fact it decreases from there, slowly, towards the unconditional variance value.

The <code>rugarch</code> package has a lot of additional functionality which you can explore through the documentation.

= Multivariate GARCH models =

Often you will want to model the volatility of a vector of assets. This can be done with the multivariate equivalent of the univariate GARCH model. Estimating multivariate GARCH models turns out to be significantly more difficult than univariate GARCH models, but fortunately procedures have been developed that deal with most of these issues.

Here we are using the <code>rmgarch</code> package which has a lot of useful functionality. We are applying it to estimate a multivariate volatility model for the returns of BP, Google/Alphabet and IBM shares.

As for the <code>rugarch</code> package we first need to specify the model we want to estimate. Here we stick with a Dynamic Conditional Correlation (DCC) model (see the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for details.). When estimating DCC models one basically estimates individual GARCH-type models (which could differ for each individual asset). These are then used to standardise the individual residuals. As a second step one then has to specify the correlation dynamics of these standardised residuals. It is possible to estimate the parameters of the univariate and the correlation model in one big swoop. however, my experience with this, and other packages, is that it is beneficial to separate the two steps.

== Model Setup ==

Here we assume that we are using the same univariate volatility model specification for each of the three assets.

<pre class="r"># DCC (MVN)
uspec.n = multispec(replicate(3, ugarchspec(mean.model = list(armaOrder = c(1,0)))))</pre>
What does this command do? You will recognise that <code>ugarchspec(mean.model = list(armaOrder = c(1,0)))</code> specifies an AR(1)-GARCH(1,1) model. By using <code>replicate(3, ugarchspec...)</code> we replicate this model 3 times (as we have three assets, IBM, Google/Alphabet and BP).

We now estimate these univariate GARCH models using the <code>multifit</code> command.

<pre class="r">multf = multifit(uspec.n, rX)</pre>
The results are saved in <code>multf</code> and you can type <code>multf</code> into the command window to see the estimated parameters for these three models. But we will here proceed to specify the DCC model (I assume that you know what a DCC model is. This is not the place to elaborate on this and many textbooks or indeed the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] to this package provide details). To specify the correlation specification we use the <code>dccspec</code> function.

<pre class="r">spec1 = dccspec(uspec = uspec.n, dccOrder = c(1, 1), distribution = 'mvnorm')</pre>
In this specification we have to state how the univariate volatilities are modeled (as per <code>uspec.n</code>) and how complex the dynamic structure of the correlation matrix is (here we are using the most standard <code>dccOrder = c(1, 1)</code> specification).

== Model Estimation ==

Now we are in a position to estimate the model using the <code>dccfit</code> function.

<pre class="r">fit1 = dccfit(spec1, data = rX, fit.control = list(eval.se = TRUE), fit = multf)</pre>
We want to estimate the model as specified in <code>spec1</code>, using the data in <code>rX</code>. The option <code>fit.control = list(eval.se = TRUE)</code> ensures that the estimation procedure produces standard errors for estimated parameters. Importantly <code>fit = multf</code> indicates that we ought to use the already estimated univariate models as they were saved in <code>multf</code>. The way to learn how to use these functions is by a combination of looking at the functions's help (<code>?dccfit</code>) and googling.

When you estimate a multivariate volatility model like the DCC model you are typically interested in the estimated covariance or correlation matrices. After all it is at the core of these models that you allow for time-variation in the correlation between the assets (there are also constant correlation models, but we do not discuss this here). Therefore we will now learn how we extract these.

<pre class="r"># Get the model based time varying covariance (arrays) and correlation matrices
cov1 = rcov(fit1) # extracts the covariance matrix
cor1 = rcor(fit1) # extracts the correlation matrix</pre>
To understand the object we have at our hands here we can have a look at the imension:

<pre class="r">dim(cor1)</pre>
<pre>## [1] 3 3 2850</pre>
We get three outputs which tells us that we have a three dimensional object. The firts two dimensions have 3 elements each (think a <math>3\times3</math> correlation matrix) and then there is a third dimension with 2850 elements. This tells us that <code>cor1</code> stores 2850 (<math>3\times3</math>) sorrelation matrices, one for each day of data.

Let's have a look at the correlation matrix for the last day, day 2853;

<pre class="r">cor1[,,dim(cor1)[3]]</pre>
<pre>## rIBM rBP rGOOG
## rIBM 1.0000000 0.2424297 0.353591
## rBP 0.2424297 1.0000000 0.275244
## rGOOG 0.3535910 0.2752440 1.000000</pre>
So let's say we want to plot the time-varying correlation between Google and BP, which is 0.275244 on that last day. In our matrix with returns <code>rX</code> BP is the second asset and Google the 3rd. So in any particular correlation matrix we want the element in row 2 and column 3.

<pre class="r">cor_BG <- cor1[2,1,] # leaving the last dimension empty implies that we want all elements
cor_BG <- as.xts(cor_BG) # imposes the xts time series format - useful for plotting</pre>
And now we plot this.

<pre class="r">plot(cor_BG)</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-28-1.png]]

If you transformed <code>cor_BG</code> to be a <code>xts</code> series the <code>plot</code> function automatically picks up the date information. As you can see there is significant variation through time with the correaltion typically varying between 0.2 and 0.5.

Let's plot all three correlations between the three assets.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
plot(as.xts(cor1[1,2,]),main="IBM and BP")
plot(as.xts(cor1[1,3,]),main="IBM and Google")
plot(as.xts(cor1[2,3,]),main="BP and Google")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-29-1.png]]

== Forecasts ==

Often you will want to use your estimated model to produce forecasts for the covariance or correlation matrix

<pre class="r">dccf1 <- dccforecast(fit1, n.ahead = 10)
dccf1</pre>
<pre>##
## *---------------------------------*
## * DCC GARCH Forecast *
## *---------------------------------*
##
## Distribution : mvnorm
## Model : DCC(1,1)
## Horizon : 10
## Roll Steps : 0
## -----------------------------------
##
## 0-roll forecast:
##
## First 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2539 0.3562
## [2,] 0.2539 1.0000 0.2883
## [3,] 0.3562 0.2883 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.2658 0.3587
## [2,] 0.2658 1.0000 0.2909
## [3,] 0.3587 0.2909 1.0000
##
## . . .
## . . .
##
## Last 2 Correlation Forecasts
## , , 1
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3202 0.3703
## [2,] 0.3202 1.0000 0.3027
## [3,] 0.3703 0.3027 1.0000
##
## , , 2
##
## [,1] [,2] [,3]
## [1,] 1.0000 0.3250 0.3714
## [2,] 0.3250 1.0000 0.3037
## [3,] 0.3714 0.3037 1.0000</pre>
The actual forecasts for the correlation can be addresse via

<pre class="r">Rf <- dccf1@mforecast$R # use H for the covariance forecast</pre>
When checking the structure of <code>Rf</code>

<pre class="r">str(Rf)</pre>
<pre>## List of 1
## $ : num [1:3, 1:3, 1:10] 1 0.254 0.356 0.254 1 ...</pre>
you realise that the object <code>Rf</code> is a list with one element. It turns out that this one list item is then a 3 dimensional matrix/array which contains the the 10 forecasts of <math>3 \times 3</math> correlation matrices. If we want to extract, say, the 10 forecasts for the correlation between IBM (1st asset) and BP (2nd asset), we have to do this in the following way:

<pre class="r">corf_IB <- Rf[[1]][1,2,] # Correlation forecasts between IBM and BP
corf_IG <- Rf[[1]][1,3,] # Correlation forecasts between IBM and Google
corf_BG <- Rf[[1]][2,3,] # Correlation forecasts between BP and Google</pre>
<code>[[1]]</code> tells R to go to the first (and here only) list item and then <code>[1,2,]</code> instructs R to select the (1,2) element of all available correlation matrices.

As for the univariate volatililty model let us display the forecast along with the last in-sample estimates of correlation.

<pre class="r">par(mfrow=c(3,1)) # this creates a frame with 3 windows to be filled by plots
c_IB <- c(tail(cor1[1,2,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IB <- c(rep(NA,20),corf_IB) # gets the 10 forecasts
plot(c_IB,type = "l",main="Correlation IBM and BP")
lines(cf_IB,type = "l", col = "orange")

c_IG <- c(tail(cor1[1,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_IG <- c(rep(NA,20),corf_IG) # gets the 10 forecasts
plot(c_IG,type = "l",main="Correlation IBM and Google")
lines(cf_IG,type = "l", col = "orange")

c_BG <- c(tail(cor1[2,3,],20),rep(NA,10)) # gets the last 20 correlation observations
cf_BG <- c(rep(NA,20),corf_BG) # gets the 10 forecasts
plot(c_BG,type = "l",main="Correlation BP and Google")
lines(cf_BG,type = "l", col = "orange")</pre>
[[File:GarchModelling_files/figure-html/unnamed-chunk-34-1.png]]

= Further thoughts =

If you are looking at using pseudo-out-of sample forecasting (i.e. pretend to forecast values that actually have already occured) you should explore the <code>out.sample</code> option of the <code>dccfit</code> function.

The <code>rmgarch</code> package also allows you to estimate multivariate factor GARCH models and copula GARCH models (check the [https://cran.r-project.org/web/packages/rmgarch/vignettes/The_rmgarch_models.pdf documentation] for more details.

An alternative package with a slightly different set of multivariate volatility models is the `<code>ccgarch</code> package.

R

2018-05-03T22:52:32Z

Rb: /* Intermediate Techniques */

R is an open source software that has been been adopted by the statistical community as its standard software package. It is a command driven software, meaning that you will have to give the software written commands to indicate what you do. On first sight this is not as convenient as a menu driven software, but it has the huge advantage that you can collect a large set of commands in a file (script file) and then have R execute all these commands in one go. This then serves as a great documentation of the work you have done and most importantly it makes it easy to change a small aspect of your work and rerun the entire project on the press of a button rather than having to laboriously retrace all your steps through menus.

The fixed cost of learning this software is higher than learning a menu driven statistical software package. But if you engage with this process the rewards will be great.

Last not least, R has a killer advantage. It is free!!!

== Installing the Software ==

[https://youtu.be/EHjakj38Nnw?hd=1 Installation Demonstration]

To work with R you will have to install the basic software package R, but we also advise you to install RStudio, which is an add-on to R (formally called an Integrated Development Environment - IDE) which makes working with R easier.

As this is open-source software that you get for free it is perhaps understandable that the webpages from which you get the R software aren't as slick as you expect. And the language tends to be somewhat more techy, but don't worry, you'll be fine.

So here are the steps you should take.

# Download and install the R software, which is available from the [http://cran.rstudio.com/ CRAN] website. Follow the "Download and Install R" link (and do not be tempted to download the source code!) for your operating system. If you have a window OS only choose the "base" package on the following screen. Then follow the usual installation instructions. You could now already work with R, but we recommend that you first undertake the next step.
# Once we have installed R, we can download and install RStudio. You can download it from the [http://www.rstudio.com/products/rstudio/download/ RStudio] download page.

The basic R software has some basic functionality, but the power of R comes from the ability to use code written to perform statistical and econometric techniques that has been written by other people. These additional pieces of software are called packages and the next step will be to learn how ot use these.

== Data Sets ==

We use a number of datasets on this page. For convenience they are listed here:

{| class="wikitable"
|-
! scope="col"|
! scope="col"| Women's wages
! scope="col"| Crime Statistics
! scope="col"| Baseball Wages
|-
| '''Description'''
| Observations for 753 females on wages, familiar and work circumstances hours worked and wages
| Crime Statistics for 90 counties in North Carolina (US) for Years 1981 to 1987 (Panel Data); includes a number of variables to characterise the counties
| Salary and other information (such as race, position and performance information) for 353 Baseball Players in 1993
|-
| '''Files'''
| [[media:mroz.xls|mroz.xls]] [[media:mroz.csv|mroz.csv]] [[MROZ_Variable_Description|Variable Description]]
| [[media:crim4.xls|crime4.xls]] [[media:crim4.csv|crime4.csv]] [[Crim4_Variable_Description|Variable Description]]
| [[media:mlb1.xls|mlb1.xls]] [[media:mlb1.csv|mlb1.csv]] [[MLB1_Variable_Description|Variable Description]]
|-
| '''Source'''
| [http://www.cengagebrain.com/cgi-wadsworth/course_products_wp.pl?fid=M20b&product_isbn_issn=9781111531041&token=8D04240DC39B22D05B49B265F2C8E62C6876DDE99FE979BC4A500075EC976963ED1045639B2C75C4B5B2337F07088998 Wooldridge Book Companion Page]
| [http://www.cengagebrain.com/cgi-wadsworth/course_products_wp.pl?fid=M20b&product_isbn_issn=9781111531041&token=8D04240DC39B22D05B49B265F2C8E62C6876DDE99FE979BC4A500075EC976963ED1045639B2C75C4B5B2337F07088998 Wooldridge Book Companion Page]
| [http://www.cengagebrain.com/cgi-wadsworth/course_products_wp.pl?fid=M20b&product_isbn_issn=9781111531041&token=8D04240DC39B22D05B49B265F2C8E62C6876DDE99FE979BC4A500075EC976963ED1045639B2C75C4B5B2337F07088998 Wooldridge Book Companion Page]
|}

Following the links in the above table you will also be able to download R data files for these datasets.

== Basic Tasks ==

To illustrate how to perform basic tasks in R we will use the Women's wages dataset ([[media:mroz.csv|mroz.csv]]). This is a comma separated value (csv) file that contains a dataset which we will use for our first steps in R. It is a well used cross-sectional dataset with 753 observations of female members of the labour force in the US (in 1975). It contains variables such as the number of children, the wage, the hours worked etc.

{| class="wikitable"
|-
! scope="col"| First Steps
! scope="col"| Loading Data and Date Formats
! scope="col"| Using Packages

|-
| [[R_FirstSteps|Discussion]]
| [[R_Data|Discussion]]
| [[R_Packages|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Basic Data Analysis
! scope="col"| Data Analysis Tidyverse
! scope="col"| A Regression
|-
| [[R_Analysis|Discussion]]
| [[R_AnalysisTidy|Discussion]]
| [[R_Regression|Discussion]]
|}

{| class="wikitable"
|-
! scope="col"| Creating Graphics
! scope="col"| Saving Data and Screen Output
|-
| [[R_Graphing|Discussion]] [[R_Graphing_Treat|Treat Yourself]]
| [[R_SavingData|Discussion]]
|}

== Bread and Butter Techniques ==

These are standard econometric problems tasks that any applied econometrician, and indeed aspiring economics students, should be familiar with.

{| class="wikitable"
|-
! scope="col"| Dummy variables
! scope="col"| Predicting from a Regression

|-
| [[Dummy Variables in R|Discussion]]
| [[Predicting from Regression in R|Discussion]]

|}

{| class="wikitable"
|-
! scope="col"| Standard inference
! scope="col"| Regression diagnostics
! scope="col"| Robust standard errors
|-
| [[Regression Inference in R|Discussion]]
| [[R_reg_diag|Discussion]]
| [[R_robust_se|Discussion]]
|}

== Intermediate Techniques ==

{| class="wikitable"
|-
! scope="col"| Panel Data
! scope="col"| Instrumental Variables Estimation
! scope="col"| Matching
|-
| [[Panel in R|Discussion]]
| [[IV in R|Discussion]]
| [[R_Matching|Discussion]]
|}

{| class="wikitable"
|-

! scope="col"| Univariate Time Series Modelling
! scope="col"| Multivariate Time Series Modelling VAR
! scope="col"| Time Series Plotting
! scope="col"| Univariate and Multivariate GARCH Modelling
|-
| [[R_TimeSeries|Discussion]]
| [[R_TS_VAR|Discussion]]
| [[R_TSplots|Discussion]] uses the following data files: [[Media:AggInfl.csv|AggInfl.csv]],[[Media:CoreInfl.csv|CoreInfl.csv]] [[Media:EnergInfl.csv|EnergInfl.csv]],[[Media:FoodInfl.csv|FoodInfl.csv]]
| [[R_GARCH|Discussion]]
|}

{| class="wikitable"
|-

! scope="col"| Bayesian Estimation Principle
|-
| [[R_BayesGrid|Discussion]]

|}

== Some Fun Stuff ==

{| class="wikitable"
|-
! scope="col"| Plotting Maps
! scope="col"| Scraping the internet
|-
| [[Maps in R|Discussion]]
| [[Scraping in R|Discussion]]
|}

== Econometric Demonstrations ==

In this section you can find code that can be useful to demonstrate a few econometric issues.

{| class="wikitable"
|-
! scope="col"| Sampling and LLN and CLT
! scope="col"| Demonstrating OLS estimator unbiasedness
! scope="col"| Demonstrating OLS estimator asymptotic behaviour
|-
| [[R_Sampling|Discussion]]
| [[R_Unbiasedness|Discussion]]
| [[R_Asymptotics|Discussion]]
|}

== Authors, Maintenance and Contributions ==

This wiki was created by [mailto:ralf.becker@manchester.ac.uk Ralf Becker] and [mailto:james.lincoln@manchester.ac.uk James Lincoln] with the financial support of a University of Manchester CHERIL grant. If you have any suggestions please contact us by email. Contributions to this wiki are encouraged. Please contact us if you are interested.

An easy way to create content for this page is to write RMarkdown documents which can then easily be translated, thanks to pandoc, to MediaWiki format (see [http://nicercode.github.io/guides/reports/]). From the command window call "pandoc -f markdown -t MediaWiki FILENAME.md -o FILENAME.mediawiki".

== More references ==

There is a plethora of resources if you want to learn R (which is one reason why this resource does not go into too much detail). Here are a few places to start.

* A dedicated tweet channel for Econometrics with R [https://twitter.com/Rstats4Econ]
* Rob Hyndman has great material [http://robjhyndman.com/publications/software/], some of which will be referred to here.
* My colleague Junanjo Medina has material for criminologists that includes good intros to graphing and some basic statistics [http://jjmedinaariza.github.io/R-for-Criminologists/]
* [http://www.computerworld.com/article/2497143/business-intelligence-beginner-s-guide-to-r-introduction.html?null A Beginner's Guide to R]
* Florian Heiss has written an R companion book to Wooldridge's Introductory Econometrics. It is available for free [http://www.urfie.net/read/mobile/index.html#p=1 online] but you can also get a [http://www.urfie.net/index.html hardcopy]
* Some R resources provided by [http://www.ats.ucla.edu/stat/r/ UCLA]
* [http://www.statmethods.net Quick-R] web-site and [http://www.manning.com/kabacoff2/RiA2E_meap_ch1.pdf first chapter of R in Action]
* Just TryR it! [http://tryr.codeschool.com/levels/1/challenges/1]
* Some resource by the UCLA [http://www.ats.ucla.edu/stat/r/]
* A practice RData file [https://drive.google.com/file/d/0B-eFeuIjpKsOWmdpOUsxT2Via3M/view?usp=sharing], use this to load required packages [https://drive.google.com/file/d/0B-eFeuIjpKsOc3VYYnh1bEtZcnM/view?usp=sharing]

R BayesGrid

2018-03-21T00:15:51Z

Rb: /* Posterior probabilities for hypothesis */

= Introduction =

Here we demonstrate how a Beyesian Updating Algorithm works. It is illustrated for the simplest of all cases, a binary variable.

As usual we start by setting the working director ('''Make sure you set it to your relevant directory''') and by loading up a couple of useful libraries

<pre class="r">setwd("YOURFULLDIRECTORPATH")
library(car)
library(AER)</pre>

= Loading the data - Global Temperature Data. =

Let's work with some Global Temperature Data [[media: Global_Temperature.csv]].

<pre class="r">td <- read.csv("Global Temperature.csv")
td$Temp <- ts(td$Temp,start = c(1850), end=c(2015),frequency = 1)
td$CO2emission <- ts(td$CO2emission,start = c(1850), end=c(2015),frequency = 1)
summary(td)</pre>
<pre>## year Temp CO2emission
## Min. :1850 Min. :-0.54700 Min. : 54
## 1st Qu.:1891 1st Qu.:-0.30025 1st Qu.: 356
## Median :1932 Median :-0.17300 Median : 983
## Mean :1932 Mean :-0.10509 Mean :2258
## 3rd Qu.:1974 3rd Qu.: 0.03375 3rd Qu.:4053
## Max. :2015 Max. : 0.74500 Max. :9167
## NA's :5</pre>
<pre class="r">plot(td$Temp,main = "Global Temperature (deviations)", col = "blue", lwd = 2)</pre>
[[File:TempData.png|frame|none|alt=|Temperature Deviations]]

= Preparing the Data =

First we calculate the difference series

<pre class="r">dtemp <- diff(td$Temp) # temperature changes
ups <- (dtemp>0) # = 1 if increase, 0 otherwise
n <- length(ups) # number of years available</pre>
= Frequentist approach =

We estimate the sample mean and get a standard deviation for the sample mean:

<pre class="r">pbar <- mean(ups)
sd_pbar <- sqrt(pbar*(1-pbar)/n)</pre>
A t-test for testing the hypothesis that <math>H_0: \mu=0.5</math> and <math>H_A: \mu > 0.5</math> is 0.7016937 and hence we would not reject the null hypothesis at any sensible significance level.

= Bayesian Approach =

The parameter of interest, a proportion (or probability) can take an infinite number of values, but to make the problem easily computable we shall create a disrete grid (with k elements)on which we perform calclulations

<pre class="r">pval <- seq(0,1,0.01) # creates (0.00, 0.01, 0.02, ... ,0.98,0.99,1.0)
k <- length(pval) # number of values f</pre>
Really we would want to use a finer grid and you could easily change this by changing the stepsize.

== Defining the initial Prior Distributions ==

Prior 1: Normal (m1,sd1^2)

<pre class="r">m1 <- 0.4;
sd1 <- 0.05;
fp_prior1_in <- pnorm(pval+0.005,m1,sd1); # CDF
fp_prior1_in <- append(diff(fp_prior1_in),0,0) # discretised probs</pre>
Prior 2: Normal (m2,sd2^2)

<pre class="r">m2 <- 0.6;
sd2 <- 0.05;
fp_prior2_in <- pnorm(pval+0.005,m2,sd2); # CDF
fp_prior2_in <- append(diff(fp_prior2_in),0,0) # discretised probs</pre>
Prior 3: Uniform

<pre class="r">fp_prior3_in = rep(1,length(pval))*(1/length(pval))</pre>
Prior 4: Beta(5,3)

<pre class="r">fp_prior4_in <- pbeta(pval,5,3)
fp_prior3_in <- append(diff(fp_prior4_in),0,0) # discretised probs</pre>
Plot the Prior distributions:

<pre class="r">plot(pval,fp_prior1_in, col = "skyblue3", ylim = c(0,0.1), type = "l" , lwd = 3, main = "Prior Distributions")
lines(pval,fp_prior2_in, col = "hotpink3", lwd = 3)
lines(pval,fp_prior3_in, col = "olivedrab3", lwd = 3)
lines(pval,fp_prior4_in, col = "orange", lwd = 3)</pre>
[[File:Priors.png|frame|none|alt=|Four different Priors]]

== Updating ==

Let's say we have a year with temp increase, then the probability at each pval, pval[i], is updated as follows: P(pval(i)|up) = P(pval(i) and up)/P(up) = fp_prior(i)''pval(i)/P(up) where p(up) = sum over all j(fp_prior(j)''pval(j))

We start by defining new variables with the prior distributions. We only do this, as in what comes <code>fo_prior</code>s will change but we also want to keep the initial prior distributions.

<pre class="r">fp_prior1 <- fp_prior1_in
fp_prior2 <- fp_prior2_in
fp_prior3 <- fp_prior3_in</pre>
<pre class="r"># we loop through the n years for which we have observations
for(sim in 1:n){
# Calculations for Prior 1
temp1 <- rep(0,k) # save the joint probability in here
# Now we calculate likelihood * prior
# we loop through all possible values for pval
for (i in 1:k){
temp1[i] <- fp_prior1[i]*pval[i]*ups[sim] + fp_prior1[i]*(1-pval[i])*(1-ups[sim])
}
# Now we need to normalise the result in temp1 such that all
# probabilities sum to 1 = posterior distribution
fp_post1 <- temp1 / sum(temp1)
# in preparation for the next iteration (next year's data) we save
# the current posterior to be next period's prior
fp_prior1 <- fp_post1

# Calculations for Prior 2
temp2 <- rep(0,k)
for (i in 1:k){
temp2[i] <- fp_prior2[i]*pval[i]*ups[sim] + fp_prior2[i]*(1-pval[i])*(1-ups[sim])
}
fp_post2 <- temp2 / sum(temp2)
fp_prior2 <- fp_post2

# Calculations for Prior 3
temp3 <- rep(0,k)
for (i in 1:k){
temp3[i] <- fp_prior3[i]*pval[i]*ups[sim] + fp_prior3[i]*(1-pval[i])*(1-ups[sim])
}
fp_post3 <- temp3 / sum(temp3)
fp_prior3 <- fp_post3

# plot how the posterior updates
# uncomment this if you want to see the development of the posterior
# plot(pval,fp_prior1_in, col = "skyblue", ylim = c(0,0.15), type = "l", xlab="pval", ylab="density", main = "Posterior Distributions")
# lines(pval,fp_post1, col = "skyblue3", lwd = 3)
# lines(pval,fp_prior2_in, col = "hotpink")
# lines(pval,fp_post2, col = "hotpink3", lwd = 3)
# lines(pval,fp_prior3_in, col = "olivedrab1")
# lines(pval,fp_post3, col = "olivedrab3", lwd = 3)
# text(0.15, 0.125, td$year[sim+1],cex = 3) # adds the year to the plot

# the following lines are merely to slow the loop down so that
# we can actually see how the posterior develops - uncomment of needed
# if (sim < 4) {Sys.sleep(1.5)}
# else if (sim < 10) {Sys.sleep(0.5)}
# else {Sys.sleep(0.05)}
}</pre>
Let's compare the priors and the posteriors

<pre class="r">plot(pval,fp_prior1_in, col = "skyblue", ylim = c(0,0.15), type = "l" ,xlab="pval", ylab="density", main = "Posterior Distributions")
lines(pval,fp_post1, col = "skyblue3", lwd = 3)
lines(pval,fp_prior2_in, col = "hotpink")
lines(pval,fp_post2, col = "hotpink3", lwd = 3)
lines(pval,fp_prior3_in, col = "olivedrab1")
lines(pval,fp_post3, col = "olivedrab3", lwd = 3)
text(0.15, 0.125, td$year[sim+1],cex = 3) # adds the year to the plot</pre>
[[File:Posteriors.png|frame|none|alt=|Posterior distributions for priors 1, 2 and 3.]]

== Posterior probabilities for hypothesis ==

So let's ask again the fundamental question. What is the probability that the parameter <math>\pi</math> has a value <math>>0.5</math>? Recall that in a classical framework we cannot get this value! Here we will "merely" have to read off probabilities from the posterior distributions.

<pre class="r">print("POSTERIOR PROBABILITIES")</pre>
<pre>## [1] "POSTERIOR PROBABILITIES"</pre>
<pre class="r">pp1 <- round(sum(fp_post1[pval>0.5]),4)
print("Prior 1")</pre>
<pre>## [1] "Prior 1"</pre>
<pre class="r">print(paste0("P(pi > 0.5) = ",pp1))</pre>
<pre>## [1] "P(pi > 0.5) = 0.2019"</pre>
<pre class="r">pp2 <- round(sum(fp_post2[pval>0.5]),4)
print("Prior 2")</pre>
<pre>## [1] "Prior 2"</pre>
<pre class="r">print(paste0("P(pi > 0.5) = ",pp2))</pre>
<pre>## [1] "P(pi > 0.5) = 0.9471"</pre>
<pre class="r">pp3 <- round(sum(fp_post3[pval>0.5]),4)
print("Prior 3")</pre>
<pre>## [1] "Prior 3"</pre>
<pre class="r">print(paste0("P(pi > 0.5) = ",pp3))</pre>
<pre>## [1] "P(pi > 0.5) = 0.7624"</pre>
Let's show these probabilities graphically.

<pre class="r">par(mfrow=c(1,3)) # tell R to put figures into (1 x 3) matrix

plot(pval,fp_post1, col = "skyblue3", xlim = c(0.3,0.7), ylim = c(0,0.15),lwd = 3, type = "l" , xlab="pval", ylab="density", main = "P(pi >0.5|data), Prior 1, N(0.4,0.05^2)")
cord.x <- c(0.51,seq(0.51,1,0.01),1)
cord.y <- c(0,fp_post1[pval>0.5],0)
polygon(cord.x,cord.y,col='skyblue')
text(0.6, 0.025, pp1,cex = 3) # adds the prob

plot(pval,fp_post2, col = "hotpink3", xlim = c(0.3,0.7), ylim = c(0,0.15),lwd = 3, type = "l" , xlab="pval", ylab="density", main = "P(pi >0.5|data), Prior 2, N(0.6,0.05^2)")
cord.x <- c(0.51,seq(0.51,1,0.01),1)
cord.y <- c(0,fp_post2[pval>0.5],0)
polygon(cord.x,cord.y,col='plum1')
text(0.6, 0.025, pp2,cex = 3) # adds the prob

plot(pval,fp_post3, col = "olivedrab3", xlim = c(0.3,0.7), ylim = c(0,0.15),lwd = 3, type = "l" , xlab="pval", ylab="density", main = "P(pi >0.5|data), Prior 1, U(0,1)")
cord.x <- c(0.51,seq(0.51,1,0.01),1)
cord.y <- c(0,fp_post3[pval>0.5],0)
polygon(cord.x,cord.y,col='darkolivegreen1')
text(0.6, 0.025, pp3,cex = 3) # adds the prob</pre>
[[File:PosteriorProbs.png|frame|none|alt=|Posterior probabilities that pi > 0.5.]]

<pre class="r">par(mfrow=c(1,1)) # tell R to put figures into (1 x 3) matrix</pre>