Beispiel #1
0
    def fgrad_y(self, y, psi, return_precalc=False):
        """
	gradient of f w.r.t to y ([N x 1])
	returns: Nx1 vector of derivatives, unless return_precalc is true,
	then it also returns the precomputed stuff
	"""

        mpsi = psi.copy()
        mpsi[:, 0:2] = SP.exp(mpsi[:, 0:2])
        s = SP.zeros((len(psi), y.shape[0], y.shape[1]))
        r = SP.zeros((len(psi), y.shape[0], y.shape[1]))
        d = SP.zeros((len(psi), y.shape[0], y.shape[1]))

        grad = 1
        for i in range(len(mpsi)):
            a, b, c = mpsi[i]
            s[i] = b * (y + c)
            r[i] = SP.tanh(s[i])
            d[i] = 1 - r[i]**2
            grad += a * b * d[i]

        #vectorized version
        S = (mpsi[:, 1] * (y + mpsi[:, 2])).T
        R = SP.tanh(S)
        D = 1 - R**2
        GRAD = (1 + (mpsi[:, 0:1] * mpsi[:, 1:2] * D).sum(axis=0))[:,
                                                                   SP.newaxis]

        if return_precalc:
            return GRAD, S, R, D

#return grad, s, r, d

        return grad
Beispiel #2
0
	def forward_pass(self, xL, xR):

		bs = sp.ones((1,xL.shape[1]), dtype=float)

		# First Layer
		xLb = sp.vstack([xL, bs])
		xRb = sp.vstack([xR, bs])

		a1L = sp.dot(self.w1l, xLb)
		a1R = sp.dot(self.w1r, xRb)
		
		z1L = sp.tanh(a1L)
		z1R = sp.tanh(a1R)

		# Second Layer		
		z1Lb = sp.vstack([z1L, bs])
		z1LRb = sp.vstack([z1L, z1R, bs])
		z1Rb = sp.vstack([z1R, bs])

		a2L = sp.dot(self.w2l, z1Lb)
		a2LR = sp.dot(self.w2lr, z1LRb)
		a2R = sp.dot(self.w2r, z1Rb)

		z2 = a2LR*self.sigmoid(a2L)*self.sigmoid(a2R)

		# Third Layer
		z2b = sp.vstack([z2, bs])
		a3 = sp.dot(self.w3, z2b)

		return a1L, a1R, a2L, a2LR, a2R, a3, z1Lb, z1LRb, z1Rb, z2b, xLb, xRb
Beispiel #3
0
def hyperbolic_tangent(a, b, prime_offset=0.0, threshold=float('inf')):
    """Return an element-wise hyperbolic tangent with range 'a' and slope 'b'.

    i.e. f(x) = a * tanh(b * x)

    Arguments:
    a               -   Output range: [-a, +a]. (real)
    b               -   Slope parameter. (real)
    prime_offset    -   Add a constant value to the derivative, avoiding values
                        to stuck on zero for large input. (real)
    threshold       -   When the output's magnitude is greater than the 
                        threshold then return 'a' (or '-a'). (real)

    Return:
    An ActivationFunction object.

    """
    thr_fun = lambda X: (X < -threshold) * -a + (X > threshold) * a + ((X < -threshold) + (X > threshold) == 0) * X
    fun = lambda X: thr_fun(a * scipy.tanh(X * b))
    # der = lambda X: scipy.ones(X.shape) - scipy.tanh(X)**2
    ab = a * b
    der = lambda X: ab * (scipy.ones(X.shape) - scipy.tanh(X * b)**2) + scipy.ones(X.shape) * prime_offset
    inv = lambda X: scipy.arctanh(X / a) / b
    descr = "hyperbolic_tangent(%f, %f, %f, %f)" % (a, b, prime_offset, threshold)
    return ActivationFunction(fun, inv, der, descr)
Beispiel #4
0
    def fgrad_y(self, y, psi, return_precalc = False):
        """
	gradient of f w.r.t to y ([N x 1])
	returns: Nx1 vector of derivatives, unless return_precalc is true,
	then it also returns the precomputed stuff
	"""

	mpsi = psi.copy()
	mpsi[:,0:2] = SP.exp(mpsi[:,0:2])
	s = SP.zeros((len(psi), y.shape[0], y.shape[1]))
	r = SP.zeros((len(psi), y.shape[0], y.shape[1]))	
	d = SP.zeros((len(psi), y.shape[0], y.shape[1]))
	
	grad = 1
	for i in range(len(mpsi)):
	    a,b,c = mpsi[i]
	    s[i] = b*(y+c)
	    r[i] = SP.tanh(s[i])
	    d[i] = 1 - r[i]**2    
	    grad += a*b*d[i]

        #vectorized version
        S = (mpsi[:,1]*(y + mpsi[:,2])).T
        R = SP.tanh(S)
        D = 1-R**2
        GRAD = (1+(mpsi[:,0:1]*mpsi[:,1:2]*D).sum(axis=0))[:,SP.newaxis]

        if return_precalc:
            return GRAD,S,R,D
	    #return grad, s, r, d
	
	return grad
Beispiel #5
0
def DP_lib(compuesto, T):
    """Dohrn, R.; Prausnitz, J.M. A simple perturbation term for the Carnahan-Starling equation of state. Fluid Phase Eq. 1990, 61, 53."""
    Tr = T / compuesto.Tc
    if Tr >= 1:
        m = 1
    else:
        m = 0

    a1 = 0.367845 + 0.055966 * compuesto.f_acent
    a2 = -1 ** m * (0.604709 + 0.008477 * compuesto.f_acent)
    ac = 0.550408 * R_atml ** 2 * compuesto.Tc ** 2 / compuesto.Pc.atm
    a = ac * (a1 * tanh(a2 * abs(Tr - 1) ** 0.7) + 1)

    b1 = 0.356983 - 0.190003 * compuesto.f_acent
    b2 = -1 ** m * (1.37 - 1.898981 * compuesto.f_acent)
    bc = 0.187276 * R_atml * compuesto.Tc / compuesto.Pc.atm
    b = bc * (b1 * tanh(b2 * abs(log(Tr)) ** 0.8) + 1)
    sigma = (3 * b / 2 / pi / Avogadro) ** (1.0 / 3)
    return a, b, sigma

    def DP_Z(self, T, P):
        """Factor de compresibilidad según la ecuación de estado de Dohrn-Prausnith"""
        V = self.DP_V(T, P) * self.peso_molecular
        return P * V / R_atml / T

    def DP_V(self, T, P):
        """Volumen según el modelo de Dohrn-Prausnith"""
        a, b, sigma = self.DP_lib(T, P)
        D = sigma
        E = sigma ** 2
        F = sigma ** 3

        if self.Fase(T, P) == "gas":
            V = 25
        else:
            V = 0.5

        def Vm(V):
            nu = b / 4 / V
            Zref = (
                1
                + (3 * D * E / F - 2) * nu
                + (3 * E ** 3 / F ** 2 - 3 * D * E / F + 1) * nu ** 2
                - E ** 3 / F ** 2 * nu ** 3
            ) / (1 - nu) ** 3
            Zpert = a / R_atml / T / V * (1 - 1.41 * b / V / 4 + 5.07 * (b / V / 4) ** 2)
            return V - (Zref + Zpert) * R_atml * T / P

        v = fsolve(Vm, V)

        return unidades.SpecificVolume(v / self.peso_molecular)

    def DP_RhoG(self, T, P):
        """Método para el cálculo de la densidad de gases haciendo uso de la ecuación de estado de Dohrn-Prausnith"""
        z = self.DP_Z(T, P)
        return unidades.SpecificVolume(P / z / R_atml / T * self.peso_molecular)
