prompt
stringlengths 19
879k
| completion
stringlengths 3
53.8k
| api
stringlengths 8
59
|
|---|---|---|
"""
This file is part of the MaternGaBO library.
Authors: <NAME> and <NAME>, 2021
License: MIT
Contact: <EMAIL>, <EMAIL>
"""
import numpy as np
from BoManifolds.Riemannian_utils.spd_utils import vector_to_symmetric_matrix_mandel
def min_eigenvalue_constraint(x_vec, min_eigenvalue):
"""
This function defines an inequality constraint on the minimum eigenvalue of a SPD matrix.
The value returned by the function is positive if the inequality constraints is satisfied.
Parameters
----------
:param x_vec: SPD matrix in Mandel vector form
:param min_eigenvalue: minimum eigenvalue to satisfy the constraint
Returns
-------
:return: difference between minimum eigenvalue of x and minimum tolerated eigenvalue
"""
x = vector_to_symmetric_matrix_mandel(x_vec)
eigenvalues = np.linalg.eigvals(x)
return np.min(eigenvalues) - min_eigenvalue
def max_eigenvalue_constraint(x_vec, max_eigenvalue):
"""
This function defines an inequality constraint on the maximum eigenvalue of a SPD matrix.
The value returned by the function is positive if the inequality constraints is satisfied.
Parameters
----------
:param x_vec: SPD matrix in Mandel vector form
:param max_eigenvalue: maximum eigenvalue to satisfy the constraint
Returns
-------
:return: difference between maximum tolerated eigenvalue and maximum eigenvalue of x
"""
x = vector_to_symmetric_matrix_mandel(x_vec)
eigenvalues = | np.linalg.eigvals(x) | numpy.linalg.eigvals |
import numpy as np
"""
basic implementation of Recurrent Neural Networks from scrach
to train model to learn to add any number pair when given in binary arrayed format
devloper--><NAME>
"""
class RecurrentNeuralNetwork:
def __init__(self,hidden_size=10):
"""hidden_size is number of neurons in hidden layer"""
self.hidden_size=hidden_size
self.activation={"sigmoid":(self.sigmoid,self.sig_grad),
"RELU":(self.RELU,self.RELU_grad),
"tanh":(self.tanh,self.tanh_grad)}
def fit(self,X,Y):
"""input your training dataset
X: input array 3D
Y: output arrray 3D
axis0- number of data data
axis1 -oredered steps(time steps) of data
axis2- input array for each step"""
#add a slot for threshold weight in each inputs
X=np.append(X,np.ones((X.shape[0],X.shape[1],1)),axis=2)
# store sizes of datasets
self.input_size=X.shape[2]
self.output_size=Y.shape[2]
self.X=X
self.Y=Y
def tanh(self,x):
"""for hyperbolic tangent activation"""
return | np.tanh(x) | numpy.tanh |
from skfda import FDataGrid, FDataBasis
from skfda.datasets import fetch_weather
from skfda.misc.operators import LinearDifferentialOperator
from skfda.misc.regularization import TikhonovRegularization
from skfda.preprocessing.dim_reduction.projection import FPCA
from skfda.representation.basis import Fourier
import unittest
import numpy as np
class FPCATestCase(unittest.TestCase):
def test_basis_fpca_fit_attributes(self):
fpca = FPCA()
with self.assertRaises(AttributeError):
fpca.fit(None)
basis = Fourier(n_basis=1)
# check that if n_components is bigger than the number of samples then
# an exception should be thrown
fd = FDataBasis(basis, [[0.9]])
with self.assertRaises(AttributeError):
fpca.fit(fd)
# check that n_components must be smaller than the number of elements
# of target basis
fd = FDataBasis(basis, [[0.9], [0.7], [0.5]])
with self.assertRaises(AttributeError):
fpca.fit(fd)
def test_discretized_fpca_fit_attributes(self):
fpca = FPCA()
with self.assertRaises(AttributeError):
fpca.fit(None)
# check that if n_components is bigger than the number of samples then
# an exception should be thrown
fd = FDataGrid([[0.5], [0.1]], sample_points=[0])
with self.assertRaises(AttributeError):
fpca.fit(fd)
# check that n_components must be smaller than the number of attributes
# in the FDataGrid object
fd = FDataGrid([[0.9], [0.7], [0.5]], sample_points=[0])
with self.assertRaises(AttributeError):
fpca.fit(fd)
def test_basis_fpca_fit_result(self):
n_basis = 9
n_components = 3
fd_data = fetch_weather()['data'].coordinates[0]
fd_data = FDataGrid( | np.squeeze(fd_data.data_matrix) | numpy.squeeze |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri May 7 13:06:21 2021
Core code obtained from <NAME>, Barnhart Lab
Class structure and relative imports from Ike Ogbonna, Barnhart Lab
@author: ike
"""
import io
from PIL import Image, ImageSequence
from glob import glob
import numpy as np
import os.path as op
import seaborn as sns
import scipy.ndimage as scn
import skimage.measure as skm
import matplotlib.pyplot as plt
from .pathutils import getPath, changeExt, makeParentDirectory
class MultipageTiff(object):
figures = list()
def __init__(self, imagePages):
if (type(imagePages) == str) and op.isdir(imagePages):
imagePages = glob(getPath(imagePages, "*", ext="tif"))
elif (type(imagePages) == list) and (len(imagePages) == 1):
imagePages = imagePages[0]
if type(imagePages) == str:
multipage = Image.open(imagePages)
self.imageArray = np.array(
[np.array(page) for page in ImageSequence.Iterator(multipage)],
dtype=np.uint8)
elif type(imagePages) == list:
self.imageArray = np.array(
[self.getImage(imageFile) for imageFile in sorted(imagePages)],
dtype=np.uint8)
else:
raise ValueError ("Trying to make an empty image")
@staticmethod
def getImage(imageFile, mask=False):
image = (np.array(Image.open(imageFile)) > 0).astype(int)
image = (np.ma.masked_equal(image, 0) if mask else image)
return image
@staticmethod
def unit8Image(image, normalize=False):
image = image + abs(min(0, np.min(image)))
oldMax = (np.max(image) if np.max(image) != 0 else 1)
newMax = (255 if normalize else min(np.max(image), 255))
image = np.rint((image / oldMax) * newMax).astype(np.uint8)
return image
@staticmethod
def savePillowArray(pilArray, saveFile):
saveFile = changeExt(saveFile, ext="tif")
makeParentDirectory(saveFile)
pilArray[0].save(
saveFile, compression="tiff_deflate",
save_all=True, append_images=pilArray[1:])
@classmethod
def saveImage(cls, image, save, normalize=False):
if image.dtype != "uint8" or normalize:
image = cls.unit8Image(image, normalize)
image = Image.fromarray(image, mode="L")
save = changeExt(save, ext="tif")
image.save(save, compression="tiff_deflate")
@classmethod
def addFigure(
cls, Y, name, yLabel, color="gray", axLabel=None, X=None, dY=None,
lightOn=None, bkg=None):
fig, ax = plt.subplots(figsize=(4, 3), dpi=300)
sns.set_theme(font_scale=0.5)
sns.set_style("ticks")
sns.despine()
X = (list(range(1, Y.shape[0] + 1)) if X is None else X)
if bkg is not None:
ax.plot(X, bkg, color="black", label="background")
if type(color) == list:
for x in range(len(color)):
ax.plot(X, Y[x], color=color[x], label=yLabel[x])
else:
ax.plot(X, Y, color=color, label=yLabel)
ax.set_title(name)
if axLabel is not None:
ax.set_xlabel(axLabel[0])
ax.set_ylabel(axLabel[1])
if dY is not None:
ax.fill_between(X, (Y - dY), (Y + dY), color=color, alpha=0.2)
if lightOn is not None:
plt.axvspan(
lightOn[0], lightOn[1], color="blue", lw=1, alpha=0.1)
ax.legend(loc="upper right")
ax.locator_params(axis="x", nbins=10)
ax.locator_params(axis="y", nbins=6)
ax.set_xlim(left=float(X[0]), right=float(X[-1]))
# ax.set_ylim(bottom=np.min(Y), top=np.max(Y))
# ax.spines['left'].set_position("zero")
# if bkg is not None:
# ax.spines['bottom'].set_position("zero")
buffer = io.BytesIO()
fig.savefig(buffer)
buffer.seek(0)
cls.figures += [Image.open(buffer)]
plt.close("all")
@classmethod
def saveFigures(cls, saveFile):
if len(cls.figures) != 0:
cls.savePillowArray(cls.figures, saveFile)
cls.figures = list()
def __len__(self):
return self.imageArray.shape[0]
def __add__(self, other):
if not isinstance(other, MultipageTiff):
return self
y = min(self.imageArray.shape[1], other.imageArray.shape[1])
x = min(self.imageArray.shape[2], other.imageArray.shape[2])
self.imageArray = np.concatenate(
(self.imageArray[:, :y, :x], other.imageArray[:, :y, :x]),
axis=0)
return self
def __radd__(self, other):
return self + other
def __getitem__(self, idx):
return self.imageArray[idx]
def __setitem__(self, idx, value):
self.imageArray[idx] = value
def __call__(self, other, mode):
if (not isinstance(other, MultipageTiff) or
(self.imageArray.shape[1:] != other.imageArray.shape[1:])):
pass
elif mode == "concatenate":
self.imageArray = np.concatenate(
(self.imageArray, other.imageArray), axis=0)
elif mode == "sum":
idx = min(self.imageArray.shape[0], other.imageArray.shape[0])
self.imageArray = self.imageArray[:idx] + other.imageArray[:idx]
return self
def averageProjection(self):
averageProjection = | np.mean(self.imageArray, axis=0) | numpy.mean |
import logging
import math
import os
import shutil
import time
import cv2
import imageio
import numpy as np
import scipy.sparse
import tensorflow as tf
import utils
from lib import graph, mesh_renderer
from lib.mesh_io import write_obj
logger = logging.getLogger('x')
class BaseModel():
"""
Mesh Convolutional Autoencoder which uses the Chebyshev approximation.
"""
def __init__(self, args, sess, graphs, refer_mesh, image_paths, img_file):
self.sess = sess
self.graph = graphs
mesh_shape = list(refer_mesh['vertices'].shape)
self.gan = args.gan
self.wide = args.wide
self.root_dir = args.root_dir
self.img_file = img_file
self.stage = args.stage
if args.mode == 'test':
self.restore = True
else:
self.restore = args.restore
self.laplacians, self.downsamp_trans, self.upsamp_trans, self.pool_size = utils.init_sampling(
refer_mesh, os.path.join(args.root_dir, 'data', 'params', args.name), args.name)
logger.info("Transform Matrices and Graph Laplacians Generated.")
self.refer_meshes = utils.get_mesh_list(args.name)
self.bfm = utils.BFM_model(self.root_dir, 'data/bfm2009_face.mat')
# color = np.ones_like(refer_mesh['vertices'], dtype=np.uint8)
# color[self.bfm.skin_index] = 0
# write_obj('tests.obj', refer_mesh['vertices'], refer_mesh['faces'], color)
# write_obj('test.obj', refer_mesh['vertices'], refer_mesh['faces'], color)
self.buffer_size = args.buffer_size
self.workers = args.workers
self.num_filter = [16, 16, 16, 32]
self.c_k = 6
self.cam_z = 34
self.z_dim = args.nz
self.num_vert = mesh_shape[0]
self.vert_dim = 6
self.drop_rate = args.drop_rate
self.batch_size = args.batch_size
self.num_epochs = args.epoch
self.img_size = args.img_size
self.learning_rate = args.lr
self.adv_lambda = args.adv_lambda
if args.suffix is None:
self.dir_name = args.name
else:
self.dir_name = args.name + '_' + args.suffix
self.brelu = self.b1relu
self.pool = self.poolwT
self.unpool = self.poolwT
self.dilation_kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,
(5, 5)).astype(np.float32)[..., np.newaxis]
self.erosion_kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,
(9, 9)).astype(np.float32)[..., np.newaxis]
# lm_3d_idx = [
# int(x)
# for x in open('data/face_landmarks.txt', 'r').readlines()
# if len(x.strip()) > 1
# ]
# # self.lm_3d_idx = lm_3d_idx[8:9] + lm_3d_idx[17:]
# self.lm_3d_idx = lm_3d_idx[17:]
self.lm_3d_idx = self.bfm.landmark[17:]
train_image_paths, self.val_image_paths, self.test_image_paths = utils.make_paths(
image_paths, os.path.join(self.root_dir, 'data', 'params', args.name, 'image'),
self.root_dir)
self.train_image_paths = np.array(train_image_paths, dtype='object')
num_train = len(self.train_image_paths)
logger.info('Number of train data: %d', num_train)
self.num_batches = num_train // self.batch_size
if args.eval == 0:
self.eval_frequency = self.num_batches
elif args.eval < 1:
self.eval_frequency = int(self.num_batches * args.eval)
else:
self.eval_frequency = int(args.eval)
logger.info('Evaluation frequency: %d', self.eval_frequency)
self.vert_mean = np.reshape(self.bfm.shapeMU, [-1, 3])
self.decay_steps = num_train // args.batch_size
self.regularizers = []
self.regularization = 5e-4
self.ckpt_dir = os.path.join('checkpoints', self.dir_name)
self.summ_dir = os.path.join('summaries', self.dir_name)
self.samp_dir = os.path.join('samples', self.dir_name)
self.build_graph()
def build_graph(self):
"""Build the computational graph of the model."""
# self.graph = tf.Graph()
# with self.graph.as_default():
# Inputs.
with tf.name_scope('inputs'):
data_idxs = [x for x in range(len(self.train_image_paths))]
image_dataset = tf.data.Dataset.from_tensor_slices(data_idxs)
# image_dataset = image_dataset.map(
# lambda start_idx: tf.py_func(self.load_image_bin, [start_idx], [tf.float32, tf.float32]))
image_dataset = image_dataset.map(
lambda start_idx: tf.py_func(self.load_image_bin, [start_idx], tf.float32))
image_dataset = image_dataset.shuffle(buffer_size=self.buffer_size)
image_dataset = image_dataset.batch(self.batch_size)
image_dataset = image_dataset.repeat()
image_iterator = image_dataset.make_one_shot_iterator()
# self.train_rgbas, self.train_2dlms = image_iterator.get_next()
self.train_rgbas = image_iterator.get_next()
self.train_rgbas.set_shape([self.batch_size, self.img_size, self.img_size, 4])
self.train_images = (self.train_rgbas[..., :3] + 1) * 127.5
# self.train_2dlms.set_shape([self.batch_size, len(self.lm_3d_idx), 2])
self.refer_faces = [
tf.convert_to_tensor(x['faces'], dtype=tf.int32, name='refer_faces_{}'.format(i))
for i, x in enumerate(self.refer_meshes)
]
self.ph_rgbas = tf.placeholder(tf.float32, (self.batch_size, self.img_size, self.img_size, 4),
'input_rgbas')
self.input_images = (self.ph_rgbas[..., :3] + 1) * 127.5
# self.input_images = tf.floor((self.ph_rgbas[..., 2::-1] + 1) * 127.5)
self.ph_2dlms = tf.placeholder(tf.float32, (self.batch_size, len(self.lm_3d_idx), 2),
'input_2dlm')
self.ph_ren_lambda = tf.placeholder(tf.float32, (), 'render_lambda')
self.ph_ref_lambda = tf.placeholder(tf.float32, (), 'refine_lambda')
# self.ph_adv_lambda = tf.placeholder(tf.float32, (), 'adv_lambda')
with tf.gfile.GFile(os.path.join(self.root_dir, 'data/FaceReconModel.pb'), 'rb') as f:
face_rec_graph_def = tf.GraphDef()
face_rec_graph_def.ParseFromString(f.read())
def get_emb_coeff(net_name, inputs):
resized = tf.image.resize_images(inputs, [224, 224])
bgr_inputs = resized[..., ::-1]
tf.import_graph_def(face_rec_graph_def, name=net_name, input_map={'input_imgs:0': bgr_inputs})
image_emb = self.graph.get_tensor_by_name(net_name + '/resnet_v1_50/pool5:0')
image_emb = tf.squeeze(image_emb, axis=[1, 2])
coeff = self.graph.get_tensor_by_name(net_name + '/coeff:0')
return image_emb, coeff
image_emb, self.coeff = get_emb_coeff('facerec', self.train_images)
image_emb_test, self.coeff_test = get_emb_coeff('facerec_test', self.input_images)
with tf.gfile.GFile(os.path.join(self.root_dir, 'data/FaceNetModel.pb'), 'rb') as f:
face_net_graph_def = tf.GraphDef()
face_net_graph_def.ParseFromString(f.read())
def get_img_feat(net_name, inputs):
# inputs should be in [0, 255]
# facenet_input = tf.image.resize_image_with_crop_or_pad(inputs, 160, 160)
# TODO: fix resize issue!!!
facenet_input = tf.image.resize_images(inputs, [160, 160])
facenet_input = (facenet_input - 127.5) / 128.0
tf.import_graph_def(face_net_graph_def, name=net_name, input_map={
'input:0': facenet_input,
'phase_train:0': False
})
image_feat = self.graph.get_tensor_by_name(
net_name + '/InceptionResnetV1/Logits/AvgPool_1a_8x8/AvgPool:0')
image_feat = tf.squeeze(image_feat, axis=[1, 2])
return image_feat
image_feat = get_img_feat('facenet', self.train_images)
image_feat_test = get_img_feat('facenet_test', self.input_images)
self.image_emb = tf.concat([image_emb, image_feat], axis=-1)
self.image_emb_test = tf.concat([image_emb_test, image_feat_test], axis=-1)
pred_results = self.inference(self.train_rgbas, self.coeff, self.image_emb)
self.vert_pred = pred_results['vertice']
self.pca_text_pred = pred_results['pca_texture']
self.gcn_text_pred = pred_results['gcn_texture']
self.pca_color_pred = pred_results['pca_color']
self.gcn_color_pred = pred_results['gcn_color']
self.proj_color_pred = pred_results['proj_color']
self.pca_render_pred = pred_results['pca_render_color']
self.gcn_render_pred = pred_results['gcn_render_color']
self.lm_proj_pred = pred_results['lm_project']
# render_mask = self._erosion2d(self.train_rgbas[..., 3:])
render_mask = self.pca_render_pred[..., 3:] * self.train_rgbas[..., 3:]
gcn_render_image = (self.gcn_render_pred[..., :3] + 1) * 127.5
self.gcn_overlay = gcn_render_image[..., :3] * render_mask +\
self.train_images[..., :3] * (1 - render_mask)
gcn_image_feat = get_img_feat('facenet_gcn', self.gcn_overlay)
self.all_loss, self.pca_loss, self.gcn_loss, self.proj_loss, self.refine_loss, self.perc_loss, self.var_loss, self.sym_loss = self.compute_loss(
self.train_rgbas, self.pca_render_pred, self.gcn_render_pred, self.pca_text_pred,
self.gcn_text_pred, self.proj_color_pred, self.pca_color_pred, self.gcn_color_pred,
image_feat, gcn_image_feat, self.regularization)
test_results = self.inference(self.ph_rgbas, self.coeff_test, self.image_emb_test,
is_training=False, reuse=True, get_inter=True)
self.vert_test = test_results['vertice']
self.norm_test = test_results['normal']
self.pca_text_test = test_results['pca_texture']
self.gcn_text_test = test_results['gcn_texture']
self.pca_color_test = test_results['pca_color']
self.gcn_color_test = test_results['gcn_color']
self.proj_color_test = test_results['proj_color']
self.pca_ren_tex_test = test_results['pca_render_text']
self.gcn_ren_tex_test = test_results['gcn_render_text']
self.pca_ren_clr_test = test_results['pca_render_color']
self.gcn_ren_clr_test = test_results['gcn_render_color']
self.lm_proj_test = test_results['lm_project']
# render_mask_test = self._erosion2d(self.ph_rgbas[..., 3:])
render_mask_test = self.pca_ren_clr_test[..., 3:] * self.ph_rgbas[..., 3:]
gcn_ren_image_test = (self.gcn_ren_clr_test[..., :3] + 1) * 127.5
self.gcn_over_test = gcn_ren_image_test[..., :3] * render_mask_test +\
self.input_images[..., :3] * (1 - render_mask_test)
gcn_image_feat_test = get_img_feat('facenet_gcn_test', self.gcn_over_test)
self.test_all_loss, self.test_pca_loss, self.test_gcn_loss, self.test_proj_loss, self.test_refine_loss, self.test_perc_loss, _, _ = self.compute_loss(
self.ph_rgbas, self.pca_ren_clr_test, self.gcn_ren_clr_test, self.pca_text_test,
self.gcn_text_test, self.proj_color_test, self.pca_color_test, self.gcn_color_test,
image_feat_test, gcn_image_feat_test, self.regularization, True)
self.d_loss = None
if self.gan:
real_image = self.train_rgbas[..., :3]
fake_image = self.gcn_overlay / 127.5 - 1.0
self.g_loss, self.d_loss = self.compute_gan_loss(real_image, fake_image)
self.all_loss = self.all_loss + self.g_loss
real_img_test = self.ph_rgbas[..., :3]
fake_img_test = self.gcn_over_test / 127.5 - 1.0
self.test_g_loss, self.test_d_loss = self.compute_gan_loss(real_img_test, fake_img_test,
reuse=True)
self.test_all_loss = self.test_all_loss + self.test_g_loss
self.gen_train, self.dis_train = self.training(self.all_loss, self.d_loss)
# self.op_encoder = self.encoder(self.ph_data, reuse=True)
# self.op_decoder = self.decoder(self.ph_z, reuse=True)
# Initialize variables, i.e. weights and biases.
self.op_init = tf.global_variables_initializer()
# Summaries for TensorBoard and Save for model parameters.
self.op_summary = tf.summary.merge_all()
var_all = tf.global_variables()
trainable_vars = tf.trainable_variables()
bn_vars = [x for x in var_all if 'BatchNorm/moving' in x.name]
global_vars = [x for x in var_all if 'training' in x.name]
vars_to_save = trainable_vars + bn_vars + global_vars
self.op_saver = tf.train.Saver(var_list=vars_to_save, max_to_keep=3)
logger.info('Successfully Build Graph')
def inference(self, images, coeff, image_emb, is_training=True, reuse=False, get_inter=False):
shape_coef, exp_coef, color_coef, angles, gamma, translation = utils.split_bfm09_coeff(coeff)
# shapeMU = tf.constant(self.bfm.shapeMU, dtype=tf.float32)
shapePC = tf.constant(self.bfm.shapePC, dtype=tf.float32)
# expMU = tf.constant(self.bfm.expressionMU, dtype=tf.float32)
expPC = tf.constant(self.bfm.expressionPC, dtype=tf.float32)
colorMU = tf.constant(self.bfm.colorMU, dtype=tf.float32)
colorPC = tf.constant(self.bfm.colorPC, dtype=tf.float32)
vert_offset = tf.einsum('ij,aj->ai', shapePC, shape_coef) + tf.einsum(
'ij,aj->ai', expPC, exp_coef)
vertice = tf.reshape(vert_offset, [self.batch_size, self.num_vert, 3]) + self.vert_mean
vertice = vertice - tf.reduce_mean(self.vert_mean, axis=0, keepdims=True)
# normal = tf.nn.l2_normalize(vertice)
normal = self.compute_norm(vertice)
rotation = utils.rotation_matrix_tf(angles)
vert_trans = tf.matmul(vertice, rotation) + tf.reshape(translation, [self.batch_size, 1, 3])
normal_rot = tf.matmul(normal, rotation)
pca_texture = tf.einsum('ij,aj->ai', colorPC, color_coef) + colorMU
# outputs of pca is [0, 255]
pca_texture = tf.clip_by_value(pca_texture, 0.0, 255.0)
pca_texture = pca_texture / 127.5 - 1
pca_texture = tf.reshape(pca_texture, [self.batch_size, self.num_vert, 3])
# outputs of mesh_decoder using tanh for activation
with tf.variable_scope('render', reuse=reuse):
camera_position = tf.constant([0, 0, 10], dtype=tf.float32)
camera_lookat = tf.constant([0, 0, 0], dtype=tf.float32)
camera_up = tf.constant([0, 1, 0], dtype=tf.float32)
light_positions = tf.tile(tf.reshape(tf.constant([0, 0, 0], dtype=tf.float32), [1, 1, 3]),
[self.batch_size, 1, 1])
light_intensities = tf.tile(tf.reshape(tf.constant([0, 0, 0], dtype=tf.float32), [1, 1, 3]),
[self.batch_size, 1, 1])
fov_y = 12.5936
ambient_color = tf.tile(tf.reshape(tf.constant([1, 1, 1], dtype=tf.float32), [1, 3]),
[self.batch_size, 1])
def postprocess(inputs):
outputs = tf.clip_by_value(inputs, 0.0, 1.0)
outputs = outputs * [[[[2.0, 2.0, 2.0, 1.0]]]] - [[[[1.0, 1.0, 1.0, 0.0]]]]
return outputs
# make color between 0 and 1 before rendering
# outputs will be post processed, [-1, 1] for rgb value
def neural_renderer(vertices, triangles, normals, diffuse_colors):
renders, shift_vert = mesh_renderer.mesh_renderer(
vertices=vertices, triangles=triangles, normals=normals, diffuse_colors=diffuse_colors,
camera_position=camera_position, camera_lookat=camera_lookat, camera_up=camera_up,
light_positions=light_positions, light_intensities=light_intensities,
image_width=self.img_size, image_height=self.img_size, fov_y=fov_y,
ambient_color=ambient_color)
return postprocess(renders), shift_vert
pca_render_text, shift_vert = neural_renderer(vertices=vert_trans,
triangles=self.refer_faces[0],
normals=normal_rot,
diffuse_colors=(pca_texture + 1) / 2)
pca_color = self.illumination((pca_texture + 1) / 2, normal_rot, gamma)
pca_render_color, _ = neural_renderer(vertices=vert_trans, triangles=self.refer_faces[0],
normals=normal_rot, diffuse_colors=pca_color)
pca_color = pca_color * 2 - 1
facial = tf.tan(fov_y / 360.0 * math.pi)
facial = tf.reshape(facial, [-1, 1, 1])
proj_vert = shift_vert[..., :3] * [[[1, -1, -1]]]
proj_vert = proj_vert[..., :2] / facial / proj_vert[..., 2:3]
eros_mask = self._erosion2d(images[..., 3:])
eros_image = tf.concat([images[..., :3], eros_mask], axis=-1)
lm_project = tf.gather(proj_vert, self.lm_3d_idx, axis=1)
proj_color = self.project_color(proj_vert, eros_image)
visiable = tf.cast(normal_rot[..., 2:3] > 0, tf.float32) * proj_color[..., 3:4]
proj_color = tf.concat([proj_color[..., :3] * visiable, visiable], axis=-1)
# TODO:
# refine_input = pca_texture
# refine_input = tf.concat([pca_texture, proj_color[..., :3]], axis=-1)
refine_input = tf.concat([pca_texture, proj_color], axis=-1)
gcn_texture = self.mesh_generator(image_emb, refine_input, reuse=reuse)
with tf.variable_scope('render', reuse=reuse):
gcn_render_text, _ = neural_renderer(vertices=vert_trans, triangles=self.refer_faces[0],
normals=normal_rot, diffuse_colors=(gcn_texture + 1) / 2)
gcn_color = self.illumination((gcn_texture + 1) / 2, normal_rot, gamma)
gcn_render_color, _ = neural_renderer(vertices=vert_trans, triangles=self.refer_faces[0],
normals=normal_rot, diffuse_colors=gcn_color)
gcn_color = gcn_color * 2 - 1
tf.summary.image('pca_render_text', pca_render_text, max_outputs=4)
tf.summary.image('gcn_render_text', gcn_render_text, max_outputs=4)
tf.summary.image('pca_render_color', pca_render_color, max_outputs=4)
tf.summary.image('gcn_render_color', gcn_render_color, max_outputs=4)
logger.info('Successfully Inferenced')
return {
# 'vertice': vert_trans,
'vertice': vertice,
'normal': normal,
'pca_texture': pca_texture, # [-1, 1]
'gcn_texture': gcn_texture, # [-1, 1]
'pca_color': pca_color, # [-1, 1]
'gcn_color': gcn_color, # [-1, 1]
'proj_color': proj_color, # [-1, 1]
'pca_render_text': pca_render_text, # [-1, 1]
'gcn_render_text': gcn_render_text, # [-1, 1]
'pca_render_color': pca_render_color, # [-1, 1]
'gcn_render_color': gcn_render_color, # [-1, 1]
'lm_project': lm_project
}
def compute_loss(self, input_image, pca_render, gcn_render, pca_texture, gcn_texture, proj_color,
pca_color, gcn_color, input_feat, gcn_feat, regularization, get_inter=False):
"""Adds to the inference model the layers required to generate loss."""
with tf.name_scope('loss'):
with tf.name_scope('data_loss'):
skin_mask = self._erosion2d(input_image[..., 3:])
gcn_render_mask = tf.round(gcn_render[..., 3:]) * skin_mask
# pca_render_loss = tf.losses.mean_squared_error(
pca_render_loss = tf.losses.absolute_difference(
predictions=pca_render[..., :3] * gcn_render_mask, labels=input_image[..., :3] *
gcn_render_mask, reduction=tf.losses.Reduction.SUM) / tf.reduce_sum(gcn_render_mask)
# gcn_render_loss = tf.losses.mean_squared_error(
gcn_render_loss = tf.losses.absolute_difference(
predictions=gcn_render[..., :3] * gcn_render_mask, labels=input_image[..., :3] *
gcn_render_mask, reduction=tf.losses.Reduction.SUM) / tf.reduce_sum(gcn_render_mask)
# project_loss_image = tf.losses.mean_squared_error(
project_loss_image = tf.losses.absolute_difference(
predictions=gcn_color * proj_color[..., 3:],
labels=proj_color[..., :3] * proj_color[..., 3:], reduction=tf.losses.Reduction.MEAN)
# project_loss_pca = tf.losses.mean_squared_error(
project_loss_pca = tf.losses.absolute_difference(
predictions=gcn_color * (1 - proj_color[..., 3:]),
labels=pca_color * (1 - proj_color[..., 3:]), reduction=tf.losses.Reduction.MEAN)
project_loss = project_loss_image + 0.3 * project_loss_pca
# refine_loss = tf.losses.mean_squared_error(
refine_loss = tf.losses.absolute_difference(predictions=gcn_texture, labels=pca_texture,
reduction=tf.losses.Reduction.MEAN)
perception_loss = 1 - tf.reduce_mean(utils.cosine(input_feat, gcn_feat))
var_losses = []
gcn_skin_texture = tf.gather(gcn_texture, self.bfm.skin_index, axis=1)
for i in range(3):
_, variance = tf.nn.moments(gcn_skin_texture[..., i], axes=1)
var_losses.append(variance)
var_loss = tf.reduce_mean(var_losses)
sym_diff = tf.gather(gcn_texture, self.bfm.left_index, axis=1) - tf.gather(
gcn_texture, self.bfm.right_index, axis=1)
sym_loss = tf.reduce_mean(tf.sqrt(tf.reduce_sum(tf.square(sym_diff) + 1e-16, axis=-1)))
# adj_tensor = tf.constant(self.adjacent.reshape(
# [1, self.num_vert, self.num_vert, 1]),
# dtype=tf.int32,
# shape=[1, self.num_vert, self.num_vert, 1])
# coo = self.adjacent.tocoo()
# indices = np.mat([0, self.adjacent.row, self.adjacent.col, 0]).transpose()
# values = np.ones_like(self.adjacent.data, np.float32)
# adj_tensor = tf.SparseTensor(indices, values, self.adjacent.shape)
# # adj_tensor = tf.SparseTensor(self.adjacent.indices,
# # np.clip(self.adjacent.data, 0, 1),
# # self.adjacent.shape)
# expand = tf.ones([1, self.num_vert, self.num_vert, 3], dtype=tf.float32)
# expand = expand * tf.expand_dims(gcn_texture, axis=1)
# exp_trans = tf.transpose(expand, [0, 2, 1, 3])
# # vertical = tf.ones([self.num_vert, self.num_vert, 3], dtype=tf.float32)
# # vertical = vertical * tf.expand_dims(gcn_texture, axis=2)
# smooth_loss = tf.abs((expand - exp_trans) * adj_tensor)
# test = tf.sparse_to_dense(smooth_loss.indices, )
#TODO: need attention
# data_loss = self.ph_ref_lambda * refine_loss + self.ph_ren_lambda * (
# gcn_render_loss + 0.2 * project_loss +
# 0.2 * perception_loss) + 0.1 * sym_loss
data_loss = self.ph_ref_lambda * refine_loss + self.ph_ren_lambda * (
project_loss + 0.2 * perception_loss + 0.5 * sym_loss + 0.01 * var_loss)
# if not get_inter:
# self.skin_mask = skin_mask
# self.gcn_render_mask = gcn_render_mask
# self.gcn_render_image = gcn_render[..., :3]
# self.input_image_rgb = input_image[..., :3]
# self.pca_render_image = pca_render[..., :3]
with tf.name_scope('regularization'):
regularization *= tf.add_n(self.regularizers)
loss = data_loss + regularization
tf.summary.scalar('loss/data_loss', data_loss)
tf.summary.scalar('loss/pca_render_loss', pca_render_loss)
tf.summary.scalar('loss/gcn_render_loss', gcn_render_loss)
tf.summary.scalar('loss/project_loss', project_loss)
tf.summary.scalar('loss/refine_loss', refine_loss)
tf.summary.scalar('loss/perception_loss', perception_loss)
tf.summary.scalar('loss/var_loss', var_loss)
tf.summary.scalar('loss/sym_loss', sym_loss)
tf.summary.scalar('loss/regularization', regularization)
logger.info('Successfully Computed Losses')
return loss, pca_render_loss, gcn_render_loss, project_loss, refine_loss, perception_loss, var_loss, sym_loss
def compute_gan_loss(self, real_image, fake_image, reuse=False, scale=10.0):
t = not reuse
real_score = self.image_disc(real_image, t, reuse=reuse)
fake_score = self.image_disc(fake_image, t, reuse=True)
epsilon = tf.random_uniform([], 0.0, 1.0)
hat_image = epsilon * real_image + (1 - epsilon) * fake_image
hat_score = self.image_disc(hat_image, t, reuse=True)
hat_gradient = tf.gradients(hat_score, hat_image)[0]
hat_gradient = tf.sqrt(tf.reduce_sum(tf.square(hat_gradient), axis=[1, 2, 3]))
hat_gradient = tf.reduce_mean(tf.square(hat_gradient - 1.0) * scale)
g_loss = -self.adv_lambda * tf.reduce_mean(fake_score)
d_loss = self.adv_lambda * (tf.reduce_mean(fake_score) - tf.reduce_mean(real_score) +
hat_gradient)
logger.info('Successfully Computed GAN Losses')
return g_loss, d_loss
def training(self, g_loss, d_loss=None, decay_rate=0.98):
"""Adds to the loss model the Ops required to generate and apply gradients."""
with tf.name_scope('training'):
# Learning rate.
global_step = tf.Variable(0, name='global_step', trainable=False)
if decay_rate != 1:
learning_rate = tf.train.exponential_decay(self.learning_rate, global_step,
self.decay_steps, decay_rate, staircase=True)
else:
learning_rate = self.learning_rate
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
check_grads = []
def check_gradients(grads):
for i, (grad, var) in enumerate(grads):
if grad is None:
logger.info('warning: %s has no gradient', var.op.name)
else:
grads[i] = (tf.clip_by_norm(grad, 5), var)
check_grads.append(tf.check_numerics(grad, "error occur"))
all_vars = tf.trainable_variables()
mesh_gen_vars = [x for x in all_vars if x.name.startswith('mesh_generator')]
g_grads = optimizer.compute_gradients(g_loss, var_list=mesh_gen_vars)
check_gradients(g_grads)
if d_loss is not None:
image_dis_vars = [x for x in all_vars if x.name.startswith('image_disc')]
d_grads = optimizer.compute_gradients(d_loss, var_list=image_dis_vars)
check_gradients(d_grads)
with tf.control_dependencies(check_grads):
op_g_grad = optimizer.apply_gradients(g_grads, global_step=global_step)
if d_loss is not None:
op_d_grad = optimizer.apply_gradients(d_grads, global_step=global_step)
# The op return the learning rate.
update_bn_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies([op_g_grad] + update_bn_ops):
gen_train = tf.identity(learning_rate, name='control')
dis_train = None
if d_loss is not None:
with tf.control_dependencies([op_d_grad] + update_bn_ops):
dis_train = tf.identity(learning_rate, name='control')
logger.info('Successfully Build Training Optimizer')
return gen_train, dis_train
def fit(self):
for d in [self.ckpt_dir, self.summ_dir, self.samp_dir]:
if not os.path.isdir(d):
os.makedirs(d)
logger.info('Start Fitting Model')
t_process, t_wall = time.clock(), time.time()
shutil.rmtree(self.summ_dir, ignore_errors=True)
writer = tf.summary.FileWriter(self.summ_dir)
# shutil.rmtree(self.ckpt_dir, ignore_errors=True)
if not os.path.isdir(self.ckpt_dir):
os.makedirs(self.ckpt_dir)
path = os.path.join(self.ckpt_dir, 'model')
if not os.path.isdir(self.samp_dir):
os.makedirs(self.samp_dir)
self.sess.run(self.op_init)
if self.restore:
self._restore_ckpt()
self.restore = False
val_image = utils.load_images(self.val_image_paths, self.img_size, alpha=True, landmark=False)
step = 0
for epoch in range(self.num_epochs):
ren_lambda = np.clip(0.2 * epoch, 0, 1).astype(np.float32)
ref_lambda = np.clip(1 - ren_lambda, 0.2, 1).astype(np.float32)
logger.info('render_lambda: %f, refine_lambda: %f', ren_lambda, ref_lambda)
feed_dict = {self.ph_ren_lambda: ren_lambda, self.ph_ref_lambda: ref_lambda}
fetches = [
self.gen_train, self.all_loss, self.pca_loss, self.gcn_loss, self.proj_loss,
self.refine_loss, self.perc_loss, self.var_loss, self.sym_loss
]
if self.gan:
dis_fetches = fetches + [self.g_loss, self.d_loss]
for batch in range(self.num_batches):
try:
train_dis = self.gan and ren_lambda > 1e-5
# train_dis = True
if train_dis:
for _ in range(5):
_ = self.sess.run(self.dis_train, feed_dict=feed_dict)
_, all_loss, pca_loss, gcn_loss, proj_loss, refine_loss, perc_loss, var_loss, sym_loss, g_loss, d_loss = self.sess.run(
dis_fetches, feed_dict=feed_dict)
else:
_, all_loss, pca_loss, gcn_loss, proj_loss, refine_loss, perc_loss, var_loss, sym_loss = self.sess.run(
fetches, feed_dict=feed_dict)
if batch % 10 == 0:
log_str = ' all_loss: {:.3e}, pca_loss: {:.3e}, gcn_loss: {:.3e}, proj_loss: {:.3e}, refine_loss: {:.3e}, perc_loss: {:.3e}, var_loss: {:.3e}, sym_loss: {:.3e}'.format(
all_loss, pca_loss, gcn_loss, proj_loss, refine_loss, perc_loss, var_loss, sym_loss)
if train_dis:
log_str += ', g_loss: {:.3e}, d_loss: {:.3e}'.format(g_loss, d_loss)
logger.info('batch {} / {} (epoch {} / {}):'.format(batch, self.num_batches, epoch,
self.num_epochs))
logger.info(log_str)
except Exception as e:
logger.info('Error Occured in Sess Run.')
logger.debug(e)
# Periodical evaluation of the model.
if batch % self.eval_frequency == 0:
string, results = self.evaluate(val_image)
logger.info(' validation {}'.format(string))
logger.info(' time: {:.0f}s (wall {:.0f}s)'.format(time.clock() - t_process,
time.time() - t_wall))
self.save_sample(results, step, val_image, idx=0)
# Summaries for TensorBoard.
summary = tf.Summary(
value=[tf.Summary.Value(tag='validation/loss', simple_value=results['all_loss'])])
writer.add_summary(summary, step)
# Save model parameters (for evaluation).
self.op_saver.save(self.sess, path, global_step=step)
step += 1
writer.close()
def save_sample(self, results, step, val_image, val_landmark=None, sample_dir=None, idx=0,
only_skin=False):
if sample_dir is None:
sample_dir = self.samp_dir
input_image = utils.img_denormalize(val_image[idx])
vertice = results['vertices'][idx]
normal = results['normals'][idx]
pca_texture = utils.img_denormalize(results['pca_texts'][idx])
gcn_texture = utils.img_denormalize(results['gcn_texts'][idx])
pca_color = utils.img_denormalize(results['pca_colors'][idx])
gcn_color = utils.img_denormalize(results['gcn_colors'][idx])
proj_color = utils.img_denormalize(results['proj_color'][idx])
pca_ren_tex = utils.img_denormalize(results['pca_ren_texs'][idx])
gcn_ren_tex = utils.img_denormalize(results['gcn_ren_texs'][idx])
pca_ren_clr = utils.img_denormalize(results['pca_ren_clrs'][idx])
gcn_ren_clr = utils.img_denormalize(results['gcn_ren_clrs'][idx])
lm_proj = results['lm_projs'][idx]
# input_image = np.clip(
# input_image.astype(np.int32) + [[[0, 0, 0, 64]]], 0,
# 255).astype(np.uint8)
imageio.imsave(os.path.join(sample_dir, '{}_input.png'.format(step)), input_image[..., :3])
# imageio.imsave(os.path.join(sample_dir, '{}_mask.png'.format(step)),
# input_image[..., 3])
if val_landmark is None:
lm_image = input_image[..., :3]
else:
lm_image = utils.draw_image_with_lm(None, input_image[..., :3], val_landmark[idx],
self.img_size, (0, 0, 255))
utils.draw_image_with_lm(os.path.join(sample_dir, '{}_lm_proj.png'.format(step)), lm_image,
lm_proj, self.img_size)
render_mask = pca_ren_clr[:, :, 3:] // 255
if only_skin:
render_mask = render_mask * (input_image[..., 3:] // 255)
# render_mask = cv2.erode(render_mask, np.ones((5, 5), dtype=np.uint8), iterations=5)
imageio.imsave(os.path.join(sample_dir, '{}_mask.png'.format(step)), render_mask * 255)
def save_render(inputs, name, draw_lm=False):
image = inputs[:, :, :3] * render_mask + input_image[:, :, :3] * (1 - render_mask)
if draw_lm:
utils.draw_image_with_lm(os.path.join(sample_dir, name), image, lm_proj, self.img_size)
else:
imageio.imsave(os.path.join(sample_dir, name), image)
# imageio.imsave(os.path.join(sample_dir, '{}_gcn.png'.format(step)), gcn_ren_clr)
save_render(pca_ren_tex, '{}_pca_ren_tex.png'.format(step))
save_render(gcn_ren_tex, '{}_gcn_ren_tex.png'.format(step))
save_render(pca_ren_clr, '{}_pca_ren_clr.png'.format(step))
save_render(gcn_ren_clr, '{}_gcn_ren_clr.png'.format(step))
write_obj(os.path.join(sample_dir, '{}_pca_texture.obj'.format(step)), vertice,
self.refer_meshes[0]['faces'], pca_texture, normal)
write_obj(os.path.join(sample_dir, '{}_gcn_texture.obj'.format(step)), vertice,
self.refer_meshes[0]['faces'], gcn_texture, normal)
write_obj(os.path.join(sample_dir, '{}_pca_color.obj'.format(step)), vertice,
self.refer_meshes[0]['faces'], pca_color, normal)
write_obj(os.path.join(sample_dir, '{}_gcn_color.obj'.format(step)), vertice,
self.refer_meshes[0]['faces'], gcn_color, normal)
write_obj(os.path.join(sample_dir, '{}_proj_color.obj'.format(step)), vertice,
self.refer_meshes[0]['faces'], proj_color, normal)
logger.info('Sample %s saved!', step)
def evaluate(self, images):
# t_process, t_wall = time.clock(), time.time()
size = images.shape[0]
result_list = []
for begin in range(0, size, self.batch_size):
end = begin + self.batch_size
end = min([end, size])
batch_image = np.zeros((self.batch_size, images.shape[1], images.shape[2], images.shape[3]))
tmp_image = images[begin:end]
batch_image[:end - begin] = tmp_image
# batch_landmark = None
# if landmarks is not None:
# batch_landmark = np.zeros((self.batch_size, len(self.lm_3d_idx), 2))
# tmp_landmark = landmarks[begin:end]
# batch_landmark[:end - begin] = tmp_landmark
result = self.predict(batch_image)
result_list.append(result)
results = {
'vertices': np.concatenate([x['vertice'] for x in result_list]),
'normals': np.concatenate([x['normal'] for x in result_list]),
'pca_texts': np.concatenate([x['pca_text'] for x in result_list]),
'gcn_texts': | np.concatenate([x['gcn_text'] for x in result_list]) | numpy.concatenate |
import numpy as np
from gurobipy import *
import time
import os
import sys
from Utilities import CalcRhoAndBetaVectors
from UtilitiesOptimization import CalculateLPGurobi, CalculateQuadGurobi,\
SubgrAlgSavPrimDualObjInd, SubgrAlgSavPrimDualObjFn_L2Ind, ExtendSizeCamps, OptimalBids, OptimalX
#
#
## Simulation Code
## To make the simulation code faster and easier to read (in particular the greedy heuristic)
## we would like to change the vector of click-through rates 'vector_ctr', vector of
## revenues 'vector_q', of revenue times the click trhough rate 'vector_qctr', and others
## into a matrix of size number of campaigns times number of impressions.
## That's done in the following function.
def CreateMatR_ctr_Rctr_Rhoctr(numCampaigns, num_impressions, num_edges, \
index_Imps, index_sizeCamps, vector_q, vector_ctr, \
vector_qctr, PPFTable, numericBeta):
## mat_r_by_Imp is a matrix in which each column 'i'
## represents the valuations of all campaigns in order for
## an impression of type 'i'. If the campaign is not interested
## in the impression a zero value is entered in that position.
mat_r_by_Imp=np.zeros((numCampaigns, num_impressions))
mat_ctr=np.zeros((numCampaigns, num_impressions))
mat_rctr_by_Imp=np.zeros((numCampaigns, num_impressions))
mat_rhoctr_by_Imp=np.zeros((numCampaigns, num_impressions))
mat_rctrBetarho_by_Imp=np.zeros((numCampaigns, num_impressions))
[rho_rctr, beta_rctr]=CalcRhoAndBetaVectors(vector_qctr, num_edges, \
index_Imps, PPFTable, numericBeta)
for i in range(num_impressions):
count=0
aux=0
indexes=np.arange(num_edges)[(index_Imps==i)]
sizeIndexes=len(indexes)
if(sizeIndexes!=0):
pos=indexes[aux]
for j in range(numCampaigns):
impInCamp=index_sizeCamps[j]
if (pos<(count+impInCamp)):
mat_r_by_Imp[j, i]=vector_q[pos]
mat_ctr[j, i]=vector_ctr[pos]
mat_rctr_by_Imp[j, i]=vector_qctr[pos]
mat_rhoctr_by_Imp[j, i]=rho_rctr[pos]
mat_rctrBetarho_by_Imp[j, i] =(vector_qctr[pos]-\
beta_rctr[pos])*rho_rctr[pos]
if(aux<sizeIndexes-1):
aux+=1
pos=indexes[aux]
else:
# No more campaigns use that impression
pos=num_edges
count+=impInCamp
return [mat_r_by_Imp, mat_ctr, mat_rctr_by_Imp, mat_rhoctr_by_Imp, \
mat_rctrBetarho_by_Imp]
# ### Greedy Heuristic Procedure
# When the greedy heuristic has the opportunity to bid for given impression type
# it first check the budget to see which of the interested campaigns has enough
# money to pay in case a click is done and then it bids for the campaign
# that maximizes the profit. Given that Ipinyou assumes second price auctions,
# the greedy heuristic bids for the campaign with highest revenue times ctr
# that still has enough money to pay for the impression in case of winning.
# 'CreateMatrixBidAndX' transforms bid and allocation vectors into matrices. This code
# will be used by all methods in the simulation step as we will obtain bidding and
# allocation vectors for Indicator and Indicator + $\ell_2$ once we run our primal-dual
# methodology and the greedy step has bidding prices equal to $r_{ik}$. Given that we run
# our primal-dual methodogy only once per simulation (which is clearly sub-optimal), the
# allocation vector is enough to decide in behalf of which campaign to bid in behalf of
# for a whole simulation.
def CreateMatrixBidAndX(numCampaigns, num_impressions, num_edges, \
index_Imps, index_sizeCamps, bid_vector, x):
mat_bid_by_Imp=np.zeros((numCampaigns, num_impressions))
mat_x_by_Imp=np.zeros((numCampaigns, num_impressions))
for i in range(num_impressions):
count=0
aux=0
indexes=np.arange(num_edges)[(index_Imps==i)]
sizeIndexes=len(indexes)
if(sizeIndexes!=0):
pos=indexes[aux]
for j in range(numCampaigns):
impInCamp=index_sizeCamps[j]
if (pos<(count+impInCamp)):
mat_bid_by_Imp[j, i]=bid_vector[pos]
mat_x_by_Imp[j, i]=x[pos]
if(aux<sizeIndexes-1):
aux+=1
pos=indexes[aux]
else:
# No more campaigns use that impression
# This should be done with a while.
pos=num_edges
count+=impInCamp
return [mat_bid_by_Imp, mat_x_by_Imp]
# For each impression type $i$, the probability of not bidding for it is
# $$1-\sum_{k \in \mathcal{K}_i} x_{ik}$$ We obtain the vector of probaility of not bidding
# for each impression type in CreateProbOfBidding. In Case we decide to bid for a given
# impression type, FastRandomChoice helps us to decide for which campaign to bid in behalf of.
# It receives as inputs the vector 'condProbVector' which represent the probability of bidding
# in behalf of the camapaigns that have enough budget to bid (this vector entries are
# non-negative and sum up to one), and a number 'unif_value' which we assumed was sampled
# for a uniform random variable. Then, it uses a standard trick to decide on behalf of
# which campaign to bid in behalf of. The campaign number which returns is relative to the
# campaigns that have enough budget to bid on behalf of.
def CreateProbOfBidding(mat_x_by_Imp):
return np.sum(mat_x_by_Imp, axis=0)
def FastRandomChoice(condProbVector, unif_value):
auxPartSum=0.0
for i in range(len(condProbVector)):
if auxPartSum+condProbVector[i]<unif_value:
return i
else:
auxPartSum+=condProbVector[i]
return len(condProbVector)-1
### Initializing data for each method (Greedy and derived from our method)
# When we run a simulation we would like to save by campaign the amount of bids made,
# won, and clicks made by each impression type. That info is saved in cartBids, cartWon,
# and cartClicked resp. Also, as general statistics we would like to know the cost, revenue
# and profit each impression type brough for the DSP. That info is saved in costBids, revenue,
# and profit resp.
# Function CreateDataForSimulation creates all the data needed to tart the simulation for the
# Greedy and a non-Greedy method.
def CreateIndicatorSimulation(numCampaigns, num_impressions, vector_m):
budget=np.zeros(numCampaigns)
budget[:]=vector_m
cartBids=np.zeros((numCampaigns, num_impressions))
cartWon=np.zeros((numCampaigns, num_impressions))
cartClicked=np.zeros((numCampaigns, num_impressions))
costBids=np.zeros(num_impressions)
revenue=np.zeros(num_impressions)
profit=np.zeros(num_impressions)
return [budget, cartBids, cartWon, cartClicked, \
costBids, revenue, profit]
def CreateDataForSimulation(bidFound, xFound, numCampaigns, \
num_impressions, num_edges, index_Imps, index_sizeCamps, vector_q, \
vector_ctr, vector_qctr, vector_m, PPFTable, numericBeta):
[budgetLR, cartBidsLR, cartWonLR, cartClickedLR, costBidsLR, revenueLR, \
profitLR]=CreateIndicatorSimulation(numCampaigns, \
num_impressions, vector_m)
[budgetGr, cartBidsGr, cartWonGr, cartClickedGr, costBidsGr, revenueGr, \
profitGr]=CreateIndicatorSimulation(numCampaigns, \
num_impressions, vector_m)
[mat_r_by_Imp, mat_ctrTest, mat_rctr_by_Imp, mat_rhoctr_by_Imp, mat_rctrBetarho_by_Imp]=\
CreateMatR_ctr_Rctr_Rhoctr(numCampaigns, num_impressions, num_edges, \
index_Imps, index_sizeCamps, vector_q, vector_ctr, vector_qctr, PPFTable, numericBeta)
[mat_bid_by_ImpLR, mat_x_by_ImpLR]=CreateMatrixBidAndX(numCampaigns, \
num_impressions, num_edges, index_Imps, index_sizeCamps, \
bidFound, xFound)
probBidLR=CreateProbOfBidding(mat_x_by_ImpLR)
return [budgetLR, cartBidsLR, cartWonLR, cartClickedLR, costBidsLR, \
revenueLR, profitLR, budgetGr, cartBidsGr, cartWonGr, \
cartClickedGr, costBidsGr, revenueGr, profitGr, mat_r_by_Imp, \
mat_ctrTest, mat_rctr_by_Imp, mat_rhoctr_by_Imp, mat_rctrBetarho_by_Imp, \
mat_bid_by_ImpLR, mat_x_by_ImpLR, probBidLR]
# Comments About the Implementation
# - We win an auction only if the bid_amount is higher than the market price that appear in the Ipinyou Log.
# In case of winning the auction we then need to check if a click occurs. We update the revenue, profit,
# budget, cartWon, costBids, and cartClicked accordingly.
# - For the indicator and indicator+$\ell_2$ case we only need to check the allocation vector to decide
# the campaign to bid in behalf of (allocation vector that comes from running other primal-dual procedure).
# Simulation code for Indicator, Indicator + $\ell_2$, and Greedy
def RunIndL2IndAndGreedy(numCampaigns, num_impressions, num_edges, index_Imps, \
index_sizeCamps, PPFTable, numericBeta, vector_q, vector_m, vector_ctrTrain, vector_rctrTrain, \
vector_ctrTest, vector_rctrTest, bidsInd, xInd, bidsL2Ind, xL2Ind, tau, ImpInOrder, MPInOrder,\
impNames, listCampPerImp):
## We first initialize the budgets used, matrices of bids made, won, and clicked for
## three methods.
[budgetInd, cartBidsInd, cartWonInd, cartClickedInd, costBidsInd, \
revenueInd, profitInd, _, _, _, _, _, _, _, _, _, mat_rctr_by_ImpTrain, _, _, \
mat_bid_by_ImpInd, mat_x_by_ImpInd, probBidInd]=CreateDataForSimulation(bidsInd, \
xInd, numCampaigns, num_impressions, num_edges, index_Imps, index_sizeCamps, \
vector_q, vector_ctrTrain, vector_rctrTrain, vector_m, PPFTable, numericBeta)
[budgetL2Ind, cartBidsL2Ind, cartWonL2Ind, cartClickedL2Ind, costBidsL2Ind, \
revenueL2Ind, profitL2Ind, budgetGr, cartBidsGr, cartWonGr, \
cartClickedGr, costBidsGr, revenueGr, profitGr, mat_r_by_Imp, \
mat_ctrTest, _, _, _, \
mat_bid_by_ImpL2Ind, mat_x_by_ImpL2Ind, probBidL2Ind]=CreateDataForSimulation(bidsL2Ind, \
xL2Ind, numCampaigns, num_impressions, num_edges, index_Imps, index_sizeCamps, \
vector_q, vector_ctrTest, vector_rctrTest, vector_m, PPFTable, numericBeta)
## Now we simulate
# campaignsArange=np.arange(numCampaigns)
## Instead of np.random.uniform every time we need a random uniform we call
## the method at the beginnning of the simulation and save all uniform
## samples we need.
allUnifToUse = np.random.uniform(0.0, 1.0, (len(ImpInOrder)*3))
# uniOnline=False
## We read the test log in irder of how the impressions type appear.
for i,clusterId in enumerate(ImpInOrder):
impType=impNames.index(clusterId)
unifs=allUnifToUse[(3*i):(3*(i+1))]
## Market Price that appears in the test log.
mp_value=MPInOrder[i]
## Update Ind
indBuyerInd=0
tryToBidInd=False
bidAmountInd=0.0
## First we check if the method would try to bid for the impression
## or would just discard it immediately
if unifs[0] <= probBidInd[impType]:
## For each campaign we check if there is any that has enough budget to bid and that
## also wants to do so.
bidUsingInd=False
# print('budgetInd[listCampPerImp[impType]]: '+str(budgetInd[listCampPerImp[impType]]))
# aux53 =(mat_r_by_Imp[listCampPerImp[impType],impType] <= budgetInd[listCampPerImp[impType]])
indInterested = (mat_x_by_ImpInd[listCampPerImp[impType],impType]>0) *\
(mat_r_by_Imp[listCampPerImp[impType],impType] <= budgetInd[listCampPerImp[impType]])
if np.sum(indInterested) >0:
bidUsingInd= True
if bidUsingInd:
## There is at least one campaign that wants to bid.
posInt=listCampPerImp[impType][indInterested]
## Conditional probability assuming that the method is going to bid.
## This conditional probability excludes all those campaigns
## that do not want to bid
condProbInterested=mat_x_by_ImpInd[posInt, impType]
condProbInterested*=1.0/np.sum(condProbInterested)
auxPartSum=0.0
## Now we will choose in behalf of which campaign to bid for.
numInterest = len(condProbInterested)
auxPosForindBuyerInd = numInterest-1
z = 0
while z<numInterest:
auxPartSum += condProbInterested[z]
if auxPartSum >= unifs[1]:
## If we exceed unifs[1] go out of the loop
auxPosForindBuyerInd=z
z+=numInterest
z += 1
indBuyerInd=posInt[auxPosForindBuyerInd]
tryToBidInd=True
bidAmountInd=mat_bid_by_ImpInd[indBuyerInd, impType]
## If tryToBidInd == True, we will try to bid inbehalf of campaign indBuyerInd
## bidding an amount of bidAmountInd.
if(tryToBidInd):
## We first register that we are bidding on behalf of indBuyerInd for an
## impression of type impType
cartBidsInd[indBuyerInd, impType]+=1
## We win the auction only if the value we are bidding is higher
## than the market price observed by Ipinyou
if bidAmountInd>= mp_value:
## Impression Won. Register that we won the impression and the change
## in cost and profit.
cartWonInd[indBuyerInd, impType]+=1
costBidsInd[impType]-=mp_value
profitInd[impType]-=mp_value
# Now we need to check if the ad was clicked.
probOfClick=mat_ctrTest[indBuyerInd, impType]
if (unifs[2]<=probOfClick):
## User clicked, increase revenue and charge the campaign (i.e. DSP wins money).
cartClickedInd[indBuyerInd, impType]+=1
payment=mat_r_by_Imp[indBuyerInd, impType]
revenueInd[impType]+=payment
profitInd[impType]+=payment
budgetInd[indBuyerInd]-=payment
## Update L2Ind (Same code as done before for the pure indicator case)
indBuyerL2Ind=0
tryToBidL2Ind=False
bidAmountL2Ind=0.0
if unifs[0] <= probBidL2Ind[impType]:
## For each campaign we check if there is any that has enough budget to bid and that
## also wants to do so.
bidUsingL2Ind=False
indInterested =\
(mat_r_by_Imp[listCampPerImp[impType],impType] <= budgetL2Ind[listCampPerImp[impType]]) * \
(mat_x_by_ImpL2Ind[listCampPerImp[impType],impType]>0)
if np.sum(indInterested) >0:
bidUsingL2Ind= True
if bidUsingL2Ind:
## There is at least one campaign that wants to bid.
posInt=listCampPerImp[impType][indInterested]
## Conditional probability assuming that the method is going to bid.
## This conditional probability excludes all those campaigns
## that do not want to bid
condProbInterested=mat_x_by_ImpL2Ind[posInt, impType]
condProbInterested*=1.0/np.sum(condProbInterested)
auxPartSum=0.0
## Now we will choose in behalf of which campaign to bid for.
numInterest = len(condProbInterested)
auxPosForindBuyerL2Ind = numInterest-1
z = 0
while z <numInterest:
auxPartSum += condProbInterested[z]
if auxPartSum >= unifs[1]:
## If we exceed unifs[1] go out of the loop
auxPosForindBuyerL2Ind=z
z+=numInterest
z += 1
indBuyerL2Ind=posInt[auxPosForindBuyerL2Ind]
tryToBidL2Ind=True
bidAmountL2Ind=mat_bid_by_ImpL2Ind[indBuyerL2Ind, impType]
if(tryToBidL2Ind):
cartBidsL2Ind[indBuyerL2Ind, impType]+=1
if bidAmountL2Ind>= mp_value:
## Impression Won.
cartWonL2Ind[indBuyerL2Ind, impType]+=1
costBidsL2Ind[impType]-=mp_value
profitL2Ind[impType]-=mp_value
# Now we need to check if the ad was clicked.
probOfClick=mat_ctrTest[indBuyerL2Ind, impType]
if (unifs[2]<=probOfClick):
## User clicked, increase revenue and charge the campaign.
cartClickedL2Ind[indBuyerL2Ind, impType]+=1
payment=mat_r_by_Imp[indBuyerL2Ind, impType]
revenueL2Ind[impType]+=payment
profitL2Ind[impType]+=payment
budgetL2Ind[indBuyerL2Ind]-=payment
### Now we update the Greedy Policy
## The greedy heuristic bids for the campaign which stills have remaining
## budget and from thos bid for the one with highest r times ctr.
## The previous is true as Ipinyou assumes second price auctions.
indBuyerGr=-1
bidAmountGr=0.0
tryToBidGr=False
indInterested =\
mat_r_by_Imp[listCampPerImp[impType],impType] <= budgetGr[listCampPerImp[impType]]
if np.sum(indInterested) > 0:
posInt=listCampPerImp[impType][indInterested]
indBuyerGr = posInt[np.argmax(mat_rctr_by_ImpTrain[posInt,impType])]
bidAmountGr=mat_rctr_by_ImpTrain[indBuyerGr, impType]
tryToBidGr=True
## If tryToBidGr == True, we will bid in behalf of campaign 'indBuyerGr'
## the amount 'bidAmountGr'
if (tryToBidGr):
## Save that we are bidding in behalf of 'indBuyerGr' for an impression of
## type 'impType'
cartBidsGr[indBuyerGr, impType]+=1
## We win the auction only if the value we are bidding is higher
## than the market price observed by Ipinyou.
if bidAmountGr>= mp_value:
## Impression Won.
cartWonGr[indBuyerGr, impType]+=1
costBidsGr[impType]-=mp_value
profitGr[impType]-=mp_value
# Now we need to check if the ad was clicked.
probOfClick=mat_ctrTest[indBuyerGr, impType]
if (unifs[2]<=probOfClick):
## User clicked, increase revenue and charge the campaign.
cartClickedGr[indBuyerGr, impType]+=1
payment=mat_r_by_Imp[indBuyerGr, impType]
revenueGr[impType]+=payment
profitGr[impType]+=payment
budgetGr[indBuyerGr]-=payment
return [budgetInd, cartBidsInd, cartWonInd, cartClickedInd, costBidsInd, \
revenueInd, profitInd, budgetL2Ind, cartBidsL2Ind, cartWonL2Ind, \
cartClickedL2Ind, costBidsL2Ind, revenueL2Ind, profitL2Ind, budgetGr, \
cartBidsGr, cartWonGr, cartClickedGr, costBidsGr, revenueGr, profitGr]
def RunInd_L2_L2Ind_Greedy(numCampaigns, num_impressions, num_edges, index_Imps, \
index_sizeCamps, PPFTable, numericBeta, vector_q, vector_m, vector_ctrTrain, vector_rctrTrain, \
vector_ctrTest, vector_rctrTest, bidsInd, xInd, bidsL2, xL2, bidsL2Ind, xL2Ind, tau,\
ImpInOrder, MPInOrder, impNames, listCampPerImp):
## We first initialize the budgets used, matrices of bids made, won, and clicked for
## three methods.
[budgetInd, cartBidsInd, cartWonInd, cartClickedInd, costBidsInd, \
revenueInd, profitInd, _, _, _, _, _, _, _, _, _, mat_rctr_by_ImpTrain, _, _, \
mat_bid_by_ImpInd, mat_x_by_ImpInd, probBidInd]=CreateDataForSimulation(bidsInd, \
xInd, numCampaigns, num_impressions, num_edges, index_Imps, index_sizeCamps, \
vector_q, vector_ctrTrain, vector_rctrTrain, vector_m, PPFTable, numericBeta)
[budgetL2Ind, cartBidsL2Ind, cartWonL2Ind, cartClickedL2Ind, costBidsL2Ind, \
revenueL2Ind, profitL2Ind, budgetGr, cartBidsGr, cartWonGr, \
cartClickedGr, costBidsGr, revenueGr, profitGr, mat_r_by_Imp, \
mat_ctrTest, _, _, _, \
mat_bid_by_ImpL2Ind, mat_x_by_ImpL2Ind, probBidL2Ind]=CreateDataForSimulation(bidsL2Ind, \
xL2Ind, numCampaigns, num_impressions, num_edges, index_Imps, index_sizeCamps, \
vector_q, vector_ctrTest, vector_rctrTest, vector_m, PPFTable, numericBeta)
[budgetL2, cartBidsL2, cartWonL2, cartClickedL2, costBidsL2, \
revenueL2, profitL2, _, _, _, _, _, _, _, _, _, _, _, _, \
mat_bid_by_ImpL2, mat_x_by_ImpL2, probBidL2]=CreateDataForSimulation(bidsL2, \
xL2, numCampaigns, num_impressions, num_edges, index_Imps, index_sizeCamps, \
vector_q, vector_ctrTest, vector_rctrTest, vector_m, PPFTable, numericBeta)
## Now we simulate
# campaignsArange=np.arange(numCampaigns)
## Instead of np.random.uniform every time we need a random uniform we call
## the method at the beginnning of the simulation and save all uniform
## samples we need.
allUnifToUse = np.random.uniform(0.0, 1.0, (len(ImpInOrder)*3))
# uniOnline=False
## We read the test log in irder of how the impressions type appear.
for i,clusterId in enumerate(ImpInOrder):
impType=impNames.index(clusterId)
unifs=allUnifToUse[(3*i):(3*(i+1))]
## Market Price that appears in the test log.
mp_value=MPInOrder[i]
## Update Ind
indBuyerInd=0
tryToBidInd=False
bidAmountInd=0.0
## First we check if the method would try to bid for the impression
## or would just discard it immediately
if unifs[0] <= probBidInd[impType]:
## For each campaign we check if there is any that has enough budget to bid and that
## also wants to do so.
bidUsingInd=False
# print('budgetInd[listCampPerImp[impType]]: '+str(budgetInd[listCampPerImp[impType]]))
# aux53 =(mat_r_by_Imp[listCampPerImp[impType],impType] <= budgetInd[listCampPerImp[impType]])
indInterested = (mat_x_by_ImpInd[listCampPerImp[impType],impType]>0) *\
(mat_r_by_Imp[listCampPerImp[impType],impType] <= budgetInd[listCampPerImp[impType]])
if np.sum(indInterested) >0:
bidUsingInd= True
if bidUsingInd:
## There is at least one campaign that wants to bid.
posInt=listCampPerImp[impType][indInterested]
## Conditional probability assuming that the method is going to bid.
## This conditional probability excludes all those campaigns
## that do not want to bid
condProbInterested=mat_x_by_ImpInd[posInt, impType]
condProbInterested*=1.0/np.sum(condProbInterested)
auxPartSum=0.0
## Now we will choose in behalf of which campaign to bid for.
numInterest = len(condProbInterested)
auxPosForindBuyerInd = numInterest-1
z = 0
while z<numInterest:
auxPartSum += condProbInterested[z]
if auxPartSum >= unifs[1]:
## If we exceed unifs[1] go out of the loop
auxPosForindBuyerInd=z
z+=numInterest
z += 1
indBuyerInd=posInt[auxPosForindBuyerInd]
tryToBidInd=True
bidAmountInd=mat_bid_by_ImpInd[indBuyerInd, impType]
## If tryToBidInd == True, we will try to bid inbehalf of campaign indBuyerInd
## bidding an amount of bidAmountInd.
if(tryToBidInd):
## We first register that we are bidding on behalf of indBuyerInd for an
## impression of type impType
cartBidsInd[indBuyerInd, impType]+=1
## We win the auction only if the value we are bidding is higher
## than the market price observed by Ipinyou
if bidAmountInd>= mp_value:
## Impression Won. Register that we won the impression and the change
## in cost and profit.
cartWonInd[indBuyerInd, impType]+=1
costBidsInd[impType]-=mp_value
profitInd[impType]-=mp_value
# Now we need to check if the ad was clicked.
probOfClick=mat_ctrTest[indBuyerInd, impType]
if (unifs[2]<=probOfClick):
## User clicked, increase revenue and charge the campaign (i.e. DSP wins money).
cartClickedInd[indBuyerInd, impType]+=1
payment=mat_r_by_Imp[indBuyerInd, impType]
revenueInd[impType]+=payment
profitInd[impType]+=payment
budgetInd[indBuyerInd]-=payment
## Update L2 (Same code as done before for the pure indicator case)
indBuyerL2=0
tryToBidL2=False
bidAmountL2=0.0
if unifs[0] <= probBidL2[impType]:
## For each campaign we check if there is any that has enough budget to bid and that
## also wants to do so.
bidUsingL2=False
indInterested =\
(mat_r_by_Imp[listCampPerImp[impType],impType] <= budgetL2[listCampPerImp[impType]]) * \
(mat_x_by_ImpL2[listCampPerImp[impType],impType]>0)
if np.sum(indInterested) >0:
bidUsingL2= True
if bidUsingL2:
## There is at least one campaign that wants to bid.
posInt=listCampPerImp[impType][indInterested]
## Conditional probability assuming that the method is going to bid.
## This conditional probability excludes all those campaigns
## that do not want to bid
condProbInterested=mat_x_by_ImpL2[posInt, impType]
condProbInterested*=1.0/np.sum(condProbInterested)
auxPartSum=0.0
## Now we will choose in behalf of which campaign to bid for.
numInterest = len(condProbInterested)
auxPosForindBuyerL2 = numInterest-1
z = 0
while z <numInterest:
auxPartSum += condProbInterested[z]
if auxPartSum >= unifs[1]:
## If we exceed unifs[1] go out of the loop
auxPosForindBuyerL2=z
z+=numInterest
z += 1
indBuyerL2=posInt[auxPosForindBuyerL2]
tryToBidL2=True
bidAmountL2=mat_bid_by_ImpL2[indBuyerL2, impType]
if(tryToBidL2):
cartBidsL2[indBuyerL2, impType]+=1
if bidAmountL2>= mp_value:
## Impression Won.
cartWonL2[indBuyerL2, impType]+=1
costBidsL2[impType]-=mp_value
profitL2[impType]-=mp_value
# Now we need to check if the ad was clicked.
probOfClick=mat_ctrTest[indBuyerL2, impType]
if (unifs[2]<=probOfClick):
## User clicked, increase revenue and charge the campaign.
cartClickedL2[indBuyerL2, impType]+=1
payment=mat_r_by_Imp[indBuyerL2, impType]
revenueL2[impType]+=payment
profitL2[impType]+=payment
budgetL2[indBuyerL2]-=payment
## Update L2Ind (Same code as done before for the pure indicator case)
indBuyerL2Ind=0
tryToBidL2Ind=False
bidAmountL2Ind=0.0
if unifs[0] <= probBidL2Ind[impType]:
## For each campaign we check if there is any that has enough budget to bid and that
## also wants to do so.
bidUsingL2Ind=False
indInterested =\
(mat_r_by_Imp[listCampPerImp[impType],impType] <= budgetL2Ind[listCampPerImp[impType]]) * \
(mat_x_by_ImpL2Ind[listCampPerImp[impType],impType]>0)
if np.sum(indInterested) >0:
bidUsingL2Ind= True
if bidUsingL2Ind:
## There is at least one campaign that wants to bid.
posInt=listCampPerImp[impType][indInterested]
## Conditional probability assuming that the method is going to bid.
## This conditional probability excludes all those campaigns
## that do not want to bid
condProbInterested=mat_x_by_ImpL2Ind[posInt, impType]
condProbInterested*=1.0/np.sum(condProbInterested)
auxPartSum=0.0
## Now we will choose in behalf of which campaign to bid for.
numInterest = len(condProbInterested)
auxPosForindBuyerL2Ind = numInterest-1
z = 0
while z < numInterest:
auxPartSum += condProbInterested[z]
if auxPartSum >= unifs[1]:
## If we exceed unifs[1] go out of the loop
auxPosForindBuyerL2Ind=z
z+=numInterest
z += 1
indBuyerL2Ind=posInt[auxPosForindBuyerL2Ind]
tryToBidL2Ind=True
bidAmountL2Ind = mat_bid_by_ImpL2Ind[indBuyerL2Ind, impType]
if(tryToBidL2Ind):
cartBidsL2Ind[indBuyerL2Ind, impType]+=1
if bidAmountL2Ind>= mp_value:
## Impression Won.
cartWonL2Ind[indBuyerL2Ind, impType]+=1
costBidsL2Ind[impType]-=mp_value
profitL2Ind[impType]-=mp_value
# Now we need to check if the ad was clicked.
probOfClick=mat_ctrTest[indBuyerL2Ind, impType]
if (unifs[2]<=probOfClick):
## User clicked, increase revenue and charge the campaign.
cartClickedL2Ind[indBuyerL2Ind, impType]+=1
payment=mat_r_by_Imp[indBuyerL2Ind, impType]
revenueL2Ind[impType]+=payment
profitL2Ind[impType]+=payment
budgetL2Ind[indBuyerL2Ind]-=payment
### Now we update the Greedy Policy
## The greedy heuristic bids for the campaign which stills have remaining
## budget and from thos bid for the one with highest r times ctr.
## The previous is true as Ipinyou assumes second price auctions.
indBuyerGr=-1
bidAmountGr=0.0
tryToBidGr=False
indInterested =\
mat_r_by_Imp[listCampPerImp[impType],impType] <= budgetGr[listCampPerImp[impType]]
if np.sum(indInterested) > 0:
posInt=listCampPerImp[impType][indInterested]
indBuyerGr = posInt[np.argmax(mat_rctr_by_ImpTrain[posInt,impType])]
bidAmountGr = mat_rctr_by_ImpTrain[indBuyerGr, impType]
tryToBidGr = True
## If tryToBidGr == True, we will bid in behalf of campaign 'indBuyerGr'
## the amount 'bidAmountGr'
if (tryToBidGr):
## Save that we are bidding in behalf of 'indBuyerGr' for an impression of
## type 'impType'
cartBidsGr[indBuyerGr, impType]+=1
## We win the auction only if the value we are bidding is higher
## than the market price observed by Ipinyou.
if bidAmountGr>= mp_value:
## Impression Won.
cartWonGr[indBuyerGr, impType]+=1
costBidsGr[impType]-=mp_value
profitGr[impType]-=mp_value
# Now we need to check if the ad was clicked.
probOfClick=mat_ctrTest[indBuyerGr, impType]
if (unifs[2]<=probOfClick):
## User clicked, increase revenue and charge the campaign.
cartClickedGr[indBuyerGr, impType]+=1
payment=mat_r_by_Imp[indBuyerGr, impType]
revenueGr[impType]+=payment
profitGr[impType]+=payment
budgetGr[indBuyerGr]-=payment
return [budgetInd, cartBidsInd, cartWonInd, cartClickedInd, costBidsInd, revenueInd, \
profitInd, budgetL2, cartBidsL2, cartWonL2, cartClickedL2, costBidsL2, revenueL2, \
profitL2, budgetL2Ind, cartBidsL2Ind, cartWonL2Ind, cartClickedL2Ind, costBidsL2Ind, \
revenueL2Ind, profitL2Ind, budgetGr, cartBidsGr, cartWonGr, cartClickedGr, costBidsGr,\
revenueGr, profitGr]
# ## Simulation for the profit maximization, profit maximization + L2 and Greedy
# Here we want to run the experiment change the budget values to be [(1.0/32.0), (1.0/8.0), .25, 0.5, 1.0]
# of the budgets used by Ipinyou. The iteration over the percentage budget values is done in 'for perc in perVector_m:'
def ExperIndL2IndAndGreedy(numCampaigns, num_impressions, num_edges, index_Imps, \
index_sizeCamps, PPFTable, numericBeta, vector_q, vector_mOrigTest, \
vector_sTest, vector_ctrTrain, vector_ctrTest, ImpInOrder, MPInOrder, impNames, \
alphasInd, num_itInd, alphasL2Ind, num_itL2Ind, p_grad_TypeInd, p_grad_TypeL2Ind, \
tau, init_lam, listCampPerImp, perVector_m=[(1.0/32.0), (1.0/8.0), .25, 0.5, 1.0], sim=100):
print('Starting ExperIndL2IndAndGreedy')
## The gradient type is needed as the different utility functions have different forms
## for p'(\cdot), and we want to use the right subgradient depending on the method we are using.
global p_grad_Type
vector_rctrTrain=np.multiply(vector_q, vector_ctrTrain)
vector_rctrTest=np.multiply(vector_q, vector_ctrTest)
dictToRetInd={}
dictToRetL2Ind={}
dictToRetGr={}
for perc in perVector_m:
## We first run the primal dual-subgradient method using the pure indicator utility function first
## and then the indicator plus l2 penalization.
print("Percentage: "+str(perc))
vector_m = vector_mOrigTest*perc
vector_s = vector_sTest
ext_s = vector_s[index_Imps]
dictToRetInd[perc]=[]
dictToRetL2Ind[perc]=[]
dictToRetGr[perc]=[]
p_grad_Type=p_grad_TypeInd
print('About to Run the SubgrAlgSavPrimDualObjInd using '+str(num_itInd)+' iterations')
initTime =time.time()
[dual_FnValues, primal_GivenMu, budget_used, dual_vars, dual_AvgLamFnValues, \
primal_AvgLamGivenMu, budget_LamAvgUse, dual_varsAvg]=SubgrAlgSavPrimDualObjInd(\
init_lam, num_itInd, alphasInd, vector_q, vector_ctrTrain, vector_rctrTrain, vector_s, ext_s, \
vector_m, num_impressions, numCampaigns, num_edges, \
PPFTable, numericBeta, index_sizeCamps, index_Imps, (num_itInd-1), p_grad_Type)
print("Took: "+str( time.time()-initTime)+' seconds')
#print("Duality Gap Last Iteration")
#print(str(dual_AvgLamFnValues[len(dual_AvgLamFnValues)-1]-primal_AvgLamGivenMu[len(primal_AvgLamGivenMu)-1]))
lamFinal=dual_varsAvg[len(dual_varsAvg)-1]
ext_LamFinal=ExtendSizeCamps(lamFinal, index_sizeCamps)
bidsInd=OptimalBids(ext_LamFinal, vector_rctrTrain)
[rho_eval_Ind, beta_eval_Ind]=CalcRhoAndBetaVectors(bidsInd, num_edges, index_Imps, PPFTable, numericBeta)
xInd = CalculateLPGurobi(rho_eval_Ind, beta_eval_Ind, vector_rctrTrain, vector_m, \
ext_s, num_impressions, numCampaigns, num_edges, index_Imps, \
index_sizeCamps)
# xInd=OptimalX(beta_eval, rho_eval, ext_LamFinal, ext_s, vector_rctrTrain, num_edges, numCampaigns, \
# num_impressions, index_Imps, index_sizeCamps)
print('')
print('')
print('About to Run the SubgrAlgSavPrimDualObjFn_L2Ind using '+str(num_itL2Ind)+' iterations')
initTime =time.time()
p_grad_Type=p_grad_TypeL2Ind
tau=np.power(vector_m, -1)
[dual_FnValues, primal_GivenMu, budget_used, dual_vars, dual_AvgLamFnValues, \
primal_AvgLamGivenMu, budget_LamAvgUse, dual_varsAvg]=SubgrAlgSavPrimDualObjFn_L2Ind(\
init_lam, num_itL2Ind, alphasL2Ind, vector_q, vector_ctrTrain, vector_rctrTrain, vector_s, ext_s, \
vector_m, num_impressions, numCampaigns, num_edges, PPFTable, numericBeta, index_sizeCamps, \
index_Imps, (num_itL2Ind-1), p_grad_Type, tau, True)
print("Took: "+str( time.time()-initTime)+' seconds')
#print("Duality Gap Last Iteration")
#print(str(dual_AvgLamFnValues[len(dual_AvgLamFnValues)-1]-primal_AvgLamGivenMu[len(primal_AvgLamGivenMu)-1]))
lamFinal=dual_varsAvg[len(dual_varsAvg)-1]
ext_LamFinal=ExtendSizeCamps(lamFinal, index_sizeCamps)
bidsL2Ind=OptimalBids(ext_LamFinal, vector_rctrTrain)
[rho_eval_L2Ind, beta_eval_L2Ind]=CalcRhoAndBetaVectors(bidsL2Ind, num_edges, index_Imps, PPFTable, numericBeta)
xL2Ind = CalculateQuadGurobi(rho_eval_L2Ind, beta_eval_L2Ind, vector_rctrTrain, vector_m, ext_s, \
num_impressions, numCampaigns, num_edges, index_Imps, index_sizeCamps, tau)
# xL2Ind=OptimalX(beta_eval, rho_eval, ext_LamFinal, ext_s, vector_rctrTrain, num_edges, numCampaigns, \
# num_impressions, index_Imps, index_sizeCamps)
## Now that we have run the primal-dual subgradient methods we run simulations of
## how they would perform in the test log as explained in the paper. The nuber of simulations to
## run is equal to the parameter sim.
print('')
print('')
print('Finished running the Primal-Dual Algorithms')
print('Starting RunIndL2IndAndGreedy using '+str(perc)+' percentage of the Test budgets')
initTime =time.time()
for i in range(sim):
[budgetInd, cartBidsInd, cartWonInd, cartClickedInd, costBidsInd, \
revenueInd, profitInd, budgetL2Ind, cartBidsL2Ind, cartWonL2Ind, \
cartClickedL2Ind, costBidsL2Ind, revenueL2Ind, profitL2Ind, budgetGr, \
cartBidsGr, cartWonGr, cartClickedGr, costBidsGr, revenueGr, profitGr]=\
RunIndL2IndAndGreedy(numCampaigns, num_impressions, num_edges, index_Imps, \
index_sizeCamps, PPFTable, numericBeta, vector_q, vector_m, vector_ctrTrain, \
vector_rctrTrain, vector_ctrTest, vector_rctrTest, bidsInd, xInd, bidsL2Ind, \
xL2Ind, tau, ImpInOrder, MPInOrder, impNames,listCampPerImp)
dictToRetInd[perc].append([budgetInd, cartBidsInd, cartWonInd, \
cartClickedInd, costBidsInd, revenueInd, profitInd])
dictToRetL2Ind[perc].append([budgetL2Ind, cartBidsL2Ind, cartWonL2Ind, \
cartClickedL2Ind, costBidsL2Ind, revenueL2Ind, profitL2Ind])
dictToRetGr[perc].append([budgetGr, cartBidsGr, cartWonGr, cartClickedGr, \
costBidsGr, revenueGr, profitGr])
# print("Profit Ind: "+str(np.sum(profitInd)))
# print("Profit Gr: "+str(np.sum(profitGr)))
# print("Ratio of Profits: "+str(np.sum(profitInd)/np.sum(profitGr)))
print("Took: "+str(time.time()-initTime)+' seconds')
return [dictToRetInd, dictToRetL2Ind, dictToRetGr]
def Exper_Ind_L2_L2Ind_Greedy(numCampaigns, num_impressions, num_edges, index_Imps, index_sizeCamps,\
PPFTable, numericBeta, vector_q, vector_mOrigTest, vector_sTest, vector_ctrTrain, vector_ctrTest, \
ImpInOrder, MPInOrder, impNames, alphasInd, num_itInd, alphasL2, num_itL2, alphasL2Ind, num_itL2Ind,\
p_grad_TypeInd, p_grad_TypeL2, p_grad_TypeL2Ind, tau, init_lam, listCampPerImp,\
perVector_m=[(1.0/32.0), (1.0/8.0), .25, 0.5, 1.0], sim=100):
print('Starting Exper_Ind_L2_L2Ind_Greedy')
## The gradient type is needed as the different utility functions have different forms
## for p'(\cdot), and we want to use the right subgradient depending on the method we are using.
global p_grad_Type
vector_rctrTrain=np.multiply(vector_q, vector_ctrTrain)
vector_rctrTest=np.multiply(vector_q, vector_ctrTest)
dictToRetInd={}
dictToRetL2={}
dictToRetL2Ind={}
dictToRetGr={}
for perc in perVector_m:
## We first run the primal dual-subgradient method using the pure indicator utility function first
## and then the indicator plus l2 penalization.
print("Percentage: "+str(perc))
vector_m = vector_mOrigTest*perc
vector_s = vector_sTest
ext_s = vector_s[index_Imps]
dictToRetInd[perc] = []
dictToRetL2[perc] = []
dictToRetL2Ind[perc] = []
dictToRetGr[perc] = []
p_grad_Type=p_grad_TypeInd
print('About to Run the SubgrAlgSavPrimDualObjInd using '+str(num_itInd)+' iterations')
initTime =time.time()
[dual_FnValues, primal_GivenMu, budget_used, dual_vars, dual_AvgLamFnValues, \
primal_AvgLamGivenMu, budget_LamAvgUse, dual_varsAvg]=SubgrAlgSavPrimDualObjInd(\
init_lam, num_itInd, alphasInd, vector_q, vector_ctrTrain, vector_rctrTrain, vector_s, ext_s, \
vector_m, num_impressions, numCampaigns, num_edges, \
PPFTable, numericBeta, index_sizeCamps, index_Imps, (num_itInd-1), p_grad_Type)
print("Took: "+str( time.time()-initTime)+' seconds')
#print("Duality Gap Last Iteration")
#print(str(dual_AvgLamFnValues[len(dual_AvgLamFnValues)-1]-primal_AvgLamGivenMu[len(primal_AvgLamGivenMu)-1]))
lamFinal=dual_varsAvg[len(dual_varsAvg)-1]
ext_LamFinal=ExtendSizeCamps(lamFinal, index_sizeCamps)
bidsInd=OptimalBids(ext_LamFinal, vector_rctrTrain)
[rho_eval_Ind, beta_eval_Ind]=CalcRhoAndBetaVectors(bidsInd, num_edges, index_Imps, PPFTable, numericBeta)
xInd = CalculateLPGurobi(rho_eval_Ind, beta_eval_Ind, vector_rctrTrain, vector_m, \
ext_s, num_impressions, numCampaigns, num_edges, index_Imps, \
index_sizeCamps)
# xInd=OptimalX(beta_eval, rho_eval, ext_LamFinal, ext_s, vector_rctrTrain, num_edges, numCampaigns, \
# num_impressions, index_Imps, index_sizeCamps)
print('')
print('')
print('About to Run the SubgrAlgSavPrimDualObjFn_L2Ind using '+str(num_itL2Ind)+' iterations without Indicator')
initTime =time.time()
p_grad_Type=p_grad_TypeL2
tau=np.power(vector_m, -1)
[dual_FnValues, primal_GivenMu, budget_used, dual_vars, dual_AvgLamFnValues, \
primal_AvgLamGivenMu, budget_LamAvgUse, dual_varsAvg]=SubgrAlgSavPrimDualObjFn_L2Ind(\
init_lam, num_itL2Ind, alphasL2Ind, vector_q, vector_ctrTrain, vector_rctrTrain, vector_s, ext_s, \
vector_m, num_impressions, numCampaigns, num_edges, PPFTable, numericBeta, index_sizeCamps, \
index_Imps, (num_itL2Ind-1), p_grad_Type, tau, False)
print("Took: "+str( time.time()-initTime)+' seconds')
#print("Duality Gap Last Iteration")
#print(str(dual_AvgLamFnValues[len(dual_AvgLamFnValues)-1]-primal_AvgLamGivenMu[len(primal_AvgLamGivenMu)-1]))
lamFinal=dual_varsAvg[len(dual_varsAvg)-1]
ext_LamFinal=ExtendSizeCamps(lamFinal, index_sizeCamps)
bidsL2=OptimalBids(ext_LamFinal, vector_rctrTrain)
[rho_eval_L2, beta_eval_L2]=CalcRhoAndBetaVectors(bidsL2, num_edges, index_Imps, PPFTable, numericBeta)
xL2 = CalculateQuadGurobi(rho_eval_L2, beta_eval_L2, vector_rctrTrain, vector_m, ext_s, \
num_impressions, numCampaigns, num_edges, index_Imps, index_sizeCamps, tau, addIndicator = False)
print('')
print('')
print('About to Run the SubgrAlgSavPrimDualObjFn_L2Ind using '+str(num_itL2Ind)+' iterations')
initTime =time.time()
p_grad_Type=p_grad_TypeL2Ind
tau=np.power(vector_m, -1)
[dual_FnValues, primal_GivenMu, budget_used, dual_vars, dual_AvgLamFnValues, \
primal_AvgLamGivenMu, budget_LamAvgUse, dual_varsAvg]=SubgrAlgSavPrimDualObjFn_L2Ind(\
init_lam, num_itL2Ind, alphasL2Ind, vector_q, vector_ctrTrain, vector_rctrTrain, vector_s, ext_s, \
vector_m, num_impressions, numCampaigns, num_edges, PPFTable, numericBeta, index_sizeCamps, \
index_Imps, (num_itL2Ind-1), p_grad_Type, tau, True)
print("Took: "+str( time.time()-initTime)+' seconds')
#print("Duality Gap Last Iteration")
#print(str(dual_AvgLamFnValues[len(dual_AvgLamFnValues)-1]-primal_AvgLamGivenMu[len(primal_AvgLamGivenMu)-1]))
lamFinal=dual_varsAvg[len(dual_varsAvg)-1]
ext_LamFinal=ExtendSizeCamps(lamFinal, index_sizeCamps)
bidsL2Ind=OptimalBids(ext_LamFinal, vector_rctrTrain)
[rho_eval_L2Ind, beta_eval_L2Ind]=CalcRhoAndBetaVectors(bidsL2Ind, num_edges, index_Imps, PPFTable, numericBeta)
xL2Ind = CalculateQuadGurobi(rho_eval_L2Ind, beta_eval_L2Ind, vector_rctrTrain, vector_m, ext_s, \
num_impressions, numCampaigns, num_edges, index_Imps, index_sizeCamps, tau, addIndicator = True)
# xL2Ind=OptimalX(beta_eval, rho_eval, ext_LamFinal, ext_s, vector_rctrTrain, num_edges, numCampaigns, \
# num_impressions, index_Imps, index_sizeCamps)
## Now that we have run the primal-dual subgradient methods we run simulations of
## how they would perform in the test log as explained in the paper. The nuber of simulations to
## run is equal to the parameter sim.
print('')
print('')
print('Finished running the Primal-Dual Algorithms')
print('Starting RunInd_L2_L2Ind_Greedy using '+str(perc)+' percentage of the Test budgets')
initTime =time.time()
for i in range(sim):
[budgetInd, cartBidsInd, cartWonInd, cartClickedInd, costBidsInd, revenueInd, \
profitInd, budgetL2, cartBidsL2, cartWonL2, cartClickedL2, costBidsL2, revenueL2, \
profitL2, budgetL2Ind, cartBidsL2Ind, cartWonL2Ind, cartClickedL2Ind, costBidsL2Ind, \
revenueL2Ind, profitL2Ind, budgetGr, cartBidsGr, cartWonGr, cartClickedGr, costBidsGr,\
revenueGr, profitGr] = RunInd_L2_L2Ind_Greedy(numCampaigns, num_impressions, num_edges, index_Imps, \
index_sizeCamps, PPFTable, numericBeta, vector_q, vector_m, vector_ctrTrain, \
vector_rctrTrain, vector_ctrTest, vector_rctrTest, bidsInd, xInd, bidsL2, xL2, bidsL2Ind, \
xL2Ind, tau, ImpInOrder, MPInOrder, impNames,listCampPerImp)
dictToRetInd[perc].append([budgetInd, cartBidsInd, cartWonInd, \
cartClickedInd, costBidsInd, revenueInd, profitInd])
dictToRetL2[perc].append([budgetL2, cartBidsL2, cartWonL2, \
cartClickedL2, costBidsL2, revenueL2, profitL2])
dictToRetL2Ind[perc].append([budgetL2Ind, cartBidsL2Ind, cartWonL2Ind, \
cartClickedL2Ind, costBidsL2Ind, revenueL2Ind, profitL2Ind])
dictToRetGr[perc].append([budgetGr, cartBidsGr, cartWonGr, cartClickedGr, \
costBidsGr, revenueGr, profitGr])
print("Took: "+str(time.time()-initTime)+' seconds')
return [dictToRetInd, dictToRetL2, dictToRetL2Ind, dictToRetGr]
def ExperIndL2IndAndGreedyOnePerc(numCampaigns, num_impressions, num_edges, index_Imps, \
index_sizeCamps, PPFTable, numericBeta, vector_q, vector_mOrigTest, \
vector_sTest, vector_ctrTrain, vector_ctrTest, ImpInOrder, MPInOrder, impNames, \
alphasInd, num_itInd, alphasL2Ind, num_itL2Ind, p_grad_TypeInd, p_grad_TypeL2Ind, \
init_lam, listCampPerImp, perc, sim, seeds):
print('Starting ExperIndL2IndAndGreedy')
## The gradient type is needed as the different utility functions have different forms
## for p'(\cdot), and we want to use the right subgradient depending on the method we are using.
np.random.seed(12345)
global p_grad_Type
vector_rctrTrain=np.multiply(vector_q, vector_ctrTrain)
vector_rctrTest=np.multiply(vector_q, vector_ctrTest)
dictToRetInd = {}
dictToRetL2Ind = {}
dictToRetGr = {}
## We first run the primal dual-subgradient method using the pure indicator utility function first
## and then the indicator plus l2 penalization.
print('')
print("Percentage: "+str(perc)+ ', process id: '+str(os.getpid()))
vector_m = vector_mOrigTest[:]*perc
vector_s = vector_sTest[:]
ext_s = vector_s[index_Imps]
dictToRetInd[perc]=[]
dictToRetL2Ind[perc]=[]
dictToRetGr[perc]=[]
p_grad_Type=p_grad_TypeInd
print('About to Run the SubgrAlgSavPrimDualObjInd using '+str(num_itInd)+' iterations, '+'process id: '+str(os.getpid()))
initTime =time.time()
[_, _, _, dual_vars, _, _, _, dual_varsAvg] = SubgrAlgSavPrimDualObjInd(\
init_lam, num_itInd, alphasInd, vector_q, vector_ctrTrain, vector_rctrTrain, vector_s, ext_s, \
vector_m, num_impressions, numCampaigns, num_edges, \
PPFTable, numericBeta, index_sizeCamps, index_Imps, (num_itInd-1), p_grad_Type)
print("Took: "+str( time.time()-initTime)+' seconds, '+'process id: '+str(os.getpid()))
#print("Duality Gap Last Iteration")
#print(str(dual_AvgLamFnValues[len(dual_AvgLamFnValues)-1]-primal_AvgLamGivenMu[len(primal_AvgLamGivenMu)-1]))
lamFinal=dual_varsAvg[len(dual_varsAvg)-1]
ext_LamFinal=ExtendSizeCamps(lamFinal, index_sizeCamps)
bidsInd=OptimalBids(ext_LamFinal, vector_rctrTrain)
[rho_eval_Ind, beta_eval_Ind]=CalcRhoAndBetaVectors(bidsInd, num_edges, index_Imps, PPFTable, numericBeta)
xInd = CalculateLPGurobi(rho_eval_Ind, beta_eval_Ind, vector_rctrTrain, vector_m, \
ext_s, num_impressions, numCampaigns, num_edges, index_Imps, \
index_sizeCamps)
# xInd=OptimalX(beta_eval, rho_eval, ext_LamFinal, ext_s, vector_rctrTrain, num_edges, numCampaigns, \
# num_impressions, index_Imps, index_sizeCamps)
print('')
print('About to Run the SubgrAlgSavPrimDualObjFn_L2Ind using '+str(num_itL2Ind)+' iterations, '+'process id: '+str(os.getpid()))
initTime =time.time()
p_grad_Type=p_grad_TypeL2Ind
tau = np.power(vector_m, -1)
[_, _, _, dual_vars, _, _, _, dual_varsAvg] = SubgrAlgSavPrimDualObjFn_L2Ind(\
init_lam, num_itL2Ind, alphasL2Ind, vector_q, vector_ctrTrain, vector_rctrTrain, vector_s, ext_s, \
vector_m, num_impressions, numCampaigns, num_edges, PPFTable, numericBeta, index_sizeCamps, \
index_Imps, (num_itL2Ind-1), p_grad_Type, tau, True)
print("Took: "+str( time.time()-initTime)+' seconds, '+'process id: '+str(os.getpid()))
#print("Duality Gap Last Iteration")
#print(str(dual_AvgLamFnValues[len(dual_AvgLamFnValues)-1]-primal_AvgLamGivenMu[len(primal_AvgLamGivenMu)-1]))
lamFinal=dual_varsAvg[len(dual_varsAvg) - 1]
ext_LamFinal=ExtendSizeCamps(lamFinal, index_sizeCamps)
bidsL2Ind=OptimalBids(ext_LamFinal, vector_rctrTrain)
[rho_eval_L2Ind, beta_eval_L2Ind] = CalcRhoAndBetaVectors(bidsL2Ind, num_edges, index_Imps, PPFTable, numericBeta)
xL2Ind = CalculateQuadGurobi(rho_eval_L2Ind, beta_eval_L2Ind, vector_rctrTrain, vector_m, ext_s, \
num_impressions, numCampaigns, num_edges, index_Imps, index_sizeCamps, tau)
## Now that we have run the primal-dual subgradient methods we run simulations of
## how they would perform in the test log as explained in the paper. The nuber of simulations to
## run is equal to the parameter sim.
print('Finished running the Primal-Dual Algorithms, '+'process id: '+str(os.getpid()))
print('About to Run the RunIndL2IndAndGreedy using '+str(perc)+' percentage of the Test budgets, '+'process id: '+str(os.getpid()))
initTime = time.time()
for i in range(sim):
np.random.seed(seeds[i])
[budgetInd, cartBidsInd, cartWonInd, cartClickedInd, costBidsInd, \
revenueInd, profitInd, budgetL2Ind, cartBidsL2Ind, cartWonL2Ind, \
cartClickedL2Ind, costBidsL2Ind, revenueL2Ind, profitL2Ind, budgetGr, \
cartBidsGr, cartWonGr, cartClickedGr, costBidsGr, revenueGr, profitGr]=\
RunIndL2IndAndGreedy(numCampaigns, num_impressions, num_edges, index_Imps, \
index_sizeCamps, PPFTable, numericBeta, vector_q, vector_m, vector_ctrTrain, \
vector_rctrTrain, vector_ctrTest, vector_rctrTest, bidsInd, xInd, bidsL2Ind, \
xL2Ind, tau, ImpInOrder, MPInOrder, impNames,listCampPerImp)
dictToRetInd[perc].append([budgetInd, cartBidsInd, cartWonInd, \
cartClickedInd, costBidsInd, revenueInd, profitInd])
dictToRetL2Ind[perc].append([budgetL2Ind, cartBidsL2Ind, cartWonL2Ind, \
cartClickedL2Ind, costBidsL2Ind, revenueL2Ind, profitL2Ind])
dictToRetGr[perc].append([budgetGr, cartBidsGr, cartWonGr, cartClickedGr, \
costBidsGr, revenueGr, profitGr])
# print("Profit Ind: "+str(np.sum(profitInd)))
# print("Profit Gr: "+str(np.sum(profitGr)))
# print("Ratio of Profits: "+str(np.sum(profitInd)/np.sum(profitGr)))
print("Took: "+str(time.time()-initTime)+' seconds')
return [dictToRetInd, dictToRetL2Ind, dictToRetGr]
def Exper_Ind_L2_L2Ind_GreedyOnePerc(numCampaigns, num_impressions, num_edges, index_Imps, index_sizeCamps,\
PPFTable, numericBeta, vector_q, vector_mOrigTest, vector_sTest, vector_ctrTrain, vector_ctrTest, \
ImpInOrder, MPInOrder, impNames, alphasInd, num_itInd, alphasL2, num_itL2, alphasL2Ind, num_itL2Ind,\
p_grad_TypeInd, p_grad_TypeL2, p_grad_TypeL2Ind, init_lam, listCampPerImp,\
perc, sim, seeds, tauMult = -1):
print('Starting Exper_Ind_L2_L2Ind_Greedy')
## The gradient type is needed as the different utility functions have different forms
## for p'(\cdot), and we want to use the right subgradient depending on the method we are using.
np.random.seed(12345)
global p_grad_Type
vector_rctrTrain = np.multiply(vector_q, vector_ctrTrain)
vector_rctrTest = np.multiply(vector_q, vector_ctrTest)
dictToRetInd = {}
dictToRetL2 = {}
dictToRetL2Ind = {}
dictToRetGr = {}
print('')
print("Percentage: "+str(perc)+ ', process id: '+str(os.getpid()))
vector_m = vector_mOrigTest[:]*perc
vector_s = vector_sTest[:]
ext_s = vector_s[index_Imps]
dictToRetInd[perc] = []
dictToRetL2[perc] = []
dictToRetL2Ind[perc] = []
dictToRetGr[perc] = []
p_grad_Type=p_grad_TypeInd
print('About to Run the SubgrAlgSavPrimDualObjInd using '+str(num_itInd)+' iterations')
initTime =time.time()
[dual_FnValues, primal_GivenMu, budget_used, dual_vars, dual_AvgLamFnValues, \
primal_AvgLamGivenMu, budget_LamAvgUse, dual_varsAvg]=SubgrAlgSavPrimDualObjInd(\
init_lam, num_itInd, alphasInd, vector_q, vector_ctrTrain, vector_rctrTrain, vector_s, ext_s, \
vector_m, num_impressions, numCampaigns, num_edges, \
PPFTable, numericBeta, index_sizeCamps, index_Imps, (num_itInd-1), p_grad_Type)
print("Took: "+str( time.time()-initTime)+' seconds')
#print("Duality Gap Last Iteration")
#print(str(dual_AvgLamFnValues[len(dual_AvgLamFnValues)-1]-primal_AvgLamGivenMu[len(primal_AvgLamGivenMu)-1]))
lamFinal=dual_varsAvg[len(dual_varsAvg)-1]
ext_LamFinal=ExtendSizeCamps(lamFinal, index_sizeCamps)
bidsInd=OptimalBids(ext_LamFinal, vector_rctrTrain)
[rho_eval_Ind, beta_eval_Ind]=CalcRhoAndBetaVectors(bidsInd, num_edges, index_Imps, PPFTable, numericBeta)
xInd = CalculateLPGurobi(rho_eval_Ind, beta_eval_Ind, vector_rctrTrain, vector_m, \
ext_s, num_impressions, numCampaigns, num_edges, index_Imps, \
index_sizeCamps)
# xInd=OptimalX(beta_eval, rho_eval, ext_LamFinal, ext_s, vector_rctrTrain, num_edges, numCampaigns, \
# num_impressions, index_Imps, index_sizeCamps)
print('')
print('')
print('About to Run the SubgrAlgSavPrimDualObjFn_L2Ind using '+str(num_itL2Ind)+' iterations without Indicator')
initTime =time.time()
p_grad_Type=p_grad_TypeL2
tau=np.power(vector_m, -1) * tauMult
[dual_FnValues, primal_GivenMu, budget_used, dual_vars, dual_AvgLamFnValues, \
primal_AvgLamGivenMu, budget_LamAvgUse, dual_varsAvg]=SubgrAlgSavPrimDualObjFn_L2Ind(\
init_lam, num_itL2Ind, alphasL2Ind, vector_q, vector_ctrTrain, vector_rctrTrain, vector_s, ext_s, \
vector_m, num_impressions, numCampaigns, num_edges, PPFTable, numericBeta, index_sizeCamps, \
index_Imps, (num_itL2Ind-1), p_grad_Type, tau, False)
print("Took: "+str( time.time()-initTime)+' seconds')
#print("Duality Gap Last Iteration")
#print(str(dual_AvgLamFnValues[len(dual_AvgLamFnValues)-1]-primal_AvgLamGivenMu[len(primal_AvgLamGivenMu)-1]))
lamFinal=dual_varsAvg[len(dual_varsAvg)-1]
ext_LamFinal=ExtendSizeCamps(lamFinal, index_sizeCamps)
bidsL2=OptimalBids(ext_LamFinal, vector_rctrTrain)
[rho_eval_L2, beta_eval_L2]=CalcRhoAndBetaVectors(bidsL2, num_edges, index_Imps, PPFTable, numericBeta)
xL2 = CalculateQuadGurobi(rho_eval_L2, beta_eval_L2, vector_rctrTrain, vector_m, ext_s, \
num_impressions, numCampaigns, num_edges, index_Imps, index_sizeCamps, tau, addIndicator = False)
print('')
print('')
print('About to Run the SubgrAlgSavPrimDualObjFn_L2Ind using '+str(num_itL2Ind)+' iterations')
initTime =time.time()
p_grad_Type=p_grad_TypeL2Ind
[dual_FnValues, primal_GivenMu, budget_used, dual_vars, dual_AvgLamFnValues, \
primal_AvgLamGivenMu, budget_LamAvgUse, dual_varsAvg]=SubgrAlgSavPrimDualObjFn_L2Ind(\
init_lam, num_itL2Ind, alphasL2Ind, vector_q, vector_ctrTrain, vector_rctrTrain, vector_s, ext_s, \
vector_m, num_impressions, numCampaigns, num_edges, PPFTable, numericBeta, index_sizeCamps, \
index_Imps, (num_itL2Ind-1), p_grad_Type, tau, True)
print("Took: "+str( time.time()-initTime)+' seconds')
#print("Duality Gap Last Iteration")
#print(str(dual_AvgLamFnValues[len(dual_AvgLamFnValues)-1]-primal_AvgLamGivenMu[len(primal_AvgLamGivenMu)-1]))
lamFinal=dual_varsAvg[len(dual_varsAvg)-1]
ext_LamFinal=ExtendSizeCamps(lamFinal, index_sizeCamps)
bidsL2Ind=OptimalBids(ext_LamFinal, vector_rctrTrain)
[rho_eval_L2Ind, beta_eval_L2Ind]=CalcRhoAndBetaVectors(bidsL2Ind, num_edges, index_Imps, PPFTable, numericBeta)
xL2Ind = CalculateQuadGurobi(rho_eval_L2Ind, beta_eval_L2Ind, vector_rctrTrain, vector_m, ext_s, \
num_impressions, numCampaigns, num_edges, index_Imps, index_sizeCamps, tau, addIndicator = True)
# xL2Ind=OptimalX(beta_eval, rho_eval, ext_LamFinal, ext_s, vector_rctrTrain, num_edges, numCampaigns, \
# num_impressions, index_Imps, index_sizeCamps)
## Now that we have run the primal-dual subgradient methods we run simulations of
## how they would perform in the test log as explained in the paper. The nuber of simulations to
## run is equal to the parameter sim.
print('')
print('')
print('Finished running the Primal-Dual Algorithms')
print('Starting RunInd_L2_L2Ind_Greedy using '+str(perc)+' percentage of the Test budgets')
initTime =time.time()
for i in range(sim):
np.random.seed(seeds[i])
[budgetInd, cartBidsInd, cartWonInd, cartClickedInd, costBidsInd, revenueInd, \
profitInd, budgetL2, cartBidsL2, cartWonL2, cartClickedL2, costBidsL2, revenueL2, \
profitL2, budgetL2Ind, cartBidsL2Ind, cartWonL2Ind, cartClickedL2Ind, costBidsL2Ind, \
revenueL2Ind, profitL2Ind, budgetGr, cartBidsGr, cartWonGr, cartClickedGr, costBidsGr,\
revenueGr, profitGr] = RunInd_L2_L2Ind_Greedy(numCampaigns, num_impressions, num_edges, index_Imps, \
index_sizeCamps, PPFTable, numericBeta, vector_q, vector_m, vector_ctrTrain, \
vector_rctrTrain, vector_ctrTest, vector_rctrTest, bidsInd, xInd, bidsL2, xL2, bidsL2Ind, \
xL2Ind, tau, ImpInOrder, MPInOrder, impNames,listCampPerImp)
dictToRetInd[perc].append([budgetInd, cartBidsInd, cartWonInd, \
cartClickedInd, costBidsInd, revenueInd, profitInd])
dictToRetL2[perc].append([budgetL2, cartBidsL2, cartWonL2, \
cartClickedL2, costBidsL2, revenueL2, profitL2])
dictToRetL2Ind[perc].append([budgetL2Ind, cartBidsL2Ind, cartWonL2Ind, \
cartClickedL2Ind, costBidsL2Ind, revenueL2Ind, profitL2Ind])
dictToRetGr[perc].append([budgetGr, cartBidsGr, cartWonGr, cartClickedGr, \
costBidsGr, revenueGr, profitGr])
print("Took: "+str(time.time()-initTime)+' seconds')
return [dictToRetInd, dictToRetL2, dictToRetL2Ind, dictToRetGr]
## For the Pareto Experiment we need to Run only the L2+Indicator for several values of \tau a
## number of simulations. We also need to run the greedy method
def RunSimOnlyGreedy(numCampaigns, num_impressions, num_edges, index_Imps, \
index_sizeCamps, PPFTable, numericBeta, vector_q, vector_m, vector_ctrTrain,\
vector_rctrTrain, vector_ctrTest, vector_rctrTest, ImpInOrder, MPInOrder, impNames,\
listCampPerImp, mult = 1.0):
## We first initialize the budgets used, matrices of bids made, won, and clicked for
## three methods.
[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, mat_rctr_by_ImpTrain, _, _, \
_, _, _]=CreateDataForSimulation(np.zeros(num_edges), np.zeros(num_edges), \
numCampaigns, num_impressions, num_edges, index_Imps, index_sizeCamps, \
vector_q, vector_ctrTrain, vector_rctrTrain, vector_m, PPFTable, numericBeta)
[_, _, _, _, _, _, _, budgetGr, cartBidsGr, cartWonGr, \
cartClickedGr, costBidsGr, revenueGr, profitGr, mat_r_by_Imp, \
mat_ctrTest, _, _, _, _, _, _]=CreateDataForSimulation(np.zeros(num_edges), \
| np.zeros(num_edges) | numpy.zeros |
from pathlib import Path
from argparse import Namespace
import numpy as np
import torch
from torch.utils.data import DataLoader
from torchvision.transforms import Compose, Resize, Normalize
from model import lpn
from model.estimator_2d import Estimator2D
from data.video_dataset import VideoDataset
from data.bbox_utils import xywh2cs, adjust_aspect_ratio
from data.data_utils import suggest_metadata
from data.person_detection import detect_person
class LPN_Estimator2D(Estimator2D):
"""2D human pose estimator using lpn-pytorch (https://github.com/zhang943/lpn-pytorch)"""
PRETRAINED_GID = '<KEY>'
CFG_FILE = 'model/configs/lpn50_256x192_gd256x2_gc.yaml'
CKPT_FILE = 'model/checkpoints/lpn_50_256x192.pth'
BATCH_SIZE = 64
def __init__(self, device='cpu'):
self.device = device
# download pretrained weights if necessary
if not Path(self.CKPT_FILE).exists():
self.download_weights()
# load pretrained lpn pose network
self.model, self.cfg = self.create_lpn_model(
Path(self.CFG_FILE).resolve(),
Path(self.CKPT_FILE).resolve())
def download_weights(self):
try:
from google_drive_downloader import GoogleDriveDownloader as gdd
gdd.download_file_from_google_drive(self.PRETRAINED_GID, self.CKPT_FILE)
except ImportError as error:
print('GoogleDriveDownloader has to be installed for automatic download' \
'You can download the weights manually under: https://drive.google.com/file/d/1dldLwjOacXV_uGkbxfEIPPJEK_2A-Snp/view?usp=sharing')
def create_lpn_model(self, cfg_file, ckp_file):
# create Configs
args = Namespace(cfg = cfg_file, modelDir='', logDir='')
lpn.update_config(lpn.cfg, args)
# Use cfg to create model
pose_model = lpn.get_pose_net(lpn.cfg, is_train=False)
# load pretrained weights
if torch.cuda.is_available():
pose_model = pose_model.cuda()
pose_model.load_state_dict(torch.load(ckp_file), strict=False)
else:
checkpoint = torch.load(ckp_file, map_location=torch.device(self.device))
pose_model.load_state_dict(checkpoint, strict=False)
pose_model.eval()
return pose_model, lpn.cfg
def default_transform(self):
return Compose([
Resize((256, 192)),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
def estimate(self, video):
# person detection on every 3rd frame interpolating in between
bboxes = detect_person('yolov5s', video, pred_every=3)
# Convert bboxes to correct aspect ratio
bboxes = | np.apply_along_axis(adjust_aspect_ratio, 1, bboxes, aspect_ratio=3/4) | numpy.apply_along_axis |
'''
Sampling source images from SMOT dataset
Download: https://www.acin.tuwien.ac.at/en/vision-for-robotics/software-tools/smot/
usage: python3 data_processing/process_SMOT.py [path/to/smot] [obj_name=="obj_01/obj_02/..."]
'''
#uniformly sample object crops using a renderer
import sys,os
sys.path.append(os.path.abspath('.')) # To find local version of the library
sys.path.append(os.path.abspath('../')) # To find local version of the library
from NOL_model import NOL_network as NOLnet
import cv2
import numpy as np
import open3d as o3d
import copy
from sklearn.neighbors import NearestNeighbors
from matplotlib import pyplot as plt
from skimage.transform import resize
import h5py
import math
from skimage.transform import resize
import NOL_tools.operations as to
import shutil
import transforms3d as tf3d
import json
if(len(sys.argv)<3):
print("usage: python3 data_processing/process_SMOT.py [path/to/smot] [obj_name e.g., obj_01,obj_02,...] [icp=yes(1)/no(0),default=1]")
sys.exit()
#smot_dir ="/root/hdd_linux/SMOT_Upload" #sys.argv[1]
#t_label="obj_01"
smot_dir=sys.argv[1]
t_label=sys.argv[2]
icp=1
if(len(sys.argv)==4):
icp=int(sys.argv[3])
#Load Camera parameters of SMOT dataset
camera_intrinsic_fn = os.path.join(smot_dir,"camera_intrinsic.json")
with open(camera_intrinsic_fn, 'r') as f:
camera_intrinsic = json.load(f)
cam_K=np.array(camera_intrinsic['intrinsic_matrix']).reshape(3,3).T
fx = cam_K[0,0]
fy = cam_K[1,1]
cx = cam_K[0,2]
cy = cam_K[1,2]
im_width = camera_intrinsic['width']
im_height = camera_intrinsic['height']
depth_th = 0.05 #depth threshold for visible mask
#Read GTS
d_type='train'
if(int(t_label[-2:])<5):
#obj_01~04: sequence 1
test_dir = os.path.join(smot_dir,d_type+"/seq{}".format(1))
else:
#obj_05~08: sequence 2
test_dir = os.path.join(smot_dir,d_type+"/seq{}".format(2))
gt_fn = os.path.join(test_dir,"scene_gt.json")
with open(gt_fn, 'r') as f:
scene_gt_smot = json.load(f)
#Define renderer
renderer = NOLnet.simple_render(img_h=im_height,img_w=im_width,cam_K=cam_K)
print("Loading the 3D model")
ply_fn = os.path.join(smot_dir,"models/{}.ply".format(t_label))
mesh = o3d.io.read_triangle_mesh(ply_fn)
vertices =np.array(mesh.vertices)
faces = np.array(mesh.triangles)
print("Computing visible verticies in each image")
n_scenes= len(scene_gt_smot.keys())
img_cnt=0
poses=[]
visible_verts=[]
v_ids=[]
scores=[] #visibility score to select the best image (with less occlusion) at the beginning
for s_id in sorted(scene_gt_smot.keys()):
scene_id = int(s_id)
gts= scene_gt_smot[str(scene_id)]
rgb_path = test_dir+"/color/{:06d}.png".format(scene_id)
depth_path = test_dir+"/depth/{:06d}.png".format(scene_id)
#img = cv2.imread(rgb_path)[:,:,::-1] #rgb is not necessary this time
depth = cv2.imread(depth_path,cv2.CV_16UC1)/1000
has_obj=False
for gt in gts:
obj_id = gt['obj_id']
if(int(obj_id)==int(t_label[-2:])):
tf_mat = np.eye(4)
tf_mat[:3,:3] =np.array(gt['cam_R_m2c']).reshape(3,3)
tf_mat[:3,3] =np.array(gt['cam_t_m2c'])
has_obj=True
break
if(has_obj):
simple_xyz = renderer.predict([np.array([vertices]),np.array([faces]),
np.array([tf_mat])])[0]
depth_r = simple_xyz[:,:,3]
mask = np.logical_and(np.abs(depth_r-depth)<depth_th,depth_r>0)
valid_vertices = to.get_valid_vertices(vertices,faces,depth_r,tf_mat,cam_K,im_width,im_height,
mask=mask)
n_full = np.sum(depth_r>0)
n_visible = np.sum(mask)
visratio=n_visible/n_full
scores.append(n_visible/n_full)
poses.append(tf_mat)
v_ids.append(s_id)
visible_verts.append(valid_vertices)
if(len(v_ids)%10==0):
print("processing: {:04d}/{:04d}".format(len(v_ids),n_scenes))
print("Finished:Computing visible verticies")
print("Iteratively adding new source images...")
scores=np.array(scores)
sorted_idx = np.argsort(scores).tolist()
th_trans = 0.3
th_rot = 45
selected_frames=[]
visible_v =np.copy(np.array(visible_verts))
sum_visible = np.zeros((visible_v.shape[1]))
data_idx=np.arange(scores.shape[0])
max_n=15 #limit maximum number of images
while visible_v.shape[0]>0:
active_idx = np.ones((visible_v.shape[0]),bool)
after_visible = sum_visible+visible_v
vert_score = np.sum(np.tanh(1.5*after_visible),axis=1)
idx =np.argmax(vert_score)
active_idx[idx]=0
before = np.sum(np.tanh(1.5*sum_visible))
sum_visible+= visible_v[idx]
after = np.sum(np.tanh(1.5*sum_visible))
print("Increased score for the observed vertices:", after-before)
if(after-before<1): #terminate the improvement is less than 1
break
d_idx = data_idx[idx]
score = scores[d_idx]
pose_q = poses[d_idx]
v_id = v_ids[d_idx]
selected_frames.append(v_id)
if(len(selected_frames)>max_n):
break
for del_id,idx_c in enumerate(data_idx):
pose_c = poses[idx_c]
tra_diff = np.linalg.norm(pose_c[:3,3]-pose_q[:3,3])
if(tra_diff<0.1):
rot_diff = np.abs(np.degrees(np.array(tf3d.euler.mat2euler(np.matmul( np.linalg.inv(pose_c[:3,:3]),pose_q[:3,:3])))))
if(rot_diff[0]<15 and rot_diff[1]<15 and rot_diff[2]<15 ): #consider the flipped hand
active_idx[del_id]=0
data_idx = data_idx[active_idx]
visible_v = visible_v[active_idx]
print("No. selected frames:",len(selected_frames))
print("Selected frames:",selected_frames)
print("Save selected frames to the NOL source format (.hdf5)")
if(icp==1):
print("ICP is enabled")
else:
print("[INFO] It is possible to perform ICP to have better poses using depth images, but it sometimes produces worse poses")
input_imgs=[]
poses_=[]
masks=[]
bboxes=[]
source_imgs=[]
for s_id in selected_frames:
scene_id = int(s_id)
gts= scene_gt_smot[str(scene_id)]
rgb_path = test_dir+"/color/{:06d}.png".format(scene_id)
depth_path = test_dir+"/depth/{:06d}.png".format(scene_id)
img = cv2.imread(rgb_path)[:,:,::-1] #rgb is not necessary this time
depth = cv2.imread(depth_path,cv2.CV_16UC1)/1000
has_obj=False
for gt in gts:
obj_id = gt['obj_id']
if(int(obj_id)==int(t_label[-2:])):
tf_mat = np.eye(4)
tf_mat[:3,:3] =np.array(gt['cam_R_m2c']).reshape(3,3)
tf_mat[:3,3] =np.array(gt['cam_t_m2c'])
has_obj=True
break
#noICP
simple_xyz = renderer.predict([np.array([vertices]),np.array([faces]),
np.array([tf_mat])])[0]
depth_r = simple_xyz[:,:,3]
mask = np.logical_and(np.abs(depth_r-depth)<depth_th,depth_r>0)
if(icp==1):
points_src = np.zeros((im_height,im_width,6),np.float32)
points_src[:,:,:3] = to.getXYZ(depth_r,cam_K[0,0],cam_K[1,1],cam_K[0,2],cam_K[1,2])
points_src[:,:,3:],_ = to.get_normal(depth_r,fx=cam_K[0,0],fy=cam_K[1,1],cx=cam_K[0,2],cy=cam_K[1,2])
points_src = points_src[mask]
points_tgt = np.zeros((depth.shape[0],depth.shape[1],6),np.float32)
points_tgt[:,:,:3] = to.getXYZ(depth,fx=cam_K[0,0],fy=cam_K[1,1],cx=cam_K[0,2],cy=cam_K[1,2])
points_tgt[:,:,3:],_ = to.get_normal(depth,fx=cam_K[0,0],fy=cam_K[1,1],cx=cam_K[0,2],cy=cam_K[1,2])
pts_tgt = points_tgt[mask]
icp_fnc = cv2.ppf_match_3d_ICP(100,tolerence=0.05,numLevels=4) #1cm
retval, residual, pose=icp_fnc.registerModelToScene(points_src.reshape(-1,6), pts_tgt.reshape(-1,6))
tf_mat = np.matmul(pose,tf_mat)
simple_xyz = renderer.predict([np.array([vertices]),np.array([faces]),
np.array([tf_mat])])[0]
depth_r = simple_xyz[:,:,3]
mask = np.logical_and(np.abs(depth_r-depth)<depth_th,depth_r>0)
#compute valid bbox and resize a cropped image and mask to 256,256
img_masked = np.copy(img)
img_masked = img_masked/255
vu_list = np.where(mask)
bbox = np.array([np.min(vu_list[0]),np.min(vu_list[1]),np.max(vu_list[0]),np.max(vu_list[1])],np.int32)
height = bbox[2]-bbox[0]
width = bbox[3]-bbox[1]
ct_v = int((bbox[2]+bbox[0])*0.5)
ct_u = int((bbox[3]+bbox[1])*0.5)
length = int(max(max(height*0.5,width*0.5),128))
img_ = np.zeros((256,256,3))
mask_ = np.zeros((256,256,1))
bbox_new = np.array([max(ct_v-length,0),max(ct_u-length,0),min(ct_v+length,im_height),min(ct_u+length,im_width)])
img_crop = img_masked[bbox_new[0]:bbox_new[2],bbox_new[1]:bbox_new[3]]
mask_crop = mask[bbox_new[0]:bbox_new[2],bbox_new[1]:bbox_new[3]]
img_crop = resize(img_crop,(256,256))
mask_crop = np.expand_dims(resize(mask_crop,(256,256))>0.5,axis=2)
input_imgs.append(img_crop)
poses_.append(tf_mat)
masks.append(mask_crop)
bboxes.append(bbox_new)
test_fn = "./sample_data/smot/"+t_label+".hdf5"
if not(os.path.exists("./sample_data/smot/")):os.makedirs("./sample_data/smot/")
train_data = h5py.File(test_fn, "w")
train_data.create_dataset("vertices_3d",data=vertices)
train_data.create_dataset("faces",data=np.array(faces))
train_data.create_dataset("images",data=np.array(input_imgs))
train_data.create_dataset("poses",data= | np.array(poses_) | numpy.array |
""" Hand Tracker on Depth Image based on https://www.learnopencv.com/object-tracking-using-opencv-cpp-python/
"""
import os
import PIL
import glob
import numpy as np
from matplotlib import pyplot as plt
import cv2
import json
import configparser
import csv
DATASET_BASE_DIR_NAME = r"D:\git\HandPointer\dataset"
def get_local_minima(img_d, img_c):
img_d[200:, :] = 10000
scale = 1/8
confidence_thrshold = 100
morph_kernel = np.ones((9, 9), np.uint8)
h, w = img_d.shape[:2]
sh = int(h*scale)
sw = int(w*scale)
imgd_scaled = cv2.resize(img_d, (sh, sw))
imgc_scaled = cv2.resize(img_c, (sh, sw))
mask = imgc_scaled > confidence_thrshold
fimgd = cv2.morphologyEx(imgd_scaled, cv2.MORPH_BLACKHAT, morph_kernel)
fimg = np.multiply(fimgd, mask.astype(np.uint8))
inv_mask = np.invert(mask)
imgd_scaled[inv_mask] = 10000
# imgd_scaled = np.multiply(imgd_scaled, mask.astype(np.uint8))
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(imgd_scaled, mask.astype(np.uint8))
imgd_scaled = imgd_scaled-400
cimg = (imgd_scaled.clip(min=0, max=600)/5).astype(np.uint8)
cimg = cv2.cvtColor(cimg, cv2.COLOR_GRAY2BGR)
cimg = cv2.drawMarker(cimg, min_loc, (0, 0, 0))
cimg = cv2.resize(cimg, (500, 500))
cv2.imshow("dpeth", cimg)
cv2.waitKey(1)
# print(min_loc, min_val)
# ax1 = plt.subplot(121)
# plt.imshow(mask)
# plt.subplot(122, sharex=ax1, sharey=ax1)
# plt.imshow(cimg), plt.title("after top hat")
# plt.show()
def check_velocity():
# json_file_name = os.path.join(DATASET_BASE_DIR_NAME, "result.json")
# if os.path.isfile(json_file_name):
# with open(json_file_name, "r", encoding='utf8') as fid:
# datasets_info = json.load(fid)
# dataset = datasets_info[id]
csv_file_names = ['D:\git\HandPointer\dataset\#git#ajay#DepthSensing#dataset#ds325#fast_circles.csv'
'D:\git\HandPointer\dataset\#git#ajay#DepthSensing#dataset#ds325#gestures_two_hands.csv',
'D:\git\HandPointer\dataset\#git#ajay#DepthSensing#dataset#ds325#gestures_two_hands_swap.csv',
'D:\git\HandPointer\dataset\#git#ajay#DepthSensing#dataset#ds325#sequence_closed_hand.csv',
'D:\git\HandPointer\dataset\#git#ajay#DepthSensing#dataset#ds325#sequence_open_hand.csv',
'D:\git\HandPointer\dataset\#git#ajay#DepthSensing#dataset#ds325#sequence_small_shapes.csv',
'D:\git\HandPointer\dataset\#git#ajay#DepthSensing#dataset#ds536#circle_ccw.csv',
'D:\git\HandPointer\dataset\#git#ajay#DepthSensing#dataset#ds536#circle_ccw_far.csv',
'D:\git\HandPointer\dataset\#git#ajay#DepthSensing#dataset#ds536#circle_ccw_hand.csv',
'D:\git\HandPointer\dataset\#git#ajay#DepthSensing#dataset#ds536#circle_sequence.csv',
'D:\git\HandPointer\dataset\#git#ajay#DepthSensing#dataset#ds536#multiple_shapes_1.csv',
'D:\git\HandPointer\dataset\#git#ajay#DepthSensing#dataset#ds536#rectangle_ccw.csv',
'D:\git\HandPointer\dataset\#git#ajay#DepthSensing#dataset#ds536#rectangle_cw.csv',
'D:\git\HandPointer\dataset\#git#ajay#DepthSensing#dataset#ds536#star.csv',
'D:\git\HandPointer\dataset\#git#ajay#DepthSensing#dataset#ds536#zigzag.csv',
'D:\git\HandPointer\dataset\#git#HandPointer#dataset#ds325#fast_circles.csv']
csv_file_name = os.path.join(r"D:\git\HandPointer\dataset", "#git#ajay#DepthSensing#dataset#ds325#fast_circles.csv")
csv_file_name = csv_file_names[13]
trajectory_data = np.zeros((800, 3))
with open(csv_file_name, "r") as fid:
reader = csv.reader(fid)
header = next(reader)
for row in reader:
if len(row)<4:
continue
file_id = int(row[0])
x = int(row[1])
y = int(row[2])
d = int(row[3])
trajectory_data[file_id,0] = x
trajectory_data[file_id,1] = y
trajectory_data[file_id,2] = d
velocity = np.zeros((800, 2))
step = 5
velocity[step:,0] = trajectory_data[step:,0] - trajectory_data[:-step,0]
velocity[step:,1] = trajectory_data[step:,1] - trajectory_data[:-step,1]
velocity_norm = np.linalg.norm(velocity, axis=1)
stop = (velocity_norm < 5).astype(np.uint8)
plt.subplot(311)
plt.plot(trajectory_data[:,0],'b')
plt.plot(trajectory_data[:,1],'r')
plt.plot(stop*100, 'g'), plt.title("xy")
plt.subplot(312), plt.plot(velocity[:,0],'b')
plt.plot(velocity[:,1],'r'), plt.title("velocity xy")
plt.subplot(313), plt.plot(velocity_norm,'b'), plt.title("velocty norm")
plt.plot(stop*100, 'g')
plt.show()
def get_datasets():
datasets = [
r"ds325\fast_circles",
r"ds325\gestures_two_hands",
r"ds325\gestures_two_hands_swap",
r"ds325\sequence_closed_hand",
r"ds325\sequence_open_hand",
r"ds325\sequence_small_shapes",
r"ds536\circle_ccw",
r"ds536\circle_ccw_far",
r"ds536\circle_ccw_hand",
r"ds536\circle_sequence",
r"ds536\multiple_shapes_1",
r"ds536\rectangle_ccw",
r"ds536\rectangle_cw",
r"ds536\star",
r"ds536\zigzag",
]
datasets = [os.path.join(DATASET_BASE_DIR_NAME, dataset) for dataset in datasets]
return datasets
datasets_info = [{
"base_dir_name" : r"D:\git\HandPointer\dataset\ds325\gestures_two_hands_swap",
"max_file_count" : 600,
"init_frame_id" : 50
}]
def calc_tajectory(file_id, loc, img_d, img_c):
# x = int(bbox[0] + bbox[2])//2
# y = int(bbox[1] + bbox[3])//2
x = int(loc[0])
y = int(loc[1])
depth = img_d[y,x]
confidence = img_c[y, x]
trajectory = {
"file_id" : file_id,
"finger_tip" : {
"x": x,
"y": y,
},
"depth": depth,
"confidence": confidence
}
return trajectory
def create_video_from_results():
dataset_dir_names = get_datasets()
for dataset_dir_name in dataset_dir_names:
camera_file_name = os.path.join(os.path.dirname(dataset_dir_name), "camera_parameters.txt")
mtx, dist, newcameramtx = read_camera_parameter(camera_file_name)
video_file_name = dataset_dir_name.replace(DATASET_BASE_DIR_NAME,"")[1:]
video_file_name = video_file_name.replace("\\", "_") + "_result.avi"
video_file_name = os.path.join(DATASET_BASE_DIR_NAME, video_file_name)
out = cv2.VideoWriter(video_file_name, cv2.VideoWriter_fourcc(*'DIVX'), 60, (320, 240))
file_names = glob.glob(os.path.join(dataset_dir_name, "*_result.png"), recursive=True)
for file_name in file_names:
if not os.path.isfile(file_name):
continue
img = np.array(PIL.Image.open(file_name))
img = img[:,:,::-1]
img = cv2.undistort(img, mtx, dist, None, newcameramtx)
out.write(img)
out.release()
def create_video():
dataset_dir_names = get_datasets()
for dataset_dir_name in dataset_dir_names:
camera_file_name = os.path.join(os.path.dirname(dataset_dir_name), "camera_parameters.txt")
mtx, dist, newcameramtx = read_camera_parameter(camera_file_name)
video_file_name = dataset_dir_name.replace(DATASET_BASE_DIR_NAME,"")[1:]
video_file_name = video_file_name.replace("\\", "_") + "_depth.avi"
video_file_name = os.path.join(DATASET_BASE_DIR_NAME, video_file_name)
out = cv2.VideoWriter(video_file_name, cv2.VideoWriter_fourcc(*'DIVX'), 60, (320, 240))
file_names = glob.glob(os.path.join(dataset_dir_name, "*_depth.tiff"), recursive=True)
for file_name in file_names:
confidence_file_name = file_name.replace("depth", "confidence")
if not os.path.isfile(file_name) or not os.path.isfile(confidence_file_name):
continue
img_d = np.array(PIL.Image.open(file_name)).astype(np.float)*0.1
img_c = np.array(PIL.Image.open(confidence_file_name)).astype(np.float)*0.1
img_d = np.clip(img_d, 0, 255).astype(np.uint8)
img_c = np.clip(img_c, 0, 255).astype(np.uint8)
img_d = cv2.undistort(img_d, mtx, dist, None, newcameramtx)
img_c = cv2.undistort(img_c, mtx, dist, None, newcameramtx)
img_out = | np.zeros((*img_d.shape, 3), dtype=np.uint8) | numpy.zeros |
import numpy as np
import math
import scipy
from fractions import Fraction
import itertools
import biotuner
from biotuner.biotuner_utils import *
import matplotlib.pyplot as plt
from numpy import array, zeros, ones, arange, log2, sqrt, diff, concatenate
import pytuning
from math import gcd
from numpy import array, zeros, ones, arange, log2, sqrt, diff, concatenate
from scipy.stats import norm
from scipy.signal import argrelextrema, detrend
import scipy.signal as ss
from pytuning import create_euler_fokker_scale
from collections import Counter
from functools import reduce
from pytuning.utilities import normalize_interval
from pactools import Comodulogram, REFERENCES
'''---------------------------------------------------------Extended peaks-------------------------------------------------------------'''
'''EXTENDED PEAKS from expansions
'''
def EEG_harmonics_mult(peaks, n_harmonics, n_oct_up = 0):
"""
Natural harmonics
This function takes a list of frequency peaks as input and computes the desired number of harmonics
with the formula: x, 2x, 3x ..., nx
peaks: List (float)
Peaks represent local maximum in a spectrum
n_harmonics: int
Number of harmonics to compute
n_oct_up: int
Defaults to 0. Corresponds to the number of octave the peaks are shifted
Returns
-------
multi_harmonics: array
(n_peaks, n_harmonics + 1)
"""
n_harmonics = n_harmonics + 2
multi_harmonics = []
multi_harmonics_rebound = []
for p in peaks:
multi_harmonics_r = []
multi_harm_temp = []
harmonics = []
p = p * (2**n_oct_up)
i = 1
harm_temp = p
while i < n_harmonics:
harm_temp = p * i
harmonics.append(harm_temp)
i+=1
multi_harmonics.append(harmonics)
multi_harmonics = np.array(multi_harmonics)
return multi_harmonics
def EEG_harmonics_div(peaks, n_harmonics, n_oct_up = 0, mode = 'div'):
"""
Natural sub-harmonics
This function takes a list of frequency peaks as input and computes the desired number of harmonics
with using division:
peaks: List (float)
Peaks represent local maximum in a spectrum
n_harmonics: int
Number of harmonics to compute
n_oct_up: int
Defaults to 0. Corresponds to the number of octave the peaks are shifted
mode: str
Defaults to 'div'.
'div': x, x/2, x/3 ..., x/n
'div_add': x, (x+x/2), (x+x/3), ... (x+x/n)
'div_sub': x, (x-x/2), (x-x/3), ... (x-x/n)
Returns
-------
div_harmonics: array
(n_peaks, n_harmonics + 1)
div_harmonics_bounded: array
(n_peaks, n_harmonics + 1)
"""
n_harmonics = n_harmonics + 2
div_harmonics = []
for p in peaks:
harmonics = []
p = p * (2**n_oct_up)
i = 1
harm_temp = p
while i < n_harmonics:
if mode == 'div':
harm_temp = (p/i)
if mode == 'div_add':
harm_temp = p + (p/i)
if mode == 'div_sub':
harm_temp = p - (p/i)
harmonics.append(harm_temp)
i+=1
div_harmonics.append(harmonics)
div_harmonics = np.array(div_harmonics)
div_harmonics_bounded = div_harmonics.copy()
#Rebound the result between 1 and 2
for i in range(len(div_harmonics_bounded)):
for j in range(len(div_harmonics_bounded[i])):
div_harmonics_bounded[i][j] = rebound(div_harmonics_bounded[i][j])
return div_harmonics, div_harmonics_bounded
def harmonic_fit(peaks, n_harm = 10, bounds = 1, function = 'mult', div_mode = 'div', n_common_harms = 5):
"""
This function computes harmonics of a list of peaks and compares the lists of harmonics pairwise to find fitting
between the harmonic series
peaks: List (float)
Peaks represent local maximum in a spectrum
n_harm: int
Number of harmonics to compute
bounds: int
Minimum distance (in Hz) between two frequencies to consider a fit
function: str
Defaults to 'mult'.
'mult' will use natural harmonics
'div' will use natural sub-harmonics
div_mode: str
Defaults to 'div'. See EEG_harmonics_div function.
Returns
-------
"""
from itertools import combinations
peak_bands = []
for i in range(len(peaks)):
peak_bands.append(i)
if function == 'mult':
multi_harmonics = EEG_harmonics_mult(peaks, n_harm)
elif function == 'div':
multi_harmonics, x = EEG_harmonics_div(peaks, n_harm, mode = div_mode)
elif function == 'exp':
multi_harmonics = []
increments = []
for h in range(n_harm+1):
h += 1
multi_harmonics.append([i**h for i in peaks])
multi_harmonics = np.array(multi_harmonics)
multi_harmonics = np.moveaxis(multi_harmonics, 0, 1)
#print(np.array(multi_harmonics).shape)
list_peaks = list(combinations(peak_bands,2))
#print(list_peaks)
harm_temp = []
harm_list1 = []
harm_list2 = []
harm_list = []
harmonics = []
for i in range(len(list_peaks)):
harms, _, _, d, e, harm_list = compareLists(multi_harmonics[list_peaks[i][0]], multi_harmonics[list_peaks[i][1]], bounds)
harm_temp.append(harms)
harm_list1.append(d)
harm_list2.append(e)
harmonics.append(harm_list)
harm_fit = np.array(harm_temp).squeeze()
harmonics = reduce(lambda x, y: x+y, harmonics)
most_common_harmonics= [h for h, h_count in Counter(harmonics).most_common(n_common_harms) if h_count > 1]
harmonics = list(np.sort(list(set(harmonics))))
if len(peak_bands) > 2:
harm_fit = list(itertools.chain.from_iterable(harm_fit))
harm_fit = [round(num, 3) for num in harm_fit]
harm_fit = list(dict.fromkeys(harm_fit))
harm_fit = list(set(harm_fit))
return harm_fit, harm_list1, harm_list2, harmonics, most_common_harmonics
'''EXTENDED PEAKS from restrictions
'''
def consonance_peaks (peaks, limit):
"""
This function computes consonance (for a given ratio a/b, when a < 2b, consonance corresponds to (a+b)/(a*b)) between peaks
peaks: List (float)
Peaks represent local maximum in a spectrum
limit: float
minimum consonance value to keep associated pairs of peaks
Comparisons with familiar ratios:
Unison-frequency ratio 1:1 yields a value of 2
Octave-frequency ratio 2:1 yields a value of 1.5
Perfect 5th-frequency ratio 3:2 yields a value of 0.833
Perfect 4th-frequency ratio 4:3 yields a value of 0.583
Major 6th-frequency ratio 5:3 yields a value of 0.533
Major 3rd-frequency ratio 5:4 yields a value of 0.45
Minor 3rd-frequency ratio 5:6 yields a value of 0.366
Minor 6th-frequency ratio 5:8 yields a value of 0.325
Major 2nd-frequency ratio 8:9 yields a value of 0.236
Major 7th-frequency ratio 8:15 yields a value of 0.192
Minor 7th-frequency ratio 9:16 yields a value of 0.174
Minor 2nd-frequency ratio 15:16 yields a value of 0.129
Returns
-------
consonance: List (float)
consonance scores for each pairs of consonant peaks
cons_pairs: List of lists (float)
list of lists of each pairs of consonant peaks
cons_peaks: List (float)
list of consonant peaks (no doublons)
cons_tot: float
averaged consonance value for each pairs of peaks
"""
from fractions import Fraction
consonance_ = []
peaks2keep = []
peaks_consonance = []
cons_tot = []
for p1 in peaks:
for p2 in peaks:
peaks2keep_temp = []
p2x = p2
p1x = p1
if p1x > p2x:
while p1x > p2x:
p1x = p1x/2
if p1x < p2x:
while p2x > p1x:
p2x = p2x/2
if p1x < 0.1:
p1x = 0.06
if p2x < 0.1:
p2x = 0.06 #random number to avoid division by 0
ratio = Fraction(p2x/p1x).limit_denominator(1000)
cons_ = (ratio.numerator + ratio.denominator)/(ratio.numerator * ratio.denominator)
if cons_ < 1 :
cons_tot.append(cons_)
if cons_ > 1 or cons_ < limit:
cons_ = None
cons_ = None
p2x = None
p1x = None
if p2x != None:
peaks2keep_temp.extend([p2, p1])
consonance_.append(cons_)
peaks2keep.append(peaks2keep_temp)
#cons_pairs = np.array(peaks2keep)
cons_pairs = [x for x in peaks2keep if x]
#consonance = np.array(consonance_)
consonance = [i for i in consonance_ if i]
cons_peaks = list(itertools.chain(*cons_pairs))
cons_peaks = [np.round(c, 2) for c in cons_peaks]
cons_peaks = list(set(cons_peaks))
#consonance = list(set(consonance))
return consonance, cons_pairs, cons_peaks, np.average(cons_tot)
def multi_consonance(cons_pairs, n_freqs = 5):
"""
Function that keeps the frequencies that are the most consonant with others
Takes pairs of frequencies that are consonant (output of the 'compute consonance' function)
cons_pairs: List of lists (float)
list of lists of each pairs of consonant peaks
n_freqs: int
maximum number of consonant freqs to keep
Returns
-------
freqs_related: List (float)
peaks that are consonant with at least two other peaks, starting with the peak that is
consonant with the maximum number of other peaks
"""
freqs_dup = list(itertools.chain(*cons_pairs))
pairs_temp = list(itertools.chain.from_iterable(cons_pairs))
freqs_nodup = list(dict.fromkeys(pairs_temp))
f_count = []
for f in freqs_nodup:
f_count.append(freqs_dup.count(f))
freqs_related = [x for _,x in sorted(zip(f_count,freqs_nodup))][-(n_freqs):][::-1]
return freqs_related
def consonant_ratios (peaks, limit, sub = False, input_type = 'peaks', metric = 'cons'):
"""
Function that computes integer ratios from peaks with higher consonance
Needs at least two pairs of values
peaks: List (float)
Peaks represent local maximum in a spectrum
limit: float
minimum consonance value to keep associated pairs of peaks
sub: boolean
Defaults to False
When set to True, include ratios a/b when a < b.
Returns
-------
cons_ratios: List (float)
list of consonant ratios
consonance: List (float)
list of associated consonance values
"""
from fractions import Fraction
consonance_ = []
ratios2keep = []
if input_type == 'peaks':
ratios = compute_peak_ratios(peaks, sub = sub)
if input_type == 'ratios':
ratios = peaks
for ratio in ratios:
frac = Fraction(ratio).limit_denominator(1000)
if metric == 'cons':
cons_ = (frac.numerator + frac.denominator)/(frac.numerator * frac.denominator)
if metric == 'harmsim':
cons_ = dyad_similarity(ratio)
if cons_ > limit :
consonance_.append(cons_)
ratios2keep.append(ratio)
#print(ratios2keep)
ratios2keep = np.array(np.round(ratios2keep, 3))
cons_ratios = np.sort(list(set(ratios2keep)))
#cons_ratios = np.array(ratios2keep)
#ratios = []
#ratios = [ratios.append(x) for x in ratios2keep if x not in ratios]
consonance = np.array(consonance_)
consonance = [i for i in consonance if i]
return cons_ratios, consonance
def timepoint_consonance (data, method = 'cons', limit = 0.2, min_notes = 3):
"""
## Function that keeps moments of consonance from multiple time series of peak frequencies
data: List of lists (float)
Axis 0 represents moments in time
Axis 1 represents the sets of frequencies
method: str
Defaults to 'cons'
'cons' will compute pairwise consonance between frequency peaks in the form of (a+b)/(a*b)
'euler' will compute Euler's gradus suavitatis
limit: float
limit of consonance under which the set of frequencies are not retained
When method = 'cons'
--> See consonance_peaks method's doc to refer consonance values to common intervals
When method = 'euler'
--> Major (4:5:6) = 9
Minor (10:12:15) = 9
Major 7th (8:10:12:15) = 10
Minor 7th (10:12:15:18) = 11
Diminish (20:24:29) = 38
min_notes: int
minimum number of consonant frequencies in the chords. Only relevant when method is set to 'cons'.
Returns
-------
chords: List of lists (float)
Axis 0 represents moments in time
Axis 1 represents the sets of consonant frequencies
positions: List (int)
positions on Axis 0
"""
data = np.moveaxis(data, 0, 1)
#print('NAN', np.argwhere(np.isnan(data)))
out = []
positions = []
for count, peaks in enumerate(data):
peaks = [x for x in peaks if x >= 0]
if method == 'cons':
cons, b, peaks_cons, d = consonance_peaks(peaks, limit)
#print(peaks_cons)
out.append(peaks_cons)
if len(list(set(peaks_cons))) >= min_notes:
positions.append(count)
if method == 'euler':
peaks_ = [int(np.round(p, 2)*100) for p in peaks]
#print(peaks_)
eul = euler(*peaks_)
#print(eul)
if eul < limit:
out.append(list(peaks))
positions.append(count)
out = [x for x in out if x != []]
#if method == 'cons':
out = list(out for out,_ in itertools.groupby(out))
chords = [x for x in out if len(x)>=min_notes]
return chords, positions
'''
################################################## PEAKS METRICS ############################################################
'''
#Consonance#
#Input: peaks
def consonance (ratio, limit = 1000):
''' Compute metric of consonance from a single ratio of frequency
ratio: float
limit: int
Defaults to 1000
Maximum value of the denominator of the fraction representing the ratio
'''
ratio = Fraction(float(ratio)).limit_denominator(limit)
cons = (ratio.numerator + ratio.denominator)/(ratio.numerator * ratio.denominator)
return cons
def euler(*numbers):
"""
Euler's "gradus suavitatis" (degree of sweetness) function
Return the "degree of sweetness" of a musical interval or chord expressed
as a ratio of frequencies a:b:c, according to Euler's formula
Greater values indicate more dissonance
numbers: List (int)
frequencies
"""
factors = prime_factors(lcm(*reduced_form(*numbers)))
return 1 + sum(p - 1 for p in factors)
#Input: peaks
def tenneyHeight(peaks, avg = True):
"""
Tenney Height is a measure of inharmonicity calculated on two frequencies (a/b) reduced in their simplest form.
It can also be called the log product complexity of a given interval.
peaks: List (float)
frequencies
avg: Boolean
Default to True
When set to True, all tenney heights are averaged
"""
pairs = getPairs(peaks)
pairs
tenney = []
for p in pairs:
try:
frac = Fraction(p[0]/p[1]).limit_denominator(1000)
except ZeroDivisionError:
p[1] = 0.01
frac = Fraction(p[0]/p[1]).limit_denominator(1000)
x = frac.numerator
y = frac.denominator
tenney.append(log2(x*y))
if avg == True:
tenney = np.average(tenney)
return tenney
def peaks_to_metrics (peaks, n_harm = 10):
'''
This function computes different metrics on peak frequencies.
peaks: List (float)
Peaks represent local maximum in a spectrum
n_harm: int
Number of harmonics to compute for 'harm_fit' metric
Returns
-------
metrics: dict (float)
Dictionary of values associated to metrics names
metrics_list: List (float)
list of peaks metrics values in the order: 'cons', 'euler', 'tenney', 'harm_fit'
'''
peaks = list(peaks)
metrics = {'cons' : 0, 'euler' : 0, 'tenney': 0, 'harm_fit': 0}
harm_fit, harm_pos1, harm_pos2 = harmonic_fit(peaks, n_harm = n_harm)
metrics['harm_pos1'] = harm_pos1
metrics['harm_pos2'] = harm_pos2
metrics['harm_fit'] = len(harm_fit)
a, b, c, metrics['cons'] = consonance_peaks (peaks, 0.1)
peaks_highfreq = [int(p*1000) for p in peaks]
metrics['euler'] = euler(*peaks_highfreq)
metrics['tenney'] = tenneyHeight(peaks_highfreq)
metrics_list = []
for value in metrics.values():
metrics_list.append(value)
return metrics, metrics_list
def metric_denom(ratio):
'''Function that computes the denominator of the normalized ratio
ratio: float
'''
ratio = sp.Rational(ratio).limit_denominator(10000)
normalized_degree = normalize_interval(ratio)
y = int(sp.fraction(normalized_degree)[1])
return y
'''SCALE METRICS'''
'''Metric of harmonic similarity represents the degree of similarity between a scale and the natural harmonic series ###
Implemented from Gill and Purves (2009)'''
def dyad_similarity(ratio):
'''
This function computes the similarity between a dyad of frequencies and the natural harmonic series
ratio: float
frequency ratio
'''
frac = Fraction(float(ratio)).limit_denominator(1000)
x = frac.numerator
y = frac.denominator
z = ((x+y-1)/(x*y))*100
return z
#Input: ratios (list of floats)
def ratios2harmsim (ratios):
'''
This function computes the similarity for each ratio of a list
ratios: List (float)
list of frequency ratios (forming a scale)
Returns
---------
similarity: List (float)
list of percentage of similarity for each ratios
'''
fracs = []
for r in ratios:
fracs.append(Fraction(r).limit_denominator(1000))
sims = []
for f in fracs:
sims.append(dyad_similarity(f.numerator/f.denominator))
similarity = np.array(sims)
return similarity
def scale_cons_matrix (scale, function):
'''
This function gives a metric of a scale corresponding to the averaged metric for each pairs of ratios (matrix)
scale: List (float)
function: function
possible functions: dyad_similarity
consonance
metric_denom
'''
metric_values = []
mode_values = []
for index1 in range(len(scale)):
for index2 in range(len(scale)):
if scale[index1] > scale[index2]: #not include the diagonale in the computation of the avg. consonance
entry = scale[index1]/scale[index2]
mode_values.append([scale[index1], scale[index2]])
metric_values.append(function(entry))
return np.average(metric_values)
def PyTuning_metrics(scale, maxdenom):
'''
This function computes the scale metrics of the PyTuning library (https://pytuning.readthedocs.io/en/0.7.2/metrics.html)
Smaller values are more consonant
scale: List (float)
List of ratios corresponding to scale steps
maxdenom: int
Maximum value of the denominator for each step's fraction
'''
scale_frac, num, denom = scale2frac(scale, maxdenom)
metrics = pytuning.metrics.all_metrics(scale_frac)
sum_p_q = metrics['sum_p_q']
sum_distinct_intervals = metrics['sum_distinct_intervals']
metric_3 = metrics['metric_3']
sum_p_q_for_all_intervals = metrics['sum_p_q_for_all_intervals']
sum_q_for_all_intervals = metrics['sum_q_for_all_intervals']
return sum_p_q, sum_distinct_intervals, metric_3, sum_p_q_for_all_intervals, sum_q_for_all_intervals
def scale_to_metrics(scale):
'''
This function computes the scale metrics of the PyTuning library and other scale metrics
scale: List (float)
List of ratios corresponding to scale steps
Returns
----------
scale_metrics: dictionary
keys correspond to metrics names
scale_metrics_list: List (float)
List of values corresponding to all computed metrics (in the same order as dictionary)
'''
scale_frac, num, denom = scale2frac(scale, maxdenom=1000)
scale_metrics = pytuning.metrics.all_metrics(scale_frac)
scale_metrics['harm_sim'] = np.round(np.average(ratios2harmsim(scale)), 2)
scale_metrics['matrix_harm_sim'] = scale_cons_matrix(scale, dyad_similarity)
scale_metrics['matrix_cons'] = scale_cons_matrix(scale, consonance)
scale_metrics_list = []
for value in scale_metrics.values():
scale_metrics_list.append(value)
return scale_metrics, scale_metrics_list
def scale_consonance (scale, function, rounding = 4):
'''
Function that gives the average consonance of each scale interval
scale: List (float)
scale to reduce
function: function
function used to compute the consonance between pairs of ratios
Choose between: consonance, dyad_similarity, metric_denom
'''
metric_values = []
mode_values = []
for index1 in range(len(scale)):
metric_value = []
for index2 in range(len(scale)):
entry = scale[index1]/scale[index2]
mode_values.append([scale[index1], scale[index2]])
metric_value.append(function(entry))
metric_values.append(np.average(metric_value))
return metric_values
'''
################################################ SCALE CONSTRUCTION ##############################################################
'''
def oct_subdiv(ratio, octave_limit = 0.01365 ,octave = 2 ,n = 5):
'''
N-TET tuning from Generator Interval
This function uses a generator interval to suggest numbers of steps to divide the octave,
so the given interval will be approximately present (octave_limit) in the steps of the N-TET tuning.
ratio: float
ratio that corresponds to the generator_interval
e.g.: by giving the fifth (3/2) as generator interval, this function will suggest to subdivide the octave in 12, 53, ...
octave_limit: float
Defaults to 0.01365 (Pythagorean comma)
approximation of the octave corresponding to the acceptable distance between the ratio of the generator interval after
multiple iterations and the octave value.
octave: int
Defaults to 2
value of the octave
n: int
Defaults to 5
number of suggested octave subdivisions
Returns
-------
Octdiv: List (int)
list of N-TET tunings corresponding to dividing the octave in equal steps
Octvalue: List (float)
list of the approximations of the octave for each N-TET tuning
'''
Octdiv, Octvalue, i = [], [], 1
ratios = []
while len(Octdiv) < n:
ratio_mult = (ratio**i)
while ratio_mult > octave:
ratio_mult = ratio_mult/octave
rescale_ratio = ratio_mult - round(ratio_mult)
ratios.append(ratio_mult)
i+=1
if -octave_limit < rescale_ratio < octave_limit:
Octdiv.append(i-1)
Octvalue.append(ratio_mult)
else:
continue
return Octdiv, Octvalue
def compare_oct_div(Octdiv = 12, Octdiv2 = 53, bounds = 0.005, octave = 2):
'''
Function that compare steps for two N-TET tunings and return matching ratios and corresponding degrees
Octdiv: int
Defaults to 12.
first N-TET tuning number of steps
Octdiv2: int
Defaults to 53.
second N-TET tuning number of steps
bounds: float
Defaults to 0.005
Maximum distance between 1 ratio of Octdiv and 1 ratio of Octdiv2 to consider a match
octave: int
Defaults to 2
value of the octave
Returns
-------
avg_ratios: List (float)
list of ratios corresponding to the shared steps in the two N-TET tunings
shared_steps: List of tuples
the two elements of each tuple corresponds to the scale steps sharing the same interval in the two N-TET tunings
'''
ListOctdiv = []
ListOctdiv2 = []
OctdivSum = 1
OctdivSum2 = 1
i = 1
i2 = 1
while OctdivSum < octave:
OctdivSum =(nth_root(octave, Octdiv))**i
i+=1
ListOctdiv.append(OctdivSum)
while OctdivSum2 < octave:
OctdivSum2 =(nth_root(octave, Octdiv2))**i2
i2+=1
ListOctdiv2.append(OctdivSum2)
shared_steps = []
avg_ratios = []
for i, n in enumerate(ListOctdiv):
for j, harm in enumerate(ListOctdiv2):
if harm-bounds < n < harm+bounds:
shared_steps.append((i+1, j+1))
avg_ratios.append((n+harm)/2)
return avg_ratios, shared_steps
#Output1: octave subdivisions
#Output2: ratios that led to Output1
def multi_oct_subdiv (peaks, max_sub = 100, octave_limit = 1.01365, octave = 2, n_scales = 10, cons_limit = 0.1):
'''
This function uses the most consonant peaks ratios as input of oct_subdiv function. Each consonant ratio
leads to a list of possible octave subdivisions. These lists are compared and optimal octave subdivisions are
determined.
peaks: List (float)
Peaks represent local maximum in a spectrum
max_sub: int
Defaults to 100.
Maximum number of intervals in N-TET tuning suggestions.
octave_limit: float
Defaults to 1.01365 (Pythagorean comma).
Approximation of the octave corresponding to the acceptable distance between the ratio of the generator interval after
multiple iterations and the octave value.
octave: int
Defaults to 2.
value of the octave
n_scales: int
Defaults to 10.
Number of N-TET tunings to compute for each generator interval (ratio).
Returns
-------
multi_oct_div: List (int)
List of octave subdivisions that fit with multiple generator intervals.
ratios: List (float)
list of the generator intervals for which at least 1 N-TET tuning match with another generator interval.
'''
import itertools
from collections import Counter
#a, b, pairs, cons = consonance_peaks(peaks, cons_limit)
ratios, cons = consonant_ratios(peaks, cons_limit)
list_oct_div = []
for i in range(len(ratios)):
list_temp, _ = oct_subdiv(ratios[i], octave_limit, octave, n_scales)
list_oct_div.append(list_temp)
counts = Counter(list(itertools.chain(*list_oct_div)))
oct_div_temp = []
for k, v in counts.items():
if v > 1:
oct_div_temp.append(k)
oct_div_temp = np.sort(oct_div_temp)
multi_oct_div = []
for i in range(len(oct_div_temp)):
if oct_div_temp[i] < max_sub:
multi_oct_div.append(oct_div_temp[i])
return multi_oct_div, ratios
def harmonic_tuning (list_harmonics, octave = 2, min_ratio = 1, max_ratio = 2):
'''
Function that computes a tuning based on a list of harmonic positions
list_harmonics: List (int)
harmonic positions to use in the scale construction
octave: int
min_ratio: float
max_ratio: float
'''
ratios = []
for i in list_harmonics:
ratios.append(rebound(1*i, min_ratio, max_ratio, octave))
ratios = list(set(ratios))
ratios = list(np.sort(np.array(ratios)))
return ratios
def euler_fokker_scale(intervals, n = 1):
'''
Function that takes as input a series of intervals and derives a Euler Fokker Genera scale
intervals: List (float)
n: int
Defaults to 1
number of times the interval is used in the scale generation
'''
multiplicities = [n for x in intervals]
scale = create_euler_fokker_scale(intervals, multiplicities)
return scale
def generator_interval_tuning (interval = 3/2, steps = 12, octave = 2):
'''
Function that takes a generator interval and derives a tuning based on its stacking.
interval: float
Generator interval
steps: int
Defaults to 12 (12-TET for interval 3/2)
Number of steps in the scale
octave: int
Defaults to 2
Value of the octave
'''
scale = []
for s in range(steps):
s += 1
degree = interval**s
while degree > octave:
degree = degree/octave
scale.append(degree)
return sorted(scale)
#function that takes two ratios a input (boundaries of )
#The mediant corresponds to the interval where small and large steps are equal.
def tuning_range_to_MOS (frac1, frac2, octave = 2, max_denom_in = 100, max_denom_out = 100):
gen1 = octave**(frac1)
gen2 = octave**(frac2)
a = Fraction(frac1).limit_denominator(max_denom_in).numerator
b = Fraction(frac1).limit_denominator(max_denom_in).denominator
c = Fraction(frac2).limit_denominator(max_denom_in).numerator
d = Fraction(frac2).limit_denominator(max_denom_in).denominator
print(a, b, c, d)
mediant = (a+c)/(b+d)
mediant_frac = sp.Rational((a+c)/(b+d)).limit_denominator(max_denom_out)
gen_interval = octave**(mediant)
gen_interval_frac = sp.Rational(octave**(mediant)).limit_denominator(max_denom_out)
MOS_signature = [d, b]
invert_MOS_signature = [b, d]
return mediant, mediant_frac, gen_interval, gen_interval_frac, MOS_signature, invert_MOS_signature
#def tuning_embedding ()
def stern_brocot_to_generator_interval (ratio, octave = 2):
gen_interval = octave**(ratio)
return gen_interval
def gen_interval_to_stern_brocot (gen):
root_ratio = log2(gen)
return root_ratio
#Dissonance
def dissmeasure(fvec, amp, model='min'):
"""
Given a list of partials in fvec, with amplitudes in amp, this routine
calculates the dissonance by summing the roughness of every sine pair
based on a model of Plomp-Levelt's roughness curve.
The older model (model='product') was based on the product of the two
amplitudes, but the newer model (model='min') is based on the minimum
of the two amplitudes, since this matches the beat frequency amplitude.
"""
# Sort by frequency
sort_idx = np.argsort(fvec)
am_sorted = np.asarray(amp)[sort_idx]
fr_sorted = np.asarray(fvec)[sort_idx]
# Used to stretch dissonance curve for different freqs:
Dstar = 0.24 # Point of maximum dissonance
S1 = 0.0207
S2 = 18.96
C1 = 5
C2 = -5
# Plomp-Levelt roughness curve:
A1 = -3.51
A2 = -5.75
# Generate all combinations of frequency components
idx = np.transpose(np.triu_indices(len(fr_sorted), 1))
fr_pairs = fr_sorted[idx]
am_pairs = am_sorted[idx]
Fmin = fr_pairs[:, 0]
S = Dstar / (S1 * Fmin + S2)
Fdif = fr_pairs[:, 1] - fr_pairs[:, 0]
if model == 'min':
a = np.amin(am_pairs, axis=1)
elif model == 'product':
a = np.prod(am_pairs, axis=1) # Older model
else:
raise ValueError('model should be "min" or "product"')
SFdif = S * Fdif
D = np.sum(a * (C1 * np.exp(A1 * SFdif) + C2 * np.exp(A2 * SFdif)))
return D
#Input: peaks and amplitudes
def diss_curve (freqs, amps, denom=1000, max_ratio=2, euler_comp = True, method = 'min', plot = True, n_tet_grid = None):
'''
This function computes the dissonance curve and related metrics for a given set of frequencies (freqs) and amplitudes (amps)
freqs: List (float)
list of frequencies associated with spectral peaks
amps: List (float)
list of amplitudes associated with freqs (must be same lenght)
denom: int
Defaults to 1000.
Highest value for the denominator of each interval
max_ratio: int
Defaults to 2.
Value of the maximum ratio
Set to 2 for a span of 1 octave
Set to 4 for a span of 2 octaves
Set to 8 for a span of 3 octaves
Set to 2**n for a span of n octaves
euler: Boolean
Defaults to True
When set to True, compute the Euler Gradus Suavitatis for the derived scale
method: str
Defaults to 'min'
Can be set to 'min' or 'product'. Refer to dissmeasure function for more information.
plot: boolean
Defaults to True
When set to True, a plot of the dissonance curve will be generated
n_tet_grid: int
Defaults to None
When an integer is given, dotted lines will be add to the plot a steps of the given N-TET scale
Returns
-------
intervals: List of tuples
Each tuple corresponds to the numerator and the denominator of each scale step ratio
ratios: List (float)
list of ratios that constitute the scale
euler_score: int
value of consonance of the scale
diss: float
value of averaged dissonance of the total curve
dyad_sims: List (float)
list of dyad similarities for each ratio of the scale
'''
from numpy import array, linspace, empty, concatenate
from scipy.signal import argrelextrema
from fractions import Fraction
freqs = np.array(freqs)
r_low = 1
alpharange = max_ratio
method = method
n = 1000
diss = empty(n)
a = concatenate((amps, amps))
for i, alpha in enumerate(linspace(r_low, alpharange, n)):
f = concatenate((freqs, alpha*freqs))
d = dissmeasure(f, a, method)
diss[i] = d
diss_minima = argrelextrema(diss, np.less)
intervals = []
for d in range(len(diss_minima[0])):
frac = Fraction(diss_minima[0][d]/(n/(max_ratio-1))+1).limit_denominator(denom)
frac = (frac.numerator, frac.denominator)
intervals.append(frac)
intervals.append((2, 1))
ratios = [i[0]/i[1] for i in intervals]
ratios_sim = [np.round(r, 2) for r in ratios] #round ratios for similarity measures of harmonic series
#print(ratios_sim)
dyad_sims = ratios2harmsim(ratios[:-1]) # compute dyads similarities with natural harmonic series
dyad_sims
a = 1
ratios_euler = [a]+ratios
ratios_euler = [int(round(num, 2)*1000) for num in ratios]
#print(ratios_euler)
euler_score = None
if euler_comp == True:
euler_score = euler(*ratios_euler)
euler_score = euler_score/len(diss_minima)
else:
euler_score = 'NaN'
if plot == True:
plt.figure(figsize=(14, 6))
plt.plot(linspace(r_low, alpharange, len(diss)), diss)
plt.xscale('linear')
plt.xlim(r_low, alpharange)
try:
plt.text(1.9, 1.5, 'Euler = '+str(int(euler_score)), horizontalalignment = 'center',
verticalalignment='center', fontsize = 16)
except:
pass
for n, d in intervals:
plt.axvline(n/d, color='silver')
# Plot N-TET grid
if n_tet_grid != None:
n_tet = NTET_ratios(n_tet_grid, max_ratio = max_ratio)
for n in n_tet :
plt.axvline(n, color='red', linestyle = '--')
# Plot scale ticks
plt.minorticks_off()
plt.xticks([n/d for n, d in intervals],
['{}/{}'.format(n, d) for n, d in intervals], fontsize = 13)
plt.yticks(fontsize = 13)
plt.tight_layout()
plt.show()
return intervals, ratios, euler_score, np.average(diss), dyad_sims
'''Harmonic Entropy'''
def compute_harmonic_entropy_domain_integral(ratios, ratio_interval, spread=0.01, min_tol=1e-15):
# The first step is to pre-sort the ratios to speed up computation
ind = np.argsort(ratios)
weight_ratios = ratios[ind]
centers = (weight_ratios[:-1] + weight_ratios[1:]) / 2
ratio_interval = array(ratio_interval)
N = len(ratio_interval)
HE = zeros(N)
for i, x in enumerate(ratio_interval):
P = diff(concatenate(([0], norm.cdf(log2(centers), loc=log2(x), scale=spread), [1])))
ind = P > min_tol
HE[i] = -np.sum(P[ind] * log2(P[ind]))
return weight_ratios, HE
def compute_harmonic_entropy_simple_weights(numerators, denominators, ratio_interval, spread=0.01, min_tol=1e-15):
# The first step is to pre-sort the ratios to speed up computation
ratios = numerators / denominators
ind = np.argsort(ratios)
numerators = numerators[ind]
denominators = denominators[ind]
weight_ratios = ratios[ind]
ratio_interval = array(ratio_interval)
N = len(ratio_interval)
HE = zeros(N)
for i, x in enumerate(ratio_interval):
P = norm.pdf(log2(weight_ratios), loc=log2(x), scale=spread) / sqrt(numerators * denominators)
ind = P > min_tol
P = P[ind]
P /= np.sum(P)
HE[i] = -np.sum(P * log2(P))
return weight_ratios, HE
def harmonic_entropy (ratios, res = 0.001, spread = 0.01, plot_entropy = True, plot_tenney = False, octave = 2):
'''
Harmonic entropy is a measure of the uncertainty in pitch perception, and it provides a physical correlate of tonalness,
one aspect of the psychoacoustic concept of dissonance (Sethares). High tonalness corresponds to low entropy and low tonalness
corresponds to high entropy.
ratios: List (float)
ratios between each pairs of frequency peaks
res: float
Defaults to 0.001
resolution of the ratio steps
spread: float
Default to 0.01
plot_entropy: boolean
Defaults to True
When set to True, plot the harmonic entropy curve
plot_tenney: boolean
Defaults to False
When set to True, plot the tenney heights (y-axis) across ratios (x-axis)
octave: int
Defaults to 2
Value of the maximum interval ratio
Returns
----------
HE_minima: List (float)
List of ratios corresponding to minima of the harmonic entropy curve
HE: float
Value of the averaged harmonic entropy
'''
fracs, numerators, denominators = scale2frac(ratios)
ratios = numerators / denominators
#print(ratios)
#ratios = np.interp(ratios, (ratios.min(), ratios.max()), (1, 10))
bendetti_heights = numerators * denominators
tenney_heights = log2(bendetti_heights)
ind = np.argsort(tenney_heights) # first, sort by Tenney height to make things more efficient
bendetti_heights = bendetti_heights[ind]
tenney_heights = tenney_heights[ind]
numerators = numerators[ind]
denominators = denominators[ind]
#ratios = ratios[ind]
if plot_tenney == True:
fig = plt.figure(figsize=(10, 4), dpi=150)
ax = fig.add_subplot(111)
# ax.scatter(ratios, 2**tenney_heights, s=1)
ax.scatter(ratios, tenney_heights, s=1, alpha=.2)
# ax.scatter(ratios[:200], tenney_heights[:200], s=1, color='r')
plt.show()
# Next, we need to ensure a distance `d` between adjacent ratios
M = len(bendetti_heights)
delta = 0.00001
indices = ones(M, dtype=bool)
for i in range(M - 2):
ind = abs(ratios[i + 1:] - ratios[i]) > delta
indices[i + 1:] = indices[i + 1:] * ind
bendetti_heights = bendetti_heights[indices]
tenney_heights = tenney_heights[indices]
numerators = numerators[indices]
denominators = denominators[indices]
ratios = ratios[indices]
M = len(tenney_heights)
#print(M)
#print('hello')
x_ratios = arange(1, octave, res)
_, HE = compute_harmonic_entropy_domain_integral(ratios, x_ratios, spread=spread)
#_, HE = compute_harmonic_entropy_simple_weights(numerators, denominators, x_ratios, spread=0.01)
ind = argrelextrema(HE, np.less)
HE_minima = (x_ratios[ind], HE[ind])
if plot_entropy == True:
fig = plt.figure(figsize=(10, 4), dpi=150)
ax = fig.add_subplot(111)
# ax.plot(weight_ratios, log2(pdf))
ax.plot(x_ratios, HE)
# ax.plot(x_ratios, HE_simple)
ax.scatter(HE_minima[0], HE_minima[1], color='k', s=4)
ax.set_xlim(1, octave)
plt.show()
return HE_minima, np.average(HE)
'''Scale reduction'''
def scale_reduction (scale, mode_n_steps, function, rounding = 4):
'''
Function that reduces the number of steps in a scale according to the consonance between pairs of ratios
scale: List (float)
scale to reduce
mode_n_steps: int
number of steps of the reduced scale
function: function
function used to compute the consonance between pairs of ratios
Choose between: consonance, dyad_similarity, metric_denom
'''
metric_values = []
mode_values = []
for index1 in range(len(scale)):
for index2 in range(len(scale)):
if scale[index1] > scale[index2]: #not include the diagonale in the computation of the avg. consonance
entry = scale[index1]/scale[index2]
#print(entry_value, scale[index1], scale[index2])
mode_values.append([scale[index1], scale[index2]])
#if function == metric_denom:
# metric_values.append(int(function(sp.Rational(entry).limit_denominator(1000))))
#else:
metric_values.append(function(entry))
if function == metric_denom:
cons_ratios = [x for _, x in sorted(zip(metric_values, mode_values))]
else:
cons_ratios = [x for _, x in sorted(zip(metric_values, mode_values))][::-1]
i = 0
mode_ = []
mode_out = []
while len(mode_out) < mode_n_steps:
cons_temp = cons_ratios[i]
mode_.append(cons_temp)
mode_out_temp = [item for sublist in mode_ for item in sublist]
mode_out_temp = [np.round(x, rounding) for x in mode_out_temp]
mode_out = sorted(set(mode_out_temp), key = mode_out_temp.index)[0:mode_n_steps]
i +=1
mode_metric = []
for index1 in range(len(mode_out)):
for index2 in range(len(mode_out)):
if mode_out[index1] > mode_out[index2]:
entry = mode_out[index1]/mode_out[index2]
#if function == metric_denom:
# mode_metric.append(int(function(sp.Rational(entry).limit_denominator(1000))))
#else:
mode_metric.append(function(entry))
return np.average(metric_values), mode_out, np.average(mode_metric)
'''------------------------------------------------------Peaks extraction--------------------------------------------------------------'''
import emd
from PyEMD import EMD, EEMD
from scipy.signal import butter, lfilter
import colorednoise as cn
#PEAKS FUNCTIONS
#HH1D_weightAVG (Hilbert-Huang 1D): takes the average of all the instantaneous frequencies weighted by power
#HH1D_max: takes the frequency bin that has the maximum power value
def compute_peaks_ts (data, peaks_function = 'EMD', FREQ_BANDS = None, precision = 0.25, sf = 1000, max_freq = 80):
alphaband = [[7, 12]]
try:
if FREQ_BANDS == None:
FREQ_BANDS = [[2, 3.55], [3.55, 7.15], [7.15, 14.3], [14.3, 28.55], [28.55, 49.4]]
except:
pass
if peaks_function == 'EEMD':
IMFs = EMD_eeg(data)[1:6]
if peaks_function == 'EMD':
data = np.interp(data, (data.min(), data.max()), (0, +1))
IMFs = emd.sift.sift(data)
#IMFs = emd.sift.ensemble_sift(data)
IMFs = np.moveaxis(IMFs, 0, 1)[1:6]
try:
peaks_temp = []
amps_temp = []
for imf in range(len(IMFs)):
p, a = compute_peak(IMFs[imf], precision = precision, average = 'median')
#print(p)
peaks_temp.append(p)
amps_temp.append(a)
peaks_temp = np.flip(peaks_temp)
amps_temp = np.flip(amps_temp)
except:
pass
if peaks_function == 'HH1D_max':
IMFs = EMD_eeg(data)
IMFs = np.moveaxis(IMFs, 0, 1)
IP, IF, IA = emd.spectra.frequency_transform(IMFs[:, 1:6], sf, 'nht')
precision_hh = precision*2
low = 1
high = max_freq
steps = int((high-low)/precision_hh)
edges, bins = emd.spectra.define_hist_bins(low, high, steps, 'log')
# Compute the 1d Hilbert-Huang transform (power over carrier frequency)
spec = emd.spectra.hilberthuang_1d(IF, IA, edges)
spec = np.moveaxis(spec, 0, 1)
peaks_temp = []
amps_temp = []
for e, i in enumerate(spec):
max_power = np.argmax(i)
peaks_temp.append(bins[max_power])
amps_temp.append(spec[e][max_power])
peaks_temp = np.flip(peaks_temp)
amps_temp = np.flip(amps_temp)
#if peaks_function == 'HH1D_weightAVG':
if peaks_function == 'adapt':
p, a = compute_peaks_raw(data, alphaband, precision = precision, average = 'median')
FREQ_BANDS = alpha2bands(p)
peaks_temp, amps_temp = compute_peaks_raw(data, FREQ_BANDS, precision = precision, average = 'median')
if peaks_function == 'fixed':
peaks_temp, amps_temp = compute_peaks_raw(data, FREQ_BANDS, precision = precision, average = 'median')
peaks = np.array(peaks_temp)
amps = np.array(amps_temp)
return peaks, amps
def extract_all_peaks (data, sf, precision, max_freq = None):
if max_freq == None:
max_freq = sf/2
mult = 1/precision
nperseg = sf*mult
nfft = nperseg
freqs, psd = scipy.signal.welch(data, sf, nfft = nfft, nperseg = nperseg, average = 'median')
psd = 10. * np.log10(psd)
indexes = ss.find_peaks(psd, height=None, threshold=None, distance=10, prominence=None, width=2, wlen=None, rel_height=0.5, plateau_size=None)
peaks = []
amps = []
for i in indexes[0]:
peaks.append(freqs[i])
amps.append(psd[i])
peaks = np.around(np.array(peaks), 5)
peaks = list(peaks)
peaks = [p for p in peaks if p<=max_freq]
return peaks, amps
def harmonic_peaks_fit (peaks, amps, min_freq = 0.5, max_freq = 30, min_harms = 2, harm_limit = 128):
n_total = []
harm_ = []
harm_peaks = []
max_n = []
max_peaks = []
max_amps = []
harmonics = []
harmonic_peaks = []
harm_peaks_fit = []
for p, a in zip(peaks, amps):
n = 0
harm_temp = []
harm_peaks_temp = []
if p < max_freq and p > min_freq:
for p2 in peaks:
if p2 == p:
ratio = 0.1 #arbitrary value to set ratio value to non integer
if p2 > p:
ratio = p2/p
harm = ratio
if p2 < p:
ratio = p/p2
harm = -ratio
if ratio.is_integer():
if harm <= harm_limit:
n += 1
harm_temp.append(harm)
if p not in harm_peaks_temp:
harm_peaks_temp.append(p)
if p2 not in harm_peaks_temp:
harm_peaks_temp.append(p2)
n_total.append(n)
harm_.append(harm_temp)
harm_peaks.append(harm_peaks_temp)
if n >= min_harms:
max_n.append(n)
max_peaks.append(p)
max_amps.append(a)
#print(harm_temp)
harmonics.append(harm_temp)
harmonic_peaks.append(harm_peaks)
harm_peaks_fit.append([p, harm_temp, harm_peaks_temp])
for i in range(len(harm_peaks_fit)):
harm_peaks_fit[i][2] = sorted(harm_peaks_fit[i][2])
max_n = | np.array(max_n) | numpy.array |
#!/usr/bin/ python3
print('''\x1b[32m
██████╗ █████╗ ███╗ ███╗ █████╗ ███╗ ██╗███████╗████████╗
██╔══██╗██╔══██╗████╗ ████║██╔══██╗████╗ ██║██╔════╝╚══██╔══╝
██████╔╝███████║██╔████╔██║███████║██╔██╗ ██║█████╗ ██║
██╔══██╗██╔══██║██║╚██╔╝██║██╔══██║██║╚██╗██║██╔══╝ ██║
██║ ██║██║ ██║██║ ╚═╝ ██║██║ ██║██║ ╚████║███████╗ ██║
╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═══╝╚══════╝ ╚═╝\x1b[35m
╔╦╗┌─┐ ┌┐┌┌─┐┬ ┬┌─┐ ╔═╗┬─┐┌─┐┌┬┐┌─┐┬┌┐┌ ╔╦╗┌─┐┌─┐┬┌─┐┌┐┌
║║├┤ ││││ │└┐┌┘│ │ ╠═╝├┬┘│ │ │ ├┤ ││││ ║║├┤ └─┐││ ┬│││
═╩╝└─┘ ┘└┘└─┘ └┘ └─┘ ╩ ┴└─└─┘ ┴ └─┘┴┘└┘ ═╩╝└─┘└─┘┴└─┘┘└┘
\u001b[31mAuthors: \x1b[33m<NAME> and <NAME>
\u001b[31mDate: \x1b[33m31-May-2017
\u001b[31mCorrespondace: \x1b[33<EMAIL>
\u001b[31mURL: \x1b[33mhttps://sarisabban.github.io/RamaNet
\x1b[36m---------------------------------------------------------\x1b[0m''')
import os
import re
import sys
import h5py
import time
import glob
import math
import tqdm
import gzip
import keras
import random
import sklearn
import Bio.PDB
import datetime
import warnings
import argparse
import numpy as np
import pandas as pd
import tensorflow as tf
from pyrosetta import *
from pyrosetta.toolbox import *
from keras.optimizers import Adam
from keras.models import Sequential, Model
from keras.losses import BinaryCrossentropy
from keras.layers.convolutional import Conv2D
from keras.layers import Activation, ZeroPadding2D
from keras.layers.advanced_activations import LeakyReLU
from keras.layers import Input, Dense, Reshape, Flatten
from keras.layers import UpSampling2D, BatchNormalization
from keras.layers import Dropout, GlobalMaxPooling2D, Conv2DTranspose
# Silence Tensorflow, Keras, and initialise PyRosetta
def warn(*args, **kwargs): pass
warnings.warn = warn
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
init('-out:level 0')
print('\x1b[36m--------------------------------------------------------\x1b[0m')
# Setup arguments
parser = argparse.ArgumentParser(description='De Novo Protein Design Neural Network')
parser.add_argument('-d', '--dataset', nargs='+', metavar='', help='Build the Backbone or Sequence datasets')
parser.add_argument('-f', '--frag', action='store_true', help='Build the Fragment dataset')
parser.add_argument('-tb', '--TrainBack', action='store_true', help='Train the Backbone neural network')
parser.add_argument('-tf', '--TrainFrag', action='store_true', help='Train the Fragment neural network')
parser.add_argument('-ts', '--TrainSeq', action='store_true', help='Train the Sequence neural network')
args = parser.parse_args()
class Dataset():
''' Build a machine learning dataset of protein structures '''
def Database(self, TempDIR, FinalDIR):
'''
Downloads the entire PDB database from https://www.wwpdb.org/
moves all files into one directory, then uncompresses all the files
Generates a directory which contains all .PDB structure files
'''
print('\x1b[33m[.] Downloading PDB database...\x1b[0m')
web = 'rsync.wwpdb.org::ftp/data/structures/divided/pdb/'
os.system('rsync -rlpt -q -v -z --delete --port=33444 {} {}'
.format(web, TempDIR))
print('\x1b[32m[+] Download complete\x1b[0m')
os.mkdir(FinalDIR)
filelist = os.listdir(TempDIR)
print('\x1b[33m[.] Moving files...\x1b[0m')
for directories in tqdm.tqdm(filelist):
files = os.listdir('{}/{}'.format(TempDIR, directories))
for afile in files:
location = ('{}/{}/{}'.format(TempDIR, directories, afile))
os.rename(location, '{}/{}'.format(FinalDIR, afile))
os.system('rm -r ./{}'.format(TempDIR))
print('\x1b[32m[+] Moving complete\x1b[0m')
def Extract(self, directory):
'''
Extracts all the .ent.gz files and separate all chains and save them
into seperate .pdb files. Replaces each .ent.gz file with the .pdb
file of each chain
'''
print('\x1b[33m[.] Extracting files...\x1b[0m')
current = os.getcwd()
pdbfilelist = os.listdir(directory)
io = Bio.PDB.PDBIO()
os.chdir(directory)
for TheFile in tqdm.tqdm(pdbfilelist):
try:
TheName = TheFile.split('.')[0].split('pdb')[1].upper()
InFile = gzip.open(TheFile, 'rt')
structure = Bio.PDB.PDBParser(QUIET=True)\
.get_structure(TheName, InFile)
count = 0
for chain in structure.get_chains():
io.set_structure(chain)
io.save(structure.get_id()+'_'+chain.get_id()+'.pdb')
os.remove(TheFile)
except Exception as TheError:
print('\x1b[31m[-] Failed to extract\t{}\x1b[33m: {}\x1b[0m'
.format(TheFile.upper(), str(TheError)))
os.remove(TheFile)
os.chdir(current)
def NonProtein(self, directory):
''' Remove non-protein structures '''
print('\x1b[33m[.] Deleting none-protein structures...\x1b[0m')
current = os.getcwd()
pdbfilelist = os.listdir(directory)
os.chdir(directory)
for TheFile in tqdm.tqdm(pdbfilelist):
try:
structure = Bio.PDB.PDBParser(QUIET=True)\
.get_structure('X', TheFile)
ppb = Bio.PDB.Polypeptide.PPBuilder()
Type = ppb.build_peptides(structure, aa_only=True)
if Type == []: os.remove(TheFile)
else: continue
except: os.remove(TheFile)
os.chdir(current)
def Size(self, directory, Size_From, Size_To):
''' Remove structures not within defined size '''
print('\x1b[33m[.] Removing unwanted structure sizes...\x1b[0m')
current = os.getcwd()
pdbfilelist = os.listdir(directory)
os.chdir(directory)
for TheFile in tqdm.tqdm(pdbfilelist):
try:
parser = Bio.PDB.PDBParser()
structure = parser.get_structure('X', TheFile)
model = structure[0]
dssp = Bio.PDB.DSSP(model, TheFile, acc_array='Wilke')
for aa in dssp: length = aa[0]
if length >= int(Size_To) or length <= int(Size_From):
os.remove(TheFile)
except: print('\x1b[31m[-] Error in finding protein size\x1b[0m')
os.chdir(current)
def Break(self, directory):
''' Remove structures with a broken (non-continuous) chains '''
print('\x1b[33m[.] Removing non-continuous structures...\x1b[0m')
current = os.getcwd()
pdbfilelist = os.listdir(directory)
os.chdir(directory)
for TheFile in tqdm.tqdm(pdbfilelist):
structure = Bio.PDB.PDBParser(QUIET=True)\
.get_structure('X', TheFile)
ppb = Bio.PDB.Polypeptide.PPBuilder()
Type = ppb.build_peptides(structure, aa_only=True)
try:
x = Type[1]
os.remove(TheFile)
except: continue
os.chdir(current)
def Loops(self, directory, LoopLength):
'''
Remove structures that have loops that are larger than a
spesific length
'''
print('\x1b[33m[.] Removing structures with long loops...\x1b[0m')
current = os.getcwd()
pdbfilelist = os.listdir(directory)
os.chdir(directory)
for TheFile in tqdm.tqdm(pdbfilelist):
try:
parser = Bio.PDB.PDBParser()
structure = parser.get_structure('X', TheFile)
model = structure[0]
dssp = Bio.PDB.DSSP(model, TheFile, acc_array='Wilke')
SS = list()
for res in dssp:
ss = res[2]
if ss == '-' or ss == 'T' or ss == 'S': SS.append('L')
else: SS.append('.')
loops = ''.join(SS).split('.')
loops = [item for item in loops if item]
LargeLoop = None
for item in loops:
if len(item) <= LoopLength: continue
else: LargeLoop = 'LargeLoop'
if LargeLoop == 'LargeLoop': os.remove(TheFile)
else: continue
except: os.remove(TheFile)
os.chdir(current)
def Renumber(self, directory):
''' Renumber structures starting at 1 '''
print('\x1b[33m[.] Renumbering structures...\x1b[0m')
current = os.getcwd()
pdbfilelist = os.listdir(directory)
os.chdir(directory)
for TheFile in tqdm.tqdm(pdbfilelist):
pdb = open(TheFile, 'r')
PDB = open(TheFile+'X', 'w')
count = 0
num = 0
AA2 = None
for line in pdb:
count += 1
AA1 = line[23:27]
if not AA1 == AA2: num += 1
final_line =line[:7]+'{:4d}'.format(count)+line[11:17]+\
line[17:21]+'A'+'{:4d}'.format(num)+line[26:]
AA2 = AA1
PDB.write(final_line)
PDB.close()
os.remove(TheFile)
os.rename(TheFile+'X', TheFile)
os.chdir(current)
def Rg(self, directory, RGcutoff):
''' Remove structures that are below the Raduis of Gyration's value '''
print('\x1b[33m[.] Removing structure low Rg values...\x1b[0m')
current = os.getcwd()
pdbfilelist = os.listdir(directory)
os.chdir(directory)
for TheFile in tqdm.tqdm(pdbfilelist):
mass = list()
Structure = open(TheFile, 'r')
for line in Structure:
line = line.split()
if line[0] == 'TER' or line[0] == 'END': continue
else:
if line[-1] == 'C': mass.append(12.0107)
elif line[-1] == 'O': mass.append(15.9994)
elif line[-1] == 'N': mass.append(14.0067)
elif line[-1] == 'S': mass.append(32.0650)
elif line[-1] == 'H': mass.append(1.00794)
else: continue
coord = list()
p = Bio.PDB.PDBParser()
structure = p.get_structure('X', TheFile)
for model in structure:
for chain in model:
for residue in chain:
for atom in residue: coord.append(atom.get_coord())
xm = [(m*i, m*j, m*k) for (i, j, k), m in zip(coord, mass)]
tmass = sum(mass)
rr = sum(mi*i + mj*j + mk*k for (i, j, k), (mi, mj, mk)\
in zip(coord, xm))
mm = sum((sum(i)/tmass)**2 for i in zip( * xm))
rg = math.sqrt(rr/tmass-mm)
if rg <= RGcutoff: os.remove(TheFile)
else: continue
os.chdir(current)
def Clean(self, directory):
''' Clean each structure within a directory '''
print('\x1b[33m[.] Cleaning structures...\x1b[0m')
os.mkdir('PDBCleaned')
current = os.getcwd()
pdbfilelist = os.listdir(directory)
os.chdir(directory)
for TheFile in tqdm.tqdm(pdbfilelist):
CurFile = open(TheFile, 'r')
NewFile = open('Clean-{}'.format(TheFile), 'a')
for line in CurFile:
if line.split()[0] == 'ATOM': NewFile.write(line)
CurFile.close()
NewFile.close()
os.system('mv Clean-{} ../PDBCleaned'.format(TheFile))
os.chdir(current)
def Path(self, directory, path):
''' Generate a file with the path to each file '''
print('\x1b[33m[.] Generating paths...\x1b[0m')
current = os.getcwd()
pdbfilelist = os.listdir(directory)
os.chdir(directory)
PathFile = open('PDB.list', 'a')
for TheFile in tqdm.tqdm(pdbfilelist):
line = '{}/PDBCleaned/{}\n'.format(path, TheFile)
PathFile.write(line)
os.system('mv PDB.list ../')
os.chdir(current)
def RelaxHPC(self, path, cores):
'''
Generate a PBS job scheduler to perform each structure
relax on a HPC
'''
HPCfile = open('relax.pbs', 'w')
HPCfile.write('#!/bin/bash\n')
HPCfile.write('#PBS -N Relax\n')
HPCfile.write('#PBS -q fat\n')
HPCfile.write('#PBS -l select=1:ncpus=1\n')
HPCfile.write('#PBS -j oe\n')
HPCfile.write('#PBS -J 1-{}\n'.format(str(cores)))
HPCfile.write('cd $PBS_O_WORKDIR\n')
HPCfile.write('mkdir PDBRelaxed\n')
HPCfile.write('cd PDBRelaxed\n')
HPCfile.write('''thefile=$(awk -v "line=${PBS_ARRAY_INDEX}"''')
HPCfile.write(''''NR == line { print; exit }' ../PDB.list)\n''')
HPCfile.write('{}/main/source/bin/'.format(path))
HPCfile.write('relax.default.linuxgccrelease')
HPCfile.write('-relax:thorough -nstruct 100 -database ')
HPCfile.write('{}/main/database -s $thefile'.format(path))
print('\x1b[32m[+] Generated HPC job submission file\x1b[0m')
def Relax(self, directory):
''' Relax each structure in a directory on a local computer '''
print('\x1b[33m[.] Relaxing structures...\x1b[0m')
os.mkdir('PDBRelaxed')
current = os.getcwd()
pdbfilelist = os.listdir(directory)
os.chdir(directory)
for TheFile in tqdm.tqdm(pdbfilelist):
for i in range(1, 101):
scorefxn = get_fa_scorefxn()
relax = pyrosetta.rosetta.protocols.relax.FastRelax()
relax.set_scorefxn(scorefxn)
pose = pose_from_pdb(TheFile)
relax.apply(pose)
pose.dump_pdb('Relaxed{}-{}'.format(i, TheFile))
os.system('mv Relaxed{}-{} ../PDBRelaxed'.format(i, TheFile))
os.chdir(current)
def C_Max(self, filename):
''' Find the maximum value of the Distance Map in a dataset '''
max_in_line = []
with open(filename, 'r') as f:
next(f)
for line in f:
line = line.strip().split(',')[1:]
line = [float(item) for item in line]
max_in_line.append(max(line))
maximum = max(max_in_line)
print('\x1b[32m[+] Contact Map maximum value: {}\x1b[0m'\
.format(maximum))
return(maximum)
def DatasetPSCM(self, directory):
'''
Compile a dataset of each residue's phi and psi angles and another
dataset of the contact map for each structure. This dataset is padded
with zeros.
'''
a = 'Compiling phi and psi angles dataset'
b = 'as well as a distance matrix dataset'
text = a+b
print('\x1b[32m{}\x1b[0m'.format(text))
# Setup dataset header for angles
headerPS = ['PDB_ID']
for i in range(1, 150+1):
headerPS.append(',phi_{},psi_{}'.format(i, i))
headerPS = ''.join(headerPS)
with open('./PS.csv', 'w') as headPS:
headPS.write(headerPS+'\n')
# Setup dataset header for distance matrices
headerCM = ['PDB_ID']
for r in range(1, 150+1):
for c in range(1, 150+1):
headerCM.append(',{}{}'.format(r, c))
headerCM = ''.join(headerCM)
with open('./CM.csv', 'w') as headCM:
headCM.write(headerCM+'\n')
for File in tqdm.tqdm(os.listdir(directory)):
TheFile = '{}/{}'.format(directory, File)
try:
# Compile angles
pose = pose_from_pdb(TheFile)
phi = []
psi = []
for aa in range(len(pose.residues)):
try:
p = pose.phi(aa+1)
s = pose.psi(aa+1)
if p < 0: p = p+360
if s < 0: s = s+360
phi.append(p)
psi.append(s)
except: pass
angles = []
for P, S in zip(phi, psi):
angles.append(str(round(P, 5))+','+str(round(S, 5)))
assert len(phi) == len(psi)
Angles = ','.join(angles)
if len(angles) >= 150: AngLine = Angles
else:
addition = 150-len(angles)
zeros = []
for adds in range(addition): zeros.append('0.0,0.0')
Zeros = ','.join(zeros)
AngLine = '{},{}'.format(Angles, Zeros)
ThePSLine = '{},{}\n'.format(File, AngLine)
with open('PS.csv', 'a') as PSdata:
PSdata.write(ThePSLine)
#Compile contact map (Ca-Ca contact <= 12 angstroms)
BIO = Bio.PDB.PDBParser(QUIET=True)
structure = BIO.get_structure('X', TheFile)
ppb = Bio.PDB.Polypeptide.PPBuilder()
Type = ppb.build_peptides(structure, aa_only=False)
model = Type
chain = model[0]
CM = []
for aa1 in range(0, 150):
for aa2 in range(0, 150):
try:
residue1 = chain[aa1]
residue2 = chain[aa2]
atom1 = residue1['CA']
atom2 = residue2['CA']
if atom1-atom2 <= 12: CM.append(str(atom1-atom2))
else: CM.append(str(0))
except:
CM.append(str(0))
assert len(CM) == 22500
ContactMap = ','.join(CM)
TheCMLine = '{},{}\n'.format(File, ContactMap)
with open('CM.csv', 'a') as CMdata:
CMdata.write(TheCMLine)
except: pass
def VectorisePSCM(self, PS_file='PS.csv',
CM_file='CM.csv',
C_MAX=12,
fp=np.float64):
'''
This function vectorises the backbone PS and CM datasets, normalises
them, combines them, as well as constructs the final tensor and
export the result as a serial.
'''
# 1. Import a single row of PS dataset
with open(PS_file) as PSf:
next(PSf)
P, S = [], []
for line in PSf:
# 2. Isolate different angles
line = line.strip().split(',')
p = [float(item) for item in line[1::2]]
s = [float(item) for item in line[2::2]]
assert len(p) == len(s)
P.append(np.array(p, dtype=fp))
S.append(np.array(s, dtype=fp))
with open(CM_file) as CMf:
next(CMf)
CM = []
for line in CMf:
# 3. Isolate different points
line = [float(item) for item in line.strip().split(',')[1:]]
cm = np.reshape(line, (150, 150))
CM.append(np.array(cm, dtype=fp))
# 4. Construct PS matrices
P = np.array(P)
S = np.array(S)
# 5. Normalise PS angles (min/max) [-1, 1]
P /= 180
S /= 180
P -= 1
S -= 1
PS = np.array([P, S])
PS = np.swapaxes(PS, 0, 2)
PS = np.swapaxes(PS, 0, 1)
# 6. Construct CM matrices
CM = np.array(CM)
# 7. Normalise CM contact map (min/max) [-1, 1]
CM /= (C_MAX/2)
CM -= 1
# 8. Construct final dataset matrix
dataset = np.concatenate([PS, CM], axis=2)
# 9. Suffle dataset
sklearn.utils.shuffle(dataset)
# 10. Serialise tensors
with h5py.File('PS+CM.h5', 'w') as data:
dataset = data.create_dataset('default', data=dataset)
def DatasetAsPSaM(self, directory):
'''
Compile a dataset of each residue's amino acid identify, secondary
structure, phi angle, psi angle, solvent accessible surface area as
a .csv file and the contact map as a separate .csv file. to be run
after clean() on the ./cleaned directory, also outputs a file
identifying the sizes of structures, so the largest value can be used
with HeaderAsPSaM()
'''
os.makedirs('./Completed', exist_ok=True)
os.makedirs('./Error_NotEqual', exist_ok=True)
os.makedirs('./Error_Broken', exist_ok=True)
os.makedirs('./Error_Small', exist_ok=True)
for File in tqdm.tqdm(os.listdir(directory)):
try:
TheFile = '{}/{}'.format(directory, File)
pose = pose_from_pdb(TheFile)
DSSP = pyrosetta.rosetta.protocols.moves.DsspMover()
DSSP.apply(pose)
sasa_calc = pyrosetta.rosetta.core.scoring.sasa.SasaCalc()
sasa_calc.calculate(pose)
size = pose.total_residue()
aa = []
ss = []
phi = []
psi = []
sasa = []
info = []
ctmp = []
m = []
surf = list(sasa_calc.get_residue_sasa())
for r in range(size):
if pose.residue(r+1).is_protein():
aa.append(pose.sequence(r+1, r+1))
ss.append(pose.secstruct(r+1))
p = pose.phi(r+1)
if p < 0: p = p+360
phi.append(p)
s = pose.psi(r+1)
if s < 0: s = s+360
psi.append(s)
sasa.append(surf[r])
for r in range(0, size):
for R in range(0, size):
if pose.residue(r+1).is_protein() and\
pose.residue(R+1).is_protein():
CAr = pose.residue(r+1).xyz('CA')
CAR = pose.residue(R+1).xyz('CA')
CAr_CAR_vector = CAR-CAr
Cont = CAr_CAR_vector.norm()
if Cont <= 12: ctmp.append(Cont)
else: ctmp.append(0)
if len(aa) >= 50:
try:
assert len(aa) == len(ss) == len(phi)\
== len(psi) == len(sasa) == math.sqrt(len(ctmp))
for AA,SS,P,S,SASA in zip(aa,ss,phi,psi,sasa):
info.append('{},{},{},{},{}'\
.format(AA, SS, P, S, SASA))
Info = ','.join(info)
with open('./AsPSa_noheader_nofill.csv', 'a') as data:
data.write(File + ',' + Info + '\n')
with open('lengths.txt', 'a') as length:
length.write(str(len(aa))+',')
for x in ctmp:
m.append('{}'.format(x))
M = ','.join(m)
with open('./M_noheader_nofill.csv', 'a') as data:
data.write(File + ',' + M + '\n')
os.system('mv {} ./Completed'.format(TheFile))
except:
os.system('mv {} ./Error_NotEqual'\
.format(TheFile))
else: os.system('mv {} ./Error_Small'.format(TheFile))
except: passos.system('mv {} ./Error_Broken'.format(TheFile))
def HeaderAsPSaM(self, choice='AsPSa'):
'''
Constructs a .csv header and completes the dataset. To find the value of
the largest structure run: sort -nk 1 lengths.txt
'''
with open('lengths.txt', 'r') as L:
length = int(max(L.readlines()[0].strip().split(',')))
header = ['PDB_ID']
if choice == 'AsPSa':
for i in range(1, length+1):
header.append(',aa_{},ss_{},phi_{},psi_{},sasa_{}'\
.format(i, i, i, i, i))
header = ''.join(header)
with open('./AsPSa_noheader_nofill.csv', 'r') as data:
with open('./AsPSa_nofill.csv', 'w') as head:
head.write(header+'\n')
for line in data:
head.write(line)
os.remove('./AsPSa_noheader_nofill.csv')
elif choice == 'M':
for r in range(1, length+1):
for c in range(1, length+1):
header.append(',{}{}'.format(r, c))
header = ''.join(header)
with open('./M_noheader_nofill.csv', 'r') as data:
with open('./M_nofill.csv', 'w') as head:
head.write(header+'\n')
for line in data:
head.write(line)
os.remove('./M_noheader_nofill.csv')
def Fill(self, filename):
''' Fills missing .csv table spaces with zeros '''
name = filename.split('_')[0]
with open(filename) as f:
with open(name+'.csv', 'a') as F:
first_line = f.readline()
F.write(first_line)
size = len(first_line.strip().split(','))
for line in f:
line = line.strip().split(',')
gap = size - len(line)
for zero in range(gap):
line.append('0')
new_line = ','.join(line)
F.write(new_line + '\n')
os.remove(filename)
def VectoriseAsPSaM(self, filenameA='AsPSa.csv', filenameM='M.csv'):
'''
This function vectorises the backbone PS and CM datasets, normalises
them, combines them, as well as constructs the final tensor and
export the result as a serial.
'''
pass
def build(self, switches='', directory='PDBDatabase'):
if len(switches) == 20:
switch = list(switches)
if switch[0] == '1': self.Database('DATABASE', directory)
if switch[1] == '1': self.Extract(directory)
if switch[2] == '1': self.NonProtein(directory)
if switch[3] == '1': self.Size(directory, 80, 150)
if switch[4] == '1': self.Break(directory)
if switch[5] == '1': self.Loops(directory, 10)
if switch[6] == '1': self.Renumber(directory)
if switch[7] == '1': self.Rg(directory, 15)
########## --- HUMAN EYE FILTERING --- ##########
if switch[8] == '1': self.Clean(directory)
if switch[9] == '1': self.Path('PDBCleaned', '{PATH}')
if switch[10] == '1': self.RelaxHPC('~/Rosetta', 829)
if switch[11] == '1': self.Relax('PDBCleaned')
if switch[12] == '1': self.DatasetAsPSaM('PDBCleaned')
if switch[13] == '1': self.HeaderAsPSaM('AsPSa')
if switch[14] == '1':
self.HeaderAsPSaM('M')
os.remove('lengths.txt')
if switch[15] == '1':
self.Fill('AsPSa_nofill.csv')
self.Fill('M_nofill.csv')
if switch[16] == '1': self.DatasetPSCM('PDBCleaned')
if switch[17] == '1': self.C_Max('dataset_CM.csv')
if switch[18] == '1': self.VectorisePSCM()
if switch[18] == '1': self.VectoriseAsPSaM()
else: print('\x1b[31m[-] Error\x1b[33m: Wrong string length\x1b[0m')
def Vall(filename='vall.jul19.2011', m=16800, nx=1490):
'''
Compile the PDB IDs, chains, phi, psi, omega, and SASA of all the structures
from the Rosetta vall.jul19.2011 database into a .csv file
'''
assert os.path.isfile('./{}'.format(filename)),\
'Make sure the vall.jul19.2011 file is in the same directory as this script'
with open(filename, 'r') as f:
with open('Fragments.csv', 'w') as F:
header = ['PDBID,Chain']
for i in range(1, nx+1):
header.append(',AA_{},SS_{},P_{},S_{},O_{},SASA_{}'\
.format(i, i, i, i, i, i))
header = ''.join(header)
F.write(header + '\n')
for i in range(30): next(f)
ID = []
CH = []
AA = []
SS = []
P = []
S = []
O = []
SASA= []
ID_seen = set()
for line in f:
line = line.strip().split()
if line[0] not in ID_seen:
exp = []
for aa, ss, p, s, o, sasa in zip(AA, SS, P, S, O, SASA):
exp.append('{},{},{},{},{},{}'\
.format(aa, ss, p, s, o, sasa))
exp = ','.join(exp)
if exp == '': pass
else: F.write(ID + ',' + CH + ',' + exp + '\n')
ID = None
CH = None
AA = []
SS = []
P = []
S = []
O = []
SASA = []
ID_seen.add(line[0])
ID = line[0][:4].upper()
CH = line[0][-1].upper()
AA.append(line[1])
SS.append(line[2])
P.append(line[14])
S.append(line[15])
O.append(line[16])
SASA.append(line[19])
else:
ID = line[0][:4].upper()
CH = line[0][-1].upper()
AA.append(line[1])
SS.append(line[2])
P.append(line[14])
S.append(line[15])
O.append(line[16])
SASA.append(line[19])
exp = []
for aa, ss, p, s, o, sasa in zip(AA, SS, P, S, O, SASA):
exp.append('{},{},{},{},{},{}'\
.format(aa, ss, p, s, o, sasa))
exp = ','.join(exp)
F.write(ID + ',' + CH + ',' + exp)
def Frag_vectorise(filename='Fragments.csv', nx=1452):
''' Vectorises the fragments dataset, normalises it, then serialises it '''
# 1. Import data
rows = len(open(filename).readlines()) - 1
# 2. Generate a list of random number of rows
lines = list(range(1, rows + 1))
random.shuffle(lines)
# 3. Open CSV file
with open(filename, 'r') as File: all_lines_variable = File.readlines()
PDBID, CHAIN, X, Y = [], [], [], []
for i in tqdm.tqdm(lines):
# 4. Import data line by line
line = all_lines_variable[i]
line = line.strip().split(',')
if line[0] == '1OFD': continue # Causes an error
aa = | np.array(line[2::6]) | numpy.array |
# coding: utf-8
import numpy as np
from core import get_kernel_fn
from numpy.testing import assert_allclose
from typedefs import DTYPE
from hypothesis import given, assume
from hypothesis.extra.numpy import arrays
from hypothesis.strategies import floats, integers, one_of, composite
NUMBERS = one_of(floats(allow_infinity = False, allow_nan = False), integers())
EPSILON = np.sqrt(np.finfo(float).eps) # 1.4901161193847656e-08
# KNOWN_KERNELS = {'bartlett', 'epanechnikov', 'uniform',
# 'biweight', 'quartic', 'tricube',
# 'triweight', 'cosine'}
# dists = np.array([-1, 0, 1, 2, 3], dtype = DTYPE)
# cutoff = 3
@composite
def generate_dists_cutoff(draw):
N = draw(integers(min_value = 0, max_value = 200))
dists = draw(arrays(DTYPE, (N,), elements = NUMBERS))
cutoff = draw(floats(min_value = 10 * EPSILON,
allow_infinity = False, allow_nan = False))
dists = dists[np.abs(dists) <= cutoff]
return (dists, cutoff)
@given(generate_dists_cutoff())
def test_bartlett(dists_and_cutoff):
dists, cutoff = dists_and_cutoff
kernel_fn = get_kernel_fn('bartlett')
claimed_weights = kernel_fn(dists, cutoff)
correct_weights = 1 - np.abs(dists / cutoff)
assert_allclose(claimed_weights, correct_weights, atol = 0.00001)
@given(generate_dists_cutoff())
def test_epanechnikov(dists_and_cutoff):
dists, cutoff = dists_and_cutoff
kernel_fn = get_kernel_fn('epanechnikov')
claimed_weights = kernel_fn(dists, cutoff)
correct_weights = 3 / 4 * (1 - (dists / cutoff)**2) * (np.abs(dists) < cutoff)
assert_allclose(claimed_weights, correct_weights, atol = 0.00001)
@given(generate_dists_cutoff())
def test_cosine(dists_and_cutoff):
dists, cutoff = dists_and_cutoff
kernel_fn = get_kernel_fn('cosine')
claimed_weights = kernel_fn(dists, cutoff)
correct_weights = (np.pi / 4 * ( | np.cos(np.pi / 2 * (dists / cutoff)) | numpy.cos |
import numpy as np
from numpy import linalg as npl
from meshpy import triangle
from mesh_sphere_packing import logger, ONE_THIRD, GROWTH_LIMIT
from mesh_sphere_packing.area_constraints import AreaConstraints
# TODO : change nomenclature. Segment is used in geometry to refer to an
# : edge connecting two points. Here segment is used to refer to part
# : of a sphere surface. This is confusing...
class PSLG(object):
"""Stores geometry and topology of a Planar Straigh Line Graph."""
def __init__(self, points, edges, holes):
"""Constructs PSLG object.
:param points numpy.ndarray: array of PSLG vertex coordinates.
:param adges numpy.ndarray: array of PSLG edges (vertex topology).
:param holes numpy.ndarray: array of coordinates of holes in the PSLG.
"""
self.points = points
self.edges = edges
self.holes = holes
class BoundaryPLC(object):
"""Stores geometry and topology of a Piecewise Linear Complex forming a domain
boundary.
"""
def __init__(self, points, tris, holes):
"""Constructs BoundaryPLC object.
:param points numpy.ndarray: array of PLC vertex coordinates.
:param adges numpy.ndarray: array of PLC tris (vertex topology).
:param holes numpy.ndarray: array of coordinates of holes in the PLC.
"""
self.points = points
self.tris = tris
self.holes = holes
def build_boundary_PSLGs(domain, sphere_pieces, ds):
"""Constructs PSLGs for domain boundaries. Each boundary is represented by a
Planar Straight Line Graph consisting of set of vertices and edges corresponding
to the union of all intersection loops which lie on the boundary and all boundary
perimeter vertices and edges.
:param domain Domain: spatial domain for mesh.
:param sphere_pieces list: list of SpherePiece objects.
:param ds float: characteristic segment length.
:return: list of PSLG objects for the lower bounds along each coordinate axis.
:rtype: list.
"""
# TODO : Break up this function a bit.
def compile_points_edges(sphere_pieces):
"""Produces consolidated arrays containing all SpherePiece vertices and
edges.
:param sphere_pieces list: list of SpherePiece objects.
:return: tuple of arrays of vertex coordinates and topology.
:rtype: tuple.
"""
def build_edge_list(tris, points):
v_adj = np.zeros(2*[points.shape[0]], dtype=np.int32)
v_adj[tris[:,0], tris[:,1]] = v_adj[tris[:,1], tris[:,0]] = 1
v_adj[tris[:,1], tris[:,2]] = v_adj[tris[:,2], tris[:,1]] = 1
v_adj[tris[:,2], tris[:,0]] = v_adj[tris[:,0], tris[:,2]] = 1
return np.array(np.where(np.triu(v_adj) == 1), dtype=np.int32).T
vcount = 0
all_points = []
all_edges = []
for points, tris in [(p.points, p.tris) for p in sphere_pieces]:
edges = build_edge_list(tris, points)
edges += vcount
vcount += len(points)
all_points.append(points)
all_edges.append(edges)
return np.vstack(all_points), | np.vstack(all_edges) | numpy.vstack |
# Copyright (c) Microsoft Corporation and contributors.
# Licensed under the MIT License.
import warnings
from abc import abstractmethod
from typing import Optional
import networkx as nx
import numpy as np
from sklearn.base import BaseEstimator
from sklearn.utils.validation import check_is_fitted
from ..utils import (
augment_diagonal,
import_graph,
is_almost_symmetric,
is_fully_connected,
)
from .svd import select_svd
class BaseSpectralEmbed(BaseEstimator):
"""
A base class for embedding a graph.
Parameters
----------
n_components : int or None, default = None
Desired dimensionality of output data. If "full",
n_components must be <= min(X.shape). Otherwise, n_components must be
< min(X.shape). If None, then optimal dimensions will be chosen by
``select_dimension`` using ``n_elbows`` argument.
n_elbows : int, optional, default: 2
If `n_components=None`, then compute the optimal embedding dimension using
`select_dimension`. Otherwise, ignored.
algorithm : {'full', 'truncated' (default), 'randomized'}, optional
SVD solver to use:
- 'full'
Computes full svd using ``scipy.linalg.svd``
- 'truncated'
Computes truncated svd using ``scipy.sparse.linalg.svd``
- 'randomized'
Computes randomized svd using
``sklearn.utils.extmath.randomized_svd``
n_iter : int, optional (default = 5)
Number of iterations for randomized SVD solver. Not used by 'full' or
'truncated'. The default is larger than the default in randomized_svd
to handle sparse matrices that may have large slowly decaying spectrum.
check_lcc : bool , optional (defult =True)
Whether to check if input graph is connected. May result in non-optimal
results if the graph is unconnected. Not checking for connectedness may
result in faster computation.
concat : bool, optional (default = False)
If graph(s) are directed, whether to concatenate each graph's left and right
(out and in) latent positions along axis 1.
svd_seed : int or None (default ``None``)
Only applicable for ``algorithm="randomized"``; allows you to seed the
randomized svd solver for deterministic, albeit pseudo-randomized behavior.
Attributes
----------
n_components_ : int
Dimensionality of the embedded space.
n_features_in_: int
Number of features passed to the fit method.
See Also
--------
graspologic.embed.select_svd, graspologic.embed.select_dimension
"""
def __init__(
self,
n_components=None,
n_elbows=2,
algorithm="randomized",
n_iter=5,
check_lcc=True,
concat=False,
svd_seed: Optional[int] = None,
):
self.n_components = n_components
self.n_elbows = n_elbows
self.algorithm = algorithm
self.n_iter = n_iter
self.check_lcc = check_lcc
if not isinstance(concat, bool):
msg = "Parameter `concat` is expected to be type bool"
raise TypeError(msg)
self.concat = concat
self.svd_seed = svd_seed
def _reduce_dim(self, A, directed=None):
"""
A function that reduces the dimensionality of an adjacency matrix
using the desired embedding method.
Parameters
----------
A: array-like, shape (n_vertices, n_vertices)
Adjacency matrix to embed.
"""
U, D, V = select_svd(
A,
n_components=self.n_components,
n_elbows=self.n_elbows,
algorithm=self.algorithm,
n_iter=self.n_iter,
svd_seed=self.svd_seed,
)
self.n_components_ = D.size
self.singular_values_ = D
self.latent_left_ = U @ np.diag(np.sqrt(D))
if directed is not None:
directed_ = directed
else:
directed_ = not is_almost_symmetric(A)
if directed_:
self.latent_right_ = V.T @ np.diag(np.sqrt(D))
else:
self.latent_right_ = None
@property
def _pairwise(self):
"""This is for sklearn compliance."""
return True
@abstractmethod
def fit(self, graph, y=None, *args, **kwargs):
"""
A method for embedding.
Parameters
----------
graph: np.ndarray or networkx.Graph
y : Ignored
Returns
-------
lpm : LatentPosition object
Contains X (the estimated latent positions), Y (same as X if input is
undirected graph, or right estimated positions if directed graph), and d.
See Also
--------
import_graph, LatentPosition
"""
# call self._reduce_dim(A) from your respective embedding technique.
# import graph(s) to an adjacency matrix using import_graph function
# here
return self
def _fit(self, graph, y=None):
"""
A method for embedding.
Parameters
----------
graph: np.ndarray or networkx.Graph
y : Ignored
Returns
-------
A : array-like, shape (n_vertices, n_vertices)
A graph
See Also
--------
import_graph, LatentPosition
"""
A = import_graph(graph)
if self.check_lcc:
if not is_fully_connected(A):
msg = (
"Input graph is not fully connected. Results may not"
+ "be optimal. You can compute the largest connected component by"
+ "using ``graspologic.utils.largest_connected_component``."
)
warnings.warn(msg, UserWarning)
self.n_features_in_ = A.shape[0]
return A
def _fit_transform(self, graph, *args, **kwargs):
"Fits the model and returns the estimated latent positions."
self.fit(graph, *args, **kwargs)
if self.latent_right_ is None:
return self.latent_left_
else:
if self.concat:
return | np.concatenate((self.latent_left_, self.latent_right_), axis=1) | numpy.concatenate |
import numpy as np
import cPickle
import os
class CrossValidation(object):
def __init__(self, data):
self.trainval = data
def validate(self, model, ranges, verbose):
return None
class KFoldCrossValidation(CrossValidation):
def __init__(self, data, k):
super(KFoldCrossValidation, self).__init__(data)
self.k = k
def validate(self, model, ranges, verbose=True):
print("\tPerforming {}-fold cross-validation".format(self.k))
if model.name == 'kNN':
if isinstance(ranges, xrange):
param_range = ranges
else:
raise ValueError("ranges must be an xrange instance")
accs = []
for k in param_range:
micro_acc = []
for train_data, val_data in self._get_folds():
model.fit(train_data)
predictions = model.predict(val_data['x'], k=k)
macc = np.sum(predictions == val_data['y']) / float(predictions.shape[0]) * 100.0
micro_acc.append(macc)
averaged_acc_for_k = np.mean(micro_acc)
if verbose:
print("\t\tValidation accuracy for k={1}: {0}".format(averaged_acc_for_k, k))
accs.append(averaged_acc_for_k)
best_k = np.argmax(accs) + 1
print("\tBest k is: {0}".format(best_k))
return best_k
elif model.name == 'LogisticRegression':
if isinstance(ranges, list):
param_range = ranges
else:
raise ValueError("ranges must be a list instance")
accs = []
for reg in param_range:
micro_acc = []
for train_data, val_data in self._get_folds():
model.fit(train_data, num_epochs=50, reg=reg, reinit=True, verbose=False, save_best=False)
predictions = model.predict(val_data['x'])
macc = np.sum(predictions == val_data['y']) / float(predictions.shape[0]) * 100.0
micro_acc.append(macc)
averaged_acc_for_epoch = np.mean(micro_acc)
if verbose:
print("\t\tValidation accuracy for reg={1}: {0}".format(averaged_acc_for_epoch, reg))
accs.append(averaged_acc_for_epoch)
best_reg = np.argmax(accs)
print("\tBest reg is: {0}".format(param_range[best_reg]))
return param_range[best_reg]
else:
raise NotImplementedError
def _get_folds(self):
data_size = self.trainval['x_train'].shape[0]
folds = np.array_split(np.arange(data_size), self.k)
# if the last split is unbalanced, merge with the one before the last
if folds[self.k - 1].shape[0] < folds[0].shape[0] // 2:
folds[self.k - 2] = np.concatenate([folds[self.k - 2], folds[self.k - 1]])
del folds[self.k - 1]
for i in xrange(self.k):
val_idxs = folds[i]
train_idxs = np.setdiff1d( | np.arange(data_size) | numpy.arange |
######################################
#
# <NAME> (C) 2017-Present
#
# <EMAIL>
#
#####################################
#
# the bottom part of this file is not by me (as is indicated below)
#
import numpy as np
from sklearn.utils import check_random_state
def circle(n,var,rs=1):
rs = check_random_state(rs)
xvec = np.linspace(0,2*np.pi,n)
X = np.zeros([n,2])
X[:,0] = np.cos(xvec) + rs.normal(0,var,n)
X[:,1] = np.sin(xvec) + rs.normal(0,var,n)
mu = np.zeros(2)
sigma = np.eye(2)
Y = rs.multivariate_normal(mu, sigma, size=n)
return X
######################################
#
# THE CODE BELOW IS NOT MY CODE
# SOURCE GITHUB: https://github.com/dougalsutherland/opt-mmd/blob/master/two_sample/generate.py
#####################################
def gaussian(n,corr,rs=1):
rs = check_random_state(rs)
mu = np.zeros(2)
correlation = corr
corr_sigma = | np.array([[1, correlation], [correlation, 1]]) | numpy.array |
import nibabel as nib
import numpy as np
ca_net = nib.load('../source_data/CortexSubcortex_ColeAnticevic_NetPartition_wSubcorGSR_netassignments_LR.dlabel.nii')
# rois of grayordinates in the cortex
rois = ca_net.dataobj[0].astype(int)
axis0 = ca_net.header.get_index_map(0)
nmap = list(axis0.named_maps)[0]
labels = []
rgba = []
keys = []
# left hemisphere
for i in nmap.label_table:
roi = nmap.label_table[i]
labels.append(roi.label[:-4])
keys.append(roi.key)
rgba.append((roi.red, roi.green, roi.blue, roi.alpha))
# replace shorthand labels by full names from ColeAnticevicNetPartition/network_labelfile.txt
labels = ['', 'Visual1', 'Visual2', 'Somatomotor', 'Cingulo-Opercular', 'Dorsal-attention', 'Language', 'Frontoparietal', 'Auditory', 'Default', 'Posterior-Multimodal', 'Ventral-Multimodal', 'Orbito-Affective']
labels = np.array(labels)
rgba = np.array(rgba)
keys = | np.array(keys) | numpy.array |
""" Simple maze environment
"""
import numpy as np
# import cv2 #why is this needed?
from deer.base_classes import Environment
import matplotlib
#matplotlib.use('agg')
matplotlib.use('qt5agg')
from mpl_toolkits.axes_grid1 import host_subplot
import mpl_toolkits.axisartist as AA
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.cm as cm
from matplotlib.patches import Circle, Rectangle
from matplotlib.offsetbox import AnchoredOffsetbox, TextArea, DrawingArea, HPacker
import copy
class MyEnv(Environment):
VALIDATION_MODE = 0
def __init__(self, rng, **kwargs):
self._mode = -1
self._mode_score = 0.0
self._mode_episode_count = 0
self._size_maze=8
self._higher_dim_obs=kwargs["higher_dim_obs"]
self.create_map()
self.intern_dim=2
def create_map(self):
self._map=np.ones((self._size_maze,self._size_maze))
self._map[-1,:]=0
self._map[0,:]=0
self._map[:,0]=0
self._map[:,-1]=0
self._map[:,self._size_maze//2]=0
self._map[self._size_maze//2,self._size_maze//2]=1
self._pos_agent=[2,2]
self._pos_goal=[self._size_maze-2,self._size_maze-2]
def reset(self, mode):
self.create_map()
self._map[self._size_maze//2,self._size_maze//2]=0
if mode == MyEnv.VALIDATION_MODE:
if self._mode != MyEnv.VALIDATION_MODE:
self._mode = MyEnv.VALIDATION_MODE
self._mode_score = 0.0
self._mode_episode_count = 0
else:
self._mode_episode_count += 1
elif self._mode != -1:
self._mode = -1
# Setting the starting position of the agent
self._pos_agent=[self._size_maze//2,self._size_maze//2]
#print ("new map:")
#print (self._map)
#print ("reset mode")
#print (mode)
return [1 * [self._size_maze * [self._size_maze * [0]]]]
def act(self, action):
"""Applies the agent action [action] on the environment.
Parameters
-----------
action : int
The action selected by the agent to operate on the environment. Should be an identifier
included between 0 included and nActions() excluded.
"""
self._cur_action=action
if(action==0):
if(self._map[self._pos_agent[0]-1,self._pos_agent[1]]==1):
self._pos_agent[0]=self._pos_agent[0]-1
elif(action==1):
if(self._map[self._pos_agent[0]+1,self._pos_agent[1]]==1):
self._pos_agent[0]=self._pos_agent[0]+1
elif(action==2):
if(self._map[self._pos_agent[0],self._pos_agent[1]-1]==1):
self._pos_agent[1]=self._pos_agent[1]-1
elif(action==3):
if(self._map[self._pos_agent[0],self._pos_agent[1]+1]==1):
self._pos_agent[1]=self._pos_agent[1]+1
# There is no reward in this simple environment
self.reward = 0
self._mode_score += self.reward
return self.reward
def summarizePerformance(self, test_data_set, learning_algo, *args, **kwargs):
""" Plot of the low-dimensional representation of the environment built by the model
"""
all_possib_inp=[] # Will store all possible inputs (=observation) for the CRAR agent
labels_maze=[]
self.create_map()
for y_a in range(self._size_maze):
for x_a in range(self._size_maze):
state=copy.deepcopy(self._map)
state[self._size_maze//2,self._size_maze//2]=0
if(state[x_a,y_a]==0):
if(self._higher_dim_obs==True):
all_possib_inp.append(self.get_higher_dim_obs([[x_a,y_a]],[self._pos_goal]))
else:
state[x_a,y_a]=0.5
all_possib_inp.append(state)
## labels
#if(y_a<self._size_maze//2):
# labels_maze.append(0.)
#elif(y_a==self._size_maze//2):
# labels_maze.append(1.)
#else:
# labels_maze.append(2.)
#arr=np.array(all_possib_inp)
#if(self._higher_dim_obs==False):
# arr=arr.reshape(arr.shape[0],-1)
#else:
# arr=arr.reshape(arr.shape[0],-1)
#
#np.savetxt('tsne_python/mazesH_X.txt',arr.reshape(arr.shape[0],-1))
#np.savetxt('tsne_python/mazesH_labels.txt',np.array(labels_maze))
all_possib_inp=np.expand_dims(np.array(all_possib_inp,dtype='float'),axis=1)
all_possib_abs_states=learning_algo.encoder.predict(all_possib_inp)
if(all_possib_abs_states.ndim==4):
all_possib_abs_states=np.transpose(all_possib_abs_states, (0, 3, 1, 2)) # data_format='channels_last' --> 'channels_first'
n=1000
historics=[]
for i,observ in enumerate(test_data_set.observations()[0][0:n]):
historics.append(np.expand_dims(observ,axis=0))
historics=np.array(historics)
abs_states=learning_algo.encoder.predict(historics)
if(abs_states.ndim==4):
abs_states=np.transpose(abs_states, (0, 3, 1, 2)) # data_format='channels_last' --> 'channels_first'
actions=test_data_set.actions()[0:n]
if self.inTerminalState() == False:
self._mode_episode_count += 1
print("== Mean score per episode is {} over {} episodes ==".format(self._mode_score / (self._mode_episode_count+0.0001), self._mode_episode_count))
m = cm.ScalarMappable(cmap=cm.jet)
x = np.array(abs_states)[:,0]
y = np.array(abs_states)[:,1]
if(self.intern_dim>2):
z = np.array(abs_states)[:,2]
fig = plt.figure()
if(self.intern_dim==2):
ax = fig.add_subplot(111)
ax.set_xlabel(r'$X_1$')
ax.set_ylabel(r'$X_2$')
else:
ax = fig.add_subplot(111,projection='3d')
ax.set_xlabel(r'$X_1$')
ax.set_ylabel(r'$X_2$')
ax.set_zlabel(r'$X_3$')
# Plot the estimated transitions
for i in range(n-1):
predicted1=learning_algo.transition.predict([abs_states[i:i+1],np.array([[1,0,0,0]])])
predicted2=learning_algo.transition.predict([abs_states[i:i+1],np.array([[0,1,0,0]])])
predicted3=learning_algo.transition.predict([abs_states[i:i+1],np.array([[0,0,1,0]])])
predicted4=learning_algo.transition.predict([abs_states[i:i+1],np.array([[0,0,0,1]])])
if(self.intern_dim==2):
ax.plot(np.concatenate([x[i:i+1],predicted1[0,:1]]), np.concatenate([y[i:i+1],predicted1[0,1:2]]), color="0.9", alpha=0.75)
ax.plot(np.concatenate([x[i:i+1],predicted2[0,:1]]), np.concatenate([y[i:i+1],predicted2[0,1:2]]), color="0.65", alpha=0.75)
ax.plot(np.concatenate([x[i:i+1],predicted3[0,:1]]), np.concatenate([y[i:i+1],predicted3[0,1:2]]), color="0.4", alpha=0.75)
ax.plot(np.concatenate([x[i:i+1],predicted4[0,:1]]), np.concatenate([y[i:i+1],predicted4[0,1:2]]), color="0.15", alpha=0.75)
else:
ax.plot(np.concatenate([x[i:i+1],predicted1[0,:1]]), np.concatenate([y[i:i+1],predicted1[0,1:2]]), np.concatenate([z[i:i+1],predicted1[0,2:3]]), color="0.9", alpha=0.75)
ax.plot(np.concatenate([x[i:i+1],predicted2[0,:1]]), np.concatenate([y[i:i+1],predicted2[0,1:2]]), np.concatenate([z[i:i+1],predicted2[0,2:3]]), color="0.65", alpha=0.75)
ax.plot(np.concatenate([x[i:i+1],predicted3[0,:1]]), np.concatenate([y[i:i+1],predicted3[0,1:2]]), np.concatenate([z[i:i+1],predicted3[0,2:3]]), color="0.4", alpha=0.75)
ax.plot(np.concatenate([x[i:i+1],predicted4[0,:1]]), np.concatenate([y[i:i+1],predicted4[0,1:2]]), np.concatenate([z[i:i+1],predicted4[0,2:3]]), color="0.15", alpha=0.75)
# Plot the dots at each time step depending on the action taken
length_block=[[0,18],[18,19],[19,31]]
for i in range(3):
colors=['blue','orange','green']
if(self.intern_dim==2):
line3 = ax.scatter(all_possib_abs_states[length_block[i][0]:length_block[i][1],0], all_possib_abs_states[length_block[i][0]:length_block[i][1],1], c=colors[i], marker='x', edgecolors='k', alpha=0.5, s=100)
else:
line3 = ax.scatter(all_possib_abs_states[length_block[i][0]:length_block[i][1],0], all_possib_abs_states[length_block[i][0]:length_block[i][1],1] ,all_possib_abs_states[length_block[i][0]:length_block[i][1],2], marker='x', depthshade=True, edgecolors='k', alpha=0.5, s=50)
if(self.intern_dim==2):
axes_lims=[ax.get_xlim(),ax.get_ylim()]
else:
axes_lims=[ax.get_xlim(),ax.get_ylim(),ax.get_zlim()]
# Plot the legend for transition estimates
box1b = TextArea(" Estimated transitions (action 0, 1, 2 and 3): ", textprops=dict(color="k"))
box2b = DrawingArea(90, 20, 0, 0)
el1b = Rectangle((5, 10), 15,2, fc="0.9", alpha=0.75)
el2b = Rectangle((25, 10), 15,2, fc="0.65", alpha=0.75)
el3b = Rectangle((45, 10), 15,2, fc="0.4", alpha=0.75)
el4b = Rectangle((65, 10), 15,2, fc="0.15", alpha=0.75)
box2b.add_artist(el1b)
box2b.add_artist(el2b)
box2b.add_artist(el3b)
box2b.add_artist(el4b)
boxb = HPacker(children=[box1b, box2b],
align="center",
pad=0, sep=5)
anchored_box = AnchoredOffsetbox(loc=3,
child=boxb, pad=0.,
frameon=True,
bbox_to_anchor=(0., 0.98),
bbox_transform=ax.transAxes,
borderpad=0.,
)
ax.add_artist(anchored_box)
#plt.show()
plt.savefig('fig_base'+str(learning_algo.update_counter)+'.pdf')
plt.close()
# # Plot the Q_vals
# c = learning_algo.Q.predict(np.concatenate((np.expand_dims(x,axis=1),np.expand_dims(y,axis=1),np.expand_dims(z,axis=1)),axis=1))
# #print "actions,C"
# #print actions
# #print c
# #c=np.max(c,axis=1)
# m1=ax.scatter(x, y, z+zrange/20, c=c[:,0], vmin=-1., vmax=1., cmap=plt.cm.RdYlGn)
# m2=ax.scatter(x, y, z+3*zrange/40, c=c[:,1], vmin=-1., vmax=1., cmap=plt.cm.RdYlGn)
#
# #plt.colorbar(m3)
# ax2 = fig.add_axes([0.85, 0.15, 0.025, 0.7])
# cmap = matplotlib.cm.RdYlGn
# norm = matplotlib.colors.Normalize(vmin=-1, vmax=1)
#
# # ColorbarBase derives from ScalarMappable and puts a colorbar
# # in a specified axes, so it has everything needed for a
# # standalone colorbar. There are many more kwargs, but the
# # following gives a basic continuous colorbar with ticks
# # and labels.
# cb1 = matplotlib.colorbar.ColorbarBase(ax2, cmap=cmap,norm=norm,orientation='vertical')
# cb1.set_label('Estimated expected return')
#
# #plt.show()
# plt.savefig('fig_w_V'+str(learning_algo.update_counter)+'.pdf')
#
#
# # fig_visuV
# fig = plt.figure()
# ax = fig.add_subplot(111, projection='3d')
#
# x = np.array([i for i in range(5) for jk in range(25)])/4.*(axes_lims[0][1]-axes_lims[0][0])+axes_lims[0][0]
# y = np.array([j for i in range(5) for j in range(5) for k in range(5)])/4.*(axes_lims[1][1]-axes_lims[1][0])+axes_lims[1][0]
# z = np.array([k for i in range(5) for j in range(5) for k in range(5)])/4.*(axes_lims[2][1]-axes_lims[2][0])+axes_lims[2][0]
#
# c = learning_algo.Q.predict(np.concatenate((np.expand_dims(x,axis=1),np.expand_dims(y,axis=1),np.expand_dims(z,axis=1)),axis=1))
# c=np.max(c,axis=1)
# #print "c"
# #print c
#
# m=ax.scatter(x, y, z, c=c, vmin=-1., vmax=1., cmap=plt.hot())
# #plt.colorbar(m)
# fig.subplots_adjust(right=0.8)
# ax2 = fig.add_axes([0.875, 0.15, 0.025, 0.7])
# cmap = matplotlib.cm.hot
# norm = matplotlib.colors.Normalize(vmin=-1, vmax=1)
#
# # ColorbarBase derives from ScalarMappable and puts a colorbar
# # in a specified axes, so it has everything needed for a
# # standalone colorbar. There are many more kwargs, but the
# # following gives a basic continuous colorbar with ticks
# # and labels.
# cb1 = matplotlib.colorbar.ColorbarBase(ax2, cmap=cmap,norm=norm,orientation='vertical')
# cb1.set_label('Estimated expected return')
#
# #plt.show()
# plt.savefig('fig_visuV'+str(learning_algo.update_counter)+'.pdf')
#
#
# # fig_visuR
# fig = plt.figure()
# ax = fig.add_subplot(111, projection='3d')
#
# x = np.array([i for i in range(5) for jk in range(25)])/4.*(axes_lims[0][1]-axes_lims[0][0])+axes_lims[0][0]
# y = np.array([j for i in range(5) for j in range(5) for k in range(5)])/4.*(axes_lims[1][1]-axes_lims[1][0])+axes_lims[1][0]
# z = np.array([k for i in range(5) for j in range(5) for k in range(5)])/4.*(axes_lims[2][1]-axes_lims[2][0])+axes_lims[2][0]
#
# coords=np.concatenate((np.expand_dims(x,axis=1),np.expand_dims(y,axis=1),np.expand_dims(z,axis=1)),axis=1)
# repeat_nactions_coord=np.repeat(coords,self.nActions(),axis=0)
# identity_matrix = np.diag(np.ones(self.nActions()))
# tile_identity_matrix=np.tile(identity_matrix,(5*5*5,1))
#
# c = learning_algo.R.predict([repeat_nactions_coord,tile_identity_matrix])
# c=np.max(np.reshape(c,(125,self.nActions())),axis=1)
# #print "c"
# #print c
# #mini=np.min(c)
# #maxi=np.max(c)
#
# m=ax.scatter(x, y, z, c=c, vmin=-1., vmax=1., cmap=plt.hot())
# #plt.colorbar(m)
# fig.subplots_adjust(right=0.8)
# ax2 = fig.add_axes([0.875, 0.15, 0.025, 0.7])
# cmap = matplotlib.cm.hot
# norm = matplotlib.colors.Normalize(vmin=-1, vmax=1)
#
# # ColorbarBase derives from ScalarMappable and puts a colorbar
# # in a specified axes, so it has everything needed for a
# # standalone colorbar. There are many more kwargs, but the
# # following gives a basic continuous colorbar with ticks
# # and labels.
# cb1 = matplotlib.colorbar.ColorbarBase(ax2, cmap=cmap,norm=norm,orientation='vertical')
# cb1.set_label('Estimated expected return')
#
# #plt.show()
# plt.savefig('fig_visuR'+str(learning_algo.update_counter)+'.pdf')
matplotlib.pyplot.close("all") # avoids memory leaks
def inputDimensions(self):
if(self._higher_dim_obs==True):
return [(1,self._size_maze*6,self._size_maze*6)]
else:
return [(1,self._size_maze,self._size_maze)]
def observationType(self, subject):
return np.float
def nActions(self):
return 4
def observe(self):
obs=copy.deepcopy(self._map)
obs[self._pos_agent[0],self._pos_agent[1]]=0.5
if(self._higher_dim_obs==True):
"self._pos_agent"
self._pos_agent
obs=self.get_higher_dim_obs([self._pos_agent],[self._pos_goal])
# plt.imshow(obs, cmap='gray_r')
# plt.show()
return [obs]
def get_higher_dim_obs(self,indices_agent,indices_reward):
""" Obtain the high-dimensional observation from indices of the agent position and the indices of the reward positions.
"""
obs=copy.deepcopy(self._map)
obs=obs/1.
obs=np.repeat(np.repeat(obs, 6, axis=0),6, axis=1)
#TODO for later experiment change agent obs
# agent repr
agent_obs= | np.zeros((6,6)) | numpy.zeros |
# coding: utf-8
# In[ ]:
import numpy as np
'''Handles analytically deconvoving two Gaussians and finding of a common beam.'''
def quadratic2elliptic(A,B,C,D=0,E=0,F=-np.log(2)):
"""Invert:
(A0 cos^2 phi + c0 sin^2 phi)k = A
(A0-C0)sin 2phi k = B
(a0 sin^2 phi + c0 cos^2 phi) k = C
returns bmaj,bmin,bpa[,xc,y if D,E != 0]"""
if ( | np.isinf(A) | numpy.isinf |
import numpy as np
from Space import Space
class SyntheticFunction:
def __init__(self, dim):
self.numCalls = 0
self.input_dim = dim
self.nbounds = [(0, 1)] * self.input_dim
def plot(self):
print("not implemented")
def rand_in_bounds(self):
rand = []
for i in self.bounds:
tmpRand = np.random.uniform(i[0], i[1])
rand.append(tmpRand)
return rand
def rand_uniform_in_bounds(self):
rand = []
for i in self.bounds:
tmp_rand = np.random.uniform(i[0], i[1])
rand.append(tmp_rand)
return rand
def rand_uniform_in_nbounds(self):
rand = []
for i in range(0, self.input_dim):
tmp_rand = np.random.uniform(self.nbounds[i][0], self.nbounds[i][1])
rand.append(tmp_rand)
return rand
def normalize(self, x):
val = []
for i in range(0, self.input_dim):
val.append((x[i] - self.bounds[i][0])/(self.bounds[i][1] - self.bounds[i][0]))
return val
def denormalize(self, x):
val = []
for i in range(0, self.input_dim):
val.append(1.0 * (x[i] * (self.bounds[i][1] - self.bounds[i][0]) + self.bounds[i][0]))
return val
class Eggholder(SyntheticFunction):
def __init__(self, dim, missing_rate, missing_noise, is_random_missing=False):
SyntheticFunction.__init__(self, 2) # Constructor of the parent class
self.input_dim = 2
self.numCalls = 0
# self.bounds = OrderedDict({'x1': (-5, 10), 'x2': (0, 15)})
self.bounds = [(-512, 512), (-512, 512)]
self.nbounds = [(0, 1), (0, 1)]
self.min = [512, 404.2319]
self.fmin = -959.6407
self.ismax = -1
self.name = 'Eggholder'
self.discreteIdx = []
self.categoricalIdx = []
self.miss_rate = missing_rate
self.miss_noise = missing_noise
self.is_random_missing = is_random_missing
def func(self, X):
self.numCalls += 1
X = | np.asarray(X) | numpy.asarray |
#!/usr/bin/env python
import sys
import rospy
from std_msgs.msg import String
from sensor_msgs.msg import Image
from geometry_msgs.msg import Pose, PoseStamped, Point, Point32, PolygonStamped
from cv_bridge import CvBridge, CvBridgeError
from scipy import ndimage, signal
import argparse
import os
import sys
import math
import numpy as np
import copy
import transforms3d as tf3d
import json
import copy
import keras
import tensorflow as tf
import open3d
import ros_numpy
#print(sys.path)
#sys.path.remove('/opt/ros/melodic/lib/python2.7/dist-packages')
import cv2
from PIL import Image as Pilimage
sys.path.append("/RGBDPose")
from RGBDPose import models
from RGBDPose.utils.config import read_config_file, parse_anchor_parameters
from RGBDPose.utils.eval import evaluate
from RGBDPose.utils.keras_version import check_keras_version
from RGBDPose.utils import ply_loader
from object_detector_msgs.srv import get_poses, get_posesResponse
from object_detector_msgs.msg import PoseWithConfidence
from geometry_msgs.msg import PoseArray, Pose
###################################
##### Global Variable Space #######
######## aka. death zone ##########
###################################
# LineMOD
#fxkin = 572.41140
#fykin = 573.57043
#cxkin = 325.26110
#cykin = 242.04899
# YCB-video
#fxkin = 1066.778
#fykin = 1067.487
#cxkin = 312.9869
#cykin = 241.3109
# our Kinect
#fxkin = 575.81573
#fykin = 575.81753
#cxkin = 314.5
#cykin = 235.5
# HSRB
# fxkin = 538.391033
# fykin = 538.085452
# cxkin = 315.30747
# cykin = 233.048356
# magic intrinsics
fxkin = 1066.778
fykin = 1067.487
cxkin = 320.0
cykin = 240.0
def get_evaluation_kiru(pcd_temp_,pcd_scene_,inlier_thres,tf,final_th, model_dia):#queue
tf_pcd =np.eye(4)
pcd_temp_.transform(tf)
mean_temp = np.mean(np.array(pcd_temp_.points)[:, 2])
mean_scene = np.median( | np.array(pcd_scene_.points) | numpy.array |
from unittest import TestCase
import numpy as np
from giant import rotations as at
class TestAttitude(TestCase):
def check_attitude(self, attitude, quaternion, mupdate, vupdate):
np.testing.assert_array_almost_equal(quaternion, attitude.q)
np.testing.assert_array_almost_equal(quaternion[:3], attitude.q_vector)
self.assertAlmostEqual(quaternion[-1], attitude.q_scalar)
self.assertIs(attitude._mupdate, mupdate)
self.assertIs(attitude._vupdate, vupdate)
def test_init(self):
att = at.Rotation()
self.check_attitude(att, [0, 0, 0, 1], True, True)
att = at.Rotation([0, 0, 0, 1])
self.check_attitude(att, [0, 0, 0, 1], True, True)
att = at.Rotation(data=[0, 0, 0, 1])
self.check_attitude(att, [0, 0, 0, 1], True, True)
att = at.Rotation(np.eye(3))
self.check_attitude(att, [0, 0, 0, 1], False, True)
att = at.Rotation([0, 0, 0])
self.check_attitude(att, [0, 0, 0, 1], True, False)
att = at.Rotation([np.sqrt(2) / 2, 0, 0, np.sqrt(2) / 2])
self.check_attitude(att, [np.sqrt(2)/2, 0, 0, np.sqrt(2)/2], True, True)
att = at.Rotation([np.sqrt(2) / 2, 0, 0, -np.sqrt(2) / 2])
self.check_attitude(att, [-np.sqrt(2)/2, 0, 0, np.sqrt(2)/2], True, True)
att2 = att
att = at.Rotation(att2)
self.check_attitude(att, [-np.sqrt(2)/2, 0, 0, np.sqrt(2)/2], True, True)
self.assertIs(att, att2)
# with self.assertWarns(UserWarning):
#
# at.Rotation([1, 2, 3, 4])
def test_quaternion_setter(self):
att = at.Rotation()
att._mupdate = False
att._vupdate = False
att.quaternion = [np.sqrt(2)/2, 0, 0, np.sqrt(2)/2]
self.check_attitude(att, [np.sqrt(2)/2, 0, 0, np.sqrt(2)/2], True, True)
att.quaternion = [np.sqrt(2)/2, 0, 0, -np.sqrt(2)/2]
self.check_attitude(att, [-np.sqrt(2)/2, 0, 0, np.sqrt(2)/2], True, True)
att2 = at.Rotation([1, 2, 3, 4])
att.quaternion = att2
self.check_attitude(att, np.array([1, 2, 3, 4])/np.sqrt(30), True, True)
self.assertIsNot(att, att2)
# with self.assertWarns(UserWarning):
# att.quaternion = [1, 2, 3, 4]
#
# self.check_attitude(att, np.array([1, 2, 3, 4])/np.sqrt(30), True, True)
with self.assertRaises(ValueError):
att.quaternion = np.eye(4)
def test_matrix_getter(self):
att = at.Rotation([np.sqrt(2) / 2, 0, 0, np.sqrt(2) / 2])
np.testing.assert_array_almost_equal([[1, 0, 0], [0, 0, -1], [0, 1, 0]], att.matrix)
np.testing.assert_array_almost_equal([[1, 0, 0], [0, 0, -1], [0, 1, 0]], att._matrix)
self.assertFalse(att._mupdate)
# this is bad and you should never do this but it checks that the caching is working
att._matrix = np.eye(3)
np.testing.assert_array_equal(att.matrix, np.eye(3))
self.check_attitude(att, [np.sqrt(2)/2, 0, 0, np.sqrt(2)/2], False, True)
def test_matrix_setter(self):
att = at.Rotation([1, 2, 3])
att.matrix = np.eye(3)
self.check_attitude(att, [0, 0, 0, 1], False, True)
np.testing.assert_array_equal(att._matrix, np.eye(3))
with self.assertRaises(ValueError):
att.matrix = [1, 2, 3]
def test_vector_getter(self):
att = at.Rotation([np.sqrt(2) / 2, 0, 0, np.sqrt(2) / 2])
np.testing.assert_array_almost_equal(att.vector, [np.pi/2, 0, 0])
np.testing.assert_array_almost_equal(att._vector, [np.pi/2, 0, 0])
self.assertFalse(att._vupdate)
# this is bad and you should never do this but it checks that the caching is working
att._vector = [1, 2, 3]
np.testing.assert_array_equal(att.vector, [1, 2, 3])
self.check_attitude(att, [np.sqrt(2)/2, 0, 0, np.sqrt(2)/2], True, False)
def test_vector_setter(self):
att = at.Rotation([np.sqrt(2) / 2, 0, 0, np.sqrt(2) / 2])
att.vector = [1, 2, 3]
self.check_attitude(att, [-0.25532186, -0.51064372, -0.76596558, 0.29555113], True, False)
np.testing.assert_array_equal(att.vector, [1, 2, 3])
with self.assertRaises(ValueError):
att.vector = np.eye(3)
def test_inv(self):
att = at.Rotation([np.sqrt(2) / 2, 0, 0, np.sqrt(2) / 2])
attinv = att.inv()
self.check_attitude(attinv, [-np.sqrt(2)/2, 0, 0, np.sqrt(2)/2], True, True)
self.check_attitude(att, [np.sqrt(2)/2, 0, 0, np.sqrt(2)/2], True, True)
def test_interp_attitude(self):
att = at.Rotation()
att.interp_attitude([1, 2, 3])
self.check_attitude(att, [-0.25532186, -0.51064372, -0.76596558, 0.29555113], True, False)
np.testing.assert_array_equal(att._vector, [1, 2, 3])
att.interp_attitude(np.eye(3))
self.check_attitude(att, [0, 0, 0, 1], False, True)
np.testing.assert_array_equal(att._matrix, np.eye(3))
att.interp_attitude([np.sqrt(2)/2, 0, 0, np.sqrt(2)/2])
self.check_attitude(att, [np.sqrt(2)/2, 0, 0, np.sqrt(2)/2], True, True)
att2 = at.Rotation([np.sqrt(2) / 2, 0, 0, np.sqrt(2) / 2])
att.interp_attitude(att2)
self.check_attitude(att, [np.sqrt(2)/2, 0, 0, np.sqrt(2)/2], True, True)
self.assertIsNot(att, att2)
with self.assertRaises(ValueError):
att.interp_attitude([1, 2])
def test_eq(self):
att = at.Rotation()
self.assertTrue(att == at.Rotation())
self.assertTrue(att == [0, 0, 0, 1])
self.assertTrue(att == np.eye(3))
self.assertTrue(att == [0, 0, 0])
def test_mul(self):
att = at.Rotation([1, 2, 3])
att2 = att.inv()
self.check_attitude(att*att2, [0, 0, 0, 1], True, True)
with self.assertRaises(TypeError):
_ = att*[0, 0, 0, 1]
with self.assertRaises(TypeError):
_ = [0, 0, 0, 1]*att
# def test_imul(self):
# att = at.Rotation()
# with self.assertWarns(DeprecationWarning):
#
# att *= [1, 0, 0, 0]
#
# self.check_attitude(att, [1, 0, 0, 0], True, True)
def test_rotate(self):
att = at.Rotation()
att.rotate([1, 0, 0, 0])
self.check_attitude(att, [1, 0, 0, 0], True, True)
class TestQuaternionInverse(TestCase):
def test_quaternion_inverse(self):
qinv = at.quaternion_inverse([1, 2, 3, 4])
np.testing.assert_array_equal(qinv, [-1, -2, -3, 4])
qinv = at.quaternion_inverse(at.Rotation([1, 2, 3, 4]))
np.testing.assert_array_almost_equal(qinv.q.flatten(), np.array([-1, -2, -3, 4])/np.sqrt(30))
qinv = at.quaternion_inverse([[1, 2], [2, 3], [3, 4], [4, 5]])
np.testing.assert_array_equal(qinv.T, [[-1, -2, -3, 4], [-2, -3, -4, 5]])
class TestQuaternionMultiplication(TestCase):
def test_quaternion_multiplication(self):
quat_1 = [1, 0, 0, 0]
quat_2 = [0, 1, 0, 0]
qm = at.quaternion_multiplication(quat_1, quat_2)
np.testing.assert_array_equal(np.abs(qm), [0, 0, 1, 0])
quat_1 = [[1], [0], [0], [0]]
quat_2 = [[0], [1], [0], [0]]
qm = at.quaternion_multiplication(quat_1, quat_2)
np.testing.assert_array_equal(np.abs(qm), [[0], [0], [1], [0]])
quat_1 = [[1, 0], [0, 1], [0, 0], [0, 0]]
quat_2 = [[0, 0], [1, 1], [0, 0], [0, 0]]
qm = at.quaternion_multiplication(quat_1, quat_2)
np.testing.assert_array_equal(np.abs(qm), [[0, 0], [0, 0], [1, 0], [0, 1]])
quat_1 = at.Rotation([1, 0, 0, 0])
quat_2 = at.Rotation([0, 0, 1, 0])
qm = at.quaternion_multiplication(quat_1, quat_2)
np.testing.assert_array_equal(np.abs(qm.q), [0, 1, 0, 0])
quat_1 = [np.sqrt(2)/2, 0, 0, np.sqrt(2)/2] # x=x, y=z, z=-y
quat_2 = [0, np.sqrt(2)/2, 0, np.sqrt(2)/2] # x=-z, y=y, z=x
qm = at.quaternion_multiplication(quat_1, quat_2)
np.testing.assert_array_almost_equal(np.abs(qm), [0.5, 0.5, 0.5, 0.5])
quat_1 = [0.25532186, 0.51064372, 0.76596558, -0.29555113]
quat_2 = [-0.43199286, -0.53999107, -0.64798929, -0.31922045]
qm = at.quaternion_multiplication(quat_1, quat_2)
# truth comes from matrix rotations
np.testing.assert_array_almost_equal(qm, [0.12889493, -0.16885878, 0.02972499, 0.97672373])
class TestQuaternionToRotVec(TestCase):
def test_quaternion_to_rotvec(self):
rvec = at.quaternion_to_rotvec([1, 0, 0, 0])
np.testing.assert_array_almost_equal(rvec, [np.pi, 0, 0])
rvec = at.quaternion_to_rotvec(at.Rotation([-1, 0, 0, 0]))
np.testing.assert_array_almost_equal(rvec, [-np.pi, 0, 0])
rvec = at.quaternion_to_rotvec([0, 1, 0, 0])
np.testing.assert_array_almost_equal(rvec, [0, np.pi, 0])
rvec = at.quaternion_to_rotvec([0, -1, 0, 0])
np.testing.assert_array_almost_equal(rvec, [0, -np.pi, 0])
rvec = at.quaternion_to_rotvec([0, 0, 1, 0])
np.testing.assert_array_almost_equal(rvec, [0, 0, np.pi])
rvec = at.quaternion_to_rotvec([0, 0, -1, 0])
np.testing.assert_array_almost_equal(rvec, [0, 0, -np.pi])
rvec = at.quaternion_to_rotvec([0, 0, 0, 1])
np.testing.assert_array_almost_equal(rvec, [0, 0, 0])
rvec = at.quaternion_to_rotvec([0, 0, 0, -1])
np.testing.assert_array_almost_equal(rvec, [0, 0, 0])
rvec = at.quaternion_to_rotvec([0.25532186, 0.51064372, 0.76596558, -0.29555113])
np.testing.assert_array_almost_equal(rvec, [1, 2, 3])
rvec = at.quaternion_to_rotvec([-0.25532186, -0.51064372, -0.76596558, 0.29555113])
# euler axis is not unique
np.testing.assert_array_almost_equal(rvec, np.array([1, 2, 3])*(1-2*np.pi/np.sqrt(14)))
rvec = at.quaternion_to_rotvec([[0.25532186], [0.51064372], [0.76596558], [-0.29555113]])
np.testing.assert_array_almost_equal(rvec, [[1], [2], [3]])
rvec = at.quaternion_to_rotvec([[1, 0, 0.25532186, 0],
[0, 0, 0.51064372, 0],
[0, 0, 0.76596558, 0],
[0, 1, -0.29555113, -1]])
np.testing.assert_array_almost_equal(rvec, [[np.pi, 0, 1, 0], [0, 0, 2, 0], [0, 0, 3, 0]])
class TestQuaternionToRotMat(TestCase):
def test_quaternion_to_rotmat(self):
rotmat = at.quaternion_to_rotmat([0, 0, 0, 1])
np.testing.assert_array_almost_equal(rotmat, np.eye(3))
rotmat = at.quaternion_to_rotmat([[0], [0], [0], [1]])
np.testing.assert_array_almost_equal(rotmat, np.eye(3))
rotmat = at.quaternion_to_rotmat([[0, 1], [0, 0], [0, 0], [1, 0]])
np.testing.assert_array_almost_equal(rotmat, [np.eye(3), [[1, 0, 0], [0, -1, 0], [0, 0, -1]]])
rotmat = at.quaternion_to_rotmat(at.Rotation([0, 1, 0, 0]))
np.testing.assert_array_almost_equal(rotmat, [[-1, 0, 0], [0, 1, 0], [0, 0, -1]])
rotmat = at.quaternion_to_rotmat([0, 0, np.sqrt(2)/2, np.sqrt(2)/2])
np.testing.assert_array_almost_equal(rotmat, [[0, -1, 0], [1, 0, 0], [0, 0, 1]])
rotmat = at.quaternion_to_rotmat([-0.25532186, -0.51064372, -0.76596558, 0.29555113])
np.testing.assert_array_almost_equal(rotmat, [[-0.69492056, 0.71352099, 0.08929286],
[-0.19200697, -0.30378504, 0.93319235],
[0.69297817, 0.6313497, 0.34810748]])
class TestQuaternionToEuler(TestCase):
def test_quaternion_to_euler(self):
orders = ['xyz', 'zxy', 'yxz', 'yzx', 'xzy', 'zyx', 'xyx', 'yxy', 'xzx', 'zxz', 'yzy', 'zyz']
angles = [[np.pi/3, np.pi/3, 0], [0, np.pi/3, np.pi/3],
[np.pi/3, np.pi/3, np.pi/3],
[-np.pi/3, -np.pi/3, 0], [0, -np.pi/3, -np.pi/3],
[-np.pi/3, -np.pi/3, -np.pi/3],
[1, 2, 3], [1, -2, 3],
[[1, 2, 3, 1], [2, 3, 1, 2], [3, 1, 2, 3]]]
for angle in angles:
for order in orders:
with self.subTest(angle=angle, order=order):
rmat = at.euler_to_rotmat(angle, order=order)
quat = at.rotmat_to_quaternion(rmat)
euler = at.quaternion_to_euler(quat, order=order)
rmat2 = at.euler_to_rotmat(euler, order=order)
quat2 = at.rotmat_to_quaternion(rmat2)
np.testing.assert_almost_equal(quat, quat2)
class TestRotVecToRotMat(TestCase):
def test_rotvec_to_rotmat(self):
rotmat = at.rotvec_to_rotmat([0, 0, 0])
np.testing.assert_array_almost_equal(rotmat, [[1, 0, 0], [0, 1, 0], [0, 0, 1]])
rotmat = at.rotvec_to_rotmat([[0, 0], [0, 0], [0, 0]])
np.testing.assert_array_almost_equal(rotmat, [[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
[[1, 0, 0], [0, 1, 0], [0, 0, 1]]])
rotmat = at.rotvec_to_rotmat([np.pi, 0, 0])
np.testing.assert_array_almost_equal(rotmat, [[1, 0, 0], [0, -1, 0], [0, 0, -1]])
rotmat = at.rotvec_to_rotmat([0, np.pi, 0])
np.testing.assert_array_almost_equal(rotmat, [[-1, 0, 0], [0, 1, 0], [0, 0, -1]])
rotmat = at.rotvec_to_rotmat([0, 0, np.pi])
np.testing.assert_array_almost_equal(rotmat, [[-1, 0, 0], [0, -1, 0], [0, 0, 1]])
rotmat = at.rotvec_to_rotmat([[np.pi, 0, 0], [0, np.pi, 0], [0, 0, -np.pi]])
np.testing.assert_array_almost_equal(rotmat, [[[1, 0, 0], [0, -1, 0], [0, 0, -1]],
[[-1, 0, 0], [0, 1, 0], [0, 0, -1]],
[[-1, 0, 0], [0, -1, 0], [0, 0, 1]]])
rotmat = at.rotvec_to_rotmat([[np.pi / 2, 0], [0, -np.pi / 2], [0, 0]])
np.testing.assert_array_almost_equal(rotmat, [[[1, 0, 0], [0, 0, -1], [0, 1, 0]],
[[0, 0, -1], [0, 1, 0], [1, 0, 0]]])
rotmat = at.rotvec_to_rotmat([[np.pi / 2, 0, 0], [0, 0, -np.pi / 2], [0, 0, 0]])
np.testing.assert_array_almost_equal(rotmat, [[[1, 0, 0], [0, 0, -1], [0, 1, 0]],
[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
[[0, 0, -1], [0, 1, 0], [1, 0, 0]]])
rotmat = at.rotvec_to_rotmat([1, 2, 3])
np.testing.assert_array_almost_equal(rotmat, [[-0.69492056, 0.71352099, 0.08929286],
[-0.19200697, -0.30378504, 0.93319235],
[0.69297817, 0.6313497, 0.34810748]])
class TestRotVecToQuaternion(TestCase):
def test_rotvec_to_quaternion(self):
q = at.rotvec_to_quaternion([0, 0, 0])
np.testing.assert_array_almost_equal(q, [0, 0, 0, 1])
q = at.rotvec_to_quaternion([[0], [0], [0]])
np.testing.assert_array_almost_equal(q, [[0], [0], [0], [1]])
q = at.rotvec_to_quaternion([np.pi, 0, 0])
np.testing.assert_array_almost_equal(q, [1, 0, 0, 0])
q = at.rotvec_to_quaternion([0, np.pi, 0])
np.testing.assert_array_almost_equal(q, [0, 1, 0, 0])
q = at.rotvec_to_quaternion([0, 0, np.pi])
np.testing.assert_array_almost_equal(q, [0, 0, 1, 0])
q = at.rotvec_to_quaternion([1, 2, 3])
np.testing.assert_array_almost_equal(q, [0.25532186, 0.51064372, 0.76596558, -0.29555113])
q = at.rotvec_to_quaternion([[0], [0], [np.pi]])
np.testing.assert_array_almost_equal(q, [[0], [0], [1], [0]])
q = at.rotvec_to_quaternion([[np.pi, 0, 1, 0],
[0, 0, 2, 0],
[0, 0, 3, 0]])
np.testing.assert_array_almost_equal(q, [[1, 0, 0.25532186, 0],
[0, 0, 0.51064372, 0],
[0, 0, 0.76596558, 0],
[0, 1, -0.29555113, 1]])
class TestRotMatToQuaternion(TestCase):
def test_rotmat_to_quaternion(self):
q = at.rotmat_to_quaternion(np.eye(3))
np.testing.assert_allclose(q, [0, 0, 0, 1], atol=1e-16)
# figure out how to account for the fact that these can be positive or negative
q = at.rotmat_to_quaternion(np.array([[-1., 0, 0], [0, 1, 0], [0, 0, -1]]))
np.testing.assert_allclose(np.abs(q), [0, 1, 0, 0], atol=1e-16)
q = at.rotmat_to_quaternion(np.array([[1., 0, 0], [0, -1, 0], [0, 0, -1]]))
np.testing.assert_allclose(np.abs(q), [1, 0, 0, 0], atol=1e-16)
q = at.rotmat_to_quaternion(np.array([[-1., 0, 0], [0, -1, 0], [0, 0, 1]]))
np.testing.assert_allclose(np.abs(q), [0, 0, 1, 0], atol=1e-16)
q = at.rotmat_to_quaternion([np.eye(3)]*2)
np.testing.assert_allclose(q.T, [[0, 0, 0, 1]]*2, atol=1e-16)
q = at.rotmat_to_quaternion([[0, 1, 0], [-1, 0, 0], [0, 0, 1]])
np.testing.assert_allclose(q, [0, 0, -np.sqrt(2)/2, np.sqrt(2)/2], atol=1e-16)
q = at.rotmat_to_quaternion([[-0.69492056, -0.19200697, 0.69297817],
[0.71352099, -0.30378504, 0.6313497],
[0.08929286, 0.93319235, 0.34810748]])
np.testing.assert_allclose(q, [0.25532186, 0.51064372, 0.76596558, 0.29555113], atol=1e-16)
q = at.rotmat_to_quaternion([[[-0.69492056, -0.19200697, 0.69297817],
[0.71352099, -0.30378504, 0.6313497],
[0.08929286, 0.93319235, 0.34810748]],
np.eye(3)])
np.testing.assert_allclose(q.T, [[0.25532186, 0.51064372, 0.76596558, 0.29555113],
[0, 0, 0, 1]], atol=1e-16)
with self.assertRaises(ValueError):
at.rotmat_to_quaternion([1, 2, 3])
with self.assertRaises(ValueError):
at.rotmat_to_quaternion([[1, 2, 3]])
with self.assertRaises(ValueError):
at.rotmat_to_quaternion([[1], [2], [3]])
with self.assertRaises(ValueError):
at.rotmat_to_quaternion([1, 2, 3, 4])
with self.assertRaises(ValueError):
at.rotmat_to_quaternion([[1, 2, 3, 4]])
with self.assertRaises(ValueError):
at.rotmat_to_quaternion([[1], [2], [3], [4]])
class TestRotMatToEuler(TestCase):
def test_rotmat_to_euler(self):
orders = ['xyz', 'zxy', 'yxz', 'yzx', 'xzy', 'zyx', 'xyx', 'yxy', 'xzx', 'zxz', 'yzy', 'zyz']
angles = [[np.pi/3, np.pi/3, 0], [0, np.pi/3, np.pi/3],
[np.pi/3, np.pi/3, np.pi/3],
[-np.pi/3, -np.pi/3, 0], [0, -np.pi/3, -np.pi/3],
[-np.pi/3, -np.pi/3, -np.pi/3],
[1, 2, 3], [1, -2, 3],
[[1, 2, 3, 1], [2, 3, 1, 2], [3, 1, 2, 3]]]
for angle in angles:
for order in orders:
with self.subTest(angle=angle, order=order):
rmat = at.euler_to_rotmat(angle, order=order)
euler = at.rotmat_to_euler(rmat, order=order)
rmat2 = at.euler_to_rotmat(euler, order=order)
np.testing.assert_almost_equal(rmat, rmat2)
class TestEulerToRotMat(TestCase):
def test_euler_to_rotmat(self):
orders = ['xyz', 'zxy', 'yxz', 'yzx', 'xzy', 'zyx', 'xyx', 'yxy', 'xzx', 'zxz', 'yzy', 'zyz']
angles = [[np.pi/3, 0, 0], [0, np.pi/3, 0], [0, 0, np.pi/3],
[np.pi/3, np.pi/3, 0], [0, np.pi/3, np.pi/3],
[np.pi/3, np.pi/3, np.pi/3],
[-np.pi/3, -np.pi/3, 0], [0, -np.pi/3, -np.pi/3],
[-np.pi/3, -np.pi/3, -np.pi/3],
[1, 2, 3], [1, -2, 3],
[[1, 2, 3, 1], [2, 3, 1, 2], [3, 1, 2, 3]]]
for angle in angles:
for order in orders:
with self.subTest(angle=angle, order=order):
rmat = at.euler_to_rotmat(angle, order=order)
rmat2 = np.eye(3)
for an, ax in zip(angle, order):
if ax.upper().lower() == 'x':
update = at.rot_x(an)
elif ax.upper().lower() == 'y':
update = at.rot_y(an)
elif ax.upper().lower() == 'z':
update = at.rot_z(an)
rmat2 = update @ rmat2
np.testing.assert_almost_equal(rmat, rmat2)
class TestRotX(TestCase):
def test_rot_x(self):
angles = [3*np.pi/2, np.pi, np.pi/2, np.pi/3, 0,
-3*np.pi/2, -np.pi, -np.pi/2, -np.pi/3,
[0, np.pi/2, np.pi/3],
[0, -np.pi/2, -np.pi/3]]
mats = [[[1, 0, 0], [0, 0, 1], [0, -1, 0]],
[[1, 0, 0], [0, -1, 0], [0, 0, -1]],
[[1, 0, 0], [0, 0, -1], [0, 1, 0]],
[[1, 0, 0], [0, 0.5, -np.sqrt(3)/2], [0, np.sqrt(3)/2, 0.5]],
[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
[[1, 0, 0], [0, 0, -1], [0, 1, 0]],
[[1, 0, 0], [0, -1, 0], [0, 0, -1]],
[[1, 0, 0], [0, 0, 1], [0, -1, 0]],
[[1, 0, 0], [0, 0.5, np.sqrt(3)/2], [0, -np.sqrt(3)/2, 0.5]],
[[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
[[1, 0, 0], [0, 0, -1], [0, 1, 0]],
[[1, 0, 0], [0, 0.5, -np.sqrt(3)/2], [0, np.sqrt(3)/2, 0.5]]],
[[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
[[1, 0, 0], [0, 0, 1], [0, -1, 0]],
[[1, 0, 0], [0, 0.5, np.sqrt(3)/2], [0, -np.sqrt(3)/2, 0.5]]]
]
for angle, solu in zip(angles, mats):
with self.subTest(angle=angle):
rmat = at.rot_x(angle)
np.testing.assert_almost_equal(rmat, solu)
class TestRotY(TestCase):
def test_rot_y(self):
angles = [3*np.pi/2, np.pi, np.pi/2, np.pi/3, 0,
-3*np.pi/2, -np.pi, -np.pi/2, -np.pi/3,
[0, np.pi/2, np.pi/3],
[0, -np.pi/2, -np.pi/3]]
srt3d2 = np.sqrt(3)/2
mats = [[[0, 0, -1], [0, 1, 0], [1, 0, 0]],
[[-1, 0, 0], [0, 1, 0], [0, 0, -1]],
[[0, 0, 1], [0, 1, 0], [-1, 0, 0]],
[[0.5, 0, srt3d2], [0, 1, 0], [-srt3d2, 0, 0.5]],
[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
[[0, 0, 1], [0, 1, 0], [-1, 0, 0]],
[[-1, 0, 0], [0, 1, 0], [0, 0, -1]],
[[0, 0, -1], [0, 1, 0], [1, 0, 0]],
[[0.5, 0, -srt3d2], [0, 1, 0], [srt3d2, 0, 0.5]],
[[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
[[0, 0, 1], [0, 1, 0], [-1, 0, 0]],
[[0.5, 0, srt3d2], [0, 1, 0], [-srt3d2, 0, 0.5]]],
[[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
[[0, 0, -1], [0, 1, 0], [1, 0, 0]],
[[0.5, 0, -srt3d2], [0, 1, 0], [srt3d2, 0, 0.5]]]
]
for angle, solu in zip(angles, mats):
with self.subTest(angle=angle):
rmat = at.rot_y(angle)
np.testing.assert_almost_equal(rmat, solu)
class TestRotZ(TestCase):
def test_rot_z(self):
angles = [3*np.pi/2, np.pi, np.pi/2, np.pi/3, 0,
-3*np.pi/2, -np.pi, -np.pi/2, -np.pi/3,
[0, np.pi/2, np.pi/3],
[0, -np.pi/2, -np.pi/3]]
srt3d2 = np.sqrt(3)/2
mats = [[[0, 1, 0], [-1, 0, 0], [0, 0, 1]],
[[-1, 0, 0], [0, -1, 0], [0, 0, 1]],
[[0, -1, 0], [1, 0, 0], [0, 0, 1]],
[[0.5, -srt3d2, 0], [srt3d2, 0.5, 0], [0, 0, 1]],
[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
[[0, -1, 0], [1, 0, 0], [0, 0, 1]],
[[-1, 0, 0], [0, -1, 0], [0, 0, 1]],
[[0, 1, 0], [-1, 0, 0], [0, 0, 1]],
[[0.5, srt3d2, 0], [-srt3d2, 0.5, 0], [0, 0, 1]],
[[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
[[0, -1, 0], [1, 0, 0], [0, 0, 1]],
[[0.5, -srt3d2, 0], [srt3d2, 0.5, 0], [0, 0, 1]]],
[[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
[[0, 1, 0], [-1, 0, 0], [0, 0, 1]],
[[0.5, srt3d2, 0], [-srt3d2, 0.5, 0], [0, 0, 1]]]
]
for angle, solu in zip(angles, mats):
with self.subTest(angle=angle):
rmat = at.rot_z(angle)
np.testing.assert_almost_equal(rmat, solu)
class TestSkew(TestCase):
def test_skew(self):
skew_mat = at.skew([1, 2, 3])
np.testing.assert_array_equal(skew_mat, [[0, -3, 2], [3, 0, -1], [-2, 1, 0]])
skew_mat = at.skew([[1, 2], [2, 3], [3, 4]])
np.testing.assert_array_equal(skew_mat, [[[0, -3, 2], [3, 0, -1], [-2, 1, 0]],
[[0, -4, 3], [4, 0, -2], [-3, 2, 0]]])
class TestNLERP(TestCase):
def test_nlerp(self):
with self.subTest(input_type=list):
q0 = [0, 0, 0, 1]
q1 = [0.5, 0.5, 0.5, 0.5]
qt = at.nlerp(q0, q1, 0)
np.testing.assert_allclose(qt, q0)
qt = at.nlerp(q0, q1, 1)
np.testing.assert_allclose(qt, q1)
qt = at.nlerp(q0, q1, 0.5)
qtrue = (np.array(q0)+np.array(q1))/2
qtrue /= np.linalg.norm(qtrue)
np.testing.assert_allclose(qt, qtrue)
qt = at.nlerp(q0, q1, 0.25)
qtrue = np.array(q0)*(1-0.25)+np.array(q1)*0.25
qtrue /= np.linalg.norm(qtrue)
np.testing.assert_allclose(qt, qtrue)
qt = at.nlerp(q0, q1, 0.79)
qtrue = np.array(q0)*(1-0.79) + np.array(q1)*0.79
qtrue /= np.linalg.norm(qtrue)
np.testing.assert_allclose(qt, qtrue)
q0 = np.array([0.23, 0.45, 0.67, 0.2])
q0 /= np.linalg.norm(q0)
q1 = np.array([-0.3, 0.2, 0.6, 0.33])
q1 /= np.linalg.norm(q1)
qt = at.nlerp(q0, q1, 0)
np.testing.assert_allclose(qt, q0)
qt = at.nlerp(q0, q1, 1)
np.testing.assert_allclose(qt, q1)
qt = at.nlerp(q0, q1, 0.5)
qtrue = (q0+q1)/2
qtrue /= np.linalg.norm(qtrue)
np.testing.assert_allclose(qt, qtrue)
qt = at.nlerp(q0, q1, 0.25)
qtrue = q0*(1-0.25)+q1*0.25
qtrue /= np.linalg.norm(qtrue)
np.testing.assert_allclose(qt, qtrue)
qt = at.nlerp(q0, q1, 0.79)
# comes from ODTBX matlab function
qtrue = (1-0.79)*q0+0.79*q1
qtrue /= np.linalg.norm(qtrue)
| np.testing.assert_allclose(qt, qtrue) | numpy.testing.assert_allclose |
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pyburst.grids import grid_analyser
from pyburst.synth import synth
from pyburst.plotting import plot_tools
from pyburst.mcmc import mcmc_plot, mcmc_versions, mcmc_tools, burstfit
# TODO:
# - plot contours
def plot_posteriors(source, mc_version, discard, chain=None, n_walkers=None,
n_steps=None, save=False, display=True):
"""Plots mcmc posteriors for synthetic data
"""
plot_truth(plot_type='posteriors', source=source, mc_version=mc_version, discard=discard,
chain=chain, n_walkers=n_walkers, n_steps=n_steps, save=save, display=display)
def plot_contours(source, mc_version, discard, chain=None, n_walkers=None,
n_steps=None, save=False, display=True):
"""Plots mcmc corner plot for synthetic data
"""
plot_truth(plot_type='contours', source=source, mc_version=mc_version, discard=discard,
chain=chain, n_walkers=n_walkers, n_steps=n_steps, save=save, display=display)
def plot_truth(plot_type, source, mc_version, discard, chain=None, n_walkers=None,
n_steps=None, save=False, display=True):
"""Plots results of MCMC against true values of synthetic data
"""
mcv = mcmc_versions.McmcVersion(source, mc_version)
chain = check_chain(chain, n_walkers=n_walkers, n_steps=n_steps, source=source,
version=mc_version)
truth = synth.get_true_values(source, version=mcv.synth_version,
group=mcv.synth_group)
if plot_type == 'posteriors':
mcmc_plot.plot_posteriors(chain, source=source, version=mc_version,
discard=discard, truth_values=truth, save=save,
display=display)
elif plot_type == 'contours':
mcmc_plot.plot_contours(chain, discard=discard, source=source, truth=True,
version=mc_version, truth_values=truth, save=save,
display=display)
else:
raise ValueError('plot_type must be one of: (posteriors, corner)')
def check_chain(chain, n_walkers, n_steps, source, version):
"""Checks if chain was provided or needs loading
"""
if chain is None:
if None in (n_walkers, n_steps):
raise ValueError('Must provide either chain, or both n_walkers and n_steps')
else:
chain = mcmc_tools.load_chain(source, version=version, n_walkers=n_walkers,
n_steps=n_steps)
return chain
def plot_interp_residuals(synth_source, batches, mc_source, mc_version,
fontsize=16):
"""Plot synthetic burst properties against interpolated predictions
to test accuracy of interpolator
"""
n_sigma = 1.96
bfit = burstfit.BurstFit(source=mc_source, version=mc_version)
bprops = bfit.mcmc_version.bprops
kgrid = grid_analyser.Kgrid(source=synth_source)
param_table = kgrid.get_combined_params(batches)
interp_table = extract_interp_table(param_table, bfit=bfit)
summ_table = kgrid.get_combined_summ(batches)
fig, ax = plt.subplots(len(bprops), figsize=(6, 8))
for i, bprop in enumerate(bprops):
u_bprop = f'u_{bprop}'
yscale = plot_tools.unit_scale(bprop)
yunits = plot_tools.unit_label(bprop)
model = np.array(summ_table[bprop]) / yscale
interp = np.array(interp_table[bprop]) / yscale
u_model = np.array(summ_table[u_bprop]) / yscale
u_interp = np.array(interp_table[u_bprop]) / yscale
residuals = interp - model
u_residuals = n_sigma * np.sqrt(u_model**2 + u_interp**2)
ax[i].errorbar(model, residuals, yerr=u_residuals, marker='o',
ls='none', capsize=3)
x_max = | np.max(model) | numpy.max |
"""
DESCRIPTION
Preprocesses audio data before sending to Neural Network
See demo in in main()
MIT License
Copyright (c) 2018 The-Instrumental-Specialists
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""
import neuralnet_02 as NN
import numpy as np
import os
import glob
import json
import time
import scipy
import matplotlib.pylab as plt
import scipy.io.wavfile as wavfile
import scipy.fftpack
from scipy.fftpack import dct
def getMax(array_list):
"""Returns a tuple (index,value) of the maximum in an 1D array or list"""
m = array_list[0]
m_index = 0
for i,value in enumerate(array_list):
if value > m:
m = value
m_index = i
return (m_index,m)
def processFile(filename,length = 256,q=1,fs_in=8000,divide=4,plot=False):
"""returns one sided FFT amplitudes of filename
filename (string): ex) 'sax.wav'
length (int): Number of datapoints of one-sided fft (must be even,preferably a power of 2)
q (int): (optional argument) Downsampling Rate
fs_in (int): (optional argument) throw ValueError if fs of filename != fs_in
divide (int): (optional argument) 1/divide*Nsamples is taken from FFT (preferably even)
plot (bool): (optional argument) plots the one sided FFT if True, otherwise does not plot
Note: length < total_time*fs//(2*q*divide)
Ex) length = 256 < (0.25sec)*(44100Hz)//(2*4*2) = 689
"""
length = length*divide
#fs = sample rate, sound = multichannel sound signal
try:
fs1, sound = wavfile.read(filename)
except ValueError:
print(str(filename) + ' failed to process')
return 'failed'
if fs1 != fs_in:
raise ValueError('Sampling rate should be ' + str(fs_in) + ' for: ' + filename)
sig1 = sound[:,0] #left channel
pre_emphasis = 0.97
sig1 = np.append(sig1[0], sig1[1:] - pre_emphasis * sig1[:-1])
fs2, sig2 = downsample(sig1,fs1,q)
N2 = len(sig2)
sig3 = sig2[N2//2-length:N2//2+length]
#print(len(sig3))
FFT = abs(scipy.fft(sig3))
FFT_side = FFT[range(len(FFT)//2)]
#freqs = scipy.fftpack.fftfreq(sig3.size, 1/fs2)
#plt.plot(freqs,FFT)
if len(FFT_side) != length:
print('ERROR MESSAGE DETAILS')
print('filename: ' + filename)
print('length = ' + str(length))
print('fs_in = ' + str(fs_in))
print('q = ' + str(q))
print('divide = ' + str(divide))
total_time = len(sig1)/fs1
print('total_time = ' + str(total_time))
print('Please check: length < total_time*fs//(2*q)')
print('Check: ' + str(length) + ' < ' + str(total_time*fs1//(2*q)))
raise ValueError('Length FFT_side != length: ' + str(len(FFT_side)) + ' != ' + str(length))
FFT_log = []
# normalize FFT
for value in FFT_side:
value = | np.log(value) | numpy.log |
"""
Holds some code for analyzing the faces_basic dataset.
Eventually much of this code should be broken out to functions that are common across datasets,
then this file should hold only study-specific information.
The working directory must be ../../.. relative to this file.
Notes:
https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1004660
0.15 - 200 Hz 1-pole filter
1000 Hz srate
Paper used CAR after rejecting artifacts or epileptiform activity.
58-62 Hz 3rd order Butterworth filter.
400 msec stimulus on (face or house), 400 msec ISI.
50 house and 50 face pictures per run.
Further methods from https://www.sciencedirect.com/science/article/pii/S105381191300935X
Spectral decoupling:
1-sec window centred in the middle of the stimulus.
PSD (Hann -> Fourier -> * complex conjugate)
Normalize w.r.t. mean spectrum across all segments ( psd / mean(psd) )
log(psd)
PCA to get projections from PSD to PSCs (only on freqs < 200 Hz that are not around 60Hz or its harmonics)
Online:
Spectrogram (wavelets), project each time point onto first PSC (broadband)
Smoothing (sigma = 0.05 sec)
z-scoring
exp()
Here we will take a slightly different approach:
PSD -> TensorDecomposition (trials, frequencies, channels)
Raw -> TensorDecomposition (trials, times, channels)
(? DemixingPCA ?)
@author: <NAME>
"""
from pathlib import Path
import numpy as np
DATA_ROOT = Path.cwd() / 'data' / 'kjm_ecog' / 'download' / 'faces_basic'
AREA_LABELS = [
'Temporal pole',
'Parahippocampal gyrus', # parahippocampal part of the medial occipito-temporal gyrus
'Inferior temporal gyrus',
'Middle temporal gyrus',
'fusiform gyrus', # Lateral occipito-temporal gyrus,
'Lingual gyrus', # lingual part of the medial occipito-temporal gyrus
'Inferior occipital gyrus',
'Cuneus',
'Post-ventral cingulate gyrus', # Posterior-ventral part of the
'Middle Occipital gyrus',
'occipital pole',
'precuneus',
'Superior occipital gyrus',
'Post-dorsal cingulate gyrus', # Posterior-dorsal part of the cingulate gyrus
' ',
' ',
' ',
' ',
' ',
'Non-included area',
]
def import_to_npype(subject_id):
import scipy.io
from collections import OrderedDict
from neuropype.engine import InstanceAxis, SpaceAxis, TimeAxis, Chunk, Block, Packet, Flags
data_fn = DATA_ROOT / 'data' / subject_id / (subject_id + '_faceshouses.mat')
dat_contents = scipy.io.loadmat(data_fn)
stim = dat_contents['stim'].reshape(-1) # samples x 1; uint8
data = dat_contents['data'] # samples x channels; float
srate = dat_contents['srate'][0][0]
# Time vector
tvec = np.arange(len(stim)) / srate
# Process the stimulus to get an events chunk
b_stim_onset = np.diff(np.hstack((0, stim))) != 0
b_stim_onset = np.logical_and(b_stim_onset, stim != 0)
stim_inds = np.where(b_stim_onset)[0]
stim_vals = stim[stim_inds]
stim_content = np.repeat(['ISI'], len(stim_vals)).astype(object)
stim_content[stim_vals <= 50] = 'house'
stim_content[ | np.logical_and(stim_vals > 50, stim_vals <= 100) | numpy.logical_and |
import popcorn.input_output as in_out
import popcorn.resampling as resampling
import material_decomposition
import popcorn.spectral_imaging.registration as registration
import popcorn.image_processing.segmentation as segmentation
from popcorn.spectral_imaging.pipelines import skull_alignment_pipeline
import sys
import numpy as np
import math
import time
import SimpleITK as Sitk
from skimage.measure import label, regionprops
from skimage import img_as_ubyte
import PyIPSDK
import PyIPSDK.IPSDKIPLBinarization as Bin
import PyIPSDK.IPSDKIPLMorphology as Morpho
import PyIPSDK.IPSDKIPLAdvancedMorphology as AdvMorpho
import PyIPSDK.IPSDKIPLShapeAnalysis as ShapeAnalysis
def conversion_pipeline(image, bin_factor, min, max):
if bin_factor > 1:
image = resampling.bin_resize(image, bin_factor)
return resampling.conversion_uint16_to_float32(image, min, max)
def retrieve_min_max_from_path(path):
"""looks for min and max float in path
Args:
path (str): folder path
Returns:
(float, float) retrieved min and max values
"""
path = path.replace("\\", "")
path = path.replace("/", "")
return float(path.split("_")[-2]), float(path.split("_")[-1])
def segmentation_coloration(output_folder, concentration_map, segmentation_result, material):
cells = np.copy(concentration_map)
cells[segmentation_result == 0] = 0
cells_part = np.copy(cells)
concentration_map = resampling.normalize_image(concentration_map) / 1.5
cells_part = resampling.normalize_image(cells_part)
noise = np.copy(concentration_map)
noise[cells_part > 0] = 0
mask = np.copy(cells)
mask[mask > 0] = 1
cells_offset = np.copy(concentration_map)
cells_offset[cells_part <= 0] = 0
cells_offset[cells_part > 0] = 0.2
rgb = [0.8, 0.8, 0] if material == "Au" else [0.8, 0.35, 0]
for i in range(cells_part.shape[0]):
red_slice = img_as_ubyte(noise[i, :, :] + rgb[0] * cells_part[i, :, :] + cells_offset[i, :, :])
green_slice = img_as_ubyte(noise[i, :, :] + rgb[1] * cells_part[i, :, :] + cells_offset[i, :, :])
blue_slice = img_as_ubyte(noise[i, :, :] + rgb[2] * cells_part[i, :, :] + cells_offset[i, :, :])
rgb_cells = np.stack((red_slice, green_slice, blue_slice), axis=-1)
in_out.save_tif_image(rgb_cells, output_folder + '{:04d}'.format(i), rgb=True)
class SpectralImagingExperiment:
def __init__(self, name, path, sample_type, modality, materials, resolution, bin_factor=1):
"""constructor of class SpectralImagingExperiment
Args:
name (str): sample radix
path (str): data path
sample_type (str): either "phantom", "rat brain" or "rat knee"
modality (str): modality used for acquisition
materials (list[str]): list of kedge materials
resolution (float): image resolution
bin_factor (int): binning factor when analyzing
"""
self.name = name
self.path = path
self.type = sample_type
self.modality = modality
self.materials = materials
self.resolution = resolution * bin_factor
self.bin_factor = bin_factor
def conversion(self):
"""Converts images from uint16 to float32 using the sample's name min/max inb4 binning them using defined bin
factor
Returns:
None
"""
for material in self.materials:
print("Conversion of :", material)
# We retrieve float min and max from given path
above_image_filenames = in_out.create_list_of_files(self.path + "*Above*" + material + "*", "tif")
above_min, above_max = retrieve_min_max_from_path(in_out.remove_filename_in_path(above_image_filenames[0]))
for index in range(len(above_image_filenames)//self.bin_factor):
# [1/5] Opening
image_to_bin = in_out.open_sequence(above_image_filenames[:self.bin_factor])
# [2/5] Deleting opened files from previous list of files
del above_image_filenames[:self.bin_factor]
# [3/5] Binning
binned_image = resampling.bin_resize(image_to_bin, self.bin_factor)
# [4/5] Conversion
converted_image = resampling.conversion_uint16_to_float32(binned_image, above_min, above_max)
# [5/5] Saving
in_out.save_tif_image(converted_image[0],
self.path + material + "\\Above_Acquisition\\" + '{:04d}'.format(index))
# We retrieve float min and max from given path
below_image_filenames = in_out.create_list_of_files(self.path + "*Below*" + material + "*", "tif")
below_min, below_max = retrieve_min_max_from_path(in_out.remove_filename_in_path(below_image_filenames[0]))
for index in range(len(below_image_filenames)//self.bin_factor):
# [1/5] Opening
image_to_bin = in_out.open_sequence(below_image_filenames[:self.bin_factor])
# [2/5] Deleting opened files from previous list of files
del below_image_filenames[:self.bin_factor]
# [3/5] Binning
binned_image = resampling.bin_resize(image_to_bin, self.bin_factor)
# [4/5] Conversion
converted_image = resampling.conversion_uint16_to_float32(binned_image, below_min, below_max)
# [5/5] Saving
in_out.save_tif_image(converted_image[0],
self.path + material + "\\Below_Acquisition\\" + '{:04d}'.format(index))
def register_volumes(self):
if self.type == "rat brain":
for material in self.materials:
print("--------", "Registering", material, "--------")
above_filenames = in_out.create_list_of_files(self.path + material + "\\Above_Acquisition\\",
"tif")
below_filenames = in_out.create_list_of_files(self.path + material + "\\Below_Acquisition\\",
"tif")
above_image = in_out.open_sequence(above_filenames)
below_image = in_out.open_sequence(below_filenames)
# -- Threshold computation
above_threshold_value = segmentation.find_threshold_value(material, "esrf")
above_mask = above_image > above_threshold_value
below_mask = below_image > above_threshold_value
# -- Extracting skulls
above_skull, above_skull_bbox = segmentation.extract_skull(above_mask)
below_skull, below_skull_bbox = segmentation.extract_skull(below_mask)
rotation_transform = registration.registration_computation(above_image,
below_image,
transform_type="rotation",
metric="msq",
moving_mask=above_skull,
ref_mask=below_skull,
verbose=True)
# Registering the above image
above_image = registration.apply_itk_transformation(above_image, rotation_transform, "linear")
in_out.save_tif_sequence(above_image,
self.path + material + "\\Above_Acquisition_Registered\\")
skull_alignment_pipeline(self.path + material + "\\Above_Acquisition_Registered\\",
self.path + material + "\\Below_Acquisition\\", material)
elif self.type == "mouse knee":
for material in self.materials:
print("--------", "Registering", material, "--------")
above_filenames = in_out.create_list_of_files(self.path + material + "\\Above_Acquisition_Binned\\",
"tif")
below_filenames = in_out.create_list_of_files(self.path + material + "\\Below_Acquisition_Binned\\",
"tif")
above_image = in_out.open_sequence(above_filenames)
below_image = in_out.open_sequence(below_filenames)
# -- Threshold computation
above_threshold_value = segmentation.find_threshold_value(material, "above", "esrf")
above_mask = np.copy(above_image)
above_mask[above_mask > above_threshold_value] = 1
above_mask[above_mask <= above_threshold_value] = 0
below_threshold_value = segmentation.find_threshold_value(material, "below", "esrf")
below_mask = np.copy(below_image)
below_mask[below_mask > below_threshold_value] = 1
below_mask[below_mask <= below_threshold_value] = 0
translation_transform = registration.registration_computation(above_image,
below_image,
transform_type="translation",
metric="msq",
moving_mask=above_mask,
ref_mask=below_mask,
verbose=True)
rotation_transform = registration.registration_computation(above_image,
below_image,
transform_type="rotation",
metric="msq",
moving_mask=above_mask,
ref_mask=below_mask,
verbose=True)
image_to_register = in_out.open_sequence(self.path + material + "\\Above_Acquisition\\")
# Registering the above image
translation_parameters = translation_transform.GetParameters()
translation_transform.SetParameters((translation_parameters[0]*2,
translation_parameters[1]*2,
translation_parameters[2]*2))
image_to_register = registration.apply_itk_transformation(image_to_register,
translation_transform,
"linear")
image_to_register_itk = Sitk.GetImageFromArray(image_to_register)
actual_rotation = Sitk.CenteredTransformInitializer(image_to_register_itk,
image_to_register_itk,
Sitk.Euler3DTransform(),
Sitk.CenteredTransformInitializerFilter.GEOMETRY)
rotation_parameters = rotation_transform.GetParameters()
actual_rotation.SetParameters((rotation_parameters[0],
rotation_parameters[1],
rotation_parameters[2],
rotation_parameters[3] * 2,
rotation_parameters[4] * 2,
rotation_parameters[5] * 2))
image_to_register = registration.apply_itk_transformation(image_to_register, actual_rotation, "linear")
print("\r[1/2] Saving registered image :", end="", flush=True)
in_out.save_tif_sequence(image_to_register,
self.path + material + "\\Above_Acquisition_Registered\\")
image_to_register = None
below_image = in_out.open_sequence(self.path + material + "\\Below_Acquisition\\")
below_image[below_image > below_threshold_value] = 1
below_image[below_image <= below_threshold_value] = 0
print("\r[2/2] Saving below mask :", end="", flush=True)
in_out.save_tif_sequence(below_image,
self.path + material + "\\Below_Mask\\")
print("\n")
elif self.type == "phantom":
for material in self.materials:
print("--------", "Registering", material, "--------")
above_filenames = in_out.create_list_of_files(self.path + material + "\\Above_Acquisition\\",
"tif")
below_filenames = in_out.create_list_of_files(self.path + material + "\\Below_Acquisition\\",
"tif")
above_image = in_out.open_sequence(above_filenames)
below_image = in_out.open_sequence(below_filenames)
# -- Threshold computation
above_mask = np.ones(above_image.shape)
above_mask[above_image > 0.18] = 0
above_mask[above_image < 0.14] = 0
below_mask = np.ones(below_image.shape)
below_mask[below_image > 0.17] = 0
below_mask[below_image < 0.14] = 0
rotation_transform = registration.registration_computation(above_image,
below_image,
transform_type="rotation",
metric="msq",
moving_mask=above_mask,
ref_mask=below_mask,
verbose=True)
# Registering the above image
above_image = registration.apply_itk_transformation(above_image, rotation_transform, "linear")
in_out.save_tif_sequence(above_image,
self.path + material + "\\Above_Acquisition_Registered\\")
def manual_registration(self, slice_of_interest):
"""Function made for manual registration tests
Args:
slice_of_interest (int): around which slice we want to test our shit
"""
for material in self.materials:
if material == "Au":
densities = np.array([19.3, 1.0])
material_attenuations = np.array([[165.8642, 000.1827],
[040.7423, 000.1835]])
else:
densities = np.array([4.93, 1.0])
material_attenuations = np.array([[170.9231, 000.3188],
[033.6370, 000.3307]])
print("--------", "Registering", material, "--------")
above_filenames = in_out.create_list_of_files(self.path + material + "\\Above_Acquisition\\",
"tif")
belowsimage = in_out.open_sequence(
in_out.create_list_of_files(self.path + material + "\\Below_Acquisition\\",
"tif")[slice_of_interest - 5:slice_of_interest + 6])
above_image = in_out.open_sequence(above_filenames)
for z in range(20):
above_image_itk = Sitk.GetImageFromArray(above_image)
translation_transformation = Sitk.TranslationTransform(above_image_itk.GetDimension())
translation_transformation.SetOffset((-0.14, z/10 - 1, 0))
above_image_itk = Sitk.Resample(above_image_itk, translation_transformation, Sitk.sitkLinear, 0.0,
above_image_itk.GetPixelIDValue())
registered_image = Sitk.GetArrayFromImage(above_image_itk)
images = np.stack((registered_image[slice_of_interest-5:slice_of_interest+6], belowsimage), axis=0)
concentration_maps = \
material_decomposition.decomposition_equation_resolution(images, densities, material_attenuations,
volume_fraction_hypothesis=False,
verbose=False)
in_out.save_tif_sequence(concentration_maps[0],
self.path + material + "\\manual_registrationz_" + str(z/10 - 1) + "\\")
def material_decomposition(self, registration_done=False):
"""material decomposition method
Args:
registration_done (bool): did we use registration ?
Returns:
None
"""
if len(self.materials) == 1:
material = self.materials[0]
if self.type == "phantom":
if registration_done:
above_filenames = \
in_out.create_list_of_files(self.path + self.materials[0] + "\\Above_Acquisition_Registered\\",
"tif")
else:
above_filenames = \
in_out.create_list_of_files(self.path + self.materials[0] + "\\Above_Acquisition\\",
"tif")
below_filenames = in_out.create_list_of_files(self.path + self.materials[0] + "\\Below_Acquisition\\",
"tif")
elif self.type == "rat brain":
above_filenames = \
in_out.create_list_of_files(self.path + self.materials[0] + "\\Aligned_Above_Acquisition\\",
"tif")
below_filenames = \
in_out.create_list_of_files(self.path + self.materials[0] + "\\Aligned_Below_Acquisition\\",
"tif")
else:
above_filenames = \
in_out.create_list_of_files(self.path + self.materials[0] + "\\Above_Acquisition_Registered\\",
"tif")
below_filenames = in_out.create_list_of_files(self.path + self.materials[0] + "\\Below_Acquisition\\",
"tif")
time_list = []
for filename_index in range(min(len(above_filenames), len(below_filenames))):
above_image = in_out.open_image(above_filenames[filename_index])
below_image = in_out.open_image(below_filenames[filename_index])
images = np.stack((above_image, below_image), axis=0)
if material == "Au":
densities = np.array([19.3, 1.0])
material_attenuations = np.array([[165.8642, 000.1827],
[040.7423, 000.1835]])
else:
densities = np.array([4.93, 1.0])
material_attenuations = np.array([[170.9231, 000.3188],
[033.6370, 000.3307]])
concentration_maps = \
material_decomposition.decomposition_equation_resolution(images, densities, material_attenuations,
volume_fraction_hypothesis=False,
verbose=False)
start_time = time.time()
material_decomposition.loading_bar(filename_index, min(len(above_filenames), len(below_filenames)))
in_out.save_tif_image(concentration_maps[0], self.path + material + "\\"
+ material + "2materials_decomposition\\" + '{:04d}'.format(filename_index))
# in_out.save_tif_image(concentration_maps[1], self.path + material + "\\"
# + "Bone_decomposition\\" + '{:04d}'.format(filename_index))
# in_out.save_tif_image(concentration_maps[2], self.path + material + "\\"
# + "Water_decomposition\\" + '{:04d}'.format(filename_index))
time_list.append(time.time() - start_time)
print("")
print("Average time for decomposition :", sum(time_list)/len(time_list), "s")
print("Min time for decomposition :", min(time_list), "s")
print("Evolution of decomposition time :", (time_list[-1] - time_list[0])/len(time_list), "s")
elif len(self.materials) == 2:
for material in self.materials:
if material == "I":
if self.type == "phantom":
if registration_done:
above_filenames = in_out.create_list_of_files(self.path + material +
"\\Above_Acquisition_Registered\\",
"tif")
else:
above_filenames = in_out.create_list_of_files(self.path + material +
"\\Above_Acquisition\\",
"tif")
below_filenames = in_out.create_list_of_files(
self.path + material + "\\Below_Acquisition\\",
"tif")
elif self.type == "rat brain":
above_filenames = in_out.create_list_of_files(
self.path + material + "\\Aligned_Above_Acquisition\\",
"tif")
below_filenames = in_out.create_list_of_files(
self.path + material + "\\Aligned_Below_Acquisition\\",
"tif")
else:
above_filenames = in_out.create_list_of_files(
self.path + material + "\\Above_Acquisition_Registered\\",
"tif")
below_filenames = in_out.create_list_of_files(
self.path + material + "\\Below_Acquisition\\",
"tif")
for filename_index in range(min(len(above_filenames), len(below_filenames))):
above_image = in_out.open_image(above_filenames[filename_index])
below_image = in_out.open_image(below_filenames[filename_index])
images = np.stack((above_image, below_image), axis=0)
if material == "Au":
densities = | np.array([19.3, 4.93, 1.0]) | numpy.array |
#import pandas as pd
import numpy as np
import random
from tqdm import tqdm
#from sklearn.linear_model import LinearRegression
#from pandas.core.common import SettingWithCopyWarning
#import warnings
#from .dbtonumpy import eurusd_prices
#warnings.simplefilter(action="ignore", category=SettingWithCopyWarning)
from datetime import datetime, timedelta
import datetime as dt
start_date = dt.date.today()
y = dt.timedelta(days=1*365)
end_date = start_date + y
nb_paths = 10
initial_price = 1.10
def r2_score_and_slope(y):
"""takes numpy array of prices and returns r2 score, slope and constant"""
y = | np.array(y) | numpy.array |
from HW_PI_PiezoStage.PiezoStage_Scan import PiezoStage_Scan
from ScopeFoundry import Measurement
from ScopeFoundry.helper_funcs import sibling_path, load_qt_ui_file
import pyqtgraph as pg
import numpy as np
import time
import pickle
import os.path
from pyqtgraph.Qt import QtGui, QtCore, QtWidgets
from pyqtgraph.Point import Point
import customplotting.mscope as cpm
class PicoHarp_Scan(PiezoStage_Scan):
name = "PicoHarp_Scan"
def setup(self):
PiezoStage_Scan.setup(self)
self.picoharp_hw = self.app.hardware['picoharp']
self.pi_device_hw = self.app.hardware['piezostage']
self.settings.New("Tacq", unit="s", dtype=float, vmin=1e-3, vmax=100*60*60, initial=1) #removed si=True to keep units from auto-changing
self.settings.New("Resolution", dtype=int, choices=[("4 ps", 4), ("8 ps", 8), ("16 ps", 16), ("32 ps", 32), ("64 ps", 64), ("128 ps", 128), ("256 ps", 256), ("512 ps", 512)], initial=4)
self.settings.New("count_rate0", dtype=int, ro=True, vmin=0, vmax=100e6)
self.settings.New("count_rate1", dtype=int, ro=True, vmin=0, vmax=100e6)
self.settings.New("flush_data", dtype=bool, initial=False)
def setup_figure(self):
PiezoStage_Scan.setup_figure(self)
#setup ui for picoharp specific settings
details_groupBox = self.set_details_widget(widget = self.settings.New_UI(include=["Tacq", "Resolution", "count_rate0", "count_rate1", "flush_data"]))
widgets = details_groupBox.findChildren(QtGui.QWidget)
tacq_spinBox = widgets[1]
resolution_comboBox = widgets[4]
count_rate0_spinBox = widgets[6]
count_rate1_spinBox = widgets[9]
flush_data_checkBox = widgets[12]
#connect settings to ui
self.picoharp_hw.settings.Tacq.connect_to_widget(tacq_spinBox)
self.picoharp_hw.settings.Resolution.connect_to_widget(resolution_comboBox)
self.picoharp_hw.settings.count_rate0.connect_to_widget(count_rate0_spinBox)
self.picoharp_hw.settings.count_rate1.connect_to_widget(count_rate1_spinBox)
self.settings.flush_data.connect_to_widget(flush_data_checkBox)
tacq_spinBox.valueChanged.connect(self.update_estimated_scan_time)
self.update_estimated_scan_time()
#save data buttons
self.ui.save_image_pushButton.clicked.connect(self.save_intensities_image)
self.ui.save_array_pushButton.clicked.connect(self.save_intensities_data)
#setup imageview
self.imv = pg.ImageView()
self.imv.getView().setAspectLocked(lock=False, ratio=1)
self.imv.getView().setMouseEnabled(x=True, y=True)
self.imv.getView().invertY(False)
roi_plot = self.imv.getRoiPlot().getPlotItem()
roi_plot.getAxis("bottom").setLabel(text="Time (ns)")
def update_estimated_scan_time(self):
try:
self.overhead = self.x_range * self.y_range * .055 #determined by running scans and timing
self.scan_time = self.x_range * self.y_range * self.settings["Tacq"] + self.overhead
self.ui.estimated_scan_time_label.setText("Estimated scan time: " + "%.2f" % self.scan_time + "s")
except:
pass
def update_display(self):
PiezoStage_Scan.update_display(self)
if hasattr(self, 'sum_intensities_image_map') and hasattr(self, 'hist_data'):
self.picoharp_hw.read_from_hardware()
if not self.interrupt_measurement_called:
per_pixel = self.scan_time/(self.x_range * self.y_range)
seconds_left = per_pixel * (self.x_range * self.y_range - self.pixels_scanned)
self.ui.estimated_time_label.setText("Estimated time remaining: " + "%.2f" % seconds_left + "s")
self.img_item.setImage(self.sum_intensities_image_map) #update stage image
#update imageview
self.times = self.time_data[:, 0, 0]*1e-3
self.imv.setImage(img=self.hist_data, autoRange=False, autoLevels=True, xvals=self.times)
self.imv.show()
self.imv.window().setWindowFlag(QtCore.Qt.WindowCloseButtonHint, False) #disable closing image view window
#update progress bar
progress = 100 * ((self.pixels_scanned+1)/np.abs(self.x_range*self.y_range))
self.ui.progressBar.setValue(progress)
self.set_progress(progress)
pg.QtGui.QApplication.processEvents()
def pre_run(self):
try:
PiezoStage_Scan.pre_run(self) #setup scan paramters
self.picoharp = self.picoharp_hw.picoharp
self.check_filename("_raw_PL_hist_data.pkl")
self.num_hist_chans = self.app.hardware['picoharp'].calc_num_hist_chans()
dirname = self.app.settings['save_dir']
self.check_filename('_histdata.dat')
sample_filename = self.app.settings['sample']
self.hist_filename = os.path.join(dirname, sample_filename + '_histdata.dat')
self.check_filename('_timedata.dat')
self.time_filename = os.path.join(dirname, sample_filename + '_timedata.dat')
hist_len = self.num_hist_chans
#Use memmaps to use less memory and store data into disk
self.hist_data= | np.memmap(self.hist_filename,dtype='float32',mode='w+',shape=(hist_len, self.x_range, self.y_range)) | numpy.memmap |
# -*- coding: utf-8 -*-
"""
Created on Wed Apr 10 15:15:09 2019
@author: egomez
"""
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib as mpl
import seaborn as sns
from exponential_fit import decission_data_exponential
from lowess_fit import significance_analysis
def func_exp_pure(x, a, c):
return a*np.exp(-c*(x))
def plot_decission_with_LOWESS(df, combination,test, measure, fs = None,
width = None, height = None, path = None,
file_name = None, colors = None, #ctheme_lowess = None,
sign_level = None, gamma = None):
"""
Function to plot the estimated p-values and the fitted exponential function
by comparisons:
- df: pandas dataframe containing the estimated p-values
- combination: dictionary with the list of comparisons, i.e.
combination={
'0': 'A02_A03',
'1': 'A02_A09',
'2': 'A02_A16',
'3': 'A02_A29',
'4': 'A02_A35',
'5': 'A02_A55',
'6': 'A02_A65',
'7': 'A02_A85',
'8': 'A02_A96'
}
- test: dictionary, i.e. {'0': 'MannWhitneyU'}
- measure: measures for which the plot is done, i.e.
variables={
'0': 'area (px^2)',
'1': 'short axis length (px)',
'2': 'orientation'
}
Optional parameters:
- ctheme: list of colors. Each measure is plot with a different color.
- fs: optional. font size
- height: height of the figure
- width: width of the figure
- path: directory in which the figure will be saved. If it is None, then
the image is not saved.
- file_name: name to use for the figure if it is saved.
- sign_level: alpha for statistical significance of 100(1-alpha).
Set by default as 0.05.
- gamma: threshold to calculate the convergence of p(n) and Theta function.
"""
if colors is None:
colors = ['#B80652', '#FF2017', '#F36635', #'#DD9952',
'#CABB04',
#'#A7C850',
'#56C452', '#2EBAB3', '#1C69A8', '#25369A',
'#4E3180']
if fs is None:
fs = 10
if height is None:
height = 5
if width is None:
width = 10
if path is None:
save_fig = 0
else:
save_fig = 1
if file_name is None:
# Change the format to png, jpg, or any other one as
# "file_name = 'p_values.pdf"
file_name = 'p_values.png'
if sign_level is None:
sign_level = 0.05
if gamma is None:
gamma = 5e-06
param = decission_data_exponential(df, combination, measure,
sign_level = sign_level, gamma = gamma)
N = 500
for c in range(len(combination)):
param1 = param[param.comparison==combination[np.str(c)]]
print(combination[np.str(c)])
f = plt.gcf()
ax = plt.gca()
f.set_figwidth(width)
f.set_figheight(height)
mpl.style.use('seaborn')
sns.set_style("white")
sns.set_context("talk")
splot = ax
labels = ['A']
df_comparison = df[df.comparison == combination[np.str(c)]]
for i in range(len(measure)):
df_measure = df_comparison[df_comparison.measure == measure[np.str(i)]]
for t in range(len(test)):
# Plot LOWESS fit
df_test = df_measure[df_measure.test == test[np.str(t)]]
L, dcoeff, positive_N = significance_analysis(df_test,
sign_level = sign_level)
positive_N = (param1[measure[np.str(i)]+
'_nalpha_estimated'][0])
splot.plot(L[:,0], L[:,1], color=colors[i])# color = ctheme[i],
# splot.fill_between(L[:,0], L[:,1], 0*L[:,1], color = ctheme_lowess[i], alpha=0.7)
labels = np.concatenate((labels, [measure[np.str(i)] +
r' $\hat{n}_\alpha$ = ' +
np.str(positive_N)]))
# EXPONENTIAL FIT
par_a,par_c= (param1[measure[np.str(i)]+'_exp_params'][0])
positive_N = (param1[measure[np.str(i)]+
'_nalpha_theory'][0])
splot.plot(np.arange(0,N),
func_exp_pure(np.arange(0,N),par_a,par_c),
linestyle='--', color=colors[i])# color = ctheme[i],
labels = np.concatenate((labels, [r'Exponential fit $n_{\alpha}$ = ' +
np.str(positive_N)]))
splot.tick_params(labelsize = fs)
y = sign_level*np.ones((len(np.arange(0,N))))
splot.plot(np.arange(0,N), y, color = 'black')
labels = np.concatenate((labels, [r'$\alpha = 0.05$']))
splot.legend(labels[1:], bbox_to_anchor=(1, 1),ncol = 1,fancybox=True,
shadow=True, fontsize = fs) # loc='best',
splot.set_title(combination[np.str(c)], fontsize = fs)
splot.set_xlabel('Sample size (n)', fontsize = fs)
splot.set_ylabel('p-value ' + combination[np.str(c)], fontsize = fs)
splot.set_ylim([0,0.45])
f.tight_layout()
if save_fig == 1:
plt.savefig(path + combination[np.str(c)] + file_name, dpi=75)
plt.show()
def plot_pcurve_by_measure(df, combination, measure, test = None, fs = None,
width = None, height = None, path = None,
file_name = None, colors = None, #ctheme_lowess = None,
sign_level = None, gamma = None):
"""
Function to plot the estimated p-values and the fitted exponential function
by measures:
- df: pandas dataframe containing the estimated p-values
- combination: dictionary with the list of comparisons, i.e.
combination={
'0': 'A02_A03',
'1': 'A02_A09',
'2': 'A02_A16',
'3': 'A02_A29',
'4': 'A02_A35',
'5': 'A02_A55',
'6': 'A02_A65',
'7': 'A02_A85',
'8': 'A02_A96'
}
- measure: measures for which the plot is done, i.e.
variables={
'0': 'area (px^2)',
'1': 'short axis length (px)',
'2': 'orientation'
}
Optional parameters:
- test: dictionary, i.e. {'0': 'MannWhitneyU'}
- ctheme: list of colors. Each measure is plot with a different color.
- fs: optional. font size
- height: height of the figure
- width: width of the figure
- path: directory in which the figure will be saved. If it is None, then
the image is not saved.
- file_name: name to use for the figure if it is saved.
- sign_level: alpha for statistical significance of 100(1-alpha).
Set by default as 0.05.
- gamma: threshold to calculate the convergence of p(n) and Theta function.
"""
if colors is None:
colors = ['#B80652', '#FF2017', '#F36635', #'#DD9952',
'#CABB04',
#'#A7C850',
'#56C452', '#2EBAB3', '#1C69A8', '#25369A',
'#4E3180']
if fs is None:
fs = 10
if height is None:
height = 8
if width is None:
width = 10
if path is None:
save_fig = 0
else:
save_fig = 1
if file_name is None:
# Change the format to png, jpg, or any other one as
# "file_name = 'p_values.pdf"
file_name = 'p_values.png'
if sign_level is None:
sign_level = 0.05
if test is None:
test ={'0': 'MannWhitneyU'}
if gamma is None:
gamma = 5e-06
param = decission_data_exponential(df, combination, measure,
sign_level = sign_level, gamma = gamma)
N = max(df.N)
# N = 1200 # 400
for i in range(len(measure)):
df_measure = df[df.measure == measure[ | np.str(i) | numpy.str |
import unittest
import numpy as np
class Test_UFUNCTests(unittest.TestCase):
#region UFUNC ADD tests
def test_UFUNC_AddAccumlate_1(self):
x = np.arange(8);
a = np.add.accumulate(x)
print(a)
x = np.arange(8).reshape((2,2,2))
b = np.add.accumulate(x)
print(b)
c = np.add.accumulate(x, 0)
print(c)
d = np.add.accumulate(x, 1)
print(d)
e = np.add.accumulate(x, 2)
print(e)
def test_UFUNC_AddReduce_1(self):
x = np.arange(8);
a = np.add.reduce(x)
print(a)
x = np.arange(8).reshape((2,2,2))
b = np.add.reduce(x)
print(b)
c = np.add.reduce(x, 0)
print(c)
d = np.add.reduce(x, 1)
print(d)
e = np.add.reduce(x, 2)
print(e)
def test_UFUNC_AddReduce_2(self):
x = np.arange(8).reshape((2,2,2))
b = np.add.reduce(x)
print(b)
c = np.add.reduce(x, (0,1))
print(c)
d = np.add.reduce(x, (1,2))
print(d)
e = np.add.reduce(x, (2,1))
print(e)
def test_UFUNC_AddReduceAt_1(self):
a =np.add.reduceat(np.arange(8),[0,4, 1,5, 2,6, 3,7])[::2]
print(a)
print("**********")
x = np.linspace(0, 15, 16).reshape(4,4)
b = np.add.reduceat(x, [0, 3, 1, 2, 0])
print(b)
print("**********")
c = np.multiply.reduceat(x, [0, 3], axis = 1)
print(c)
def test_UFUNC_AddOuter_1(self):
x = np.arange(4);
a = np.add.outer(x, x)
print(a.shape)
print(a)
x = np.arange(6).reshape((3,2))
y = np.arange(6).reshape((2,3))
b = np.add.outer(x, y)
print(b.shape)
print(b)
#endregion
#region UFUNC SUBTRACT tests
def test_UFUNC_SubtractAccumulate_1(self):
x = np.arange(8);
a = np.subtract.accumulate(x)
print(a)
x = np.arange(8).reshape((2,2,2))
b = np.subtract.accumulate(x)
print(b)
c = np.subtract.accumulate(x, 0)
print(c)
d = np.subtract.accumulate(x, 1)
print(d)
e = np.subtract.accumulate(x, 2)
print(e)
def test_UFUNC_SubtractReduce_1(self):
x = np.arange(8);
a = np.subtract.reduce(x)
print(a)
x = np.arange(8).reshape((2,2,2))
b = np.subtract.reduce(x)
print(b)
c = np.subtract.reduce(x, 0)
print(c)
d = np.subtract.reduce(x, 1)
print(d)
e = np.subtract.reduce(x, 2)
print(e)
def test_UFUNC_SubtractReduceAt_1(self):
a =np.subtract.reduceat(np.arange(8),[0,4, 1,5, 2,6, 3,7])[::2]
print(a)
print("**********")
x = | np.linspace(0, 15, 16) | numpy.linspace |
# This file is heavily based on waterfall.py from satnogs-client.
import matplotlib
import numpy as np
import sys
matplotlib.use('Agg')
import matplotlib.pyplot as plt
OFFSET_IN_STDS = -2.0
SCALE_IN_STDS = 8.0
class Waterfall():
"""
Parse waterfall data file
:param datafile_path: Path to data file
:type datafile_path: str_array
"""
def __init__(self, datafile_path, logger=None):
"""
Class constructor
"""
self.logger = logger or sys.stdout
self.data = self._get_waterfall(datafile_path)
def plot(self, figure_path, vmin=None, vmax=None):
"""
Plot waterfall into a figure
:param figure_path: Path of figure file to save
:type figure_path: str
:param value_range: Minimum and maximum value range
:type value_range: tuple
"""
tmin = np.min(self.data['data']['tabs'] / 1000000.0)
tmax = np.max(self.data['data']['tabs'] / 1000000.0)
fmin = np.min(self.data['freq'] / 1000.0)
fmax = np.max(self.data['freq'] / 1000.0)
if vmin is None or vmax is None:
vmin = -100
vmax = -50
c_idx = self.data['data']['spec'] > -200.0
if np.sum(c_idx) > 100:
data_mean = np.mean(self.data['data']['spec'][c_idx])
data_std = np.std(self.data['data']['spec'][c_idx])
vmin = data_mean - 2.0 * data_std
vmax = data_mean + 4.0 * data_std
plt.figure(figsize=(10, 20))
plt.imshow(self.data['data']['spec'],
origin='lower',
aspect='auto',
interpolation='None',
extent=[fmin, fmax, tmin, tmax],
vmin=vmin,
vmax=vmax,
cmap='Greens') # 'viridis', 'plasma', 'inferno', 'magma', 'cividis'
# also, see https://matplotlib.org/stable/tutorials/colors/colormaps.html
plt.xlabel('Frequency (kHz)')
plt.ylabel('Time (seconds)')
fig = plt.colorbar(aspect=50)
fig.set_label('Power (dB)')
plt.savefig(figure_path, bbox_inches='tight')
plt.close()
def _read_waterfall(self, datafile_path):
"""
Read waterfall data file
:param datafile_path: Path to data file
:type datafile_path: str
:return: Waterfall data
:rtype: dict
"""
waterfall = {}
with open(datafile_path, mode='rb') as datafile:
waterfall = {
'timestamp': np.fromfile(datafile, dtype='|S32', count=1)[0],
'nchan': np.fromfile(datafile, dtype='>i4', count=1)[0],
'samp_rate': np.fromfile(datafile, dtype='>i4', count=1)[0],
'nfft_per_row': np.fromfile(datafile, dtype='>i4', count=1)[0],
'center_freq': np.fromfile(datafile, dtype='>f4', count=1)[0],
'endianess': np.fromfile(datafile, dtype='>i4', count=1)[0]
}
# Let's disable the logging for now.
# self.logger.write("Waterfall details: " + repr(waterfall) + "\n")
data_dtypes = np.dtype([('tabs', 'int64'), ('spec', 'float32', (waterfall['nchan'], ))])
waterfall['data'] = np.fromfile(datafile, dtype=data_dtypes)
if waterfall['data'].size == 0:
raise EOFError
datafile.close()
return waterfall
def _compress_waterfall(self, waterfall):
"""
Compress spectra of waterfall
:param waterfall: Watefall data
:type waterfall: dict
:return: Compressed spectra
:rtype: dict
"""
spec = waterfall['data']['spec']
std = np.std(spec, axis=0)
offset = | np.mean(spec, axis=0) | numpy.mean |
# -*- coding: utf-8 -*-
"""
Created on Mon 2018.02.28:00:00:00
@author: jac-nosm
Abstrac:
Dilution experiments are performed routinely in microbial laboratories.
However, their results are not properly analyzed, with only very basic hueristic
formulas. We present a proper statistical analysis of these experiments and
include also a further analysis of the bacterial evolution under temperature stress.
"""
# Packages
from numpy import array, zeros, exp
from DilExp import DilExp, MultiDilExp
from matplotlib import pyplot as plt
def TransformTNTC( count, c=300):
if isinstance( count, int):
return count
else:
return c
def AnaBF( spreadsheet, lab, T=100000, control=False, data_all=True):
"""Analyse BF for the repetitions in all data
experiment in lab = 'Lab5', 'Lab6', 'Lab8' or
if control 'Lab5Cntrl', 'Lab6Cntrl', 'Lab8Cntrl'
not(data_all), that is, only include the first countable dilution.
"""
J=7 ## Dilutions < J
c=300 ##maximum count for the drop or plated volumen, TNTC threshold
d = DilExp( J=J, alpha0=4, alpha=10, alphap=100, c=c, Sc=4.13, Sc_unit=r"cm^2", q=0.05, pr_a=10)
""" alpha0, dilution factor for tube 1 from tube 0: 1ml from 4*10ml
alpha, dilution factor for each tube =10, 1ml from 10ml
alphap, dilution factor for the drop or plated volumen =100, 0.1ml from 10ml
q, probibility of misscounting (=0.05)
pr_a, prior mean of the count, given the dilution s to be counted (=20)
Sc, coupon surface area (=4.13)
Sc_unit, coupon surface area units (=r"cm^2").
"""
if control:
sheet = lab + 'Cntrl'
#print("Analizing control experiment of %s" % (lab,))
else:
sheet = lab
#print("Analizing experiment of %s" % (lab,))
rt = []
for k in range(3): #Repetitions 1, 2, 3
s = zeros(2)
y = | zeros(2) | numpy.zeros |
# -*- coding: utf-8 -*-
"""MCIR for PET with primal-dual algorithms.
Usage:
PET_MCIR_PD [--help | options]
Options:
-T <pattern>, --trans=<pattern> transformation pattern, * or % wildcard
(e.g., tm_ms*.txt). Enclose in quotations.
-t <str>, --trans_type=<str> transformation type (tm, disp, def)
[default: tm]
-S <pattern>, --sino=<pattern> sinogram pattern, * or % wildcard
(e.g., sino_ms*.hs). Enclose in quotations.
-a <pattern>, --attn=<pattern> attenuation pattern, * or % wildcard
(e.g., attn_ms*.hv). Enclose in quotations.
-R <pattern>, --rand=<pattern> randoms pattern, * or % wildcard
(e.g., rand_ms*.hs). Enclose in quotations.
-n <norm>, --norm=<norm> ECAT8 bin normalization file
-e <int>, --epoch=<int> num epochs [default: 10]
-r <string>, --reg=<string> regularisation ("None","FGP_TV","explicit_TV", ...)
[default: None]
-o <outp>, --outp=<outp> output file prefix [default: recon]
--outpath=<string> output folder path [default: './']
--param_path=<string> param folder path [default: './']
--nxny=<nxny> image x and y dimension [default: 127]
--dxdy=<dxdy> image x and y spacing
(default: determined by scanner)
-I <str>, --initial=<str> Initial estimate
--visualisations show visualisations
--nifti save output as nifti
--gpu use GPU projector
-v <int>, --verbosity=<int> STIR verbosity [default: 0]
-s <int>, --save_interval=<int> save every x iterations [default: 10]
--descriptive_fname option to have descriptive filenames
--update_obj_fn_interval=<int> frequency to update objective function
[default: 1]
--alpha=<val> regularisation strength (if used)
[default: 0.5]
--reg_iters=<val> Number of iterations for the regularisation
subproblem [default: 100]
--precond Use preconditioning
--numSegsToCombine=<val> Rebin all sinograms, with a given number of
segments to combine. Increases speed.
--numViewsToCombine=<val> Rebin all sinograms, with a given number of
views to combine. Increases speed.
--normaliseDataAndBlock Normalise raw data and block operator by
multiplying by 1./normK.
--algorithm=<string> Which algorithm to run [default: spdhg]
--numThreads=<int> Number of threads to use
--numSubsets=<int> Number of physical subsets to use [default: 1]
--gamma=<val> parameter controlling primal-dual trade-off (>1 promotes dual)
[default: 1.]
--PowerMethod_iters=<val> number of iterations for the computation of operator norms
with the power method [default: 10]
--templateAcqData Use template acd data
--StorageSchemeMemory Use memory storage scheme
"""
# SyneRBI Synergistic Image Reconstruction Framework (SIRF)
# Copyright 2020 University College London.
#
# This is software developed for the Collaborative Computational
# Project in Synergistic Reconstruction for Biomedical Imaging
# (formerly CCP PETMR)
# (http://www.ccpsynerbi.ac.uk/).
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from functools import partial
from os import path
import os
from glob import glob
from docopt import docopt
import matplotlib.pyplot as plt
import numpy as np
from sirf.Utilities import error, show_2D_array, examples_data_path
import sirf.Reg as reg
import sirf.STIR as pet
from cil.framework import BlockDataContainer, ImageGeometry, BlockGeometry
from cil.optimisation.algorithms import PDHG, SPDHG
from cil.optimisation.functions import \
KullbackLeibler, BlockFunction, IndicatorBox, MixedL21Norm, ScaledFunction
from cil.optimisation.operators import \
CompositionOperator, BlockOperator, LinearOperator, GradientOperator, ScaledOperator
from cil.plugins.ccpi_regularisation.functions import FGP_TV
from ccpi.filters import regularisers
from cil.utilities.multiprocessing import NUM_THREADS
__version__ = '0.1.0'
args = docopt(__doc__, version=__version__)
###########################################################################
# Global set-up
###########################################################################
# storage scheme
if args['--StorageSchemeMemory']:
pet.AcquisitionData.set_storage_scheme('memory')
else:
pet.AcquisitionData.set_storage_scheme('default')
# Verbosity
pet.set_verbosity(int(args['--verbosity']))
if int(args['--verbosity']) == 0:
msg_red = pet.MessageRedirector(None, None, None)
# Number of threads
numThreads = args['--numThreads'] if args['--numThreads'] else NUM_THREADS
pet.set_max_omp_threads(numThreads)
if args['--templateAcqData']:
template_acq_data = pet.AcquisitionData('Siemens_mMR', span=11, max_ring_diff=15, view_mash_factor=1)
def main():
"""Run main function."""
use_gpu = True if args['--gpu'] else False
###########################################################################
# Parse input files
###########################################################################
[num_ms, trans_files, sino_files, attn_files, rand_files] = \
get_filenames(args['--trans'],args['--sino'],args['--attn'],args['--rand'])
###########################################################################
# Read input
###########################################################################
[trans, sinos_raw, attns, rands_raw] = \
read_files(trans_files, sino_files, attn_files, rand_files, args['--trans_type'])
sinos = pre_process_sinos(sinos_raw, num_ms)
rands = pre_process_sinos(rands_raw, num_ms)
###########################################################################
# Initialise recon image
###########################################################################
image = get_initial_estimate(sinos,use_gpu)
###########################################################################
# Set up resamplers
###########################################################################
if trans is None:
resamplers = None
else:
resamplers = [get_resampler(image, trans=tran) for tran in trans]
###########################################################################
# Resample attenuation images (if necessary)
###########################################################################
resampled_attns = resample_attn_images(num_ms, attns, trans, use_gpu, image)
print ("resampled_attns", len (resampled_attns))
###########################################################################
# Set up acquisition models (one per motion state)
###########################################################################
acq_models, masks = set_up_acq_models(
num_ms, sinos, rands, resampled_attns, image, use_gpu)
###########################################################################
# Set up reconstructor
###########################################################################
if args['--reg']=='explicit_TV':
[F, G, K, normK, tau, sigma, use_axpby, prob, gamma] = set_up_explicit_reconstructor(
use_gpu, num_ms, image, acq_models, resamplers, masks, sinos, rands)
else:
[F, G, K, normK, tau, sigma, use_axpby, prob, gamma] = set_up_reconstructor(
use_gpu, num_ms, acq_models, resamplers, masks, sinos, rands)
###########################################################################
# Get output filename
###########################################################################
outp_file = get_output_filename(
attn_files, normK, sigma, tau, sino_files, resamplers, use_gpu)
###########################################################################
# Get algorithm
###########################################################################
algo, num_iter = get_algo(F, G, K, normK, tau, sigma, gamma, use_axpby, prob, outp_file,image)
###########################################################################
# Create save call back function
###########################################################################
save_callback = get_save_callback_function(outp_file, num_iter)
###########################################################################
# Run the reconstruction
###########################################################################
# algo.run(num_iter, verbose=2, print_interval=1, callback=save_callback)
algo.run(num_iter, verbose=2, callback=save_callback)
def get_filenames(trans, sino, attn, rand):
"""Get filenames."""
trans_pattern = str(trans).replace('%', '*')
sino_pattern = str(sino).replace('%', '*')
attn_pattern = str(attn).replace('%', '*')
rand_pattern = str(rand).replace('%', '*')
if sino_pattern is None:
raise AssertionError("--sino missing")
trans_files = sorted(glob(trans_pattern))
sino_files = sorted(glob(sino_pattern))
attn_files = sorted(glob(attn_pattern))
rand_files = sorted(glob(rand_pattern))
num_ms = len(sino_files)
# Check some sinograms found
if num_ms == 0:
raise AssertionError("No sinograms found at {}!".format(sino_pattern))
# Should have as many trans as sinos
if len(trans_files) > 0 and num_ms != len(trans_files):
raise AssertionError("#trans should match #sinos. "
"#sinos = " + str(num_ms) +
", #trans = " + str(len(trans_files)))
# If any rand, check num == num_ms
if len(rand_files) > 0 and len(rand_files) != num_ms:
raise AssertionError("#rand should match #sinos. "
"#sinos = " + str(num_ms) +
", #rand = " + str(len(rand_files)))
# For attn, there should be 0, 1 or num_ms images
if len(attn_files) > 1 and len(attn_files) != num_ms:
raise AssertionError("#attn should be 0, 1 or #sinos")
return [num_ms, trans_files, sino_files, attn_files, rand_files]
def read_files(trans_files, sino_files, attn_files, rand_files, trans_type):
"""Read files."""
if trans_files == []:
trans = None
else:
if trans_type == "tm":
trans = [reg.AffineTransformation(file) for file in trans_files]
elif trans_type == "disp":
trans = [reg.NiftiImageData3DDisplacement(file)
for file in trans_files]
elif trans_type == "def":
trans = [reg.NiftiImageData3DDeformation(file)
for file in trans_files]
else:
raise error("Unknown transformation type")
sinos_raw = [pet.AcquisitionData(file) for file in sino_files]
attns = [pet.ImageData(file) for file in attn_files]
# fix a problem with the header which doesn't allow
# to do algebra with randoms and sinogram
rands_arr = [pet.AcquisitionData(file).as_array() for file in rand_files]
rands_raw = [ s * 0 for s in sinos_raw ]
for r,a in zip(rands_raw, rands_arr):
r.fill(a)
return [trans, sinos_raw, attns, rands_raw]
def pre_process_sinos(sinos_raw, num_ms):
"""Preprocess raw sinograms.
Make positive if necessary and do any required rebinning."""
# If empty (e.g., no randoms), return
if not sinos_raw:
return sinos_raw
# Loop over all sinograms
sinos = [0]*num_ms
for ind in range(num_ms):
# If any sinograms contain negative values
# (shouldn't be the case), set them to 0
sino_arr = sinos_raw[ind].as_array()
if (sino_arr < 0).any():
print("Input sinogram " + str(ind) +
" contains -ve elements. Setting to 0...")
sinos[ind] = sinos_raw[ind].clone()
sino_arr[sino_arr < 0] = 0
sinos[ind].fill(sino_arr)
else:
sinos[ind] = sinos_raw[ind]
# If rebinning is desired
segs_to_combine = 1
if args['--numSegsToCombine']:
segs_to_combine = int(args['--numSegsToCombine'])
views_to_combine = 1
if args['--numViewsToCombine']:
views_to_combine = int(args['--numViewsToCombine'])
if segs_to_combine * views_to_combine > 1:
sinos[ind] = sinos[ind].rebin(segs_to_combine, views_to_combine)
# only print first time
if ind == 0:
print("Rebinned sino dimensions: {sinos[ind].dimensions()}")
return sinos
def get_initial_estimate(sinos, use_gpu):
"""Get initial estimate."""
# from the arguments
initial_estimate = args['--initial']
nxny = int(args['--nxny'])
if initial_estimate:
image = pet.ImageData(initial_estimate)
elif args['--templateAcqData']:
image = sinos[0].create_uniform_image(0., (127, 220, 220))
image.initialise(dim=(127, 220, 220), vsize=(2.03125, 1.7080754, 1.7080754))
else:
# Create image based on ProjData
image = sinos[0].create_uniform_image(0.0, (nxny, nxny))
# If using GPU, need to make sure that image is right size.
if use_gpu:
dim = (127, 320, 320)
spacing = (2.03125, 2.08626, 2.08626)
# elif non-default spacing desired
elif args['--dxdy']:
dim = image.dimensions()
dxdy = float(args['--dxdy'])
spacing = (image.voxel_sizes()[0], dxdy, dxdy)
if use_gpu or args['--dxdy']:
image.initialise(dim=dim,
vsize=spacing)
image.fill(0.0)
return image
def get_resampler(image, ref=None, trans=None):
"""Return a NiftyResample object for the specified transform and image."""
if ref is None:
ref = image
resampler = reg.NiftyResample()
resampler.set_reference_image(ref)
resampler.set_floating_image(image)
resampler.set_padding_value(0)
resampler.set_interpolation_type_to_linear()
if trans is not None:
resampler.add_transformation(trans)
return resampler
def resample_attn_images(num_ms, attns, trans, use_gpu, image):
"""Resample attenuation images if necessary."""
resampled_attns = None
if trans is None:
resampled_attns = attns
else:
if len(attns) > 0:
resampled_attns = [0]*num_ms
# if using GPU, dimensions of attn and recon images have to match
ref = image if use_gpu else None
for i in range(num_ms):
# if we only have 1 attn image, then we need to resample into
# space of each gate. However, if we have num_ms attn images,
# then assume they are already in the correct position, so use
# None as transformation.
tran = trans[i] if len(attns) == 1 else None
# If only 1 attn image, then resample that. If we have num_ms
# attn images, then use each attn image of each frame.
attn = attns[0] if len(attns) == 1 else attns[i]
resam = get_resampler(attn, ref=ref, trans=tran)
resampled_attns[i] = resam.forward(attn)
return resampled_attns
def set_up_acq_models(num_ms, sinos, rands, resampled_attns, image, use_gpu):
"""Set up acquisition models."""
print("Setting up acquisition models...")
# From the arguments
algo = str(args['--algorithm'])
nsub = int(args['--numSubsets']) if args['--numSubsets'] and algo=='spdhg' else 1
norm_file = args['--norm']
verbosity = int(args['--verbosity'])
if not use_gpu:
acq_models = [pet.AcquisitionModelUsingRayTracingMatrix() for k in range(nsub * num_ms)]
else:
acq_models = [pet.AcquisitionModelUsingNiftyPET() for k in range(nsub * num_ms)]
for acq_model in acq_models:
acq_model.set_use_truncation(True)
acq_model.set_cuda_verbosity(verbosity)
acq_model.set_num_tangential_LORs(10)
# create masks
im_one = image.clone().allocate(1.)
masks = []
# If present, create ASM from ECAT8 normalisation data
asm_norm = None
if norm_file:
if not path.isfile(norm_file):
raise error("Norm file not found: " + norm_file)
asm_norm = pet.AcquisitionSensitivityModel(norm_file)
# Loop over each motion state
for ind in range(num_ms):
# Create attn ASM if necessary
asm_attn = None
if resampled_attns:
s = sinos[ind]
ra = resampled_attns[ind]
am = pet.AcquisitionModelUsingRayTracingMatrix()
asm_attn = get_asm_attn(s,ra,am)
# Get ASM dependent on attn and/or norm
asm = None
if asm_norm and asm_attn:
if ind == 0:
print("ASM contains norm and attenuation...")
asm = pet.AcquisitionSensitivityModel(asm_norm, asm_attn)
elif asm_norm:
if ind == 0:
print("ASM contains norm...")
asm = asm_norm
elif asm_attn:
if ind == 0:
print("ASM contains attenuation...")
asm = asm_attn
# Loop over physical subsets
for k in range(nsub):
current = k * num_ms + ind
if asm:
acq_models[current].set_acquisition_sensitivity(asm)
#KT we'll set the background in the KL function below
#KTif len(rands) > 0:
#KT acq_models[ind].set_background_term(rands[ind])
# Set up
acq_models[current].set_up(sinos[ind], image)
acq_models[current].num_subsets = nsub
acq_models[current].subset_num = k
# compute masks
if ind==0:
mask = acq_models[current].direct(im_one)
masks.append(mask)
# rescale by number of gates
if num_ms > 1:
acq_models[current] = ScaledOperator(acq_models[current], 1./num_ms)
return acq_models, masks
def get_asm_attn(sino, attn, acq_model):
"""Get attn ASM from sino, attn image and acq model."""
asm_attn = pet.AcquisitionSensitivityModel(attn, acq_model)
# temporary fix pending attenuation offset fix in STIR:
# converting attenuation into 'bin efficiency'
asm_attn.set_up(sino)
bin_eff = pet.AcquisitionData(sino)
bin_eff.fill(1.0)
asm_attn.unnormalise(bin_eff)
asm_attn = pet.AcquisitionSensitivityModel(bin_eff)
return asm_attn
def set_up_reconstructor(use_gpu, num_ms, acq_models, resamplers, masks, sinos, rands=None):
"""Set up reconstructor."""
# From the arguments
algo = str(args['--algorithm'])
regularizer = str(args['--reg'])
r_iters = int(args['--reg_iters'])
r_alpha = float(args['--alpha'])
nsub = int(args['--numSubsets']) if args['--numSubsets'] and algo=='spdhg' else 1
precond = True if args['--precond'] else False
param_path = str(args['--param_path'])
normalise = True if args['--normaliseDataAndBlock'] else False
gamma = float(args['--gamma'])
output_name = str(args['--outp'])
if not os.path.exists(param_path):
os.makedirs(param_path)
if normalise:
raise error('options {} and regularization={} are not yet implemented together'.format(normalise, regularizer))
# We'll need an additive term (eta). If randoms are present, use them
# Else, use a scaled down version of the sinogram
etas = rands if rands else [sino * 0 + 1e-5 for sino in sinos]
# Create composition operators containing linear
# acquisition models and resamplers,
# and create data fit functions
if nsub == 1:
if resamplers is None:
#KT C = [am.get_linear_acquisition_model() for am in acq_models]
C = [am for am in acq_models]
else:
C = [CompositionOperator(
#KTam.get_linear_acquisition_model(),
am,
res, preallocate=True)
for am, res in zip(*(acq_models, resamplers))]
fi = [KullbackLeibler(b=sino, eta=eta, mask=masks[0].as_array(),use_numba=True)
for sino, eta in zip(sinos, etas)]
else:
C = [am for am in acq_models]
fi = [None] * (num_ms * nsub)
for (k,i) in np.ndindex((nsub,num_ms)):
# resample if needed
if resamplers is not None:
C[k * num_ms + i] = CompositionOperator(
#KTam.get_linear_acquisition_model(),
C[k * num_ms + i],
resamplers[i], preallocate=True)
fi[k * num_ms + i] = KullbackLeibler(b=sinos[i], eta=etas[i], mask=masks[k].as_array(),use_numba=True)
if regularizer == "FGP_TV":
r_tolerance = 1e-7
r_iso = 0
r_nonneg = 1
r_printing = 0
device = 'gpu' if use_gpu else 'cpu'
G = FGP_TV(r_alpha, r_iters, r_tolerance,
r_iso, r_nonneg, r_printing, device)
if precond:
FGP_TV.proximal = precond_proximal
elif regularizer == "None":
G = IndicatorBox(lower=0)
else:
raise error("Unknown regularisation")
F = BlockFunction(*fi)
K = BlockOperator(*C)
if algo == 'spdhg':
prob = [1./ len(K)] * len(K)
else:
prob = None
if not precond:
if algo == 'pdhg':
# we want the norm of the whole physical BlockOp
normK = get_proj_norm(BlockOperator(*C),param_path)
sigma = gamma/normK
tau = 1/(normK*gamma)
elif algo == 'spdhg':
# we want the norm of each component
normK = get_proj_normi(BlockOperator(*C),nsub,param_path)
# we'll let spdhg do its default implementation
sigma = None
tau = None
use_axpby = False
else:
normK=None
if algo == 'pdhg':
tau = K.adjoint(K.range_geometry().allocate(1.))
# CD take care of edge of the FOV
filter = pet.TruncateToCylinderProcessor()
filter.apply(tau)
backproj_np = tau.as_array()
vmax = np.max(backproj_np[backproj_np>0])
backproj_np[backproj_np==0] = 10 * vmax
tau_np = 1/backproj_np
tau.fill(tau_np)
# apply filter second time just to be sure
filter.apply(tau)
tau_np = tau.as_array()
tau_np[tau_np==0] = 1 / (10 * vmax)
elif algo == 'spdhg':
taus_np = []
for (Ki,pi) in zip(K,prob):
tau = Ki.adjoint(Ki.range_geometry().allocate(1.))
# CD take care of edge of the FOV
filter = pet.TruncateToCylinderProcessor()
filter.apply(tau)
backproj_np = tau.as_array()
vmax = np.max(backproj_np[backproj_np>0])
backproj_np[backproj_np==0] = 10 * vmax
tau_np = 1/backproj_np
tau.fill(tau_np)
# apply filter second time just to be sure
filter.apply(tau)
tau_np = tau.as_array()
tau_np[tau_np==0] = 1 / (10 * vmax)
taus_np.append(pi * tau_np)
taus = np.array(taus_np)
tau_np = np.min(taus, axis = 0)
tau.fill(tau_np)
# save
np.save('{}/tau_{}.npy'.format(param_path, output_name), tau_np, allow_pickle=True)
i = 0
sigma = []
xx = K.domain_geometry().allocate(1.)
for Ki in K:
tmp_np = Ki.direct(xx).as_array()
tmp_np[tmp_np==0] = 10 * np.max(tmp_np)
sigmai = Ki.range_geometry().allocate(0.)
sigmai.fill(1/tmp_np)
sigma.append(sigmai)
# save
# np.save('{}/sigma_{}.npy'.format(param_path,i), 1/tmp_np, allow_pickle=True)
i += 1
sigma = BlockDataContainer(*sigma)
# trade-off parameter
sigma *= gamma
tau *= (1/gamma)
use_axpby = False
return [F, G, K, normK, tau, sigma, use_axpby, prob, gamma]
def set_up_explicit_reconstructor(use_gpu, num_ms, image, acq_models, resamplers, masks, sinos, rands=None):
"""Set up reconstructor."""
# From the arguments
algo = str(args['--algorithm'])
r_alpha = float(args['--alpha'])
nsub = int(args['--numSubsets']) if args['--numSubsets'] and algo=='spdhg' else 1
precond = True if args['--precond'] else False
param_path = str(args['--param_path'])
normalise = True if args['--normaliseDataAndBlock'] else False
gamma = float(args['--gamma'])
if precond:
raise error('Options precond and explicit TV are not yet implemented together')
# We'll need an additive term (eta). If randoms are present, use them
# Else, use a scaled down version of the sinogram
etas = rands if rands else [sino * 0 + 1e-5 for sino in sinos]
# Create composition operators containing linear
# acquisition models and resamplers,
# and create data fit functions
if nsub == 1:
if resamplers is None:
#KT C = [am.get_linear_acquisition_model() for am in acq_models]
C = [am for am in acq_models]
else:
C = [CompositionOperator(
#KTam.get_linear_acquisition_model(),
am,
res, preallocate=True)
for am, res in zip(*(acq_models, resamplers))]
fi = [KullbackLeibler(b=sino, eta=eta, mask=masks[0].as_array(),use_numba=True)
for sino, eta in zip(sinos, etas)]
else:
C = [am for am in acq_models]
fi = [None] * (num_ms * nsub)
for (k,i) in np.ndindex((nsub,num_ms)):
# resample if needed
if resamplers is not None:
C[k * num_ms + i] = CompositionOperator(
#KTam.get_linear_acquisition_model(),
C[k * num_ms + i],
resamplers[i], preallocate=True)
fi[k * num_ms + i] = KullbackLeibler(b=sinos[i], eta=etas[i], mask=masks[k].as_array(),use_numba=True)
# define gradient
Grad = GradientOperator(image, backend='c', correlation='SpaceChannel')
normGrad = get_grad_norm(Grad,param_path)
# define data fit
data_fit = MixedL21Norm()
MixedL21Norm.proximal = MixedL21Norm_proximal
if algo == 'pdhg':
# we want the norm of the whole physical BlockOp
normProj = get_proj_norm(BlockOperator(*C),param_path)
if normalise:
C_rs = [ScaledOperator(Ci,1/normProj) for Ci in C]
Grad_rs = ScaledOperator(Grad,1/normGrad)
C_rs.append(Grad_rs)
f_rs = [ScaledFunction(f,normProj)
for f in fi]
f_rs.append(ScaledFunction(data_fit,r_alpha * normGrad))
normK = np.sqrt(2)
else:
C.append(Grad)
fi.append(ScaledFunction(data_fit,r_alpha))
normK = np.sqrt(normProj**2 + normGrad**2)
sigma = gamma/normK
tau = 1/(normK*gamma)
prob = None
elif algo == 'spdhg':
# we want the norm of each component
normProj = get_proj_normi(BlockOperator(*C),nsub,param_path)
if normalise:
C_rs = [ScaledOperator(Ci,1/normProji) for Ci, normProji in zip(C,normProj)]
Grad_rs = ScaledOperator(Grad,1/normGrad)
C_rs.append(Grad_rs)
f_rs = [ScaledFunction(f,normProji)
for f, normProji in zip(fi, normProj)]
f_rs.append(ScaledFunction(data_fit,r_alpha * normGrad))
normK = [1.] * len(C_rs)
prob = [1./(2 * (len(C_rs)-1))] * (len(C_rs)-1) + [1./2]
else:
C.append(Grad)
fi.append(ScaledFunction(data_fit,r_alpha))
normK = normProj + [normGrad]
prob = [1./(2 * (len(C)-1))] * (len(C)-1) + [1./2]
# we'll let spdhg do its default stepsize implementation
sigma = None
tau = None
else:
raise error("algorithm '{}' is not implemented".format(algo))
G = IndicatorBox(lower=0)
if normalise:
F = BlockFunction(*f_rs)
K = BlockOperator(*C_rs)
else:
F = BlockFunction(*fi)
K = BlockOperator(*C)
use_axpby = False
return [F, G, K, normK, tau, sigma, use_axpby, prob, gamma]
def PowerMethod(operator, x_init=None):
'''Power method to calculate iteratively the Lipschitz constant
:param operator: input operator
:type operator: :code:`LinearOperator`
:param iterations: number of iterations to run
:type iteration: int
:param x_init: starting point for the iteration in the operator domain
:returns: tuple with: L, list of L at each iteration, the data the iteration worked on.
'''
# From the arguments
iterations = int(args['--PowerMethod_iters'])
# Initialise random
if x_init is None:
x0 = operator.domain_geometry().allocate('random')
else:
x0 = x_init.copy()
x1 = operator.domain_geometry().allocate()
y_tmp = operator.range_geometry().allocate()
s = []
# Loop
i = 0
while i < iterations:
operator.direct(x0,out=y_tmp)
operator.adjoint(y_tmp,out=x1)
x1norm = x1.norm()
if hasattr(x0, 'squared_norm'):
s.append( x1.dot(x0) / x0.squared_norm() )
else:
x0norm = x0.norm()
s.append( x1.dot(x0) / (x0norm * x0norm) )
x1.multiply((1.0/x1norm), out=x0)
print ("current squared norm: {}".format(s[-1]))
i += 1
return | np.sqrt(s[-1]) | numpy.sqrt |
"""Test tilted backpropagation algorithm"""
import numpy as np
import odtbrain
from common_methods import create_test_sino_3d, create_test_sino_3d_tilted, \
cutout, get_test_parameter_set
def test_3d_backprop_phase_real():
sino, angles = create_test_sino_3d()
parameters = get_test_parameter_set(2)
# reference
rref = list()
for p in parameters:
fref = odtbrain.backpropagate_3d(sino, angles, padval=0,
dtype=np.float64, onlyreal=True, **p)
rref.append(cutout(fref))
dataref = np.array(rref).flatten().view(float)
r = list()
for p in parameters:
f = odtbrain.backpropagate_3d_tilted(sino, angles, padval=0,
dtype=np.float64, onlyreal=True,
**p)
r.append(cutout(f))
data = np.array(r).flatten().view(float)
assert np.allclose(data, dataref)
def test_3d_backprop_pad():
sino, angles = create_test_sino_3d()
parameters = get_test_parameter_set(2)
# reference
rref = list()
for p in parameters:
fref = odtbrain.backpropagate_3d(sino, angles, padval="edge",
dtype=np.float64, onlyreal=False, **p)
rref.append(cutout(fref))
dataref = np.array(rref).flatten().view(float)
r = list()
for p in parameters:
f = odtbrain.backpropagate_3d_tilted(sino, angles, padval="edge",
dtype=np.float64, onlyreal=False,
**p)
r.append(cutout(f))
data = np.array(r).flatten().view(float)
assert np.allclose(data, dataref)
def test_3d_backprop_plane_rotation():
"""
A very soft test to check if planar rotation works fine
in the reconstruction with tilted angles.
"""
parameters = get_test_parameter_set(1)
results = []
# These are specially selected angles that don't give high results.
# Probably due to phase-wrapping, errors >2 may appear. Hence, we
# call it a soft test.
tilts = [1.1, 0.0, 0.234, 2.80922, -.29, 9.87]
for angz in tilts:
sino, angles = create_test_sino_3d_tilted(tilt_plane=angz, A=21)
rotmat = np.array([
[np.cos(angz), -np.sin(angz), 0],
[np.sin(angz), np.cos(angz), 0],
[0, 0, 1],
])
# rotate `tilted_axis` onto the y-z plane.
tilted_axis = np.dot(rotmat, [0, 1, 0])
rref = list()
for p in parameters:
fref = odtbrain.backpropagate_3d_tilted(sino, angles,
padval="edge",
tilted_axis=tilted_axis,
padding=(False, False),
dtype=np.float64,
onlyreal=False,
**p)
rref.append(cutout(fref))
data = np.array(rref).flatten().view(float)
results.append(data)
for ii in np.arange(len(results)):
assert np.allclose(results[ii], results[ii-1], atol=.2, rtol=.2)
def test_3d_backprop_plane_alignment_along_axes():
"""
Tests whether the reconstruction is always aligned with
the rotational axis (and not antiparallel).
"""
parameters = get_test_parameter_set(1)
p = parameters[0]
results = []
# These are specially selected angles that don't give high results.
# Probably due to phase-wrapping, errors >2 may appear. Hence, we
# call it a soft test.
tilts = [0, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi]
for angz in tilts:
sino, angles = create_test_sino_3d_tilted(tilt_plane=angz, A=21)
rotmat = np.array([
[np.cos(angz), -np.sin(angz), 0],
[np.sin(angz), | np.cos(angz) | numpy.cos |
from copy import deepcopy
from functools import reduce
import operator
import numpy as np
import pandas as pd
from pandas.api.types import is_string_dtype
import pandapower as pp
import pandapower.topology as top
from pandapower.grid_equivalents.auxiliary import drop_internal_branch_elements, ensure_origin_id
from pandapower.grid_equivalents.get_equivalent import get_equivalent, \
merge_internal_net_and_equivalent_external_net
try:
import pandaplan.core.pplog as logging
except ImportError:
import logging
try:
from misc.groups import Group
group_imported = True
except ImportError:
group_imported = False
try:
from simbench import voltlvl_idx
simbench_imported = True
except ImportError:
simbench_imported = False
logger = logging.getLogger(__name__)
def getFromDict(dict_, keys):
""" Get value from nested dict """
return reduce(operator.getitem, keys, dict_)
def setInDict(dict_, keys, value):
""" Set value to nested dict """
getFromDict(dict_, keys[:-1])[keys[-1]] = value
def appendSetInDict(dict_, keys, set_):
""" Use case specific: append existing value of type set in nested dict """
getFromDict(dict_, keys[:-1])[keys[-1]] |= set_
def setSetInDict(dict_, keys, set_):
""" Use case specific: set new or append existing value of type set in nested dict """
if isinstance(getFromDict(dict_, keys[:-1]), dict):
if keys[-1] in getFromDict(dict_, keys[:-1]).keys():
if isinstance(getFromDict(dict_, keys), set):
appendSetInDict(dict_, keys, set_)
else:
raise ValueError("The set in the nested dict cannot be appended since it actually "
"is not a set but a " + str(type(getFromDict(dict_, keys))))
else:
setInDict(dict_, keys, set_)
else:
raise ValueError("This function expects a dict for 'getFromDict(dict_, " + str(keys[:-1]) +
")', not a" + str(type(getFromDict(dict_, keys[:-1]))))
def append_set_to_dict(dict_, set_, keys):
""" Appends a nested dict by the values of a set, independant if the keys already exist or not.
"""
keys = pp.ensure_iterability(keys)
# ensure that the dict way to the last key exist
for pos, _ in enumerate(keys[:-1]):
if isinstance(getFromDict(dict_, keys[:pos]), dict):
if keys[pos] not in getFromDict(dict_, keys[:pos]).keys():
setInDict(dict_, keys[:pos + 1], dict())
else:
raise ValueError("This function expects a dict for 'getFromDict(dict_, " +
str(keys[:pos]) + ")', not a" + str(type(getFromDict(
dict_, keys[:pos]))))
# set the value
setSetInDict(dict_, keys, set_)
def eq_name(eq_type, other_zone=None, zone=None, number=None):
number_str = "" if number is None else " %i" % number
st = "%s%s equivalent" % (eq_type, number_str)
if other_zone is not None:
st += " of zone "
if isinstance(other_zone, str):
st += "'%s'" % other_zone
else:
st += str(other_zone)
if zone is not None:
st += " at zone "
if isinstance(zone, str):
st += "'%s'" % zone
else:
st += str(zone)
return st
def set_bus_zone_by_boundary_branches(net, all_boundary_branches):
"""
Set integer values (0, 1, 2, ...) to net.bus.zone with regard to the given boundary branches in
'all_boundary_branches'.
INPUT:
**net** - pandapowerNet
**all_boundary_branches** (dict) - defines which element indices are boundary branches.
The dict keys must be pandapower elements, e.g. "line" or "trafo"
"""
include = dict.fromkeys(["line", "dcline", "trafo", "trafo3w", "impedance"])
for elm in include.keys():
if elm in all_boundary_branches.keys():
include[elm] = net[elm].index.difference(all_boundary_branches[elm])
else:
include[elm] = True
mg = top.create_nxgraph(net, include_lines=include["line"], include_impedances=include["impedance"],
include_dclines=include["dcline"], include_trafos=include["trafo"],
include_trafo3ws=include["trafo3w"])
cc = top.connected_components(mg)
ccl = [list(c) for c in cc]
areas = []
while len(ccl):
# check intersections of the first area with all other unchecked areas (remains in ccl) and
# then add first area unionized with all intersectioned other areas to "areas"
areas += [ccl.pop(0)]
n_last_area = -1
while n_last_area != len(areas[-1]):
# check as long as len(areas[-1]) not changes anymore - needed because there can be
# intersections of remaining areas with the buses added to areas[-1]
# within the last while loop iteration via union
n_last_area = len(areas[-1])
for i, c in enumerate(ccl):
if np.intersect1d(c, areas[-1]):
areas[-1] = np.union1d(areas[-1], ccl.pop(i))
for i, area in enumerate(areas):
net.bus.zone.loc[area] = i
def get_branch_power(net, bus, power_type, branches_dict=None):
"""
Sums power of branches connected to 'bus'. The power is summed negative (= how much power flows
into the bus).
INPUT:
**net** - pandapower net
**bus** (int) - index of the bus whose connected branches power flows are summed
**power_type** (str) - should be "p_mw" or "q_mvar"
OPTIONAL:
**branches_dict** (dict, None) - if given, only branches within 'branches_dict' are
considered for summing the power. An exemplary input is {"line": {0, 1, 2}, "trafo": {1}}.
"""
connected_branches = pp.get_connected_elements_dict(
net, [bus], connected_buses=False, connected_bus_elements=False,
connected_branch_elements=True, connected_other_elements=False)
power = 0
bus_types = ["from_bus", "to_bus", "hv_bus", "lv_bus", "mv_bus"]
for elm, idxs in connected_branches.items():
if branches_dict is not None:
if elm in branches_dict.keys():
idxs = set(branches_dict[elm]).intersection(set(idxs))
else:
continue
for idx in idxs:
for bus_type in bus_types:
if bus_type in net[elm].columns and net[elm][bus_type].at[idx] == bus:
col = power_type[0] + "_" + bus_type.split("_")[0] + power_type[1:]
power -= net["res_" + elm][col].at[idx]
break
return power
def _create_eq_elms(net, buses, elm, branches=None, idx_start=None, sign=1,
name=None, zone=None, other_zone=None, **kwargs):
"""
Internal function of create_eq_loads() or create_eq_gens()
"""
name = name if name is not None else f"equivalent {elm}"
# --- check existing results and return if not available
cols = {"load": ["p_mw", "q_mvar"], "gen": ["p_mw", "vm_pu"]}[elm]
if len(buses - set(net.res_bus.index)) or net.res_bus.loc[
buses, cols].isnull().any().any():
logger.warning(f"No {elm}s could be added to 'net_ib_eq_load' since bus results " +
"are missing.")
return pd.Index()
# --- run functionality
if branches is not None:
branches_has_buses_keys = not len(set(branches.keys()).symmetric_difference(set(buses)))
names = pp.ensure_iterability(name, len(buses))
new_idx = []
for no, (bus, name) in enumerate(zip(buses, names)):
bra = branches if branches is None or not branches_has_buses_keys else branches[bus]
idx = idx_start + no if idx_start is not None else None
p = sign * get_branch_power(net, bus, "p_mw", bra)
if elm == "load":
q = sign * get_branch_power(net, bus, "q_mvar", bra)
new = pp.create_load(net, bus, p, q, name=name, index=idx, **kwargs)
elif elm == "gen":
vm = net.res_bus.vm_pu.at[bus]
new = pp.create_gen(net, bus, p, vm, name=name, index=idx, **kwargs)
else:
raise NotImplementedError(f"elm={elm} is not implemented.")
if "origin_id" in net[elm].columns:
net[elm].origin_id.loc[new] = eq_name(elm, other_zone, zone, number=no)
new_idx.append(new)
return pd.Index(new_idx)
def create_eq_loads(net, buses, branches=None, idx_start=None, sign=1,
name="equivalent load", zone=None, other_zone=None, **kwargs):
"""
Create loads at 'buses' with p and q values equal to sums of p, q power flows over the given
branches.
INPUT:
**net** - pandapower net to be manipulated
**buses** (iterable) - buses at which additional loads should be created
**branches** (dict of (element: set of element indices) or dict of those (with buses as
keys)) - selection of branches to be considered to sum p and q power flows to be set to the
loads. If None, within all branches, all connecting branches must be found and are then
considered for summation.
Example 1: {'trafo': {0, 1, 2}}
Example 2: {1: {'trafo': {0, 1}}, 2: {'trafo': {2}} (if buses is [1, 2])
OPTIONAL:
**idx_start** (int, None) - Starting index for creating the loads. I.e. if 'idx_start' == 3
and len(buses) == 2, then the indices of the created loads will be 3 and 4.
**sign** (1 or -1, 1) - If 1, load get the power which flows out of the branches.
**name** (str or iterable of strings (with length of buses), 'equivalent load') - Value
to be set to the new net.load.name
**zone** (value, None) - This value will be included in net.load.origin_id, if
this column exist
**other_zone** (value, None) - This value will be included in net.load.origin_id, if
this column exist
****kwargs** - key word arguments for pp.create_load(), e.g. in_service=False.
OUTPUT:
new_idx - list of indices of the new loads
"""
return _create_eq_elms(net, buses, "load", branches=branches, idx_start=idx_start, sign=sign,
name=name, zone=zone, other_zone=other_zone, **kwargs)
def create_eq_gens(net, buses, branches=None, idx_start=None, sign=-1,
name="equivalent gen", zone=None, other_zone=None, **kwargs):
""" Same as create_eq_loads """
return _create_eq_elms(net, buses, "gen", branches=branches, idx_start=idx_start, sign=sign,
name=name, zone=zone, other_zone=other_zone, **kwargs)
def split_grid_by_bus_zone(net, boundary_bus_zones=None, eq_type=None, separate_eqs=True,
**kwargs):
"""
INPUT:
**net** - pandapower net - In net.bus.zone different zones must be given.
OPTIONAL:
**boundary_bus_zones** - strings in net.bus.zone which are to be considered as boundary
buses
**eq_type** (str, None) - If given, equivalent elements are added to the boundaries
**separate_eqs** (bool, True) - Flag whether the equivalents (if eq_type is given)
should be calculated by each external zone indivudually
****kwargs** key word arguments such as "only_connected_groups"
OUTPUT:
**nets_ib** - dict of subnets
**boundary_buses** - dict of boundary buses (details at the docstrings of the subfunctions)
A difference between with boundary_bus_zones and without is that the letter does
additionally contain the key "internal".
"""
if net.bus.zone.isnull().any():
raise ValueError("There are NaNs in net.bus.zone")
if boundary_bus_zones is None:
return nets_ib_by_bus_zone_with_boundary_branches(
net, eq_type=eq_type, separate_eqs=separate_eqs, **kwargs)
else:
return split_grid_by_bus_zone_with_boundary_buses(
net, boundary_bus_zones, eq_type=eq_type, separate_eqs=separate_eqs, **kwargs)
def get_boundaries_by_bus_zone_with_boundary_branches(net):
"""
Only in_service branches and closed switches are considered.
INPUT:
**net** - pandapower net - In net.bus.zone different zones must be given.
OUTPUT:
**boundary_buses** - dict of boundary buses - for each zone the internal and external
boundary buses are given as well as the external boundary buses for each other zone.
Furthermore the value of the boundary_buses key "all" concludes all boundary buses of all
zones.
Example:
{"all": {0, 1, 3},
1: {"all": {0, 1, 3},
"external": {3},
"internal": {0, 1},
2: {3}
},
2: {"all": {1, 2, 3, 4},
"external": {0, 1, 4},
"internal": {2, 3},
1: {0, 1},
3: {4}
},
3: {"all": {2, 4},
"external": {2},
"internal": {4},
2: {2}
}
}
**boundary_branches** - dict of branch elements - for each zone a set of the corresponding
boundary boundary branches as well as "all" boundary branches
Example:
{"all": {"line": {0, 1},
"trafo": {0}
},
1: {"line": {0},
"trafo": {0}
},
2: {"line": {0, 1}},
3: {"line": {1}}
}
"""
def append_boundary_buses_externals_per_zone(boundary_buses, boundaries, zone, other_zone_cols):
""" iterate throw all boundaries which matches this_zone and add the other_zone_bus to
boundary_buses """
for idx, ozc in other_zone_cols.iteritems():
other_zone = boundaries[zone_cols].values[idx, ozc]
if isinstance(other_zone, np.generic):
other_zone = other_zone.item()
if zone == other_zone:
continue # this happens if 2 trafo3w connections are in zone
other_zone_bus = boundaries[buses].values[idx, ozc]
append_set_to_dict(boundary_buses, {other_zone_bus}, [zone, other_zone])
if "all" in set(net.bus.zone.values):
raise ValueError("'all' is not a proper zone name.") # all is used later for other purpose
branch_elms = pp.pp_elements(bus=False, bus_elements=False, branch_elements=True,
other_elements=False, res_elements=False)
branch_tuples = pp.element_bus_tuples(bus_elements=False, branch_elements=True,
res_elements=False) | {("switch", "element")}
branch_dict = {branch_elm: [] for branch_elm in branch_elms}
for elm, bus in branch_tuples:
branch_dict[elm] += [bus]
zones = net.bus.zone.unique()
boundary_branches = {zone if net.bus.zone.dtype == object else zone.item():
dict() for zone in zones}
boundary_branches["all"] = dict()
boundary_buses = {zone if net.bus.zone.dtype == object else zone.item():
{"all": set(), "internal": set(), "external": set()} for zone in zones}
boundary_buses["all"] = set()
for elm, buses in branch_dict.items():
idx = net[elm].index[net[elm].in_service] if elm != "switch" else net.switch.index[
(net.switch.et == "b") & net.switch.closed]
boundaries = deepcopy(net[elm][buses].loc[idx]) # copy relevant info from net[elm]
zone_cols = list()
for i, bus_col in enumerate(buses):
# add to which zones the connected buses belong to
boundaries["zone%i" % i] = net.bus.zone.loc[boundaries[bus_col].values].values
zone_cols.append("zone%i" % i)
# compare the zones and conclude if the branches can be boundaries
if i > 0:
boundaries["is_boundary"] |= boundaries["zone%i" % i] != boundaries["zone0"]
else:
boundaries["is_boundary"] = False
# reduce the DataFrame 'boundaries' to those branches which actually are boundaries
boundaries = boundaries.loc[boundaries["is_boundary"],
boundaries.columns.difference(["is_boundary"])]
# determine boundary_branches and boundary_buses
if len(boundaries):
boundary_branches["all"][elm] = set(boundaries.index)
boundary_buses["all"] |= set(boundaries[buses].values.flatten())
for zone in set(boundaries[zone_cols].values.flatten()):
# determine which columns belong to this zone and which not
this_zone_col = np.zeros(boundaries.shape[0]) * np.nan
for i, _ in enumerate(buses):
this_zone_col[boundaries[zone_cols[i]] == zone] = i
this_zone_col = pd.Series(this_zone_col).dropna().astype(int)
other_zone_col1 = pd.Series(np.ones(this_zone_col.shape, dtype=int),
index=this_zone_col.index) - this_zone_col
if len(buses) == 3:
other_zone_col1.loc[other_zone_col1 < 0] = 0
other_zone_col2 = pd.Series(3 * np.ones(this_zone_col.shape, dtype=int),
index=this_zone_col.index) - \
this_zone_col - other_zone_col1
# fill zone dependant values to boundary_branches and boundary_buses
boundary_branches[zone][elm] = set(boundaries.index[this_zone_col.index])
nint = set(boundaries[buses].values[this_zone_col.index, this_zone_col.values])
ext = set(boundaries[buses].values[other_zone_col1.index, other_zone_col1.values])
boundary_buses[zone]["internal"] |= nint
boundary_buses[zone]["external"] |= ext
boundary_buses[zone]["all"] |= ext | nint
if len(buses) == 3:
ext = set(boundaries[buses].values[
other_zone_col2.index, other_zone_col2.values])
boundary_buses[zone]["external"] |= ext
boundary_buses[zone]["all"] |= ext
append_boundary_buses_externals_per_zone(
boundary_buses, boundaries, zone, other_zone_col1)
if len(buses) == 3:
append_boundary_buses_externals_per_zone(
boundary_buses, boundaries, zone, other_zone_col2)
# check for missing zone connections
zones_without_connection = list()
for zone, bra in boundary_branches.items():
if zone != "all" and not bra:
zones_without_connection.append(zone)
if len(zones_without_connection):
logger.warning("These zones have no connections to other zones: " + str(
zones_without_connection))
return boundary_buses, boundary_branches
def nets_ib_by_bus_zone_with_boundary_branches(
net, eq_type=None, separate_eqs=True, duplicated_boundary_bus_elements=True, **kwargs):
"""
INPUT:
**net** - pandapower net - In net.bus.zone different zones must be given.
OPTIONAL:
**eq_type** (str, None) - If given, equivalent elements are added to the boundaries
**separate_eqs** (bool, True) - If True and if eq_type is not None, subnets with
different zones are represented by indivuduals equivalents
**duplicated_boundary_bus_elements** (bool, True) - if True, bus elements at boundary buses
are included in all connected nets_ib. If False, only the first nets_ib includes these bus
elements.
OUTPUT:
**nets_ib** - dict of pandapower nets - the internal grid and boundary grid of each zone
as far as the external boundary buses
**boundary_buses** - dict of boundary buses - for each zone the internal and external
boundary buses are given. Furthermore the value of the boundary_buses key "all" concludes
all boundary buses of all zones
**boundary_branches** - dict of branch elements - for each zone a set of the corresponding
boundary boundary branches as well as "all" boundary branches
"""
eq_type = eq_type if not isinstance(eq_type, str) else eq_type.lower()
if eq_type is not None and eq_type not in ["load", "gen", "rei", "ward", "xward"]:
raise ValueError("eq_type %s is unknown." % str(eq_type))
nets_ib = dict() # internal + boundary: the internal and up to the external boundary buses
# are included
boundary_buses, boundary_branches = get_boundaries_by_bus_zone_with_boundary_branches(net)
# --- define nets_ib with consideration of eq_type (very similar to part of
# split_grid_by_bus_zone_with_boundary_buses())
n_add_elm1 = 1
fully_included_boundary_buses = set()
for zone in boundary_buses.keys():
if zone == "all":
continue
this_zone_buses = set(net.bus.index[net.bus.zone == zone])
# direct calculation of nets_ib and continue
if eq_type in ["rei", "ward", "xward"] and not separate_eqs:
nets_ib[zone] = get_equivalent(
net, eq_type, boundary_buses=boundary_buses[zone]["external"],
internal_buses=this_zone_buses, elm_col=kwargs.get("elm_col", None))
continue
# all other cases comes here: ...
nets_ib[zone] = pp.select_subnet(
net, this_zone_buses.union(boundary_buses[zone]["external"]), include_results=True)
nets_ib[zone]["bus"].sort_index(inplace=True)
if not duplicated_boundary_bus_elements:
bb2dr = fully_included_boundary_buses & boundary_buses[zone]["internal"]
pp.drop_elements_at_buses(nets_ib[zone], bb2dr, branch_elements=False)
fully_included_boundary_buses |= boundary_buses[zone]["internal"]
# drop all elements at external boundary buses
pp.drop_inner_branches(nets_ib[zone], boundary_buses[zone]["external"])
for elm in pp.pp_elements(bus=False, branch_elements=False, other_elements=False):
pp.drop_elements_at_buses(nets_ib[zone], boundary_buses[zone]["external"],
branch_elements=False, drop_measurements=False)
if eq_type is None:
continue
elif eq_type in ["load", "gen"] and not separate_eqs:
create_eq_fct = {"load": create_eq_loads, "gen": create_eq_gens}[eq_type]
eq_elms = create_eq_fct(nets_ib[zone], boundary_buses[zone]["external"],
idx_start=net[eq_type].index.values.max() + n_add_elm1,
zone=zone)
n_add_elm1 += len(eq_elms)
if group_imported:
elm_col = kwargs.get("elm_col", None)
if elm_col is not None:
eq_elms = nets_ib[zone][eq_type][elm_col].loc[eq_elms]
Group(nets_ib[zone], {eq_type: eq_elms}, name=eq_name(eq_type, zone=zone),
elm_col=elm_col)
continue
if not separate_eqs:
logger.error("With separate_eqs is False, this point should not be"
"reached. Hereafter other_zones are iterated")
continue
for other_zone, bb in boundary_buses[zone].items():
if other_zone in ["all", "internal", "external"]:
continue
if eq_type in ["load", "gen"] and separate_eqs:
create_eq_fct = {"load": create_eq_loads, "gen": create_eq_gens}[eq_type]
eq_elms = create_eq_fct(nets_ib[zone], bb,
idx_start=net[eq_type].index.values.max() + n_add_elm1,
zone=zone, other_zone=other_zone)
n_add_elm1 += len(eq_elms)
if group_imported:
elm_col = kwargs.get("elm_col", None)
if elm_col is not None:
eq_elms = nets_ib[zone][eq_type][elm_col].loc[eq_elms]
Group(nets_ib[zone], {eq_type: eq_elms},
name=eq_name(eq_type, other_zone, zone), elm_col=elm_col)
elif eq_type in ["rei", "ward", "xward"] and separate_eqs:
raise NotImplementedError("eq_type '%s' and separate_eqs is %s is not implemented" %
(eq_type, str(separate_eqs)))
else:
raise NotImplementedError("This else should not be reached!")
return nets_ib, boundary_buses, boundary_branches
def split_grid_by_bus_zone_with_boundary_buses(
net, boundary_bus_zones, eq_type=None, separate_eqs=True, only_connected_groups=False,
duplicated_boundary_bus_elements=True, **kwargs):
"""
INPUT:
**net** (pandapower net) - In net.bus.zone different zones must be given.
**boundary_bus_zones** - values in net.bus.zone which are to be considered as boundary
buses
OPTIONAL:
**eq_type** (str, None) - If given, equivalent elements are added to the boundaries
**separate_eqs** (bool, True) - If True and if eq_type is not None, subnets with
different zones are represented by indivuduals equivalents
**only_connected_groups** (bool, False) - if True, an error is raised if buses of the same
zone are not directly connected
**duplicated_boundary_bus_elements** (bool, True) - if True, bus elements at boundary buses
are included in all connected nets_ib. If False, only the first nets_ib includes these bus
elements.
OUTPUT:
**nets_ib** - dict of pandapower nets - the internal grid and boundary grid of each zone
as far as the external boundary buses
**boundary_buses** - dict of boundary buses - for each zone the external (always equal to
all - since no internal boundaries are considered here)
boundary buses are given as well as the external boundary buses for each other zone.
Furthermore the value of the boundary_buses key "all" concludes all boundary buses of all
zones.
Example:
{"all": {0, 1, 3},
1: {"all": {3},
"external": {3},
2: {3}
},
2: {"all": {0, 1, 4},
"external": {0, 1, 4},
1: {0, 1},
3: {4}
},
3: {"all": {2},
"external": {2},
2: {2}
}
}
**boundary_branches** - empty dict
"""
if is_string_dtype(net.bus["zone"]) and "all" in net.bus.zone.values:
raise ValueError("'all' is not a proper zone name.") # all is used later for other purpose
eq_type = eq_type if not isinstance(eq_type, str) else eq_type.lower()
if eq_type is not None and eq_type not in ["load", "gen", "rei", "ward", "xward"]:
raise ValueError("eq_type %s is unknown." % str(eq_type))
boundary_bus_zones = pp.ensure_iterability(boundary_bus_zones)
# initialize boundary_buses and nets_ib (and boundary_branches)
boundary_buses = {"all": set(net.bus.index[net.bus.zone.isin(boundary_bus_zones)])}
boundary_branches = dict()
nets_ib_buses = dict()
nets_ib = dict()
# create topology graphs and bus groups
mg = top.create_nxgraph(net, nogobuses=boundary_buses["all"])
cc = top.connected_components(mg)
# --- check validity + fill nets_ib_buses and boundary_buses
for bus_group in cc:
zones = net.bus.zone.loc[bus_group].unique()
if len(zones) > 1:
raise ValueError("These zones exist in a group of " + str(len(bus_group)) +
" connected bus which should have only one zone: " + str(zones))
else:
zone = zones[0] if net.bus.zone.dtype == object else zones[0].item()
conn_buses = pp.get_connected_buses(net, bus_group)
conn_other_zone_buses = conn_buses - boundary_buses["all"]
# raise if other buses than boundary_buses["all"] are boundaries
if len(conn_other_zone_buses) > 10:
raise ValueError(str(len(conn_other_zone_buses)) + " buses are connected to zone " +
str(zone) + " buses although they are no boundary buses." % zone)
elif len(conn_other_zone_buses) > 0:
raise ValueError("Theses buses are connected to zone " + str(
zone) + " buses although they are no boundary buses: " + str(conn_other_zone_buses))
if zone in boundary_buses.keys(): # buses of this zone has already been considered in
# boundary_buses by another bus_group -> same zone without connection
message = "Zone " + str(zone) + " exist in multiple bus groups. These are the" + \
" zones of the bus groups: " + str(zones)
if only_connected_groups:
raise ValueError(message)
else:
logger.warning(message)
# fill nets_ib_buses
append_set_to_dict(nets_ib_buses, bus_group | conn_buses, [zone])
# fill boundary_buses[zone]["all"] and boundary_buses[zone]["external"] which is the same
append_set_to_dict(boundary_buses, conn_buses, [zone, "all"])
boundary_buses[zone]["external"] = boundary_buses[zone]["all"]
# fill boundary_buses[zone1][zone2]
for zone1 in nets_ib_buses.keys():
for zone2 in nets_ib_buses.keys():
if zone1 == zone2:
continue
overlap = boundary_buses[zone1]["all"] & boundary_buses[zone2]["all"]
if len(overlap):
append_set_to_dict(boundary_buses, overlap, [zone1, zone2])
append_set_to_dict(boundary_buses, overlap, [zone2, zone1])
# --- define nets_ib with consideration of eq_type (very similar to part of
# split_grid_by_bus_zone_with_boundary_branches())
n_add_elm1 = 1
fully_included_boundary_buses = set()
for zone, buses in nets_ib_buses.items():
if eq_type in ["rei", "ward", "xward"] and not separate_eqs:
nets_ib[zone] = get_equivalent(
net, eq_type, boundary_buses=boundary_buses[zone]["all"],
internal_buses=net.bus.index[net.bus.zone == zone],
elm_col=kwargs.get("elm_col", None))
continue
nets_ib[zone] = pp.select_subnet(net, buses, include_results=True)
nets_ib[zone]["bus"].sort_index(inplace=True)
if not duplicated_boundary_bus_elements:
bb2dr = fully_included_boundary_buses & boundary_buses[zone]["all"]
pp.drop_elements_at_buses(nets_ib[zone], bb2dr, branch_elements=False)
fully_included_boundary_buses |= boundary_buses[zone]["all"]
if eq_type is None:
continue
elif eq_type in ["load", "gen"] and not separate_eqs:
create_eq_fct = {"load": create_eq_loads, "gen": create_eq_gens}[eq_type]
eq_elms = create_eq_fct(nets_ib[zone], boundary_buses[zone]["all"],
idx_start=net[eq_type].index.values.max() + n_add_elm1,
zone=zone)
n_add_elm1 += len(eq_elms)
if group_imported:
elm_col = kwargs.get("elm_col", None)
if elm_col is not None:
eq_elms = nets_ib[zone][eq_type][elm_col].loc[eq_elms]
Group(nets_ib[zone], {eq_type: eq_elms}, name=eq_name(eq_type, zone=zone),
elm_col=elm_col)
continue
if not separate_eqs:
logger.error("With separate_eqs is False, this point should not be"
"reached. Hereafter other_zones are iterated")
continue
for other_zone, bb in boundary_buses[zone].items():
if other_zone in ["all", "external", "internal"]:
continue
if eq_type in ["load", "gen"] and separate_eqs:
create_eq_fct = {"load": create_eq_loads, "gen": create_eq_gens}[eq_type]
eq_elms = create_eq_fct(nets_ib[zone], bb,
idx_start=net[eq_type].index.values.max() + n_add_elm1,
zone=zone, other_zone=other_zone)
n_add_elm1 += len(eq_elms)
if group_imported:
elm_col = kwargs.get("elm_col", None)
if elm_col is not None:
eq_elms = nets_ib[zone][eq_type][elm_col].loc[eq_elms]
Group(nets_ib[zone], {eq_type: eq_elms},
name=eq_name(eq_type, other_zone, zone),
elm_col=elm_col)
elif eq_type in ["rei", "ward", "xward"] and separate_eqs:
raise NotImplementedError("eq_type '%s' and separate_eqs is %s is not implemented" %
(eq_type, str(separate_eqs)))
else:
raise NotImplementedError("This else should not be reached!")
return nets_ib, boundary_buses, boundary_branches
def split_grid_by_bus_zone_with_boundary_branches(net, **kwargs):
"""
INPUT:
**net** - pandapower net - In net.bus.zone different zones must be given.
OPTIONAL:
****kwargs** - with_oos_eq_loads (bool)
OUTPUT:
**boundary_buses** - dict of boundary buses - for each zone the internal and external
boundary buses are given. Furthermore the value of the boundary_buses key "all" concludes
all boundary buses of all zones
**boundary_branches** - dict of branch elements - for each zone a set of the corresponding
boundary boundary branches as well as "all" boundary branches
**nets_i** - dict of pandapower nets - the internal grid of each zone as far as the
internal boundary buses
**nets_ib** - dict of pandapower nets - the internal grid and boundary grid of each zone
as far as the external boundary buses
**nets_ib0** - dict of pandapower nets - same as nets_ib but with elements at the external
boundary buses
**nets_ib_eq_load** - dict of pandapower nets - similar to nets_ib but with equivalent
loads at the external boundary buses instead of original elements at the external boundary
buses
**nets_b** - dict of pandapower nets - the boundary grid connected to each zone
"""
if "all" in set(net.bus.zone.values):
raise ValueError("'all' is not a proper zone name.") # all is used later for other purpose
boundary_buses, boundary_branches = get_boundaries_by_bus_zone_with_boundary_branches(net)
nets_i = dict()
nets_ib = dict()
nets_ib0 = dict()
nets_ib_eq_load = dict()
nets_b = dict()
n_add_load1 = 1
n_add_load2 = 1
for zone in boundary_buses.keys():
if zone == "all":
continue
this_zone_buses = set(net.bus.index[net.bus.zone == zone])
# --- get splitted grids
# nets_i (only the internal net, no boundary buses and branches)
nets_i[zone] = pp.select_subnet(net, this_zone_buses, include_results=True)
nets_i[zone]["bus"].sort_index(inplace=True)
if kwargs.get("with_oos_eq_loads", False):
create_eq_loads(nets_i[zone], boundary_buses[zone]["internal"],
idx_start=net.load.index.values.max() + n_add_load2,
zone=zone, in_service=False)
n_add_load2 += (nets_i[zone].load.name == "equivalent load").sum()
# nets_ib (the internal and the boundary branch including the external boundary buses and
# their bus elements)
nets_ib[zone] = pp.select_subnet(
net, this_zone_buses.union(boundary_buses[zone]["external"]), include_results=True)
nets_ib[zone]["bus"].sort_index(inplace=True)
pp.drop_inner_branches(nets_ib[zone], boundary_buses[zone]["external"])
# nets_ib0 (as nets_ib but without the bus elements at the external boundary buses)
nets_ib0[zone] = deepcopy(nets_ib[zone])
pp.drop_elements_at_buses(nets_ib0[zone], boundary_buses[zone]["external"],
branch_elements=False)
# nets_ib_eq_load (as nets_ib0 but with equivalent loads at the external boundary buses)
# -> used in decomp approach
nets_ib_eq_load[zone] = deepcopy(nets_ib0[zone])
create_eq_loads(nets_ib_eq_load[zone], boundary_buses[zone]["external"],
boundary_branches[zone], zone=zone,
idx_start=net.load.index.values.max() + n_add_load1)
n_add_load1 += (nets_ib_eq_load[zone].load.name == "equivalent load").sum()
# nets_b (only the boundary branches)
nets_b[zone] = deepcopy(nets_ib[zone])
full_drop_buses = nets_i[zone].bus.index.difference(boundary_buses["all"])
simple_drop_buses = nets_i[zone].bus.index.intersection(boundary_buses["all"])
pp.drop_buses(nets_b[zone], full_drop_buses, drop_elements=True)
pp.drop_buses(nets_b[zone], simple_drop_buses, drop_elements=False)
drop_internal_branch_elements(nets_b[zone], simple_drop_buses)
pp.drop_elements_at_buses(nets_b[zone], simple_drop_buses, branch_elements=False)
return boundary_buses, boundary_branches, nets_i, nets_ib, nets_ib0, nets_ib_eq_load, nets_b
def get_bus_lookup_by_name(net, bus_lookup_by_name):
return {net.bus.index[net.bus.name == name][0]: idx for name, idx in
bus_lookup_by_name.items() if name in net.bus.name.values}
def dict_sum_value(dict1, dict2):
"""
Return a dict with the sum of values of both input dicts.
"""
output = deepcopy(dict1)
dict2 = deepcopy(dict2)
for key in set(dict2.keys()) & set(output.keys()):
output[key] += dict2[key]
del dict2[key] # to not overwrite the new output values by dict2 in the line
# "output.update(dict2)"
output.update(dict2) # include all values of dict2 which keys are not in dict1
return output
def is_res_table_with_same_idx(net, elm):
return "res_" + elm in net.keys() and \
isinstance(net["res_" + elm], pd.DataFrame) and \
net["res_" + elm].shape[0] == net[elm].shape[0] and \
all(net["res_" + elm].index == net[elm].index)
def _sort_from_to_buses(net, elm, idx):
# determine from and to columns to switch
from_cols = [col for col in net[elm].columns if "from_" in col]
to_cols = [col.replace("from", "to") for col in from_cols]
if elm == "impedance":
ft_cols = [col for col in net[elm].columns if "ft_" in col]
tf_cols = [col.replace("ft_", "tf_") for col in ft_cols]
from_cols += ft_cols
to_cols += tf_cols
# for every column which includes "from_", there must be a counterpart:
assert not set(to_cols) - set(net[elm].columns)
# sort:
net[elm].loc[idx, from_cols + to_cols] = net[elm].loc[idx, to_cols + from_cols].values
def sort_from_to_buses(net, elm):
""" sorts the given element table by from_bus and to_bus columns. """
if net[elm].shape[0]:
cols = ["from_bus", "to_bus"]
assert not set(cols) - set(net[elm].columns)
idx_to_sort = net[elm].index.values[ | np.argsort(net[elm][cols].values, axis=1) | numpy.argsort |
import os
import pandas as pd
import numpy as np
from collections import Counter, defaultdict
def train_from_file(dir_path, leap_limit=15):
file_list = os.listdir(dir_path)
pig_format = [
"id",
"onset",
"offset",
"pitch",
"onsetvel",
"offsetvel",
"hand",
"fingernum",
]
right_init = Counter()
right_transition_count = Counter()
right_emission = defaultdict(Counter)
left_init = Counter()
left_transition_count = Counter()
left_emission = defaultdict(Counter)
for idx, file in enumerate(file_list):
path = dir_path + "/" + file
data_size = len(file_list)
print(f"Processing: {path} ({idx + 1}/{data_size})")
data = pd.read_csv(path, sep="\t", header=0, names=pig_format)
if data.fingernum.dtype == object:
data.fingernum = data.fingernum.apply(
lambda x: x.split("_")[0]
).astype("int")
left_hand = data[data.fingernum < 0]
right_hand = data[data.fingernum > 0]
init, transition, emission = count_fingering(
right_hand, limit=leap_limit
)
right_init += init
right_transition_count += transition
for k, counter in emission.items():
right_emission[k].update(counter)
init, transition, emission = count_fingering(
left_hand, limit=leap_limit
)
left_init += init
left_transition_count += transition
for k, counter in emission.items():
left_emission[k].update(counter)
return (right_init, right_transition_count, right_emission, left_init, left_transition_count, left_emission)
def pitch_to_key(pitch: str):
posx = {"C": 0, "D": 1, "E": 2, "F": 3, "G": 4, "A": 5, "B": 6}[pitch[0]]
posy = 0
if pitch[1].isdigit():
posx += (int(pitch[1]) - 4) * 7
elif pitch[1] == "#":
if pitch[2] == "#":
posx += (int(pitch[3]) - 4) * 7 + 1
else:
posy = 1
posx += (int(pitch[2]) - 4) * 7
elif pitch[1] == "b" or pitch[1] == "-":
if pitch[2] == "b" or pitch[2] == "-":
posx += (int(pitch[3]) - 4) * 7
else:
posy = 1
posx += (int(pitch[2]) - 4) * 7 - 1
return (posx, posy)
def note_to_diff(fingering_data, limit=15):
pos_x, pos_y = zip(*fingering_data.pitch.map(pitch_to_key))
series_x = pd.Series(pos_x)
series_y = pd.Series(pos_y)
diffs = list(
zip(
series_x.diff()
.fillna(0, downcast="infer")
.apply(lambda x: limit if x > limit else x)
.apply(lambda x: -limit if x < -limit else x),
series_y.diff().fillna(0, downcast="infer"),
)
)
return diffs
def count_fingering(fingering_data, limit=15):
hidden_state = list(
zip(
fingering_data.fingernum.shift(fill_value=0),
fingering_data.fingernum,
)
)
pos_x, pos_y = zip(*fingering_data.pitch.map(pitch_to_key))
model = pd.DataFrame(
{"hidden_state": hidden_state, "pos_x": pos_x, "pos_y": pos_y}
)
model["pos_diff"] = list(
zip(
model.pos_x.diff()
.fillna(0, downcast="infer")
.apply(lambda x: limit if x > limit else x)
.apply(lambda x: -limit if x < -limit else x),
model.pos_y.diff().fillna(0, downcast="infer"),
)
)
# First observation only
init = Counter([model.hidden_state[0][1]])
# Without first observation
transition = Counter(model.hidden_state[1:])
# Emission
emission = {
state: Counter(model[model.hidden_state == state].pos_diff)
for state in set(model.hidden_state[1:])
}
return (init, transition, Counter(emission))
def normalize(v):
return v / v.sum(axis=0)
def init_count_to_prob(init_count):
init_prob = np.zeros(5)
for key, value in init_count.items():
if key < 0:
init_prob[-key - 1] = value
else:
init_prob[key - 1] = value
return normalize(init_prob)
def transition_count_to_prob(transition_count):
transition_prob = np.zeros((5, 5))
for key, value in transition_count.items():
if key[0] < 0 and key[1] < 0:
transition_prob[-key[0] - 1, -key[1] - 1] = value
else:
transition_prob[key[0] - 1, key[1] - 1] = value
return np.apply_along_axis(normalize, axis=1, arr=transition_prob)
def series_to_matrix(emission_prob):
out_prob = np.zeros((5, 5))
for key, value in emission_prob.items():
if key[0] < 0 and key[1] < 0:
out_prob[-key[0] - 1, -key[1] - 1] = value
else:
out_prob[key[0] - 1, key[1] - 1] = value
return out_prob
def emission_count_to_prob(emission_count):
prob_df = (
pd.DataFrame.from_dict(emission_count).fillna(0, downcast="infer") + 1
).apply(normalize, axis=0)
prob_dict = {
out: series_to_matrix(prob_df.loc[out]) for out in prob_df.index
}
return prob_dict
def decoding(init_prob, transition, out_prob, observations, hand):
n_state = len(init_prob)
obs_len = len(observations)
delta = np.zeros((n_state, obs_len + 1))
psi = np.zeros((n_state, obs_len), dtype=int)
delta[:, 0] = np.log(init_prob)
for i, (pitch, time) in enumerate(
zip(observations.pitch_diff, observations.time_diff)
):
delta_mat = np.tile(delta[:, i], (n_state, 1)).transpose()
prod = delta_mat + np.log(transition) + np.log(out_prob[pitch])
if time < 0.03:
if hand == "R":
if pitch[0] > 0:
prod[ | np.tril_indices(n_state) | numpy.tril_indices |
import numpy as np
import os
import glob
import cv2
import geoio
import tifffile as tiff
flood_map_dir = "D:\\Workspace\\results\\pisar\\scences\\flood_mask_post"
geo_dir = "D:\\Workspace\\data\\raw\\pi-sar2\\20110312\\tiff_all"
dem_path = "D:\\Workspace\\data\\raw\\pi-sar2\\20110312\\dem.tif"
save_dir = "D:\\Workspace\\results\\pisar\\scences\\dem"
dem_img = geoio.GeoImage(dem_path)
dem_data = dem_img.get_data() # (bands, rows, cols)
for filepath in glob.glob(os.path.join(flood_map_dir, "*.png")):
basename = os.path.basename(filepath).split(".")[0]
flood_img = cv2.imread(filepath, 0)
flood_dem_img = np.zeros(flood_img.shape + (1,))
geo_path = os.path.join(geo_dir, "%s_sc.tif" % basename)
geo_img = geoio.GeoImage(geo_path)
y = | np.arange(flood_img.shape[0]) | numpy.arange |
from scipy import misc
import os
import time
import numpy as np
import tensorflow as tf
import random
import matplotlib.pyplot as plt
import matplotlib as mp
# --------------------------------------------------
# setup
def weight_variable(shape):
'''
Initialize weights
:param shape: shape of weights, e.g. [w, h ,Cin, Cout] where
w: width of the filters
h: height of the filters
Cin: the number of the channels of the filters
Cout: the number of filters
:return: a tensor variable for weights with initial values
'''
# IMPLEMENT YOUR WEIGHT_VARIABLE HERE
initial = tf.truncated_normal(shape, stddev=0.1)
W = tf.Variable(initial, name="W")
return W
def bias_variable(shape):
'''
Initialize biases
:param shape: shape of biases, e.g. [Cout] where
Cout: the number of filters
:return: a tensor variable for biases with initial values
'''
# IMPLEMENT YOUR BIAS_VARIABLE HERE
initial = tf.constant(0.1, shape=shape)
b = tf.Variable(initial, name="b")
return b
def conv2d(x, W):
'''
Perform 2-D convolution
:param x: input tensor of size [N, W, H, Cin] where
N: the number of images
W: width of images
H: height of images
Cin: the number of channels of images
:param W: weight tensor [w, h, Cin, Cout]
w: width of the filters
h: height of the filters
Cin: the number of the channels of the filters = the number of channels of images
Cout: the number of filters
:return: a tensor of features extracted by the filters, a.k.a. the results after convolution
'''
# IMPLEMENT YOUR CONV2D HERE
h_conv = tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
return h_conv
def max_pool_2x2(x):
'''
Perform non-overlapping 2-D maxpooling on 2x2 regions in the input data
:param x: input data
:return: the results of maxpooling (max-marginalized + downsampling)
'''
# IMPLEMENT YOUR MAX_POOL_2X2 HERE
h_max = tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1], padding='SAME')
return h_max
ntrain = 1000 # per class
ntest = 100 # per class
nclass = 10 # number of classes
imsize = 28
nchannels = 1
batchsize = 100
# Load training and test images
Train = | np.zeros((ntrain*nclass,imsize,imsize,nchannels)) | numpy.zeros |
import gym
import jax
import jax.numpy as jnp
import haiku as hk
import numpy as np
from tqdm.auto import trange
from collections import deque
from haiku_baselines.common.base_classes import TensorboardWriter, save, restore, select_optimizer
#from haiku_baselines.common.buffers import ReplayBuffer, PrioritizedReplayBuffer, EpisodicReplayBuffer, PrioritizedEpisodicReplayBuffer
from haiku_baselines.common.cpprb_buffers import ReplayBuffer, PrioritizedReplayBuffer
from haiku_baselines.common.utils import convert_states
from haiku_baselines.common.worker import gymMultiworker
from mlagents_envs.environment import UnityEnvironment, ActionTuple
class Deteministic_Policy_Gradient_Family(object):
def __init__(self, env, gamma=0.995, learning_rate=5e-5, buffer_size=50000, train_freq=1, gradient_steps=1, batch_size=32,
n_step = 1, learning_starts=1000, target_network_update_tau=5e-4, prioritized_replay=False,
prioritized_replay_alpha=0.6, prioritized_replay_beta0=0.4, prioritized_replay_eps=1e-6,
log_interval=200, tensorboard_log=None, _init_setup_model=True, policy_kwargs=None,
full_tensorboard_log=False, seed=None, optimizer = 'adamw'):
self.env = env
self.log_interval = log_interval
self.policy_kwargs = policy_kwargs
self.seed = 42 if seed is None else seed
self.key_seq = hk.PRNGSequence(self.seed)
self.learning_starts = learning_starts
self.train_freq = train_freq
self.gradient_steps = gradient_steps
self.prioritized_replay = prioritized_replay
self.prioritized_replay_eps = prioritized_replay_eps
self.batch_size = batch_size
self.target_network_update_tau = target_network_update_tau
self.prioritized_replay_alpha = prioritized_replay_alpha
self.prioritized_replay_beta0 = prioritized_replay_beta0
self.buffer_size = buffer_size
self.learning_rate = learning_rate
self.gamma = gamma
self._gamma = self.gamma**n_step #n_step gamma
self.tensorboard_log = tensorboard_log
self.full_tensorboard_log = full_tensorboard_log
self.n_step_method = (n_step > 1)
self.n_step = n_step
self.params = None
self.target_params = None
self.save_path = None
self.optimizer = select_optimizer(optimizer,self.learning_rate,1e-2/self.batch_size)
self.get_env_setup()
self.get_memory_setup()
def save_params(self, path):
save(path, self.params)
def load_params(self, path):
self.params = self.target_params = restore(path)
def get_env_setup(self):
print("----------------------env------------------------")
if isinstance(self.env,UnityEnvironment):
print("unity-ml agent environmet")
self.env.reset()
group_name = list(self.env.behavior_specs.keys())[0]
group_spec = self.env.behavior_specs[group_name]
self.env.step()
dec, term = self.env.get_steps(group_name)
self.group_name = group_name
self.observation_space = [list(spec.shape) for spec in group_spec.observation_specs]
self.action_size = [group_spec.action_spec.continuous_size]
self.worker_size = len(dec.agent_id)
self.env_type = "unity"
elif isinstance(self.env,gym.Env) or isinstance(self.env,gym.Wrapper):
print("openai gym environmet")
action_space = self.env.action_space
observation_space = self.env.observation_space
self.observation_space = [list(observation_space.shape)]
self.action_size = [action_space.shape[0]]
self.worker_size = 1
self.env_type = "gym"
elif isinstance(self.env,gymMultiworker):
print("gymMultiworker")
env_info = self.env.env_info
self.observation_space = [list(env_info['observation_space'].shape)]
self.action_size = [env_info['action_space'].n]
self.worker_size = self.env.worker_num
self.env_type = "gymMultiworker"
print("observation size : ", self.observation_space)
print("action size : ", self.action_size)
print("worker_size : ", self.worker_size)
print("-------------------------------------------------")
def get_memory_setup(self):
'''
if self.prioritized_replay:
if self.n_step_method:
self.replay_buffer = PrioritizedEpisodicReplayBuffer(self.buffer_size,self.observation_space, self.worker_size, self.action_size[0],
self.n_step, self.gamma, self.prioritized_replay_alpha)
else:
self.replay_buffer = PrioritizedReplayBuffer(self.buffer_size,self.observation_space, self.worker_size, self.action_size[0],
self.prioritized_replay_alpha)
else:
if self.n_step_method:
self.replay_buffer = EpisodicReplayBuffer(self.buffer_size,self.observation_space, self.worker_size, self.action_size[0], self.n_step, self.gamma)
else:
self.replay_buffer = ReplayBuffer(self.buffer_size,self.observation_space, self.worker_size, self.action_size[0])
'''
if not self.prioritized_replay:
self.replay_buffer = ReplayBuffer(self.buffer_size,self.observation_space, self.worker_size, self.action_size, self.n_step, self.gamma)
else:
self.replay_buffer = PrioritizedReplayBuffer(self.buffer_size,self.observation_space,self.prioritized_replay_alpha, self.worker_size, self.action_size, self.n_step, self.gamma)
def setup_model(self):
pass
def _train_step(self, steps):
pass
def _get_actions(self, params, obses) -> np.ndarray:
pass
def actions(self,obs,steps):
pass
def learn(self, total_timesteps, callback=None, log_interval=1000, tb_log_name="Q_network",
reset_num_timesteps=True, replay_wrapper=None):
if self.n_step_method:
tb_log_name = "{}Step_".format(self.n_step) + tb_log_name
if self.prioritized_replay:
tb_log_name = tb_log_name + "+PER"
pbar = trange(total_timesteps, miniters=log_interval)
with TensorboardWriter(self.tensorboard_log, tb_log_name) as (self.summary, self.save_path):
if self.env_type == "unity":
self.learn_unity(pbar, callback, log_interval)
if self.env_type == "gym":
self.learn_gym(pbar, callback, log_interval)
if self.env_type == "gymMultiworker":
self.learn_gymMultiworker(pbar, callback, log_interval)
self.save_params(self.save_path)
def discription(self):
return "score : {:.3f}, loss : {:.3f} |".format(
np.mean(self.scoreque),np.mean(self.lossque)
)
def learn_unity(self, pbar, callback=None, log_interval=100):
self.env.reset()
self.env.step()
dec, term = self.env.get_steps(self.group_name)
self.scores = np.zeros([self.worker_size])
self.eplen = np.zeros([self.worker_size])
self.scoreque = deque(maxlen=10)
self.lossque = deque(maxlen=10)
obses = convert_states(dec.obs)
for steps in pbar:
self.eplen += 1
actions = self.actions(obses,steps)
action_tuple = ActionTuple(continuous=actions)
old_obses = obses
self.env.set_actions(self.group_name, action_tuple)
self.env.step()
if steps > self.learning_starts and steps % self.train_freq == 0: #train in step the environments
loss = self.train_step(steps,self.gradient_steps)
self.lossque.append(loss)
dec, term = self.env.get_steps(self.group_name)
term_ids = list(term.agent_id)
term_obses = convert_states(term.obs)
term_rewards = list(term.reward)
term_done = list(term.interrupted)
while len(dec) == 0:
self.env.step()
dec, term = self.env.get_steps(self.group_name)
if len(term.agent_id) > 0:
term_ids += list(term.agent_id)
newterm_obs = convert_states(term.obs)
term_obses = [ | np.concatenate((to,o),axis=0) | numpy.concatenate |
import matplotlib.pyplot as plt
import numpy as np
import pyfftw
import scipy.signal as sg
from PIL import Image, ImageDraw
from litho.config import PATH
from litho.gdsii.library import Library
class Mask:
"""
Binary Mask
Args:
x/ymax: for the computing area
x/y_gridsize: the simulated size of the area. Different value are supported. 2nm
CD: used for method poly2mask, 45nm
.. plot::
:include-source:
import matplotlib.pyplot as plt
from litho.config import PATH
from litho.mask import Mask
m = Mask()
m.x_range = [-300.0, 300.0]
m.y_range = [-300.0, 300.0]
m.x_gridsize = 10
m.y_gridsize = 10
m.openGDS(PATH.gdsdir / "AND2_X4.gds", 10)
m.maskfft()
m.smooth()
plt.imshow(
m.data,
extent=(m.x_range[0], m.x_range[1], m.y_range[0], m.y_range[1]),
cmap="hot",
interpolation="none",
)
plt.figure()
plt.imshow(
m.sdata,
extent=(m.x_range[0], m.x_range[1], m.y_range[0], m.y_range[1]),
cmap="hot",
interpolation="none",
)
plt.show()
"""
def __init__(self, xmax=500, ymax=500, x_gridsize=1, y_gridsize=1, CD=45):
self.x_range = [-xmax, xmax] # nm
self.y_range = [-ymax, ymax]
self.x_gridsize = x_gridsize # nm
self.y_gridsize = y_gridsize
self.CD = CD
def poly2mask(self):
"""Get Pixel-based Mask Image from Polygon Data
The Poylgon Data Form are sensitive
Similar to poly2mask in Matlab
"""
self.x_gridnum = int((self.x_range[1] - self.x_range[0]) / self.x_gridsize)
self.y_gridnum = int((self.y_range[1] - self.y_range[0]) / self.y_gridsize)
img = Image.new("L", (self.x_gridnum, self.y_gridnum), 0)
self.perimeter = 0.0
for ii in self.polygons:
pp = np.array(ii) * self.CD # polygon
polygonlen = len(pp)
self.perimeter += np.sum(np.abs(pp[0:-1] - pp[1:polygonlen]))
pp[:, 0] = (pp[:, 0] - self.x_range[0]) / self.x_gridsize
pp[:, 1] = (pp[:, 1] - self.y_range[0]) / self.y_gridsize
vetex_list = list(pp)
polygon = [tuple(y) for y in vetex_list]
ImageDraw.Draw(img).polygon(polygon, outline=1, fill=1)
self.data = np.array(img)
self.data = np.float64(self.data)
self.spat_part = pyfftw.empty_aligned(
(self.y_gridnum, self.x_gridnum), dtype="complex128"
)
self.freq_part = pyfftw.empty_aligned(
(self.y_gridnum, self.x_gridnum), dtype="complex128"
)
self.fft_mask = pyfftw.FFTW(self.spat_part, self.freq_part, axes=(0, 1))
def openGDS(
self, gdsdir, layername, boundary=0.16, pixels_per_um=10, with_fft=False
):
with open(gdsdir, "rb") as stream:
lib = Library.load(stream)
a = lib.pop(0)
b = []
xmin = []
xmax = []
ymin = []
ymax = []
for ii in range(0, len(a)):
if a[ii].layer == layername:
# if hasattr(a[ii],'data_type'):
if len(a[ii].xy) > 1:
aa = np.array(a[ii].xy) / 1000 * pixels_per_um
b.append(aa)
xmin.append(min([k for k, v in aa]))
xmax.append(max([k for k, v in aa]))
ymin.append(min([v for k, v in aa]))
ymax.append(max([v for k, v in aa]))
self.polylist = b
xmin = min(xmin)
xmax = max(xmax)
ymin = min(ymin)
ymax = max(ymax)
self.xmin = xmin - boundary * (xmax - xmin)
self.xmax = xmax + boundary * (xmax - xmin)
self.ymin = ymin - boundary * (ymax - ymin)
self.ymax = ymax + boundary * (ymax - ymin)
self.x_range = [self.xmin, self.xmax]
self.y_range = [self.ymin, self.ymax]
self.x_gridnum = int((self.xmax - self.xmin) / self.x_gridsize)
self.y_gridnum = int((self.ymax - self.ymin) / self.y_gridsize)
img = Image.new("L", (self.x_gridnum, self.y_gridnum), 0)
self.perimeter = 0.0
for ii in self.polylist:
pp = np.array(ii) # polygon
polygonlen = len(pp)
self.perimeter += np.sum(np.abs(pp[0:-1] - pp[1:polygonlen]))
pp[:, 0] = (pp[:, 0] - self.xmin) / self.x_gridsize
pp[:, 1] = (pp[:, 1] - self.ymin) / self.y_gridsize
vetex_list = list(pp)
polygon = [tuple(y) for y in vetex_list]
ImageDraw.Draw(img).polygon(polygon, outline=1, fill=1)
self.perimeter += np.sum(np.abs(pp[0:-1] - pp[1:polygonlen]))
self.data = np.array(img)
# Fourier transform pair, pyfftw syntax
self.spat_part = pyfftw.empty_aligned(
(self.y_gridnum, self.x_gridnum), dtype="complex128"
)
self.freq_part = pyfftw.empty_aligned(
(self.y_gridnum, self.x_gridnum), dtype="complex128"
)
self.fft_mask = pyfftw.FFTW(self.spat_part, self.freq_part, axes=(0, 1))
# use the fftw packages
def maskfft(self):
self.spat_part[:] = np.fft.ifftshift(self.data)
self.fft_mask()
self.fdata = np.fft.fftshift(self.freq_part)
def maskfftold(self):
self.fdata = np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(self.data)))
def smooth(self):
xx = | np.linspace(-1, 1, 21) | numpy.linspace |
"""Construction of nodes and weights for integration."""
import functools
import itertools
from typing import Iterable, List, Optional, Tuple
import numpy as np
import scipy.special
import scipy.stats
from ..utilities.basics import Array, Options, StringRepresentation, format_options
class Integration(StringRepresentation):
r"""Configuration for building integration nodes and weights.
Parameters
----------
specification : `str`
How to build nodes and weights. One of the following:
- ``'monte_carlo'`` - Draw from a pseudo-random standard multivariate normal distribution. Integration
weights are ``1 / size``. The ``seed`` field of ``options`` can be used to seed the random number
generator.
- ``'halton'`` - Generate nodes according to the Halton. Different primes (2, 3, 5, etc.) are used for
different dimensions. Integration weights are ``1 / size``. By default, the first ``100`` values in each
dimension are discarded to eliminate correlation between dimensions. The ``discard`` field of ``options``
can be used to increase this number.
- ``'lhs'`` - Generate nodes according to Latin Hypercube Sampling (LHS). Integration weights are
``1 / size``. The ``seed`` field of ``options`` can be used to seed the random number generator.
- ``'mlhs'`` - Generate nodes according to Modified Latin Hypercube Sampling (MLHS) described by
:ref:`references:Hess, Train, and Polak (2004)`. Integration weights are ``1 / size``. The ``seed`` field
of ``options`` can be used to seed the random number generator.
- ``'product'`` - Generate nodes and weights according to the level-``size`` Gauss-Hermite product rule.
- ``'nested_product'`` - Generate nodes and weights according to the level-``size`` nested Gauss-Hermite
product rule. Weights can be negative.
- ``'grid'`` - Generate a sparse grid of nodes and weights according to the level-``size`` Gauss-Hermite
quadrature rule. Weights can be negative.
- ``'nested_grid'`` - Generate a sparse grid of nodes and weights according to the level ``size`` nested
Gauss-Hermite quadrature rule. Weights can be negative.
Best practice for low dimensions is probably to use ``'product'`` to a relatively high degree of polynomial
accuracy. In higher dimensions, ``'grid'`` appears to scale the best. For more information, see
:ref:`references:Judd and Skrainka (2011)` and :ref:`references:Conlon and Gortmaker (2019)`.
Sparse grids are constructed in analogously to the Matlab function `nwspgr <http://www.sparse-grids.de/>`_
created by <NAME> and <NAME>. For more information, see
:ref:`references:Heiss and Winschel (2008)`.
size : `int`
The number of draws if ``specification`` is ``'monte_carlo'``, ``'lhs'``, or ``'mlhs'``, and the level of the
quadrature rule otherwise.
specification_options : `dict, optional`
Options for the integration specification. The ``'monte_carlo'``, ``'lhs'``, and ``'mlhs'`` specifications
support the following option:
- **seed** : (`int`) - Passed to :class:`numpy.random.mtrand.RandomState` to seed the random number
generator before building integration nodes. By default, a seed is not passed to the random number
generator.
The ``'halton'`` specification supports the following option:
- **discard** : (`int`) - How many values at the beginning of each dimension's Halton sequence to discard.
Discarding values at the start of each dimension's sequence is the simplest way to eliminate correlation
between dimensions. By default, the first ``100`` values in each dimension are discarded.
Examples
--------
.. raw:: latex
\begin{examplenotebook}
.. toctree::
/_notebooks/api/integration.ipynb
.. raw:: latex
\end{examplenotebook}
"""
_size: int
_seed: Optional[int]
_description: str
_builder: functools.partial
_specification_options: Options
def __init__(self, specification: str, size: int, specification_options: Optional[Options] = None) -> None:
"""Validate the specification and identify the builder."""
specifications = {
'monte_carlo': (functools.partial(monte_carlo), "with Monte Carlo simulation"),
'halton': (functools.partial(halton), "with Halton sequences"),
'lhs': (functools.partial(lhs), "with Latin Hypercube Sampling (LHS)"),
'mlhs': (functools.partial(lhs, modified=True), "with Modified Latin Hypercube Sampling (MLHS)"),
'product': (functools.partial(product_rule), f"according to the level-{size} Gauss-Hermite product rule"),
'grid': (
functools.partial(sparse_grid),
f"in a sparse grid according to the level-{size} Gauss-Hermite rule"
),
'nested_product': (
functools.partial(product_rule, nested=True),
f"according to the level-{size} nested Gauss-Hermite product rule"
),
'nested_grid': (
functools.partial(sparse_grid, nested=True),
f"in a sparse grid according to the level-{size} nested Gauss-Hermite rule"
)
}
# validate the configuration
if specification not in specifications:
raise ValueError(f"specification must be one of {list(specifications.keys())}.")
if not isinstance(size, int) or size < 1:
raise ValueError("size must be a positive integer.")
if specification_options is not None and not isinstance(specification_options, dict):
raise ValueError("specification_options must be None or a dict.")
# initialize class attributes
self._size = size
self._specification = specification
self._builder, self._description = specifications[specification]
# set default options
self._specification_options: Options = {}
if specification == 'halton':
self._specification_options['discard'] = 100
# update and validate options
self._specification_options.update(specification_options or {})
if specification in {'monte_carlo', 'lhs', 'mlhs'}:
if not isinstance(self._specification_options.get('seed', 0), int):
raise ValueError("The specification option seed must be an integer.")
elif specification == 'halton':
discard = self._specification_options['discard']
if not isinstance(discard, int) or discard < 0:
raise ValueError("The specification option discard must be a nonnegative integer.")
def __str__(self) -> str:
"""Format the configuration as a string."""
return (
f"Configured to construct nodes and weights {self._description} with options "
f"{format_options(self._specification_options)}."
)
def _build_many(self, dimensions: int, ids: Iterable) -> Tuple[Array, Array, Array]:
"""Build concatenated IDs, nodes, and weights for each ID."""
builder = self._builder
if self._specification in {'monte_carlo', 'lhs', 'mlhs'}:
builder = functools.partial(builder, state=np.random.RandomState(self._specification_options.get('seed')))
count = 0
ids_list: List[Array] = []
nodes_list: List[Array] = []
weights_list: List[Array] = []
for i in ids:
if self._specification == 'halton':
nodes, weights = builder(dimensions, self._size, start=self._specification_options['discard'] + count)
else:
nodes, weights = builder(dimensions, self._size)
ids_list.append(np.repeat(i, weights.size))
nodes_list.append(nodes)
weights_list.append(weights)
count += weights.size
return np.concatenate(ids_list), np.concatenate(nodes_list), np.concatenate(weights_list)
def _build(self, dimensions: int) -> Tuple[Array, Array]:
"""Build nodes and weights."""
builder = self._builder
if self._specification in {'monte_carlo', 'lhs', 'mlhs'}:
builder = functools.partial(builder, state=np.random.RandomState(self._specification_options.get('seed')))
if self._specification == 'halton':
return builder(dimensions, self._size, start=self._specification_options['discard'])
return builder(dimensions, self._size)
def monte_carlo(dimensions: int, size: int, state: np.random.RandomState) -> Tuple[Array, Array]:
"""Draw from a pseudo-random standard multivariate normal distribution."""
nodes = state.normal(size=(size, dimensions))
weights = np.repeat(1 / size, size)
return nodes, weights
def halton(dimensions: int, size: int, start: int) -> Tuple[Array, Array]:
"""Generate nodes and weights for integration according to the Halton sequence."""
# generate Halton sequences
sequences = np.zeros((size, dimensions))
for dimension in range(dimensions):
base = get_prime(dimension)
for index in range(size):
value = 0.0
denominator = 1.0
quotient = start + index
while quotient > 0:
quotient, remainder = divmod(quotient, base)
denominator *= base
value += remainder / denominator
sequences[index, dimension] = value
# transform the sequences and construct weights
nodes = scipy.stats.norm().ppf(sequences)
weights = | np.repeat(1 / size, size) | numpy.repeat |
import pytest
import numpy as np
from numpy.testing import assert_almost_equal, assert_warns, assert_raises
from ...sims import linear
from .. import RV
class TestRVStat:
@pytest.mark.parametrize("n", [10, 100, 1000])
@pytest.mark.parametrize("obs_stat", [1.0])
@pytest.mark.parametrize("obs_pvalue", [1 / 1000])
def test_linear_oned(self, n, obs_stat, obs_pvalue):
np.random.seed(123456789)
x, y = linear(n, 1)
stat, pvalue = RV().test(x, y)
assert_almost_equal(stat, obs_stat, decimal=2)
assert_almost_equal(pvalue, obs_pvalue, decimal=2)
class TestRVErrorWarn:
"""Tests errors and warnings derived from MGC."""
def test_error_notndarray(self):
# raises error if x or y is not a ndarray
x = | np.arange(20) | numpy.arange |
import torch
import numpy as np
from torchvision import transforms
from PIL import Image
from utils.resize import ResizeTool
class Rescale:
def __init__(self, output_size):
self.output_size = output_size
def __resize_with_pad(self, image, label):
resized_image, ratio, top, bottom, left, right = ResizeTool.resize_image(image, self.output_size)
label = ResizeTool.adjust_label(label, ratio, top, left)
return resized_image, label
def __call__(self, sample, *args, **kwargs):
image, label = sample["image"], sample["label"]
image = image / 255.0
image, label = self.__resize_with_pad(image, label)
return {
"image": image,
"label": label
}
class ToTensor:
def __init__(self):
pass
def __call__(self, sample, *args, **kwargs):
image, label = sample["image"], sample["label"]
image_tensor = torch.from_numpy(image)
image_tensor = image_tensor.permute(2, 0, 1)
label_tensor = torch.from_numpy(label)
return {
"image": image_tensor.type(torch.float32),
"label": label_tensor.type(torch.float32)
}
class ColorTransform:
def __init__(self, brightness=0, contrast=0, saturation=0, hue=0):
self.color_jitter = transforms.ColorJitter(brightness, contrast, saturation, hue)
def __call__(self, sample, *args, **kwargs):
image, label = sample["image"], sample["label"]
image = Image.fromarray(image)
image = self.color_jitter(image)
image = | np.array(image) | numpy.array |
import tvm
from tvm import relay
from tvm import hago
import numpy as np
from common_utils import target_and_ctx
def create_hardware():
hardware = hago.Hardware()
hardware.add_op_desc('concatenate', hago.OpDesc(in_dtypes='float32', out_dtypes='float32'))
hardware.add_op_desc('concatenate', hago.OpDesc(in_dtypes='int8', out_dtypes='int8'))
hardware.add_op_desc('concatenate', hago.OpDesc(in_dtypes='int32', out_dtypes='int32'))
hardware.add_op_desc('add', hago.OpDesc(in_dtypes='int8', out_dtypes='int32'))
hardware.add_op_desc('nn.dense', hago.OpDesc(in_dtypes='int8', out_dtypes='int32'))
hardware.add_op_desc('nn.conv2d', hago.OpDesc(in_dtypes='int8', out_dtypes='int32'))
return hardware
def test_dense(ishape=(8, 16), wshape=(10, 16), batch_num=5, device='cpu'):
target, ctx = target_and_ctx(device)
data = relay.var('data', shape=ishape)
weight = relay.var('weight', shape=wshape)
out = relay.nn.dense(data, weight)
func = relay.Function([data, weight], out)
# weight_np = np.random.rand(*wshape).astype('float32')
weight_np = np.random.normal(size=wshape).astype('float32')
# generate dataset
batches = []
for i in range(batch_num):
data_np = np.random.rand(*ishape).astype('float32')
ex = relay.create_executor("debug", ctx=ctx, target=target)
out_np = ex.evaluate(func)(data_np, weight_np).asnumpy()
pred_np = np.argmax(out_np, axis=1)
batches.append({'data': tvm.nd.array(data_np), 'label': tvm.nd.array(pred_np)})
dataset = hago.CalibrationDataset(batches)
params = {'weight': tvm.nd.array(weight_np)}
return func, params, dataset
def test_concatenate(ishape=(8, 16), wshape=(10, 16), batch_num=3, device='cpu'):
target, ctx = target_and_ctx(device)
w0shape = wshape
w1shape = (wshape[1], wshape[0])
data_a = relay.var('data_a', shape=ishape)
data_b = relay.var('data_b', shape=ishape)
data_c = relay.var('data_c', shape=ishape)
data_d = relay.var('data_d', shape=ishape)
weight0 = relay.var('weight0', shape=w0shape)
weight1 = relay.var('weight1', shape=w0shape)
weight2 = relay.var('weight2', shape=w0shape)
weight3 = relay.var('weight3', shape=w0shape)
dense_a = relay.nn.dense(data_a, weight0)
dense_b = relay.nn.dense(data_b, weight1)
dense_c = relay.nn.dense(data_c, weight2)
dense_d = relay.nn.dense(data_d, weight3)
concat = relay.concatenate([dense_a, dense_b, dense_c, dense_d], axis=0)
# 32, 10
weight5 = relay.var('weight5', shape=w1shape)
out = relay.nn.dense(concat, weight5)
func = relay.Function([data_a, data_b, data_c, data_d, weight0, weight1, weight2, weight3, weight5], out)
weight0_np = np.random.normal(size=w0shape).astype('float32')
weight1_np = np.random.normal(size=w0shape).astype('float32')
weight2_np = np.random.normal(size=w0shape).astype('float32')
weight3_np = np.random.normal(size=w0shape).astype('float32')
weight5_np = np.random.normal(size=w1shape).astype('float32')
# generate dataset
batches = []
for i in range(batch_num):
data_a_np = np.random.rand(*ishape).astype('float32')
data_b_np = np.random.rand(*ishape).astype('float32')
data_c_np = np.random.rand(*ishape).astype('float32')
data_d_np = | np.random.rand(*ishape) | numpy.random.rand |
import time
import numpy as np
from scipy import signal
import matplotlib.pyplot as plt
def fft_window(tnum, nfft, window, overlap):
# IN : full length of time series, nfft, window name, overlap ratio
# OUT : bins, 1 x nfft window function
# use overlapping
bins = int(np.fix((int(tnum/nfft) - overlap)/(1.0 - overlap)))
# window function
if window == 'rectwin': # overlap = 0.5
win = np.ones(nfft)
elif window == 'hann': # overlap = 0.5
win = np.hanning(nfft)
elif window == 'hamm': # overlap = 0.5
win = np.hamming(nfft)
elif window == 'kaiser': # overlap = 0.62
win = np.kaiser(nfft, beta=30)
elif window == 'HFT248D': # overlap = 0.84
z = 2*np.pi/nfft*np.arange(0,nfft)
win = 1 - 1.985844164102*np.cos(z) + 1.791176438506*np.cos(2*z) - 1.282075284005*np.cos(3*z) + \
0.667777530266*np.cos(4*z) - 0.240160796576*np.cos(5*z) + 0.056656381764*np.cos(6*z) - \
0.008134974479*np.cos(7*z) + 0.000624544650*np.cos(8*z) - 0.000019808998*np.cos(9*z) + \
0.000000132974*np.cos(10*z)
return bins, win
def fftbins(x, dt, nfft, window, overlap, detrend=0, full=0):
# IN : 1 x tnum data
# OUT : bins x faxis fftdata
tnum = len(x)
bins, win = fft_window(tnum, nfft, window, overlap)
win_factor = np.mean(win**2) # window factors
# make an x-axis #
ax = np.fft.fftfreq(nfft, d=dt) # full 0~fN -fN~-f1
if np.mod(nfft, 2) == 0: # even nfft
ax = np.hstack([ax[0:int(nfft/2)], -(ax[int(nfft/2)]), ax[int(nfft/2):nfft]])
if full == 1: # full shift to -fN ~ 0 ~ fN
ax = np.fft.fftshift(ax)
else: # half 0~fN
ax = ax[0:int(nfft/2+1)]
# make fftdata
if full == 1: # full shift to -fN ~ 0 ~ fN
if np.mod(nfft, 2) == 0: # even nfft
fftdata = np.zeros((bins, nfft+1), dtype=np.complex_)
else: # odd nfft
fftdata = np.zeros((bins, nfft), dtype=np.complex_)
else: # half 0 ~ fN
fftdata = np.zeros((bins, int(nfft/2+1)), dtype=np.complex_)
for b in range(bins):
idx1 = int(b*np.fix(nfft*(1 - overlap)))
idx2 = idx1 + nfft
sx = x[idx1:idx2]
if detrend == 0:
sx = signal.detrend(sx, type='constant') # subtract mean
elif detrend == 1:
sx = signal.detrend(sx, type='linear')
sx = sx * win # apply window function
# get fft
SX = np.fft.fft(sx, n=nfft)/nfft # divide by the length
if np.mod(nfft, 2) == 0: # even nfft
SX = np.hstack([SX[0:int(nfft/2)], np.conj(SX[int(nfft/2)]), SX[int(nfft/2):nfft]])
if full == 1: # shift to -fN ~ 0 ~ fN
SX = np.fft.fftshift(SX)
else: # half 0 ~ fN
SX = SX[0:int(nfft/2+1)]
fftdata[b,:] = SX
return ax, fftdata, win_factor
def cwt(x, dt, df, detrend=0, full=1):
# detrend signal
if detrend == 0:
x = signal.detrend(x, type='constant') # subtract mean
elif detrend == 1:
x = signal.detrend(x, type='linear')
# make a t-axis
tnum = len(x)
nfft = nextpow2(tnum) # power of 2
t = np.arange(nfft)*dt
# make a f-axis with constant df
s0 = 2.0*dt # the smallest scale
ax = np.arange(0.0, 1.0/(1.03*s0), df) # 1.03 for the Morlet wavelet function
# scales
old_settings = np.seterr(divide='ignore')
sj = 1.0/(1.03*ax)
np.seterr(**old_settings)
dj = np.log2(sj/s0) / np.arange(len(sj)) # dj; necessary for reconstruction
sj[0] = tnum*dt/2.0
dj[0] = 0 # remove infinity point due to fmin = 0
# Morlet wavelet function (unnormalized)
omega0 = 6.0 # nondimensional wavelet frequency
wf0 = lambda eta: np.pi**(-1.0/4) * np.exp(1.0j*omega0*eta) * np.exp(-1.0/2*eta**2)
ts = np.sqrt(2)*sj # e-folding time for Morlet wavelet with omega0 = 6; significance level
# FFT of signal
X = np.fft.fft(x, n=nfft)/nfft
# calculate CWT
snum = len(sj)
cwtdata = np.zeros((nfft, snum), dtype=np.complex_)
for j, s in enumerate(sj):
# nondimensional time axis at time scale s
eta = t/s
# FFT of the normalized wavelet function
W = np.fft.fft( np.conj( wf0(eta - np.mean(eta))*np.sqrt(dt/s) ) )
# Wavelet transform at scae s for all n time
cwtdata[:,j] = np.conj(np.fft.fftshift(np.fft.ifft(X * W) * nfft)) # phase direction correct
# full size
if full == 1:
cwtdata = np.hstack([np.fliplr(np.conj(cwtdata)), cwtdata[:,1:]]) # real x only
ax = np.hstack([-ax[::-1], ax[1:]])
return ax, cwtdata[0:tnum,:], dj, ts
def cross_power(XX, YY, win_factor):
Pxy = np.mean(XX * np.conjugate(YY), 0)
Pxy = np.abs(Pxy).real / win_factor
return Pxy
def coherence(XX, YY):
# normalization outside loop
# Pxy = np.mean(XX * np.conjugate(YY), 0)
# Pxx = np.mean(XX * np.conjugate(XX), 0).real
# Pyy = np.mean(YY * np.conjugate(YY), 0).real
# Gxy = np.abs(Pxy).real / np.sqrt(Pxx * Pyy)
# normalization inside loop
bins = XX.shape[0]
val = np.zeros(XX.shape, dtype=np.complex_)
for i in range(bins):
X = XX[i,:]
Y = YY[i,:]
Pxx = X * np.matrix.conjugate(X)
Pyy = Y * np.matrix.conjugate(Y)
val[i,:] = X*np.matrix.conjugate(Y) / np.sqrt(Pxx*Pyy)
# average over bins
Gxy = np.mean(val, 0)
Gxy = np.abs(Gxy).real
return Gxy
def cross_phase(XX, YY):
Pxy = np.mean(XX * np.conjugate(YY), 0)
Axy = np.arctan2(Pxy.imag, Pxy.real).real
return Axy
def correlation(XX, YY, win_factor):
bins = XX.shape[0]
nfreq = XX.shape[1]
val = np.zeros(XX.shape, dtype=np.complex_)
for b in range(bins):
X = XX[b,:]
Y = YY[b,:]
val[b,:] = np.fft.ifftshift(X*np.matrix.conjugate(Y) / win_factor)
val[b,:] = np.fft.ifft(val[b,:], n=nfreq)*nfreq
val[b,:] = np.fft.fftshift(val[b,:])
val[b,:] = np.flip(val[b,:], axis=0)
# average over bins; return real value
Cxy = np.mean(val, 0)
return Cxy.real
def corr_coef(XX, YY):
bins = XX.shape[0]
nfreq = XX.shape[1]
val = np.zeros(XX.shape, dtype=np.complex_)
for b in range(bins):
X = XX[b,:]
Y = YY[b,:]
x = np.fft.ifft(np.fft.ifftshift(X), n=nfreq)*nfreq
Rxx = np.mean(x**2)
y = np.fft.ifft(np.fft.ifftshift(Y), n=nfreq)*nfreq
Ryy = np.mean(y**2)
val[b,:] = np.fft.ifftshift(X*np.matrix.conjugate(Y))
val[b,:] = np.fft.ifft(val[b,:], n=nfreq)*nfreq
val[b,:] = np.fft.fftshift(val[b,:])
val[b,:] = np.flip(val[b,:], axis=0)/np.sqrt(Rxx*Ryy)
# average over bins; return real value
cxy = np.mean(val, 0)
return cxy.real
def xspec(XX, YY, win_factor):
val = np.abs(XX * np.conjugate(YY)).real
return val
def bicoherence(XX, YY):
# ax1 = self.Dlist[dtwo].ax # full -fN ~ fN
# ax2 = np.fft.ifftshift(self.Dlist[dtwo].ax) # full 0 ~ fN, -fN ~ -f1
# ax2 = ax2[0:int(nfft/2+1)] # half 0 ~ fN
bins = XX.shape[0]
full = XX.shape[1]
half = int(full/2+1) # half length
# calculate bicoherence
B = np.zeros((full, half), dtype=np.complex_)
P12 = np.zeros((full, half))
P3 = np.zeros((full, half))
val = np.zeros((full, half))
for b in range(bins):
X = XX[b,:] # full -fN ~ fN
Y = YY[b,:] # full -fN ~ fN
Xhalf = np.fft.ifftshift(X) # full 0 ~ fN, -fN ~ -f1
Xhalf = Xhalf[0:half] # half 0 ~ fN
X1 = np.transpose(np.tile(X, (half, 1)))
X2 = np.tile(Xhalf, (full, 1))
X3 = np.zeros((full, half), dtype=np.complex_)
for j in range(half):
if j == 0:
X3[0:, j] = Y[j:]
else:
X3[0:(-j), j] = Y[j:]
B = B + X1 * X2 * np.matrix.conjugate(X3) # complex bin average
P12 = P12 + (np.abs(X1 * X2).real)**2 # real average
P3 = P3 + (np.abs(X3).real)**2 # real average
# val = np.log10(np.abs(B)**2) # bispectrum
old_settings = np.seterr(invalid='ignore')
val = (np.abs(B)**2) / P12 / P3 # bicoherence
np.seterr(**old_settings)
# summation over pairs
sum_val = np.zeros(full)
for i in range(half):
if i == 0:
sum_val = sum_val + val[:,i]
else:
sum_val[i:] = sum_val[i:] + val[:-i,i]
N = np.array([i+1 for i in range(half)] + [half for i in range(full-half)])
sum_val = sum_val / N # element wise division
return val, sum_val
def ritz_nonlinear(XX, YY):
bins = XX.shape[0]
full = XX.shape[1]
kidx = get_kidx(full)
Aijk = np.zeros((full, full), dtype=np.complex_) # Xo1 Xo2 cXo
cAijk = np.zeros((full, full), dtype=np.complex_) # cXo1 cXo2 Xo
Bijk = np.zeros((full, full), dtype=np.complex_) # Yo cXo1 cXo2
Aij = np.zeros((full, full)) # |Xo1 Xo2|^2
Ak = np.zeros(full) # Xo cXo
Bk = np.zeros(full, dtype=np.complex_) # Yo cXo
for b in range(bins):
X = XX[b,:] # full -fN ~ fN
Y = YY[b,:] # full -fN ~ fN
# make Xi and Xj
Xi = np.transpose(np.tile(X, (full, 1))) # columns of (-fN ~ fN)
Xj = np.tile(X, (full, 1)) # rows of (-fN ~ fN)
# make Xk and Yk
Xk = np.zeros((full, full), dtype=np.complex_)
Yk = np.zeros((full, full), dtype=np.complex_)
for k in range(full):
idx = kidx[k]
for n, ij in enumerate(idx):
Xk[ij] = X[k]
Yk[ij] = Y[k]
# do ensemble average
Aijk = Aijk + Xi * Xj * np.matrix.conjugate(Xk) / bins
cAijk = cAijk + np.matrix.conjugate(Xi) * np.matrix.conjugate(Xj) * Xk / bins
Bijk = Bijk + np.matrix.conjugate(Xi) * np.matrix.conjugate(Xj) * Yk / bins
Aij = Aij + (np.abs(Xi * Xj).real)**2 / bins
Ak = Ak + (np.abs(X).real)**2 / bins
Bk = Bk + Y * np.matrix.conjugate(X) / bins
# Linear transfer function ~ growth rate
Lk = np.zeros(full, dtype=np.complex_)
bsum = np.zeros(full, dtype=np.complex_)
asum = np.zeros(full)
for k in range(full):
idx = kidx[k]
for n, ij in enumerate(idx):
bsum[k] = bsum[k] + Aijk[ij] * Bijk[ij] / Aij[ij]
asum[k] = asum[k] + (np.abs(Aijk[ij]).real)**2 / Aij[ij]
Lk = (Bk - bsum) / (Ak - asum)
# Quadratic transfer function ~ nonlinear energy transfer rate
Lkk = np.zeros((full, full), dtype=np.complex_)
for k in range(full):
idx = kidx[k]
for n, ij in enumerate(idx):
Lkk[ij] = Lk[k]
Qijk = (Bijk - Lkk * cAijk) / Aij
return Lk, Qijk, Bk, Aijk
def wit_nonlinear(XX, YY):
bins = XX.shape[0]
full = XX.shape[1]
kidx = get_kidx(full)
Lk = np.zeros(full, dtype=np.complex_) # Linear
Qijk = np.zeros((full, full), dtype=np.complex_) # Quadratic
print('For stable calculations, bins ({0}) >> full/2 ({1})'.format(bins, full/2))
for k in range(full):
idx = kidx[k]
# construct equations for each k
U = np.zeros((bins, len(idx)+1), dtype=np.complex_) # N (number of ensembles) x P (number of pairs + 1)
V = | np.zeros(bins, dtype=np.complex_) | numpy.zeros |
#!/usr/bin/env python3
import os
import cv2
import numpy as np
import pandas as pd
import tensorflow as tf
from tqdm import tqdm
from glob2 import glob
from skimage import transform
from skimage.io import imread, imsave
from sklearn.preprocessing import normalize
from sklearn.metrics import roc_curve, auc
from tensorflow.keras.preprocessing.image import ImageDataGenerator
gpus = tf.config.experimental.list_physical_devices("GPU")
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
class Eval_folder:
def __init__(self, model_interf, data_path, batch_size=128, save_embeddings=None):
if isinstance(model_interf, str) and model_interf.endswith("h5"):
model = tf.keras.models.load_model(model_interf)
self.model_interf = lambda imms: model((imms - 127.5) * 0.0078125).numpy()
else:
self.model_interf = model_interf
self.dist_func = lambda aa, bb: np.dot(aa, bb)
self.embs, self.imm_classes, self.filenames = self.prepare_images_and_embeddings(data_path, batch_size, save_embeddings)
self.data_path = data_path
def prepare_images_and_embeddings(self, data_path, batch_size=128, save_embeddings=None):
if save_embeddings and os.path.exists(save_embeddings):
print(">>>> Reloading from backup:", save_embeddings)
aa = np.load(save_embeddings)
embs, imm_classes, filenames = aa["embs"], aa["imm_classes"], aa["filenames"]
embs, imm_classes = embs.astype("float32"), imm_classes.astype("int")
else:
img_shape = (112, 112)
img_gen = ImageDataGenerator().flow_from_directory(data_path, class_mode="binary", target_size=img_shape, batch_size=batch_size, shuffle=False)
steps = int(np.ceil(img_gen.classes.shape[0] / img_gen.batch_size))
filenames = np.array(img_gen.filenames)
embs, imm_classes = [], []
for _ in tqdm(range(steps), "Embedding"):
imm, imm_class = img_gen.next()
emb = self.model_interf(imm)
embs.extend(emb)
imm_classes.extend(imm_class)
embs, imm_classes = normalize(np.array(embs).astype("float32")), np.array(imm_classes).astype("int")
if save_embeddings:
print(">>>> Saving embeddings to:", save_embeddings)
np.savez(save_embeddings, embs=embs, imm_classes=imm_classes, filenames=filenames)
return embs, imm_classes, filenames
def do_evaluation(self):
register_ids = np.unique(self.imm_classes)
print(">>>> [base info] embs:", self.embs.shape, "imm_classes:", self.imm_classes.shape, "register_ids:", register_ids.shape)
register_base_embs = np.array([]).reshape(0, self.embs.shape[-1])
register_base_dists = []
for register_id in tqdm(register_ids, "Evaluating"):
pos_pick_cond = self.imm_classes == register_id
pos_embs = self.embs[pos_pick_cond]
register_base_emb = normalize([np.sum(pos_embs, 0)])[0]
register_base_dist = self.dist_func(self.embs, register_base_emb)
register_base_dists.append(register_base_dist)
register_base_embs = np.vstack([register_base_embs, register_base_emb])
register_base_dists = np.array(register_base_dists).T
accuracy = (register_base_dists.argmax(1) == self.imm_classes).sum() / register_base_dists.shape[0]
reg_pos_cond = np.equal(register_ids, np.expand_dims(self.imm_classes, 1))
reg_pos_dists = register_base_dists[reg_pos_cond].ravel()
reg_neg_dists = register_base_dists[np.logical_not(reg_pos_cond)].ravel()
label = np.concatenate([np.ones_like(reg_pos_dists), np.zeros_like(reg_neg_dists)])
score = | np.concatenate([reg_pos_dists, reg_neg_dists]) | numpy.concatenate |
import torch
import torch.nn as nn
import numpy as np
from cnnseq import utils
from cnnseq.utils_models import set_optimizer, flatten_audio
from skimage.io import imsave
import json
import os
# Recurrent neural network (many-to-one)
class Seq2Seq(nn.Module):
def __init__(self, params, device=torch.device('cpu')):
super(Seq2Seq, self).__init__()
self.params = params
input_size = self.params['input_size']
output_size = self.params['output_size']
hidden_size = self.params['hidden_size']
num_layers = self.params['num_layers']
activation_function = self.params['activation_function']
self.model_type = self.params['model_type']
self.device = device
self.hidden_size = self.params['hidden_size']
self.num_layers = self.params['num_layers']
if self.model_type == 'seq2seq':
self.lstm_enc = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
self.lstm_dec = nn.LSTM(output_size, hidden_size, num_layers, batch_first=True)
self.decoder_linear = nn.Linear(hidden_size, output_size)
elif self.model_type == 'seq2seq_gru':
self.lstm_enc = nn.GRU(input_size, hidden_size, num_layers=num_layers, batch_first=True)
self.lstm_dec = nn.GRU(output_size, hidden_size, num_layers=num_layers, batch_first=True)
self.decoder_linear = nn.Linear(hidden_size, output_size)
else:
self.lstm_enc = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
self.decoder_linear = nn.Linear(hidden_size, input_size)
#self.lstm_enc = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
#if self.model_type == 'seq2seq':
# self.lstm_dec = nn.LSTM(output_size, hidden_size, num_layers, batch_first=True)
# self.decoder_linear = nn.Linear(hidden_size, output_size)
#else:
# self.decoder_linear = nn.Linear(hidden_size, input_size)
# self.softmax = nn.LogSoftmax(dim=1)
if activation_function == 'softmax':
self.softmax = nn.Softmax(dim=num_layers)
elif activation_function == 'sigmoid':
self.softmax = nn.Sigmoid()
elif activation_function == 'tanh':
self.softmax = nn.Tanh()
elif activation_function =='relu':
self.softmax = nn.ReLU()
else:
self.softmax = nn.Softplus()
def forward(self, x, y):
# print("x: {}".format(np.shape(x)))
# Set initial hidden and cell states
h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(self.device)
c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(self.device)
# Encoder: Forward propagate LSTM
if self.model_type == 'seq2seq' or self.model_type == 'lstm':
out, hidden = self.lstm_enc(x, (h0, c0)) # out: tensor of shape (batch_size, seq_length, hidden_size)
# print("Enc shapes: out {}, hidden: {}, h0: {}, c0: {}".format(np.shape(out), np.shape(hidden), np.shape(h0), np.shape(c0)))
else: # seq2seq_gru
out, hidden = self.lstm_enc(x, h0)
# Decoder: Decode the hidden state of the last time step
if 'seq2seq' in self.model_type:
out, _ = self.lstm_dec(y, hidden)
# print("Decoder: {}".format(np.shape(out)))
out = self.softmax(self.decoder_linear(out))
# print("Out: {}".format(np.shape(out)))
return out, hidden
def train(model, dataloader_train, dataloader_label_train, args, device):
# Loss and optimizer
criterion = nn.L1Loss() # SmoothL1Loss, NLLLoss(), CrossEntropyLoss()
optimizer, partial_name = set_optimizer(model, args)
# New results dir based on model's parameters
res_dir = args.results_dir + '{}_trainSize_{}_testSize_{}/'.format(partial_name, args.train_samples_size,
args.test_samples_size)
args.results_dir = res_dir
utils.ensure_dir(res_dir)
# print("res_dir: {}".format(res_dir))
log_file = open(res_dir + 'log.txt', 'w')
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=args.scheduler_factor,
verbose=True)
total_step = len(dataloader_train.keys())
loss_arr = []
epoch_arr = []
for epoch in range(args.num_epochs):
for i, (im, la) in enumerate(zip(dataloader_train.keys(), dataloader_label_train.keys())):
labels = dataloader_label_train[la]
images = dataloader_train[im]
# print("Shape images: {}, labels: {}".format(np.shape(images), np.shape(labels)))
images = images.reshape(-1, np.shape(images)[-1], args.input_size).to(device) # bsx28x28
labels = labels.reshape(-1, np.shape(labels)[-1], args.output_size).to(device) # labels.to(device)
# print("Shape after reshape images: {}, labels: {}".format(np.shape(images), np.shape(labels)))
# Forward pass
target = labels # images # 1-images
outputs, _ = model(images, target) # (2, 96, 90), (2, 6000, 8)
loss = criterion(outputs, target)
# Backward and optimize
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (i + 1) % 50 == 0:
log_str = 'Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch + 1, args.num_epochs,
i + 1, total_step, loss.item())
print(log_str)
log_file.write(log_str + '\n')
scheduler.step(loss)
loss_arr.append(loss.item())
epoch_arr.append(epoch + 1)
if (epoch + 1) % args.save_step == 0:
# Input images
input_data = images.cpu().data.numpy()[0]
input_reshaped = np.reshape(input_data, [np.shape(input_data)[1], np.shape(input_data)[0]])
# Target audio
images_white_data = target.cpu().data.numpy()[0]
im_reshaped = np.reshape(images_white_data,
[np.shape(images_white_data)[1], np.shape(images_white_data)[0]])
im_reshaped = flatten_audio(im_reshaped, args)
# Generated audio
outputs_data = outputs.cpu().data.numpy()[0]
out_reshaped = np.reshape(outputs_data, [np.shape(outputs_data)[1], np.shape(outputs_data)[0]])
out_reshaped = flatten_audio(out_reshaped, args)
# Save audio, 16KHz
from scipy.io.wavfile import write
scaled = -1.0 + (1.0 - (-1.0)) * (input_reshaped - np.min(input_reshaped)) / (
np.max(input_reshaped) - np.min(input_reshaped))
imsave('{}{}_input.jpg'.format(res_dir, epoch + 1), scaled)
scaled = -1.0 + (1.0 - (-1.0)) * (im_reshaped - np.min(im_reshaped)) / (
np.max(im_reshaped) - np.min(im_reshaped))
scaled = np.int16(scaled / np.max(np.abs(scaled)) * 32767)
write('{}{}_target.wav'.format(res_dir, epoch + 1), 16000, scaled[0])
scaled2 = np.int16(out_reshaped / np.max(np.abs(out_reshaped)) * 32767)
write('{}{}_gen.wav'.format(res_dir, epoch + 1), 16000, scaled2[0])
# imsave('{}{}_target.jpg'.format(res_dir, epoch + 1), images_white_data[0])
# imsave('{}{}_gen.jpg'.format(res_dir, epoch + 1), outputs_data[0])
# Save the model checkpoint
torch.save(model.state_dict(), res_dir + args.saved_model)
# Plot loss_epochs.svg file
import matplotlib.pyplot as plt
plt.figure(figsize=[6, 6])
plt.plot(epoch_arr, loss_arr, '*-')
plt.title('Training loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.grid('on')
# plt.gca().set_position([0, 0, 1, 1])
plt.savefig("{}loss_epochs.svg".format(res_dir))
plt.cla()
# Save args in json file so model can be fully loaded independently
with open(os.path.join(res_dir, args.saved_model_parameters), 'w') as fp:
json.dump(vars(args), fp, sort_keys=True, indent=4)
log_file.close()
return res_dir
def test(dataloader_test, dataloader_label_test, args, device):
# Test the model
print("\nTesting model")
# Load model parameters from JSON file
with open(os.path.join(args.results_dir, args.saved_model_parameters), 'r') as fp:
print(os.path.join(args.results_dir, args.saved_model_parameters))
params = json.load(fp)
# model = CNNSeq2Seq(args.input_size, args.output_size, args.hidden_size, args.num_layers).to(device)
model = Seq2Seq(params, device).to(device)
model_path = args.results_dir + args.saved_model
print(model_path)
model.load_state_dict(torch.load(model_path))
with torch.no_grad():
correct = 0
total = 0
for im, la in zip(dataloader_test.keys(), dataloader_label_test.keys()):
labels = dataloader_label_test[la]
images = dataloader_test[im]
images = images.reshape(-1, np.shape(images)[-1], params['input_size']).to(device)
labels = labels.reshape(-1, np.shape(labels)[-1], params['output_size']).to(device)
target = labels # 1 - images
outputs, _ = model(images, target)
input_data_tmp = images.cpu().data.numpy()
images_white_data_tmp = target.cpu().data.numpy()
outputs_data_tmp = outputs.cpu().data.numpy()
print(np.size(images_white_data_tmp))
for i in range(0, min(2, params['batch_size'])):
input_data = input_data_tmp[i]
images_white_data = images_white_data_tmp[i]
outputs_data = outputs_data_tmp[i]
im_reshaped = np.reshape(images_white_data,
[np.shape(images_white_data)[1], np.shape(images_white_data)[0]])
im_reshaped = flatten_audio(im_reshaped, args)
input_reshaped = np.reshape(input_data, [np.shape(input_data)[1], np.shape(input_data)[0]])
out_reshaped = np.reshape(outputs_data, [np.shape(outputs_data)[1], np.shape(outputs_data)[0]])
out_reshaped = flatten_audio(out_reshaped, args)
print(np.shape(out_reshaped))
# Save audio, 16KHz
from scipy.io.wavfile import write
scaled = -1.0 + (1.0 - (-1.0)) * (input_reshaped - np.min(input_reshaped)) / (
np.max(input_reshaped) - np.min(input_reshaped))
imsave('{}test_input.jpg'.format(args.results_dir), scaled)
scaled = -1.0 + (1.0 - (-1.0)) * (im_reshaped - np.min(im_reshaped)) / (
| np.max(im_reshaped) | numpy.max |
import scipy as sp
import numpy as np
from scipy.stats import lognorm as dist
from ngboost.distns import SurvivalDistn
from ngboost.scores import LogScore, CRPScore
class LogNormalLogScore(LogScore):
def score(self, Y):
E = Y['Event']
T = Y['Time']
cens = (1-E) * np.log(1 - self.dist.cdf(T) + self.eps)
uncens = E * self.dist.logpdf(T)
return -(cens + uncens)
def d_score(self, Y):
E = Y['Event'][:,np.newaxis]
T = Y['Time']
lT = np.log(T)
Z = (lT - self.loc) / self.scale
D_uncens = np.zeros((self.loc.shape[0], 2))
D_uncens[:, 0] = (self.loc - lT) / (self.scale ** 2)
D_uncens[:, 1] = 1 - ((self.loc - lT) ** 2) / (self.scale ** 2)
D_cens = np.zeros((self.loc.shape[0], 2))
D_cens[:, 0] = -sp.stats.norm.pdf(lT, loc=self.loc, scale=self.scale) / \
(1 - self.dist.cdf(T) + self.eps)
D_cens[:, 1] = -Z * sp.stats.norm.pdf(lT, loc=self.loc, scale=self.scale) / \
(1 - self.dist.cdf(T) + self.eps)
D_cens[:, 0] = -sp.stats.norm.pdf(lT, loc=self.loc, scale=self.scale) / \
(1 - self.dist.cdf(T) + self.eps)
D_cens[:, 1] = -Z * sp.stats.norm.pdf(lT, loc=self.loc, scale=self.scale) / \
(1 - self.dist.cdf(T) + self.eps)
return (1-E) * D_cens + E * D_uncens
def metric(self):
FI = | np.zeros((self.loc.shape[0], 2, 2)) | numpy.zeros |
import numpy as np
import re
from commands.AbstractCommand import AbstractCommand
class roll(AbstractCommand):
type = str()
def __init__(self, command_specific_setup):
self.type = command_specific_setup
def execute(self, command_input):
diceInput = command_input.partition("d") #returns a tuple with index 0 being the x, index 1 being d, index 2 being the n
if not re.search(r'^\d*?d\d+$',command_input):
return "the vibes are simply rancid"
n = int(diceInput[2])
x = int(diceInput[0])
if self.type == 'ad':
return(xdn_ad(x,n))
elif self.type == 'da':
return(xdn_da(x,n))
else:
return (xdn(x,n))
def dn(n): #a die with n sides
return np.random.randint(1,n+1,1)
def xdn(x, n): #x dice with n sides
if (x < 1) or (n < 1):
return("numprob")
dice = | np.random.randint(1,n+1,x) | numpy.random.randint |
# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for horizon_util."""
from . import horizon_util
from absl.testing import absltest
from absl.testing import parameterized
import numpy as np
class HorizonUtilTest(parameterized.TestCase):
def test_int_frame_horizons(self):
radius = np.array([0.1, 0.3, 1, 3])
actual = horizon_util.int_frame_horizon(radius, num_frames=10, time_scale=5)
expected = [0, 1, 5, 9]
np.testing.assert_equal(actual, expected)
self.assertTrue(np.issubdtype(actual.dtype, np.integer))
def test_int_frame_horizons_infinite(self):
num_frames = 10
radius = np.array([-np.inf, 0, np.inf])
actual = horizon_util.int_frame_horizon(radius, num_frames, time_scale=1)
expected = [0, 0, num_frames - 1]
| np.testing.assert_equal(actual, expected) | numpy.testing.assert_equal |
import glob
import numpy as np
from tqdm import tqdm
def opticflow(x1, y1, x2, y2):
# caculate the optic flow of 2 opints
# return dx dy
# checked
dx = x2 - x1
dy = y2 - y1
return dx, dy
def get_opticflow(data_before, data, model, kp_num, people_num = 0):
# one people
# get dx, dy from 2 frames
# checked
if data[model][people_num, kp_num, 2] != 0 and data_before[model][people_num, kp_num, 2] != 0:
# if curray is not 0
x2 = data[model][people_num, kp_num, 0]
y2 = data[model][people_num, kp_num, 1]
x1 = data_before[model][people_num, kp_num, 0]
y1 = data_before[model][people_num, kp_num, 1]
dx, dy = opticflow(x1, y1, x2, y2)
# out = [dx, dy]
else:
# out = None
dx = dy = 0
return dx, dy
def get_coordinate(data, model, kp_num, people_num = 0):
# one people
# get coordinate from one frame
# checked
if data[model][people_num, kp_num, 2] != 0:
x = data[model][people_num, kp_num, 0]
y = data[model][people_num, kp_num, 1]
# out = [x, y]
else:
# out = None
x = y = None
return x, y
def load_FV(folder):
# folder: W2_6_000000/
files = sorted(glob.glob(folder + '/data/*'))
data_before = None
out_list = []
first_data = np.load(files[0])
body1_x, body1_y = get_coordinate(first_data, 'pose', 1)
body8_x, body8_y = get_coordinate(first_data, 'pose', 8)
rate = 300 / ((body1_x - body8_x)**2 + (body1_y - body8_y)**2)**(1/2)
for i in files:
# i: 000000.npz
data = np.load(i)
body1_x, body1_y = get_coordinate(data, 'pose', 1)
body8_x, body8_y = get_coordinate(data, 'pose', 8)
if data_before != None:
FV_1_dx, FV_1_dy = get_opticflow(data_before, data, 'pose', 4)
FV_2_dx, FV_2_dy = get_opticflow(data_before, data, 'pose', 7)
FV_3_dx, FV_3_dy = get_opticflow(data_before, data, 'pose', 3)
FV_4_dx, FV_4_dy = get_opticflow(data_before, data, 'pose', 6)
FV_5_dx, FV_5_dy = get_coordinate(data, 'pose', 4)
FV_6_dx, FV_6_dy = get_coordinate(data, 'pose', 7)
FV_7_dx, FV_7_dy = get_coordinate(data, 'pose', 3)
FV_8_dx, FV_8_dy = get_coordinate(data, 'pose', 6)
FV_5_dx, FV_5_dy = FV_5_dx - body1_x, FV_5_dy - body1_y
FV_6_dx, FV_6_dy = FV_6_dx - body1_x, FV_6_dy - body1_y
FV_7_dx, FV_7_dy = FV_7_dx - body1_x, FV_7_dy - body1_y
FV_8_dx, FV_8_dy = FV_8_dx - body1_x, FV_8_dy - body1_y
FV_9_dx, FV_9_dy = get_opticflow(data_before, data, 'pose', 1)
FV_10_dx, FV_10_dy = get_opticflow(data_before, data, 'pose', 0)
else:
FV_1_dx = FV_1_dy = FV_2_dx = FV_2_dy = FV_3_dx = FV_3_dy = FV_4_dx = FV_4_dy = FV_9_dx = FV_9_dy = FV_10_dx = FV_10_dy = 0
FV_5_dx, FV_5_dy = get_coordinate(data, 'pose', 4)
FV_6_dx, FV_6_dy = get_coordinate(data, 'pose', 7)
FV_7_dx, FV_7_dy = get_coordinate(data, 'pose', 3)
FV_8_dx, FV_8_dy = get_coordinate(data, 'pose', 6)
FV_5_dx, FV_5_dy = FV_5_dx - body1_x, FV_5_dy - body1_y
FV_6_dx, FV_6_dy = FV_6_dx - body1_x, FV_6_dy - body1_y
FV_7_dx, FV_7_dy = FV_7_dx - body1_x, FV_7_dy - body1_y
FV_8_dx, FV_8_dy = FV_8_dx - body1_x, FV_8_dy - body1_y
out = np.array([FV_1_dx, FV_1_dy, FV_2_dx, FV_2_dy, FV_3_dx, FV_3_dy, FV_4_dx, FV_4_dy, FV_5_dx, FV_5_dy, FV_6_dx, FV_6_dy, FV_7_dx, FV_7_dy, FV_8_dx, FV_8_dy, FV_9_dx, FV_9_dy, FV_10_dx, FV_10_dy]) * rate
data_before = data
out_list.append(out)
out_list = np.array(out_list)
return out_list
def load_dataset(video_path):
folders = sorted(glob.glob(video_path + '/*'))
labels = []
fv_list = []
name_list = []
print('loading dataset ...')
for folder in tqdm(folders):
# folder: W2_6_000000/
folder_name = folder.split('/')[-1]
with open(folder + '/label.txt', 'r') as f:
label = f.read()
if label == '手を回転させる':
labels.append(0)
fv = load_FV(folder)
fv_list.append(fv)
name_list.append(folder_name)
elif label == '黒板で手をスライドさせる':
labels.append(1)
fv = load_FV(folder)
fv_list.append(fv)
name_list.append(folder_name)
elif label == '黒板に指す':
labels.append(2)
fv = load_FV(folder)
fv_list.append(fv)
name_list.append(folder_name)
else:
pass
y = np.array(labels)
x = np.array(fv_list)
name = np.array(name_list)
return x, y, name
if __name__ == '__main__':
x, y, name = load_dataset('/Users/songminglun/Documents/ILCS/data/video')
np.save('/Users/songminglun/Documents/ILCS/data/label.npy', y)
np.save('/Users/songminglun/Documents/ILCS/data/path_name.npy', name)
| np.save('/Users/songminglun/Documents/ILCS/data/feature_value.npy', x) | numpy.save |
# This module has been generated automatically from space group information
# obtained from the Computational Crystallography Toolbox
#
"""
Space groups
This module contains a list of all the 230 space groups that can occur in
a crystal. The variable space_groups contains a dictionary that maps
space group numbers and space group names to the corresponding space
group objects.
.. moduleauthor:: <NAME> <<EMAIL>>
"""
#-----------------------------------------------------------------------------
# Copyright (C) 2013 The Mosaic Development Team
#
# Distributed under the terms of the BSD License. The full license is in
# the file LICENSE.txt, distributed as part of this software.
#-----------------------------------------------------------------------------
import numpy as N
class SpaceGroup(object):
"""
Space group
All possible space group objects are created in this module. Other
modules should access these objects through the dictionary
space_groups rather than create their own space group objects.
"""
def __init__(self, number, symbol, transformations):
"""
:param number: the number assigned to the space group by
international convention
:type number: int
:param symbol: the Hermann-Mauguin space-group symbol as used
in PDB and mmCIF files
:type symbol: str
:param transformations: a list of space group transformations,
each consisting of a tuple of three
integer arrays (rot, tn, td), where
rot is the rotation matrix and tn/td
are the numerator and denominator of the
translation vector. The transformations
are defined in fractional coordinates.
:type transformations: list
"""
self.number = number
self.symbol = symbol
self.transformations = transformations
self.transposed_rotations = N.array([N.transpose(t[0])
for t in transformations])
self.phase_factors = N.exp(N.array([(-2j*N.pi*t[1])/t[2]
for t in transformations]))
def __repr__(self):
return "SpaceGroup(%d, %s)" % (self.number, repr(self.symbol))
def __len__(self):
"""
:return: the number of space group transformations
:rtype: int
"""
return len(self.transformations)
def symmetryEquivalentMillerIndices(self, hkl):
"""
:param hkl: a set of Miller indices
:type hkl: Scientific.N.array_type
:return: a tuple (miller_indices, phase_factor) of two arrays
of length equal to the number of space group
transformations. miller_indices contains the Miller
indices of each reflection equivalent by symmetry to the
reflection hkl (including hkl itself as the first element).
phase_factor contains the phase factors that must be applied
to the structure factor of reflection hkl to obtain the
structure factor of the symmetry equivalent reflection.
:rtype: tuple
"""
hkls = N.dot(self.transposed_rotations, hkl)
p = N.multiply.reduce(self.phase_factors**hkl, -1)
return hkls, p
space_groups = {}
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(1, 'P 1', transformations)
space_groups[1] = sg
space_groups['P 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(2, 'P -1', transformations)
space_groups[2] = sg
space_groups['P -1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(3, 'P 1 2 1', transformations)
space_groups[3] = sg
space_groups['P 1 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(4, 'P 1 21 1', transformations)
space_groups[4] = sg
space_groups['P 1 21 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(5, 'C 1 2 1', transformations)
space_groups[5] = sg
space_groups['C 1 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(6, 'P 1 m 1', transformations)
space_groups[6] = sg
space_groups['P 1 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(7, 'P 1 c 1', transformations)
space_groups[7] = sg
space_groups['P 1 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(8, 'C 1 m 1', transformations)
space_groups[8] = sg
space_groups['C 1 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(9, 'C 1 c 1', transformations)
space_groups[9] = sg
space_groups['C 1 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(10, 'P 1 2/m 1', transformations)
space_groups[10] = sg
space_groups['P 1 2/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(11, 'P 1 21/m 1', transformations)
space_groups[11] = sg
space_groups['P 1 21/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(12, 'C 1 2/m 1', transformations)
space_groups[12] = sg
space_groups['C 1 2/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(13, 'P 1 2/c 1', transformations)
space_groups[13] = sg
space_groups['P 1 2/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(14, 'P 1 21/c 1', transformations)
space_groups[14] = sg
space_groups['P 1 21/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(15, 'C 1 2/c 1', transformations)
space_groups[15] = sg
space_groups['C 1 2/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(16, 'P 2 2 2', transformations)
space_groups[16] = sg
space_groups['P 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(17, 'P 2 2 21', transformations)
space_groups[17] = sg
space_groups['P 2 2 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(18, 'P 21 21 2', transformations)
space_groups[18] = sg
space_groups['P 21 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(19, 'P 21 21 21', transformations)
space_groups[19] = sg
space_groups['P 21 21 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(20, 'C 2 2 21', transformations)
space_groups[20] = sg
space_groups['C 2 2 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(21, 'C 2 2 2', transformations)
space_groups[21] = sg
space_groups['C 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(22, 'F 2 2 2', transformations)
space_groups[22] = sg
space_groups['F 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(23, 'I 2 2 2', transformations)
space_groups[23] = sg
space_groups['I 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(24, 'I 21 21 21', transformations)
space_groups[24] = sg
space_groups['I 21 21 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(25, 'P m m 2', transformations)
space_groups[25] = sg
space_groups['P m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(26, 'P m c 21', transformations)
space_groups[26] = sg
space_groups['P m c 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(27, 'P c c 2', transformations)
space_groups[27] = sg
space_groups['P c c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(28, 'P m a 2', transformations)
space_groups[28] = sg
space_groups['P m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(29, 'P c a 21', transformations)
space_groups[29] = sg
space_groups['P c a 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(30, 'P n c 2', transformations)
space_groups[30] = sg
space_groups['P n c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(31, 'P m n 21', transformations)
space_groups[31] = sg
space_groups['P m n 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(32, 'P b a 2', transformations)
space_groups[32] = sg
space_groups['P b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(33, 'P n a 21', transformations)
space_groups[33] = sg
space_groups['P n a 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(34, 'P n n 2', transformations)
space_groups[34] = sg
space_groups['P n n 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(35, 'C m m 2', transformations)
space_groups[35] = sg
space_groups['C m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(36, 'C m c 21', transformations)
space_groups[36] = sg
space_groups['C m c 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(37, 'C c c 2', transformations)
space_groups[37] = sg
space_groups['C c c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(38, 'A m m 2', transformations)
space_groups[38] = sg
space_groups['A m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(39, 'A b m 2', transformations)
space_groups[39] = sg
space_groups['A b m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(40, 'A m a 2', transformations)
space_groups[40] = sg
space_groups['A m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(41, 'A b a 2', transformations)
space_groups[41] = sg
space_groups['A b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(42, 'F m m 2', transformations)
space_groups[42] = sg
space_groups['F m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(43, 'F d d 2', transformations)
space_groups[43] = sg
space_groups['F d d 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(44, 'I m m 2', transformations)
space_groups[44] = sg
space_groups['I m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(45, 'I b a 2', transformations)
space_groups[45] = sg
space_groups['I b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(46, 'I m a 2', transformations)
space_groups[46] = sg
space_groups['I m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(47, 'P m m m', transformations)
space_groups[47] = sg
space_groups['P m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(48, 'P n n n :2', transformations)
space_groups[48] = sg
space_groups['P n n n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(49, 'P c c m', transformations)
space_groups[49] = sg
space_groups['P c c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(50, 'P b a n :2', transformations)
space_groups[50] = sg
space_groups['P b a n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(51, 'P m m a', transformations)
space_groups[51] = sg
space_groups['P m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(52, 'P n n a', transformations)
space_groups[52] = sg
space_groups['P n n a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(53, 'P m n a', transformations)
space_groups[53] = sg
space_groups['P m n a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(54, 'P c c a', transformations)
space_groups[54] = sg
space_groups['P c c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(55, 'P b a m', transformations)
space_groups[55] = sg
space_groups['P b a m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(56, 'P c c n', transformations)
space_groups[56] = sg
space_groups['P c c n'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(57, 'P b c m', transformations)
space_groups[57] = sg
space_groups['P b c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(58, 'P n n m', transformations)
space_groups[58] = sg
space_groups['P n n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(59, 'P m m n :2', transformations)
space_groups[59] = sg
space_groups['P m m n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(60, 'P b c n', transformations)
space_groups[60] = sg
space_groups['P b c n'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(61, 'P b c a', transformations)
space_groups[61] = sg
space_groups['P b c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(62, 'P n m a', transformations)
space_groups[62] = sg
space_groups['P n m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(63, 'C m c m', transformations)
space_groups[63] = sg
space_groups['C m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(64, 'C m c a', transformations)
space_groups[64] = sg
space_groups['C m c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(65, 'C m m m', transformations)
space_groups[65] = sg
space_groups['C m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(66, 'C c c m', transformations)
space_groups[66] = sg
space_groups['C c c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(67, 'C m m a', transformations)
space_groups[67] = sg
space_groups['C m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(68, 'C c c a :2', transformations)
space_groups[68] = sg
space_groups['C c c a :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(69, 'F m m m', transformations)
space_groups[69] = sg
space_groups['F m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(70, 'F d d d :2', transformations)
space_groups[70] = sg
space_groups['F d d d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(71, 'I m m m', transformations)
space_groups[71] = sg
space_groups['I m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(72, 'I b a m', transformations)
space_groups[72] = sg
space_groups['I b a m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(73, 'I b c a', transformations)
space_groups[73] = sg
space_groups['I b c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(74, 'I m m a', transformations)
space_groups[74] = sg
space_groups['I m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(75, 'P 4', transformations)
space_groups[75] = sg
space_groups['P 4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(76, 'P 41', transformations)
space_groups[76] = sg
space_groups['P 41'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(77, 'P 42', transformations)
space_groups[77] = sg
space_groups['P 42'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(78, 'P 43', transformations)
space_groups[78] = sg
space_groups['P 43'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(79, 'I 4', transformations)
space_groups[79] = sg
space_groups['I 4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(80, 'I 41', transformations)
space_groups[80] = sg
space_groups['I 41'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(81, 'P -4', transformations)
space_groups[81] = sg
space_groups['P -4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(82, 'I -4', transformations)
space_groups[82] = sg
space_groups['I -4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(83, 'P 4/m', transformations)
space_groups[83] = sg
space_groups['P 4/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(84, 'P 42/m', transformations)
space_groups[84] = sg
space_groups['P 42/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(85, 'P 4/n :2', transformations)
space_groups[85] = sg
space_groups['P 4/n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(86, 'P 42/n :2', transformations)
space_groups[86] = sg
space_groups['P 42/n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(87, 'I 4/m', transformations)
space_groups[87] = sg
space_groups['I 4/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(88, 'I 41/a :2', transformations)
space_groups[88] = sg
space_groups['I 41/a :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(89, 'P 4 2 2', transformations)
space_groups[89] = sg
space_groups['P 4 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(90, 'P 4 21 2', transformations)
space_groups[90] = sg
space_groups['P 4 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(91, 'P 41 2 2', transformations)
space_groups[91] = sg
space_groups['P 41 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(92, 'P 41 21 2', transformations)
space_groups[92] = sg
space_groups['P 41 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(93, 'P 42 2 2', transformations)
space_groups[93] = sg
space_groups['P 42 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(94, 'P 42 21 2', transformations)
space_groups[94] = sg
space_groups['P 42 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(95, 'P 43 2 2', transformations)
space_groups[95] = sg
space_groups['P 43 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(96, 'P 43 21 2', transformations)
space_groups[96] = sg
space_groups['P 43 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(97, 'I 4 2 2', transformations)
space_groups[97] = sg
space_groups['I 4 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(98, 'I 41 2 2', transformations)
space_groups[98] = sg
space_groups['I 41 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(99, 'P 4 m m', transformations)
space_groups[99] = sg
space_groups['P 4 m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(100, 'P 4 b m', transformations)
space_groups[100] = sg
space_groups['P 4 b m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(101, 'P 42 c m', transformations)
space_groups[101] = sg
space_groups['P 42 c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(102, 'P 42 n m', transformations)
space_groups[102] = sg
space_groups['P 42 n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(103, 'P 4 c c', transformations)
space_groups[103] = sg
space_groups['P 4 c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(104, 'P 4 n c', transformations)
space_groups[104] = sg
space_groups['P 4 n c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(105, 'P 42 m c', transformations)
space_groups[105] = sg
space_groups['P 42 m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(106, 'P 42 b c', transformations)
space_groups[106] = sg
space_groups['P 42 b c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(107, 'I 4 m m', transformations)
space_groups[107] = sg
space_groups['I 4 m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(108, 'I 4 c m', transformations)
space_groups[108] = sg
space_groups['I 4 c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(109, 'I 41 m d', transformations)
space_groups[109] = sg
space_groups['I 41 m d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(110, 'I 41 c d', transformations)
space_groups[110] = sg
space_groups['I 41 c d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(111, 'P -4 2 m', transformations)
space_groups[111] = sg
space_groups['P -4 2 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(112, 'P -4 2 c', transformations)
space_groups[112] = sg
space_groups['P -4 2 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(113, 'P -4 21 m', transformations)
space_groups[113] = sg
space_groups['P -4 21 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(114, 'P -4 21 c', transformations)
space_groups[114] = sg
space_groups['P -4 21 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(115, 'P -4 m 2', transformations)
space_groups[115] = sg
space_groups['P -4 m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(116, 'P -4 c 2', transformations)
space_groups[116] = sg
space_groups['P -4 c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(117, 'P -4 b 2', transformations)
space_groups[117] = sg
space_groups['P -4 b 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(118, 'P -4 n 2', transformations)
space_groups[118] = sg
space_groups['P -4 n 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(119, 'I -4 m 2', transformations)
space_groups[119] = sg
space_groups['I -4 m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(120, 'I -4 c 2', transformations)
space_groups[120] = sg
space_groups['I -4 c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(121, 'I -4 2 m', transformations)
space_groups[121] = sg
space_groups['I -4 2 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(122, 'I -4 2 d', transformations)
space_groups[122] = sg
space_groups['I -4 2 d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(123, 'P 4/m m m', transformations)
space_groups[123] = sg
space_groups['P 4/m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(124, 'P 4/m c c', transformations)
space_groups[124] = sg
space_groups['P 4/m c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(125, 'P 4/n b m :2', transformations)
space_groups[125] = sg
space_groups['P 4/n b m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(126, 'P 4/n n c :2', transformations)
space_groups[126] = sg
space_groups['P 4/n n c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(127, 'P 4/m b m', transformations)
space_groups[127] = sg
space_groups['P 4/m b m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(128, 'P 4/m n c', transformations)
space_groups[128] = sg
space_groups['P 4/m n c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(129, 'P 4/n m m :2', transformations)
space_groups[129] = sg
space_groups['P 4/n m m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(130, 'P 4/n c c :2', transformations)
space_groups[130] = sg
space_groups['P 4/n c c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(131, 'P 42/m m c', transformations)
space_groups[131] = sg
space_groups['P 42/m m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(132, 'P 42/m c m', transformations)
space_groups[132] = sg
space_groups['P 42/m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(133, 'P 42/n b c :2', transformations)
space_groups[133] = sg
space_groups['P 42/n b c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(134, 'P 42/n n m :2', transformations)
space_groups[134] = sg
space_groups['P 42/n n m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(135, 'P 42/m b c', transformations)
space_groups[135] = sg
space_groups['P 42/m b c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(136, 'P 42/m n m', transformations)
space_groups[136] = sg
space_groups['P 42/m n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(137, 'P 42/n m c :2', transformations)
space_groups[137] = sg
space_groups['P 42/n m c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(138, 'P 42/n c m :2', transformations)
space_groups[138] = sg
space_groups['P 42/n c m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(139, 'I 4/m m m', transformations)
space_groups[139] = sg
space_groups['I 4/m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(140, 'I 4/m c m', transformations)
space_groups[140] = sg
space_groups['I 4/m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(141, 'I 41/a m d :2', transformations)
space_groups[141] = sg
space_groups['I 41/a m d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(142, 'I 41/a c d :2', transformations)
space_groups[142] = sg
space_groups['I 41/a c d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(143, 'P 3', transformations)
space_groups[143] = sg
space_groups['P 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(144, 'P 31', transformations)
space_groups[144] = sg
space_groups['P 31'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(145, 'P 32', transformations)
space_groups[145] = sg
space_groups['P 32'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(146, 'R 3 :H', transformations)
space_groups[146] = sg
space_groups['R 3 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(147, 'P -3', transformations)
space_groups[147] = sg
space_groups['P -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(148, 'R -3 :H', transformations)
space_groups[148] = sg
space_groups['R -3 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(149, 'P 3 1 2', transformations)
space_groups[149] = sg
space_groups['P 3 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(150, 'P 3 2 1', transformations)
space_groups[150] = sg
space_groups['P 3 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(151, 'P 31 1 2', transformations)
space_groups[151] = sg
space_groups['P 31 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(152, 'P 31 2 1', transformations)
space_groups[152] = sg
space_groups['P 31 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(153, 'P 32 1 2', transformations)
space_groups[153] = sg
space_groups['P 32 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(154, 'P 32 2 1', transformations)
space_groups[154] = sg
space_groups['P 32 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(155, 'R 3 2 :H', transformations)
space_groups[155] = sg
space_groups['R 3 2 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(156, 'P 3 m 1', transformations)
space_groups[156] = sg
space_groups['P 3 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(157, 'P 3 1 m', transformations)
space_groups[157] = sg
space_groups['P 3 1 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(158, 'P 3 c 1', transformations)
space_groups[158] = sg
space_groups['P 3 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(159, 'P 3 1 c', transformations)
space_groups[159] = sg
space_groups['P 3 1 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(160, 'R 3 m :H', transformations)
space_groups[160] = sg
space_groups['R 3 m :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(161, 'R 3 c :H', transformations)
space_groups[161] = sg
space_groups['R 3 c :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(162, 'P -3 1 m', transformations)
space_groups[162] = sg
space_groups['P -3 1 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(163, 'P -3 1 c', transformations)
space_groups[163] = sg
space_groups['P -3 1 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(164, 'P -3 m 1', transformations)
space_groups[164] = sg
space_groups['P -3 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(165, 'P -3 c 1', transformations)
space_groups[165] = sg
space_groups['P -3 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(166, 'R -3 m :H', transformations)
space_groups[166] = sg
space_groups['R -3 m :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,-1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,-1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,-1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(167, 'R -3 c :H', transformations)
space_groups[167] = sg
space_groups['R -3 c :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(168, 'P 6', transformations)
space_groups[168] = sg
space_groups['P 6'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(169, 'P 61', transformations)
space_groups[169] = sg
space_groups['P 61'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(170, 'P 65', transformations)
space_groups[170] = sg
space_groups['P 65'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(171, 'P 62', transformations)
space_groups[171] = sg
space_groups['P 62'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(172, 'P 64', transformations)
space_groups[172] = sg
space_groups['P 64'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(173, 'P 63', transformations)
space_groups[173] = sg
space_groups['P 63'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(174, 'P -6', transformations)
space_groups[174] = sg
space_groups['P -6'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(175, 'P 6/m', transformations)
space_groups[175] = sg
space_groups['P 6/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(176, 'P 63/m', transformations)
space_groups[176] = sg
space_groups['P 63/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(177, 'P 6 2 2', transformations)
space_groups[177] = sg
space_groups['P 6 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(178, 'P 61 2 2', transformations)
space_groups[178] = sg
space_groups['P 61 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(179, 'P 65 2 2', transformations)
space_groups[179] = sg
space_groups['P 65 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(180, 'P 62 2 2', transformations)
space_groups[180] = sg
space_groups['P 62 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(181, 'P 64 2 2', transformations)
space_groups[181] = sg
space_groups['P 64 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(182, 'P 63 2 2', transformations)
space_groups[182] = sg
space_groups['P 63 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(183, 'P 6 m m', transformations)
space_groups[183] = sg
space_groups['P 6 m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(184, 'P 6 c c', transformations)
space_groups[184] = sg
space_groups['P 6 c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(185, 'P 63 c m', transformations)
space_groups[185] = sg
space_groups['P 63 c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(186, 'P 63 m c', transformations)
space_groups[186] = sg
space_groups['P 63 m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(187, 'P -6 m 2', transformations)
space_groups[187] = sg
space_groups['P -6 m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(188, 'P -6 c 2', transformations)
space_groups[188] = sg
space_groups['P -6 c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(189, 'P -6 2 m', transformations)
space_groups[189] = sg
space_groups['P -6 2 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(190, 'P -6 2 c', transformations)
space_groups[190] = sg
space_groups['P -6 2 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(191, 'P 6/m m m', transformations)
space_groups[191] = sg
space_groups['P 6/m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(192, 'P 6/m c c', transformations)
space_groups[192] = sg
space_groups['P 6/m c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = | N.array([0,1,0,1,0,0,0,0,-1]) | numpy.array |
import numpy as np
from torchnet.meter import AverageValueMeter
from visdom import Visdom
class Trainer:
def __init__(self, args, model):
self.name = args.name
self.model = model
self.l1win = None
self.l2win = None
self.l1meter = AverageValueMeter()
self.l2meter = AverageValueMeter()
self.visdom = Visdom(port=args.vis_port) if args.vis_steps > 0 else None
@property
def mode(self):
return 'training' if self.model.training else 'testing'
@property
def losses(self):
return self.l1meter.value()[0], self.l2meter.value()[1]
def reset(self):
self.l1meter.reset()
self.l2meter.reset()
def log_losses(self, epoch, step):
l1, l2 = self.losses
message = f'{self.name} is {self.mode} (epoch: {epoch}, step: {step}) '
message += f'l1 average: {l1}, l2 average: {l2}'
print(message)
def vis_losses(self, epoch):
l1, l2 = self.losses
x, y1, y2 = np.array([epoch]), | np.array([l1]) | numpy.array |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
def rotate_pc_along_y(pc, rot_angle):
'''
Input:
pc: numpy array (N,C), first 3 channels are XYZ
z is facing forward, x is left ward, y is downward
rot_angle: rad scalar
Output:
pc: updated pc with XYZ rotated
'''
cosval = np.cos(rot_angle)
sinval = np.sin(rot_angle)
rotmat = np.array([[cosval, -sinval], [sinval, cosval]])
pc = pc.copy()
pc[:, [0, 2]] = np.dot(pc[:, [0, 2]], | np.transpose(rotmat) | numpy.transpose |
"""
Copyright (c) 2017, <NAME>
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of anybody else.
"""
import os
import numpy as np
class POWER:
class Data:
def __init__(self, data):
self.x = data.astype(np.float32)
self.N = self.x.shape[0]
def __init__(self, root):
trn, val, tst = load_data_normalised(root)
self.trn = self.Data(trn)
self.val = self.Data(val)
self.tst = self.Data(tst)
self.n_dims = self.trn.x.shape[1]
def load_data(root):
return np.load(os.path.join(root, 'power/data.npy'))
def load_data_split_with_noise(root):
rng = np.random.RandomState(42)
data = load_data(root)
rng.shuffle(data)
N = data.shape[0]
data = | np.delete(data, 3, axis=1) | numpy.delete |
import numpy as np
from scipy.signal import find_peaks, peak_widths, peak_prominences
from scipy.signal import savgol_filter
import matplotlib.pyplot as plt
from scipy.signal import find_peaks, peak_widths, peak_prominences
import pandas as pd
def dist_sarco(img, meta, lines, directory, plot=False, save = False):
dist = np.empty((len(lines), len(img)))
for frame, im in enumerate(img):
for num, li in enumerate(lines):
peak, _ = find_peaks(im[li[1], li[0]], distance=7)
dist_p = np.diff(peak)*meta['PhysicalSizeX']
dist[num, frame] = np.mean(dist_p)
dist_smooth = []
for i in range(len(dist)):
dist_smooth.append(savgol_filter(dist[i], 31, 5))
if plot:
fig, ax = plt.subplots(nrows = 1+(len(dist)*2), figsize=(12,36))
ax[0].imshow(img[0])
cycle = plt.rcParams['axes.prop_cycle'].by_key()['color']
for i, li in enumerate(lines):
ax[0].plot(li[0], li[1], c=cycle[i])
k=0
j=1
for i in range(len(dist)):
k+=2
ax[j].plot(meta['Timepoint']*100, dist[i], label="Raw Data")
ax[j].plot(meta['Timepoint']*100, dist_smooth[i], label="Smoothed Data", c = cycle[i-1])
ax[j].legend()
ax[j].set_xlabel('Time in ms')
ax[j].set_ylabel('Sarcomere length (um)')
ax[j].set_title('Example 1')
positive_raw = 100-((dist[i] / np.percentile(dist[i], 90)))*100
positive_smooth = 100-((dist_smooth[i] / np.percentile(dist_smooth[i], 90)))*100
ax[k].plot(meta['Timepoint']*100, positive_raw, label="Raw Data")
ax[k].plot(meta['Timepoint']*100, positive_smooth, label="Smoothed Data")
ax[k].legend()
ax[k].set_xlabel('Time in ms')
ax[k].set_ylabel('Sarcomere shortening (%)')
j+=2
plt.savefig("sarcomere_ex1_data.pdf", transparent=True)
if save:
try:
filename = meta['Name']+'.pdf'
plt.savefig(directory+'/'+filename, transparent=True)
except FileNotFoundError:
plt.savefig(filename, transparent=True)
return dist_smooth
def av_dist_sarco(img, meta, lines, directory, plot=True, save = False):
mean_time = np.empty(len(img))
for frame, im in enumerate(img):
peaks_lst = []
for li in lines:
peaks, _ = find_peaks(im[li[1], li[0]], distance=7)
peaks_lst.append(peaks)
dists = []
for peak in peaks_lst:
dists.append(np.diff(peak)*meta['PhysicalSizeX'])
mean_time[frame] = np.mean( | np.hstack(dists) | numpy.hstack |
"""
Copyright (C) 2019 NVIDIA Corporation. All rights reserved.
Licensed under the CC BY-NC-SA 4.0 license
(https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode).
"""
import torch
from torch.utils.data import Dataset
import numpy as np
import time
import os
import cv2
import sys
import utils
from datasets.scannet_scene import ScanNetScene
class PlaneDatasetSingle(Dataset):
def __init__(self, options, config, split, random=True, loadNeighborImage=False, load_semantics=False, load_boundary=False):
self.options = options
self.config = config
self.split = split
self.random = random
self.dataFolder = options.dataFolder
self.scenes = []
self.sceneImageIndices = []
self.loadClassMap()
planenet_scene_ids_val = np.load('datasets/scene_ids_val.npy')
planenet_scene_ids_val = {scene_id.decode('utf-8'): True for scene_id in planenet_scene_ids_val}
with open(self.dataFolder + '/ScanNet/Tasks/Benchmark/scannetv1_' + split + '.txt') as f:
for line in f:
scene_id = line.strip()
if split == 'test':
## Remove scenes which are in PlaneNet's training set for fair comparison
if scene_id not in planenet_scene_ids_val:
continue
pass
scenePath = self.dataFolder + '/scans/' + scene_id
if not os.path.exists(scenePath + '/' + scene_id + '.txt') or not os.path.exists(scenePath + '/annotation/planes.npy'):
continue
scene = ScanNetScene(options, scenePath, scene_id, self.confident_labels, self.layout_labels, load_semantics=load_semantics, load_boundary=load_boundary)
self.scenes.append(scene)
self.sceneImageIndices += [[len(self.scenes) - 1, imageIndex] for imageIndex in range(len(scene.imagePaths))]
continue
pass
if random:
t = int(time.time() * 1000000)
np.random.seed(((t & 0xff000000) >> 24) +
((t & 0x00ff0000) >> 8) +
((t & 0x0000ff00) << 8) +
((t & 0x000000ff) << 24))
else:
np.random.seed(0)
pass
np.random.shuffle(self.sceneImageIndices)
self.invalid_indices = {}
with open(self.dataFolder + '/invalid_indices_' + split + '.txt', 'r') as f:
for line in f:
tokens = line.split(' ')
if len(tokens) == 3:
assert(int(tokens[2]) < 10000)
invalid_index = int(tokens[1]) * 10000 + int(tokens[2])
if invalid_index not in self.invalid_indices:
self.invalid_indices[invalid_index] = True
pass
pass
continue
pass
self.sceneImageIndices = [[sceneIndex, imageIndex] for sceneIndex, imageIndex in self.sceneImageIndices if (sceneIndex * 10000 + imageIndex) not in self.invalid_indices]
print('num images', len(self.sceneImageIndices))
self.anchors = utils.generate_pyramid_anchors(config.RPN_ANCHOR_SCALES,
config.RPN_ANCHOR_RATIOS,
config.BACKBONE_SHAPES,
config.BACKBONE_STRIDES,
config.RPN_ANCHOR_STRIDE)
self.loadNeighborImage = loadNeighborImage
return
def loadClassMap(self):
classLabelMap = {}
with open(self.dataFolder + '/scannetv2-labels.combined.tsv') as info_file:
line_index = 0
for line in info_file:
if line_index > 0:
line = line.split('\t')
key = line[1].strip()
if line[4].strip() != '':
label = int(line[4].strip())
else:
label = -1
pass
classLabelMap[key] = label
classLabelMap[key + 's'] = label
classLabelMap[key + 'es'] = label
pass
line_index += 1
continue
pass
confidentClasses = {'wall': True,
'floor': True,
'cabinet': True,
'bed': True,
'chair': False,
'sofa': False,
'table': True,
'door': True,
'window': True,
'bookshelf': False,
'picture': True,
'counter': True,
'blinds': False,
'desk': True,
'shelf': False,
'shelves': False,
'curtain': False,
'dresser': True,
'pillow': False,
'mirror': False,
'entrance': True,
'floor mat': True,
'clothes': False,
'ceiling': True,
'book': False,
'books': False,
'refridgerator': True,
'television': True,
'paper': False,
'towel': False,
'shower curtain': False,
'box': True,
'whiteboard': True,
'person': False,
'night stand': True,
'toilet': False,
'sink': False,
'lamp': False,
'bathtub': False,
'bag': False,
'otherprop': False,
'otherstructure': False,
'otherfurniture': False,
'unannotated': False,
'': False
}
self.confident_labels = {}
for name, confidence in confidentClasses.items():
if confidence and name in classLabelMap:
self.confident_labels[classLabelMap[name]] = True
pass
continue
self.layout_labels = {1: True, 2: True, 22: True, 9: True}
return
def __len__(self):
return len(self.sceneImageIndices)
def transformPlanes(self, transformation, planes):
planeOffsets = np.linalg.norm(planes, axis=-1, keepdims=True)
centers = planes
centers = np.concatenate([centers, np.ones((planes.shape[0], 1))], axis=-1)
newCenters = np.transpose(np.matmul(transformation, np.transpose(centers)))
newCenters = newCenters[:, :3] / newCenters[:, 3:4]
refPoints = planes - planes / np.maximum(planeOffsets, 1e-4)
refPoints = np.concatenate([refPoints, np.ones((planes.shape[0], 1))], axis=-1)
newRefPoints = np.transpose(np.matmul(transformation, np.transpose(refPoints)))
newRefPoints = newRefPoints[:, :3] / newRefPoints[:, 3:4]
planeNormals = newRefPoints - newCenters
planeNormals /= np.linalg.norm(planeNormals, axis=-1, keepdims=True)
planeOffsets = np.sum(newCenters * planeNormals, axis=-1, keepdims=True)
newPlanes = planeNormals * planeOffsets
return newPlanes
def __getitem__(self, index):
t = int(time.time() * 1000000)
np.random.seed(((t & 0xff000000) >> 24) +
((t & 0x00ff0000) >> 8) +
((t & 0x0000ff00) << 8) +
((t & 0x000000ff) << 24))
if self.config.ANCHOR_TYPE == 'layout':
return self.getItemLayout(index)
if self.config.ANCHOR_TYPE == 'structure':
return self.getItemStructure(index)
while True:
if self.random:
index = np.random.randint(len(self.sceneImageIndices))
else:
index = index % len(self.sceneImageIndices)
pass
sceneIndex, imageIndex = self.sceneImageIndices[index]
scene = self.scenes[sceneIndex]
try:
image, planes, plane_info, segmentation, depth, camera, extrinsics = scene[imageIndex]
if len(planes) == 0:
index += 1
continue
except:
index += 1
continue
pass
if segmentation.max() < 0:
index += 1
continue
break
instance_masks = []
class_ids = []
parameters = []
if len(planes) > 0:
if 'joint' in self.config.ANCHOR_TYPE:
distances = np.linalg.norm(np.expand_dims(planes, 1) - self.config.ANCHOR_PLANES, axis=-1)
plane_anchors = distances.argmin(-1)
elif self.config.ANCHOR_TYPE == 'Nd':
plane_offsets = np.linalg.norm(planes, axis=-1)
plane_normals = planes / np.expand_dims(plane_offsets, axis=-1)
distances_N = np.linalg.norm(np.expand_dims(plane_normals, 1) - self.config.ANCHOR_NORMALS, axis=-1)
normal_anchors = distances_N.argmin(-1)
distances_d = np.abs(np.expand_dims(plane_offsets, -1) - self.config.ANCHOR_OFFSETS)
offset_anchors = distances_d.argmin(-1)
elif self.config.ANCHOR_TYPE in ['normal', 'patch']:
plane_offsets = np.linalg.norm(planes, axis=-1)
plane_normals = planes / np.expand_dims(plane_offsets, axis=-1)
distances_N = np.linalg.norm(np.expand_dims(plane_normals, 1) - self.config.ANCHOR_NORMALS, axis=-1)
normal_anchors = distances_N.argmin(-1)
elif self.config.ANCHOR_TYPE == 'normal_none':
plane_offsets = np.linalg.norm(planes, axis=-1)
plane_normals = planes / np.expand_dims(plane_offsets, axis=-1)
pass
pass
for planeIndex, plane in enumerate(planes):
m = segmentation == planeIndex
if m.sum() < 1:
continue
instance_masks.append(m)
if self.config.ANCHOR_TYPE == 'none':
class_ids.append(1)
parameters.append(np.concatenate([plane, np.zeros(1)], axis=0))
elif 'joint' in self.config.ANCHOR_TYPE:
class_ids.append(plane_anchors[planeIndex] + 1)
residual = plane - self.config.ANCHOR_PLANES[plane_anchors[planeIndex]]
parameters.append(np.concatenate([residual, np.zeros(1)], axis=0))
elif self.config.ANCHOR_TYPE == 'Nd':
class_ids.append(normal_anchors[planeIndex] * len(self.config.ANCHOR_OFFSETS) + offset_anchors[planeIndex] + 1)
normal = plane_normals[planeIndex] - self.config.ANCHOR_NORMALS[normal_anchors[planeIndex]]
offset = plane_offsets[planeIndex] - self.config.ANCHOR_OFFSETS[offset_anchors[planeIndex]]
parameters.append(np.concatenate([normal, np.array([offset])], axis=0))
elif self.config.ANCHOR_TYPE == 'normal':
class_ids.append(normal_anchors[planeIndex] + 1)
normal = plane_normals[planeIndex] - self.config.ANCHOR_NORMALS[normal_anchors[planeIndex]]
parameters.append(np.concatenate([normal, np.zeros(1)], axis=0))
elif self.config.ANCHOR_TYPE == 'normal_none':
class_ids.append(1)
normal = plane_normals[planeIndex]
parameters.append(np.concatenate([normal, np.zeros(1)], axis=0))
else:
assert(False)
pass
continue
parameters = np.array(parameters, dtype=np.float32)
mask = np.stack(instance_masks, axis=2)
class_ids = np.array(class_ids, dtype=np.int32)
image, image_metas, gt_class_ids, gt_boxes, gt_masks, gt_parameters = load_image_gt(self.config, index, image, mask, class_ids, parameters, augment=self.split == 'train')
## RPN Targets
rpn_match, rpn_bbox = build_rpn_targets(image.shape, self.anchors,
gt_class_ids, gt_boxes, self.config)
## If more instances than fits in the array, sub-sample from them.
if gt_boxes.shape[0] > self.config.MAX_GT_INSTANCES:
ids = np.random.choice(
np.arange(gt_boxes.shape[0]), self.config.MAX_GT_INSTANCES, replace=False)
gt_class_ids = gt_class_ids[ids]
gt_boxes = gt_boxes[ids]
gt_masks = gt_masks[:, :, ids]
gt_parameters = gt_parameters[ids]
## Add to batch
rpn_match = rpn_match[:, np.newaxis]
image = utils.mold_image(image.astype(np.float32), self.config)
depth = np.concatenate([np.zeros((80, 640)), depth, np.zeros((80, 640))], axis=0)
segmentation = np.concatenate([np.full((80, 640), fill_value=-1, dtype=np.int32), segmentation, np.full((80, 640), fill_value=-1, dtype=np.int32)], axis=0)
info = [image.transpose((2, 0, 1)).astype(np.float32), image_metas, rpn_match, rpn_bbox.astype(np.float32), gt_class_ids, gt_boxes.astype(np.float32), gt_masks.transpose((2, 0, 1)).astype(np.float32), gt_parameters, depth.astype(np.float32), segmentation, camera.astype(np.float32)]
if self.loadNeighborImage:
if imageIndex + self.options.frameGap < len(scene.imagePaths):
imagePath = scene.imagePaths[imageIndex + self.options.frameGap]
else:
imagePath = scene.imagePaths[imageIndex - self.options.frameGap]
pass
image_2 = cv2.imread(imagePath)
image_2 = cv2.resize(image_2, (self.config.IMAGE_MAX_DIM, self.config.IMAGE_MAX_DIM))
info.append(image_2.transpose((2, 0, 1)).astype(np.float32))
extrinsics_2_inv = []
posePath = imagePath.replace('color', 'pose').replace('.jpg', '.txt')
with open(posePath, 'r') as f:
for line in f:
extrinsics_2_inv += [float(value) for value in line.strip().split(' ') if value.strip() != '']
continue
f.close()
pass
extrinsics_2_inv = np.array(extrinsics_2_inv).reshape((4, 4))
extrinsics_2 = np.linalg.inv(extrinsics_2_inv)
temp = extrinsics_2[1].copy()
extrinsics_2[1] = extrinsics_2[2]
extrinsics_2[2] = -temp
transformation = np.matmul(extrinsics_2, np.linalg.inv(extrinsics))
if np.any(np.isnan(transformation)):
transformation = np.concatenate([np.diag(np.ones(3)), np.zeros((3, 1))], axis=-1)
pass
rotation = transformation[:3, :3]
translation = transformation[:3, 3]
axis, angle = utils.rotationMatrixToAxisAngle(rotation)
pose = np.concatenate([translation, axis * angle], axis=0).astype(np.float32)
info.append(pose)
info.append(scene.scenePath + ' ' + str(imageIndex))
pass
return info
def getAnchorPlanesNormalOffset(self, visualize=False):
for k in [7, ]:
print('k', k)
filename_N = self.dataFolder + '/anchor_planes_N_' + str(k) + '.npy'
filename_d = self.dataFolder + '/anchor_planes_d.npy'
if os.path.exists(filename_N) and os.path.exists(filename_d) and False:
return
if os.path.exists('test/anchor_planes/all_planes.npy'):
all_planes = np.load('test/anchor_planes/all_planes.npy')
else:
all_planes = []
for sceneIndex, imageIndex in self.sceneImageIndices[:10000]:
if len(all_planes) % 100 == 0:
print(len(all_planes))
pass
scene = self.scenes[sceneIndex]
image, planes, plane_info, segmentation, depth, camera, extrinsics = scene[imageIndex]
planes = planes[np.linalg.norm(planes, axis=-1) > 1e-4]
if len(planes) == 0:
continue
all_planes.append(planes)
continue
all_planes = np.concatenate(all_planes, axis=0)
np.save('test/anchor_planes/all_planes.npy', all_planes)
pass
from sklearn.cluster import KMeans
num_anchor_planes_N = k
num_anchor_planes_d = 3
offsets = np.linalg.norm(all_planes, axis=-1)
normals = all_planes / np.expand_dims(offsets, -1)
kmeans_N = KMeans(n_clusters=num_anchor_planes_N).fit(normals)
self.anchor_planes_N = kmeans_N.cluster_centers_
## Global offset anchors
kmeans_d = KMeans(n_clusters=num_anchor_planes_d).fit(np.expand_dims(offsets, -1))
self.anchor_planes_d = kmeans_d.cluster_centers_
if visualize:
color_map = utils.ColorPalette(max(num_anchor_planes_N, num_anchor_planes_d)).getColorMap()
normals_rotated = normals.copy()
normals_rotated[:, 1] = normals[:, 2]
normals_rotated[:, 2] = -normals[:, 1]
plane_cloud = np.concatenate([normals_rotated, color_map[kmeans_N.labels_]], axis=-1)
utils.writePointCloud('test/anchor_planes/anchor_planes_N.ply', plane_cloud)
plane_cloud = np.concatenate([all_planes, color_map[kmeans_d.labels_]], axis=-1)
utils.writePointCloud('test/anchor_planes/anchor_planes_d.ply', plane_cloud)
width = 500
height = 500
Us = np.round(np.arctan2(normals[:, 1], normals[:, 0]) / np.pi * width).astype(np.int32)
Vs = np.round((1 - (np.arcsin(normals[:, 2]) + np.pi / 2) / np.pi) * height).astype(np.int32)
indices = Vs * width + Us
validMask = np.logical_and(np.logical_and(Us >= 0, Us < width), np.logical_and(Vs >= 0, Vs < height))
indices = indices[validMask]
normalImage = np.zeros((height * width, 3))
normalImage[indices] = color_map[kmeans_N.labels_[validMask]]
normalImage = normalImage.reshape((height, width, 3))
cv2.imwrite('test/anchor_planes/normal_color_' + str(k) + '.png', normalImage)
exit(1)
pass
np.save(filename_N, self.anchor_planes_N)
np.save(filename_d, self.anchor_planes_d)
continue
return
def load_image_gt(config, image_id, image, depth, mask, class_ids, parameters, augment=False,
use_mini_mask=True):
"""Load and return ground truth data for an image (image, mask, bounding boxes).
augment: If true, apply random image augmentation. Currently, only
horizontal flipping is offered.
use_mini_mask: If False, returns full-size masks that are the same height
and width as the original image. These can be big, for example
1024x1024x100 (for 100 instances). Mini masks are smaller, typically,
224x224 and are generated by extracting the bounding box of the
object and resizing it to MINI_MASK_SHAPE.
Returns:
image: [height, width, 3]
shape: the original shape of the image before resizing and cropping.
class_ids: [instance_count] Integer class IDs
bbox: [instance_count, (y1, x1, y2, x2)]
mask: [height, width, instance_count]. The height and width are those
of the image unless use_mini_mask is True, in which case they are
defined in MINI_MASK_SHAPE.
"""
## Load image and mask
shape = image.shape
image, window, scale, padding = utils.resize_image(
image,
min_dim=config.IMAGE_MAX_DIM,
max_dim=config.IMAGE_MAX_DIM,
padding=config.IMAGE_PADDING)
mask = utils.resize_mask(mask, scale, padding)
## Random horizontal flips.
if augment and False:
if np.random.randint(0, 1):
image = np.fliplr(image)
mask = np.fliplr(mask)
depth = np.fliplr(depth)
pass
pass
## Bounding boxes. Note that some boxes might be all zeros
## if the corresponding mask got cropped out.
## bbox: [num_instances, (y1, x1, y2, x2)]
bbox = utils.extract_bboxes(mask)
## Resize masks to smaller size to reduce memory usage
if use_mini_mask:
mask = utils.minimize_mask(bbox, mask, config.MINI_MASK_SHAPE)
pass
active_class_ids = np.ones(config.NUM_CLASSES, dtype=np.int32)
## Image meta data
image_meta = utils.compose_image_meta(image_id, shape, window, active_class_ids)
if config.NUM_PARAMETER_CHANNELS > 0:
if config.OCCLUSION:
depth = utils.resize_mask(depth, scale, padding)
mask_visible = utils.minimize_mask(bbox, depth, config.MINI_MASK_SHAPE)
mask = np.stack([mask, mask_visible], axis=-1)
else:
depth = np.expand_dims(depth, -1)
depth = utils.resize_mask(depth, scale, padding).squeeze(-1)
depth = utils.minimize_depth(bbox, depth, config.MINI_MASK_SHAPE)
mask = np.stack([mask, depth], axis=-1)
pass
pass
return image, image_meta, class_ids, bbox, mask, parameters
def build_rpn_targets(image_shape, anchors, gt_class_ids, gt_boxes, config):
"""Given the anchors and GT boxes, compute overlaps and identify positive
anchors and deltas to refine them to match their corresponding GT boxes.
anchors: [num_anchors, (y1, x1, y2, x2)]
gt_class_ids: [num_gt_boxes] Integer class IDs.
gt_boxes: [num_gt_boxes, (y1, x1, y2, x2)]
Returns:
rpn_match: [N] (int32) matches between anchors and GT boxes.
1 = positive anchor, -1 = negative anchor, 0 = neutral
rpn_bbox: [N, (dy, dx, log(dh), log(dw))] Anchor bbox deltas.
"""
## RPN Match: 1 = positive anchor, -1 = negative anchor, 0 = neutral
rpn_match = np.zeros([anchors.shape[0]], dtype=np.int32)
## RPN bounding boxes: [max anchors per image, (dy, dx, log(dh), log(dw))]
rpn_bbox = | np.zeros((config.RPN_TRAIN_ANCHORS_PER_IMAGE, 4)) | numpy.zeros |
import matplotlib.pyplot as plt
import numpy as np
from MLG import imagepath, paperpath, path
from imageio import imread
import matplotlib.cbook as cbook
from MLG.utils import color_own
from matplotlib import rc
__all__ = ['dark','Image_Window','Image_precision','Image_Illustration','Image_Illustration_Multi','Image_compare_micro','Image_astroshift', 'create_all_Image']
def dark(onof = 0):
if onof is 'on': plt.style.use('dark_background')
elif onof is 'off': plt.style.use('default')
elif onof == True: plt.style.use('dark_background')
else: plt.style.use('default')
def Image_Window(string = 'resolve_Window', pres = False):
'''------------------------------------------------------------
Description:
---------------------------------------------------------------
Input:
---------------------------------------------------------------
Output:
------------------------------------------------------------'''
dark= 'black' in plt.rcParams['savefig.facecolor']
if dark:
string = 'dark_'+string
black = color_own([0.7,0.7,0.7,1])
else: black = color_own([0.,0.,0.,1])
c1 = color_own([0,1,1,1])
c2 = color_own([1,0,0,1])
c3 = color_own([1,1,0.2,1])
c4 = color_own([0.4,0.4,0.4,1])
c_star = [c1,c2,c3,c4]
c_grid1 = color_own([0,int(dark),1,1])
c_grid2 = color_own([0.5,1,0,1])
star= np.array([[0, 0],[0.1,0.9],[-1,-1.1],[-0.5,0.1]])
fig = plt.figure(figsize = [12,12])
x_width = 0.059
y_width = 0.177
#------------------------------------------------------------
# axis
plt.xticks( fontsize = 25)
plt.yticks( fontsize = 25)
plt.grid(True)
plt.axis('equal')
plt.axis([-1.5,1.5,-1.4,1.6])
plt.ylabel('Across-scan direction (AC) [arcsec]', fontsize = 30)
plt.xlabel('Along-scan direction (AL) [arcsec]', fontsize = 30)
#------------------------------------------------------------
#------------------------------------------------------------
#Grid Major Star
for i in range(-6,7):
plt.plot([-6*x_width,6*x_width], [i*y_width,i*y_width], c = c_grid1,linewidth = 3)
plt.plot([i*x_width,i*x_width], [-6*y_width,6*y_width], c = c_grid1, linewidth = 3)
plt.text(0,1.4,"Along-scan direction\n $12\,\mathrm{pix} \\times 0.059 \mathrm{''/pix} = 0.708\mathrm{''}$",fontsize = 25, verticalalignment = 'center', horizontalalignment = 'center', rotation = 0)
plt.text(0.7,0,"Across-scan direction\n $12\,\mathrm{pix} \\times 0.177 \mathrm{''/pix} = 2.124\mathrm{''}$",fontsize = 25, verticalalignment = 'center', horizontalalignment = 'center', rotation = 90)
plt.arrow(0,6*y_width+2*x_width, -6*x_width+0.02,0,color= black, head_width=0.1,\
overhang = 0.5, length_includes_head=True ,zorder = 10, linewidth = 3)
plt.arrow(0,6*y_width+2*x_width, 6*x_width-0.02,0,color= black, head_width=0.1,\
overhang = 0.5, length_includes_head=True ,zorder = 10, linewidth = 3)
plt.arrow(8*x_width,0,0, -6*y_width+0.02,color= black, head_width=0.1,\
overhang = 0.5, length_includes_head=True ,zorder = 10, linewidth = 3)
plt.arrow(8*x_width,0,0, 6*y_width-0.02,color= black, head_width=0.1,\
overhang = 0.5, length_includes_head=True ,zorder = 10, linewidth = 3)
plt.scatter(star[:1,0], star[:1,1], marker=(5, 1),c = c_star[:1], s = [3000], zorder = 1000)
if pres: fig.savefig(imagepath + string + '_1.png', format = 'png')
#------------------------------------------------------------
#------------------------------------------------------------
#Grid Minor Star
plt.scatter(star[1:3,0], star[1:3,1], marker=(5, 1),c = c_star[1:3], s = [2000,2000], zorder = 1000)
if pres: fig.savefig(imagepath + string + '_2.png', format = 'png')
for i in range(-5,8):
plt.plot([-15*x_width,-6*x_width], [i*y_width,i*y_width], c = c_grid2,linewidth = 3, zorder = -1)
for i in range(-15,-5):
plt.plot([i*x_width,i*x_width], [-5*y_width,7*y_width], c = c_grid2, linewidth = 3, zorder = -1)
plt.scatter(star[3:,0], star[3:,1], marker=(5, 1),c = c_star[3:], s = [2000], zorder = 1000)
if pres: fig.savefig(imagepath + string + '_3.png', format = 'png')
#------------------------------------------------------------
fig.savefig(imagepath + string + '.png', format = 'png')
print('Create Image: '+ imagepath+ string + '.png')
if paperpath is not None: fig.savefig(paperpath + string + '.png', format = 'png')
plt.close(fig)
def Image_precision(string = 'Sig_vs_Gmag', Gaia_precision = path+'InputTable/resolution_Gaia.png', pres = False):
'''------------------------------------------------------------
Description:
---------------------------------------------------------------
Input:
---------------------------------------------------------------
Output:
------------------------------------------------------------'''
dark= 'black' in plt.rcParams['savefig.facecolor']
if dark:
string = 'dark_'+string
black = color_own([0.7,0.7,0.7,1])
color1 = color_own([0.85,0,0,1])
color2 = color_own([0,0,1,1])
color3 = color_own([0,1,1,1])
color4 = color_own([0.5,1,0,1])
color5 = color_own([1,1,0,1])
else:
black = color_own([0.,0.,0.,1])
color1 = color_own([0.85,0,0,1])
color2 = color_own([0,0,1,1])
color3 = color_own([0,1,1,1])
color4 = color_own([0,1,0,1])
color5 = color_own([1,1,0,1])
fig = plt.figure(figsize = [12,10])
Gmag = np.arange(4,22,0.01)
datafile = cbook.get_sample_data(Gaia_precision)
img = imread(datafile)
z = 10 ** (0.4 * (np.maximum(Gmag, 14) - 15)) #(14-np.minimum(Gmag, 14))
z2 = 10 ** (0.4 * (np.maximum(Gmag, 12) - 15))
sig_pi = (-1.631 + 680.766 * z2 + 32.732 * z2**2)**0.5/1000
sig_fov2 =(-1.631 + 680.766 * z + 32.732 * z**2)**0.5/1000 *7.75 +0.1
sig_fov3 = sig_fov2 / np.sqrt(9)
plt.plot([0,1],[-5,-5], c = color1, linewidth = 3, label = 'formal precision from Gaia DR2 (per CCD)' )
plt.plot([0,1],[-5,-5], c = color2, linewidth = 3, label = 'actual precision from Gaia DR2 (per CCD)' )
plt.yticks([np.log10(i) for i in [20,10, 5,2,1, 0.5,0.2,0.1, 0.05,0.02, 0.01]],[20,10, 5,2,1, 0.5,0.2,0.1, 0.05,0.02,0.01], fontsize = 25)
plt.xticks( fontsize = 25)
plt.ylabel('Standard deviation of AL field angle [mas]', fontsize = 30)
plt.xlabel('G magnitude', fontsize = 30)
plt.imshow(img, zorder=0, extent=[5, 21.04, np.log10(0.0195),np.log10(10)])
plt.axis('auto')
plt.xlim([4,22])
plt.ylim([np.log10(0.005),np.log10(40)])
if pres:
plt.legend(loc = 'upper left',fontsize = 20)
fig.savefig(imagepath + string + '_1.png', format = 'png')
plt.plot(Gmag,np.log10(sig_pi), '--',c = color3, dashes =(5,5), linewidth = 3, label= 'predicted end-of-mission parallax error')
if pres:
plt.legend(loc = 'upper left',fontsize = 20)
fig.savefig(imagepath + string + '_2.png', format = 'png')
plt.plot(Gmag,np.log10(sig_fov2), ':' , c = color4, linewidth = 5, label= 'used Standard deviation (per CCD)' )
if pres:
plt.legend(loc = 'upper left',fontsize = 20)
fig.savefig(imagepath + string + '_3.png', format = 'png')
plt.plot(Gmag,np.log10(sig_fov3) ,c = color5,linewidth = 7, label= 'used Standard deviation for 9 CCD observations' )
plt.plot([5, 21.04, 21.04,5,5], [np.log10(0.0195),np.log10(0.0195),np.log10(10),np.log10(10),np.log10(0.0195)], linewidth = 2, color = [0.5,0.5,0.5,1], zorder = 0.1)
plt.axis('auto')
plt.xlim([4,22])
plt.ylim([np.log10(0.005),np.log10(40)])
plt.legend(loc = 'upper left',fontsize = 20)
fig.savefig(imagepath + string + '.png', format = 'png')
print('Create Image: '+ imagepath+ string + '.png')
if paperpath is not None: fig.savefig(paperpath + string + '.png', format = 'png')
plt.close(fig)
def Image_Illustration(string = 'Illustration'):
'''------------------------------------------------------------
Description:
---------------------------------------------------------------
Input:
---------------------------------------------------------------
Output:
------------------------------------------------------------'''
dark= 'black' in plt.rcParams['savefig.facecolor']
if dark:
string = 'dark_'+string
black = color_own([0.7,0.7,0.7,1])
color1 = color_own([0,1,1,1])
color2 = color_own([1,0.5,0,1])
color3 = color_own([0.5,1,0,1])
color4 = color_own([1,0,1,1])
color5 = color_own([0,1,1,1])
color6 = color_own([0,1,1,1])
else:
black = color_own([0.,0.,0.,1])
color1 = color_own([0,0,1,1])
color2 = color_own([1,0.5,0,1])
color3 = color_own([0,1,0,1])
color4 = color_own([1,0,1,1])
color5 = color_own([0,1,1,1])
color6 = color_own([0,1,1,1])
t = np.array([12, 35, 41, 61, 73, 89])
scandir = np.array([0.1, 0.7, 0.4, 0.8 , 0.2, 0.1])*np.pi
x1 = np.linspace(1,13,100) + 0.3 * np.sin(np.linspace(np.pi/4,12*np.pi/4,100))
y1 = np.linspace(1,3,100) + 0.3* np.cos(np.linspace(np.pi/4,12*np.pi/4,100))
x2 = np.linspace(3,7,100)# + 0.03 * np.sin(np.linspace(np.pi/4,12*np.pi/4,100))
y2 = np.linspace(7,4.5,100)# + 0.03* np.cos(np.linspace(np.pi/4,12*np.pi/4,100))
d = np.sqrt((x1-x2)**2 + (y1-y2)**2)
TE = 1.5
X2 = x2 + (x2-x1) * TE/(d**2 +2*TE)
Y2 = y2 + (y2-y1) * TE/(d**2 +2*TE)
dX2 = x1-X2
dY2 = y1-Y2
dx2 = x1-x2
dy2 = y1-y2
fig = plt.figure(figsize= (12,8))
ax = plt.subplot(111)
ax.axis('equal')
ax.axis('off')
for i in range(len(t)):
xm1 =np.array([-1,1]) * np.cos(scandir[i]) + x1[t[i]]
ym1 =np.array([-1,1]) * np.sin(scandir[i]) + y1[t[i]]
xm2 =np.array([-1,1]) * np.cos(scandir[i]) + X2[t[i]]
ym2 =np.array([-1,1]) * np.sin(scandir[i]) + Y2[t[i]]
dsc = ((dx2[t[i]]).reshape(-1,1)*[np.sin(scandir[i]),np.cos(scandir[i])] \
+ (dy2[t[i]]).reshape(-1,1) *[-np.cos(scandir[i]),np.sin(scandir[i])])[0]
dSC = ((dX2[t[i]]).reshape(-1,1)*[np.sin(scandir[i]),np.cos(scandir[i])] \
+ (dY2[t[i]]).reshape(-1,1) *[-np.cos(scandir[i]),np.sin(scandir[i])])[0]
ttX2 = np.array([0,-dSC[1]/2,dSC[1]/2,0]) * np.cos(scandir[i]) + ([x1[t[i]],x1[t[i]],X2[t[i]],X2[t[i]]])
ttY2 = np.array([0,-dSC[1]/2,dSC[1]/2,0]) * np.sin(scandir[i]) +([y1[t[i]],y1[t[i]],Y2[t[i]],Y2[t[i]]])
ttx2 = np.array([0,-dsc[1]/2-0.2,dsc[1]/2-0.2,0]) * np.cos(scandir[i]) + ([x1[t[i]],x1[t[i]],x2[t[i]],x2[t[i]]])
tty2 = np.array([0,-dsc[1]/2-0.2,dsc[1]/2-0.2,0]) * np.sin(scandir[i]) +([y1[t[i]],y1[t[i]],y2[t[i]],y2[t[i]]])
if i % 2 == 0:
plt.arrow(ttx2[2],tty2[2], 0.0001*(ttx2[2]-ttx2[1]),0.0001*(tty2[2]-tty2[1]),color= color1, head_width=0.2,\
overhang = 0.5, length_includes_head=True ,zorder = 10)
plt.arrow(ttx2[1],tty2[1], 0.0001*(ttx2[1]-ttx2[2]),0.0001*(tty2[1]-tty2[2]),color= color1, head_width=0.2,\
overhang = 0.5, length_includes_head=True ,zorder = 10)
plt.arrow(ttX2[2],ttY2[2], 0.0001*(ttX2[2]-ttX2[1]),0.0001*(ttY2[2]-ttY2[1]),color= color2, head_width=0.2,\
overhang = 0.5, length_includes_head=True ,zorder = 10)
plt.arrow(ttX2[1],ttY2[1], 0.0001*(ttX2[1]-ttX2[2]),0.0001*(ttY2[1]-ttY2[2]),color= color2, head_width=0.2,\
overhang = 0.5, length_includes_head=True, zorder = 10)
plt.plot(ttx2[0:2],tty2[0:2],color = black, linestyle= ':')
plt.plot(ttX2[0:2],ttY2[0:2],color = black, linestyle= ':')
plt.plot(ttx2[1:3],tty2[1:3],color = color1,linewidth = 3 , linestyle= '--',dashes=(10, 10))
plt.plot(ttX2[1:3],ttY2[1:3],color = color2, linewidth = 3,linestyle= '-')
plt.plot(ttx2[2:],tty2[2:],color = black, linestyle= ':')
plt.plot(ttX2[2:],ttY2[2:],color = black, linestyle= ':')
if i% 2 == 0:
plt.plot(xm2,ym2, color = black, linewidth = 3,zorder = 1)
plt.plot(xm1,ym1, color = black, linewidth = 3,zorder = 1)
else:
plt.plot(xm2,ym2, color = 'grey', linewidth = 2, zorder = -1)
plt.plot(xm1,ym1, color = 'grey', linewidth = 2, zorder = -1)
#if i ==0 :
plt.plot(x1,y1, color = color3, linewidth = 3)
plt.plot(x2,y2, color = color1, linestyle= '--',dashes=(10, 5), linewidth = 3, zorder = -1)
plt.plot(X2,Y2, color = color2, linewidth = 3)
plt.xlim([-0.5,14])
xr = 12
yr = 7
plt.text(xr-0.8,0,'RA $\cdot$ cos(Dec)',verticalalignment = 'center',fontsize = 25)
plt.text(0,yr + 0.25,'Dec',fontsize = 25, horizontalalignment = 'center', rotation = 90)
plt.arrow(-0.025,0,xr-1,0,width = 0.05,overhang = 0.5,head_width = 0.5, head_length = 0.5,color= black, zorder = 100,length_includes_head=True)
plt.arrow(0,-0.025,0,yr-0.5,width = 0.05,overhang = 0.5,head_width = 0.5,head_length = 0.5,color= black, zorder = 100,length_includes_head=True)
plt.text(2,1.5,'Lens',color = color3, fontsize = 25, horizontalalignment = 'center', rotation = 0, weight = 'bold')
plt.text(4,7.5,'Star 1',color = color2,fontsize = 25, horizontalalignment = 'center', rotation = 0,weight = 'bold')
fig.savefig(imagepath + string + '.png', format = 'png')
print('Create Image: '+ imagepath+ string + '.png')
if paperpath is not None: fig.savefig(paperpath + string + '.png', format = 'png')
plt.close(fig)
def Image_Illustration2 (string = 'Illustration'):
'''------------------------------------------------------------
Description:
---------------------------------------------------------------
Input:
---------------------------------------------------------------
Output:
------------------------------------------------------------'''
dark= 'black' in plt.rcParams['savefig.facecolor']
if dark:
string = 'dark_'+string
black = color_own([0.,0.,0.,1])
grey = color_own([.5,.5,0.5,1])
cyan = color_own([0,1,1,1])
blue = color_own([0,0,1,1])
lime = color_own([0.6,1.2,0,1])
green = color_own([0,1,0,1])
red = color_own([1,0,0,1])
orange = color_own([1,1,0,1])
else:
black = color_own([0.,0.,0.,1])
grey = color_own([.5,.5,0.5,1])
cyan = color_own([0,1,1,1])
blue = color_own([0,0,1,1])
lime = color_own([0.6,1.2,0,1])
green = color_own([0,1,0,1])
red = color_own([1,0,0,1])
orange = color_own([1,1,0,1])
t = np.array([12, 35, 41, 61, 73, 89])
scandir = np.array([0.1, 0.7, 0.4, 0.8 , 0.2, 0.1])*np.pi
#Position_lens
x1 = np.linspace(1,13,100) + 0.3 * np.sin(np.linspace(np.pi/4,12*np.pi/4,100))
y1 = np.linspace(1,3,100) + 0.3* np.cos(np.linspace(np.pi/4,12*np.pi/4,100))
#unlensed Position_source
x2 = np.linspace(5,9,100)# + 0.03 * np.sin(np.linspace(np.pi/4,12*np.pi/4,100))
y2 = np.linspace(7,4.5,100)# + 0.03* np.cos(np.linspace(np.pi/4,12*np.pi/4,100))
d = np.sqrt((x1-x2)**2 + (y1-y2)**2)
TE = 2
X2 = x2 + (x2-x1) * TE/(d**2 +2*TE)
Y2 = y2 + (y2-y1) * TE/(d**2 +2*TE)
dX2 = x1-X2
dY2 = y1-Y2
dx2 = x1-x2
dy2 = y1-y2
fig = plt.figure(figsize= (12,8))
ax = plt.subplot(111)
ax.axis('equal')
ax.axis('off')
#---------------------------------------------------------------
#axis
plt.xlim([-0.5,14])
xr = 12
yr = 7
plt.text(xr-0.8,0,'RA $\cdot$ cos(Dec)',verticalalignment = 'center',fontsize = 25)
plt.text(0,yr + 0.25,'Dec',fontsize = 25, horizontalalignment = 'center', rotation = 90)
plt.arrow(-0.025,0,xr-1,0,width = 0.05,overhang = 0.5,head_width = 0.5, head_length = 0.5,color= black, zorder = 100,length_includes_head=True)
plt.arrow(0,-0.025,0,yr-0.5,width = 0.05,overhang = 0.5,head_width = 0.5,head_length = 0.5,color= black, zorder = 100,length_includes_head=True)
plt.text(2,1.5,'Lens',color = grey, fontsize = 25, horizontalalignment = 'center', rotation = 0, weight = 'bold')
#---------------------------------------------------------------
# Motion source
plt.plot(x1,y1, color = grey, linewidth = 7)
fig.savefig(imagepath + string + '_1.png', format = 'png')
plt.text(4,7.5,'Source',color = blue,fontsize = 25, horizontalalignment = 'center', rotation = 0,weight = 'bold')
plt.plot(x2,y2, color = cyan, linestyle= '--',dashes=(10, 5), linewidth = 3, zorder = -1)
fig.savefig(imagepath + string + '_2.png', format = 'png')
plt.plot(X2,Y2, color = blue, linewidth = 3)
for i in range(len(t)):
plt.plot([x2[t[i]],X2[t[i]]],[y2[t[i]],Y2[t[i]]],':',color = black)
fig.savefig(imagepath + string + '_3.png', format = 'png')
delta = 0.05
for i in range(len(t)):
xm1 =np.array([-1,1,1,-1,-1]) * np.cos(scandir[i]) + delta * np.array([-1,-1,1,1,-1]) * np.sin(scandir[i]) + x1[t[i]]
ym1 =np.array([-1,1,1,-1,-1]) * np.sin(scandir[i]) - delta * np.array([-1,-1,1,1,-1]) * np.cos(scandir[i]) + y1[t[i]]
xm2 =np.array([-1,1,1,-1,-1]) * np.cos(scandir[i]) + delta * np.array([-1,-1,1,1,-1]) * np.sin(scandir[i]) + X2[t[i]]
ym2 =np.array([-1,1,1,-1,-1]) * np.sin(scandir[i]) - delta * np.array([-1,-1,1,1,-1]) * np.cos(scandir[i]) + Y2[t[i]]
plt.plot(xm2,ym2, color = black, linewidth = 1,zorder = 1)
plt.plot(xm1,ym1, color = black, linewidth = 1,zorder = 1)
fig.savefig(imagepath + string + '_4.png', format = 'png')
for i in range(len(t)):
xm1 =np.array([-1,1,1,-1,-1]) * np.cos(scandir[i]) + delta * np.array([-1,-1,1,1,-1]) * np.sin(scandir[i]) + x1[t[i]]
ym1 =np.array([-1,1,1,-1,-1]) * np.sin(scandir[i]) - delta * np.array([-1,-1,1,1,-1]) * np.cos(scandir[i]) + y1[t[i]]
xm2 =np.array([-1,1,1,-1,-1]) * np.cos(scandir[i]) + delta * np.array([-1,-1,1,1,-1]) * np.sin(scandir[i]) + X2[t[i]]
ym2 =np.array([-1,1,1,-1,-1]) * np.sin(scandir[i]) - delta * np.array([-1,-1,1,1,-1]) * np.cos(scandir[i]) + Y2[t[i]]
dsc = ((dx2[t[i]]).reshape(-1,1)*[np.sin(scandir[i]),np.cos(scandir[i])] \
+ (dy2[t[i]]).reshape(-1,1) *[-np.cos(scandir[i]),np.sin(scandir[i])])[0]
dSC = ((dX2[t[i]]).reshape(-1,1)*[np.sin(scandir[i]),np.cos(scandir[i])] \
+ (dY2[t[i]]).reshape(-1,1) *[-np.cos(scandir[i]),np.sin(scandir[i])])[0]
ttX2 = np.array([0,-dSC[1]/2,dSC[1]/2,0]) * np.cos(scandir[i]) + ([x1[t[i]],x1[t[i]],X2[t[i]],X2[t[i]]])
ttY2 = np.array([0,-dSC[1]/2,dSC[1]/2,0]) * np.sin(scandir[i]) +([y1[t[i]],y1[t[i]],Y2[t[i]],Y2[t[i]]])
ttx2 = np.array([0,-dsc[1]/2-0.2,dsc[1]/2-0.2,0]) * np.cos(scandir[i]) + ([x1[t[i]],x1[t[i]],x2[t[i]],x2[t[i]]])
tty2 = np.array([0,-dsc[1]/2-0.2,dsc[1]/2-0.2,0]) * np.sin(scandir[i]) +([y1[t[i]],y1[t[i]],y2[t[i]],y2[t[i]]])
if i % 2 == 0:
plt.arrow(ttx2[2],tty2[2], 0.0001*(ttx2[2]-ttx2[1]),0.0001*(tty2[2]-tty2[1]),color= red, head_width=0.2,\
overhang = 0.5, length_includes_head=True ,zorder = 10)
plt.arrow(ttx2[1],tty2[1], 0.0001*(ttx2[1]-ttx2[2]),0.0001*(tty2[1]-tty2[2]),color= red, head_width=0.2,\
overhang = 0.5, length_includes_head=True ,zorder = 10)
plt.arrow(ttX2[2],ttY2[2], 0.0001*(ttX2[2]-ttX2[1]),0.0001*(ttY2[2]-ttY2[1]),color= orange, head_width=0.2,\
overhang = 0.5, length_includes_head=True ,zorder = 10)
plt.arrow(ttX2[1],ttY2[1], 0.0001*(ttX2[1]-ttX2[2]),0.0001*(ttY2[1]-ttY2[2]),color= orange, head_width=0.2,\
overhang = 0.5, length_includes_head=True, zorder = 10)
plt.plot(ttx2[0:2],tty2[0:2],color = black, linestyle= ':')
plt.plot(ttX2[0:2],ttY2[0:2],color = black, linestyle= ':')
plt.plot(ttx2[1:3],tty2[1:3],color = red,linewidth = 3 , linestyle= '--',dashes=(10, 10))
plt.plot(ttX2[1:3],ttY2[1:3],color = orange, linewidth = 3,linestyle= '-')
plt.plot(ttx2[2:],tty2[2:],color = black, linestyle= ':')
plt.plot(ttX2[2:],ttY2[2:],color = black, linestyle= ':')
#if i ==0 :
fig.savefig(imagepath + string + '_5.png', format = 'png')
print('Create Image: '+ imagepath+ string + '.png')
if paperpath is not None: fig.savefig(paperpath + string + '.png', format = 'png')
plt.close(fig)
def Image_Illustration_Multi(string = 'Illustration_Multi'):
'''------------------------------------------------------------
Description:
---------------------------------------------------------------
Input:
---------------------------------------------------------------
Output:
------------------------------------------------------------'''
dark= 'black' in plt.rcParams['savefig.facecolor']
if dark:
string = 'dark_'+string
black = color_own([0.7,0.7,0.7,1])
grey = color_own([.5,.5,0.5,1])
cyan = color_own([0,1,1,1])
blue = color_own([0,0,1,1])
lime = color_own([0.6,1.2,0,1])
green = color_own([0,1,0,1])
red = color_own([1,0,0,1])
orange = color_own([1,.5,0,1])
else:
black = color_own([0.,0.,0.,1])
grey = color_own([.5,.5,0.5,1])
cyan = color_own([0,1,1,1])
blue = color_own([0,0,1,1])
lime = color_own([0.6,1.2,0,1])
green = color_own([0,1,0,1])
red = color_own([1,0,0,1])
orange = color_own([1,1,0,1])
t = np.array([12, 35, 41, 61, 73, 89])
scandir = np.array([0.1, 0.7, 0.4, 0.8 , 0.2, 0.1])*np.pi
x1 = np.linspace(1,13,100) + 0.3 * np.sin(np.linspace(np.pi/4,12*np.pi/4,100))
y1 = np.linspace(1,3,100) + 0.3* np.cos(np.linspace(np.pi/4,12*np.pi/4,100))
x2 = np.linspace(3,7,100)# + 0.03 * np.sin(np.linspace(np.pi/4,12*np.pi/4,100))
y2 = np.linspace(7,4.5,100)# + 0.03* np.cos(np.linspace(np.pi/4,12*np.pi/4,100))
x3 = np.linspace(12,10,100)# + 0.03 * np.sin(np.linspace(np.pi/4,12*np.pi/4,100))
y3 = np.linspace(8,6,100)# + 0.03* np.cos(np.linspace(np.pi/4,12*np.pi/4,100))
d2 = np.sqrt((x1-x2)**2 + (y1-y2)**2)
d3 = np.sqrt((x1-x3)**2 + (y1-y3)**2)
TE = 1.5
X2 = x2 + (x2-x1) * TE/(d2**2 +2*TE)
Y2 = y2 + (y2-y1) * TE/(d2**2 +2*TE)
X3 = x3 + (x3-x1) * TE/(d3**2 +2*TE)
Y3 = y3 + (y3-y1) * TE/(d3**2 +2*TE)
dX2 = x1-X2
dY2 = y1-Y2
dx2 = x1-x2
dy2 = y1-y2
dX3 = x1-X3
dY3 = y1-Y3
dx3 = x1-x3
dy3 = y1-y3
fig = plt.figure(figsize= (12,8.8))
plt.subplots_adjust(
top=0.95,
bottom=0.05,
left=0.05,
right=0.95,
hspace=0.0,
wspace=0.2)
ax = plt.subplot(111)
ax.axis('equal')
ax.axis('off')
for i in range(len(t)):
delta = 0.05
xm1 =np.array([-1,1,1,-1,-1]) * np.cos(scandir[i]) + delta * np.array([-1,-1,1,1,-1]) * np.sin(scandir[i]) + x1[t[i]]
ym1 =np.array([-1,1,1,-1,-1]) * np.sin(scandir[i]) - delta * np.array([-1,-1,1,1,-1]) * np.cos(scandir[i]) + y1[t[i]]
xm2 =np.array([-1,1,1,-1,-1]) * np.cos(scandir[i]) + delta * np.array([-1,-1,1,1,-1]) * np.sin(scandir[i]) + X2[t[i]]
ym2 =np.array([-1,1,1,-1,-1]) * np.sin(scandir[i]) - delta * np.array([-1,-1,1,1,-1]) * np.cos(scandir[i]) + Y2[t[i]]
xm3 =np.array([-1,1,1,-1,-1]) * np.cos(scandir[i]) + delta * np.array([-1,-1,1,1,-1]) * np.sin(scandir[i]) + X3[t[i]]
ym3 =np.array([-1,1,1,-1,-1]) * np.sin(scandir[i]) - delta * np.array([-1,-1,1,1,-1]) * np.cos(scandir[i]) + Y3[t[i]]
dSC3 = ((dX3[t[i]]).reshape(-1,1)*[np.sin(scandir[i]),np.cos(scandir[i])] \
+ (dY3[t[i]]).reshape(-1,1) *[-np.cos(scandir[i]),np.sin(scandir[i])])[0]
dSC2 = ((dX2[t[i]]).reshape(-1,1)*[np.sin(scandir[i]),np.cos(scandir[i])] \
+ (dY2[t[i]]).reshape(-1,1) *[-np.cos(scandir[i]),np.sin(scandir[i])])[0]
dsc3 = ((dx3[t[i]]).reshape(-1,1)*[np.sin(scandir[i]),np.cos(scandir[i])] \
+ (dy3[t[i]]).reshape(-1,1) *[-np.cos(scandir[i]),np.sin(scandir[i])])[0]
dsc2 = ((dx2[t[i]]).reshape(-1,1)*[np.sin(scandir[i]),np.cos(scandir[i])] \
+ (dy2[t[i]]).reshape(-1,1) *[-np.cos(scandir[i]),np.sin(scandir[i])])[0]
ttX2 = np.array([0,-dSC2[1]/2,dSC2[1]/2,0]) * np.cos(scandir[i]) + ([x1[t[i]],x1[t[i]],X2[t[i]],X2[t[i]]])
ttY2 = np.array([0,-dSC2[1]/2,dSC2[1]/2,0]) * np.sin(scandir[i]) +([y1[t[i]],y1[t[i]],Y2[t[i]],Y2[t[i]]])
ttX3 = np.array([0,-dSC3[1]/2,dSC3[1]/2,0]) * np.cos(scandir[i]) + ([x1[t[i]],x1[t[i]],X3[t[i]],X3[t[i]]])
ttY3 = np.array([0,-dSC3[1]/2,dSC3[1]/2,0]) * np.sin(scandir[i]) +([y1[t[i]],y1[t[i]],Y3[t[i]],Y3[t[i]]])
ttx2 = np.array([0,-dsc2[1]/2-0.3,dsc2[1]/2-0.3,0]) * np.cos(scandir[i]) + ([x1[t[i]],x1[t[i]],x2[t[i]],x2[t[i]]])
tty2 = np.array([0,-dsc2[1]/2-0.3,dsc2[1]/2-0.3,0]) * np.sin(scandir[i]) +([y1[t[i]],y1[t[i]],y2[t[i]],y2[t[i]]])
if i == 3: off = [-0.4,-0.2]
else: off = [0,-0.2]
ttx3 = np.array([0,-dsc3[1]/2+off[1],dsc3[1]/2+off[1],0]) * np.cos(scandir[i]) + ([x1[t[i]],x1[t[i]],x3[t[i]],x3[t[i]]])
tty3 = np.array([0,-dsc3[1]/2+off[1],dsc3[1]/2+off[1],0]) * np.sin(scandir[i]) +([y1[t[i]],y1[t[i]],y3[t[i]],y3[t[i]]])
ttX3 = np.array([0,-dSC3[1]/2+off[0],dSC3[1]/2+off[0],0]) * np.cos(scandir[i]) + ([x1[t[i]],x1[t[i]],X3[t[i]],X3[t[i]]])
ttY3 = np.array([0,-dSC3[1]/2+off[0],dSC3[1]/2+off[0],0]) * np.sin(scandir[i]) +([y1[t[i]],y1[t[i]],Y3[t[i]],Y3[t[i]]])
'''
if i % 2 == 0:
plt.arrow(ttX2[2],ttY2[2], 0.0001*(ttX2[2]-ttX2[1]),0.0001*(ttY2[2]-ttY2[1]),color = color_own([0,0,1,1]),head_width=0.2,\
overhang = 0.5, length_includes_head=True ,zorder = 10)
plt.arrow(ttX2[1],ttY2[1], 0.0001*(ttX2[1]-ttX2[2]),0.0001*(ttY2[1]-ttY2[2]),color = color_own([0,0,1,1]),head_width=0.2,\
overhang = 0.5, length_includes_head=True ,zorder = 10)
plt.plot(ttX2[0:2],ttY2[0:2],color = black, linestyle= ':')
plt.plot(ttX2[1:3],ttY2[1:3],color = [158/200,1/200,66/200, 1], linewidth = 3,linestyle= '-')
plt.plot(ttX2[2:],ttY2[2:],color = black, linestyle= ':')
'''
if i% 2 == 0:
plt.plot(xm2,ym2, color = black, linewidth = 1,zorder = 1)
plt.plot(xm1,ym1, color = black, linewidth = 1,zorder = 1)
plt.arrow(ttX2[2],ttY2[2], 0.0001*(ttX2[2]-ttX2[1]),0.0001*(ttY2[2]-ttY2[1]),color=red ,head_width=0.2,\
overhang = 0.5, length_includes_head=True ,zorder = 10)
plt.arrow(ttX2[1],ttY2[1], 0.0001*(ttX2[1]-ttX2[2]),0.0001*(ttY2[1]-ttY2[2]),color=red ,head_width=0.2,\
overhang = 0.5, length_includes_head=True, zorder = 10)
plt.plot(ttX2[0:2],ttY2[0:2],color = black, linestyle= ':')
plt.plot(ttX2[1:3],ttY2[1:3],color = red, linewidth = 3)
plt.plot(ttX2[2:],ttY2[2:],color = black, linestyle= ':')
plt.plot(ttx2[0:2],tty2[0:2],color = black, linestyle= ':')
plt.plot(ttx2[1:3],tty2[1:3],color = orange, linewidth = 3,linestyle= '-', dashes=(10, 2))
plt.plot(ttx2[2:],tty2[2:],color = black, linestyle= ':')
plt.arrow(ttx2[2],tty2[2], 0.0001*(ttx2[2]-ttx2[1]),0.0001*(tty2[2]-tty2[1]),color = orange, head_width=0.2,\
overhang = 0.5, length_includes_head=True ,zorder = 10)
plt.arrow(ttx2[1],tty2[1], 0.0001*(ttx2[1]-ttx2[2]),0.0001*(tty2[1]-tty2[2]),color = orange, head_width=0.2,\
overhang = 0.5, length_includes_head=True, zorder = 10)
if i >=3:
plt.plot(ttX3[0:2],ttY3[0:2],color = black, linestyle= ':')
plt.plot(ttX3[1:3],ttY3[1:3],color = red, linewidth = 3)
plt.plot(ttX3[2:],ttY3[2:],color = black, linestyle= ':')
plt.arrow(ttX3[2],ttY3[2], 0.0001*(ttX3[2]-ttX3[1]),0.0001*(ttY3[2]-ttY3[1]),color=red, head_width=0.2,\
overhang = 0.5, length_includes_head=True ,zorder = 10)
plt.arrow(ttX3[1],ttY3[1], 0.0001*(ttX3[1]-ttX3[2]),0.0001*(ttY3[1]-ttY3[2]),color= red, head_width=0.2,\
overhang = 0.5, length_includes_head=True ,zorder = 10)
plt.plot(xm3,ym3, color = black, linewidth = 1,zorder = 1)
plt.plot(ttx3[0:2],tty3[0:2],color = black, linestyle= ':')
plt.plot(ttx3[1:3],tty3[1:3],color = orange, linewidth = 3,linestyle= '-', dashes=(10, 2))
plt.plot(ttx3[2:],tty3[2:],color = black, linestyle= ':')
plt.arrow(ttx3[2],tty3[2], 0.0001*(ttx3[2]-ttx3[1]),0.0001*(tty3[2]-tty3[1]),color = orange, head_width=0.2,\
overhang = 0.5, length_includes_head=True ,zorder = 10)
plt.arrow(ttx3[1],tty3[1], 0.0001*(ttx3[1]-ttx3[2]),0.0001*(tty3[1]-tty3[2]),color = orange, head_width=0.2,\
overhang = 0.5, length_includes_head=True, zorder = 10)
'''
else:
plt.plot(xm3,ym3, color = 'grey', linewidth = 2, zorder = -1)
'''
elif i >=3:
plt.plot(xm3,ym3, color = black, linewidth = 1,zorder = 1)
plt.plot(xm1,ym1, color = black, linewidth = 1,zorder = 1)
#plt.plot(xm2,ym2, color = 'grey', linewidth = 2, zorder = -1)
plt.plot(ttX3[0:2],ttY3[0:2],color = black, linestyle= ':')
plt.plot(ttX3[1:3],ttY3[1:3],color = red, linewidth = 3 )
plt.plot(ttX3[2:],ttY3[2:],color = black, linestyle= ':')
plt.arrow(ttX3[2],ttY3[2], 0.0001*(ttX3[2]-ttX3[1]),0.0001*(ttY3[2]-ttY3[1]),color= red, head_width=0.2,\
overhang = 0.5, length_includes_head=True ,zorder = 10)
plt.arrow(ttX3[1],ttY3[1], 0.0001*(ttX3[1]-ttX3[2]),0.0001*(ttY3[1]-ttY3[2]),color= red, head_width=0.2,\
overhang = 0.5, length_includes_head=True ,zorder = 10)
plt.plot(ttx3[0:2],tty3[0:2],color = black, linestyle= ':')
plt.plot(ttx3[1:3],tty3[1:3],color = orange, linewidth = 3,linestyle= '-', dashes=(10, 2))
plt.plot(ttx3[2:],tty3[2:],color = black, linestyle= ':')
plt.arrow(ttx3[2],tty3[2], 0.0001*(ttx3[2]-ttx3[1]),0.0001*(tty3[2]-tty3[1]),color= orange, head_width=0.2,\
overhang = 0.5, length_includes_head=True ,zorder = 10)
plt.arrow(ttx3[1],tty3[1], 0.0001*(ttx3[1]-ttx3[2]),0.0001*(tty3[1]-tty3[2]),color= orange, head_width=0.2,\
overhang = 0.5, length_includes_head=True, zorder = 10)
'''
else:
plt.plot(xm3,ym3, color = 'grey', linewidth = 2, zorder = -1)
plt.plot(xm2,ym2, color = 'grey', linewidth = 2, zorder = -1)
plt.plot(xm1,ym1, color = 'grey', linewidth = 2, zorder = -1)
'''
#if i ==0 :
plt.plot(x1,y1, color = grey, linewidth = 7)
plt.plot(x2,y2, color = cyan, linestyle= '--',dashes=(6, 2), linewidth = 3, zorder = -1)
plt.plot(X2,Y2, color = blue, linewidth = 3)
plt.plot(x3,y3, color = lime, linestyle= '--',dashes=(6, 2), linewidth = 3, zorder = -1)
plt.plot(X3,Y3, color = green, linewidth = 3)
plt.xlim([-0.2,13.5])
xr = 12
yr = 7
plt.text(xr-0.8,0,'RA $\cdot$ cos(Dec)',verticalalignment = 'center',fontsize = 25)
plt.text(0,yr + 0.25,'Dec',fontsize = 25, horizontalalignment = 'center', rotation = 90)
plt.text(2,1.5,'Lens',color = grey,fontsize = 25, horizontalalignment = 'center', rotation = 0, weight = 'bold')
plt.text(4,7.5,'Star 1',color = blue, fontsize = 25, horizontalalignment = 'center', rotation = 0,weight = 'bold')
plt.text(11,8,'Star 2',color = green, fontsize = 25, horizontalalignment = 'center', rotation = 0,weight = 'bold')
plt.arrow(-0.025,0,xr-1,0,width = 0.05,overhang = 0.5,head_width = 0.5, head_length = 0.5,color= black, zorder = 100,length_includes_head=True)
plt.arrow(0,-0.025,0,yr-0.5,width = 0.05,overhang = 0.5,head_width = 0.5,head_length = 0.5,color= black, zorder = 100,length_includes_head=True)
fig.savefig(imagepath + string + '.png', format = 'png')
print('Create Image: '+ imagepath+ string + '.png')
if paperpath is not None: fig.savefig(paperpath + string + '.png', format = 'png')
plt.close(fig)
def Image_compare_micro(string = 'aml_vs_pml.png'):
'''------------------------------------------------------------
Description:
---------------------------------------------------------------
Input:
---------------------------------------------------------------
Output:
------------------------------------------------------------'''
dark= 'black' in plt.rcParams['savefig.facecolor']
if dark:
string = 'dark_'+string
c1 =color_own([1,1,0,1])
c2 =color_own([1,0,1,1])
c3 =color_own([0.6,1.2,0,1])
c4 =color_own([0,1,1,1])
else:
c1 =color_own([0,0,1,1])
c2 =color_own([1,0,0,1])
c3 =color_own([0.5,1,0,1])
c4 =color_own([1,0,1,1])
rc('xtick', labelsize=24)
rc('ytick', labelsize=24)
Separation_E1 = 20
Separation_E2 = 2
Separation_E3 = 20
xx1 = np.array(range(-1000,1000,1))
xx2 = xx1
xx3 = xx1
yy1 = xx1*0+10
yy2 = xx1*0+1
yy3 = xx1*0+200
uu1 = np.sqrt(xx1*xx1+yy1*yy1)/Separation_E1
uu2 = np.sqrt(xx2*xx2+yy2*yy2)/Separation_E2
uu3 = np.sqrt(xx3*xx3+yy3*yy3)/Separation_E3
dSeparation1 = uu1/(uu1*uu1 + 2)*Separation_E1
dSeparation2 = uu2/(uu2*uu2 + 2)*Separation_E2
dSeparation3 = uu3/(uu3*uu3 + 2)*Separation_E3
A1 = (uu1*uu1+2)/(uu1*np.sqrt(uu1*uu1+4))
A2 = (uu2*uu2+2)/(uu2*np.sqrt(uu2*uu2+4))
A3 = (uu3*uu3+2)/(uu3*np.sqrt(uu3*uu3+4))
dm1 = 2.5*np.log10(A1)
dm2 = 2.5*np.log10(A2)
dm3 = 2.5*np.log10(A3)
xx1 = xx1/250
xx2 = xx2/250
xx3 = xx3/250
figure = plt.figure(figsize = (12,12))
plt.subplots_adjust(hspace=0.1)
ax1 = plt.subplot2grid((2,1), (0, 0), rowspan=1)
plt.plot(xx1,dSeparation1, color = c1,linewidth = 4)
line1, = plt.plot(xx2,dSeparation2,color = c3 ,linewidth = 4)
plt.plot(xx3,dSeparation3,linestyle = '--',color = c4,linewidth = 4)
line1.set_dashes([10, 2, 10, 2])
plt.yticks([1,2,3,4,5,6,7,8],['1.0 ','2.0 ','3.0 ','4.0 ','5.0 ','6.0 ','7.0 ','8.0 '])
plt.ylim([0,8])
plt.ylabel('Shift [mas]',fontsize = 30)
plt.plot(xx1,xx1*0+0.5, color=c2,linewidth = 3)
ax1.tick_params(length=6, width=2)
ax1.tick_params(which='minor', length=4,width=2)
xticklabels1 = ax1.get_xticklabels()
plt.setp(xticklabels1, visible=False)
ax2 = plt.subplot2grid((2,1), (1, 0), rowspan=1,sharex=ax1)
plt.semilogy(xx1,dm1,color = c1,linewidth = 4)
line1, = plt.semilogy(xx2,dm2,color = c3,linewidth = 4)
plt.semilogy(xx3,dm3,linestyle = '--',color = c4,linewidth = 4)
line1.set_dashes([10, 2, 10, 2])
plt.semilogy(xx1,xx1*0+0.001, color= c2 ,linewidth = 3)
plt.ylim([0.0001,1])
plt.ylabel('Magnification [mag]',fontsize = 30)
ax2.tick_params(length=6, width=2)
ax2.tick_params(which='minor', length=4,width=2)
plt.xlabel('$\Delta$ T [yr]',fontsize = 30)
figure.savefig(imagepath+ string,format = 'png')
print('Create Image: '+ imagepath+ string + '.png')
plt.close(figure)
def Image_astroshift(string = 'astroshift'):
'''------------------------------------------------------------
Description:
---------------------------------------------------------------
Input:
---------------------------------------------------------------
Output:
------------------------------------------------------------'''
fig,ax = plt.subplots(figsize = [12,12] )
x = np.array([-100+0.1*t for t in range(2000)])
ThetaE = 12.75
umin = 0.75
ThetaE = 12.75
fls = 10
siz = 10
y = np.array([ThetaE*umin for i in x])
ax.set_xlim(-30,30)
ax.set_ylim(-30,30)
ux =np.array([x[i]/ThetaE for i in range(len(x))])
uy =np.array([y[i]/ThetaE for i in range(len(x))])
u = np.array([np.sqrt(np.power(ux[i],2)+np.power(uy[i],2)) for i in range(len(x))])
theta_px = - (np.sqrt(u*u+4) - u)/(2 * u) * x
theta_py = - (np.sqrt(u*u+4) - u)/(2 * u) * y
theta_mx = - (-np.sqrt(u*u+4) - u)/(2 * u) * x
theta_my = - (- | np.sqrt(u*u+4) | numpy.sqrt |
import numpy as np
class hmm_discreet(object):
"""An exemple of discreet Hidden Markov Model. """
def __init__(self, M, X, V):
r"""Initialize a discreet Hidden Markov Model.
Arguments :
M -- the number of states
X -- the observation sequences
V -- the number of symbols
"""
self.T_MAX = 250
self.T_INC = 10
self.M = M
self.X = X
self.V = V
self.N = len(X)
self.T = len(X[0])
self.alpha = np.zeros((self.T, self.M))
self.beta = np.zeros((self.T, self.M))
self.A = np.ones((self.M, self.M))
self.B = np.ones((self.M, self.V))
self.pi = np.ones(self.M)
self.alphas = []
self.betas = []
self.P = np.zeros(self.N)
self.scales = []
self.logP = np.zeros(self.N)
self.gamma = np.ones((self.T, self.M))
self.xi = np.ones((self.T, self.M, self.M))
@staticmethod
def normalized_matrix(m):
r"""Normalize a matrix.
Arguments :
m -- the matrix to normalize
"""
if len(m.shape) > 1:
return m / m.sum(axis=1, keepdims=True)
elif len(m.shape) == 1:
return m / m.sum(axis=0, keepdims=True)
else:
return ValueError("Reload Matrix")
@staticmethod
def random_matrix_normalized(dim1, dim2=0):
r"""Normalize a vector or a matrix.
Arguments :
dim1 -- the first dimension of the matrix
Keywords Arguments :
dim2 -- the second dimension of the matrix
"""
if dim2 == 0:
v = np.random.random(dim1)
return v / v.sum(axis=0, keepdims=True)
else:
m = np.random.random((dim1, dim2))
return m / m.sum(axis=1, keepdims=True)
def compute_alpha(self, seq_idx):
r"""Compute alpha matrix of a given observation sequence.
Arguments:
seq_idx -- the index of the observed sequence
Latex:
Equation: $\alpha({t+1,}{j})=(b[j,O[t+1]].\sum_{i=1}^{N}(a_{i,j}.\alpha({t},{i})) , \forall t \in [1,T-1], \forall j \in [1,N]$
"""
x = self.X[seq_idx]
self.T = len(x)
for i in range(self.M):
self.alpha[0][i] = self.B[i][x[0]]*self.pi[i]
for t in range(1, self.T):
for j in range(self.M):
s = 0
for i in range(self.M):
s += self.A[i][j]*self.alpha[t-1][i]
self.alpha[t][j] = self.B[j][x[t]]*s
self.alphas.append(self.alpha.copy())
def compute_alpha_scaled(self, seq_idx):
r"""Compute alpha scaled matrix of a given observation sequence.
Arguments:
seq_idx -- the index of the observed sequence
Latex:
Equation: $\alpha({t+1,}{j})=(b[j,O[t+1]].\sum_{i=1}^{N}(a_{i,j}.\alpha({t},{i})) , \forall t \in [1,T-1], \forall j \in [1,N]$
"""
x = self.X[seq_idx]
self.T = len(x)
scale = np.zeros(self.T)
for i in range(self.M):
self.alpha[0][i] = self.B[i][x[0]]*self.pi[i]
print(self.alpha[0])
scale[0] = self.alpha[0].sum()
self.alpha[0] /= scale[0]
print(self.alpha[0])
for t in range(1, self.T):
for j in range(self.M):
s = 0
for i in range(self.M):
s += self.A[i][j]*self.alpha[t-1][i]
self.alpha[t][j] = self.B[j][x[t]]*s
scale[t] = self.alpha[t].sum()
self.alpha[t] = self.alpha[t] / scale[t]
self.alphas.append(self.alpha.copy())
self.scales.append(scale)
def compute_p_from_alpha(self, seq_idx):
r"""Compute probability of observing a sequence from alpha.
Arguments:
seq_idx -- the index of the observed sequence
Latex:
Equation: # $P(X(1,...,T) / H)=\sum_{i=1}^{N}\alpha({T},{i}))$
"""
p = self.alpha[-1].sum()
self.P[seq_idx] = p
return p
def compute_logp_from_alpha(self, seq_idx):
r"""Compute log probability of observing a sequence from alpha.
Arguments:
seq_idx -- the index of the observed sequence
Latex:
Equation: # $P(X(1,...,T) / H)=\sum_{i=1}^{N}\alpha({T},{i}))$
"""
p = self.scales[seq_idx][self.T-1].sum()
self.logP[seq_idx] = p
return p
def compute_beta(self, seq_idx):
r"""Compute bêta matrix of a given observation sequence.
Arguments:
seq_idx -- the index of the observed sequence
Latex:
Equation: $\beta({t-1,}{i})=\sum_{j=1}^{N}(a(i,j)*b(j,o_{t})*\beta(t,j))$ $\forall$ T $\in$ [T-1, T-2, ...,1] and $\forall$ i $\in$ [1,N]$
"""
x = self.X[seq_idx]
self.T = len(x)
for i in range(self.M):
self.beta[self.T-1][i] = 1
for t in reversed(range(1, self.T)):
for i in range(self.M):
s = 0
for j in range(self.M):
s += self.A[i][j]*self.B[j][x[t]]*self.beta[t][j]
self.beta[t-1][i] = s
self.betas.append(self.beta.copy())
def compute_p_from_beta(self, seq_idx):
r"""Compute probability of observing a sequence from bêta.
Arguments:
seq_idx -- the index of the observed sequence
Latex:
Equation: # $P(X(1,...,T) / H)=\sum_{i}\Pi_{i}*b(i,o_{1})*\beta(1,i)$
"""
x = self.X[seq_idx]
p = np.sum(self.beta[0][:]*self.B[:, x[0]] * self.pi)
self.P[seq_idx] = p
return p
def compute_p_from_alpha_beta(self, t=None):
r"""Compute probability of observing a sequence from alpha and bêta.
Keywords Arguments:
t -- the time index, Default : None
Latex:
Equation: $P(X(1,...,T) / H)=\sum_{i}\alpha(t,i)*beta(t,i)$
"""
if t != None:
t = t
else:
t = np.random.choice(self.T)
p = np.sum(self.alpha[t][:]*self.beta[t][:])
return p
def compute_gamma(self, seq_idx):
r"""Compute gamma matrix of a given observation sequence.
Arguments:
seq_idx -- the index of the observed sequence
Latex:
Equation: $\gamma(t,i)=\alpha(t,i)*\beta(t,i)/(\sum_{i=1}^{N}\alpha(t,i)*\beta(t,i))$
"""
p = self.P[seq_idx]
alpha = self.alphas[seq_idx]
beta = self.betas[seq_idx]
for t in range(self.T):
self.gamma[t][:] = (alpha[t][:]*beta[t][:])/p
def compute_gamma_scaled(self, seq_idx):
r"""Compute gamma scaled matrix of a given observation sequence.
Arguments:
seq_idx -- the index of the observed sequence
Latex:
Equation: $\gamma(t,i)=\alpha(t,i)*\beta(t,i)/(\sum_{i=1}^{N}\alpha(t,i)*\beta(t,i))$
"""
p = self.P[seq_idx]
alpha = self.alphas[seq_idx]
beta = self.betas[seq_idx]
for t in range(self.T):
self.gamma[t][:] = (alpha[t][:]*beta[t][:])
def compute_xi(self, seq_idx):
r"""Compute xi matrix of a given observation sequence.
Arguments:
seq_idx -- the index of the observed sequence
Latex:
Equation: $\xi(t,i,j)=\frac{\alpha(t,i)*a_{i,j}*b{j,X_{t+1}}*\beta(t+1,j)}{p(X/\lambda)}$
"""
p = self.P[seq_idx]
x = self.X[seq_idx]
alpha = self.alphas[seq_idx]
beta = self.betas[seq_idx]
for i in range(self.M):
for j in range(self.M):
for t in range(self.T-1):
self.xi[t, i, j] = (
alpha[t, i] * self.A[i, j] * self.B[j, x[t+1]] * beta[t+1, j])/p
def compute_xi_scaled(self, seq_idx):
r"""Compute xi matrix of a given observation sequence.
Arguments:
seq_idx -- the index of the observed sequence
Latex:
Equation: $\xi(t,i,j)=\frac{\alpha(t,i)*a_{i,j}*b{j,X_{t+1}}*\beta(t+1,j)}{p(X/\lambda)}$
"""
p = self.P[seq_idx]
x = self.X[seq_idx]
alpha = self.alphas[seq_idx]
beta = self.betas[seq_idx]
for i in range(self.M):
for j in range(self.M):
for t in range(self.T-1):
self.xi[t, i, j] = (
alpha[t, i] * self.A[i, j] * self.B[j, x[t+1]] * beta[t+1, j])/self.scales[seq_idx][t+1]
def reestimate_A(self, n):
r"""Reevaluate A matrix using Baum-Welch re-estimation formulas.
Arguments:
n -- the time index
Latex:
Equation: $\hat a_{i,j}=\frac{\sum_{t=1}^{T-1}\xi(t,i,j)}{\sum_{t=1}^{T-1}\gamma(t,i)}$
"""
num = 0
den = 0
den += (self.alphas[n][:-1] * self.betas[n][:-1]
).sum(axis=0, keepdims=True).T / self.P[n]
self.compute_xi(n)
for t in range(self.T-1):
num += self.xi[t, :, :]
return num, den
def reestimate_A_scaled(self, n):
r"""Reevaluate A matrix using Baum-Welch re-estimation formulas.
Arguments:
n -- the time index
Latex:
Equation: $\hat a_{i,j}=\frac{\sum_{t=1}^{T-1}\xi(t,i,j)}{\sum_{t=1}^{T-1}\gamma(t,i)}$
"""
num = 0
den = 0
den += (self.alphas[n][:-1] * self.betas[n]
[:-1]).sum(axis=0, keepdims=True).T
self.compute_xi_scaled(n)
for t in range(self.T-1):
num += self.xi[t, :, :]
return num, den
def reestimate_B(self, n):
r"""Reevaluate B matrix using Baum-Welch re-estimation formulas.
Arguments:
n -- the time index
Latex:
Equation: $\hat b_{j,k}=\frac{\sum_{t=1,o_t=k}^{T}\gamma(t,j)}{\sum_{t=1}^{T}\gamma(t,j)}$
"""
num = np.zeros((self.M, self.V))
den = 0
x = self.X[n]
den += (self.alphas[n] * self.betas[n]
).sum(axis=0, keepdims=True).T / self.P[n]
self.compute_gamma(n)
for t in range(self.T):
num[:, x[t]] += self.gamma[t][:]
return num, den
def reestimate_B_scaled(self, n):
r"""Reevaluate B matrix using Baum-Welch re-estimation formulas.
Arguments:
n -- the time index
Latex:
Equation: $\hat b_{j,k}=\frac{\sum_{t=1,o_t=k}^{T}\gamma(t,j)}{\sum_{t=1}^{T}\gamma(t,j)}$
"""
num = np.zeros((self.M, self.V))
den = 0
x = self.X[n]
den += (self.alphas[n] * self.betas[n]).sum(axis=0, keepdims=True).T
self.compute_gamma_scaled(n)
for t in range(self.T):
num[:, x[t]] += self.gamma[t][:]
return num, den
def Baum_Welch_Algorithm(self,A_init=None,B_init=None,pi_init=None,max_iter=1):
r"""Reevaluate A,B,Pi matrix using Baum-Welch re-estimation formulas.
Arguments:
A_init -- the initial A matrix
B_init -- the initial B matrix
pi_init -- the initial Pi matrix
max_iter -- the maximim nunber of iteration
"""
if (A_init, B_init, pi_init) != (None, None, None):
self.A = normalized_matrix(A_init)
self.B = normalized_matrix(B_init)
self.pi = normalized_matrix(pi_init)
else:
self.A = random_matrix_normalized(self.M,self.M)
self.B = random_matrix_normalized(self.M,self.V)
self.pi = random_matrix_normalized(self.M)
self.costs = []
# iteration loop
for i in range(max_iter):
num_A = 0
den_A = 0
num_B = np.zeros((self.M, self.V))
den_B = 0
pi = np.zeros(self.M)
self.alphas = []
self.betas = []
self.P = np.zeros(self.N)
for n in range(self.N):
self.compute_alpha(n)
self.compute_p_from_alpha(n)
self.compute_beta(n)
pi += (self.alphas[n][0] * self.betas[n][0])/self.P[n]
numA, denA = self.reestimate_A(n)
num_A += numA
den_A += denA
numB, denB = self.reestimate_B(n)
num_B += numB
den_B += denB
self.costs.append(np.sum(self.P.copy()))
self.pi = pi / self.N
self.A = num_A / den_A
self.B = num_B / den_B
def Baum_Welch_Algorithm_scaled(self,A_init=None,B_init=None,pi_init=None,max_iter=1):
r""" eevaluate A,B,Pi matrix using Baum-Welch re-estimation formulas.
Arguments:
A_init -- the initial A matrix
B_init -- the initial B matrix
pi_init -- the initial Pi matrix
max_iter -- the maximim nunber of iteration
"""
if (A_init, B_init, pi_init) != (None, None, None):
self.A = normalized_matrix(A_init)
self.B = normalized_matrix(B_init)
self.pi = normalized_matrix(pi_init)
else:
self.A = random_matrix_normalized(self.M,self.M)
self.B = random_matrix_normalized(self.M,self.V)
self.pi = random_matrix_normalized(self.M)
self.costs = []
# iteration loop
for i in range(max_iter):
num_A = 0
den_A = 0
num_B = np.zeros((self.M, self.V))
den_B = 0
pi = np.zeros(self.M)
self.alphas = []
self.betas = []
self.scales = []
self.logP = np.zeros(self.N)
for n in range(self.N):
self.compute_alpha_scaled(n)
self.compute_logp_from_alpha(n)
self.compute_beta_scaled(n)
pi += (self.alphas[n][0] * self.betas[n][0])
numA, denA = self.reestimate_A_scaled(n)
num_A += numA
den_A += denA
numB, denB = self.reestimate_B_scaled(n)
num_B += numB
den_B += denB
self.costs.append(np.sum(self.logP.copy()))
self.pi = pi / self.N
self.A = num_A / den_A
self.B = num_B / den_B
def likelihood(self, x):
r"""Compute likelihood P(x/lambda) given an observed sequence x.
1
Arguments :
x -- the observed sequence
"""
T = len(x)
alpha = np.zeros((T, self.M))
alpha[0] = self.pi*self.B[:, x[0]]
for t in range(1, T):
alpha[t] = alpha[t-1].dot(self.A) * self.B[:, x[t]]
return alpha[-1].sum()
def log_likelihood(self, x):
r"""Compute log likelihood log(P(x/lambda)) given an observed sequence x.
1
Arguments :
x -- the observed sequence
"""
T = len(x)
scale = np.zeros(T)
alpha = np.zeros((T, self.M))
alpha[0] = self.pi*self.B[:, x[0]]
for t in range(1, T):
alpha_t = alpha[t-1].dot(self.A) * self.B[:, x[t]]
scale[t] = alpha_t.sum()
alpha[t] = alpha_t / scale[t]
return np.log(scale[-1].sum())
def log_likelihood_multi(self, X):
r"""Compute log likelihoods log(P(x/lambda)) given observed sequence x
of vector X .
1
Arguments :
X -- the observed sequences vector
"""
return np.array([self.log_likelihood(x) for x in X])
def get_state_sequence(self, x):
r"""Compute Viterbi algorithm in order to get the optimal state sequence .
1
Arguments :
x -- the observed sequences
"""
T = len(x)
delta = np.zeros((T, self.M))
psi = np.zeros((T, self.M))
delta[0] = self.pi*self.B[:, x[0]]
for t in range(1, T):
for j in range(self.M):
delta[t, j] = np.max(delta[t-1]*self.A[:, j]) * self.B[j, x[t]]
psi[t, j] = np.argmax(delta[t-1]*self.A[:, j])
# finding the path
states = np.zeros(T, dtype=np.int32)
states[T-1] = np.argmax(delta[T-1])
for t in reversed(range(T-1)):
states[t] = psi[t+1, states[t+1]]
return states
def get_state_sequence_scaled(self, x):
r"""Compute Viterbi algorithm in order to get the optimal state sequence .
1
Arguments :
x -- the observed sequences
"""
T = len(x)
delta = | np.zeros((T, self.M)) | numpy.zeros |
# -*- coding: utf-8 -*-
"""
CESSIPy: Civil Engineer Stochastic System Identification for Python
Author: <NAME>
Support email: <EMAIL>
Site: https://github.com/MatheusCarini/CESSIPy
MIT License
Federal University of Rio Grande do Sul, Porto Alegre, Brazil
Version: 1.1
Date: 20211012
"""
#=============================================================================
import sys
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
from MRPy import MRPy
from scipy import signal
from scipy.optimize import curve_fit
from matplotlib.gridspec import GridSpec
plt.rcParams["font.family"] = "Times New Roman"
mpl.rcParams['mathtext.fontset'] = 'cm'
#=============================================================================
# Naked Class
#=============================================================================
class auxclass(np.ndarray):
"""
Create a simple class to improve code readability
"""
def __new__(cls, np_array):
return np.asarray(np_array).view(cls)
#=============================================================================
# Time-Domain
#=============================================================================
def rearrange_data(self,ref):
"""
Rearrange the l outputs by positioning the r reference outputs in the first
rows.
Parameters
-------
self : MRPy_like
Time data MRPy object.
ref: tupple, list
List of reference sensors.
Returns
-------
yk : MRPy_like
MRPy object that contains the reference outputs in the first rows and
the attributes r and l.
.. l : MRPy attribute
Number of outputs.
.. r : MRPy attribute
Number of reference outputs.
"""
r = len(ref)
l = self.shape[0]
yk = MRPy(np.empty((l,self.N)),fs=self.fs)
yk.r = r
yk.l = l
yk[:r,:] = self[ref,:]
yk[r:,:] = np.delete(self, ref, 0)
return yk
#-----------------------------------------------------------------------------
def Toeplitz(self, i):
"""
Create the block Toeplitz matriz, which gathers the output covariances
estimates up to 2*i-1 time lags.
Parameters
-------
self : MRPy_like
MRPy object that contains the time data and the attributes r and l.
i : int
Number of time lags used to calculate the covariances length.
Note that they are estimated up to 2*i-1 time lags.
Returns
-------
T : auxclass_like
Auxclass object that contains the block Toeplitz matrix and the
attributes r, l and i.
"""
N = self.N - 2*i + 1
r = self.r
l = self.l
Ypref = np.zeros((r*i,N))
Yf = np.zeros((l*i,N))
for k in range(i):
Ypref[k*r:k*r+r,:] = self[:r,k:k+N]
Yf [k*l:k*l+l,:] = self[: ,k+i:k+i+N]
Ypref = Ypref/N**0.5
Yf = Yf /N**0.5
T = auxclass(Yf @ Ypref.T)
T.fs, T.r, T.l, T.i = self.fs, r, l, i
return T
#-----------------------------------------------------------------------------
def SSI_COV(T, no):
"""
Covariance-Driven Stochastic Subspace Identification Method
Estimate the eigenfrequencies, damping ratios and mode shapes of the block
Toeplitz matrix.
Parameters
-------
T : auxclass_like
Auxclass object that contains the block Toeplitz matrix and the
attributes SVD, r, l and i.
no : int
State space model order.
Returns
-------
fn : ndarray
Eigenfrequencies array.
zt : ndarray
Damping ratios array.
V : ndarray
Mode shapes array as columns.
See also
-------
Toeplitz, SSI_COV_iterator
"""
l = T.l
i = T.i
U, S, VT = T.SVD
U1 = U[:,:no]
S1 = np.eye(no)*S[:no]
Oi = U1 @ S1**0.5
C = Oi[:l,:]
A = np.linalg.pinv(Oi[:l*(i-1),:]) @ Oi[l:l*i+1,:]
Λd, Ψ = np.linalg.eig(A)
λ = np.log(Λd)*T.fs
fn = np.abs(λ)/(2*np.pi)
zt = -np.real(λ)/np.abs(λ)
V = C @ Ψ
return fn, zt, V
#-----------------------------------------------------------------------------
def SSI_COV_iterator(yk, i, nmin, nmax, incr=2, plot=False):
"""
Iterate the SSI_COV function for model orders from nmin to nmax and step
equal incr.
Estimate the eigenfrequencies, damping ratios and mode shapes using
SSI COV algorithm for increasing state space orders.
Parameters
-------
yk : MRPy_like
MRPy object returned by rearrange_data function.
i : int
Number of time lags used to calculate the covariances length.
Note that they are estimated up to 2*i-1 time lags.
nmin : int
The starting order number of the state space model.
nmax : int
The end order number of the state space model.
incr : int, optional
Step, spacing between model orders. The default step size is 2.
plot : bool, optional
If true, plots the singular values graph of the Toeplitz matrix.
Default is false.
Returns
-------
FN : ndarray
Eigenfrequencies 2D array. Each row originates from the same state
space model.
ZT : ndarray
Damping ratios 2D array. Each row originates from the same state
space model.
VV : ndarray
Mode shapes 3D array. The first index selects the state space order.
Notes
-------
The modal parameters of the first nmin state space model are FN[0,:],
ZT[0,:] and VV[0,:,:].
"""
T = Toeplitz(yk, i)
T.method = 'SSI COV'
if plot: plot_singular_values(T)
T.SVD = np.linalg.svd(T)
n = np.arange(nmin,nmax+incr,incr)
FN = np.zeros((n.shape[0],nmax))
ZT = np.zeros((n.shape[0],nmax))
VV = np.zeros((n.shape[0],T.l,nmax),dtype=np.complex_)
for ii, no in np.ndenumerate(n):
FN[ii,:no], ZT[ii,:no], VV[ii,:,:no] = SSI_COV(T,no)
return FN, ZT, VV
#-----------------------------------------------------------------------------
def projection(yk, i):
"""
Compute the QR factorization of the Hankel matrix and calculate the
matrices Piref, Pi1ref and Yii.
Parameters
-------
yk : MRPy_like
MRPy object returned by rearrange_data function.
i : int
Number of time lags used to calculate the covariances length.
Note that they are estimated up to 2*i-1 time lags.
Returns
-------
Pi : auxclass_like
Auxclass object that contains the projection of the row space of the
future outputs into the rows space of the past reference outputs and
the attributes r, l and i.
Pi1 : array_like
Projection array changing the separation between past and future
outputs one row below.
Yii : array_like
Subset of the block Hankel matrix.
"""
N = yk.N - 2*i + 1
r = yk.r
l = yk.l
Ypref = np.zeros((r*i,N))
Yf = np.zeros((l*i,N))
for k in range(i):
Ypref[k*r:k*r+r,:] = yk[:r,k:k+N]
Yf [k*l:k*l+l,:] = yk[: ,k+i:k+i+N]
Ypref = Ypref/N**0.5
Yf = Yf /N**0.5
Href = np.vstack([Ypref,Yf])
R = np.linalg.qr(Href.T, mode='r').T
Pi = auxclass(R[r*i:,:r*i] @ np.eye(r*i,N))
Pi1 = R[r*i+l:,:r*i+r] @ np.eye(r*i+r,N)
Yii = R[r*i:r*i+l,:r*i+l] @ np.eye(r*i+l,N)
Pi.fs, Pi.r, Pi.l, Pi.i = yk.fs, r, l, i
return Pi, Pi1, Yii
#-----------------------------------------------------------------------------
def SSI_DATA(Pi, Pi1, Yii, no):
"""
Data-Driven Stochastic Subspace Identification Method
Estimate the eigenfrequencies, damping ratios and mode shapes of the
Piref, Pi1ref e Yii matrices.
Parameters
-------
Pi, Pi1, Yii
See projection.
no : int
State space model order.
Returns
-------
fn : ndarray
Eigenfrequencies array.
zt : ndarray
Damping ratios array.
V : ndarray
Mode shapes array as columns.
"""
U, S, VT = Pi.SVD
U1 = U[:,:no]
S1 = np.eye(no)*S[:no]
Oi = U1 @ S1**0.5
Oi1 = Oi[:-Pi.l,:]
Xi = np.linalg.pinv(Oi) @ Pi
Xi1 = np.linalg.pinv(Oi1) @ Pi1
AC = np.vstack([Xi1,Yii]) @ np.linalg.pinv(Xi)
A = AC[:no,:]
C = AC[no:,:]
Λd, Ψ = np.linalg.eig(A)
λ = np.log(Λd)*Pi.fs
fn = np.abs(λ)/(2*np.pi)
zt = -np.real(λ)/np.abs(λ)
V = C @ Ψ
return fn, zt, V
#-----------------------------------------------------------------------------
def SSI_DATA_iterator(yk, i, nmin, nmax, incr=2, plot=False):
"""
Iterate the SSI_DATA function for model orders from nmin to nmax and step
equal incr.
Estimate the eigenfrequencies, damping ratios and mode shapes using
SSI DATA algorithm for increasing state space orders.
Parameters
-------
yk : MRPy_like
MRPy object returned by rearrange_data function.
i : int
Number of time lags used to calculate the covariances length.
Note that they are estimated up to 2*i-1 time lags.
nmin : int
The starting order number of the state space model.
nmax : int
The end order number of the state space model.
incr : int, optional
Step, spacing between model orders. The default step size is 2.
plot : bool, optional
If true, plots the singular values graph of the Pi matrix.
Default is false.
Returns
-------
FN : ndarray
Eigenfrequencies 2D array. Each row originates from the same state
space model.
ZT : ndarray
Damping ratios 2D array. Each row originates from the same state
space model.
VV : ndarray
Mode shapes 3D array. The first index selects the state space order.
Notes
-------
The modal parameters of the first nmin state space model are FN[0,:],
ZT[0,:] and VV[0,:,:].
"""
Pi, Pi1, Yii = projection(yk, i)
Pi.method = 'SSI DATA'
if plot: plot_singular_values(Pi)
Pi.SVD = np.linalg.svd(Pi)
n = np.arange(nmin,nmax+incr,incr)
FN = np.zeros((n.shape[0],nmax))
ZT = np.zeros((n.shape[0],nmax))
VV = np.zeros((n.shape[0],Pi.l,nmax),dtype=np.complex_)
for ii, no in np.ndenumerate(n):
FN[ii,:no],ZT[ii,:no],VV[ii,:,:no] = SSI_DATA(Pi,Pi1,Yii,no)
return FN, ZT, VV
#-----------------------------------------------------------------------------
def Fast_SSI(yk, i, nmin, nmax, incr=2, plot=False, based='COV'):
"""
Estimate the eigenfrequencies, damping ratios and mode shapes using Fast
Subspace-Based System Identification algorithm 2 from [1] for increasing
state space orders.
Parameters
-------
yk : MRPy_like
MRPy object returned by rearrange_data function.
i : int
Number of time lags used to calculate the covariances length.
Note that they are estimated up to 2*i-1 time lags.
nmin : int
The starting order number of the state space model.
nmax : int
The end order number of the state space model.
incr : int, optional
Step, spacing between model orders. The default step size is 2.
plot : bool, optional
If true, plots the singular values graph. Default is false.
based : string, optinal
SSI based method. If 'COV', it uses the covariance-driven SSI. If
'DATA', it uses the data-driven SSI. Default is 'COV'.
Returns
-------
FN : ndarray
Eigenfrequencies 2D array. Each row originates from the same state
space model.
ZT : ndarray
Damping ratios 2D array. Each row originates from the same state
space model.
VV : ndarray
Mode shapes 3D array. The first index selects the state space order.
Notes
-------
The modal parameters of the first nmin state space model are FN[0,:],
ZT[0,:] and VV[0,:,:].
Reference
----------
.. [1] <NAME>; <NAME>. Fast Multi-Order Computation of System
Matrices in Subspace-Based System Identification. Control
Engineering Practice, Elsevier, 2012, 20 (9), pp.882-894.
10.1016/j.conengprac.2012.05.005. hal-00724068
"""
if based.lower() == 'cov':
T = Toeplitz(yk, i)
T.method = 'SSI COV'
if plot: plot_singular_values(T)
U, S, VT = np.linalg.svd(T)
U1 = U[:,:nmax]
S1 = np.eye(nmax)*S[:nmax]
Oi = U1 @ S1**0.5
elif based.lower() == 'data':
Pi, Pi1, Yii = projection(yk, i)
Pi.method = 'SSI DATA'
if plot: plot_singular_values(Pi)
U, S, VT = np.linalg.svd(Pi)
U1 = U[:,:nmax]
S1 = np.eye(nmax)*S[:nmax]
Oi = U1 @ S1**0.5
else:
sys.exit('based method must be COV or DATA')
l = yk.l
Oiu = Oi[:l*(i-1),:]
Oid = Oi[l:l*i+1 ,:]
C = Oi[:l,:]
Q, R = np.linalg.qr(Oiu)
St = Q.T @ Oid
n = np.arange(nmin,nmax+incr,incr)
FN = np.zeros((n.shape[0],nmax))
ZT = np.zeros((n.shape[0],nmax))
VV = np.zeros((n.shape[0],l,nmax),dtype=np.complex_)
for ii, no in np.ndenumerate(n):
A = np.linalg.inv(R[:no,:no]) @ St[:no,:no]
Cj = C[:,:no]
Λd, Ψ = np.linalg.eig(A)
λ = np.log(Λd)*yk.fs
FN[ii,:no] = np.abs(λ)/(2*np.pi)
ZT[ii,:no] = -np.real(λ)/np.abs(λ)
VV[ii,:,:no] = Cj @ Ψ
return FN, ZT, VV
#-----------------------------------------------------------------------------
def IV(T, no):
"""
Instrumental Variable Method
Estimate the eigenfrequencies, damping ratios and mode shapes of the block
Toeplitz matrix.
Parameters
-------
T : auxclass_like
Auxclass object that contains the block Toeplitz matrix and the
attributes SVD, r, l and i.
no : int
State space model order.
Returns
-------
fn : ndarray
Eigenfrequencies array.
zt : ndarray
Damping ratios array.
V : ndarray
Mode shapes array as columns.
See also
-------
Toeplitz
"""
r = T.r
l = T.l
αb = np.linalg.lstsq(T[:,-no*r:],
-T[:,-(no+1)*r:-no*r], rcond=None)[0]
Apcomp = np.zeros((no*r,no*r))
Apcomp[:-r,r:] += np.eye((no-1)*r)
for kk in range(no):
Apcomp[-r:,r*kk:r*(kk+1)] -= αb.T[:,r*(no-kk)-r:r*(no-kk)]
Λd, Ψ = np.linalg.eig(Apcomp)
λ = np.log(Λd)*T.fs
fn = np.abs(λ)/(2*np.pi)
zt = -np.real(λ)/np.abs(λ)
Gmref = (Ψ[:r,:]).T
Γmref = np.zeros((no*r,no*r),dtype=np.complex_)
for ii in range(no):
Γmref[:,ii*r:(ii+1)*r] = np.diag(Λd**(no-ii-1)) @ Gmref
V = T[:l,-no*r:] @ np.linalg.inv(Γmref)
return fn, zt, V
#-----------------------------------------------------------------------------
def IV_iterator(yk, i, nmin, nmax, incr=2, plot=False):
"""
Iterate the IV function for model orders from nmin to nmax and step equal
incr.
Estimate the eigenfrequencies, damping ratios and mode shapes using IV
algorithm for increasing state space orders.
Parameters
-------
yk : MRPy_like
MRPy object returned by rearrange_data function.
i : int
Number of time lags used to calculate the covariances length.
Note that they are estimated up to 2*i-1 time lags.
nmin : int
The starting order number of the state space model.
nmax : int
The end order number of the state space model.
incr : int, optional
Step, spacing between model orders. The default step size is 2.
plot : bool, optional
If true, plots the singular values graph of the Toeplitz matrix.
Default is false.
Returns
-------
FN : ndarray
Eigenfrequencies 2D array. Each row originates from the same state
space model.
ZT : ndarray
Damping ratios 2D array. Each row originates from the same state
space model.
VV : ndarray
Mode shapes 3D array. The first index selects the state space order.
Notes
-------
The relation between ARMA order p and state space order n is n = p * r.
The modal parameters of the first nmin state space model are FN[0,:],
ZT[0,:] and VV[0,:,:].
"""
T = Toeplitz(yk,i)
T.method = 'IV'
if plot: plot_singular_values(T)
n = np.arange(nmin,nmax+incr,incr)
FN = np.zeros((n.shape[0],nmax*T.r))
ZT = np.zeros((n.shape[0],nmax*T.r))
VV = np.zeros((n.shape[0],T.l,nmax*T.r),dtype=np.complex_)
for ii, no in np.ndenumerate(n):
FN[ii,:no*T.r], ZT[ii,:no*T.r], VV[ii,:,:no*T.r] = IV(T,no)
return FN, ZT, VV
#-----------------------------------------------------------------------------
def stabilization_diagram(FN, ZT, VV, title,
tol = np.array(([0.01,0, 100],
[0.05,0,0.05],
[0.10,0, 1])), plot=True):
"""
Compute the stable poles and plot the stabilization diagram
Parameters
-------
FN, ZT, VV
Modal parameters returned by SSI_COV_Iterator, SSI_DATA_Iterator and
IV_Iterator functions.
title : str
Graph title.
tol : ndarray, optional
Array of stabilization criteria.
Rows: frequencies, damping ratios and MAC values respectively.
Columns: percentage tolerance, minimum and maximum values respectively.
Default is:
[0.01,0,100 ] Δf = 1%; fmin = 0 Hz; fmax = 100 Hz
[0.05,0,0.05] Δζ = 5%; ζmin = 0%; ζmax = 5%
[0.10,0,1 ] MAC >= (1 - 0.10) = 0.90
plot : bool, optional
If true, plots the stabilization diagram. Default is false.
Returns
-------
stb : array_like
Boolean array that contains True for stable poles. Each row originates
from the same state space model.
Notes
-------
First stb index refers to model order. For example, the last stable poles
row stb[-1,:] originates from nmax model order.
"""
nmin = np.count_nonzero(FN, axis=1)[0]
nmax = np.count_nonzero(FN, axis=1)[-1]
incr = (nmax-nmin)//(FN.shape[0]-1)
n = | np.arange(nmin,nmax+incr,incr) | numpy.arange |
import os
import sys
import time
import json
import argparse
import librosa
import numpy as np
from tqdm import tqdm
from glob import glob
from typing import Any
from tf_lite.filter import Filter
from tf_lite.tf_lite import TFLiteModel
class Dataset_Filter:
def __init__(self,
dataset: str,
filter: TFLiteModel,
**kwargs: Any) -> None:
# dataset variables
self.dataset = dataset
self.audio_metadata = json.load(open(dataset, 'r'))
self.wake_word = kwargs['wake_word']
# filter class variables
self.filter = Filter(model_dir=args.models_dir)
self.num_filter_outputs = self.filter.num_outputs()
# audio parameters
self.sr = kwargs['sample_rate']
self.fw = kwargs['frame_width']
self.frame_len = self.sr // 1000 * self.fw
# data locations
self.out_dir = kwargs['out_dir']
self.data_dir = kwargs['data_dir']
# make directory structure for dataset
self.dataset_name = os.path.basename(dataset).replace('.json', '')
self.dataset_dir = os.path.join(self.out_dir, self.dataset_name)
os.makedirs(self.dataset_dir, exist_ok=True)
os.makedirs(os.path.join(self.dataset_dir, self.wake_word), exist_ok=True)
os.makedirs(os.path.join(self.dataset_dir, f'not-{self.wake_word}'), exist_ok=True)
def filter_audio_file(self, audio_file: str) -> None:
features = []
# load audio from file
samples, _ = librosa.load(os.path.join(self.data_dir, audio_file), sr=self.sr)
# frame audio and process it through filter
for start_idx in np.arange(0, len(samples), self.frame_len):
frame = samples[start_idx:start_idx+self.frame_len]
if len(frame) < self.frame_len:
pad_len = self.frame_len - len(frame)
frame = | np.pad(frame, (0,pad_len), mode='constant') | numpy.pad |
# coding:utf-8
# Test for upsample_2d
# Created : 7, 5, 2018
# Revised : 7, 5, 2018
# All rights reserved
#------------------------------------------------------------------------------------------------
__author__ = 'dawei.leng'
import os, sys
os.environ['THEANO_FLAGS'] = "floatX=float32, mode=FAST_RUN, warn_float64='raise'"
import theano
from theano import tensor
from dandelion.module import *
from dandelion.functional import upsample_2d, upsample_2d_bilinear
from lasagne.layers import InputLayer, get_output, Upscale2DLayer
import dandelion
dandelion_path = os.path.split(dandelion.__file__)[0]
print('dandelion path = %s\n' % dandelion_path)
class build_model_D(Module):
def __init__(self, ratio=[2, 3], mode='repeat'):
super().__init__()
self.ratio = ratio
self.mode = mode
self.predict = self.forward
def forward(self, x):
"""
:param x: (B, C, H, W)
:return:
"""
x = upsample_2d(x, ratio=self.ratio, mode=self.mode)
# x = relu(x)
return x
def build_model_L(ratio=[2,3], mode='repeat'):
input_var = tensor.ftensor4('x') # (B, C, H, W)
input0 = InputLayer(shape=(None, None, None, None), input_var=input_var, name='input0')
x = Upscale2DLayer(input0, scale_factor=ratio, mode=mode)
return x
def test_case_0():
import numpy as np
from lasagne_ext.utils import get_layer_by_name
ratio = [1, 2]
mode = 'dilate'
model_D = build_model_D(ratio=ratio, mode=mode)
model_L = build_model_L(ratio=ratio, mode=mode)
X = get_layer_by_name(model_L, 'input0').input_var
y_D = model_D.forward(X)
y_L = get_output(model_L)
fn_D = theano.function([X], y_D, no_default_updates=True, on_unused_input='ignore')
fn_L = theano.function([X], y_L, no_default_updates=True, on_unused_input='ignore')
for i in range(20):
B = np.random.randint(low=1, high=16)
C = np.random.randint(low=1, high=32)
H = np.random.randint(low=5, high=256)
W = np.random.randint(low=5, high=255)
x = np.random.rand(B, C, H, W).astype(np.float32) - 0.5
y_D = fn_D(x)
y_L = fn_L(x)
# print(y_D)
diff = np.max( | np.abs(y_D - y_L) | numpy.abs |
# coding=utf-8
# Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Finetuning the library models for sequence classification on GLUE-style tasks
(BERT, XLM, XLNet, RoBERTa, Albert, XLM-RoBERTa); modified for Dataset Cartography.
"""
import _jsonnet
import argparse
import glob
import json
import logging
import numpy as np
import os
import random
import shutil
import torch
from scipy.spatial import distance
from scipy.stats import entropy
from itertools import cycle
import torch.nn as nn
#label propagation
import word_level_augment
import torch.nn.functional as F
import mmd_loss
from torch.utils.data import Dataset
from torch.utils.data import DataLoader, RandomSampler, SequentialSampler, TensorDataset
from torch.utils.data.distributed import DistributedSampler
from tqdm import tqdm, trange
from transformers import (
WEIGHTS_NAME,
AdamW,
BertConfig,
BertTokenizer,
RobertaConfig,
RobertaTokenizer,
get_linear_schedule_with_warmup,
)
from cartography.classification.glue_utils import adapted_glue_compute_metrics as compute_metrics
from cartography.classification.glue_utils import adapted_glue_convert_examples_to_features as convert_examples_to_features
from cartography.classification.glue_utils import glue_output_modes as output_modes
from cartography.classification.glue_utils import glue_processors as processors
from cartography.classification.diagnostics_evaluation import evaluate_by_category
from cartography.classification.models import (
AdaptedBertForMultipleChoice,
AdaptedBertForSequenceClassification,
AdaptedRobertaForMultipleChoice,
AdaptedRobertaForSequenceClassification
)
from cartography.classification.multiple_choice_utils import convert_mc_examples_to_features
from cartography.classification.params import Params, save_args_to_file
from cartography.selection.selection_utils import log_training_dynamics
from cartography.data_utils_glue import convert_string_to_unique_number
try:
from torch.utils.tensorboard import SummaryWriter
except ImportError:
from tensorboardX import SummaryWriter
logger = logging.getLogger(__name__)
ALL_MODELS = sum(
(
tuple(conf.pretrained_config_archive_map.keys())
for conf in (
BertConfig,
RobertaConfig,
)
),
(),
)
MODEL_CLASSES = {
"bert": (BertConfig, AdaptedBertForSequenceClassification, BertTokenizer),
"bert_mc": (BertConfig, AdaptedBertForMultipleChoice, BertTokenizer),
"roberta": (RobertaConfig, AdaptedRobertaForSequenceClassification, RobertaTokenizer),
"roberta_mc": (RobertaConfig, AdaptedRobertaForMultipleChoice, RobertaTokenizer),
}
def set_seed(args):
random.seed(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.n_gpu > 0:
torch.cuda.manual_seed_all(args.seed)
class TripleDataset(torch.utils.data.Dataset):
def __init__(self, *datasets):
self.datasets = datasets
def __getitem__(self, i):
return tuple(d[i] for d in self.datasets)
def __len__(self):
return min(len(d) for d in self.datasets)
def train(args, train_dataset, model, tokenizer, flag_in_training):
""" Train the model """
if args.local_rank in [-1, 0]:
tb_writer = SummaryWriter()
args.train_batch_size = args.per_gpu_train_batch_size * max(1, args.n_gpu)
# train_sampler = RandomSampler(
# train_dataset) if args.local_rank == -1 else DistributedSampler(train_dataset)
train_dataloader = DataLoader(
train_dataset, batch_size=args.train_batch_size, shuffle=True)
if args.max_steps > 0:
t_total = args.max_steps
args.num_train_epochs = args.max_steps // (
len(train_dataloader) // args.gradient_accumulation_steps) + 1
else:
t_total = len(train_dataloader) // args.gradient_accumulation_steps * args.num_train_epochs
# Prepare optimizer and schedule (linear warmup and decay)
no_decay = ["bias", "LayerNorm.weight"]
optimizer_grouped_parameters = [
{"params": [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)],
"weight_decay": args.weight_decay,
},
{"params": [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)],
"weight_decay": 0.0
},
]
if flag_in_training =='finetune':
optimizer = AdamW(optimizer_grouped_parameters, lr=args.finetune_learning_rate, eps=args.adam_epsilon)
else:
optimizer = AdamW(optimizer_grouped_parameters, lr=args.learning_rate, eps=args.adam_epsilon)
scheduler = get_linear_schedule_with_warmup(
optimizer, num_warmup_steps=args.warmup_steps, num_training_steps=t_total
)
# Check if saved optimizer or scheduler states exist
if os.path.isfile(os.path.join(args.model_name_or_path, "optimizer.pt")) and os.path.isfile(
os.path.join(args.model_name_or_path, "scheduler.pt")
):
# Load in optimizer and scheduler states
optimizer.load_state_dict(torch.load(os.path.join(args.model_name_or_path, "optimizer.pt")))
scheduler.load_state_dict(torch.load(os.path.join(args.model_name_or_path, "scheduler.pt")))
if args.fp16:
try:
from apex import amp
except ImportError:
raise ImportError(
"Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
# multi-gpu training (should be after apex fp16 initialization)
if args.n_gpu > 1:
model = torch.nn.DataParallel(model)
# Distributed training (should be after apex fp16 initialization)
if args.local_rank != -1:
model = torch.nn.parallel.DistributedDataParallel(
model,
device_ids=[args.local_rank],
output_device=args.local_rank,
find_unused_parameters=True,
)
# Train!
# args.local_rank = -1
# get_world_size = 1
# args.train_batch_size = 128
logger.info("***** Running training *****")
logger.info(" Num examples = %d", len(train_dataset))
logger.info(" Num Epochs = %d", args.num_train_epochs)
logger.info(" Instantaneous batch size per GPU = %d", args.per_gpu_train_batch_size)
logger.info(
" Total train batch size (w. parallel, distributed & accumulation) = %d",
args.train_batch_size
* args.gradient_accumulation_steps
* (torch.distributed.get_world_size() if args.local_rank != -1 else 1),
)
logger.info(" local_rank = %d", args.local_rank)
logger.info(" Gradient Accumulation steps = %d", args.gradient_accumulation_steps)
logger.info(" Total optimization steps = %d", t_total)
global_step = 0
epochs_trained = 0
steps_trained_in_this_epoch = 0
# Check if continuing training from a checkpoint
if os.path.exists(args.model_name_or_path):
# set global_step to gobal_step of last saved checkpoint from model path
global_step = int(args.model_name_or_path.split("-")[-1].split("/")[0])
epochs_trained = global_step // (len(train_dataloader) // args.gradient_accumulation_steps)
steps_trained_in_this_epoch = global_step % (
len(train_dataloader) // args.gradient_accumulation_steps)
logger.info(f" Continuing training from checkpoint, will skip to saved global_step")
logger.info(f" Continuing training from epoch {epochs_trained}")
logger.info(f" Continuing training from global step {global_step}")
logger.info(f" Will skip the first {steps_trained_in_this_epoch} steps in the first epoch")
tr_loss, logging_loss, epoch_loss = 0.0, 0.0, 0.0
model.zero_grad()
if flag_in_training =='finetune':
train_iterator = trange(epochs_trained,
(int(args.ft_num_train_epochs)*3),
desc="Epoch",
disable=args.local_rank not in [-1, 0],
mininterval=10,
ncols=100)
else:
train_iterator = trange(epochs_trained,
int(args.num_train_epochs),
desc="Epoch",
disable=args.local_rank not in [-1, 0],
mininterval=10,
ncols=100)
set_seed(args) # Added here for reproductibility
best_dev_performance = 0
best_epoch = epochs_trained
train_acc = 0.0
total_entropy = 0.
total_sample_size = 0
for epoch, _ in enumerate(train_iterator):
epoch_iterator = tqdm(train_dataloader,
desc="Iteration",
disable=args.local_rank not in [-1, 0],
mininterval=10,
ncols=100)
train_iterator.set_description(f"train_epoch: {epoch} train_acc: {train_acc:.4f}")
train_ids = None
train_golds = None
train_logits = None
train_losses = None
for step, batch in enumerate(epoch_iterator):
# Skip past any already trained steps if resuming training
if steps_trained_in_this_epoch > 0:
steps_trained_in_this_epoch -= 1
continue
model.train()
batch = tuple(t.to(args.device) for t in batch)
inputs = {"input_ids": batch[0], "attention_mask": batch[1], "labels": batch[3]}
if args.model_type != "distilbert":
inputs["token_type_ids"] = (
batch[2] if args.model_type in ["bert", "xlnet", "albert"] else None
) # XLM, DistilBERT, RoBERTa, and XLM-RoBERTa don't use segment_ids
outputs = model(**inputs)
loss = outputs[0] # model outputs are always tuple in transformers (see doc)
entropy=outputs[-1]
if train_logits is None: # Keep track of training dynamics.
train_ids = batch[4].detach().cpu().numpy()
train_logits = outputs[1].detach().cpu().numpy()
train_golds = inputs["labels"].detach().cpu().numpy()
train_losses = loss.detach().cpu().numpy()
train_entropy = entropy.detach().cpu().numpy()
print(entropy.size(), "check entropy size")
else:
train_ids = np.append(train_ids, batch[4].detach().cpu().numpy())
train_logits = np.append(train_logits, outputs[1].detach().cpu().numpy(), axis=0)
train_golds = np.concatenate((train_golds, inputs["labels"].detach().cpu().numpy()), 0)
train_losses = np.append(train_losses, loss.detach().cpu().numpy())
train_entropy = np.append(train_entropy, entropy.detach().cpu().numpy())
if args.n_gpu > 1:
loss = loss.mean() # mean() to average on multi-gpu parallel training
if args.gradient_accumulation_steps > 1:
loss = loss / args.gradient_accumulation_steps
if args.fp16:
with amp.scale_loss(loss, optimizer) as scaled_loss:
scaled_loss.backward()
else:
loss.backward()
tr_loss += loss.item()
if (step + 1) % args.gradient_accumulation_steps == 0:
if args.fp16:
torch.nn.utils.clip_grad_norm_(amp.master_params(optimizer), args.max_grad_norm)
else:
torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
optimizer.step()
scheduler.step() # Update learning rate schedule
model.zero_grad()
global_step += 1
if (
args.local_rank in [-1, 0] and
args.logging_steps > 0 and
global_step % args.logging_steps == 0
):
epoch_log = {}
# Only evaluate when single GPU otherwise metrics may not average well
if args.local_rank == -1 and args.evaluate_during_training_epoch:
logger.info(f"From within the epoch at step {step}")
results, _ = evaluate(args, model, tokenizer)
for key, value in results.items():
eval_key = "eval_{}".format(key)
epoch_log[eval_key] = value
epoch_log["learning_rate"] = scheduler.get_lr()[0]
epoch_log["loss"] = (tr_loss - logging_loss) / args.logging_steps
logging_loss = tr_loss
for key, value in epoch_log.items():
tb_writer.add_scalar(key, value, global_step)
logger.info(json.dumps({**epoch_log, **{"step": global_step}}))
if (
args.local_rank in [-1, 0] and
args.save_steps > 0 and
global_step % args.save_steps == 0
):
# Save model checkpoint
output_dir = os.path.join(args.output_dir, "checkpoint-{}".format(global_step))
if not os.path.exists(output_dir):
os.makedirs(output_dir)
model_to_save = (
model.module if hasattr(model, "module") else model
) # Take care of distributed/parallel training
model_to_save.save_pretrained(output_dir)
tokenizer.save_pretrained(output_dir)
torch.save(args, os.path.join(output_dir, "training_args.bin"))
logger.info("Saving model checkpoint to %s", output_dir)
torch.save(optimizer.state_dict(), os.path.join(output_dir, "optimizer.pt"))
torch.save(scheduler.state_dict(), os.path.join(output_dir, "scheduler.pt"))
logger.info("Saving optimizer and scheduler states to %s", output_dir)
epoch_iterator.set_description(f"lr = {scheduler.get_lr()[0]:.8f}, "
f"loss = {(tr_loss-epoch_loss)/(step+1):.4f}")
if args.max_steps > 0 and global_step > args.max_steps:
epoch_iterator.close()
break
mean_entropy= np.sum(train_entropy) / np.where(train_entropy < -(np.ones_like(train_entropy) * 1e-10),
np.ones_like(train_entropy),
np.zeros_like(train_entropy)).sum()
logger.info(f"*********************************selected_questions*********************************: {mean_entropy:.4f}***")
#### Post epoch eval ####
# Only evaluate when single GPU otherwise metrics may not average well
if args.local_rank == -1 and args.evaluate_during_training:
best_dev_performance, best_epoch = save_model(
args, model, tokenizer, epoch, best_epoch, best_dev_performance)
log_training_dynamics(output_dir=args.output_dir,
epoch=epoch,
train_ids=list(train_ids),
train_logits=list(train_logits),
train_golds=list(train_golds))
train_result = compute_metrics(args.task_name, np.argmax(train_logits, axis=1), train_golds)
train_acc = train_result["acc"]
epoch_log = {"epoch": epoch,
"train_acc": train_acc,
"best_dev_performance": best_dev_performance,
"avg_batch_loss": (tr_loss - epoch_loss) / args.per_gpu_train_batch_size,
"learning_rate": scheduler.get_lr()[0],}
epoch_loss = tr_loss
logger.info(f" End of epoch : {epoch}")
with open(os.path.join(args.output_dir, f"eval_metrics_train.json"), "a") as toutfile:
toutfile.write(json.dumps(epoch_log) + "\n")
for key, value in epoch_log.items():
tb_writer.add_scalar(key, value, global_step)
logger.info(f" {key}: {value:.6f}")
if args.max_steps > 0 and global_step > args.max_steps:
train_iterator.close()
break
elif args.evaluate_during_training and epoch - best_epoch >= args.patience:
logger.info(f"Ran out of patience. Best epoch was {best_epoch}. "
f"Stopping training at epoch {epoch} out of {args.num_train_epochs} epochs.")
train_iterator.close()
break
if args.local_rank in [-1, 0]:
tb_writer.close()
return global_step, tr_loss / global_step
def interleave(x, size):
s = list(x.shape)
return x.reshape([-1, size] + s[1:]).transpose(0, 1).reshape([-1] + s[1:])
def lp_train(args, train_dataset, single_dataset, single_aug_dataset, model, tokenizer, flag_in_training):
""" Train the model """
if args.local_rank in [-1, 0]:
tb_writer = SummaryWriter()
args.train_batch_size = args.per_gpu_train_batch_size * max(1, args.n_gpu)
train_dataloader = DataLoader(
train_dataset, batch_size=args.train_batch_size, shuffle=True)
if args.label_propagation and args.do_finetune:
single_aug= TripleDataset(single_dataset, single_aug_dataset)
single_train_dataloader = DataLoader(
single_aug, batch_size=args.train_batch_size, shuffle=True)
if args.max_steps > 0:
t_total = args.max_steps
args.ft_num_train_epochs = args.max_steps // (
len(train_dataloader) // args.gradient_accumulation_steps) + 1
else:
t_total = len(train_dataloader) // args.gradient_accumulation_steps * args.ft_num_train_epochs
# Prepare optimizer and schedule (linear warmup and decay)
no_decay = ["bias", "LayerNorm.weight"]
optimizer_grouped_parameters = [
{"params": [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)],
"weight_decay": args.weight_decay,
},
{"params": [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)],
"weight_decay": 0.0
},
]
if flag_in_training =='finetune':
optimizer = AdamW(optimizer_grouped_parameters, lr=args.finetune_learning_rate, eps=args.adam_epsilon)
else:
optimizer = AdamW(optimizer_grouped_parameters, lr=args.learning_rate, eps=args.adam_epsilon)
scheduler = get_linear_schedule_with_warmup(
optimizer, num_warmup_steps=args.warmup_steps, num_training_steps=t_total
)
# Check if saved optimizer or scheduler states exist
if os.path.isfile(os.path.join(args.model_name_or_path, "optimizer.pt")) and os.path.isfile(
os.path.join(args.model_name_or_path, "scheduler.pt")
):
# Load in optimizer and scheduler states
optimizer.load_state_dict(torch.load(os.path.join(args.model_name_or_path, "optimizer.pt")))
for param_group in optimizer.param_groups:
param_group['lr'] =args.finetune_learning_rate
# scheduler.load_state_dict(torch.load(os.path.join(args.model_name_or_path, "scheduler.pt")))
if args.fp16:
try:
from apex import amp
except ImportError:
raise ImportError(
"Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
# multi-gpu training (should be after apex fp16 initialization)
if args.n_gpu > 1:
model = torch.nn.DataParallel(model)
# Distributed training (should be after apex fp16 initialization)
if args.local_rank != -1:
model = torch.nn.parallel.DistributedDataParallel(
model,
device_ids=[args.local_rank],
output_device=args.local_rank,
find_unused_parameters=True,
)
# Train!
# args.local_rank = -1
# get_world_size = 1
# args.train_batch_size = 128
logger.info("***** Running training *****")
logger.info(" Num examples = %d", len(train_dataset))
logger.info(" Num Epochs = %d", args.ft_num_train_epochs)
logger.info(" Instantaneous batch size per GPU = %d", args.per_gpu_train_batch_size)
logger.info(
" Total train batch size (w. parallel, distributed & accumulation) = %d",
args.train_batch_size
* args.gradient_accumulation_steps
* (torch.distributed.get_world_size() if args.local_rank != -1 else 1),
)
logger.info(" local_rank = %d", args.local_rank)
logger.info(" Gradient Accumulation steps = %d", args.gradient_accumulation_steps)
logger.info(" Total optimization steps = %d", t_total)
global_step = 0
epochs_trained = 0
steps_trained_in_this_epoch = 0
# Check if continuing training from a checkpoint
if os.path.exists(args.model_name_or_path):
# set global_step to gobal_step of last saved checkpoint from model path
global_step = 0
# global_step = int(args.model_name_or_path.split("-")[-1].split("/")[0])
epochs_trained = global_step // (len(train_dataloader) // args.gradient_accumulation_steps)
steps_trained_in_this_epoch = global_step % (
len(train_dataloader) // args.gradient_accumulation_steps)
logger.info(f" Continuing training from checkpoint, will skip to saved global_step")
logger.info(f" Continuing training from epoch {epochs_trained}")
logger.info(f" Continuing training from global step {global_step}")
logger.info(f" Will skip the first {steps_trained_in_this_epoch} steps in the first epoch")
tr_loss, logging_loss, epoch_loss = 0.0, 0.0, 0.0
model.zero_grad()
if flag_in_training =='finetune':
train_iterator = trange(epochs_trained,
int(args.ft_num_train_epochs),
desc="Epoch",
disable=args.local_rank not in [-1, 0],
mininterval=10,
ncols=100)
else:
train_iterator = trange(epochs_trained,
int(args.num_train_epochs),
desc="Epoch",
disable=args.local_rank not in [-1, 0],
mininterval=10,
ncols=100)
set_seed(args) # Added here for reproductibility
best_dev_performance = 0
best_epoch = epochs_trained
train_acc = 0.0
total_entropy = 0.
total_sample_size = 0
single_iter = iter(single_train_dataloader)
for epoch, _ in enumerate(train_iterator):
epoch_iterator = tqdm(train_dataloader,
desc="Iteration",
disable=args.local_rank not in [-1, 0],
mininterval=10,
ncols=100)
train_iterator.set_description(f"train_epoch: {epoch} train_acc: {train_acc:.4f}")
train_ids = None
train_golds = None
train_logits = None
train_losses = None
for step, batch in enumerate(epoch_iterator):
# Skip past any already trained steps if resuming training
if steps_trained_in_this_epoch > 0:
steps_trained_in_this_epoch -= 1
continue
model.train()
try:
inputs_u_w, inputs_u_s = single_iter.next()
except StopIteration:
single_iter = iter(single_train_dataloader)
inputs_u_w, inputs_u_s = single_iter.next()
batch = tuple(t.to(args.device) for t in batch)
inputs = {"input_ids": batch[0], "attention_mask": batch[1], "labels": batch[3]}
if args.model_type != "distilbert":
inputs["token_type_ids"] = (
batch[2] if args.model_type in ["bert", "xlnet", "albert"] else None
) # XLM, DistilBERT, RoBERTa, and XLM-RoBERTa don't use segment_ids
outputs = model(**inputs)
loss = outputs[0] # model outputs are always tuple in transformers (see doc)
if args.label_propagation and args.do_finetune:
# import pdb
# pdb.set_trace()
batch_single = tuple(t.to(args.device) for t in inputs_u_w)
inputs_single = {"input_ids": batch_single[0], "attention_mask": batch_single[1], "labels": batch_single[3]}
if args.model_type != "distilbert":
inputs_single["token_type_ids"] = (
batch_single[2] if args.model_type in ["bert", "xlnet", "albert"] else None
) # XLM, DistilBERT, RoBERTa, and XLM-RoBERTa don't use segment_ids
batch_single_aug = tuple(t.to(args.device) for t in inputs_u_s)
inputs_single_aug = {"input_ids": batch_single_aug[0], "attention_mask": batch_single_aug[1], "labels": batch_single_aug[3]}
if args.model_type != "distilbert":
inputs_single_aug["token_type_ids"] = (
batch_single_aug[2] if args.model_type in ["bert", "xlnet", "albert"] else None
) # XLM, DistilBERT, RoBERTa, and XLM-RoBERTa don't use segment_ids
multi_before_softmax = outputs[1]
single_outputs = model(**inputs_single)
alpha = 1. # 1., 0.5 is enough
lsmooth_tau = 0.6
lamb = np.random.beta(alpha, alpha)
index = min(multi_before_softmax.shape[0], single_outputs[1].shape[0])
print(multi_before_softmax.size(), 'multi_before')
print(single_outputs[1].size(), 'single_output')
mixup_feature = multi_before_softmax[:index] * lamb + single_outputs[1][:index] * (1 - lamb)
# soft label v2
soft_label_tau = .75
soft_label = torch.softmax(single_outputs[1][:index], dim=-1) * soft_label_tau \
+ inputs_single['labels'][:index] * (1 - soft_label_tau)
# single+single
shuffle_index = torch.randperm(index).long().cuda()
single_mixup_feature = single_outputs[1][:index][shuffle_index] * lamb + single_outputs[1][:index] * (
1 - lamb)
single_mixup_label = inputs_single['labels'][:index][shuffle_index] * lamb + inputs_single['labels'][:index] * (1 - lamb)
single_loss = nn.KLDivLoss()(F.log_softmax(single_mixup_feature, dim=-1), single_mixup_label)
#multi+multi
mul_shuffle_index = torch.randperm(index).long().cuda()
multi_mixup_feature = outputs[1][:index][mul_shuffle_index] * lamb + outputs[1][:index] * (
1 - lamb)
multi_mixup_label = inputs['labels'][:index][mul_shuffle_index] * lamb + inputs['labels'][:index] * (1 - lamb)
multi_loss = nn.KLDivLoss()(F.log_softmax(multi_mixup_feature, dim=-1),
multi_mixup_label)
mixup_loss = nn.KLDivLoss()(F.log_softmax(mixup_feature, dim=-1), inputs['labels'][:index] * lamb + soft_label* (1. - lamb))
jsd_mixup_loss = JSDLossSoft()(F.log_softmax(mixup_feature, dim=-1), inputs['labels'][:index]) * lamb \
+ JSDLossSoft()(F.log_softmax(mixup_feature, dim=-1),
inputs_single['labels'][:index] * lsmooth_tau
+ (1. - lsmooth_tau) * torch.ones_like(inputs_single['labels'][:index])) \
* (1. - lamb)
print(mixup_loss.item(), jsd_mixup_loss.item(), "mixup_loss.item(), jsd_mixup_loss.item()")
reg_loss = mixup_loss * 1. + jsd_mixup_loss * 0. # check .1 or not
print(loss.mean().item(), 'original_loss')
print(reg_loss, 'reg_loss')
loss = multi_loss #+ reg_loss + single_loss
entropy=outputs[-1]
if train_logits is None: # Keep track of training dynamics.
train_ids = batch[4].detach().cpu().numpy()
train_logits = outputs[1].detach().cpu().numpy()
train_golds = inputs["labels"].detach().cpu().numpy()
train_losses = loss.detach().cpu().numpy()
train_entropy = entropy.detach().cpu().numpy()
print(entropy.size(), "check entropy size")
else:
train_ids = np.append(train_ids, batch[4].detach().cpu().numpy())
train_logits = np.append(train_logits, outputs[1].detach().cpu().numpy(), axis=0)
train_golds = np.concatenate((train_golds, inputs["labels"].detach().cpu().numpy()), 0)
train_losses = np.append(train_losses, loss.detach().cpu().numpy())
train_entropy = np.append(train_entropy, entropy.detach().cpu().numpy())
if args.n_gpu > 1:
loss = loss.mean() # mean() to average on multi-gpu parallel training
if args.gradient_accumulation_steps > 1:
loss = loss / args.gradient_accumulation_steps
if args.fp16:
with amp.scale_loss(loss, optimizer) as scaled_loss:
scaled_loss.backward()
else:
loss.backward()
tr_loss += loss.item()
if (step + 1) % args.gradient_accumulation_steps == 0:
if args.fp16:
torch.nn.utils.clip_grad_norm_(amp.master_params(optimizer), args.max_grad_norm)
else:
torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
optimizer.step()
scheduler.step() # Update learning rate schedule
model.zero_grad()
global_step += 1
if (
args.local_rank in [-1, 0] and
args.logging_steps > 0 and
global_step % args.logging_steps == 0
):
epoch_log = {}
# Only evaluate when single GPU otherwise metrics may not average well
if args.local_rank == -1 and args.evaluate_during_training_epoch:
logger.info(f"From within the epoch at step {step}")
results, _ = evaluate(args, model, tokenizer)
for key, value in results.items():
eval_key = "eval_{}".format(key)
epoch_log[eval_key] = value
epoch_log["learning_rate"] = scheduler.get_lr()[0]
epoch_log["loss"] = (tr_loss - logging_loss) / args.logging_steps
logging_loss = tr_loss
for key, value in epoch_log.items():
tb_writer.add_scalar(key, value, global_step)
logger.info(json.dumps({**epoch_log, **{"step": global_step}}))
if (
args.local_rank in [-1, 0] and
args.save_steps > 0 and
global_step % args.save_steps == 0
):
# Save model checkpoint
output_dir = os.path.join(args.output_dir, "checkpoint-{}".format(global_step))
if not os.path.exists(output_dir):
os.makedirs(output_dir)
model_to_save = (
model.module if hasattr(model, "module") else model
) # Take care of distributed/parallel training
model_to_save.save_pretrained(output_dir)
tokenizer.save_pretrained(output_dir)
torch.save(args, os.path.join(output_dir, "training_args.bin"))
logger.info("Saving model checkpoint to %s", output_dir)
torch.save(optimizer.state_dict(), os.path.join(output_dir, "optimizer.pt"))
torch.save(scheduler.state_dict(), os.path.join(output_dir, "scheduler.pt"))
logger.info("Saving optimizer and scheduler states to %s", output_dir)
epoch_iterator.set_description(f"lr = {scheduler.get_lr()[0]:.8f}, "
f"loss = {(tr_loss-epoch_loss)/(step+1):.4f}")
if args.max_steps > 0 and global_step > args.max_steps:
epoch_iterator.close()
break
# mean_entropy = total_entropy / total_sample_size
mean_entropy= np.sum(train_entropy) / np.where(train_entropy < -(np.ones_like(train_entropy) * 1e-10),
np.ones_like(train_entropy),
np.zeros_like(train_entropy)).sum()
logger.info(f"*********************************selected_questions*********************************: {mean_entropy:.4f}***")
#### Post epoch eval ####
# Only evaluate when single GPU otherwise metrics may not average well
if args.local_rank == -1 and args.evaluate_during_training:
best_dev_performance, best_epoch = save_model(
args, model, tokenizer, epoch, best_epoch, best_dev_performance)
log_training_dynamics(output_dir=args.output_dir,
epoch=epoch,
train_ids=list(train_ids),
train_logits=list(train_logits),
train_golds=list(train_golds))
train_result = compute_metrics(args.task_name, np.argmax(train_logits, axis=1), train_golds)
train_acc = train_result["acc"]
epoch_log = {"epoch": epoch,
"train_acc": train_acc,
"best_dev_performance": best_dev_performance,
"avg_batch_loss": (tr_loss - epoch_loss) / args.per_gpu_train_batch_size,
"learning_rate": scheduler.get_lr()[0],}
epoch_loss = tr_loss
logger.info(f" End of epoch : {epoch}")
with open(os.path.join(args.output_dir, f"eval_metrics_train.json"), "a") as toutfile:
toutfile.write(json.dumps(epoch_log) + "\n")
for key, value in epoch_log.items():
tb_writer.add_scalar(key, value, global_step)
logger.info(f" {key}: {value:.6f}")
if args.max_steps > 0 and global_step > args.max_steps:
train_iterator.close()
break
elif args.evaluate_during_training and epoch - best_epoch >= args.patience:
logger.info(f"Ran out of patience. Best epoch was {best_epoch}. "
f"Stopping training at epoch {epoch} out of {args.ft_num_train_epochs} epochs.")
train_iterator.close()
break
if args.local_rank in [-1, 0]:
tb_writer.close()
return global_step, tr_loss / global_step
def save_model(args, model, tokenizer, epoch, best_epoch, best_dev_performance):
results, _ = evaluate(args, model, tokenizer, prefix="in_training")
# TODO(SS): change hard coding `acc` as the desired metric, might not work for all tasks.
desired_metric = "acc"
dev_performance = results.get(desired_metric)
# if dev_performance > best_dev_performance:
if True:
best_epoch = epoch
best_dev_performance = dev_performance
# Save model checkpoint
# Take care of distributed/parallel training
model_to_save = (model.module if hasattr(model, "module") else model)
model_to_save.save_pretrained(args.output_dir)
tokenizer.save_pretrained(args.output_dir)
torch.save(args, os.path.join(args.output_dir, "training_args.bin"))
logger.info(f"*** Found BEST model, and saved checkpoint. "
f"BEST dev performance : {dev_performance:.4f} ***")
return best_dev_performance, best_epoch
#Entropy
def JSD(P, Q):
M = 0.5 * (P + Q)
# print('entropy', entropy(P, M), P, M)
return 0.5 * (entropy(P, M) + entropy(Q, M))
#torch Kl_div
def JSD_2(P, Q):
P= np.array(P, dtype=float)
Q= np.array(Q, dtype=float)
M = 0.5 * (P+Q)
_jsd = 0.5* ((torch.nn.functional.kl_div(torch.log(torch.from_numpy(M)), torch.from_numpy(P)).numpy() - 0) + (torch.nn.functional.kl_div(torch.log(torch.from_numpy(M)), torch.from_numpy(Q)).numpy() - 0))
return _jsd
def evaluate(args, model, tokenizer, prefix="", eval_split="dev"):
eval_task_names = (args.task_name,)
eval_outputs_dirs = (args.output_dir,)
results = {}
all_predictions = {}
for eval_task, eval_output_dir in zip(eval_task_names, eval_outputs_dirs):
eval_dataset, pair_id = eval_load_and_cache_examples(
args, eval_task, tokenizer, evaluate=True, data_split=f"{eval_split}_{prefix}")
if not os.path.exists(eval_output_dir) and args.local_rank in [-1, 0]:
os.makedirs(eval_output_dir)
args.eval_batch_size = args.per_gpu_eval_batch_size * max(1, args.n_gpu)
eval_sampler = SequentialSampler(eval_dataset)
eval_dataloader = DataLoader(
eval_dataset, sampler=eval_sampler, batch_size=args.eval_batch_size)
# multi-gpu eval
if args.n_gpu > 1 and not isinstance(model, torch.nn.DataParallel):
model = torch.nn.DataParallel(model)
# Eval!
logger.info(f"***** Running {eval_task} {prefix} evaluation on {eval_split} *****")
logger.info(f" Num examples = {len(eval_dataset)}")
logger.info(f" Batch size = {args.eval_batch_size}")
eval_loss = 0.0
nb_eval_steps = 0
preds = None
out_label_ids = None
example_ids = []
gold_labels = []
for batch in tqdm(eval_dataloader, desc="Evaluating", mininterval=10, ncols=100):
model.eval()
batch = tuple(t.to(args.device) for t in batch)
with torch.no_grad():
inputs = {"input_ids": batch[0], "attention_mask": batch[1], "labels": batch[3]}
if args.model_type != "distilbert":
inputs["token_type_ids"] = (
batch[2] if args.model_type in ["bert", "xlnet", "albert"] else None
) # XLM, DistilBERT, RoBERTa, and XLM-RoBERTa don't use segment_ids
outputs = model(**inputs)
tmp_eval_loss, logits = outputs[:2]
eval_loss += tmp_eval_loss.mean().item()
example_ids += batch[4].tolist()
gold_labels += batch[3].tolist()
nb_eval_steps += 1
if preds is None:
preds = logits.detach().cpu().numpy()
out_label_ids = inputs["labels"].detach().cpu().numpy()
else:
preds = np.append(preds, logits.detach().cpu().numpy(), axis=0)
out_label_ids = np.append(
out_label_ids, inputs["labels"].detach().cpu().numpy(), axis=0)
eval_loss = eval_loss / nb_eval_steps
if args.output_mode == "classification":
probs = torch.nn.functional.softmax(torch.Tensor(preds), dim=-1)
if args.do_temperature:
probs = torch.nn.functional.softmax(torch.Tensor(preds)/1.75, dim=-1)
max_confidences = (torch.max(probs, dim=-1)[0]).tolist()
preds = np.argmax(preds, axis=1) # Max of logit is the same as max of probability.
elif args.output_mode == "regression":
preds = np.squeeze(preds)
result = compute_metrics(eval_task, preds, out_label_ids)
# order: [E, N, C]
results.update(result)
output_eval_file = os.path.join(
eval_output_dir, f"eval_metrics_{eval_task}_{eval_split}_{prefix}.json")
logger.info(f"***** {eval_task} {eval_split} results {prefix} *****")
for key in sorted(result.keys()):
logger.info(f"{eval_task} {eval_split} {prefix} {key} = {result[key]:.4f}")
with open(output_eval_file, "a") as writer:
writer.write(json.dumps(results) + "\n")
# predictions
all_predictions[eval_task] = []
output_pred_file = os.path.join(
eval_output_dir, f"predictions_{eval_task}_{eval_split}_{prefix}.lst")
with open(output_pred_file, "w") as writer:
logger.info(f"***** Write {eval_task} {eval_split} predictions {prefix} *****")
for ex_id, pred, gold, max_conf, prob in zip(
example_ids, preds, gold_labels, max_confidences, probs.tolist()):
# print(pred, prob, gold);input()
# print('gold_label', processors[args.task_name]().get_labels()[int(max(gold))])
record = {"guid": ex_id,
"label": processors[args.task_name]().get_labels()[pred],
"gold": processors[args.task_name]().get_labels()[int( | np.argmax(gold) | numpy.argmax |
import numpy as np
import torch
import imageio
import os
import torch.utils.data as data
def InfiniteSampler(n):
"""Data sampler"""
i = n - 1
order = np.random.permutation(n)
while True:
yield order[i]
i += 1
if i >= n:
np.random.seed()
order = np.random.permutation(n)
i = 0
class InfiniteSamplerWrapper(data.sampler.Sampler):
"""Data sampler wrapper"""
def __init__(self, data_source):
self.num_samples = len(data_source)
def __iter__(self):
return iter(InfiniteSampler(self.num_samples))
def __len__(self):
return 2 ** 15
def get_nsamples(data_loader, N):
x = []
n = 0
while n < N:
x_next = next(data_loader)
x_next = x_next.cuda(non_blocking=True)
x.append(x_next)
n += x_next.size(0)
x = torch.cat(x, dim=0)[:N]
return x
def count_trainable_parameters(model):
model_parameters = filter(lambda p: p.requires_grad, model.parameters())
return sum([np.prod(p.size()) for p in model_parameters])
def save_video(imgs, fname, as_gif=False, fps=24, quality=8):
# convert to np.uint8
imgs = (255 * np.clip(imgs.permute(0, 2, 3, 1).detach().cpu().numpy() / 2 + 0.5, 0, 1)).astype(np.uint8)
imageio.mimwrite(fname, imgs, fps=fps, quality=quality)
if as_gif: # save as gif, too
os.system(f'ffmpeg -i {fname} -r 15 '
f'-vf "scale=512:-1,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" {os.path.splitext(fname)[0] + ".gif"}')
def color_depth_map(depths, scale=None):
"""
Color an input depth map.
Arguments:
depths -- HxW numpy array of depths
[scale=None] -- scaling the values (defaults to the maximum depth)
Returns:
colored_depths -- HxWx3 numpy array visualizing the depths
"""
_color_map_depths = np.array([
[0, 0, 0], # 0.000
[0, 0, 255], # 0.114
[255, 0, 0], # 0.299
[255, 0, 255], # 0.413
[0, 255, 0], # 0.587
[0, 255, 255], # 0.701
[255, 255, 0], # 0.886
[255, 255, 255], # 1.000
[255, 255, 255], # 1.000
]).astype(float)
_color_map_bincenters = np.array([
0.0,
0.114,
0.299,
0.413,
0.587,
0.701,
0.886,
1.000,
2.000, # doesn't make a difference, just strictly higher than 1
])
if scale is None:
scale = depths.max()
values = np.clip(depths.flatten() / scale, 0, 1)
# for each value, figure out where they fit in in the bincenters: what is the last bincenter smaller than this value?
lower_bin = ((values.reshape(-1, 1) >= _color_map_bincenters.reshape(1, -1)) * np.arange(0, 9)).max(axis=1)
lower_bin_value = _color_map_bincenters[lower_bin]
higher_bin_value = _color_map_bincenters[lower_bin + 1]
alphas = (values - lower_bin_value) / (higher_bin_value - lower_bin_value)
colors = _color_map_depths[lower_bin] * (1 - alphas).reshape(-1, 1) + _color_map_depths[
lower_bin + 1] * alphas.reshape(-1, 1)
return colors.reshape(depths.shape[0], depths.shape[1], 3).astype(np.uint8)
# Virtual camera utils
def to_sphere(u, v):
theta = 2 * np.pi * u
phi = | np.arccos(1 - 2 * v) | numpy.arccos |
# See info about the sl2 file format at:
# * https://wiki.openstreetmap.org/wiki/SL2
# * https://github.com/kmpm/node-sl2format/blob/master/doc/sl2fileformat.md
# * https://www.geotech1.com/forums/showthread.php?11159-Lowrance-MCC-saved-data-structure
# * https://github.com/Chris78/sl2decode/blob/master/sl2decode.rb
# * https://github.com/Chris78/sl2decode
#
# Also has sl2+sl3 and extra comments about the field meanings, includes encoder as well:
# https://github.com/risty/SonarLogApi/tree/master/SonarLogAPI/Lowrance
#
# Note: I think all info that appears public about the "flags" field is wrong.
# None of the decoders make use of the flags and I saw little correlation between
# the flags and changes in associated data. There are however some correlations
# like when the GPS values change that appear to correlate with a few flags etc
import os
import os.path
import glob
import struct
import math
import re
import numpy
import pandas
import dask
import dask.dataframe
import xarray
import json
import datetime
import pytz
import tzlocal
import logging
logger = logging.getLogger('lowrance_log_parser')
CACHE_VERSION = 3
PARAQUET_ENGINE='pyarrow'
# Max items in a single pandas.DataFrame, we split and use dask to handle them
MAX_SEGMENT_SIZE = 5 * 1024
# Max bytes of data we expect to see in the sonar data segment
SONAR_DATA_MAX_SIZE = 3072
FORMAT_SLG = 1
FORMAT_SL2 = 2
FORMAT_SL3 = 3
FORMAT_MAP = {
1: 'slg',
2: 'sl2',
3: 'sl3',
}
def FormatToStr(format):
if format not in FORMAT_MAP:
return 'UNK(' + str(format) + ')'
return FORMAT_MAP[format]
FAMILY_MAP = {
0: 'HDS 7',
1: 'Elite 4 CHIRP',
}
def FamilyToStr(family):
if family not in FAMILY_MAP:
return 'UNK(' + str(family) + ')'
return FAMILY_MAP[family]
# Traditional Sonar
PRIMARY = 0
# Traditional Sonar
SECONDARY = 1
# DownScan Imaging
DOWNSCAN = 2
LEFT_SIDESCAN = 3
RIGHT_SIDESCAN = 4
COMPOSITE_SIDESCAN = 5
# 7,8 found in yens new HDS Live sonar log.
# 7 looks like a normal sonar or downscan or something
# but has 2x samples for each frame index
#
# 8 looks like some kinds of other non-image data
# maybe not even uint8 also has 2x samples for each frame index
# like channel 7
#
# All other channels have 1 sample per frame index so it is weird
THREE_DIMENSIONAL = 9
def ChannelToStr(id):
if id == PRIMARY: return 'primary'
elif id == SECONDARY: return 'secondary'
elif id == DOWNSCAN: return 'downscan'
elif id == LEFT_SIDESCAN: return 'left_sidescan'
elif id == RIGHT_SIDESCAN: return 'right_sidescan'
elif id == COMPOSITE_SIDESCAN: return 'composite_sidescan'
else: return 'unknown' + str(id)
#Sonar transducer frequency
FREQUENCY_MAP = {
0 : '200 KHz',
1 : '50 KHz',
2 : '83 KHz',
3 : '455 KHz',
4 : '800 KHz',
5 : '38 KHz',
6 : '28 KHz',
7 : '130 KHz - 210 KHz',
8 : '90 KHz - 150 KHz',
9 : '40 KHz - 60 KHz',
10 : '25 KHz - 45 KHz',
# Any other value is treated like 200 KHz
}
def FrequencyToStr(freq):
if freq not in FREQUENCY_MAP:
#logger.warning('Invalid frequency input: %s assuming 200 KHz', freq)
return 'Unknown frequency value %s assume 200 KHz' % (freq)
return FREQUENCY_MAP[freq]
# Included both forward/reverse because still trying to figure out
# what the flags mean. The public docs I saw didnt seem to match up
# with my sl2 files.
# From: https://github.com/risty/SonarLogApi/blob/master/SonarLogAPI/Lowrance/Frame.cs
#TrackValid = 0,
#Preset_0_1 = 1,
#Unknown0_2 = 2,
#PositionValid = 3,
#Unknown_0_4 = 4,
#CourseOrSpeed_0_5 = 5,
#SpeedValid = 6,
#Preset_0_7 = 7,
#Unknown1_0 = 8,
#AltitudeOrCourseOrSpeed_1_1 = 9,
#Unknown1_2 = 10,
#Unknown1_3 = 11,
#Unknown1_4 = 12,
#Unknown1_5 = 13,
#AltitudeValid = 14,
#HeadingValid = 15
FLAGS_MAP_FORWARD = {
'course_over_ground_valid' : 1 << 15,
'speed_water_valid' : 1 << 14,
'flag_unknown01' : 1 << 13,
'position_valid' : 1 << 12,
'flag_unknown02' : 1 << 11,
'temperature_valid' : 1 << 10,
'speed_gps_valid' : 1 << 9,
'flag_unknown03' : 1 << 8,
'flag_unknown04' : 1 << 7,
'flag_unknown05' : 1 << 6,
'flag_unknown06' : 1 << 5,
'flag_unknown07' : 1 << 4,
'flag_unknown08' : 1 << 3,
'flag_unknown09' : 1 << 2,
'altitude_valid' : 1 << 1,
'heading_valid' : 1 << 0,
}
FLAGS_MAP_REVERSE = {
'course_over_ground_valid' : 1 << 0,
'speed_water_valid' : 1 << 1,
'flag_unknown01' : 1 << 2,
'position_valid' : 1 << 3,
'flag_unknown02' : 1 << 4,
'temperature_valid' : 1 << 5,
'speed_gps_valid' : 1 << 6,
'flag_unknown03' : 1 << 7,
'flag_unknown04' : 1 << 8,
'flag_unknown05' : 1 << 9,
'flag_unknown06' : 1 << 10,
'flag_unknown07' : 1 << 11,
'flag_unknown08' : 1 << 12,
'flag_unknown09' : 1 << 13,
'altitude_valid' : 1 << 14,
'heading_valid' : 1 << 15,
}
# The settings below are used to help try and figure out /reverse engineer the purpose
# of the flags item in the sl2 file by correlating changes in data with
# true/false values in the flags.
#
# Other reverse engineering summaries say these flags mean XYZ_valid I.e.
# when true we expect updates to the data for XYZ. So for example
# position_valid indicates there should be valid data in the longitude/latitude
# fields. I have also noticed that most data fields tend to maintain previous values
# until updated. So you might get a speed_gps of 2km/h and it stays exactly the
# same value for a few data samples, then it changes to something else.
#
# I was expecting thus that the speed_gps_valid flag would be set to true
# when we see this change in the speed_gps value.
#
# Likewise more importantly, I should NEVER see the data for speed_gps change
# while speed_gps_valid = false.
#
# It turns out these assumptions are not correct which leads me to believe
# that these flags have different meanings than previously described
# Choose the bitmask allocation of names to bit
#FLAGS_MAP = FLAGS_MAP_FORWARD
FLAGS_MAP = FLAGS_MAP_REVERSE
def FlagsToStr(flags, sep=','):
s = []
for k,v in FLAGS_MAP.items():
if v & flags: s.append(k + '=true')
else: s.append(k + '=false')
return sep.join(s)
def FeetToMeters(value): return value / 3.2808399
SECONDS_PER_MINUTE = 60
MINUTES_PER_HOUR = 60
def KnotsToKmph(value): return (value / 1.94385) / 1000 * SECONDS_PER_MINUTE * MINUTES_PER_HOUR
def RadiansToDegrees(rad): return rad * 180.0 / math.pi
# Copied from datashader.utils, importing datashader is very slow so we duplicate this here
# as we dont care about the rest of it
def lnglat_to_meters(longitude, latitude):
"""
Projects the given (longitude, latitude) values into Web Mercator
coordinates (meters East of Greenwich and meters North of the Equator).
Longitude and latitude can be provided as scalars, Pandas columns,
or Numpy arrays, and will be returned in the same form. Lists
or tuples will be converted to Numpy arrays.
Examples:
easting, northing = lnglat_to_meters(-40.71,74)
easting, northing = lnglat_to_meters(np.array([-74]),np.array([40.71]))
df=pandas.DataFrame(dict(longitude=np.array([-74]),latitude=np.array([40.71])))
df.loc[:, 'longitude'], df.loc[:, 'latitude'] = lnglat_to_meters(df.longitude,df.latitude)
"""
if isinstance(longitude, (list, tuple)):
longitude = numpy.array(longitude)
if isinstance(latitude, (list, tuple)):
latitude = numpy.array(latitude)
origin_shift = numpy.pi * 6378137
easting = longitude * origin_shift / 180.0
northing = numpy.log(numpy.tan((90 + latitude) * numpy.pi / 360.0)) * origin_shift / numpy.pi
return (easting, northing)
# Implemented just doing reverse of lnglat_to_meters
def meters_to_lnglat(easting, northing):
if isinstance(easting, (list, tuple)):
easting = numpy.array(easting)
if isinstance(northing, (list, tuple)):
northing = numpy.array(northing)
origin_shift = numpy.pi * 6378137
longitude = easting / origin_shift * 180.0
latitude = (numpy.arctan(numpy.exp(northing / origin_shift * numpy.pi)) / numpy.pi * 360.0) - 90.0
return (longitude, latitude)
# SL2 format stores Easting and Northing coordinates in Spherical Mercator Projection,
# using WGS84 POLAR Earth radius
#
# OpenStreetMap and Google instead use the WGS84 EQUATORIAL Earth Radius
# So we will convert and use the more popular format
POLAR_EARTH_RADIUS = 6356752.3142;
# https://www.movable-type.co.uk/scripts/latlong-utm-mgrs.html
# A Universal Transverse Mercator coordinate comprises a zone number, a hemisphere (N/S), an easting and a northing.
# Eastings are referenced from the central meridian of each zone, & northings from the equator, both in metres.
# To avoid negative numbers, ‘false eastings’ and ‘false northings’ are used:
# Eastings are measured from 500,000 metres west of the central meridian. Eastings (at the equator) range from 166,021m to 833,978m (the range decreases moving away from the equator); a point on the the central meridian has the value 500,000m.
#
#In the northern hemisphere, northings are measured from the equator – ranging from 0 at the equator to 9,329,005m at 84°N). In the southern hemisphere they are measured from 10,000,000 metres south of the equator (close to the pole) – ranging from 1,116,915m at 80°S to 10,000,000m at the equator.
def UniversalTransverseMercatorToWGS84EquatorialLongitude(polar_longitude):
plon = int(polar_longitude)
equatorial_longitude = plon / POLAR_EARTH_RADIUS * (180.0 / math.pi)
return equatorial_longitude
# From: https://github.com/Chris78/sl2decode/blob/master/sl2decode.rb
# https://github.com/Chris78/sl2decode
UINT32_MAX = 0xffffffff # 4294967295U
def UniversalTransverseMercatorToWGS84EquatorialLatitude(polar_latitude, is_northern_hemisphere=False):
plat = int(polar_latitude)
if not is_northern_hemisphere:
plat = plat - UINT32_MAX
temp = plat / POLAR_EARTH_RADIUS
temp = math.exp(temp)
temp = (2 * math.atan(temp)) - (math.pi / 2)
equatorial_latitude = temp * (180/math.pi)
# @todo Horrible hack, I need to understand this better so we can do the
# correct thing not just copy from others something that only worked for the northern hemisphere
if equatorial_latitude == -90.0 and not is_northern_hemisphere:
return UniversalTransverseMercatorToWGS84EquatorialLatitude(polar_latitude, True)
return equatorial_latitude
# Copied from datashader.utils, importing datashader is very slow so we duplicate this here
# as we dont care about the rest of it
def LowranceLongitudeToWebMercator(longitude):
longitude = UniversalTransverseMercatorToWGS84EquatorialLongitude(longitude)
origin_shift = numpy.pi * 6378137
easting = longitude * origin_shift / 180.0
return easting
def LowranceLatitudeToWebMercator(latitude):
latitude = UniversalTransverseMercatorToWGS84EquatorialLatitude(latitude)
origin_shift = numpy.pi * 6378137
northing = numpy.log(numpy.tan((90 + latitude) * numpy.pi / 360.0)) * origin_shift / numpy.pi
return northing
#Ideally I would like to define the parsing in a single location/definition that we use and is fast
#Something like:
class Field:
def __init__(self, offset, struct_format, name, dtype, attrs={}, conversion=None, description='', notes=''):
self.offset = offset
self.struct_format = struct_format
self.name = name
self.conversion = conversion
self.dtype = None
if dtype is not None:
self.dtype = numpy.dtype(dtype)
self.attrs = attrs
self.description = description
self.notes = notes
if self.conversion is None:
self.conversion = lambda a : a
def GetIfNone(f, inp, name):
if inp is not None:
return inp
return getattr(f, name)
def FieldCopy(src, offset, name, struct_format=None, dtype=None, attrs=None, conversion=None, description=None, notes=None):
for f in src:
if f.name == name:
struct_format = GetIfNone(f, struct_format, 'struct_format')
dtype = GetIfNone(f, dtype, 'dtype')
attrs = GetIfNone(f, attrs, 'attrs')
conversion = GetIfNone(f, conversion, 'conversion')
description = GetIfNone(f, description, 'description')
notes = GetIfNone(f, notes, 'notes')
return Field(offset, struct_format, name, dtype, attrs, conversion, description, notes)
raise Exception('Failed to copy as no field matching name: %s' % (name))
MSEC_TO_NSEC = numpy.uint64(1000000)
def ToDatetime64ns(arg):
# Is in milliseconds (except the first value)
return (numpy.uint64(arg) * MSEC_TO_NSEC).astype('datetime64[ns]')
slX_header_parser = [
Field(0, 'H', 'format', 'uint16', description='Lowrance sonar log file format', notes='One of 1:slg, 2:sl2, 3:sl3'),
# Not sure what options exist and mean here. So far have seen:
# 0 = HDS 7 (Not sure where i got this info from)
# 1 = Elite 5 CHIRP (My unit reports this, not sure what others do)
# 2 = HDS Live 7 (Yens unit reports this, not sure what others do)
Field(2, 'H', 'family', 'uint16', description='Lowrance product hardware version'),
# Not sure about this. So far have seen:
# 1970=Downscan #b207
# 3200=Sidescan #800c
Field(4, 'H', 'block_size', 'uint16', description='Sonar type or blocksize'),
# Supposed to be always 0 according to sl2, but in sl3 logs I have seen it has value of 1
#Field(6, 'H', 'reserved', 'uint16'),
# Mark the end of the fixed length struct without requiring a value decoded from it
Field(8, None, None, None)
]
sl2_block_parser = [
# FrameOffset = 0, //int, 4 bytes : https://github.com/risty/SonarLogApi/tree/master/SonarLogAPI/Lowrance
# Used sometimes to detect we are in a valid offset for decoding
# The last block in some log files (when sonar crashed) this has all zeros
Field(0, 'I', 'block_offset', 'uint32', description='The offset in bytes from start of file this block starts'),
#LastPrimaryChannelFrameOffset = 4, //int, 4 bytes : https://github.com/risty/SonarLogApi/tree/master/SonarLogAPI/Lowrance
#last_primary_channel_block_offset
#LastSecondaryChannelFrameOffset = 8, //int, 4 bytes : https://github.com/risty/SonarLogApi/tree/master/SonarLogAPI/Lowrance
#last_secondary_channel_block_offset
#LastDownScanChannelFrameOffset = 12, //int, 4 bytes : https://github.com/risty/SonarLogApi/tree/master/SonarLogAPI/Lowrance
#last_downscan_channel_block_offset
#LastSidescanLeftChannelFrameOffset = 16, //int, 4 bytes : https://github.com/risty/SonarLogApi/tree/master/SonarLogAPI/Lowrance
#last_left_sidescan_channel_block_offset
#LastSidescanRightChannelFrameOffset = 20, //int, 4 bytes : https://github.com/risty/SonarLogApi/tree/master/SonarLogAPI/Lowrance
#last_right_sidescan_channel_block_offset
#LastSidescanCompositeChannelFrameOffset = 24, //int, 4 bytes : https://github.com/risty/SonarLogApi/tree/master/SonarLogAPI/Lowrance
#last_composite_sidescan_channel_block_offset
#ThisFrameSize = 28, //short, 2 bytes. Bytes to next frame Start : https://github.com/risty/SonarLogApi/tree/master/SonarLogAPI/Lowrance
Field(28, 'H', 'current_block_bytes', 'uint16', description=''),
#PreviousFrameSize = 30, //short, 2 bytes. Bytes to previous frame Start
#last_block_bytes
#ChannelType = 32,//short, 2 bytes
Field(32, 'H', 'channel', 'uint16', description='Identifies type of sonar data like primary, side-scan, downscan etc'),
#PacketSize = 34,//short, 2 bytes : https://github.com/risty/SonarLogApi/tree/master/SonarLogAPI/Lowrance
Field(34, 'H', 'data_size', 'uint16', description='Size of sounding/bounce data'),
#FrameIndex = 36,//int, 4 bytes
Field(36, 'I', 'frame_index', 'uint32', description='Starts at 0. Used to match frames/block on different channels.'),
#UpperLimit = 40,//float, 4 bytes
Field(40, 'f', 'upper_limit', 'float32', {'units': 'meters'}, FeetToMeters, description=''),
#LowerLimit = 44,//float, 4 bytes
Field(44, 'f', 'lower_limit', 'float32', {'units': 'meters'}, FeetToMeters, description=''),
#Frequency = 50,//byte
Field(50, 'B', 'sonar_frequency', 'uint8', description='Sonar frequency'),
#CreationDataTime = 60,//int, 4 bytes,
# value in first frame = Unix time stamp of file creation.
# other frames - time from device boot.
Field(60, 'I', 'datetime', 'datetime64[ns]', {}, ToDatetime64ns, description='Unix timestamp of file creation'),
# Depth = 64,//float, 4 bytes
Field(64, 'f', 'water_depth', 'float32', {'units': 'meters'}, FeetToMeters, description='Depth under water surface(transponder)'),
# Depth under keel
# KeelDepth = 68,//float, 4 bytes
#SpeedGps = 100,//float, 4 bytes
# @todo Validate speed correct, one says m/s we want k/h original said in knots
Field(100, 'f', 'speed_gps', 'float32', {'units': 'km/h'}, KnotsToKmph, description='Speed from GPS in km/h'),
#Temperature = 104,//float, 4 bytes
Field(104, 'f', 'temperature', 'float32', {'units': 'celsius'}, description='Temperature, in Celsius'),
# IntLongitude = 108,//int, 4 bytes
Field(108, 'I', 'longitude', 'float32', {'units': 'meters', 'coordinate system': 'Web Mercator'}, LowranceLongitudeToWebMercator, description=''),
# IntLatitude = 112,//int, 4 bytes
Field(112, 'I', 'latitude', 'float32', {'units': 'meters', 'coordinate system': 'Web Mercator'}, LowranceLatitudeToWebMercator, description=''),
# If such a sensor is not present, it takes the value from "Speed" (GPS NMEA data)
# and sets WaterSpeedValid to false.
#WaterSpeed = 116,//float, 4 bytes
Field(116, 'f', 'speed_water', 'float32', {'units': 'kmph'}, KnotsToKmph, description='WaterSpeed in m/s. This value is taken from an actual Water Speed Sensor (such as a paddle-wheel).'),
#CourseOverGround = 120,//float, 4 bytes
Field(120, 'f', 'course_over_ground', 'float32', {'units': 'degrees'}, RadiansToDegrees, description='Track/Course-Over-Ground in radians. Real direction of boat movement. Taken from GPS NMEA data. '),
#Altitude = 124,//float, 4 bytes
Field(124, 'f', 'altitude', 'float32', {'units': 'meters'}, FeetToMeters, description='Altitude in meters. Taken from GPS NMEA data.'),
#Heading = 128,//float, 4 bytes
Field(128, 'f', 'heading', 'float32', {'units': 'degrees'}, RadiansToDegrees, description='Heading in radians. Angle in radians between magnetic north and transducer.'),
#Flags = 132, // two bytes
#Field(132, 'H', 'flags', 'uint16', {}, description=''),
# I validated that this appears in logs from my device to be msec since the device
# booted. I.e. Not start of log as it doesnt start at t=0
# TimeOffset = 140,//int, 4 bytes.
Field(140, 'I', 'time_offset', 'uint32', {}, description='Duration since device boot in msec'),
# Mark the end of the fixed length struct without requiring a value decoded from it
Field(144, None, None, None)
# Contains sounding/bounce data
#SoundedData = 144// bytes array, size of PacketSize
]
sl3_block_parser = [
#FrameOffset = 0,//int, 4 bytes
FieldCopy(sl2_block_parser, 0, 'block_offset'),
#ThisFrameSize = 8, //short, 2 bytes. Bytes to next frame Start : https://github.com/risty/SonarLogApi/tree/master/SonarLogAPI/Lowrance
FieldCopy(sl2_block_parser, 8, 'current_block_bytes'),
#PreviousFrameSize = 10,//short, 2 bytes. Bytes to previous frame Start
#last_block_bytes
#ChannelType = 12,//short, 2 bytes
FieldCopy(sl2_block_parser, 12, 'channel'),
#FrameIndex = 16,//int, 4 bytes
FieldCopy(sl2_block_parser, 16, 'frame_index'),
#UpperLimit = 20,//float, 4 bytes
FieldCopy(sl2_block_parser, 20, 'upper_limit'),
#LowerLimit = 24,//float, 4 bytes
FieldCopy(sl2_block_parser, 24, 'lower_limit'),
#CreationDataTime = 40,//int, 4 bytes, value at fist frame = Unix time stamp of file creation. if GPS cant find position value will be "-1" # value in first frame = Unix time stamp of file creation.
#//other frames - time in milliseconds from device boot.
FieldCopy(sl2_block_parser, 40, 'datetime'),
#PacketSize = 44,//short, 2 bytes
FieldCopy(sl2_block_parser, 44, 'data_size'),
#Depth = 48,//float, 4 bytes
FieldCopy(sl2_block_parser, 48, 'water_depth'),
#Frequency = 52,//byte
FieldCopy(sl2_block_parser, 52, 'sonar_frequency'),
#SpeedGps = 84,//float, 4 bytes
FieldCopy(sl2_block_parser, 84, 'speed_gps'),
#Temperature = 88,//float, 4 bytes
FieldCopy(sl2_block_parser, 88, 'temperature'),
#IntLongitude = 92,//int, 4 bytes
FieldCopy(sl2_block_parser, 92, 'longitude'),
#IntLatitude = 96,//int, 4 bytes
FieldCopy(sl2_block_parser, 96, 'latitude'),
#WaterSpeed = 100,//float, 4 bytes
FieldCopy(sl2_block_parser, 100, 'speed_water'),
#CourseOverGround = 104,//float, 4 bytes
FieldCopy(sl2_block_parser, 104, 'course_over_ground'),
#Altitude = 108,//float, 4 bytes
FieldCopy(sl2_block_parser, 108, 'altitude'),
#Heading = 112,//float, 4 bytes
FieldCopy(sl2_block_parser, 112, 'heading'),
#Flags = 116, // two bytes
#FieldCopy(sl2_block_parser, 116, 'flags'),
#TimeOffset = 124,//int, 4 bytes, time in milliseconds from log file creation.
FieldCopy(sl2_block_parser, 124, 'time_offset'),
# ... Need extra fields ...
# Mark the end of the fixed length struct without requiring a value decoded from it
Field(144, None, None, None)
# Data starts at different locations for channel 7,8 and others
# others start at 168, channels 7,8 start at 128
#SoundedData = 168// bytes array
]
# Only used for certain channels as overlaps sonar data otherwise on some of the newer channels
# Newer channels 7 & 8 dont seem to have this block and also have 2x blocks per frame_index
sl3_extra_offsets_parser = [
#LastPrimaryChannelFrameOffset = 128, //int, 4 bytes
#last_primary_channel_block_offset
#LastSecondaryChannelFrameOffset = 132, //int, 4 bytes
#last_secondary_channel_block_offset
#LastDownScanChannelFrameOffset = 136, //int, 4 bytes
#last_downscan_channel_block_offset
#LastSidescanLeftChannelFrameOffset = 140, //int, 4 bytes
#last_left_sidescan_channel_block_offset
#LastSidescanRightChannelFrameOffset = 144, //int, 4 bytes
#last_right_sidescan_channel_block_offset
#LastSidescanCompositeChannelFrameOffset = 148,//int, 4 bytes
#last_composite_sidescan_channel_block_offset
#LastThreeDChannelFrameOffset = 164,//int, 4 bytes
#last_3d_channel_frame_offset
# Mark the end of the fixed length struct without requiring a value decoded from it
Field(168, None, None, None)
]
def ToStruct(format):
struct_format = '<'
current_offset = 0
for field in format:
# MUST be in offset order
assert(field.offset >= current_offset)
# Add any unused padding bytes to move to the next offset
struct_format += 'x' * (field.offset - current_offset)
current_offset = field.offset
# Simply moves to the next field after setting the current_offset
if field.struct_format is None:
assert(field.name is None)
assert(field.dtype is None)
continue
# Add the new field
size = struct.calcsize(field.struct_format)
struct_format += field.struct_format
current_offset += size
logger.debug('Creating struct with format: %s', struct_format)
return struct.Struct(struct_format)
class DecodedObject:
def __repr__(self): return "{}({!r})".format(self.__class__.__name__, self.__dict__)
def UnpackedToObject(format, unpacked):
obj = DecodedObject()
for i in range(0, len(format)):
field = format[i]
data = unpacked[i]
value = field.dtype.type(field.conversion(data))
setattr(obj, field.name, value)
return obj
class ChannelData(object):
def __init__(self, file_name, cache_name, channel, frame_index, format):
self.file_name = file_name
self.cache_name = cache_name
self.channel = channel
self.format = format
self.current_segment = 0
# Used for mapping new channels when seeing a duplicate frame index
# Stores the frame_index we saw last for this channel
self.last_frame_index = frame_index
self.last_frame_index_count = 1
self.data = DecodedObject()
for field in self.format:
value = | numpy.zeros(MAX_SEGMENT_SIZE, dtype=field.dtype) | numpy.zeros |
import numpy as np
from copy import deepcopy
from utils.visualize import draw_bounding_box
from utils.nms import nms
from utils.metrics import rect_dist
from utils.dense_overlap import compute_dense_overlap
import logging
logger = logging.getLogger("detector")
class DataProcessor:
"""
This is a helper class to abstract out all the operation needed during the data-loading
pipeline of the Tiny Faces object detector.
The idea is that this can act as a mixin that enables paddle dataloaders with the heatmap
generation semantics.
"""
def __init__(self, input_size, heatmap_size, pos_thresh, neg_thresh, templates,
img_means=None, rf=None):
self.input_size = input_size
self.heatmap_size = heatmap_size
self.pos_thresh = pos_thresh
self.neg_thresh = neg_thresh
self.templates = templates
self.rf = rf
self.ofy, self.ofx = rf['offset']
self.sty, self.stx = rf['stride']
self.img_means = img_means or [0.485, 0.456, 0.406]
def crop_image(self, img, bboxes):
"""
Crop a 500x500 patch from the image, taking care for smaller images.
bboxes is the np.array of all bounding boxes [x1, y1, x2, y2]
"""
# randomly pick a cropping window for the image
# We keep the second arg to randint at least 1 since randint is [low, high)
crop_x1 = np.random.randint(0, np.max([1, (img.shape[1] - self.input_size[1] + 1)]))
crop_y1 = np.random.randint(0, np.max([1, (img.shape[0] - self.input_size[0] + 1)]))
crop_x2 = min(img.shape[1], crop_x1 + self.input_size[1])
crop_y2 = min(img.shape[0], crop_y1 + self.input_size[0])
crop_h = crop_y2 - crop_y1
crop_w = crop_x2 - crop_x1
# place the cropped image in a random location in a `input_size` image
paste_box = [0, 0, 0, 0] # x1, y1, x2, y2
paste_box[0] = np.random.randint(0, self.input_size[1] - crop_w + 1)
paste_box[1] = np.random.randint(0, self.input_size[0] - crop_h + 1)
paste_box[2] = paste_box[0] + crop_w
paste_box[3] = paste_box[1] + crop_h
# set this to average image colors
# this will later be subtracted in mean image subtraction
img_buf = np.zeros((self.input_size + (3,)))
# add the average image so it gets subtracted later.
for i, c in enumerate(self.img_means):
img_buf[:, :, i] += c
# img is a int8 array, so we need to scale the values accordingly
img_buf = (img_buf * 255).astype(np.int8)
img_buf[paste_box[1]:paste_box[3], paste_box[0]:paste_box[2], :] = img[crop_y1:crop_y2, crop_x1:crop_x2, :]
if bboxes.shape[0] > 0:
# check if overlap is above negative threshold
tbox = deepcopy(bboxes)
tbox[:, 0] = np.maximum(tbox[:, 0], crop_x1)
tbox[:, 1] = np.maximum(tbox[:, 1], crop_y1)
tbox[:, 2] = np.minimum(tbox[:, 2], crop_x2)
tbox[:, 3] = np.minimum(tbox[:, 3], crop_y2)
overlap = 1 - rect_dist(tbox, bboxes)
# adjust the bounding boxes - first for crop and then for random placement
bboxes[:, 0] = bboxes[:, 0] - crop_x1 + paste_box[0]
bboxes[:, 1] = bboxes[:, 1] - crop_y1 + paste_box[1]
bboxes[:, 2] = bboxes[:, 2] - crop_x1 + paste_box[0]
bboxes[:, 3] = bboxes[:, 3] - crop_y1 + paste_box[1]
# correct for bbox to be within image border
bboxes[:, 0] = np.minimum(self.input_size[1], np.maximum(0, bboxes[:, 0]))
bboxes[:, 1] = np.minimum(self.input_size[0], np.maximum(0, bboxes[:, 1]))
bboxes[:, 2] = np.minimum(self.input_size[1], np.maximum(1, bboxes[:, 2]))
bboxes[:, 3] = np.minimum(self.input_size[0], np.maximum(1, bboxes[:, 3]))
# check to see if the adjusted bounding box is invalid
invalid = np.logical_or(np.logical_or(bboxes[:, 2] <= bboxes[:, 0], bboxes[:, 3] <= bboxes[:, 1]),
overlap < self.neg_thresh)
# remove invalid bounding boxes
ind = np.where(invalid)
bboxes = np.delete(bboxes, ind, 0)
return img_buf, bboxes, paste_box
def get_padding(self, paste_box):
"""
Get the padding of the image based on where the sampled image patch was placed.
:param paste_box: [x1, y1, x2, y2]
:return:
"""
ofy, ofx = self.rf['offset']
sty, stx = self.rf['stride']
vsy, vsx = self.heatmap_size
coarse_x, coarse_y = np.meshgrid(ofx + np.array(range(vsx)) * stx,
ofy + np.array(range(vsy)) * sty)
# each cluster is [x1, y1, x2, y2]
dx1 = self.templates[:, 0]
dy1 = self.templates[:, 1]
dx2 = self.templates[:, 2]
dy2 = self.templates[:, 3]
# compute the bounds
# We add new axes so that the arrays are numpy broadcasting compatible
coarse_xx1 = coarse_x[:, :, np.newaxis] + dx1[np.newaxis, np.newaxis, :] # (vsy, vsx, nt)
coarse_yy1 = coarse_y[:, :, np.newaxis] + dy1[np.newaxis, np.newaxis, :] # (vsy, vsx, nt)
coarse_xx2 = coarse_x[:, :, np.newaxis] + dx2[np.newaxis, np.newaxis, :] # (vsy, vsx, nt)
coarse_yy2 = coarse_y[:, :, np.newaxis] + dy2[np.newaxis, np.newaxis, :] # (vsy, vsx, nt)
# Matlab code indexes from 1 hence to check against it, we need to add +1
# However, in python we don't need the +1 during actual training
padx1 = coarse_xx1 < paste_box[0] + 1
pady1 = coarse_yy1 < paste_box[1] + 1
padx2 = coarse_xx2 > paste_box[2]
pady2 = coarse_yy2 > paste_box[3]
pad_mask = padx1 | pady1 | padx2 | pady2
return pad_mask
def get_regression(self, bboxes, cluster_boxes, iou):
"""
Compute the target bounding box regression values
:param bboxes:
:param cluster_boxes:
:param iou:
:return:
"""
ofy, ofx = self.rf['offset']
sty, stx = self.rf['stride']
vsy, vsx = self.heatmap_size
coarse_xx, coarse_yy = np.meshgrid(ofx + np.array(range(vsx)) * stx,
ofy + np.array(range(vsy)) * sty)
dx1, dy1, dx2, dy2 = cluster_boxes
# We reshape to take advantage of numpy broadcasting
fxx1 = bboxes[:, 0].reshape(1, 1, 1, bboxes.shape[0]) # (1, 1, 1, bboxes)
fyy1 = bboxes[:, 1].reshape(1, 1, 1, bboxes.shape[0])
fxx2 = bboxes[:, 2].reshape(1, 1, 1, bboxes.shape[0])
fyy2 = bboxes[:, 3].reshape(1, 1, 1, bboxes.shape[0])
h = dy2 - dy1 + 1
w = dx2 - dx1 + 1
dhh = h.reshape(1, 1, h.shape[0], 1) # (1, 1, N, 1)
dww = w.reshape(1, 1, w.shape[0], 1) # (1, 1, N, 1)
fcx = (fxx1 + fxx2) / 2
fcy = (fyy1 + fyy2) / 2
tx = np.divide((fcx - coarse_xx.reshape(vsy, vsx, 1, 1)), dww)
ty = np.divide((fcy - coarse_yy.reshape(vsy, vsx, 1, 1)), dhh)
fhh = fyy2 - fyy1 + 1
fww = fxx2 - fxx1 + 1
tw = np.log(np.divide(fww, dww)) # (1, 1, N, bboxes)
th = np.log(np.divide(fhh, dhh))
# Randomly perturb the IOU so that if multiple candidates have the same IOU,
# we don't pick the same one every time. This is useful when the template is smaller than the GT bbox
iou = iou + (1e-6 * np.random.rand(*iou.shape))
best_obj_per_loc = iou.argmax(axis=3)
idx0, idx1, idx2 = np.indices(iou.shape[:-1])
tx = tx[idx0, idx1, idx2, best_obj_per_loc]
ty = ty[idx0, idx1, idx2, best_obj_per_loc]
tw = np.repeat(tw, vsy, axis=0) # (vsy, 1, N, bboxes)
tw = np.repeat(tw, vsx, axis=1) # (vsy, vsx, N, bboxes)
tw = tw[idx0, idx1, idx2, best_obj_per_loc]
th = np.repeat(th, vsy, axis=0)
th = np.repeat(th, vsx, axis=1)
th = th[idx0, idx1, idx2, best_obj_per_loc]
return np.concatenate((tx, ty, tw, th), axis=2), iou
def get_heatmaps(self, bboxes, pad_mask):
ofy, ofx = self.rf['offset']
sty, stx = self.rf['stride']
vsy, vsx = self.heatmap_size
nt = self.templates.shape[0]
# Initiate heatmaps
class_maps = -np.ones((vsy, vsx, nt))
regress_maps = np.zeros((vsy, vsx, nt * 4))
# each cluster is [-w/2, -h/2, w/2, h/2]
dx1, dx2 = self.templates[:, 0], self.templates[:, 2]
dy1, dy2 = self.templates[:, 1], self.templates[:, 3]
# Filter out invalid bbox
invalid = np.logical_or(bboxes[:, 2] <= bboxes[:, 0], bboxes[:, 3] <= bboxes[:, 1])
ind = np.where(invalid)
bboxes = np.delete(bboxes, ind, axis=0)
ng = bboxes.shape[0]
iou = np.zeros((vsy, vsx, self.templates.shape[0], bboxes.shape[0]))
if ng > 0:
gx1, gy1, gx2, gy2 = bboxes[:, 0], bboxes[:, 1], bboxes[:, 2], bboxes[:, 3]
iou = compute_dense_overlap(ofx, ofy, stx, sty, vsx, vsy,
dx1, dy1, dx2, dy2,
gx1, gy1, gx2, gy2,
1, 1)
regress_maps, iou = self.get_regression(bboxes, [dx1, dy1, dx2, dy2], iou)
best_iou = iou.max(axis=3)
# Set max IoU values to 1 (even if they are < pos_thresh, as long as they are above neg_thresh)
per_object_iou = np.reshape(iou, (-1, ng))
fbest_idx = np.argmax(per_object_iou, axis=0)
iou_ = | np.amax(per_object_iou, axis=0) | numpy.amax |
import os
from datetime import datetime
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
import util.io as mio
from util import statsUtil
from model.message import Message
SAVE_PLOT = False
def plotBasicLengthStatsByYearAndMonth(data, yearsToShow=None, targetStats=None,
targetSenders=None):
df = statsUtil.filter_stats(data, {'sender':targetSenders, 'year':yearsToShow,
'stat':targetStats})
g = sns.factorplot(x="month", y="val", row="stat", hue='sender', col='year', data=df,
kind="bar", size=3, aspect=2.5, legend_out=False)
g.fig.suptitle('Basic Length Stats')
sns.plt.show()
def plotBasicLengthStatsByHour(data, targetStats=None, targetSenders=None, kind='bar'):
df = statsUtil.filter_stats(data, {'sender':targetSenders, 'stat':targetStats})
g = sns.factorplot(x="hour", y="val", row="stat", hue='sender', data=df,
kind=kind, size=3, aspect=2.5, legend_out=False)
g.fig.suptitle('Basic Length Stats - Hour')
#sns.plt.show()
def plotRichnessVariation(data, targetLabel, yearsToShow=None, targetSenders=None):
df = data.reset_index()
df = statsUtil.filter_stats(df, {'year':yearsToShow, 'sender':targetSenders})
g = sns.factorplot(x=targetLabel, y="lexicalRichness", col="year", hue='sender',
data=df, kind="point", legend_out=False)
g.set(ylabel='lexical richness (%)')
g.fig.suptitle('Vocabulary Richness')
sns.plt.show()
def _genericFactorPlot(data, xTarget, yTarget, filters, title, yLabel, col=None, row=None,
kind='point'):
df = statsUtil.filter_stats(data, filters)
g = sns.factorplot(x=xTarget, y=yTarget, col=col, row=row, hue='sender',
data=df, kind=kind, legend_out=False)
g.set(ylabel=yLabel)
g.fig.suptitle(title)
sns.plt.show()
# does single year only. Use with animations or to see boxplots
def plotSingleBasicLengthStatByYearAndHour(data, stat, yearsToShow=None,
targetSenders=None, ax=None):
df = statsUtil.filter_stats(data, {'sender':targetSenders, 'year':yearsToShow,
'stat':[stat]})
ax = sns.barplot(x="hour", y='val', hue="sender", data=df, ax=ax)
ax.set(ylabel=stat)
#sns.plt.show()
def plotSingleBasicLengthStatHeatmap(data, stat, targetSender, yearsToShow=None):
df = data.xs(targetSender, level='sender')
df = df.reset_index()
def plot(ax, df, count):
df = df.pivot('month', 'day', stat)
# TODO share y. Fix it or try factorgrid
ax = sns.heatmap(df, mask=df.isnull(), ax=ax, vmin=0, vmax=30000)#cmap=ListedColormap(['red', 'blue'])
ax.set(ylabel='month' if count == 1 else '')
_plotByYear(df, "{} ({})".format(stat, targetSender), plot, yearsToShow)
def plotSentimentStatsByHour(sentimentStats, valueNames):
data = statsUtil.transformSentimentStats(sentimentStats, valueNames, ['sender', 'hour'])
ax = sns.factorplot(x="hour", y="val", col="emotion", hue='sender',
data=data, kind="point", sharey=False, legend_out=False)
ax.set(ylabel='mean(val)')
sns.plt.show()
def plotSentimentStatsByYearAndMonth(sentimentStats, valueNames):
data = statsUtil.transformSentimentStats(sentimentStats, valueNames, ['sender', 'year', 'month'])
sns.factorplot(x="month", y="val", row="emotion", hue='sender', col='year',
data=data, kind="point", sharey=False, legend_out=False)
sns.plt.show()
# TODO fill all possible values for the index (dates, month, year)
# Add sender or total labels
def plotWordsCount(wordsCountStats, words, sender=None, yearsToShow=None):
data = wordsCountStats.getWordsCount(words, sender)
if data is None:
return
def plot(ax, df, count):
df.reset_index(level='year').plot(ax=ax)
if 'year' in list(data.index.names):
_plotByYear(data, 'Word count', plot, yearsToShow)
else:
data.plot()
sns.plt.show()
def plotZipfLaw(words, count):
figureAesthetic()
#plt.figure(1).suptitle("Zip's Law", fontsize=20)
ax = plt.subplot(1,2,1)
plt.xlabel("word")
plt.ylabel("frequency")
numWords = 20
x = | np.arange(numWords) | numpy.arange |
import numpy as np
import scipy.stats
import copy
from astropy.tests.helper import pytest
from astropy.modeling import models
from scipy.special import gammaln as scipy_gammaln
from stingray import Lightcurve, Powerspectrum
from stingray.modeling import Posterior, PSDPosterior, \
PoissonPosterior, GaussianPosterior, LaplacePosterior
from stingray.modeling import set_logprior
from stingray.modeling.posterior import logmin
from stingray.modeling.posterior import IncorrectParameterError
from stingray.modeling.posterior import LogLikelihood
np.random.seed(20150907)
class TestMeta(object):
def test_use_loglikelihood_class_directly(self):
with pytest.raises(TypeError):
a = LogLikelihood(1, 2, models.Lorentz1D)
def test_inherit_loglikelihood_improperly(self):
class a(LogLikelihood):
def __init__(self, *args, **kwargs):
LogLikelihood.__init__(self, *args, **kwargs)
with pytest.raises(TypeError):
a(1, 2, models.Lorentz1D)
def test_inherit_loglikelihood_properly(self):
class a(LogLikelihood):
def __init__(self, *args, **kwargs):
LogLikelihood.__init__(self, *args, **kwargs)
def evaluate(self, parameters):
pass
a(1, 2, models.Lorentz1D)
class TestSetPrior(object):
@classmethod
def setup_class(cls):
photon_arrivals = np.sort(np.random.uniform(0,1000, size=10000))
cls.lc = Lightcurve.make_lightcurve(photon_arrivals, dt=1.0)
cls.ps = Powerspectrum(cls.lc, norm="frac")
pl = models.PowerLaw1D()
pl.x_0.fixed = True
cls.lpost = PSDPosterior(cls.ps.freq, cls.ps.power, pl, m=cls.ps.m)
def test_set_prior_runs(self):
p_alpha = lambda alpha: ((-1. <= alpha) & (alpha <= 5.))/6.0
p_amplitude = lambda amplitude: ((-10 <= np.log(amplitude)) &
((np.log(amplitude) <= 10.0)))/20.0
priors = {"alpha":p_alpha, "amplitude":p_amplitude}
self.lpost.logprior = set_logprior(self.lpost, priors)
def test_prior_executes_correctly(self):
p_alpha = lambda alpha: ((-1. <= alpha) & (alpha <= 5.))/6.0
p_amplitude = lambda amplitude: ((-10 <= np.log(amplitude)) &
((np.log(amplitude) <= 10.0)))/20.0
priors = {"alpha":p_alpha, "amplitude":p_amplitude}
self.lpost.logprior = set_logprior(self.lpost, priors)
true_logprior = np.log(1./6.) + np.log(1./20.0)
assert self.lpost.logprior([np.exp(0.0), np.exp(0.0)]) == true_logprior
def test_prior_returns_logmin_outside_prior_range(self):
p_alpha = lambda alpha: ((-1. <= alpha) & (alpha <= 5.))/6.0
p_amplitude = lambda amplitude: ((-10 <= np.log(amplitude)) &
((np.log(amplitude) <= 10.0)))/20.0
priors = {"alpha":p_alpha, "amplitude":p_amplitude}
self.lpost.logprior = set_logprior(self.lpost, priors)
assert self.lpost.logprior([-2.0, np.exp(11.0)]) == logmin
class PosteriorClassDummy(Posterior):
"""
This is a test class that tests the basic functionality of the
Posterior superclass.
"""
def __init__(self, x, y, model):
Posterior.__init__(self, x, y, model)
def loglikelihood(self, t0, neg=False):
loglike = 1.0
return loglike
def logprior(self, t0):
lp = 2.0
return lp
class TestPosterior(object):
@classmethod
def setup_class(cls):
cls.x = np.arange(100)
cls.y = np.ones(cls.x.shape[0])
cls.model = models.Const1D()
cls.p = PosteriorClassDummy(cls.x, cls.y, cls.model)
p_alpha = lambda alpha: ((-1. <= alpha) & (alpha <= 5.))/6.0
priors = {"amplitude":p_alpha}
cls.p.logprior = set_logprior(cls.p, priors)
def test_inputs(self):
assert np.allclose(self.p.x, self.x)
assert np.allclose(self.p.y, self.y)
assert isinstance(self.p.model, models.Const1D)
def test_call_method_positive(self):
t0 = [1]
post = self.p(t0, neg=False)
assert post == 1.0 + np.log(1./6.0)
def test_call_method_negative(self):
t0 = [1]
post = self.p(t0, neg=True)
assert post == -(1.0 + np.log(1./6.0))
class TestPSDPosterior(object):
@classmethod
def setup_class(cls):
m = 1
nfreq = 1000000
freq = np.arange(nfreq)
noise = np.random.exponential(size=nfreq)
power = noise*2.0
ps = Powerspectrum()
ps.freq = freq
ps.power = power
ps.m = m
ps.df = freq[1]-freq[0]
ps.norm = "leahy"
cls.ps = ps
cls.a_mean, cls.a_var = 2.0, 1.0
cls.model = models.Const1D()
p_amplitude = lambda amplitude: \
scipy.stats.norm(loc=cls.a_mean, scale=cls.a_var).pdf(amplitude)
cls.priors = {"amplitude":p_amplitude}
def test_logprior_fails_without_prior(self):
lpost = PSDPosterior(self.ps.freq, self.ps.power, self.model,
m=self.ps.m)
with pytest.raises(AttributeError):
lpost.logprior([1])
def test_making_posterior(self):
lpost = PSDPosterior(self.ps.freq, self.ps.power,
self.model, m=self.ps.m)
lpost.logprior = set_logprior(lpost, self.priors)
assert lpost.x.all() == self.ps.freq.all()
assert lpost.y.all() == self.ps.power.all()
def test_correct_number_of_parameters(self):
lpost = PSDPosterior(self.ps.freq, self.ps.power,
self.model, m=self.ps.m)
lpost.logprior = set_logprior(lpost, self.priors)
with pytest.raises(IncorrectParameterError):
lpost([2,3])
def test_logprior(self):
t0 = [2.0]
lpost = PSDPosterior(self.ps.freq, self.ps.power,
self.model, m=self.ps.m)
lpost.logprior = set_logprior(lpost, self.priors)
lp_test = lpost.logprior(t0)
lp = np.log(scipy.stats.norm(2.0, 1.0).pdf(t0))
assert lp == lp_test
def test_loglikelihood(self):
t0 = [2.0]
self.model.amplitude = t0[0]
mean_model = self.model(self.ps.freq)
loglike = -np.sum(np.log(mean_model)) - np.sum(self.ps.power/mean_model)
lpost = PSDPosterior(self.ps.freq, self.ps.power,
self.model, m=self.ps.m)
lpost.logprior = set_logprior(lpost, self.priors)
loglike_test = lpost.loglikelihood(t0, neg=False)
assert np.isclose(loglike, loglike_test)
def test_negative_loglikelihood(self):
t0 = [2.0]
self.model.amplitude = t0[0]
m = self.model(self.ps.freq[1:])
loglike = np.sum(self.ps.power[1:]/m + np.log(m))
lpost = PSDPosterior(self.ps.freq, self.ps.power,
self.model, m=self.ps.m)
lpost.logprior = set_logprior(lpost, self.priors)
loglike_test = lpost.loglikelihood(t0, neg=True)
assert np.isclose(loglike, loglike_test)
def test_posterior(self):
t0 = [2.0]
self.model.amplitude = t0[0]
m = self.model(self.ps.freq[1:])
lpost = PSDPosterior(self.ps.freq, self.ps.power,
self.model, m=self.ps.m)
lpost.logprior = set_logprior(lpost, self.priors)
post_test = lpost(t0, neg=False)
loglike = -np.sum(self.ps.power[1:]/m + np.log(m))
logprior = np.log(scipy.stats.norm(2.0, 1.0).pdf(t0))
post = loglike + logprior
assert np.isclose(post_test, post, atol=1.e-10)
def test_negative_posterior(self):
t0 = [2.0]
self.model.amplitude = t0[0]
m = self.model(self.ps.freq[1:])
lpost = PSDPosterior(self.ps.freq, self.ps.power,
self.model, m=self.ps.m)
lpost.logprior = set_logprior(lpost, self.priors)
post_test = lpost(t0, neg=True)
loglike = -np.sum(self.ps.power[1:]/m + np.log(m))
logprior = np.log(scipy.stats.norm(2.0, 1.0).pdf(t0))
post = -loglike - logprior
assert np.isclose(post_test, post, atol=1.e-10)
class TestPoissonPosterior(object):
@classmethod
def setup_class(cls):
nx = 1000000
cls.x = np.arange(nx)
cls.countrate = 10.0
cls.y = np.random.poisson(cls.countrate, size=cls.x.shape[0])
cls.model = models.Const1D()
p_amplitude = lambda amplitude: \
scipy.stats.norm(loc=cls.countrate, scale=cls.countrate).pdf(amplitude)
cls.priors = {"amplitude":p_amplitude}
def test_logprior_fails_without_prior(self):
lpost = PoissonPosterior(self.x, self.y, self.model)
with pytest.raises(AttributeError):
lpost.logprior([10])
def test_making_posterior(self):
lpost = PoissonPosterior(self.x, self.y, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
assert lpost.x.all() == self.x.all()
assert lpost.y.all() == self.y.all()
def test_correct_number_of_parameters(self):
lpost = PoissonPosterior(self.x, self.y, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
with pytest.raises(IncorrectParameterError):
lpost([2,3])
def test_logprior(self):
t0 = [10.0]
lpost = PoissonPosterior(self.x, self.y, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
lp_test = lpost.logprior(t0)
lp = np.log(scipy.stats.norm(self.countrate, self.countrate).pdf(t0))
assert lp == lp_test
def test_loglikelihood(self):
t0 = [10.0]
self.model.amplitude = t0[0]
mean_model = self.model(self.x)
loglike = np.sum(-mean_model + self.y*np.log(mean_model) - scipy_gammaln(self.y+1))
lpost = PoissonPosterior(self.x, self.y, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
loglike_test = lpost.loglikelihood(t0, neg=False)
assert np.isclose(loglike, loglike_test)
def test_negative_loglikelihood(self):
t0 = [10.0]
self.model.amplitude = t0[0]
mean_model = self.model(self.x)
loglike = -np.sum(-mean_model + self.y*np.log(mean_model) - scipy_gammaln(self.y+1))
lpost = PoissonPosterior(self.x, self.y, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
loglike_test = lpost.loglikelihood(t0, neg=True)
assert np.isclose(loglike, loglike_test)
def test_posterior(self):
t0 = [10.0]
self.model.amplitude = t0[0]
mean_model = self.model(self.x)
lpost = PoissonPosterior(self.x, self.y, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
post_test = lpost(t0, neg=False)
loglike = np.sum(-mean_model + self.y*np.log(mean_model) - scipy_gammaln(self.y+1))
logprior = np.log(scipy.stats.norm(self.countrate, self.countrate).pdf(t0))
post = loglike + logprior
assert np.isclose(post_test, post, atol=1.e-10)
def test_negative_posterior(self):
t0 = [10.0]
self.model.amplitude = t0[0]
mean_model = self.model(self.x)
lpost = PoissonPosterior(self.x, self.y, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
post_test = lpost(t0, neg=True)
loglike = np.sum(-mean_model + self.y*np.log(mean_model) - scipy_gammaln(self.y+1))
logprior = np.log(scipy.stats.norm(self.countrate, self.countrate).pdf(t0))
post = -loglike - logprior
assert np.isclose(post_test, post, atol=1.e-10)
def test_counts_are_nan(self):
y = np.nan * np.ones(self.x.shape[0])
t0 = [10.0]
self.model.amplitude = t0[0]
mean_model = self.model(self.x)
lpost = PoissonPosterior(self.x, y, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
assert np.isclose(lpost(t0), logmin, 1e-5)
class TestGaussianPosterior(object):
@classmethod
def setup_class(cls):
nx = 1000000
cls.x = np.arange(nx)
cls.countrate = 10.0
cls.cerr = 2.0
cls.y = np.random.normal(cls.countrate, cls.cerr, size=cls.x.shape[0])
cls.yerr = np.ones_like(cls.y)*cls.cerr
cls.model = models.Const1D()
p_amplitude = lambda amplitude: \
scipy.stats.norm(loc=cls.countrate, scale=cls.cerr).pdf(amplitude)
cls.priors = {"amplitude":p_amplitude}
def test_logprior_fails_without_prior(self):
lpost = GaussianPosterior(self.x, self.y, self.yerr, self.model)
with pytest.raises(AttributeError):
lpost.logprior([10])
def test_making_posterior(self):
lpost = GaussianPosterior(self.x, self.y, self.yerr, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
assert lpost.x.all() == self.x.all()
assert lpost.y.all() == self.y.all()
def test_correct_number_of_parameters(self):
lpost = GaussianPosterior(self.x, self.y, self.yerr, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
with pytest.raises(IncorrectParameterError):
lpost([2,3])
def test_logprior(self):
t0 = [10.0]
lpost = GaussianPosterior(self.x, self.y, self.yerr, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
lp_test = lpost.logprior(t0)
lp = np.log(scipy.stats.norm(self.countrate, self.cerr).pdf(t0))
assert lp == lp_test
def test_loglikelihood(self):
t0 = [10.0]
self.model.amplitude = t0[0]
mean_model = self.model(self.x)
loglike = np.sum(-0.5*np.log(2.*np.pi) - np.log(self.yerr) - \
0.5*((self.y - mean_model)/self.yerr)**2.0)
lpost = GaussianPosterior(self.x, self.y, self.yerr, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
loglike_test = lpost.loglikelihood(t0, neg=False)
assert np.isclose(loglike, loglike_test)
def test_negative_loglikelihood(self):
t0 = [10.0]
self.model.amplitude = t0[0]
mean_model = self.model(self.x)
loglike = -np.sum(-0.5*np.log(2.*np.pi) - np.log(self.yerr) - \
0.5*((self.y - mean_model)/self.yerr)**2.0)
lpost = GaussianPosterior(self.x, self.y, self.yerr, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
loglike_test = lpost.loglikelihood(t0, neg=True)
assert np.isclose(loglike, loglike_test)
def test_posterior(self):
t0 = [10.0]
self.model.amplitude = t0[0]
mean_model = self.model(self.x)
lpost = GaussianPosterior(self.x, self.y, self.yerr, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
post_test = lpost(t0, neg=False)
loglike = np.sum(-0.5*np.log(2.*np.pi) - np.log(self.yerr) - \
0.5*((self.y - mean_model)/self.yerr)**2.0)
logprior = np.log(scipy.stats.norm(self.countrate, self.cerr).pdf(t0))
post = loglike + logprior
assert np.isclose(post_test, post, atol=1.e-10)
def test_negative_posterior(self):
t0 = [10.0]
self.model.amplitude = t0[0]
mean_model = self.model(self.x)
lpost = GaussianPosterior(self.x, self.y, self.yerr, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
post_test = lpost(t0, neg=True)
loglike = np.sum(-0.5*np.log(2.*np.pi) - np.log(self.yerr) - \
0.5*((self.y - mean_model)/self.yerr)**2.0)
logprior = np.log(scipy.stats.norm(self.countrate, self.cerr).pdf(t0))
post = -loglike - logprior
assert np.isclose(post_test, post, atol=1.e-10)
def test_counts_are_nan(self):
y = np.nan * np.ones(self.x.shape[0])
t0 = [10.0]
self.model.amplitude = t0[0]
lpost = GaussianPosterior(self.x, y, self.yerr, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
assert np.isclose(lpost(t0), logmin, 1e-5)
class TestLaplacePosterior(object):
@classmethod
def setup_class(cls):
nx = 1000000
cls.x = np.arange(nx)
cls.countrate = 10.0
cls.cerr = 2.0
cls.y = np.random.normal(cls.countrate, cls.cerr, size=cls.x.shape[0])
cls.yerr = np.ones_like(cls.y)*cls.cerr
cls.model = models.Const1D()
p_amplitude = lambda amplitude: \
scipy.stats.norm(loc=cls.countrate, scale=cls.cerr).pdf(amplitude)
cls.priors = {"amplitude":p_amplitude}
def test_logprior_fails_without_prior(self):
lpost = LaplacePosterior(self.x, self.y, self.yerr, self.model)
with pytest.raises(AttributeError):
lpost.logprior([10])
def test_making_posterior(self):
lpost = LaplacePosterior(self.x, self.y, self.yerr, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
assert lpost.x.all() == self.x.all()
assert lpost.y.all() == self.y.all()
def test_correct_number_of_parameters(self):
lpost = LaplacePosterior(self.x, self.y, self.yerr, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
with pytest.raises(IncorrectParameterError):
lpost([2,3])
def test_logprior(self):
t0 = [10.0]
lpost = LaplacePosterior(self.x, self.y, self.yerr, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
lp_test = lpost.logprior(t0)
lp = np.log(scipy.stats.norm(self.countrate, self.cerr).pdf(t0))
assert lp == lp_test
def test_loglikelihood(self):
t0 = [10.0]
self.model.amplitude = t0[0]
mean_model = self.model(self.x)
loglike = np.sum(-np.log(2.0*self.yerr) -
np.abs(self.y - mean_model)/self.yerr)
lpost = LaplacePosterior(self.x, self.y, self.yerr, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
loglike_test = lpost.loglikelihood(t0, neg=False)
assert np.isclose(loglike, loglike_test)
def test_negative_loglikelihood(self):
t0 = [10.0]
self.model.amplitude = t0[0]
mean_model = self.model(self.x)
loglike = -np.sum(-np.log(2.0*self.yerr) -
np.abs(self.y - mean_model)/self.yerr)
lpost = LaplacePosterior(self.x, self.y, self.yerr, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
loglike_test = lpost.loglikelihood(t0, neg=True)
assert np.isclose(loglike, loglike_test)
def test_posterior(self):
t0 = [10.0]
self.model.amplitude = t0[0]
mean_model = self.model(self.x)
lpost = LaplacePosterior(self.x, self.y, self.yerr, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
post_test = lpost(t0, neg=False)
loglike = np.sum(-np.log(2.0*self.yerr) -
| np.abs(self.y - mean_model) | numpy.abs |
from __future__ import division, absolute_import, print_function
import sys
from itertools import product
import numpy as np
from numpy.core import zeros, float64
from numpy.testing import dec, TestCase, assert_almost_equal, assert_, \
assert_raises, assert_array_equal, assert_allclose, assert_equal
from numpy.core.multiarray import inner as inner_
DECPREC = 14
class TestInner(TestCase):
def test_vecself(self):
"""Ticket 844."""
# Inner product of a vector with itself segfaults or give meaningless
# result
a = zeros(shape = (1, 80), dtype = float64)
p = inner_(a, a)
assert_almost_equal(p, 0, decimal = DECPREC)
try:
import numpy.core._dotblas as _dotblas
except ImportError:
_dotblas = None
@dec.skipif(_dotblas is None, "Numpy is not compiled with _dotblas")
def test_blasdot_used():
from numpy.core import dot, vdot, inner, alterdot, restoredot
assert_(dot is _dotblas.dot)
assert_(vdot is _dotblas.vdot)
assert_(inner is _dotblas.inner)
assert_(alterdot is _dotblas.alterdot)
assert_(restoredot is _dotblas.restoredot)
def test_dot_2args():
from numpy.core import dot
a = | np.array([[1, 2], [3, 4]], dtype=float) | numpy.array |
from utilities.python_path_utility import append_to_pythonpath
append_to_pythonpath(['feature_extractors/reid_strong_baseline'
,'feature_extractors/ABD_Net'
,'detectors/mmdetection'
,'evaluation/py_motmetrics'
,'trackers/fair/src/lib'], __file__)
import argparse
import mmcv
import numpy as np
from trackers.deep_sort import DeepSort
from util import draw_bboxes
from tqdm import tqdm
from utilities.helper import xtylwh_to_xyxy
import warnings
import cv2
import logging
import json
from utilities.track_result_statistics import count_tracks
from utilities.python_path_utility import *
import pandas as pd
from feature_extractors.reid_strong_baseline.utils.logger import setup_logger
from datasets.mta_dataset_cam_iterator import get_cam_iterators
from tracking_utils.timer import Timer
class Run_tracker:
def __init__(self,args):
self.cfg = mmcv.Config.fromfile(args.config).root
self.cfg.general.config_basename = os.path.basename(args.config).replace(".py","")
self.use_original_wda = self.cfg.general.config_basename[:4] != "fair"
self.cfg.general.repository_root = os.path.abspath(os.path.dirname(__file__))
self.set_tracker_config_run_path()
self.set_track_features_folder()
#mmdetection does not put everything to the device that is being set in its function calls
#E.g. With torch.cuda.set_device(4) it will run without errors. But still using GPU 0
#With os.environ['CUDA_VISIBLE_DEVICES'] = '4' the visibility will be restricted to only the named GPUS starting internatlly from zero
os.environ['CUDA_VISIBLE_DEVICES'] = self.cfg.general.cuda_visible_devices
#Initializes the detector class by calling the constructor and creating the object
if self.use_original_wda:
from detectors.mmdetection_detector import Mmdetection_detector
self.detector = Mmdetection_detector(self.cfg)
self.deep_sort = DeepSort(self.cfg, use_original_wda=self.use_original_wda)
#Set up the logger
logger = setup_logger("mtmct", self.cfg.general.config_run_path, 0)
logger.info(args)
logger.info(json.dumps(self.cfg,sort_keys=True, indent=4))
def get_detections_path(self,cam_id):
detections_path_folder = os.path.join(self.cfg.general.config_run_path
, "detections")
os.makedirs(detections_path_folder, exist_ok=True)
detections_path = os.path.join(detections_path_folder, "detections_cam_{}.csv".format(cam_id))
return detections_path
def get_detections_frame_nos_path(self, cam_id):
detections_path_folder = os.path.join(self.cfg.general.config_run_path
, "detections")
os.makedirs(detections_path_folder, exist_ok=True)
detections_path = os.path.join(detections_path_folder, "detections_frame_nos_cam_{}.csv".format(cam_id))
return detections_path
def load_detections(self,cam_iterator):
self.detections_to_store = []
self.detections_frame_nos = []
detections_frame_nos_loaded = pd.DataFrame({ "frame_no_cam" : [] })
self.detections_loaded = pd.DataFrame()
self.detections_path = self.get_detections_path(cam_id=cam_iterator.cam_id)
self.detections_frame_nos_path = self.get_detections_frame_nos_path(cam_id=cam_iterator.cam_id)
if os.path.exists(self.detections_frame_nos_path):
detections_frame_nos_loaded = pd.read_csv(self.detections_frame_nos_path)
#This will assure that if the selection of frame nos is changed new detections have to be generated
cam_iterator_frame_nos = cam_iterator.get_all_frame_nos()
frame_nos_union_length = len(set(detections_frame_nos_loaded["frame_no_cam"]).intersection(set(cam_iterator_frame_nos)))
cam_iterator_frame_nos_length = len(cam_iterator_frame_nos)
if frame_nos_union_length == cam_iterator_frame_nos_length and os.path.exists(self.detections_path):
self.detections_loaded = pd.read_csv(self.detections_path)
def set_track_features_folder(self):
# Build the path where transformed track features will be stored for preparation of clustering.
self.cfg.general.track_features_folder = os.path.join(self.cfg.general.repository_root
, "work_dirs"
, "clustering"
, "config_runs"
, self.cfg.general.config_basename
, "pickled_appearance_features"
, "test")
os.makedirs(self.cfg.general.track_features_folder, exist_ok=True)
def set_tracker_config_run_path(self):
# Build the path where results and logging files etc. should be stored
self.cfg.general.config_run_path = os.path.join(self.cfg.general.repository_root
,"work_dirs"
, "tracker"
, "config_runs"
, self.cfg.general.config_basename)
os.makedirs(self.cfg.general.config_run_path, exist_ok=True)
def save_detections(self):
if len(self.detections_to_store) > 0:
detections_to_store_df = pd.DataFrame(self.detections_to_store)
detections_to_store_df = detections_to_store_df.astype({"frame_no_cam": int
, "id": int
, "x": int
, "y": int
, "w": int
, "h": int
, "score": float})
detections_to_store_df.to_csv(self.detections_path, index=False)
detections_frame_nos = pd.DataFrame(self.detections_frame_nos)
detections_frame_nos.to_csv(self.detections_frame_nos_path, index=False)
def store_detections_one_frame(self, frame_no_cam, xywh_bboxes, scores):
'''
"frame_no_cam,id,x,y,w,h,score"
:param xywh_bboxes:
:return:
'''
for index, xywh_bbox_score in enumerate(zip(xywh_bboxes,scores)):
xywh_bbox, score = xywh_bbox_score
self.detections_to_store.append({ "frame_no_cam" : frame_no_cam
, "id" : index
, "x" : xywh_bbox[0]
, "y" : xywh_bbox[1]
, "w" : xywh_bbox[2]
, "h" : xywh_bbox[3]
, "score" : score })
def img_callback_original_wda(self, dataset_img):
if len(self.detections_loaded) > 0:
detections_current_frame = self.detections_loaded[self.detections_loaded["frame_no_cam"] == dataset_img.frame_no_cam]
scores = detections_current_frame["score"].tolist()
bboxes_xtlytlwh = list(zip(detections_current_frame["x"], detections_current_frame["y"],detections_current_frame["w"],detections_current_frame["h"]))
else:
bboxes_xtlytlwh, scores = self.detector.detect(dataset_img.img)
self.store_detections_one_frame(dataset_img.frame_no_cam, bboxes_xtlytlwh, scores)
self.detections_frame_nos.append({ "frame_no_cam" : dataset_img.frame_no_cam })
draw_img = dataset_img.img
if bboxes_xtlytlwh is not None:
outputs = self.deep_sort.update(bboxes_xtlytlwh, scores, dataset_img)
if len(outputs) > 0:
bboxes_xtylwh = outputs[:, :4]
bboxes_xyxy = [ xtylwh_to_xyxy(bbox_xtylwh,dataset_img.img_dims) for bbox_xtylwh in bboxes_xtylwh ]
identities = outputs[:, -2]
detection_idxs = outputs[:, -1]
draw_img = draw_bboxes(dataset_img.img, bboxes_xyxy, identities)
for detection_idx, person_id, bbox in zip(detection_idxs,identities,bboxes_xyxy):
print('%d,%d,%d,%d,%d,%d,%d,%d' % (
dataset_img.frame_no_cam, dataset_img.cam_id, person_id, detection_idx,int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3])), file=self.track_results_file)
if self.cfg.general.display_viewer:
cv2.imshow("Annotation Viewer", draw_img)
cv2.waitKey(1)
def img_callback(self, dataset_img):
draw_img = dataset_img.img
outputs = self.deep_sort.update_with_fair_detections(dataset_img)
if len(outputs) > 0:
bboxes_xtylwh = outputs[:, :4]
bboxes_xyxy = [ xtylwh_to_xyxy(bbox_xtylwh,dataset_img.img_dims) for bbox_xtylwh in bboxes_xtylwh ]
identities = outputs[:, -2]
detection_idxs = outputs[:, -1]
draw_img = draw_bboxes(dataset_img.img, bboxes_xyxy, identities)
for detection_idx, person_id, bbox in zip(detection_idxs,identities,bboxes_xyxy):
print('%d,%d,%d,%d,%d,%d,%d,%d' % (
dataset_img.frame_no_cam, dataset_img.cam_id, person_id, detection_idx,int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3])), file=self.track_results_file)
if self.cfg.general.display_viewer:
cv2.imshow("Annotation Viewer", draw_img)
cv2.waitKey(1)
def run_on_cam_images(self,cam_iterator):
timer = Timer()
for image in cam_iterator:
self.pbar_tracker.update()
timer.tic()
if self.use_original_wda:
self.img_callback_original_wda(image)
else:
self.img_callback(image)
timer.toc()
return timer.average_time, timer.calls
@staticmethod
def get_cam_iterator_len_sum(cam_image_iterators):
overall_len = 0
for cam_iterator in cam_image_iterators:
overall_len += len(cam_iterator)
return overall_len
def get_track_results_path(self,cam_id):
tracker_results_folder = os.path.join(self.cfg.general.config_run_path,"tracker_results")
os.makedirs(tracker_results_folder,exist_ok=True)
return os.path.join(tracker_results_folder,"track_results_{}.txt".format(cam_id))
def run_on_dataset(self):
logger = logging.getLogger("mtmct")
logger.info("Starting tracking on dataset.")
cam_iterators = get_cam_iterators(self.cfg, self.cfg.data.source.cam_ids)
frame_count_all_cams = self.get_cam_iterator_len_sum(cam_iterators)
self.pbar_tracker = tqdm(total=frame_count_all_cams)
timer_avgs, timer_calls = [], []
for cam_iterator in cam_iterators:
logger.info("Processing cam {}".format(cam_iterator.cam_id))
self.track_results_path = self.get_track_results_path(cam_iterator.cam_id)
logger.info(self.track_results_path)
self.track_results_file = open(self.track_results_path, 'w')
print("frame_no_cam,cam_id,person_id,detection_idx,xtl,ytl,xbr,ybr", file=self.track_results_file)
if self.use_original_wda:
self.load_detections(cam_iterator)
ta, tc = self.run_on_cam_images(cam_iterator)
timer_avgs.append(ta)
timer_calls.append(tc)
self.track_results_file.close()
if self.use_original_wda:
self.save_detections()
track_count_string = count_tracks(self.track_results_path)
logger.info(track_count_string)
timer_avgs = np.asarray(timer_avgs)
timer_calls = np.asarray(timer_calls)
all_time = | np.dot(timer_avgs, timer_calls) | numpy.dot |
import pytest
import numpy as np
import pandas as pd
import geopandas
from shapely import geometry
from disarm_gears.frames import TilePattern
from disarm_gears.util.buffers import voronoi_polygons
# Inputs
n_points = 10
g_points = np.random.uniform(0, 1, n_points * 2).reshape(n_points, -1)
vor = voronoi_polygons(g_points)
b_attrib = np.random.random(25)
g_attrib_1 = np.random.random(10)
g_attrib_2 = np.random.random(40).reshape(10, -1)
g_attrib_3 = pd.DataFrame({li: ci for li,ci in zip(['a', 'b', 'c', 'd'], g_attrib_2.T)})
X = np.vstack([g_points.copy()[5:], np.array([10, 10])])
B = geopandas.GeoDataFrame({'id': [0], 'geometry': [geometry.Polygon(((0.2, 0.3), (0.2, 0.8),
(0.7, 0.8), (0.2, 0.3)))]})
B2 = geopandas.GeoDataFrame({'id': [0, 1], 'geometry': [geometry.Polygon(((0.2, 0.3), (0.2, 0.8),
(0.7, 0.8), (0.2, 0.3))),
geometry.Polygon(((0.2, 0.3), (0.7, 0.3),
(0.7, 0.8), (0.2, 0.3)))]})
# Demo object used repeatedly
sf_0 = TilePattern(geometries=vor.geometry, attributes=None, crs=None)
def test_inputs():
# Check bad inputs
with pytest.raises(AssertionError):
TilePattern(geometries=g_points)
with pytest.raises(NotImplementedError):
TilePattern(geometries=vor.geometry, attributes=None, crs=0)
def test_outputs():
# Check output types
assert isinstance(sf_0.region, geopandas.GeoDataFrame)
assert isinstance(sf_0.centroids, np.ndarray)
# Check sf.region shape
sf_0.region.ndim == 2
sf_0.region.shape[0] == n_points
sf_0.region.shape[1] == 1
# Check sf.region.columns
'geometry' in sf_0.region.columns
# Check box type
assert isinstance(sf_0.box, pd.DataFrame)
sf_0.box.ndim == 2
sf_0.box.shape[0] == 2
sf_0.box.shape[1] == 2
def test_attributes_array():
assert sf_0.attributes_array() is None
_attr = np.random.uniform(0, 100, g_points.size).reshape(-1, 2)
sf_1 = TilePattern(geometries=vor.geometry, attributes=_attr, crs=None)
sf_attr = sf_1.attributes_array()
assert isinstance(sf_attr, np.ndarray)
assert sf_attr.shape[0] == _attr.shape[0]
assert sf_attr.shape[1] == _attr.shape[1]
def test_set_boundary():
sf_1 = TilePattern(geometries=vor.geometry, attributes=None, crs=None)
with pytest.raises(AssertionError):
sf_1.set_boundary(B=B.geometry[0])
sf_1.set_boundary(B=B)
assert isinstance(sf_1.boundary, geopandas.GeoDataFrame)
sf_2 = TilePattern(geometries=vor.geometry, attributes=None, crs=None)
sf_2.set_boundary(B2)
assert sf_1.region.shape[0] < sf_2.region.shape[0]
def test_locate():
ix = sf_0.locate(X=X)
assert isinstance(ix, np.ndarray)
assert ix.ndim == 1
assert ix.size == X.shape[0]
assert ix[-1] == -1
assert np.all(ix[:-1] - np.arange(5, 10) == 0)
def test_points_to_frame():
nx = X.shape[0]
summary = sf_0.points_to_frame(X=X, group_by=None)
assert isinstance(summary, pd.DataFrame)
assert summary.ndim == 2
assert summary.shape[0] == nx - 1
assert summary['var_0'].sum() == nx - 1
assert np.unique(summary['tile']).size == nx - 1
with pytest.raises(AssertionError):
sf_0.points_to_frame(X=np.vstack([X] * 3),
group_by=[['A'] * 2 * nx + ['B'] * nx])
summary = sf_0.points_to_frame(X=np.vstack([X] * 3),
group_by=np.hstack([['A'] * 2 * nx + ['B'] * nx]))
assert summary.shape[0] == 2 * (nx - 1)
assert 'var_0' in summary.columns
assert | np.all(summary.loc[summary.group == 'A', 'var_0'] == 2) | numpy.all |
import numpy as np
import pandas as pd
from scipy.stats import norm, percentileofscore
from tqdm.notebook import tqdm
def rv_cc_estimator(sample,n=22):
"""
Realized volatility close to close calculation. Returns a time series of the realized volatility.
sample: series or dataframe of closing prices indexed by date
n: sample size period for the volatility
"""
sample_clean = sample.dropna()
returns = np.divide(sample_clean, sample_clean.shift(1))
log_returns = np.log(returns)
ann_log_returns = 252*np.power(log_returns,2)/n
return 100 * np.sqrt(ann_log_returns.rolling(window=n,min_periods=n).sum())
def cc_estimator(sample,n=22,days=1):
combined_rv = pd.Series()
sample_clean = sample.dropna()
for i in range(days):
staggered_samples = sample_clean[i::days]
returns = np.divide(staggered_samples, staggered_samples.shift(1))
log_returns = np.log(returns)
ann_log_returns = 252*np.power(log_returns,2)/n/days
sample_rv = 100 * np.sqrt(ann_log_returns.rolling(window=n,min_periods=n).sum())
combined_rv = pd.concat([combined_rv, sample_rv])
return combined_rv.sort_index()
def calc_period_var(sample, return_period=22, lookback=66):
"""
A period return's move normalized. Calculated as the squared move (variance) scaled by the period
sample: series or dataframe of closing prices indexed by date
"""
sample_clean = sample.dropna()
lookback_ret = sample_clean.pct_change(periods=return_period)
return (lookback_ret**2).rolling(window=lookback).mean() * 250 / return_period
def calc_var_ratio(sample, return_period=22, period_min=3, day_min=66):
"""
The variance ratio based on the normalized historical returns over a given rolling return period ratioed to the daily historical returns
sample: series or dataframe of closing prices indexed by date
return period:
"""
lookback = max(return_period * period_min, day_min)
period_var = calc_period_var(sample, return_period=return_period, lookback=lookback)
daily_var = calc_period_var(sample, return_period=1, lookback=lookback)
return period_var / daily_var
def calc_lfev(sample, return_period=22, period_min=3, day_min=66):
lookback = max(return_period * period_min, day_min)
period_var = calc_period_var(sample, return_period=return_period, lookback=lookback)
daily_var = calc_period_var(sample, return_period=1, lookback=lookback)
return (np.sqrt(period_var) - np.sqrt(daily_var)) * 100
def move_volatility(prices, days=66):
abs_move = (prices / prices.shift(days) - 1)
high_low = (prices.rolling(days+1).max() - prices.rolling(days+1).min()) / prices.shift(days)
return abs_move / high_low * np.abs(abs_move) * 100
def move_volatility_range(prices, days=66):
abs_move = (prices / prices.shift(days) - 1)
high_prices = prices.rolling(days+1).max()
low_prices = prices.rolling(days+1).min()
close_dist_high_low = ((high_prices - prices.shift(days)) + (low_prices - prices.shift(days))) / prices.shift(days)
high_low = (high_prices - low_prices) / prices.shift(days)
return close_dist_high_low * (0.5 * (np.abs(abs_move) + high_low)) / high_low * 100
def generate_returns_dict(prices, undl_list, return_days):
returns = {}
for u in undl_list:
returns[u] = pd.DataFrame()
for i in return_days:
close_prices = prices[u, 'Close'].dropna()
returns[u][i] = (close_prices / close_prices.shift(i) - 1) * 100
return returns
def rolling_trend(prices, undl_list, return_days, smoothing=5):
'''Determines the trend by blending the returns across different periods and smooths the results.'''
avg_returns_dict = {}
returns_summary = {}
returns_dict = generate_returns_dict(prices, undl_list, return_days)
for u in undl_list:
avg_returns_dict[u] = pd.DataFrame()
for i in return_days:
avg_returns_dict[u]['{}D Trend'.format(i)] = returns_dict[u][i].dropna().rolling(smoothing).mean() / np.sqrt(i)
avg_returns_dict[u]['Average Trend'] = avg_returns_dict[u].dropna().mean(axis=1)
if len(avg_returns_dict[u].dropna()) > 0:
returns_summary[u] = avg_returns_dict[u]['Average Trend'].dropna()[-1]
returns_summary = pd.Series(returns_summary)
return returns_summary, avg_returns_dict
def spot_stats(sample, n=260):
"""
Simple spot statistics returning the distance in % terms from the last spot to the max spot in the period, distance to min spot, and current percentile in min to max.
sample: series or dataframe of closing prices
n: historical lookback period.
"""
spot_window = sample.dropna()[-n:]
percentile = percentileofscore(spot_window, spot_window[-1])
high = spot_window.max()
low = spot_window.min()
max_pct = (high / spot_window[-1] - 1) * 100
min_pct = (low / spot_window[-1] - 1) * 100
return max_pct, min_pct, percentile
def past_spot_ranges(sample, n=22, haircut=0.2, intraday=True):
'''Finds Returns the past n spot range based on max/min of the period'''
if intraday:
sample_max = (sample['High'].rolling(n).max() / sample['Close'].shift(n) - 1) * 100
sample_min = (sample['Low'].rolling(n).min() / sample['Close'].shift(n) - 1) * 100
else:
sample_max = (sample['Close'].rolling(n).max() / sample['Close'].shift(n) - 1) * 100
sample_min = (sample['Close'].rolling(n).min() / sample['Close'].shift(n) - 1) * 100
delta_scale = 1 - haircut # Set a more conservative estimate of the range.
return pd.concat([abs(sample_max) * delta_scale, abs(sample_min) * delta_scale], axis=1).max(axis=1)
def past_abs_returns(sample, n=5):
return np.abs((1 - sample['Close'].shift(n) / sample['Close']) * 100)
def varvolbreakeven(var, vol):
b = -1
a = 1 / (2 * var)
c = vol - var / 2
breakeven1 = (-b + np.sqrt(b**2 - 4 * a * c)) / (2 * a)
breakeven2 = (-b - np.sqrt(b**2 - 4 * a * c)) / (2 * a)
return breakeven1, breakeven2
def zscore_calc(hist_data, live_data):
return (live_data - hist_data.mean()) / hist_data.std()
def var_payout(realized,strike):
return 0.5 * (realized**2 / strike - strike)
def vol_payout(realized, strike):
return realized - strike
class BlackScholes:
def __init__(self, s, k, r, q, vol, t, payoff):
"""vol is expressed in %. eg enter 16v as 16, not 0.16"""
self.s = s
self.k = k
self.r = r
self.q = q
self.vol = vol / 100
self.t = t
self.payoff = payoff
def d1(self):
return (np.log(self.s / self.k) +
(self.r - self.q + self.vol ** 2 / 2) * \
self.t) / (self.vol * np.sqrt(self.t))
def d2(self):
return (np.log(self.s / self.k) +
(self.r - self.q - self.vol ** 2 / 2) * \
self.t) / (self.vol * np.sqrt(self.t))
def phi(self, x):
return np.exp(-x ** 2 / 2) / np.sqrt(2 * np.pi)
def price(self):
if self.payoff.lower() == 'put':
return self.put_price()
else:
return self.call_price()
def call_price(self):
if self.t == 0:
return 0
return self.s * np.exp(-self.q * self.r) * norm.cdf(self.d1()) - np.exp(-self.r * self.t) * self.k * norm.cdf(self.d2())
def put_price(self):
if self.t == 0:
return 0
return np.exp(-self.r * self.t) * self.k * norm.cdf(-self.d2()) - self.s * np.exp(-self.q * self.r) * norm.cdf(-self.d1())
def delta(self):
if self.t == 0:
return 0
if self.payoff.lower() == 'put':
return -np.exp(-self.q * self.r) * norm.cdf(-self.d1())
else:
return np.exp(-self.q * self.r) * norm.cdf(self.d1())
def vega(self):
if self.t == 0:
return 0
return self.s * np.exp(-self.q * self.r) * self.phi(self.d1()) * np.sqrt(self.t)
def alt_vega(self):
return self.k * np.exp(-self.r * self.t) * self.phi(self.d2()) * | np.sqrt(self.t) | numpy.sqrt |
import numpy as np
import scipy.signal as sps
from sklearn.preprocessing import MinMaxScaler, StandardScaler
def resample_data(gsrdata, prevSR, newSR):
'''Calculates rolling mean
Function to calculate moving average over the passed data
Parameters
----------
gsrdata : 1-d array
array containing the gsr data
prevSR : int or float
the previous sample rate of the data
newSR : int or float
the new sample rate of the data
Returns
-------
data : 1-d array
array containing the resampled data
'''
number_of_samples = int(round(len(gsrdata) * float(newSR) / prevSR))
data = sps.resample(gsrdata, number_of_samples)
return data
def normalization(gsrdata):
'''Min Max normalization
Function to calculate normalized gsr data
Parameters
----------
gsrdata : 1-d array
array containing the gsr data
Returns
-------
n_gsrdata : 1-d array
normalized gsr data
'''
gsrdata = gsrdata - (np.min(gsrdata))
gsrdata /= (np.max(gsrdata) - np.min(gsrdata))
n_gsrdata = gsrdata
return n_gsrdata
def rolling_mean(data, windowsize, sample_rate):
'''calculates rolling mean
Function to calculate moving average over the passed data
Parameters
----------
data : 1-d array
array containing the gsr data
windowsize : int or float
the moving average window size in seconds
sample_rate : int or float
the sample rate of the data set
Returns
-------
rol_mean : 1-d array
array containing computed rolling mean
'''
avg_hr = (np.mean(data))
data_arr = np.array(data)
t_windowsize = int(windowsize*sample_rate)
t_shape = data_arr.shape[:-1] + (data_arr.shape[-1] - t_windowsize + 1, t_windowsize)
t_strides = data_arr.strides + (data_arr.strides[-1],)
sep_win = np.lib.stride_tricks.as_strided(data_arr, shape=t_shape, strides=t_strides)
rol_mean = np.mean(sep_win, axis=1)
missing_vals = np.array([avg_hr for i in range(0, int(abs(len(data_arr) - len(rol_mean))/2))])
rol_mean = np.insert(rol_mean, 0, missing_vals)
rol_mean = np.append(rol_mean, missing_vals)
#only to catch length errors that sometimes unexplicably occur.
##Generally not executed, excluded from testing and coverage
if len(rol_mean) != len(data): # pragma: no cover
lendiff = len(rol_mean) - len(data)
if lendiff < 0:
rol_mean = np.append(rol_mean, 0)
else:
rol_mean = rol_mean[:-1]
return rol_mean
def min_max_scale(data):
"""
Min-Max scale the data in the range [-1.0, 1.0]
The data is expected to have the shape (samples, length, channels)
Return the scaled data in the original shape.
"""
_, segment_length, n_channels = data.shape
# flatten the data
features = data.reshape(-1, segment_length * n_channels)
# scale the data
scaler = MinMaxScaler(feature_range=(-1.0, 1.0))
features = scaler.fit_transform(features)
# reshape the data
features = features.reshape(-1, n_channels, segment_length)
features = np.transpose(features, (0, 2, 1))
return features
def standard_scaler(data):
""" Normalize the data to have zero mean and unit standard devication
The data is expected to have the shape (n_samples, segment_length, n_channels)
Return the scaled data in the original shape.
"""
_, segment_length, n_channels = data.shape
# flatten the data
features = data.reshape(-1, segment_length * n_channels)
# scale the data
scaler = StandardScaler(with_mean=False, with_std=False)
features = scaler.fit_transform(features)
# reshape the data
features = features.reshape(-1, n_channels, segment_length)
features = | np.transpose(features, (0, 2, 1)) | numpy.transpose |
import numpy as np
import os
import requests
from matplotlib import pyplot as plt
from matplotlib import cm
from lmfit.models import Model
from sklearn.cluster import KMeans
from shapely.geometry import Polygon
from radio_beam.commonbeam import getMinVolEllipse
from scipy import ndimage as ndi
from scipy.spatial import distance
from skimage import io
from skimage.measure import EllipseModel
from skimage.color import rgb2gray
from skimage import filters, util
from skimage.morphology import disk, skeletonize, ball
from skimage.measure import approximate_polygon
from skimage import transform
from PIL import Image, ImageDraw, ImageFilter, ImageOps
from sklearn.linear_model import LinearRegression
from scipy import ndimage
import copy
import cv2
from scipy.spatial import ConvexHull
import sys
import logging
import time
import glob
from logging import StreamHandler, Formatter
from src.cfg import CfgAnglesNames, CfgBeamsNames, CfgDataset
handler = StreamHandler(stream=sys.stdout)
handler.setFormatter(Formatter(fmt='[%(asctime)s: %(levelname)s] %(message)s'))
logger = logging.getLogger(__name__)
logger.addHandler(handler)
file_path = os.getcwd() + '/utils.py'
class grainPreprocess():
@classmethod
def imdivide(cls, image: np.ndarray, h: int, side: str) -> np.ndarray:
"""
:param image: ndarray (height,width,channels)
:param h: int scalar
:param side: str 'left'
:return: ndarray (height,width/2,channels)
"""
#
# возвращает левую или правую часть полученного изображения
#
height, width = image.shape
sides = {'left': 0, 'right': 1}
shapes = [(0, height - h, 0, width // 2), (0, height - h, width // 2, width)]
shape = shapes[sides[side]]
return image[shape[0]:shape[1], shape[2]:shape[3]]
@classmethod
def combine(cls, image: np.ndarray, h: int, k=0.5) -> np.ndarray:
"""
:param image: ndarray (height,width,channels)
:param h: int scalar
:param k: float scalar
:return: ndarray (height,width/2,channels)
"""
#
# накладывает левую и правые части изображения
# если k=1, то на выходе будет левая часть изображения, если k=0, то будет правая часть
#
left_img = cls.imdivide(image, h, 'left')
right_img = cls.imdivide(image, h, 'right')
l = k
r = 1 - l
gray = np.array(left_img) * l
gray += np.array(right_img) * r
return gray.astype('uint8')
@classmethod
def do_otsu(cls, img: np.ndarray) -> np.ndarray:
"""
:param img: ndarray (height,width,channels)
:return: ndarray (height,width), Boolean
"""
#
# бинаризация отсу
#
global_thresh = filters.threshold_otsu(img)
binary_global = img > global_thresh
return binary_global.astype('uint8')
@classmethod
def image_preprocess(cls, image: np.ndarray) -> np.ndarray:
"""
:param image: ndarray (height,width,channels)
:return: ndarray (height,width)
"""
#
# комбинация медианного фильтра, биноризации и гражиента
# у зерен значение пикселя - 0, у регионов связ. в-ва - 127,а у их границы - 254
#
unsigned_image = util.img_as_ubyte(image)
denoised = filters.rank.median(unsigned_image, ball(3))
binary = cls.do_otsu(denoised)
grad = abs(filters.rank.gradient(binary, ball(1)))
bin_grad = (1 - binary + grad) * 127
return bin_grad.astype(np.uint8)
@classmethod
def image_preprocess_kmeans(cls, image: np.ndarray, h=135, k=1, n_clusters=3, pos=1) -> np.ndarray:
"""
:param image: array (height,width,channels)
:param h: int scalar
:param k: float scalar
:param n_clusters: int scalar
:param pos: int scalar, cluster index
:return: ndarray (height,width)
"""
#
# выделение границ при помощи кластеризации
# и выравнивание шума медианным фильтром
# pos отвечает за выбор кластера, который будет отображен на возвращенном изображении
#
combined = cls.combine(image, h, k)
clustered, colors = grainMorphology.kmeans_image(combined, n_clusters)
cluster = clustered == colors[pos]
cluster = np.array(cluster * 255, dtype='uint8')
new_image = filters.median(cluster, disk(2))
return new_image
@classmethod
def read_preprocess_data(cls, images_dir, max_images_num_per_class=100, preprocess=False, save=False,
crop_bottom=False,
h=135, resize=True, resize_shape=None,
save_name='all_images.npy'):
folders_names = glob.glob(images_dir + '*')
images_paths = [glob.glob(folder_name + '/*')[:max_images_num_per_class] for folder_name in folders_names]
l = np.array(images_paths).flatten().shape[0]
# Initial call to print 0% progress
GrainLogs.printProgressBar(0, l, prefix='Progress:', suffix='Complete', length=50)
preproc_images = []
start_time = time.time()
step = 0
for i, images_list_paths in enumerate(images_paths):
preproc_images.append([])
for image_path in images_list_paths:
step += 1
image = io.imread(image_path).astype(np.uint8)
# вырезает нижнюю полоску фотографии с линекой и тд
if crop_bottom:
image = grainPreprocess.combine(image, h)
# ресайзит изображения
if resize:
if resize_shape is not None:
image = transform.resize(image, resize_shape)
else:
print('No resize shape')
# последовательно применяет фильтры (медианный, отсу, собель и тд)
if preprocess:
image = grainPreprocess.image_preprocess(image)
end_time = time.time()
eta = round((end_time - start_time) * (l - step), 1)
GrainLogs.printProgressBar(step, l, eta=eta, prefix='Progress:', suffix='Complete', length=50)
start_time = time.time()
preproc_images[i].append(image)
if save:
| np.save(save_name, preproc_images) | numpy.save |
"""HOOMD snapshot format."""
import operator
from collections import namedtuple
import numpy as np
import packaging.version
import parmed as pmd
from mbuild.box import Box
from mbuild.compound import Compound, Particle
from mbuild.utils.geometry import coord_shift
from mbuild.utils.io import import_
from mbuild.utils.sorting import natural_sort
hoomd = import_("hoomd")
__all__ = ["to_hoomdsnapshot", "from_snapshot"]
def _get_hoomd_version():
if "version" in dir(hoomd):
return packaging.version.parse(hoomd.version.version)
else:
return packaging.version.parse(hoomd.__version__)
def from_snapshot(snapshot, scale=1.0):
"""Convert a Snapshot to a Compound.
Snapshot can be a hoomd.Snapshot or a gsd.hoomd.Snapshot.
Parameters
----------
snapshot : hoomd.Snapshot or gsd.hoomd.Snapshot
Snapshot from which to build the mbuild Compound.
scale : float, optional, default 1.0
Value by which to scale the length values
Returns
-------
comp : Compound
Note
----
GSD and HOOMD snapshots center their boxes on the origin (0,0,0), so the
compound is shifted by half the box lengths
"""
comp = Compound()
bond_array = snapshot.bonds.group
n_atoms = snapshot.particles.N
if "SnapshotSystemData_float" in dir(hoomd._hoomd) and isinstance(
snapshot, hoomd._hoomd.SnapshotSystemData_float
):
# hoomd v2
box = snapshot.box
comp.box = Box.from_lengths_tilt_factors(
lengths=np.array([box.Lx, box.Ly, box.Lz]) * scale,
tilt_factors=np.array([box.xy, box.xz, box.yz]),
)
else:
# gsd / hoomd v3
box = np.asarray(snapshot.configuration.box)
comp.box = Box.from_lengths_tilt_factors(
lengths=box[:3] * scale, tilt_factors=box[3:]
)
# GSD and HOOMD snapshots center their boxes on the origin (0,0,0)
shift = np.array(comp.box.lengths) / 2
# Add particles
for i in range(n_atoms):
name = snapshot.particles.types[snapshot.particles.typeid[i]]
xyz = snapshot.particles.position[i] * scale + shift
charge = snapshot.particles.charge[i]
atom = Particle(name=name, pos=xyz, charge=charge)
comp.add(atom, label=str(i))
# Add bonds
particle_dict = {idx: p for idx, p in enumerate(comp.particles())}
for i in range(bond_array.shape[0]):
atom1 = int(bond_array[i][0])
atom2 = int(bond_array[i][1])
comp.add_bond([particle_dict[atom1], particle_dict[atom2]])
return comp
def to_hoomdsnapshot(
structure,
ref_distance=1.0,
ref_mass=1.0,
ref_energy=1.0,
rigid_bodies=None,
shift_coords=True,
write_special_pairs=True,
auto_scale=False,
parmed_kwargs={},
hoomd_snapshot=None,
):
"""Convert a Compound or parmed.Structure to hoomd.Snapshot.
Parameters
----------
structure : parmed.Structure
ParmEd Structure object
ref_distance : float, optional, default=1.0
Reference distance for conversion to reduced units
ref_mass : float, optional, default=1.0
Reference mass for conversion to reduced units
ref_energy : float, optional, default=1.0
Reference energy for conversion to reduced units
rigid_bodies : list of int, optional, default=None
List of rigid body information. An integer value is required for
each atom corresponding to the index of the rigid body the particle
is to be associated with. A value of None indicates the atom is not
part of a rigid body.
shift_coords : bool, optional, default=True
Shift coordinates from (0, L) to (-L/2, L/2) if necessary.
auto_scale : bool, optional, default=False
Automatically use largest sigma value as ref_distance,
largest mass value as ref_mass
and largest epsilon value as ref_energy
write_special_pairs : bool, optional, default=True
Writes out special pair information necessary to correctly use
the OPLS fudged 1,4 interactions in HOOMD.
hoomd_snapshot : hoomd.Snapshot, optional, default=None
Initial snapshot to which to add the ParmEd structure object.
The box information of the initial snapshot will be overwritten.
(useful for rigid bodies)
Returns
-------
hoomd_snapshot : hoomd.Snapshot
ReferenceValues : namedtuple
Values used in scaling
Notes
-----
Force field parameters are not written to the hoomd_snapshot
"""
if not isinstance(structure, (Compound, pmd.Structure)):
raise ValueError(
"You are trying to create a hoomd.Snapshot from a "
f"{type(structure)} please pass a Compound or pmd.Structure"
)
elif isinstance(structure, Compound):
structure = structure.to_parmed(**parmed_kwargs)
hoomd_version = _get_hoomd_version()
if hoomd_version.major == 2 and not hoomd.context.current:
hoomd.context.initialize("")
if auto_scale:
ref_mass = max([atom.mass for atom in structure.atoms])
pair_coeffs = list(
set(
(atom.type, atom.epsilon, atom.sigma)
for atom in structure.atoms
)
)
ref_energy = max(pair_coeffs, key=operator.itemgetter(1))[1]
ref_distance = max(pair_coeffs, key=operator.itemgetter(2))[2]
ReferenceValues = namedtuple("ref_values", ["distance", "mass", "energy"])
ref_values = ReferenceValues(ref_distance, ref_mass, ref_energy)
xyz = np.array([[atom.xx, atom.xy, atom.xz] for atom in structure.atoms])
if shift_coords:
xyz = coord_shift(xyz, structure.box[:3])
# Get box information
if np.allclose(structure.box[3:6], np.array([90, 90, 90])):
lx, ly, lz = structure.box[:3] / ref_distance
xy, xz, yz = 0, 0, 0
else:
a, b, c = structure.box[0:3] / ref_distance
alpha, beta, gamma = np.radians(structure.box[3:6])
lx = a
xy = b * np.cos(gamma)
xz = c * np.cos(beta)
ly = | np.sqrt(b ** 2 - xy ** 2) | numpy.sqrt |
"""PISA data container"""
from __future__ import absolute_import, division, print_function
import argparse
from collections.abc import Mapping, Iterable, Sequence
from collections import OrderedDict
import copy
import numpy as np
from pisa import FTYPE
from pisa.core.binning import OneDimBinning, MultiDimBinning
from pisa.utils.fileio import from_file
from pisa.utils.log import logging
__all__ = [
"NU_FLAVORS",
"NU_INTERACTIONS",
"OUTPUT_NUFLAVINT_KEYS",
"LEGACY_FLAVKEY_XLATION",
"EventsPi",
"split_nu_events_by_flavor_and_interaction",
"fix_oppo_flux",
"main",
]
__author__ = "<NAME>"
__license__ = """Copyright (c) 2014-2018, The IceCube Collaboration
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License."""
# Define the flavors and interactions for neutrino events
NU_FLAVORS = OrderedDict(
nue=12, nuebar=-12, numu=14, numubar=-14, nutau=16, nutaubar=-16
)
NU_INTERACTIONS = OrderedDict(cc=1, nc=2)
OUTPUT_NUFLAVINT_KEYS = tuple(
"%s_%s" % (fk, ik)
for fk, fc in NU_FLAVORS.items()
for ik, ic in NU_INTERACTIONS.items()
)
LEGACY_FLAVKEY_XLATION = dict(
nue="nue",
nuebar="nuebar",
nue_bar="nuebar",
numu="numu",
numubar="numubar",
numu_bar="numubar",
nutau="nutau",
nutaubar="nutaubar",
nutau_bar="nutaubar",
)
# Backwards cmpatiblity fixes
OPPO_FLUX_LEGACY_FIX_MAPPING_NU = {
"nominal_nue_flux" : "neutrino_nue_flux",
"nominal_numu_flux" : "neutrino_numu_flux",
"nominal_nuebar_flux" : "neutrino_oppo_nue_flux",
"nominal_numubar_flux" : "neutrino_oppo_numu_flux",
}
OPPO_FLUX_LEGACY_FIX_MAPPING_NUBAR = {
"nominal_nue_flux" : "neutrino_oppo_nue_flux",
"nominal_numu_flux" : "neutrino_oppo_numu_flux",
"nominal_nuebar_flux" : "neutrino_nue_flux",
"nominal_numubar_flux" : "neutrino_numu_flux",
}
def append_arrays_dict(key, val, sdict):
'''
Helper function for appending multiple dicts of arrays (e.g. from
multiple input files) into a single dict of arrays
'''
if isinstance(val, Mapping):
# Handle sub-dict
for key2, val2 in val.items() :
if key not in sdict :
sdict[key] = OrderedDict()
append_arrays_dict(key2, val2, sdict[key])
else :
# Have now reached a variable
assert isinstance(val, np.ndarray), "'%s' is not an array, is a %s" % (key, type(val))
if key in sdict :
sdict[key] = np.append(sdict[key], val)
else :
sdict[key] = val
class EventsPi(OrderedDict):
"""
Container for events for use with PISA pi
Parameters
----------
name : string, optional
Name to identify events
neutrinos : bool, optional
Flag indicating if events represent neutrinos; toggles special
behavior such as splitting into nu/nubar and CC/NC. Default is True.
fraction_events_to_keep : float
Fraction of loaded events to use (use to downsample).
Must be in range [0.,1.], or disable by setting to `None`.
Default in None.
*args, **kwargs
Passed on to `__init__` method of OrderedDict
"""
def __init__(
self,
*args,
name=None,
neutrinos=True,
fraction_events_to_keep=None,
events_subsample_index=0,
**kwargs
):
super().__init__(*args, **kwargs)
self.name = name
self.neutrinos = neutrinos
self.fraction_events_to_keep = fraction_events_to_keep
self.events_subsample_index = events_subsample_index
# Checks for down-sampling inputs
if self.fraction_events_to_keep is not None:
# Check `fraction_events_to_keep` value is required range
self.fraction_events_to_keep = float(self.fraction_events_to_keep)
assert (self.fraction_events_to_keep >= 0.) and (self.fraction_events_to_keep <= 1.), "`fraction_events_to_keep` must be in range [0.,1.], or None to disable"
# Check `fraction_events_to_keep` and `events_subsample_index` values are compatible
assert isinstance(self.events_subsample_index, int), f"`events_subsample_index` must be an integer"
assert self.events_subsample_index >= 0, f"`events_subsample_index` = {self.events_subsample_index}, but must be >= 0"
max_index = int(np.floor( 1. / self.fraction_events_to_keep )) - 1
assert self.events_subsample_index <= max_index, f"`events_subsample_index` = {self.events_subsample_index} is too large given `fraction_events_to_keep` = {self.fraction_events_to_keep} (max is {max_index})"
# Define some metadata
#TODO Is this out of date?
self.metadata = OrderedDict(
[
("detector", ""),
("geom", ""),
("runs", []),
("proc_ver", ""),
("cuts", []),
]
)
def load_events_file(self, events_file, variable_mapping=None, required_metadata=None, seed=123456):
"""Fill this events container from an input HDF5 file filled with event
data Optionally can provide a variable mapping so select a subset of
variables, rename them, etc.
Parameters
----------
events_file : string or mapping
If string, interpret as a path and load file at that path; the
loaded object should be a mapping. If already a mapping, take and
interpret events from that.
variable_mapping : mapping, optional
If specified, should be a mapping where the keys are the
destination variable names and the items are either the source
variable names or an iterable of source variables names. In the
latter case, each of the specified source variables will become a
column vector in the destination array.
required_metadata : None, or list of str
Can optionally specify metadata keys to parse from the input file metdata.
ONLY metadata specified here will be parsed.
Anything specified here MUST exist in the files.
"""
# Validate `events_file`
if not isinstance(events_file, (str, Mapping, Sequence)):
raise TypeError(
"`events_file` must be either string or mapping; got (%s)"
% type(events_file)
)
# Validate `variable_mapping`
if variable_mapping is not None:
if not isinstance(variable_mapping, Mapping):
raise TypeError("'variable_mapping' must be a mapping (e.g., dict)")
for dst, src in variable_mapping.items():
if not isinstance(dst, str):
raise TypeError("`variable_mapping` 'dst' (key) must be a string")
if isinstance(src, str):
pass # Nothing to do
elif isinstance(src, Iterable):
for v in src:
if not isinstance(v, str):
raise TypeError(
"`variable_mapping` 'src' (value) has at least"
" one element that is not a string"
)
else:
raise TypeError(
"`variable_mapping` 'src' (value) must be a string or"
" an iterable of strings"
)
# Validate `required_metadata`
if required_metadata is not None :
assert isinstance(required_metadata, Sequence)
assert all([ isinstance(k, str) for k in required_metadata ])
# Reporting
if self.fraction_events_to_keep is not None :
logging.info("Down-sampling events (keeping %0.2g%% of the total). Will take sub-sample %i." % (100.*self.fraction_events_to_keep, self.events_subsample_index))
#
# Loop over files
#
input_data = OrderedDict()
metadata = OrderedDict()
# Handle list of files vs single file
events_files_list = []
if isinstance(events_file, str):
events_files_list = [events_file]
elif isinstance(events_file, Mapping):
events_files_list = [events_file]
elif isinstance(events_file, Sequence):
events_files_list = events_file
# Loop over files
for i_file, infile in enumerate(events_files_list) :
#
# Parse variables from file
#
# Read the file
# If `variable_mapping` was specified, only load those variables (saves time/memory)
if isinstance(infile, str):
# If user provided a variable mapping, only load the requested variables.
# Remember to andle cases where the variable is defined as a list of variables in
# the cfg file.
if variable_mapping is None :
choose = None
else :
choose = []
for var_name in variable_mapping.values() :
if isinstance(var_name, str) :
choose.append(var_name)
elif isinstance(var_name, Sequence) :
for sub_var_name in var_name :
assert isinstance(sub_var_name, str), "Unknown variable format, must be `str`"
choose.append(sub_var_name)
else :
raise IOError("Unknown variable name format, must be `str` or list of `str`")
# Handle "oppo" flux backwards compatibility
# This means adding the old variable names into the chosen variable list
# The actual renaming is done later by `fix_oppo_flux`
if variable_mapping is not None :
for var_name in choose :
if var_name in OPPO_FLUX_LEGACY_FIX_MAPPING_NU :
choose.append( OPPO_FLUX_LEGACY_FIX_MAPPING_NU[var_name] )
if var_name in OPPO_FLUX_LEGACY_FIX_MAPPING_NUBAR :
choose.append( OPPO_FLUX_LEGACY_FIX_MAPPING_NUBAR[var_name] )
# Load the file
file_input_data = from_file(infile, choose=choose)
if not isinstance(file_input_data, Mapping):
raise TypeError(
'Contents loaded from "%s" must be a mapping; got: %s'
% (infile, type(file_input_data))
)
assert len(file_input_data) > 0, "No input data found"
# File already loaded
elif isinstance(infile, Mapping) :
file_input_data = infile
# Add to overall container
for k, v in file_input_data.items() :
append_arrays_dict(k, v, input_data)
#
# Parse metadata from file
#
if required_metadata is not None :
# Events and EventsPi objects have attr `metadata`
file_metadata = getattr(file_input_data, 'metadata', None)
# HDF files have attr `attrs` attached, if present (see pisa.utils.hdf)
if not file_metadata:
file_metadata = getattr(file_input_data, 'attrs', None)
if file_metadata:
# Check format
if not isinstance(file_metadata, Mapping):
raise TypeError(
"metadata or attrs expected to be a Mapping, but got {}".format(
type(file_metadata)
)
)
# Loop over expected metadata
for k in required_metadata :
assert k in file_metadata, "Expected metadata '%s' not found" % k
# For the special case of livetime, append livetiem from each file
# Otherwise, expect identical value in all cases
if k in self.metadata :
if k == "livetime" :
self.metadata[k] += file_metadata[k]
else :
assert self.metadata[k] == file_metadata[k]
else :
self.metadata[k] = file_metadata[k]
#
# Re-format inputs
#
# The following is intended to re-format input data into the desired
# format. This is required to handle various inout cases and to ensure
# backwards compatibility with older input file formats.
# Convert to the required event keys, e.g. "numu_cc", "nutaubar_nc", etc.
if self.neutrinos:
input_data = split_nu_events_by_flavor_and_interaction(input_data)
# The value for each category should itself be a dict of the event
# variables, where each entry is has a variable name as the key and an
# np.array filled once per event as the value.
#
# For backwards compatibility, convert to this format from known older
# formats first
if self.neutrinos:
for key, cat_dict in input_data.items():
if not isinstance(cat_dict, Mapping):
raise Exception(
"'%s' input data is not a mapping, unknown format (%s)"
% (key, type(cat_dict))
)
for var_key, var_data in cat_dict.items():
if not isinstance(var_data, np.ndarray):
raise Exception(
"'%s/%s' input data is not a numpy array, unknown"
" format (%s)" % (key, var_key, type(var_data))
)
# Ensure backwards compatibility with the old style "oppo" flux
# variables
if self.neutrinos:
fix_oppo_flux(input_data)
#
# Load the event data
#
# Should be organised under a single layer of keys, each representing
# some category of input data
# Loop over the input types
for data_key in input_data.keys():
if data_key in self:
raise ValueError(
"Key '%s' has already been added to this data structure"
)
self[data_key] = OrderedDict()
# Loop through variable mapping
# If none provided, just use all variables and keep the input names
if variable_mapping is None:
variable_mapping_to_use = tuple(
zip(input_data[data_key].keys(), input_data[data_key].keys())
)
else:
variable_mapping_to_use = variable_mapping.items()
# Init stuff for down-sampling later
chosen_event_indices = None
rand = np.random.RandomState(seed) # Enforce same sample each time
# Get the array data (stacking if multiple input variables defined)
# and check the variable exists in the input data
for var_dst, var_src in variable_mapping_to_use:
# TODO What about non-float data? Use dtype...
# Prepare for the stacking
array_data = None
if isinstance(var_src, str):
var_src = [var_src]
# Perform the stacking
array_data_to_stack = []
for var in var_src:
if var in input_data[data_key]:
array_data_to_stack.append(
input_data[data_key][var].astype(FTYPE)
)
else:
raise KeyError(
"Variable '%s' cannot be found for '%s' events"
% (var, data_key)
)
# Note `squeeze` removes the extraneous 2nd dim in case of a
# single `src`
array_data = np.squeeze(np.stack(array_data_to_stack, axis=1))
# Check actually have some data
if array_data is None:
raise ValueError(
"Cannot find source variable(s) '%s' for '%s'"
% (var_src, data_key)
)
#
# Event down sampling
#
# Only if requested by user
if self.fraction_events_to_keep is not None:
# Define events to keep only once for each species (e.g. same choice for all variables for a given species)
if chosen_event_indices is None :
# Get intitial conditions
initial_num_events = array_data.size
desired_num_events = int( self.fraction_events_to_keep * float(initial_num_events) )
# Start with all events as input
current_event_indices = np.array( range(initial_num_events) )
# Loop over subsamples (will break out once reach desired subsample)
i = 0
while True :
# Get indices for the events to keep for this current sub-sample
assert current_event_indices.size >= desired_num_events, "Not enough events available" # Earlier checks on `fraction_events_to_keep` and `events_subsample_index` should prevent this error ever happening
chosen_event_indices = np.sort( rand.choice(current_event_indices, replace=False, size=desired_num_events) )
# If this is the requested sub-sample, done here
if i == self.events_subsample_index :
break
# Otherwise have not yet reached our subsample.
# Choose the remaining events as the new input events in the algorithm,
# and on the next iteration of this loop these remaining events will be
# used for extracting the new sub-sample.
# This will result in statistically independent sub-samples
remaining_event_indices = np.sort( np.setxor1d(current_event_indices, chosen_event_indices) )
current_event_indices = remaining_event_indices
i += 1
# Report
logging.info("Down-sampled %s events : %i -> %i (%0.2g%%)" % ( data_key, array_data.size, chosen_event_indices.size, 100.*(chosen_event_indices.size/array_data.size) ))
# Extract just the requested events
array_data = array_data[chosen_event_indices]
# Add to array
self[data_key][var_dst] = array_data
def apply_cut(self, keep_criteria):
"""Apply a cut by specifying criteria for keeping events. The cut must
be successfully applied to all flav/ints in the events object before
the changes are kept, otherwise the cuts are reverted.
Parameters
----------
keep_criteria : string
Any string interpretable as numpy boolean expression.
Examples
--------
Keep events with true energies in [1, 80] GeV (note that units are not
recognized, so have to be handled outside this method)
>>> events = events.apply_cut("(true_energy >= 1) & (true_energy <= 80)")
Do the opposite with "~" inverting the criteria
>>> events = events.apply_cut("~((true_energy >= 1) & (true_energy <= 80))")
Numpy namespace is available for use via `np` prefix
>>> events = events.apply_cut("np.log10(true_energy) >= 0")
"""
assert isinstance(keep_criteria, str)
# Check if have already applied these cuts
if keep_criteria in self.metadata["cuts"]:
logging.debug(
"Criteria '%s' have already been applied. Returning"
" events unmodified.",
keep_criteria,
)
return self
# TODO Get everything from the GPU first ?
# Prepare the post-cut data container
cut_data = EventsPi(name=self.name)
cut_data.metadata = copy.deepcopy(self.metadata)
# Loop over the data containers
for key in self.keys():
cut_data[key] = {}
# TODO Need to think about how to handle array, scalar and binned data
# TODO Check for `events` data mode, or should this kind of logic
# already be in the Container class?
variables = self[key].keys()
# Create the cut expression, and get the resulting mask
crit_str = keep_criteria
for variable_name in variables:
crit_str = crit_str.replace(
variable_name, 'self["%s"]["%s"]' % (key, variable_name)
)
mask = eval(crit_str) # pylint: disable=eval-used
# Fill a new container with the post-cut data
for variable_name in variables:
cut_data[key][variable_name] = copy.deepcopy(
self[key][variable_name][mask]
)
# TODO update to GPUs?
# Record the cuts
cut_data.metadata["cuts"].append(keep_criteria)
return cut_data
def keep_inbounds(self, binning):
"""Cut out any events that fall outside `binning`. Note that events
that fall exactly on an outer edge are kept.
Parameters
----------
binning : OneDimBinning or MultiDimBinning
Returns
-------
cut_data : EventsPi
"""
# Get the binning instance
try:
binning = OneDimBinning(binning)
except: # pylint: disable=bare-except
pass
if isinstance(binning, OneDimBinning):
binning = [binning]
binning = MultiDimBinning(binning)
# Define a cut to remove events outside of the binned region
bin_edge_cuts = [dim.inbounds_criteria for dim in binning]
bin_edge_cuts = " & ".join([str(x) for x in bin_edge_cuts])
# Apply the cut
return self.apply_cut(bin_edge_cuts)
def __str__(self): # TODO Handle non-array data cases
string = "-----------------------------\n"
string += "EventsPi container %s :" % self.name
for key, container in self.items():
string += " %s :\n" % key
for var, array in container.items():
array_data = array
if len(array_data) <= 4:
array_data_string = str(array_data)
else:
array_data_string = "[%s, %s, ..., %s, %s]" % (
array_data[0],
array_data[1],
array_data[-2],
array_data[-1],
)
string += " %s : %i elements : %s\n" % (
var,
len(array_data),
array_data_string,
)
string += "-----------------------------"
return string
def split_nu_events_by_flavor_and_interaction(input_data):
"""Split neutrino events by nu vs nubar, and CC vs NC.
Should be compatible with DRAGON and GRECO samples, but this depends on the
contents of the original I3 files and whatever conversion script was used
to produce the HDF5 files from these.
Parameters
----------
input_data : mapping
Returns
-------
output_data : OrderedDict
"""
# TODO Split into one function for nu/nubar and one for CC/NC?
assert isinstance(input_data, Mapping)
assert input_data, "`input_data` has no members"
output_data = OrderedDict()
# Loop through subcategories in the input data
for key, data in input_data.items():
# If key already is one of the desired keys, nothing new to do
# Just move the data to the output container
if key in OUTPUT_NUFLAVINT_KEYS:
if key in output_data:
output_data[key] = np.concatenate(output_data[key], data)
else:
output_data[key] = data
continue
# Legacy PISA HDF5 files are structured as
# {"<flavor>": {"<int_type>": data}};
# and `flavor` can have "_" separating "bar". Remove such underscores
# and flatten the nested dicts into
# {"<flavor>_<int_type>": data}
# format
if key in LEGACY_FLAVKEY_XLATION:
new_flav_key = LEGACY_FLAVKEY_XLATION[key]
for sub_key, sub_data in data.items():
assert sub_key in ("cc", "nc"), str(sub_key)
output_key = new_flav_key + "_" + sub_key
if output_key in output_data:
output_data[output_key] = np.concatenate(
output_data[output_key], sub_data
)
else:
output_data[output_key] = sub_data
continue
assert "pdg_code" in data, "No 'pdg_code' variable found for %s data" % key
# Check these are neutrino events
assert np.all(np.isin(data["pdg_code"], NU_FLAVORS.values())), (
"%s data does not appear to be a neutrino data" % key
)
assert "interaction" in data, (
"No 'interaction' variable found for %s data" % key
)
# Define a mask to select the events for each desired output key
key_mask_pairs = [
("%s_%s" % (fk, ik), (data["pdg_code"] == fc) & (data["interaction"] == ic))
for fk, fc in NU_FLAVORS.items()
for ik, ic in NU_INTERACTIONS.items()
]
# Loop over the keys/masks and write the data for each class to the
# output container
for mkey, mask in key_mask_pairs:
if | np.any(mask) | numpy.any |
#!/usr/bin/env python
import argparse
import os
import sys
import csv
import h5py
import tensorflow.keras as keras
import tensorflow as tf
import numpy as np
from tqdm import tqdm
import cv2
import SimpleITK as sitk
import time
tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)
tf.compat.v1.enable_v2_behavior()
if __name__ == "__main__" and __package__ is None:
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
import fl_covid.bin # noqa: F401
__package__ = "fl_covid.bin"
# Change these to absolute imports if you copy this script outside the fl_covid package.
from ..utils.anchors import compute_overlap
from .. import models
from ..preprocessing.csv_generator import CSVGenerator
from ..utils.eval import _compute_ap, _get_annotations, _get_annotations_and_img_path
from ..utils.config import read_config_file, parse_anchor_parameters
from ..utils.keras_version import check_keras_version
from ..utils.visualization import draw_detections, draw_annotations
from ..utils.visualization import draw_box, label_color, draw_caption
from ..utils.image import preprocess_image, resize_image
from fl_covid.bin.train_fed import create_models
from fl_covid.bin.evaluate_overall import fp_reduce
def get_session():
""" Construct a modified tf session.
"""
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
return tf.Session(config=config)
def draw_label_hit(image, box, caption):
""" Draws a caption above the box in an image.
# Arguments
image : The image to draw on.
box : A list of 4 elements (x1, y1, x2, y2).
caption : String containing the text to draw.
"""
b = np.array(box).astype(int)
cv2.putText(image, caption, (b[0]+5, b[3] - 5), cv2.FONT_HERSHEY_PLAIN, 1, (0, 0, 0), 2)
cv2.putText(image, caption, (b[0]+5, b[3] - 5), cv2.FONT_HERSHEY_PLAIN, 1, (255, 255, 255), 1)
def draw_detections(image, boxes, scores, labels, color=None, label_to_name=None, slice_id=None, bbox_writer=None, score_threshold=0.4): # score_threshold used to be 0.5
""" Draws detections in an image.
# Arguments
image : The image to draw on.
boxes : A [N, 4] matrix (x1, y1, x2, y2).
scores : A list of N classification scores.
labels : A list of N labels.
color : The color of the boxes. By default the color from keras_retinanet.utils.colors.label_color will be used.
label_to_name : (optional) Functor for mapping a label to a name.
score_threshold : Threshold used for determining what detections to draw.
"""
selection = np.where(scores > score_threshold)[0]
for i in selection:
c = color if color is not None else label_color(labels[i])
if bbox_writer is not None and slice_id is not None:
tar_path = 'slice_{}.png'.format(slice_id)
b = np.array(boxes[i, :]).astype(int)
bbox_writer.writerow([tar_path]+ [b[0],b[1],b[2],b[3]]+['lesion'])
draw_box(image, boxes[i, :], color=c,thickness=1)
# draw labels
caption = (label_to_name(labels[i]) if label_to_name else str(labels[i])) + ': {0:.2f}'.format(scores[i])
draw_caption(image, boxes[i, :], caption)
def read_h5(img_path):
with h5py.File(img_path, "r") as hf:
arr = hf['arr'][:]
return arr
def draw_colorful_result(
args,
client_name,
patient_name,
iou_threshold=0.5,
score_threshold=0.05,
max_detections=100,
save_path=None
):
def _parse(value, function, fmt):
"""Parse a string into a value, and format a nice ValueError if it fails.
Returns `function(value)`.
Any `ValueError` raised is catched and a new `ValueError` is raised
with message `fmt.format(e)`, where `e` is the caught `ValueError`.
"""
try:
return function(value)
except ValueError as e:
raise ValueError(fmt.format(e))
if args.reduce_fp:
sign = 'fp_reduced_'
else:
sign=''
bbox_result_path = os.path.join(save_path,'{}_{}_score_thres_{}_bbox.csv'.format(client_name, patient_name, score_threshold))
anno_result_path = os.path.join(save_path,'{}_{}_score_thres_{}_anno.csv'.format(client_name, patient_name, score_threshold))
all_annotations_img_path = np.load(os.path.join(save_path, '{}_{}_annotations_img_path.npy'.format(client_name, patient_name)), allow_pickle=True)
# prepare annotation result
anno_result = {}
annos = open(anno_result_path, 'r')
classes = {'lesion': 0}
for line, row in enumerate(annos):
splits = row.split(',')
# print(splits)
# print(len(splits))
try:
img_file, x1, y1, x2, y2, class_name, hit_cnt = splits
hit_cnt = hit_cnt.replace('\n', '')
except ValueError:
raise ValueError(
'line {}: format should be \'img_file,x1,y1,x2,y2,class_name\' or \'img_file,,,,,\''.format(line))
if img_file not in anno_result:
anno_result[img_file] = []
x1 = _parse(x1, int, 'line {}: malformed x1: {{}}'.format(line))
y1 = _parse(y1, int, 'line {}: malformed y1: {{}}'.format(line))
x2 = _parse(x2, int, 'line {}: malformed x2: {{}}'.format(line))
y2 = _parse(y2, int, 'line {}: malformed y2: {{}}'.format(line))
hit_cnt = _parse(hit_cnt, int, 'line {}: malformed hit count: {{}}'.format(line))
if x2 <= x1:
raise ValueError('line {}: x2 ({}) must be higher than x1 ({})'.format(line, x2, x1))
if y2 <= y1:
raise ValueError('line {}: y2 ({}) must be higher than y1 ({})'.format(line, y2, y1))
# check if the current class name is correctly present
if str(class_name) not in classes:
raise ValueError(
'line {}: unknown class name: \'{}\' (classes: {})'.format(line, class_name, classes))
anno_result[img_file].append({'x1': x1, 'x2': x2, 'y1': y1, 'y2': y2, 'class': class_name, 'hit_cnt':hit_cnt})
# prepare prediction bbox result
bbox_result = {}
bboxs = open(bbox_result_path, 'r')
classes = {'lesion': 0}
for line, row in enumerate(bboxs):
splits = row.split(',')
try:
img_file, x1, y1, x2, y2, class_name, score, box_type = splits
box_type = box_type.replace('\n', '')
except ValueError:
raise ValueError(
'line {}: format should be \'img_file,x1,y1,x2,y2,class_name\' or \'img_file,,,,,\''.format(line))
if img_file not in bbox_result:
bbox_result[img_file] = []
x1 = _parse(x1, int, 'line {}: malformed x1: {{}}'.format(line))
y1 = _parse(y1, int, 'line {}: malformed y1: {{}}'.format(line))
x2 = _parse(x2, int, 'line {}: malformed x2: {{}}'.format(line))
y2 = _parse(y2, int, 'line {}: malformed y2: {{}}'.format(line))
if x2 <= x1:
raise ValueError('line {}: x2 ({}) must be higher than x1 ({})'.format(line, x2, x1))
if y2 <= y1:
raise ValueError('line {}: y2 ({}) must be higher than y1 ({})'.format(line, y2, y1))
# check if the current class name is correctly present
if str(class_name) not in classes:
raise ValueError(
'line {}: unknown class name: \'{}\' (classes: {})'.format(line, class_name, classes))
bbox_result[img_file].append({'x1': x1, 'x2': x2, 'y1': y1, 'y2': y2, 'class': class_name, 'score':score, 'box_type': str(box_type)})
detection_out = np.zeros([len(all_annotations_img_path), 512, 512, 3])
for i in tqdm(range(len(all_annotations_img_path)), desc='Drawing colorful {} result on {} {}: '.format(sign, client_name, patient_name)):
img_path = all_annotations_img_path[i]
raw_img = read_h5(img_path)
# print(img_path)
image = raw_img.copy()
if keras.backend.image_data_format() == 'channels_first':
image = image.transpose((2, 0, 1))
if img_path in anno_result:
for anno_index in range(len(anno_result[img_path])):
# draw annotation
hit_cnt = anno_result[img_path][anno_index]['hit_cnt']
caption = '{}'.format(hit_cnt)
anno_box = [anno_result[img_path][anno_index]['x1'], anno_result[img_path][anno_index]['y1'], anno_result[img_path][anno_index]['x2'],anno_result[img_path][anno_index]['y2']]
draw_label_hit(image, anno_box , caption)
draw_box(image, anno_box, color=[0,255,0], thickness=1)
if img_path in bbox_result:
for bbox_index in range(len(bbox_result[img_path])):
pred_box = [bbox_result[img_path][bbox_index]['x1'], bbox_result[img_path][bbox_index]['y1'], bbox_result[img_path][bbox_index]['x2'],bbox_result[img_path][bbox_index]['y2']]
box_type = str(bbox_result[img_path][bbox_index]['box_type'])
score = float(bbox_result[img_path][bbox_index]['score'])
# print(box_type)
# print('assigned_gt')
# print(box_type=='assigned_gt')
if box_type == 'max_overlap':
box_color = [31, 0, 255]
elif box_type == 'assigned_pre':
box_color =[184, 0, 255]
elif box_type == 'assigned_gt':
box_color = [139, 69, 19]
elif box_type == 'fp':
box_color = [225, 0, 0]
else:
raise ValueError("Unknown box type :{}".format(box_type))
draw_box(image, pred_box, color=box_color, thickness=1)
caption = ('{0:.2f}'.format(score))
draw_caption(image, pred_box, caption)
detection_out[i, :, :] = image
print('Writing colorful results on {} {}...'.format(client_name, patient_name))
detection_out = sitk.GetImageFromArray(detection_out)
sitk.WriteImage(detection_out, os.path.join(save_path, '{}_{}_colorful_detection_{}result.nii.gz'.format(client_name, patient_name, sign)))
def create_generator(args):
""" Create generators for evaluation.
"""
if args.dataset_type == 'csv':
validation_generator = CSVGenerator(
args.annotations,
args.classes,
image_min_side=args.image_min_side,
image_max_side=args.image_max_side,
config=args.config,
shuffle_groups=False
)
else:
raise ValueError('Invalid data type received: {}'.format(args.dataset_type))
return validation_generator
def _seg_filter(bboxes,scores_sort,seg):
image_boxes = bboxes
inner = np.asarray([],dtype=np.bool)
flag = False
for i in range(image_boxes.shape[0]):
x1 = int(image_boxes[i][0])
y1 = int(image_boxes[i][1])
x2 = int(image_boxes[i][2])
y2 = int(image_boxes[i][3])
x1 = 511 if x1 > 511 else x1
y1 = 511 if y1 > 511 else y1
x2 = 511 if x2 > 511 else x2
y2 = 511 if y2 > 511 else y2
# print(scores_sort)
# print(scores_sort.shape)
if (seg[y1,x1,:] == 0).all() and (seg[y2,x2,:] == 0).all() and (seg[y1,x2,:] == 0).all() and (seg[y2,x1,:] == 0).all():
inner = np.append(inner,False)
flag=True
# scores_sort = np.delete(scores_sort,i,axis=0)
else:
inner = | np.append(inner, True) | numpy.append |
import numpy as np
import matplotlib.pyplot as plt
import glob
import json
configs = ['kp200_startVel_special']
def running_mean(x, N):
cumsum = np.cumsum(np.insert(x, 0, 0))
return (cumsum[N:] - cumsum[:-N]) / float(N)
labels = {}
labels["NoIntent"] = "CarEnv-TenOpponent-States-SpeedControl-TL-v0_"
labels['Intent'] = "CarEnv-TenOpponentWithIntention-States-SpeedControl-TL-v0_"
for config in configs:
print(glob.glob("data/"+labels["NoIntent"]+config+"*.npy"))
# print(glob.glob("data/"+labels["PredIntent"]+config+"*.npy"))
print(glob.glob("data/" + labels["Intent"]+config+"*.npy"))
for key, val in labels.items():
for config in configs:
fnames = glob.glob("data/" + val + config + "*.npy")
data = []
for fname in fnames:
data.append(np.load(fname)[:13392])
data = | np.array(data) | numpy.array |
#!/usr/bin/env python
"""
Perform the Mann-Whitney U test, the Kolmogorov-Smirnov test, and the Student's
t-test for the following ensembles:
- GPU double precision (reference & control)
- CPU double precision
- GPU single precision
- GPU double precision with additional explicit diffusion
Make sure to compile the cpp files for the Mann-Whitney U test and the
Kolmogorov-Smirnov test first before running this script (see mannwhitneyu.cpp
and kolmogorov_smirnov.cpp).
Copyright (c) 2021 ETH Zurich, <NAME>
MIT License
"""
import numpy as np
import xarray as xr
import pickle
import mannwhitneyu as mwu
import kolmogorov_smirnov as ks
rpert = 'e4' # prefix
n_runs = 50 # total number of runs
n_sel = 100 # how many times we randomly select runs
alpha = 0.05 # significance level
nm = 20 # members per ensemble
u_crit = 127 # nm = 20
t_crit = 2.024 # nm = 20
replace = False # to bootstrap or not to bootstrap
nbins = 100 # Kolmogorov-Smirnov
# Some arrays to make life easier
tests = ['mwu', 'ks', 't']
comparisons = ['c', 'cpu', 'sp', 'diff']
# Variable
variables = ['t_850hPa', 'fi_500hPa', 'u_10m', 't_2m', 'precip', 'asob_t',
'athb_t', 'ps']
path_gpu = '../data/10d_gpu_cpu_sp_diff/gpu_dycore/'
path_cpu = '../data/10d_gpu_cpu_sp_diff/cpu_nodycore/'
path_gpu_sp = '../data/10d_gpu_cpu_sp_diff/gpu_dycore_sp/'
path_gpu_diff = '../data/10d_gpu_cpu_sp_diff/gpu_dycore_diff/'
# Final rejection rates
rej_rates = {}
for comp in comparisons:
rej_rates[comp] = {}
for vname in variables:
rej_rates[comp][vname] = {}
runs_r = {}
runs_c = {}
runs_cpu = {}
runs_sp = {}
runs_diff = {}
# Load data for gpu (reference and control) and cpu
for i in range(n_runs):
i_str_r = str(i).zfill(4)
i_str_c = str(i+n_runs).zfill(4)
fname_r = path_gpu + rpert + '_' + i_str_r + '.nc'
fname_c = path_gpu + rpert + '_' + i_str_c + '.nc'
fname_cpu = path_cpu + rpert + '_' + i_str_r + '.nc'
fname_sp = path_gpu_sp + rpert + '_' + i_str_r + '.nc'
fname_diff = path_gpu_diff + rpert + '_' + i_str_r + '.nc'
runs_r[i] = {}
runs_c[i] = {}
runs_cpu[i] = {}
runs_sp[i] = {}
runs_diff[i] = {}
runs_r[i]['dset'] = xr.open_dataset(fname_r)
runs_c[i]['dset'] = xr.open_dataset(fname_c)
runs_cpu[i]['dset'] = xr.open_dataset(fname_cpu)
runs_sp[i]['dset'] = xr.open_dataset(fname_sp)
runs_diff[i]['dset'] = xr.open_dataset(fname_diff)
# Test for each variable
for vname in variables:
print("----------------------------")
print("Working on " + vname + " ...")
print("----------------------------")
# initialize arrays
nt, ny, nx = runs_r[0]['dset'][vname].shape
values_r = np.zeros((nt, ny, nx, nm))
values_c = np.zeros((nt, ny, nx, nm))
values_cpu = np.zeros((nt, ny, nx, nm))
values_sp = np.zeros((nt, ny, nx, nm))
values_diff = np.zeros((nt, ny, nx, nm))
# For the results
results = {}
for test in tests:
results[test] = {}
for comp in comparisons:
results[test][comp] = np.zeros((n_sel, nt))
# Do test multiple times with random selection of ensemble members
for s in range(n_sel):
if ((s+1) % 10 == 0):
print(str(s+1) + " / " + str(n_sel))
# Pick random samples for comparison
idxs_r = np.random.choice(np.arange(n_runs), nm, replace=replace)
idxs_c = np.random.choice(np.arange(n_runs), nm, replace=replace)
idxs_cpu = np.random.choice(np.arange(n_runs), nm, replace=replace)
idxs_sp = np.random.choice(np.arange(n_runs), nm, replace=replace)
idxs_diff = np.random.choice(np.arange(n_runs), nm, replace=replace)
# ============================================================
# Mann-Whitney U test
# ============================================================
test = 'mwu'
# Put together arrays
for i in range(nm):
values_r[:,:,:,i] = runs_r[idxs_r[i]]['dset'][vname].values
values_c[:,:,:,i] = runs_c[idxs_c[i]]['dset'][vname].values
values_cpu[:,:,:,i] = runs_cpu[idxs_cpu[i]]['dset'][vname].values
values_sp[:,:,:,i] = runs_sp[idxs_sp[i]]['dset'][vname].values
values_diff[:,:,:,i] = runs_diff[idxs_diff[i]]['dset'][vname].values
# Call test
reject_c = mwu.mwu(values_r, values_c, u_crit)
reject_cpu = mwu.mwu(values_r, values_cpu, u_crit)
reject_sp = mwu.mwu(values_r, values_sp, u_crit)
reject_diff = mwu.mwu(values_r, values_diff, u_crit)
results[test]['c'][s] = np.mean(reject_c, axis=(1,2))
results[test]['cpu'][s] = np.mean(reject_cpu, axis=(1,2))
results[test]['sp'][s] = np.mean(reject_sp, axis=(1,2))
results[test]['diff'][s] = np.mean(reject_diff, axis=(1,2))
# ============================================================
# Kolmogorov-Smirnov test
# ============================================================
test = 'ks'
# Call test
reject_c = ks.ks(values_r, values_c, nbins)
reject_cpu = ks.ks(values_r, values_cpu, nbins)
reject_sp = ks.ks(values_r, values_sp, nbins)
reject_diff = ks.ks(values_r, values_diff, nbins)
results[test]['c'][s] = np.mean(reject_c, axis=(1,2))
results[test]['cpu'][s] = np.mean(reject_cpu, axis=(1,2))
results[test]['sp'][s] = np.mean(reject_sp, axis=(1,2))
results[test]['diff'][s] = np.mean(reject_diff, axis=(1,2))
# ============================================================
# Student's t-test
# ============================================================
test = 't'
# Means
mean_r = np.mean(values_r, axis=-1)
mean_c = np.mean(values_c, axis=-1)
mean_cpu = np.mean(values_cpu, axis=-1)
mean_sp = np.mean(values_sp, axis=-1)
mean_diff = | np.mean(values_diff, axis=-1) | numpy.mean |
"""
data_utils.py
Collection of functions for dealing with data for plotting.
Author: <NAME>
Date: 01/27/2020
"""
from __future__ import absolute_import, division, print_function
import os
import arviz as az
import numpy as np
import tensorflow as tf
import pandas as pd
import xarray as xr
from dataclasses import dataclass
import seaborn as sns
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
from typing import Dict
from pathlib import Path
import utils.file_io as io
from utils.file_io import timeit
from lattice.utils import u1_plaq_exact
from utils.attr_dict import AttrDict
# from plotters.plot_utils import get_matching_log_dirs
# from plotters.plot_observables import get_obs_dict, grid_plot
mpl.style.use('fast')
sns.set_palette('bright')
TLS_DEFAULT = mpl.rcParams['xtick.labelsize']
@dataclass
class RunParams:
hmc: bool
run_dir: str
eps: float
beta: float
run_steps: int
plaq_weight: float
charge_weight: float
num_steps: int
x_shape: tuple
input_shape: tuple
def __post__init__(self):
self.traj_len = self.num_steps * self.eps
@dataclass
class ChargeData:
q: tf.Tensor
dq: tf.Tensor
params: RunParams
# pylint:disable=invalid-name
def filter_dict(d, cond, key=None):
if key is not None:
val = d[key]
if isinstance(val, dict):
return {
k: v for k, v in val.items() if cond
}
raise ValueError('If passing a key, d[key] must be a dict.')
return {
k: v for k, v in d.items() if cond
}
def _look(p, s, conds=None):
print(f'Looking in {p}...')
matches = [x for x in Path(p).rglob(f'*{s}*')]
if conds is not None:
if isinstance(conds, (list, tuple)):
for cond in conds:
matches = [x for x in matches if cond(x)]
else:
matches = [x for x in matches if cond(x)]
return matches
def _get_dirs(paths, hmc=False):
def _look(p, s, conds=None):
print(f'Looking in {p}...')
matches = [x for x in Path(p).rglob(f'*{s}*')]
if conds is not None:
if isinstance(conds, (list, tuple)):
for cond in conds:
matches = [x for x in matches if cond(x)]
else:
matches = [x for x in matches if cond(x)]
return matches
dirs = []
if hmc:
search_str = 'HMC_L16_b'
conds = (
lambda x: 'hmc_logs' in str(x),
lambda x: 'hmc' in str(x).lower()
)
else:
search_str = 'L16_b2048'
conds = (
lambda x: 'GaugeModel_logs' in (str(x)),
lambda x: 'HMC_' not in str(x),
lambda x: Path(x).is_dir(),
)
if isinstance(paths, (list, tuple)):
for path in paths:
dirs += _look(path, search_str, conds)
else:
dirs = _look(paths, search_str, conds)
return dirs
def load_from_dir(d, fnames=None):
if fnames is None:
fnames = {
'dq': 'dq.z',
'charges': 'charges.z',
'run_params': 'run_params.z'
}
darr = [x for x in Path(d).iterdir() if x.is_dir()]
for rd in darr:
files = {k: sorted(rd.glob(f'*{v}*')) for k, v in fnames.items()}
data = {k: io.loadz(v) for k, v in files.items()}
return data
def load_charge_data(dirs, hmc=False):
data = {}
for d in dirs:
print(f'Looking in dir: {d}...')
if 'inference_hmc' in str(d):
print(f'Skipping {str(d)}...')
continue
dqfile = sorted(d.rglob('dq.z'))
qfile = sorted(d.rglob('charges.z'))
rpfile = sorted(d.rglob('run_params.z'))
num_runs = len(dqfile)
if num_runs > 0:
for dqf, qf, rpf in zip(dqfile, qfile, rpfile):
params = io.loadz(rpf)
if 'xeps' and 'veps' in params.keys():
xeps = np.array([i.numpy() for i in params['xeps']])
veps = np.array([i.numpy() for i in params['veps']])
eps = (np.mean(xeps) + np.mean(veps)) / 2.
elif 'eps' in params.keys():
eps = params['eps']
params['eps'] = eps
params = RunParams(**params)
qarr = io.loadz(qf)
dqarr = io.loadz(dqf)
print(
'...loading data for (beta, num_steps, eps): '
f'({params.beta}, {params.num_steps}, {params.eps:.3g})'
)
charge_data = ChargeData(q=qarr, dq=dqarr, params=params)
try:
data[params.beta].update({params.traj_len: charge_data})
except KeyError:
data[params.beta] = {params.traj_len: charge_data}
# def _update_dict(beta, z, qdata):
# try:
# z[beta].update({params.traj_len: qdata})
# except KeyError:
# z[beta] = {params.traj_len: qdata}
#
# return z
#
# data = _update_dict(params.beta, data, charge_data)
return data
def calc_tau_int(data, therm_frac=0.2):
"""Calculate the integrated autocorrelation time."""
tau_int = {}
for key, val in data.items():
tau_int[key] = {}
for k, v in val.items():
arr, _ = therm_arr(v, therm_frac=therm_frac)
arr = arr.T
pass
# reference:
# https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md
# ----------
# Problem:
# 100. Compute bootstrapped 95% confidence intervals for the mean of a 1D
# array X (i.e., resample the elements of an array with replacement N times,
# compute the mean of each sample, and then compute percentiles over the
# means).
def bootstrapped_confidence_interval(x: np.ndarray, N: int = 1000):
idx = np.random.randint(0, x.size, (N, x.size))
means = x[idx].mean(axis=1)
confint = np.percentile(means, [2.5, 97.5])
return confint
# Reference: https://dfm.io/posts/autocorr/
def next_pow_two(n):
i = 1
while i < n:
i = i << 1
return i
def autocorr_func_1d(x, norm=True):
"""Compute the autocorrelation function of a 1D chain."""
x = np.atleast_1d(x)
if len(x.shape) != 1:
raise ValueError('Invalid dimensions for 1D autocorrelation function.')
n = next_pow_two(len(x))
# Compute the FFT and then (from that) the auto-correlation function
f = np.fft.fft(x - np.mean(x), n=2*n)
acf = np.fft.ifft(f * np.conjugate(f))[:len(x)].real
acf /= 4 * n
# Optionally normalize
if norm:
acf /= acf[0]
return acf
def auto_window(taus, c):
"""Automated windowing procedure following Sokal (1989)."""
m = np.arange(len(taus)) < c * taus
if np.any(m):
return np.argmin(m)
return len(taus) - 1
def autocorr_gw2010(y, c=5.0):
"""Following the suggestion from Goodman & Weare (2010)."""
f = autocorr_func_1d(np.mean(y, axis=0))
taus = 2.0 * np.cumsum(f) - 1.0
window = auto_window(taus, c)
return taus[window]
def autocorr_new(y, c=5.0):
"""New implementation of autocorrelation function."""
f = np.zeros(y.shape[1])
for yy in y:
f += autocorr_func_1d(yy)
f /= len(y)
taus = 2.0 * np.cumsum(f) - 1.0
window = auto_window(taus, c)
return taus[window]
def calc_autocorr(x):
N = np.exp(np.linspace(np.log(100), np.log(y.shape[1]), 20)).astype(int)
new = np.empty(len(N))
for i, n in enumerate(N):
new[i] = autocorr_new(y[:, :n])
return N, new
def flatten_dict(d):
"""Recursively convert all entries of `d` to be `AttrDict`."""
if not isinstance(d, AttrDict):
d = AttrDict(**d)
for key, val in d.items():
if isinstance(val, dict):
if not isinstance(val, AttrDict):
d[key] = flatten_dict(val)
else:
d[key] = AttrDict(**val)
return d
def _load_inference_data(log_dir, fnames, inference_str='inference'):
"""Helper function for loading inference data from `log_dir`."""
run_dir = os.path.join(log_dir, inference_str)
if os.path.isdir(run_dir):
data_dir = os.path.join(run_dir, 'run_data')
rp_file = os.path.join(run_dir, 'run_params.z')
if os.path.isfile(rp_file) and os.path.isdir(data_dir):
run_params = io.loadz(rp_file)
key = (run_params['beta'],
run_params['eps'],
run_params['num_steps'])
data = [
io.loadz(os.path.join(data_dir, f'{fname}.z'))
for fname in fnames
]
return key, data
def load_inference_data(dirs, search_strs, inference_str='inference'):
data = {
s: {} for s in search_strs
}
for d in dirs:
print(f'Looking in dir: {d}...')
run_dir = Path(os.path.join(d, inference_str))
if run_dir.is_dir():
run_dirs = [x for x in run_dir.iterdir() if x.is_dir()]
for rd in run_dirs:
print(f'...looking in run_dir: {rd}...')
rp_file = os.path.join(str(rd), 'run_params.z')
if os.path.isfile(rp_file):
params = io.loadz(rp_file)
beta = params['beta']
eps = params['eps']
num_steps = params['num_steps']
data_dir = os.path.join(str(rd), 'run_data')
if os.path.isdir(data_dir):
for search_str in search_strs:
dfile = os.path.join(data_dir, f'{search_str}.z')
if os.path.isfile(dfile):
_data = io.loadz(dfile)
try:
data[search_str].update({
(beta, num_steps, eps): _data
})
except KeyError:
data[search_str] = {
(beta, num_steps, eps): _data
}
return data
def _get_l2hmc_dirs(paths, search_str=None):
"""Look for `log_dirs` containing a training/inference run for L2HMC."""
if search_str is None:
search_str = '*L16_b*'
dirs = []
for path in paths:
if not isinstance(path, Path):
path = Path(os.path.abspath(path))
print(f'Looking in {path}...')
dirs += [
x for x in path.rglob(search_str)
if 'GaugeModel_logs' in str(x)
and 'HMC_' not in str(x)
and x.is_dir()
]
return dirs
def get_l2hmc_dirs():
bd_local = os.path.abspath(
'/Users/saforem2/thetaGPU/training'
)
bd_theta = os.path.abspath(
'/lus/theta-fs0/projects/DLHMC/thetaGPU/training'
)
l2hmc_dirs = []
if os.path.isdir(bd_local):
l2hmc_dirs += _get_l2hmc_dirs(bd_local)
if os.path.isdir(bd_theta):
l2hmc_dirs += _get_l2hmc_dirs(bd_theta)
return l2hmc_dirs
def get_hmc_dirs(base_dir=None):
if base_dir is None:
base_dir = os.path.abspath(
'/lus/theta-fs0/projects/DLHMC/thetaGPU/inference/'
)
if not os.path.isdir(base_dir):
base_dir = os.path.abspath(
'/Users/saforem2/thetaGPU/inference'
)
if not os.path.isdir(base_dir):
raise FileNotFoundError(f'Unable to locate {base_dir}')
base_dir = Path(base_dir)
hmc_dirs = [x for x in hmc_dir.rglob('*HMC_L16*') if x.is_dir()]
return hmc_dirs
def bootstrap(x, reps=10000):
n = len(x)
xb = np.random.choice(x, (n, reps), replace=True)
yb = xb.mean(axis=0)
upper, lower = np.percentile(yb, [2.5, 97.5])
return yb, (lower, upper)
def dq_stats(dq, reps=10000, therm_frac=0.2):
stats = {}
for key, val in dq.items():
for k, v in val.items():
data = therm_arr(v, therm_frac=therm_frac, ret_steps=False)
avgs = []
errs = []
for chain in data.T:
avg, (lower, upper) = bootstrap(chain, reps)
err = np.max([np.abs(avg - lower), np.abs(upper - avg)])
avgs.append(avg)
errs.append(err)
try:
stats[key].update({
k: {
'avg': np.mean(avgs),
'avg_std': np.std(avgs),
'err': np.mean(errs),
'err_std': np.std(errs),
'min': np.min(data),
'max': np.max(data),
}
})
except KeyError:
stats[key] = {
k: {
'avg': np.mean(avgs),
'avg_std': np.std(avgs),
'err': np.mean(errs),
'err_std': np.std(errs),
'min': np.min(data),
'max': np.max(data),
},
}
return stats
def autocorrelation_time(x, s, mu, var):
"""Compute the autocorrelation time."""
b, t, d = x.shape
act_ = np.zeros([d])
for i in range(b):
y = x[i] - mu
p, n = y[:-s], y[s:]
act_ += np.mean(p * n, axis=0) / var
act_ /= b
return act_
def effective_sample_size(x, mu, var):
# batch_size, time, dimension
b, t, d = x.shape
ess_ = np.ones([d])
for s in range(1, t):
p = autocorrelation_time(x, s, mu, var)
if np.sum(p > 0.05) == 0:
break
else:
for j in range(d):
if p[j] > 0.05:
ess_[j] += 2. * p[j] * (1. - float(s) / t)
return t / ess_
def batch_means_ess(x):
"""Estimate the ESS.
We estimate the ESS as the ratio of the variance of the batch means to the
variance of the chain, [ref](https://arxiv.org/pdf/1011.0175.pdf).
NOTE: `x` should be a chain with shape: [time_steps, num_chains, dim].
"""
x = np.transpose(x, [1, 0, 2])
T, M, D = x.shape
num_batches = int(np.floor(T ** (1 / 3)))
batch_size = int(np.floor(num_batches ** 2))
batch_means = []
for i in range(num_batches):
batch = x[batch_size * i:batch_size * i + batch_size]
batch_means.append(np.mean(batch, axis=0))
batch_variance = np.var(np.array(batch_means), axis=0)
chain_variance = np.var(x, axis=0)
act = batch_size * batch_variance / (chain_variance + 1e-20)
return 1. / act
def _calc_var_explained(x):
"""Calculate the % variance explained by the singular values of `x`."""
_, s, _ = np.linalg.svd(x, full_matrices=True)
return s ** 2 / np.sum(s ** 2)
def calc_var_explained(weights_dict):
"""Calculate the % variance explained by the sv's for each weight mtx."""
xweights = weights_dict['xnet']
vweights = weights_dict['vnet']
var_explained = {}
for ((xk, xv), (vk, vv)) in zip(xweights.items(), vweights.items()):
xk_ = f'xnet_{xk}'
vk_ = f'vnet_{vk}'
var_explained[xk_] = _calc_var_explained(xv)
var_explained[vk_] = _calc_var_explained(vv)
return var_explained
def bootstrap_old(data, n_boot=10000, ci=68):
"""Bootstrap resampling.
Returns:
mean (float): Mean of the (bootstrap) resampled data.
err (float): Standard deviation of the (bootstrap) resampled data.
data_rs (np.ndarray): Boostrap resampled data.
"""
if not isinstance(data, np.ndarray):
data = np.array(data)
step_axis = np.argmax(data.shape)
samples = []
for _ in range(int(n_boot)):
resampler = np.random.randint(0,
data.shape[step_axis],
data.shape[step_axis])
sample = data.take(resampler, axis=step_axis)
samples.append(np.mean(sample, axis=step_axis))
data_rs = np.array(samples)
mean = np.mean(data_rs)
err = np.std(data_rs)
return mean, err, data_rs
def calc_tunneling_rate(charges):
"""Calculate the tunneling rate as Q_{i+1} - Q_{i}."""
if not isinstance(charges, np.ndarray):
charges = np.array(charges)
charges = charges.T if charges.shape[0] > charges.shape[1] else charges
charges = | np.around(charges) | numpy.around |
from os import path, mkdir, listdir
import numpy as np
np.random.seed(1)
import random
random.seed(1)
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
tf.set_random_seed(1)
import timeit
import cv2
from models import get_densenet121_unet_softmax
from tqdm import tqdm
import argparse, logging
test_folder = path.join('..', 'data_test')
models_folder = 'nn_models'
test_pred = path.join('..', 'predictions', 'densenet_test_pred_2')
all_ids = []
all_images = []
all_masks = []
def preprocess_inputs(x):
x = np.asarray(x, dtype='float32')
x /= 127.5
x -= 1.
return x
def bgr_to_lab(img):
lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(17, 17))
lab = clahe.apply(lab[:, :, 0])
if lab.mean() > 127:
lab = 255 - lab
return lab[..., np.newaxis]
#def load_image(path):
# bf = bfio.BioReader(path)
# image = bf.read_image()
# image=image[:,:,0,:,0]
# if image.shape[2] == 3:
# return image
# elif image.shape[2]==1:
# return np.dstack((image[:,:,0], image[:,:,0],image[:,:,0]))
def factors(n):
# Modified from https://stackoverflow.com/a/6909532
f = [1,1]
for i in range(1,int(n**0.5)+1):
if n % i == 0:
f = [i,n//i]
return f
if __name__ == '__main__':
# intialize logging
logging.basicConfig(format='%(asctime)s - %(name)-8s - %(levelname)-8s - %(message)s',
datefmt='%d-%b-%y %H:%M:%S')
logger = logging.getLogger("main")
logger.setLevel(logging.INFO)
# setup arguement parsing
parser = argparse.ArgumentParser(prog='predict_densenet')
parser.add_argument('--num_tiles', dest='num_tiles', type=int, required=True)
# parse the arguments
args = parser.parse_args()
num_tiles = args.num_tiles
t0 = timeit.default_timer()
if not path.isdir(test_pred):
mkdir(test_pred)
models = []
logger.info('Loading densenet models...')
for it in range(4):
model = get_densenet121_unet_softmax((None, None), weights=None)
model.load_weights(path.join(models_folder, 'densenet_weights_{0}.h5'.format(it)))
models.append(model)
#print('Predicting test')
for d in tqdm(listdir(test_folder)):
logger.info('Predicting image: {}'.format(d))
fid = d
full_img = cv2.imread(path.join(test_folder, fid), cv2.IMREAD_COLOR)
if num_tiles == None:
num_tiles = 1
f = factors(num_tiles)
X_TILE_SIZE = 512 * f[1]
Y_TILE_SIZE = 512 * f[0]
predicted = | np.zeros((full_img.shape[0], full_img.shape[1], 3), dtype='uint8') | numpy.zeros |
import argparse
import numpy as np
import pandas as pd
from Bio import SearchIO, SeqIO
from pathlib import Path
"""
calculate identity, positive, and coverage considering missing residues
"""
def calc_coverage_from_pir(pir_file):
query_record, template_record = SeqIO.parse(pir_file, 'pir')
query_seq, template_seq = query_record.seq, template_record.seq
template_not_gap_indices = np.where( | np.array(template_seq) | numpy.array |
import sys
import open3d
import numpy as np
import time
import os
from geometric_registration.utils import get_pcd, get_keypts, get_desc, loadlog
import cv2
from functools import partial
def build_correspondence(source_desc, target_desc):
"""
Find the mutually closest point pairs in feature space.
source and target are descriptor for 2 point cloud key points. [5000, 32]
"""
distance = np.sqrt(2 - 2 * (source_desc @ target_desc.T))
source_idx = np.argmin(distance, axis=1)
source_dis = | np.min(distance, axis=1) | numpy.min |
from collections import OrderedDict
import numpy as np
import matplotlib as mpl
mpl.rcParams['hatch.linewidth']=2.0
import matplotlib.pyplot as plt
fs=25
plt.rc('xtick',labelsize=int(fs*.8))
plt.rc('ytick',labelsize=int(fs*.8))
import ROOT as rt
from ROOT import TH1F,TColor
import os
# FIXME SetYTitle
class BinaryClassifierResponse(object):
def __init__(self,
name,
title,
directory,
pt):
f=np.load("jj25{}.npz".format(pt))
self.bdt=f["bdtset"]
#cmult,nmult,ptd,axis1,axis2,
#cmult,nmult,ptd,axis1,axis2,
#dr,pt/pt,mult/mult
self.eve=f["eveset"]
self.pairlist=f["pairlist"]
self._name = name
self._title = title
self._path = os.path.join(directory, name + ".{ext}")
def append(self, pt,var):
res=30
maxv=self.bdt[:,var].max()
if(maxv<self.bdt[:,var].max()):
maxv=self.bdt[:,var].max()
print(pt)
if(pt==100):maxpt=175
if(pt==200):maxpt=357
if(pt==500):maxpt=874
if(pt==1000):maxpt=1750
if(pt==100):
ptmin=0.815*pt
ptmax=1.159*pt
if(pt==200):
ptmin=0.819*pt
ptmax=1.123*pt
if(pt==500):
ptmin=0.821*pt
ptmax=1.093*pt
if(pt==1000):
ptmin=0.8235*pt
ptmax=1.076*pt
if(var=="eta"):
#q1hist=rt.TH1F("q1hist","pp#rightarrowqq", res, -1,1)
#q2hist=rt.TH1F("q2hist","Z+jet", res, -1,1)
#g1hist=rt.TH1F("g1hist","dijet", res, -1,1)
#g2hist=rt.TH1F("g2hist","Z+jet", res, -1,1)
q1hist=rt.TH1F("q1hist","pp#rightarrowqq", res, -2.4,2.4)
q2hist=rt.TH1F("q2hist","Z+jet", res, -2.4,2.4)
g1hist=rt.TH1F("g1hist","dijet", res, -2.4,2.4)
g2hist=rt.TH1F("g2hist","Z+jet", res, -2.4,2.4)
elif(var=="pt"):
q1hist=rt.TH1F("q1hist","dijet", res, 0, maxpt)
q2hist=rt.TH1F("q2hist","Z+jet", res, 0, maxpt)
g1hist=rt.TH1F("g1hist","dijet", res, 0, maxpt)
g2hist=rt.TH1F("g2hist","Z+jet", res, 0, maxpt)
else:
maxv=int(0.8*maxv)
vb=int(maxv)
#if(pt==500 or pt==1000):vb=int(vb/2)
#vb=res
print("max",maxv)
q1hist=rt.TH1F("q1hist","dijet", vb,0, maxv)
q2hist=rt.TH1F("q2hist","Z+jet", vb,0, maxv)
g1hist=rt.TH1F("g1hist","dijet", vb,0, maxv)
g2hist=rt.TH1F("g2hist","Z+jet", vb,0, maxv)
res=int(vb)
for k in range(len(self.bdt)):
pair=np.argmax(self.eve[k])
pair=self.pairlist[np.argmax(self.eve[k])]
"""if(pair==0):
q1hist.Fill(self.bdt[k][var])
if(pair==1):
q2hist.Fill(self.bdt[k][var])
if(pair==2):
g1hist.Fill(self.bdt[k][var])
if(pair==3):
g2hist.Fill(self.bdt[k][var])"""
if(pair[0]=="q"):
q1hist.Fill(self.bdt[k][0])
if(pair[1]=="q"):
q2hist.Fill(self.bdt[k][5])
if(pair[0]=="g"):
g1hist.Fill(self.bdt[k][0])
if(pair[1]=="g"):
g2hist.Fill(self.bdt[k][5])
q1hist.Scale(1.0 / q1hist.Integral())
#q2hist.Scale(1.0 / q2hist.Integral())
g1hist.Scale(1.0 / g1hist.Integral())
#g2hist.Scale(1.0 / g2hist.Integral())
q1hist.Draw("hist")
q1=[]
q2=[]
g1=[]
g2=[]
for i in range(res):
q1.append(q1hist.GetBinContent(i+1))
q2.append(q2hist.GetBinContent(i+1))
g1.append(g1hist.GetBinContent(i+1))
g2.append(g2hist.GetBinContent(i+1))
print(g2hist.GetEntries())
fs=25
plt.figure(figsize=(12,8))
plt.title("jet $p_T$ range {}~{} GeV".format(pt,int(pt*1.1)),fontdict={"weight":"bold","size":fs*1.})
plt.ylabel("Fraction of Events",fontsize=fs*1.3)
if(var=='eta'):
xax=np.append(np.arange(-2.4,2.4,((-q1hist.GetBinLowEdge(0)+q1hist.GetBinLowEdge(res))/res))[:res],2.4)
plt.xlabel("jet $\eta$",fontsize=fs*1.3)
plt.fill_between(xax,np.append(q1,0),alpha=0.6,linewidth=2,facecolor='azure',edgecolor='C0',label=r"pp$\rightarrow$qq",step='post')
plt.plot(xax,np.append(q1,0),color='C0',alpha=0.5,drawstyle='steps-post',linewidth=2)
plt.plot(xax,np.append(q2,0),label=r"pp$\rightarrow$q2",color='blue',drawstyle='steps-post',linewidth=3)
plt.fill_between(xax,np.append(g1,0),alpha=0.3,linewidth=2,linestyle='--',facecolor="#ffcfdc",edgecolor='C1',label=r"pp$\rightarrow$gg",step='post')
#plt.plot(xax,np.append(g1,0),label=r"pp$\rightarrow$gg",color='C1',drawstyle='steps-post',linewidth=3,linestyle='--',alpha=0.6)
plt.plot(xax,np.append(g2,0),label=r"pp$\rightarrow$g2",color='red',drawstyle='steps-post',linewidth=3,linestyle='--')
else:
#if("chad" in var):plt.xlabel("Charged Particle Multiplicity",fontsize=fs*1.)
#elif("ptd" in var):plt.xlabel("jet $p_TD$",fontsize=fs*1.3)
#elif("axis" in var):plt.xlabel("jet {}".format(var),fontsize=fs*1.3)
#else:plt.xlabel("jet $p_T$(GeV)",fontsize=fs*1.3)
q1=np.concatenate([[0],q1])
q2=np.concatenate([[0],q2])
g1= | np.concatenate([[0],g1]) | numpy.concatenate |
import time
import cv2
import numpy as np
import json
import tensorflow as tf
from scipy.spatial import distance as dist
from shapely.geometry import Point
from shapely.geometry.polygon import Polygon
from .model.yolo import Yolo
with open("config.json", "r") as file:
config = json.load(file)
class YoloSocialDistance:
def __init__(self, tiny=False):
self.__class_names = {0: "person"}
self.__show_masks = config["showMasks"]
self.__show_fps = config["showFPS"]
self.__show_scores = config["showScores"]
self.__score_threshold = config["scoreThreshold"]
self.__iou_threshold = config["iouThreshold"]
self.__write_detection = config["writeDetection"]
self.__min_distance = 0
print("[INFO]: Building model")
model = Yolo(80, tiny)
print("[INFO]: Model built succesfully")
print("[INFO]: Loading detector weights")
model.load_weights(config["weightsPath"])
print("[INFO]: Detector weights loaded")
self.pedestrian_detector = model.get_graph()
def detect_from_image(self, image_path):
self.__pixel_to_meter()
self.__get_perspecive_points()
frame = cv2.imread(image_path)
if frame is None:
print("\n[WARNING]: Please enter a valid image path")
return
self.__detect_frame(frame)
if self.__write_detection:
cv2.imwrite("prediction.jpg", frame)
if not config["dontShow"]:
cv2.imshow("Image", frame)
key = cv2.waitKey(0)
if key == ord("q"):
cv2.destroyAllWindows()
def detect_from_video(self, src=0):
self.__pixel_to_meter()
self.__get_perspecive_points()
cap = cv2.VideoCapture(src, cv2.CAP_ANY)
avg_fps = []
if self.__write_detection:
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = int(cap.get(cv2.CAP_PROP_FPS))
output = cv2.VideoWriter(
filename="prediction.avi",
apiPreference=cv2.CAP_ANY,
fourcc=cv2.VideoWriter_fourcc("M", "J", "P", "G"),
fps=fps,
frameSize=(width, height),
)
while True:
prev_time = time.time()
retval, frame = cap.read(0)
if not retval:
print("Can't receive frame (stream end?). Exiting ...")
break
self.__detect_frame(frame)
pts = np.array(
[
self.__circles[0],
self.__circles[1],
self.__circles[3],
self.__circles[2],
],
np.int32,
)
pts = pts.reshape((-1, 1, 2))
cv2.polylines(frame, [pts], True, (0, 255, 255))
if not config["dontShow"]:
cv2.imshow("Frame", frame)
if cv2.waitKey(1) & 0xFF == ord("q"):
break
if self.__show_fps:
fps = int(1 / (time.time() - prev_time))
avg_fps.append(fps)
print("FPS: {}".format(fps))
if self.__write_detection:
output.write(frame)
cap.release()
cv2.destroyAllWindows()
if len(avg_fps) != 0:
avg_fps = sum(avg_fps) / len(avg_fps)
print(f"[INFO]: Average FPS: {avg_fps}")
def __detect_frame(self, frame):
image_data = frame.copy()
image_data = cv2.cvtColor(image_data, cv2.COLOR_BGR2RGB)
image_data = cv2.resize(image_data, (416, 416))
image_data = image_data / 255.0
image_data = image_data.astype("float32")
image_data = np.expand_dims(image_data, axis=0)
image_data = tf.constant(image_data)
prediction = self.pedestrian_detector(image_data)
boxes = prediction[0, :, 0:4]
pred_conf = prediction[0, :, 4:]
boxes = | np.reshape(boxes, (1, boxes.shape[0], boxes.shape[1])) | numpy.reshape |
import numpy as np
def check_uv(u, v):
"""
Returns weightings for frequencies u and v
for anisotropic surfaces
"""
if abs(u) + abs(v) == 0:
return 4.
elif u * v == 0:
return 2.
return 1.
vcheck = np.vectorize(check_uv)
def wave_function(x, u, Lx):
"""
Wave in Fourier sum
"""
coeff = 2 * np.pi / Lx
if u >= 0:
return np.cos(coeff * u * x)
return np.sin(coeff * abs(u) * x)
def d_wave_function(x, u, Lx):
"""
First derivative of wave in Fourier sum wrt x
"""
coeff = 2 * np.pi / Lx
if u >= 0:
return - coeff * u * np.sin(coeff * u * x)
return coeff * abs(u) * np.cos(coeff * abs(u) * x)
def dd_wave_function(x, u, Lx):
"""
Second derivative of wave in Fouier sum wrt x
"""
coeff = 2 * np.pi / Lx
return - coeff ** 2 * u ** 2 * wave_function(x, u, Lx)
def cos_sin_indices(u_array):
"""Return indices of wave function arrays for
both cos and sin functions"""
cos_indices = np.argwhere(u_array >= 0)
sin_indices = | np.argwhere(u_array < 0) | numpy.argwhere |
import os
import random
from collections import namedtuple
import numpy as np
from tqdm import tqdm
import gym
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data._utils import collate
import wandb
def set_all_seeds(seed):
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
class ReplayBuffer:
def __init__(
self, replay_size, batch_size, device, observation_space, action_space
):
self.replay_size = replay_size
self.batch_size = batch_size
self.device = device
self.index = 0
self.full = False
self.states = np.empty((replay_size, observation_space), dtype=np.float32)
self.next_states = np.empty((replay_size, observation_space), dtype=np.float32)
self.actions = np.empty((replay_size, 1), dtype=np.int)
self.rewards = np.empty((replay_size, 1), dtype=np.float32)
self.dones = np.empty((replay_size, 1), dtype=np.float32)
def add(self, obs, action, reward, next_obs, done):
np.copyto(self.states[self.index], obs)
np.copyto(self.actions[self.index], action)
np.copyto(self.rewards[self.index], reward)
np.copyto(self.next_states[self.index], next_obs)
np.copyto(self.dones[self.index], float(done))
self.index = (self.index + 1) % self.replay_size
self.full = self.full or self.index == 0
def sample(self):
idxs = np.random.randint(
0, self.replay_size if self.full else self.index, size=self.batch_size
)
states = torch.as_tensor(self.states[idxs], device=self.device).float()
actions = torch.as_tensor(self.actions[idxs], device=self.device)
rewards = (
torch.as_tensor(self.rewards[idxs], device=self.device).squeeze().float()
)
next_states = torch.as_tensor(
self.next_states[idxs], device=self.device
).float()
dones = torch.as_tensor(self.dones[idxs], device=self.device).squeeze().float()
return states, actions, rewards, next_states, dones
class MLP(nn.Module):
def __init__(self, observation_space, action_space):
super(MLP, self).__init__()
self.fc1 = nn.Linear(observation_space, 64)
self.fc2 = nn.Linear(64, 32)
self.fc3 = nn.Linear(32, action_space)
def forward(self, x):
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
class DQN:
def __init__(
self,
env,
rbuffer,
value,
target,
optimizer,
device,
eps_start,
eps_decay,
eps_end,
totalnum_iterations,
gamma,
update_target,
):
self.eps_start = eps_start
self.eps_decay = eps_decay
self.eps_end = eps_end
self.epsilon = max(self.eps_start * self.eps_decay, self.eps_end)
self.batch_size = batch_size
self.env = env
self.rbuffer = rbuffer
self.value = value
self.target = target
self.optimizer = optimizer
self.device = device
self.totalnum_iterations = totalnum_iterations
self.gamma = gamma
self.update_target = update_target
self.loss_fn = torch.nn.MSELoss()
@torch.no_grad()
def get_action(self, obs):
if np.random.rand() < self.epsilon:
return env.action_space.sample()
else:
obs = torch.from_numpy(obs).float().unsqueeze(0).to(self.device)
return torch.argmax(self.value(obs)).item()
def train(self):
for episode in tqdm(range(0, self.totalnum_iterations)):
obs = env.reset()
done = False
episode_reward = 0
while not done:
action = self.get_action(obs)
new_obs, reward, done, _ = env.step(action)
self.rbuffer.add(obs, action, reward, new_obs, done)
episode_reward += reward
obs = new_obs
if self.rbuffer.index > self.batch_size:
states, actions, rewards, next_states, dones = self.rbuffer.sample()
next_qs = dones * rewards + (1 - dones) * (
rewards
+ self.gamma * self.target(next_states).detach().max(dim=1).values
)
current_qs = torch.gather(self.value(states), 1, actions).squeeze()
loss = self.loss_fn(current_qs, next_qs)
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
self.epsilon = max(self.epsilon * self.eps_decay, self.eps_end)
wandb.log(
{
"Episode reward": episode_reward,
"Epsilon": self.epsilon,
"Loss": loss,
},
step=episode,
)
if episode % self.update_target == 0:
self.target.load_state_dict(self.value.state_dict())
def evaluate(self):
episode_rewards = []
for episode in range(10):
obs = self.env.reset()
done = False
episode_reward = 0
while not done:
action = self.get_action(obs)
new_obs, reward, done, _ = self.env.step(action)
self.env.render()
episode_reward += reward
obs = new_obs
episode_rewards.append(episode_reward)
print("Average episodes (10): ", np.mean(episode_rewards))
seed = | np.random.randint(1000) | numpy.random.randint |
from __future__ import absolute_import, division, print_function
from collections import Iterable, defaultdict, deque
from functools import reduce
import numbers
import operator
import numpy as np
import scipy.sparse
try: # Windows compatibility
int = long
except NameError:
pass
class COO(object):
""" A Sparse Multidimensional Array
This is stored in COO format. It depends on NumPy and Scipy.sparse for
computation, but supports arrays of arbitrary dimension.
Parameters
----------
coords: np.ndarray (ndim, nnz)
An array holding the index locations of every value
Should have shape (number of dimensions, number of non-zeros)
data: np.array (nnz,)
An array of Values
shape: tuple (ndim,), optional
The shape of the array
Examples
--------
>>> x = np.eye(4)
>>> x[2, 3] = 5
>>> s = COO(x)
>>> s
<COO: shape=(4, 4), dtype=float64, nnz=5, sorted=True, duplicates=False>
>>> s.data
array([ 1., 1., 1., 5., 1.])
>>> s.coords
array([[0, 1, 2, 2, 3],
[0, 1, 2, 3, 3]], dtype=uint8)
>>> s.dot(s.T).sum(axis=0).todense()
array([ 1., 1., 31., 6.])
Make a sparse array by passing in an array of coordinates and an array of
values.
>>> coords = [[0, 0, 0, 1, 1],
... [0, 1, 2, 0, 3],
... [0, 3, 2, 0, 1]]
>>> data = [1, 2, 3, 4, 5]
>>> y = COO(coords, data, shape=(3, 4, 5))
>>> y
<COO: shape=(3, 4, 5), dtype=int64, nnz=5, sorted=False, duplicates=True>
>>> tensordot(s, y, axes=(0, 1))
<COO: shape=(4, 3, 5), dtype=float64, nnz=6, sorted=False, duplicates=False>
Following scipy.sparse conventions you can also pass these as a tuple with
rows and columns
>>> rows = [0, 1, 2, 3, 4]
>>> cols = [0, 0, 0, 1, 1]
>>> data = [10, 20, 30, 40, 50]
>>> z = COO((data, (rows, cols)))
>>> z.todense()
array([[10, 0],
[20, 0],
[30, 0],
[ 0, 40],
[ 0, 50]])
You can also pass a dictionary or iterable of index/value pairs. Repeated
indices imply summation:
>>> d = {(0, 0, 0): 1, (1, 2, 3): 2, (1, 1, 0): 3}
>>> COO(d)
<COO: shape=(2, 3, 4), dtype=int64, nnz=3, sorted=False, duplicates=False>
>>> L = [((0, 0), 1),
... ((1, 1), 2),
... ((0, 0), 3)]
>>> COO(L).todense()
array([[4, 0],
[0, 2]])
See Also
--------
COO.from_numpy
COO.from_scipy_sparse
"""
__array_priority__ = 12
def __init__(self, coords, data=None, shape=None, has_duplicates=True,
sorted=False, cache=False):
self._cache = None
if cache:
self.enable_caching()
if data is None:
# {(i, j, k): x, (i, j, k): y, ...}
if isinstance(coords, dict):
coords = list(coords.items())
has_duplicates = False
if isinstance(coords, np.ndarray):
result = COO.from_numpy(coords)
self.coords = result.coords
self.data = result.data
self.has_duplicates = result.has_duplicates
self.sorted = result.sorted
self.shape = result.shape
return
# []
if not coords:
data = []
coords = []
# [((i, j, k), value), (i, j, k), value), ...]
elif isinstance(coords[0][0], Iterable):
if coords:
assert len(coords[0]) == 2
data = [x[1] for x in coords]
coords = [x[0] for x in coords]
coords = np.asarray(coords).T
# (data, (row, col, slab, ...))
else:
data = coords[0]
coords = np.stack(coords[1], axis=0)
self.data = np.asarray(data)
self.coords = np.asarray(coords)
if self.coords.ndim == 1:
self.coords = self.coords[None, :]
if shape and not np.prod(self.coords.shape):
self.coords = np.zeros((len(shape), 0), dtype=np.uint64)
if shape is None:
if self.coords.nbytes:
shape = tuple((self.coords.max(axis=1) + 1).tolist())
else:
shape = ()
self.shape = tuple(shape)
if self.shape:
dtype = np.min_scalar_type(max(self.shape))
else:
dtype = np.int_
self.coords = self.coords.astype(dtype)
assert not self.shape or len(data) == self.coords.shape[1]
self.has_duplicates = has_duplicates
self.sorted = sorted
def enable_caching(self):
""" Enable caching of reshape, transpose, and tocsr/csc operations
This enables efficient iterative workflows that make heavy use of
csr/csc operations, such as tensordot. This maintains a cache of
recent results of reshape and transpose so that operations like
tensordot (which uses both internally) store efficiently stored
representations for repeated use. This can significantly cut down on
computational costs in common numeric algorithms.
However, this also assumes that neither this object, nor the downstream
objects will have their data mutated.
Examples
--------
>>> x.enable_caching() # doctest: +SKIP
>>> csr1 = x.transpose((2, 0, 1)).reshape((100, 120)).tocsr() # doctest: +SKIP
>>> csr2 = x.transpose((2, 0, 1)).reshape((100, 120)).tocsr() # doctest: +SKIP
>>> csr1 is csr2 # doctest: +SKIP
True
"""
self._cache = defaultdict(lambda: deque(maxlen=3))
return self
@classmethod
def from_numpy(cls, x):
if x.shape:
coords = np.where(x)
data = x[coords]
coords = np.vstack(coords)
else:
coords = []
data = x
return cls(coords, data, shape=x.shape, has_duplicates=False,
sorted=True)
def todense(self):
self = self.sum_duplicates()
x = np.zeros(shape=self.shape, dtype=self.dtype)
coords = tuple([self.coords[i, :] for i in range(self.ndim)])
x[coords] = self.data
return x
@classmethod
def from_scipy_sparse(cls, x):
x = scipy.sparse.coo_matrix(x)
coords = np.empty((2, x.nnz), dtype=x.row.dtype)
coords[0, :] = x.row
coords[1, :] = x.col
return COO(coords, x.data, shape=x.shape,
has_duplicates=not x.has_canonical_format,
sorted=x.has_canonical_format)
@property
def dtype(self):
return self.data.dtype
@property
def ndim(self):
return len(self.shape)
@property
def nnz(self):
return self.coords.shape[1]
@property
def nbytes(self):
return self.data.nbytes + self.coords.nbytes
def __sizeof__(self):
return self.nbytes
def __getitem__(self, index):
if not isinstance(index, tuple):
index = (index,)
index = tuple(ind + self.shape[i] if isinstance(ind, numbers.Integral) and ind < 0 else ind
for i, ind in enumerate(index))
if (all(ind == slice(None) or ind == slice(0, d)
for ind, d in zip(index, self.shape))):
return self
mask = np.ones(self.nnz, dtype=bool)
for i, ind in enumerate([i for i in index if i is not None]):
if ind == slice(None, None):
continue
mask &= _mask(self.coords[i], ind)
n = mask.sum()
coords = []
shape = []
i = 0
for ind in index:
if isinstance(ind, numbers.Integral):
i += 1
continue
elif isinstance(ind, slice):
start = ind.start or 0
stop = ind.stop if ind.stop is not None else self.shape[i]
shape.append(min(stop, self.shape[i]) - start)
coords.append(self.coords[i][mask] - start)
i += 1
elif isinstance(ind, list):
old = self.coords[i][mask]
new = np.empty(shape=old.shape, dtype=old.dtype)
for j, item in enumerate(ind):
new[old == item] = j
coords.append(new)
shape.append(len(ind))
i += 1
elif ind is None:
coords.append(np.zeros(n))
shape.append(1)
for j in range(i, self.ndim):
coords.append(self.coords[j][mask])
shape.append(self.shape[j])
coords = np.stack(coords, axis=0)
shape = tuple(shape)
data = self.data[mask]
return COO(coords, data, shape=shape,
has_duplicates=self.has_duplicates,
sorted=self.sorted)
def __str__(self):
return "<COO: shape=%s, dtype=%s, nnz=%d, sorted=%s, duplicates=%s>" % (
self.shape, self.dtype, self.nnz, self.sorted,
self.has_duplicates)
__repr__ = __str__
def reduction(self, method, axis=None, keepdims=False, dtype=None):
if axis is None:
axis = tuple(range(self.ndim))
kwargs = {}
if dtype:
kwargs['dtype'] = dtype
if isinstance(axis, numbers.Integral):
axis = (axis,)
if set(axis) == set(range(self.ndim)):
result = getattr(self.data, method)(**kwargs)
else:
axis = tuple(axis)
neg_axis = list(range(self.ndim))
for ax in axis:
neg_axis.remove(ax)
neg_axis = tuple(neg_axis)
a = self.transpose(axis + neg_axis)
a = a.reshape((np.prod([self.shape[d] for d in axis]),
np.prod([self.shape[d] for d in neg_axis])))
a = a.to_scipy_sparse()
a = getattr(a, method)(axis=0, **kwargs)
if isinstance(a, scipy.sparse.spmatrix):
a = COO.from_scipy_sparse(a)
a.sorted = self.sorted
a.has_duplicates = False
elif isinstance(a, np.matrix):
a = np.asarray(a)[0]
a = COO.from_numpy(a)
a = a.reshape([self.shape[d] for d in neg_axis])
result = a
if keepdims:
result = _keepdims(self, result, axis)
return result
def sum(self, axis=None, keepdims=False, dtype=None, out=None):
return self.reduction('sum', axis=axis, keepdims=keepdims, dtype=dtype)
def max(self, axis=None, keepdims=False, out=None):
x = self.reduction('max', axis=axis, keepdims=keepdims)
# TODO: verify that there are some missing elements in each entry
if isinstance(x, COO):
x.data[x.data < 0] = 0
return x
elif isinstance(x, np.ndarray):
x[x < 0] = 0
return x
else:
return np.max(x, 0)
def transpose(self, axes=None):
if axes is None:
axes = reversed(range(self.ndim))
axes = tuple(axes)
if axes == tuple(range(self.ndim)):
return self
if self._cache is not None:
for ax, value in self._cache['transpose']:
if ax == axes:
return value
shape = tuple(self.shape[ax] for ax in axes)
result = COO(self.coords[axes, :], self.data, shape,
has_duplicates=self.has_duplicates,
cache=self._cache is not None)
if self._cache is not None:
self._cache['transpose'].append((axes, result))
return result
@property
def T(self):
return self.transpose(list(range(self.ndim))[::-1])
def dot(self, other):
return dot(self, other)
def __matmul__(self, other):
try:
return dot(self, other)
except NotImplementedError:
return NotImplemented
def __rmatmul__(self, other):
try:
return dot(other, self)
except NotImplementedError:
return NotImplemented
def __numpy_ufunc__(self, ufunc, method, i, inputs, **kwargs):
return NotImplemented
def linear_loc(self, signed=False):
""" Index location of every piece of data in a flattened array
This is used internally to check for duplicates, re-order, reshape,
etc..
"""
n = reduce(operator.mul, self.shape)
if signed:
n = -n
dtype = np.min_scalar_type(n)
out = np.zeros(self.nnz, dtype=dtype)
tmp = np.zeros(self.nnz, dtype=dtype)
strides = 1
for i, d in enumerate(self.shape[::-1]):
# out += self.coords[-(i + 1), :].astype(dtype) * strides
np.multiply(self.coords[-(i + 1), :], strides, out=tmp, dtype=dtype)
np.add(tmp, out, out=out)
strides *= d
return out
def reshape(self, shape):
if self.shape == shape:
return self
if any(d == -1 for d in shape):
extra = int(np.prod(self.shape) /
np.prod([d for d in shape if d != -1]))
shape = tuple([d if d != -1 else extra for d in shape])
if self.shape == shape:
return self
if self._cache is not None:
for sh, value in self._cache['reshape']:
if sh == shape:
return value
# TODO: this np.prod(self.shape) enforces a 2**64 limit to array size
linear_loc = self.linear_loc()
coords = np.empty((len(shape), self.nnz), dtype=np.min_scalar_type(max(shape)))
strides = 1
for i, d in enumerate(shape[::-1]):
coords[-(i + 1), :] = (linear_loc // strides) % d
strides *= d
result = COO(coords, self.data, shape,
has_duplicates=self.has_duplicates,
sorted=self.sorted, cache=self._cache is not None)
if self._cache is not None:
self._cache['reshape'].append((shape, result))
return result
def to_scipy_sparse(self):
assert self.ndim == 2
result = scipy.sparse.coo_matrix((self.data,
(self.coords[0],
self.coords[1])),
shape=self.shape)
result.has_canonical_format = (not self.has_duplicates and self.sorted)
return result
def _tocsr(self):
assert self.ndim == 2
# Pass 1: sum duplicates
self.sum_duplicates()
# Pass 2: sort indices
self.sort_indices()
row, col = self.coords
# Pass 3: count nonzeros in each row
indptr = np.zeros(self.shape[0] + 1, dtype=np.int64)
np.cumsum(np.bincount(row, minlength=self.shape[0]), out=indptr[1:])
return scipy.sparse.csr_matrix((self.data, col, indptr), shape=self.shape)
def tocsr(self):
if self._cache is not None:
try:
return self._csr
except AttributeError:
pass
try:
self._csr = self._csc.tocsr()
return self._csr
except AttributeError:
pass
self._csr = csr = self._tocsr()
else:
csr = self._tocsr()
return csr
def tocsc(self):
if self._cache is not None:
try:
return self._csc
except AttributeError:
pass
try:
self._csc = self._csr.tocsc()
return self._csc
except AttributeError:
pass
self._csc = csc = self.tocsr().tocsc()
else:
csc = self.tocsr().tocsc()
return csc
def sort_indices(self):
if self.sorted:
return
linear = self.linear_loc(signed=True)
if (np.diff(linear) > 0).all(): # already sorted
self.sorted = True
return self
order = np.argsort(linear)
self.coords = self.coords[:, order]
self.data = self.data[order]
self.sorted = True
return self
def sum_duplicates(self):
# Inspired by scipy/sparse/coo.py::sum_duplicates
# See https://github.com/scipy/scipy/blob/master/LICENSE.txt
if not self.has_duplicates:
return self
if not np.prod(self.coords.shape):
return self
self.sort_indices()
linear = self.linear_loc()
unique_mask = np.diff(linear) != 0
if unique_mask.sum() == len(unique_mask): # already unique
self.has_duplicates = False
return self
unique_mask = np.append(True, unique_mask)
coords = self.coords[:, unique_mask]
(unique_inds,) = np.nonzero(unique_mask)
data = np.add.reduceat(self.data, unique_inds, dtype=self.data.dtype)
self.data = data
self.coords = coords
self.has_duplicates = False
return self
def __add__(self, other):
if isinstance(other, numbers.Number) and other == 0:
return self
if not isinstance(other, COO):
return self.maybe_densify() + other
if self.shape == other.shape:
return self.elemwise_binary(operator.add, other)
else:
raise NotImplementedError("Broadcasting not yet supported")
def __radd__(self, other):
return self + other
def __neg__(self):
return COO(self.coords, -self.data, self.shape, self.has_duplicates,
self.sorted)
def __sub__(self, other):
return self + (-other)
def __rsub__(self, other):
return -self + other
def __mul__(self, other):
if isinstance(other, COO):
return self.elemwise_binary(operator.mul, other)
else:
return self.elemwise(operator.mul, other)
__rmul__ = __mul__
def __truediv__(self, other):
return self.elemwise(operator.truediv, other)
def __floordiv__(self, other):
return self.elemwise(operator.floordiv, other)
__div__ = __truediv__
def __pow__(self, other):
return self.elemwise(operator.pow, other)
def elemwise(self, func, *args, **kwargs):
if kwargs.pop('check', True) and func(0, *args, **kwargs) != 0:
raise ValueError("Performing this operation would produce "
"a dense result: %s" % str(func))
return COO(self.coords, func(self.data, *args, **kwargs),
shape=self.shape,
has_duplicates=self.has_duplicates,
sorted=self.sorted)
def elemwise_binary(self, func, other, *args, **kwargs):
assert isinstance(other, COO)
if kwargs.pop('check', True) and func(0, 0, *args, **kwargs) != 0:
raise ValueError("Performing this operation would produce "
"a dense result: %s" % str(func))
if self.shape != other.shape:
raise NotImplementedError("Broadcasting is not supported")
self.sum_duplicates() # TODO: document side-effect or make copy
other.sum_duplicates() # TODO: document side-effect or make copy
# Sort self.coords in lexographical order using record arrays
self_coords = np.rec.fromarrays(self.coords)
i = np.argsort(self_coords)
self_coords = self_coords[i]
self_data = self.data[i]
# Convert other.coords to a record array
other_coords = | np.rec.fromarrays(other.coords) | numpy.rec.fromarrays |
# -*- coding: utf-8 -*-
"""
Created on Sat Nov 28 17:08:13 2015
@author: jordan
"""
import os
import numpy as np
from astropy.table import Table, hstack
from astropy.stats import sigma_clipped_stats
from astropy.wcs import WCS
from astropy.wcs.utils import proj_plane_pixel_area
from astropy import units as u
from astropy.coordinates import SkyCoord
from matplotlib import pyplot as plt
from photutils import daofind, aperture_photometry, CircularAperture, CircularAnnulus
import pdb
from pyPol import Image
#Setup the path delimeter for this operating system
delim = os.path.sep
# Grab all the *.fits files in the reduced science data directory
reducedDir = '/home/jordan/ThesisData/PRISM_Data/Reduced_data'
# Setup new directory for polarimetry data
polarimetryDir = reducedDir + delim + 'Polarimetry'
if (not os.path.isdir(polarimetryDir)):
os.mkdir(polarimetryDir, 0o755)
polAngDir = polarimetryDir + delim + 'polAngImgs'
if (not os.path.isdir(polAngDir)):
os.mkdir(polAngDir, 0o755)
stokesDir = polarimetryDir + delim + 'stokesImgs'
if (not os.path.isdir(stokesDir)):
os.mkdir(stokesDir, 0o755)
# Read in the indexFile data and select the filenames
print('\nReading file index from disk')
indexFile = 'fileIndex.csv'
fileIndex = Table.read(indexFile, format='csv')
#fileIndex = ascii.read(indexFile, guess=False, delimiter=',')
fileList = fileIndex['Filename']
# Determine which parts of the fileIndex pertain to science images
useFiles = np.logical_and((fileIndex['Use'] == 1), (fileIndex['Dither'] == 'ABBA'))
# Cull the file index to only include files selected for use
fileIndex = fileIndex[np.where(useFiles)]
# Group the fileIndex by...
# 1. Target
# 2. Waveband
# 3. Dither (pattern)
fileIndexByTarget = fileIndex.group_by(['Target', 'Waveband', 'Dither'])
# Define any required conversion constants
rad2deg = (180.0/np.pi)
deg2rad = (np.pi/180.0)
# Use the following data for final calibration
# ...
# Magnitude zero point from Bessel 1990, PASP 102, 1181
# Extinction from <NAME> & Mathis 1989, ApJ 345, 245 or Rieke and Lebosky 1985, ApJ
# ...
# Bands and zero point flux [in Jy = 10^(-26) W /(m^2 Hz)]
zeroFlux = dict(zip(['U', 'B', 'V', 'R'],
[1884, 4646, 3953, 2875]))
# Loop through each group
groupKeys = fileIndexByTarget.groups.keys
for group in fileIndexByTarget.groups:
# Grab the current target information
thisTarget = str(np.unique(group['Target'].data)[0])
thisWaveband = str(np.unique(group['Waveband'].data)[0])
numImgs = len(group)
print('\nProcessing images for'.format(numImgs))
print('\tTarget : {0}'.format(thisTarget))
print('\tWaveband : {0}'.format(thisWaveband))
# Calibrate stokes intensity from USNOB stars...
catalogFile = stokesDir + delim + thisTarget + '_stars.xml'
starCatalog = Table.read(catalogFile)
thisMag = thisWaveband + 'mag'
theseStars = np.logical_not(starCatalog[thisMag].mask)
# Cull the catalog to those entries with relevant photometric data
starCatalog = starCatalog[np.where(theseStars)]
# Form a "catalog" of position entries for matching
ra1 = starCatalog['RAJ2000']
dec1 = starCatalog['DEJ2000']
catalog1 = SkyCoord(ra = ra1, dec = dec1, frame = 'fk5')
# Read in the image and find tars in the image
Ifile = (stokesDir + delim +
'_'.join([thisTarget, thisWaveband, 'I']) + '.fits')
stokesI = Image(Ifile)
mean, median, std = sigma_clipped_stats(stokesI.arr, sigma=3.0, iters=5)
threshold = median + 3.0*std
fwhm = 3.0
sources = daofind(stokesI.arr, threshold, fwhm, ratio=1.0, theta=0.0,
sigma_radius=1.5, sharplo=0.2, sharphi=1.0,
roundlo=-1.0, roundhi=1.0, sky=0.0,
exclude_border=True)
# Convert source positions to RA and Dec
wcs = WCS(stokesI.header)
ADstars = wcs.all_pix2world(sources['xcentroid'], sources['ycentroid'], 0)
catalog2 = SkyCoord(ra = ADstars[0]*u.deg, dec = ADstars[1]*u.deg, frame = 'fk5')
###
### This slow, meat-axe method was useful for verification.
### It produces the same results as the method below.
###
# # Loop through each of the detected sources, and check for possible confusion
# keepStars = []
# numCat1Match = []
# numCat2Match = []
# for i in range(len(catalog2)):
# # Establish the coordinates of the current star
# thisCoord = SkyCoord(ra = catalog2[i].ra, dec = catalog2[i].dec)
#
# # Compute the distances from this star to other stars in both catalogs
# d2d_cat1 = thisCoord.separation(catalog1)
# d2d_cat2 = thisCoord.separation(catalog2)
#
# # Check if there is more than one star nearby in EITHER catalog
# numCat1Match.append(np.sum(d2d_cat1 < 20*u.arcsec))
# numCat2Match.append(np.sum(d2d_cat2 < 20*u.arcsec))
# keepStars.append(numCat1Match[i] == 1 and numCat2Match[i] == 1)
#Search for all possible matches within 10 arcsec of a given detected source
idxc1, idxc2, d2d, d3d = catalog2.search_around_sky(catalog1, 20*u.arcsec)
# Detect which matches from catalog2 to catalog1 are unique
bins, freq = np.unique(idxc2, return_inverse=True)
cat2Keep = np.bincount(freq) == 1
isoCatalog2 = bins[np.where(cat2Keep)]
# Cull the decteced sources catalog to only include good, isolated stars
xStars = sources['xcentroid'][isoCatalog2]
yStars = sources['ycentroid'][isoCatalog2]
# Now check for saturation near this star
saturatedStars = []
for xStar, yStar in zip(xStars, yStars):
lf, rt = xStar - 10, xStar + 10
bt, tp = yStar - 10, yStar + 10
patch = stokesI.arr[lf:rt, bt:tp]
saturatedStars.append(np.sum(np.logical_or(patch > 9e3, patch < -100)) > 1)
# Check for stars near the edge of the image
ny, nx = stokesI.arr.shape
edgeStars = np.logical_or(
np.logical_or(xStars < 40, xStars > (nx - 40)),
np.logical_or(yStars < 40, yStars > (ny - 40)))
# Now let's do aperture photometry on the remaining sources in the image
# 1. Setup the apertures
sourcePos = [xStars, yStars]
apertures = CircularAperture(sourcePos, r = 6.0)
annulus_apertures = CircularAnnulus(sourcePos, r_in=12., r_out=14.)
# 2. Perform the basic photometry
rawflux_table = aperture_photometry(stokesI.arr, apertures)
bkgflux_table = aperture_photometry(stokesI.arr, annulus_apertures)
phot_table = hstack([rawflux_table, bkgflux_table], table_names=['raw', 'bkg'])
# 3. Compute background contribution and subtract from raw photometry
bkg_mean = phot_table['aperture_sum_bkg'] / annulus_apertures.area()
bkg_sum = bkg_mean * apertures.area()
final_sum = phot_table['aperture_sum_raw'] - bkg_sum
phot_table['residual_aperture_sum'] = final_sum
# Compute the signal-to-noise ratio and find the stars with SNR < 3.0
SNR = final_sum/bkg_sum
bkgDominated = SNR < 1.0
# ###########################################################################
# # PRINT OUT THE PHOTOMETRY TO CHECK FOR CONSISTENCY
# ###########################################################################
# xFmtStr = '{x[0]:>6}.{x[1]:<3}'
# yFmtStr = '{y[0]:>6}.{y[1]:<3}'
# starFmtStr = '{star[0]:>9}.{star[1]:<3}'
# bkgFmtStr = '{bkg[0]:>9}.{bkg[1]:<3}'
# snrFmtStr = '{snr[0]:>9}.{snr[1]:<3}'
# print('final photometry is...')
# print(' x y Star Flux Bkg Flux SNR')
# print('===========================================================')
# printStr = xFmtStr + yFmtStr + starFmtStr + bkgFmtStr + snrFmtStr
# for i in range(len(SNR)):
# xVal = str(xStars[i]).split('.')
# xVal[1] = (xVal[1])[0:3]
# yVal = str(yStars[i]).split('.')
# yVal[1] = (yVal[1])[0:3]
# starVal = str(final_sum[i]).split('.')
# starVal[1] = (starVal[1])[0:3]
# bkgVal = str(bkg_sum[i]).split('.')
# bkgVal[1] = (bkgVal[1])[0:3]
# snrVal = str(SNR[i]).split('.')
# snrVal[1] = (snrVal[1])[0:3]
# print(printStr.
# format(x = xVal, y = yVal, star = starVal, bkg = bkgVal, snr = snrVal))
# Cull the lists to juts keep
# non-saturated,
# non-edge,
# non-background-dominated stars
keepStars = np.logical_not(
np.logical_or(
| np.logical_or(saturatedStars, edgeStars) | numpy.logical_or |
"""Wild Life
An interactive version of Conway’s Life Game, written in Python.
Source and description:
https://github.com/pawelbudziszewski/Wild-Life
Copyright 2021, 2022 <NAME>
This is an interactive version of Conway’s Life Game, written in Python.
It allows placing different life forms using mouse while game is running.
How to run it:
On Windows just execute 'python3.exe wild_life.py'
In theory this code should run fine also on Linux, but I did not test it.
How use it:
- Mouse-click anywhere to insert species
- Mouse-click on the species list in the bottom to select species to
be inserted
- [1], [2], [3], [4] keys to change color map
- [Esc] to exit
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import time
import random
import numpy as np
import cv2
from scipy.signal import convolve2d
import life_forms
## Configuration
# Size of the world (number of grid cells)
WIDTH=600
HEIGHT=300
# Magnification - each cell will be displayed as NxN pixels.
N=2
# Do we want to wrap the world? If yes, everything that moves outside
# of the border will appear at opposite border.
WRAP_WORLD = False
# Dying life cells leaves shadows. FADE_COEFFICIENT determines,
# how long this shadow will last. Greater value - longer shadow
# lifetime. Value of 0.0 means no shadows.
# This value should be larger or equal to 0 and lower than 1 - other
# values are technically possible, but may give awkward results (have
# fun testing).
FADE_COEFFICIENT = 0.6
# Color maps we can use
COLOR_MAPS = [cv2.COLORMAP_BONE,
cv2.COLORMAP_HOT,
cv2.COLORMAP_OCEAN,
cv2.COLORMAP_PINK
]
# Initial color map
INITIAL_COLOR_MAP = 0
# Life forms to be used in menu (see life_forms.py)
SPECIES_MENU_ITEMS = [
life_forms.GOSPER_GLIDER_GUN,
life_forms.GLIDERS,
life_forms.TURTLE_R,
life_forms.BLIMKER_PUFFER,
life_forms.KOK_GALAXY,
life_forms.PULSAR,
life_forms.BLANK,
]
# Initially selected life form
INITIAL_SPECIES_MENU_ITEM = 0
class WildLife:
""" Life class"""
def __init__(self):
self.W = WIDTH
self.H = HEIGHT
self.N = N
self.current_species = INITIAL_SPECIES_MENU_ITEM
# This will be our arena
self.world = np.zeros([self.H,self.W])
# Arena transformed into image to be displayed
self.world_img=np.ones([self.H,self.W])*0.5
self.color_map_id = INITIAL_COLOR_MAP
self.generate_menu()
def generate_image(self):
""" Generate OpenCV image based on game's world and menu
"""
img = self.world_img*-1+1
remapped = cv2.applyColorMap((img*255).astype(np.uint8), COLOR_MAPS[self.color_map_id])
remapped = np.vstack((remapped,self.menu))
if self.N>1:
remapped=remapped.repeat(self.N, axis=0).repeat(self.N, axis=1)
return remapped
def life_step(self):
""" One step of life cycle
"""
if WRAP_WORLD:
boundary = 'wrap'
else:
boundary = 'fill'
neighbors_count = convolve2d(self.world, | np.ones((3, 3)) | numpy.ones |
# --------------------------------------------------------
# Tensorflow Faster R-CNN
# Licensed under The MIT License [see LICENSE for details]
# Written by <NAME> and <NAME>
# --------------------------------------------------------
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from model.config import cfg
import roi_data_layer.roidb as rdl_roidb
from roi_data_layer.layer import RoIDataLayer
from utils.timer import Timer
import keras as k
try:
import cPickle as pickle
except ImportError:
import pickle
import numpy as np
import os
import sys
import glob
import time
import math
import tensorflow as tf
from tensorflow.python import pywrap_tensorflow
from model.bbox_transform import clip_boxes, bbox_transform_inv
from utils.cython_bbox import bbox_overlaps
def _clip_boxes(boxes, im_shape):
"""Clip boxes to image boundaries."""
# x1 >= 0
boxes[:, 0] = np.maximum(boxes[:, 0], 0)
# y1 >= 0
boxes[:, 1] = np.maximum(boxes[:, 1], 0)
# x2 < im_shape[1]
boxes[:, 2] = np.minimum(boxes[:, 2], im_shape[1] - 1)
# y2 < im_shape[0]
boxes[:, 3] = np.minimum(boxes[:, 3], im_shape[0] - 1)
return boxes
class SolverWrapper(object):
"""
A wrapper class for the training process
"""
def __init__(self, sess, network, imdb, roidb, valroidb, output_dir = "", tbdir = "", pretrained_model=""):
self.net = network
self.imdb = imdb
self.roidb = roidb
self.valroidb = valroidb
self.output_dir = output_dir
self.tbdir = tbdir
# Simply put '_val' at the end to save the summaries from the validation set
self.tbvaldir = tbdir + '_val'
if not os.path.exists(self.tbvaldir):
os.makedirs(self.tbvaldir)
self.pretrained_model = pretrained_model
def snapshot(self, sess, iter):
net = self.net
if not os.path.exists(self.output_dir):
os.makedirs(self.output_dir)
# Store the model snapshot
filename = cfg.TRAIN.SNAPSHOT_PREFIX + '_iter_{:d}'.format(iter) + '.ckpt'
filename = os.path.join(self.output_dir, filename)
self.saver.save(sess, filename)
print('Wrote snapshot to: {:s}'.format(filename))
# Also store some meta information, random state, etc.
nfilename = cfg.TRAIN.SNAPSHOT_PREFIX + '_iter_{:d}'.format(iter) + '.pkl'
nfilename = os.path.join(self.output_dir, nfilename)
# current state of numpy random
st0 = np.random.get_state()
# current position in the database
cur = self.data_layer._cur
# current shuffled indexes of the database
perm = self.data_layer._perm
# current position in the validation database
cur_val = self.data_layer_val._cur
# current shuffled indexes of the validation database
perm_val = self.data_layer_val._perm
# Dump the meta info
with open(nfilename, 'wb') as fid:
pickle.dump(st0, fid, pickle.HIGHEST_PROTOCOL)
pickle.dump(cur, fid, pickle.HIGHEST_PROTOCOL)
pickle.dump(perm, fid, pickle.HIGHEST_PROTOCOL)
pickle.dump(cur_val, fid, pickle.HIGHEST_PROTOCOL)
pickle.dump(perm_val, fid, pickle.HIGHEST_PROTOCOL)
pickle.dump(iter, fid, pickle.HIGHEST_PROTOCOL)
return filename, nfilename
def from_snapshot(self, sess, sfile, nfile):
print('Restoring model snapshots from {:s}'.format(sfile))
init = tf.global_variables_initializer()
sess.run(init)
self.saver.restore(sess, sfile)
print('Restored.')
# Needs to restore the other hyper-parameters/states for training, (TODO xinlei) I have
# tried my best to find the random states so that it can be recovered exactly
# However the Tensorflow state is currently not available
with open(nfile, 'rb') as fid:
st0 = pickle.load(fid)
cur = pickle.load(fid)
perm = pickle.load(fid)
cur_val = pickle.load(fid)
perm_val = pickle.load(fid)
last_snapshot_iter = pickle.load(fid)
np.random.set_state(st0)
return last_snapshot_iter
def get_variables_in_checkpoint_file(self, file_name):
try:
reader = pywrap_tensorflow.NewCheckpointReader(file_name)
var_to_shape_map = reader.get_variable_to_shape_map()
return var_to_shape_map
except Exception as e: # pylint: disable=broad-except
print(str(e))
if "corrupted compressed block contents" in str(e):
print("It's likely that your checkpoint file has been compressed "
"with SNAPPY.")
def construct_graph(self, sess):
with sess.graph.as_default():
# Set the random seed for tensorflow
tf.set_random_seed(cfg.RNG_SEED)
# Build the main computation graph
layers = self.net.create_architecture('TRAIN', self.imdb.num_classes, tag='default',
anchor_scales=cfg.ANCHOR_SCALES,
anchor_ratios=cfg.ANCHOR_RATIOS)
# Define the loss
loss = layers['total_loss']
# Set learning rate and momentum
lr = tf.Variable(cfg.TRAIN.LEARNING_RATE, trainable=False)
self.optimizer = tf.train.MomentumOptimizer(lr, cfg.TRAIN.MOMENTUM)
#self.optimizer = tf.train.AdamOptimizer(learning_rate=1e-3)
# Compute the gradients with regard to the loss
gvs = self.optimizer.compute_gradients(loss)
# Double the gradient of the bias if set
if cfg.TRAIN.DOUBLE_BIAS:
final_gvs = []
with tf.variable_scope('Gradient_Mult') as scope:
for grad, var in gvs:
scale = 1.
if cfg.TRAIN.DOUBLE_BIAS and '/biases:' in var.name:
scale *= 2.
if not np.allclose(scale, 1.0):
grad = tf.multiply(grad, scale)
final_gvs.append((grad, var))
train_op = self.optimizer.apply_gradients(final_gvs)
else:
train_op = self.optimizer.apply_gradients(gvs)
# Write the train and validation information to tensorboard
self.writer = tf.summary.FileWriter(self.tbdir, sess.graph)
self.valwriter = tf.summary.FileWriter(self.tbvaldir)
return lr, train_op
def find_previous(self, max_iters):
sfiles = os.path.join(self.output_dir, cfg.TRAIN.SNAPSHOT_LOAD_PREFIX + '_iter_*.ckpt.meta')
sfiles = glob.glob(sfiles)
sfiles.sort(key=os.path.getmtime)
# Get the snapshot name in TensorFlow
redfiles = []
for stepsize in range(0, max_iters, cfg.TRAIN.SNAPSHOT_ITERS):
redfiles.append(os.path.join(self.output_dir, cfg.TRAIN.SNAPSHOT_LOAD_PREFIX + '_iter_{:d}.ckpt.meta'.format(stepsize)))
sfiles = [ss.replace('.meta', '') for ss in sfiles if ss in redfiles]
nfiles = os.path.join(self.output_dir, cfg.TRAIN.SNAPSHOT_LOAD_PREFIX + '_iter_*.pkl')
nfiles = glob.glob(nfiles)
nfiles.sort(key=os.path.getmtime)
redfiles = [redfile.replace('.ckpt.meta', '.pkl') for redfile in redfiles]
nfiles = [nn for nn in nfiles if nn in redfiles]
lsf = len(sfiles)
assert len(nfiles) == lsf
return lsf, nfiles, sfiles
def initialize(self, sess):
# Initial file lists are empty
np_paths = []
ss_paths = []
# Fresh train directly from ImageNet weights
print('Loading initial model weights from {:s}'.format(self.pretrained_model))
variables = tf.global_variables()
# Initialize all variables first
sess.run(tf.variables_initializer(variables, name='init'))
var_keep_dic = self.get_variables_in_checkpoint_file(self.pretrained_model)
# Get the variables to restore, ignoring the variables to fix
variables_to_restore = self.net.get_variables_to_restore(variables, var_keep_dic)
init = tf.global_variables_initializer()
sess.run(init)
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.pretrained_model)
print('Loaded.')
# Need to fix the variables before loading, so that the RGB weights are changed to BGR
# For VGG16 it also changes the convolutional weights fc6 and fc7 to
# fully connected weights
self.net.fix_variables(sess, self.pretrained_model)
print('Fixed.')
last_snapshot_iter = 0
rate = cfg.TRAIN.LEARNING_RATE
stepsizes = list(cfg.TRAIN.STEPSIZE)
return rate, last_snapshot_iter, stepsizes, np_paths, ss_paths
def restore(self, sess, sfile, nfile):
# Get the most recent snapshot and restore
np_paths = [nfile]
ss_paths = [sfile]
# Restore model from snapshots
last_snapshot_iter = self.from_snapshot(sess, sfile, nfile)
self.net.fix_variables(sess, sfile)
print('Fixed.')
# Set the learning rate
rate = cfg.TRAIN.LEARNING_RATE
stepsizes = cfg.TRAIN.STEPSIZE
return rate, last_snapshot_iter, stepsizes, np_paths, ss_paths
def remove_snapshot(self, np_paths, ss_paths):
to_remove = len(np_paths) - cfg.TRAIN.SNAPSHOT_KEPT
for c in range(to_remove):
nfile = np_paths[0]
os.remove(str(nfile))
np_paths.remove(nfile)
to_remove = len(ss_paths) - cfg.TRAIN.SNAPSHOT_KEPT
for c in range(to_remove):
sfile = ss_paths[0]
# To make the code compatible to earlier versions of Tensorflow,
# where the naming tradition for checkpoints are different
if os.path.exists(str(sfile)):
os.remove(str(sfile))
else:
os.remove(str(sfile + '.data-00000-of-00001'))
os.remove(str(sfile + '.index'))
sfile_meta = sfile + '.meta'
os.remove(str(sfile_meta))
ss_paths.remove(sfile)
def train_model(self, sess, max_iters, just_test = False):
# Build data layers for both training and validation set
self.data_layer = RoIDataLayer(self.roidb, self.imdb.num_classes)
self.data_layer_val = RoIDataLayer(self.valroidb, self.imdb.num_classes, random=True)
# Construct the computation graph
lr, train_op = self.construct_graph(sess)
# Find previous snapshots if there is any to restore from
lsf, nfiles, sfiles = self.find_previous(max_iters)
# Initialize the variables or restore them from the last snapshot
if lsf == 0:
variables = tf.global_variables()
var_keep_dic = self.get_variables_in_checkpoint_file(self.pretrained_model)
variables_to_restore = self.net.get_variables_to_restore(variables, var_keep_dic)
self.saver = tf.train.Saver(variables_to_restore, max_to_keep=100000, reshape=True)
rate, last_snapshot_iter, stepsizes, np_paths, ss_paths = self.initialize(sess)
else:
variables = tf.global_variables()
var_keep_dic = self.get_variables_in_checkpoint_file(sfiles[-1])
variables_to_restore = self.net.get_variables_to_restore(variables, var_keep_dic)
self.saver = tf.train.Saver(variables_to_restore, max_to_keep=100000, reshape=True)
rate, last_snapshot_iter, stepsizes, np_paths, ss_paths = self.restore(sess,
str(sfiles[-1]),
str(nfiles[-1]))
self.saver = tf.train.Saver(max_to_keep=100000, reshape=True)
iter = 1
np_paths = []
ss_paths = []
# Make sure the lists are not empty
stepsizes.append(max_iters)
stepsizes.reverse()
next_stepsize = stepsizes.pop()
best_result = 0.0
sess.run(tf.assign(lr, rate))
while iter < max_iters + 1:
if iter == next_stepsize + 1:
# Add snapshot here before reducing the learning rate
rate *= cfg.TRAIN.GAMMA
sess.run(tf.assign(lr, rate))
next_stepsize = stepsizes.pop()
if not just_test:
self.run_epoch(iter, self.data_layer, "train", sess, lr, train_op)
result = self.run_epoch(iter, self.data_layer_val, "validation", sess, lr, None)
else:
self.run_epoch(iter, self.data_layer_val, "test", sess, lr, None)
result = - 1.0
# Snapshotting
if iter % cfg.TRAIN.SNAPSHOT_ITERS == 0 and not just_test:
last_snapshot_iter = iter
ss_path, np_path = self.snapshot(sess, iter)
np_paths.append(np_path)
ss_paths.append(ss_path)
# Remove the old snapshots if there are too many
try:
if len(np_paths) > cfg.TRAIN.SNAPSHOT_KEPT:
self.remove_snapshot(np_paths, ss_paths)
except:
print("failed to remove snapshot")
if result > best_result:
self.snapshot(sess, 0)
best_result = result
print(">>> best_result %f" % (best_result))
iter += 1
if last_snapshot_iter != iter - 1 and not just_test:
self.snapshot(sess, iter - 1)
self.writer.close()
self.valwriter.close()
def run_epoch(self, epoch, data_layer, name, sess, lr, train_op):
accum_results = None
accum_losses = None
epoch_iter = 0.0
timer = Timer()
# Get training data, one batch at a time
while True:
timer.tic()
blobs, new_epoch = data_layer.forward()
if new_epoch and epoch_iter != 0.0:
print_stat(name, epoch, epoch_iter, lr, accum_results, accum_losses)
sub_iou = float(accum_results['sub_iou']) / accum_results['total']
obj_iou = float(accum_results['obj_iou']) / accum_results['total']
return (sub_iou + obj_iou) / 2
if blobs["query"].shape[0] == 0 or blobs["gt_boxes"].shape[0] == 0:
continue
# Compute the graph without summary
try:
losses, predictions, proposal_targets = self.net.train_step(sess, blobs, train_op)
if math.isnan(losses["total_loss"]):
print("total loss is nan - iter %d" % (int(epoch_iter)))
continue
gt_bbox = blobs['gt_boxes']
gt = blobs['gt_labels'][:, :, 0]
im = blobs["im_info"]
gt_ent = blobs['partial_entity_class']
gt_rel = blobs['partial_relation_class']
boxes0 = predictions["rois"][:, 1:5]
# Apply bounding-box regression deltas
pred_boxes = np.reshape(predictions["pred_bbox_gpi"], [predictions["pred_bbox_gpi"].shape[0], -1])
box_deltas = pred_boxes * np.array(cfg.TRAIN.BBOX_NORMALIZE_STDS) + np.array(cfg.TRAIN.BBOX_NORMALIZE_MEANS)
pred_boxes = bbox_transform_inv(boxes0, box_deltas)
pred_boxes = _clip_boxes(pred_boxes, im)
# normalize boxes to [0-1]
gt_bbox_norm = gt_bbox.copy()
for i in range(4):
pred_boxes[:, i] /= im[(i+1)%2]
gt_bbox_norm[:, i] /= im[(i+1)%2]
boxes0[:, i] /= im[(i+1)%2]
rpn_results = rpn_test(gt_bbox_norm, boxes0, pred_boxes, gt_ent, gt_rel, predictions)
if accum_results == None:
first_result = True
accum_results = rpn_results
accum_losses = losses
else:
first_result = False
for key in rpn_results:
accum_results[key] += rpn_results[key]
for key in losses:
accum_losses[key] += losses[key]
for query_index in range(gt.shape[0]):
results = iou_test(gt[query_index], gt_bbox_norm,
proposal_targets["labels_mask"],
proposal_targets["labels"][query_index, :, 0],
predictions["cls_pred_gpi"][query_index],
predictions["cls_prob_gpi"][query_index],
pred_boxes, blobs['im_info'])
results_baseline = iou_test(gt[query_index], gt_bbox_norm,
proposal_targets["labels_mask"],
proposal_targets["labels"][query_index, :, 0],
predictions["cls_pred_baseline"][query_index],
predictions["cls_prob_baseline"][query_index],
boxes0, blobs['im_info'])
# accumulate results
if first_result:
for key in results:
accum_results[key] = results[key]
for key in results_baseline:
accum_results[key + "_bl"] = results_baseline[key]
first_result = False
else:
for key in results:
accum_results[key] += results[key]
for key in results_baseline:
accum_results[key + "_bl"] += results_baseline[key]
epoch_iter += 1.0
except Exception as e:
print(e)
print("error iter %d" % (int(epoch_iter)))
continue
timer.toc()
# Display training information
if (epoch == 1 and int(epoch_iter) % (cfg.TRAIN.DISPLAY) == 0) or (int(epoch_iter) % (10000) == 0):
print_stat(name, epoch, epoch_iter, lr, accum_results, accum_losses)
def print_stat(name, epoch, epoch_iter, lr, accum_results, losses):
sub_iou = float(accum_results['sub_iou']) / accum_results['total']
obj_iou = float(accum_results['obj_iou']) / accum_results['total']
sub_kl = float(accum_results['sub_kl']) / accum_results['total']
obj_kl = float(accum_results['obj_kl']) / accum_results['total']
acc = float(accum_results['acc']) / accum_results['total']
prec0 = float(accum_results['prec0']) / (accum_results['prec0_total'] + 1.0)
prec1 = float(accum_results['prec1']) / (accum_results['prec1_total'] + 1.0)
prec2 = float(accum_results['prec2']) / (accum_results['prec2_total'] + 1.0)
prec3 = float(accum_results['prec3']) / (accum_results['prec3_total'] + 1.0)
recall0 = float(accum_results['recall0']) / (accum_results['recall0_total'] + 1.0)
recall1 = float(accum_results['recall1']) / (accum_results['recall1_total'] + 1.0)
recall2 = float(accum_results['recall2']) / (accum_results['recall2_total'] + 1.0)
recall3 = float(accum_results['recall3']) / (accum_results['recall3_total'] + 1.0)
try:
f10 = 2 * recall0 * prec0 / (recall0 + prec0)
f11 = 2 * recall1 * prec1 / (recall1 + prec1)
f12 = 2 * recall2 * prec2 / (recall2 + prec2)
f13 = 2 * recall3 * prec3 / (recall3 + prec3)
except:
f10 = 0
f11 = 0
f12 = 0
f13 = 0
sub_iou_bl = float(accum_results['sub_iou_bl']) / accum_results['total_bl']
obj_iou_bl = float(accum_results['obj_iou_bl']) / accum_results['total_bl']
sub_kl_bl = float(accum_results['sub_kl_bl']) / accum_results['total_bl']
obj_kl_bl = float(accum_results['obj_kl_bl']) / accum_results['total_bl']
acc_bl = float(accum_results['acc_bl']) / accum_results['total_bl']
prec0_bl = float(accum_results['prec0_bl']) / (accum_results['prec0_total_bl'] + 1.0)
prec1_bl = float(accum_results['prec1_bl']) / (accum_results['prec1_total_bl'] + 1.0)
prec2_bl = float(accum_results['prec2_bl']) / (accum_results['prec2_total_bl'] + 1.0)
prec3_bl = float(accum_results['prec3_bl']) / (accum_results['prec3_total_bl'] + 1.0)
recall0_bl = float(accum_results['recall0_bl']) / (accum_results['recall0_total_bl'] + 1.0)
recall1_bl = float(accum_results['recall1_bl']) / (accum_results['recall1_total_bl'] + 1.0)
recall2_bl = float(accum_results['recall2_bl']) / (accum_results['recall2_total_bl'] + 1.0)
recall3_bl = float(accum_results['recall3_bl']) / (accum_results['recall3_total_bl'] + 1.0)
try:
f10_bl = 2 * recall0_bl * prec0_bl / (recall0_bl + prec0_bl)
f11_bl = 2 * recall1_bl * prec1_bl / (recall1_bl + prec1_bl)
f12_bl = 2 * recall2_bl * prec2_bl / (recall2_bl + prec2_bl)
f13_bl = 2 * recall3_bl * prec3_bl / (recall3_bl + prec3_bl)
except:
f10_bl = 0
f11_bl = 0
f12_bl = 0
f13_bl = 0
print('\n###### %s (%s): epoch %d iter: %d, total loss: %.4f lr: %f' % \
(name, cfg.TRAIN.SNAPSHOT_PREFIX, epoch, int(epoch_iter), losses["total_loss"] / epoch_iter, lr.eval()))
print('###scene-graph')
print(">>> loss_entity_gt: %.6f loss_relation_gt: %.6f acc_entity_gt: %.4f acc_relation_gt %.4f" % (losses["ent_cross_entropy0"] / epoch_iter, losses["rel_cross_entropy0"] / epoch_iter, accum_results["gt_sg_entity_acc"] / epoch_iter, accum_results["gt_sg_relation_acc"] / epoch_iter))
print(">>> loss_entity: %.6f loss_relation: %.6f acc_entity: %.4f acc_relation %.4f" % (losses["ent_cross_entropy"] / epoch_iter, losses["rel_cross_entropy"] / epoch_iter, accum_results["sg_entity_acc"] / epoch_iter, accum_results["sg_relation_acc"] / epoch_iter))
print('###rpn')
print('>>> rpn_loss_cls: %.6f rpn_loss_box: %.6f loss_box: %.6f' % (losses["rpn_cross_entropy"] / epoch_iter, losses["rpn_loss_box"] / epoch_iter, losses["loss_box"] / epoch_iter))
print('###gpi loss: %.6f' % (losses["cross_entropy_gpi"] / epoch_iter))
print('sub_iou: %.4f obj_iou: %.4f sub_kl: %.4f obj_kl: %.4f rpn_overlaps: %.4f' % (sub_iou, obj_iou, sub_kl, obj_kl, accum_results["gpi_overlaps"] / epoch_iter))
print('acc: %.4f ' % (acc))
print('recall0: %.4f recall1: %.4f recall2: %.4f recall3: %.4f' % (recall0, recall1, recall2, recall3))
print('prec0: %.4f prec1: %.4f prec2: %.4f prec3: %.4f' % (prec0, prec1, prec2, prec3))
print('f10: %.4f f11: %.4f f12: %.4f f13: %.4f' % (f10, f11, f12, f13))
print('###baseline loss: %.6f' % (losses["cross_entropy_baseline"] / epoch_iter))
print('sub_iou_bl: %.4f obj_iou_bl: %.4f sub_kl_bl: %.4f obj_kl_bl: %.4f rpn_overlaps_bl: %.4f' % (sub_iou_bl, obj_iou_bl, sub_kl_bl, obj_kl_bl, accum_results["baseline_overlaps"] / epoch_iter))
print('acc_bl: %.4f' % (acc_bl))
print('recall0_bl: %.4f recall1_bl: %.4f recall2_bl: %.4f recall3_bl: %.4f' % (recall0_bl, recall1_bl, recall2_bl, recall3_bl))
print('prec0_bl: %.4f prec1_bl: %.4f prec2_bl: %.4f prec3_bl: %.4f' % (prec0_bl, prec1_bl, prec2_bl, prec3_bl))
print('f10_bl: %.4f f11_bl: %.4f f12_bl: %.4f f13_bl: %.4f' % (f10_bl, f11_bl, f12_bl, f13_bl))
def get_training_roidb(imdb):
"""Returns a roidb (Region of Interest database) for use in training."""
if cfg.TRAIN.USE_FLIPPED:
print('Appending horizontally-flipped training examples...')
imdb.append_flipped_images()
print('done')
print('Preparing data...')
rdl_roidb.prepare_roidb(imdb)
print('done')
return imdb.roidb
def filter_roidb(roidb):
"""Remove roidb entries that have no usable RoIs."""
def is_valid(entry):
# Valid images have:
# (1) At least one foreground RoI OR
# (2) At least one background RoI
overlaps = entry['max_overlaps']
# find boxes with sufficient overlap
fg_inds = np.where(overlaps >= cfg.TRAIN.FG_THRESH)[0]
# Select background RoIs as those within [BG_THRESH_LO, BG_THRESH_HI)
bg_inds = np.where((overlaps < cfg.TRAIN.BG_THRESH_HI) &
(overlaps >= cfg.TRAIN.BG_THRESH_LO))[0]
# image is only valid if such boxes exist
valid = len(fg_inds) > 0 or len(bg_inds) > 0
return valid
num = len(roidb)
filtered_roidb = [entry for entry in roidb if is_valid(entry)]
num_after = len(filtered_roidb)
print('Filtered {} roidb entries: {} -> {}'.format(num - num_after,
num, num_after))
return roidb
def train_net(network, imdb, roidb, valroidb, output_dir, tb_dir,
pretrained_model=None,
max_iters=100, just_test=False):
"""Train a Faster R-CNN network."""
#pretrained_model="output/res101/VisualGenome/default/gpir_imagenet_baseline_iter_7.ckpt"
#just_test=True
tfconfig = tf.ConfigProto(allow_soft_placement=True)
tfconfig.gpu_options.allow_growth = True
with tf.Session(config=tfconfig) as sess:
sw = SolverWrapper(sess, network, imdb, roidb, valroidb, output_dir, tb_dir,
pretrained_model=pretrained_model)
print('Solving...')
sw.train_model(sess, max_iters,just_test)
print('done solving')
MASK_WIDTH = 14
MASK_HEIGHT = 14
def softmax(x):
xexp = np.exp(x)
return xexp / np.sum(xexp, axis=-1, keepdims=1)
def rpn_test(gt_bbox, pred_boxes0, pred_boxes, gt_ent, gt_rel, predictions):
overlaps0 = bbox_overlaps(np.ascontiguousarray(gt_bbox, dtype=np.float), np.ascontiguousarray(pred_boxes0, dtype=np.float))
overlaps0_assign = np.argmax(overlaps0, axis=1)
max_overlaps0 = overlaps0.max(axis=1)
overlaps = bbox_overlaps(np.ascontiguousarray(gt_bbox, dtype=np.float), np.ascontiguousarray(pred_boxes, dtype=np.float))
overlaps_assign = np.argmax(overlaps, axis=1)
max_overlaps = overlaps.max(axis=1)
pred_ent = predictions['ent_cls_score']
pred_ent = softmax(pred_ent[overlaps_assign])
ent_accuracy = np.sum(np.multiply(pred_ent, gt_ent)) / np.sum(gt_ent)
pred_rel = predictions['rel_cls_score']
pred_rel = softmax(pred_rel[overlaps_assign,:][:,overlaps_assign])
rel_accuracy = np.sum(np.multiply(pred_rel, gt_rel)) / np.sum(gt_rel)
pred_ent0 = predictions['ent_cls_score0']
pred_ent0 = softmax(pred_ent0)
ent0_accuracy = np.sum(np.multiply(pred_ent0, gt_ent)) / np.sum(gt_ent)
pred_rel0 = predictions['rel_cls_score0']
pred_rel0 = softmax(pred_rel0)
rel0_accuracy = np.sum(np.multiply(pred_rel0, gt_rel)) / np.sum(gt_rel)
results = {}
results["baseline_overlaps"] = np.mean(max_overlaps0)
results["gpi_overlaps"] = np.mean(max_overlaps)
results["sg_entity_acc"] = ent_accuracy
results["gt_sg_entity_acc"] = ent0_accuracy
results["sg_relation_acc"] = rel_accuracy
results["gt_sg_relation_acc"] = rel0_accuracy
return results
def iou_test(gt, gt_bbox, pred_mask, pred_label, pred, pred_prob, pred_bbox, im_info):
results = {}
# number of objects
results["total"] = 1
results["sub_iou"] = 0.0
results["obj_iou"] = 0.0
results["sub_kl"] = 0.0
results["obj_kl"] = 0.0
# accuracy
results["acc"] = np.sum(pred == pred_label).astype(float) / pred_label.shape[0]
# precision
for i in range(4):
total = np.sum(np.logical_and(pred == i, pred_mask != 0)).astype(float)
if total != 0:
results["prec" + str(i)] = np.sum(np.logical_and(np.logical_and(pred == pred_label, pred_label == i), pred_mask != 0)).astype(float) / total
results["prec" + str(i) + "_total"] = 1.0
else:
results["prec" + str(i)] = 0.0
results["prec" + str(i) + "_total"] = 0.0
# recall
for i in range(4):
total = np.sum(np.logical_and(pred_label == i, pred_mask != 0)).astype(float)
if total != 0:
results["recall" + str(i)] = np.sum(np.logical_and(np.logical_and(pred == pred_label, pred_label == i), pred_mask != 0)).astype(float) / total
results["recall" + str(i) + "_total"] = 1.0
else:
results["recall" + str(i)] = 0.0
results["recall" + str(i) + "_total"] = 0.0
width = MASK_WIDTH
height = MASK_HEIGHT
MASK_SHAPE = (width, height)
mask_sub_gt = np.zeros(MASK_SHAPE, dtype=float)
mask_obj_gt = np.zeros(MASK_SHAPE, dtype=float)
mask_sub_pred = np.zeros(MASK_SHAPE, dtype=float)
mask_obj_pred = np.zeros(MASK_SHAPE, dtype=float)
mask_sub_pred_bool = np.zeros(MASK_SHAPE, dtype=bool)
mask_obj_pred_bool = np.zeros(MASK_SHAPE, dtype=bool)
# sub and obj bool mask
i = np.argmax(pred_prob[:, 1])
mask_sub_pred_bool[int(math.floor(pred_bbox[i][0] * MASK_SHAPE[0])):int(math.ceil(pred_bbox[i][2] * MASK_SHAPE[0])),
int(math.floor(pred_bbox[i][1] * MASK_SHAPE[1])):int(math.ceil(pred_bbox[i][3] * MASK_SHAPE[1]))] = True
i = np.argmax(pred_prob[:, 2])
mask_obj_pred_bool[int(math.floor(pred_bbox[i][0] * MASK_SHAPE[0])):int(math.ceil(pred_bbox[i][2] * MASK_SHAPE[0])),
int(math.floor(pred_bbox[i][1] * MASK_SHAPE[1])):int(math.ceil(pred_bbox[i][3] * MASK_SHAPE[1]))] = True
for i in range(pred.shape[0]):
if pred[i] == 1:
x1 = int(math.floor(pred_bbox[i][0] * MASK_SHAPE[0]))
x2 = int(math.ceil(pred_bbox[i][2] * MASK_SHAPE[0]))
y1 = int(math.floor(pred_bbox[i][1] * MASK_SHAPE[1]))
y2 = int(math.ceil(pred_bbox[i][3] * MASK_SHAPE[1]))
mask_sub_pred_bool[x1:x2, y1:y2] = True
if pred[i] == 2:
x1 = int(math.floor(pred_bbox[i][0] * MASK_SHAPE[0]))
x2 = int(math.ceil(pred_bbox[i][2] * MASK_SHAPE[0]))
y1 = int(math.floor(pred_bbox[i][1] * MASK_SHAPE[1]))
y2 = int(math.ceil(pred_bbox[i][3] * MASK_SHAPE[1]))
mask_obj_pred_bool[x1:x2, y1:y2] = True
# GT mask
for i in range(gt.shape[0]):
if gt[i] == 1:
x1 = int(math.floor(gt_bbox[i][0] * MASK_SHAPE[0]))
x2 = int(math.ceil(gt_bbox[i][2] * MASK_SHAPE[0]))
y1 = int(math.floor(gt_bbox[i][1] * MASK_SHAPE[1]))
y2 = int(math.ceil(gt_bbox[i][3] * MASK_SHAPE[1]))
mask_sub_gt[x1:x2, y1:y2] = 1.0
if gt[i] == 2:
x1 = int(math.floor(gt_bbox[i][0] * MASK_SHAPE[0]))
x2 = int(math.ceil(gt_bbox[i][2] * MASK_SHAPE[0]))
y1 = int(math.floor(gt_bbox[i][1] * MASK_SHAPE[1]))
y2 = int(math.ceil(gt_bbox[i][3] * MASK_SHAPE[1]))
mask_obj_gt[x1:x2, y1:y2] = 1.0
# predicted mask
for i in range(pred.shape[0]):
x1 = int(math.floor(pred_bbox[i][0] * MASK_SHAPE[0]))
x2 = int(math.ceil(pred_bbox[i][2] * MASK_SHAPE[0]))
y1 = int(math.floor(pred_bbox[i][1] * MASK_SHAPE[1]))
y2 = int(math.ceil(pred_bbox[i][3] * MASK_SHAPE[1]))
mask = np.zeros(MASK_SHAPE, dtype=float)
mask[x1:x2, y1:y2] = 1.0
mask_sub_pred = np.maximum(mask_sub_pred, mask * pred_prob[i, 1])
mask_obj_pred = np.maximum(mask_obj_pred, mask * pred_prob[i, 2])
sub_iou = iou(mask_sub_gt.astype(bool), mask_sub_pred_bool)
obj_iou = iou(mask_obj_gt.astype(bool), mask_obj_pred_bool)
sub_kl = kl(mask_sub_gt, mask_sub_pred)
obj_kl = kl(mask_obj_gt, mask_obj_pred)
results["sub_iou"] += sub_iou
results["obj_iou"] += obj_iou
results["sub_kl"] += sub_kl
results["obj_kl"] += obj_kl
return results
def iou(mask_a, mask_b):
union = np.sum(np.logical_or(mask_a, mask_b))
if union == 0:
return 0.0
intersection = np.sum(np.logical_and(mask_a, mask_b))
return float(intersection) / float(union)
def kl(mask_gt, mask_pred):
gt = mask_gt.astype(float) / (np.sum(mask_gt) + k.backend.epsilon())
pred = mask_pred.astype(float) / ( | np.sum(mask_pred) | numpy.sum |
import numpy as np
from seisig import*
def create_timewedgeModel(seismic, model, dtc, Theta, Beta, tBottom, tTop, wedgeAngle, Q=False):
print('\n\n Cálculos del modelo de cuña sintético\n\n')
FreqVel = model.vp[0]
for z in range(seismic.zLen):
print(('CDP #{} de {}').format(z+1, seismic.zLen))
for x in range(seismic.xTraces):
R = ReflectivityS( ns = seismic.ySamples )
#top reflector
digitize_wedge(R, model, dtc, Theta[z][x], Beta[z][x], tTop[z][x], 'top', wedgeAngle)
Wv = Wavelet(wtype='bp', wf=[5, 10, 40, 80], duration=0.28, wdt=seismic.dt)
#Wv = Wavelet(wtype='r', wf=75)
if Q:
Wv.apply_Q(tTop[z][x], FreqVel)
trace = Trace(wavelet = Wv, rseries = R.rserie)
#base reflector
R = ReflectivityS( ns = seismic.ySamples )
digitize_wedge(R, model, dtc, Theta[z][x], Beta[z][x], tBottom[z][x], 'base', wedgeAngle)
Wv = Wavelet(wtype='bp', wf=[5, 10, 40, 80], duration=0.28, wdt=seismic.dt)
#Wv = Wavelet(wtype='r', wf=75)
if Q:
Wv.apply_Q(tBottom[z][x], FreqVel)
traceB = Trace(wavelet = Wv, rseries = R.rserie)
trace+= traceB
#calculation made on individual trace are made here
seismic.add_trace(trace, x, z)
def Xmin(angmax, topDepth):
return -np.tan(angmax) * topDepth
def Xmax(angmax, topDepth, gamma, dhmax):
return topDepth * np.tan(angmax) + dhmax / np.tan(gamma)
def XonWedge(angle_in, topDepth, Xsrc):
xw = Xsrc + topDepth * np.tan(angle_in)
if xw.any() < -0.1:
raise ValueError('Something went wrong on XonWedge')
return -1
else:
return xw
def DHtop(angle_in, topDepth, gamma, Xsrc):
return XonWedge(angle_in, topDepth, Xsrc) * np.tan(gamma)
def AlphaTr(angle_in, V1, V2):
return np.arcsin(np.sin(angle_in) * V2 / V1)
def BetaBase(angle_in, gamma, V1, V2):
return AlphaTr(angle_in, V1, V2) + gamma
def PsiTr(angle_in, gamma, V1, V2):
return np.arcsin(np.sin(DeltaUp(angle_in, gamma, V1, V2)) * V1/V2)
def DeltaUp(angle_in, gamma, V1, V2):
return 2 * BetaBase(angle_in, gamma, V1, V2) - AlphaTr(angle_in, V1, V2)
def P1(angle_in, topDepth):
return topDepth / np.cos(angle_in)
def P2(angle_in, topDepth, gamma, Xsrc, V1, V2):
return ( np.cos(gamma) * DHtop(angle_in, topDepth, gamma, Xsrc) / \
np.cos(BetaBase(angle_in, gamma, V1, V2)) )
def XbaseWedge(angle_in, topDepth, gamma, Xsrc, V1, V2):
xb = XonWedge(angle_in, topDepth, Xsrc) + np.sin(AlphaTr(angle_in, V1, V2)) * \
P2(angle_in, topDepth, gamma, Xsrc, V1, V2)
if xb.any() < -0.1:
raise ValueError('Something went wrong on XbaseWedge')
return -1
else:
return xb
def DHbase(angle_in, topDepth, gamma, Xsrc, V1, V2):
return XbaseWedge(angle_in, topDepth, gamma, Xsrc, V1, V2) * np.tan(gamma)
def P3(angle_in, topDepth, gamma, Xsrc, V1, V2):
return np.cos(AlphaTr(angle_in, V1, V2)) * P2(angle_in, topDepth, gamma, Xsrc, V1, V2) \
/ np.cos(2 * gamma + AlphaTr(angle_in, V1, V2))
def P4(angle_in, topDepth, gamma, V1, V2):
return topDepth / np.cos(PsiTr(angle_in, gamma, V1, V2))
def fullOffset(angle_in, topDepth, gamma, Xsrc, V1, V2):
return P1(angle_in, topDepth) * np.sin(angle_in) + P3(angle_in, topDepth, gamma, Xsrc, V1, V2)\
* np.sin(2 * BetaBase(angle_in, gamma, V1, V2)) / np.cos(AlphaTr(angle_in, V1, V2)) + \
np.tan(PsiTr(angle_in, gamma, V1, V2)) * topDepth
def ThetaEquiv(angle_in, topDepth, gamma, Xsrc, V1, V2):
return np.arctan(0.5 * fullOffset(angle_in, topDepth, gamma, Xsrc, V1, V2) / topDepth)
def wedge_shotgather(gamma, radmax_downwards, radmax_upwards, angstep, topDepth, velocities, X):
v1, v2 = velocities[0], velocities[1] #m/s
Angles_in = np.zeros(0, dtype='float')
Angles_top = np.zeros(0, dtype='float')
Angles_base = np.zeros(0, dtype='float')
rad_in = -np.arctan(X / topDepth) #ang min
while True:
beta = BetaBase(rad_in, gamma, v1, v2)
delta = DeltaUp(rad_in, gamma, v1, v2)
theta = ThetaEquiv(rad_in, topDepth, gamma, X, v1, v2)
Angles_in = np.append(Angles_in, rad_in)
Angles_base = np.append(Angles_base, beta)
Angles_top = np.append(Angles_top, theta)
if ((theta >= radmax_downwards) or (delta >= radmax_upwards)):
break
rad_in += angstep
RayPath_top = 2 * topDepth / np.cos(Angles_top)
RayPath_base1 = P1(Angles_in, topDepth) + P4(Angles_in, topDepth, gamma, v1, v2)
RayPath_base2 = P2(Angles_in, topDepth, gamma, X, v1, v2) + \
P3(Angles_in, topDepth, gamma, X, v1, v2)
RayPath_base = RayPath_base1 + RayPath_base2
TopTime = RayPath_top / v1
BaseTime = ((RayPath_base1 / v1) + (RayPath_base2 / v2))
CDPtop = XonWedge(Angles_top, topDepth, X)
CDPbase = XbaseWedge(Angles_in, topDepth, gamma, X, v1, v2)
TopDH = DHtop(Angles_top, topDepth, gamma, X)
BaseDH = DHbase(Angles_in, topDepth, gamma, X, v1, v2)
return Angles_top, Angles_base, RayPath_top, RayPath_base, TopTime, BaseTime, TopDH, BaseDH, \
CDPtop, CDPbase
def wedge_array_maker(model, wedgeSlope, dhmax, maxAng, topDepth, nsrc=500):
import warnings
warnings.filterwarnings("error")
velocities = model.vp
v1, v2 = velocities[0], velocities[1] #m/s
gamma = np.radians(wedgeSlope)
try:
radmax_downwards = min(np.arcsin(v1/v2), np.radians(maxAng))
except:
radmax_downwards = np.radians(maxAng)
try:
radmax_upwards = min(np.arcsin(v2/v1), DeltaUp(radmax_downwards, gamma, v1, v2))
except:
radmax_upwards = DeltaUp(radmax_downwards, gamma, v1, v2)
srcMin = Xmin(radmax_downwards, topDepth)
srcMax = Xmax(radmax_downwards, topDepth, gamma, dhmax)
XsrcVector = np.linspace(srcMin, srcMax, nsrc)
XsrcStep = XsrcVector[-1] - XsrcVector[-2]
angStep = np.arctan(XsrcStep / topDepth)
#print(XsrcVector)
sizeX = int(np.ceil(1+2 * radmax_downwards/angStep))
spanSize = np.zeros(XsrcVector.size, dtype='int')
for i in range(XsrcVector.size):
th, be, ru, rl, tt, tb, dhu, dhl, cdpu, cdpl = wedge_shotgather(gamma, radmax_downwards, \
radmax_upwards, angStep, topDepth, velocities, XsrcVector[i])
spanSize[i] = th.size
if i == 0:
TH = np.nan * np.ones(sizeX, dtype='float')
TH[:th.size] = th
BE = np.nan * np.ones(sizeX, dtype='float')
BE[:be.size] = be
RU = np.nan * np.ones(sizeX, dtype='float')
RU[:ru.size] = ru
RL = np.nan * np.ones(sizeX, dtype='float')
RL[:rl.size] = rl
TT = np.nan * np.ones(sizeX, dtype='float')
TT[:tt.size] = tt
TB = np.nan * np.ones(sizeX, dtype='float')
TB[:tb.size] = tb
DHU = np.nan * np.ones(sizeX, dtype='float')
DHU[:dhu.size] = dhu
DHL = np.nan * np.ones(sizeX, dtype='float')
DHL[:dhl.size] = dhl
CDPU = np.nan * np.ones(sizeX, dtype='float')
CDPU[:cdpu.size] = cdpu
CDPL = np.nan * np.ones(sizeX, dtype='float')
CDPL[:cdpl.size] = cdpl
X = np.nan * np.ones(sizeX, dtype='float')
X[:cdpl.size] = XsrcVector[i] * np.ones(cdpl.size, dtype='float')
else:
aux = np.nan * np.ones(sizeX, dtype='float')
aux[:th.size] = th
TH = np.vstack([TH, aux])
aux[:be.size] = be
BE = np.vstack([BE, aux])
aux[:ru.size] = ru
RU = np.vstack([RU, aux])
aux[:rl.size] = rl
RL = np.vstack([RL, aux])
aux[:tt.size] = tt
TT = np.vstack([TT, aux])
aux[:tb.size] = tb
TB = np.vstack([TB, aux])
aux[:dhu.size] = dhu
DHU = np.vstack([DHU, aux])
aux[:dhl.size] = dhl
DHL = np.vstack([DHL, aux])
aux[:cdpu.size] = cdpu
CDPU = np.vstack([CDPU, aux])
aux[:cdpl.size] = cdpl
CDPL = np.vstack([CDPL, aux])
aux[:cdpl.size] = XsrcVector[i] * np.ones(cdpl.size, dtype='float')
X = np.vstack([X, aux])
del(aux)
return TH[~np.isnan(TH)], BE[~np.isnan(BE)], RU[~np.isnan(RU)], RL[~np.isnan(RL)], TT[~np.isnan(TT)], \
TB[~np.isnan(TB)], DHU[~np.isnan(DHU)], DHL[~np.isnan(DHL)], CDPU[~np.isnan(CDPU)], \
CDPL[~np.isnan(CDPL)], X[~np.isnan(X)], XsrcStep, XsrcVector
def CDPgather(srcspacing, cdpMax, CDParray, th, be, ru, rl, tt, tb, dhu, dhl):
'''
all the arrays should be reshaped to 1d
'''
cdpRanges = np.arange(0.0, cdpMax + 2 * srcspacing, srcspacing)
zSize = cdpRanges.size-1
cdpVector = np.zeros([zSize, 2])
TH = np.zeros([zSize, zSize], dtype='float')
BE = np.zeros([zSize, zSize], dtype='float')
RU = np.zeros([zSize, zSize], dtype='float')
RL = np.zeros([zSize, zSize], dtype='float')
TT = np.zeros([zSize, zSize], dtype='float')
TB = np.zeros([zSize, zSize], dtype='float')
DHU = np.zeros([zSize, zSize], dtype='float')
DHL = | np.zeros([zSize, zSize], dtype='float') | numpy.zeros |
"""Tests of the homogeneity module"""
import unittest
import dcor
import numpy as np
class TestEnergyTest(unittest.TestCase):
"""Tests for the homogeneity energy test function."""
def test_same_distribution_same_parameters(self):
"""
Test that the test works on equal distributions.
As the distributions are the same, the test should not reject
the null hypothesis.
"""
vector_size = 10
num_samples = 100
mean = np.zeros(vector_size)
cov = np.eye(vector_size)
random_state = np.random.RandomState(0)
a = random_state.multivariate_normal(mean=mean,
cov=cov,
size=num_samples)
b = random_state.multivariate_normal(mean=mean,
cov=cov,
size=num_samples)
significance = 0.01
num_resamples = int(3 / significance + 1)
result = dcor.homogeneity.energy_test(
a, b, num_resamples=num_resamples, random_state=random_state)
self.assertGreater(result.p_value, significance)
def test_same_distribution_different_means(self):
"""
Test that the test works on distributions with different means.
As the distributions are not the same, the test should reject
the null hypothesis.
"""
vector_size = 10
num_samples = 100
mean_0 = np.zeros(vector_size)
mean_1 = np.ones(vector_size)
cov = np.eye(vector_size)
random_state = np.random.RandomState(0)
a = random_state.multivariate_normal(mean=mean_0, cov=cov,
size=num_samples)
b = random_state.multivariate_normal(mean=mean_1, cov=cov,
size=num_samples)
significance = 0.01
num_resamples = int(3 / significance + 1)
result = dcor.homogeneity.energy_test(
a, b, num_resamples=num_resamples, random_state=random_state)
self.assertLess(result.p_value, significance)
def test_same_distribution_different_covariances(self):
"""
Test that the test works on distributions with different covariance.
As the distributions are not the same, the test should reject
the null hypothesis.
"""
vector_size = 10
num_samples = 100
mean = np.zeros(vector_size)
cov_0 = np.eye(vector_size)
cov_1 = 3 * np.eye(vector_size)
random_state = np.random.RandomState(0)
a = random_state.multivariate_normal(mean=mean, cov=cov_0,
size=num_samples)
b = random_state.multivariate_normal(mean=mean, cov=cov_1,
size=num_samples)
significance = 0.01
num_resamples = int(3 / significance + 1)
result = dcor.homogeneity.energy_test(
a, b, num_resamples=num_resamples, random_state=random_state)
self.assertLess(result.p_value, significance)
def test_different_distributions(self):
"""
Test that the test works on different distributions.
As the distributions are not the same, the test should reject
the null hypothesis.
"""
num_samples = 100
random_state = | np.random.RandomState(0) | numpy.random.RandomState |
from fastconv import corr1d
import numpy as np
import os
TESTCASE_PATH = 'testcases'
MULTIDATA_MULTICHAN_FNAME = 'multidata_multichan.npy'
MULTICHAN_FILTERS_FNAME = 'multifilters.npy'
FILTER_PATH = os.path.join(TESTCASE_PATH, MULTICHAN_FILTERS_FNAME)
DATA_PATH = os.path.join(TESTCASE_PATH, MULTIDATA_MULTICHAN_FNAME)
FILTERS = np.load(FILTER_PATH)
DATA = np.load(DATA_PATH)
def test_corr1D_AA_double():
test_data = DATA[0, 35, :].astype(np.float64)
test_filter = FILTERS[0, 35, :].astype(np.float64)
comparison = np.correlate(test_data, test_filter, mode='valid') # type: np.ndarray
my_output = corr1d.short_filter_correlate1D(test_data, test_filter) # type: np.ndarray
assert my_output.dtype == np.float64, 'data type should be np.float64'
assert comparison.shape == my_output.shape, 'shape is {0}, should be {1}'.format(my_output.shape,
comparison.shape)
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_corr1D_AA_float():
test_data = DATA[0, 35, :].astype(np.float32)
test_filter = FILTERS[0, 35, :].astype(np.float32)
comparison = np.correlate(test_data, test_filter, mode='valid')
my_output = corr1d.short_filter_correlate1D(test_data, test_filter)
assert my_output.dtype == np.float32, 'data type should be np.float32'
assert comparison.shape == my_output.shape, 'shape is {0}, should be {1}'.format(my_output.shape,
comparison.shape)
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_corr1D_AB_double():
test_data = DATA[0, 35, 1000:2001].astype(np.float64)
test_filter = FILTERS[0, 35, :].astype(np.float64)
comparison = np.correlate(test_data, test_filter, mode='valid') # type: np.ndarray
my_output = corr1d.short_filter_correlate1D(test_data, test_filter) # type: np.ndarray
assert my_output.dtype == np.float64, 'data type should be np.float64'
assert comparison.shape == my_output.shape, 'shape is {0}, should be {1}'.format(my_output.shape,
comparison.shape)
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_corr1D_AB_float():
test_data = DATA[0, 35, 1000:2001].astype(np.float32)
test_filter = FILTERS[0, 35, :].astype(np.float32)
comparison = np.correlate(test_data, test_filter, mode='valid')
my_output = corr1d.short_filter_correlate1D(test_data, test_filter)
assert my_output.dtype == np.float32, 'data type should be np.float32'
assert comparison.shape == my_output.shape, 'shape is {0}, should be {1}'.format(my_output.shape,
comparison.shape)
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_corr1D_AC_double():
test_data = FILTERS[0, 35, :].astype(np.float64)
test_filter = FILTERS[0, 35, :].astype(np.float64)
comparison = np.correlate(test_data, test_filter, mode='valid') # type: np.ndarray
my_output = corr1d.short_filter_correlate1D(test_data, test_filter) # type: np.ndarray
assert my_output.dtype == np.float64, 'data type should be np.float64'
assert comparison.shape == my_output.shape, 'shape is {0}, should be {1}'.format(my_output.shape,
comparison.shape)
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_corr1D_AC_float():
test_data = FILTERS[0, 35, :].astype(np.float32)
test_filter = FILTERS[0, 35, :].astype(np.float32)
comparison = np.correlate(test_data, test_filter, mode='valid')
my_output = corr1d.short_filter_correlate1D(test_data, test_filter)
assert my_output.dtype == np.float32, 'data type should be np.float32'
assert comparison.shape == my_output.shape, 'shape is {0}, should be {1}'.format(my_output.shape,
comparison.shape)
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_single_filter_multidata_1D_A_double():
test_data = DATA[0, ...].astype(np.float64)
test_filter = FILTERS[0, 35, :].astype(np.float64)
comparison = np.zeros((test_data.shape[0], test_data.shape[1] - test_filter.shape[0] + 1),
dtype=np.float64)
for i in range(test_data.shape[0]):
comparison[i, ...] = np.correlate(test_data[i, :], test_filter)
my_output = corr1d.single_filter_multiple_data_correlate1D(test_data, test_filter)
assert my_output.dtype == np.float64
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_single_filter_multidata_1D_A_float():
test_data = DATA[0, ...].astype(np.float32)
test_filter = FILTERS[0, 35, :].astype(np.float32)
comparison = np.zeros((test_data.shape[0], test_data.shape[1] - test_filter.shape[0] + 1),
dtype=np.float32)
for i in range(test_data.shape[0]):
comparison[i, ...] = np.correlate(test_data[i, :], test_filter)
my_output = corr1d.single_filter_multiple_data_correlate1D(test_data, test_filter)
assert my_output.dtype == np.float32
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_single_filter_multidata_1D_B_double():
test_data = DATA[0, :, :1001].astype(np.float64)
test_filter = FILTERS[0, 35, :].astype(np.float64)
comparison = np.zeros((test_data.shape[0], test_data.shape[1] - test_filter.shape[0] + 1),
dtype=np.float64)
for i in range(test_data.shape[0]):
comparison[i, ...] = np.correlate(test_data[i, :], test_filter)
my_output = corr1d.single_filter_multiple_data_correlate1D(test_data, test_filter)
assert my_output.dtype == np.float64
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_single_filter_multidata_1D_B_float():
test_data = DATA[0, :, :1001].astype(np.float32)
test_filter = FILTERS[0, 35, :].astype(np.float32)
comparison = np.zeros((test_data.shape[0], test_data.shape[1] - test_filter.shape[0] + 1),
dtype=np.float32)
for i in range(test_data.shape[0]):
comparison[i, ...] = np.correlate(test_data[i, :], test_filter)
my_output = corr1d.single_filter_multiple_data_correlate1D(test_data, test_filter)
assert my_output.dtype == np.float32
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_single_data_multifilter_1D_A_double():
test_data = DATA[0, 35, :].astype(np.float64)
test_filter = FILTERS[0, :, :].astype(np.float64)
comparison = np.zeros((test_filter.shape[0], test_data.shape[0] - test_filter.shape[1] + 1),
dtype=np.float64)
for i in range(test_filter.shape[0]):
comparison[i, ...] = np.correlate(test_data, test_filter[i, :])
my_output = corr1d.multiple_filter_single_data_correlate1D(test_data, test_filter)
assert my_output.dtype == np.float64
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_single_data_multifilter_1D_A_float():
test_data = DATA[0, 35, :].astype(np.float32)
test_filter = FILTERS[0, :, :].astype(np.float32)
comparison = np.zeros((test_filter.shape[0], test_data.shape[0] - test_filter.shape[1] + 1),
dtype=np.float32)
for i in range(test_filter.shape[0]):
comparison[i, ...] = np.correlate(test_data, test_filter[i, :])
my_output = corr1d.multiple_filter_single_data_correlate1D(test_data, test_filter)
assert my_output.dtype == np.float32
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_single_data_multifilter_1D_B_double():
test_data = DATA[0, 54, 1337:9999].astype(np.float64)
test_filter = FILTERS[0, :, :].astype(np.float64)
comparison = np.zeros((test_filter.shape[0], test_data.shape[0] - test_filter.shape[1] + 1),
dtype=np.float64)
for i in range(test_filter.shape[0]):
comparison[i, ...] = np.correlate(test_data, test_filter[i, :])
my_output = corr1d.multiple_filter_single_data_correlate1D(test_data, test_filter)
assert my_output.dtype == np.float64
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_single_data_multifilter_1D_B_float():
test_data = DATA[0, 54, 1337:9999].astype(np.float32)
test_filter = FILTERS[0, :, :].astype(np.float32)
comparison = np.zeros((test_filter.shape[0], test_data.shape[0] - test_filter.shape[1] + 1),
dtype=np.float32)
for i in range(test_filter.shape[0]):
comparison[i, ...] = np.correlate(test_data, test_filter[i, :])
my_output = corr1d.multiple_filter_single_data_correlate1D(test_data, test_filter)
assert my_output.dtype == np.float32
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_multidata_multifilter_1D_A_double():
test_data = DATA[0, 13:26, :].astype(np.float64)
test_filter = FILTERS[0, 15:19, :].astype(np.float64)
comparison = np.zeros((test_data.shape[0], test_filter.shape[0], test_data.shape[1] - test_filter.shape[1] + 1),
dtype=np.float64)
for j in range(test_data.shape[0]):
for i in range(test_filter.shape[0]):
comparison[j, i, :] = np.correlate(test_data[j, :], test_filter[i, :])
my_output = corr1d.multiple_filter_multiple_data_correlate1D(test_data, test_filter)
assert my_output.dtype == np.float64
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_multidata_multifilter_1D_A_float():
test_data = DATA[0, 13:26, :].astype(np.float32)
test_filter = FILTERS[0, 15:19, :].astype(np.float32)
comparison = np.zeros((test_data.shape[0], test_filter.shape[0], test_data.shape[1] - test_filter.shape[1] + 1),
dtype=np.float32)
for j in range(test_data.shape[0]):
for i in range(test_filter.shape[0]):
comparison[j, i, :] = np.correlate(test_data[j, :], test_filter[i, :])
my_output = corr1d.multiple_filter_multiple_data_correlate1D(test_data, test_filter)
assert my_output.dtype == np.float32
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_single_data_single_filter_accum_A_double():
test_data = (DATA[0, :, :] / 10.0).astype(np.float64)
test_filter = (FILTERS[0, :, :] / 10.0).astype(np.float64)
buffer = np.zeros((test_data.shape[0], test_data.shape[1] - test_filter.shape[1] + 1),
dtype=np.float64)
for j in range(test_data.shape[0]):
buffer[j, :] = np.correlate(test_data[j, :], test_filter[j, :])
comparison = np.sum(buffer, axis=0)
my_output = corr1d.multichan_accum_correlate1D(test_data, test_filter)
assert my_output.dtype == np.float64
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_single_data_single_filter_accum_A_float():
test_data = (DATA[0, :, :] / 10.0).astype(np.float32)
test_filter = (FILTERS[0, :, :] / 10.0).astype(np.float32)
buffer = np.zeros((test_data.shape[0], test_data.shape[1] - test_filter.shape[1] + 1),
dtype=np.float32)
for j in range(test_data.shape[0]):
buffer[j, :] = np.correlate(test_data[j, :], test_filter[j, :])
comparison = np.sum(buffer, axis=0)
my_output = corr1d.multichan_accum_correlate1D(test_data, test_filter)
assert my_output.dtype == np.float32
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_single_data_multifilter_accum_A_double():
test_data = (DATA[0, :13, :] / 10.0).astype(np.float64)
test_filter = (FILTERS[:, :13, :] / 10.0).astype(np.float64)
buffer = np.zeros((test_filter.shape[0], test_data.shape[0], test_data.shape[1] - test_filter.shape[2] + 1),
dtype=np.float64)
for k in range(test_filter.shape[0]):
for j in range(test_data.shape[0]):
buffer[k, j, :] = np.correlate(test_data[j, :], test_filter[k, j, :])
comparison = np.sum(buffer, axis=1)
my_output = corr1d.batch_filter_multichan_accum_correlate1D(test_data, test_filter)
print(np.max(np.abs(comparison - my_output)))
assert my_output.dtype == np.float64
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_single_data_multifilter_accum_A_float():
test_data = (DATA[0, :13, :] / 10.0).astype(np.float32)
test_filter = (FILTERS[:, :13, :] / 10.0).astype(np.float32)
buffer = np.zeros((test_filter.shape[0], test_data.shape[0], test_data.shape[1] - test_filter.shape[2] + 1),
dtype=np.float32)
for k in range(test_filter.shape[0]):
for j in range(test_data.shape[0]):
buffer[k, j, :] = np.correlate(test_data[j, :], test_filter[k, j, :])
comparison = np.sum(buffer, axis=1)
my_output = corr1d.batch_filter_multichan_accum_correlate1D(test_data, test_filter)
print(np.max(np.abs(comparison - my_output)))
assert my_output.dtype == np.float32
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-3, atol=1e-2)
def test_multidata_single_filter_accum_A_double():
test_data = (DATA[:, :13, :] / 10.0).astype(np.float64)
test_filter = (FILTERS[0, :13, :] / 10.0).astype(np.float64)
buffer = np.zeros((test_data.shape[0], test_data.shape[1], test_data.shape[2] - test_filter.shape[1] + 1),
dtype=np.float64)
for k in range(test_data.shape[0]):
for j in range(test_data.shape[1]):
buffer[k, j, :] = np.correlate(test_data[k, j, :], test_filter[j, :])
comparison = np.sum(buffer, axis=1)
my_output = corr1d.batch_data_multichan_accum_correlate1D(test_data, test_filter)
print(np.max(np.abs(comparison - my_output)))
assert my_output.dtype == np.float64
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-2, atol=1e-2)
def test_multidata_single_filter_accum_A_float():
test_data = (DATA[:, :13, :] / 10.0).astype(np.float32)
test_filter = (FILTERS[0, :13, :] / 10.0).astype(np.float32)
buffer = np.zeros((test_data.shape[0], test_data.shape[1], test_data.shape[2] - test_filter.shape[1] + 1),
dtype=np.float32)
for k in range(test_data.shape[0]):
for j in range(test_data.shape[1]):
buffer[k, j, :] = np.correlate(test_data[k, j, :], test_filter[j, :])
comparison = np.sum(buffer, axis=1)
my_output = corr1d.batch_data_multichan_accum_correlate1D(test_data, test_filter)
print(np.max(np.abs(comparison - my_output)))
assert my_output.dtype == np.float32
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-2, atol=1e-2)
def test_multidata_multifilter_accum_A_double():
test_data = (DATA[:, :13, :] / 10.0).astype(np.float64)
test_filter = (FILTERS[:, :13, :] / 10.0).astype(np.float64)
buffer = np.zeros((test_data.shape[0], test_filter.shape[0],
test_data.shape[1], test_data.shape[2] - test_filter.shape[2] + 1),
dtype=np.float64)
for k in range(test_data.shape[0]):
for l in range(test_filter.shape[0]):
for j in range(test_data.shape[1]):
buffer[k, l, j, :] = np.correlate(test_data[k, j, :], test_filter[l, j, :])
comparison = np.sum(buffer, axis=2)
my_output = corr1d.batch_data_batch_filter_multichan_accum_correlate1D(test_data, test_filter)
print(np.max(np.abs(comparison - my_output)))
assert my_output.dtype == np.float64
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-2, atol=1e-2)
def test_multidata_multifilter_accum_A_float():
test_data = (DATA[:, :13, :] / 10.0).astype(np.float32)
test_filter = (FILTERS[:, :13, :] / 10.0).astype(np.float32)
buffer = np.zeros((test_data.shape[0], test_filter.shape[0],
test_data.shape[1], test_data.shape[2] - test_filter.shape[2] + 1),
dtype=np.float32)
for k in range(test_data.shape[0]):
for l in range(test_filter.shape[0]):
for j in range(test_data.shape[1]):
buffer[k, l, j, :] = np.correlate(test_data[k, j, :], test_filter[l, j, :])
comparison = np.sum(buffer, axis=2)
my_output = corr1d.batch_data_batch_filter_multichan_accum_correlate1D(test_data, test_filter)
print(np.max(np.abs(comparison - my_output)))
assert my_output.dtype == np.float32
assert my_output.shape == comparison.shape
assert np.allclose(comparison, my_output, rtol=1e-2, atol=1e-2)
def test__single_filter_single_data_channel_correlate1D():
N_CH = 13
test_data = (DATA[0, :N_CH, :] / 10.0).astype(np.float64)
test_filter = (FILTERS[0, :N_CH, :] / 10.0).astype(np.float64)
buffer = np.zeros((test_data.shape[0], test_data.shape[1] - test_filter.shape[1] + 1),
dtype=np.float64)
for k in range(N_CH):
buffer[k, :] = np.correlate(test_data[k, :], test_filter[k, :])
my_output = corr1d.single_filter_single_data_channel_correlate1D(test_data,
test_filter)
print(np.max(np.abs(buffer - my_output)))
assert my_output.dtype == np.float64
assert my_output.shape == buffer.shape
assert np.allclose(buffer, my_output, rtol=1e-2, atol=1e-2)
def test__single_filter_single_data_channel_correlate1D__float():
N_CH = 13
test_data = (DATA[0, :N_CH, :] / 10.0).astype(np.float32)
test_filter = (FILTERS[0, :N_CH, :] / 10.0).astype(np.float32)
buffer = np.zeros((test_data.shape[0], test_data.shape[1] - test_filter.shape[1] + 1),
dtype=np.float32)
for k in range(N_CH):
buffer[k, :] = np.correlate(test_data[k, :], test_filter[k, :])
my_output = corr1d.single_filter_single_data_channel_correlate1D(test_data,
test_filter)
print(np.max(np.abs(buffer - my_output)))
assert my_output.dtype == np.float32
assert my_output.shape == buffer.shape
assert np.allclose(buffer, my_output, rtol=1e-2, atol=1e-2)
def test__single_filter_batch_data_channel_correlate1D():
N_CH = 13
test_data = (DATA[:, :N_CH, :] / 10.0).astype(np.float64)
test_filter = (FILTERS[0, :N_CH, :] / 10.0).astype(np.float64)
buffer = np.zeros((test_data.shape[0], test_data.shape[1], test_data.shape[2] - test_filter.shape[1] + 1),
dtype=np.float64)
for i in range(test_data.shape[0]):
for k in range(test_data.shape[1]):
buffer[i, k, :] = np.correlate(test_data[i, k, :], test_filter[k, :])
my_output = corr1d.single_filter_batch_data_channel_correlate1D(test_data,
test_filter)
print(np.max(np.abs(buffer - my_output)))
assert my_output.dtype == np.float64
assert my_output.shape == buffer.shape
assert np.allclose(buffer, my_output, rtol=1e-2, atol=1e-2)
def test__single_filter_batch_data_channel_correlate1D__float():
N_CH = 13
test_data = (DATA[:, :N_CH, :] / 10.0).astype(np.float32)
test_filter = (FILTERS[0, :N_CH, :] / 10.0).astype(np.float32)
buffer = np.zeros((test_data.shape[0], test_data.shape[1], test_data.shape[2] - test_filter.shape[1] + 1),
dtype=np.float32)
for i in range(test_data.shape[0]):
for k in range(test_data.shape[1]):
buffer[i, k, :] = np.correlate(test_data[i, k, :], test_filter[k, :])
my_output = corr1d.single_filter_batch_data_channel_correlate1D(test_data,
test_filter)
print(np.max(np.abs(buffer - my_output)))
assert my_output.dtype == np.float32
assert my_output.shape == buffer.shape
assert np.allclose(buffer, my_output, rtol=1e-2, atol=1e-2)
def test__batch_filter_single_data_channel_correlate1D():
N_CH = 13
test_data = (DATA[0, :N_CH, :] / 10.0).astype(np.float64)
test_filter = (FILTERS[:, :N_CH, :] / 10.0).astype(np.float64)
buffer = np.zeros((test_filter.shape[0], test_filter.shape[1], test_data.shape[1] - test_filter.shape[2] + 1),
dtype=np.float64)
for i in range(test_filter.shape[0]):
for k in range(N_CH):
buffer[i, k, :] = np.correlate(test_data[k, :], test_filter[i, k, :])
my_output = corr1d.batch_filter_single_data_channel_correlate1D(test_data,
test_filter)
print(np.max(np.abs(buffer - my_output)))
assert my_output.dtype == np.float64
assert my_output.shape == buffer.shape
assert np.allclose(buffer, my_output, rtol=1e-2, atol=1e-2)
def test__batch_filter_single_data_channel_correlate1D__float():
N_CH = 13
test_data = (DATA[0, :N_CH, :] / 10.0).astype(np.float32)
test_filter = (FILTERS[:, :N_CH, :] / 10.0).astype(np.float32)
buffer = np.zeros((test_filter.shape[0], test_filter.shape[1], test_data.shape[1] - test_filter.shape[2] + 1),
dtype=np.float32)
for i in range(test_filter.shape[0]):
for k in range(N_CH):
buffer[i, k, :] = np.correlate(test_data[k, :], test_filter[i, k, :])
my_output = corr1d.batch_filter_single_data_channel_correlate1D(test_data,
test_filter)
print(np.max( | np.abs(buffer - my_output) | numpy.abs |
# coding: utf-8
# In[1]:
# Package imports
import numpy as np
import matplotlib.pyplot as plt
from testCases import *
import sklearn
import sklearn.datasets
import sklearn.linear_model
from planar_utils import plot_decision_boundary, sigmoid, load_planar_dataset, load_extra_datasets
get_ipython().run_line_magic('matplotlib', 'inline')
np.random.seed(1) # set a seed so that the results are consistent
# ## Neural Network model
#
# You are going to train a Neural Network with a single hidden layer.
#
# **Here is our model**:
# <img src="images/classification_kiank.png" style="width:600px;height:300px;">
#
# **Mathematically**:
#
# For one example $x^{(i)}$:
# $$z^{[1] (i)} = W^{[1]} x^{(i)} + b^{[1] (i)}\tag{1}$$
# $$a^{[1] (i)} = \tanh(z^{[1] (i)})\tag{2}$$
# $$z^{[2] (i)} = W^{[2]} a^{[1] (i)} + b^{[2] (i)}\tag{3}$$
# $$\hat{y}^{(i)} = a^{[2] (i)} = \sigma(z^{ [2] (i)})\tag{4}$$
# $$y^{(i)}_{prediction} = \begin{cases} 1 & \mbox{if } a^{[2](i)} > 0.5 \\ 0 & \mbox{otherwise } \end{cases}\tag{5}$$
#
# Given the predictions on all the examples, you can also compute the cost $J$ as follows:
# $$J = - \frac{1}{m} \sum\limits_{i = 0}^{m} \large\left(\small y^{(i)}\log\left(a^{[2] (i)}\right) + (1-y^{(i)})\log\left(1- a^{[2] (i)}\right) \large \right) \small \tag{6}$$
#
# **Reminder**: The general methodology to build a Neural Network is to:
# 1. Define the neural network structure ( # of input units, # of hidden units, etc).
# 2. Initialize the model's parameters
# 3. Loop:
# - Implement forward propagation
# - Compute loss
# - Implement backward propagation to get the gradients
# - Update parameters (gradient descent)
#
# You often build helper functions to compute steps 1-3 and then merge them into one function we call `nn_model()`. Once you've built `nn_model()` and learnt the right parameters, you can make predictions on new data.
# ### Defining the neural network structure ####
#
# **Exercise**: Define three variables:
# - n_x: the size of the input layer
# - n_h: the size of the hidden layer (set this to 4)
# - n_y: the size of the output layer
#
# **Hint**: Use shapes of X and Y to find n_x and n_y. Also, hard code the hidden layer size to be 4.
# In[2]:
def layer_sizes(X, Y):
"""
Arguments:
X -- input dataset of shape (input size, number of examples)
Y -- labels of shape (output size, number of examples)
Returns:
n_x -- the size of the input layer
n_h -- the size of the hidden layer
n_y -- the size of the output layer
"""
n_x = X.shape[0]
n_h = 4
n_y = Y.shape[0]
return (n_x, n_h, n_y)
# In[3]:
X_assess, Y_assess = layer_sizes_test_case()
(n_x, n_h, n_y) = layer_sizes(X_assess, Y_assess)
if __name__=='__main__':
print("The size of the input layer is: n_x = " + str(n_x))
print("The size of the hidden layer is: n_h = " + str(n_h))
print("The size of the output layer is: n_y = " + str(n_y))
# **Expected Output** (these are not the sizes you will use for your network, they are just used to assess the function you've just coded).
#
# <table style="width:20%">
# <tr>
# <td>**n_x**</td>
# <td> 5 </td>
# </tr>
#
# <tr>
# <td>**n_h**</td>
# <td> 4 </td>
# </tr>
#
# <tr>
# <td>**n_y**</td>
# <td> 2 </td>
# </tr>
#
# </table>
# ### Initialize the model's parameters ####
#
# **Exercise**: Implement the function `initialize_parameters()`.
#
# **Instructions**:
# - Make sure your parameters' sizes are right. Refer to the neural network figure above if needed.
# - You will initialize the weights matrices with random values.
# - Use: `np.random.randn(a,b) * 0.01` to randomly initialize a matrix of shape (a,b).
# - You will initialize the bias vectors as zeros.
# - Use: `np.zeros((a,b))` to initialize a matrix of shape (a,b) with zeros.
# In[4]:
def initialize_parameters(n_x, n_h, n_y):
"""
Argument:
n_x -- size of the input layer
n_h -- size of the hidden layer
n_y -- size of the output layer
Returns:
params -- python dictionary containing your parameters:
W1 -- weight matrix of shape (n_h, n_x)
b1 -- bias vector of shape (n_h, 1)
W2 -- weight matrix of shape (n_y, n_h)
b2 -- bias vector of shape (n_y, 1)
"""
np.random.seed(2)
W1 = np.random.randn(n_h, n_x)*0.01
b1 = np.zeros(shape=(n_h,1))
W2 = np.random.randn(n_y, n_h)*0.01
b2 = np.zeros(shape=(n_y,1))
assert (W1.shape == (n_h, n_x))
assert (b1.shape == (n_h, 1))
assert (W2.shape == (n_y, n_h))
assert (b2.shape == (n_y, 1))
parameters = {"W1": W1,
"b1": b1,
"W2": W2,
"b2": b2}
return parameters
# In[5]:
n_x, n_h, n_y = initialize_parameters_test_case()
parameters = initialize_parameters(n_x, n_h, n_y)
if __name__=='__main__':
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
# **Expected Output**:
#
# <table style="width:90%">
# <tr>
# <td>**W1**</td>
# <td> [[-0.00416758 -0.00056267]
# [-0.02136196 0.01640271]
# [-0.01793436 -0.00841747]
# [ 0.00502881 -0.01245288]] </td>
# </tr>
#
# <tr>
# <td>**b1**</td>
# <td> [[ 0.]
# [ 0.]
# [ 0.]
# [ 0.]] </td>
# </tr>
#
# <tr>
# <td>**W2**</td>
# <td> [[-0.01057952 -0.00909008 0.00551454 0.02292208]]</td>
# </tr>
#
#
# <tr>
# <td>**b2**</td>
# <td> [[ 0.]] </td>
# </tr>
#
# </table>
#
#
# ### The Loop ####
#
# **Question**: Implement `forward_propagation()`.
#
# **Instructions**:
# - Look above at the mathematical representation of your classifier.
# - You can use the function `sigmoid()`. It is built-in (imported) in the notebook.
# - You can use the function `np.tanh()`. It is part of the numpy library.
# - The steps you have to implement are:
# 1. Retrieve each parameter from the dictionary "parameters" (which is the output of `initialize_parameters()`) by using `parameters[".."]`.
# 2. Implement Forward Propagation. Compute $Z^{[1]}, A^{[1]}, Z^{[2]}$ and $A^{[2]}$ (the vector of all your predictions on all the examples in the training set).
# - Values needed in the backpropagation are stored in "`cache`". The `cache` will be given as an input to the backpropagation function.
# In[6]:
def forward_propagation(X, parameters):
"""
Argument:
X -- input data of size (n_x, m)
parameters -- python dictionary containing your parameters (output of initialization function)
Returns:
A2 -- The sigmoid output of the second activation
cache -- a dictionary containing "Z1", "A1", "Z2" and "A2"
"""
# Retrieve each parameter from the dictionary "parameters"
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
# Implement Forward Propagation to calculate A2 (probabilities)
Z1 = np.matmul(W1,X) + b1
A1 = np.tanh(Z1)
Z2 = | np.matmul(W2,A1) | numpy.matmul |
import logging
import os
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
import scipy
from scipy import stats
import datetime
import networkx as nx
import matplotlib as mpl
import sys
import tqdm
from matplotlib import animation, rc
from matplotlib.ticker import MaxNLocator
from IPython.display import clear_output, HTML, Image
from neurolib.utils import atlases
import neurolib.utils.paths as paths
import neurolib.utils.functions as func
class Brainplot:
def __init__(self, Cmat, data, nframes=None, dt=0.1, fps=25, labels=False, darkmode=True):
self.sc = Cmat
self.n = self.sc.shape[0]
self.data = data
self.darkmode = darkmode
self.G = nx.Graph()
self.G.add_nodes_from(range(self.n))
coords = {}
atlas = atlases.AutomatedAnatomicalParcellation2()
for i, c in enumerate(atlas.coords()):
coords[i] = [c[0], c[1]]
self.position = coords
self.edge_threshold = 0.01
self.fps = fps
self.dt = dt
nframes = nframes or int((data.shape[1] * self.dt / 1000) * self.fps) # 20 fps default
logging.info(f"Defaulting to {nframes} frames at {self.fps} fp/s")
self.nframes = nframes
self.frame_interval = self.data.shape[1] // self.nframes
self.interval = int(self.frame_interval * self.dt)
self.draw_labels = labels
for t in range(self.n):
# print t
for s in range(t):
# print( n, t, s)
if self.sc[t, s] > self.edge_threshold:
# print( 'edge', t, s, self.sc[t,s])
self.G.add_edge(t, s)
# node color map
self.cmap = plt.get_cmap("plasma") # mpl.cm.cool
# default style
self.imagealpha = 0.5
self.edgecolor = "k"
self.edgealpha = 0.8
self.edgeweight = 1.0
self.nodesize = 50
self.nodealpha = 0.8
self.vmin = 0
self.vmax = 50
self.lw = 0.5
if self.darkmode:
plt.style.use("dark")
# let's choose a cyberpunk style for the dark theme
self.edgecolor = "#37f522"
self.edgeweight = 0.5
self.edgealpha = 0.6
self.nodesize = 40
self.nodealpha = 0.8
self.vmin = 0
self.vmax = 30
self.cmap = plt.get_cmap("cool") # mpl.cm.cool
self.imagealpha = 0.5
self.lw = 1
fname = os.path.join("neurolib", "data", "resources", "clean_brain_white.png")
else:
# plt.style.use("light")
fname = os.path.join("neurolib", "data", "resources", "clean_brain.png")
self.imgTopView = mpl.image.imread(fname)
self.pbar = tqdm.tqdm(total=self.nframes)
def update(self, i, ax, ax_rates=None, node_color=None, node_size=None, node_alpha=None, clear=True):
frame = int(i * self.frame_interval)
node_color = node_color or self.data[:, frame]
node_size = node_size or self.nodesize
node_alpha = node_alpha or self.nodealpha
if clear:
ax.cla()
im = ax.imshow(self.imgTopView, alpha=self.imagealpha, origin="upper", extent=[40, 202, 28, 240])
ns = nx.draw_networkx_nodes(
self.G,
pos=self.position,
node_color=node_color,
cmap=self.cmap,
vmin=self.vmin,
vmax=self.vmax,
node_size=node_size,
alpha=node_alpha,
ax=ax,
edgecolors="k",
)
es = nx.draw_networkx_edges(
self.G, pos=self.position, alpha=self.edgealpha, edge_color=self.edgecolor, ax=ax, width=self.edgeweight
)
labels = {}
for ni in range(self.n):
labels[ni] = str(ni)
if self.draw_labels:
nx.draw_networkx_labels(self.G, self.position, labels, font_size=8)
ax.set_axis_off()
ax.set_xlim(20, 222)
ax.set_ylim(25, 245)
# timeseries
if ax_rates:
ax_rates.cla()
ax_rates.set_xticks([])
ax_rates.set_yticks([])
ax_rates.set_ylabel("Brain activity", fontsize=8)
t = np.linspace(0, frame * self.dt, frame)
ax_rates.plot(t, np.mean(self.data[:, :frame], axis=0).T, lw=self.lw)
t_total = self.data.shape[1] * self.dt
ax_rates.set_xlim(0, t_total)
self.pbar.update(1)
plt.tight_layout()
if clear:
clear_output(wait=True)
def plot_rates(model):
plt.figure(figsize=(4, 1))
plt_until = 10 * 1000
plt.plot(model.t[model.t < plt_until], model.output[:, model.t < plt_until].T, lw=0.5)
def plot_brain(
model, ds, color=None, size=None, title=None, cbar=True, cmap="RdBu", clim=None, cbarticks=None, cbarticklabels=None
):
"""Dump and easy wrapper around the brain plotting function.
:param color: colors of nodes, defaults to None
:type color: numpy.ndarray, optional
:param size: size of the nodes, defaults to None
:type size: numpy.ndarray, optional
:raises ValueError: Raises error if node size is too big.
"""
s = Brainplot(ds.Cmat, model.output, fps=10, darkmode=False)
s.cmap = plt.get_cmap(cmap)
dpi = 300
fig = plt.figure(dpi=dpi)
ax = plt.gca()
if title:
ax.set_title(title, fontsize=26)
if clim is None:
s.vmin, s.vmax = np.min(color), np.max(color)
else:
s.vmin, s.vmax = clim[0], clim[1]
if size is not None:
node_size = size
else:
# some weird scaling of the color to a size
def norm(what):
what = what.copy()
what -= np.min(what)
what /= np.max(what)
return what
node_size = list(np.exp((norm(color) + 2) * 2))
if isinstance(color, np.ndarray):
color = list(color)
if isinstance(node_size, np.ndarray):
node_size = list(node_size)
if np.max(node_size) > 2000:
raise ValueError(f"node_size too big: {np.max(node_size)}")
s.update(0, ax, node_color=color, node_size=node_size, clear=False)
if cbar:
cbaxes = fig.add_axes([0.68, 0.1, 0.015, 0.7])
sm = plt.cm.ScalarMappable(cmap=s.cmap, norm=plt.Normalize(vmin=s.vmin, vmax=s.vmax))
cbar = plt.colorbar(sm, cbaxes, ticks=cbarticks)
cbar.ax.tick_params(labelsize=16)
if cbarticklabels:
cbar.ax.set_yticklabels(cbarticklabels)
# other plotting
def plot_average_timeseries(model, xticks=False, kwargs={}, xlim=None, figsize=(8, 1)):
# print("{} Peaks found ({} p/s)".format(len(peaks), len(peaks)/(model.params['duration']/1000)))
plt.figure(figsize=figsize, dpi=300)
# cut rates if xlim is given
if xlim:
rates = model.output[:, (model.t / 1000 > xlim[0]) & (model.t / 1000 < xlim[1])]
t = model.t[(model.t / 1000 > xlim[0]) & (model.t / 1000 < xlim[1])]
print(rates.shape)
else:
rates = model.output
t = model.t
plt.plot(t / 1000, np.mean(rates, axis=0), **kwargs)
# plt.plot(model.t/1000, signal, lw=2, label = 'smoothed')
plt.autoscale(enable=True, axis="x", tight=True)
# for p in peaks:
# plt.vlines(p*params['dt']*10, 0, 0.008, color='b', lw=2, alpha=0.6)
# plt.xlim(0, 10000)
# plt.plot(model.t/1000, states*10, lw=2, c='C1', alpha=0.4, label='detected state')
# plt.xlabel("Time [s]")
if not xticks:
plt.xticks([])
if xlim:
plt.xlim(*xlim)
plt.ylabel("Rate [Hz]")
# plt.legend(loc=1, fontsize=8)
# import matplotlib as mpl
# mpl.rcParams['axes.spines.left'] = False
# mpl.rcParams['axes.spines.right'] = False
# mpl.rcParams['axes.spines.top'] = False
# mpl.rcParams['axes.spines.bottom'] = False
plt.gca().spines["right"].set_visible(False)
plt.gca().spines["top"].set_visible(False)
plt.gca().spines["left"].set_visible(False)
plt.gca().spines["bottom"].set_visible(False)
plt.tight_layout()
set_axis_size(*figsize)
def detectSWStates(output, threshold=1):
states = np.zeros(output.shape)
# super_threshold_indices = rates > threshold
# works with 1D thresholds, per node
super_threshold_indices = np.greater(output.T, threshold).T
states[super_threshold_indices] = 1
return states
def filter_long_states(model, states):
states = states.copy()
LENGTH_THRESHOLD = int(50 / model.params["dt"]) # ms
for s in states:
lengths = get_state_lengths(s)
current_idx = 0
last_long_state = lengths[0][0] # first state
for state, length in lengths:
if length >= LENGTH_THRESHOLD:
last_long_state = state
else:
s[current_idx : current_idx + length] = last_long_state
current_idx += length
return states
def detectSWs(model, up_thresh=0.01, detectSWStates_kw=None, filter_long=True):
threshold_per_node = up_thresh * np.max(model.output, axis=1) # as per Nghiem et al., 2020, Renart et al., 2010
states = np.zeros(model.output.shape)
if detectSWStates_kw:
logging.warning(f"Warning: detectSWStates_kw is not implemented anymore, using up_thresh = {up_thresh}")
states = detectSWStates(model.output, threshold=threshold_per_node)
# for i, o in enumerate(model.output):
# smoothed = o # scipy.ndimage.gaussian_filter(o, sigma=500)
# s = detectSWStates(model.t, smoothed, **detectSWStates_kw)
# states[i, :] = s
if filter_long:
states = filter_long_states(model, states)
return states
def get_involvement(states, down=True):
"""Returns involvement in up- and down-states.
:param states: state array (NxT)
:type states: np.ndarray
:return: Involvement time series (1xT)
:rtype: np.ndarray
"""
up_involvement = np.sum(states, axis=0) / states.shape[0]
if down:
return 1 - up_involvement
else:
return up_involvement
def plot_states_timeseries(model, states, title=None, labels=True, cmap="plasma"):
figsize = (8, 2)
plt.figure(figsize=figsize)
plt.imshow(
states,
extent=[0, states.shape[1] * model.params.dt / 1000, 0, states.shape[0]],
aspect="auto",
cmap=plt.cm.get_cmap(cmap, 2),
)
if labels:
plt.xlabel("Time [s]")
plt.ylabel("Node")
else:
plt.xticks([])
plt.yticks([])
if title:
plt.title(title)
plt.autoscale(enable=True, axis="x", tight=True)
if labels:
cbar = plt.colorbar(pad=0.02)
cbar.set_ticks([0.25, 0.75])
cbar.ax.set_yticklabels(["Down", "Up"], rotation=90, va="center")
cbar.ax.tick_params(width=0, labelsize=14)
plt.tight_layout()
set_axis_size(*figsize)
def plot_involvement_timeseries(model, involvement):
fig, axs = plt.subplots(1, 2, figsize=(10, 4), gridspec_kw={"width_ratios": [4, 1]})
axs[0].set_title("Involvement of brain areas in SO events")
axs[0].plot(model.t / 1000, involvement * 100, c="C0")
axs[0].set_ylabel("Involvement [%]")
axs[0].set_xlabel("Time [s]")
axs[0].set_ylim([0, 100])
axs[0].set_aspect("auto")
axs[1].hist(involvement * 100, bins=10, orientation="horizontal", density=True, rwidth=0.8, edgecolor="k")
axs[1].set_yticks([])
axs[1].set_xlabel("KDE")
axs[1].set_ylim([0, 100])
plt.tight_layout()
def plot_degree_duration_scatterplot(model, states, ds, lingres=False, color_down="C0", color_up="C1"):
figsize = (2, 2)
plt.figure(figsize=figsize)
area_downtimes = np.sum(states == 0, axis=1) / model.output.shape[1] * 100
area_uptimes = np.sum(states == 1, axis=1) / model.output.shape[1] * 100
fig, ax = plt.subplots(1, 1, figsize=(3, 3))
degrees = [(np.sum(ds.Cmat, axis=1))[i] / np.max(np.sum(ds.Cmat, axis=1)) for i in range(ds.Cmat.shape[0])]
ax.scatter(
degrees,
area_uptimes,
s=14,
c=color_up,
edgecolor="black",
linewidth=0.5,
label="up-state",
)
ax.scatter(
degrees,
area_downtimes,
s=14,
c=color_down,
edgecolor="black",
linewidth=0.5,
label="down-state",
)
if lingres:
plot_linregress(degrees, area_downtimes, kwargs={"c": color_down, "zorder": -2})
if lingres:
plot_linregress(degrees, area_uptimes, kwargs={"c": color_up, "zorder": -2})
for i in range(ds.Cmat.shape[0]):
degree = (np.sum(ds.Cmat, axis=1))[i] / np.max(np.sum(ds.Cmat, axis=1))
plt.legend(fontsize=12, frameon=False, markerscale=1.8, handletextpad=-0.5)
ax.set_xlabel("Node degree")
ax.set_ylabel("Time spent [%]")
plt.tight_layout()
set_axis_size(*figsize)
def plot_transition_phases(node_mean_phases_down, node_mean_phases_up, atlas):
def hide_axis(ax):
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.spines["bottom"].set_visible(False)
ax.spines["left"].set_visible(False)
names = []
phases_down = []
phases_up = []
ipsilateral_mean_down_phase = [
(i + k) / 2 for i, k in zip(node_mean_phases_down[0::2], node_mean_phases_down[1::2])
]
ipsilateral_mean_up_phase = [(i + k) / 2 for i, k in zip(node_mean_phases_up[0::2], node_mean_phases_up[1::2])]
# ipsilateral_names = [i[:-2] for i, k in zip(atlas.names()[0::2], atlas.names()[1::2])]
ipsilateral_names = [
f"{i[:-2]} ({nr*2}, {nr*2+1})" for nr, (i, k) in enumerate(zip(atlas.names()[0::2], atlas.names()[1::2]))
]
# clean up names
for i in range(len(ipsilateral_names)):
ipsilateral_names[i] = ipsilateral_names[i].replace("_", " ")
for i, ipsi_region in enumerate(np.argsort(ipsilateral_mean_down_phase)):
# print(i, region, node_mean_phases_down[region], atlas.names()[region], atlas.coords()[region][2])
# y_coord = (i%80)/30
names.append(ipsilateral_names[ipsi_region])
phases_down.append(ipsilateral_mean_down_phase[ipsi_region])
phases_up.append(ipsilateral_mean_up_phase[ipsi_region])
names = [n.replace("_", " ") for n in names]
fig, ax = plt.subplots(1, 1, figsize=(6, 3))
# left=-np.asarray(phases[::-1]),
ax.bar(names, phases_up, lw=1, ls="--", color="C0", label="up-transition")
ax.bar(names, phases_down, lw=1, ls="--", color="C1", label="down-transition")
# ax.tick_params(axis="both", which="major", labelsize=8)
# ax.yaxis.set_tick_params(width=1)
ax.autoscale(enable=True, axis="x", tight=True)
ax.legend(fontsize=8, loc=1, bbox_to_anchor=(0.98, 1.0))
ax.set_ylabel("Phase of transition", fontsize=12)
# ax.text(0.2, 80, "Up-state", fontsize=10)
# ax.text(-0.2, 80, "Down-state", fontsize=10, ha="right")
# ax.set_title("Mean transition phase")
hide_axis(ax)
plt.grid(alpha=0.5, lw=0.5)
ax.tick_params(axis="y", labelsize=10)
ax.tick_params(axis="x", which="major", labelsize=7, rotation=90)
plt.tight_layout(pad=0)
def plot_transition_phases_against_eachother(node_mean_phases_down, node_mean_phases_up):
figsize = (2, 2)
figsize = np.multiply(figsize, 0.75)
plt.figure(figsize=figsize)
plt.scatter(
node_mean_phases_down,
node_mean_phases_up,
s=8,
edgecolor="black",
linewidth=0.5,
c="lightgray",
)
plot_linregress(node_mean_phases_down, node_mean_phases_up, kwargs={"c": "k", "alpha": 0.5, "zorder": -2})
plt.xlabel("Mean down-phase")
plt.ylabel("Up-phase")
plt.tight_layout(pad=0)
set_axis_size(*figsize)
def plot_state_brain_areas(model, states, atlas, ds, color_down="C0", color_up="C1"):
fig, axs = plt.subplots(1, 1, figsize=(6, 3))
# axs.set_title("Time spent in up- and down-state per brain area", fontsize=12)
area_downtimes = np.sum(states == 0, axis=1) / model.output.shape[1] * 100
area_uptimes = np.sum(states == 1, axis=1) / model.output.shape[1] * 100
ipsilateral_downtimes = [(i + k) / 2 for i, k in zip(area_downtimes[0::2], area_downtimes[1::2])]
ipsilateral_uptimes = [(i + k) / 2 for i, k in zip(area_uptimes[0::2], area_uptimes[1::2])]
ipsilateral_uptimes_diff = [(i - k) for i, k in zip(area_uptimes[0::2], area_uptimes[1::2])]
ipsilateral_names = [
f"{i[:-2]} ({nr*2}, {nr*2+1})" for nr, (i, k) in enumerate(zip(atlas.names()[0::2], atlas.names()[1::2]))
]
# clean up names
for i in range(len(ipsilateral_names)):
ipsilateral_names[i] = ipsilateral_names[i].replace("_", " ")
axs.bar(
ipsilateral_names,
ipsilateral_uptimes,
bottom=ipsilateral_downtimes,
edgecolor="k",
color="C0",
linewidth="0.2",
zorder=-10,
label="up-state",
)
axs.bar(ipsilateral_names, ipsilateral_downtimes, edgecolor="k", color="C1", linewidth="0.2", label="down-state")
axs.legend(fontsize=8, loc=1, bbox_to_anchor=(0.98, 0.9))
axs.autoscale(enable=True, axis="x", tight=True)
axs.spines["right"].set_visible(False)
axs.spines["top"].set_visible(False)
axs.spines["left"].set_visible(False)
axs.spines["bottom"].set_visible(False)
axs.tick_params(axis="x", which="major", labelsize=7, rotation=90)
# axs[0].set_xlabel("Brain area")
axs.set_ylabel("Time spent [%]", fontsize=12)
axs.set_yticks([0, 25, 50, 75, 100])
axs.tick_params(axis="y", labelsize=10)
# for i in range(ds.Cmat.shape[0]):
# degree = (np.sum(ds.Cmat, axis=1))[i] / np.max(np.sum(ds.Cmat, axis=1))
# axs[1].scatter(degree, area_downtimes[i], s=5, c="C1", edgecolor="black", linewidth="0.2")
# axs[1].scatter(degree, area_uptimes[i], s=5, c="C0", edgecolor="black", linewidth="0.2")
# axs[1].set_xlabel("Node degree")
# axs[1].set_xticks([0, 1, 2, 3])
# axs[1].set_yticklabels([])
plt.tight_layout(pad=0)
return area_downtimes, area_uptimes
def plot_involvement_durations(model, states, involvement, nbins=6, legend=False):
invs = {0: [], 1: []}
lens = {0: [], 1: []}
for s in states[:]:
lengths = get_state_lengths(s)
current_idx = 0
for state, length in lengths:
state = int(state)
# compuite average involvement during this state
mean_involvement = np.mean(involvement[current_idx : current_idx + length])
lens[state].append(length * model.params.dt) # convert to seconds
invs[state].append(mean_involvement)
current_idx += length
from scipy.stats import binned_statistic
figsize = (3, 2)
figsize = np.multiply(figsize, 0.75)
plt.figure(figsize=figsize)
up_bin_means, bin_edges, _ = binned_statistic(invs[1], lens[1], bins=nbins, range=(0, 1))
plt.bar(bin_edges[:-1], up_bin_means[::-1], width=0.04, edgecolor="k", color="C0", label="up-state")
down_bin_means, bin_edges, _ = binned_statistic(invs[0], lens[0], bins=nbins, range=(0, 1))
plt.bar(bin_edges[:-1] + 0.05, down_bin_means, width=0.04, edgecolor="k", color="C1", label="down-state")
if legend:
plt.legend(fontsize=8)
plt.xticks([0, 0.5, 1], [0, 50, 100])
axs = plt.gca()
axs.spines["right"].set_visible(False)
axs.spines["top"].set_visible(False)
axs.spines["left"].set_visible(False)
plt.gca().tick_params(axis="both", direction="out", which="major", bottom=True, left=True)
plt.xlabel("Involvement [%]")
plt.ylabel("Duration [ms]")
plt.tight_layout()
set_axis_size(*figsize)
def get_state_durations_flat(model, states):
durations = get_state_lengths(states)
ups, downs = get_updown_lengths(durations)
dt_to_s = model.params.dt / 1000 # return seconds
flat_ups = [u * dt_to_s for up in ups for u in up]
flat_downs = [d * dt_to_s for down in downs for d in down]
return flat_ups, flat_downs
def plot_state_durations(model, states, legend=True, alpha=1.0):
durations = get_state_lengths(states)
ups, downs = get_updown_lengths(durations)
dt_to_s = model.params.dt / 1000
flat_ups = [u * dt_to_s for up in ups for u in up]
flat_downs = [d * dt_to_s for down in downs for d in down]
# figsize = (3, 2.0)
figsize = (2, 1.7)
# figsize = np.multiply(figsize, 0.75)
plt.figure(figsize=figsize)
plt.hist(flat_ups, color="C0", label="up", edgecolor="k", linewidth=0.75)
plt.hist(flat_downs, color="C1", label="down", edgecolor="k", linewidth=0.75, alpha=alpha)
if legend:
plt.legend(fontsize=12, frameon=False)
plt.gca().set_yscale("log")
plt.gca().xaxis.set_major_locator(plt.MaxNLocator(4))
plt.ylabel("Log-probability")
plt.yticks([])
plt.xlabel("Duration [s]")
plt.gca().tick_params(axis="x", direction="out", which="major", bottom=True, left=True)
ax = plt.gca()
ax.spines["right"].set_visible(False)
ax.spines["top"].set_visible(False)
ax.spines["left"].set_visible(False)
# ax.spines["bottom"].set_visible(False)
plt.tight_layout()
set_axis_size(*figsize)
def plot_involvement_distribution(model, involvement, remove_xticks=True, color_localglobal=False):
# figsize = (3, 2)
figsize = (2, 1.7)
# figsize = np.multiply(figsize, 0.75)
plt.figure(figsize=figsize)
N, bins, patches = plt.hist(involvement * 100, bins=12, density=True, rwidth=0.8, edgecolor="k", color="C1")
if color_localglobal:
for i in range(0, len(patches) // 2):
patches[i].set_facecolor("C0")
for i in range(len(patches) // 2, len(patches)):
patches[i].set_facecolor("C1")
plt.xticks([0, 50, 100])
if remove_xticks:
plt.yticks([])
else:
y_vals = plt.gca().get_yticks()
plt.gca().set_yticklabels(["{:3.0f}".format(x * 100) for x in y_vals])
plt.ylabel("Probability")
plt.xlabel("Involvement [%]")
plt.gca().tick_params(axis="x", direction="out", which="major", bottom=True, left=True)
plt.xlim([0, 100])
ax = plt.gca()
ax.spines["right"].set_visible(False)
ax.spines["top"].set_visible(False)
ax.spines["left"].set_visible(False)
# ax.spines["bottom"].set_visible(False)
max_y = plt.gca().get_ylim()[1] * 1.1
plt.ylim(0, max_y * 1.1)
# plt.vlines([50], 0, max_y, linestyles="--", colors="#363638", alpha=0.9)
plt.text(25, max_y * 0.95, "local", fontsize=14, color="C0", ha="center")
plt.text(75, max_y * 0.95, "global", fontsize=14, color="C1", ha="center")
plt.tight_layout()
set_axis_size(*figsize)
def plot_involvement_mean_amplitude(model, involvement, skip=300, lingress=True):
figsize = (3, 2)
figsize = np.multiply(figsize, 0.75)
plt.figure(figsize=figsize)
rates = np.mean(model.output, axis=0)[::skip]
plt.scatter(
involvement[::skip] * 100,
rates,
# scipy.stats.zscore(np.mean(model.output, axis=0)[::skip]),
s=10,
edgecolor="w",
linewidth=0.2,
c="C1",
alpha=0.7,
)
# plt.gca().axhline(0, linestyle="--", lw=1, color="#ABB2BF", zorder=-1)
plt.xlim(0, 100)
plt.xticks([0, 50, 100])
plt.xlabel("Involvement [%]")
plt.ylabel("Rate [Hz]")
if lingress:
slope, intercept, r_value, p_value, std_err = plot_linregress(
involvement[::skip] * 100, rates, kwargs={"c": "k", "alpha": 0.75}
)
plt.text(50, np.max(rates) * 0.75, f"$R^2={r_value**2:0.2f}$")
axs = plt.gca()
axs.spines["right"].set_visible(False)
axs.spines["top"].set_visible(False)
axs.spines["left"].set_visible(False)
axs.spines["bottom"].set_visible(False)
plt.gca().tick_params(axis="both", direction="out", which="major", bottom=True, left=True)
plt.tight_layout()
set_axis_size(*figsize)
def get_state_lengths(xs):
"""
Get's the length of successive elements in a list.
Useful for computing inter-spike-intervals (ISI) or the length
of states.
Example: get_state_lengths([0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0])
Returns: [(0, 4), (1, 4), (0, 2), (1, 1), (0, 1)]
:param xs: Input list with successive states
:type xs: list
:return: List of (state, length) tuples
:rtype: list
"""
import itertools
if np.array(xs).ndim == 1:
durations = [(x, len(list(y))) for x, y in itertools.groupby(xs)]
elif np.array(xs).ndim > 1:
durations = [get_state_lengths(xss) for xss in xs]
return durations
def get_updown_lengths(durations):
"""Returns the length of all up- and down-states for each node"""
ups = []
downs = []
for i, l in enumerate(durations):
ups.append([u[1] for u in l if u[0] == 1.0])
downs.append([u[1] for u in l if u[0] == 0.0])
return ups, downs
def plot_linregress(x, y, plot=True, kwargs={}):
slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)
print(f"slope = {slope}, intercept = {intercept}, r_value = {r_value}, p_value = {p_value}, std_err = {std_err}")
if plot:
plt.plot(x, intercept + x * slope, **kwargs)
return slope, intercept, r_value, p_value, std_err
def plot_down_up_durations(model, durations, ds, plot_regression=False):
import matplotlib.cm as cm
all_ups = []
all_downs = []
all_colors = []
for n, dur in enumerate(durations):
# make sure to start with a down-state
skip = 0 if dur[0][0] == 0.0 else 1
down_durations = [d[1] * model.params.dt / 1000 for d in dur[skip::2]]
up_durations = [d[1] * model.params.dt / 1000 for d in dur[skip + 1 :: 2]]
# normalized degree [0, 1]
degree = (np.sum(ds.Cmat, axis=1))[n] / np.max(np.sum(ds.Cmat, axis=1))
for d, u in zip(down_durations, up_durations):
all_ups.append(u)
all_downs.append(d)
all_colors.append(degree)
fig_scale = 1.2
plt.figure(figsize=(3 * fig_scale, 2.5 * fig_scale))
plt.scatter(all_downs, all_ups, s=2, c=all_colors, cmap="plasma", alpha=0.8)
plt.ylabel("Next up-state duration [s]")
plt.xlabel("Down-state duration [s]")
plot_linregress(all_downs, all_ups, plot=plot_regression)
cbar = plt.colorbar()
cbar.set_label(label="Node degree", size=10)
cbar.ax.tick_params(labelsize=10)
plt.show()
def get_transition_phases(states, phase):
transitions = np.diff(states)
node_mean_phases_down = []
node_mean_phases_up = []
for ni, trs in enumerate(transitions):
down_phases = []
up_phases = []
for i, t in enumerate(trs):
if t == -1:
down_phases.append(float(phase[i]))
if t == 1:
up_phases.append(float(phase[i]))
mean_down_phase = scipy.stats.circmean(down_phases, high=np.pi, low=-np.pi, nan_policy="raise")
mean_up_phase = scipy.stats.circmean(up_phases, high=np.pi, low=-np.pi, nan_policy="raise")
print(f"Node {ni}: mean_down_phase = {mean_down_phase}, mean_up_phase = {mean_up_phase}")
node_mean_phases_down.append(mean_down_phase)
node_mean_phases_up.append(mean_up_phase)
return node_mean_phases_down, node_mean_phases_up
def phase_transition_coordinate(node_mean_phases_down, node_mean_phases_up, atlas):
coords = atlas.coords()
minmax_coords = [int(np.min([c[1] for c in coords])), int(np.max([c[1] for c in coords]))]
figsize = (2, 2)
plt.figure(figsize=figsize)
# ATTENTION!!!! MULTIPLYING COORDINATES WITH -1 SO THE PLOT GOES ANTERIOR TO POSTERIOR
y_coords = np.array([c[1] for c in coords]) * -1
plt.scatter(y_coords, node_mean_phases_down, c="C1", s=14, edgecolor="k", linewidth=0.5, label="down")
plt.scatter(y_coords, node_mean_phases_up, c="C0", s=14, edgecolor="k", linewidth=0.5, label="up")
# plt.legend(fontsize=8)
down_slope, down_intercept, down_r_value, down_p_value, down_std_err = stats.linregress(
y_coords, node_mean_phases_down
)
print(f"Down transitions: slope: {down_slope} r: {down_r_value}, p: {down_p_value}")
plt.plot(y_coords, (lambda c: down_intercept + down_slope * c)(y_coords), c="C1", label="x", zorder=-5)
up_slope, up_intercept, up_r_value, up_p_value, up_std_err = stats.linregress(y_coords, node_mean_phases_up)
print(f"Up transitions: slope: {up_slope} r: {up_r_value}, p: {up_p_value}")
plt.plot(y_coords, (lambda c: up_intercept + up_slope * c)(y_coords), c="C0", label="x", zorder=-5)
plt.xlabel("Coordinate")
plt.xticks([np.min(y_coords) + 30, np.max(y_coords) - 30], [f"Anterior", f"Posterior"])
plt.ylabel("Transition phase $\phi$")
plt.tight_layout()
set_axis_size(*figsize)
return (
down_slope,
down_intercept,
down_r_value,
down_p_value,
down_std_err,
up_slope,
up_intercept,
up_r_value,
up_p_value,
up_std_err,
)
def kuramoto(events):
import tqdm
# fill in event at the end of the timeseries
events[:, -1] = True
phases = []
logging.info("Determining phases ...")
for n, ev in tqdm.tqdm(enumerate(events), total=len(events)):
maximalist = np.where(ev)[0]
phases.append([])
last_event = 0
for m in maximalist:
for t in range(last_event, m):
phi = 2 * np.pi * float(t - last_event) / float(m - last_event)
phases[n].append(phi)
last_event = m
phases[n].append(2 * np.pi)
logging.info("Computing Kuramoto order parameter ...")
# determine kuramoto order paramter
kuramoto = []
nTraces = events.shape[0]
for t in tqdm.tqdm(range(events.shape[1]), total=events.shape[1]):
R = 1j * 0
for n in range(nTraces):
R += np.exp(1j * phases[n][t])
R /= nTraces
kuramoto.append(np.absolute(R))
return kuramoto
def plot_phases_and_involvement(model, involvement, phases, states):
fig, axs = plt.subplots(2, 1, figsize=(4, 2), sharex=True)
up_transitions = np.diff(states) > 0
down_transitions = np.diff(states) < 0
for i, ups in enumerate(up_transitions):
axs[0].vlines(np.where(ups)[0] * model.params.dt / 1000, 0, 3, lw=0.2, alpha=1, color="C0")
for i, downs in enumerate(down_transitions):
axs[0].vlines(np.where(downs)[0] * model.params.dt / 1000, -3, 0, lw=0.2, alpha=1, color="C1")
# annotate vlines
axs[0].text(7.7, 7.0, "up-transitions", fontsize=8)
axs[0].vlines(7.6, 6.8, 9.0, lw=1, color="C0")
axs[0].text(7.7, 4.4, "down-transitions", fontsize=8)
axs[0].vlines(7.6, 4.0, 6.2, lw=1, color="C1")
# axs[0].fill_between(model.t/1000, phases, 0, where=phases<0, zorder=-2, color='C0', alpha=0.8, label='$\phi < 0$')
# axs[0].fill_between(model.t/1000, phases, 0, where=phases>0, zorder=-2, color='C1', alpha=0.8, label='$\phi > 0$')
axs[0].plot(model.t / 1000, phases, zorder=2, lw=1, label="Global phase $\phi$", c="fuchsia")
axs[0].set_yticks([])
axs[0].legend(fontsize=8, frameon=False, loc="upper center", bbox_to_anchor=(0.5, 1.1), ncol=1)
axs[1].plot(model.t / 1000, np.mean(model.output, axis=0), c="k", alpha=1, lw=1, label="Mean rate")
axs[1].plot(model.t / 1000, involvement * 30, lw=1, c="C3", label="Involvement")
axs[1].set_xlim(0, 10)
axs[1].set_yticks([])
axs[1].set_xticks([0, 5, 10])
axs[1].tick_params(labelsize=8)
axs[1].set_xlabel("Time [s]", fontsize=8)
axs[1].legend(fontsize=8, frameon=False, loc="upper center", bbox_to_anchor=(0.5, 1.25), ncol=2)
for ax in axs:
ax.spines["right"].set_visible(False)
ax.spines["top"].set_visible(False)
ax.spines["left"].set_visible(False)
ax.spines["bottom"].set_visible(False)
plt.tight_layout()
plt.subplots_adjust(wspace=0, hspace=0.2)
# used for RESULT-dynamical-regimes-EXP-5.ipynb
def plot_ts(
model,
plot_nodes=[0],
plot_alpha=1,
plot_mean_background=False,
mean_alpha=0.3,
shift_mean=False,
adaptation=False,
stimulus=False,
stimulus_scale=1.0,
log_power=False,
log_freq=False,
norm_power=True,
title_add="",
lw=1,
figsize=(4, 1.5),
labels=False,
crop_zero=None,
xlim=None,
savename=None,
fontsize=None,
n_ticks=2,
tick_width=1,
tick_length=3,
legend=False,
yticks=None,
):
_, axs = plt.subplots(1, 1, dpi=600, figsize=figsize)
title = " ".join([f"{p} = {model.params[p]}" for p in ["mue_ext_mean", "mui_ext_mean", "b", "sigma_ou"]])
title += " " + title_add
plot_col = "k"
if str(plot_nodes) == "all":
plot_output = model.output
plot_adaptation = model.outputs.IA
plot_col = None
elif str(plot_nodes) == "mean":
plot_output = np.mean(model.output, axis=0)
plot_adaptation = np.mean(model.outputs.IA, axis=0)
else:
plot_output = model.output[plot_nodes]
plot_adaptation = model.outputs.IA[plot_nodes]
plot_col = None if len(plot_nodes) > 1 else "k"
if plot_mean_background:
mean_signal = np.mean(model.output, axis=0)
# plot_adaptation = model.outputs.IA if str(plot_nodes) == "all" else model.outputs.IA[plot_nodes]
plot_t = model.t / 1000
plot_stimulus = model.params["ext_exc_current"] * stimulus_scale
if xlim:
plot_t = plot_t[xlim[0] : xlim[1]]
if plot_output.ndim == 2:
plot_output = plot_output[:, xlim[0] : xlim[1]]
if adaptation:
plot_adaptation = plot_adaptation[:, xlim[0] : xlim[1]]
else:
plot_output = plot_output[xlim[0] : xlim[1]]
if adaptation:
plot_adaptation = plot_adaptation[xlim[0] : xlim[1]]
if stimulus and model.params["ext_exc_current"].ndim > 0:
plot_stimulus = plot_stimulus[xlim[0] : xlim[1]]
if plot_mean_background:
mean_signal = mean_signal[xlim[0] : xlim[1]]
axs.plot(
plot_t,
plot_output.T,
alpha=plot_alpha,
lw=lw,
c=plot_col,
# label="Firing rate" if len(plot_nodes) == 1 else None,
)
# plot the mean signal in the background?
if plot_mean_background:
if shift_mean:
mean_signal /= np.max(mean_signal)
mean_signal *= np.abs(np.max(plot_output) - np.min(plot_output)) / 4
mean_signal = mean_signal + np.max(plot_output) * 1.1
axs.plot(plot_t, mean_signal, alpha=mean_alpha, lw=lw, c="k", zorder=10, label="Mean brain")
# if a stimulus was present
if legend and stimulus and model.params["ext_exc_current"].ndim > 0:
axs.plot(plot_t, plot_stimulus, lw=lw, c="C1", label="Stimulus", alpha=0.8)
# add a line for adaptation current in legend
if adaptation:
axs.plot([0], [0], lw=lw, c="C0", label="Adaptation")
leg = axs.legend(frameon=True, fontsize=14, framealpha=0.9)
# Get the bounding box of the original legend
bb = leg.get_bbox_to_anchor().inverse_transformed(axs.transAxes)
# Change to location of the legend.
yOffset = +0.0
bb.y0 += yOffset
bb.y1 += yOffset
leg.set_bbox_to_anchor(bb, transform=axs.transAxes)
if adaptation and not stimulus:
color = "C0"
ax_adapt = axs.twinx()
# ax_adapt.set_ylabel("$I_A$ [pA]", color=color)
ax_adapt.tick_params(
axis="y",
color=color,
labelcolor=color,
direction="out",
length=tick_length,
width=tick_width,
labelsize=fontsize,
right=False,
)
# plot_adaptation = model.outputs.IA if str(plot_nodes) == "all" else model.outputs.IA[plot_nodes]
ax_adapt.plot(plot_t, plot_adaptation.T, lw=lw, label="Adaptation", color=color)
# ax_adapt.legend(loc=4)
if legend and adaptation:
ax_adapt.legend(loc="lower right", frameon=True, fontsize=14, framealpha=0.9)
ax_adapt.spines["right"].set_visible(False)
ax_adapt.spines["top"].set_visible(False)
ax_adapt.spines["left"].set_visible(False)
ax_adapt.spines["bottom"].set_visible(False)
ax_adapt.yaxis.set_major_locator(plt.MaxNLocator(n_ticks))
if labels:
axs.set_xlabel("Time [s]")
axs.set_ylabel("Rate $r_E$ [Hz]")
if adaptation:
ax_adapt.set_ylabel("Adaptation $I_A$ [pA]", color=color)
axs.spines["right"].set_visible(False)
axs.spines["top"].set_visible(False)
axs.spines["left"].set_visible(False)
axs.spines["bottom"].set_visible(False)
# reduce number of ticks
axs.yaxis.set_major_locator(plt.MaxNLocator(n_ticks))
axs.xaxis.set_major_locator(MaxNLocator(integer=True))
if yticks is not None:
axs.set_yticks(yticks)
axs.tick_params(
axis="both",
direction="out",
length=tick_length,
width=tick_width,
colors="k",
labelsize=fontsize,
bottom=False,
left=False,
)
if crop_zero:
axs.set_xlim(crop_zero, model.t[-1] / 1000)
plt.tight_layout()
# set the axis size precisely
set_axis_size(figsize[0], figsize[1])
if savename:
save_fname = os.path.join(paths.FIGURES_DIR, f"{savename}")
plt.savefig(save_fname)
# helper function
def set_axis_size(w, h, ax=None):
""" w, h: width, height in inches """
if not ax:
ax = plt.gca()
l = ax.figure.subplotpars.left
r = ax.figure.subplotpars.right
t = ax.figure.subplotpars.top
b = ax.figure.subplotpars.bottom
figw = float(w) / (r - l)
figh = float(h) / (t - b)
ax.figure.set_size_inches(figw, figh)
def plot_matrix(mat, cbarlabel, cbar=True, ylabels=True, plotlog=False):
figsize = (2, 2)
fig = plt.figure(figsize=figsize)
# fc_fit = du.model_fit(model, ds, bold_transient=bold_transient, fc=True)["mean_fc_score"]
# plt.title(f"FC (corr: {fc_fit:0.2f})", fontsize=12)
if plotlog:
from matplotlib.colors import LogNorm
im = plt.imshow(mat, norm=LogNorm(vmin=10e-5, vmax=np.max(mat)), origin="upper")
else:
im = plt.imshow(mat, origin="upper")
plt.ylabel("Node")
plt.xlabel("Node")
plt.xticks([0, 20, 40, 60])
plt.yticks([0, 20, 40, 60])
if ylabels == False:
plt.ylabel("")
plt.yticks([])
if cbar:
# cbaxes = fig.add_axes([0.95, 0.36, 0.02, 0.52])
cbar = plt.colorbar(im, ax=plt.gca(), fraction=0.046, pad=0.04)
# cbar = plt.colorbar(im, cbaxes)
# cbar.set_ticks([0, 1])
# cbar.ax.tick_params(width=0, labelsize=10)
cbar.set_label(label=cbarlabel, size=10, labelpad=-1)
plt.tight_layout()
set_axis_size(*figsize)
################### plot fits
def plot_fc(bold, model=None, bold_transient=0, cbar=False, ylabels=True):
if bold_transient and model:
t_bold = model.outputs.BOLD.t_BOLD[model.outputs.BOLD.t_BOLD > bold_transient] / 1000
bold = model.outputs.BOLD.BOLD[:, model.outputs.BOLD.t_BOLD > bold_transient]
figsize = (2, 2)
fig = plt.figure(figsize=figsize)
# fc_fit = du.model_fit(model, ds, bold_transient=bold_transient, fc=True)["mean_fc_score"]
# plt.title(f"FC (corr: {fc_fit:0.2f})", fontsize=12)
im = plt.imshow(func.fc(bold), origin="upper", clim=(0, 1))
plt.ylabel("Node")
plt.xlabel("Node")
plt.xticks([0, 20, 40, 60])
plt.yticks([0, 20, 40, 60])
if ylabels == False:
plt.ylabel("")
plt.yticks([])
if cbar:
cbaxes = fig.add_axes([0.95, 0.36, 0.02, 0.52])
cbar = plt.colorbar(im, cbaxes)
cbar.set_ticks([0, 1])
cbar.ax.tick_params(width=0, labelsize=10)
cbar.set_label(label="Correlation", size=10, labelpad=-1)
plt.tight_layout()
set_axis_size(*figsize)
def plot_fcd(bold, model=None, bold_transient=0, cbar=False, ylabels=True):
if bold_transient and model:
t_bold = model.outputs.BOLD.t_BOLD[model.outputs.BOLD.t_BOLD > bold_transient] / 1000
bold = model.outputs.BOLD.BOLD[:, model.outputs.BOLD.t_BOLD > bold_transient]
figsize = (2, 2)
fig = plt.figure(figsize=figsize)
fcd_matrix = func.fcd(bold)
print(fcd_matrix.shape)
im = plt.imshow(fcd_matrix, origin="upper")
plt.xlabel("Time [min]")
plt.ylabel("Time [min]")
# nticks = 3
# plt.xticks(np.linspace(0, fcd_matrix.shape[0] - 1, nticks), np.linspace(0, bold.shape[1] * 2.0, nticks, dtype=int))
# plt.yticks(np.linspace(0, fcd_matrix.shape[0] - 1, nticks), np.linspace(0, bold.shape[1] * 2.0, nticks, dtype=int))
plt.xticks([0, 32, 64], [0, 6, 12])
plt.yticks([0, 32, 64], [0, 6, 12])
if ylabels == False:
plt.ylabel("")
plt.yticks([])
if cbar:
cbaxes = fig.add_axes([0.9, 0.36, 0.02, 0.52])
cbar = plt.colorbar(im, cbaxes)
# cbar.set_ticks([0.4, 1])
cbar.ax.locator_params(nbins=5)
cbar.ax.tick_params(width=0, labelsize=10)
cbar.set_label(label="Correlation", size=10)
plt.tight_layout(w_pad=4.5)
set_axis_size(*figsize)
def plot_fcd_distribution(model, ds, bold_transient=0):
if bold_transient and model:
t_bold = model.outputs.BOLD.t_BOLD[model.outputs.BOLD.t_BOLD > bold_transient] / 1000
bold = model.outputs.BOLD.BOLD[:, model.outputs.BOLD.t_BOLD > bold_transient]
figsize = (4, 3)
fig = plt.figure(figsize=figsize)
# plot distribution in fcd
# axs[2, 1].set_title(f"FCD distance {fcd_fit:0.2f}", fontsize=12)
plt.ylabel("Density")
plt.yticks([])
plt.xticks([0, 0.5, 1])
plt.xlabel("FCD$_{ij}$")
m1 = func.fcd(bold)
triu_m1_vals = m1[np.triu_indices(m1.shape[0], k=1)]
plt.hist(triu_m1_vals, density=True, color="springgreen", zorder=10, alpha=0.6, edgecolor="k")
# plot fcd distributions of data
if hasattr(ds, "FCDs"):
for emp_fcd in ds.FCDs:
m1 = emp_fcd
triu_m1_vals = m1[ | np.triu_indices(m1.shape[0], k=1) | numpy.triu_indices |
import os
import logging
from PIL import Image
import numpy as np
import sklearn.datasets
import joblib
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms, datasets
import skorch.dataset
from skorch.utils import to_numpy
from utils.helpers import set_attributes
from .helpers import train_dev_split, make_ssl_dataset_
from .transforms import (precompute_batch_tranforms, global_contrast_normalization,
zca_whitening, random_translation, robust_minmax_scale,
gaussian_noise)
DIR = os.path.abspath(os.path.dirname(__file__))
DATASETS_DICT = {"cifar10": "CIFAR10",
"svhn": "SVHN",
"mnist": "MNIST",
"pts_circles": "None",
"pts_moons": "None",
"pts_var_gaus": "None",
"pts_cov_gaus": "None",
"pts_iso_gaus": "None"}
DATASETS = list(DATASETS_DICT.keys())
N_LABELS = {"cifar10": 4000,
"svhn": 1000,
"mnist": 100,
"pts_circles": 10,
"pts_moons": 6,
"pts_var_gaus": 12,
"pts_cov_gaus": 12,
"pts_iso_gaus": 12}
def get_dataset(dataset):
"""Return the correct dataset."""
dataset = dataset.lower()
try:
# eval because stores name as string in order to put it at top of file
return eval(DATASETS_DICT[dataset])
except KeyError:
raise ValueError("Unkown dataset: {}".format(dataset))
def get_train_dev_test_ssl(dataset,
n_labels=None,
root=None,
dev_size=0.1,
seed=123,
**kwargs):
"""Return the training, validation and test dataloaders
Parameters
----------
dataset : {"cifar", "svhn"}
Name of the dataset to load
n_labels : int
Number of labels to keep. If `None` uses dataset specific default.
root : str, optional
Path to the dataset root. If `None` uses the default one.
dev_size : float or int, optional
If float, should be between 0.0 and 1.0 and represent the proportion of
the dataset to include in the dev split. If int, represents the absolute
number of dev samples.
seed : int, optional
Random seed.
kwargs :
Additional arguments to `generate_train_dev_test_ssl`.
"""
_Dataset = get_dataset(dataset)
if n_labels is None:
n_labels = N_LABELS[dataset]
if _Dataset is None:
# has to generate
return generate_train_dev_test_ssl(dataset, n_labels,
dev_size=dev_size,
seed=seed,
**kwargs)
data_kwargs = dict()
if root is not None:
data_kwargs["root"] = root
# important to do train before test => compute ZCA on train
train = _Dataset(split="train", **data_kwargs)
test = _Dataset(split="test", **data_kwargs)
# Nota Bene: we are actually first doing the transformatiosn such as GCN
# the dev splitting => normalization also done on dev, which is not ideal
# but fine because not doing on the test set => final results will be correct
# but hyperparametrization is a little biased
train, dev = train_dev_split(train, dev_size=dev_size, seed=seed, is_stratify=True)
make_ssl_dataset_(train, n_labels, seed=seed, is_stratify=True)
return train, dev, test
# POINT DATASETS
def generate_train_dev_test_ssl(dataset, n_label,
n_unlabel=int(1e4),
n_test=int(1e4),
dev_size=0.1, seed=123, is_hard=False):
"""Genererate simple ssl datasets.
Parameters
----------
dataset : {"pts_circles", "pts_moons", "pts_var_gaus", "pts_cov_gaus", "pts_iso_gaus"}
Name of the dataset to generate
n_labels : int
Number of labelled examples.
n_lunabels : int
Number of unlabelled examples.
n_test : int
Number of test examples.
root : str
Path to the dataset root. If `None` uses the default one.
dev_size : float or int
If float, should be between 0.0 and 1.0 and represent a ratio beteen the
n_unlabel and size of the dev set. If int, represents the absolute number
of dev samples.
seed : int, optional
Random seed.
is_hard : bool, optional
Whether to increase nosie / variance by 1.5x to make the task more difficult.
"""
n_dev = int(n_unlabel * dev_size) if dev_size < 1 else dev_size
hard_factor = 1.5 if is_hard else 1 # multiply by 1.5 if hard
gaus_means = np.array([[7, 9], [8., -1], [-5., -9.]])
args = dict(pts_circles={"f": sklearn.datasets.make_circles,
"std": 0.09, "kwargs": dict(factor=.5)},
pts_moons={"f": sklearn.datasets.make_moons,
"std": 0.13, "kwargs": {}},
pts_iso_gaus={"f": sklearn.datasets.make_blobs,
"std": 1.5, "kwargs": dict(centers=gaus_means)},
pts_cov_gaus={"f": sklearn.datasets.make_blobs,
"std": 1.5,
"kwargs": dict(centers=gaus_means)},
pts_var_gaus={"f": sklearn.datasets.make_blobs,
"std": np.array([1.0, 2.5, 0.5]),
"kwargs": dict(centers=gaus_means)})
spec_args = args[dataset]
def get_noisy_kwargs(is_label=False):
if "_gaus" in dataset:
std_label_factor = 1 if not is_label else 0.5 # divide by 10 std
spec_args["kwargs"]["cluster_std"] = spec_args["std"] * std_label_factor * hard_factor
else:
std_label_factor = 1 if not is_label else 0 # no noise
spec_args["kwargs"]["noise"] = spec_args["std"] * std_label_factor * hard_factor
return spec_args["kwargs"]
X_lab, y_lab = spec_args["f"](n_samples=n_label, random_state=seed,
**get_noisy_kwargs(True))
X_unlab, y_unlab = spec_args["f"](n_samples=n_unlabel, random_state=seed,
**get_noisy_kwargs())
y_unlab[:] = -1
X_train = np.concatenate([X_lab, X_unlab])
y_train = np.concatenate([y_lab, y_unlab])
X_dev, y_dev = spec_args["f"](n_samples=n_dev, random_state=seed,
**get_noisy_kwargs())
X_test, y_test = spec_args["f"](n_samples=n_test, random_state=seed,
**get_noisy_kwargs())
if dataset == "pts_cov_gaus":
transformation = [[0.6, -0.6], [-0.4, 0.8]]
X_train = np.dot(X_train, transformation)
X_dev = np.dot(X_dev, transformation)
X_test = | np.dot(X_test, transformation) | numpy.dot |
from __future__ import division, print_function, absolute_import
__usage__ = """
To run tests locally:
python tests/test_arpack.py [-l<int>] [-v<int>]
"""
import warnings
import numpy as np
from numpy.testing import assert_allclose, \
assert_array_almost_equal_nulp, TestCase, run_module_suite, dec, \
assert_raises, verbose, assert_equal, assert_array_equal
from numpy import array, finfo, argsort, dot, round, conj, random
from scipy.linalg import eig, eigh
from scipy.sparse import csc_matrix, csr_matrix, lil_matrix, isspmatrix
from scipy.sparse.linalg import LinearOperator, aslinearoperator
from scipy.sparse.linalg.eigen.arpack import eigs, eigsh, svds, \
ArpackNoConvergence, arpack
from scipy.linalg import svd, hilbert
from scipy.lib._gcutils import assert_deallocated
# eigs() and eigsh() are called many times, so apply a filter for the warnings
# they generate here.
_eigs_warn_msg = "Single-precision types in `eigs` and `eighs`"
def setup_module():
warnings.filterwarnings("ignore", message=_eigs_warn_msg)
def teardown_module():
warnings.filterwarnings("default", message=_eigs_warn_msg)
# precision for tests
_ndigits = {'f': 3, 'd': 11, 'F': 3, 'D': 11}
def _get_test_tolerance(type_char, mattype=None):
"""
Return tolerance values suitable for a given test:
Parameters
----------
type_char : {'f', 'd', 'F', 'D'}
Data type in ARPACK eigenvalue problem
mattype : {csr_matrix, aslinearoperator, asarray}, optional
Linear operator type
Returns
-------
tol
Tolerance to pass to the ARPACK routine
rtol
Relative tolerance for outputs
atol
Absolute tolerance for outputs
"""
rtol = {'f': 3000 * np.finfo(np.float32).eps,
'F': 3000 * np.finfo(np.float32).eps,
'd': 2000 * np.finfo(np.float64).eps,
'D': 2000 * np.finfo(np.float64).eps}[type_char]
atol = rtol
tol = 0
if mattype is aslinearoperator and type_char in ('f', 'F'):
# iterative methods in single precision: worse errors
# also: bump ARPACK tolerance so that the iterative method converges
tol = 30 * np.finfo(np.float32).eps
rtol *= 5
if mattype is csr_matrix and type_char in ('f', 'F'):
# sparse in single precision: worse errors
rtol *= 5
return tol, rtol, atol
def generate_matrix(N, complex=False, hermitian=False,
pos_definite=False, sparse=False):
M = np.random.random((N,N))
if complex:
M = M + 1j * np.random.random((N,N))
if hermitian:
if pos_definite:
if sparse:
i = np.arange(N)
j = np.random.randint(N, size=N-2)
i, j = np.meshgrid(i, j)
M[i,j] = 0
M = np.dot(M.conj(), M.T)
else:
M = np.dot(M.conj(), M.T)
if sparse:
i = np.random.randint(N, size=N * N // 4)
j = np.random.randint(N, size=N * N // 4)
ind = np.where(i == j)
j[ind] = (j[ind] + 1) % N
M[i,j] = 0
M[j,i] = 0
else:
if sparse:
i = np.random.randint(N, size=N * N // 2)
j = np.random.randint(N, size=N * N // 2)
M[i,j] = 0
return M
def _aslinearoperator_with_dtype(m):
m = aslinearoperator(m)
if not hasattr(m, 'dtype'):
x = np.zeros(m.shape[1])
m.dtype = (m * x).dtype
return m
def assert_allclose_cc(actual, desired, **kw):
"""Almost equal or complex conjugates almost equal"""
try:
assert_allclose(actual, desired, **kw)
except:
assert_allclose(actual, conj(desired), **kw)
def argsort_which(eval, typ, k, which,
sigma=None, OPpart=None, mode=None):
"""Return sorted indices of eigenvalues using the "which" keyword
from eigs and eigsh"""
if sigma is None:
reval = np.round(eval, decimals=_ndigits[typ])
else:
if mode is None or mode == 'normal':
if OPpart is None:
reval = 1. / (eval - sigma)
elif OPpart == 'r':
reval = 0.5 * (1. / (eval - sigma)
+ 1. / (eval - np.conj(sigma)))
elif OPpart == 'i':
reval = -0.5j * (1. / (eval - sigma)
- 1. / (eval - np.conj(sigma)))
elif mode == 'cayley':
reval = (eval + sigma) / (eval - sigma)
elif mode == 'buckling':
reval = eval / (eval - sigma)
else:
raise ValueError("mode='%s' not recognized" % mode)
reval = np.round(reval, decimals=_ndigits[typ])
if which in ['LM', 'SM']:
ind = np.argsort(abs(reval))
elif which in ['LR', 'SR', 'LA', 'SA', 'BE']:
ind = np.argsort(np.real(reval))
elif which in ['LI', 'SI']:
# for LI,SI ARPACK returns largest,smallest abs(imaginary) why?
if typ.islower():
ind = np.argsort(abs(np.imag(reval)))
else:
ind = np.argsort(np.imag(reval))
else:
raise ValueError("which='%s' is unrecognized" % which)
if which in ['LM', 'LA', 'LR', 'LI']:
return ind[-k:]
elif which in ['SM', 'SA', 'SR', 'SI']:
return ind[:k]
elif which == 'BE':
return np.concatenate((ind[:k//2], ind[k//2-k:]))
def eval_evec(symmetric, d, typ, k, which, v0=None, sigma=None,
mattype=np.asarray, OPpart=None, mode='normal'):
general = ('bmat' in d)
if symmetric:
eigs_func = eigsh
else:
eigs_func = eigs
if general:
err = ("error for %s:general, typ=%s, which=%s, sigma=%s, "
"mattype=%s, OPpart=%s, mode=%s" % (eigs_func.__name__,
typ, which, sigma,
mattype.__name__,
OPpart, mode))
else:
err = ("error for %s:standard, typ=%s, which=%s, sigma=%s, "
"mattype=%s, OPpart=%s, mode=%s" % (eigs_func.__name__,
typ, which, sigma,
mattype.__name__,
OPpart, mode))
a = d['mat'].astype(typ)
ac = mattype(a)
if general:
b = d['bmat'].astype(typ.lower())
bc = mattype(b)
# get exact eigenvalues
exact_eval = d['eval'].astype(typ.upper())
ind = argsort_which(exact_eval, typ, k, which,
sigma, OPpart, mode)
exact_eval_a = exact_eval
exact_eval = exact_eval[ind]
# compute arpack eigenvalues
kwargs = dict(which=which, v0=v0, sigma=sigma)
if eigs_func is eigsh:
kwargs['mode'] = mode
else:
kwargs['OPpart'] = OPpart
# compute suitable tolerances
kwargs['tol'], rtol, atol = _get_test_tolerance(typ, mattype)
# on rare occasions, ARPACK routines return results that are proper
# eigenvalues and -vectors, but not necessarily the ones requested in
# the parameter which. This is inherent to the Krylov methods, and
# should not be treated as a failure. If such a rare situation
# occurs, the calculation is tried again (but at most a few times).
ntries = 0
while ntries < 5:
# solve
if general:
try:
eval, evec = eigs_func(ac, k, bc, **kwargs)
except ArpackNoConvergence:
kwargs['maxiter'] = 20*a.shape[0]
eval, evec = eigs_func(ac, k, bc, **kwargs)
else:
try:
eval, evec = eigs_func(ac, k, **kwargs)
except ArpackNoConvergence:
kwargs['maxiter'] = 20*a.shape[0]
eval, evec = eigs_func(ac, k, **kwargs)
ind = argsort_which(eval, typ, k, which,
sigma, OPpart, mode)
eval_a = eval
eval = eval[ind]
evec = evec[:,ind]
# check eigenvectors
LHS = np.dot(a, evec)
if general:
RHS = eval * np.dot(b, evec)
else:
RHS = eval * evec
assert_allclose(LHS, RHS, rtol=rtol, atol=atol, err_msg=err)
try:
# check eigenvalues
assert_allclose_cc(eval, exact_eval, rtol=rtol, atol=atol,
err_msg=err)
break
except AssertionError:
ntries += 1
# check eigenvalues
assert_allclose_cc(eval, exact_eval, rtol=rtol, atol=atol, err_msg=err)
class DictWithRepr(dict):
def __init__(self, name):
self.name = name
def __repr__(self):
return "<%s>" % self.name
class SymmetricParams:
def __init__(self):
self.eigs = eigsh
self.which = ['LM', 'SM', 'LA', 'SA', 'BE']
self.mattypes = [csr_matrix, aslinearoperator, np.asarray]
self.sigmas_modes = {None: ['normal'],
0.5: ['normal', 'buckling', 'cayley']}
# generate matrices
# these should all be float32 so that the eigenvalues
# are the same in float32 and float64
N = 6
np.random.seed(2300)
Ar = generate_matrix(N, hermitian=True,
pos_definite=True).astype('f').astype('d')
M = generate_matrix(N, hermitian=True,
pos_definite=True).astype('f').astype('d')
Ac = generate_matrix(N, hermitian=True, pos_definite=True,
complex=True).astype('F').astype('D')
v0 = np.random.random(N)
# standard symmetric problem
SS = DictWithRepr("std-symmetric")
SS['mat'] = Ar
SS['v0'] = v0
SS['eval'] = eigh(SS['mat'], eigvals_only=True)
# general symmetric problem
GS = DictWithRepr("gen-symmetric")
GS['mat'] = Ar
GS['bmat'] = M
GS['v0'] = v0
GS['eval'] = eigh(GS['mat'], GS['bmat'], eigvals_only=True)
# standard hermitian problem
SH = DictWithRepr("std-hermitian")
SH['mat'] = Ac
SH['v0'] = v0
SH['eval'] = eigh(SH['mat'], eigvals_only=True)
# general hermitian problem
GH = DictWithRepr("gen-hermitian")
GH['mat'] = Ac
GH['bmat'] = M
GH['v0'] = v0
GH['eval'] = eigh(GH['mat'], GH['bmat'], eigvals_only=True)
self.real_test_cases = [SS, GS]
self.complex_test_cases = [SH, GH]
class NonSymmetricParams:
def __init__(self):
self.eigs = eigs
self.which = ['LM', 'LR', 'LI'] # , 'SM', 'LR', 'SR', 'LI', 'SI']
self.mattypes = [csr_matrix, aslinearoperator, np.asarray]
self.sigmas_OPparts = {None: [None],
0.1: ['r'],
0.1 + 0.1j: ['r', 'i']}
# generate matrices
# these should all be float32 so that the eigenvalues
# are the same in float32 and float64
N = 6
np.random.seed(2300)
Ar = generate_matrix(N).astype('f').astype('d')
M = generate_matrix(N, hermitian=True,
pos_definite=True).astype('f').astype('d')
Ac = generate_matrix(N, complex=True).astype('F').astype('D')
v0 = np.random.random(N)
# standard real nonsymmetric problem
SNR = DictWithRepr("std-real-nonsym")
SNR['mat'] = Ar
SNR['v0'] = v0
SNR['eval'] = eig(SNR['mat'], left=False, right=False)
# general real nonsymmetric problem
GNR = DictWithRepr("gen-real-nonsym")
GNR['mat'] = Ar
GNR['bmat'] = M
GNR['v0'] = v0
GNR['eval'] = eig(GNR['mat'], GNR['bmat'], left=False, right=False)
# standard complex nonsymmetric problem
SNC = DictWithRepr("std-cmplx-nonsym")
SNC['mat'] = Ac
SNC['v0'] = v0
SNC['eval'] = eig(SNC['mat'], left=False, right=False)
# general complex nonsymmetric problem
GNC = DictWithRepr("gen-cmplx-nonsym")
GNC['mat'] = Ac
GNC['bmat'] = M
GNC['v0'] = v0
GNC['eval'] = eig(GNC['mat'], GNC['bmat'], left=False, right=False)
self.real_test_cases = [SNR, GNR]
self.complex_test_cases = [SNC, GNC]
def test_symmetric_modes():
params = SymmetricParams()
k = 2
symmetric = True
for D in params.real_test_cases:
for typ in 'fd':
for which in params.which:
for mattype in params.mattypes:
for (sigma, modes) in params.sigmas_modes.items():
for mode in modes:
yield (eval_evec, symmetric, D, typ, k, which,
None, sigma, mattype, None, mode)
def test_hermitian_modes():
params = SymmetricParams()
k = 2
symmetric = True
for D in params.complex_test_cases:
for typ in 'FD':
for which in params.which:
if which == 'BE':
continue # BE invalid for complex
for mattype in params.mattypes:
for sigma in params.sigmas_modes:
yield (eval_evec, symmetric, D, typ, k, which,
None, sigma, mattype)
def test_symmetric_starting_vector():
params = SymmetricParams()
symmetric = True
for k in [1, 2, 3, 4, 5]:
for D in params.real_test_cases:
for typ in 'fd':
v0 = random.rand(len(D['v0'])).astype(typ)
yield (eval_evec, symmetric, D, typ, k, 'LM', v0)
def test_symmetric_no_convergence():
np.random.seed(1234)
m = generate_matrix(30, hermitian=True, pos_definite=True)
tol, rtol, atol = _get_test_tolerance('d')
try:
w, v = eigsh(m, 4, which='LM', v0=m[:, 0], maxiter=5, tol=tol)
raise AssertionError("Spurious no-error exit")
except ArpackNoConvergence as err:
k = len(err.eigenvalues)
if k <= 0:
raise AssertionError("Spurious no-eigenvalues-found case")
w, v = err.eigenvalues, err.eigenvectors
assert_allclose(dot(m, v), w * v, rtol=rtol, atol=atol)
def test_real_nonsymmetric_modes():
params = NonSymmetricParams()
k = 2
symmetric = False
for D in params.real_test_cases:
for typ in 'fd':
for which in params.which:
for mattype in params.mattypes:
for sigma, OPparts in params.sigmas_OPparts.items():
for OPpart in OPparts:
yield (eval_evec, symmetric, D, typ, k, which,
None, sigma, mattype, OPpart)
def test_complex_nonsymmetric_modes():
params = NonSymmetricParams()
k = 2
symmetric = False
for D in params.complex_test_cases:
for typ in 'DF':
for which in params.which:
for mattype in params.mattypes:
for sigma in params.sigmas_OPparts:
yield (eval_evec, symmetric, D, typ, k, which,
None, sigma, mattype)
def test_standard_nonsymmetric_starting_vector():
params = NonSymmetricParams()
sigma = None
symmetric = False
for k in [1, 2, 3, 4]:
for d in params.complex_test_cases:
for typ in 'FD':
A = d['mat']
n = A.shape[0]
v0 = random.rand(n).astype(typ)
yield (eval_evec, symmetric, d, typ, k, "LM", v0, sigma)
def test_general_nonsymmetric_starting_vector():
params = NonSymmetricParams()
sigma = None
symmetric = False
for k in [1, 2, 3, 4]:
for d in params.complex_test_cases:
for typ in 'FD':
A = d['mat']
n = A.shape[0]
v0 = random.rand(n).astype(typ)
yield (eval_evec, symmetric, d, typ, k, "LM", v0, sigma)
def test_standard_nonsymmetric_no_convergence():
np.random.seed(1234)
m = generate_matrix(30, complex=True)
tol, rtol, atol = _get_test_tolerance('d')
try:
w, v = eigs(m, 4, which='LM', v0=m[:, 0], maxiter=5, tol=tol)
raise AssertionError("Spurious no-error exit")
except ArpackNoConvergence as err:
k = len(err.eigenvalues)
if k <= 0:
raise AssertionError("Spurious no-eigenvalues-found case")
w, v = err.eigenvalues, err.eigenvectors
for ww, vv in zip(w, v.T):
assert_allclose(dot(m, vv), ww * vv, rtol=rtol, atol=atol)
def test_eigen_bad_shapes():
# A is not square.
A = csc_matrix(np.zeros((2, 3)))
assert_raises(ValueError, eigs, A)
def test_eigen_bad_kwargs():
# Test eigen on wrong keyword argument
A = csc_matrix(np.zeros((2, 2)))
assert_raises(ValueError, eigs, A, which='XX')
def test_ticket_1459_arpack_crash():
for dtype in [np.float32, np.float64]:
# XXX: this test does not seem to catch the issue for float32,
# but we made the same fix there, just to be sure
N = 6
k = 2
np.random.seed(2301)
A = np.random.random((N, N)).astype(dtype)
v0 = np.array([-0.71063568258907849895, -0.83185111795729227424,
-0.34365925382227402451, 0.46122533684552280420,
-0.58001341115969040629, -0.78844877570084292984e-01],
dtype=dtype)
# Should not crash:
evals, evecs = eigs(A, k, v0=v0)
#----------------------------------------------------------------------
# sparse SVD tests
def sorted_svd(m, k, which='LM'):
# Compute svd of a dense matrix m, and return singular vectors/values
# sorted.
if isspmatrix(m):
m = m.todense()
u, s, vh = svd(m)
if which == 'LM':
ii = np.argsort(s)[-k:]
elif which == 'SM':
ii = np.argsort(s)[:k]
else:
raise ValueError("unknown which=%r" % (which,))
return u[:, ii], s[ii], vh[ii]
def svd_estimate(u, s, vh):
return np.dot(u, np.dot(np.diag(s), vh))
def test_svd_simple_real():
x = np.array([[1, 2, 3],
[3, 4, 3],
[1, 0, 2],
[0, 0, 1]], np.float)
y = np.array([[1, 2, 3, 8],
[3, 4, 3, 5],
[1, 0, 2, 3],
[0, 0, 1, 0]], np.float)
z = csc_matrix(x)
for m in [x.T, x, y, z, z.T]:
for k in range(1, min(m.shape)):
u, s, vh = sorted_svd(m, k)
su, ss, svh = svds(m, k)
m_hat = svd_estimate(u, s, vh)
sm_hat = svd_estimate(su, ss, svh)
assert_array_almost_equal_nulp(m_hat, sm_hat, nulp=1000)
def test_svd_simple_complex():
x = np.array([[1, 2, 3],
[3, 4, 3],
[1 + 1j, 0, 2],
[0, 0, 1]], np.complex)
y = np.array([[1, 2, 3, 8 + 5j],
[3 - 2j, 4, 3, 5],
[1, 0, 2, 3],
[0, 0, 1, 0]], np.complex)
z = csc_matrix(x)
for m in [x, x.T.conjugate(), x.T, y, y.conjugate(), z, z.T]:
for k in range(1, min(m.shape) - 1):
u, s, vh = sorted_svd(m, k)
su, ss, svh = svds(m, k)
m_hat = svd_estimate(u, s, vh)
sm_hat = svd_estimate(su, ss, svh)
assert_array_almost_equal_nulp(m_hat, sm_hat, nulp=1000)
def test_svd_maxiter():
# check that maxiter works as expected
x = hilbert(6)
# ARPACK shouldn't converge on such an ill-conditioned matrix with just
# one iteration
assert_raises(ArpackNoConvergence, svds, x, 1, maxiter=1)
# but 100 iterations should be more than enough
u, s, vt = svds(x, 1, maxiter=100)
assert_allclose(s, [1.7], atol=0.5)
def test_svd_return():
# check that the return_singular_vectors parameter works as expected
x = hilbert(6)
_, s, _ = sorted_svd(x, 2)
ss = svds(x, 2, return_singular_vectors=False)
assert_allclose(s, ss)
def test_svd_which():
# check that the which parameter works as expected
x = hilbert(6)
for which in ['LM', 'SM']:
_, s, _ = sorted_svd(x, 2, which=which)
ss = svds(x, 2, which=which, return_singular_vectors=False)
ss.sort()
assert_allclose(s, ss, atol=np.sqrt(1e-15))
def test_svd_v0():
# check that the v0 parameter works as expected
x = np.array([[1, 2, 3, 4], [5, 6, 7, 8]], float)
u, s, vh = svds(x, 1)
u2, s2, vh2 = svds(x, 1, v0=u[:,0])
assert_allclose(s, s2, atol=np.sqrt(1e-15))
def _check_svds(A, k, U, s, VH):
n, m = A.shape
# Check shapes.
assert_equal(U.shape, (n, k))
assert_equal(s.shape, (k,))
assert_equal(VH.shape, (k, m))
# Check that the original matrix can be reconstituted.
A_rebuilt = (U*s).dot(VH)
assert_equal(A_rebuilt.shape, A.shape)
assert_allclose(A_rebuilt, A)
# Check that U is a semi-orthogonal matrix.
UH_U = np.dot(U.T.conj(), U)
assert_equal(UH_U.shape, (k, k))
assert_allclose(UH_U, np.identity(k), atol=1e-12)
# Check that V is a semi-orthogonal matrix.
VH_V = np.dot(VH, VH.T.conj())
assert_equal(VH_V.shape, (k, k))
assert_allclose(VH_V, np.identity(k), atol=1e-12)
def test_svd_LM_ones_matrix():
# Check that svds can deal with matrix_rank less than k in LM mode.
k = 3
for n, m in (6, 5), (5, 5), (5, 6):
for t in float, complex:
A = np.ones((n, m), dtype=t)
U, s, VH = svds(A, k)
# Check some generic properties of svd.
_check_svds(A, k, U, s, VH)
# Check that the largest singular value is near sqrt(n*m)
# and the other singular values have been forced to zero.
assert_allclose(np.max(s), np.sqrt(n*m))
assert_array_equal(sorted(s)[:-1], 0)
def test_svd_LM_zeros_matrix():
# Check that svds can deal with matrices containing only zeros.
k = 1
for n, m in (3, 4), (4, 4), (4, 3):
for t in float, complex:
A = np.zeros((n, m), dtype=t)
U, s, VH = svds(A, k)
# Check some generic properties of svd.
_check_svds(A, k, U, s, VH)
# Check that the singular values are zero.
assert_array_equal(s, 0)
def test_svd_LM_zeros_matrix_gh_3452():
# Regression test for a github issue.
# https://github.com/scipy/scipy/issues/3452
# Note that for complex dype the size of this matrix is too small for k=1.
n, m, k = 4, 2, 1
A = np.zeros((n, m))
U, s, VH = svds(A, k)
# Check some generic properties of svd.
_check_svds(A, k, U, s, VH)
# Check that the singular values are zero.
assert_array_equal(s, 0)
class CheckingLinearOperator(LinearOperator):
def __init__(self, A):
self.A = A
self.dtype = A.dtype
self.shape = A.shape
def matvec(self, x):
assert_equal(max(x.shape), np.size(x))
return self.A.dot(x)
def rmatvec(self, x):
assert_equal(max(x.shape), | np.size(x) | numpy.size |
# -*- coding: utf-8 -*-
# Copyright (c) 2020. Distributed under the terms of the MIT License.
from typing import List, Tuple
import numpy as np
from pydefect.defaults import defaults
from pydefect.input_maker.defect import SimpleDefect
from pydefect.input_maker.defect_entry import DefectEntry
from pydefect.input_maker.defect_set import DefectSet
from pydefect.input_maker.supercell_info import SupercellInfo
from pymatgen import Structure, IStructure
class DefectEntriesMaker:
def __init__(self, supercell_info: SupercellInfo, defect_set: DefectSet):
self.supercell_info = supercell_info
self.defect_entries = set()
for defect in defect_set:
structure, perturbed_structure, coords, site_symmetry = \
self._create_defect_structures(defect)
for charge in defect.charges:
self.defect_entries.add(
DefectEntry(name=defect.name,
charge=charge,
structure=structure,
perturbed_structure=perturbed_structure,
site_symmetry=site_symmetry,
defect_center=coords))
def _create_defect_structures(self,
defect: SimpleDefect,
) -> Tuple[IStructure, IStructure,
Tuple[float, float, float], str]:
structure = copy_to_structure(self.supercell_info.structure)
if defect.out_atom[0] is "i":
index = int(defect.out_atom[1:]) - 1
site = self.supercell_info.interstitials[index]
cutoff = self.supercell_info.interstitial_coords(index).cutoff
coords = self.supercell_info.interstitials[index].frac_coords
else:
site = self.supercell_info.sites[defect.out_atom]
cutoff = self.supercell_info.coords(defect.out_atom).cutoff
removed_site_index = site.equivalent_atoms[0]
coords = structure.pop(removed_site_index).frac_coords
perturbed_structure = perturb_structure(structure, coords, cutoff)
if defect.in_atom:
add_atom_to_structure(structure, defect.in_atom, coords)
add_atom_to_structure(perturbed_structure, defect.in_atom, coords)
return to_istructure(structure), to_istructure(perturbed_structure), \
tuple(coords), site.site_symmetry
def copy_to_structure(structure: IStructure) -> Structure:
return Structure.from_dict(structure.as_dict())
def to_istructure(structure: Structure) -> IStructure:
return IStructure.from_dict(structure.as_dict())
def add_atom_to_structure(structure: Structure, elem: str, coords: List[float]):
"""In-place atom insertion to structure
https://stackoverflow.com/questions/2361426/get-the-first-item-from-an-iterable-that-matches-a-condition
"""
try:
idx = next(i for i, s in enumerate(structure) if str(s.specie) == elem)
except StopIteration:
idx = len(structure)
structure.insert(idx, elem, coords)
def perturb_structure(structure: Structure, center: List[float], cutoff: float
) -> Structure:
""" structure perturbation
Args:
structure: pmg Structure class object
center: Fractional coordinates of a central position.
cutoff: Radius of a sphere in which atoms are perturbed.
"""
result = structure.copy()
cartesian_coords = structure.lattice.get_cartesian_coords(center)
neighboring_atoms = structure.get_sites_in_sphere(
pt=cartesian_coords, r=cutoff, include_index=True)
# assert cutoff < min(structure.lattice.lengths) / 2.0
# neighboring_atom is composed of (PeriodicSite, distance, index)
for _, _, site_index in neighboring_atoms:
vector = random_3d_vector(defaults.displace_distance)
result.translate_sites(site_index, vector, frac_coords=False)
return result
def random_3d_vector(distance):
"""Random 3d vector with uniform spherical distribution with 0 <= norm <= 1.
stackoverflow.com/questions/5408276/python-uniform-spherical-distribution
"""
phi = np.random.uniform(0, np.pi * 2)
cos_theta = np.random.uniform(-1, 1)
theta = | np.arccos(cos_theta) | numpy.arccos |
# Copyright 2021 The Magenta Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Lint as: python3
"""Metrics."""
import math
import note_seq
import numpy as np
import scipy
from sklearn import metrics
def frechet_distance(real, fake):
"""Frechet distance.
Lower score is better.
"""
mu1, sigma1 = np.mean(real, axis=0), np.cov(real, rowvar=False)
mu2, sigma2 = np.mean(fake, axis=0), np.cov(fake, rowvar=False)
diff = mu1 - mu2
covmean, _ = scipy.linalg.sqrtm(sigma1.dot(sigma2), disp=False)
if not np.isfinite(covmean).all():
msg = ('fid calculation produces singular product; '
'adding %s to diagonal of cov estimates') % eps
print(msg)
offset = np.eye(sigma1.shape[0]) * eps
covmean = scipy.linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset))
# Numerical error might give slight imaginary component
if np.iscomplexobj(covmean):
if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3):
m = np.max(np.abs(covmean.imag))
raise ValueError('Imaginary component {}'.format(m))
covmean = covmean.real
assert np.isfinite(covmean).all() and not np.iscomplexobj(covmean)
tr_covmean = np.trace(covmean)
frechet_dist = diff.dot(diff)
frechet_dist += np.trace(sigma1) + np.trace(sigma2)
frechet_dist -= 2 * tr_covmean
return frechet_dist
def mmd_rbf(real, fake, gamma=1.0):
"""(RBF) kernel distance.
Lower score is better.
"""
XX = metrics.pairwise.rbf_kernel(real, real, gamma)
YY = metrics.pairwise.rbf_kernel(fake, fake, gamma)
XY = metrics.pairwise.rbf_kernel(real, fake, gamma)
return XX.mean() + YY.mean() - 2 * XY.mean()
def mmd_polynomial(real, fake, degree=2, gamma=1, coef0=0):
"""(Polynomial) kernel distance.
Lower score is better.
"""
XX = metrics.pairwise.polynomial_kernel(real, real, degree, gamma, coef0)
YY = metrics.pairwise.polynomial_kernel(fake, fake, degree, gamma, coef0)
XY = metrics.pairwise.polynomial_kernel(real, fake, degree, gamma, coef0)
return XX.mean() + YY.mean() - 2 * XY.mean()
def framewise_statistic(ns, stat_fn, hop_size=1, frame_size=1):
"""Computes framewise MIDI statistic."""
total_time = int(math.ceil(ns.total_time))
frames = []
trim = frame_size - hop_size
for i in range(0, total_time - trim, hop_size):
one_sec_chunk = note_seq.sequences_lib.trim_note_sequence(
ns, i, i + frame_size)
value = stat_fn(one_sec_chunk.notes)
frames.append(value)
return np.array(frames)
def note_density(ns, hop_size=1, frame_size=1):
stat_fn = lambda notes: len(notes)
return framewise_statistic(ns,
stat_fn,
hop_size=hop_size,
frame_size=frame_size)
def pitch_range(ns, hop_size=1, frame_size=1):
def stat_fn(notes):
pitches = [note.pitch for note in notes]
return max(pitches) - min(pitches) if len(pitches) > 0 else 0
return framewise_statistic(ns,
stat_fn,
hop_size=hop_size,
frame_size=frame_size)
def mean_pitch(ns, hop_size=1, frame_size=1):
def stat_fn(notes):
pitches = np.array([note.pitch for note in notes])
return pitches.mean() if len(pitches) > 0 else 0
return framewise_statistic(ns,
stat_fn,
hop_size=hop_size,
frame_size=frame_size)
def var_pitch(ns, hop_size=1, frame_size=1):
def stat_fn(notes):
pitches = np.array([note.pitch for note in notes])
return pitches.var() if len(pitches) > 0 else 0
return framewise_statistic(ns,
stat_fn,
hop_size=hop_size,
frame_size=frame_size)
def mean_note_duration(ns, hop_size=1, frame_size=1):
def stat_fn(notes):
durations = np.array([note.end_time - note.start_time for note in notes])
return durations.mean() if len(durations) > 0 else 0
return framewise_statistic(ns,
stat_fn,
hop_size=hop_size,
frame_size=frame_size)
def var_note_duration(ns, hop_size=1, frame_size=1):
def stat_fn(notes):
durations = np.array([note.end_time - note.start_time for note in notes])
return durations.var() if len(durations) > 0 else 0
return framewise_statistic(ns,
stat_fn,
hop_size=hop_size,
frame_size=frame_size)
def perceptual_midi_histograms(ns, interval=1):
"""Generates histograms for each MIDI feature."""
return dict(
nd=note_density(ns, interval=interval),
pr=pitch_range(ns, interval=interval),
mp=mean_pitch(ns, interval=interval),
vp=var_pitch(ns, interval=interval),
md=mean_note_duration(ns, interval=interval),
vd=var_note_duration(ns, interval=interval),
)
def perceptual_midi_statistics(ns, interval=1, vector=False):
"""Feature vector of means and variances of MIDI histograms.
Args:
ns: NoteSequence object.
interval: Integer time interval (in seconds) for each histogram bin.
vector: If True, returns statistics as a feature vector.
"""
features = {}
histograms = perceptual_midi_histograms(ns, interval=interval)
for key in histograms:
mu = histograms[key].mean()
var = histograms[key].var()
features[key] = (mu, var)
if vector:
vec = np.array(list(features.values()))
return vec.reshape(-1)
return features
def perceptual_similarity(ns1, ns2, interval=1):
"""Perceptual similarity as determined by Overlapping Area Metric.
Determines pairwise similarity for two NoteSequence objects.
Args:
ns1: NoteSequence object.
ns2: NoteSequence object.
interval: Integer time interval (in seconds) for each histogram bin.
"""
stats1 = perceptual_midi_statistics(ns1, interval, vector=False)
stats2 = perceptual_midi_statistics(ns2, interval, vector=False)
similarity = {}
for key in stats1:
mu1, var1 = stats1[key]
mu2, var2 = stats2[key]
similarity[key] = overlapping_area(mu1, mu2, var1, var2)
return similarity
def overlapping_area(mu1, mu2, var1, var2):
"""Compute overlapping area of two Gaussians.
Args:
mu1: Mean of first Gaussian pdf.
mu2: Mean of second Gaussian pdf.
var1: Variance of first Gaussian pdf.
var2: Variance of second Gaussian pdf.
Returns:
Overlapping area of the two density functions.
"""
idx = mu2 < mu1
mu_a = mu2 * idx + np.logical_not(idx) * mu1
mu_b = mu1 * idx + | np.logical_not(idx) | numpy.logical_not |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.