def predict(self, vdf: vDataFrame, y: str='', ts: str='', X: list=[], nlead: int=0, name: str=''):
    '\n    ---------------------------------------------------------------------------\n    Predicts using the input relation.\n\n    Parameters\n    ----------\n    vdf: vDataFrame\n        Object to use to run the prediction.\n    y: str, optional\n        Response column.\n    ts: str, optional\n        vcolumn used to order the data.\n    X: list, optional\n        exogenous vcolumns.\n    nlead: int, optional\n        Number of records to predict after the last ts date.\n    name: str, optional\n        Name of the added vcolumn. If empty, a name will be generated.\n\n    Returns\n    -------\n    vDataFrame\n        object including the prediction.\n        '
    check_types([('name', name, [str]), ('y', y, [str]), ('ts', ts, [str]), ('X', X, [list]), ('nlead', nlead, [int, float]), ('vdf', vdf, [vDataFrame])])
    if (not y):
        y = self.y
    if (not ts):
        ts = self.ts
    if (not X):
        X = self.exogenous
    columns_check([y, ts], vdf)
    (y, ts) = vdf_columns_names([y, ts], vdf)
    name = (('{}_'.format(self.type) + ''.join((ch for ch in self.name if ch.isalnum()))) if (not name) else name)
    key_columns = (', ' + ', '.join(vdf.get_columns(exclude_columns=[y])))
    transform_relation = self.transform_relation.replace('[VerticaPy_y]', y).replace('[VerticaPy_ts]', ts)
    transform_relation = transform_relation.replace('[VerticaPy_key_columns]', key_columns)
    predictSQL = (self.deploySQL().replace('[VerticaPy_y]', y).replace('[VerticaPy_ts]', ts) + ' AS {}'.format(name))
    for (idx, elem) in enumerate(X):
        transform_relation = transform_relation.replace('[X{}]'.format(idx), elem)
        predictSQL = predictSQL.replace('[X{}]'.format(idx), elem)
    columns = ((vdf.get_columns(exclude_columns=[y]) + [predictSQL]) + ['VerticaPy_y_copy AS {}'.format(y)])
    relation = vdf.__genSQL__()
    for i in range(nlead):
        query = 'SELECT ({} - LAG({}, 1) OVER (ORDER BY {}))::VARCHAR FROM {} ORDER BY {} DESC LIMIT 1'.format(ts, ts, ts, relation, ts)
        deltat = vdf._VERTICAPY_VARIABLES_['cursor'].execute(query).fetchone()[0]
        query = "SELECT (MAX({}) + '{}'::interval)::VARCHAR FROM {}".format(ts, deltat, relation)
        next_t = vdf._VERTICAPY_VARIABLES_['cursor'].execute(query).fetchone()[0]
        if (i == 0):
            first_t = next_t
        new_line = "SELECT '{}'::TIMESTAMP AS {}, {}".format(next_t, ts, ', '.join(['NULL AS {}'.format(column) for column in vdf.get_columns(exclude_columns=[ts])]))
        relation_tmp = '(SELECT {} FROM {} UNION ALL ({})) VERTICAPY_SUBTABLE'.format(', '.join(([ts] + vdf.get_columns(exclude_columns=[ts]))), relation, new_line)
        query = 'SELECT {} FROM {} ORDER BY {} DESC LIMIT 1'.format(self.deploySQL().replace('[VerticaPy_y]', y).replace('[VerticaPy_ts]', ts), transform_relation.format(relation_tmp), ts)
        prediction = vdf._VERTICAPY_VARIABLES_['cursor'].execute(query).fetchone()[0]
        columns_tmp = vdf.get_columns(exclude_columns=[ts, y])
        new_line = "SELECT '{}'::TIMESTAMP AS {}, {} AS {} {}".format(next_t, ts, prediction, y, ((', ' if columns_tmp else '') + ', '.join(['NULL AS {}'.format(column) for column in columns_tmp])))
        relation = '(SELECT {} FROM {} UNION ALL ({})) VERTICAPY_SUBTABLE'.format(', '.join(([ts, y] + vdf.get_columns(exclude_columns=[ts, y]))), relation, new_line)
    final_relation = '(SELECT {} FROM {}) VERTICAPY_SUBTABLE'.format(', '.join(columns), transform_relation.format(relation))
    result = vdf_from_relation(final_relation, 'SARIMAX', self.cursor)
    if (nlead > 0):
        result[y].apply("CASE WHEN {} >= '{}' THEN NULL ELSE {} END".format(ts, first_t, '{}'))
    return result
---------------------------------------------------------------------------
Predicts using the input relation.

Parameters
----------
vdf: vDataFrame
    Object to use to run the prediction.
y: str, optional
    Response column.
ts: str, optional
    vcolumn used to order the data.
