Exemplo n.º 1
0
def threshold_generator(waveform, bins):
    try:
        new_waveform = np.abs(waveform[:, 0])
    except:
        new_waveform = np.abs(waveform)

    new_waveform_hist, new_waveform_bin = np.histogram(new_waveform, bins=bins)
    s_max = (0, -10)
    len_of_new_waveform_hist = len(new_waveform_hist)
    for th in range(len(new_waveform_hist) + 1):

        n1 = npsum(new_waveform_hist[:th])
        n2 = npsum(new_waveform_hist[th:])

        if n1 == 0:
            mu1 = 0
        else:
            mu1 = npsum(np.arange(0, th) * new_waveform_hist[0:th]) / n1
        if n2 == 0:
            mu2 = 0
        else:
            mu2 = npsum(
                np.arange(th, len_of_new_waveform_hist) *
                new_waveform_hist[th:len_of_new_waveform_hist]) / n2

        s = n1 * n2 * (mu1 - mu2)**2
        if s > s_max[1]:
            s_max = (th, s)

    return s_max[0]
Exemplo n.º 2
0
def _autocorr_func2(mags, lag, maglen, magmed, magstd):
    '''
    This is an alternative function to calculate the autocorrelation.

    mags MUST be an array with no nans.

    lag is the current lag to calculate the autocorr for. MUST be less than the
    total number of observations in mags (maglen).

    maglen, magmed, magstd are provided by auto_correlation below.

    This version is from (first definition):

    https://en.wikipedia.org/wiki/Correlogram#Estimation_of_autocorrelations

    '''

    lagindex = nparange(0, maglen - lag)
    products = (mags[lagindex] - magmed) * (mags[lagindex + lag] - magmed)

    autocovarfunc = npsum(products) / lagindex.size
    varfunc = npsum(
        (mags[lagindex] - magmed) * (mags[lagindex] - magmed)) / mags.size

    acorr = autocovarfunc / varfunc

    return acorr
Exemplo n.º 3
0
def _replace_missing_values_in_matrix(all_data, missing_value_indicator, data_max_missing_values, samples_max_missing_values, replace = False, col_names=None, row_names=None):
    number_of_data, number_of_samples = all_data.shape
    na_count_per_sample  = zeros(number_of_samples)
    data_indices_to_remove = []
    print "Replacing missing values by mean..."
    
    na_count_per_sample = npsum(isnan(all_data), axis=0)
    samples_indices_to_keep = where(na_count_per_sample <= samples_max_missing_values*number_of_data)[0]
    print("%s samples were not replaced because they have more than %s missing values" % (number_of_samples - len(samples_indices_to_keep), samples_max_missing_values))

    na_count_per_site = npsum(isnan(all_data), axis=1)
    sites_indices_to_keep = where(na_count_per_site <= data_max_missing_values*number_of_samples)[0]
    print("%s sites were not replaced because they have more than %s missing values" % (number_of_data - len(sites_indices_to_keep), data_max_missing_values))

    print("replacing each missing value by it's site mean...")
    all_data =  all_data[sites_indices_to_keep, :][:,samples_indices_to_keep]
    sites_mean = nanmean(all_data, axis=1)
    for i, data_for_all_samples in enumerate(all_data):
        na_indices = where(isnan(all_data[i,:]))[0]
        all_data[i][na_indices] = sites_mean[i]
   
    # return the relevant samples ids and sites ids
    if col_names is not None:
        col_names = col_names[samples_indices_to_keep]

    if row_names is not None:
        row_names = row_names[sites_indices_to_keep]

    return all_data, col_names, row_names
Exemplo n.º 4
0
def chaowangjost(counts):
    """Entropy calculation using Chao, Wang, Jost correction.
    doi: 10.1111/2041-210X.12108

    Parameters
    ----------
    counts : list
        bin counts
    Returns
    -------
    entropy : float
    """
    n_samples = npsum(counts)
    bcbc = bincount(counts.astype(int))
    if len(bcbc) < 3:
        return grassberger(counts)
    if bcbc[2] == 0:
        if bcbc[1] == 0:
            A = 1.
        else:
            A = 2. / ((n_samples - 1.) * (bcbc[1] - 1.) + 2.)
    else:
        A = 2. * bcbc[2] / ((n_samples - 1.) * (bcbc[1] - 1.) +
                            2. * bcbc[2])
    pr = arange(1, int(n_samples))
    pr = 1. / pr * (1. - A) ** pr
    entropy = npsum(counts / n_samples * (psi(n_samples) -
                    nan_to_num(psi(counts))))

    if bcbc[1] > 0 and A != 1.:
        entropy += nan_to_num(bcbc[1] / n_samples *
                              (1 - A) ** (1 - n_samples *
                                          (-log(A) - npsum(pr))))
    return entropy
Exemplo n.º 5
0
def NormEmpHistFP(Epsi, p, tau, k_):
    # This function estimates the empirical histogram with Flexible
    # Probabilities of an invariant whose distribution is
    # represented in terms of simulations/historical realizations
    # INPUT
    #  Epsi  :[vector](1 x t_end) MC scenarios/historical realizations
    #  p     :[vector](1 x t_end) flexible probabilities
    #  tau   :[scalar] projection horizon
    #  k_    :[scalar] coarseness level
    # OP
    #  xi    :[1 x k_] centers of the bins
    #  f     :[1 x k_] discretized pdf of invariant

    # For details on the exercise, see here .

    ## code

    # bins width
    a = -norm.inv(10**(-15), 0, sqrt(tau))
    h = 2 * a / k_

    # centers of the bins
    xi = arange(-a + h, a + h, h)

    # frequency
    p_bin = zeros((len(xi), 1))
    for k in range(len(xi)):
        index = (Epsi > xi[k] - h / 2) & (Epsi <= xi[k] + h / 2)
        p_bin[k] = npsum(p[index])

    # discretized pdf of an invariant
    f = 1 / h * p_bin  # normalized heights
    f[k_] = 1 / h * (1 - npsum(p_bin[:-1]))

    return xi, f
Exemplo n.º 6
0
def stetson_kindex(fmags, ferrs):
    '''
    This calculates the Stetson K index (robust measure of the kurtosis).

    Requires finite mags and errs.

    '''

    # use a fill in value for the errors if they're none
    if ferrs is None:
        ferrs = npfull_like(mags, 0.005)

    ndet = len(fmags)

    if ndet > 9:

        # get the median and ndet
        medmag = npmedian(fmags)

        # get the stetson index elements
        delta_prefactor = (ndet / (ndet - 1))
        sigma_i = delta_prefactor * (fmags - medmag) / ferrs

        stetsonk = (npsum(npabs(sigma_i)) /
                    (npsqrt(npsum(sigma_i * sigma_i))) * (ndet**(-0.5)))

        return stetsonk

    else:

        LOGERROR('not enough detections in this magseries '
                 'to calculate stetson K index')
        return npnan
Exemplo n.º 7
0
def chaowangjost(counts):
    """Entropy calculation using Chao, Wang, Jost correction.
    doi: 10.1111/2041-210X.12108

    Parameters
    ----------
    counts : list
        bin counts

    Returns
    -------
    entropy : float
    """
    n_samples = npsum(counts)
    bcbc = bincount(counts.astype(int))
    if len(bcbc) < 3:
        return grassberger(counts)
    if bcbc[2] == 0:
        if bcbc[1] == 0:
            A = 1.
        else:
            A = 2. / ((n_samples - 1.) * (bcbc[1] - 1.) + 2.)
    else:
        A = 2. * bcbc[2] / ((n_samples - 1.) * (bcbc[1] - 1.) +
                            2. * bcbc[2])
    pr = arange(1, int(n_samples))
    pr = 1. / pr * (1. - A) ** pr
    entropy = npsum(counts / n_samples * (psi(n_samples) -
                    nan_to_num(psi(counts))))

    if bcbc[1] > 0 and A != 1.:
        entropy += nan_to_num(bcbc[1] / n_samples *
                              (1 - A) ** (1 - n_samples *
                                          (-log(A) - npsum(pr))))
    return entropy
Exemplo n.º 8
0
    def calculate_K(self,K0, P, T):
        def funct(V):
            F = self.mole_fraction*(K0 - 1)/(V*(K0-1)+1)
            if V>0:
                return F.sum()
            else:
                return np.nan
        (root,root_res) = brenth(funct, 0.1e-8, 1,disp = False, full_output = True)

        
        x = self.mole_fraction/(root*(K0-1)+1)
        self.x = x/npsum(x)
        y = x*K0
        self.y = y/sum(y)

        phiL, self.ZL = self.fugacity_coeffecient(x,P,T,'liquid')
        phiV, self.ZV = self.fugacity_coeffecient(y,P,T,'vapor')

        Knew = phiL/phiV
        diff = abs(npsum(Knew) - npsum(K0))
        K = Knew

        self.V = root
        self.L = 1 - root

        return K , diff
