Python numpy 模块，set_printoptions() 实例源码
我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.set_printoptions()。
def print_resul(sol):
#==============================================================================
# Impression des résultats
pm, model, filename = sol.pm, sol.model, sol.filename
print('\n\nInversion success!')
print('Name of file:', filename)
print('Model used:', model)
try:
pm.pop("cond_std")
pm.pop("tau_i_std")
pm.pop("m_i_std")
except:
pass
e_keys = sorted([s for s in list(pm.keys()) if "_std" in s])
v_keys = [e.replace("_std", "") for e in e_keys]
labels = ["{:<8}".format(x+":") for x in v_keys]
np.set_printoptions(formatter={'float': lambda x: format(x, '6.3E')})
for l, v, e in zip(labels, v_keys, e_keys):
if "noise" not in l:
print(l, np.atleast_1d(pm[v]), '+/-', np.atleast_1d(pm[e]), np.char.mod('(%.2f%%)',abs(100*pm[e]/pm[v])))
else:
print(l, np.atleast_1d(pm[v]), '+/-', np.atleast_1d(pm[e]))
def print_resul(sol):
#==============================================================================
# Impression des résultats
pm, model, filename = sol.pm, sol.model, sol.filename
print('\n\nInversion success!')
print('Name of file:', filename)
print('Model used:', model)
try:
pm.pop("cond_std")
pm.pop("tau_i_std")
pm.pop("m_i_std")
except:
pass
e_keys = sorted([s for s in list(pm.keys()) if "_std" in s])
v_keys = [e.replace("_std", "") for e in e_keys]
labels = ["{:<8}".format(x+":") for x in v_keys]
np.set_printoptions(formatter={'float': lambda x: format(x, '6.3E')})
for l, v, e in zip(labels, v_keys, e_keys):
if "noise" not in l:
print(l, np.atleast_1d(pm[v]), '+/-', np.atleast_1d(pm[e]), np.char.mod('(%.2f%%)',abs(100*pm[e]/pm[v])))
else:
print(l, np.atleast_1d(pm[v]), '+/-', np.atleast_1d(pm[e]))
def test_timeseries_bootstrap():
"""
Tests the timeseries_bootstrap method of BASC workflow
"""
np.random.seed(27)
#np.set_printoptions(threshold=np.nan)
# Create a 10x5 matrix which counts up by column-wise
x = np.arange(50).reshape((5,10)).T
actual= timeseries_bootstrap(x,3)
desired = np.array([[ 4, 14, 24, 34, 44],
[ 5, 15, 25, 35, 45],
[ 6, 16, 26, 36, 46],
[ 8, 18, 28, 38, 48],
[ 9, 19, 29, 39, 49],
[ 0, 10, 20, 30, 40],
[ 7, 17, 27, 37, 47],
[ 8, 18, 28, 38, 48],
[ 9, 19, 29, 39, 49],
[ 8, 18, 28, 38, 48]])
np.testing.assert_equal(actual, desired)
def to_tfrecord(data, file_dir):
for key, values in data.iteritems():
writer = tf.python_io.TFRecordWriter(os.path.join(file_dir, key + '.tfrecord'))
image = values['image']
ground_truth = values['ground_truth']
shape = np.array(image.shape).astype(np.int32)
# set precision of string printing to be float32
np.set_printoptions(precision=32)
example = tf.train.Example(features=tf.train.Features(feature={
'example_name': _bytes_feature(key),
'shape': _bytes_feature(shape.tostring()),
'img_raw': _bytes_feature(image.tostring()),
'gt_raw': _bytes_feature(ground_truth.tostring())}))
writer.write(example.SerializeToString())
writer.close()
def test_formatter_reset(self):
x = np.arange(3)
np.set_printoptions(formatter={'all':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'int':None})
assert_equal(repr(x), "array([0, 1, 2])")
np.set_printoptions(formatter={'all':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'all':None})
assert_equal(repr(x), "array([0, 1, 2])")
np.set_printoptions(formatter={'int':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'int_kind':None})
assert_equal(repr(x), "array([0, 1, 2])")
x = np.arange(3.)
np.set_printoptions(formatter={'float':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1.0, 0.0, 1.0])")
np.set_printoptions(formatter={'float_kind':None})
assert_equal(repr(x), "array([ 0., 1., 2.])")
def main():
# don't use scientific notation when printing
numpy.set_printoptions(suppress=True)
filename = sys.argv[1]
with open(filename) as f:
c = pickle.load(f)
c.reset()
print 'Matrix'
print c.matrix
print
print 'Constant'
print c.constant
#env = Environment(show=True, z1=5, z2=3)
#env = Environment(show=True, z1=5, z2=8)
env = Environment(z0=100+3, z1=100+10, total_t=4, show=True)
fitness = env.run(c)
print 'fitness:', fitness
def plot_normalized_confusion_matrix_at_depth(self):
""" Returns a normalized confusion matrix.
:returns: normalized confusion matrix
:rtype: matplotlib figure
"""
cm = metrics.confusion_matrix(self.predictions['label'], self.y_pred)
np.set_printoptions(precision = 2)
fig = plt.figure()
cm_normalized = cm.astype('float') / cm.sum(axis = 1)[:, np.newaxis]
plt.imshow(cm_normalized, interpolation = 'nearest',
cmap = plt.cm.Blues)
plt.title("Normalized Confusion Matrix")
plt.colorbar()
tick_marks = np.arange(len(self.labels))
plt.xticks(tick_marks, self.labels, rotation = 45)
plt.yticks(tick_marks, self.labels)
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
return(fig)
def execute_calculation(operands, first_operand, const_executor):
iterations = len(operands) != 1
for i in operands:
_operands, expected_result, description = unpack_list(*i)
if description:
print("Description: ", description)
print("Operands: ", _operands)
print("Expected result: ", expected_result)
flex_result = const_executor(*_operands)
try:
print("flex_result: {0:.30}".format(float(flex_result)))
except TypeError:
# exception for arrays
np.set_printoptions(precision=30)
print("flex_result: {}".format(flex_result))
print("difference: ", flex_result - expected_result)
if iterations:
assert_allclose(flex_result, expected_result)
elif not isinstance(first_operand, np.ndarray):
assert flex_result == expected_result
else:
assert np.array_equal(flex_result, expected_result)
def compute_mean(self, file_list):
logger = logging.getLogger("acoustic_norm")
mean_vector = numpy.zeros((1, self.feature_dimension))
all_frame_number = 0
io_funcs = BinaryIOCollection()
for file_name in file_list:
features = io_funcs.load_binary_file(file_name, self.feature_dimension)
current_frame_number = features.size // self.feature_dimension
mean_vector += numpy.reshape(numpy.sum(features, axis=0), (1, self.feature_dimension))
all_frame_number += current_frame_number
mean_vector /= float(all_frame_number)
# po=numpy.get_printoptions()
# numpy.set_printoptions(precision=2, threshold=20, linewidth=1000, edgeitems=4)
logger.info('computed mean vector of length %d :' % mean_vector.shape[1] )
logger.info(' mean: %s' % mean_vector)
# restore the print options
# numpy.set_printoptions(po)
return mean_vector
def compute_mean(self, file_list, start_index, end_index):
local_feature_dimension = end_index - start_index
mean_vector = numpy.zeros((1, local_feature_dimension))
all_frame_number = 0
io_funcs = BinaryIOCollection()
for file_name in file_list:
features, current_frame_number = io_funcs.load_binary_file_frame(file_name, self.feature_dimension)
mean_vector += numpy.reshape(numpy.sum(features[:, start_index:end_index], axis=0), (1, local_feature_dimension))
all_frame_number += current_frame_number
mean_vector /= float(all_frame_number)
# po=numpy.get_printoptions()
# numpy.set_printoptions(precision=2, threshold=20, linewidth=1000, edgeitems=4)
self.logger.info('computed mean vector of length %d :' % mean_vector.shape[1] )
self.logger.info(' mean: %s' % mean_vector)
# restore the print options
# numpy.set_printoptions(po)
return mean_vector
def test_propagate_information_filter():
np.set_printoptions(precision=2, linewidth=132)
M_matrix = np.eye(7)
sigma = np.array([0.12, 0.7, 0.0959, 0.15, 1.5, 0.2, 0.5])
x_analysis = np.array([0.17, 1.0, 0.1, 0.7, 2.0, 0.18, np.exp(-0.5*1.5)])
Pd = np.diag(sigma**2).astype(np.float32)
Pd[5, 2] = 0.8862*0.0959*0.2
Pd[2, 5] = 0.8862*0.0959*0.2
Pi = np.linalg.inv(Pd)
Q_matrix = np.eye(7)*0.1
x_forecast, P_forecast, P_forecast_inverse = propagate_information_filter(
x_analysis, None, Pi, M_matrix, Q_matrix)
assert np.allclose(
np.array(P_forecast_inverse.todense()).squeeze().diagonal(),
np.array([8.74, 1.69, 9.81, 8.16, 0.43, 9.21, 2.86]), atol=0.01)
# In reality, the matrix ought to be
# [[ 8.74 0. 0. 0. 0. 0. 0. ]
# [ 0. 1.69 0. 0. 0. 0. 0. ]
# [ 0. 0. 9.33 0. 0. -1.13 0. ]
# [ 0. 0. 0. 8.16 0. 0. 0. ]
# [ 0. 0. 0. 0. 0.43 0. 0. ]
# [ 0. 0. -1.13 0. 0. 7.28 0. ]
# [ 0. 0. 0. 0. 0. 0. 2.86]]
def main():
args = parse_args()
print('Called with args:')
print(args)
lang_db = get_language_model(args.lang_name)
imdb = get_imdb(args.imdb_name)
# Get words in space
vocabulary = imdb.get_labels(args.space)
# Get features for words
wv = [lang_db.word_vector(w) for w in vocabulary]
from sklearn.metrics.pairwise import cosine_similarity
from scipy import spatial
#spatial.distance.cosine(dataSetI, dataSetII)
tsne = TSNE(n_components=2, random_state=0)
np.set_printoptions(suppress=True)
Y = tsne.fit_transform(wv)
plt.scatter(Y[:, 0], Y[:, 1])
for label, x, y in zip(vocabulary, Y[:, 0], Y[:, 1]):
plt.annotate(label, xy=(x, y), xytext=(0, 0), textcoords='offset points')
plt.show()
def test_formatter_reset(self):
x = np.arange(3)
np.set_printoptions(formatter={'all':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'int':None})
assert_equal(repr(x), "array([0, 1, 2])")
np.set_printoptions(formatter={'all':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'all':None})
assert_equal(repr(x), "array([0, 1, 2])")
np.set_printoptions(formatter={'int':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'int_kind':None})
assert_equal(repr(x), "array([0, 1, 2])")
x = np.arange(3.)
np.set_printoptions(formatter={'float':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1.0, 0.0, 1.0])")
np.set_printoptions(formatter={'float_kind':None})
assert_equal(repr(x), "array([ 0., 1., 2.])")
def detect_nan(i, node, fn):
'''
x = theano.tensor.dscalar('x')
f = theano.function([x], [theano.tensor.log(x) * x],
mode=theano.compile.MonitorMode(post_func=detect_nan))
'''
nan_detected = False
for output in fn.outputs:
if np.isnan(output[0]).any():
nan_detected = True
np.set_printoptions(threshold=np.nan) # Print the whole arrays
print '*** NaN detected ***'
print '--------------------------NODE DESCRIPTION:'
theano.printing.debugprint(node)
print '--------------------------Variables:'
print 'Inputs : %s' % [input[0] for input in fn.inputs]
print 'Outputs: %s' % [output[0] for output in fn.outputs]
break
if nan_detected:
exit()
def __init__(self, environment):
self.env = environment
self.algorithm = MGAIL(environment=self.env)
self.init_graph = tf.global_variables_initializer()
self.saver = tf.train.Saver()
self.sess = tf.Session()
if self.env.trained_model:
self.saver.restore(self.sess, self.env.trained_model)
else:
self.sess.run(self.init_graph)
self.run_dir = self.env.run_dir
self.loss = 999. * np.ones(3)
self.reward_mean = 0
self.reward_std = 0
self.run_avg = 0.001
self.discriminator_policy_switch = 0
self.policy_loop_time = 0
self.disc_acc = 0
self.er_count = 0
self.itr = 0
self.best_reward = 0
self.mode = 'Prep'
np.set_printoptions(precision=2)
np.set_printoptions(linewidth=220)
def update_target_text(self):
np.set_printoptions(precision=3, suppress=True)
text = (
'target number = %s\n' % str(self._target_number) +
'actuator name = %s\n' % str(self._actuator_name) +
'\ninitial position\n%s' % self.position_to_str(self._initial_position) +
'\ntarget position\n%s' % self.position_to_str(self._target_position) +
'\ninitial image (left) =\n%s\n' % str(self._initial_image) +
'\ntarget image (right) =\n%s\n' % str(self._target_image)
)
self._target_output.set_text(text)
if config['image_on']:
self._initial_image_visualizer.update(self._initial_image)
self._target_image_visualizer.update(self._target_image)
self._image_visualizer.set_initial_image(self._initial_image, alpha=0.3)
self._image_visualizer.set_target_image(self._target_image, alpha=0.3)
def encode(content, word_delimiter="|", tag_delimiter="/", num_step=60):
# Create corpus instance
corpus = Corpus(word_delimiter=word_delimiter, tag_delimiter=tag_delimiter)
# Add text to corpus
corpus.add_text(content)
# Create index for character and tag
char_index = index_builder(constant.CHARACTER_LIST,
constant.CHAR_START_INDEX)
tag_index = index_builder(constant.TAG_LIST, constant.TAG_START_INDEX)
# Generate input
inb = InputBuilder(corpus, char_index, tag_index, num_step, y_one_hot=False)
# Display encoded content
np.set_printoptions(threshold=np.inf)
print("[Input]")
print(inb.x)
print("[Label]")
print(inb.y)
def PrintSolution(self, Filename=None):
numpy.set_printoptions(linewidth=numpy.inf)
out = sys.stdout if (Filename == None) else open(Filename, 'w+')
out.write('Status: %s\n' % self.status)
out.write('Total Objective: %f\n' % self.value)
for ni in self.Nodes():
nid = ni.GetId()
s = 'Node %d:\n' % nid
out.write(s)
for (varID, varName, var, offset) in self.node_variables[nid]:
val = numpy.transpose(self.GetNodeValue(nid, varName))
s = ' %s %s\n' % (varName, str(val))
out.write(s)
# Helper method to verify existence of an NId.
def compute_mean(self, file_list):
logger = logging.getLogger("acoustic_norm")
mean_vector = numpy.zeros((1, self.feature_dimension))
all_frame_number = 0
io_funcs = BinaryIOCollection()
for file_name in file_list:
features = io_funcs.load_binary_file(file_name, self.feature_dimension)
current_frame_number = features.size / self.feature_dimension
mean_vector += numpy.reshape(numpy.sum(features, axis=0), (1, self.feature_dimension))
all_frame_number += current_frame_number
mean_vector /= float(all_frame_number)
# po=numpy.get_printoptions()
# numpy.set_printoptions(precision=2, threshold=20, linewidth=1000, edgeitems=4)
logger.info('computed mean vector of length %d :' % mean_vector.shape[1] )
logger.info(' mean: %s' % mean_vector)
# restore the print options
# numpy.set_printoptions(po)
return mean_vector
def compute_mean(self, file_list, start_index, end_index):
local_feature_dimension = end_index - start_index
mean_vector = numpy.zeros((1, local_feature_dimension))
all_frame_number = 0
io_funcs = BinaryIOCollection()
for file_name in file_list:
features, current_frame_number = io_funcs.load_binary_file_frame(file_name, self.feature_dimension)
mean_vector += numpy.reshape(numpy.sum(features[:, start_index:end_index], axis=0), (1, local_feature_dimension))
all_frame_number += current_frame_number
mean_vector /= float(all_frame_number)
# po=numpy.get_printoptions()
# numpy.set_printoptions(precision=2, threshold=20, linewidth=1000, edgeitems=4)
self.logger.info('computed mean vector of length %d :' % mean_vector.shape[1] )
self.logger.info(' mean: %s' % mean_vector)
# restore the print options
# numpy.set_printoptions(po)
return mean_vector
def test_formatter_reset(self):
x = np.arange(3)
np.set_printoptions(formatter={'all':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'int':None})
assert_equal(repr(x), "array([0, 1, 2])")
np.set_printoptions(formatter={'all':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'all':None})
assert_equal(repr(x), "array([0, 1, 2])")
np.set_printoptions(formatter={'int':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'int_kind':None})
assert_equal(repr(x), "array([0, 1, 2])")
x = np.arange(3.)
np.set_printoptions(formatter={'float':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1.0, 0.0, 1.0])")
np.set_printoptions(formatter={'float_kind':None})
assert_equal(repr(x), "array([ 0., 1., 2.])")
def pformat(obj, indent=0, depth=3):
if 'numpy' in sys.modules:
import numpy as np
print_options = np.get_printoptions()
np.set_printoptions(precision=6, threshold=64, edgeitems=1)
else:
print_options = None
out = pprint.pformat(obj, depth=depth, indent=indent)
if print_options:
np.set_printoptions(**print_options)
return out
###############################################################################
# class `Logger`
###############################################################################
def compute_mean(self, file_list):
logger = logging.getLogger("acoustic_norm")
mean_vector = numpy.zeros((1, self.feature_dimension))
all_frame_number = 0
io_funcs = BinaryIOCollection()
for file_name in file_list:
features = io_funcs.load_binary_file(file_name, self.feature_dimension)
current_frame_number = features.size / self.feature_dimension
mean_vector += numpy.reshape(numpy.sum(features, axis=0), (1, self.feature_dimension))
all_frame_number += current_frame_number
mean_vector /= float(all_frame_number)
# po=numpy.get_printoptions()
# numpy.set_printoptions(precision=2, threshold=20, linewidth=1000, edgeitems=4)
logger.info('computed mean vector of length %d :' % mean_vector.shape[1] )
logger.info(' mean: %s' % mean_vector)
# restore the print options
# numpy.set_printoptions(po)
return mean_vector
def compute_mean(self, file_list, start_index, end_index):
local_feature_dimension = end_index - start_index
mean_vector = numpy.zeros((1, local_feature_dimension))
all_frame_number = 0
io_funcs = BinaryIOCollection()
for file_name in file_list:
features, current_frame_number = io_funcs.load_binary_file_frame(file_name, self.feature_dimension)
mean_vector += numpy.reshape(numpy.sum(features[:, start_index:end_index], axis=0), (1, local_feature_dimension))
all_frame_number += current_frame_number
mean_vector /= float(all_frame_number)
# po=numpy.get_printoptions()
# numpy.set_printoptions(precision=2, threshold=20, linewidth=1000, edgeitems=4)
self.logger.info('computed mean vector of length %d :' % mean_vector.shape[1] )
self.logger.info(' mean: %s' % mean_vector)
# restore the print options
# numpy.set_printoptions(po)
return mean_vector
def test_fcc_conv(self):
# np.set_printoptions(threshold=2304, linewidth=145) # 48 * 48
filename = "../poscars/POSCAR_fcc"
atoms = read_vasp(filename)
symmetry = UnfolderSymmetry(atoms)
rotations = symmetry.get_pointgroup_operations()
check_irreps(rotations)
rotations = symmetry.get_group_of_wave_vector([0.00, 0.25, 0.25])[0]
check_irreps(rotations)
rotations = symmetry.get_group_of_wave_vector([0.25, 0.00, 0.25])[0]
check_irreps(rotations)
rotations = symmetry.get_group_of_wave_vector([0.25, 0.25, 0.00])[0]
check_irreps(rotations)
def test_formatter_reset(self):
x = np.arange(3)
np.set_printoptions(formatter={'all':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'int':None})
assert_equal(repr(x), "array([0, 1, 2])")
np.set_printoptions(formatter={'all':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'all':None})
assert_equal(repr(x), "array([0, 1, 2])")
np.set_printoptions(formatter={'int':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'int_kind':None})
assert_equal(repr(x), "array([0, 1, 2])")
x = np.arange(3.)
np.set_printoptions(formatter={'float':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1.0, 0.0, 1.0])")
np.set_printoptions(formatter={'float_kind':None})
assert_equal(repr(x), "array([ 0., 1., 2.])")
def update_target_text(self):
np.set_printoptions(precision=3, suppress=True)
text = (
'target number = %s\n' % str(self._target_number) +
'actuator name = %s\n' % str(self._actuator_name) +
'\ninitial position\n%s' % self.position_to_str(self._initial_position) +
'\ntarget position\n%s' % self.position_to_str(self._target_position) +
'\ninitial image (left) =\n%s\n' % str(self._initial_image) +
'\ntarget image (right) =\n%s\n' % str(self._target_image)
)
self._target_output.set_text(text)
if config['image_on']:
self._initial_image_visualizer.update(self._initial_image)
self._target_image_visualizer.update(self._target_image)
self._image_visualizer.set_initial_image(self._initial_image, alpha=0.3)
self._image_visualizer.set_target_image(self._target_image, alpha=0.3)
def main():
np.set_printoptions(suppress=True, precision=5, linewidth=1000)
phases = {
'0_sampletrajs': phase0_sampletrajs,
'1_train': phase1_train,
'2_eval': phase2_eval,
}
parser = argparse.ArgumentParser()
parser.add_argument('spec', type=str)
parser.add_argument('phase', choices=sorted(phases.keys()))
args = parser.parse_args()
with open(args.spec, 'r') as f:
spec = yaml.load(f)
phases[args.phase](spec, args.spec)
def export_collada(mesh):
'''
Export a mesh as a COLLADA file.
'''
from ..templates import get_template
from string import Template
template_string = get_template('collada.dae.template')
template = Template(template_string)
# we bother setting this because np.array2string uses these printoptions
np.set_printoptions(threshold=np.inf, precision=5, linewidth=np.inf)
replacement = dict()
replacement['VERTEX'] = np.array2string(mesh.vertices.reshape(-1))[1:-1]
replacement['FACES'] = np.array2string(mesh.faces.reshape(-1))[1:-1]
replacement['NORMALS'] = np.array2string(mesh.vertex_normals.reshape(-1))[1:-1]
replacement['VCOUNT'] = str(len(mesh.vertices))
replacement['VCOUNTX3'] = str(len(mesh.vertices) * 3)
replacement['FCOUNT'] = str(len(mesh.faces))
export = template.substitute(replacement)
return export
def ACO(self, df):
"""
Helper indicator
:param df:
:return:
"""
df_mid_points = (df['High'] + df['Low']) / 2
mid_points = Data.toFloatArray(df_mid_points)
longav = tl.SMA(np.array(mid_points), timeperiod=40)
shortav = tl.SMA(np.array(mid_points), timeperiod=15)
A0 = longav - shortav
Mavg = tl.SMA(A0, timeperiod=15)
AcResult = tl.SMA(Mavg - A0, timeperiod=15)
signals = np.diff(AcResult)
return signals
# if __name__ == "__main__":
# np.set_printoptions(threshold=np.nan)
# pd.set_option("display.max_rows", 280)
# dt = Data()
# df = dt.getCSVData()
# #ACOscillator(df)
# ACOscillator(df)
def main():
# model_file = "../data/word2vec/character.model"
model_file = "../data/word2vec_new/word.model"
checkSimilarity(model_file, "?")
# character_wv_file = '../data/word2vec/character_model.txt'
# word_wv_file = '../data/word2vec/word_model.txt'
#
# embeddings_file = word_wv_file
# wv, vocabulary = load_embeddings(embeddings_file)
#
# tsne = TSNE(n_components=2, random_state=0)
# np.set_printoptions(suppress=True)
# Y = tsne.fit_transform(wv[:1000, :])
#
# plt.scatter(Y[:, 0], Y[:, 1])
# for label, x, y in zip(vocabulary, Y[:, 0], Y[:, 1]):
# plt.annotate(label, xy=(x, y), xytext=(0, 0), textcoords='offset points')
# plt.show()
def test_formatter_reset(self):
x = np.arange(3)
np.set_printoptions(formatter={'all':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'int':None})
assert_equal(repr(x), "array([0, 1, 2])")
np.set_printoptions(formatter={'all':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'all':None})
assert_equal(repr(x), "array([0, 1, 2])")
np.set_printoptions(formatter={'int':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'int_kind':None})
assert_equal(repr(x), "array([0, 1, 2])")
x = np.arange(3.)
np.set_printoptions(formatter={'float':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1.0, 0.0, 1.0])")
np.set_printoptions(formatter={'float_kind':None})
assert_equal(repr(x), "array([ 0., 1., 2.])")
def grad_nan_report(grads, tparams):
numpy.set_printoptions(precision=3)
D = OrderedDict()
i = 0
NaN_keys = []
magnitude = []
assert len(grads) == len(tparams)
for k, v in tparams.iteritems():
grad = grads[i]
magnitude.append(numpy.abs(grad).mean())
if numpy.isnan(grad.sum()):
NaN_keys.append(k)
#assert v.get_value().shape == grad.shape
D[k] = grad
i += 1
#norm = [numpy.sqrt(numpy.sum(grad**2)) for grad in grads]
#print '\tgrad mean(abs(x))', numpy.array(magnitude)
return D, NaN_keys
def test_formatter_reset(self):
x = np.arange(3)
np.set_printoptions(formatter={'all':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'int':None})
assert_equal(repr(x), "array([0, 1, 2])")
np.set_printoptions(formatter={'all':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'all':None})
assert_equal(repr(x), "array([0, 1, 2])")
np.set_printoptions(formatter={'int':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1, 0, 1])")
np.set_printoptions(formatter={'int_kind':None})
assert_equal(repr(x), "array([0, 1, 2])")
x = np.arange(3.)
np.set_printoptions(formatter={'float':lambda x: str(x-1)})
assert_equal(repr(x), "array([-1.0, 0.0, 1.0])")
np.set_printoptions(formatter={'float_kind':None})
assert_equal(repr(x), "array([ 0., 1., 2.])")
def pformat(obj, indent=0, depth=3):
if 'numpy' in sys.modules:
import numpy as np
print_options = np.get_printoptions()
np.set_printoptions(precision=6, threshold=64, edgeitems=1)
else:
print_options = None
out = pprint.pformat(obj, depth=depth, indent=indent)
if print_options:
np.set_printoptions(**print_options)
return out
###############################################################################
# class `Logger`
###############################################################################
def plot_swap_subject_cm(swappy,title,name):
from sklearn.metrics import confusion_matrix
import numpy as np
subs = swappy.exportSubjectData()
labs = getLabelReal(subs)
# Compute confusion matrix
cnf_matrix = confusion_matrix(labs['actual'], labs['predicted'])
np.set_printoptions(precision=2)
plt.figure()
plot_confusion_matrix(cnf_matrix, classes=['Bogus','Real'],
normalize=False,
title=title)
plt.savefig(name)
plt.show()
#import pandas as pd
#ps = pd.Series([(labs['actual'][x],labs['predicted'][x]) for x in range(0, len(labs['actual']))])
#counts = ps.value_counts()
#counts
def np_printoptions(**kwargs):
"""Context manager to temporarily set numpy print options."""
old = np.get_printoptions()
np.set_printoptions(**kwargs)
yield
np.set_printoptions(**old)
def _nn_pose_fill(valid):
"""
Looks up closest True for each False and returns
indices for fill-in-lookup
In: [True, False, True, ... , False, True]
Out: [0, 0, 2, ..., 212, 212]
"""
valid_inds, = np.where(valid)
invalid_inds, = np.where(~valid)
all_inds = np.arange(len(valid))
all_inds[invalid_inds] = -1
for j in range(10):
fwd_inds = valid_inds + j
bwd_inds = valid_inds - j
# Forward fill
invalid_inds, = np.where(all_inds < 0)
fwd_fill_inds = np.intersect1d(fwd_inds, invalid_inds)
all_inds[fwd_fill_inds] = all_inds[fwd_fill_inds-j]
# Backward fill
invalid_inds, = np.where(all_inds < 0)
if not len(invalid_inds): break
bwd_fill_inds = np.intersect1d(bwd_inds, invalid_inds)
all_inds[bwd_fill_inds] = all_inds[bwd_fill_inds+j]
# Check if any missing
invalid_inds, = np.where(all_inds < 0)
if not len(invalid_inds): break
# np.set_printoptions(threshold=np.nan)
# print valid.astype(np.int)
# print np.array_str(all_inds)
# print np.where(all_inds < 0)
return all_inds
def save_results(save_dict=None, **kwargs):
np.set_printoptions(precision=2,threshold=np.nan)
if save_dict==None:
save_dict=kwargs
for key in save_dict.keys():
save_dict[key] = str(save_dict[key])
np.set_printoptions(precision=2,threshold=1000)
append_json('experiments.json', save_dict)
jsondict2csv('experiments.json', 'experiments.csv')
def run_model(model):
'''Train model'''
# Call global variables
x_train, x_test, y_train, y_test = X_TRAIN, X_TEST, Y_TRAIN, Y_TEST
model.fit(x_train, y_train)
# make predictions for test data
y_pred = model.predict(x_test)
# Accuracy
acc = metrics.accuracy_score(y_test, y_pred)
print('Accuracy: %.2f%%' % (acc * 100.0))
# F1_score
# f1_score = metrics.f1_score(y_test, y_pred)
# print("F1_score: %.2f%%" % (f1_score * 100.0))
# AUC of ROC
fpr, tpr, _ = metrics.roc_curve(y_test, y_pred)
auc = metrics.auc(fpr, tpr)
print('AUC: %.3f' % (auc))
# Logs for each fold
crossvalidation_acc.append(acc)
crossvalidation_auc.append(auc)
if ARGS.m:
cnf_matrix = confusion_matrix(y_test, y_pred)
print(cnf_matrix)
np.set_printoptions(precision=2)
if ARGS.t == '2':
classes = np.asarray(['Spiced', 'Non-spliced'])
plot_confusion_matrix(cnf_matrix, classes=classes, normalize=True)
elif ARGS.t == '3':
classes = np.asarray(['Low', 'Medium', 'High'])
plot_confusion_matrix(cnf_matrix, classes=classes, normalize=True)
plt.show()
if ARGS.f:
feature_selection(imp=IMP, model=model)
print()
def __init__(self, model, filename, mcmc=default_mcmc, headers=1,
ph_units="mrad", cc_modes=2, decomp_poly=4, c_exp=1.0,
log_min_tau=-3, guess_noise=False, keep_traces=False,
ccdt_priors='auto', ccdt_cfg=None):
self.model = model
self.filename = filename
self.mcmc = mcmc
self.headers = headers
self.ph_units = ph_units
self.cc_modes = cc_modes
self.decomp_poly = decomp_poly
self.c_exp = c_exp
self.log_min_tau = log_min_tau
self.guess_noise = guess_noise
self.keep_traces = keep_traces
self.ccd_priors = ccdt_priors
self.ccdtools_config = ccdt_cfg
if model == "CCD":
if self.ccd_priors == 'auto':
self.ccd_priors = self.get_ccd_priors(config=self.ccdtools_config)
print("\nUpdated CCD priors with new data")
self.start()
# def print_resul(self):
# #==============================================================================
# # Impression des résultats
# pm, model, filename = self.pm, self.model, self.filename
# print('\n\nInversion success!')
# print('Name of file:', filename)
# print('Model used:', model)
# e_keys = sorted([s for s in list(pm.keys()) if "_std" in s])
# v_keys = [e.replace("_std", "") for e in e_keys]
# labels = ["{:<8}".format(x+":") for x in v_keys]
# np.set_printoptions(formatter={'float': lambda x: format(x, '6.3E')})
# for l, v, e in zip(labels, v_keys, e_keys):
# print(l, pm[v], '+/-', pm[e], np.char.mod('(%.2f%%)',abs(100*pm[e]/pm[v])))
def __init__(self, model, filename, mcmc=default_mcmc, headers=1,
ph_units="mrad", cc_modes=2, decomp_poly=4, c_exp=1.0,
log_min_tau=-3, guess_noise=False, keep_traces=False,
ccdt_priors='auto', ccdt_cfg=None):
self.model = model
self.filename = filename
self.mcmc = mcmc
self.headers = headers
self.ph_units = ph_units
self.cc_modes = cc_modes
self.decomp_poly = decomp_poly
self.c_exp = c_exp
self.log_min_tau = log_min_tau
self.guess_noise = guess_noise
self.keep_traces = keep_traces
self.ccd_priors = ccdt_priors
self.ccdtools_config = ccdt_cfg
if model == "CCD":
if self.ccd_priors == 'auto':
self.ccd_priors = self.get_ccd_priors(config=self.ccdtools_config)
print("\nUpdated CCD priors with new data")
self.start()
# def print_resul(self):
# #==============================================================================
# # Impression des résultats
# pm, model, filename = self.pm, self.model, self.filename
# print('\n\nInversion success!')
# print('Name of file:', filename)
# print('Model used:', model)
# e_keys = sorted([s for s in list(pm.keys()) if "_std" in s])
# v_keys = [e.replace("_std", "") for e in e_keys]
# labels = ["{:<8}".format(x+":") for x in v_keys]
# np.set_printoptions(formatter={'float': lambda x: format(x, '6.3E')})
# for l, v, e in zip(labels, v_keys, e_keys):
# print(l, pm[v], '+/-', pm[e], np.char.mod('(%.2f%%)',abs(100*pm[e]/pm[v])))
def plot_tsne(doc_codes, doc_labels, classes_to_visual, save_file):
# markers = ["D", "p", "*", "s", "d", "8", "^", "H", "v", ">", "<", "h", "|"]
markers = ["o", "v", "8", "s", "p", "*", "h", "H", "+", "x", "D"]
plt.rc('legend',**{'fontsize':30})
classes_to_visual = list(set(classes_to_visual))
C = len(classes_to_visual)
while True:
if C <= len(markers):
break
markers += markers
class_ids = dict(zip(classes_to_visual, range(C)))
if isinstance(doc_codes, dict) and isinstance(doc_labels, dict):
codes, labels = zip(*[(code, doc_labels[doc]) for doc, code in doc_codes.items() if doc_labels[doc] in classes_to_visual])
else:
codes, labels = doc_codes, doc_labels
X = np.r_[list(codes)]
tsne = TSNE(perplexity=30, n_components=2, init='pca', n_iter=5000)
np.set_printoptions(suppress=True)
X = tsne.fit_transform(X)
plt.figure(figsize=(10, 10), facecolor='white')
for c in classes_to_visual:
idx = np.array(labels) == c
# idx = get_indices(labels, c)
plt.plot(X[idx, 0], X[idx, 1], linestyle='None', alpha=1, marker=markers[class_ids[c]],
markersize=10, label=c)
legend = plt.legend(loc='upper right', shadow=True)
# plt.title("tsne")
# plt.savefig(save_file)
plt.savefig(save_file, format='eps', dpi=2000)
plt.show()
def plot_tsne_3d(doc_codes, doc_labels, classes_to_visual, save_file, maker_size=None, opaque=None):
markers = ["D", "p", "*", "s", "d", "8", "^", "H", "v", ">", "<", "h", "|"]
plt.rc('legend',**{'fontsize':20})
colors = ['r', 'b', 'g', 'c', 'm', 'y', 'k']
C = len(classes_to_visual)
while True:
if C <= len(markers):
break
markers += markers
while True:
if C <= len(colors):
break
colors += colors
class_ids = dict(zip(classes_to_visual, range(C)))
if isinstance(doc_codes, dict) and isinstance(doc_labels, dict):
codes, labels = zip(*[(code, doc_labels[doc]) for doc, code in doc_codes.items() if doc_labels[doc] in classes_to_visual])
else:
codes, labels = doc_codes, doc_labels
X = np.r_[list(codes)]
tsne = TSNE(perplexity=30, n_components=3, init='pca', n_iter=5000)
np.set_printoptions(suppress=True)
X = tsne.fit_transform(X)
fig = plt.figure(figsize=(10, 10), facecolor='white')
ax = fig.add_subplot(111, projection='3d')
# The problem is that the legend function don't support the type returned by a 3D scatter.
# So you have to create a "dummy plot" with the same characteristics and put those in the legend.
scatter_proxy = []
for i in range(C):
cls = classes_to_visual[i]
idx = np.array(labels) == cls
ax.scatter(X[idx, 0], X[idx, 1], X[idx, 2], c=colors[i], alpha=opaque[i] if opaque else 1, s=maker_size[i] if maker_size else 20, marker=markers[i], label=cls)
scatter_proxy.append(mpl.lines.Line2D([0],[0], linestyle="none", c=colors[i], marker=markers[i], label=cls))
ax.legend(scatter_proxy, classes_to_visual, numpoints=1)
plt.savefig(save_file)
plt.show()
def DBN_plot_tsne(doc_codes, doc_labels, classes_to_visual, save_file):
markers = ["o", "v", "8", "s", "p", "*", "h", "H", "+", "x", "D"]
C = len(classes_to_visual)
while True:
if C <= len(markers):
break
markers += markers
class_ids = dict(zip(classes_to_visual.keys(), range(C)))
codes, labels = doc_codes, doc_labels
X = np.r_[list(codes)]
tsne = TSNE(perplexity=30, n_components=2, init='pca', n_iter=5000)
np.set_printoptions(suppress=True)
X = tsne.fit_transform(X)
plt.figure(figsize=(10, 10), facecolor='white')
for c in classes_to_visual.keys():
idx = np.array(labels) == c
# idx = get_indices(labels, c)
plt.plot(X[idx, 0], X[idx, 1], linestyle='None', alpha=0.6, marker=markers[class_ids[c]],
markersize=6, label=classes_to_visual[c])
legend = plt.legend(loc='upper center', shadow=True)
plt.title("tsne")
plt.savefig(save_file)
plt.show()
def reuters_visualize_tsne(doc_codes, doc_labels, classes_to_visual, save_file):
"""
Visualize the input data on a 2D PCA plot. Depending on the number of components,
the plot will contain an X amount of subplots.
@param doc_codes:
@param number_of_components: The number of principal components for the PCA plot.
"""
# markers = ["p", "s", "h", "H", "+", "x", "D"]
markers = ["o", "v", "8", "s", "p", "*", "h", "H", "+", "x", "D"]
C = len(classes_to_visual)
while True:
if C <= len(markers):
break
markers += markers
class_names = classes_to_visual.keys()
class_ids = dict(zip(class_names, range(C)))
class_names = set(class_names)
codes, labels = zip(*[(code, doc_labels[doc]) for doc, code in doc_codes.items() if class_names.intersection(set(doc_labels[doc]))])
X = np.r_[list(codes)]
tsne = TSNE(perplexity=30, n_components=2, init='pca', n_iter=5000)
np.set_printoptions(suppress=True)
X = tsne.fit_transform(X)
plt.figure(figsize=(10, 10), facecolor='white')
for c in classes_to_visual.keys():
idx = get_indices(labels, c)
plt.plot(X[idx, 0], X[idx, 1], linestyle='None', alpha=0.6, marker=markers[class_ids[c]],
markersize=6, label=classes_to_visual[c])
legend = plt.legend(loc='upper center', shadow=True)
plt.title("tsne")
plt.savefig(save_file)
plt.show()
def main():
# Collect the user arguments and hyper parameters
args, hyper_params = get_args_and_hyperparameters()
np.set_printoptions( precision=8, suppress=True, edgeitems=6, threshold=2048)
# setup the CPU or GPU backend
be = gen_backend(**extract_valid_args(args, gen_backend))
# load the training dataset. This will download the dataset from the web and cache it
# locally for subsequent use.
train_set = MultiscaleSampler('trainval', '2007', samples_per_img=hyper_params.samples_per_img,
sample_height=224, path=args.data_dir,
samples_per_batch=hyper_params.samples_per_batch,
max_imgs = hyper_params.max_train_imgs,
shuffle = hyper_params.shuffle)
# create the model by replacing the classification layer of AlexNet with
# new adaptation layers
model, opt = create_model( args, hyper_params)
# Seed the Alexnet conv layers with pre-trained weights
if args.model_file is None and hyper_params.use_pre_trained_weights:
load_imagenet_weights(model, args.data_dir)
train( args, hyper_params, model, opt, train_set)
# Load the test dataset. This will download the dataset from the web and cache it
# locally for subsequent use.
test_set = MultiscaleSampler('test', '2007', samples_per_img=hyper_params.samples_per_img,
sample_height=224, path=args.data_dir,
samples_per_batch=hyper_params.samples_per_batch,
max_imgs = hyper_params.max_test_imgs,
shuffle = hyper_params.shuffle)
test( args, hyper_params, model, test_set)
return
# parse the command line arguments
def trainer(model_params):
"""Train a sketch-rnn model."""
np.set_printoptions(precision=8, edgeitems=6, linewidth=200, suppress=True)
tf.logging.info('sketch-rnn')
tf.logging.info('Hyperparams:')
for key, val in model_params.values().iteritems():
tf.logging.info('%s = %s', key, str(val))
tf.logging.info('Loading data files.')
datasets = load_dataset(FLAGS.data_dir, model_params)
train_set = datasets[0]
valid_set = datasets[1]
test_set = datasets[2]
model_params = datasets[3]
eval_model_params = datasets[4]
reset_graph()
model = sketch_rnn_model.Model(model_params)
eval_model = sketch_rnn_model.Model(eval_model_params, reuse=True)
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())
if FLAGS.resume_training:
load_checkpoint(sess, FLAGS.log_root)
# Write config file to json file.
tf.gfile.MakeDirs(FLAGS.log_root)
with tf.gfile.Open(
os.path.join(FLAGS.log_root, 'model_config.json'), 'w') as f:
json.dump(model_params.values(), f, indent=True)
train(sess, model, eval_model, train_set, valid_set, test_set)
def plot_confusion_matrix(cm, classes,
normalize=False,
title='Confusion matrix',
cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
"""
np.set_printoptions(precision=2)
plt.figure()
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
logger.info("Normalized confusion matrix")
else:
logger.info('Confusion matrix, without normalization')
logger.info(cm)
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, cm[i, j],
horizontalalignment="center",
color="white" if cm[i, j] > thresh else "black")
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
plt.show()
def __init__(self, n_hidden=10, max_iter=10000, tol=1e-5, anneal=True, missing_values=None,
discourage_overlap=True, gaussianize='standard', gpu=False,
verbose=False, seed=None):
self.m = n_hidden # Number of latent factors to learn
self.max_iter = max_iter # Number of iterations to try
self.tol = tol # Threshold for convergence
self.anneal = anneal
self.eps = 0 # If anneal is True, it's adjusted during optimization to avoid local minima
self.missing_values = missing_values
self.discourage_overlap = discourage_overlap # Whether or not to discourage overlapping latent factors
self.gaussianize = gaussianize # Preprocess data: 'standard' scales to zero mean and unit variance
self.gpu = gpu # Enable GPU support for some large matrix multiplications.
if self.gpu:
cm.cublas_init()
self.yscale = 1. # Can be arbitrary, but sets the scale of Y
np.random.seed(seed) # Set seed for deterministic results
self.verbose = verbose
if verbose:
np.set_printoptions(precision=3, suppress=True, linewidth=160)
print(('Linear CorEx with {:d} latent factors'.format(n_hidden)))
# Initialize these when we fit on data
self.n_samples, self.nv = 0, 0 # Number of samples/variables in input data
self.ws = np.zeros((0, 0)) # m by nv array of weights
self.moments = {} # Dictionary of moments
self.theta = None # Parameters for preprocessing each variable
self.history = {} # Keep track of values for each iteration
self.last_update = 0 # Used for momentum methods