Beispiel #6
0
def DP_lib(compuesto, T):
    """Dohrn, R.; Prausnitz, J.M. A simple perturbation term for the Carnahan-Starling equation of state. Fluid Phase Eq. 1990, 61, 53."""
    Tr = T / compuesto.Tc
    if Tr >= 1:
        m = 1
    else:
        m = 0

    a1 = 0.367845 + 0.055966 * compuesto.f_acent
    a2 = -1**m * (0.604709 + 0.008477 * compuesto.f_acent)
    ac = 0.550408 * R_atml**2 * compuesto.Tc**2 / compuesto.Pc.atm
    a = ac * (a1 * tanh(a2 * abs(Tr - 1)**0.7) + 1)

    b1 = 0.356983 - 0.190003 * compuesto.f_acent
    b2 = -1**m * (1.37 - 1.898981 * compuesto.f_acent)
    bc = 0.187276 * R_atml * compuesto.Tc / compuesto.Pc.atm
    b = bc * (b1 * tanh(b2 * abs(log(Tr))**0.8) + 1)
    sigma = (3 * b / 2 / pi / Avogadro)**(1. / 3)
    return a, b, sigma

    def DP_Z(self, T, P):
        """Factor de compresibilidad según la ecuación de estado de Dohrn-Prausnith"""
        V = self.DP_V(T, P) * self.peso_molecular
        return P * V / R_atml / T

    def DP_V(self, T, P):
        """Volumen según el modelo de Dohrn-Prausnith"""
        a, b, sigma = self.DP_lib(T, P)
        D = sigma
        E = sigma**2
        F = sigma**3

        if self.Fase(T, P) == "gas":
            V = 25
        else:
            V = 0.5

        def Vm(V):
            nu = b / 4 / V
            Zref = (1 + (3 * D * E / F - 2) * nu +
                    (3 * E**3 / F**2 - 3 * D * E / F + 1) * nu**2 -
                    E**3 / F**2 * nu**3) / (1 - nu)**3
            Zpert = a / R_atml / T / V * (1 - 1.41 * b / V / 4 + 5.07 *
                                          (b / V / 4)**2)
            return V - (Zref + Zpert) * R_atml * T / P

        v = fsolve(Vm, V)

        return unidades.SpecificVolume(v / self.peso_molecular)

    def DP_RhoG(self, T, P):
        """Método para el cálculo de la densidad de gases haciendo uso de la ecuación de estado de Dohrn-Prausnith"""
        z = self.DP_Z(T, P)
        return unidades.SpecificVolume(P / z / R_atml / T *
                                       self.peso_molecular)
Beispiel #7
0
    def encode(self, graph, input_label):
        """Perform the encoding of given graph. 
        Return the internal state representation x \in (|V(g)| x Nr) as a 
        list of arrays.
        
        How it works:
            - Start from x=0.
            - For each vertex v compute: 
                x_t(v) = tanh( W_in u(v) + \sum_{w \in N(v)} W x_{t-1}(w) ).
            - Stop when 
                ||x_t - x_{t-1}|| < epsilon 
              for each vertex or after a fixed number of iterations.

        Note: no bias is needed in the input label. A bias term (+1) is added 
        during the encoding process.

        Arguments:
        graph       --  Input Graph.
        input_label --  Name of the attribute storing the input label.
                        Input label must be a scipy.array shaped (Nu,). (string) 
        
        Return:
        Internal representation of the graph (scipy.array (|V(g)|,Nr)).
        
        Exceptions:
        Raise an error if the encoding doesn't converge (i.e. after 'maxit'
        iterations).

        """
        key = self._extract_key(graph, input_label)
        if key in self._cache_encode:
            return self._cache_encode[key]
        else:
            Wu = self._compute_Wu(graph, input_label)  # W_in u(v), (|V|,Nr)
            x = scipy.zeros((len(graph.vertices), self.Nr))  # (|V|,Nr)
            done = False
            it = 0  # iteration counter
            while (not done) and it < self.maxit:
                if it == 0:  # x_0(v) = 0 = Wx_0 for each vertex
                    next_x = scipy.tanh(Wu)
                else:
                    Wx = self._compute_Wx(graph, x)  # (|V|,Nr)
                    next_x = scipy.tanh(Wx + Wu)
                # check for convergence
                done = self._check_convergence(x, next_x)
                x = next_x  # update current encoding
                it += 1
            if it == self.maxit:
                raise Exception("Unable to reach reservoir convergence")
            assert x.shape == (len(graph.vertices), self.Nr), \
                "Invalid shape x(g): %s" % str(x.shape)
            if self.memo_enc:
                self._cache_encode[key] = x  # save result
            return x
Beispiel #8
0
def double_tanh_warp(x, n, lcore, lmid, ledge, la, lb, xa, xb):
    r"""Implements a sum-of-tanh warping function and its derivative.
    
    .. math::
    
        l = a\tanh\frac{x-x_a}{l_a} + b\tanh\frac{x-x_b}{l_b}
    
    Parameters
    ----------
    x : float or array of float
        Locations to evaluate the function at.
    n : int
        Derivative order to take. Used for ALL of the points.
    lcore : float
        Core length scale.
    lmid : float
        Intermediate length scale.
    ledge : float
        Edge length scale.
    la : positive float
        Transition of first tanh.
    lb : positive float
        Transition of second tanh.
    xa : float
        Transition of first tanh.
    xb : float
        Transition of second tanh.
    
    Returns
    -------
    l : float or array
        Warped length scale at the given locations.

    Raises
    ------
    NotImplementedError
        If `n` > 1.
    """
    a, b, c = scipy.dot([[-0.5, 0, 0.5], [0, 0.5, -0.5], [0.5, 0.5, 0]],
                        [[lcore], [ledge], [lmid]])
    a = a[0]
    b = b[0]
    c = c[0]
    if n == 0:
        return a * scipy.tanh((x - xa) / la) + b * scipy.tanh(
            (x - xb) / lb) + c
    elif n == 1:
        return (a / la * (scipy.cosh(
            (x - xa) / la))**(-2.0) + b / lb * (scipy.cosh(
                (x - xb) / lb))**(-2.0))
    else:
        raise NotImplementedError(
            "Only derivatives up to order 1 are supported!")
Beispiel #9
0
def RegularLightSimple(t, Intensity=150.0, wakeUp=8.0, workday=16.0):
    """Define a basic light schedule with a given intensity of the light, wakeup time and length of the active period (non-sleeping)
    This schedule will automatically repeat on a daily basis, so each day will be the same.....
    """

    s=fmod(t,24.0)-wakeUp

    if (s<0):
        s+=24.0

    val=0.5*sp.tanh(100*(s)) - 0.5*sp.tanh(100*(s - workday))
    return(Intensity*val)
Beispiel #10
0
    def encode(self, graph, input_label):
        """Override the GraphESN.encode method.

        New encode is performed considering also auxiliary reservoir inputs,
        possibly coming from other PluggableGraphESN.
        Encoding step il modified as following:

        x_t(v) = tanh( W_in u(v) + \sum_{w \in N(v)} W x_{t-1}(w) + W_aux z_aux(g) )

        It's worth mentioning that z_aux(g) is the concatenation of values all
        referring to the whole graph instead of the current vertex. This allows
        the local encoding process to exploit contextual informations.

        Arguments:
        graph       --  Input Graph.
        input_label --  Name of the attribute storing the input label.
                        Input label must be a scipy.array shaped (Nu,). (string)
        
        Return:
        Internal representation of the graph (scipy.array (|V(g)|,Nr)).        

        Exceptions:
        Raise an error if the encoding doesn't converge (i.e. after 'maxit'
        iterations).

        """
        key = self._extract_key(graph, input_label)
        if key in self._cache_encode:
            return self._cache_encode[key]
        else:
            Wu = self._compute_Wu(graph, input_label)  # W_in u(v), (|V|,Nr)
            Wz = self._compute_Wz(graph, input_label)  # W_aux z_sub(g), (Nr,)
            Wuz = Wu + Wz  # W_in u(v) + W_sub z_sub(g) forall v, (|V|,Nr)
            x = scipy.zeros((len(graph.vertices), self.Nr))  # (|V|,Nr)
            done = False
            it = 0  # iteration counter
            while (not done) and it < self.maxit:
                if it == 0:  # x_0(v) = 0 = Wx_0 for each vertex
                    next_x = scipy.tanh(Wu)
                else:
                    Wx = self._compute_Wx(graph, x)  # (|V|,Nr)
                    next_x = scipy.tanh(Wx + Wuz)
                # check for convergence
                done = self._check_convergence(x, next_x)
                x = next_x  # update current encoding
                it += 1
            if it == self.maxit:
                raise Exception("Unable to reach reservoir convergence")
            assert x.shape == (len(graph.vertices), self.Nr), \
                "Invalid shape x(g): %s" % str(x.shape)
            if self.memo_enc:
                self._cache_encode[key] = x  # save result
            return x
