def plot(self, vdf: vDataFrame=None, X: list=[], ts: str='', X_idx: int=0, dynamic: bool=False, one_step: bool=True, observed: bool=True, confidence: bool=True, nlead: int=10, nlast: int=0, limit: int=1000, ax=None, **style_kwds):
    '\n    ---------------------------------------------------------------------------\n    Draws the VAR model.\n\n    Parameters\n    ----------\n    vdf: vDataFrame\n        Object to use to run the prediction.\n    X: list, optional\n        List of the response columns.\n    ts: str, optional\n        vcolumn used to order the data.\n    X_idx: int, optional\n        Index of the main vector vcolumn to draw. It can also be the name of a \n        predictor vcolumn.\n    dynamic: bool, optional\n        If set to True, the dynamic forecast will be drawn.\n    one_step: bool, optional\n        If set to True, the one step ahead forecast will be drawn.\n    observed: bool, optional\n        If set to True, the observation will be drawn.\n    confidence: bool, optional\n        If set to True, the confidence ranges will be drawn.\n    nlead: int, optional\n        Number of predictions computed by the dynamic forecast after\n        the last ts date.\n    nlast: int, optional\n        The dynamic forecast will start nlast values before the last\n        ts date.\n    limit: int, optional\n        Maximum number of past elements to use.\n    ax: Matplotlib axes object, optional\n        The axes to plot on.\n    **style_kwds\n        Any optional parameter to pass to the Matplotlib functions.\n\n    Returns\n    -------\n    ax \n        Matplotlib axes object\n        '
    if (not vdf):
        vdf = vdf_from_relation(relation=self.input_relation, cursor=self.cursor)
    check_types([('limit', limit, [int, float]), ('nlead', nlead, [int, float]), ('X_idx', X_idx, [int, float, str]), ('dynamic', dynamic, [bool]), ('observed', observed, [bool]), ('one_step', one_step, [bool]), ('confidence', confidence, [bool]), ('vdf', vdf, [vDataFrame])])
    (delta_limit, limit) = (limit, max(max(limit, ((self.parameters['p'] + 1) + nlast)), 200))
    delta_limit = max(((limit - delta_limit) - nlast), 0)
    if (not ts):
        ts = self.ts
    if (not X):
        X = self.X
    assert (dynamic or one_step or observed), ParameterError('No option selected.\n You should set either dynamic, one_step or observed to True.')
    assert (((nlead + nlast) > 0) or (not dynamic)), ParameterError("Dynamic Plots are only possible if either parameter 'nlead' is greater than 0 or parameter 'nlast' is greater than 0, and parameter 'dynamic' is set to True.")
    if isinstance(X_idx, str):
        X_idx = str_column(X_idx).lower()
        for (idx, elem) in enumerate(X):
            if (str_column(elem).lower() == X_idx):
                X_idx = idx
                break
    assert (isinstance(X_idx, (float, int)) and (len(self.X) > X_idx >= 0)), ParameterError("The index of the vcolumn to draw 'X_idx' must be between 0 and {}. It can also be the name of a predictor vcolumn.".format(len(self.X)))
    result_all = self.predict(vdf=vdf, X=X, ts=ts, nlead=0, name=['_verticapy_prediction_{}_'.format(idx) for idx in range(len(self.X))])
    (y, prediction) = (X[X_idx], '_verticapy_prediction_{}_'.format(X_idx))
    error_eps = (1.96 * math.sqrt(self.score(method='mse').values['mse'][X_idx]))
    print_info = verticapy.options['print_info']
    verticapy.options['print_info'] = False
    try:
        result = result_all.select([ts, y, prediction]).dropna().sort([ts]).tail(limit).values
    except:
        verticapy.options['print_info'] = print_info
        raise
    verticapy.options['print_info'] = print_info
    columns = [elem for elem in result]
    if isinstance(result[columns[0]][0], str):
        result[columns[0]] = [parse(elem) for elem in result[columns[0]]]
    true_value = [result[columns[0]], result[columns[1]]]
    one_step_ahead = [result[columns[0]], result[columns[2]]]
    (lower_osa, upper_osa) = ([((float(elem) - error_eps) if (elem != None) else None) for elem in one_step_ahead[1]], [((float(elem) + error_eps) if (elem != None) else None) for elem in one_step_ahead[1]])
    if dynamic:
        print_info = verticapy.options['print_info']
        verticapy.options['print_info'] = False
        try:
            result = result_all.select(([ts] + X)).dropna().sort([ts]).tail(limit).values
        except:
            verticapy.options['print_info'] = print_info
            raise
        verticapy.options['print_info'] = print_info
        columns = [elem for elem in result]
        if isinstance(result[columns[0]][0], str):
            result[columns[0]] = [parse(elem) for elem in result[columns[0]]]
        deltat = (result[columns[0]][(- 1)] - result[columns[0]][(- 2)])
        (lead_time_list, lead_list) = ([], [])
        if (nlast > 0):
            for i in range(len(result[columns[0]][:(- nlast)])):
                lead_list += [[result[elem][i] for elem in columns[1:]]]
        else:
            for i in range(len(result[columns[0]])):
                lead_list += [[result[elem][i] for elem in columns[1:]]]
        for i in range(nlast):
            lead_list += [self.fpredict(lead_list)]
            lead_time_list += [result[columns[0]][(i - nlast)]]
        if lead_time_list:
            start_time = lead_time_list[(- 1)]
        else:
            start_time = result[columns[0]][(- 1)]
        for i in range(nlead):
            lead_list += [self.fpredict(lead_list)]
            lead_time_list += [(start_time + ((i + 1) * deltat))]
        dynamic_forecast = (([result[columns[0]][((- nlast) - 1)]] + lead_time_list), ([result[columns[(1 + X_idx)]][((- nlast) - 1)]] + [elem[X_idx] for elem in lead_list[((- nlast) - nlead):]]))
        (lower_d, upper_d) = ([], [])
        for i in range(len(dynamic_forecast[1])):
            delta_error = (error_eps * math.sqrt((i + 1)))
            lower_d += [(float(dynamic_forecast[1][i]) - delta_error)]
            upper_d += [(float(dynamic_forecast[1][i]) + delta_error)]
    else:
        (lower_d, upper_d, dynamic_forecast) = ([], [], ([], []))
    alpha = 0.3
    if (not ax):
        (fig, ax) = plt.subplots()
        if isnotebook():
            fig.set_size_inches(10, 6)
        ax.grid()
    colors = gen_colors()
    param1 = {'color': colors[2], 'linewidth': 2}
    param2 = {'color': colors[3], 'linewidth': 2, 'linestyle': ':'}
    param3 = {'color': colors[0], 'linewidth': 2, 'linestyle': 'dashed'}
    if dynamic:
        ax.fill_between(dynamic_forecast[0], (1.02 * float(min(((true_value[1] + dynamic_forecast[1]) + one_step_ahead[1])))), (1.02 * float(max(((true_value[1] + dynamic_forecast[1]) + one_step_ahead[1])))), alpha=0.04, color=updated_dict(param3, style_kwds, 2)['color'])
        if confidence:
            ax.fill_between(dynamic_forecast[0], lower_d, upper_d, alpha=0.08, color='#555555')
            ax.plot(dynamic_forecast[0], lower_d, alpha=0.08, color='#000000')
            ax.plot(dynamic_forecast[0], upper_d, alpha=0.08, color='#000000')
        ax.plot(dynamic_forecast[0], dynamic_forecast[1], label='Dynamic Forecast', **updated_dict(param3, style_kwds, 2))
    if one_step:
        if confidence:
            ax.fill_between(one_step_ahead[0][delta_limit:], lower_osa[delta_limit:], upper_osa[delta_limit:], alpha=0.04, color='#555555')
            ax.plot(one_step_ahead[0][delta_limit:], lower_osa[delta_limit:], alpha=0.04, color='#000000')
            ax.plot(one_step_ahead[0][delta_limit:], upper_osa[delta_limit:], alpha=0.04, color='#000000')
        ax.plot(one_step_ahead[0][delta_limit:], one_step_ahead[1][delta_limit:], label='One-step ahead Forecast', **updated_dict(param2, style_kwds, 1))
    if observed:
        ax.plot(true_value[0][delta_limit:], true_value[1][delta_limit:], label='Observed', **updated_dict(param1, style_kwds, 0))
    ax.set_title('VAR({}) [{}]'.format(self.parameters['p'], y))
    ax.set_xlabel(ts)
    ax.legend(loc='center left', bbox_to_anchor=[1, 0.5])
    ax.set_ylim((1.02 * float(min(((true_value[1] + dynamic_forecast[1]) + one_step_ahead[1])))), (1.02 * float(max(((true_value[1] + dynamic_forecast[1]) + one_step_ahead[1])))))
    for tick in ax.get_xticklabels():
        tick.set_rotation(90)
    return ax
