def run(self,iterations): ''' Run the Gibbs sampler. ''' self.all_U = numpy.zeros((iterations,self.I,self.K)) self.all_V = numpy.zeros((iterations,self.J,self.K)) self.all_tau = numpy.zeros(iterations) self.all_lambdak = numpy.zeros((iterations,self.K)) self.all_times = [] # to plot performance against time self.all_performances = {} # for plotting convergence of metrics for metric in ALL_METRICS: self.all_performances[metric] = [] time_start = time.time() for it in range(iterations): # Update lambdak if self.ARD: for k in range(self.K): self.lambdak[k] = gamma_mode(self.alphak_s(k),self.betak_s(k)) # Update U for k in range(0,self.K): tauUk = self.tauU(k) muUk = self.muU(tauUk,k) self.U[:,k] = TN_vector_mode(muUk) self.U[:,k] = numpy.maximum(self.U[:,k],MINIMUM_TN*numpy.ones(self.I)) # Update V for k in range(0,self.K): tauVk = self.tauV(k) muVk = self.muV(tauVk,k) self.V[:,k] = TN_vector_mode(muVk) self.V[:,k] = numpy.maximum(self.V[:,k],MINIMUM_TN*numpy.ones(self.J)) # Update tau self.tau = gamma_mode(self.alpha_s(),self.beta_s()) # Store draws self.all_U[it], self.all_V[it], self.all_tau[it] = numpy.copy(self.U), numpy.copy(self.V), self.tau if self.ARD: self.all_lambdak[it] = numpy.copy(self.lambdak) # Store and print performances perf = self.predict_while_running() for metric in ALL_METRICS: self.all_performances[metric].append(perf[metric]) print "Iteration %s. MSE: %s. R^2: %s. Rp: %s." % (it+1,perf['MSE'],perf['R^2'],perf['Rp']) # Store time taken for iteration time_iteration = time.time() self.all_times.append(time_iteration-time_start)
def initialise(self,init_S='random',init_FG='random'): assert init_S in ['random','exp'], "Unknown initialisation option for S: %s. Should be 'random' or 'exp'." % init_S assert init_FG in ['random','exp','kmeans'], "Unknown initialisation option for S: %s. Should be 'random', 'exp', or 'kmeans." % init_FG self.S = 1./self.lambdaS if init_S == 'random': for k,l in itertools.product(xrange(0,self.K),xrange(0,self.L)): self.S[k,l] = exponential_draw(self.lambdaS[k,l]) self.F, self.G = 1./self.lambdaF, 1./self.lambdaG if init_FG == 'random': for i,k in itertools.product(xrange(0,self.I),xrange(0,self.K)): self.F[i,k] = exponential_draw(self.lambdaF[i,k]) for j,l in itertools.product(xrange(0,self.J),xrange(0,self.L)): self.G[j,l] = exponential_draw(self.lambdaG[j,l]) elif init_FG == 'kmeans': print "Initialising F using KMeans." kmeans_F = KMeans(self.R,self.M,self.K) kmeans_F.initialise() kmeans_F.cluster() self.F = kmeans_F.clustering_results + 0.2 print "Initialising G using KMeans." kmeans_G = KMeans(self.R.T,self.M.T,self.L) kmeans_G.initialise() kmeans_G.cluster() self.G = kmeans_G.clustering_results + 0.2 self.tau = gamma_mode(self.alpha_s(), self.beta_s())
def initialise(self, init_FG='random', init_S='random'): ''' Initialise F, S, G, tau, and lambdaFk, lambdaGl (if ARD). ''' assert init_FG in OPTIONS_INIT_FG, "Unknown initialisation option for F and G: %s. Should be in %s." % ( init_FG, OPTIONS_INIT_FG) assert init_S in OPTIONS_INIT_S, "Unknown initialisation option for S: %s. Should be in %s." % ( init_S, OPTIONS_INIT_S) self.F = numpy.zeros((self.I, self.K)) self.S = numpy.zeros((self.K, self.L)) self.G = numpy.zeros((self.J, self.L)) self.lambdaFk = numpy.zeros(self.K) self.lambdaGl = numpy.zeros(self.L) # Initialise lambdaFk, lambdaGl if self.ARD: for k in range(self.K): self.lambdaFk[k] = self.alpha0 / self.beta0 for l in range(self.L): self.lambdaGl[l] = self.alpha0 / self.beta0 # Initialise F, G if init_FG == 'kmeans': print "Initialising F using KMeans." kmeans_F = KMeans(self.R, self.M, self.K) kmeans_F.initialise() kmeans_F.cluster() self.F = kmeans_F.clustering_results + 0.2 print "Initialising G using KMeans." kmeans_G = KMeans(self.R.T, self.M.T, self.L) kmeans_G.initialise() kmeans_G.cluster() self.G = kmeans_G.clustering_results + 0.2 else: # 'random' or 'exp' for i, k in itertools.product(range(self.I), range(self.K)): hyperparam = self.lambdaFk[k] if self.ARD else self.lambdaF[i, k] self.F[i, k] = exponential_draw( hyperparam) if init_FG == 'random' else 1.0 / hyperparam for j, l in itertools.product(range(self.J), range(self.L)): hyperparam = self.lambdaGl[l] if self.ARD else self.lambdaG[j, l] self.G[j, l] = exponential_draw( hyperparam) if init_FG == 'random' else 1.0 / hyperparam # Initialise S for k, l in itertools.product(range(self.K), range(self.L)): hyperparam = self.lambdaS[k, l] self.S[k, l] = exponential_draw( hyperparam) if init_S == 'random' else 1.0 / hyperparam # Initialise tau self.tau = gamma_mode(self.alpha_s(), self.beta_s())
def run(self, iterations, minimum_TN=0.): self.all_tau = numpy.zeros(iterations) self.all_times = [] # to plot performance against time metrics = ['MSE', 'R^2', 'Rp'] self.all_performances = {} # for plotting convergence of metrics for metric in metrics: self.all_performances[metric] = [] time_start = time.time() for it in range(0, iterations): for k in range(0, self.K): tauFk = self.tauF(k) muFk = self.muF(tauFk, k) self.F[:, k] = TN_vector_mode(muFk) self.F[:, k] = numpy.maximum(self.F[:, k], minimum_TN * numpy.ones(self.I)) for k, l in itertools.product(xrange(0, self.K), xrange(0, self.L)): tauSkl = self.tauS(k, l) muSkl = self.muS(tauSkl, k, l) self.S[k, l] = TN_mode(muSkl) self.S[k, l] = max(self.S[k, l], minimum_TN) for l in range(0, self.L): tauGl = self.tauG(l) muGl = self.muG(tauGl, l) self.G[:, l] = TN_vector_mode(muGl) self.G[:, l] = numpy.maximum(self.G[:, l], minimum_TN * numpy.ones(self.J)) self.tau = gamma_mode(self.alpha_s(), self.beta_s()) self.all_tau[it] = self.tau perf = self.predict(self.M) for metric in metrics: self.all_performances[metric].append(perf[metric]) print "Iteration %s. MSE: %s. R^2: %s. Rp: %s." % ( it + 1, perf['MSE'], perf['R^2'], perf['Rp']) time_iteration = time.time() self.all_times.append(time_iteration - time_start) return
def initialise(self,init='random'): assert init in ['random','exp'], "Unknown initialisation option: %s. Should be 'random' or 'exp'." % init self.U = numpy.zeros((self.I,self.K)) self.V = numpy.zeros((self.J,self.K)) if init == 'random': for i,k in itertools.product(xrange(0,self.I),xrange(0,self.K)): self.U[i,k] = exponential_draw(self.lambdaU[i][k]) for j,k in itertools.product(xrange(0,self.J),xrange(0,self.K)): self.V[j,k] = exponential_draw(self.lambdaV[j][k]) elif init == 'exp': for i,k in itertools.product(xrange(0,self.I),xrange(0,self.K)): self.U[i,k] = 1.0/self.lambdaU[i][k] for j,k in itertools.product(xrange(0,self.J),xrange(0,self.K)): self.V[j,k] = 1.0/self.lambdaV[j][k] self.tau = gamma_mode(self.alpha_s(), self.beta_s())
def run(self,iterations,minimum_TN=0.): self.all_tau = numpy.zeros(iterations) self.all_times = [] # to plot performance against time metrics = ['MSE','R^2','Rp'] self.all_performances = {} # for plotting convergence of metrics for metric in metrics: self.all_performances[metric] = [] time_start = time.time() for it in range(0,iterations): for k in range(0,self.K): tauFk = self.tauF(k) muFk = self.muF(tauFk,k) self.F[:,k] = TN_vector_mode(muFk) self.F[:,k] = numpy.maximum(self.F[:,k],minimum_TN*numpy.ones(self.I)) for k,l in itertools.product(xrange(0,self.K),xrange(0,self.L)): tauSkl = self.tauS(k,l) muSkl = self.muS(tauSkl,k,l) self.S[k,l] = TN_mode(muSkl) self.S[k,l] = max(self.S[k,l],minimum_TN) for l in range(0,self.L): tauGl = self.tauG(l) muGl = self.muG(tauGl,l) self.G[:,l] = TN_vector_mode(muGl) self.G[:,l] = numpy.maximum(self.G[:,l],minimum_TN*numpy.ones(self.J)) self.tau = gamma_mode(self.alpha_s(),self.beta_s()) self.all_tau[it] = self.tau perf = self.predict(self.M) for metric in metrics: self.all_performances[metric].append(perf[metric]) print "Iteration %s. MSE: %s. R^2: %s. Rp: %s." % (it+1,perf['MSE'],perf['R^2'],perf['Rp']) time_iteration = time.time() self.all_times.append(time_iteration-time_start) return
def run(self, iterations, minimum_TN=0.): self.all_tau = numpy.zeros(iterations) # to plot convergence self.all_times = [] # to plot performance against time metrics = ['MSE', 'R^2', 'Rp'] self.all_performances = {} # for plotting convergence of metrics for metric in metrics: self.all_performances[metric] = [] time_start = time.time() for it in range(0, iterations): for k in range(0, self.K): tauUk = self.tauU(k) muUk = self.muU(tauUk, k) self.U[:, k] = TN_vector_mode(muUk) self.U[:, k] = numpy.maximum(self.U[:, k], minimum_TN * numpy.ones(self.I)) for k in range(0, self.K): tauVk = self.tauV(k) muVk = self.muV(tauVk, k) self.V[:, k] = TN_vector_mode(muVk) self.V[:, k] = numpy.maximum(self.V[:, k], minimum_TN * numpy.ones(self.J)) self.tau = gamma_mode(self.alpha_s(), self.beta_s()) self.all_tau[it] = self.tau perf = self.predict(self.M) for metric in metrics: self.all_performances[metric].append(perf[metric]) print "Iteration %s. MSE: %s. R^2: %s. Rp: %s." % ( it + 1, perf['MSE'], perf['R^2'], perf['Rp']) time_iteration = time.time() self.all_times.append(time_iteration - time_start) return
def initialise(self,init_UV='random'): ''' Initialise U, V, tau, and lambda (if ARD). ''' assert init_UV in OPTIONS_INIT_UV, "Unknown initialisation option: %s. Should be in %s." % (init_UV, OPTIONS_INIT_UV) self.U = numpy.zeros((self.I,self.K)) self.V = numpy.zeros((self.J,self.K)) self.lambdak = numpy.zeros(self.K) # Initialise lambdak if self.ARD: for k in range(self.K): self.lambdak[k] = self.alpha0 / self.beta0 # Initialise U, V for i,k in itertools.product(range(self.I),range(self.K)): hyperparam = self.lambdak[k] if self.ARD else self.lambdaU[i,k] self.U[i,k] = exponential_draw(hyperparam) if init_UV == 'random' else 1.0/hyperparam for j,k in itertools.product(range(self.J),range(self.K)): hyperparam = self.lambdak[k] if self.ARD else self.lambdaV[j,k] self.V[j,k] = exponential_draw(hyperparam) if init_UV == 'random' else 1.0/hyperparam # Initialise tau self.tau = gamma_mode(self.alpha_s(),self.beta_s())
def initialise(self, init_S='random', init_FG='random'): assert init_S in [ 'random', 'exp' ], "Unknown initialisation option for S: %s. Should be 'random' or 'exp'." % init_S assert init_FG in [ 'random', 'exp', 'kmeans' ], "Unknown initialisation option for S: %s. Should be 'random', 'exp', or 'kmeans." % init_FG self.S = 1. / self.lambdaS if init_S == 'random': for k, l in itertools.product(xrange(0, self.K), xrange(0, self.L)): self.S[k, l] = exponential_draw(self.lambdaS[k, l]) self.F, self.G = 1. / self.lambdaF, 1. / self.lambdaG if init_FG == 'random': for i, k in itertools.product(xrange(0, self.I), xrange(0, self.K)): self.F[i, k] = exponential_draw(self.lambdaF[i, k]) for j, l in itertools.product(xrange(0, self.J), xrange(0, self.L)): self.G[j, l] = exponential_draw(self.lambdaG[j, l]) elif init_FG == 'kmeans': print "Initialising F using KMeans." kmeans_F = KMeans(self.R, self.M, self.K) kmeans_F.initialise() kmeans_F.cluster() self.F = kmeans_F.clustering_results + 0.2 print "Initialising G using KMeans." kmeans_G = KMeans(self.R.T, self.M.T, self.L) kmeans_G.initialise() kmeans_G.cluster() self.G = kmeans_G.clustering_results + 0.2 self.tau = gamma_mode(self.alpha_s(), self.beta_s())
def initialise(self, init='random'): assert init in [ 'random', 'exp' ], "Unknown initialisation option: %s. Should be 'random' or 'exp'." % init self.U = numpy.zeros((self.I, self.K)) self.V = numpy.zeros((self.J, self.K)) if init == 'random': for i, k in itertools.product(xrange(0, self.I), xrange(0, self.K)): self.U[i, k] = exponential_draw(self.lambdaU[i][k]) for j, k in itertools.product(xrange(0, self.J), xrange(0, self.K)): self.V[j, k] = exponential_draw(self.lambdaV[j][k]) elif init == 'exp': for i, k in itertools.product(xrange(0, self.I), xrange(0, self.K)): self.U[i, k] = 1.0 / self.lambdaU[i][k] for j, k in itertools.product(xrange(0, self.J), xrange(0, self.K)): self.V[j, k] = 1.0 / self.lambdaV[j][k] self.tau = gamma_mode(self.alpha_s(), self.beta_s())
def run(self,iterations,minimum_TN=0.): self.all_tau = numpy.zeros(iterations) # to plot convergence self.all_times = [] # to plot performance against time metrics = ['MSE','R^2','Rp'] self.all_performances = {} # for plotting convergence of metrics for metric in metrics: self.all_performances[metric] = [] time_start = time.time() for it in range(0,iterations): for k in range(0,self.K): tauUk = self.tauU(k) muUk = self.muU(tauUk,k) self.U[:,k] = TN_vector_mode(muUk) self.U[:,k] = numpy.maximum(self.U[:,k],minimum_TN*numpy.ones(self.I)) for k in range(0,self.K): tauVk = self.tauV(k) muVk = self.muV(tauVk,k) self.V[:,k] = TN_vector_mode(muVk) self.V[:,k] = numpy.maximum(self.V[:,k],minimum_TN*numpy.ones(self.J)) self.tau = gamma_mode(self.alpha_s(),self.beta_s()) self.all_tau[it] = self.tau perf = self.predict(self.M) for metric in metrics: self.all_performances[metric].append(perf[metric]) print "Iteration %s. MSE: %s. R^2: %s. Rp: %s." % (it+1,perf['MSE'],perf['R^2'],perf['Rp']) time_iteration = time.time() self.all_times.append(time_iteration-time_start) return
def run(self, iterations): ''' Run the Gibbs sampler. ''' self.all_F = numpy.zeros((iterations, self.I, self.K)) self.all_S = numpy.zeros((iterations, self.K, self.L)) self.all_G = numpy.zeros((iterations, self.J, self.L)) self.all_tau = numpy.zeros(iterations) self.all_lambdaFk = numpy.zeros((iterations, self.K)) self.all_lambdaGl = numpy.zeros((iterations, self.L)) self.all_times = [] # to plot performance against time self.all_performances = {} # for plotting convergence of metrics for metric in ALL_METRICS: self.all_performances[metric] = [] time_start = time.time() for it in range(0, iterations): # Update lambdaFk, lambdaGl if self.ARD: for k in range(self.K): self.lambdaFk[k] = gamma_mode(self.alphaFk_s(k), self.betaFk_s(k)) for l in range(self.L): self.lambdaGl[l] = gamma_mode(self.alphaGl_s(l), self.betaGl_s(l)) # Update F for k in range(0, self.K): tauFk = self.tauF(k) muFk = self.muF(tauFk, k) self.F[:, k] = TN_vector_mode(muFk) self.F[:, k] = numpy.maximum(self.F[:, k], MINIMUM_TN * numpy.ones(self.I)) # Update S for k, l in itertools.product(xrange(0, self.K), xrange(0, self.L)): tauSkl = self.tauS(k, l) muSkl = self.muS(tauSkl, k, l) self.S[k, l] = TN_mode(muSkl) self.S[k, l] = max(self.S[k, l], MINIMUM_TN) # Update G for l in range(0, self.L): tauGl = self.tauG(l) muGl = self.muG(tauGl, l) self.G[:, l] = TN_vector_mode(muGl) self.G[:, l] = numpy.maximum(self.G[:, l], MINIMUM_TN * numpy.ones(self.J)) # Update tau self.tau = gamma_mode(self.alpha_s(), self.beta_s()) # Store draws self.all_F[it], self.all_S[it], self.all_G[it], self.all_tau[ it] = numpy.copy(self.F), numpy.copy(self.S), numpy.copy( self.G), self.tau if self.ARD: self.all_lambdaFk[it] = numpy.copy(self.lambdaFk) self.all_lambdaGl[it] = numpy.copy(self.lambdaGl) # Store and print performances perf = self.predict_while_running() for metric in ALL_METRICS: self.all_performances[metric].append(perf[metric]) print "Iteration %s. MSE: %s. R^2: %s. Rp: %s." % ( it + 1, perf['MSE'], perf['R^2'], perf['Rp']) # Store time taken for iteration time_iteration = time.time() self.all_times.append(time_iteration - time_start)