human
I am working on the file "SC1v2/Bonus - 11 - BVP linear and nonlinear with Finite Difference and the Shooting Method.ipynb".
The first task is:
<div id='example3s' />

Example 3
Back to toc
Considere que tiene la siguiente colección de datos:
\begin{align}
    {(t_1, y_1),(t_2,y_2),\dots,(t_n,y_n)},
\end{align}
donde sabemos que $0 \leq t_i \leq 100$ para $i\in{1,2,\dots,n}$.
Una aproximación tradicional de mínimos cuadrados requeriría proponer una función $y(t)$, por ejemplo lineal $a+b\,t$, para minimizar el error cuadrático, $E=\sum_{i=1}^n \left(y(t_i)-y_i\right)^2$.
Esto nos entregaría los coeficientes de la estructura propuesta para $y(t)$.
La mayor desventaja de este procedimiento es que tenemos que conocer a priori la estructura algebraica de $y(t)$.
Una alternativa sería construir numéricamente una aproximación de $y(t)$, por ejemplo reemplazando la minimización por un problema de valor inicial, para lo cual se propone el siguiente IVP,
\begin{align}
    \dot{y}(t) &= \gamma\,\tanh\left(\dfrac{\displaystyle\sum_{t_i\in[t-T,t]} (y_i-y(t))}{\gamma}\right),\
    y(0)       &= y_1,
\end{align}
donde $\gamma=1$.
1. Implemente el solver. 
2. ¿Se suaviza la data?
3. ¿Cómo depende la aproximación en función de $T$?
4. ¿Cómo depende la aproximación en función de $\gamma$?
Nota: Si el conjunto $t_i\in[t-T,t]$ es vacio, entonces el lado derecho de $\dot{y}(t)$ se considera que es $0$.
Can you write Python code for it?

Can you provide a the Python code you requested?
assistant
#Here is the Python code you requested.

'''
input:
N         : (integer) número de puntos en la discretización espacial del intervalo [0,100]
Tw        : (double)  ventana deslizante utilizada en la sumatoria [t-Tw,t]
gamma     : (double)  coeficiente usado en conjunto con tanh
Ti        : (double) tiempo inicial de simulación
Tf        : (double) tiempo final de simulación
ti        : (ndarray) ti data de entrada
yi        : (ndarray) yi data de entrada

output:
t_out        : (ndarray) discretización equiespaciada de N puntos t
y_out        : (ndarray) aproximación numérica de y(t) en los puntos ti
'''
def solve_almost_LS_IVP(N,Tw,gamma,Ti,Tf,ti,yi):
    # Your own code.
    return t_out, y_out

# Consider the following data
np.random.seed(0)
Ndata    = 1000
ti       = np.linspace(0,100,Ndata)
yi       = 0.2*np.cos(2*ti)+np.sin(0.1*ti)+0.1*np.random.rand(Ndata)

'''
input:
N         : (integer) número de puntos en la discretización espacial del intervalo [0,100]
Tw        : (double)  ventana deslizante utilizada en la sumatoria [t-Tw,t]
gamma     : (double)  coeficiente usado en conjunto con tanh
Ti        : (double) tiempo inicial de simulación
Tf        : (double) tiempo final de simulación
ti        : (ndarray) ti data de entrada
yi        : (ndarray) yi data de entrada

output:
t_out        : (ndarray) discretización equiespaciada de N puntos t
y_out        : (ndarray) aproximación numérica de y(t) en los puntos ti
'''
def solve_almost_LS_IVP(N,Tw,gamma,Ti,Tf,ti,yi):
    def my_f(t,y):
        ysample = yi[np.logical_and((t-Tw)<ti,ti<t)]
        if len(ysample)>=1:
            return gamma*np.tanh((np.sum(ysample)-len(ysample)*y)/gamma)
        else:
            return 0
    sol = solve_ivp(my_f,(Ti,Tf),(yi[0],),t_eval=np.linspace(Ti,Tf,N))
    t_out = sol.t
    y_out = sol.y[0]
    return t_out, y_out

def show_output_LS_IVP(Tw=3,gamma=1):
    N        = 10000
    Ti       = 0
    Tf       = 120
    t_out, y_out = solve_almost_LS_IVP(N,Tw,gamma,Ti,Tf,ti,yi)

    plt.figure(figsize=(16,8))
    plt.plot(ti,yi,'.',label=r'$y_i$')
   ...