├── economic_data.xlsx
├── FactorAugmentedVAR.py
├── Functions.py
└── copper_price_forecast.ipynb


/economic_data.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/HoagieT/Factor-Augmented-Vector-Autoregression/HEAD/economic_data.xlsx


--------------------------------------------------------------------------------
/FactorAugmentedVAR.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | """
  3 | Created on Sat Nov 14 23:00:48 2020
  4 | 
  5 | @author: Hogan Tong
  6 | """
  7 | 
  8 | from Functions import *
  9 | from scipy.interpolate import interp1d
 10 | import numpy as np
 11 | import matplotlib.pyplot as plt
 12 | import pandas as pd
 13 | import os
 14 | from datetime import datetime
 15 | import tkinter.filedialog
 16 | from datetime import timedelta
 17 | import math 
 18 | import time
 19 | import calendar
 20 | from numba import jit
 21 | from sklearn.metrics import mean_squared_error
 22 | from statsmodels.tsa.api import VAR
 23 | import scipy
 24 | import statsmodels.tsa.stattools as ts
 25 | import statsmodels.tsa as tsa
 26 | import matplotlib.pyplot as plt
 27 | import numpy as np
 28 | import sklearn
 29 | from sklearn.metrics import mean_squared_error, r2_score
 30 | import statsmodels.api as sm
 31 | from datetime import datetime,timedelta
 32 | from statsmodels.tsa.stattools import adfuller
 33 | from numpy.linalg import cholesky
 34 | 
 35 | def Factor(Y, X_slow, n_factors, X_fast='None'):
 36 |     #n_time = len(Y.index)
 37 |     n_var = len(Y.columns)
 38 |     if isinstance(X_fast,str)==True:
 39 |         hist = Y.join(X_slow)
 40 |     else:
 41 |         hist = Y.join(X_slow).join(X_fast)
 42 |     
 43 |     hist=hist.dropna(axis=0,how='any')
 44 | 
 45 |     "step 1 - PCA on all observable variables"
 46 |     x = np.mat(hist - hist.mean())
 47 |     z = np.mat((hist - hist.mean())/hist.std())
 48 |     D, V, S = calculate_pca(hist, n_factors + n_var)
 49 |     Psi = np.mat(np.diag(np.diag(S - V.dot(D).dot(V.T))))
 50 |     factors = V.T.dot(z.T).T
 51 |     C = pd.DataFrame(data=factors, index=hist.index, columns=['C' + str(i+1) for i in range(n_factors+n_var)])
 52 |     Loadings_C = calculate_factor_loadings(hist, C)
 53 |     
 54 |     "step 2 - PCA on slow moving variables"
 55 |     x = np.mat(X_slow-X_slow.mean())
 56 |     z = np.mat((X_slow-X_slow.mean())/X_slow.std())
 57 |     D, V, S = calculate_pca(X_slow, n_factors)
 58 |     Psi = np.mat(np.diag(np.diag(S - V.dot(D).dot(V.T))))
 59 |     factors = V.T.dot(z.T).T
 60 |     F_minus = pd.DataFrame(data=factors, index=X_slow.index, columns=['F_minus' + str(i+1) for i in range(n_factors)])
 61 |     Loadings_F_slow = calculate_factor_loadings(X_slow, F_minus)
 62 |     
 63 |     "step 3 - C_t = b1*Y_t + b2*F_t"
 64 |     X = Y.join(F_minus)
 65 |     B = calculate_factor_loadings(C, X)
 66 |     Lambda_y, Lambda_f = B[:,0:n_var], B[:,n_var:]
 67 |     # F_t= Lambda_f^-1*(C_t-Lambda_y*Y_t)
 68 |     F = Lambda_f.I.dot((np.mat(C).T - Lambda_y.dot(Y.T))).T
 69 |     F = pd.DataFrame(data=F, index=X_slow.index, columns=['F' + str(i+1) for i in range(n_factors)])
 70 | 
 71 |     return FactorResultsWrapper(C=C, Lambda_c=Loadings_C, F_minus=F_minus, F=F)
 72 |     
 73 | class FactorResultsWrapper():
 74 |     def __init__(self, C, Lambda_c, F_minus, F):
 75 |         self.C = C
 76 |         self.Lambda_c = Lambda_c
 77 |         self.F_minus = F_minus
 78 |         self.F = F
 79 | 
 80 | def FAVAR(Factor, Y, lag):
 81 |     hist = Y.join(Factor)
 82 |     model=VAR(hist,missing='drop').fit(lag,trend='nc')
 83 |  
 84 |     return FAVARResultsWrapper(VAR=model)
 85 |     
 86 | class FAVARResultsWrapper():
 87 |     def __init__(self, VAR):
 88 |         self.VAR = VAR
 89 |     
 90 |     def summary(self):
 91 |         print(self.VAR.summary())
 92 |         return
 93 |     
 94 |     def predict(self, Factor, Y, step, freq='M', alpha=0.05):
 95 |         hist = Y.join(Factor)
 96 |         [forecast_mean,forecast_low,forecast_up] = self.VAR.forecast_interval(hist.values, step, alpha)
 97 |         mean = np.concatenate((hist.values, forecast_mean), axis=0)
 98 |         up = np.concatenate((hist.values, forecast_up), axis=0)
 99 |         low = np.concatenate((hist.values, forecast_low), axis=0)
