Llevo un tiempo respondiendo ¿Cómo discretizo una función continua evitando la generación de ruido? (ver foto) , y en todo momento sentí que estaba reinventando una bicicleta.

Esencialmente, el problema es:

• Se le da una función de curva: para cualquier x , puede obtener y .
• Desea aproximar la curva utilizando una función lineal por partes con exactamente N puntos, en función de alguna métrica de error, por ejemplo, la distancia a la curva, o minimizar la diferencia absoluta del área debajo de las curvas (gracias a @QuangHoang por señalar que estos son diferente).

Aquí hay un ejemplo de una curva que aproximé usando 20 puntos:

Pregunta : He codificado esto usando bisecciones repetidas. ¿Hay una biblioteca que podría haber usado? ¿Hay un buen término de este tipo de problema que no pude buscar en Google? ¿Esto se generaliza a un conjunto de problemas más amplio?

Editar: a pedido, así es como lo hice: Google Colab

Datos:

 import numpy as np from scipy.signal import gaussian N_MOCK = 2000 # A nice-ish mock distribution xs = np.linspace(-10.0, 10.0, num=N_MOCK) sigmoid = 1 / (1 + np.exp(-xs)) gauss = gaussian(N_MOCK, std=N_MOCK / 10) ys = gauss - sigmoid + 1 xs += 10 xs /= 20

Graficado:

 import matplotlib.pyplot as plt def plot_graph(cont_time, cont_array, disc_time, disc_array, plot_name): """A simplified version of the provided plotting function""" # Setting Axis properties and titles fig, ax = plt.subplots(figsize=(20, 4)) ax.set_title(plot_name) # Plotting stuff ax.plot(cont_time, cont_array, label="Continuous", color='#0000ff') ax.plot(disc_time, disc_array, label="Discrete", color='#00ff00') fig.legend(loc="upper left", bbox_to_anchor=(0,1), bbox_transform=ax.transAxes)

Así es como lo resolví, pero espero que haya una forma más estándar:

 import warnings warnings.simplefilter('ignore', np.RankWarning) def line_error(x0, y0, x1, y1, ideal_line, integral_points=100): """Assume a straight line between (x0,y0)->(x1,p1). Then sample the perfect line multiple times and compute the distance.""" straight_line = np.poly1d(np.polyfit([x0, x1], [y0, y1], 1)) xs = np.linspace(x0, x1, num=integral_points) ys = straight_line(xs) perfect_ys = ideal_line(xs) err = np.abs(ys - perfect_ys).sum() / integral_points * (x1 - x0) # Remove (x1 - x0) to only look at avg errors return err def discretize_bisect(xs, ys, bin_count): """Returns xs and ys of discrete points""" # For a large number of datapoints, without loss of generality you can treat xs and ys as bin edges # If it gives bad results, you can edges in many ways, eg with np.polyline or np.histogram_bin_edges ideal_line = np.poly1d(np.polyfit(xs, ys, 50)) new_xs = [xs[0], xs[-1]] new_ys = [ys[0], ys[-1]] while len(new_xs) < bin_count: errors = [] for i in range(len(new_xs)-1): err = line_error(new_xs[i], new_ys[i], new_xs[i+1], new_ys[i+1], ideal_line) errors.append(err) max_segment_id = np.argmax(errors) new_x = (new_xs[max_segment_id] + new_xs[max_segment_id+1]) / 2 new_y = ideal_line(new_x) new_xs.insert(max_segment_id+1, new_x) new_ys.insert(max_segment_id+1, new_y) return new_xs, new_ys

Correr:

 BIN_COUNT = 25 new_xs, new_ys = discretize_bisect(xs, ys, BIN_COUNT) plot_graph(xs, ys, new_xs, new_ys, f"Discretized and Continuous comparison, N(cont) = {N_MOCK}, N(disc) = {BIN_COUNT}") print("Bin count:", len(new_xs))

Nota: aunque prefiero numpy , la respuesta puede ser una biblioteca en cualquier idioma o el nombre del término matemático. Por favor, no escriba mucho código, ya que lo he hecho yo mismo :)