Python numpy 模块，savetxt() 实例源码
我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.savetxt()。
def calc_auc(y_pred_proba, labels, exp_run_folder, classifier, fold):
auc = roc_auc_score(labels, y_pred_proba)
fpr, tpr, thresholds = roc_curve(labels, y_pred_proba)
curve_roc = np.array([fpr, tpr])
dataile_id = open(exp_run_folder+'/data/roc_{}_{}.txt'.format(classifier, fold), 'w+')
np.savetxt(dataile_id, curve_roc)
dataile_id.close()
plt.plot(fpr, tpr, label='ROC curve: AUC={0:0.2f}'.format(auc))
plt.xlabel('1-Specificity')
plt.ylabel('Sensitivity')
plt.ylim([0.0, 1.05])
plt.xlim([0.0, 1.0])
plt.grid(True)
plt.title('ROC Fold {}'.format(fold))
plt.legend(loc="lower left")
plt.savefig(exp_run_folder+'/data/roc_{}_{}.pdf'.format(classifier, fold), format='pdf')
return auc
def main():
files = tf.gfile.Glob(flags.FLAGS.src_path_1)
labels_uni = np.zeros([4716,1])
labels_matrix = np.zeros([4716,4716])
for file in files:
labels_all = get_video_input_feature(file)
print(len(labels_all[0][2]),len(labels_all[0][3]),len(labels_all[0][4]),len(labels_all[0][5]))
"""
for labels in labels_all:
for i in range(len(labels)):
labels_uni[labels[i]] += 1
for j in range(len(labels)):
labels_matrix[labels[i],labels[j]] += 1
labels_matrix = labels_matrix/labels_uni
labels_matrix = labels_matrix/(np.sum(labels_matrix,axis=0)-1.0)
for i in range(4716):
labels_matrix[i,i] = 1.0
np.savetxt('labels_uni.out', labels_uni, delimiter=',')
np.savetxt('labels_matrix.out', labels_matrix, delimiter=',')"""
def _write(self, stream, text, byte_order):
'''
Write the data to a PLY file.
'''
if self._have_list:
# There are list properties, so serialization is
# slightly complicated.
if text:
self._write_txt(stream)
else:
self._write_bin(stream, byte_order)
else:
# no list properties, so serialization is
# straightforward.
if text:
_np.savetxt(stream, self.data, '%.18g', newline='\r\n')
else:
data = self.data.astype(self.dtype(byte_order),
copy=False)
data.tofile(stream)
def write_segment(self, segment,
delimiter = '\t',
skiprows =0,
writetimecolumn = True,
):
"""
Write a segment and AnalogSignal in a text file.
**Arguments**
delimiter : columns delimiter in file '\t' or one space or two space or ',' or ';'
writetimecolumn : True or Flase write time vector as first column
"""
if skiprows:
raise NotImplementedError('skiprows values other than 0 are not ' +
'supported')
l = [ ]
if writetimecolumn is not None:
l.append(segment.analogsignals[0].times[:, np.newaxis])
for anaSig in segment.analogsignals:
l.append(anaSig.magnitude[:, np.newaxis])
sigs = np.concatenate(l, axis=1)
#print sigs.shape
np.savetxt(self.filename , sigs , delimiter = delimiter)
def transpose_contig_matrix( args ):
contig = args[0]
opts = args[1]
logging.info(" Transposing %s" % contig)
contig_ipds_fn = os.path.join( opts.tmp, "%s_ipds.tmp" % contig)
contig_ipds_kmers_fn = os.path.join( opts.tmp, "%s_ipdskmers.tmp" % contig)
contig_ipds_N_fn = os.path.join( opts.tmp, "%s_ipdsN.tmp" % contig)
contig_ipds = np.loadtxt(contig_ipds_fn, dtype="float")
contig_ipds_kmers = np.loadtxt(contig_ipds_kmers_fn, dtype="str")
contig_ipds_N = np.loadtxt(contig_ipds_N_fn, dtype="int")
if len(contig_ipds.shape)==1:
contig_ipds = contig_ipds.reshape(1,contig_ipds.shape[0])
contig_ipds_N = contig_ipds_N.reshape(1,contig_ipds_N.shape[0])
contig_ipds = contig_ipds.T
contig_ipds_N = contig_ipds_N.T
np.savetxt(contig_ipds_fn+".trans", contig_ipds, fmt="%.4f", delimiter="\t")
np.savetxt(contig_ipds_N_fn+".trans", contig_ipds_N, fmt="%s", delimiter="\t")
return None
def writeToCSV(_imat, _nameOfFile):
_rows, _columns = _imat.shape;
_array = [];
_index = 0;
#_imat.tofile(_nameOfFile + ".csv", sep = ',', format = '%10.5f');
#np.savetxt(_nameOfFile + ".csv", _imat, delimiter = ",");
for i in range(0, _rows):
for j in range(0, _columns):
_array.append([]);
_array[_index].append(i);
#print(_array[_index]);
_array[_index].append(j);
#print(_array[_index]);
_array[_index].append(_imat[i][j]);
#print(_mag[i][j]);
#_array[_index].append(_mag[i][j]);
#_array[_index].append(_ang[i][j]);
#print(_array[_index]);
_index = _index + 1;
writeCSVFile(_array, _nameOfFile + ".csv");
#np.savetxt(_nameOfFile + ".csv", _array, delimiter = ",", fmt = '%10.5f');
#_array[_index].tofile(_nameOfFile + ".csv", sep = ',', format = '%10.5f');
return
def save(self, outfile):
if self.ps1d_normalized:
ps1d_desc = "normalized power [K^2]"
else:
ps1d_desc = "power [K^2 Mpc^3]"
header = [
"EoR window definition:",
"+ FoV: %f [deg]" % self.ps2d.fov,
"+ e_ConvWidth: %f" % self.ps2d.e,
"+ k_perp_min: %f [Mpc^-1]" % self.ps2d.k_perp_min,
"+ k_perp_max: %f [Mpc^-1]" % self.ps2d.k_perp_max,
"+ k_los_min: %f [Mpc^-1]" % self.ps2d.k_los_min,
"+ k_los_max: %f [Mpc^-1]" % self.ps2d.k_los_max,
"",
"Columns:",
"1. k: wavenumber [Mpc^-1]",
"2. ps1d: %s" % ps1d_desc,
"ps1d_err: power errors",
"",
"k ps1d ps1d_err",
]
np.savetxt(outfile, self.ps1d, header="\n".join(header))
print("Saved 1D power spectrum to file: %s" % outfile)
def save(self, outfile):
data = self.psd1d
header = [
"pixel: %s [%s]" % self.pixel,
"frequency: [%s^-1]" % self.pixel[1],
]
if self.meanstd:
header += [
"psd1d: *mean* powers of radial averaging annuli",
"psd1d_err: *standard deviation*",
]
else:
header += [
"psd1d: *median* powers of radial averaging annuli",
"psd1d_err: 1.4826*MAD (median absolute deviation)",
]
header += [
"n_cells: number of averaging cells",
"",
"frequency psd1d psd1d_err n_cells"
]
np.savetxt(outfile, data, header="\n".join(header))
print("Saved PSD data to: %s" % outfile)
def dump_all_actions(ae,configs,trans_fn,name="all_actions.csv",repeat=1):
if 'dump' not in mode:
return
l = len(configs)
batch = 5000
loop = (l // batch) + 1
try:
print(ae.local(name))
with open(ae.local(name), 'wb') as f:
for i in range(repeat):
for begin in range(0,loop*batch,batch):
end = begin + batch
print((begin,end,len(configs)))
transitions = trans_fn(configs[begin:end])
orig, dest = transitions[0], transitions[1]
orig_b = ae.encode_binary(orig,batch_size=1000).round().astype(int)
dest_b = ae.encode_binary(dest,batch_size=1000).round().astype(int)
actions = np.concatenate((orig_b,dest_b), axis=1)
np.savetxt(f,actions,"%d")
except AttributeError:
print("this AE does not support dumping")
except KeyboardInterrupt:
print("dump stopped")
def dump_all_states(ae,configs,states_fn,name="all_states.csv",repeat=1):
if 'dump' not in mode:
return
l = len(configs)
batch = 5000
loop = (l // batch) + 1
try:
print(ae.local(name))
with open(ae.local(name), 'wb') as f:
for i in range(repeat):
for begin in range(0,loop*batch,batch):
end = begin + batch
print((begin,end,len(configs)))
states = states_fn(configs[begin:end])
states_b = ae.encode_binary(states,batch_size=1000).round().astype(int)
np.savetxt(f,states_b,"%d")
except AttributeError:
print("this AE does not support dumping")
except KeyboardInterrupt:
print("dump stopped")
def dump_states(ae,states,name="states.csv",repeat=1):
if 'dump' not in mode:
return
try:
print(ae.local(name))
with open(ae.local(name), 'wb') as f:
for i in range(repeat):
np.savetxt(f,ae.encode_binary(states,batch_size=1000).round().astype(int),"%d")
except AttributeError:
print("this AE does not support dumping")
except KeyboardInterrupt:
print("dump stopped")
import subprocess
################################################################
# note: lightsout has epoch 200
def writeModelUBC(mesh, fileName, model):
"""Writes a model associated with a TensorMesh
to a UBC-GIF format model file.
:param string fileName: File to write to
:param numpy.ndarray model: The model
"""
# Reshape model to a matrix
modelMat = mesh.r(model, 'CC', 'CC', 'M')
# Transpose the axes
modelMatT = modelMat.transpose((2, 0, 1))
# Flip z to positive down
modelMatTR = utils.mkvc(modelMatT[::-1, :, :])
np.savetxt(fileName, modelMatTR.ravel())
def encoder(args, model):
latent_dim = args.latent_dim
data, charset = load_dataset(args.data, split = False)
if os.path.isfile(args.model):
model.load(charset, args.model, latent_rep_size = latent_dim)
else:
raise ValueError("Model file %s doesn't exist" % args.model)
x_latent = model.encoder.predict(data)
if args.save_h5:
h5f = h5py.File(args.save_h5, 'w')
h5f.create_dataset('charset', data = charset)
h5f.create_dataset('latent_vectors', data = x_latent)
h5f.close()
else:
np.savetxt(sys.stdout, x_latent, delimiter = '\t')
def main():
args = get_arguments()
model = MoleculeVAE()
data, data_test, charset = load_dataset(args.data)
if os.path.isfile(args.model):
model.load(charset, args.model, latent_rep_size = args.latent_dim)
else:
raise ValueError("Model file %s doesn't exist" % args.model)
x_latent = model.encoder.predict(data)
if not args.visualize:
if not args.save_h5:
np.savetxt(sys.stdout, x_latent, delimiter = '\t')
else:
h5f = h5py.File(args.save_h5, 'w')
h5f.create_dataset('charset', data = charset)
h5f.create_dataset('latent_vectors', data = x_latent)
h5f.close()
else:
visualize_latent_rep(args, model, x_latent)
def export_histories(self, path):
if not os.path.exists(path):
os.makedirs(path)
i = np.arange(len(self.loss_history)) + 1
z = np.array(zip(i, i*self.batch_size, self.loss_history))
np.savetxt(path + 'loss_history.csv', z, delimiter=',', fmt=[
'%d', '%d', '%f'], header='iteration, n_images, loss')
i = np.arange(len(self.train_acc_history), dtype=np.int)
z = np.array(zip(i, self.train_acc_history))
np.savetxt(path + 'train_acc_history.csv', z, delimiter=',', fmt=[
'%d', '%f'], header='epoch, train_acc')
z = np.array(zip(i, self.val_acc_history))
np.savetxt(path + 'val_acc_history.csv', z, delimiter=',', fmt=[
'%d', '%f'], header='epoch, val_acc')
np.save(path + 'loss', self.loss_history)
np.save(path + 'train_acc_history', self.train_acc_history)
np.save(path + 'val_acc_history', self.val_acc_history)
def test_format(self):
a = np.array([(1, 2), (3, 4)])
c = BytesIO()
# Sequence of formats
np.savetxt(c, a, fmt=['%02d', '%3.1f'])
c.seek(0)
assert_equal(c.readlines(), [b'01 2.0\n', b'03 4.0\n'])
# A single multiformat string
c = BytesIO()
np.savetxt(c, a, fmt='%02d : %3.1f')
c.seek(0)
lines = c.readlines()
assert_equal(lines, [b'01 : 2.0\n', b'03 : 4.0\n'])
# Specify delimiter, should be overiden
c = BytesIO()
np.savetxt(c, a, fmt='%02d : %3.1f', delimiter=',')
c.seek(0)
lines = c.readlines()
assert_equal(lines, [b'01 : 2.0\n', b'03 : 4.0\n'])
# Bad fmt, should raise a ValueError
c = BytesIO()
assert_raises(ValueError, np.savetxt, c, a, fmt=99)
def test_usecols(self):
# Test the selection of columns
# Select 1 column
control = np.array([[1, 2], [3, 4]], float)
data = TextIO()
np.savetxt(data, control)
data.seek(0)
test = np.ndfromtxt(data, dtype=float, usecols=(1,))
assert_equal(test, control[:, 1])
#
control = np.array([[1, 2, 3], [3, 4, 5]], float)
data = TextIO()
np.savetxt(data, control)
data.seek(0)
test = np.ndfromtxt(data, dtype=float, usecols=(1, 2))
assert_equal(test, control[:, 1:])
# Testing with arrays instead of tuples.
data.seek(0)
test = np.ndfromtxt(data, dtype=float, usecols=np.array([1, 2]))
assert_equal(test, control[:, 1:])
def create_scatter_plot(outfile_results, config):
true_vs_pred = os.path.join(config.output_dir,
config.name + "_results.csv")
true_vs_pred_plot = os.path.join(config.output_dir,
config.name + "_results.png")
with hdf.open_file(outfile_results, 'r') as f:
prediction = f.get_node("/", "Prediction").read()
y_true = f.get_node("/", "y_true").read()
np.savetxt(true_vs_pred, X=np.vstack([y_true, prediction]).T,
delimiter=',')
plt.figure()
plt.scatter(y_true, prediction)
plt.title('true vs prediction')
plt.xlabel('True')
plt.ylabel('Prediction')
plt.savefig(true_vs_pred_plot)
def WordToVec(bet_list):
model = Word2Vec.load('word2vector.model')
# ????
bet_vec_list = [] # between???????
for bet in bet_list:
between_vec = [] # ???between??
bet = bet.strip()
num, line = bet.split(':', 1)
line = line.split()
between_vec = np.array([0] * 50)
for word in line:
if word in model:
between_vec = between_vec + np.array(model[word])
bet_vec_list.append(between_vec)
bet_vec_list = np.array(bet_vec_list)
np.savetxt('2.csv', bet_vec_list)
return bet_vec_list
def compar_pic(path1,path2):
global net
#??????
X=read_image(path1)
test_num=np.shape(X)[0]
#X ?? ?????
out = net.forward_all(data = X)
#fc7??????,??????
feature1 = np.float64(out['fc7'])
feature1=np.reshape(feature1,(test_num,4096))
#np.savetxt('feature1.txt', feature1, delimiter=',')
#??????
X=read_image(path2)
#X ?? ?????
out = net.forward_all(data=X)
#fc7??????,??????
feature2 = np.float64(out['fc7'])
feature2=np.reshape(feature2,(test_num,4096))
#np.savetxt('feature2.txt', feature2, delimiter=',')
#????????cos?,??????????
predicts=pw.cosine_similarity(feature1, feature2)
return predicts
def run(self):
"""
extract and resize images then write manifest files to disk.
"""
cfg_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'train.cfg')
log_file = os.path.join(self.orig_out_dir, 'train.log')
manifest_list_cfg = ', '.join([k + ':' + v for k, v in self.manifests.items()])
with open(cfg_file, 'w') as f:
f.write('manifest = [{}]\n'.format(manifest_list_cfg))
f.write('manifest_root = {}\n'.format(self.out_dir))
f.write('log = {}\n'.format(log_file))
f.write('epochs = 90\nrng_seed = 0\nverbose = True\neval_freq = 1\n')
for setn, manifest in self.manifests.items():
if not os.path.exists(manifest):
pairs = self.train_or_val_pairs(setn)
records = [(os.path.relpath(fname, self.out_dir),
os.path.relpath(self._target_filename(int(tgt)), self.out_dir))
for fname, tgt in pairs]
np.savetxt(manifest, records, fmt='%s,%s')
def main(self, input_ring):
"""Initiate the writing to filename
@param[in] input_rings First ring in this list will be used for
data
@param[out] output_rings This list of rings won't be used."""
span_generator = self.iterate_ring_read(input_ring)
data_accumulate = None
for span in span_generator:
if self.nbit < 8:
unpacked_data = unpack(span.data_view(self.dtype), self.nbit)
else:
if self.dtype == np.complex64:
unpacked_data = span.data_view(self.dtype).view(np.float32)
elif self.dtype == np.complex128:
unpacked_data = span.data_view(self.dtype).view(np.float64)
else:
unpacked_data = span.data_view(self.dtype)
if data_accumulate is not None:
data_accumulate = np.concatenate((data_accumulate, unpacked_data[0]))
else:
data_accumulate = unpacked_data[0]
text_file = open(self.filename, 'a')
np.savetxt(text_file, data_accumulate.reshape((1, -1)))
def saveData(self):
try:
os.mkdir(self.savedir)
except:
print('directory exists. overwriting')
print ('saving to ',self.savedir)
if self.calibrateOnlyADC: # create ideal dataset for PV1, PV2
np.savetxt(os.path.join(self.savedir,'PV1_ERR.csv'),np.column_stack([np.linspace(-5,5,4096),np.linspace(-5,5,4096) ]))
np.savetxt(os.path.join(self.savedir,'PV2_ERR.csv'),np.column_stack([np.linspace(-3.3,3.3,4096),np.linspace(-3.3,3.3,4096) ]))
else:
np.savetxt(os.path.join(self.savedir,'PV1_ERR.csv'),np.column_stack([self.A.ADC24['AIN5'],self.A.DAC_VALS['PV1'] ]))
np.savetxt(os.path.join(self.savedir,'PV2_ERR.csv'),np.column_stack([self.A.ADC24['AIN6'],self.A.DAC_VALS['PV2'] ]))
np.savetxt(os.path.join(self.savedir,'PV3_ERR.csv'),np.column_stack([self.A.ADC24['AIN7'],self.A.DAC_VALS['PV3'] ]))
np.savetxt(os.path.join(self.savedir,'CALIB_INL.csv'),np.column_stack([self.A.ADC24['AIN7'],self.A.ADCPIC_INL]))
for a in self.INPUTS:
if self.I.analogInputSources[a].gainEnabled:
for b in range(8):
raw=self.A.ADC_VALUES[a][b]
np.savetxt(os.path.join(self.savedir,'CALIB_%s_%dx.csv'%(a,self.I.gain_values[b])),np.column_stack([np.array(self.A.ADC24['AIN6'])[self.A.ADC_ACTUALS[a][b]],raw]))
else:
np.savetxt(os.path.join(self.savedir,'CALIB_%s_%dx.csv'%(a,1)),np.column_stack([np.array(self.A.ADC24['AIN6'])[self.A.ADC_ACTUALS[a][0]],self.A.ADC_VALUES[a][0]]))
def main():
import sys
num_samples = int(sys.argv[1])
num_variables = int(sys.argv[2])
if num_variables < 9:
raise ValueError('needed at least 9 variables')
print 'Generation of %d samples with %d variables...' % (num_samples,
num_variables),
X, Y = correlated_dataset(num_samples, num_variables, (5, 5, 5), [1.0]*15)
np.savetxt('data.txt', X)
np.savetxt('labels.txt', Y)
print 'done'
def main():
import sys
num_samples = int(sys.argv[1])
num_variables = int(sys.argv[2])
if num_variables < 9:
raise ValueError('needed at least 9 variables')
print 'Generation of %d samples with %d variables...' % (num_samples,
num_variables),
X, Y = correlated_dataset(num_samples, num_variables, (5, 5, 5), [1.0]*15)
np.savetxt('data.txt', X)
np.savetxt('labels.txt', Y)
print 'done'
def dump(self, base):
header = ",".join(["x" + str(x) for x in range(1, 1 + self.X_train.shape[1])])
header += ","
header += ",".join(["y" + str(x) for x in range(1, 1 + self.y_train_nn.shape[1])])
np.savetxt(base + "_train.csv",
np.hstack((self.X_train, self.y_train_nn)),
fmt='%10.5f', delimiter=',', header=header, comments="")
np.savetxt(base + "_validate.csv",
np.hstack((self.X_validate, self.y_validate_nn)),
fmt='%10.5f', delimiter=',', header=header, comments="")
np.savetxt(base + "_train_norm.csv",
np.hstack((self.X_train_norm, self.y_train_nn)),
fmt='%10.5f', delimiter=',', header=header, comments="")
np.savetxt(base + "_validate_norm.csv",
np.hstack((self.X_validate_norm, self.y_validate_nn)),
fmt='%10.5f', delimiter=',', header=header, comments="")
# Human readable time elapsed string.
def save_raw_csv(raw, soln, dir_csv):
np.savetxt(os.path.join(dir_csv,str(raw['axis0_type'])+'.csv'), raw['axis0'])
np.savetxt(os.path.join(dir_csv,'pressure.csv'), raw['pressure'])
np.savetxt(os.path.join(dir_csv,'temperature.csv'), raw['temperature'])
np.savetxt(os.path.join(dir_csv,'mole_fraction.csv'), raw['mole_fraction'], delimiter=',')
np.savetxt(os.path.join(dir_csv,'net_reaction_rate.csv'), raw['net_reaction_rate'], delimiter=',')
if 'speed' in raw.keys():
np.savetxt(os.path.join(dir_csv,'speed.csv'), raw['speed'], delimiter=',')
f = open(os.path.join(dir_csv,'species_list.csv'),'w')
for sp in soln.species_names:
f.write(sp+'\n')
f.close()
f = open(os.path.join(dir_csv,'reaction_list.csv'),'w')
for rxn in soln.reaction_equations():
f.write(rxn+'\n')
f.close()
def save_adjacency_matrix_for_gephi(matrix, name, root_dir=None, notebook_mode=True, class_names=None):
if root_dir is None: root_dir = os.getcwd()
directory = check_or_create_dir(join_paths(root_dir, FOLDER_NAMINGS['GEPHI_DIR']),
notebook_mode=notebook_mode)
filename = join_paths(directory, '%s.csv' % name)
m, n = np.shape(matrix)
assert m == n, '%s should be a square matrix.' % matrix
if not class_names:
class_names = [str(k) for k in range(n)]
left = np.array([class_names]).T
matrix = np.hstack([left, matrix])
up = np.vstack([[''], left]).T
matrix = np.vstack([up, matrix])
np.savetxt(filename, matrix, delimiter=';', fmt='%s')
def GenerateData(nf = 256, ns = 16384):
try: #Try to read data from file
A = np.loadtxt('bdatA.csv', delimiter = ',')
Y = np.loadtxt('bdatY.csv', delimiter = ',').reshape(-1, 1)
except OSError: #New data needs to be generated
x = np.linspace(-1, 1, num = ns).reshape(-1, 1)
A = np.concatenate([x] * nf, axis = 1)
Y = ((np.sum(A, axis = 1) / nf) ** 2).reshape(-1, 1)
A = (A + np.random.rand(ns, nf)) / (2.0)
np.savetxt('bdatA.csv', A, delimiter = ',')
np.savetxt('bdatY.csv', Y, delimiter = ',')
return (A, Y)
#R: Regressor network to use
#A: The sample data matrix
#Y: Target data matrix
#nt: Number of times to divide the sample matrix
#fn: File name to write results
def MakeBenchDataFeature(R, A, Y, nt, fn):
#Divide samples into nt pieces on for each i run benchmark with chunks 0, 1, ..., i
step = A.shape[1] // nt
TT = np.zeros((nt, 3))
for i in range(1, nt):
#Number of features
TT[i, 0] = len(range(0, (i * step)))
print('{:8d} feature benchmark.'.format(int(TT[i, 0])))
#Training and testing times respectively
TT[i, 1], TT[i, 2] = RunBenchmark(R, A[:, 0:(i * step)], Y[:, 0:(i * step)])
#Save benchmark data to csv file
np.savetxt(fn, TT, delimiter = ',', header = 'Samples,Train,Test')
#R: Regressor network to use
#A: The sample data matrix
#Y: Target data matrix
#nt: Number of times to divide the sample matrix
#fn: File name to write results
def makeRotMatrix(motionParams, simDirClusterDirection):
#Make three rotation matrices
call(["makerot", "-t", str(motionParams[4]), "-a", "1,0,0", "--cov="+simDirClusterDirection+ "/brain.nii.gz", "-o", "rotx.mat"])
call(["makerot", "-t", str(motionParams[5]), "-a", "0,1,0", "--cov="+simDirClusterDirection+ "/brain.nii.gz", "-o", "roty.mat"])
call(["makerot", "-t", str(motionParams[6]), "-a", "0,0,1", "--cov="+simDirClusterDirection+ "/brain.nii.gz", "-o", "rotz.mat"])
#Concatenate
call(["convert_xfm", "-omat", "rotxy.mat","-concat", "roty.mat", "rotx.mat"])
call(["convert_xfm", "-omat", "rotxyz.mat","-concat", "rotz.mat", "rotxy.mat"])
#Add translations
rot = np.loadtxt('rotxyz.mat')
rot[0,3] += motionParams[1]
rot[1,3] += motionParams[2]
rot[2,3] += motionParams[3]
np.savetxt('trans.mat', rot )
#Tidy up
call(["rm","rotx.mat","roty.mat","rotz.mat","rotxy.mat","rotxyz.mat",])
def plot_loss(train_losses, dev_losses, steps, save_path):
"""Save history of training & dev loss as figure.
Args:
train_losses (list): train losses
dev_losses (list): dev losses
steps (list): steps
"""
# Save as csv file
loss_graph = np.column_stack((steps, train_losses, dev_losses))
if os.path.isfile(os.path.join(save_path, "ler.csv")):
os.remove(os.path.join(save_path, "ler.csv"))
np.savetxt(os.path.join(save_path, "loss.csv"), loss_graph, delimiter=",")
# TODO: error check for inf loss
# Plot & save as png file
plt.clf()
plt.plot(steps, train_losses, blue, label="Train")
plt.plot(steps, dev_losses, orange, label="Dev")
plt.xlabel('step', fontsize=12)
plt.ylabel('loss', fontsize=12)
plt.legend(loc="upper right", fontsize=12)
if os.path.isfile(os.path.join(save_path, "loss.png")):
os.remove(os.path.join(save_path, "loss.png"))
plt.savefig(os.path.join(save_path, "loss.png"), dvi=500)
def save(weight_vec, out_dir, subject, str_suffix=None):
"Saves the features to disk."
if out_dir is not None:
# get outpath returned from hiwenet, based on dist name and all other parameters
# choose out_dir name based on dist name and all other parameters
out_subject_dir = pjoin(out_dir, subject)
if not pexists(out_subject_dir):
os.mkdir(out_subject_dir)
if str_suffix is not None:
out_file_name = '{}_graynet.csv'.format(str_suffix)
else:
out_file_name = 'graynet.csv'
out_weights_path = pjoin(out_subject_dir, out_file_name)
try:
np.savetxt(out_weights_path, weight_vec, fmt='%.5f')
print('\nSaved the features to \n{}'.format(out_weights_path))
except:
print('\nUnable to save features to {}'.format(out_weights_path))
traceback.print_exc()
return
def encode(sess, memory, encoder, values, keys, full_batch_host, keys_host, batch_size):
full_batch_size = full_batch_host.shape[0]
assert full_batch_size >= batch_size, "full batch size needs to be >= mini-batch size"
memories_host = np.zeros([memory.num_models, memory.input_size])
print 'full_batch_size = ', full_batch_size, 'minibatch_size = ', batch_size
for begin,end in zip(range(0, full_batch_size, batch_size),
range(batch_size, full_batch_size+1, batch_size)):
feed_dict={keys: keys_host[begin:end],
values: full_batch_host[begin:end]}
# encode value with the keys
memories_host += sess.run(encoder, feed_dict=feed_dict)
#np.savetxt("encoded.csv", memories_host, delimiter=",")
return memories_host
def create_boc_w2v_train(doc_path,dim,win,freq,num_concept):
'''
Creates (word, concept) result for given dimension, window, min freq threshold and num of concepts Trains new W2v models simultaneously
'''
all_param=[]
for edim in dim:
model=train_w2v(doc_path,edim,win,freq)
wlist=get_tokens(doc_path,freq)
wM=get_wordvectors(model,wlist)
for ecp in num_concpt:
w2c_output="w2c_d%s_w%s_mf%s_c%s.csv" %(str(edim),str(win),str(freq),str(ecp))
boc_output="boc_d%s_w%s_mf%s_c%s.csv" %(str(edim),str(win),str(freq),str(ecp))
word2concept=create_concepts(wM,wlist,w2c_output,num_concept)
boc=apply_cfidf(doc_path,word2concept,num_concept)
np.savetxt(boc_output, boc, delimiter=",")
print(".... BOC vectors created in %s" %boc_output)
all_param.append(namedtuple('parameters','document_path dimension window_size min_freq num_concept'))
return all_param
def create_boc_w2v_load(models,doc_path,win,freq,num_concept,model_path):
'''
Creates (word, concept) result for given dimension, window, min freq threshold and num of concepts Trains new W2v models simultaneously
'''
all_param=[]
for em in models:
em_name=em.split("/")[-1]
model=KeyedVectors.load_word2vec_format(em)
wlist=get_tokens(doc_path,freq)
wM=get_wordvectors(model,wlist)
for ecp in num_concpt:
w2c_output="w2c_d%s_w%s_mf%s_c%s.csv" %(str(em_name),str(win),str(freq),str(ecp))
boc_output="boc_d%s_w%s_mf%s_c%s.csv" %(str(em_name),str(win),str(freq),str(ecp))
word2concept=create_concepts(wM,wlist,w2c_output,num_concept)
boc=apply_cfidf(doc_path,word2concept,num_concept)
np.savetxt(boc_output, boc, delimiter=",")
print(".... BOC vectors created in %s" %boc_output)
all_param.append(namedtuple('parameters','document_path dimension window_size min_freq num_concept'))
return all_param
def create_boc_w2v_train(doc_path,dim,win,freq,num_concept):
'''
Creates (word, concept) result for given dimension, window, min freq threshold and num of concepts Trains new W2v models simultaneously
'''
all_param=[]
for edim in dim:
model=train_w2v(doc_path,edim,win,freq)
wlist=get_tokens(doc_path,freq)
wM=get_wordvectors(model,wlist)
for ecp in num_concpt:
w2c_output="w2c_d%s_w%s_mf%s_c%s.csv" %(str(edim),str(win),str(freq),str(ecp))
boc_output="boc_d%s_w%s_mf%s_c%s.csv" %(str(edim),str(win),str(freq),str(ecp))
word2concept=create_concepts(wM,wlist,w2c_output,num_concept)
boc=apply_cfidf(doc_path,word2concept,num_concept)
np.savetxt(boc_output, boc, delimiter=",")
print(".... BOC vectors created in %s" %boc_output)
all_param.append(namedtuple('parameters','document_path dimension window_size min_freq num_concept'))
return all_param
def create_boc_w2v_load(models,doc_path,win,freq,num_concept,model_path):
'''
Creates (word, concept) result for given dimension, window, min freq threshold and num of concepts Trains new W2v models simultaneously
'''
all_param=[]
for em in models:
em_name=em.split("/")[-1]
model=KeyedVectors.load_word2vec_format(em)
wlist=get_tokens(doc_path,freq)
wM=get_wordvectors(model,wlist)
for ecp in num_concpt:
w2c_output="w2c_d%s_w%s_mf%s_c%s.csv" %(str(em_name),str(win),str(freq),str(ecp))
boc_output="boc_d%s_w%s_mf%s_c%s.csv" %(str(em_name),str(win),str(freq),str(ecp))
word2concept=create_concepts(wM,wlist,w2c_output,num_concept)
boc=apply_cfidf(doc_path,word2concept,num_concept)
np.savetxt(boc_output, boc, delimiter=",")
print(".... BOC vectors created in %s" %boc_output)
all_param.append(namedtuple('parameters','document_path dimension window_size min_freq num_concept'))
return all_param
def write_preprocessed_data(output_directory, cell_IDs, cell_stages, data, markers):
processed_data_path = path.join(output_directory, 'processed_data.tsv')
with open(processed_data_path, 'w') as f:
f.write('\t'.join(cell_IDs))
f.write('\n')
f.write('\t'.join(cell_stages))
f.write('\n')
np.savetxt(f, data.T, fmt = '%.6f', delimiter = '\t')
dataset = np.genfromtxt(processed_data_path, delimiter = '\t', dtype = str)
dataset = np.insert(dataset, 0, np.append(['Cell ID', 'Stage'],
markers), axis = 1)
with open(processed_data_path, 'w') as f:
np.savetxt(f, dataset, fmt = '%s', delimiter = '\t')
def prepare_inputs(*inputs, **kwinputs):
"""Prepare the inputs for the simulator.
The signature follows that given in `elfi.tools.external_operation`. This function
appends kwinputs with unique and descriptive filenames and writes an input file for
the bdm executable.
"""
alpha, delta, tau, N = inputs
meta = kwinputs['meta']
# Organize the parameters to an array. The broadcasting works nicely with constant
# arguments.
param_array = np.row_stack(np.broadcast(alpha, delta, tau, N))
# Prepare a unique filename for parallel settings
filename = '{model_name}_{batch_index}_{submission_index}.txt'.format(**meta)
np.savetxt(filename, param_array, fmt='%.4f %.4f %.4f %d')
# Add the filenames to kwinputs
kwinputs['filename'] = filename
kwinputs['output_filename'] = filename[:-4] + '_out.txt'
# Return new inputs that the command will receive
return inputs, kwinputs
def run(self):
# pr = cProfile.Profile()
print '[LOG]: start new thread '+str(self.threadID)
curTime = time.time()
distM = self.matrix[self.sfrom].dot(
self.matrix[self.sto].T).todense()
distM = np.maximum(
np.arccos(np.minimum(distM, np.ones(distM.shape))) /
(PI_VALUE/200)-0.01,
np.zeros(distM.shape)).astype(np.int8)
# np.savetxt(self.fo, distM, fmt = '%d')
np.save(self.fo + '.npy', distM)
print('[LOG]: thread %d finished after %d' %
(self.threadID, time.time() - curTime))
# self.pr.disable()
# # sortby = 'cumulative'
# # pstats.Stats(pr).strip_dirs().sort_stats(sortby).print_stats()
# self.pr.print_stats()
def test_format(self):
a = np.array([(1, 2), (3, 4)])
c = BytesIO()
# Sequence of formats
np.savetxt(c, a, fmt=['%02d', '%3.1f'])
c.seek(0)
assert_equal(c.readlines(), [b'01 2.0\n', b'03 4.0\n'])
# A single multiformat string
c = BytesIO()
np.savetxt(c, a, fmt='%02d : %3.1f')
c.seek(0)
lines = c.readlines()
assert_equal(lines, [b'01 : 2.0\n', b'03 : 4.0\n'])
# Specify delimiter, should be overiden
c = BytesIO()
np.savetxt(c, a, fmt='%02d : %3.1f', delimiter=',')
c.seek(0)
lines = c.readlines()
assert_equal(lines, [b'01 : 2.0\n', b'03 : 4.0\n'])
# Bad fmt, should raise a ValueError
c = BytesIO()
assert_raises(ValueError, np.savetxt, c, a, fmt=99)
def main():
labels_uni = np.zeros([4716,1])
with open(flags.FLAGS.src_path_1, "rt", encoding='utf-8') as csvfile:
spamreader = csv.reader(csvfile)
line_num = 0
for row in spamreader:
line_num += 1
print('the '+str(line_num)+'th file is processing')
if line_num==1:
continue
lbs = row[1].split()
for i in range(0,len(lbs),2):
labels_uni[int(lbs[i])] += 1
np.savetxt('labels_model.out', labels_uni, delimiter=',')
def main():
rootclass = {}
with open(flags.FLAGS.src_path_1, "rt", encoding='utf-8') as csvfile:
spamreader = csv.reader(csvfile)
line_num = 0
for row in spamreader:
line_num += 1
print('the '+str(line_num)+'th file is processing')
if line_num==1:
continue
if row[5] in rootclass:
rootclass[row[5]].append(line_num-2)
else:
rootclass[row[5]] = [line_num-2]
labels_ordered = []
for x in rootclass:
labels_ordered.extend(rootclass[x])
labels_ordered = [int(l) for l in labels_ordered]
reverse_ordered = np.zeros([4716,1])
for i in range(len(labels_ordered)):
reverse_ordered[labels_ordered[i]] = i
print(len(rootclass))
print(labels_ordered)
np.savetxt('labels_ordered.out', reverse_ordered, delimiter=',')
random.shuffle(labels_ordered)
reverse_unordered = np.zeros([4716,1])
for i in range(len(labels_ordered)):
reverse_unordered[labels_ordered[i]] = i
print(labels_ordered)
np.savetxt('labels_unordered.out', reverse_unordered, delimiter=',')
labels_class = np.zeros([len(rootclass),4716])
flag = 0
for x in rootclass:
for i in rootclass[x]:
labels_class[flag,i] = 1
flag +=1
np.savetxt('labels_class.out', labels_class)
def _write_txt(self, stream):
'''
Save a PLY element to an ASCII-format PLY file. The element may
contain list properties.
'''
for rec in self.data:
fields = []
for prop in self.properties:
fields.extend(prop._to_fields(rec[prop.name]))
_np.savetxt(stream, [fields], '%.18g', newline='\r\n')
def _write_txt(self, stream):
'''
Save a PLY element to an ASCII-format PLY file. The element may
contain list properties.
'''
for rec in self.data:
fields = []
for prop in self.properties:
fields.extend(prop._to_fields(rec[prop.name]))
_np.savetxt(stream, [fields], '%.18g', newline='\r\n')
def save_poses(fn, poses):
""" Save poses in toon format """
Rts = [pose.matrix[:3,:] for pose in poses]
with file(fn, 'w') as outfile:
for Rt in Rts:
for row in Rt:
np.savetxt(outfile, row, fmt='%-8.7f', delimiter=' ', newline=' ')
outfile.write('\n')
outfile.write('\n')
return
def write_test_file(self, variable='v', check=False):
data, metadata = self.build_test_data(variable)
with open(self.test_file, 'wb') as f:
for item in sorted(metadata.items()):
f.write(("# %s = %s\n" % item).encode('utf8'))
np.savetxt(f, data)
if check:
raise NotImplementedError
def _write_file_contents(self, data, metadata):
with open(self.filename, 'wb') as f:
for item in sorted(metadata.items()):
f.write(("# %s = %s\n" % item).encode('utf8'))
numpy.savetxt(f, data)
def write_test_file(self, variable='v', check=False):
data, metadata = self.build_test_data(variable)
with open(self.test_file, 'wb') as f:
for item in sorted(metadata.items()):
f.write(("# %s = %s\n" % item).encode('utf8'))
np.savetxt(f, data)
if check:
raise NotImplementedError