100 |         
101 |         
102 |         dates = pd.date_range(Y.index[0], periods=len(Y.index)+step,freq=freq)
103 |         
104 |         mean = pd.DataFrame(data=mean[:,0:len(Y.columns)], columns=Y.columns.tolist(), index=dates)
105 |         low = pd.DataFrame(data=low[:,0:len(Y.columns)], columns=Y.columns.tolist(), index=dates)
106 |         up = pd.DataFrame(data=up[:,0:len(Y.columns)], columns=Y.columns.tolist(), index=dates)
107 |         
108 |         return [mean,low,up]
109 |     
110 |     def predict_plot(self, Factor, Y, step, freq='M', alpha=0.05, figure_size=[18,12],line_width=3.0,font_size='xx-large', actural='None'):
111 |         mean, low, up = self.predict(Factor, Y, step, freq, alpha)
112 |         n_var = len(mean.columns)
113 |         n_act = len(Y.index)
114 |         
115 |         plt.rcParams['figure.figsize'] = (figure_size[0], figure_size[1])
116 |         plt.rcParams['lines.markersize'] = 6
117 |         plt.rcParams['image.cmap'] = 'gray'
118 |         
119 |         for i in range(n_var):
120 |             plt.figure()
121 |             plt.plot(mean.index[n_act-1:],mean.iloc[n_act-1:,i],color='r',label='forecast', linewidth=line_width)
122 |             plt.plot(mean.index[:n_act],mean.iloc[:n_act,i],color='k',label='observed',linewidth=line_width)
123 |             plt.plot(mean.index[n_act-1:],low.iloc[n_act-1:,i],color='r', linestyle = '--', label='lower - '+str(int(100-alpha*100))+'%',linewidth=line_width)
124 |             plt.plot(mean.index[n_act-1:],up.iloc[n_act-1:,i],color='r', linestyle = ':', label='upper - '+str(int(100-alpha*100))+'%',linewidth=line_width)
125 |             plt.legend()
126 |             if isinstance(actural,str)!=True:
127 |                 plt.plot(mean.index[n_act-1:],actural.iloc[:,i],color='k',label='observed', linewidth=line_width)
128 |             plt.title(mean.columns[i], fontweight='bold', fontsize=font_size)
129 |             #plt.xlabel('Date')
130 |             #plt.ylabel('Value')
131 |             plt.show()
132 |         
133 |         return
134 | 