Beispiel #11
0
    def generateTS(self):

        dt=1.0/60.0 #minute long bins
        self.time=np.arange(0.0, 24.0*1000+dt, dt)

        self.lightVals=[]

        period=24.0 #period of the days
        AP=16.0 #activity period (this is allowed to vary day to day)
        PP=12.0 #photoperiod (hours where you can get outdoor sunlight, this is fixed)
        IntLast=0.0
        LightOnset=0.0 #This controls when the AP starts (defaults to dawn). Can't do wake up earlier than dawn as of yet

        for t in self.time:

            day=t/24.0

            if (day.is_integer()):
                AP=np.random.normal(loc=self.ap_loc, scale=self.ap_sd)
                if (AP>22.0):
                    AP=22.0
                if(PP < 12.0):
                    AP=12.0

                #LightOnset=np.random.uniform(0.0,2.0)



            val=0.5*sp.tanh(10*(fmod(t, period)-LightOnset)) - 0.5*sp.tanh(10*(fmod(t, period) - (AP+LightOnset))) #Sleep modulation of light input
            if (fmod(t, period)<=PP):
                Int=self.background_ll+10**np.random.normal(0.0,self.nl_sd) #Random light Intensity, allowing for natural light exposures
            else:
                Int=self.background_ll+np.random.normal(loc=0.0, scale=self.al_sd) #Random light intensity only indoor ranges

            if (Int> 10000):
                Int=10000.0
            if (Int < 0.0):
                Int=0.0
            self.lightVals.append(Int*val)

            IntLast=Int

        self.lightVals=np.array(self.lightVals)

        #Do some smoothing of the data
        LightTS=pd.Series(self.lightVals, self.time)
        b=LightTS.rolling(window=10, center=False).mean()
        self.lightVals[10:]=b.values[10:]

        self.LightFunc=interpolate.interp1d(self.time, self.lightVals)
Beispiel #12
0
def double_tanh_warp(x, n, lcore, lmid, ledge, la, lb, xa, xb):
    r"""Implements a sum-of-tanh warping function and its derivative.

    .. math::

        l = a\tanh\frac{x-x_a}{l_a} + b\tanh\frac{x-x_b}{l_b}

    Parameters
    ----------
    x : float or array of float
        Locations to evaluate the function at.
    n : int
        Derivative order to take. Used for ALL of the points.
    lcore : float
        Core length scale.
    lmid : float
        Intermediate length scale.
    ledge : float
        Edge length scale.
    la : positive float
        Transition of first tanh.
    lb : positive float
        Transition of second tanh.
    xa : float
        Transition of first tanh.
    xb : float
        Transition of second tanh.

    Returns
    -------
    l : float or array
        Warped length scale at the given locations.

    Raises
    ------
    NotImplementedError
        If `n` > 1.
    """
    a, b, c = scipy.dot([[-0.5, 0, 0.5], [0, 0.5, -0.5], [0.5, 0.5, 0]],
                        [[lcore], [ledge], [lmid]])
    a = a[0]
    b = b[0]
    c = c[0]
    if n == 0:
        return a * scipy.tanh((x - xa) / la) + b * scipy.tanh((x - xb) / lb) + c
    elif n == 1:
        return (a / la * (scipy.cosh((x - xa) / la))**(-2.0) +
                b / lb * (scipy.cosh((x - xb) / lb))**(-2.0))
    else:
        raise NotImplementedError("Only derivatives up to order 1 are supported!")
Beispiel #13
0
    def calculate_dwf(self):
        """
        Calculates Debye-Waller factor according to
        Sears and Shelley Acta Cryst. A 47, 441 (1991)
        """
        run = self.vanaws.getRun()
        nhist = self.vanaws.getNumberHistograms()
        thetasort = np.zeros(nhist)  # theta in radians, not 2Theta

        instrument = self.vanaws.getInstrument()
        detID_offset = self.get_detID_offset()

        for i in range(nhist):
            det = instrument.getDetector(i + detID_offset)
            thetasort[i] = 0.5*np.sign(np.cos(det.getPhi()))*self.vanaws.detectorTwoTheta(det)
            # thetasort[i] = 0.5*self.vanaws.detectorSignedTwoTheta(det) # gives opposite sign for detectors 0-24

        temperature = self.get_temperature()                    # T in K
        wlength = float(run.getLogData('wavelength').value)     # Wavelength, Angstrom
        mass_vana = 0.001*self.Mvan/sp.constants.N_A            # Vanadium mass, kg
        temp_ratio = temperature/self.DebyeT

        if temp_ratio < 1.e-3:
            integral = 0.5
        else:
            integral = integrate.quad(lambda x: x/sp.tanh(0.5*x/temp_ratio), 0, 1)[0]

        msd = 3.*sp.constants.hbar**2/(2.*mass_vana*sp.constants.k * self.DebyeT)*integral*1.e20
        return np.exp(-msd*(4.*sp.pi*sp.sin(thetasort)/wlength)**2)
Beispiel #14
0
def plot_neural_net(X, y, clf, segment=False):
    values = X
    pca_plot(X, y, save="00_conn.png", segment=segment)
    counter = 1
    for i, layer in enumerate(clf.nn.modulesSorted):
        name = layer.__class__.__name__
        if name == "BiasUnit":
            continue

        try:
            conn = clf.nn.connections[layer][0]
        except IndexError:
            continue

        if "Linear" not in name:
            if "Sigmoid" in name:
                add = "sigmoid"
                values = sigmoid(values)
            elif "Tanh" in name:
                add = "tanh"
                values = tanh(values)
            pca_plot(values, y, save="%02d_conn_%s.png" % (counter, add), segment=segment)
            counter += 1
        shape = (conn.outdim, conn.indim)
        temp = numpy.dot(numpy.reshape(conn.params, shape), values.T)
        pca_plot(temp.T, y, save="%02d_conn.png" % counter, segment=segment)
        counter += 1
        values = temp.T
Beispiel #15
0
    def calculateELBO(self):
        # Compute Evidence Lower Bound using the lower bound to the likelihood
        Z = self.markov_blanket["Z"].getExpectation()
        Wtmp = self.markov_blanket["W"].getExpectations()
        Ztmp = self.markov_blanket["Z"].getExpectations()
        zeta = self.params["zeta"]
        SW, SWW = Wtmp["E"], Wtmp["E2"]
        Z, ZZ = Ztmp["E"], Ztmp["E2"]
        mask = self.getMask()

        # calculate E(Z)E(W)
        ZW = Z.dot(SW.T)
        ZW[mask] = 0.

        # Calculate E[(ZW_nd)^2]
        # this is equal to E[\sum_{k != k} z_k w_k z_k' w_k'] + E[\sum_{k} z_k^2 w_k^2]
        tmp1 = s.square(ZW) - s.dot(
            s.square(Z),
            s.square(SW).T)  # this is for terms in k != k'
        tmp2 = ZZ.dot(SWW.T)  # this is for terms in k = k'
        EZZWW = tmp1 + tmp2

        # calculate elbo terms
        term1 = 0.5 * ((2. * self.obs - 1.) * ZW - zeta)
        term2 = -s.log(1 + s.exp(-zeta))
        term3 = -1 / (4 * zeta) * s.tanh(zeta / 2.) * (EZZWW - zeta**2)

        lb = term1 + term2 + term3
        lb[mask] = 0.

        return lb.sum()
Beispiel #16
0
    def draw_eccentricities(self, eccentricity='flat', emin=0., emax='tidal'):
        """Draw a new eccentricity distribution.

        Either provide an array (with the same length as the number of binaries) or choose from:
        - 'flat': Flat distribution between `emin` and `emax`.
        - 'thermal`: f(e) ~ e^2 between `emin` and `emax`.

        If `emax` is set to 'tidal' it will depend on the period of the binary to mimic tidal circulirization through:
        emax = max(emin, 0.5 * (0.95 + tanh(0.6 * log_10(period in days) - 1.7)))
        If this setting is chosen the eccentricities will have to be redrawn if the periods are redrawn.

        Arguments:
        - `eccentricity`: New eccentricity distribution (array or name of distriution).
        - `emin`: Minimum eccentricity (default: 0.)
        - `emax`: Maximum eccentricity (default: set by tidal circularization)
        """
        nbinaries = self.size
        if emax == 'tidal':
            emax =  .5 * (0.95 + sp.tanh(0.6 * sp.log10(self['period'] * 365.25) - 1.7))
            emax[emax < emin] = emin
        if eccentricity == 'flat':
            self['eccentricity'] = sp.random.rand(nbinaries) * (emax - emin) + emin
        elif eccentricity == 'thermal':
            self['eccentricity'] = sp.sqrt(sp.random.rand(nbinaries) * (emax ** 2. - emin ** 2.) + emin ** 2.)
        elif isinstance(eccentricity, basestring):
            raise ValueError("Eccentricity distribution '%s' not found" % eccentricity)
        else:
            self['eccentricity'] = eccentricity
