Stock Prediction with LorenzANN

def approximate_nearest_neighbors(df, y_col, x_cols, sampling_factor=4, neighber_count=8, look_back_period=80):
    '''
    1. The algorithm iterates through the dataset (df) in chronological order, 
    using the modulo operator to only perform calculations every sampling_factor bars, where sampling_factor= 4. 

    2. This serves the dual purpose of reducing the computational overhead of the algorithm 
        and ensuring a minimum chronological spacing between the neighbors of at least sampling_factor bars, 
        where sampling_factor = 4. 

    3. A list of the k-similar neighbors is simultaneously maintained in both 
    a predictions array and corresponding distances array. 
    When the size of the predictions array exceeds the desired number of nearest 
    neighbors specified in neighber_count, where neighber_count=8, 
    the algorithm removes the first neighbor from the predictions array 
    and the corresponding distance array.

    4. The lastDistance variable is overriden to be a distance in the lower 25% of the array. 
    This step helps to boost overall accuracy by ensuring subsequent newly added distance values increase at a slower rate.
    '''
    assert len(df)> look_back_period

    res = [None]* look_back_period
    for i in tqdm(range(look_back_period, len(df))):
        row = df.iloc[i]
        predictions = []
        distances = []
        last_dist = -1
        for pre_i in range(i-look_back_period, i):
            # sampling
            if pre_i % sampling_factor == 0:
                pre_row = df.iloc[pre_i]
                # Calculate Lorentzian distance and add to distances array
                distance = lorentzian_distance(row[x_cols].values, pre_row[x_cols].values)
                if distance > last_dist:
                    distances.append(distance)
                    # Add prediction to predictions array
                    predictions.append(np.round(df[y_col].iloc[i]))

                # If number of neighbors is greater than neighber_count, remove the first neighbor
                if len(predictions) > neighber_count:
                    predictions = predictions[1:]
                    distances = distances[1:]

                # Override last_dist to be a distance in the lower 25% of the array
                # this is like the time-decay factor 
                if distances:
                    last_dist = np.percentile(distances, 25)
        res.append(np.mean(predictions))
    return res