Exemplo n.º 9
0
def softmax_cost( theta, nclasses, dim, wdecay, data, labels ):
    # unroll parameters from theta
    theta = reshape(theta,(dim, nclasses)) # This was wrong
    theta= theta.T
    nsamp = data.shape[1]

    # generate ground truth matrix
    onevals = squeeze(ones((1,nsamp)))
    rows = squeeze(labels)-1 # This was wrong
    cols = arange(nsamp)
    ground_truth = csr_matrix((onevals,(rows,cols))).todense()


    # compute hypothesis; use some in-place computations
    theta_dot_prod = dot(theta,data)
    theta_dot_prod = theta_dot_prod - numpy.amax(theta_dot_prod, axis=0) # This was wrong
    soft_theta = npexp(theta_dot_prod)
    soft_theta_sum = npsum(soft_theta,axis=0)
    soft_theta_sum = tile(soft_theta_sum,(nclasses,1))
    hyp = soft_theta/soft_theta_sum


    # compute cost
    log_hyp = nplog(hyp)
    temp = array(multiply(ground_truth,log_hyp))
    temp = npsum(npsum(temp,axis=1),axis=0)
    cost = (-1.0/nsamp)*temp + 0.5*wdecay*pow(norm(theta,'fro'),2)
    return cost
Exemplo n.º 10
0
def lightcurve_moments(ftimes, fmags, ferrs):
    '''This calculates the weighted mean, stdev, median, MAD, percentiles, skew,
    kurtosis, fraction of LC beyond 1-stdev, and IQR.

    Parameters
    ----------

    ftimes,fmags,ferrs : np.array
        The input mag/flux time-series with all non-finite elements removed.

    Returns
    -------

    dict
        A dict with all of the light curve moments calculated.

    '''

    ndet = len(fmags)

    if ndet > 9:

        # now calculate the various things we need
        series_median = npmedian(fmags)
        series_wmean = (npsum(fmags * (1.0 / (ferrs * ferrs))) /
                        npsum(1.0 / (ferrs * ferrs)))
        series_mad = npmedian(npabs(fmags - series_median))
        series_stdev = 1.483 * series_mad
        series_skew = spskew(fmags)
        series_kurtosis = spkurtosis(fmags)

        # get the beyond1std fraction
        series_above1std = len(fmags[fmags > (series_median + series_stdev)])
        series_below1std = len(fmags[fmags < (series_median - series_stdev)])

        # this is the fraction beyond 1 stdev
        series_beyond1std = (series_above1std + series_below1std) / float(ndet)

        # get the magnitude percentiles
        series_mag_percentiles = nppercentile(
            fmags, [5.0, 10, 17.5, 25, 32.5, 40, 60, 67.5, 75, 82.5, 90, 95])

        return {
            'median': series_median,
            'wmean': series_wmean,
            'mad': series_mad,
            'stdev': series_stdev,
            'skew': series_skew,
            'kurtosis': series_kurtosis,
            'beyond1std': series_beyond1std,
            'mag_percentiles': series_mag_percentiles,
            'mag_iqr': series_mag_percentiles[8] - series_mag_percentiles[3],
        }

    else:
        LOGERROR('not enough detections in this magseries '
                 'to calculate light curve moments')
        return None
Exemplo n.º 11
0
def rombextrap(StepRatio, der_init, rombexpon):
    # do romberg extrapolation for each estimate
    #
    #  StepRatio - Ratio decrease in step
    #  der_init - initial derivative estimates
    #  rombexpon - higher order terms to cancel using the romberg step
    #
    #  der_romb - derivative estimates returned
    #  errest - error estimates
    #  amp - noise amplification factor due to the romberg step

    srinv = 1 / StepRatio

    # do nothing if no romberg terms
    nexpon = len(rombexpon)
    rombexpon = array(rombexpon)
    rmat = ones((nexpon + 2, nexpon + 1))
    if nexpon == 0:
        pass
        # rmat is simple: ones((2,1))
    elif nexpon == 1:
        # only one romberg term
        rmat[1, 1] = srinv ** rombexpon
        rmat[2, 1] = srinv ** (2 * rombexpon)
    elif nexpon == 2:
        # two romberg terms
        rmat[1, 1:3] = srinv ** rombexpon
        rmat[2, 1:3] = srinv ** (2 * rombexpon)
        rmat[3, 1:3] = srinv ** (3 * rombexpon)
    elif nexpon == 3:
        # three romberg terms
        rmat[1, 1:4] = srinv ** rombexpon
        rmat[2, 1:4] = srinv ** (2 * rombexpon)
        rmat[3, 1:4] = srinv ** (3 * rombexpon)
        rmat[4, 1:4] = srinv ** (4 * rombexpon)

    # qr factorization used for the extrapolation as well
    # as the uncertainty estimates
    qromb, rromb = qr(rmat)

    # the noise amplification is further amplified by the Romberg step.
    # amp = cond(rromb)

    # this does the extrapolation to a zero step size.
    ne = len(der_init)
    rhs = vec2mat(der_init, nexpon + 2, max(1, ne - (nexpon + 2)))
    rombcoefs = solve(rromb, qromb.T @ rhs.astype(np.float64))
    der_romb = rombcoefs[0].T

    # uncertainty estimate of derivative prediction
    s = sqrt(npsum((rhs - rmat @ rombcoefs) ** 2, 0))
    rinv = solve(rromb, eye(nexpon + 1))
    cov1 = npsum(rinv ** 2, 1)  # 1 spare dof
    errest = s.T * 12.7062047361747 ** sqrt(cov1[0])

    return der_romb, errest
Exemplo n.º 12
0
    def facquisition(xx, X, F, N, alpha, delta_E, dF, W, rbf, useRBF,
                     isUnknownFeasibilityConstrained,
                     isUnknownSatisfactionConstrained, Feasibility_unkn,
                     SatConst_unkn, delta_G, delta_S, iw_ibest, maxevals):
        # Acquisition function to minimize to get next sample

        d = npsum((X[0:N, ] - xx)**2, axis=-1)

        ii = where(d < 1e-12)
        if ii[0].size > 0:
            fhat = F[ii[0]][0]
            dhat = 0
            if isUnknownFeasibilityConstrained:
                Ghat = Feasibility_unkn[ii]
            else:
                Ghat = 1
            if isUnknownSatisfactionConstrained:
                Shat = SatConst_unkn[ii]
            else:
                Shat = 1
        else:
            w = exp(-d) / d
            sw = sum(w)

            if useRBF:
                v = rbf(X[0:N, :], xx)
                fhat = v.ravel().dot(W.ravel())
            else:
                fhat = npsum(F[0:N, ] * w) / sw

            if maxevals <= 30:
                # for comparision, used in the original GLIS and when N_max <= 30 in C-GLIS
                dhat = delta_E * atan(
                    1 / sum(1 / d)) * 2 / pi * dF + alpha * sqrt(
                        sum(w * (F[0:N, ] - fhat).flatten("c")**2) / sw)
            else:
                dhat = delta_E * (
                    (1 - N / maxevals) * atan(
                        (1 / sum(1. / d)) / iw_ibest) + N / maxevals *
                    atan(1 / sum(1. / d))) * 2 / pi * dF + alpha * sqrt(
                        sum(w * (F[0:N, ] - fhat).flatten("c")**2) / sw)

            # to account for the unknown constraints
            if isUnknownFeasibilityConstrained:
                Ghat = npsum(Feasibility_unkn[0:N].T * w) / sw
            else:
                Ghat = 1

            if isUnknownSatisfactionConstrained:
                Shat = npsum(SatConst_unkn[0:N].T * w) / sw
            else:
                Shat = 1

        f = fhat - dhat + (delta_G * (1 - Ghat) + delta_S * (1 - Shat)) * dF

        return f
Exemplo n.º 13
0
  def get_tfidf(self):
    terms_per_doc = npsum(self.term_matrix, axis=0)
    docs_per_term = npsum(asarray(self.term_matrix > 0, 'i'), axis=1)
    rows, cols = self.term_matrix.shape

    for i in range(rows):

      for j in range(cols):
        self.term_matrix[i, j] = ((self.term_matrix[i, j] / terms_per_doc[j]) *
                                   log(cols / docs_per_term[j]))