--------------------------------------------------------------------------------
/Functions.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | """
  3 | Created on Fri Nov 13 21:45:00 2020
  4 | 
  5 | @author: Hogan Tong
  6 | """
  7 | from scipy.interpolate import interp1d
  8 | import numpy as np
  9 | import matplotlib.pyplot as plt
 10 | import pandas as pd
 11 | import os
 12 | from datetime import datetime
 13 | import tkinter.filedialog
 14 | from datetime import timedelta
 15 | import math 
 16 | import time
 17 | import calendar
 18 | from numba import jit
 19 | from sklearn.metrics import mean_squared_error
 20 | import scipy
 21 | import statsmodels.tsa.stattools as ts
 22 | import statsmodels.tsa as tsa
 23 | import matplotlib.pyplot as plt
 24 | import numpy as np
 25 | import sklearn
 26 | from sklearn.metrics import mean_squared_error, r2_score
 27 | import statsmodels.api as sm
 28 | from datetime import datetime,timedelta
 29 | 
 30 | def import_data(file_name, sheet_name, start=0, interpolation=False, encoding='gb18030'):
 31 |     Temp = pd.read_excel(file_name, sheet_name, encoding = encoding)
 32 |     res = Temp.iloc[start:,1:]
 33 |     res.index = Temp.iloc[start:,0]
 34 |     if interpolation==True:
 35 |         res = DataInterpolation(res, 0, len(res.index), 'cubic').dropna(axis=0,how='any')
 36 |     return res
 37 | 
 38 | def DataInterpolation(data, start, end, method):
 39 |     # data must be a time series dataframe
 40 |     n_row = len(data.index)
 41 |     n_col = len(data.columns)
 42 |     res = np.array(np.zeros(shape=(n_row,n_col)))
 43 |     
 44 |     for i in range(n_col):
 45 |         res[:,i] = np.array(data.iloc[:,i]).T
 46 |         y=data.iloc[start:end,i]
 47 |         location = np.where(y.notnull())[0]
 48 |         upper_bound=max(location)
 49 |         lower_bound=min(location)
 50 |         f2 = interp1d(location, y[y.notnull()], kind=method)
 51 |         x = np.linspace(lower_bound, upper_bound, num=upper_bound-lower_bound, endpoint=False)
 52 |         res[lower_bound:upper_bound,i]=np.array(f2(x)).T
 53 |     
 54 |     res = pd.DataFrame(res, index=data.index, columns=data.columns)
 55 |     
 56 |     return res
 57 | 
 58 | def rand_Matrix(n_row, n_col):
 59 |     randArr = np.random.randn(n_row, n_col)
 60 |     randMat = np.mat(randArr)
 61 |     return randMat
 62 | 
 63 | 
 64 | def calculate_factor_loadings(observables, factors):
 65 |     # Both dataframes should have the same time stamp
 66 |     n_time = len(observables.index)
 67 |     x = np.mat(observables-observables.mean())
 68 |     F=np.mat(factors)
 69 |     temp = F[0].T.dot(F[0])
 70 |     for i in range(1,n_time):
 71 |         temp = temp + F[i].T.dot(F[i])
 72 |     
 73 |     Lambda = x[0].T.dot(F[0]).dot(temp.I)
 74 |     for i in range(1,n_time):
 75 |         Lambda = Lambda + x[i].T.dot(F[i]).dot(temp.I)
 76 |         
 77 |     return Lambda
 78 | 
 79 | def calculate_prediction_matrix(factors):
 80 |     n_time = len(factors.index)
 81 |     F=np.mat(factors)
 82 |     
 83 |     temp = F[0].T.dot(F[0])
 84 |     for i in range(2,n_time):
 85 |         temp = temp + F[i-1].T.dot(F[i-1])
 86 |     
 87 |     A = F[1].T.dot(F[0]).dot(temp.I)
 88 |     for i in range(2,n_time):
 89 |         A = A + F[i].T.dot(F[i-1]).dot(temp.I)
 90 |     
 91 |     return A
 92 | 
 93 | def calculate_shock_matrix(factors, prediction_matrix, n_shocks):
 94 |     n_time = len(factors.index)
 95 |     F = np.mat(factors)
 96 |     A = prediction_matrix
 97 |     
 98 |     temp = F[0].T.dot(F[0])
 99 |     for i in range(2,n_time):