Beispiel #17
0
    def calculate_dwf(self):
        """
        Calculates Debye-Waller factor according to
        Sears and Shelley Acta Cryst. A 47, 441 (1991)
        """
        run = self.vanaws.getRun()
        nhist = self.vanaws.getNumberHistograms()
        thetasort = np.empty(nhist)  # half of the scattering angle, in radians
        for i in range(nhist):
            det = self.vanaws.getDetector(i)
            thetasort[i] = 0.5 * self.vanaws.detectorTwoTheta(det)

        # T in K
        temperature = self.get_temperature()
        # Wavelength, Angstrom
        wlength = float(run.getLogData('wavelength').value)
        # Vanadium mass, kg
        mass_vana = 0.001 * self.Mvan / sp.constants.N_A
        temp_ratio = temperature / self.DebyeT

        if temp_ratio < 1.e-3:
            integral = 0.5
        else:
            integral = \
                integrate.quad(lambda x: x/sp.tanh(0.5*x/temp_ratio), 0, 1)[0]

        msd = 3.*sp.constants.hbar**2 / \
            (2.*mass_vana*sp.constants.k * self.DebyeT)*integral*1.e20
        return np.exp(-msd * (4. * sp.pi * sp.sin(thetasort) / wlength)**2)
    def calculate_dwf(self):
        """
        Calculates Debye-Waller factor according to
        Sears and Shelley Acta Cryst. A 47, 441 (1991)
        """
        run = self.vanaws.getRun()
        nhist = self.vanaws.getNumberHistograms()
        thetasort = np.empty(nhist)  # half of the scattering angle, in radians
        for i in range(nhist):
            det = self.vanaws.getDetector(i)
            thetasort[i] = 0.5 * self.vanaws.detectorTwoTheta(det)

        # T in K
        temperature = self.get_temperature()
        # Wavelength, Angstrom
        wlength = float(run.getLogData('wavelength').value)
        # Vanadium mass, kg
        mass_vana = 0.001*self.Mvan/sp.constants.N_A
        temp_ratio = temperature/self.DebyeT

        if temp_ratio < 1.e-3:
            integral = 0.5
        else:
            integral = \
                integrate.quad(lambda x: x/sp.tanh(0.5*x/temp_ratio), 0, 1)[0]

        msd = 3.*sp.constants.hbar**2 / \
            (2.*mass_vana*sp.constants.k * self.DebyeT)*integral*1.e20
        return np.exp(-msd*(4.*sp.pi*sp.sin(thetasort)/wlength)**2)
Beispiel #19
0
def ne(rho, ncore, nped):
    #horrible function from /u/dlbo/w_diag/fit_function_ne_profile.pro, used by the GIW shotfile generator w_diag
    temp = (_func(rho) - _func(.97)) / (_func(0.) - _func(.97))
    temp[rho > .97] = 0.

    return temp * (ncore - nped) * scipy.exp(
        -2 * pow(rho, 2)) + nped * .5 * (1 + scipy.tanh((.99 - rho) * 80))
Beispiel #20
0
    def calculate_dwf(self):
        """
        Calculates Debye-Waller factor according to
        Sears and Shelley Acta Cryst. A 47, 441 (1991)
        """
        run = self.vanaws.getRun()
        nhist = self.vanaws.getNumberHistograms()
        thetasort = np.zeros(nhist)  # theta in radians, not 2Theta

        instrument = self.vanaws.getInstrument()
        detID_offset = self.get_detID_offset()

        for i in range(nhist):
            det = instrument.getDetector(i + detID_offset)
            thetasort[i] = 0.5*np.sign(np.cos(det.getPhi()))*self.vanaws.detectorTwoTheta(det)
            # thetasort[i] = 0.5*self.vanaws.detectorSignedTwoTheta(det) # gives opposite sign for detectors 0-24

        temperature = self.get_temperature()                    # T in K
        wlength = float(run.getLogData('wavelength').value)     # Wavelength, Angstrom
        mass_vana = 0.001*self.Mvan/sp.constants.N_A            # Vanadium mass, kg
        temp_ratio = temperature/self.DebyeT

        if temp_ratio < 1.e-3:
            integral = 0.5
        else:
            integral = integrate.quad(lambda x: x/sp.tanh(0.5*x/temp_ratio), 0, 1)[0]

        msd = 3.*sp.constants.hbar**2/(2.*mass_vana*sp.constants.k * self.DebyeT)*integral*1.e20
        return np.exp(-msd*(4.*sp.pi*sp.sin(thetasort)/wlength)**2)
 def astroOut(self):
     for astro in self.astros:
         astro.act = tanh(astro.act)
         for syn in astro.syns:
             i, j = syn
             self.astroOuts[i][j] = astro.act * self.syn_wi[i][j]
     return self.astroOuts.copy()
Beispiel #22
0
def tanh_warp_arb(X, l1, l2, lw, x0):
    r"""Warps the `X` coordinate with the tanh model
    
    .. math::
    
        l = \frac{l_1 + l_2}{2} - \frac{l_1 - l_2}{2}\tanh\frac{x-x_0}{l_w}
    
    Parameters
    ----------
    X : :py:class:`Array`, (`M`,) or scalar float
        `M` locations to evaluate length scale at.
    l1 : positive float
        Small-`X` saturation value of the length scale.
    l2 : positive float
        Large-`X` saturation value of the length scale.
    lw : positive float
        Length scale of the transition between the two length scales.
    x0 : float
        Location of the center of the transition between the two length scales.
    
    Returns
    -------
    l : :py:class:`Array`, (`M`,) or scalar float
        The value of the length scale at the specified point.
    """
    if isinstance(X, scipy.ndarray):
        if isinstance(X, scipy.matrix):
            X = scipy.asarray(X, dtype=float)
        return 0.5 * ((l1 + l2) - (l1 - l2) * scipy.tanh((X - x0) / lw))
    else:
        return 0.5 * ((l1 + l2) - (l1 - l2) * mpmath.tanh((X - x0) / lw))
Beispiel #23
0
def tanh_warp_arb(X, l1, l2, lw, x0):
    r"""Warps the `X` coordinate with the tanh model

    .. math::

        l = \frac{l_1 + l_2}{2} - \frac{l_1 - l_2}{2}\tanh\frac{x-x_0}{l_w}

    Parameters
    ----------
    X : :py:class:`Array`, (`M`,) or scalar float
        `M` locations to evaluate length scale at.
    l1 : positive float
        Small-`X` saturation value of the length scale.
    l2 : positive float
        Large-`X` saturation value of the length scale.
    lw : positive float
        Length scale of the transition between the two length scales.
    x0 : float
        Location of the center of the transition between the two length scales.

    Returns
    -------
    l : :py:class:`Array`, (`M`,) or scalar float
        The value of the length scale at the specified point.
    """
    if isinstance(X, scipy.ndarray):
        if isinstance(X, scipy.matrix):
            X = scipy.asarray(X, dtype=float)
        return 0.5 * ((l1 + l2) - (l1 - l2) * scipy.tanh((X - x0) / lw))
    else:
        return 0.5 * ((l1 + l2) - (l1 - l2) * mpmath.tanh((X - x0) / lw))
Beispiel #24
0
def EstimateCC_NewHighRes(cutoff, d0, r, Ey):
    '''Estimate a New High resolution
    cutoff based on CC1/2=value
    Ey is used to check if experimental data
    contain a CC1/2<Threshold, if not
    function is stopped
    '''
    from math import sqrt
    from scipy import tanh
    from numpy import linspace

    #Check if calculation is sensible or not
    if cutoff <= min(Ey):
        print "WARNING: data don't reach this cutoff value...skipping CC1/2 analysis"
        return

    cutoff = float(cutoff)
    d0 = float(d0)
    r = float(r)
    HighRes = None
    CC_calc, delta = [], []
    #Searching for CC1/2 resolution by minimizing CC1/2-cutoff
    x = linspace(0., 1., 1001).tolist()
    for val in x:
        CC_calc.append((0.5 * (1 - tanh((val - d0) / r))))

    for val in CC_calc:
        delta.append(abs(val - cutoff))
    HighRes = round(sqrt(1 / x[delta.index(min(delta))]), 2)
    CalculatedCutoff = CC_calc[delta.index(min(delta))]
    print '''   %s
   ->  Suggested New High Resolution Limit: %.2f A for CC1/2= %.2f <-
   %s
   ''' % ('=' * 66, HighRes, CalculatedCutoff, '=' * 66)
    return HighRes