Exemplo n.º 14
0
def approx_pnd(X_pred, X_cov, X_train, signs, n=int(1e4), seed=None):
    r"""Approximate the PND via mixture importance sampling

    Approximate the probability non-dominated (PND) for a set of predictive
    points using a mixture importance sampling approach. Predictive points are
    assumed to have predictive gaussian distributions (with specified mean and
    covariance matrix).

    Args:
        X_pred (2d numpy array): Predictive values
        X_cov (iterable of 2d numpy arrays): Predictive covariance matrices
        X_train (2d numpy array): Training values, used to determine existing Pareto frontier
        signs (numpy array of +/-1 values): Array of optimization signs: {-1: Minimize, +1 Maximize}

    Kwargs:
        n (int): Number of draws for importance sampler
        seed (int): Seed for random state

    Returns:
        pr_scores (array): Estimated PND values
        var_values (array): Estimated variance values

    References:
        Owen *Monte Carlo theory, methods and examples* (2013)

    """
    ## Setup
    X_wk_train = -X_train * signs
    X_wk_pred = -X_pred * signs
    n_train, n_dim = X_train.shape
    n_pred = X_pred.shape[0]

    ## Find the training Pareto frontier
    idx_pareto = pareto_min_rel(X_wk_train)
    n_pareto = len(idx_pareto)
    ## Sample the mixture points
    Sig_mix = make_proposal_sigma(X_wk_train, idx_pareto, X_cov)
    X_mix = rprop(n, Sig_mix, X_wk_train[idx_pareto, :], seed=seed)
    ## Take non-dominated points only
    idx_ndom = pareto_min_rel(X_mix, X_base=X_wk_train[idx_pareto, :])
    X_mix = X_mix[idx_ndom, :]

    ## Evaluate the Pr[non-dominated]
    d_mix = dprop(X_mix, Sig_mix, X_wk_train[idx_pareto, :])
    pr_scores = zeros(n_pred)
    var_values = zeros(n_pred)
    for i in range(n_pred):
        dist_test = mvnorm(mean=X_wk_pred[i], cov=X_cov[i])
        w_test = dist_test.pdf(X_mix) / d_mix
        # Owen (2013), Equation (9.3)
        pr_scores[i] = npsum(w_test) / n
        # Owen (2013), Equation (9.5)
        var_values[i] = npsum((w_test - pr_scores[i])**2) / n

    return pr_scores, var_values
Exemplo n.º 15
0
    def get_tfidf(self):
        terms_per_doc = npsum(self.term_matrix, axis=0)
        docs_per_term = npsum(asarray(self.term_matrix > 0, 'i'), axis=1)
        rows, cols = self.term_matrix.shape

        for i in range(rows):

            for j in range(cols):
                self.term_matrix[i, j] = (
                    (self.term_matrix[i, j] / terms_per_doc[j]) *
                    log(cols / docs_per_term[j]))
Exemplo n.º 16
0
def likelihood(intensity, cases):
    '''
    Sum over care homes i and dates t:
    ln(\\lambda^k exp(-\\lambda) / (k!))
      = (k ln \\lambda - \\lambda - ln(k!))
    where k = cases and \\lambda = intensity
    '''
    non_zero_cases = (cases > 0)

    # gammaln(n) = ln((n-1)!) for integer n
    return (npsum(cases[non_zero_cases] * log(intensity[non_zero_cases])) -
            npsum(intensity) - npsum(gammaln(cases[cases > 1] + 1)))
Exemplo n.º 17
0
 def _van_der_walls_mixing(self, mole_fraction, P, T):
     alpha = self._Twu91(T)
     attraction = 0.45724 * alpha * (self.R * self.Tc).pow(2)/(self.Pc * 100000)
     cohesion = 0.07780 * self.R * self.Tc / (self.Pc * 100000)
     # aij = [(ai.aj)0.5(1 - kij)] = aji
     mixture = outer(attraction, attraction)
     mixture = power(mixture,0.5)
     mixture = multiply(mixture, subtract(1,self.interaction_params))
     a_ij = mixture * P * 100000 / (self.R * T) ** 2
     b = cohesion * P * 100000 / (self.R * T)
     A = npsum(npsum(multiply(a_ij, outer(mole_fraction, mole_fraction))))
     B = npsum(b*mole_fraction)
     return A, B, a_ij, b
Exemplo n.º 18
0
    def cof(self, mode="log"):
        from numpy import sum as npsum

        data = None
        if mode == "log":
            data = self.get_logpow()
        elif mode in ("linear", 'lin'):
            data = self.get_pow()

        freq = self.get_xdata()

        c = npsum(data * freq) / npsum(data)
        return c
Exemplo n.º 19
0
    def cof(self, mode="log"):
        from numpy import sum as npsum

        data = None
        if mode == "log":
            data = self.get_logpow()
        elif mode in ("linear", 'lin'):
            data = self.get_pow()

        freq = self.get_xdata()

        c = npsum(data * freq) / npsum(data)
        return c
Exemplo n.º 20
0
def _calc_accel(jack_dist):
    from numpy import mean as npmean
    from numpy import sum as npsum
    from numpy import errstate

    jack_mean = npmean(jack_dist)

    numer = npsum((jack_mean - jack_dist)**3)
    denom = 6.0 * (npsum((jack_mean - jack_dist)**2)**1.5)

    with errstate(invalid='ignore'):
        # does not raise warning if invalid division encountered.
        return numer / denom
Exemplo n.º 21
0
def logdet(a):
    # Fast logarithm-determizerost of large matrix

    ## code
    try:
        v = 2 * npsum(log(diag(cholesky(a))))
    except:  ##ok<CTCH>
        dummy, u, p = lu(a)  ##ok<ASGLU>
        du = diag(u)
        c = det(p) * prod(sign(du))
        v = log(c) + npsum(log(abs(du)))
        v = real(v)
    return v
Exemplo n.º 22
0
def mU1F1C2(U_in, F_in, C_in, C_slab, dt):
    """ Model of a simple room that has heating/cooling applied in a different node
    than that of the air, eg.: a radiant slab system.

    Node Number: Object
    0: room air node, connected to ambient air (F0) node
    1: under slab node, connected to capacitor 1 (slab) and Node 0

    Node Number with known temperatures: Object
    0: ambient air

    External input:
    U_in: conductance under slab to slab surface
    F_in: conductance room air to slab surface
    C_in: capacitance of air
    C_slab: capacitance of slab
    """
    # Load dependencies
    from numpy import zeros
    from numpy import sum as npsum
    from numpy.linalg import inv

    nN = 2  # number of nodes
    nM = 1  # number of nodes with known temperatures

    #%% Nodal Connections
    # Declare variables
    Uin = zeros((nN, nN))  # W/K
    F = zeros((nN, nM))  # W/K
    C = zeros((nN, 1))  # J/K

    # How are the nodes connected?
    Uin[0, 1] = U_in

    # Connected to temperature sources
    F[0, 0] = F_in

    # Nodes with capacitance
    C[0] = C_in
    C[1] = C_slab

    #%% U-matrix completion, and its inverse
    U = -Uin - Uin.T  # U is symmetrical, non-diagonals are -ve
    s = -npsum(U, 1)
    for i in range(0, nN):
        U[i, i] = s[i] + npsum(F[i, ]) + C[i] / dt
    Uinv = inv(U)

    #%% Ship it
    return (Uinv, F, C, nN, nM)
Exemplo n.º 23
0
def specwindow_lsp_value(times, mags, errs, omega):
    '''
    This calculates the peak associated with the spectral window function
    for times and at the specified omega.

    '''

    norm_times = times - times.min()

    tau = ((1.0 / (2.0 * omega)) * nparctan(
        npsum(npsin(2.0 * omega * norm_times)) /
        npsum(npcos(2.0 * omega * norm_times))))

    lspval_top_cos = (npsum(1.0 * npcos(omega * (norm_times - tau))) *
                      npsum(1.0 * npcos(omega * (norm_times - tau))))
    lspval_bot_cos = npsum((npcos(omega * (norm_times - tau))) *
                           (npcos(omega * (norm_times - tau))))

    lspval_top_sin = (npsum(1.0 * npsin(omega * (norm_times - tau))) *
                      npsum(1.0 * npsin(omega * (norm_times - tau))))
    lspval_bot_sin = npsum((npsin(omega * (norm_times - tau))) *
                           (npsin(omega * (norm_times - tau))))

    lspval = 0.5 * ((lspval_top_cos / lspval_bot_cos) +
                    (lspval_top_sin / lspval_bot_sin))

    return lspval