100 |         temp = temp + F[i-1].T.dot(F[i-1])
101 |     
102 |     term1 = F[1].T.dot(F[1])
103 |     for i in range(2,n_time):
104 |         term1 = term1 + F[i].T.dot(F[i])
105 |     term1 = term1/(n_time-1)
106 |     term2 = A.dot(temp/(n_time-1)).dot(A.T)
107 |     Sigma = term1 - term2
108 |     
109 |     eigenvalues, eigenvectors = np.linalg.eig(Sigma)
110 |     sorted_indices = np.argsort(eigenvalues)
111 |     evalues = eigenvalues[sorted_indices[:-n_shocks-1:-1]]
112 |     M = eigenvectors[:,sorted_indices[:-n_shocks-1:-1]]
113 |     B = M.dot(np.diag(pow(evalues,0.5)))
114 |     
115 |     return B, Sigma
116 | 
117 | def calculate_pca(observables, n_factors):
118 |     # syntax: 
119 |     n_time = len(observables.index)
120 |     x = np.mat(observables-observables.mean())
121 |     z = np.mat((observables-observables.mean())/observables.std())
122 |     
123 |     S = z[0].T.dot(z[0])
124 |     for i in range(1,n_time):
125 |         S = S + z[i].T.dot(z[i])
126 |     
127 |     eigenvalues, eigenvectors = np.linalg.eig(S)
128 |     sorted_indices = np.argsort(eigenvalues)
129 |     evalues = eigenvalues[sorted_indices[:-n_factors-1:-1]]
130 |     V = np.mat(eigenvectors[:,sorted_indices[:-n_factors-1:-1]])
131 |     D = np.diag(evalues)
132 |     
133 |     return D, V, S
134 |     
135 | def calculate_covariance(factors):
136 |     n_time = len(factors.index)
137 |     F = np.mat(factors)
138 |     temp = [factors.iloc[:,i] for i in range(len(factors.columns))]
139 |     return np.cov(temp)
140 | 
141 | def plot_double_axis(x1,x2, label1, label2, title=False, shift1=0,shift2=0, fig_size=[24,16], line_width=3.0,font_size='xx-large', legend_size=12, grid=False, legend_loc=(1,1)):
142 |     plt.rcParams['figure.figsize'] = (fig_size[0], fig_size[1])
143 |     plt.rcParams['lines.markersize'] = 6
144 |     plt.rcParams['legend.fontsize'] = legend_size
145 |     plt.rcParams['font.sans-serif']=['SimHei']
146 |     plt.rcParams['axes.unicode_minus'] = False
147 | 
148 |     fig = plt.figure()
149 |     plt.grid(grid)
150 |     ax1 = fig.add_subplot(111)
151 |     Label1 = label1
152 |     if shift1 > 0:
153 |         Label1 = label1 + '-lag'+ str(shift1)
154 |     line1=ax1.plot(x1.index, x1.shift(shift1).values,color='k',label=Label1, linewidth=line_width,zorder=-1)
155 |     #ax1.legend(loc=2)
156 |     
157 |     ax2 = ax1.twinx()
158 |     Label2 = label2
159 |     if shift2 > 0:
160 |         Label2 = label2 + '-lag'+ str(shift2)
161 |     line2=ax2.plot(x2.index, x2.shift(shift2).values,color='r',label=Label2, linewidth=line_width,zorder=1)
162 |     #ax2.legend(loc=1)
163 |     #plt.legend(loc=1)
164 |     if title!=False:
165 |         plt.title(title, fontweight='bold', fontsize=font_size)
166 |     
167 |     #ax1.legend(loc=2)
168 |     fig.legend( bbox_to_anchor=legend_loc, bbox_transform=ax2.transAxes)
169 |     plt.show()
170 |     
171 |     return
172 | 
173 | def data_transform(data, method):
174 |     # 0 - no transformation
175 |     # 1 - first difference
176 |     # 2 - 12th difference
177 |     # 3 - logarithm
178 |     # 4 - first difference of logarithm
179 |     if len(data.columns) != len(method):
180 |         return print('Does not match')
181 |     
182 |     data_transformed = pd.DataFrame(data=np.nan, index=data.index, columns=data.columns)
183 |     columns = data.columns.tolist()
184 |     
185 |     for i in range(len(data.columns)):
186 |         if method[i] == 0:
187 |             data_transformed.iloc[:,i] = data.iloc[:,i]
188 |         if method[i] == 1:
189 |             data_transformed.iloc[:,i] = data.iloc[:,i].diff(1)
190 |             columns[i] = columns[i] +'.D1'
191 |         if method[i] == 2:
192 |             data_transformed.iloc[:,i] = data.iloc[:,i].diff(12)
193 |             columns[i] = columns[i] +'.D12'
194 |         if method[i] == 3:
195 |             data_transformed.iloc[:,i] = np.log(data.iloc[:,i])
196 |             columns[i] = 'Log.' + columns[i]
197 |         if method[i] == 4:
198 |             data_transformed.iloc[:,i] = np.log(data.iloc[:,i]).diff(1)
199 |             columns[i] = 'Log.' + columns[i] + '.D1'
200 |     
201 |     data_transformed.columns = columns
202 |     
203 |     return data_transformed
204 |             
205 |             