Beispiel #25
0
    def draw_eccentricities(self, eccentricity='flat', emin=0., emax='tidal'):
        """Draw a new eccentricity distribution.

        Either provide an array (with the same length as the number of binaries) or choose from:
        - 'flat': Flat distribution between `emin` and `emax`.
        - 'thermal`: f(e) ~ e^2 between `emin` and `emax`.

        If `emax` is set to 'tidal' it will depend on the period of the binary to mimic tidal circulirization through:
        emax = max(emin, 0.5 * (0.95 + tanh(0.6 * log_10(period in days) - 1.7)))
        If this setting is chosen the eccentricities will have to be redrawn if the periods are redrawn.

        Arguments:
        - `eccentricity`: New eccentricity distribution (array or name of distriution).
        - `emin`: Minimum eccentricity (default: 0.)
        - `emax`: Maximum eccentricity (default: set by tidal circularization)
        """
        nbinaries = self.size
        if emax == 'tidal':
            emax = .5 * (
                0.95 + sp.tanh(0.6 * sp.log10(self['period'] * 365.25) - 1.7))
            emax[emax < emin] = emin
        if eccentricity == 'flat':
            self['eccentricity'] = sp.random.rand(nbinaries) * (emax -
                                                                emin) + emin
        elif eccentricity == 'thermal':
            self['eccentricity'] = sp.sqrt(
                sp.random.rand(nbinaries) * (emax**2. - emin**2.) + emin**2.)
        elif isinstance(eccentricity, basestring):
            raise ValueError("Eccentricity distribution '%s' not found" %
                             eccentricity)
        else:
            self['eccentricity'] = eccentricity
 def astroOut(self):
     for astro in self.astros:
         astro.act = tanh(astro.act)
         for syn in astro.syns:
             i, j = syn
             self.astroOuts[i][j] = astro.act * self.syn_wi[i][j]  
     return self.astroOuts.copy()
Beispiel #27
0
def calculateCPandRT(stim_strengths, k, A, t1_nondt, t2_nondt):
    """
    Given a diffusion to bound model with flat bounds, compute the following
    as a function of stimulus strength:
        1) Probability of t1 choice (correct choice for positive strengths)
        2) Mean reaction times for t1 and t2 choices

    Parameters
    ----------
    stim_strengths : array of unique stimulus strengths

    k : float, proportionality constant between stim_strength and drift rate

    A : float, bound

    t1_nondt: float, non decision time for making t1 choice

    t2_nondt: float, non decision time for making t2 choice

    Returns
    -------
    out : dictionary with keys stim_strength, p_t1, t1_meanrt, t2_meanrt

    """

    # compute probability of t1 response given k and A
    p = 1 / (1 + np.exp(-2 * A * k * stim_strengths))

    # compute mean response times for t1 and t2
    t1_meanrt = np.zeros(len(stim_strengths))
    t2_meanrt = np.zeros(len(stim_strengths))
    for i in range(len(stim_strengths)):
        if stim_strengths[i] == 0:
            t1_meanrt[i] = A ** 2 + t1_nondt
            t2_meanrt[i] = A ** 2 + t2_nondt
        else:
            t1_meanrt[i] = A / (k * stim_strengths[i]) * \
                sp.tanh(A * k * stim_strengths[i]) + t1_nondt
            t2_meanrt[i] = A / (k * stim_strengths[i]) * \
                sp.tanh(A * k * stim_strengths[i]) + t2_nondt

    out = {}
    out['stim_strengths'] = stim_strengths
    out['p_t1'] = p
    out['t1_meanrt'] = t1_meanrt
    out['t2_meanrt'] = t2_meanrt
    return out
 def activateHid(self):
     # self.ah[:] = tanh(sum(self.wi.T * self.ai, axis=1))
     for j in range(self.hiddim):
         s = 0
         for i in range(self.indim):
             s += sum(self.wi[i][j] * (self.ai + self.astroOuts[i][j]))
             # print self.astroOuts
         self.ah[j] = tanh(s)
def TempProfile(z,T0=1000.,z0=100.):
    """This function creates a tempreture profile for test purposes."""
    zall = (z-z0)*2.*sp.exp(1)/400. -sp.exp(1)
    atanshp = (sp.tanh(zall)+1.)/2
    Te = 1700*atanshp+T0
    Ti = 500*atanshp+T0

    return (Te,Ti)
Beispiel #30
0
def func(x, d0, r):
    '''x and y are lists of same size
       x is 1/d**2, y is CC1/2
       d0 is 1/d**2 at half decrease
       r is the steepness of the falloff
    '''
    from scipy import tanh
    return 0.5 * (1 - tanh((x - d0) / r))
 def activateHid(self):
     # self.ah[:] = tanh(sum(self.wi.T * self.ai, axis=1))
     for j in range(self.hiddim):
         s = 0
         for i in range(self.indim):
             s += sum(self.wi[i][j] * (self.ai + self.astroOuts[i][j]))
             # print self.astroOuts
         self.ah[j] = tanh(s)
Beispiel #32
0
def get_rotation_angle(t, f, amp, u, k, phase=0.0):
    """
    Rotation angle function w/ J. Wang's shape parameter. The control input shifts
    the mean rotation angle.

    Arguments:
        t     = array of time points 
        f     = flapping frequency
        amp   = rotation angle amplitude
        u     = control input, scalar or array
        k     = shape parameter, k near 0 implies sinewave, k large implies
                square wave.
    """

    alpha = amp / scipy.tanh(k) * scipy.tanh(
        k * scipy.sin(2 * PI * f * t + phase)) + u
    return alpha
Beispiel #33
0
def grate(k,L):
    l2 = (np.pi**2)/(4*(L**2))
    mu = np.sqrt(k**2 + l2) 
    th = sp.tanh(mu/2.)
    cth = 1./th
    sigma = (k/mu)*np.sqrt( (mu/2.-cth)*(th-mu/2.)  )
    sigma[np.isnan(sigma)] = 0.
    return sigma
def step(x, break_points):
    """
    Step-like scaling function.

    Parameters
    ----------
    x: ndarray
        An input array, for which to compute the scalings.
    break_points: tuple
        A list of the break points. Each entry should be a tuple of
        (break_position, break_width).

    Returns
    -------
    ndarray
        Array of computed scales in the [-1; 1] range.
    """

    # Applying the first break point
    break_point = break_points[0]
    break_x = break_point[0]
    break_width = break_point[1]

    res = scipy.tanh((x - break_x) / break_width)
    sign = 1

    # If there are more break points given, applying them as well
    for break_point in break_points[1:]:
        # First recalling the previous break point position
        break_x_old = break_x

        # New break point data
        break_x = break_point[0]
        break_width = break_point[1]

        # Will fill only points above the transition position
        trans_x = (break_x + break_x_old) / 2.0
        above_trans_x = scipy.where(x >= trans_x)

        # Flip the sign - above the transition position function behaviour is reversed
        sign *= -1
        res[above_trans_x] = sign * scipy.tanh(
            (x[above_trans_x] - break_x) / break_width)

    return res
Beispiel #35
0
 def performAction(self, action):
     #Filtered mapping towards performAction of the underlying environment
     #The standard Johnnie task uses a PID controller to controll directly angles instead of forces
     #This makes most tasks much simpler to learn
     isJoints=self.env.getSensorByName('JointSensor') #The joint angles
     isSpeeds=self.env.getSensorByName('JointVelocitySensor') #The joint angular velocitys
     act=(action+1.0)/2.0*(self.env.cHighList-self.env.cLowList)+self.env.cLowList #norm output to action intervall
     action=tanh((act-isJoints-isSpeeds)*16.0)*self.maxPower*self.env.tourqueList #simple PID
     EpisodicTask.performAction(self, action)
Beispiel #36
0
 def performAction(self, action):
     #Filtered mapping towards performAction of the underlying environment   
     #The standard Johnnie task uses a PID controller to controll directly angles instead of forces
     #This makes most tasks much simpler to learn             
     isJoints=self.env.getSensorByName('JointSensor') #The joint angles
     isSpeeds=self.env.getSensorByName('JointVelocitySensor') #The joint angular velocitys
     act=(action+1.0)/2.0*(self.env.cHighList-self.env.cLowList)+self.env.cLowList #norm output to action intervall  
     action=tanh((act-isJoints-isSpeeds)*16.0)*self.maxPower*self.env.tourqueList #simple PID
     EpisodicTask.performAction(self, action)
Beispiel #37
0
def fun(t, z):
    i = 1
    Fr = sp.zeros(40)
    while i < 20:
        Fr[i +
           20] = -(CAP[i]) * invM[i, i] * sp.tanh((z[20 + i]) - z[20 + i - 1])
        i += 1

    return sp.matmul(A, z) + Fr