Exemplo n.º 24
0
def stellingwerf_pdm_theta(times, mags, errs, frequency,
                           binsize=0.05, minbin=9):
    '''
    This calculates the Stellingwerf PDM theta value at a test frequency.

    '''

    period = 1.0/frequency
    fold_time = times[0]

    phased = phase_magseries(times,
                             mags,
                             period,
                             fold_time,
                             wrap=False,
                             sort=True)

    phases = phased['phase']
    pmags = phased['mags']
    bins = np.arange(0.0, 1.0, binsize)
    nbins = bins.size

    binnedphaseinds = npdigitize(phases, bins)

    binvariances = []
    binndets = []
    goodbins = 0

    for x in npunique(binnedphaseinds):

        thisbin_inds = binnedphaseinds == x
        thisbin_phases = phases[thisbin_inds]
        thisbin_mags = pmags[thisbin_inds]

        if thisbin_mags.size > minbin:
            thisbin_variance = npvar(thisbin_mags,ddof=1)
            binvariances.append(thisbin_variance)
            binndets.append(thisbin_mags.size)
            goodbins = goodbins + 1

    # now calculate theta
    binvariances = nparray(binvariances)
    binndets = nparray(binndets)

    theta_top = npsum(binvariances*(binndets - 1)) / (npsum(binndets) -
                                                      goodbins)
    theta_bot = npvar(pmags,ddof=1)
    theta = theta_top/theta_bot

    return theta
Exemplo n.º 25
0
    def eval(self, x, y):

        xfound = False
        yfound = False

        itest = self.itest
        if itest > 0:
            Xtest = self.Xtest
            Ftest = self.Ftest
        else:
            fx = self.f(x)
            itest = 1
            Xtest = array([x])
            Ftest = array([fx])
            xfound = True

        for i in range(itest):
            if not (xfound) and npsum(abs(Xtest[i, :] - x)) <= 1e-10:
                xfound = True
                fx = Ftest[i]

            if not (yfound) and npsum(abs(Xtest[i, :] - y)) <= 1e-10:
                yfound = True
                fy = Ftest[i]

        if not (xfound):
            fx = self.f(x)
            Xtest = vstack((Xtest, x))
            Ftest = append(Ftest, fx)
            itest = itest + 1

        if not (yfound):
            fy = self.f(y)
            Xtest = vstack((Xtest, y))
            Ftest = append(Ftest, fy)
            itest = itest + 1

        # Make comparison
        if fx < fy - self.comparetol:
            out = -1
        elif fx > fy + self.comparetol:
            out = 1
        else:
            out = 0

        self.Xtest = Xtest
        self.Ftest = Ftest
        self.itest = itest

        return out
Exemplo n.º 26
0
def Stats(epsi, FP=None):
    # Given a time series (epsi) and the associated probabilities FP,
    # this def computes the statistics: mean,
    # standard deviation,VaR,CVaR,skewness and kurtosis.
    # INPUT
    # epsi :[vector] (1 x t_end)
    # FP   :[matrix] (q_ x t_end) statistics are computed for each of the q_ sets of probabilities.
    # OUTPUT
    # m     :[vector] (q_ x 1) mean of epsi with FP (for each set of FP)
    # stdev :[vector] (q_ x 1) standard deviation of epsi with FP (for each set of FP)
    # VaR   :[vector] (q_ x 1) value at risk with FP
    # CVaR  :[vector] (q_ x 1) conditional value at risk with FP
    # sk    :[vector] (q_ x 1) skewness with FP
    # kurt  :[vector] (q_ x 1) kurtosis with FP
    ###########################################################################

    # size check
    if epsi.shape[0] > epsi.shape[1]:
        epsi = epsi.T  # eps: row vector
    if FP.shape[1] != epsi.shape[1]:
        FP = FP.T

    # if FP argument is missing, set equally weighted FP
    t_ = epsi.shape[1]
    if FP is None:
        FP = ones((1, t_)) / t_

    q_ = FP.shape[0]

    m = zeros((q_, 1))
    stdev = zeros((q_, 1))
    VaR = zeros((q_, 1))
    CVaR = zeros((q_, 1))
    sk = zeros((q_, 1))
    kurt = zeros((q_, 1))

    for q in range(q_):
        m[q] = (epsi * FP[[q], :]).sum()
        stdev[q] = sqrt(npsum(((epsi - m[q])**2) * FP[q, :]))
        SortedEps, idx = sort(epsi), argsort(epsi)
        SortedP = FP[[q], idx]
        VarPos = where(cumsum(SortedP) >= 0.01)[0][0]
        VaR[q] = -SortedEps[:, VarPos]
        CVaR[q] = -FPmeancov(
            SortedEps[[0], :VarPos + 1],
            SortedP[:, :VarPos + 1].T / npsum(SortedP[:, :VarPos + 1]))[0]
        sk[q] = npsum(FP[q, :] * ((epsi - m[q])**3)) / (stdev[q]**3)
        kurt[q] = npsum(FP[q, :] * ((epsi - m[q])**4)) / (stdev[q]**4)

    return m, stdev, VaR, CVaR, sk, kurt
Exemplo n.º 27
0
Arquivo: mmfe.py Projeto: sebsou/lmet
def cren1D(etaC,nulamC,M):
    " fonction crÈneau "
    eta1, eta2 =vstack([0,etaC.reshape(-1,1)]), vstack([etaC.reshape(-1,1),1]) # remise sous forme colonne : .reshape(-1,1) ; remise sous forme ligne : .reshape(1,-1)
    epr,  m_   =nulamC.reshape(-1,1)**2,  -2*pi*(arange(2*M)+1)

    #print (eta1, eta2, epr)
    epr0 = npsum( (eta2-eta1) * epr )
    eprm = dot(epr,ones((1,2*M)))
    m =  m_.reshape(1,-1)

    e1m,  e2m  =1j*dot(eta1,m),  1j*dot(eta2,m)
    epr_m =hstack([0., -1j* npsum( (exp(e2m) -exp(e1m)) *eprm ,0) /m_ ])
    epr_p =hstack([0.,  1j* npsum( (exp(-e2m)-exp(-e1m))*eprm ,0) /m_ ])
    return diagflat(epr0*ones(2*M+1)) + triu( toeplitz(epr_m.real)+1j*toeplitz(epr_m.imag) ) + tril( toeplitz(epr_p.real)+1j*toeplitz(epr_p.imag) )
Exemplo n.º 28
0
def GarchResiduals(x,
                   t_garch=None,
                   p_garch=None,
                   g=0.95,
                   p0=[0, 0.01, 0.8, 0]):
    # This function computes the residuals of a Garch((1,1)) fit on x.
    # If t_garch < t_obs=x.shape[1] the fit is performed on a rolling window of
    # t_garch observations
    #  INPUTS
    #  x        [matrix]: (n_ x t_obs) dataset of observations
    #  t_garch  [scalar]: number of observations processed at every iteration
    #  p_garch  [vector]: (1 x t_end) flexible probabilities (optional default=exponential decay flexible probability with half life 6 months)
    #  g        [scalar]: we impose the contraint a+b <= g on the GARCH(1,1) parameters (default: g=0.95)
    #  p0  [vector]: (1 x 4) initial guess (for compatibility with OCTAVE)
    #  OPS
    #  epsi     [matrix]: (n_ x t_end) residuals
    # note: sigma**2 is initialized with a forward exponential smoothing

    ## Code
    if t_garch is None:
        t_garch = x.shape[1]

    if p_garch is None:
        lambda1 = log(2) / 180
        p_garch = exp(-lambda1 * arange(t_garch, 1 + -1, -1)).reshape(1, -1)
        p_garch = p_garch / npsum(p_garch)

    n_, t_obs = x.shape
    lam = 0.7

    if t_garch == t_obs:  #no rolling window
        epsi = zeros((n_, t_obs))
        for n in range(n_):
            s2_0 = lam * var(x[n, :], ddof=1) + (1 - lam) * npsum(
                (lam**arange(0, t_obs - 1 + 1)) * (x[n, :]**2))
            _, _, epsi[n, :], _ = FitGARCHFP(x[[n], :], s2_0, p0, g,
                                             p_garch)  #GARCH fit

    else:
        t_ = t_obs - t_garch  #use rolling window
        epsi = zeros((n_, t_))
        for t in range(t_):
            for n in range(n_):
                x_t = x[n, t:t + t_garch - 1]
                s2_0 = lam * var(x_t) + (1 - lam) * npsum(
                    (lam**arange(0, t_garch - 1 + 1)) * (x_t**2))
                _, _, e, _ = FitGARCHFP(x_t, s2_0, p0, g, p_garch)
                epsi[n, t] = e[-1]
    return epsi