--------------------------------------------------------------------------------
/copper_price_forecast.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "<h4> 1. Methodology Description </h4>\n",
  8 |     "\n",
  9 |     "In this script, I used a factor augmented vector autoregression (FAVAR) model to forecast copper price. FAVAR was first developed by Bernanke, Boivin and Eliasz (2004) to estimate the impact of monetary policy. Vanguard later applied this model to create the Vanguard Capital Market Model to forecast asset prices. Plese refer to https://www.nber.org/system/files/working_papers/w10220/w10220.pdf for detailed explaination of the model.\n",
 10 |     "\n",
 11 |     "The mechanism is simple: the math behind FAVAR and classic VAR are the same. But unlike VAR, which can only take  a few variables, FAVAR can incorporate a very large data set and reduce them to a few factors using principal component analysis.\n",
 12 |     "\n",
 13 |     "Principal component analysis is an algorithm that finds a few common factors that can explain the most variation in the underlying data. It is like taking a two-dimensional photo for a three-dimentinal person. We can take the photo from many angles. Some angles can clearly identify the person, e.g. the front anglge, and others lose a lot of critical information, e.g. the back angle. Principal component analysis is an algorithm that finds the best shooting angle when we take a x-dimentional photo for a N-dimentional data set (x<<N). \n",
 14 |     "\n",
 15 |     "Then, we combine variables of interest, which in our case is the copper price, and the common factors to run the classical VAR regression. With this framework, we can include as many variables as possible and can even expand the model to a big data setting.\n",
 16 |     "\n",
 17 |     "The model also allows us to impose restrictions on the factors. Some economic indicators move synchronously with copper price, others lead or lag copper price movement. To implement this identification scheme, it is useful to define two categories of variables, “slow-moving” and “fast-moving”. A “slow-moving” variable is one that is largely predetermined as of the current period, while a “fast-moving” variable – think of an asset price – is highly sensitive to contemporaneous economic news or shocks.\n",
 18 |     "\n",
 19 |     "Please refer to the FactorAugmentedVAR.py for more details on model execution."
 20 |    ]
 21 |   },
 22 |   {
 23 |    "cell_type": "code",
 24 |    "execution_count": 1,
 25 |    "metadata": {},
 26 |    "outputs": [],
 27 |    "source": [
 28 |     "from FactorAugmentedVAR import *\n",
 29 |     "from Functions import *\n",
 30 |     "from datetime import *\n",
 31 |     "import warnings\n",
 32 |     "warnings.filterwarnings('ignore')"
 33 |    ]
 34 |   },
 35 |   {
 36 |    "cell_type": "markdown",
 37 |    "metadata": {},
 38 |    "source": [
 39 |     "<h4> 2. Data Description </h4>\n",
 40 |     "\n",
 41 |     "The four largest metal consumers are US, China, Germany and Japan. Therefore, I included some of the most important economic indicators of these four companies in the data set.\n",
 42 |     "\n",
 43 |     "I took out the data of January and February of China because of the Spring Festical anomaly and use interpolations instead. This is a common practice when studying China's economic indicators because the Spring Festival can be either in Januray or February.\n",
 44 |     "\n",
 45 |     "Missing data are all replaced with interpolation. Alternatively, we can also use Kalman Filter to estimate the missing data. I included a KalmanFilter.py in the files. For simplicity, I didn't use Kalman Filter for this exercise.\n",
 46 |     "\n",
 47 |     "All data was transformed to make times series stationary."
 48 |    ]
 49 |   },
 50 |   {
 51 |    "cell_type": "code",
 52 |    "execution_count": 3,
 53 |    "metadata": {},
 54 |    "outputs": [],
 55 |    "source": [
 56 |     "\"Data Import\"\n",
 57 |     "file_name='economic_data.xlsx'\n",
 58 |     "sheet_name='transformed_vintage'\n",
 59 |     "Temp = pd.read_excel(file_name, sheet_name, encoding = 'gb18030')\n",
 60 |     "vintage_transformed = Temp.iloc[:,1:]\n",
 61 |     "vintage_transformed.index = Temp.iloc[:,0]\n",
 62 |     "\n",
 63 |     "\"Data Interpolation\"\n",
 64 |     "vintage_intrpl = DataInterpolation(vintage_transformed[1:], 0, len(vintage_transformed.index), 'slinear').dropna(axis=0,how='any')\n",
 65 |     "\n",
 66 |     "# vintage_intrpl"
 67 |    ]
 68 |   },
 69 |   {
 70 |    "cell_type": "markdown",
 71 |    "metadata": {},
 72 |    "source": [
 73 |     "<h4> 3. Copper Price Prediction </h4>\n"
 74 |    ]
 75 |   },
 76 |   {
 77 |    "cell_type": "markdown",
 78 |    "metadata": {},
 79 |    "source": [
 80 |     "<h4> Step 1: Calculate common factors </h4>\n",
 81 |     "Common factors for all variables, i.e. copper price, fast moving variables and slow moving variables, are denoted by C. Common factors calculated from slow moving variables are denoted by F. The variable of interest, i.e. copper price, is denoted by Y."
 82 |    ]
 83 |   },
 84 |   {
 85 |    "cell_type": "code",
 86 |    "execution_count": 4,
 87 |    "metadata": {},
 88 |    "outputs": [],
 89 |    "source": [
 90 |     "\"Factor Calculation\"\n",
 91 |     "factor = Factor(Y=pd.DataFrame(vintage_intrpl.iloc[:,0]), X_slow=vintage_intrpl.iloc[:,14:], n_factors=3, X_fast=vintage_intrpl.iloc[:,1:14])\n",
 92 |     "\n",
 93 |     "#factor.C.plot()\n",
 94 |     "#factor.F.plot()"
 95 |    ]
 96 |   },
 97 |   {
 98 |    "cell_type": "markdown",
 99 |    "metadata": {},
100 |    "source": [
101 |     "<h4> Step 2: SVAR on F and Y </h4>\n",
102 |     "Run the classic structural vector autoregression on Y and F."
103 |    ]
104 |   },
105 |   {
106 |    "cell_type": "code",
107 |    "execution_count": 5,
108 |    "metadata": {},
109 |    "outputs": [],
110 |    "source": [
111 |     "favar = FAVAR(Factor=factor.F, Y=pd.DataFrame(vintage_intrpl.iloc[:,0]), lag=3)\n",
112 |     "# favar.VAR.summary()"
113 |    ]
114 |   },
115 |   {
116 |    "cell_type": "markdown",
117 |    "metadata": {},
118 |    "source": [
119 |     "<h4> Step 3: Plot prediction </h4>"
120 |    ]
121 |   },
122 |   {
123 |    "cell_type": "code",
124 |    "execution_count": 6,
125 |    "metadata": {},
126 |    "outputs": [
127 |     {
128 |      "data": {
129 |       "image/png": "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\n",
130 |       "text/plain": [
131 |        "<Figure size 648x432 with 1 Axes>"
132 |       ]
133 |      },
134 |      "metadata": {
135 |       "needs_background": "light"
136 |      },
137 |      "output_type": "display_data"
138 |     }
139 |    ],
140 |    "source": [
141 |     "mean, low, up = favar.predict(Factor=factor.F[-5:], Y=pd.DataFrame(vintage_intrpl.iloc[-5:,0]), step=20)\n",
142 |     "\n",
143 |     "favar.predict_plot(Factor=factor.F[-5:], Y=pd.DataFrame(vintage_intrpl.iloc[-10:,0]), step=12, freq='M', alpha=0.8, figure_size=[9,6],line_width=3.0,font_size='xx-large', actural='None')"
144 |    ]
145 |   },
146 |   {
147 |    "cell_type": "markdown",
148 |    "metadata": {},
149 |    "source": [
150 |     "From the char above, copper price should soon reach its cyclical peak and start to decrease."
151 |    ]
152 |   },
153 |   {
154 |    "cell_type": "code",
155 |    "execution_count": null,
156 |    "metadata": {},
157 |    "outputs": [],
158 |    "source": []
159 |   }
160 |  ],
161 |  "metadata": {
162 |   "celltoolbar": "Raw Cell Format",
163 |   "kernelspec": {
164 |    "display_name": "Python 3",
165 |    "language": "python",
166 |    "name": "python3"
167 |   },
168 |   "language_info": {
169 |    "codemirror_mode": {
170 |     "name": "ipython",
171 |     "version": 3
172 |    },
173 |    "file_extension": ".py",
174 |    "mimetype": "text/x-python",
175 |    "name": "python",
176 |    "nbconvert_exporter": "python",
177 |    "pygments_lexer": "ipython3",
178 |    "version": "3.8.3"
179 |   }
180 |  },
181 |  "nbformat": 4,
182 |  "nbformat_minor": 4
183 | }
184 | 


--------------------------------------------------------------------------------