Beispiel #38
0
def te(rho, tcore, tped):
    #horrible function from /u/dlbo/w_diag/fit_function_te_profile_new.pro, used by the GIW shotfile generator w_diag

    #corr = scipy.exp(-3.*pow(.97-rho,2))
    #temp = ((1-corr)+.97*6*scipy.exp(-3*pow(.97,2))*(rho*scipy.exp(-8*pow(rho,2))-.97*scipy.exp(-8*pow(.97,2))))/0.940374146
    temp = (_func(rho) - _func(.97)) / (_func(0.) - _func(.97))
    temp[rho > .97] = 0.

    return temp * (tcore - tped) * scipy.exp(
        -2 * pow(rho, 2)) + tped * .5 * (1 + scipy.tanh((.985 - rho) * 60))
Beispiel #39
0
def avgxHomogeneous(h, J, N):
    Zfunc = lambda m: scipy.exp(-FHomogeneous(h, J, N, m))
    Z = scipy.integrate.quad(Zfunc, -scipy.inf, scipy.inf)[0]

    Jbar = N * J
    xFunc = lambda m: scipy.tanh(2. * Jbar * m + h) * scipy.exp(-FHomogeneous(
        h, J, N, m))
    avgx = scipy.integrate.quad(xFunc, -scipy.inf, scipy.inf)[0] / Z

    return avgx
Beispiel #40
0
 def update_reservoir(self, u, n, Y):
     # u is input at specific time
     #   u has shape (N_u (3 for L63))
     # See page 16 eqtn 18 of Lukosevicius PracticalESN for feedback info.
     x_n_tilde = sp.tanh(
         sp.matmul(self.W, self.x[n]) +
         sp.matmul(self.W_in, sp.hstack((sp.array([1]), u))) +
         sp.matmul(self.W_fb, Y))  # TODO: Add derivative term?
     self.x[n+1] = sp.multiply((1-self.alpha_matrix), self.x[n]) \
           + sp.multiply(self.alpha_matrix, x_n_tilde)
def main():
    a = array([1, 1])
    b = array([0, 0])
    x = array([-0.5, 1])
    y = tanh(a * x + b)

    dbma = [-(-0.46 * 2.79), -(0.76 * 2.42)]

    print("ma byt:", dbma[0], dbma[1])
    print("je:", ipgauss(x, y, a, b)[0])
Beispiel #42
0
    def dNeurons(self, statevec, t):

        # Extract relevant parameters from
        train = training > 0 and t > training and t < training + train_dur

        x_i = statevec[0:Ng]
        w_i = statevec[Ng:2 * Ng]

        # generate noise patterns
        exp_noise_amp = 0.1
        if train:
            zeta = np.random.uniform(-exp_noise_amp, exp_noise_amp, 1)
        else:
            zeta = 0.0

        # Compute Firing Rates and feedback signals
        r_i = sp.tanh(x_i) + zeta_state(t)
        z_i = np.dot(w_i, r_i) + zeta

        # Compute next timestep depending on if training or not
        if train:

            dxidt = (-x_i + lambd * np.dot(W_rec, r_i) +
                     np.dot(W_in_left, self.uleft[t]) +
                     np.dot(W_in_right, self.uright[t]) + z_i * W_fb) / tau
            x_new = x_i + dxidt * dt

            P = -1.0 * sp.power(z_i - self.f_target[t], 2)
            M = 1.0 * (P > self.P_avg)

            dwdt = eta(t) * (z_i - self.z_avg) * M * r_i
            w_new = w_i + dwdt * dt

            self.P_avg = (1 - (dt / tau_avg)) * self.P_avg + (dt / tau_avg) * P
            self.z_avg = (1 -
                          (dt / tau_avg)) * self.z_avg + (dt / tau_avg) * z_i

        else:

            dxidt = (-x_i + lambd * np.dot(W_rec, r_i) +
                     np.dot(W_in_left, self.uleft[t]) +
                     np.dot(W_in_right, self.uright[t]) + z_i * W_fb) / tau

            x_new = x_i + dxidt * dt
            dwdt = np.zeros(np.shape(w_i))
            w_new = w_i

        #weight change magnitude:
        dwmag = LA.norm(dwdt)
        rmag = LA.norm(r_i)
        if t % 10000 == 0:
            print(str(t) + '    ' + str(z_i) + '   ' + str(train))
        self.zsave[t] = z_i
        self.rsave[t] = rmag
        return np.concatenate((x_new, w_new))
Beispiel #43
0
def fun(t, z):
    #---- Esto sirve solo para reportar en que tiempo vamos
    if t > fun.tnextreport:
        print "  {} at t = {}".format(fun.solver, fun.tnextreport)
        fun.tnextreport += 1

    if fun.solver != "Euler":
        z = np.squeeze(z)
    Famort = sp.zeros(40)  #vector de fuerza friccional de amortiguamiento
    Famort[0] = -(CAP[0] * (1. / M[0, 0]) * sp.tanh((z[20] / vr)))

    for i in range(1, 20):
        Famort[i] = -(1. / M[i, i]) * CAP[i] * sp.tanh(
            (z[i + 20] - z[i - 1 + 20]) / vr)

    Ft = sp.zeros(40)
    if t < 226.81:
        Ft[20:] = inte(t) * 9.8

    return sp.matmul(A, z) + Famort + Ft
def main():
	a = array([1, 1])
	b = array([0, 0])
	x = array([-0.5, 1])
	y = tanh( a * x + b)

	dbma = [-(-0.46 * 2.79), -(0.76*2.42)]


	print("ma byt:", dbma[0], dbma[1])
	print("je:", ipgauss(x, y, a, b)[0])
Beispiel #45
0
 def showFor(self, segment, multiplier=1.0):
     nhi = self.takeNumber(self.getSymbol("hi"))
     nlo = self.takeNumber(self.getSymbol("lo"))
     hi = max(nlo + 1.0, nhi)
     lo = min(nhi - 1.0, nlo)
     self.modSymbol("hi", self.makeNumber(hi))
     self.modSymbol("lo", self.makeNumber(lo))
     duration = abs(hi + lo) / 2.0
     duration += (abs(hi - lo) / 2.0) * scipy.tanh(self.tparam)
     print segment + "\r",
     sys.stdout.flush()
     time.sleep(duration * multiplier)
Beispiel #46
0
def fun(t,z):
    # --- Reporte de paso de tiempo
    if t > fun.tnextreport:
        print "  {} at t = {}".format(fun.solver, fun.tnextreport)
        fun.tnextreport += 1
    # --- Cálculo
    Famort = sp.zeros((40))   # vector de fuerza friccional de amortiguamiento
    Famort[0] = -(Cap[0] * (1./M[0,0]) * sp.tanh((z[20]/vr)))    
    Ft=sp.zeros(40)
    if t<226.81:
        Ft[20:]=f0(t)*9.8
    return sp.matmul(A,z) + Famort + Ft
Beispiel #47
0
    def ungray(self):
        self.R = self.source[:,:,0]
        self.G = self.source[:,:,1]
        self.B = self.source[:,:,2]

        self.R = filter2D(self.R, -1, self.kernel)
        self.G = filter2D(self.G, -1, self.kernel)
        self.B = filter2D(self.B, -1, self.kernel)

        slope = self.control[ord('s')].val
        self.R = (1.0 + tanh(slope*self.R)) / 2.0
        self.G = (1.0 + tanh(slope*self.G)) / 2.0
        self.B = (1.0 + tanh(slope*self.B)) / 2.0

        self.R = filter2D(self.R, -1, self.gauss)
        self.G = filter2D(self.G, -1, self.gauss)
        self.B = filter2D(self.B, -1, self.gauss)

        self.target[:,:,0] = self.R * self.scale
        self.target[:,:,1] = self.G * self.scale
        self.target[:,:,2] = self.B * self.scale