Exemplo n.º 29
0
def cosine_similarity_low_rank_multi(G, y):
    """
    Cosine similarity between matrices from outer products of matrix :math:`\mathbf{G}` and vector :math:`\mathbf{y}`.

    :param G: (``numpy.ndarray``) Low-rank matrix.
    
    :param y: (``numpy.ndarray``) Column vector.
    
    :return: (``float``) Cosine similarity (kernel alignment).
    
    """
    enum = npsum(G.T.dot(y)**2)
    denom = y.T.dot(y) * sqrt(npsum([npsum(G[:, i] * G[:, j])**2
                                         for i, j in product(xrange(G.shape[1]), xrange(G.shape[1]))]))
    return 1.0 * enum / denom
Exemplo n.º 30
0
def gaussian_kernel(**kwargs):
    s       = kwargs.get('size',    2)
    mu      = kwargs.get('mu',      0.0)
    sigma   = kwargs.get('sigma',   1.0)
    integer = kwargs.get('integer', False)

    x       = array(range(-s,s+1))
    g       = gaussian(x, mu=mu, sigma=sigma)
    m       = outer(g,g)

    if integer:
        gi  = (m/m[0,0]).astype(int)
        return gi, npsum(gi)
    else:
        return m, npsum(m)
Exemplo n.º 31
0
def multivariate_student_t_pdf(x, mu, Sigma2, df):
    x = np.atleast_2d(x)  # requires x as 2d
    n_ = Sigma2.shape[0]  # dimensionality

    R = cholesky(Sigma2)

    z = solve(R, x)

    logSqrtDetC = npsum(log(diag(R)))
    logNumer = -((df + n_) / 2) * log(1 + npsum(z**2, axis=0) / df)
    logDenom = logSqrtDetC + (n_ / 2) * log(df * np.pi)

    y = exp(gammaln((df + n_) / 2) - gammaln(df / 2) + logNumer - logDenom)

    return y
Exemplo n.º 32
0
def grassberger(counts):
    """Entropy calculation using Grassberger correction.
    doi:10.1016/0375-9601(88)90193-4

    Parameters
    ----------
    counts : list
        bin counts
    Returns
    -------
    entropy : float
    """
    n_samples = npsum(counts)
    return npsum(counts * (log(n_samples) - nan_to_num(psi(counts)) -
                           ((-1.)**counts / (counts + 1.)))) / n_samples
Exemplo n.º 33
0
 def bubble(P):
     y = self.mole_fraction
     phiL, ZL = self.fugacity_coeffecient(y,P,self.T,'liquid')
     fL = phiL*y*P
     K_est = self.Pc/P * exp(5.37*(1 - self.w)*(1 - self.Tc/self.T))
     x = y*K_est
     x = x/npsum(x)
     phiV, ZV = self.fugacity_coeffecient(x,P,self.T,'vapor')
     fV = phiV*x*P
     for i in range(50):
         x = fL/fV*x
         phiV, ZV = self.fugacity_coeffecient(x,P,self.T,'vapor')
         fV = phiV*x*P   
     sum2 = npsum(x)
     return abs(sum2 - 1)
Exemplo n.º 34
0
    def gen_data(self):
        self.num_bg_meas = self.peakdata[:, :, :, :].shape[2] - 1
        channels_per_step = self.med_stepsize

        max_i = int(floor(npmax(self.mset) - 1))
        self.peak_ranges = self.peak_ranges[:max_i]
        self.raw_signal = npsum(self.peakdata[:, :, 0, :max_i],
                                axis=1) * self.numadds
        self.raw_background = npsum(npsum(self.peakdata[:, :, 1:, :max_i],
                                          axis=2),
                                    axis=1) * self.numadds

        out_array = zeros([len(self.wl_inds), self.raw_signal.shape[1]])
        bg_out_array = zeros([len(self.wl_inds), self.raw_background.shape[1]])

        for i, ind0 in enumerate(self.wl_inds):
            out_array[i, :] = npsum(
                self.raw_signal[ind0:int(ind0 + channels_per_step), :max_i],
                axis=0)
            bg_out_array[i, :] = npsum(
                self.raw_background[ind0:int(ind0 +
                                             channels_per_step), :max_i],
                axis=0)

        self.signal = out_array
        self.background = bg_out_array

        signal_err = sqrt(self.signal)
        background_err = sqrt(self.background)

        with catch_warnings():
            simplefilter("ignore", category=RuntimeWarning)
            self.diff_signal = self.signal - (self.background /
                                              self.num_bg_meas)
            self.flat_signal = self.signal / (self.background /
                                              self.num_bg_meas)
            self.flat_signal_err = sqrt(
                signal_err**2 * (self.num_bg_meas / self.background)**2 +
                background_err**2 *
                (self.num_bg_meas * self.signal / self.background**2)**2)

            self.flat_signal[isnan(self.flat_signal)] = 0
            self.flat_signal_err[isnan(self.flat_signal_err)] = 0
            self.flat_signal[self.flat_signal == 0] = 1e-6
            self.flat_signal_err[self.flat_signal_err == 0] = 1e-6

        self.wls_pow, self.flat_signal_pow, self.flat_signal_err_pow = laser_corr(
            self.wls, self.flat_signal, self.flat_signal_err)
Exemplo n.º 35
0
    def pinball_loss(y_true, y_pred, probs):
        """Compute the pinball loss.

        Parameters
        ----------
        pred : {array-like}, shape = [n_quantiles, n_samples] or [n_samples]
            Predictions.
        y : {array-like}, shape = [n_samples]
            Targets.

        Returns
        -------
        l : {array}, shape = [n_quantiles]
            Average loss for each quantile level.
        """
        probs = asarray(probs).reshape(-1)
        check_consistent_length(y_true, y_pred.T)
        y_true = check_array(y_true.reshape((-1, 1)),
                             ensure_2d=True)
        y_pred = check_array(y_pred.T.reshape((y_true.shape[0], -1)),
                             ensure_2d=True)
        residual = y_true - y_pred
        loss = npsum([fmax(prob * res, (prob - 1) * res) for (res, prob) in
                      zip(residual.T, probs)], axis=1)
        return loss / y_true.size
Exemplo n.º 36
0
def EffectiveScenarios(p, Type=None):
    # This def computes the Effective Number of Scenarios of Flexible
    # Probabilities via different types of defs
    #  INPUTS
    #   p       : [vector] (1 x t_) vector of Flexible Probabilities
    #   Type    : [struct] type of def: 'ExpEntropy', 'GenExpEntropy'
    #  OUTPUTS
    #   ens     : [scalar] Effective Number of Scenarios
    # NOTE:
    # The exponential of the entropy is set as default, otherwise
    # Specify Type.ExpEntropy.on = true to use the exponential of the entropy
    # or
    # Specify Type.GenExpEntropy.on = true and supply the scalar
    # Type.ExpEntropy.g to use the generalized exponential of the entropy

    # For details on the exercise, see here .
    if Type is None:
        Type = namedtuple('type',['Entropy'])
        Type.Entropy = 'Exp'
    if Type.Entropy != 'Exp':
        Type.Entropy = 'GenExp'

    ## Code

    if Type.Entropy == 'Exp':
        p[p==0] = 10**(-250)    #avoid log(0) in ens computation
        ens = exp(-p@log(p.T))
    else:
        ens = npsum(p ** Type.g) ** (-1 / (Type.g - 1))

    return ens
Exemplo n.º 37
0
def softmax_grad( theta, nclasses, dim, wdecay, data, labels ):
    # unroll parameters from theta
    theta = reshape(theta,(dim, nclasses)) # Do this
    theta= theta.T
    nsamp = data.shape[1]

    # generate ground truth matrix
    onevals = squeeze(ones((1,nsamp)))
    rows = squeeze(labels)-1 # Here should -1 to align zero-indexing
    cols = arange(nsamp)

    ground_truth = csr_matrix((onevals,(rows,cols))).todense()
#     plt.imshow(ground_truth,interpolation='nearest')
#     plt.draw()
#     print ground_truth

    # compute hypothesis; use some in-place computations
    theta_dot_prod = dot(theta,data)
    theta_dot_prod = theta_dot_prod - numpy.amax(theta_dot_prod, axis=0) # This was wrong
    soft_theta = npexp(theta_dot_prod)
    soft_theta_sum = npsum(soft_theta,axis=0)
    soft_theta_sum = tile(soft_theta_sum,(nclasses,1))
    hyp = soft_theta/soft_theta_sum

    # compute gradient
    thetagrad = (-1.0/nsamp)*dot(ground_truth-hyp,transpose(data)) + wdecay*theta

    thetagrad = asarray(thetagrad)
    thetagrad = thetagrad.flatten(1)
    return thetagrad