X: list, optional
    exogenous vcolumns.
nlead: int, optional
    Number of records to predict after the last ts date.
name: str, optional
    Name of the added vcolumn. If empty, a name will be generated.

Returns
-------
vDataFrame
    object including the prediction.
def predict(self, vdf: vDataFrame, y: str=, ts: str=, X: list=[], nlead: int=0, name: str=):
    '\n    ---------------------------------------------------------------------------\n    Predicts using the input relation.\n\n    Parameters\n    ----------\n    vdf: vDataFrame\n        Object to use to run the prediction.\n    y: str, optional\n        Response column.\n    ts: str, optional\n        vcolumn used to order the data.\n    X: list, optional\n        exogenous vcolumns.\n    nlead: int, optional\n        Number of records to predict after the last ts date.\n    name: str, optional\n        Name of the added vcolumn. If empty, a name will be generated.\n\n    Returns\n    -------\n    vDataFrame\n        object including the prediction.\n        '
    check_types([('name', name, [str]), ('y', y, [str]), ('ts', ts, [str]), ('X', X, [list]), ('nlead', nlead, [int, float]), ('vdf', vdf, [vDataFrame])])
    if (not y):
        y = self.y
    if (not ts):
        ts = self.ts
    if (not X):
        X = self.exogenous
    columns_check([y, ts], vdf)
    (y, ts) = vdf_columns_names([y, ts], vdf)
    name = (('{}_'.format(self.type) + .join((ch for ch in self.name if ch.isalnum()))) if (not name) else name)
    key_columns = (', ' + ', '.join(vdf.get_columns(exclude_columns=[y])))
    transform_relation = self.transform_relation.replace('[VerticaPy_y]', y).replace('[VerticaPy_ts]', ts)
    transform_relation = transform_relation.replace('[VerticaPy_key_columns]', key_columns)
    predictSQL = (self.deploySQL().replace('[VerticaPy_y]', y).replace('[VerticaPy_ts]', ts) + ' AS {}'.format(name))
    for (idx, elem) in enumerate(X):
        transform_relation = transform_relation.replace('[X{}]'.format(idx), elem)
        predictSQL = predictSQL.replace('[X{}]'.format(idx), elem)
    columns = ((vdf.get_columns(exclude_columns=[y]) + [predictSQL]) + ['VerticaPy_y_copy AS {}'.format(y)])
    relation = vdf.__genSQL__()
    for i in range(nlead):
        query = 'SELECT ({} - LAG({}, 1) OVER (ORDER BY {}))::VARCHAR FROM {} ORDER BY {} DESC LIMIT 1'.format(ts, ts, ts, relation, ts)
        deltat = vdf._VERTICAPY_VARIABLES_['cursor'].execute(query).fetchone()[0]
        query = "SELECT (MAX({}) + '{}'::interval)::VARCHAR FROM {}".format(ts, deltat, relation)
        next_t = vdf._VERTICAPY_VARIABLES_['cursor'].execute(query).fetchone()[0]
        if (i == 0):
            first_t = next_t
        new_line = "SELECT '{}'::TIMESTAMP AS {}, {}".format(next_t, ts, ', '.join(['NULL AS {}'.format(column) for column in vdf.get_columns(exclude_columns=[ts])]))
        relation_tmp = '(SELECT {} FROM {} UNION ALL ({})) VERTICAPY_SUBTABLE'.format(', '.join(([ts] + vdf.get_columns(exclude_columns=[ts]))), relation, new_line)
        query = 'SELECT {} FROM {} ORDER BY {} DESC LIMIT 1'.format(self.deploySQL().replace('[VerticaPy_y]', y).replace('[VerticaPy_ts]', ts), transform_relation.format(relation_tmp), ts)
        prediction = vdf._VERTICAPY_VARIABLES_['cursor'].execute(query).fetchone()[0]
        columns_tmp = vdf.get_columns(exclude_columns=[ts, y])
        new_line = "SELECT '{}'::TIMESTAMP AS {}, {} AS {} {}".format(next_t, ts, prediction, y, ((', ' if columns_tmp else ) + ', '.join(['NULL AS {}'.format(column) for column in columns_tmp])))
        relation = '(SELECT {} FROM {} UNION ALL ({})) VERTICAPY_SUBTABLE'.format(', '.join(([ts, y] + vdf.get_columns(exclude_columns=[ts, y]))), relation, new_line)
    final_relation = '(SELECT {} FROM {}) VERTICAPY_SUBTABLE'.format(', '.join(columns), transform_relation.format(relation))
    result = vdf_from_relation(final_relation, 'SARIMAX', self.cursor)
    if (nlead > 0):
        result[y].apply("CASE WHEN {} >= '{}' THEN NULL ELSE {} END".format(ts, first_t, '{}'))
    return result