Beispiel #48
0
 def performAction(self, action):
     #Filtered mapping towards performAction of the underlying environment
     #The standard CCRL task uses a PID controller to controll directly angles instead of forces
     #This makes most tasks much simpler to learn
     self.oldAction = action
     #Grasping as reflex depending on the distance to target - comment in for more easy grasping
     if abs(abs(self.dist[:3]).sum())<2.0: action[15]=1.0 #self.grepRew=action[15]*.01
     else: action[15]=-1.0 #self.grepRew=action[15]*-.03
     isJoints=array(self.env.getSensorByName('JointSensor')) #The joint angles
     isSpeeds=array(self.env.getSensorByName('JointVelocitySensor')) #The joint angular velocitys
     act=(action+1.0)/2.0*(self.env.cHighList-self.env.cLowList)+self.env.cLowList #norm output to action intervall
     action=tanh((act-isJoints-0.9*isSpeeds*self.env.tourqueList)*16.0)*self.maxPower*self.env.tourqueList #simple PID
     EpisodicTask.performAction(self, action)
 def performAction(self, action):
     #Filtered mapping towards performAction of the underlying environment   
     #The standard CCRL task uses a PID controller to controll directly angles instead of forces
     #This makes most tasks much simpler to learn             
     self.oldAction = action
     #Grasping as reflex depending on the distance to target - comment in for more easy grasping
     #if abs(self.dist[2])<2.0: action[15]=(1.0+2.0*action[15])*.3333 #self.grepRew=action[15]*.01
     #else: action[15]=(-1.0+2.0*action[15])*.3333 #self.grepRew=action[15]*-.03
     isJoints=array(self.env.getSensorByName('JointSensor')) #The joint angles
     isSpeeds=array(self.env.getSensorByName('JointVelocitySensor')) #The joint angular velocitys
     act=(action+1.0)/2.0*(self.env.cHighList-self.env.cLowList)+self.env.cLowList #norm output to action intervall  
     action=tanh((act-isJoints-0.9*isSpeeds*self.env.tourqueList)*16.0)*self.maxPower*self.env.tourqueList #simple PID
     EpisodicTask.performAction(self, action)
    def dNeurons(self, statevec, t):
    
        # Extract relevant parameters from
        train = training > 0 and t > training and t < training + train_dur

        x_i = statevec[0:Ng]
        w_i = statevec[Ng:2*Ng]

        # generate noise patterns
        exp_noise_amp = 0.1
        if train:
            zeta = np.random.uniform(-exp_noise_amp, exp_noise_amp, 1)
        else:
            zeta = 0.0
            
        # Compute Firing Rates and feedback signals
        r_i = sp.tanh(x_i) + zeta_state(t)
        z_i = np.dot(w_i, r_i) + zeta
        
        # Compute next timestep depending on if training or not
        if train:
        
            dxidt = (-x_i + lambd * np.dot(W_rec, r_i) + np.dot(W_in_left, self.uleft[t]) + np.dot(W_in_right, self.uright[t]) + z_i*W_fb )/tau
            x_new = x_i + dxidt*dt
        
            P = -1.0*sp.power(z_i - self.f_target[t], 2)
            M = 1.0*(P > self.P_avg)
        
            dwdt = eta(t) * (z_i - self.z_avg) * M * r_i
            w_new = w_i + dwdt*dt

            self.P_avg = (1 - (dt/tau_avg)) * self.P_avg + (dt/tau_avg) * P
            self.z_avg = (1 - (dt/tau_avg)) * self.z_avg + (dt/tau_avg) * z_i
        
        else:
        
            dxidt = (-x_i + lambd * np.dot(W_rec, r_i) + np.dot(W_in_left, self.uleft[t]) + np.dot(W_in_right, self.uright[t]) + z_i*W_fb )/tau
                    
            x_new = x_i + dxidt*dt
            dwdt = np.zeros(np.shape(w_i))
            w_new = w_i
            
        #weight change magnitude:
        dwmag = LA.norm(dwdt)
        rmag = LA.norm(r_i)
        if t%10000 == 0: print(str(t) + '    ' + str(z_i) + '   ' + str(train))
        self.zsave[t] = z_i
        self.rsave[t] = rmag
        return np.concatenate((x_new, w_new))
	def Calculate_Sigma(self, data):
		for temperature in xrange(self.n_temp):
			tmp = 1/(sp.tanh(data.energy/(2*K_B*(temperature+1))))
			self.IP_cluster_qu[temperature] = np.sqrt(np.sum((data.IP_cluster_a1*data.IP_cluster_a1)/2 * tmp))
			self.EA_cluster_qu[temperature] = np.sqrt(np.sum((data.EA_cluster_a1*data.EA_cluster_a1)/2 * tmp))
			self.IP_alone_qu[temperature] = np.sqrt(np.sum((data.IP_alone_a1*data.IP_alone_a1)/2 * tmp))
			self.EA_alone_qu[temperature] = np.sqrt(np.sum((data.EA_alone_a1*data.EA_alone_a1)/2 * tmp))
			self.P_plus_qu[temperature] = np.sqrt(np.sum((data.P_plus_a1*data.P_plus_a1)/2 * tmp))
			self.P_minus_qu[temperature] = np.sqrt(np.sum((data.P_minus_a1*data.P_minus_a1)/2 * tmp))

			if temperature+1 == 300:
				self.IP_cluster_qu_300K = 100*((data.IP_cluster_a1*data.IP_cluster_a1)/2 * tmp)/(self.IP_cluster_qu[temperature]*self.IP_cluster_qu[temperature])
				self.EA_cluster_qu_300K = 100*((data.EA_cluster_a1*data.EA_cluster_a1)/2 * tmp)/(self.EA_cluster_qu[temperature]*self.EA_cluster_qu[temperature])
				self.IP_alone_qu_300K = 100*((data.IP_alone_a1*data.IP_alone_a1)/2 * tmp)/(self.IP_alone_qu[temperature]*self.IP_alone_qu[temperature])
				self.EA_alone_qu_300K = 100*((data.EA_alone_a1*data.EA_alone_a1)/2 * tmp)/(self.EA_alone_qu[temperature]*self.EA_alone_qu[temperature])
				self.P_plus_qu_300K = 100*((data.P_plus_a1*data.P_plus_a1)/2 * tmp)/(self.P_plus_qu[temperature]*self.P_plus_qu[temperature])
				self.P_minus_qu_300K = 100*((data.P_minus_a1*data.P_minus_a1)/2 * tmp)/(self.P_minus_qu[temperature]*self.P_minus_qu[temperature])
				
			tmp = 2*K_B*(temperature+1)/data.energy
			self.IP_cluster_cl[temperature] = np.sqrt(np.sum((data.IP_cluster_a1*data.IP_cluster_a1)/2 * tmp))
			self.EA_cluster_cl[temperature] = np.sqrt(np.sum((data.EA_cluster_a1*data.EA_cluster_a1)/2 * tmp))
			self.IP_alone_cl[temperature] = np.sqrt(np.sum((data.IP_alone_a1*data.IP_alone_a1)/2 * tmp))
			self.EA_alone_cl[temperature] = np.sqrt(np.sum((data.EA_alone_a1*data.EA_alone_a1)/2 * tmp))
			self.P_plus_cl[temperature] = np.sqrt(np.sum((data.P_plus_a1*data.P_plus_a1)/2 * tmp))
			self.P_minus_cl[temperature] = np.sqrt(np.sum((data.P_minus_a1*data.P_minus_a1)/2 * tmp))
			
			if temperature+1 == 300:
				self.IP_cluster_cl_300K = 100*((data.IP_cluster_a1*data.IP_cluster_a1)/2 * tmp)/(self.IP_cluster_cl[temperature]*self.IP_cluster_cl[temperature])
				self.EA_cluster_cl_300K = 100*((data.EA_cluster_a1*data.EA_cluster_a1)/2 * tmp)/(self.EA_cluster_cl[temperature]*self.EA_cluster_cl[temperature])
				self.IP_alone_cl_300K = 100*((data.IP_alone_a1*data.IP_alone_a1)/2 * tmp)/(self.IP_alone_cl[temperature]*self.IP_alone_cl[temperature])
				self.EA_alone_cl_300K = 100*((data.EA_alone_a1*data.EA_alone_a1)/2 * tmp)/(self.EA_alone_cl[temperature]*self.EA_alone_cl[temperature])
				self.P_plus_cl_300K = 100*((data.P_plus_a1*data.P_plus_a1)/2 * tmp)/(self.P_plus_cl[temperature]*self.P_plus_cl[temperature])
				self.P_minus_cl_300K = 100*((data.P_minus_a1*data.P_minus_a1)/2 * tmp)/(self.P_minus_cl[temperature]*self.P_minus_cl[temperature])
				
		self.IP_cluster_L = np.sum((data.IP_cluster_a1*data.IP_cluster_a1)/(2*data.energy))
		self.EA_cluster_L = np.sum((data.EA_cluster_a1*data.EA_cluster_a1)/(2*data.energy))
		self.IP_alone_L = np.sum((data.IP_alone_a1*data.IP_alone_a1)/(2*data.energy))
		self.EA_alone_L = np.sum((data.EA_alone_a1*data.EA_alone_a1)/(2*data.energy))
		self.P_plus_L = np.sum((data.P_plus_a1*data.P_plus_a1)/(2*data.energy))
		self.P_minus_L = np.sum((data.P_minus_a1*data.P_minus_a1)/(2*data.energy))
		
		self.IP_cluster_G2 = np.sum((data.IP_cluster_a1*data.IP_cluster_a1)/(2))
		self.EA_cluster_G2 = np.sum((data.EA_cluster_a1*data.EA_cluster_a1)/(2))
		self.IP_alone_G2 = np.sum((data.IP_alone_a1*data.IP_alone_a1)/(2))
		self.EA_alone_G2 = np.sum((data.EA_alone_a1*data.EA_alone_a1)/(2))
		self.P_plus_G2 = np.sum((data.P_plus_a1*data.P_plus_a1)/(2))
		self.P_minus_G2 = np.sum((data.P_minus_a1*data.P_minus_a1)/(2))