Exemplo n.º 38
0
def countStoppedVehiclesVissim(filename, lanes = None, proportionStationaryTime = 0.7):
    '''Counts the number of vehicles stopped for a long time in a VISSIM trajectory file
    and the total number of vehicles

    Vehicles are considered finally stationary
    if more than proportionStationaryTime of their total time
    If lanes is not None, only the data for the selected lanes will be provided
    (format as string x_y where x is link index and y is lane index)'''
    from pandas import read_csv
    from numpy import array, sum as npsum
    columns = ['NO', '$VEHICLE:SIMSEC', 'POS']
    if lanes is not None:
        columns += ['LANE\LINK\NO', 'LANE\INDEX']
    data = read_csv(filename, delimiter=';', comment='*', header=0, skiprows = 1, usecols = columns)
    data = selectPDLanes(data, lanes)
    data.sort(['$VEHICLE:SIMSEC'], inplace = True)

    nStationary = 0
    from matplotlib.pyplot import plot, figure
    nVehicles = 0
    for name, group in data.groupby(['NO'], sort = False):
        nVehicles += 1
        positions = array(group['POS'])
        diff = positions[1:]-positions[:-1]
        if npsum(diff == 0.) >= proportionStationaryTime*len(positions):
            nStationary += 1

    return nStationary, nVehicles
Exemplo n.º 39
0
def grassberger(counts):
    """Entropy calculation using Grassberger correction.
    doi:10.1016/0375-9601(88)90193-4

    Parameters
    ----------
    counts : list
        bin counts
    Returns
    -------
    entropy : float
    """
    n_samples = npsum(counts)
    return npsum(counts * (log(n_samples) -
                           nan_to_num(psi(counts)) -
                           ((-1.) ** counts / (counts + 1.)))) / n_samples
Exemplo n.º 40
0
    def project(self, tdata):
        """
        This function projects test data :math:`D'` onto the mean map, i.e.
        it computes and returns :math:`\\langle\mu_{{D_1}},\\psi(x)\\rangle_\mathcal{H}`
        for each :math:`x\in D'`, where :math:`\\psi:\mathbb{R}^{d}\\to\mathcal{H}` is the feature
        map associated to the RKHS :math:`\mathcal{H}`. 

        :param data: testdata matrix :math:`D'\in\mathbb{R}^{d \\times n}`, where 
                     :math:`d` is the dimensionality and 
                     :math:`n` is the number of training samples
        :type data: numpy array
        :return: projected data
        :rtype:  numpy array
        """        
        # parse data and ensure it meets requirements
        test_dim = tdata.shape[0]
        ntest = tdata.shape[1]

        if test_dim != self.dim:
          raise Exception("ERROR: dimensionality of data must be consistent with training set.")

        # compute kernel matrix between data and tdata 
        kmat = kernel(self.data,tdata,self.kernel)
        kmat = npsum(kmat,axis=0)
        kmat = (1/self.nsamp)*kmat
        return kmat 
Exemplo n.º 41
0
 def object_val_calc(self, codebook_comps, ksi, gamma, theta, vecs):
     '''
     Calculate objective function value
     '''
     _bs_ = np.dot(codebook_comps, vecs)
     square_term = 0.5 * npsum((ksi - _bs_)**2, axis=0)
     res = (square_term + gamma * dot(theta.T, vecs)).ravel()
     return res
Exemplo n.º 42
0
def gaussian_kde(data,x,w):
  """
  kernel density estimate of the pdf represented by data
  at point x with bandwidth w
  """
  N = float(len(data))

  return npsum([_gauss_kern(x,xn,w) for xn in data])/(N*w*sqrt(2.*pi))
Exemplo n.º 43
0
def sparse_CostFunc(weightAllLayers, *args):
    r'''
    Vectorized/regulated sparse cost function (described in the sparseae_reading.pdf on the `UFLDL Tutorial Exercise:Sparse_Autoencoder <http://ufldl.stanford.edu/wiki/index.php/Exercise:Sparse_Autoencoder>`_) that computes the total cost over multiple inputs:

    .. math::
    
        &define: \hat{\rho}_j=\frac{1}{m}\sum_{i=1}^{m}[actvh_j(x^i)]\\
        &define: \sum_{j=1}^{h}KL(\rho||\hat{\rho}_j)=\sum_{j=1}^{f}\rho~log\frac{\rho}{\hat{\rho}_j}+(1-\rho)log\frac{1-\rho}{1-\hat{\rho}_j}\\
        &costFunction:~\frac{1}{m}\sum_{i=1}^{m}(0.5~||forwardThruAllLayers(x^i)-y^i||^2)]+\frac{\lambda}{2}\sum^{allLayers~excludeAnyBias} (weight^2)\\
        &+\beta\sum_{j=1}^{f}KL(\rho||\hat{\rho}_j)

    where :math:`\hat{\rho}_j` =average activation of hidden unit j; :math:`m` =the number of inputs; :math:`h` =number of hidden units exclude bias units; :math:`y^i` =a single target array; :math:`x^i` =a single input array; :math:`\beta` =this is sparseParam.

    :param weightAllLayers: A flatten array contains all forward weights.
    :param *args: Must in the following order:

        **inputArr2D**: 1 training example per row.

        **targets**: Must be a 2D ndarray instead of matrix. And the number of labels must match the number of units in output layer.

        **weightDecayParam**: For model complexity regulation.
        
        **sparsity**: Setting the sparsity of neural network.  
        
        **sparseParam**: For sparsity regulation.

        **nn**: An instance of class FeedforwardNeuNet.

    :returns: A scalar representing the cost of current input using weightAllLayers.
    '''
    inputArr2D, targets, weightDecayParam, sparsity, sparseParam, nn = args
    startIndex, weightsExcBias = 0, 0
    avgEx = 1.0 / targets.shape[0]
    for ly in nn.layersExOutputLy:  # update all forward weights
        newWeight = reshape(weightAllLayers[startIndex:startIndex + ly.forwardWeight.size], ly.forwardWeight.shape)
        ly.forwardWeight = asmatrix(newWeight)
        startIndex += ly.forwardWeight.size
        weightsExcBias = append(weightsExcBias, newWeight[:-1])  # exclude weights for bias unit with [:-1]
    output = asarray(nn.forwardPropogateAllInput(inputArr2D))
    assert output.shape[1] == targets.shape[1], 'dimension mismatch in next layer'
    avgActvArrAllLyAllEx = 0
    for ly in nn.layersExOutputLy[1:]:
        ly.avgActvArrAllEx = avgEx * npsum(ly.self2D[:, :-1], 0)
        avgActvArrAllLyAllEx = append(avgActvArrAllLyAllEx, ly.avgActvArrAllEx)  # not sure whether I should include bias here?
    avgActvArrAllLyAllEx = avgActvArrAllLyAllEx[1:]  # discard 0 at the beginning
    return avgEx * npsum(0.5 * (output - targets) ** 2) + 0.5 * weightDecayParam * npsum(weightsExcBias ** 2) + sparseParam * npsum(sparsity * log(sparsity / avgActvArrAllLyAllEx) + (1 - sparsity) * log((1 - sparsity) / (1 - avgActvArrAllLyAllEx)))
Exemplo n.º 44
0
def sigma_distribution(xoff, n, sigma_s, x_range, angles,
                       interp_kind='slinear'):
    s = sigma_integrate(x_range, xoff, sigma_s, angles)
    # weight the contribution of each radial bin
    sarray = [ni * si(x_range) for ni, si in izip(n, s)]
    s = npsum(sarray, axis=0) / n.sum()
    # go back to the required format
    s = interp1d(x_range, s, kind=interp_kind)
    return s
Exemplo n.º 45
0
def AvAnimalNSum_f(NYrs, NGPctManApp, GrazingAnimal_0, NumAnimals, AvgAnimalWt, AnimalDailyN, NGAppNRate, Prec,
                   DaysMonth,
                   NGPctSoilIncRate, GRPctManApp, GRAppNRate, GRPctSoilIncRate, NGBarnNRate, AWMSNgPct, NgAWMSCoeffN,
                   RunContPct, RunConCoeffN, PctGrazing, GRBarnNRate, AWMSGrPct, GrAWMSCoeffN, PctStreams,
                   GrazingNRate):
    return npsum(
        AvAnimalN_f(NYrs, NGPctManApp, GrazingAnimal_0, NumAnimals, AvgAnimalWt, AnimalDailyN, NGAppNRate, Prec,
                    DaysMonth, NGPctSoilIncRate, GRPctManApp, GRAppNRate, GRPctSoilIncRate, NGBarnNRate,
                    AWMSNgPct, NgAWMSCoeffN, RunContPct, RunConCoeffN, PctGrazing, GRBarnNRate, AWMSGrPct,
                    GrAWMSCoeffN, PctStreams, GrazingNRate))
