def write_hypos(self, all_hypos, sen_indices): """Writes ngram files for each sentence in ``all_hypos``. Args: all_hypos (list): list of nbest lists of hypotheses sen_indices (list): List of sentence indices (0-indexed) Raises: OSError. If the directory could not be created IOError. If something goes wrong while writing to the disk """ _mkdir(self.path, "ngram") for sen_idx, hypos in zip(sen_indices, all_hypos): sen_idx += 1 total = utils.log_sum([hypo.total_score for hypo in hypos]) normed_scores = [hypo.total_score - total for hypo in hypos] ngrams = defaultdict(dict) # Collect ngrams for hypo_idx, hypo in enumerate(hypos): sen_eos = [utils.GO_ID] + hypo.trgt_sentence + [utils.EOS_ID] for pos in range(1, len(sen_eos) + 1): hist = sen_eos[:pos] for order in range(self.min_order, self.max_order + 1): ngram = ' '.join(map(str, hist[-order:])) ngrams[ngram][hypo_idx] = True with open(self.file_pattern % sen_idx, "w") as f: for ngram, hypo_indices in ngrams.items(): ngram_score = np.exp( utils.log_sum([ normed_scores[hypo_idx] for hypo_idx in hypo_indices ])) f.write("%s : %f\n" % (ngram, min(1.0, ngram_score)))
def ic_log_pvalue(N, L, des_ic, verbose=False, trials=100, method="ub"): print des_ic correction_per_col = 3/(2*log(2)*N) K = L * correction_per_col # correction per motif ic_for_beta = des_ic + K tolerance = 10**-10 beta = find_beta_for_mean_motif_ic(N,L,ic_for_beta,tolerance=tolerance,verbose=verbose) # correct val of beta countses = enumerate_counts(N) entropies = np.array(map(entropy_from_counts, countses)) iterator = tqdm(countses) if verbose else countses log_cols = np.array(map(log_counts_to_cols, iterator)) log_Zq = log_sum(log_cols + -beta*entropies)*L log_Zp = N*L*log(4) #log_prefactor = log_Zq - log_Zp + beta*2*L log_prefactor = log_Zq - log_Zp + beta*(2*L-K) if method == "UB": log_expectation_ub = (-beta*(des_ic)) log_pval_ub = log_prefactor + log_expectation_ub return log_pval_ub - log(2) elif method == "analytic": mu, sigma = calc_params(N, L, beta) log_expectation = log(compute_expectation_spec(beta, mu, sigma)) log_pval = log_prefactor + log_expectation return log_pval else: ms = maxent_motifs(N, L, des_ic, trials, beta=beta) ics = map(motif_ic, ms) print "des_ic, mean ics:", des_ic, mean(ics) log_expectation = log_sum([-beta*ic for ic in ics if ic > des_ic]) - log(trials) # Xxx loss of precision log_pval = log_prefactor + log_expectation return log_pval
def pval_estimate(v): limit = len(v) low = max(s0 - Q1, 0) mid = min(s0, limit) if theta != 0: v += -np.arange(limit) * theta if log_mgf != 0: v += (L - 1) * log_mgf q1 = utils.log_sum(v[low:mid] + tail_sums[s0 - low:s0 - mid:-1]) q2 = utils.log_sum(v[mid:limit]) q = np.logaddexp(q1, q2) return q
def pval_estimate(v): limit = len(v) low = max(s0 - Q1, 0) mid = min(s0, limit) if theta != 0: v += -np.arange(limit) * theta if log_mgf != 0: v += (L - 1) * log_mgf q1 = utils.log_sum(v[low:mid] + tail_sums[s0 - low:s0 - mid:-1]) q2 = utils.log_sum(v[mid:limit]) q = np.logaddexp(q1, q2) return q
def sfft_pvalue(log_pmf, s0, L): theta = sisfft._compute_theta(log_pmf, s0, L) shifted, mgf = utils.shift(log_pmf, theta) sfft_vector, fft_len = naive.power_fft(shifted, L) error_estimate = utils.sfft_error_threshold_factor(fft_len, L) sfft_vector[sfft_vector < np.log(error_estimate)] = utils.NEG_INF return utils.log_sum(utils.unshift(sfft_vector, theta, (mgf, L))[s0:])
def sfft_pvalue(log_pmf, s0, L): theta = sisfft._compute_theta(log_pmf, s0, L) shifted, mgf = utils.shift(log_pmf, theta) sfft_vector, fft_len = naive.power_fft(shifted, L) error_estimate = utils.sfft_error_threshold_factor(fft_len, L) sfft_vector[sfft_vector < np.log(error_estimate)] = utils.NEG_INF return utils.log_sum(utils.unshift(sfft_vector, theta, (mgf, L))[s0:])
def log_alpha(self, observation): # 1. Initilization T = len(observation) ln_alpha = np.zeros(shape=(T, self.state_dim)) ln_alpha = self.__log_alpha(observation, ln_alpha) # 2. Induction loglikelihood = float('-inf') for i in range(self.state_dim): loglikelihood = log_sum(loglikelihood, ln_alpha[T - 1][i]) return ln_alpha, loglikelihood
def log_beta(self, observation): # 1. Initilization T = len(observation) ln_beta = np.zeros(shape=(T, self.state_dim)) ln_beta = self.__log_alpha(observation, ln_beta) # 2. Induction loglikelihood = float('-inf') for i in range(self.state_dim): loglikelihood = log_sum(loglikelihood, ln_beta[0][i] + self.log_pi[i] + self.log_emissions[i][observation[0]]) return ln_beta, loglikelihood
def log_alpha(self, observation): # 1. Initilization T = len(observation) ln_alpha = np.zeros(shape=(T, self.state_dim)) ln_alpha = self.__log_alpha(observation, ln_alpha) # 2. Induction loglikelihood = float('-inf') for i in range(self.state_dim): loglikelihood = log_sum(loglikelihood, ln_alpha[T-1][i]) return ln_alpha, loglikelihood
def convolve_naive_into(log_c, locations, log_u, log_v): nu = len(log_u) nv = len(log_v) nc = nu + nv - 1 assert len(log_c) == nc for k in locations: low_j = max(0, k - nv + 1) hi_j = min(k + 1, nu) slice_u = log_u[low_j:hi_j] slice_v = log_v[k - low_j:k - hi_j:-1] if k - hi_j != -1 else log_v[k - low_j::-1] log_c[k] = utils.log_sum(slice_u + slice_v)
def log_beta(self, observation): # 1. Initilization T = len(observation) ln_beta = np.zeros(shape=(T, self.state_dim)) ln_beta = self.__log_alpha(observation, ln_beta) # 2. Induction loglikelihood = float('-inf') for i in range(self.state_dim): loglikelihood = log_sum( loglikelihood, ln_beta[0][i] + self.log_pi[i] + self.log_emissions[i][observation[0]]) return ln_beta, loglikelihood
def __log_beta(self, observation, ln_beta): # 1. Initilization T = len(observation) for i in range(self.state_dim): ln_beta[T-1][i] = 0 # 2. Induction for t in range(T-2, -1, -1): for i in range(self.state_dim): tmp_sum = float('-inf') for j in range(self.state_dim): tmp_sum = log_sum(tmp_sum, ln_beta[t+1][j] + self.log_transitions[i][j] + self.log_emissions[j][observation[t+1]]) ln_beta[t][i] += tmp_sum return ln_beta
def ic_log_pvalue(N, L, des_ic, verbose=False, trials=100, method="ub"): print des_ic correction_per_col = 3 / (2 * log(2) * N) K = L * correction_per_col # correction per motif ic_for_beta = des_ic + K tolerance = 10**-10 beta = find_beta_for_mean_motif_ic(N, L, ic_for_beta, tolerance=tolerance, verbose=verbose) # correct val of beta countses = enumerate_counts(N) entropies = np.array(map(entropy_from_counts, countses)) iterator = tqdm(countses) if verbose else countses log_cols = np.array(map(log_counts_to_cols, iterator)) log_Zq = log_sum(log_cols + -beta * entropies) * L log_Zp = N * L * log(4) #log_prefactor = log_Zq - log_Zp + beta*2*L log_prefactor = log_Zq - log_Zp + beta * (2 * L - K) if method == "UB": log_expectation_ub = (-beta * (des_ic)) log_pval_ub = log_prefactor + log_expectation_ub return log_pval_ub - log(2) elif method == "analytic": mu, sigma = calc_params(N, L, beta) log_expectation = log(compute_expectation_spec(beta, mu, sigma)) log_pval = log_prefactor + log_expectation return log_pval else: ms = maxent_motifs(N, L, des_ic, trials, beta=beta) ics = map(motif_ic, ms) print "des_ic, mean ics:", des_ic, mean(ics) log_expectation = log_sum([-beta * ic for ic in ics if ic > des_ic ]) - log(trials) # Xxx loss of precision log_pval = log_prefactor + log_expectation return log_pval
def __log_alpha(self, observation, ln_alpha): # 1. Initilization # alpha representation: alpha[t][i] T = len(observation) for i in range(self.state_dim): ln_alpha[0][i] = self.log_pi[i] + self.log_emissions[i][observation[0]] # 2. Induction for t in range(1, T): obs = observation[t] for i in range(self.state_dim): tmp_sum = float('-inf') for j in range(self.state_dim): tmp_sum = log_sum(tmp_sum, ln_alpha[t-1][j] + self.log_transitions[j][i]) ln_alpha[t][i] = tmp_sum + self.log_emissions[i][obs] return ln_alpha
def ksi(self, index, observation, ln_alpha, ln_beta, log_ksi): T = len(observation) for t in range(T-1): ln_sum = float('-inf') x = observation[t+1] for i in range(self.state_dim): for j in range(self.state_dim): log_ksi[index][t][i][j] = ln_alpha[t][i] + self.log_transitions[i][j] + self.log_emissions[j][x] + ln_beta[t+1][j] ln_sum = log_sum(ln_sum, log_ksi[index][t][i][j]) for i in range(self.state_dim): for j in range(self.state_dim): log_ksi[index][t][i][j] -= ln_sum return log_ksi
def __log_beta(self, observation, ln_beta): # 1. Initilization T = len(observation) for i in range(self.state_dim): ln_beta[T - 1][i] = 0 # 2. Induction for t in range(T - 2, -1, -1): for i in range(self.state_dim): tmp_sum = float('-inf') for j in range(self.state_dim): tmp_sum = log_sum( tmp_sum, ln_beta[t + 1][j] + self.log_transitions[i][j] + self.log_emissions[j][observation[t + 1]]) ln_beta[t][i] += tmp_sum return ln_beta
def finalize_posterior(self, scores, use_weights, normalize_scores): """This method can be used to enforce the parameters use_weights normalize_scores in predictors with dict posteriors. Args: scores (dict): unnormalized log valued scores use_weights (bool): Set to false to replace all values in ``scores`` with 0 (= log 1) normalize_scores: Set to true to make the exp of elements in ``scores`` sum up to 1""" if not scores: # empty scores -> pass through return scores if not use_weights: scores = dict.fromkeys(scores, 0.0) if normalize_scores: log_sum = utils.log_sum(scores.values()) ret = {k: v - log_sum for k, v in scores.items()} return ret return scores
def pvalue(log_pmf, s0, L, desired_beta): """Compute $log((exp(log_pmf)**L)[s0:])$, such that the relative error to the exact answer is less than or equal to $desired_beta$.""" total_len, _ = utils.iterated_convolution_lengths(len(log_pmf), L) if s0 >= total_len: return NEG_INF _, p_lower_preshift, p_upper_preshift = _bounds(log_pmf, log_pmf, 0, 0.0, s0, L, desired_beta) sfft_good_preshift, sfft_pval_preshift = _check_sfft_pvalue(p_lower_preshift, p_upper_preshift, desired_beta) if sfft_good_preshift: logging.debug(' pre-shift sfft worked %.20f', sfft_pval_preshift) return sfft_pval_preshift with timer('computing theta'): theta = _compute_theta(log_pmf, s0, L) logging.debug('raw theta %s', theta) # TODO: too-large or negative theta causes numerical instability, # so this is a huge hack theta = utils.clamp(theta, 0, THETA_LIMIT) shifted_pmf, log_mgf = utils.shift(log_pmf, theta) beta = desired_beta / 2.0 with timer('bounds'): log_delta, p_lower, p_upper = _bounds(log_pmf, shifted_pmf, theta, log_mgf, s0, L, desired_beta) sfft_good, sfft_pval = _check_sfft_pvalue(p_lower, p_upper, desired_beta) logging.debug('theta %s, log_mgf %s, beta %s, log delta %s', theta, log_mgf, beta, log_delta) if sfft_good: logging.debug(' sfft worked %.20f', sfft_pval) return sfft_pval delta = np.exp(log_delta) conv = conv_power(shifted_pmf, L, beta, delta) pval = utils.log_sum(utils.unshift(conv, theta, (log_mgf, L))[s0:]) logging.debug(' sis pvalue %.20f', pval) return pval
def pvalue(log_pmf, s0, L, desired_beta): """Compute $log((exp(log_pmf)**L)[s0:])$, such that the relative error to the exact answer is less than or equal to $desired_beta$.""" total_len, _ = utils.iterated_convolution_lengths(len(log_pmf), L) if s0 >= total_len: return NEG_INF _, p_lower_preshift, p_upper_preshift = _bounds(log_pmf, log_pmf, 0, 0.0, s0, L, desired_beta) sfft_good_preshift, sfft_pval_preshift = _check_sfft_pvalue( p_lower_preshift, p_upper_preshift, desired_beta) if sfft_good_preshift: logging.debug(' pre-shift sfft worked %.20f', sfft_pval_preshift) return sfft_pval_preshift with timer('computing theta'): theta = _compute_theta(log_pmf, s0, L) logging.debug('raw theta %s', theta) # TODO: too-large or negative theta causes numerical instability, # so this is a huge hack theta = utils.clamp(theta, 0, THETA_LIMIT) shifted_pmf, log_mgf = utils.shift(log_pmf, theta) beta = desired_beta / 2.0 with timer('bounds'): log_delta, p_lower, p_upper = _bounds(log_pmf, shifted_pmf, theta, log_mgf, s0, L, desired_beta) sfft_good, sfft_pval = _check_sfft_pvalue(p_lower, p_upper, desired_beta) logging.debug('theta %s, log_mgf %s, beta %s, log delta %s', theta, log_mgf, beta, log_delta) if sfft_good: logging.debug(' sfft worked %.20f', sfft_pval) return sfft_pval delta = np.exp(log_delta) conv = conv_power(shifted_pmf, L, beta, delta) pval = utils.log_sum(utils.unshift(conv, theta, (log_mgf, L))[s0:]) logging.debug(' sis pvalue %.20f', pval) return pval
def ksi(self, index, observation, ln_alpha, ln_beta, log_ksi): T = len(observation) for t in range(T - 1): ln_sum = float('-inf') x = observation[t + 1] for i in range(self.state_dim): for j in range(self.state_dim): log_ksi[index][t][i][ j] = ln_alpha[t][i] + self.log_transitions[i][ j] + self.log_emissions[j][x] + ln_beta[t + 1][j] ln_sum = log_sum(ln_sum, log_ksi[index][t][i][j]) for i in range(self.state_dim): for j in range(self.state_dim): log_ksi[index][t][i][j] -= ln_sum return log_ksi
def __log_alpha(self, observation, ln_alpha): # 1. Initilization # alpha representation: alpha[t][i] T = len(observation) for i in range(self.state_dim): ln_alpha[0][i] = self.log_pi[i] + self.log_emissions[i][ observation[0]] # 2. Induction for t in range(1, T): obs = observation[t] for i in range(self.state_dim): tmp_sum = float('-inf') for j in range(self.state_dim): tmp_sum = log_sum( tmp_sum, ln_alpha[t - 1][j] + self.log_transitions[j][i]) ln_alpha[t][i] = tmp_sum + self.log_emissions[i][obs] return ln_alpha
def baum_welch(self, observation_sequences=None, encoded_sequences=None, max_iter=15, tolerance=0.001): # ???? testing only if observation_sequences: observation_sequences = self.map_binary_to_decimal( observation_sequences) if encoded_sequences: observation_sequences = encoded_sequences convergence = AbsoluteConvergence(max_iter, tolerance) # 1. Initialization N = len(observation_sequences) logN = math.log(N) log_ksi = [] log_gamma = [] for i in range(N): T = len(observation_sequences[i]) log_ksi.append([]) log_gamma.append(np.zeros(shape=(T, self.state_dim))) for t in range(T): log_ksi[i].append( np.zeros(shape=(self.state_dim, self.state_dim))) stop = False TMax = max([len(obs) for obs in observation_sequences]) # ln_alpha = np.zeros(shape=(TMax, self.state_dim)) # ln_beta = np.zeros(shape=(TMax, self.state_dim)) new_ll = float('-inf') old_ll = float('-inf') # 2. Iterate until convergence or max iterations is reached while not stop: # for each sequence in the observation_sequences for i in range(N): observation = observation_sequences[i] T = len(observation) tmp_log_gamma = log_gamma[i] # w = log_weights[i] # 1st step: calculating the forward and backward prob for each HMM state ln_alpha, ln_beta, ln_alpha_ll, ln_beta_ll = self.forward_backward( observation) # 2nd step: determining the freq of the transition-emission pair values, and dividing it by the prob of the entire string # compute the gamma values for next computations for t in range(T): ln_sum = float('-inf') for k in range(self.state_dim): tmp_log_gamma[t][k] = ln_alpha[t][k] + ln_beta[t][ k] # + w ln_sum = log_sum(ln_sum, tmp_log_gamma[t][k]) # Normalize if different from zero if ln_sum != float('-inf'): for k in range(self.state_dim): tmp_log_gamma[t][k] = tmp_log_gamma[t][k] - ln_sum # Calculate ksi values for next computations log_ksi = self.ksi(i, observation, ln_alpha, ln_beta, log_ksi) # Compute loglikelihood for the given sequence new_ll = float('-inf') for j in range(self.state_dim): new_ll = log_sum(new_ll, ln_alpha[T - 1][j]) # Average the loglikelihood for all sequences new_ll /= N convergence.set_new_value(new_ll) # Check for convergence if not convergence.has_converged(): print 'not converged!' # 3. Continue with the param re-estimation old_ll = new_ll new_ll = float('-inf') # 3.1 Re-estimate of initial state prob for i in range(len(self.log_pi)): ln_sum = float('-inf') for k in range(N): ln_sum = log_sum(ln_sum, log_gamma[k][0][i]) print '>>>>>>>shoud update pi, ln_sum: ', ln_sum, ', logN: ', logN, ', i: ', i self.log_pi[i] = ln_sum - logN # 3.2 Re-estimate of transition probabilities for i in range(self.state_dim): for j in range(self.state_dim): ln_num = float('-inf') ln_den = float('-inf') for k in range(N): T = len(observation_sequences[k]) for t in range(T - 1): ln_num = log_sum(ln_num, log_ksi[k][t][i][j]) ln_den = log_sum(ln_den, log_gamma[k][t][i]) print '>>>>>>>shoud update trans' if ln_num == ln_den: self.log_transitions[i][j] = 0 else: self.log_transitions[i][j] = ln_num - ln_den # Update the emission prob matrix for i in range(self.state_dim): for j in range(self.encoded_observation_dim): ln_num = float('-inf') ln_den = float('-inf') for k in range(N): T = len(observation_sequences[k]) gamma_k = log_gamma[k] for t in range(T): if observation_sequences[k][t] == j: ln_num = log_sum(ln_num, gamma_k[t][i]) ln_den = log_sum(ln_den, gamma_k[t][i]) print '>>>>>>>shoud update emit' self.log_emissions[i][j] = ln_num - ln_den else: print 'converged?' stop = True # Update the non_log params for i in range(len(self.log_pi)): self.pi[i] = math.exp(self.log_pi[i]) for i in range(len(self.log_transitions)): for j in range(len(self.log_transitions)): self.transitions[i][j] = math.exp(self.log_transitions[i][j]) for i in range(len(self.log_emissions)): for j in range(len(self.log_emissions[0])): self.emissions[i][j] = math.exp(self.log_emissions[i][j]) return new_ll
def baum_welch(self, observation_sequences=None, encoded_sequences=None, max_iter=15, tolerance=0.001): # ???? testing only if observation_sequences: observation_sequences = self.map_binary_to_decimal(observation_sequences) if encoded_sequences: observation_sequences = encoded_sequences convergence = AbsoluteConvergence(max_iter, tolerance) # 1. Initialization N = len(observation_sequences) logN = math.log(N) log_ksi = [] log_gamma = [] for i in range(N): T = len(observation_sequences[i]) log_ksi.append([]) log_gamma.append(np.zeros(shape=(T, self.state_dim))) for t in range(T): log_ksi[i].append(np.zeros(shape=(self.state_dim, self.state_dim))) stop = False TMax = max([len(obs) for obs in observation_sequences]) # ln_alpha = np.zeros(shape=(TMax, self.state_dim)) # ln_beta = np.zeros(shape=(TMax, self.state_dim)) new_ll = float('-inf') old_ll = float('-inf') # 2. Iterate until convergence or max iterations is reached while not stop: # for each sequence in the observation_sequences for i in range(N): observation = observation_sequences[i] T = len(observation) tmp_log_gamma = log_gamma[i] # w = log_weights[i] # 1st step: calculating the forward and backward prob for each HMM state ln_alpha, ln_beta, ln_alpha_ll, ln_beta_ll = self.forward_backward(observation) # 2nd step: determining the freq of the transition-emission pair values, and dividing it by the prob of the entire string # compute the gamma values for next computations for t in range(T): ln_sum = float('-inf') for k in range(self.state_dim): tmp_log_gamma[t][k] = ln_alpha[t][k] + ln_beta[t][k]# + w ln_sum = log_sum(ln_sum, tmp_log_gamma[t][k]) # Normalize if different from zero if ln_sum != float('-inf'): for k in range(self.state_dim): tmp_log_gamma[t][k] = tmp_log_gamma[t][k] - ln_sum # Calculate ksi values for next computations log_ksi = self.ksi(i, observation, ln_alpha, ln_beta, log_ksi) # Compute loglikelihood for the given sequence new_ll = float('-inf') for j in range(self.state_dim): new_ll = log_sum(new_ll, ln_alpha[T-1][j]) # Average the loglikelihood for all sequences new_ll /= N convergence.set_new_value(new_ll) # Check for convergence if not convergence.has_converged(): print 'not converged!' # 3. Continue with the param re-estimation old_ll = new_ll new_ll = float('-inf') # 3.1 Re-estimate of initial state prob for i in range(len(self.log_pi)): ln_sum = float('-inf') for k in range(N): ln_sum = log_sum(ln_sum, log_gamma[k][0][i]) print '>>>>>>>shoud update pi, ln_sum: ', ln_sum, ', logN: ', logN, ', i: ', i self.log_pi[i] = ln_sum - logN # 3.2 Re-estimate of transition probabilities for i in range(self.state_dim): for j in range(self.state_dim): ln_num = float('-inf') ln_den = float('-inf') for k in range(N): T = len(observation_sequences[k]) for t in range(T-1): ln_num = log_sum(ln_num, log_ksi[k][t][i][j]) ln_den = log_sum(ln_den, log_gamma[k][t][i]) print '>>>>>>>shoud update trans' if ln_num == ln_den: self.log_transitions[i][j] = 0 else: self.log_transitions[i][j] = ln_num - ln_den # Update the emission prob matrix for i in range(self.state_dim): for j in range(self.encoded_observation_dim): ln_num = float('-inf') ln_den = float('-inf') for k in range(N): T = len(observation_sequences[k]) gamma_k = log_gamma[k] for t in range(T): if observation_sequences[k][t] == j: ln_num = log_sum(ln_num, gamma_k[t][i]) ln_den = log_sum(ln_den, gamma_k[t][i]) print '>>>>>>>shoud update emit' self.log_emissions[i][j] = ln_num - ln_den else: print 'converged?' stop = True # Update the non_log params for i in range(len(self.log_pi)): self.pi[i] = math.exp(self.log_pi[i]) for i in range(len(self.log_transitions)): for j in range(len(self.log_transitions)): self.transitions[i][j] = math.exp(self.log_transitions[i][j]) for i in range(len(self.log_emissions)): for j in range(len(self.log_emissions[0])): self.emissions[i][j] = math.exp(self.log_emissions[i][j]) return new_ll