Beispiel #52
0
def k_fuel(p, B, T_K):
    """ Calculate fuel conductivity (W/m-K)
    
    From J.D. Hales et al. (2013) "Bison Theory" (NFIR model)
    """
    # kelvin to celsius
    T = T_K - 273.15
    # thermal recovery function
    rf = 0.5 * (1.0 + sp.tanh((T - 900.0) / 150.0))
    # phonon contribution at start of thermal recovery [Hales eq. 8.14]
    kps = 1.0 / (0.09592 + 0.00614 * B - 0.000014 * B ** 2 + (0.00025 - 0.00000181 * B) * T)
    # phonon contribution at the end of thermal recovery [Hales eq. 8.15]
    kpend = 1.0 / (0.09592 + 0.0026 * B + (0.00025 - 0.00000027 * B) * T)
    # unirradiated material at 95% th. density [Hales eq. 8.17]
    kel = 0.0132 * sp.exp((0.00188) * T)
    k = (1.0 - rf) * kps + rf * kpend + kel
    return k
Beispiel #53
0
def TempProfile(z,T0=1000.,z0=100.):
    """
    This function creates a tempreture profile using arc tan functions for test purposes.
    Inputs
        z - The altitude locations in km.
        T0 - The value of the lowest tempretures in K.
        z0 - The middle value of the atan functions along alitutude. In km.
    Outputs
        Te - The electron density profile in K. 1700*(atan((z-z0)2*exp(1)/400-exp(1))+1)/2 +T0
        Ti - The ion density profile in K. 500*(atan((z-z0)2*exp(1)/400-exp(1))+1)/2 +T0
    """
    zall = (z-z0)*2.*sp.exp(1)/400. -sp.exp(1)
    atanshp = (sp.tanh(zall)+1.)/2
    Te = 1700*atanshp+T0
    Ti = 500*atanshp+T0

    return (Te,Ti)
Beispiel #54
0
 def __init__(self, indim, outdim, peepholes = False, name = None):
     nrNeurons = outdim
     self.peep = peepholes
     # internal buffers:
     self.ingate = zeros((0,nrNeurons))
     self.outgate = zeros((0,nrNeurons))
     self.forgetgate = zeros((0,nrNeurons))
     self.cell = zeros((0,nrNeurons))
     self.ingatex = zeros((0,nrNeurons))
     self.outgatex = zeros((0,nrNeurons))
     self.forgetgatex = zeros((0,nrNeurons))
     self.cellx = zeros((0,nrNeurons))
     self.state = zeros((0,nrNeurons))
     self.ingateError = zeros((0,nrNeurons))
     self.outgateError = zeros((0,nrNeurons))
     self.forgetgateError = zeros((0,nrNeurons))
     self.stateError = zeros((0,nrNeurons))
     self.Sin = zeros((0,indim*nrNeurons))
     self.Sforget = zeros((0,indim*nrNeurons))
     self.Scell = zeros((0,indim*nrNeurons))
     self.SinRec = zeros((0,nrNeurons*nrNeurons))
     self.SforgetRec = zeros((0,nrNeurons*nrNeurons))
     self.ScellRec = zeros((0,nrNeurons*nrNeurons))
     
     Module.__init__(self, indim, outdim, name)
     if self.peep:
         ParameterContainer.__init__(self, nrNeurons*3 + (4*indim+nrNeurons)*nrNeurons)
         self.Sin_peep = zeros((0,nrNeurons))
         self.Sforget_peep = zeros((0,nrNeurons))
         self.Scell_peep = zeros((0,nrNeurons))
     else:
         ParameterContainer.__init__(self, (4*indim+nrNeurons)*nrNeurons)
     self._setParameters(self.params)
     self._setDerivatives(self.derivs)
         
     # transfer functions and their derivatives
     self.f = sigmoid
     self.fprime = sigmoidPrime
     self.g = lambda x: 2*tanh(x)
     self.gprime = lambda x: 2*tanhPrime(x)
     self.h = self.g
     self.hprime = self.gprime
Beispiel #55
0
    def f(self,y,psi):
        """transform y with f using parameter vector psi
        psi = [[a,b,c]]
        f = \sum_{terms} a * tanh(b*(y+c))
        """

        #1. check that number of params is consistent
        assert psi.shape[0]==self.n_terms, 'inconsistent parameter dimensions'
        assert psi.shape[1]==3, 'inconsistent parameter dimensions'

        #2. exponentiate the a and b (positive!)
        mpsi = psi.copy()
        mpsi[:,0:2] = SP.exp(mpsi[:,0:2])

        #3. transform data
	z = y.copy()
	for i in range(len(mpsi)):
	    a,b,c = mpsi[i]
	    z += a*SP.tanh(b*(y+c))	    
        return z
Beispiel #56
0
    def genTraitEffect(self,distribution='normal'):

        W = SP.zeros((self.P,self.P))
        if self.trait_effect=='shared':


            if distribution=='normal':
                W[0,:] = SP.random.randn(1,self.P)
            else:
                W[0,:] = genBinormal(1,self.P)

        elif self.trait_effect=='tanh':
            assert distribution=='normal', 'tanh trait effect is only implemented for normal distributed effects'
            X = 10*SP.linspace(0,1,self.P)-5
            a = - SP.absolute(SP.random.randn())
            c = - SP.absolute(SP.random.randn())
            Y = SP.tanh(a*X + c)
            W[0,:] = Y

        return W
Beispiel #57
0
def tanh_warp(x, n, l1, l2, lw, x0):
    r"""Implements a tanh warping function and its derivative.

    .. math::

        l = \frac{l_1 + l_2}{2} - \frac{l_1 - l_2}{2}\tanh\frac{x-x_0}{l_w}

    Parameters
    ----------
    x : float or array of float
        Locations to evaluate the function at.
    n : int
        Derivative order to take. Used for ALL of the points.
    l1 : positive float
        Left saturation value.
    l2 : positive float
        Right saturation value.
    lw : positive float
        Transition width.
    x0 : float
        Transition location.

    Returns
    -------
    l : float or array
        Warped length scale at the given locations.

    Raises
    ------
    NotImplementedError
        If `n` > 1.
    """
    if n == 0:
        return (l1 + l2) / 2.0 - (l1 - l2) / 2.0 * scipy.tanh((x - x0) / lw)
    elif n == 1:
        return -(l1 - l2) / (2.0 * lw) * (scipy.cosh((x - x0) / lw))**(-2.0)
    else:
        raise NotImplementedError(
            "Only derivatives up to order 1 are supported!"
        )
Beispiel #58
0
def save(data, P, M, fmt, font, **kw):
    coeff = float(kw.get('--tanh', 0.0))
    count = "%07d" % (P)
    annotation = ["%02x" % (ord(c)) for c in count.lstrip('0')]
    if kw.get('--verbose', False):
        print annotation
    # TODO use BIOSFONT to annotate image
    #for n, code in enumerate([eval('0x%s' % (val)) for val in annotation]):
        #font.text(data, "a", (1,1))

    #if kw.get('constrain', False):
        #image = toimage(data, cmax=256, cmin=0, mode='RGB')
    #else:
        #image = toimage(data, mode='RGB')
    if coeff != 0.0:
        temp = tanh(coeff * data)
        image = toimage(temp, mode='RGB')
    else:
        image = toimage(data, mode='RGB')
    image = toimage(zoom(image, (4.0, 4.0, 1.0), order=0), mode='RGB')
    filename = fmt % (count)
    image.save(filename)
    return filename
Beispiel #59
0
def tanhPrime(x):
    """ Derivative of tanh. """
    tmp = tanh(x)
    return 1 - tmp * tmp
 def activateOut(self):
     self.ao[:] = tanh(npsum(self.wo.T * self.ah, axis=1))