---------------------------------------------------------------------------
Draws the VAR model.

Parameters
----------
vdf: vDataFrame
    Object to use to run the prediction.
X: list, optional
    List of the response columns.
ts: str, optional
    vcolumn used to order the data.
X_idx: int, optional
    Index of the main vector vcolumn to draw. It can also be the name of a 
    predictor vcolumn.
dynamic: bool, optional
    If set to True, the dynamic forecast will be drawn.
one_step: bool, optional
    If set to True, the one step ahead forecast will be drawn.
observed: bool, optional
    If set to True, the observation will be drawn.
confidence: bool, optional
    If set to True, the confidence ranges will be drawn.
nlead: int, optional
    Number of predictions computed by the dynamic forecast after
    the last ts date.
nlast: int, optional
    The dynamic forecast will start nlast values before the last
    ts date.
limit: int, optional
    Maximum number of past elements to use.
ax: Matplotlib axes object, optional
    The axes to plot on.
**style_kwds
    Any optional parameter to pass to the Matplotlib functions.

Returns
-------
ax 
    Matplotlib axes object
def plot(self, vdf: vDataFrame=None, X: list=[], ts: str=, X_idx: int=0, dynamic: bool=False, one_step: bool=True, observed: bool=True, confidence: bool=True, nlead: int=10, nlast: int=0, limit: int=1000, ax=None, **style_kwds):
    '\n    ---------------------------------------------------------------------------\n    Draws the VAR model.\n\n    Parameters\n    ----------\n    vdf: vDataFrame\n        Object to use to run the prediction.\n    X: list, optional\n        List of the response columns.\n    ts: str, optional\n        vcolumn used to order the data.\n    X_idx: int, optional\n        Index of the main vector vcolumn to draw. It can also be the name of a \n        predictor vcolumn.\n    dynamic: bool, optional\n        If set to True, the dynamic forecast will be drawn.\n    one_step: bool, optional\n        If set to True, the one step ahead forecast will be drawn.\n    observed: bool, optional\n        If set to True, the observation will be drawn.\n    confidence: bool, optional\n        If set to True, the confidence ranges will be drawn.\n    nlead: int, optional\n        Number of predictions computed by the dynamic forecast after\n        the last ts date.\n    nlast: int, optional\n        The dynamic forecast will start nlast values before the last\n        ts date.\n    limit: int, optional\n        Maximum number of past elements to use.\n    ax: Matplotlib axes object, optional\n        The axes to plot on.\n    **style_kwds\n        Any optional parameter to pass to the Matplotlib functions.\n\n    Returns\n    -------\n    ax \n        Matplotlib axes object\n        '
    if (not vdf):
        vdf = vdf_from_relation(relation=self.input_relation, cursor=self.cursor)
    check_types([('limit', limit, [int, float]), ('nlead', nlead, [int, float]), ('X_idx', X_idx, [int, float, str]), ('dynamic', dynamic, [bool]), ('observed', observed, [bool]), ('one_step', one_step, [bool]), ('confidence', confidence, [bool]), ('vdf', vdf, [vDataFrame])])
    (delta_limit, limit) = (limit, max(max(limit, ((self.parameters['p'] + 1) + nlast)), 200))
    delta_limit = max(((limit - delta_limit) - nlast), 0)
    if (not ts):
        ts = self.ts
    if (not X):
        X = self.X
    assert (dynamic or one_step or observed), ParameterError('No option selected.\n You should set either dynamic, one_step or observed to True.')
    assert (((nlead + nlast) > 0) or (not dynamic)), ParameterError("Dynamic Plots are only possible if either parameter 'nlead' is greater than 0 or parameter 'nlast' is greater than 0, and parameter 'dynamic' is set to True.")
    if isinstance(X_idx, str):
        X_idx = str_column(X_idx).lower()
        for (idx, elem) in enumerate(X):
            if (str_column(elem).lower() == X_idx):
                X_idx = idx
                break
    assert (isinstance(X_idx, (float, int)) and (len(self.X) > X_idx >= 0)), ParameterError("The index of the vcolumn to draw 'X_idx' must be between 0 and {}. It can also be the name of a predictor vcolumn.".format(len(self.X)))
    result_all = self.predict(vdf=vdf, X=X, ts=ts, nlead=0, name=['_verticapy_prediction_{}_'.format(idx) for idx in range(len(self.X))])
    (y, prediction) = (X[X_idx], '_verticapy_prediction_{}_'.format(X_idx))
    error_eps = (1.96 * math.sqrt(self.score(method='mse').values['mse'][X_idx]))
    print_info = verticapy.options['print_info']
    verticapy.options['print_info'] = False
    try:
        result = result_all.select([ts, y, prediction]).dropna().sort([ts]).tail(limit).values
    except:
        verticapy.options['print_info'] = print_info
        raise
    verticapy.options['print_info'] = print_info
    columns = [elem for elem in result]
    if isinstance(result[columns[0]][0], str):
        result[columns[0]] = [parse(elem) for elem in result[columns[0]]]
    true_value = [result[columns[0]], result[columns[1]]]
    one_step_ahead = [result[columns[0]], result[columns[2]]]
    (lower_osa, upper_osa) = ([((float(elem) - error_eps) if (elem != None) else None) for elem in one_step_ahead[1]], [((float(elem) + error_eps) if (elem != None) else None) for elem in one_step_ahead[1]])
    if dynamic:
        print_info = verticapy.options['print_info']
        verticapy.options['print_info'] = False
        try:
            result = result_all.select(([ts] + X)).dropna().sort([ts]).tail(limit).values
        except:
            verticapy.options['print_info'] = print_info
            raise
        verticapy.options['print_info'] = print_info
        columns = [elem for elem in result]
        if isinstance(result[columns[0]][0], str):
            result[columns[0]] = [parse(elem) for elem in result[columns[0]]]
        deltat = (result[columns[0]][(- 1)] - result[columns[0]][(- 2)])
        (lead_time_list, lead_list) = ([], [])
        if (nlast > 0):
            for i in range(len(result[columns[0]][:(- nlast)])):
                lead_list += [[result[elem][i] for elem in columns[1:]]]
        else:
            for i in range(len(result[columns[0]])):
                lead_list += [[result[elem][i] for elem in columns[1:]]]
        for i in range(nlast):
            lead_list += [self.fpredict(lead_list)]
            lead_time_list += [result[columns[0]][(i - nlast)]]
        if lead_time_list:
            start_time = lead_time_list[(- 1)]
        else:
            start_time = result[columns[0]][(- 1)]
        for i in range(nlead):
            lead_list += [self.fpredict(lead_list)]
            lead_time_list += [(start_time + ((i + 1) * deltat))]
        dynamic_forecast = (([result[columns[0]][((- nlast) - 1)]] + lead_time_list), ([result[columns[(1 + X_idx)]][((- nlast) - 1)]] + [elem[X_idx] for elem in lead_list[((- nlast) - nlead):]]))
        (lower_d, upper_d) = ([], [])
        for i in range(len(dynamic_forecast[1])):
            delta_error = (error_eps * math.sqrt((i + 1)))
            lower_d += [(float(dynamic_forecast[1][i]) - delta_error)]
            upper_d += [(float(dynamic_forecast[1][i]) + delta_error)]
    else:
        (lower_d, upper_d, dynamic_forecast) = ([], [], ([], []))
    alpha = 0.3
    if (not ax):
        (fig, ax) = plt.subplots()
        if isnotebook():
            fig.set_size_inches(10, 6)
        ax.grid()
    colors = gen_colors()
    param1 = {'color': colors[2], 'linewidth': 2}
    param2 = {'color': colors[3], 'linewidth': 2, 'linestyle': ':'}
    param3 = {'color': colors[0], 'linewidth': 2, 'linestyle': 'dashed'}
    if dynamic:
        ax.fill_between(dynamic_forecast[0], (1.02 * float(min(((true_value[1] + dynamic_forecast[1]) + one_step_ahead[1])))), (1.02 * float(max(((true_value[1] + dynamic_forecast[1]) + one_step_ahead[1])))), alpha=0.04, color=updated_dict(param3, style_kwds, 2)['color'])
        if confidence:
            ax.fill_between(dynamic_forecast[0], lower_d, upper_d, alpha=0.08, color='#555555')
            ax.plot(dynamic_forecast[0], lower_d, alpha=0.08, color='#000000')
            ax.plot(dynamic_forecast[0], upper_d, alpha=0.08, color='#000000')
        ax.plot(dynamic_forecast[0], dynamic_forecast[1], label='Dynamic Forecast', **updated_dict(param3, style_kwds, 2))
    if one_step:
        if confidence:
            ax.fill_between(one_step_ahead[0][delta_limit:], lower_osa[delta_limit:], upper_osa[delta_limit:], alpha=0.04, color='#555555')
            ax.plot(one_step_ahead[0][delta_limit:], lower_osa[delta_limit:], alpha=0.04, color='#000000')
            ax.plot(one_step_ahead[0][delta_limit:], upper_osa[delta_limit:], alpha=0.04, color='#000000')
        ax.plot(one_step_ahead[0][delta_limit:], one_step_ahead[1][delta_limit:], label='One-step ahead Forecast', **updated_dict(param2, style_kwds, 1))
    if observed:
        ax.plot(true_value[0][delta_limit:], true_value[1][delta_limit:], label='Observed', **updated_dict(param1, style_kwds, 0))
    ax.set_title('VAR({}) [{}]'.format(self.parameters['p'], y))
    ax.set_xlabel(ts)
    ax.legend(loc='center left', bbox_to_anchor=[1, 0.5])
    ax.set_ylim((1.02 * float(min(((true_value[1] + dynamic_forecast[1]) + one_step_ahead[1])))), (1.02 * float(max(((true_value[1] + dynamic_forecast[1]) + one_step_ahead[1])))))
    for tick in ax.get_xticklabels():
        tick.set_rotation(90)
    return ax