Exemplo n.º 46
0
    def mmd(self, data2):
        """
        Compute the maximum mean discrepancy between 
        :math:`D_1` and :math:`D_2`, i.e. :math:`\\|\\mu_{{D_1}} - \\mu_{{D_2}}\\|_{\mathcal{H}}`

        :param data2: data matrix :math:`D_2\in\mathbb{R}^{d \\times n}`, where 
                     :math:`d` is the dimensionality and 
                     :math:`n` is the number of training samples
        :type data: numpy array
        :return: diffused data
        :rtype:  numpy array
        """        
        # parse data and ensure it meets requirements
        dim_data2 = data2.shape[0]
        ntest = data2.shape[1]                

        if dim_data2 != self.dim:
          raise Exception("ERROR: dimensionality of data must be consistent with training set.")

        # now, compute MMD equation, using in-place computations 
        kmat = kernel(data2,data2,self.kernel);
        ktestsum = npsum(npsum(kmat,axis=0),axis=1)/(pow(ntest,2));    

        kmat = kernel(self.data,self.data,self.kernel);
        ktrainsum = npsum(npsum(kmat,axis=0),axis=1)/(pow(self.nsamp,2));    

        kmat = kernel(self.data,data2,self.kernel);
        kcrossum = npsum(npsum(kmat,axis=0),axis=1)/(self.nsamp*ntest);                  

        mmdcomputed = ktestsum + ktrainsum - 2*kcrossum
 
        return mmdcomputed
Exemplo n.º 47
0
def AvStreamBankNSum_f(NYrs, DaysMonth, Temp, InitSnow_0, Prec, NRur, NUrb, Area, CNI_0, AntMoist_0, Grow_0, CNP_0,
                       Imper, ISRR, ISRA, CN, UnsatStor_0, KV, PcntET, DayHrs, MaxWaterCap, SatStor_0, RecessionCoef,
                       SeepCoef, Qretention, PctAreaInfil, n25b, Landuse, TileDrainDensity, PointFlow, StreamWithdrawal,
                       GroundWithdrawal, NumAnimals, AvgAnimalWt, StreamFlowVolAdj, SedAFactor_0, AvKF, AvSlope,
                       SedAAdjust, StreamLength, n42b, n46c, n85d, AgLength, n42, n54, n85, UrbBankStab, SedNitr,
                       BankNFrac, n69c, n45, n69):
    return npsum(StreamBankN_1_f(NYrs, DaysMonth, Temp, InitSnow_0, Prec, NRur, NUrb, Area, CNI_0, AntMoist_0, Grow_0,
                                 CNP_0, Imper, ISRR, ISRA, CN, UnsatStor_0, KV, PcntET, DayHrs, MaxWaterCap, SatStor_0,
                                 RecessionCoef, SeepCoef, Qretention, PctAreaInfil, n25b, Landuse, TileDrainDensity,
                                 PointFlow, StreamWithdrawal, GroundWithdrawal, NumAnimals, AvgAnimalWt,
                                 StreamFlowVolAdj,
                                 SedAFactor_0, AvKF, AvSlope, SedAAdjust, StreamLength, n42b, AgLength,
                                 UrbBankStab, SedNitr, BankNFrac, n69c, n45, n69, n46c, n42)) / NYrs
Exemplo n.º 48
0
 def auto_roi(self):
     """
     Attempts to automatically determine the location of the atom clouds
     using find_clouds, and then creates a region of interest for the Cycle
     that is the union of the ROI for all frames
     """
     if self.clouds == []:
         self.find_clouds()
     if self.clouds == []:
         self.roi = ROI(tblr=[0, self.height - 1, 0, self.width - 1])
     self.roi = npsum([cloud.roi for cloud in self.clouds])
     for cloud in self.clouds:
         cloud.roi = self.roi
Exemplo n.º 49
0
 def auto_roi(self):
     """
     Invokes auto_roi for each cycle, which attempts to automatically
     determine the location of the atom clouds using find_clouds, and then
     creates a region of interest for the Cycle that is the union of the ROI
     for all frames
     """ 
     roilist = []
     for cycle in self.cycles:
         cycle.auto_roi()
         for frame in cycle.frames:
             roilist.append(frame.roi)            
     allroi = npsum(roilist)
     self.set_roi(tblr = allroi.tblr)
Exemplo n.º 50
0
 def find_clouds(self, thresh_OD=0.05, thresh_sum_OD=500):
     """ 
     Finds all clouds in the image frame with an OD > thresh_OD.
     If many are found, the clouds with "mass" below sum_OD are
     eliminated. These clouds are stored in frame.clouds, sorted in order
     of total mass.
     
     keywords
     --------        
     
     'thresh_OD' : number, default = 0.05
          threshold value above which a pixel is counted as part of a cloud
     'thresh_sumOD' : number, default = 500
         Minimum "mass" of a cloud for it to be counted
                 
     Usage
     ------
     
     ::
         
         > Frame.find_clouds()     # default values
         > Frame.find_clouds( thresh_OD = 0.1, thresh_sumOD = 1000 )
     """
     self.clouds = []
     self.limg = []
     self.limg, object_regions = binary_threshold(self.OD, thresh_OD)
     if len(object_regions) == 0:
         print('%s: 0 clouds with OD > %.2f' % (self.frame_id, thresh_OD))
         return
     else:
         sum_OD_list = [npsum(self.OD[obj]) for obj in object_regions]
         obj_info = zip(sum_OD_list, object_regions)
         big_obj_info = [ bo for bo in obj_info if bo[0] > thresh_sum_OD ]
         if len(big_obj_info) == 0:
             print('%s: %d clouds with OD > %.2f and sum_OD > %d' % \
               (self.frame_id, len(self.clouds), thresh_OD, thresh_sum_OD))
         else: # sort the clouds in order of decreasing mass
             for num, o in enumerate(sorted(big_obj_info, reverse=True)):
                 roi = ROI(slices = o[1])
                 roi.square()
                 roi.scale(factor = 1.2)
                 next_cloud = Cloud(frame_OD=self.OD,
                                    cloudnum = num,
                                    sumOD=o[0],
                                    init_slices=roi.slices,
                                    frame_id = self.frame_id,
                                    cam_info=self.cam_info,)
                 self.clouds.append(next_cloud)
                 print('%s: %d clouds (OD > %.2f, sum_OD > %d)' % \
                 (self.frame_id, len(self.clouds), thresh_OD, thresh_sum_OD))
Exemplo n.º 51
0
def fro_prod(A, B):
    """
    The Frobenius product is an inner product between matrices :math:`\mathbf{A}` and :math:`\mathbf{B}` of same shape.

    .. math::
        <\mathbf{A}, \mathbf{B}>_F = \sum_{i, j} \mathbf{A}_{ij} \mathbf{B}_{ij}

    :param A: (``numpy.ndarray``) a matrix.

    :param B: (``numpy.ndarray``) a matrix.

    :return: (``float``) Frobenius product value.
    """
    return npsum(multiply(A, B))
Exemplo n.º 52
0
    def fit(self, Ks, y, holdout=None):
        """Learn weights for kernel matrices or Kinterfaces.

        :param Ks: (``list``) of (``numpy.ndarray``) or of (``Kinterface``) to be aligned.

        :param y: (``numpy.ndarray``) Class labels :math:`y_i \in {-1, 1}` or regression targets.

        :param holdout: (``list``) List of indices to exlude from alignment.
        """
        model = CSI(**self.csi_args)
        p = len(Ks)
        Gs = []
        Qs = []
        Rs = []
        for K in Ks:
            model.fit(K, y, holdout)
            Gs.append(model.G)
            Rs.append(model.R)
            Qs.append(model.Q)

        # Construct holdin set if doing transductive learning
        holdin = None
        if holdout is not None:
            n = Ks[0].shape[0]
            holdin = list(set(range(n)) - set(holdout))

        # Solve for the best linear combination of weights
        a = zeros((p, 1))
        M = zeros((p, p))
        for (i, Gu), (j, Hu) in combinations(enumerate(list(Gs)), 2):
            G = center_kernel_low_rank(Gu)
            H = center_kernel_low_rank(Hu)
            M[i, j] = M[j, i] = npsum(G.T.dot(H)**2)
            if a[i] == 0:
                M[i, i] = npsum(G.T.dot(G)**2)
                if holdin is None:
                    a[i] = npsum(G.T.dot(y)**2)
                else:
                    a[i] = npsum(G[holdin, :].T.dot(y[holdin])**2)
            if a[j] == 0:
                M[j, j] = npsum(H.T.dot(H)**2)
                if holdin is None:
                    a[j] = npsum(H.T.dot(y)**2)
                else:
                    a[j] = npsum(H[holdin, :].T.dot(y[holdin])**2)

        Mi = inv(M)
        mu = Mi.dot(a) / norm(Mi.dot(a), ord=2)
        self.Gs = map(center_kernel_low_rank, Gs)
        self.G  = hstack(Gs)
        self.mu = mu
        self.trained = True
