def predict(self, vdf: vDataFrame, X: list=[], ts: str='', nlead: int=0, name: list=[]):
    '\n    ---------------------------------------------------------------------------\n    Predicts using the input relation.\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    nlead: int, optional\n        Number of records to predict after the last ts date.\n    name: list, optional\n        Names of the added vcolumns. If empty, names will be generated.\n\n    Returns\n    -------\n    vDataFrame\n        object including the prediction.\n        '
    check_types([('name', name, [list]), ('ts', ts, [str]), ('nlead', nlead, [int, float]), ('X', X, [list]), ('vdf', vdf, [vDataFrame])])
    if (not ts):
        ts = self.ts
    if (not X):
        X = self.X
    columns_check((X + [ts]), vdf)
    X = vdf_columns_names(X, vdf)
    ts = vdf_columns_names([ts], vdf)[0]
    (all_pred, names) = ([], [])
    transform_relation = self.transform_relation.replace('[VerticaPy_ts]', self.ts)
    for (idx, elem) in enumerate(X):
        name_tmp = (('{}_'.format(self.type) + ''.join((ch for ch in elem if ch.isalnum()))) if (len(name) != len(X)) else name[idx])
        all_pred += ['{} AS {}'.format(self.deploySQL()[idx], name_tmp)]
        transform_relation = transform_relation.replace('[X{}]'.format(idx), elem)
    columns = (vdf.get_columns() + all_pred)
    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(', '.join(self.deploySQL()), transform_relation.format(relation_tmp), ts)
        prediction = vdf._VERTICAPY_VARIABLES_['cursor'].execute(query).fetchone()
        for (idx, elem) in enumerate(X):
            prediction[idx] = '{} AS {}'.format(prediction[idx], elem)
        columns_tmp = vdf.get_columns(exclude_columns=([ts] + X))
        new_line = "SELECT '{}'::TIMESTAMP AS {}, {} {}".format(next_t, ts, ', '.join(prediction), ((', ' if columns_tmp else '') + ', '.join(['NULL AS {}'.format(column) for column in columns_tmp])))
        relation = '(SELECT {} FROM {} UNION ALL ({})) VERTICAPY_SUBTABLE'.format(', '.join((([ts] + X) + vdf.get_columns(exclude_columns=([ts] + X)))), relation, new_line)
    final_relation = '(SELECT {} FROM {}) VERTICAPY_SUBTABLE'.format(', '.join(columns), transform_relation.format(relation))
    result = vdf_from_relation(final_relation, 'VAR', self.cursor)
    if (nlead > 0):
        for elem in X:
            result[elem].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.
X: list, optional
    List of the response columns.
ts: str, optional
    vcolumn used to order the data.
nlead: int, optional
    Number of records to predict after the last ts date.
name: list, optional
    Names of the added vcolumns. If empty, names will be generated.

Returns
-------
vDataFrame
    object including the prediction.
def predict(self, vdf: vDataFrame, X: list=[], ts: str=, nlead: int=0, name: list=[]):
    '\n    ---------------------------------------------------------------------------\n    Predicts using the input relation.\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    nlead: int, optional\n        Number of records to predict after the last ts date.\n    name: list, optional\n        Names of the added vcolumns. If empty, names will be generated.\n\n    Returns\n    -------\n    vDataFrame\n        object including the prediction.\n        '
    check_types([('name', name, [list]), ('ts', ts, [str]), ('nlead', nlead, [int, float]), ('X', X, [list]), ('vdf', vdf, [vDataFrame])])
    if (not ts):
        ts = self.ts
    if (not X):
        X = self.X
    columns_check((X + [ts]), vdf)
    X = vdf_columns_names(X, vdf)
    ts = vdf_columns_names([ts], vdf)[0]
    (all_pred, names) = ([], [])
    transform_relation = self.transform_relation.replace('[VerticaPy_ts]', self.ts)
    for (idx, elem) in enumerate(X):
        name_tmp = (('{}_'.format(self.type) + .join((ch for ch in elem if ch.isalnum()))) if (len(name) != len(X)) else name[idx])
        all_pred += ['{} AS {}'.format(self.deploySQL()[idx], name_tmp)]
        transform_relation = transform_relation.replace('[X{}]'.format(idx), elem)
    columns = (vdf.get_columns() + all_pred)
    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(', '.join(self.deploySQL()), transform_relation.format(relation_tmp), ts)
        prediction = vdf._VERTICAPY_VARIABLES_['cursor'].execute(query).fetchone()
        for (idx, elem) in enumerate(X):
            prediction[idx] = '{} AS {}'.format(prediction[idx], elem)
        columns_tmp = vdf.get_columns(exclude_columns=([ts] + X))
        new_line = "SELECT '{}'::TIMESTAMP AS {}, {} {}".format(next_t, ts, ', '.join(prediction), ((', ' if columns_tmp else ) + ', '.join(['NULL AS {}'.format(column) for column in columns_tmp])))
        relation = '(SELECT {} FROM {} UNION ALL ({})) VERTICAPY_SUBTABLE'.format(', '.join((([ts] + X) + vdf.get_columns(exclude_columns=([ts] + X)))), relation, new_line)
    final_relation = '(SELECT {} FROM {}) VERTICAPY_SUBTABLE'.format(', '.join(columns), transform_relation.format(relation))
    result = vdf_from_relation(final_relation, 'VAR', self.cursor)
    if (nlead > 0):
        for elem in X:
            result[elem].apply("CASE WHEN {} >= '{}' THEN NULL ELSE {} END".format(ts, first_t, '{}'))
    return result