def calcColNormalizer(inMatrix): #Theano function for calculating logSum, i.e., calculate ln(X + Y) based on ln(X) and ln(Y). maxExp = -4950.0 x, y = T.fscalars(2) yMinusx = y - x ## this part is for the condition which x > y xMinusy = x - y # if x < y bigger = T.switch(T.gt(x, y), x, y) YSubtractX = T.switch(T.gt(x,y), yMinusx, xMinusy) x_prime = T.log(1 + T.exp(YSubtractX)) + bigger calcSum = T.switch(T.lt(YSubtractX, maxExp), bigger, x_prime) logSum = function([x, y], calcSum, allow_input_downcast=True) ####### end of logSum ############### # now we caclculate sum of log joint as normalizer if len(inMatrix.shape) < 2: raise Exception ("calcColNormalizer expect a 2D matrix") nRows, nCols = inMatrix.shape columnAccumLogSum = np.zeros(nCols) for col in range(nCols): currLogSum = np.NINF for j in range(nRows): if inMatrix[j,col] == np.NINF: continue currLogSum = logSum(currLogSum, inMatrix[j,col]) columnAccumLogSum[col] = currLogSum return columnAccumLogSum
def advance(u, u_1, u_2, f_a, Cx2, Cy2, dt2, V=None, step1=False): u_in, u_1_in, u_2_in = T.fmatrices('u_in','u_1_in','u_2_in') f_a_in, V_in = T.fmatrices('f_in','V_in') step1_in = T.lscalar('step1_in') Cx2_in, Cy2_in, dt2_in = T.fscalars('Cx2_in','Cy2_in','dt2_in') u_out = T.fmatrix('u_out') if V is None: V = np.zeros_like(f_a) step_f = theano.function([u_in, u_1_in, u_2_in, f_a_in, Cx2_in, Cy2_in, dt2_in, V_in, step1_in], u_out, step, on_unused_input='ignore') u_out = step_f(u, u_1, u_2, f_a, Cx2, Cy2, dt2, V, step1) return u_out
import sys, os, math import NamedMatrix import scipy.special as ss from utilTCI import * ############################################################################################### """ The following block define the Theano functions that going to be used in the regular python funcitons """ """ 1. Calculate ln(X + Y) based on ln(X) and ln(Y) using theano library """ ########### Theano function for calculating logSum maxExp = -4950.0 x, y = T.fscalars(2) yMinusx = y - x ## this part is for the condition which x > y xMinusy = x - y # if x < y bigger = T.switch(T.gt(x, y), x, y) YSubtractX = T.switch(T.gt(x,y), yMinusx, xMinusy) x_prime = T.log(1 + T.exp(YSubtractX)) + bigger calcSum = T.switch(T.lt(YSubtractX, maxExp), bigger, x_prime) logSum = function([x, y], calcSum, allow_input_downcast=True) ####### end of logSum ############### def calcTDI (mutcnaMatrixFN, degMatrixFN, alphaNull = [1, 1], alphaIJKList = [2, 1, 1, 2], v0=0.3, outputPath = ".", opFlag = None, rowBegin=0, rowEnd = None, GeGlobalDriverDict = None): """
# Multiple outputs a, b = T.fmatrices('a', 'b') diff = a - b absDiff = abs(diff) sqrDiff = diff**2 f = function([a, b], [diff, absDiff, sqrDiff]) mat2 = [[10, 5], [5, 10]] mat3 = [[5, 10], [10, 5]] print(f(mat2, mat3)) # Default values x, y = T.fscalars('x', 'y') z = x + y f = function([x, In(y, value=0)], z) print(f(20)) print(f(20, 10)) # Shared variables state = shared(0) inc = T.iscalar('inc') accumulator = function([inc], state, updates=[(state, state + inc)]) print("state : ", state.get_value())
# Multiple outputs a, b = T.fmatrices('a', 'b') diff = a - b absDiff = abs(diff) sqrDiff = diff ** 2 f = function([a, b], [diff, absDiff, sqrDiff]) mat2 = [[10, 5], [5, 10]] mat3 = [[5, 10], [10, 5]] print(f(mat2, mat3)) # Default values x, y = T.fscalars('x', 'y') z = x + y f = function([x, In(y, value=0)], z) print(f(20)) print(f(20, 10)) # Shared variables state = shared(0) inc = T.iscalar('inc') accumulator = function([inc], state, updates=[(state, state + inc)]) print("state : ", state.get_value())
x = T.fvector('x') x1 = T.fscalar('x1') y = 1/(1 + T.exp(-x)) y1 = 1/(1 + T.exp(-x1)) logistic = function([x], y) logistic1 = function([x1], y1) grady = T.grad(y1, x1) derivada = function([x1], grady) a = float(input('Introduce el extremo izqdo. \n')) b = float(input('Introduce el extremo drcho. \n')) particion = float(input('Introduce la longitud de particion del intervalo. \n')) pderiv = float(input('Introduce el punto donde hallar su recta tangente. \n')) xval = arange(a,b,particion, dtype='float32') z,w,w1=T.fscalars('z', 'w', 'w1') rectatg2 = (x-z)*w+w1 rectatg3 = function([x, Param(z, default=pderiv), Param(w, default=derivada(pderiv)), Param(w1, default=logistic1(pderiv))], rectatg2) figure(1) plot(xval, logistic(xval), linewidth=1.5, color='r') plot(xval, rectatg3(xval), linewidth=1.0, color='g') ylim([0,1]) xlabel(r'\textbf{Abcisa}', fontsize=12) ylabel(r'\textit{Ordenada}',fontsize=12) title(r"Funcion logistica f(x) = $\displaystyle\frac{1}{1+e^{-x}}$", fontsize=12, color='r') legend(('Funcion Logistica', 'Recta Tangente'),'upper left', shadow=True, fancybox=True) leg = gca().get_legend()
def __init__(self, inf=1e37): pos, vel = T.fmatrices(['pos', 'vel']) nc, N, n_steps = T.iscalars(['nc', 'N', 'n_steps']) ra, rb, re, r0 = T.fscalars(['ra', 'rb', 're', 'r0']) v0, j, b = T.fscalars(['v0', 'J', 'b']) nu = trng.uniform(size=(N, 2), low=0.0, high=3.14159, dtype='floatX') def distance_tensor(X): E = X.reshape((X.shape[0], 1, -1)) - X.reshape((1, X.shape[0], -1)) D = T.sqrt(T.sum(T.square(E), axis=2)) return D def direction_tensor(X): E = X.reshape((X.shape[0], 1, -1)) - X.reshape((1, X.shape[0], -1)) L = T.sqrt(T.sum(T.square(E), axis=2)) L = T.pow(L + T.identity_like(L), -1) L = T.stack([L, L, L], axis=2) return L * E def neighbourhood(X): D = distance_tensor(X) N = T.argsort(D, axis=0) mask = T.cast(T.lt(N, nc), 'float32') return N[1:nc + 1], mask def alignment(X, Y): n, d = neighbourhood(X) return T.sum(Y[n], axis=0) def cohesion(X, inf=100.0): D = distance_tensor(X) E = direction_tensor(X) n, d = neighbourhood(X) F = T.zeros_like(E) D = T.stack([D, D, D], axis=2) d = T.stack([d, d, d], axis=2) c1 = T.lt(D, rb) c2 = T.and_(T.gt(D, rb), T.lt(D, ra)) c3 = T.and_(T.gt(D, ra), T.lt(D, r0)) F = T.set_subtensor(F[c1], -E[c1]) F = T.set_subtensor(F[c2], 0.25 * (D[c2] - re) / (ra - re) * E[c2]) F = T.set_subtensor(F[c3], E[c3]) return T.sum(d * F, axis=0) def perturbation(nu=nu): phi = nu[:, 0] theta = 2.0 * nu[:, 1] return T.stack([ T.sin(theta) * T.sin(phi), T.cos(theta) * T.sin(phi), T.cos(phi) ], axis=1) def step(X, dX): X_ = X + dX V_ = j * nc / v0 * (alignment( X, dX)) + b * (cohesion(X)) + nc * (perturbation()) dV = T.sqrt(T.sum(T.square(V_), axis=1)).reshape(V_.shape[0], 1) dV = T.stack([dV, dV, dV], axis=1) V = v0 * V_ / dV return T.cast(X_, 'float32'), T.cast(V, 'float32') def probability(X, Y): n, d = neighbourhood(X) vDv = T.batched_dot(Y[n].swapaxes(0, 1), Y) p = T.exp((j / 2.0) * T.sum(vDv, axis=1)) return p / T.sum(p) sim, update = theano.scan(step, outputs_info=[pos, vel], n_steps=n_steps) pos_, vel_ = sim mean_final_velocity = 1 / (N * v0) * T.sqrt( T.sum(T.square(T.sum(vel_[-1], axis=0)))) particle_probability = probability(pos_[-1], vel_[-1]) self.f = theano.function( [pos, vel, nc, ra, rb, r0, re, j, v0, b, N, n_steps], [pos_, vel_], allow_input_downcast=True) self.g = theano.function( [pos, vel, nc, ra, rb, r0, re, j, v0, b, N, n_steps], mean_final_velocity, allow_input_downcast=True) self.h = theano.function( [pos, vel, nc, ra, rb, r0, re, j, v0, b, N, n_steps], particle_probability, allow_input_downcast=True)
import theano import theano.tensor as T import numpy as np from scipy.stats import norm from theano import function import _pickle as cPickle # dictionary with the distributions data = cPickle.load( open('C:\\Users\\user\\Desktop\\Master-Project-master\\save.pkl', 'rb')) dict = {} words = ['ich', 'das', 'ist', 'du', 'die'] # TensorVariables for mi, mj, si, sj respectivelly. a, b = T.fscalars('a', 'b') # mu c, d = T.fscalars('c', 'd') # sigma # Energy as a TensorVariable E = 0.5 * (d / c + (a - b)**2 / c - 1 - T.log(d / c)) enrg = function([a, b, c, d], E) def KLdivergence(data): dictKLword = [] distList = [] for i in range(len(data)): mu, std = norm.fit(data[i]) var = np.power(std, 2) distList.append([mu, var])
x = T.fvector("x") x1 = T.fscalar("x1") y = 1/(1 + T.exp(-x)) y1 = 1/(1 + T.exp(-x1)) logistic = function([x], y) logistic1 = function([x1], y1) grady = T.grad(y1, x1) derivada = function([x1], grady) a = float(input("Introduce el extremo izqdo. \n")) b = float(input("Introduce el extremo drcho. \n")) particion = float(input("Introduce la longitud de particion del intervalo. \n")) pderiv = float(input("Introduce el punto donde hallar su recta tangente. \n")) xval = arange(a,b,particion, dtype="float32") z,w,w1=T.fscalars("z", "w’, ‘w1′) rectatg2 = (x-z)*w+w1 rectatg3 = function([x, Param(z, default=pderiv), Param(w, default=derivada(pderiv)), Param(w1, default=logistic1(pderiv))], rectatg2) figure(1) plot(xval, logistic(xval), linewidth=1.5, color=’r") plot(xval, rectatg3(xval), linewidth=1.0, color=’g") ylim([0,1]) xlabel(r’\textbf{Abcisa}’, fontsize=12) ylabel(r’\textit{Ordenada}’,fontsize=12) title(r”Funcion logistica f(x) = $\displaystyle\frac{1}{1+e^{-x}}$”, fontsize=12, color=’r") legend((‘Funcion Logistica’, ‘Recta Tangente’),’upper left’, shadow=True, fancybox=True) leg = gca().get_legend()
def __init__(self, N=None, size=1, mu0=0.1, sigma_mean0=10, sigma_std0=1.0, sigma_min=0.1, sigma_max=10, data=None): self.N = N self.K = size # Parameter initialization #random init if data is None: # mu = random normal with std mu0,mean 0 self.mu = mu0 * np.random.randn(self.N, self.K).astype(DTYPE) # Sigma = random normal with mean sigma_mean0, std sigma_std0, and min/max of sigma_min, sigma_max self.Sigma = np.random.randn(self.N, 1).astype(DTYPE) self.Sigma *= sigma_std0 self.Sigma += sigma_mean0 self.Sigma = np.maximum(sigma_min, np.minimum(self.Sigma, sigma_max)) self.Gaussian = np.concatenate((self.mu, self.Sigma), axis=1) # TensorVariables for mi, mj, si, sj respectivelly. a, b = T.fvectors('a', 'b') c, d = T.fscalars('c', 'd') # Energy as a TensorVariable E = -0.5 * (self.K * d / c + T.sum( (a - b)**2 / c) - self.K - self.K * T.log(d / c)) self.enrg = function([a, b, c, d], E) g1 = T.grad(E, a) # dE/dmi self.f1 = function([a, b, c, d], g1) g2 = T.grad(E, b) # dE/dmj self.f2 = function([a, b, c, d], g2) g3 = T.grad(E, c) # dE/dsi self.f3 = function([a, b, c, d], g3) g4 = T.grad(E, d) # dE/dsj self.f4 = function([a, b, c, d], g4) #non random init else: self.mu = [] self.Sigma = [] for i in range(len(data)): mu, std = norm.fit(data[i]) var = np.power(std, 2) self.mu.append(mu) self.Sigma.append(var) self.Gaussian = np.concatenate( (np.asarray(self.mu), np.asarray(self.Sigma)), axis=1) self.Gaussian = np.reshape(self.Gaussian, (2, N)).T