Exemplo n.º 53
0
    def cost(self, theta):
        """
        This function computes the cost associated to the softmax classifier.

        :param data: data matrix :math:`D_1\in\mathbb{R}^{d \\times n}`, where
                     :math:`d` is the dimensionality and
                     :math:`n` is the number of training samples
        :type data: numpy array
        """
        # unroll parameters from theta
        theta = reshape(theta, (self.dim, self.nclasses))
        theta = theta.T
        nsamp = self.data.shape[1]

        # generate ground truth matrix
        onevals = squeeze(ones((1, nsamp)))
        rows = squeeze(self.labels) - 1
        cols = arange(nsamp)
        ground_truth = csr_matrix((onevals, (rows, cols))).todense()

        # compute hypothesis; use some in-place computations
        theta_dot_prod = dot(theta, self.data)
        theta_dot_prod = theta_dot_prod - numpy.amax(theta_dot_prod, axis=0)
        soft_theta = npexp(theta_dot_prod)
        soft_theta_sum = npsum(soft_theta, axis=0)
        soft_theta_sum = tile(soft_theta_sum, (self.nclasses, 1))
        hyp = soft_theta / soft_theta_sum

        # compute cost
        log_hyp = nplog(hyp)
        temp = array(multiply(ground_truth, log_hyp))
        temp = npsum(npsum(temp, axis=1), axis=0)
        cost = (-1.0 / nsamp) * temp + 0.5 * self.wdecay * pow(norm(theta, "fro"), 2)
        thetagrad = (-1.0 / nsamp) * dot(ground_truth - hyp, transpose(self.data)) + self.wdecay * theta

        thetagrad = thetagrad.flatten(1)
        return cost, thetagrad
Exemplo n.º 54
0
 def train(self, inputArr2D, targets, costFunc, costFuncGrad, maxIter=100):
     '''
     This method will fit the weights of the neural network to the targets.
     :param inputArr2D: 1 input per row.
     :param targets: ground truth class label for each input
     :param costFunc: callable *f(paramToOptimize, \*arg)* that will be used as cost function.
     :param costFuncGrad: callable *f'(paramToOptimize, \*arg)* that will be used to compute partial derivative of cost function over each parameter in paramToOptimize.
     '''
     self.forwardPropogateAllInput(inputArr2D)  # perform forward propagation to set self.outputs
     avgEx = 1.0 / targets.shape[0]
     flatWeights = asarray(self.layersExOutputLy[0].forwardWeight)
     for ly in self.layersExOutputLy[1:]:
         ly.avgActvArrAllEx = avgEx * npsum(ly.self2D[:, :-1], 0)
         flatWeights = append(flatWeights, asarray(ly.forwardWeight))
     fmin_cg(costFunc, flatWeights, costFuncGrad, (inputArr2D, targets, self.__weightDecayParam, self.__sparsity, self.__sparseParam, self), maxiter=maxIter, full_output=True)  # fmin_cg calls grad before cost func
Exemplo n.º 55
0
def softmax_predict( theta, nclasses, dim,  data ):
    # unroll parameters from theta
    theta = reshape(theta,(dim, nclasses)) # Do this
    theta= theta.T

    # compute hypothesis; use some in-place computations
    theta_dot_prod = dot(theta,data)
    theta_dot_prod = theta_dot_prod - numpy.amax(theta_dot_prod, axis=0) # This was wrong
    soft_theta = npexp(theta_dot_prod)
    soft_theta_sum = npsum(soft_theta,axis=0)
    soft_theta_sum = tile(soft_theta_sum,(nclasses,1))
    hyp = soft_theta/soft_theta_sum
    print "hyp.shape"
    print hyp.shape
    pred=numpy.argmax(hyp, axis=0)

    return numpy.asarray(pred)
Exemplo n.º 56
0
def courseraML_CostFunc(weightAllLayers, *args):
    r'''
    Vectorized/regulated cost function (described in the Coursera Stanford Machine Learning course) that computes the total cost over multiple inputs:

    .. math::

        &\frac{1}{m}\sum_{i=1}^{m}\sum_{k=1}^{K}[-y_k^i log(forwardThruAllLayers(x^i)_k)-(1-y_k^i) log(1-forwardThruAllLayers(x^i)_k)]\\
        &+\frac{\lambda}{2m}\sum^{allLayers~excludeAnyBias} (weight^2)\\

    where :math:`m` =the number of inputs; :math:`k` =the number of labels in targets; :math:`y` =a single target array; :math:`x` =a single input array.

    :param weightAllLayers: A flatten array contains all forward weights.
    :param *args: Must in the following order:

        **inputArr2D**: 1 training example per row.

        **targets**: Must be a 2D ndarray instead of matrix. And the number of labels must match the number of units in output layer.

        **weightDecayParam**: For model complexity regulation.

        **sparsity**: Ignored.

        **sparseParam**: Ignored.

        **nn**: An instance of class FeedforwardNeuNet.

    :returns: A scalar representing the cost of current input using weightAllLayers.
    '''
    inputArr2D, targets, weightDecayParam, _, _, nn = args
    startIndex, weightsExcBias = 0, 0
    for ly in nn.layersExOutputLy:  # update all forward weights
        newWeight = reshape(weightAllLayers[startIndex:startIndex + ly.forwardWeight.size], ly.forwardWeight.shape)
        ly.forwardWeight = asmatrix(newWeight)
        startIndex += ly.forwardWeight.size
        weightsExcBias = append(weightsExcBias, newWeight[:-1])  # exclude weights for bias unit with [:-1]
    output = asarray(nn.forwardPropogateAllInput(inputArr2D))
    assert output.shape[1] == targets.shape[1], 'dimension mismatch in next layer'
    return 1.0 / targets.shape[0] * (npsum(-targets * log(output) - (1 - targets) * log(1 - output)) + weightDecayParam / 2.0 * npsum(weightsExcBias ** 2))
Exemplo n.º 57
0
    def sliding_window(self, x, coeff):
        """ The principle of the sliding window is the following:
            We have an array that we want to reduce by a certain factor
            (16 by default). We only reduce the array in the column
            dimension, as the row dimension is critical for certain
            features (as the 12 step chromagram). So we take the array
            and average over coeff + coeff/2 cases (50 percent overlapping)
            and store it as a new array.
            Example: if the initial shape of x is (50,1600), after the
            sliding window has been applied, its new shape is (50,100)
        """
        new_array = []
        # Determine the dimensions of x
        if x.shape != (x.shape[0],):
            for i in x:
                template = []
                for j in arange(int(len(i)/coeff)):
                    if(j != 0):
                        # If it is neither the first, nor the last case
                        template.append(float(npsum(i[j*coeff-coeff/2:(j+1)*coeff])/(coeff+coeff/2)))
                    elif j == int(len(i)/coeff)-1:
                        # Last case, filling up
                        template.append(float(npsum(i[j*coeff-coeff/2:])/len(i[j*coeff-coeff/2:])))
                    else:
                        # First case
                        template.append(float(npsum(i[:(j+1)*coeff])/coeff))
                new_array.append(template)
            xshape = (len(new_array),len(new_array[0]))
        else:
            template = []
            for j in arange(int(x.shape[0]/coeff)):
                if(j != 0):
                    template.append(float(npsum(x[j*coeff-coeff/2:(j+1)*coeff])/(coeff+coeff/2)))
                elif j == int(x.shape[0]/coeff)-1:
                    # Last case, filling up
                    template.append(float(npsum(x[j*coeff-coeff/2:])/len(x[j*coeff-coeff/2:])))
                else:
                    # First case
                    template.append(float(npsum(x[:(j+1)*coeff])/coeff))
            new_array = template
            xshape = (len(new_array),1)

        return new_array, xshape
Exemplo n.º 58
0
 def sampleV(self,v):
     self.KE.append(npsum(v**2)/2)
Exemplo n.º 59
0
def currentTemperature(v):
    #script 6.39
    mvsq=npsum(v**2)
    mvsq/=N
    currentT=mvsq/(3.0*N)
    return currentT
Exemplo n.º 60
0
from numpy import array, sum as npsum

NA = 39.5e-3 # m^2
D = 10
k = 1.78e-6 # from last assignment
S = array([998, 945, 953, 989, 934, 995])

S_mean = npsum(S) / float(S.size)

B = k * D * S_mean / float(NA)

with open("Oppgave2.2.txt", 'w') as f:
    f.write("B = %.3g \\text{ T}" % B)