def testPeephole(self):
batch_size = 5
hidden_size = 20
# Initialize the rnn and verify the number of parameter sets.
inputs = tf.placeholder(tf.float32, shape=[batch_size, hidden_size])
prev_cell = tf.placeholder(tf.float32, shape=[batch_size, hidden_size])
prev_hidden = tf.placeholder(tf.float32, shape=[batch_size, hidden_size])
lstm = snt.LSTM(hidden_size, use_peepholes=True)
_, next_state = lstm(inputs, (prev_hidden, prev_cell))
next_hidden, next_cell = next_state
lstm_variables = lstm.get_variables()
self.assertEqual(len(lstm_variables), 5, "LSTM should have 5 variables")
# Unpack parameters into dict and check their sizes.
param_map = {param.name.split("/")[-1].split(":")[0]:
param for param in lstm_variables}
self.assertShapeEqual(np.ndarray(4 * hidden_size),
param_map[snt.LSTM.B_GATES].initial_value)
self.assertShapeEqual(np.ndarray((2 * hidden_size, 4 * hidden_size)),
param_map[snt.LSTM.W_GATES].initial_value)
self.assertShapeEqual(np.ndarray(hidden_size),
param_map[snt.LSTM.W_F_DIAG].initial_value)
self.assertShapeEqual(np.ndarray(hidden_size),
param_map[snt.LSTM.W_I_DIAG].initial_value)
self.assertShapeEqual(np.ndarray(hidden_size),
param_map[snt.LSTM.W_O_DIAG].initial_value)
# With random data, check the TF calculation matches the Numpy version.
input_data = np.random.randn(batch_size, hidden_size)
prev_hidden_data = np.random.randn(batch_size, hidden_size)
prev_cell_data = np.random.randn(batch_size, hidden_size)
with self.test_session() as session:
tf.global_variables_initializer().run()
fetches = [(next_hidden, next_cell),
param_map[snt.LSTM.W_GATES],
param_map[snt.LSTM.B_GATES],
param_map[snt.LSTM.W_F_DIAG],
param_map[snt.LSTM.W_I_DIAG],
param_map[snt.LSTM.W_O_DIAG]]
output = session.run(fetches,
{inputs: input_data,
prev_cell: prev_cell_data,
prev_hidden: prev_hidden_data})
next_state_ex, w_ex, b_ex, wfd_ex, wid_ex, wod_ex = output
in_and_hid = np.concatenate((input_data, prev_hidden_data), axis=1)
real_gate = np.dot(in_and_hid, w_ex) + b_ex
# i = input_gate, j = next_input, f = forget_gate, o = output_gate
i, j, f, o = np.hsplit(real_gate, 4)
real_cell = (prev_cell_data /
(1 + np.exp(-(f + lstm._forget_bias +
wfd_ex * prev_cell_data))) +
1 / (1 + np.exp(-(i + wid_ex * prev_cell_data))) * np.tanh(j))
real_hidden = (np.tanh(real_cell + wod_ex * real_cell) *
1 / (1 + np.exp(-o)))
self.assertAllClose(real_hidden, next_state_ex[0])
self.assertAllClose(real_cell, next_state_ex[1])
python类hsplit()的实例源码
def convert_cmvn_to_numpy(inputs_cmvn, labels_cmvn):
if FLAGS.labels_cmvn !='':
"""Convert global binary ark cmvn to numpy format."""
tf.logging.info("Convert %s and %s to numpy format" % (
inputs_cmvn, labels_cmvn))
inputs_filename = FLAGS.inputs_cmvn
labels_filename = FLAGS.labels_cmvn
inputs = read_binary_file(inputs_filename, 0)
labels = read_binary_file(labels_filename, 0)
inputs_frame = inputs[0][-1]
labels_frame = labels[0][-1]
#assert inputs_frame == labels_frame
cmvn_inputs = np.hsplit(inputs, [inputs.shape[1]-1])[0]
cmvn_labels = np.hsplit(labels, [labels.shape[1]-1])[0]
mean_inputs = cmvn_inputs[0] / inputs_frame
stddev_inputs = np.sqrt(cmvn_inputs[1] / inputs_frame - mean_inputs ** 2)
mean_labels = cmvn_labels[0] / labels_frame
stddev_labels = np.sqrt(cmvn_labels[1] / labels_frame - mean_labels ** 2)
cmvn_name = os.path.join(FLAGS.output_dir, "train_cmvn.npz")
np.savez(cmvn_name,
mean_inputs=mean_inputs,
stddev_inputs=stddev_inputs,
mean_labels=mean_labels,
stddev_labels=stddev_labels)
tf.logging.info("Write to %s" % cmvn_name)
else :
"""Convert global binary ark cmvn to numpy format."""
tf.logging.info("Convert %s to numpy format" % (
inputs_cmvn))
inputs_filename = FLAGS.inputs_cmvn
inputs = read_binary_file(inputs_filename, 0)
inputs_frame = inputs[0][-1]
cmvn_inputs = np.hsplit(inputs, [inputs.shape[1]-1])[0]
mean_inputs = cmvn_inputs[0] / inputs_frame
stddev_inputs = np.sqrt(cmvn_inputs[1] / inputs_frame - mean_inputs ** 2)
cmvn_name = os.path.join(FLAGS.output_dir, "train_cmvn.npz")
np.savez(cmvn_name,
mean_inputs=mean_inputs,
stddev_inputs=stddev_inputs)
tf.logging.info("Write to %s" % cmvn_name)
def __init__(self, treatment, control):
assert [type(treatment), type(control)] == [ndarray, ndarray] # numpy arrays only
yt, Xt = hsplit(treatment, [1])
yc, Xc = hsplit(control, [1])
self._nt, mt = Xt.shape
self._nc, mc = Xc.shape
self._n = self._nc + self._nt # n is number of datum across both groups
assert min(mt, mc, self._nt, self._nc) >= 1 and self._n >= 3 # data shouldn't be trivial
assert mt == mc # same number of features in treatment and control
self._m = mt # store number of features
assert unique(yt).all() in [-1,1] and unique(yc).all() in [-1,1] # labels are binary
tPlusIndex = where(yt.flatten() == 1.0)[0] # index for positive in treatment
self._ntplus = len(tPlusIndex) # number of such points (length of index)
tMinusIndex = delete(range(self._nt), tPlusIndex) # index for negative in treatment
self._ntminus = self._nt - self._ntplus # number of such points
self._Dtplus = Xt[tPlusIndex] # positive treatment datum
self._Dtminus = Xt[tMinusIndex] # negative treatment datum
cPlusIndex = where(yc.flatten() == 1.0)[0] # index for positive in control
self._ncplus = len(cPlusIndex) # number of such points (length of index)
cMinusIndex = delete(range(self._nc), cPlusIndex) # index for negative in control
self._ncminus = self._nc - self._ncplus # number of such points
self._Dcplus = Xc[cPlusIndex] # positive treatment datum
self._Dcminus = Xc[cMinusIndex] # negative treatment datum
# model parameters
self.__optimized = False # indicator for whether otpimization routine was performed
options['show_progress'] = False # supress optimization output
self.w = None # hyperplane slope
self.b1 = None # treatment group intercept
self.b2 = None # control group intercept
self.threshold = None # thresholding predictor function
print("Successfully initialized.")
def __init__(self, instance_array_amps, n_clusters = 9, n_iterations = 20, n_cpus=1, start='random', kappa_calc='approx', hard_assignments = 0, kappa_converged = 0.1, mu_converged = 0.01, min_iterations=10, LL_converged = 1.e-4, verbose = 0, seed=None, norm_method = 'sum'):
print 'EM_GMM_GMM2', instance_array_amps.shape
self.settings = {'n_clusters':n_clusters,'n_iterations':n_iterations,'n_cpus':n_cpus,'start':start,
'kappa_calc':kappa_calc,'hard_assignments':hard_assignments, 'method':'EM_VMM_GMM'}
#self.instance_array = copy.deepcopy(instance_array)
self.instance_array_amps = instance_array_amps
self.data_complex = norm_bet_chans(instance_array_amps, method = norm_method)
print 'hello norm method', norm_method
self.data_complex = instance_array_amps/np.sum(instance_array_amps,axis = 1)[:,np.newaxis]
self.input_data = np.hstack((np.real(self.data_complex), np.imag(self.data_complex)))
self.n_dim = self.data_complex.shape[1]
self.n_instances, self.n_dimensions = self.input_data.shape
self.n_clusters = n_clusters; self.max_iterations = n_iterations; self.start = start
self.hard_assignments = hard_assignments; self.seed = seed
if self.seed == None: self.seed = os.getpid()
print('seed,',self.seed)
np.random.seed(self.seed)
self.iteration = 1
self._initialisation()
self.convergence_record = []; converged = 0
self.LL_diff = np.inf
while converged!=1:
start_time = time.time()
self._EM_VMM_GMM_expectation_step()
if self.hard_assignments:
print 'hard assignments'
self.cluster_assignments = np.argmax(self.zij,axis=1)
self.zij = self.zij *0
for i in range(self.n_clusters):
self.zij[self.cluster_assignments==i,i] = 1
valid_items = self.probs>(1.e-300)
self.LL_list.append(np.sum(self.zij[valid_items]*np.log(self.probs[valid_items])))
self._EM_VMM_GMM_maximisation_step()
if (self.iteration>=2): self.LL_diff = np.abs(((self.LL_list[-1] - self.LL_list[-2])/self.LL_list[-2]))
if verbose:
print 'Time for iteration %d :%.2f, mu_convergence:%.3e, kappa_convergence:%.3e, LL: %.8e, LL_dif : %.3e'%(self.iteration,time.time() - start_time,self.convergence_mean, self.convergence_std, self.LL_list[-1],self.LL_diff)
self.convergence_record.append([self.iteration, self.convergence_mean, self.convergence_std])
mean_converged = mu_converged; std_converged = kappa_converged
if (self.iteration > min_iterations) and (self.convergence_mean<mean_converged) and (self.convergence_std<std_converged) and (self.LL_diff<LL_converged):
converged = 1
print 'Convergence criteria met!!'
elif self.iteration > n_iterations:
converged = 1
print 'Max number of iterations'
self.iteration+=1
print os.getpid(), 'Time for iteration %d :%.2f, mu_convergence:%.3e, kappa_convergence:%.3e, LL: %.8e, LL_dif : %.3e'%(self.iteration,time.time() - start_time,self.convergence_mean, self.convergence_std,self.LL_list[-1],self.LL_diff)
#print 'AIC : %.2f'%(2*(mu_list.shape[0]*mu_list.shape[1])-2.*LL_list[-1])
self.cluster_assignments = np.argmax(self.zij,axis=1)
self.BIC = -2*self.LL_list[-1]+self.n_clusters*3*np.log(self.n_dimensions)
gmm_means_re, gmm_means_im = np.hsplit(self.mean_list, 2)
gmm_vars_re, gmm_vars_im = np.hsplit(self.std_list**2, 2)
self.cluster_details = {'EM_GMM_means':self.mean_list, 'EM_GMM_variances':self.std_list**2,'BIC':self.BIC,'LL':self.LL_list,
'EM_GMM_means_re':gmm_means_re, 'EM_GMM_variances_re':gmm_vars_re,
'EM_GMM_means_im':gmm_means_im, 'EM_GMM_variances_im':gmm_vars_im}
