<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def learning_entropy(w, m=10, order=1, alpha=False):
 """ This function estimates Learning Entropy. **Args:** * `w` : history of adaptive parameters of an adaptive model (2d array), every row represents parameters in given time index. **Kwargs:** * `m` : window size (1d array) - how many last samples are used for evaluation of every sample. * `order` : order of the LE (int) - order of weights differention * `alpha` : list of senstitivites (1d array). If not provided, the LE direct approach is used. **Returns:** * Learning Entropy of data (1 d array) - one value for every sample """

    w = np.array(w)
    # get length of data and number of parameters
    N = w.shape[0]
    n = w.shape[1]
    # get abs dw from w
    dw = np.copy(w)
    dw[order:] = np.abs(np.diff(dw, n=order, axis=0))
    # average floting window - window is k-m ... k-1
    awd = np.zeros(w.shape)
    if not alpha:
        # estimate the ALPHA with multiscale approach
        swd = np.zeros(w.shape)
        for k in range(m, N):
            awd[k] = np.mean(dw[k-m:k], axis=0)
            swd[k] = np.std(dw[k-m:k], axis=0)
        # estimate the points of entropy
        eps = 1e-10 # regularization term
        le  = (dw - awd) / (swd+eps)
    else:
        # estimate the ALPHA with direct approach
        for k in range(m, N):
            awd[k] = np.mean(dw[k-m:k], axis=0)
        # estimate the points of entropy
        alphas = np.array(alpha)
        fh = np.zeros(N)
        for alpha in alphas:
            fh += np.sum(awd*alpha < dw, axis=1)
        le = fh / float(n*len(alphas))
    # clear unknown zone on begining
    le[:m] = 0
    # return output
    return le